Move Logback.xml

Some libraires are not yet ready..

{Arrow,Lucene,Http4k} should be packed inside a shaded jar because they
all have some split packages

HikariCP has an invalid module-info.java

Kapt doesn't work

.gitignore

@@ -125,8 +125,8 @@ data/
 letsencrypt/
 
 # generated resources
-app/src/main/resources/css-manifest.json
+simplenotes-app/src/main/resources/css-manifest.json
-app/src/main/resources/static/styles*
+simplenotes-app/src/main/resources/static/styles*
 
 # h2 db
 *.db

Dockerfile

@@ -4,19 +4,23 @@ WORKDIR /tmp
 
 # Cache dependencies
 COPY pom.xml .
-COPY app/pom.xml app/pom.xml
+COPY simplenotes-test-resources/pom.xml simplenotes-test-resources/pom.xml
-COPY domain/pom.xml domain/pom.xml
+COPY simplenotes-types/pom.xml simplenotes-types/pom.xml
-COPY persistance/pom.xml persistance/pom.xml
+COPY simplenotes-config/pom.xml simplenotes-config/pom.xml
-COPY shared/pom.xml shared/pom.xml
+COPY simplenotes-persistance/pom.xml simplenotes-persistance/pom.xml
-COPY search/pom.xml search/pom.xml
+COPY simplenotes-search/pom.xml simplenotes-search/pom.xml
+COPY simplenotes-domain/pom.xml simplenotes-domain/pom.xml
+COPY simplenotes-app/pom.xml simplenotes-app/pom.xml
 
 RUN mvn verify clean --fail-never
 
-COPY app/src app/src
+COPY simplenotes-test-resources/src simplenotes-test-resources/src
-COPY domain/src domain/src
+COPY simplenotes-types/src simplenotes-types/src
-COPY persistance/src persistance/src
+COPY simplenotes-config/src simplenotes-config/src
-COPY shared/src shared/src
+COPY simplenotes-persistance/src simplenotes-persistance/src
-COPY search/src search/src
+COPY simplenotes-search/src simplenotes-search/src
+COPY simplenotes-domain/src simplenotes-domain/src
+COPY simplenotes-app/src simplenotes-app/src
 
 RUN mvn -Dstyle.color=always package
 
@@ -42,8 +46,8 @@ RUN chown -R $APPLICATION_USER /app
 
 USER $APPLICATION_USER
 
-COPY --from=builder /tmp/app/target/app-*.jar /app/app.jar
+COPY --from=builder /tmp/simplenotes-app/target/simplenotes-app-*.jar /app/simplenotes.jar
 COPY --from=jdkbuilder /myjdk /myjdk
 WORKDIR /app
 
-CMD ["/myjdk/bin/java", "-server", "-XX:+UnlockExperimentalVMOptions", "-Xms64m", "-Xmx256m", "-XX:+UseG1GC", "-XX:MaxGCPauseMillis=100", "-XX:+UseStringDeduplication", "-jar", "app.jar"]
+CMD ["/myjdk/bin/java", "-server", "-XX:+UnlockExperimentalVMOptions", "-Xms64m", "-Xmx256m", "-XX:+UseG1GC", "-XX:MaxGCPauseMillis=100", "-XX:+UseStringDeduplication", "-jar", "simplenotes.jar"]

app/src/main/kotlin/api/ApiNoteController.kt

@@ -1,77 +0,0 @@
-package be.simplenotes.app.api
-
-import be.simplenotes.app.extensions.json
-import be.simplenotes.app.utils.parseSearchTerms
-import be.simplenotes.domain.model.PersistedNote
-import be.simplenotes.domain.model.PersistedNoteMetadata
-import be.simplenotes.domain.security.JwtPayload
-import be.simplenotes.domain.usecases.NoteService
-import kotlinx.serialization.Contextual
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.builtins.ListSerializer
-import kotlinx.serialization.json.Json
-import org.http4k.core.Request
-import org.http4k.core.Response
-import org.http4k.core.Status.Companion.BAD_REQUEST
-import org.http4k.core.Status.Companion.NOT_FOUND
-import org.http4k.core.Status.Companion.OK
-import org.http4k.routing.path
-import java.util.*
-
-class ApiNoteController(private val noteService: NoteService, private val json: Json) {
-
-    fun createNote(request: Request, jwtPayload: JwtPayload): Response {
-        val content = json.decodeFromString(NoteContent.serializer(), request.bodyString()).content
-        return noteService.create(jwtPayload.userId, content).fold(
-            {
-                Response(BAD_REQUEST)
-            },
-            {
-                Response(OK).json(json.encodeToString(UuidContent.serializer(), UuidContent(it.uuid)))
-            }
-        )
-    }
-
-    fun notes(request: Request, jwtPayload: JwtPayload): Response {
-        val notes = noteService.paginatedNotes(jwtPayload.userId, page = 1).notes
-        val json = json.encodeToString(ListSerializer(PersistedNoteMetadata.serializer()), notes)
-        return Response(OK).json(json)
-    }
-
-    fun note(request: Request, jwtPayload: JwtPayload): Response {
-        val uuid = request.path("uuid")!!
-
-        return noteService.find(jwtPayload.userId, UUID.fromString(uuid))
-            ?.let { Response(OK).json(json.encodeToString(PersistedNote.serializer(), it)) }
-            ?: Response(NOT_FOUND)
-    }
-
-    fun update(request: Request, jwtPayload: JwtPayload): Response {
-        val uuid = UUID.fromString(request.path("uuid")!!)
-        val content = json.decodeFromString(NoteContent.serializer(), request.bodyString()).content
-        return noteService.update(jwtPayload.userId, uuid, content).fold({
-            Response(BAD_REQUEST)
-        }, {
-            if (it == null) Response(NOT_FOUND)
-            else Response(OK)
-        })
-    }
-
-    fun search(request: Request, jwtPayload: JwtPayload): Response {
-        val query = json.decodeFromString(SearchContent.serializer(), request.bodyString()).query
-        val terms = parseSearchTerms(query)
-        val notes = noteService.search(jwtPayload.userId, terms)
-        val json = json.encodeToString(ListSerializer(PersistedNoteMetadata.serializer()), notes)
-        return Response(OK).json(json)
-    }
-
-}
-
-@Serializable
-data class NoteContent(val content: String)
-
-@Serializable
-data class UuidContent(@Contextual val uuid: UUID)
-
-@Serializable
-data class SearchContent(@Contextual val query: String)

app/src/main/kotlin/api/ApiUserController.kt

@@ -1,26 +0,0 @@
-package be.simplenotes.app.api
-
-import be.simplenotes.app.extensions.json
-import be.simplenotes.domain.usecases.UserService
-import be.simplenotes.domain.usecases.users.login.LoginForm
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.Json
-import org.http4k.core.Request
-import org.http4k.core.Response
-import org.http4k.core.Status
-
-class ApiUserController(private val userService: UserService, private val json: Json) {
-
-    fun login(request: Request): Response {
-        val form = json.decodeFromString(LoginForm.serializer(), request.bodyString())
-        val result = userService.login(form)
-        return result.fold({
-            Response(Status.BAD_REQUEST)
-        }, {
-            Response(Status.OK).json(json.encodeToString(Token.serializer(), Token(it)))
-        })
-    }
-}
-
-@Serializable
-data class Token(val token: String)

app/src/main/kotlin/extensions/Http4kExtensions.kt

@@ -1,17 +0,0 @@
-package be.simplenotes.app.extensions
-
-import org.http4k.core.Request
-import org.http4k.core.Response
-import org.http4k.core.Status.Companion.FOUND
-import org.http4k.core.Status.Companion.MOVED_PERMANENTLY
-
-fun Response.html(html: String) = body(html)
-    .header("Content-Type", "text/html; charset=utf-8")
-    .header("Cache-Control", "no-cache")
-
-fun Response.json(json: String) = body(json).header("Content-Type", "application/json")
-
-fun Response.Companion.redirect(url: String, permanent: Boolean = false) =
-    Response(if (permanent) MOVED_PERMANENTLY else FOUND).header("Location", url)
-
-fun Request.isSecure() = header("X-Forwarded-Proto")?.contains("https") ?: false

app/src/main/kotlin/modules/ConfigModule.kt

@@ -1,11 +0,0 @@
-package be.simplenotes.app.modules
-
-import be.simplenotes.app.Config
-import org.koin.dsl.module
-
-val configModule = module {
-    single { Config() }
-    single { get<Config>().dataSourceConfig }
-    single { get<Config>().jwtConfig }
-    single { get<Config>().serverConfig }
-}

app/src/main/kotlin/modules/CoreModules.kt

@@ -1,29 +0,0 @@
-package be.simplenotes.app.modules
-
-import be.simplenotes.app.controllers.*
-import be.simplenotes.app.views.BaseView
-import be.simplenotes.app.views.NoteView
-import be.simplenotes.app.views.SettingView
-import be.simplenotes.app.views.UserView
-import org.koin.dsl.module
-
-val userModule = module {
-    single { UserController(get(), get(), get()) }
-    single { UserView(get()) }
-}
-
-val baseModule = module {
-    single { HealthCheckController(get()) }
-    single { BaseController(get()) }
-    single { BaseView(get()) }
-}
-
-val noteModule = module {
-    single { NoteController(get(), get()) }
-    single { NoteView(get()) }
-}
-
-val settingsModule = module {
-    single { SettingsController(get(), get()) }
-    single { SettingView(get()) }
-}

app/src/main/kotlin/utils/PrettyDate.kt

@@ -1,10 +0,0 @@
-package be.simplenotes.app.utils
-
-import org.ocpsoft.prettytime.PrettyTime
-import java.time.LocalDateTime
-import java.time.ZoneId
-import java.util.*
-
-private val prettyTime = PrettyTime()
-
-fun LocalDateTime.toTimeAgo(): String = prettyTime.format(Date.from(atZone(ZoneId.systemDefault()).toInstant()))

app/src/test/kotlin/Empty.kt

@@ -1 +0,0 @@
-package be.simplenotes.app

css/package.json

@@ -2,8 +2,8 @@
     "name": "css",
     "version": "1.0.0",
     "scripts": {
-        "css": "NODE_ENV=dev MANIFEST=../app/src/main/resources/css-manifest.json postcss build src/styles.pcss --output ../app/src/main/resources/static/styles.css",
+        "css": "NODE_ENV=dev MANIFEST=../simplenotes-app/src/main/resources/css-manifest.json postcss build src/styles.pcss --output ../simplenotes-app/src/main/resources/static/styles.css",
-        "css-purge": "NODE_ENV=production  MANIFEST=../app/src/main/resources/css-manifest.json postcss build src/styles.pcss --output ../app/src/main/resources/static/styles.css"
+        "css-purge": "NODE_ENV=production  MANIFEST=../simplenotes-app/src/main/resources/css-manifest.json postcss build src/styles.pcss --output ../simplenotes-app/src/main/resources/static/styles.css"
     },
     "dependencies": {
         "autoprefixer": "^9.8.6",

css/tailwind.config.js

@@ -1,7 +1,7 @@
 module.exports = {
     purge: {
         content: [
-            '../app/src/main/kotlin/views/**/*.kt'
+            '../simplenotes-app/src/main/kotlin/be/simplenotes/app/views/**/*.kt'
         ]
     },
     theme: {

deploy-docker-hub.sh

@@ -1,7 +1,7 @@
 #!/bin/sh
 
-rm app/src/main/resources/css-manifest.json
+rm simplenotes-app/src/main/resources/css-manifest.json
-rm app/src/main/resources/static/styles*
+rm simplenotes-app/src/main/resources/static/styles*
 
 yarn --cwd css run css-purge \
     && docker build -t hubv/simplenotes:latest . \

domain/src/main/kotlin/model/User.kt

@@ -1,4 +0,0 @@
-package be.simplenotes.domain.model
-
-data class User(val username: String, val password: String)
-data class PersistedUser(val username: String, val password: String, val id: Int)

domain/src/test/kotlin/Empty.kt

@@ -1,5 +0,0 @@
-package be.simplenotes.domain
-
-/**
- * Empty file @see [root-package-declaration](https://discuss.kotlinlang.org/t/root-package-declaration-to-reduce-folder-clutter/2247/4)
- */

persistance/src/test/kotlin/Empty.kt

@@ -1 +0,0 @@
-package be.simplenotes.persistance

pom.xml

@@ -4,15 +4,18 @@
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>be.simplenotes</groupId>
-    <artifactId>parent</artifactId>
+    <artifactId>simplenotes-parent</artifactId>
     <version>1.0-SNAPSHOT</version>
 
     <modules>
-        <module>persistance</module>
+        <module>simplenotes-persistance</module>
-        <module>app</module>
+        <module>simplenotes-app</module>
-        <module>domain</module>
+        <module>simplenotes-domain</module>
-        <module>shared</module>
+        <module>simplenotes-search</module>
-        <module>search</module>
+        <module>simplenotes-types</module>
+        <module>simplenotes-config</module>
+        <module>simplenotes-test-resources</module>
+        <module>simplenotes-views</module>
     </modules>
 
     <packaging>pom</packaging>
@@ -179,7 +182,7 @@
             <dependency>
                 <groupId>io.arrow-kt</groupId>
                 <artifactId>arrow-core</artifactId>
-                <version>0.10.5</version>
+                <version>0.11.0</version>
             </dependency>
             <dependency>
                 <groupId>org.slf4j</groupId>

shared/src/test/kotlin/Empty.kt

@@ -1 +0,0 @@
-package be.simplenotes.shared

simplenotes-app/pom.xml

@@ -2,13 +2,13 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>parent</artifactId>
+        <artifactId>simplenotes-parent</artifactId>
         <groupId>be.simplenotes</groupId>
         <version>1.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>app</artifactId>
+    <artifactId>simplenotes-app</artifactId>
 
     <properties>
         <http4k.version>3.268.0</http4k.version>
@@ -17,52 +17,58 @@
     <dependencies>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>persistance</artifactId>
+            <artifactId>simplenotes-persistance</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>search</artifactId>
+            <artifactId>simplenotes-search</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>domain</artifactId>
+            <artifactId>simplenotes-domain</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>shared</artifactId>
+            <artifactId>simplenotes-config</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>org.http4k</groupId>
             <artifactId>http4k-core</artifactId>
         </dependency>
+
+        <!--
         <dependency>
             <groupId>org.http4k</groupId>
             <artifactId>http4k-server-jetty</artifactId>
-            <exclusions>
+        </dependency>
-                <exclusion>
+        -->
-                    <groupId>org.eclipse.jetty.websocket</groupId>
+        <dependency>
-                    <artifactId>javax-websocket-server-impl</artifactId>
+            <groupId>org.eclipse.jetty</groupId>
-                </exclusion>
+            <artifactId>jetty-server</artifactId>
-            </exclusions>
+            <version>9.4.32.v20200930</version>
+            <scope>compile</scope>
         </dependency>
         <dependency>
-            <groupId>org.jetbrains.kotlinx</groupId>
+            <groupId>org.eclipse.jetty</groupId>
-            <artifactId>kotlinx-html-jvm</artifactId>
+            <artifactId>jetty-servlet</artifactId>
-            <version>0.7.1</version>
+            <version>9.4.32.v20200930</version>
+            <scope>compile</scope>
         </dependency>
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>javax.servlet-api</artifactId>
+            <version>4.0.1</version>
+            <scope>compile</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.jetbrains.kotlinx</groupId>
             <artifactId>kotlinx-serialization-json-jvm</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.ocpsoft.prettytime</groupId>
-            <artifactId>prettytime</artifactId>
-            <version>4.0.5.Final</version>
-        </dependency>
 
         <dependency>
             <groupId>ch.qos.logback</groupId>
@@ -81,7 +87,7 @@
 
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>shared</artifactId>
+            <artifactId>simplenotes-test-resources</artifactId>
             <version>1.0-SNAPSHOT</version>
             <type>test-jar</type>
             <scope>test</scope>
@@ -96,6 +102,12 @@
             <groupId>me.liuwj.ktorm</groupId>
             <artifactId>ktorm-core</artifactId>
         </dependency>
+        <dependency>
+            <groupId>be.simplenotes</groupId>
+            <artifactId>simplenotes-views</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
 
     <dependencyManagement>

simplenotes-app/src/main/kotlin/be/simplenotes/app/Server.kt

@@ -2,7 +2,7 @@ package be.simplenotes.app
 
 import org.http4k.server.Http4kServer
 import org.slf4j.LoggerFactory
-import be.simplenotes.shared.config.ServerConfig as SimpleNotesServerConfig
+import be.simplenotes.config.ServerConfig as SimpleNotesServerConfig
 
 class Server(
     private val config: SimpleNotesServerConfig,

simplenotes-app/src/main/kotlin/be/simplenotes/app/SimpleNotes.kt

@@ -2,10 +2,12 @@ package be.simplenotes.app
 
 import be.simplenotes.app.extensions.addShutdownHook
 import be.simplenotes.app.modules.*
+import be.simplenotes.config.configModule
 import be.simplenotes.domain.domainModule
 import be.simplenotes.persistance.migrationModule
 import be.simplenotes.persistance.persistanceModule
 import be.simplenotes.search.searchModule
+import be.simplenotes.views.viewModule
 import org.koin.core.context.startKoin
 import org.koin.core.context.unloadKoinModules
 
@@ -16,10 +18,8 @@ fun main() {
             persistanceModule,
             migrationModule,
             configModule,
-            baseModule,
+            viewModule,
-            userModule,
+            controllerModule,
-            noteModule,
-            settingsModule,
             domainModule,
             searchModule,
             apiModule,

simplenotes-app/src/main/kotlin/be/simplenotes/app/api/ApiNoteController.kt

@@ -0,0 +1,74 @@
+package be.simplenotes.app.api
+
+import be.simplenotes.app.extensions.auto
+import be.simplenotes.app.utils.parseSearchTerms
+import be.simplenotes.types.PersistedNote
+import be.simplenotes.types.PersistedNoteMetadata
+import be.simplenotes.domain.usecases.NoteService
+import be.simplenotes.types.LoggedInUser
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import org.http4k.core.Request
+import org.http4k.core.Response
+import org.http4k.core.Status.Companion.BAD_REQUEST
+import org.http4k.core.Status.Companion.NOT_FOUND
+import org.http4k.core.Status.Companion.OK
+import org.http4k.lens.Path
+import org.http4k.lens.uuid
+import java.util.*
+
+class ApiNoteController(private val noteService: NoteService, private val json: Json) {
+
+    fun createNote(request: Request, loggedInUser: LoggedInUser): Response {
+        val content = noteContentLens(request)
+        return noteService.create(loggedInUser.userId, content).fold(
+            { Response(BAD_REQUEST) },
+            { uuidContentLens(UuidContent(it.uuid), Response(OK)) }
+        )
+    }
+
+    fun notes(request: Request, loggedInUser: LoggedInUser): Response {
+        val notes = noteService.paginatedNotes(loggedInUser.userId, page = 1).notes
+        return persistedNotesMetadataLens(notes, Response(OK))
+    }
+
+    fun note(request: Request, loggedInUser: LoggedInUser): Response =
+        noteService.find(loggedInUser.userId, uuidLens(request))
+            ?.let { persistedNoteLens(it, Response(OK)) }
+            ?: Response(NOT_FOUND)
+
+    fun update(request: Request, loggedInUser: LoggedInUser): Response {
+        val content = noteContentLens(request)
+        return noteService.update(loggedInUser.userId, uuidLens(request), content).fold({
+            Response(BAD_REQUEST)
+        }, {
+            if (it == null) Response(NOT_FOUND)
+            else Response(OK)
+        })
+    }
+
+    fun search(request: Request, loggedInUser: LoggedInUser): Response {
+        val query = searchContentLens(request)
+        val terms = parseSearchTerms(query)
+        val notes = noteService.search(loggedInUser.userId, terms)
+        return persistedNotesMetadataLens(notes, Response(OK))
+    }
+
+    private val uuidContentLens = json.auto<UuidContent>().toLens()
+    private val noteContentLens = json.auto<NoteContent>().map { it.content }.toLens()
+    private val searchContentLens = json.auto<SearchContent>().map { it.query }.toLens()
+    private val persistedNotesMetadataLens = json.auto<List<PersistedNoteMetadata>>().toLens()
+    private val persistedNoteLens = json.auto<PersistedNote>().toLens()
+    private val uuidLens = Path.uuid().of("uuid")
+
+}
+
+@Serializable
+data class NoteContent(val content: String)
+
+@Serializable
+data class UuidContent(@Contextual val uuid: UUID)
+
+@Serializable
+data class SearchContent(@Contextual val query: String)

simplenotes-app/src/main/kotlin/be/simplenotes/app/api/ApiUserController.kt

@@ -0,0 +1,26 @@
+package be.simplenotes.app.api
+
+import be.simplenotes.app.extensions.auto
+import be.simplenotes.domain.usecases.UserService
+import be.simplenotes.domain.usecases.users.login.LoginForm
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import org.http4k.core.Request
+import org.http4k.core.Response
+import org.http4k.core.Status.Companion.BAD_REQUEST
+import org.http4k.core.Status.Companion.OK
+
+class ApiUserController(private val userService: UserService, private val json: Json) {
+    private val tokenLens = json.auto<Token>().toLens()
+    private val loginFormLens = json.auto<LoginForm>().toLens()
+
+    fun login(request: Request) = userService
+        .login(loginFormLens(request))
+        .fold(
+            { Response(BAD_REQUEST) },
+            { tokenLens(Token(it), Response(OK)) }
+        )
+}
+
+@Serializable
+data class Token(val token: String)

simplenotes-app/src/main/kotlin/be/simplenotes/app/controllers/BaseController.kt

@@ -1,13 +1,13 @@
 package be.simplenotes.app.controllers
 
 import be.simplenotes.app.extensions.html
-import be.simplenotes.app.views.BaseView
+import be.simplenotes.types.LoggedInUser
-import be.simplenotes.domain.security.JwtPayload
+import be.simplenotes.views.BaseView
 import org.http4k.core.Request
 import org.http4k.core.Response
 import org.http4k.core.Status.Companion.OK
 
 class BaseController(private val view: BaseView) {
-    fun index(@Suppress("UNUSED_PARAMETER") request: Request, jwtPayload: JwtPayload?) =
+    fun index(@Suppress("UNUSED_PARAMETER") request: Request, loggedInUser: LoggedInUser?) =
-        Response(OK).html(view.renderHome(jwtPayload))
+        Response(OK).html(view.renderHome(loggedInUser))
 }

simplenotes-app/src/main/kotlin/be/simplenotes/app/controllers/NoteController.kt

@@ -3,12 +3,12 @@ package be.simplenotes.app.controllers
 import be.simplenotes.app.extensions.html
 import be.simplenotes.app.extensions.redirect
 import be.simplenotes.app.utils.parseSearchTerms
-import be.simplenotes.app.views.NoteView
+import be.simplenotes.views.NoteView
-import be.simplenotes.domain.security.JwtPayload
 import be.simplenotes.domain.usecases.NoteService
 import be.simplenotes.domain.usecases.markdown.InvalidMeta
 import be.simplenotes.domain.usecases.markdown.MissingMeta
 import be.simplenotes.domain.usecases.markdown.ValidationError
+import be.simplenotes.types.LoggedInUser
 import org.http4k.core.Method
 import org.http4k.core.Request
 import org.http4k.core.Response
@@ -25,18 +25,18 @@ class NoteController(
     private val noteService: NoteService,
 ) {
 
-    fun new(request: Request, jwtPayload: JwtPayload): Response {
+    fun new(request: Request, loggedInUser: LoggedInUser): Response {
-        if (request.method == Method.GET) return Response(OK).html(view.noteEditor(jwtPayload))
+        if (request.method == Method.GET) return Response(OK).html(view.noteEditor(loggedInUser))
 
         val markdownForm = request.form("markdown") ?: ""
 
-        return noteService.create(jwtPayload.userId, markdownForm).fold(
+        return noteService.create(loggedInUser.userId, markdownForm).fold(
             {
                 val html = when (it) {
-                    MissingMeta -> view.noteEditor(jwtPayload, error = "Missing note metadata", textarea = markdownForm)
+                    MissingMeta -> view.noteEditor(loggedInUser, error = "Missing note metadata", textarea = markdownForm)
-                    InvalidMeta -> view.noteEditor(jwtPayload, error = "Invalid note metadata", textarea = markdownForm)
+                    InvalidMeta -> view.noteEditor(loggedInUser, error = "Invalid note metadata", textarea = markdownForm)
                     is ValidationError -> view.noteEditor(
-                        jwtPayload,
+                        loggedInUser,
                         validationErrors = it.validationErrors,
                         textarea = markdownForm
                     )
@@ -49,66 +49,66 @@ class NoteController(
         )
     }
 
-    fun list(request: Request, jwtPayload: JwtPayload): Response {
+    fun list(request: Request, loggedInUser: LoggedInUser): Response {
         val currentPage = request.query("page")?.toIntOrNull()?.let(::abs) ?: 1
         val tag = request.query("tag")
-        val (pages, notes) = noteService.paginatedNotes(jwtPayload.userId, currentPage, tag = tag)
+        val (pages, notes) = noteService.paginatedNotes(loggedInUser.userId, currentPage, tag = tag)
-        val deletedCount = noteService.countDeleted(jwtPayload.userId)
+        val deletedCount = noteService.countDeleted(loggedInUser.userId)
-        return Response(OK).html(view.notes(jwtPayload, notes, currentPage, pages, deletedCount, tag = tag))
+        return Response(OK).html(view.notes(loggedInUser, notes, currentPage, pages, deletedCount, tag = tag))
     }
 
-    fun search(request: Request, jwtPayload: JwtPayload): Response {
+    fun search(request: Request, loggedInUser: LoggedInUser): Response {
         val query = request.form("search") ?: ""
         val terms = parseSearchTerms(query)
-        val notes = noteService.search(jwtPayload.userId, terms)
+        val notes = noteService.search(loggedInUser.userId, terms)
-        val deletedCount = noteService.countDeleted(jwtPayload.userId)
+        val deletedCount = noteService.countDeleted(loggedInUser.userId)
-        return Response(OK).html(view.search(jwtPayload, notes, query, deletedCount))
+        return Response(OK).html(view.search(loggedInUser, notes, query, deletedCount))
     }
 
-    fun note(request: Request, jwtPayload: JwtPayload): Response {
+    fun note(request: Request, loggedInUser: LoggedInUser): Response {
         val noteUuid = request.uuidPath() ?: return Response(NOT_FOUND)
 
         if (request.method == Method.POST) {
             if (request.form("delete") != null) {
-                return if (noteService.trash(jwtPayload.userId, noteUuid))
+                return if (noteService.trash(loggedInUser.userId, noteUuid))
                     Response.redirect("/notes") // TODO: flash cookie to show success ?
                 else
                     Response(NOT_FOUND) // TODO: show an error
             }
             if (request.form("public") != null) {
-                if (!noteService.makePublic(jwtPayload.userId, noteUuid)) return Response(NOT_FOUND)
+                if (!noteService.makePublic(loggedInUser.userId, noteUuid)) return Response(NOT_FOUND)
             } else if (request.form("private") != null) {
-                if (!noteService.makePrivate(jwtPayload.userId, noteUuid)) return Response(NOT_FOUND)
+                if (!noteService.makePrivate(loggedInUser.userId, noteUuid)) return Response(NOT_FOUND)
             }
         }
 
-        val note = noteService.find(jwtPayload.userId, noteUuid) ?: return Response(NOT_FOUND)
+        val note = noteService.find(loggedInUser.userId, noteUuid) ?: return Response(NOT_FOUND)
-        return Response(OK).html(view.renderedNote(jwtPayload, note, shared = false))
+        return Response(OK).html(view.renderedNote(loggedInUser, note, shared = false))
     }
 
-    fun public(request: Request, jwtPayload: JwtPayload?): Response {
+    fun public(request: Request, loggedInUser: LoggedInUser?): Response {
         val noteUuid = request.uuidPath() ?: return Response(NOT_FOUND)
         val note = noteService.findPublic(noteUuid) ?: return Response(NOT_FOUND)
-        return Response(OK).html(view.renderedNote(jwtPayload, note, shared = true))
+        return Response(OK).html(view.renderedNote(loggedInUser, note, shared = true))
     }
 
-    fun edit(request: Request, jwtPayload: JwtPayload): Response {
+    fun edit(request: Request, loggedInUser: LoggedInUser): Response {
         val noteUuid = request.uuidPath() ?: return Response(NOT_FOUND)
-        val note = noteService.find(jwtPayload.userId, noteUuid) ?: return Response(NOT_FOUND)
+        val note = noteService.find(loggedInUser.userId, noteUuid) ?: return Response(NOT_FOUND)
 
         if (request.method == Method.GET) {
-            return Response(OK).html(view.noteEditor(jwtPayload, textarea = note.markdown))
+            return Response(OK).html(view.noteEditor(loggedInUser, textarea = note.markdown))
         }
 
         val markdownForm = request.form("markdown") ?: ""
 
-        return noteService.update(jwtPayload.userId, note.uuid, markdownForm).fold(
+        return noteService.update(loggedInUser.userId, note.uuid, markdownForm).fold(
             {
                 val html = when (it) {
-                    MissingMeta -> view.noteEditor(jwtPayload, error = "Missing note metadata", textarea = markdownForm)
+                    MissingMeta -> view.noteEditor(loggedInUser, error = "Missing note metadata", textarea = markdownForm)
-                    InvalidMeta -> view.noteEditor(jwtPayload, error = "Invalid note metadata", textarea = markdownForm)
+                    InvalidMeta -> view.noteEditor(loggedInUser, error = "Invalid note metadata", textarea = markdownForm)
                     is ValidationError -> view.noteEditor(
-                        jwtPayload,
+                        loggedInUser,
                         validationErrors = it.validationErrors,
                         textarea = markdownForm
                     )
@@ -121,21 +121,21 @@ class NoteController(
         )
     }
 
-    fun trash(request: Request, jwtPayload: JwtPayload): Response {
+    fun trash(request: Request, loggedInUser: LoggedInUser): Response {
         val currentPage = request.query("page")?.toIntOrNull()?.let(::abs) ?: 1
         val tag = request.query("tag")
-        val (pages, notes) = noteService.paginatedNotes(jwtPayload.userId, currentPage, tag = tag, deleted = true)
+        val (pages, notes) = noteService.paginatedNotes(loggedInUser.userId, currentPage, tag = tag, deleted = true)
-        return Response(OK).html(view.trash(jwtPayload, notes, currentPage, pages))
+        return Response(OK).html(view.trash(loggedInUser, notes, currentPage, pages))
     }
 
-    fun deleted(request: Request, jwtPayload: JwtPayload): Response {
+    fun deleted(request: Request, loggedInUser: LoggedInUser): Response {
         val uuid = request.uuidPath() ?: return Response(NOT_FOUND)
         return if (request.form("delete") != null)
-            if (noteService.delete(jwtPayload.userId, uuid))
+            if (noteService.delete(loggedInUser.userId, uuid))
                 Response.redirect("/notes/trash")
             else
                 Response(NOT_FOUND)
-        else if (noteService.restore(jwtPayload.userId, uuid))
+        else if (noteService.restore(loggedInUser.userId, uuid))
             Response.redirect("/notes/$uuid")
         else
             Response(NOT_FOUND)

simplenotes-app/src/main/kotlin/be/simplenotes/app/controllers/SettingsController.kt

@@ -2,11 +2,11 @@ package be.simplenotes.app.controllers
 
 import be.simplenotes.app.extensions.html
 import be.simplenotes.app.extensions.redirect
-import be.simplenotes.app.views.SettingView
+import be.simplenotes.views.SettingView
-import be.simplenotes.domain.security.JwtPayload
 import be.simplenotes.domain.usecases.UserService
 import be.simplenotes.domain.usecases.users.delete.DeleteError
 import be.simplenotes.domain.usecases.users.delete.DeleteForm
+import be.simplenotes.types.LoggedInUser
 import org.http4k.core.*
 import org.http4k.core.body.form
 import org.http4k.core.cookie.invalidateCookie
@@ -15,11 +15,11 @@ class SettingsController(
     private val userService: UserService,
     private val settingView: SettingView,
 ) {
-    fun settings(request: Request, jwtPayload: JwtPayload): Response {
+    fun settings(request: Request, loggedInUser: LoggedInUser): Response {
         if (request.method == Method.GET)
-            return Response(Status.OK).html(settingView.settings(jwtPayload))
+            return Response(Status.OK).html(settingView.settings(loggedInUser))
 
-        val deleteForm = request.deleteForm(jwtPayload)
+        val deleteForm = request.deleteForm(loggedInUser)
         val result = userService.delete(deleteForm)
 
         return result.fold(
@@ -28,13 +28,13 @@ class SettingsController(
                     DeleteError.Unregistered -> Response.redirect("/").invalidateCookie("Bearer")
                     DeleteError.WrongPassword -> Response(Status.OK).html(
                         settingView.settings(
-                            jwtPayload,
+                            loggedInUser,
                             error = "Wrong password"
                         )
                     )
                     is DeleteError.InvalidForm -> Response(Status.OK).html(
                         settingView.settings(
-                            jwtPayload,
+                            loggedInUser,
                             validationErrors = it.validationErrors
                         )
                     )
@@ -53,23 +53,23 @@ class SettingsController(
             .header("Content-Type", contentType)
     }
 
-    fun export(request: Request, jwtPayload: JwtPayload): Response {
+    fun export(request: Request, loggedInUser: LoggedInUser): Response {
         val isDownload = request.form("download") != null
 
         return if (isDownload) {
-            val filename = "simplenotes-export-${jwtPayload.username}"
+            val filename = "simplenotes-export-${loggedInUser.username}"
             if (request.form("format") == "zip") {
-                val zip = userService.exportAsZip(jwtPayload.userId)
+                val zip = userService.exportAsZip(loggedInUser.userId)
                 Response(Status.OK)
                     .with(attachment("$filename.zip", "application/zip"))
                     .body(zip)
             } else
                 Response(Status.OK)
                     .with(attachment("$filename.json", "application/json"))
-                    .body(userService.exportAsJson(jwtPayload.userId))
+                    .body(userService.exportAsJson(loggedInUser.userId))
-        } else Response(Status.OK).body(userService.exportAsJson(jwtPayload.userId)).header("Content-Type", "application/json")
+        } else Response(Status.OK).body(userService.exportAsJson(loggedInUser.userId)).header("Content-Type", "application/json")
     }
 
-    private fun Request.deleteForm(jwtPayload: JwtPayload) =
+    private fun Request.deleteForm(loggedInUser: LoggedInUser) =
-        DeleteForm(jwtPayload.username, form("password"), form("checked") != null)
+        DeleteForm(loggedInUser.username, form("password"), form("checked") != null)
 }

simplenotes-app/src/main/kotlin/be/simplenotes/app/controllers/UserController.kt

@@ -3,14 +3,14 @@ package be.simplenotes.app.controllers
 import be.simplenotes.app.extensions.html
 import be.simplenotes.app.extensions.isSecure
 import be.simplenotes.app.extensions.redirect
-import be.simplenotes.app.views.UserView
+import be.simplenotes.views.UserView
-import be.simplenotes.domain.security.JwtPayload
 import be.simplenotes.domain.usecases.UserService
 import be.simplenotes.domain.usecases.users.login.*
 import be.simplenotes.domain.usecases.users.register.InvalidRegisterForm
 import be.simplenotes.domain.usecases.users.register.RegisterForm
 import be.simplenotes.domain.usecases.users.register.UserExists
-import be.simplenotes.shared.config.JwtConfig
+import be.simplenotes.config.JwtConfig
+import be.simplenotes.types.LoggedInUser
 import org.http4k.core.Method.GET
 import org.http4k.core.Request
 import org.http4k.core.Response
@@ -27,9 +27,9 @@ class UserController(
     private val userView: UserView,
     private val jwtConfig: JwtConfig,
 ) {
-    fun register(request: Request, jwtPayload: JwtPayload?): Response {
+    fun register(request: Request, loggedInUser: LoggedInUser?): Response {
         if (request.method == GET) return Response(OK).html(
-            userView.register(jwtPayload)
+            userView.register(loggedInUser)
         )
 
         val result = userService.register(request.registerForm())
@@ -38,12 +38,12 @@ class UserController(
             {
                 val html = when (it) {
                     UserExists -> userView.register(
-                        jwtPayload,
+                        loggedInUser,
                         error = "User already exists"
                     )
                     is InvalidRegisterForm ->
                         userView.register(
-                            jwtPayload,
+                            loggedInUser,
                             validationErrors = it.validationErrors
                         )
                 }
@@ -58,9 +58,9 @@ class UserController(
     private fun Request.registerForm() = RegisterForm(form("username"), form("password"))
     private fun Request.loginForm(): LoginForm = registerForm()
 
-    fun login(request: Request, jwtPayload: JwtPayload?): Response {
+    fun login(request: Request, loggedInUser: LoggedInUser?): Response {
         if (request.method == GET) return Response(OK).html(
-            userView.login(jwtPayload)
+            userView.login(loggedInUser)
         )
 
         val result = userService.login(request.loginForm())
@@ -70,17 +70,17 @@ class UserController(
                 val html = when (it) {
                     Unregistered ->
                         userView.login(
-                            jwtPayload,
+                            loggedInUser,
                             error = "User does not exist"
                         )
                     WrongPassword ->
                         userView.login(
-                            jwtPayload,
+                            loggedInUser,
                             error = "Wrong password"
                         )
                     is InvalidLoginForm ->
                         userView.login(
-                            jwtPayload,
+                            loggedInUser,
                             validationErrors = it.validationErrors
                         )
                 }

simplenotes-app/src/main/kotlin/be/simplenotes/app/extensions/Http4kExtensions.kt

@@ -0,0 +1,35 @@
+package be.simplenotes.app.extensions
+
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.http4k.asString
+import org.http4k.core.Body
+import org.http4k.core.ContentType
+import org.http4k.core.Request
+import org.http4k.core.Response
+import org.http4k.core.Status.Companion.FOUND
+import org.http4k.core.Status.Companion.MOVED_PERMANENTLY
+import org.http4k.lens.*
+
+fun Response.html(html: String) = body(html)
+    .header("Content-Type", "text/html; charset=utf-8")
+    .header("Cache-Control", "no-cache")
+
+fun Response.Companion.redirect(url: String, permanent: Boolean = false) =
+    Response(if (permanent) MOVED_PERMANENTLY else FOUND).header("Location", url)
+
+fun Request.isSecure() = header("X-Forwarded-Proto")?.contains("https") ?: false
+
+val bodyLens = httpBodyRoot(
+    listOf(Meta(true, "body", ParamMeta.ObjectParam, "body")),
+    ContentType.APPLICATION_JSON.withNoDirectives(), ContentNegotiation.StrictNoDirective
+).map(
+    { it.payload.asString() },
+    { Body(it) }
+)
+
+inline fun <reified T> Json.auto(): BiDiBodyLensSpec<T> = bodyLens.map(
+    { decodeFromString(it) },
+    { encodeToString(it) }
+)

simplenotes-app/src/main/kotlin/be/simplenotes/app/filters/AuthFilter.kt

@@ -1,8 +1,8 @@
 package be.simplenotes.app.filters
 
 import be.simplenotes.app.extensions.redirect
-import be.simplenotes.domain.security.JwtPayload
 import be.simplenotes.domain.security.JwtPayloadExtractor
+import be.simplenotes.types.LoggedInUser
 import org.http4k.core.*
 import org.http4k.core.Status.Companion.UNAUTHORIZED
 import org.http4k.core.cookie.cookie
@@ -40,7 +40,7 @@ class AuthFilter(
     }
 }
 
-fun Request.jwtPayload(ctx: RequestContexts): JwtPayload? = ctx[this][authKey]
+fun Request.jwtPayload(ctx: RequestContexts): LoggedInUser? = ctx[this][authKey]
 
 enum class JwtSource {
     Header, Cookie

simplenotes-app/src/main/kotlin/be/simplenotes/app/filters/ErrorFilter.kt

@@ -1,8 +1,8 @@
 package be.simplenotes.app.filters
 
 import be.simplenotes.app.extensions.html
-import be.simplenotes.app.views.ErrorView
+import be.simplenotes.views.ErrorView
-import be.simplenotes.app.views.ErrorView.Type.*
+import be.simplenotes.views.ErrorView.Type.*
 import org.http4k.core.*
 import org.http4k.core.Status.Companion.INTERNAL_SERVER_ERROR
 import org.http4k.core.Status.Companion.NOT_FOUND

simplenotes-app/src/main/kotlin/be/simplenotes/app/jetty/Jetty.kt

@@ -0,0 +1,40 @@
+package be.simplenotes.app.jetty
+
+import org.eclipse.jetty.server.Server
+import org.eclipse.jetty.server.ServerConnector
+import org.eclipse.jetty.servlet.ServletContextHandler
+import org.eclipse.jetty.servlet.ServletContextHandler.SESSIONS
+import org.eclipse.jetty.servlet.ServletHolder
+import org.http4k.core.HttpHandler
+import org.http4k.server.Http4kServer
+import org.http4k.server.ServerConfig
+import org.http4k.servlet.asServlet
+
+class Jetty(private val port: Int, private val server: Server) : ServerConfig {
+    constructor(port: Int = 8000) : this(port, http(port))
+    constructor(port: Int, vararg inConnectors: ConnectorBuilder) : this(port, Server().apply {
+        inConnectors.forEach { addConnector(it(this)) }
+    })
+
+    override fun toServer(httpHandler: HttpHandler): Http4kServer {
+        server.insertHandler(httpHandler.toJettyHandler())
+
+        return object : Http4kServer {
+            override fun start(): Http4kServer = apply {
+                server.start()
+            }
+
+            override fun stop(): Http4kServer = apply { server.stop() }
+
+            override fun port(): Int = if (port > 0) port else server.uri.port
+        }
+    }
+}
+
+fun HttpHandler.toJettyHandler() = ServletContextHandler(SESSIONS).apply {
+    addServlet(ServletHolder(this@toJettyHandler.asServlet()), "/*")
+}
+
+typealias ConnectorBuilder = (Server) -> ServerConnector
+
+fun http(httpPort: Int): ConnectorBuilder = { server: Server -> ServerConnector(server).apply { port = httpPort } }

simplenotes-app/src/main/kotlin/be/simplenotes/app/modules/CoreModules.kt

@@ -0,0 +1,12 @@
+package be.simplenotes.app.modules
+
+import be.simplenotes.app.controllers.*
+import org.koin.dsl.module
+
+val controllerModule = module {
+    single { UserController(get(), get(), get()) }
+    single { HealthCheckController(get()) }
+    single { BaseController(get()) }
+    single { NoteController(get(), get()) }
+    single { SettingsController(get(), get()) }
+}

simplenotes-app/src/main/kotlin/be/simplenotes/app/modules/ServerModule.kt

@@ -5,17 +5,17 @@ import be.simplenotes.app.filters.AuthFilter
 import be.simplenotes.app.filters.AuthType
 import be.simplenotes.app.filters.ErrorFilter
 import be.simplenotes.app.filters.TransactionFilter
+import be.simplenotes.app.jetty.ConnectorBuilder
+import be.simplenotes.app.jetty.Jetty
 import be.simplenotes.app.routes.Router
 import be.simplenotes.app.utils.StaticFileResolver
 import be.simplenotes.app.utils.StaticFileResolverImpl
-import be.simplenotes.app.views.ErrorView
+import be.simplenotes.views.ErrorView
-import be.simplenotes.shared.config.ServerConfig
+import be.simplenotes.config.ServerConfig
 import org.eclipse.jetty.server.ServerConnector
 import org.http4k.core.Filter
 import org.http4k.core.RequestContexts
 import org.http4k.routing.RoutingHttpHandler
-import org.http4k.server.ConnectorBuilder
-import org.http4k.server.Jetty
 import org.http4k.server.asServer
 import org.koin.core.qualifier.named
 import org.koin.core.qualifier.qualifier
@@ -59,5 +59,5 @@ val serverModule = module {
     single<Filter>(AuthType.Required.qualifier) { AuthFilter(get(), AuthType.Required, get()) }
     single { ErrorFilter(get()) }
     single { TransactionFilter(get()) }
-    single { ErrorView(get()) }
+    single(named("styles")) { get<StaticFileResolver>().resolve("styles.css") }
 }

simplenotes-app/src/main/kotlin/be/simplenotes/app/routes/Router.kt

@@ -4,7 +4,7 @@ import be.simplenotes.app.api.ApiNoteController
 import be.simplenotes.app.api.ApiUserController
 import be.simplenotes.app.controllers.*
 import be.simplenotes.app.filters.*
-import be.simplenotes.domain.security.JwtPayload
+import be.simplenotes.types.LoggedInUser
 import org.http4k.core.*
 import org.http4k.core.Method.*
 import org.http4k.filter.ResponseFilters.GZip
@@ -102,5 +102,5 @@ class Router(
         this to transactionFilter.then { handler(it, it.jwtPayload(contexts)) }
 }
 
-private typealias PublicHandler = (Request, JwtPayload?) -> Response
+private typealias PublicHandler = (Request, LoggedInUser?) -> Response
-private typealias ProtectedHandler = (Request, JwtPayload) -> Response
+private typealias ProtectedHandler = (Request, LoggedInUser) -> Response

simplenotes-app/src/main/kotlin/be/simplenotes/app/utils/SearchTermsParser.kt

@@ -1,6 +1,6 @@
 package be.simplenotes.app.utils
 
-import be.simplenotes.domain.usecases.search.SearchTerms
+import be.simplenotes.search.SearchTerms
 
 private fun innerRegex(name: String) =
     """$name:['"](.*?)['"]""".toRegex()

simplenotes-app/src/test/kotlin/be/simplenotes/app/filters/AuthFilterTest.kt

@@ -1,9 +1,9 @@
 package be.simplenotes.app.filters
 
-import be.simplenotes.domain.security.JwtPayload
 import be.simplenotes.domain.security.JwtPayloadExtractor
 import be.simplenotes.domain.security.SimpleJwt
-import be.simplenotes.shared.config.JwtConfig
+import be.simplenotes.config.JwtConfig
+import be.simplenotes.types.LoggedInUser
 import com.natpryce.hamkrest.assertion.assertThat
 import org.http4k.core.*
 import org.http4k.core.Method.GET
@@ -58,7 +58,7 @@ internal class AuthFilterTest {
 
         @Test
         fun `it should allow a valid token`() {
-            val jwtPayload = JwtPayload(1, "user")
+            val jwtPayload = LoggedInUser(1, "user")
             val token = simpleJwt.sign(jwtPayload)
             val response = app(Request(GET, "/optional").cookie("Bearer", token))
             assertThat(response, hasStatus(OK))
@@ -84,7 +84,7 @@ internal class AuthFilterTest {
 
         @Test
         fun `it should allow a valid token"`() {
-            val jwtPayload = JwtPayload(1, "user")
+            val jwtPayload = LoggedInUser(1, "user")
             val token = simpleJwt.sign(jwtPayload)
             val response = app(Request(GET, "/protected").cookie("Bearer", token))
             assertThat(response, hasStatus(OK))

simplenotes-app/src/test/kotlin/be/simplenotes/app/utils/SearchTermsParserKtTest.kt

@@ -1,6 +1,6 @@
 package be.simplenotes.app.utils
 
-import be.simplenotes.domain.usecases.search.SearchTerms
+import be.simplenotes.search.SearchTerms
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.MethodSource

simplenotes-config/pom.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>simplenotes-parent</artifactId>
+        <groupId>be.simplenotes</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>simplenotes-config</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.koin</groupId>
+            <artifactId>koin-core</artifactId>
+        </dependency>
+    </dependencies>
+
+</project>

simplenotes-config/src/main/kotlin/be/simplenotes/config/Config.kt

@@ -1,4 +1,4 @@
-package be.simplenotes.shared.config
+package be.simplenotes.config
 
 import java.util.concurrent.TimeUnit
 

simplenotes-config/src/main/kotlin/be/simplenotes/config/ConfigLoader.kt

@@ -1,12 +1,9 @@
-package be.simplenotes.app
+package be.simplenotes.config
 
-import be.simplenotes.shared.config.DataSourceConfig
-import be.simplenotes.shared.config.JwtConfig
-import be.simplenotes.shared.config.ServerConfig
 import java.util.*
 import java.util.concurrent.TimeUnit
 
-class Config {
+class ConfigLoader {
     //region Config loading
     private val properties: Properties = javaClass
         .getResource("/application.properties")

simplenotes-config/src/main/kotlin/be/simplenotes/config/ConfigModule.kt

@@ -0,0 +1,10 @@
+package be.simplenotes.config
+
+import org.koin.dsl.module
+
+val configModule = module {
+    single { ConfigLoader() }
+    single { get<ConfigLoader>().dataSourceConfig }
+    single { get<ConfigLoader>().jwtConfig }
+    single { get<ConfigLoader>().serverConfig }
+}

simplenotes-domain/pom.xml

@@ -2,36 +2,38 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>parent</artifactId>
+        <artifactId>simplenotes-parent</artifactId>
         <groupId>be.simplenotes</groupId>
         <version>1.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>domain</artifactId>
+    <artifactId>simplenotes-domain</artifactId>
 
     <dependencies>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>shared</artifactId>
+            <artifactId>simplenotes-config</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>shared</artifactId>
+            <artifactId>simplenotes-test-resources</artifactId>
             <version>1.0-SNAPSHOT</version>
             <type>test-jar</type>
             <scope>test</scope>
         </dependency>
 
-        <dependency>
-            <groupId>io.arrow-kt</groupId>
-            <artifactId>arrow-core</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.koin</groupId>
             <artifactId>koin-core</artifactId>
         </dependency>
+
+        <dependency>
+            <groupId>io.arrow-kt</groupId>
+            <artifactId>arrow-core</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>com.natpryce</groupId>
             <artifactId>hamkrest</artifactId>
@@ -83,15 +85,29 @@
             <artifactId>owasp-java-html-sanitizer</artifactId>
             <version>20200713.1</version>
         </dependency>
-        <dependency>
-            <groupId>org.jetbrains.kotlinx</groupId>
-            <artifactId>kotlinx-serialization-json-jvm</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-compress</artifactId>
             <version>1.20</version>
         </dependency>
+        <dependency>
+            <groupId>be.simplenotes</groupId>
+            <artifactId>simplenotes-types</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>be.simplenotes</groupId>
+            <artifactId>simplenotes-persistance</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>be.simplenotes</groupId>
+            <artifactId>simplenotes-search</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
 
 </project>

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/security/HtmlSanitizer.kt

@@ -2,7 +2,7 @@ package be.simplenotes.domain.security
 
 import org.owasp.html.HtmlPolicyBuilder
 
-object HtmlSanitizer {
+internal object HtmlSanitizer {
     private val htmlPolicy = HtmlPolicyBuilder()
         .allowElements("a")
         .allowCommonBlockElements()

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/security/JwtPayload.kt

@@ -1,18 +1,14 @@
 package be.simplenotes.domain.security
 
-import be.simplenotes.domain.model.PersistedUser
+import be.simplenotes.types.LoggedInUser
 import com.auth0.jwt.exceptions.JWTVerificationException
 
-data class JwtPayload(val userId: Int, val username: String) {
-    constructor(user: PersistedUser) : this(user.id, user.username)
-}
-
 class JwtPayloadExtractor(private val jwt: SimpleJwt) {
-    operator fun invoke(token: String): JwtPayload? = try {
+    operator fun invoke(token: String): LoggedInUser? = try {
         val decodedJWT = jwt.verifier.verify(token)
         val id = decodedJWT.getClaim(userIdField).asInt() ?: null
         val username = decodedJWT.getClaim(usernameField).asString() ?: null
-        id?.let { username?.let { JwtPayload(id, username) } }
+        id?.let { username?.let { LoggedInUser(id, username) } }
     } catch (e: JWTVerificationException) {
         null
     } catch (e: IllegalArgumentException) {

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/security/SimpleJwt.kt

@@ -1,6 +1,7 @@
 package be.simplenotes.domain.security
 
-import be.simplenotes.shared.config.JwtConfig
+import be.simplenotes.config.JwtConfig
+import be.simplenotes.types.LoggedInUser
 import com.auth0.jwt.JWT
 import com.auth0.jwt.JWTVerifier
 import com.auth0.jwt.algorithms.Algorithm
@@ -15,9 +16,9 @@ class SimpleJwt(jwtConfig: JwtConfig) {
     private val algorithm = Algorithm.HMAC256(jwtConfig.secret)
 
     val verifier: JWTVerifier = JWT.require(algorithm).build()
-    fun sign(jwtPayload: JwtPayload): String = JWT.create()
+    fun sign(loggedInUser: LoggedInUser): String = JWT.create()
-        .withClaim(userIdField, jwtPayload.userId)
+        .withClaim(userIdField, loggedInUser.userId)
-        .withClaim(usernameField, jwtPayload.username)
+        .withClaim(usernameField, loggedInUser.username)
         .withExpiresAt(getExpiration())
         .sign(algorithm)
 

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/usecases/NoteService.kt

@@ -2,16 +2,16 @@ package be.simplenotes.domain.usecases
 
 import arrow.core.Either
 import arrow.core.extensions.fx
-import be.simplenotes.domain.model.Note
+import be.simplenotes.types.Note
-import be.simplenotes.domain.model.PersistedNote
+import be.simplenotes.types.PersistedNote
-import be.simplenotes.domain.model.PersistedNoteMetadata
+import be.simplenotes.types.PersistedNoteMetadata
 import be.simplenotes.domain.security.HtmlSanitizer
 import be.simplenotes.domain.usecases.markdown.MarkdownConverter
 import be.simplenotes.domain.usecases.markdown.MarkdownParsingError
-import be.simplenotes.domain.usecases.repositories.NoteRepository
+import be.simplenotes.persistance.repositories.NoteRepository
-import be.simplenotes.domain.usecases.repositories.UserRepository
+import be.simplenotes.persistance.repositories.UserRepository
-import be.simplenotes.domain.usecases.search.NoteSearcher
+import be.simplenotes.search.NoteSearcher
-import be.simplenotes.domain.usecases.search.SearchTerms
+import be.simplenotes.search.SearchTerms
 import java.util.*
 
 class NoteService(

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/usecases/export/ExportUseCaseImpl.kt

@@ -1,7 +1,7 @@
 package be.simplenotes.domain.usecases.export
 
-import be.simplenotes.domain.model.ExportedNote
+import be.simplenotes.types.ExportedNote
-import be.simplenotes.domain.usecases.repositories.NoteRepository
+import be.simplenotes.persistance.repositories.NoteRepository
 import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.json.Json
 import org.apache.commons.compress.archivers.zip.ZipArchiveEntry

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/usecases/markdown/MarkdownConverter.kt

@@ -4,7 +4,7 @@ import arrow.core.Either
 import arrow.core.extensions.fx
 import arrow.core.left
 import arrow.core.right
-import be.simplenotes.domain.model.NoteMetadata
+import be.simplenotes.types.NoteMetadata
 import be.simplenotes.domain.validation.NoteValidations
 import com.vladsch.flexmark.ext.gfm.tasklist.TaskListExtension
 import com.vladsch.flexmark.html.HtmlRenderer

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/usecases/users/delete/DeleteUseCaseImpl.kt

@@ -4,9 +4,9 @@ import arrow.core.Either
 import arrow.core.extensions.fx
 import arrow.core.rightIfNotNull
 import be.simplenotes.domain.security.PasswordHash
-import be.simplenotes.domain.usecases.repositories.UserRepository
+import be.simplenotes.persistance.repositories.UserRepository
-import be.simplenotes.domain.usecases.search.NoteSearcher
 import be.simplenotes.domain.validation.UserValidations
+import be.simplenotes.search.NoteSearcher
 
 internal class DeleteUseCaseImpl(
     private val userRepository: UserRepository,

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/usecases/users/login/LoginUseCaseImpl.kt

@@ -4,11 +4,11 @@ import arrow.core.Either
 import arrow.core.extensions.fx
 import arrow.core.filterOrElse
 import arrow.core.rightIfNotNull
-import be.simplenotes.domain.security.JwtPayload
 import be.simplenotes.domain.security.PasswordHash
 import be.simplenotes.domain.security.SimpleJwt
-import be.simplenotes.domain.usecases.repositories.UserRepository
 import be.simplenotes.domain.validation.UserValidations
+import be.simplenotes.persistance.repositories.UserRepository
+import be.simplenotes.types.LoggedInUser
 
 internal class LoginUseCaseImpl(
     private val userRepository: UserRepository,
@@ -20,6 +20,6 @@ internal class LoginUseCaseImpl(
         !userRepository.find(user.username)
             .rightIfNotNull { Unregistered }
             .filterOrElse({ passwordHash.verify(form.password!!, it.password) }, { WrongPassword })
-            .map { jwt.sign(JwtPayload(it)) }
+            .map { jwt.sign(LoggedInUser(it)) }
     }
 }

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/usecases/users/register/RegisterUseCaseImpl.kt

@@ -3,10 +3,10 @@ package be.simplenotes.domain.usecases.users.register
 import arrow.core.Either
 import arrow.core.filterOrElse
 import arrow.core.leftIfNull
-import be.simplenotes.domain.model.PersistedUser
+import be.simplenotes.types.PersistedUser
 import be.simplenotes.domain.security.PasswordHash
-import be.simplenotes.domain.usecases.repositories.UserRepository
 import be.simplenotes.domain.validation.UserValidations
+import be.simplenotes.persistance.repositories.UserRepository
 
 internal class RegisterUseCaseImpl(
     private val userRepository: UserRepository,

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/usecases/users/register/RegisterUsecase.kt

@@ -1,7 +1,7 @@
 package be.simplenotes.domain.usecases.users.register
 
 import arrow.core.Either
-import be.simplenotes.domain.model.PersistedUser
+import be.simplenotes.types.PersistedUser
 import be.simplenotes.domain.usecases.users.login.LoginForm
 import io.konform.validation.ValidationErrors
 

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/validation/NoteValidations.kt

@@ -1,7 +1,7 @@
 package be.simplenotes.domain.validation
 
 import arrow.core.*
-import be.simplenotes.domain.model.NoteMetadata
+import be.simplenotes.types.NoteMetadata
 import be.simplenotes.domain.usecases.markdown.ValidationError
 import io.konform.validation.Validation
 import io.konform.validation.jsonschema.maxItems

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/validation/UserValidations.kt

@@ -3,7 +3,7 @@ package be.simplenotes.domain.validation
 import arrow.core.Either
 import arrow.core.left
 import arrow.core.right
-import be.simplenotes.domain.model.User
+import be.simplenotes.types.User
 import be.simplenotes.domain.usecases.users.delete.DeleteError
 import be.simplenotes.domain.usecases.users.delete.DeleteForm
 import be.simplenotes.domain.usecases.users.login.InvalidLoginForm

simplenotes-domain/src/test/kotlin/be/simplenotes/domain/security/LoggedInUserExtractorTest.kt

@@ -1,7 +1,8 @@
 package be.simplenotes.domain.security
 
 import be.simplenotes.domain.usecases.users.login.Token
-import be.simplenotes.shared.config.JwtConfig
+import be.simplenotes.config.JwtConfig
+import be.simplenotes.types.LoggedInUser
 import com.auth0.jwt.JWT
 import com.auth0.jwt.algorithms.Algorithm
 import com.natpryce.hamkrest.absent
@@ -13,7 +14,7 @@ import org.junit.jupiter.params.provider.MethodSource
 import java.util.concurrent.TimeUnit
 import java.util.stream.Stream
 
-internal class JwtPayloadExtractorTest {
+internal class LoggedInUserExtractorTest {
     private val jwtConfig = JwtConfig("a secret", 1, TimeUnit.HOURS)
     private val simpleJwt = SimpleJwt(jwtConfig)
     private val jwtPayloadExtractor = JwtPayloadExtractor(simpleJwt)
@@ -45,6 +46,6 @@ internal class JwtPayloadExtractorTest {
     @Test
     fun `parse valid token`() {
         val token = createToken(username = "someone", id = 1)
-        assertThat(jwtPayloadExtractor(token), equalTo(JwtPayload(1, "someone")))
+        assertThat(jwtPayloadExtractor(token), equalTo(LoggedInUser(1, "someone")))
     }
 }

simplenotes-domain/src/test/kotlin/be/simplenotes/domain/testutils/ArrowAssertions.kt

@@ -1,4 +1,4 @@
-package be.simplenotes.shared.testutils.assertions
+package be.simplenotes.domain.testutils
 
 import arrow.core.Either
 import com.natpryce.hamkrest.MatchResult

simplenotes-domain/src/test/kotlin/be/simplenotes/domain/usecases/users/login/LoginUseCaseImplTest.kt

@@ -1,12 +1,12 @@
 package be.simplenotes.domain.usecases.users.login
 
-import be.simplenotes.domain.model.PersistedUser
+import be.simplenotes.types.PersistedUser
 import be.simplenotes.domain.security.BcryptPasswordHash
 import be.simplenotes.domain.security.SimpleJwt
-import be.simplenotes.domain.usecases.repositories.UserRepository
+import be.simplenotes.persistance.repositories.UserRepository
-import be.simplenotes.shared.config.JwtConfig
+import be.simplenotes.config.JwtConfig
-import be.simplenotes.shared.testutils.assertions.isLeftOfType
+import be.simplenotes.domain.testutils.isLeftOfType
-import be.simplenotes.shared.testutils.assertions.isRight
+import be.simplenotes.domain.testutils.isRight
 import com.natpryce.hamkrest.assertion.assertThat
 import io.mockk.*
 import org.junit.jupiter.api.BeforeEach

simplenotes-domain/src/test/kotlin/be/simplenotes/domain/usecases/users/register/RegisterUseCaseImplTest.kt

@@ -1,10 +1,10 @@
 package be.simplenotes.domain.usecases.users.register
 
-import be.simplenotes.domain.model.PersistedUser
+import be.simplenotes.types.PersistedUser
 import be.simplenotes.domain.security.BcryptPasswordHash
-import be.simplenotes.domain.usecases.repositories.UserRepository
+import be.simplenotes.domain.testutils.isLeftOfType
-import be.simplenotes.shared.testutils.assertions.isLeftOfType
+import be.simplenotes.domain.testutils.isRight
-import be.simplenotes.shared.testutils.assertions.isRight
+import be.simplenotes.persistance.repositories.UserRepository
 import com.natpryce.hamkrest.assertion.assertThat
 import com.natpryce.hamkrest.equalTo
 import io.mockk.*

simplenotes-domain/src/test/kotlin/be/simplenotes/domain/validation/UserValidationsTest.kt

@@ -1,10 +1,10 @@
 package be.simplenotes.domain.validation
 
+import be.simplenotes.domain.testutils.isLeftOfType
+import be.simplenotes.domain.testutils.isRight
 import be.simplenotes.domain.usecases.users.login.InvalidLoginForm
 import be.simplenotes.domain.usecases.users.login.LoginForm
 import be.simplenotes.domain.usecases.users.register.RegisterForm
-import be.simplenotes.shared.testutils.assertions.isLeftOfType
-import be.simplenotes.shared.testutils.assertions.isRight
 import com.natpryce.hamkrest.assertion.assertThat
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.params.ParameterizedTest

simplenotes-persistance/pom.xml

@@ -2,13 +2,13 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>parent</artifactId>
+        <artifactId>simplenotes-parent</artifactId>
         <groupId>be.simplenotes</groupId>
         <version>1.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>persistance</artifactId>
+    <artifactId>simplenotes-persistance</artifactId>
 
     <dependencies>
         <dependency>
@@ -17,22 +17,27 @@
         </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>domain</artifactId>
+            <artifactId>simplenotes-types</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>shared</artifactId>
+            <artifactId>simplenotes-config</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>shared</artifactId>
+            <artifactId>simplenotes-test-resources</artifactId>
             <version>1.0-SNAPSHOT</version>
             <type>test-jar</type>
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.koin</groupId>
+            <artifactId>koin-core</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.assertj</groupId>
             <artifactId>assertj-core</artifactId>
@@ -59,11 +64,13 @@
             <artifactId>flyway-core</artifactId>
             <version>6.5.4</version>
         </dependency>
+
         <dependency>
             <groupId>com.zaxxer</groupId>
             <artifactId>HikariCP</artifactId>
-            <version>3.4.5</version>
+            <version>3.4.3</version>
         </dependency>
+
         <dependency>
             <groupId>me.liuwj.ktorm</groupId>
             <artifactId>ktorm-core</artifactId>

simplenotes-persistance/src/main/kotlin/be/simplenotes/persistance/HealthCheck.kt

@@ -2,7 +2,7 @@ package be.simplenotes.persistance
 
 import be.simplenotes.persistance.utils.DbType
 import be.simplenotes.persistance.utils.type
-import be.simplenotes.shared.config.DataSourceConfig
+import be.simplenotes.config.DataSourceConfig
 import me.liuwj.ktorm.database.Database
 import me.liuwj.ktorm.database.asIterable
 import java.sql.SQLTransientException

simplenotes-persistance/src/main/kotlin/be/simplenotes/persistance/Migrations.kt

@@ -2,7 +2,7 @@ package be.simplenotes.persistance
 
 import be.simplenotes.persistance.utils.DbType
 import be.simplenotes.persistance.utils.type
-import be.simplenotes.shared.config.DataSourceConfig
+import be.simplenotes.config.DataSourceConfig
 import org.flywaydb.core.Flyway
 import javax.sql.DataSource
 

simplenotes-persistance/src/main/kotlin/be/simplenotes/persistance/PersistanceModule.kt

@@ -1,21 +1,20 @@
 package be.simplenotes.persistance
 
-import be.simplenotes.domain.usecases.repositories.NoteRepository
+import be.simplenotes.config.DataSourceConfig
-import be.simplenotes.domain.usecases.repositories.UserRepository
 import be.simplenotes.persistance.converters.NoteConverter
 import be.simplenotes.persistance.converters.NoteConverterImpl
 import be.simplenotes.persistance.converters.UserConverter
 import be.simplenotes.persistance.converters.UserConverterImpl
 import be.simplenotes.persistance.notes.NoteRepositoryImpl
+import be.simplenotes.persistance.repositories.NoteRepository
+import be.simplenotes.persistance.repositories.UserRepository
 import be.simplenotes.persistance.users.UserRepositoryImpl
-import be.simplenotes.shared.config.DataSourceConfig
 import com.zaxxer.hikari.HikariConfig
 import com.zaxxer.hikari.HikariDataSource
 import me.liuwj.ktorm.database.Database
 import org.koin.dsl.bind
 import org.koin.dsl.module
 import org.koin.dsl.onClose
-import org.mapstruct.factory.Mappers
 import javax.sql.DataSource
 
 private fun hikariDataSource(conf: DataSourceConfig): HikariDataSource {

simplenotes-persistance/src/main/kotlin/be/simplenotes/persistance/converters/NoteConverter.kt

@@ -1,6 +1,6 @@
 package be.simplenotes.persistance.converters
 
-import be.simplenotes.domain.model.*
+import be.simplenotes.types.*
 import be.simplenotes.persistance.notes.NoteEntity
 import me.liuwj.ktorm.entity.Entity
 import org.mapstruct.Mapper

simplenotes-persistance/src/main/kotlin/be/simplenotes/persistance/converters/UserConverter.kt

@@ -1,16 +1,17 @@
 package be.simplenotes.persistance.converters
 
-import be.simplenotes.domain.model.PersistedUser
+import be.simplenotes.types.PersistedUser
-import be.simplenotes.domain.model.User
+import be.simplenotes.types.User
 import be.simplenotes.persistance.users.UserEntity
 import me.liuwj.ktorm.entity.Entity
 import org.mapstruct.Mapper
 
 @Mapper(uses = [UserEntityFactory::class])
 internal interface UserConverter {
-    fun convertToUser(userEntity: UserEntity): User
+    fun toUser(userEntity: UserEntity): User
-    fun convertToPersistedUser(userEntity: UserEntity): PersistedUser
+    fun toPersistedUser(userEntity: UserEntity): PersistedUser
-    fun convertToEntity(user: User): UserEntity
+    fun toEntity(user: User): UserEntity
+    fun toEntity(user: PersistedUser): UserEntity
 }
 
 internal class UserEntityFactory : Entity.Factory<UserEntity>()