Import feature

Tailwind 3
Update kotlin libs
2023-05-09 22:46:07 +02:00 · 2023-05-09 22:40:39 +02:00 · 2023-05-09 22:40:10 +02:00 · 2023-05-09 22:39:34 +02:00 · 2021-05-06 12:22:16 +02:00 · 2021-05-06 12:22:16 +02:00
236 changed files with 5567 additions and 5216 deletions
@@ -9,9 +9,10 @@ charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
-[*.{kt, kts}]
+[*.{kt,kts}]
 indent_size = 4
 insert_final_newline = true
 max_line_length = 120
-disabled_rules = no-wildcard-imports
+ktlint_standard_no-wildcard-imports = disabled
-kotlin_imports_layout = idea
+ktlint_standard_import-ordering = disabled
 ktlint_standard_multiline-if-else = disabled
@@ -1,10 +1 @@
 ## can be generated with `openssl rand -base64 32`
 JWT_SECRET=
 #
 ## can be generated with `openssl rand -base64 32`
 MYSQL_ROOT_PASSWORD=
 #
 ## can be generated with `openssl rand -base64 32`
 MYSQL_PASSWORD=
 # password should be the same as mysql_password
 PASSWORD=
@@ -1,24 +1,6 @@
-# Java
+# Gradle
-.mtj.tmp/
+build/
-*.class
+.gradle
 *.jar
 *.war
 *.ear
 *.nar
 hs_err_pid*
 # Maven
 target/
 pom.xml.tag
 pom.xml.releaseBackup
 pom.xml.versionsBackup
 pom.xml.next
 pom.xml.bak
 release.properties
 dependency-reduced-pom.xml
 buildNumber.properties
 .mvn/timing.properties
 .mvn/wrapper/maven-wrapper.jar
 # IntelliJ
 out/
@@ -28,11 +10,8 @@ out/
 *.ipr
 *.iws
 # Vue
 node_modules
 /dist
 # Local env files
 .env
 .env.local
 .env.*.local
@@ -49,85 +28,13 @@ pids
 *.seed
 *.pid.lock
 # Directory for instrumented libs generated by jscoverage/JSCover
 lib-cov
 # Coverage directory used by tools like istanbul
 coverage
 # nyc test coverage
 .nyc_output
 # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
 .grunt
 # Bower dependency directory (https://bower.io/)
 bower_components
 # node-waf configuration
 .lock-wscript
 # Compiled binary addons (https://nodejs.org/api/addons.html)
 build/Release
 # Dependency directories
 node_modules/
 jspm_packages/
 # TypeScript v1 declaration files
 typings/
 # Optional npm cache directory
 .npm
 # Optional eslint cache
 .eslintcache
 # Optional REPL history
 .node_repl_history
 # Output of 'npm pack'
 *.tgz
 # Yarn Integrity file
 .yarn-integrity
 # dotenv environment variables file
 .env
 # parcel-bundler cache (https://parceljs.org/)
 .cache
 # next.js build output
 .next
 # nuxt.js build output
 .nuxt
 # Nuxt generate
 dist
 # vuepress build output
 .vuepress/dist
 # Serverless directories
 .serverless
 # IDE / Editor
 .idea
 # Service worker
 sw.*
 *.private.env.json
 # Certificates
 data/
 letsencrypt/
 # generated resources
 app/src/main/resources/css-manifest.json
 app/src/main/resources/static/styles*
 # h2 db
 *.db
@@ -136,3 +43,4 @@ app/src/main/resources/static/styles*
 # python
 __pycache__
@@ -0,0 +1,5 @@
 # Enable auto-env through the sdkman_auto_env config
 # Add key=value pairs of SDKs to use below
 java=15-open
 gradle=6.8-rc-1
 kotlin=1.4.20
@@ -1,30 +1,8 @@
-FROM maven:3.6.3-jdk-14 as builder
+FROM eclipse-temurin:19-alpine as jdkbuilder
 WORKDIR /tmp
 # Cache dependencies
 COPY pom.xml .
 COPY app/pom.xml app/pom.xml
 COPY domain/pom.xml domain/pom.xml
 COPY persistance/pom.xml persistance/pom.xml
 COPY shared/pom.xml shared/pom.xml
 COPY search/pom.xml search/pom.xml
 RUN mvn verify clean --fail-never
 COPY app/src app/src
 COPY domain/src domain/src
 COPY persistance/src persistance/src
 COPY shared/src shared/src
 COPY search/src search/src
 RUN mvn -Dstyle.color=always package
 FROM openjdk:14-alpine as jdkbuilder
 RUN apk add --no-cache binutils
-ENV MODULES java.base,java.compiler,java.desktop,java.instrument,java.logging,java.management,java.naming,java.scripting,java.security.jgss,java.sql,java.sql.rowset,java.transaction.xa,java.xml,jdk.net
+ENV MODULES java.base,java.compiler,java.desktop,java.instrument,java.logging,java.management,java.naming,java.scripting,java.security.jgss,java.sql,java.sql.rowset,java.transaction.xa,java.xml,jdk.net,jdk.zipfs
 RUN jlink --output /myjdk --module-path $JAVA_HOME/jmods --add-modules $MODULES --no-header-files --no-man-pages --strip-debug --compress=2
@@ -32,16 +10,30 @@ RUN strip -p --strip-unneeded /myjdk/lib/server/libjvm.so
 FROM alpine
-ENV APPLICATION_USER simplenotes
+RUN apk add --no-cache curl
 RUN adduser -D -g '' $APPLICATION_USER
 RUN mkdir /app
-RUN chown -R $APPLICATION_USER /app
+RUN mkdir /app/data
 USER $APPLICATION_USER
 COPY --from=builder /tmp/app/target/app-*.jar /app/app.jar
 COPY --from=jdkbuilder /myjdk /myjdk
 COPY app/build/libs/app-with-dependencies*.jar /app/simplenotes.jar
 WORKDIR /app
-CMD ["/myjdk/bin/java", "-server", "-XX:+UnlockExperimentalVMOptions", "-Xms256m", "-Xmx1g", "-XX:+UseG1GC", "-XX:MaxGCPauseMillis=100", "-XX:+UseStringDeduplication", "-jar", "app.jar"]
+VOLUME /app/data
 ENV SERVER_HOST 0.0.0.0
 CMD [ \
    "/myjdk/bin/java", \
    "--add-opens", \
    "java.base/java.nio=ALL-UNNAMED", \
    "-server", \
    "-XX:+UnlockExperimentalVMOptions", \
    "-Xms64m", \
    "-Xmx256m", \
    "-XX:+UseG1GC", \
    "-XX:MaxGCPauseMillis=100", \
    "-XX:+UseStringDeduplication", \
    "-jar", \
    "simplenotes.jar" \
 ]
@@ -15,5 +15,4 @@
 ## Configuration
 The app is configured with environments variables.
-If no match is found within the env, a default value is read from a properties file in /app/src/main/resources/application.properties.
+If no match is found within the env, a default value is read from a yaml file in simplenotes-app/src/main/resources/application.yaml.
 Don't use the default values for secrets ! Every value inside *.env.dist* should be changed.
@@ -0,0 +1,33 @@
 import be.simplenotes.micronaut
 plugins {
    id("be.simplenotes.base")
    id("be.simplenotes.kotlinx-serialization")
    id("be.simplenotes.app-shadow")
    id("be.simplenotes.docker")
    id("be.simplenotes.micronaut")
 }
 dependencies {
    implementation(project(":domain"))
    implementation(project(":views"))
    implementation(project(":css"))
    implementation(libs.http4k.core)
    implementation(libs.http4k.multipart)
    implementation(libs.bundles.jetty)
    implementation(libs.kotlinx.serialization.json)
    implementation(libs.slf4j.api)
    runtimeOnly(libs.slf4j.logback)
    micronaut()
    testImplementation(libs.bundles.test)
    testImplementation(libs.http4k.testing.hamkrest)
 }
 docker {
    image = "hubv/simplenotes"
    tag = "latest"
 }
@@ -1,155 +0,0 @@
 <project>
    <parent>
        <artifactId>parent</artifactId>
        <groupId>be.simplenotes</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>app</artifactId>
    <properties>
        <http4k.version>3.258.0</http4k.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>be.simplenotes</groupId>
            <artifactId>persistance</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>be.simplenotes</groupId>
            <artifactId>search</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>be.simplenotes</groupId>
            <artifactId>domain</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>be.simplenotes</groupId>
            <artifactId>shared</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.http4k</groupId>
            <artifactId>http4k-core</artifactId>
            <version>${http4k.version}</version>
        </dependency>
        <dependency>
            <groupId>org.http4k</groupId>
            <artifactId>http4k-server-jetty</artifactId>
            <version>${http4k.version}</version>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.kotlinx</groupId>
            <artifactId>kotlinx-html-jvm</artifactId>
            <version>0.7.1</version>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.kotlinx</groupId>
            <artifactId>kotlinx-serialization-runtime</artifactId>
        </dependency>
        <dependency>
            <groupId>org.ocpsoft.prettytime</groupId>
            <artifactId>prettytime</artifactId>
            <version>4.0.5.Final</version>
        </dependency>
        <dependency>
            <groupId>be.simplenotes</groupId>
            <artifactId>shared</artifactId>
            <version>1.0-SNAPSHOT</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.http4k</groupId>
            <artifactId>http4k-testing-hamkrest</artifactId>
            <version>${http4k.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <minimizeJar>true</minimizeJar>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>be.simplenotes.app.SimpleNotesKt</mainClass>
                                </transformer>
                            </transformers>
                            <filters>
                                <filter>
                                    <artifact>com.h2database:h2</artifact>
                                    <includes>
                                        <include>**</include>
                                    </includes>
                                </filter>
                                <filter>
                                    <artifact>org.mariadb.jdbc:mariadb-java-client</artifact>
                                    <includes>
                                        <include>**</include>
                                    </includes>
                                </filter>
                                <filter>
                                    <artifact>org.jetbrains.kotlin:kotlin-reflect</artifact>
                                    <includes>
                                        <include>**</include>
                                    </includes>
                                </filter>
                                <filter>
                                    <artifact>org.eclipse.jetty:*</artifact>
                                    <includes>
                                        <include>**</include>
                                    </includes>
                                </filter>
                                <filter>
                                    <artifact>org.apache.lucene:*</artifact>
                                    <includes>
                                        <include>**</include>
                                    </includes>
                                </filter>
                                <filter>
                                    <artifact>org.ocpsoft.prettytime:prettytime</artifact>
                                    <includes>
                                        <include>**</include>
                                    </includes>
                                </filter>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/maven/**</exclude>
                                        <exclude>META-INF/proguard/**</exclude>
                                        <exclude>META-INF/*.kotlin_module</exclude>
                                        <exclude>META-INF/DEPENDENCIES*</exclude>
                                        <exclude>META-INF/NOTICE*</exclude>
                                        <exclude>META-INF/LICENSE*</exclude>
                                        <exclude>LICENSE*</exclude>
                                        <exclude>META-INF/README*</exclude>
                                        <exclude>META-INF/native-image/**</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
 </project>
@@ -1,6 +1,5 @@
 <configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <withJansi>true</withJansi>
        <encoder>
            <pattern>%cyan(%d{YYYY-MM-dd HH:mm:ss.SSS}) [%thread] %highlight(%-5level) %green(%logger{36}) - %msg%n
            </pattern>
@@ -13,4 +12,6 @@
    <logger name="me.liuwj.ktorm.database" level="INFO"/>
    <logger name="com.zaxxer.hikari" level="INFO"/>
    <logger name="org.flywaydb.core" level="INFO"/>
    <logger name="io.micronaut" level="INFO"/>
    <logger name="io.micronaut.context.lifecycle" level="INFO"/>
 </configuration>
@@ -0,0 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <browserconfig>
    <msapplication>
        <tile>
            <square150x150logo src="/mstile-150x150.png"/>
            <TileColor>#00aba9</TileColor>
        </tile>
    </msapplication>
 </browserconfig>
@@ -0,0 +1,33 @@
 <?xml version="1.0" standalone="no"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
 "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
 <svg version="1.0" xmlns="http://www.w3.org/2000/svg"
 width="700.000000pt" height="700.000000pt" viewBox="0 0 700.000000 700.000000"
 preserveAspectRatio="xMidYMid meet">
 <metadata>
 Created by potrace 1.11, written by Peter Selinger 2001-2013
 </metadata>
 <g transform="translate(0.000000,700.000000) scale(0.100000,-0.100000)"
 fill="#000000" stroke="none">
 <path d="M1255 6993 c-179 -23 -313 -62 -461 -133 -396 -187 -665 -533 -766
 -981 l-23 -104 0 -2275 0 -2275 23 -102 c125 -565 530 -970 1095 -1095 l102
 -23 2275 0 2275 0 102 23 c565 125 970 530 1095 1095 l23 102 0 2275 0 2275
 -23 102 c-125 566 -521 964 -1090 1095 l-97 22 -2250 2 c-1237 1 -2263 -1
 -2280 -3z m1024 -1979 c128 -18 287 -70 394 -127 262 -139 448 -395 472 -649
 3 -34 8 -78 11 -95 l5 -33 -255 0 -254 0 -6 28 c-2 15 -7 44 -11 65 -27 168
 -204 335 -416 393 -94 26 -317 24 -421 -4 -218 -59 -345 -196 -356 -384 -6
 -105 16 -173 80 -243 81 -88 227 -148 563 -230 509 -123 742 -228 916 -412
 123 -131 170 -248 176 -448 9 -245 -55 -420 -212 -580 -162 -165 -387 -270
 -667 -311 -154 -22 -461 -15 -595 15 -280 62 -513 193 -662 373 -72 85 -162
 262 -185 358 -8 36 -18 95 -22 133 l-6 67 254 0 255 0 6 -53 c22 -179 135
 -332 310 -417 127 -61 195 -74 387 -75 195 0 279 16 399 76 179 89 260 234
 231 415 -22 137 -98 231 -243 302 -109 55 -202 84 -447 142 -237 57 -306 76
 -427 120 -340 125 -535 303 -600 550 -23 87 -23 271 0 360 87 335 409 595 827
 665 108 19 371 18 499 -1z m3170 0 c202 -35 325 -95 453 -224 77 -77 93 -100
 141 -201 30 -63 63 -143 72 -179 49 -183 48 -159 52 -1307 l4 -1083 -256 0
 -255 0 0 1034 c0 1160 1 1133 -70 1282 -92 192 -259 271 -548 262 -117 -4
 -149 -9 -221 -33 -177 -60 -340 -200 -440 -376 l-31 -56 0 -1056 0 -1057 -255
 0 -255 0 0 1480 0 1480 239 0 238 0 6 -82 c4 -46 7 -120 7 -165 0 -45 3 -88 6
 -97 4 -11 28 8 92 72 163 164 356 267 575 307 103 19 334 18 446 -1z"/>
 </g>
 </svg>
@@ -0,0 +1,19 @@
 {
    "name": "SimpleNotes",
    "short_name": "SimpleNotes",
    "icons": [
        {
            "src": "/android-chrome-192x192.png",
            "sizes": "192x192",
            "type": "image/png"
        },
        {
            "src": "/android-chrome-512x512.png",
            "sizes": "512x512",
            "type": "image/png"
        }
    ],
    "theme_color": "#ffffff",
    "background_color": "#ffffff",
    "display": "standalone"
 }
@@ -0,0 +1,29 @@
 package be.simplenotes.app
 import jakarta.annotation.PostConstruct
 import jakarta.annotation.PreDestroy
 import jakarta.inject.Singleton
 import org.http4k.server.Http4kServer
 import org.slf4j.LoggerFactory
 import be.simplenotes.config.ServerConfig as SimpleNotesServerConfig
@Singleton
 class Server(
    private val config: SimpleNotesServerConfig,
    private val http4kServer: Http4kServer,
 ) {
    private val logger = LoggerFactory.getLogger(javaClass)
    @PostConstruct
    fun start(): Server {
        http4kServer.start()
        logger.info("Listening on http://${config.host}:${http4kServer.port()}")
        return this
    }
    @PreDestroy
    fun stop() {
        logger.info("Stopping server")
        http4kServer.close()
    }
 }
@@ -0,0 +1,14 @@
 package be.simplenotes.app
 import io.micronaut.context.ApplicationContext
 import java.lang.Runtime.getRuntime
 fun main() {
    val env = if (System.getenv("ENV") == "dev") "dev" else "prod"
    val ctx = ApplicationContext.builder()
        .deduceEnvironment(false)
        .environments(env)
        .start()
    ctx.createBean(Server::class.java)
    getRuntime().addShutdownHook(Thread { ctx.stop() })
 }
@@ -0,0 +1,79 @@
 package be.simplenotes.app.api
 import be.simplenotes.app.extensions.auto
 import be.simplenotes.domain.NoteService
 import be.simplenotes.types.LoggedInUser
 import be.simplenotes.types.PersistedNote
 import be.simplenotes.types.PersistedNoteMetadata
 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.*
 import jakarta.inject.Singleton
@Singleton
 class ApiNoteController(
    json: Json,
    private val noteService: NoteService,
 ) {
    fun createNote(request: Request, loggedInUser: LoggedInUser): Response {
        val content = noteContentLens(request)
        return noteService.create(loggedInUser, content).fold(
            { Response(BAD_REQUEST) },
            { uuidContentLens(UuidContent(it.uuid), Response(OK)) },
        )
    }
    fun notes(@Suppress("UNUSED_PARAMETER") 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, 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 notes = noteService.search(loggedInUser.userId, query)
        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(val query: String)
@@ -0,0 +1,31 @@
 package be.simplenotes.app.api
 import be.simplenotes.app.extensions.auto
 import be.simplenotes.domain.LoginForm
 import be.simplenotes.domain.UserService
 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
 import jakarta.inject.Singleton
@Singleton
 class ApiUserController(
    json: Json,
    private val userService: UserService,
 ) {
    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)
@@ -0,0 +1,15 @@
 package be.simplenotes.app.controllers
 import be.simplenotes.app.extensions.html
 import be.simplenotes.types.LoggedInUser
 import be.simplenotes.views.BaseView
 import org.http4k.core.Request
 import org.http4k.core.Response
 import org.http4k.core.Status.Companion.OK
 import jakarta.inject.Singleton
@Singleton
 class BaseController(private val view: BaseView) {
    fun index(@Suppress("UNUSED_PARAMETER") request: Request, loggedInUser: LoggedInUser?) =
        Response(OK).html(view.renderHome(loggedInUser))
 }
@@ -0,0 +1,166 @@
 package be.simplenotes.app.controllers
 import be.simplenotes.app.extensions.html
 import be.simplenotes.app.extensions.redirect
 import be.simplenotes.domain.MarkdownParsingError
 import be.simplenotes.domain.NoteService
 import be.simplenotes.types.LoggedInUser
 import be.simplenotes.views.NoteView
 import org.http4k.core.Method
 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.core.body.form
 import org.http4k.routing.path
 import java.util.*
 import jakarta.inject.Singleton
 import kotlin.math.abs
@Singleton
 class NoteController(
    private val view: NoteView,
    private val noteService: NoteService,
 ) {
    fun new(request: Request, loggedInUser: LoggedInUser): Response {
        if (request.method == Method.GET) return Response(OK).html(view.noteEditor(loggedInUser))
        val markdownForm = request.form("markdown") ?: ""
        return noteService.create(loggedInUser, markdownForm).fold(
            {
                val html = when (it) {
                    MarkdownParsingError.MissingMeta -> view.noteEditor(
                        loggedInUser,
                        error = "Missing note metadata",
                        textarea = markdownForm,
                    )
                    MarkdownParsingError.InvalidMeta -> view.noteEditor(
                        loggedInUser,
                        error = "Invalid note metadata",
                        textarea = markdownForm,
                    )
                    is MarkdownParsingError.ValidationError -> view.noteEditor(
                        loggedInUser,
                        validationErrors = it.validationErrors,
                        textarea = markdownForm,
                    )
                }
                Response(BAD_REQUEST).html(html)
            },
            {
                Response.redirect("/notes/${it.uuid}")
            },
        )
    }
    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(loggedInUser.userId, currentPage, tag = tag)
        val deletedCount = noteService.countDeleted(loggedInUser.userId)
        return Response(OK).html(view.notes(loggedInUser, notes, currentPage, pages, deletedCount, tag = tag))
    }
    fun search(request: Request, loggedInUser: LoggedInUser): Response {
        val query = request.form("search") ?: ""
        val notes = noteService.search(loggedInUser.userId, query)
        val deletedCount = noteService.countDeleted(loggedInUser.userId)
        return Response(OK).html(view.search(loggedInUser, notes, query, deletedCount))
    }
    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(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(loggedInUser.userId, noteUuid)) return Response(NOT_FOUND)
            } else if (request.form("private") != null) {
                if (!noteService.makePrivate(loggedInUser.userId, noteUuid)) return Response(NOT_FOUND)
            }
        }
        val note = noteService.find(loggedInUser.userId, noteUuid) ?: return Response(NOT_FOUND)
        return Response(OK).html(view.renderedNote(loggedInUser, note, shared = false))
    }
    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(loggedInUser, note, shared = true))
    }
    fun edit(request: Request, loggedInUser: LoggedInUser): Response {
        val noteUuid = request.uuidPath() ?: 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(loggedInUser, textarea = note.markdown))
        }
        val markdownForm = request.form("markdown") ?: ""
        return noteService.update(loggedInUser, note.uuid, markdownForm).fold(
            {
                val html = when (it) {
                    MarkdownParsingError.MissingMeta -> view.noteEditor(
                        loggedInUser,
                        error = "Missing note metadata",
                        textarea = markdownForm,
                    )
                    MarkdownParsingError.InvalidMeta -> view.noteEditor(
                        loggedInUser,
                        error = "Invalid note metadata",
                        textarea = markdownForm,
                    )
                    is MarkdownParsingError.ValidationError -> view.noteEditor(
                        loggedInUser,
                        validationErrors = it.validationErrors,
                        textarea = markdownForm,
                    )
                }
                Response(BAD_REQUEST).html(html)
            },
            {
                Response.redirect("/notes/${note.uuid}")
            },
        )
    }
    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(loggedInUser.userId, currentPage, tag = tag, deleted = true)
        return Response(OK).html(view.trash(loggedInUser, notes, currentPage, pages))
    }
    fun deleted(request: Request, loggedInUser: LoggedInUser): Response {
        val uuid = request.uuidPath() ?: return Response(NOT_FOUND)
        return if (request.form("delete") != null)
            if (noteService.delete(loggedInUser.userId, uuid))
                Response.redirect("/notes/trash")
            else
                Response(NOT_FOUND)
        else if (noteService.restore(loggedInUser.userId, uuid))
            Response.redirect("/notes/$uuid")
        else
            Response(NOT_FOUND)
    }
    private fun Request.uuidPath(): UUID? {
        val uuidPath = path("uuid")!!
        return try {
            UUID.fromString(uuidPath)!!
        } catch (e: IllegalArgumentException) {
            null
        }
    }
 }
@@ -0,0 +1,89 @@
 package be.simplenotes.app.controllers
 import be.simplenotes.app.extensions.html
 import be.simplenotes.app.extensions.redirect
 import be.simplenotes.domain.*
 import be.simplenotes.types.LoggedInUser
 import be.simplenotes.views.SettingView
 import jakarta.inject.Singleton
 import org.http4k.core.*
 import org.http4k.core.body.form
 import org.http4k.core.cookie.invalidateCookie
@Singleton
 class SettingsController(
    private val userService: UserService,
    private val exportService: ExportService,
    private val importService: ImportService,
    private val settingView: SettingView,
 ) {
    fun settings(request: Request, loggedInUser: LoggedInUser): Response {
        if (request.method == Method.GET)
            return Response(Status.OK).html(settingView.settings(loggedInUser))
        val deleteForm = request.deleteForm(loggedInUser)
        val result = userService.delete(deleteForm)
        return result.fold(
            {
                when (it) {
                    DeleteError.Unregistered -> Response.redirect("/").invalidateCookie("Bearer")
                    DeleteError.WrongPassword -> Response(Status.OK).html(
                        settingView.settings(
                            loggedInUser,
                            error = "Wrong password",
                        ),
                    )
                    is DeleteError.InvalidForm -> Response(Status.OK).html(
                        settingView.settings(
                            loggedInUser,
                            validationErrors = it.validationErrors,
                        ),
                    )
                }
            },
            {
                Response.redirect("/").invalidateCookie("Bearer")
            },
        )
    }
    private fun attachment(filename: String, contentType: String) = { response: Response ->
        val name = filename.replace("[^a-zA-Z0-9-_.]".toRegex(), "_")
        response
            .header("Content-Disposition", "attachment; filename=\"$name\"")
            .header("Content-Type", contentType)
    }
    fun export(request: Request, loggedInUser: LoggedInUser): Response {
        val isDownload = request.form("download") != null
        return if (isDownload) {
            val filename = "simplenotes-export-${loggedInUser.username}"
            if (request.form("format") == "zip") {
                val zip = exportService.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(exportService.exportAsJson(loggedInUser.userId))
        } else Response(Status.OK).body(exportService.exportAsJson(loggedInUser.userId)).header(
            "Content-Type",
            "application/json",
        )
    }
    private fun Request.deleteForm(loggedInUser: LoggedInUser) =
        DeleteForm(loggedInUser.username, form("password"), form("checked") != null)
    fun import(request: Request, loggedInUser: LoggedInUser): Response {
        val form = MultipartFormBody.from(request)
        val file = form.file("file") ?: return Response(Status.BAD_REQUEST)
        val json = file.content.bufferedReader().readText()
        importService.importJson(loggedInUser, json)
        return Response.redirect("/notes")
    }
 }
@@ -3,14 +3,10 @@ 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.config.JwtConfig
-import be.simplenotes.domain.security.JwtPayload
+import be.simplenotes.domain.*
-import be.simplenotes.domain.usecases.UserService
+import be.simplenotes.types.LoggedInUser
-import be.simplenotes.domain.usecases.users.login.*
+import be.simplenotes.views.UserView
 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 org.http4k.core.Method.GET
 import org.http4k.core.Request
 import org.http4k.core.Response
@@ -21,15 +17,17 @@ import org.http4k.core.cookie.SameSite
 import org.http4k.core.cookie.cookie
 import org.http4k.core.cookie.invalidateCookie
 import java.util.concurrent.TimeUnit
 import jakarta.inject.Singleton
@Singleton
 class UserController(
    private val userService: UserService,
    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())
@@ -37,30 +35,30 @@ class UserController(
        return result.fold(
            {
                val html = when (it) {
-                    UserExists -> userView.register(
+                    RegisterError.UserExists -> userView.register(
-                        jwtPayload,
+                        loggedInUser,
-                        error = "User already exists"
+                        error = "User already exists",
                    )
-                    is InvalidRegisterForm ->
+                    is RegisterError.InvalidRegisterForm ->
                        userView.register(
-                            jwtPayload,
+                            loggedInUser,
-                            validationErrors = it.validationErrors
+                            validationErrors = it.validationErrors,
                        )
                }
                Response(OK).html(html)
            },
            {
                Response.redirect("/login")
-            }
+            },
        )
    }
    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())
@@ -68,27 +66,27 @@ class UserController(
        return result.fold(
            {
                val html = when (it) {
-                    Unregistered ->
+                    LoginError.Unregistered ->
                        userView.login(
-                            jwtPayload,
+                            loggedInUser,
-                            error = "User does not exist"
+                            error = "User does not exist",
                        )
-                    WrongPassword ->
+                    LoginError.WrongPassword ->
                        userView.login(
-                            jwtPayload,
+                            loggedInUser,
-                            error = "Wrong password"
+                            error = "Wrong password",
                        )
-                    is InvalidLoginForm ->
+                    is LoginError.InvalidLoginForm ->
                        userView.login(
-                            jwtPayload,
+                            loggedInUser,
-                            validationErrors = it.validationErrors
+                            validationErrors = it.validationErrors,
                        )
                }
                Response(OK).html(html)
            },
            { token ->
                Response.redirect("/notes").loginCookie(token, request.isSecure())
-            }
+            },
        )
    }
@@ -103,8 +101,8 @@ class UserController(
                httpOnly = true,
                sameSite = SameSite.Lax,
                maxAge = validityInSeconds,
-                secure = secure
+                secure = secure,
-            )
+            ),
        )
    }
@@ -0,0 +1,36 @@
 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) },
 )
@@ -0,0 +1,47 @@
 package be.simplenotes.app.filters
 import be.simplenotes.app.extensions.html
 import be.simplenotes.views.ErrorView
 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
 import org.http4k.core.Status.Companion.NOT_IMPLEMENTED
 import org.http4k.core.Status.Companion.SERVICE_UNAVAILABLE
 import org.slf4j.LoggerFactory
 import java.sql.SQLTransientException
 import jakarta.inject.Singleton
@Singleton
 class ErrorFilter(private val errorView: ErrorView) : Filter {
    private val logger = LoggerFactory.getLogger(javaClass)
    private fun errorResponse(status: Status): Response {
        val type = when (status) {
            SERVICE_UNAVAILABLE -> SqlTransientError
            NOT_FOUND -> NotFound
            NOT_IMPLEMENTED -> Other
            else -> Other
        }
        return Response(status).html(errorView.error(type)).noCache()
    }
    override fun invoke(next: HttpHandler): HttpHandler = { request ->
        try {
            val response = next(request)
            if (response.status == NOT_FOUND) errorResponse(NOT_FOUND)
            else response
        } catch (e: SQLTransientException) {
            logger.error(e.stackTraceToString())
            errorResponse(SERVICE_UNAVAILABLE)
        } catch (e: Exception) {
            logger.error(e.stackTraceToString())
            errorResponse(INTERNAL_SERVER_ERROR)
        } catch (e: NotImplementedError) {
            logger.error(e.stackTraceToString())
            errorResponse(NOT_IMPLEMENTED)
        }
    }
 }
@@ -0,0 +1,15 @@
 package be.simplenotes.app.filters
 import org.http4k.core.Filter
 import org.http4k.core.HttpHandler
 import org.http4k.core.Request
 import org.http4k.core.Status.Companion.OK
 object ImmutableFilter : Filter {
    override fun invoke(next: HttpHandler) = { request: Request ->
        val res = next(request)
        if (res.status == OK)
            res.header("Cache-Control", "public, max-age=31536000, immutable")
        else res
    }
 }
@@ -0,0 +1,18 @@
 package be.simplenotes.app.filters
 import org.http4k.core.Filter
 import org.http4k.core.HttpHandler
 import org.http4k.core.Request
 object SecurityFilter : Filter {
    override fun invoke(next: HttpHandler): HttpHandler = { request: Request ->
        val response = next(request)
            .header("X-Content-Type-Options", "nosniff")
        if (response.header("Content-Type")?.contains("text/html") == true) {
            response
                .header("Content-Security-Policy", "default-src 'self'")
                .header("Referrer-Policy", "no-referrer")
        } else response
    }
 }
@@ -0,0 +1,24 @@
 package be.simplenotes.app.filters.auth
 import be.simplenotes.types.LoggedInUser
 import org.http4k.core.Request
 import org.http4k.core.cookie.cookie
 import org.http4k.lens.BiDiLens
 typealias OptionalAuthLens = BiDiLens<@JvmSuppressWildcards Request, @JvmSuppressWildcards LoggedInUser?>
 typealias RequiredAuthLens = BiDiLens<@JvmSuppressWildcards Request, @JvmSuppressWildcards LoggedInUser>
 enum class JwtSource {
    Header, Cookie
 }
 fun Request.bearerTokenCookie(): String? = cookie("Bearer")
    ?.value
    ?.trim()
 fun Request.bearerTokenHeader(): String? =
    header("Authorization")
        ?.trim()
        ?.takeIf { it.startsWith("Bearer") }
        ?.substringAfter("Bearer")
        ?.trim()
@@ -0,0 +1,23 @@
 package be.simplenotes.app.filters.auth
 import be.simplenotes.app.filters.auth.JwtSource.Cookie
 import be.simplenotes.domain.security.SimpleJwt
 import be.simplenotes.types.LoggedInUser
 import org.http4k.core.Filter
 import org.http4k.core.HttpHandler
 import org.http4k.core.with
 class OptionalAuthFilter(
    private val simpleJwt: SimpleJwt<LoggedInUser>,
    private val lens: OptionalAuthLens,
    private val source: JwtSource = Cookie,
 ) : Filter {
    override fun invoke(next: HttpHandler): HttpHandler = {
        val token = when (source) {
            JwtSource.Header -> it.bearerTokenHeader()
            Cookie -> it.bearerTokenCookie()
        }
        next(it.with(lens of token?.let { simpleJwt.extract(it) }))
    }
 }
@@ -0,0 +1,31 @@
 package be.simplenotes.app.filters.auth
 import be.simplenotes.app.extensions.redirect
 import be.simplenotes.domain.security.SimpleJwt
 import be.simplenotes.types.LoggedInUser
 import org.http4k.core.Filter
 import org.http4k.core.HttpHandler
 import org.http4k.core.Response
 import org.http4k.core.Status.Companion.UNAUTHORIZED
 import org.http4k.core.with
 class RequiredAuthFilter(
    private val simpleJwt: SimpleJwt<LoggedInUser>,
    private val lens: RequiredAuthLens,
    private val source: JwtSource = JwtSource.Cookie,
    private val redirect: Boolean = true,
 ) : Filter {
    override fun invoke(next: HttpHandler): HttpHandler = {
        val token = when (source) {
            JwtSource.Header -> it.bearerTokenHeader()
            JwtSource.Cookie -> it.bearerTokenCookie()
        }
        val jwtPayload = token?.let { simpleJwt.extract(token) }
        if (jwtPayload != null) next(it.with(lens of jwtPayload))
        else {
            if (redirect) Response.redirect("/login")
            else Response(UNAUTHORIZED)
        }
    }
 }
@@ -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.jakarta.asServlet
 class Jetty(private val port: Int, private val server: Server) : ServerConfig {
    constructor(port: Int, vararg inConnectors: ConnectorBuilder) : this(
        port,
        Server().apply {
            inConnectors.forEach { addConnector(it(this)) }
        },
    )
    override fun toServer(http: HttpHandler): Http4kServer {
        server.insertHandler(http.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
@@ -1,48 +0,0 @@
 package be.simplenotes.app
 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
 object Config {
    //region Config loading
    private val properties: Properties = javaClass
        .getResource("/application.properties")
        .openStream()
        .use {
            Properties().apply { load(it) }
        }
    private val env = System.getenv()
    private fun value(key: String): String =
        env[key.toUpperCase().replace(".", "_")]
            ?: properties.getProperty(key)
            ?: error("Missing config key $key")
    //endregion
    val jwtConfig
        get() = JwtConfig(
            secret = value("jwt.secret"),
            validity = value("jwt.validity").toLong(),
            timeUnit = TimeUnit.HOURS,
        )
    val dataSourceConfig
        get() = DataSourceConfig(
            jdbcUrl = value("jdbcUrl"),
            driverClassName = value("driverClassName"),
            username = value("username"),
            password = value("password"),
            maximumPoolSize = value("maximumPoolSize").toInt(),
            connectionTimeout = value("connectionTimeout").toLong()
        )
    val serverConfig
        get() = ServerConfig(
            host = value("host"),
            port = value("port").toInt(),
        )
 }
@@ -1,32 +0,0 @@
 package be.simplenotes.app
 import org.eclipse.jetty.server.Server
 import org.eclipse.jetty.server.ServerConnector
 import org.http4k.routing.RoutingHttpHandler
 import org.http4k.server.ConnectorBuilder
 import org.http4k.server.Jetty
 import org.http4k.server.ServerConfig
 import org.http4k.server.asServer
 import org.slf4j.LoggerFactory
 import be.simplenotes.shared.config.ServerConfig as SimpleNotesServeConfig
 class Server(
    private val config: SimpleNotesServeConfig,
    private val serverConfig: ServerConfig,
    private val router: RoutingHttpHandler,
 ) {
    fun start() {
        router.asServer(serverConfig).start()
        LoggerFactory.getLogger(javaClass).info("Listening on http://${config.host}:${config.port}")
    }
 }
 fun serverConfig(config: SimpleNotesServeConfig): ServerConfig {
    val builder: ConnectorBuilder = { server: Server ->
        ServerConnector(server).apply {
            port = config.port
            host = config.host
        }
    }
    return Jetty(config.port, builder)
 }
@@ -1,180 +0,0 @@
 package be.simplenotes.app
 import be.simplenotes.app.api.ApiNoteController
 import be.simplenotes.app.api.ApiUserController
 import be.simplenotes.app.controllers.BaseController
 import be.simplenotes.app.controllers.NoteController
 import be.simplenotes.app.controllers.SettingsController
 import be.simplenotes.app.controllers.UserController
 import be.simplenotes.app.filters.AuthFilter
 import be.simplenotes.app.filters.AuthType
 import be.simplenotes.app.filters.ErrorFilter
 import be.simplenotes.app.filters.JwtSource
 import be.simplenotes.app.routes.Router
 import be.simplenotes.app.utils.StaticFileResolver
 import be.simplenotes.app.utils.StaticFileResolverImpl
 import be.simplenotes.app.views.*
 import be.simplenotes.domain.domainModule
 import be.simplenotes.domain.usecases.NoteService
 import be.simplenotes.persistance.DbMigrations
 import be.simplenotes.persistance.persistanceModule
 import be.simplenotes.search.searchModule
 import be.simplenotes.shared.config.DataSourceConfig
 import be.simplenotes.shared.config.JwtConfig
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.descriptors.PrimitiveKind
 import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.modules.SerializersModule
 import org.http4k.core.RequestContexts
 import org.koin.core.context.startKoin
 import org.koin.core.qualifier.named
 import org.koin.core.qualifier.qualifier
 import org.koin.dsl.module
 import org.slf4j.LoggerFactory
 import java.time.LocalDateTime
 import java.util.*
 import be.simplenotes.shared.config.ServerConfig as SimpleNotesServeConfig
 fun main() {
    val koin = startKoin {
        modules(
            persistanceModule,
            configModule,
            domainModule,
            serverModule,
            userModule,
            baseModule,
            noteModule,
            settingsModule,
            searchModule,
            apiModule,
        )
    }.koin
    val dataSourceConfig = koin.get<DataSourceConfig>()
    val jwtConfig = koin.get<JwtConfig>()
    val serverConfig = koin.get<SimpleNotesServeConfig>()
    val logger = LoggerFactory.getLogger("SimpleNotes")
    logger.info("datasource: $dataSourceConfig")
    logger.info("jwt: $jwtConfig")
    logger.info("server: $serverConfig")
    val migrations = koin.get<DbMigrations>()
    migrations.migrate()
    val noteService = koin.get<NoteService>()
    noteService.dropAllIndexes()
    noteService.indexAll()
    koin.get<Server>().start()
 }
 val serverModule = module {
    single { Server(get(), get(), get()) }
    single<StaticFileResolver> { StaticFileResolverImpl() }
    single {
        Router(
            get(),
            get(),
            get(),
            get(),
            get(),
            get(),
            requiredAuth = get(AuthType.Required.qualifier),
            optionalAuth = get(AuthType.Optional.qualifier),
            errorFilter = get(named("ErrorFilter")),
            apiAuth = get(named("apiAuthFilter")),
            get()
        )()
    }
    single { serverConfig(get()) }
    single { RequestContexts() }
    single(AuthType.Optional.qualifier) { AuthFilter(get(), AuthType.Optional, get())() }
    single(AuthType.Required.qualifier) { AuthFilter(get(), AuthType.Required, get())() }
    single(named("ErrorFilter")) { ErrorFilter(get())() }
    single { ErrorView(get()) }
 }
 val userModule = module {
    single { UserController(get(), get(), get()) }
    single { UserView(get()) }
 }
 val baseModule = module {
    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()) }
 }
 val configModule = module {
    single { Config.dataSourceConfig }
    single { Config.jwtConfig }
    single { Config.serverConfig }
 }
 val apiModule = module {
    single { ApiUserController(get(), get()) }
    single { ApiNoteController(get(), get()) }
    single {
        Json {
            prettyPrint = true
            serializersModule = get()
        }
    }
    single {
        SerializersModule {
            contextual(LocalDateTime::class, LocalDateTimeSerializer)
            contextual(UUID::class, UuidSerializer)
        }
    }
    single(named("apiAuthFilter")) {
        AuthFilter(
            extractor = get(),
            authType = AuthType.Required,
            ctx = get(),
            source = JwtSource.Header,
            redirect = false
        )()
    }
 }
 internal object LocalDateTimeSerializer : KSerializer<LocalDateTime> {
    override val descriptor: SerialDescriptor
        get() = PrimitiveSerialDescriptor("LocalDateTime", PrimitiveKind.STRING)
    override fun serialize(encoder: Encoder, value: LocalDateTime) {
        encoder.encodeString(value.toString())
    }
    override fun deserialize(decoder: Decoder): LocalDateTime {
        TODO("Not implemented, isn't needed")
    }
 }
 internal object UuidSerializer : KSerializer<UUID> {
    override val descriptor: SerialDescriptor
        get() = PrimitiveSerialDescriptor("LocalDateTime", PrimitiveKind.STRING)
    override fun serialize(encoder: Encoder, value: UUID) {
        encoder.encodeString(value.toString())
    }
    override fun deserialize(decoder: Decoder): UUID {
        TODO()
    }
 }
@@ -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)
@@ -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)
@@ -1,13 +0,0 @@
 package be.simplenotes.app.controllers
 import be.simplenotes.app.extensions.html
 import be.simplenotes.app.views.BaseView
 import be.simplenotes.domain.security.JwtPayload
 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?) =
        Response(OK).html(view.renderHome(jwtPayload))
 }
@@ -1,152 +0,0 @@
 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.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 org.http4k.core.Method
 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.core.body.form
 import org.http4k.routing.path
 import java.util.*
 import kotlin.math.abs
 class NoteController(
    private val view: NoteView,
    private val noteService: NoteService,
 ) {
    fun new(request: Request, jwtPayload: JwtPayload): Response {
        if (request.method == Method.GET) return Response(OK).html(view.noteEditor(jwtPayload))
        val markdownForm = request.form("markdown") ?: ""
        return noteService.create(jwtPayload.userId, markdownForm).fold(
            {
                val html = when (it) {
                    MissingMeta -> view.noteEditor(jwtPayload, error = "Missing note metadata", textarea = markdownForm)
                    InvalidMeta -> view.noteEditor(jwtPayload, error = "Invalid note metadata", textarea = markdownForm)
                    is ValidationError -> view.noteEditor(
                        jwtPayload,
                        validationErrors = it.validationErrors,
                        textarea = markdownForm
                    )
                }
                Response(BAD_REQUEST).html(html)
            },
            {
                Response.redirect("/notes/${it.uuid}")
            }
        )
    }
    fun list(request: Request, jwtPayload: JwtPayload): 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 deletedCount = noteService.countDeleted(jwtPayload.userId)
        return Response(OK).html(view.notes(jwtPayload, notes, currentPage, pages, deletedCount, tag = tag))
    }
    fun search(request: Request, jwtPayload: JwtPayload): Response {
        val query = request.form("search") ?: ""
        val terms = parseSearchTerms(query)
        val notes = noteService.search(jwtPayload.userId, terms)
        val deletedCount = noteService.countDeleted(jwtPayload.userId)
        return Response(OK).html(view.search(jwtPayload, notes, query, deletedCount))
    }
    fun note(request: Request, jwtPayload: JwtPayload): 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))
                    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)
            } else if (request.form("private") != null) {
                if (!noteService.makePrivate(jwtPayload.userId, noteUuid)) return Response(NOT_FOUND)
            }
        }
        val note = noteService.find(jwtPayload.userId, noteUuid) ?: return Response(NOT_FOUND)
        return Response(OK).html(view.renderedNote(jwtPayload, note, shared = false))
    }
    fun public(request: Request, jwtPayload: JwtPayload?): 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))
    }
    fun edit(request: Request, jwtPayload: JwtPayload): Response {
        val noteUuid = request.uuidPath() ?: return Response(NOT_FOUND)
        val note = noteService.find(jwtPayload.userId, noteUuid) ?: return Response(NOT_FOUND)
        if (request.method == Method.GET) {
            return Response(OK).html(view.noteEditor(jwtPayload, textarea = note.markdown))
        }
        val markdownForm = request.form("markdown") ?: ""
        return noteService.update(jwtPayload.userId, note.uuid, markdownForm).fold(
            {
                val html = when (it) {
                    MissingMeta -> view.noteEditor(jwtPayload, error = "Missing note metadata", textarea = markdownForm)
                    InvalidMeta -> view.noteEditor(jwtPayload, error = "Invalid note metadata", textarea = markdownForm)
                    is ValidationError -> view.noteEditor(
                        jwtPayload,
                        validationErrors = it.validationErrors,
                        textarea = markdownForm
                    )
                }
                Response(BAD_REQUEST).html(html)
            },
            {
                Response.redirect("/notes/${note.uuid}")
            }
        )
    }
    fun trash(request: Request, jwtPayload: JwtPayload): 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)
        return Response(OK).html(view.trash(jwtPayload, notes, currentPage, pages))
    }
    fun deleted(request: Request, jwtPayload: JwtPayload): Response {
        val uuid = request.uuidPath() ?: return Response(NOT_FOUND)
        return if (request.form("delete") != null)
            if (noteService.delete(jwtPayload.userId, uuid))
                Response.redirect("/notes/trash")
            else
                Response(NOT_FOUND)
        else if (noteService.restore(jwtPayload.userId, uuid))
            Response.redirect("/notes/$uuid")
        else
            Response(NOT_FOUND)
    }
    private fun Request.uuidPath(): UUID? {
        val uuidPath = path("uuid")!!
        return try {
            UUID.fromString(uuidPath)!!
        } catch (e: IllegalArgumentException) {
            null
        }
    }
 }
@@ -1,67 +0,0 @@
 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.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 org.http4k.core.Method
 import org.http4k.core.Request
 import org.http4k.core.Response
 import org.http4k.core.Status
 import org.http4k.core.body.form
 import org.http4k.core.cookie.invalidateCookie
 class SettingsController(
    private val userService: UserService,
    private val settingView: SettingView,
 ) {
    fun settings(request: Request, jwtPayload: JwtPayload): Response {
        if (request.method == Method.GET)
            return Response(Status.OK).html(settingView.settings(jwtPayload))
        val deleteForm = request.deleteForm(jwtPayload)
        val result = userService.delete(deleteForm)
        return result.fold(
            {
                when (it) {
                    DeleteError.Unregistered -> Response.redirect("/").invalidateCookie("Bearer")
                    DeleteError.WrongPassword -> Response(Status.OK).html(
                        settingView.settings(
                            jwtPayload,
                            error = "Wrong password"
                        )
                    )
                    is DeleteError.InvalidForm -> Response(Status.OK).html(
                        settingView.settings(
                            jwtPayload,
                            validationErrors = it.validationErrors
                        )
                    )
                }
            },
            {
                Response.redirect("/").invalidateCookie("Authorization")
            }
        )
    }
    fun export(request: Request, jwtPayload: JwtPayload): Response {
        val isDownload = request.form("download") != null
        val json = userService.export(jwtPayload.userId)
        val res = Response(Status.OK).body(json).header("Content-Type", "application/json")
        return if (isDownload) res.header(
            "Content-Disposition",
            "attachment; filename=\"simplenotes-export-${sanitizeFilename(jwtPayload.username)}.json\""
        )
        else res
    }
    private fun sanitizeFilename(inputName: String): String = inputName.replace("[^a-zA-Z0-9-_.]".toRegex(), "_")
    private fun Request.deleteForm(jwtPayload: JwtPayload) =
        DeleteForm(jwtPayload.username, form("password"), form("checked") != null)
 }
@@ -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
@@ -1,15 +0,0 @@
 package be.simplenotes.app.extensions
 import kotlinx.html.*
 class SUMMARY(consumer: TagConsumer<*>) :
    HTMLTag(
        "summary", consumer, emptyMap(),
        inlineTag = true,
        emptyTag = false
    ),
    HtmlInlineTag
 fun DETAILS.summary(block: SUMMARY.() -> Unit = {}) {
    SUMMARY(consumer).visit(block)
 }
@@ -1,60 +0,0 @@
 package be.simplenotes.app.filters
 import be.simplenotes.app.extensions.redirect
 import be.simplenotes.domain.security.JwtPayload
 import be.simplenotes.domain.security.JwtPayloadExtractor
 import org.http4k.core.*
 import org.http4k.core.Status.Companion.UNAUTHORIZED
 import org.http4k.core.cookie.cookie
 enum class AuthType {
    Optional, Required
 }
 private const val authKey = "auth"
 class AuthFilter(
    private val extractor: JwtPayloadExtractor,
    private val authType: AuthType,
    private val ctx: RequestContexts,
    private val source: JwtSource = JwtSource.Cookie,
    private val redirect: Boolean = true,
 ) {
    operator fun invoke() = Filter { next ->
        {
            val token = when (source) {
                JwtSource.Header -> it.bearerTokenHeader()
                JwtSource.Cookie -> it.bearerTokenCookie()
            }
            val jwtPayload = token?.let { token -> extractor(token) }
            when {
                jwtPayload != null -> {
                    ctx[it][authKey] = jwtPayload
                    next(it)
                }
                authType == AuthType.Required -> {
                    if (redirect) Response.redirect("/login")
                    else Response(UNAUTHORIZED)
                }
                else -> next(it)
            }
        }
    }
 }
 fun Request.jwtPayload(ctx: RequestContexts): JwtPayload? = ctx[this][authKey]
 enum class JwtSource {
    Header, Cookie
 }
 private fun Request.bearerTokenCookie(): String? = cookie("Bearer")
    ?.value
    ?.trim()
 private fun Request.bearerTokenHeader(): String? =
    header("Authorization")
        ?.trim()
        ?.takeIf { it.startsWith("Bearer") }
        ?.substringAfter("Bearer")
        ?.trim()
@@ -1,33 +0,0 @@
 package be.simplenotes.app.filters
 import be.simplenotes.app.extensions.html
 import be.simplenotes.app.views.ErrorView
 import org.http4k.core.*
 import org.slf4j.LoggerFactory
 import java.sql.SQLTransientException
 class ErrorFilter(private val errorView: ErrorView) {
    private val logger = LoggerFactory.getLogger(javaClass)
    operator fun invoke(): Filter = Filter { next ->
        {
            try {
                val response = next(it)
                if (response.status == Status.NOT_FOUND) Response(Status.NOT_FOUND)
                    .html(errorView.error(ErrorView.Type.NotFound))
                else response
            } catch (e: Exception) {
                logger.error(e.stackTraceToString())
                if (e is SQLTransientException)
                    Response(Status.SERVICE_UNAVAILABLE).html(errorView.error(ErrorView.Type.SqlTransientError))
                        .noCache()
                else
                    Response(Status.INTERNAL_SERVER_ERROR).html(errorView.error(ErrorView.Type.Other)).noCache()
            } catch (e: NotImplementedError) {
                logger.error(e.stackTraceToString())
                Response(Status.NOT_IMPLEMENTED).html(errorView.error(ErrorView.Type.Other)).noCache()
            }
        }
    }
 }
@@ -1,14 +0,0 @@
 package be.simplenotes.app.filters
 import org.http4k.core.Filter
 import org.http4k.core.HttpHandler
 import org.http4k.core.Method
 import org.http4k.core.Request
 object ImmutableFilter {
    operator fun invoke() = Filter { next: HttpHandler ->
        { request: Request ->
           next(request).header("Cache-Control", "public, max-age=31536000, immutable")
        }
    }
 }
@@ -1,20 +0,0 @@
 package be.simplenotes.app.filters
 import org.http4k.core.Filter
 import org.http4k.core.HttpHandler
 import org.http4k.core.Request
 object SecurityFilter {
    operator fun invoke() = Filter { next: HttpHandler ->
        { request: Request ->
            val response = next(request)
                .header("X-Content-Type-Options", "nosniff")
            if (response.header("Content-Type")?.contains("text/html") == true) {
                response
                    .header("Content-Security-Policy", "default-src 'self'")
                    .header("Referrer-Policy", "no-referrer")
            } else response
        }
    }
 }
@@ -1,98 +0,0 @@
 package be.simplenotes.app.routes
 import be.simplenotes.app.api.ApiNoteController
 import be.simplenotes.app.api.ApiUserController
 import be.simplenotes.app.controllers.BaseController
 import be.simplenotes.app.controllers.NoteController
 import be.simplenotes.app.controllers.SettingsController
 import be.simplenotes.app.controllers.UserController
 import be.simplenotes.app.filters.ImmutableFilter
 import be.simplenotes.app.filters.SecurityFilter
 import be.simplenotes.app.filters.jwtPayload
 import be.simplenotes.domain.security.JwtPayload
 import org.http4k.core.*
 import org.http4k.core.Method.*
 import org.http4k.filter.ResponseFilters
 import org.http4k.filter.ServerFilters.InitialiseRequestContext
 import org.http4k.routing.*
 class Router(
    private val baseController: BaseController,
    private val userController: UserController,
    private val noteController: NoteController,
    private val settingsController: SettingsController,
    private val apiUserController: ApiUserController,
    private val apiNoteController: ApiNoteController,
    private val requiredAuth: Filter,
    private val optionalAuth: Filter,
    private val errorFilter: Filter,
    private val apiAuth: Filter,
    private val contexts: RequestContexts,
 ) {
    operator fun invoke(): RoutingHttpHandler {
        val resourceLoader = ResourceLoader.Classpath(("/static"))
        val basicRoutes = routes(
            ImmutableFilter().then(static(resourceLoader, "woff2" to ContentType("font/woff2"))),
        )
        infix fun PathMethod.public(handler: PublicHandler) = this to { handler(it, it.jwtPayload(contexts)) }
        infix fun PathMethod.protected(handler: ProtectedHandler) = this to { handler(it, it.jwtPayload(contexts)!!) }
        val publicRoutes: RoutingHttpHandler = routes(
            "/" bind GET public baseController::index,
            "/register" bind GET public userController::register,
            "/register" bind POST public userController::register,
            "/login" bind GET public userController::login,
            "/login" bind POST public userController::login,
            "/logout" bind POST to userController::logout,
            "/notes/public/{uuid}" bind GET public noteController::public,
        )
        val protectedRoutes = routes(
            "/settings" bind GET protected settingsController::settings,
            "/settings" bind POST protected settingsController::settings,
            "/export" bind POST protected settingsController::export,
            "/notes" bind GET protected noteController::list,
            "/notes" bind POST protected noteController::search,
            "/notes/new" bind GET protected noteController::new,
            "/notes/new" bind POST protected noteController::new,
            "/notes/trash" bind GET protected noteController::trash,
            "/notes/{uuid}" bind GET protected noteController::note,
            "/notes/{uuid}" bind POST protected noteController::note,
            "/notes/{uuid}/edit" bind GET protected noteController::edit,
            "/notes/{uuid}/edit" bind POST protected noteController::edit,
            "/notes/deleted/{uuid}" bind POST protected noteController::deleted,
        )
        val apiRoutes = routes(
            "/api/login" bind POST to apiUserController::login,
        )
        val protectedApiRoutes = routes(
            "/api/notes" bind GET protected apiNoteController::notes,
            "/api/notes" bind POST protected apiNoteController::createNote,
            "/api/notes/search" bind POST protected apiNoteController::search,
            "/api/notes/{uuid}" bind GET protected apiNoteController::note,
            "/api/notes/{uuid}" bind PUT protected apiNoteController::update,
        )
        val routes = routes(
            basicRoutes,
            optionalAuth.then(publicRoutes),
            requiredAuth.then(protectedRoutes),
            apiAuth.then(protectedApiRoutes),
            apiRoutes,
        )
        val globalFilters = errorFilter
            .then(InitialiseRequestContext(contexts))
            .then(SecurityFilter())
            .then(ResponseFilters.GZip())
        return globalFilters.then(routes)
    }
 }
 private typealias PublicHandler = (Request, JwtPayload?) -> Response
 private typealias ProtectedHandler = (Request, JwtPayload) -> Response
@@ -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()))
@@ -1,43 +0,0 @@
 package be.simplenotes.app.utils
 import be.simplenotes.domain.usecases.search.SearchTerms
 private fun innerRegex(name: String) =
    """$name:['"](.*?)['"]""".toRegex()
 private fun outerRegex(name: String) =
    """($name:['"].*?['"])""".toRegex()
 private val titleRe = innerRegex("title")
 private val outerTitleRe = outerRegex("title")
 private val tagRe = innerRegex("tag")
 private val outerTagRe = outerRegex("tag")
 private val contentRe = innerRegex("content")
 private val outerContentRe = outerRegex("content")
 fun parseSearchTerms(input: String): SearchTerms {
    var c: String = input
    fun extract(innerRegex: Regex, outerRegex: Regex): String? {
        val match = innerRegex.find(input)?.groups?.get(1)?.value
        if (match != null) {
            val group = outerRegex.find(input)?.groups?.get(1)?.value
            group?.let { c = c.replace(it, "") }
        }
        return match
    }
    val title: String? = extract(titleRe, outerTitleRe)
    val tag: String? = extract(tagRe, outerTagRe)
    val content: String? = extract(contentRe, outerContentRe)
    val all = c.trim().ifEmpty { null }
    return SearchTerms(
        title = title,
        tag = tag,
        content = content,
        all = all
    )
 }
@@ -1,115 +0,0 @@
 package be.simplenotes.app.views
 import be.simplenotes.app.utils.StaticFileResolver
 import be.simplenotes.domain.security.JwtPayload
 import kotlinx.html.*
 import kotlinx.html.div
 import org.intellij.lang.annotations.Language
 class BaseView(staticFileResolver: StaticFileResolver) : View(staticFileResolver) {
    fun renderHome(jwtPayload: JwtPayload?) = renderPage(
        title = "Home",
        description = "A fast and simple note taking website",
        jwtPayload = jwtPayload
    ) {
        section("text-center my-2 p-2") {
            h1("text-5xl casual") {
                span("text-teal-300") { +"Simplenotes " }
                +"- access your notes anywhere"
            }
        }
        div("container mx-auto flex flex-wrap justify-center content-center") {
            unsafe {
                @Language("html")
                val html =
                    """
                    <div aria-label="demo" class="md:order-1 order-2 flipped p-4 my-10 w-full md:w-1/2">
                        <div class="flex justify-between mb-4">
                          <h1 class="text-2xl underline">Notes</h1>
                            <span>
                            <span class="btn btn-teal pointer-events-none">Trash (3)</span>
                            <span class="ml-2 btn btn-green pointer-events-none">New</span>
                            </span>
                        </div>
                        <form class="md:space-x-2" id="search">
                        <input aria-label="demo-search" name="search" disabled="" value="tag:&quot;demo&quot;">
                        <span id="buttons">
                        <button type="button" disabled="" class="btn btn-green pointer-events-none">search</button>
                        <span class="btn btn-red pointer-events-none">clear</span>
                        </span>
                        </form>
                        <div class="overflow-x-auto">
                          <table id="notes">
                            <thead>
                              <tr>
                                <th scope="col" class="w-1/2">Title</th>
                                <th scope="col" class="w-1/4">Updated</th>
                                <th scope="col" class="w-1/4">Tags</th>
                              </tr>
                            </thead>
                            <tbody>
                              <tr>
                                <td><span class="text-blue-200 font-semibold underline">Formula 1</span></td>
                                <td class="text-center">moments ago</td>
                                <td>
                                  <ul class="inline flex flex-wrap justify-center">
                                    <li class="mx-2 my-1"><span class="tag disabled">#demo</span ></li>
                                  </ul>
                                </td>
                              </tr>
                              <tr>
                                <td><span class="text-blue-200 font-semibold underline">Syntax highlighting</span></td>
                                <td class="text-center">2 hours ago</td>
                                <td>
                                  <ul class="inline flex flex-wrap justify-center">
                                    <li class="mx-2 my-1"><span class="tag disabled">#features</span></li>
                                    <li class="mx-2 my-1"><span class="tag disabled">#demo</span></li>
                                  </ul>
                                </td>
                              </tr>
                              <tr>
                                <td><span class="text-blue-200 font-semibold underline">report</span></td>
                                <td class="text-center">5 days ago</td>
                                <td>
                                  <ul class="inline flex flex-wrap justify-center">
                                    <li class="mx-2 my-1"><span class="tag disabled">#study</span></li>
                                    <li class="mx-2 my-1"><span class="tag disabled">#demo</span></li>
                                  </ul>
                                </td>
                              </tr>
                            </tbody>
                          </table>
                        </div>
                    </div>
                    """.trimIndent()
                +html
            }
            welcome()
        }
    }
    @Suppress("NOTHING_TO_INLINE")
    private inline fun DIV.welcome() {
        div("w-full my-auto md:w-1/2 md:order-2 order-1 text-center") {
            div("m-4 rounded-lg p-6") {
                p("text-teal-400") {
                    h2("text-3xl text-teal-400 underline") { +"Features:" }
                    ul("list-disc text-lg list-inside") {
                        li { +"Markdown support" }
                        li { +"Full text search" }
                        li { +"Structured search" }
                        li { +"Code highlighting" }
                        li { +"Fast and lightweight" }
                        li { +"No tracking" }
                        li { +"Works without javascript" }
                        li { +"Data export" }
                    }
                }
            }
        }
    }
 }
@@ -1,88 +0,0 @@
 package be.simplenotes.app.views
 import be.simplenotes.app.extensions.summary
 import be.simplenotes.app.utils.StaticFileResolver
 import be.simplenotes.app.views.components.Alert
 import be.simplenotes.app.views.components.alert
 import be.simplenotes.app.views.components.input
 import be.simplenotes.domain.security.JwtPayload
 import io.konform.validation.ValidationError
 import kotlinx.html.*
 import kotlinx.html.ButtonType.submit
 class SettingView(staticFileResolver: StaticFileResolver) : View(staticFileResolver) {
    fun settings(
        jwtPayload: JwtPayload,
        error: String? = null,
        validationErrors: List<ValidationError> = emptyList(),
    ) = renderPage("Settings", jwtPayload = jwtPayload) {
        div("container mx-auto") {
            section("m-4 p-4 bg-gray-800 rounded") {
                h1("text-xl") {
                    +"Welcome "
                    span("text-teal-200 font-semibold") { +jwtPayload.username }
                }
            }
            section("m-4 p-4 bg-gray-800 rounded") {
                p(classes = "mb-4") {
                    +"Export all my data"
                }
                form(method = FormMethod.post, action = "/export") {
                    button(name = "display", classes = "inline btn btn-teal block", type = submit) { +"Display my data" }
                    button(name = "download", classes = "inline btn btn-green block ml-2 mt-2", type = submit) {
                        +"Download my data"
                    }
                }
            }
            section(classes = "m-4 p-4 bg-gray-800 rounded") {
                h2(classes = "mb-4 text-red-400 text-lg font-semibold") {
                    +"Delete my account"
                }
                error?.let { alert(Alert.Warning, error) }
                details {
                    if (error != null || validationErrors.isNotEmpty()) {
                        attributes["open"] = ""
                    }
                    summary {
                        span(classes = "mb-4 font-semibold underline") {
                            +"Are you sure? "
                            +"You are about to delete this user, and this process is irreversible !"
                        }
                    }
                    form(classes = "mt-4", method = FormMethod.post) {
                        input(
                            id = "password",
                            placeholder = "Password",
                            autoComplete = "off",
                            type = InputType.password,
                            error = validationErrors.find { it.dataPath == ".password" }?.message
                        )
                        checkBoxInput(name = "checked") {
                            id = "checked"
                            attributes["required"] = ""
                            label {
                                attributes["for"] = "checked"
                                +" Do you want to proceed ?"
                            }
                        }
                        button(
                            type = submit,
                            classes = "block mt-4 btn btn-red",
                            name = "delete"
                        ) { +"I'm sure" }
                    }
                }
            }
        }
    }
 }
@@ -1,12 +0,0 @@
 host=localhost
 port=8080
 #
 jdbcUrl=jdbc:h2:./notes-db;
 driverClassName=org.h2.Driver
 username=h2
 password=
 maximumPoolSize=10
 connectionTimeout=3000
 #
 jwt.secret=PliLvfk7l4WF+cZJk66LR5Mpnh+ocbvJ2wfUCK2UCms=
 jwt.validity=24
@@ -0,0 +1,47 @@
 package be.simplenotes.app.modules
 import be.simplenotes.app.filters.auth.*
 import be.simplenotes.domain.security.SimpleJwt
 import be.simplenotes.types.LoggedInUser
 import io.micronaut.context.annotation.Factory
 import io.micronaut.context.annotation.Primary
 import org.http4k.core.RequestContexts
 import org.http4k.lens.RequestContextKey
 import jakarta.inject.Named
 import jakarta.inject.Singleton
@Factory
 class AuthModule {
    @Singleton
    @Named("optional")
    fun optionalAuthLens(ctx: RequestContexts): OptionalAuthLens = RequestContextKey.optional(ctx)
    @Singleton
    @Named("required")
    fun requiredAuthLens(ctx: RequestContexts): RequiredAuthLens = RequestContextKey.required(ctx)
    @Singleton
    fun optionalAuth(simpleJwt: SimpleJwt<LoggedInUser>, @Named("optional") lens: OptionalAuthLens) =
        OptionalAuthFilter(simpleJwt, lens)
    @Primary
    @Singleton
    fun requiredAuth(simpleJwt: SimpleJwt<LoggedInUser>, @Named("required") lens: RequiredAuthLens) =
        RequiredAuthFilter(simpleJwt, lens)
    @Singleton
    @Named("api")
    internal fun apiAuthFilter(
        simpleJwt: SimpleJwt<LoggedInUser>,
        @Named("required") lens: RequiredAuthLens,
    ) = RequiredAuthFilter(
        simpleJwt = simpleJwt,
        lens = lens,
        source = JwtSource.Header,
        redirect = false,
    )
    @Singleton
    fun requestContexts() = RequestContexts()
 }
@@ -0,0 +1,23 @@
 package be.simplenotes.app.modules
 import be.simplenotes.app.serialization.LocalDateTimeSerializer
 import be.simplenotes.app.serialization.UuidSerializer
 import io.micronaut.context.annotation.Factory
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.modules.SerializersModule
 import java.time.LocalDateTime
 import java.util.*
 import jakarta.inject.Singleton
@Factory
 class JsonModule {
    @Singleton
    fun json() = Json {
        prettyPrint = true
        serializersModule = SerializersModule {
            contextual(LocalDateTime::class, LocalDateTimeSerializer())
            contextual(UUID::class, UuidSerializer())
        }
    }
 }
@@ -0,0 +1,38 @@
 package be.simplenotes.app.modules
 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.config.ServerConfig
 import io.micronaut.context.annotation.Factory
 import org.eclipse.jetty.server.ServerConnector
 import org.http4k.server.Http4kServer
 import org.http4k.server.asServer
 import jakarta.inject.Named
 import jakarta.inject.Singleton
 import org.eclipse.jetty.server.Server as JettyServer
 import org.http4k.server.ServerConfig as Http4kServerConfig
@Factory
 class ServerModule {
    @Singleton
    @Named("styles")
    fun styles(resolver: StaticFileResolver) = resolver.resolve("styles.css")!!
    @Singleton
    fun http4kServer(router: Router, serverConfig: Http4kServerConfig): Http4kServer =
        router().asServer(serverConfig)
    @Singleton
    fun http4kServerConfig(config: ServerConfig): Http4kServerConfig {
        val builder: ConnectorBuilder = { server: JettyServer ->
            ServerConnector(server).apply {
                port = config.port
                host = config.host
            }
        }
        return Jetty(config.port, builder)
    }
 }
@@ -0,0 +1,46 @@
 package be.simplenotes.app.routes
 import be.simplenotes.app.api.ApiNoteController
 import be.simplenotes.app.api.ApiUserController
 import be.simplenotes.app.filters.auth.RequiredAuthFilter
 import be.simplenotes.app.filters.auth.RequiredAuthLens
 import org.http4k.core.Method.*
 import org.http4k.core.Request
 import org.http4k.core.then
 import org.http4k.routing.PathMethod
 import org.http4k.routing.RoutingHttpHandler
 import org.http4k.routing.bind
 import org.http4k.routing.routes
 import java.util.function.Supplier
 import jakarta.inject.Named
 import jakarta.inject.Singleton
@Singleton
 class ApiRoutes(
    private val apiUserController: ApiUserController,
    private val apiNoteController: ApiNoteController,
    @Named("api") private val auth: RequiredAuthFilter,
    @Named("required") private val authLens: RequiredAuthLens,
 ) : Supplier<RoutingHttpHandler> {
    override fun get(): RoutingHttpHandler {
        infix fun PathMethod.to(action: ProtectedHandler) =
            this to { req: Request -> action(req, authLens(req)) }
        return routes(
            "/login" bind POST to apiUserController::login,
            with(apiNoteController) {
                auth.then(
                    routes(
                        "/" bind GET to ::notes,
                        "/" bind POST to ::createNote,
                        "/search" bind POST to ::search,
                        "/{uuid}" bind GET to ::note,
                        "/{uuid}" bind PUT to ::update,
                    ),
                ).withBasePath("/notes")
            },
        ).withBasePath("/api")
    }
 }
@@ -0,0 +1,55 @@
 package be.simplenotes.app.routes
 import be.simplenotes.app.controllers.BaseController
 import be.simplenotes.app.controllers.NoteController
 import be.simplenotes.app.controllers.UserController
 import be.simplenotes.app.filters.ImmutableFilter
 import be.simplenotes.app.filters.auth.OptionalAuthFilter
 import be.simplenotes.app.filters.auth.OptionalAuthLens
 import org.http4k.core.ContentType
 import org.http4k.core.Method.GET
 import org.http4k.core.Method.POST
 import org.http4k.core.Request
 import org.http4k.core.then
 import org.http4k.routing.*
 import java.util.function.Supplier
 import jakarta.inject.Named
 import jakarta.inject.Singleton
@Singleton
 class BasicRoutes(
    private val baseCtrl: BaseController,
    private val userCtrl: UserController,
    private val noteCtrl: NoteController,
    @Named("optional") private val authLens: OptionalAuthLens,
    private val auth: OptionalAuthFilter,
 ) : Supplier<RoutingHttpHandler> {
    override fun get(): RoutingHttpHandler {
        infix fun PathMethod.to(action: PublicHandler) =
            this to { req: Request -> action(req, authLens(req)) }
        val staticHandler = ImmutableFilter.then(
            static(
                ResourceLoader.Classpath("/static"),
                "woff2" to ContentType("font/woff2"),
                "webmanifest" to ContentType("application/manifest+json"),
            ),
        )
        return routes(
            auth.then(
                routes(
                    "/" bind GET to baseCtrl::index,
                    "/register" bind GET to userCtrl::register,
                    "/register" bind POST to userCtrl::register,
                    "/login" bind GET to userCtrl::login,
                    "/login" bind POST to userCtrl::login,
                    "/logout" bind POST to userCtrl::logout,
                    "/notes/public/{uuid}" bind GET to noteCtrl::public,
                ),
            ),
            staticHandler,
        )
    }
 }
@@ -0,0 +1,45 @@
 package be.simplenotes.app.routes
 import be.simplenotes.app.controllers.NoteController
 import be.simplenotes.app.filters.auth.RequiredAuthFilter
 import be.simplenotes.app.filters.auth.RequiredAuthLens
 import org.http4k.core.Method.GET
 import org.http4k.core.Method.POST
 import org.http4k.core.Request
 import org.http4k.core.then
 import org.http4k.routing.PathMethod
 import org.http4k.routing.RoutingHttpHandler
 import org.http4k.routing.bind
 import org.http4k.routing.routes
 import java.util.function.Supplier
 import jakarta.inject.Named
 import jakarta.inject.Singleton
@Singleton
 class NoteRoutes(
    private val noteCtrl: NoteController,
    private val auth: RequiredAuthFilter,
    @Named("required") private val authLens: RequiredAuthLens,
 ) : Supplier<RoutingHttpHandler> {
    override fun get(): RoutingHttpHandler {
        infix fun PathMethod.to(action: ProtectedHandler) =
            this to { req: Request -> action(req, authLens(req)) }
        return auth.then(
            with(noteCtrl) {
                routes(
                    "/" bind GET to ::list,
                    "/" bind POST to ::search,
                    "/new" bind GET to ::new,
                    "/new" bind POST to ::new,
                    "/trash" bind GET to ::trash,
                    "/{uuid}" bind GET to ::note,
                    "/{uuid}" bind POST to ::note,
                    "/{uuid}/edit" bind GET to ::edit,
                    "/{uuid}/edit" bind POST to ::edit,
                    "/deleted/{uuid}" bind POST to ::deleted,
                ).withBasePath("/notes")
            },
        )
    }
 }
@@ -0,0 +1,8 @@
 package be.simplenotes.app.routes
 import be.simplenotes.types.LoggedInUser
 import org.http4k.core.Request
 import org.http4k.core.Response
 internal typealias PublicHandler = (Request, LoggedInUser?) -> Response
 internal typealias ProtectedHandler = (Request, LoggedInUser) -> Response
@@ -0,0 +1,31 @@
 package be.simplenotes.app.routes
 import be.simplenotes.app.filters.ErrorFilter
 import be.simplenotes.app.filters.SecurityFilter
 import org.http4k.core.RequestContexts
 import org.http4k.core.then
 import org.http4k.filter.ResponseFilters.GZip
 import org.http4k.filter.ServerFilters.InitialiseRequestContext
 import org.http4k.routing.RoutingHttpHandler
 import org.http4k.routing.routes
 import java.util.function.Supplier
 import jakarta.inject.Singleton
@Singleton
 class Router(
    private val errorFilter: ErrorFilter,
    private val contexts: RequestContexts,
    private val subRouters: List<Supplier<RoutingHttpHandler>>,
 ) {
    operator fun invoke(): RoutingHttpHandler {
        val routes = routes(
            *subRouters.map { it.get() }.toTypedArray(),
        )
        return errorFilter
            .then(InitialiseRequestContext(contexts))
            .then(SecurityFilter)
            .then(GZip())
            .then(routes)
    }
 }
@@ -0,0 +1,37 @@
 package be.simplenotes.app.routes
 import be.simplenotes.app.controllers.SettingsController
 import be.simplenotes.app.filters.auth.RequiredAuthFilter
 import be.simplenotes.app.filters.auth.RequiredAuthLens
 import org.http4k.core.Method.GET
 import org.http4k.core.Method.POST
 import org.http4k.core.Request
 import org.http4k.core.then
 import org.http4k.routing.PathMethod
 import org.http4k.routing.RoutingHttpHandler
 import org.http4k.routing.bind
 import org.http4k.routing.routes
 import java.util.function.Supplier
 import jakarta.inject.Named
 import jakarta.inject.Singleton
@Singleton
 class SettingsRoutes(
    private val settingsController: SettingsController,
    private val auth: RequiredAuthFilter,
    @Named("required") private val authLens: RequiredAuthLens,
 ) : Supplier<RoutingHttpHandler> {
    override fun get(): RoutingHttpHandler {
        infix fun PathMethod.to(action: ProtectedHandler) =
            this to { req: Request -> action(req, authLens(req)) }
        return auth.then(
            routes(
                "/settings" bind GET to settingsController::settings,
                "/settings" bind POST to settingsController::settings,
                "/export" bind POST to settingsController::export,
                "/import" bind POST to settingsController::import,
            ),
        )
    }
 }
@@ -0,0 +1,22 @@
 package be.simplenotes.app.serialization
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.descriptors.PrimitiveKind
 import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 import java.time.LocalDateTime
 internal class LocalDateTimeSerializer : KSerializer<LocalDateTime> {
    override val descriptor: SerialDescriptor
        get() = PrimitiveSerialDescriptor("LocalDateTime", PrimitiveKind.STRING)
    override fun serialize(encoder: Encoder, value: LocalDateTime) {
        encoder.encodeString(value.toString())
    }
    override fun deserialize(decoder: Decoder): LocalDateTime {
        return LocalDateTime.parse(decoder.decodeString())
    }
 }
@@ -0,0 +1,22 @@
 package be.simplenotes.app.serialization
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.descriptors.PrimitiveKind
 import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 import java.util.*
 internal class UuidSerializer : KSerializer<UUID> {
    override val descriptor: SerialDescriptor
        get() = PrimitiveSerialDescriptor("UUID", PrimitiveKind.STRING)
    override fun serialize(encoder: Encoder, value: UUID) {
        encoder.encodeString(value.toString())
    }
    override fun deserialize(decoder: Decoder): UUID {
        TODO()
    }
 }
@@ -1,16 +1,19 @@
 package be.simplenotes.app.utils
-import kotlinx.serialization.json.*
+import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
 import jakarta.inject.Singleton
 interface StaticFileResolver {
    fun resolve(name: String): String?
 }
-class StaticFileResolverImpl : StaticFileResolver {
+@Singleton
 class StaticFileResolverImpl(json: Json) : StaticFileResolver {
    private val mappings: Map<String, String>
    init {
        val json = Json {}
        val manifest = javaClass.getResource("/css-manifest.json").readText()
        val manifestObject = json.parseToJsonElement(manifest).jsonObject
        val keys = manifestObject.keys
@@ -1,15 +1,24 @@
 package be.simplenotes.app.filters
-import be.simplenotes.domain.security.JwtPayload
+import be.simplenotes.app.filters.auth.OptionalAuthFilter
-import be.simplenotes.domain.security.JwtPayloadExtractor
+import be.simplenotes.app.filters.auth.OptionalAuthLens
 import be.simplenotes.app.filters.auth.RequiredAuthFilter
 import be.simplenotes.app.filters.auth.RequiredAuthLens
 import be.simplenotes.config.JwtConfig
 import be.simplenotes.domain.security.SimpleJwt
-import be.simplenotes.shared.config.JwtConfig
+import be.simplenotes.domain.security.UserJwtMapper
 import be.simplenotes.types.LoggedInUser
 import com.natpryce.hamkrest.assertion.assertThat
-import org.http4k.core.*
+import io.micronaut.context.BeanContext
 import io.micronaut.inject.qualifiers.Qualifiers
 import org.http4k.core.Method.GET
 import org.http4k.core.Request
 import org.http4k.core.RequestContexts
 import org.http4k.core.Response
 import org.http4k.core.Status.Companion.FOUND
 import org.http4k.core.Status.Companion.OK
 import org.http4k.core.cookie.cookie
 import org.http4k.core.then
 import org.http4k.filter.ServerFilters
 import org.http4k.hamkrest.hasBody
 import org.http4k.hamkrest.hasHeader
@@ -20,23 +29,37 @@ import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 import java.util.concurrent.TimeUnit
-internal class AuthFilterTest {
+internal class RequiredAuthFilterTest {
    // region setup
    private val jwtConfig = JwtConfig("secret", 1, TimeUnit.HOURS)
-    private val simpleJwt = SimpleJwt(jwtConfig)
+    private val simpleJwt = SimpleJwt(jwtConfig, UserJwtMapper())
    private val extractor = JwtPayloadExtractor(simpleJwt)
    private val ctx = RequestContexts()
    private val requiredAuth = AuthFilter(extractor, AuthType.Required, ctx)()
    private val optionalAuth = AuthFilter(extractor, AuthType.Optional, ctx)()
-    private val echoJwtPayloadHandler = { request: Request -> Response(OK).body(request.jwtPayload(ctx).toString()) }
+    private val beanCtx = BeanContext.build()
        .registerSingleton(jwtConfig)
        .start()
    private inline fun <reified T> BeanContext.getBean(): T = getBean(T::class.java)
    private inline fun <reified T> BeanContext.getBean(name: String): T =
        getBean(T::class.java, Qualifiers.byName(name))
    private val requiredAuth = beanCtx.getBean<RequiredAuthFilter>()
    private val requiredLens = beanCtx.getBean<RequiredAuthLens>("required")
    private val optionalAuth = beanCtx.getBean<OptionalAuthFilter>()
    private val optionalLens = beanCtx.getBean<OptionalAuthLens>("optional")
    private val ctx = beanCtx.getBean<RequestContexts>()
    private val app = ServerFilters.InitialiseRequestContext(ctx).then(
        routes(
-            "/optional" bind GET to optionalAuth.then(echoJwtPayloadHandler),
+            "/optional" bind GET to optionalAuth.then { request: Request ->
-            "/protected" bind GET to requiredAuth.then(echoJwtPayloadHandler)
+                Response(OK).body(optionalLens(request).toString())
-        )
+            },
            "/protected" bind GET to requiredAuth.then { request: Request ->
                Response(OK).body(requiredLens(request).toString())
            },
        ),
    )
    // endregion
@@ -58,7 +81,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))
@@ -83,8 +106,8 @@ internal class AuthFilterTest {
        }
        @Test
-        fun `it should allow a valid token"`() {
+        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))
@@ -0,0 +1,3 @@
 plugins {
    id("be.simplenotes.versions")
 }
@@ -0,0 +1,15 @@
 plugins {
    `kotlin-dsl`
 }
 repositories {
    gradlePluginPortal()
 }
 dependencies {
    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.21")
    implementation("org.jetbrains.kotlin:kotlin-serialization:1.8.21")
    implementation("com.github.johnrengelman:shadow:8.1.1")
    implementation("com.diffplug.spotless:spotless-plugin-gradle:6.13.0")
    implementation("com.github.ben-manes:gradle-versions-plugin:0.46.0")
 }
@@ -0,0 +1,44 @@
 package be.simplenotes
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.create
 open class DockerPluginExtension {
    var image: String? = null
    var tag = "latest"
 }
 class DockerPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        val extension = project.extensions.create<DockerPluginExtension>("docker")
        project.task("dockerBuild") {
            dependsOn("package")
            group = "docker"
            description = "Build a docker image"
            doLast {
                project.exec {
                    commandLine("docker", "build", "-t", "${extension.image}:${extension.tag}", ".")
                    workingDir(project.rootProject.projectDir)
                }
            }
        }
        project.task("dockerPush") {
            dependsOn("dockerBuild")
            group = "docker"
            description = "Push a docker image"
            doLast {
                project.exec {
                    commandLine("docker", "push", "${extension.image}:${extension.tag}")
                    workingDir(project.rootProject.projectDir)
                }
            }
        }
    }
 }
@@ -0,0 +1,13 @@
@file:Suppress("SpellCheckingInspection")
 package be.simplenotes
 object Libs {
    object Micronaut {
        private const val version = "4.0.0-M2"
        const val inject = "io.micronaut:micronaut-inject:$version"
        const val processor = "io.micronaut:micronaut-inject-java:$version"
    }
 }
@@ -0,0 +1,33 @@
 package be.simplenotes
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.jetbrains.kotlin.gradle.plugin.KaptExtension
 class MicronautPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        target.plugins.apply("org.jetbrains.kotlin.kapt")
        target.extensions.configure<KaptExtension>("kapt") {
            arguments {
                arg("micronaut.processing.incremental", true)
            }
        }
    }
 }
 fun DependencyHandler.micronaut() {
    add("kapt", Libs.Micronaut.processor)
    add("implementation", Libs.Micronaut.inject)
 }
 fun DependencyHandler.micronautTest() {
    add("kaptTest", Libs.Micronaut.processor)
    add("testImplementation", Libs.Micronaut.inject)
 }
 fun DependencyHandler.micronautFixtures() {
    add("kaptTestFixtures", Libs.Micronaut.inject)
    add("testFixturesImplementation", Libs.Micronaut.processor)
 }
@@ -0,0 +1,26 @@
 package be.simplenotes
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.tasks.SourceSetContainer
 import org.gradle.kotlin.dsl.get
 import org.gradle.kotlin.dsl.getByType
 import org.gradle.kotlin.dsl.register
 import java.io.File
 class PostcssPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        with(project.tasks) {
            register<PostcssTask>("postcss") {
                group = "postcss"
                description = "generate postcss resources"
            }
            getByName("processResources").dependsOn("postcss")
        }
        val sourceSets = project.extensions.getByType<SourceSetContainer>()
        val root = File("${project.buildDir}/generated-resources/css")
        sourceSets["main"].resources.srcDir(root)
    }
 }
@@ -0,0 +1,75 @@
 package be.simplenotes
 import org.gradle.api.DefaultTask
 import org.gradle.api.GradleException
 import org.gradle.api.tasks.*
 import org.gradle.kotlin.dsl.getByType
 import java.io.File
 import java.lang.ProcessBuilder.Redirect.PIPE
 import java.util.concurrent.TimeUnit
 import kotlin.concurrent.thread
 open class PostcssTask : DefaultTask() {
    private val viewsProject = project
        .parent
        ?.project(":views")
        ?: error("Missing :views")
    @get:InputDirectory
    val templatesDir = viewsProject.extensions
        .getByType<SourceSetContainer>()
        .asMap.getOrElse("main") { error("main sources not found") }
        .allSource.srcDirs
        .find { it.endsWith("src") }
        ?: error("kotlin sources not found")
    private val yarnRoot = File(project.rootDir, "css")
    @get:InputDirectory
    val postCssDir = File(project.rootDir, "css/src")
    @get:InputFiles
    val postCssConfig = listOf(
        "tailwind.config.js",
        "postcss.config.js",
        "package.json"
    ).map { File(yarnRoot, it) }
    @get:OutputDirectory
    val outputRootDir = File(project.buildDir, "generated-resources/css")
    private val cssIndex = File(postCssDir, "styles.pcss")
    private val cssOutput = File(outputRootDir, "static/styles.css")
    private val manifestOutput = File(outputRootDir, "css-manifest.json")
    private val purgeGlob = "$templatesDir/**/*.kt"
    @TaskAction
    fun generateCss() {
        // TODO: auto yarn install ?
        outputRootDir.deleteRecursively()
        ProcessBuilder("yarn", "run", "postcss", "$cssIndex", "--output", "$cssOutput")
            .apply {
                environment().let {
                    it["MANIFEST"] = "$manifestOutput"
                    it["NODE_ENV"] = "production"
                    it["PURGE"] = purgeGlob
                }
            }
            .redirectOutput(PIPE)
            .redirectError(PIPE)
            .directory(yarnRoot)
            .start()
            .apply {
                thread { inputStream.use { it.copyTo(System.out) } }
                thread { errorStream.use { it.copyTo(System.out) } }
                waitFor(30, TimeUnit.SECONDS)
                if (exitValue() != 0) throw GradleException(":/")
            }
    }
 }
@@ -0,0 +1,41 @@
 package be.simplenotes
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 plugins {
    id("com.github.johnrengelman.shadow")
 }
 tasks.withType<ShadowJar> {
    archiveAppendix.set("with-dependencies")
    manifest.attributes["Main-Class"] = "be.simplenotes.app.SimpleNotesKt"
    // johnrengelman/shadow#449
    // we need this for lucene-core
    manifest.attributes["Multi-Release"] = "true"
    mergeServiceFiles()
    File(rootProject.projectDir, "buildSrc/src/main/resources/exclusions")
        .listFiles()!!
        .flatMap {
            it.readLines()
                .asSequence()
                .map { it.trim() }
                .filterNot { it.isBlank() }
                .filterNot { it.startsWith("#") }
                .asIterable()
        }.forEach { exclude(it) }
 }
 tasks.create("package") {
    tasks.getByName("build").dependsOn("package")
    dependsOn("shadowJar")
    doLast {
        println("SimpleNotes Packaged !")
    }
 }
@@ -0,0 +1,14 @@
 package be.simplenotes
 plugins {
    id("be.simplenotes.java-convention")
    id("be.simplenotes.kotlin-convention")
    id("be.simplenotes.junit-convention")
    id("com.diffplug.spotless")
 }
 spotless {
    kotlin {
        ktlint("0.48.0").setEditorConfigPath(project.rootProject.file(".editorconfig"))
    }
 }
@@ -0,0 +1,28 @@
 package be.simplenotes
 plugins {
    `java-library`
 }
 repositories {
    mavenCentral()
 }
 group = "be.simplenotes"
 version = "1.0-SNAPSHOT"
 java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(19))
        vendor.set(JvmVendorSpec.ORACLE)
    }
 }
 tasks.withType<JavaCompile> {
    options.encoding = "UTF-8"
 }
 sourceSets["main"].resources.setSrcDirs(listOf("resources"))
 sourceSets["main"].java.setSrcDirs(emptyList<String>())
 sourceSets["test"].resources.setSrcDirs(listOf("testresources"))
 sourceSets["test"].java.setSrcDirs(emptyList<String>())
@@ -0,0 +1,15 @@
 package be.simplenotes
 plugins {
    java apply false
 }
 tasks.withType<Test> {
    useJUnitPlatform {
        excludeTags("slow")
    }
 }
 dependencies {
    testRuntimeOnly(project(":junit-config"))
 }
@@ -0,0 +1,31 @@
 package be.simplenotes
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 plugins {
    kotlin("jvm")
 }
 dependencies {
    implementation(kotlin("stdlib-jdk8"))
    implementation(platform(kotlin("bom")))
    testImplementation(platform(kotlin("bom")))
 }
 tasks.withType<KotlinCompile> {
    compilerOptions {
        jvmTarget.set(JvmTarget.JVM_19)
        javaParameters.set(true)
        freeCompilerArgs.addAll(
            "-Xinline-classes",
            "-Xno-param-assertions",
            "-Xno-call-assertions",
            "-Xno-receiver-assertions",
        )
    }
 }
 kotlin.sourceSets["main"].kotlin.setSrcDirs(listOf("src"))
 kotlin.sourceSets["test"].kotlin.setSrcDirs(listOf("test"))
@@ -0,0 +1,5 @@
 package be.simplenotes
 plugins {
    kotlin("plugin.serialization")
 }
@@ -0,0 +1,17 @@
 package be.simplenotes
 import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask
 plugins {
    id("com.github.ben-manes.versions")
 }
 tasks.named<DependencyUpdatesTask>("dependencyUpdates").configure {
    resolutionStrategy {
        componentSelection {
            all {
                if ("alpha|beta|rc".toRegex().containsMatchIn(candidate.version.lowercase())) reject("Non stable version")
            }
        }
    }
 }
@@ -0,0 +1 @@
 implementation-class=be.simplenotes.DockerPlugin
@@ -0,0 +1 @@
 implementation-class=be.simplenotes.MicronautPlugin
@@ -0,0 +1 @@
 implementation-class=be.simplenotes.PostcssPlugin
@@ -0,0 +1,16 @@
 META-INF/maven/**
 META-INF/proguard/**
 META-INF/com.android.tools/**
 META-INF/*.kotlin_module
 META-INF/DEPENDENCIES*
 META-INF/NOTICE*
 META-INF/LICENSE*
 LICENSE*
 META-INF/README*
 META-INF/native-image/**
 **/module-info.**
 # Jetty
 about.html
 jetty-dir.css
 server-ssl-cert.pem
@@ -0,0 +1,261 @@
 com/google/common/util/**
 com/google/common/eventbus/**
 com/google/common/reflect/**
 com/google/common/escape/**
 com/google/common/graph/**
 com/google/common/html/**
 com/google/common/hash/**
 com/google/common/xml/**
 com/google/common/io/**
 com/google/common/cache/**
 com/google/common/net/**
 # Collections
 com/google/common/collect/AbstractBiMap$1.class
 com/google/common/collect/AbstractBiMap$BiMapEntry.class
 com/google/common/collect/AbstractBiMap$EntrySet.class
 com/google/common/collect/AbstractBiMap$Inverse.class
 com/google/common/collect/AbstractBiMap$KeySet.class
 com/google/common/collect/AbstractBiMap$ValueSet.class
 com/google/common/collect/AbstractBiMap.class
 com/google/common/collect/AbstractSortedKeySortedSetMultimap.class
 com/google/common/collect/AbstractSortedMultiset$1DescendingMultisetImpl.class
 com/google/common/collect/AbstractSortedMultiset.class
 com/google/common/collect/AbstractTable$1.class
 com/google/common/collect/AbstractTable$CellSet.class
 com/google/common/collect/AbstractTable$Values.class
 com/google/common/collect/AbstractTable.class
 com/google/common/collect/ArrayListMultimap.class
 com/google/common/collect/ArrayListMultimapGwtSerializationDependencies.class
 com/google/common/collect/ArrayTable$1.class
 com/google/common/collect/ArrayTable$2.class
 com/google/common/collect/ArrayTable$3.class
 com/google/common/collect/ArrayTable$ArrayMap$1.class
 com/google/common/collect/ArrayTable$ArrayMap$2.class
 com/google/common/collect/ArrayTable$ArrayMap.class
 com/google/common/collect/ArrayTable$Column.class
 com/google/common/collect/ArrayTable$ColumnMap.class
 com/google/common/collect/ArrayTable$Row.class
 com/google/common/collect/ArrayTable$RowMap.class
 com/google/common/collect/ArrayTable.class
 com/google/common/collect/ClassToInstanceMap.class
 com/google/common/collect/CompactHashMap$1.class
 com/google/common/collect/CompactHashMap$2.class
 com/google/common/collect/CompactHashMap$3.class
 com/google/common/collect/CompactHashMap$EntrySetView.class
 com/google/common/collect/CompactHashMap$Itr.class
 com/google/common/collect/CompactHashMap$KeySetView.class
 com/google/common/collect/CompactHashMap$MapEntry.class
 com/google/common/collect/CompactHashMap$ValuesView.class
 com/google/common/collect/CompactHashMap.class
 com/google/common/collect/CompactHashSet$1.class
 com/google/common/collect/CompactHashSet.class
 com/google/common/collect/CompactLinkedHashMap$1EntrySetImpl.class
 com/google/common/collect/CompactLinkedHashMap$1KeySetImpl.class
 com/google/common/collect/CompactLinkedHashMap$1ValuesImpl.class
 com/google/common/collect/CompactLinkedHashMap.class
 com/google/common/collect/CompactLinkedHashSet.class
 com/google/common/collect/Comparators.class
 com/google/common/collect/ComputationException.class
 com/google/common/collect/ConcurrentHashMultiset$1.class
 com/google/common/collect/ConcurrentHashMultiset$2.class
 com/google/common/collect/ConcurrentHashMultiset$3.class
 com/google/common/collect/ConcurrentHashMultiset$EntrySet.class
 com/google/common/collect/ConcurrentHashMultiset$FieldSettersHolder.class
 com/google/common/collect/ConcurrentHashMultiset.class
 com/google/common/collect/DenseImmutableTable$1.class
 com/google/common/collect/DenseImmutableTable$Column.class
 com/google/common/collect/DenseImmutableTable$ColumnMap.class
 com/google/common/collect/DenseImmutableTable$ImmutableArrayMap$1.class
 com/google/common/collect/DenseImmutableTable$ImmutableArrayMap.class
 com/google/common/collect/DenseImmutableTable$Row.class
 com/google/common/collect/DenseImmutableTable$RowMap.class
 com/google/common/collect/DenseImmutableTable.class
 com/google/common/collect/DescendingImmutableSortedMultiset.class
 com/google/common/collect/DescendingMultiset$1EntrySetImpl.class
 com/google/common/collect/DescendingMultiset.class
 com/google/common/collect/EnumBiMap.class
 com/google/common/collect/EnumHashBiMap.class
 com/google/common/collect/EnumMultiset$1.class
 com/google/common/collect/EnumMultiset$2$1.class
 com/google/common/collect/EnumMultiset$2.class
 com/google/common/collect/EnumMultiset$Itr.class
 com/google/common/collect/EnumMultiset.class
 com/google/common/collect/EvictingQueue.class
 com/google/common/collect/ForwardingBlockingDeque.class
 com/google/common/collect/ForwardingDeque.class
 com/google/common/collect/ForwardingImmutableCollection.class
 com/google/common/collect/ForwardingImmutableList.class
 com/google/common/collect/ForwardingImmutableMap.class
 com/google/common/collect/ForwardingImmutableSet.class
 com/google/common/collect/ForwardingIterator.class
 com/google/common/collect/ForwardingListIterator.class
 com/google/common/collect/ForwardingListMultimap.class
 com/google/common/collect/ForwardingNavigableMap$StandardDescendingMap$1.class
 com/google/common/collect/ForwardingNavigableMap$StandardDescendingMap.class
 com/google/common/collect/ForwardingNavigableMap$StandardNavigableKeySet.class
 com/google/common/collect/ForwardingNavigableMap.class
 com/google/common/collect/ForwardingQueue.class
 com/google/common/collect/ForwardingSetMultimap.class
 com/google/common/collect/ForwardingSortedMultiset$StandardDescendingMultiset.class
 com/google/common/collect/ForwardingSortedMultiset$StandardElementSet.class
 com/google/common/collect/ForwardingSortedMultiset.class
 com/google/common/collect/ForwardingSortedSetMultimap.class
 com/google/common/collect/ForwardingTable.class
 com/google/common/collect/GeneralRange.class
 com/google/common/collect/GwtTransient.class
 com/google/common/collect/HashBasedTable$Factory.class
 com/google/common/collect/HashBasedTable.class
 com/google/common/collect/HashBiMap$1$MapEntry.class
 com/google/common/collect/HashBiMap$1.class
 com/google/common/collect/HashBiMap$BiEntry.class
 com/google/common/collect/HashBiMap$Inverse$1$InverseEntry.class
 com/google/common/collect/HashBiMap$Inverse$1.class
 com/google/common/collect/HashBiMap$Inverse$InverseKeySet$1.class
 com/google/common/collect/HashBiMap$Inverse$InverseKeySet.class
 com/google/common/collect/HashBiMap$Inverse.class
 com/google/common/collect/HashBiMap$InverseSerializedForm.class
 com/google/common/collect/HashBiMap$Itr.class
 com/google/common/collect/HashBiMap$KeySet$1.class
 com/google/common/collect/HashBiMap$KeySet.class
 com/google/common/collect/HashBiMap.class
 com/google/common/collect/HashMultimap.class
 com/google/common/collect/HashMultimapGwtSerializationDependencies.class
 com/google/common/collect/ImmutableClassToInstanceMap$1.class
 com/google/common/collect/ImmutableClassToInstanceMap$Builder.class
 com/google/common/collect/ImmutableClassToInstanceMap.class
 com/google/common/collect/ImmutableSortedMultiset$Builder.class
 com/google/common/collect/ImmutableSortedMultiset$SerializedForm.class
 com/google/common/collect/ImmutableSortedMultiset.class
 com/google/common/collect/ImmutableSortedMultisetFauxverideShim.class
 com/google/common/collect/ImmutableTable$1.class
 com/google/common/collect/ImmutableTable$Builder.class
 com/google/common/collect/ImmutableTable$CollectorState.class
 com/google/common/collect/ImmutableTable$MutableCell.class
 com/google/common/collect/ImmutableTable$SerializedForm.class
 com/google/common/collect/ImmutableTable.class
 com/google/common/collect/Interner.class
 com/google/common/collect/Interners$1.class
 com/google/common/collect/Interners$InternerBuilder.class
 com/google/common/collect/Interners$InternerFunction.class
 com/google/common/collect/Interners$InternerImpl.class
 com/google/common/collect/Interners.class
 com/google/common/collect/LinkedHashMultimap$1.class
 com/google/common/collect/LinkedHashMultimap$ValueEntry.class
 com/google/common/collect/LinkedHashMultimap$ValueSet$1.class
 com/google/common/collect/LinkedHashMultimap$ValueSet.class
 com/google/common/collect/LinkedHashMultimap$ValueSetLink.class
 com/google/common/collect/LinkedHashMultimap.class
 com/google/common/collect/LinkedHashMultimapGwtSerializationDependencies.class
 com/google/common/collect/LinkedListMultimap$1.class
 com/google/common/collect/LinkedListMultimap$1EntriesImpl.class
 com/google/common/collect/LinkedListMultimap$1KeySetImpl.class
 com/google/common/collect/LinkedListMultimap$1ValuesImpl$1.class
 com/google/common/collect/LinkedListMultimap$1ValuesImpl.class
 com/google/common/collect/LinkedListMultimap$DistinctKeyIterator.class
 com/google/common/collect/LinkedListMultimap$KeyList.class
 com/google/common/collect/LinkedListMultimap$Node.class
 com/google/common/collect/LinkedListMultimap$NodeIterator.class
 com/google/common/collect/LinkedListMultimap$ValueForKeyIterator.class
 com/google/common/collect/LinkedListMultimap.class
 com/google/common/collect/MinMaxPriorityQueue$1.class
 com/google/common/collect/MinMaxPriorityQueue$Builder.class
 com/google/common/collect/MinMaxPriorityQueue$Heap.class
 com/google/common/collect/MinMaxPriorityQueue$MoveDesc.class
 com/google/common/collect/MinMaxPriorityQueue$QueueIterator.class
 com/google/common/collect/MinMaxPriorityQueue.class
 com/google/common/collect/MoreCollectors$ToOptionalState.class
 com/google/common/collect/MoreCollectors.class
 com/google/common/collect/MutableClassToInstanceMap$1.class
 com/google/common/collect/MutableClassToInstanceMap$2$1.class
 com/google/common/collect/MutableClassToInstanceMap$2.class
 com/google/common/collect/MutableClassToInstanceMap$SerializedForm.class
 com/google/common/collect/MutableClassToInstanceMap.class
 com/google/common/collect/Queues.class
 com/google/common/collect/RegularImmutableSortedMultiset.class
 com/google/common/collect/RegularImmutableTable$1.class
 com/google/common/collect/RegularImmutableTable$CellSet.class
 com/google/common/collect/RegularImmutableTable$Values.class
 com/google/common/collect/RegularImmutableTable.class
 com/google/common/collect/RowSortedTable.class
 com/google/common/collect/SingletonImmutableTable.class
 com/google/common/collect/SortedMultisets$ElementSet.class
 com/google/common/collect/SortedMultisets$NavigableElementSet.class
 com/google/common/collect/SortedMultisets.class
 com/google/common/collect/SparseImmutableTable.class
 com/google/common/collect/StandardRowSortedTable$1.class
 com/google/common/collect/StandardRowSortedTable$RowSortedMap.class
 com/google/common/collect/StandardRowSortedTable.class
 com/google/common/collect/StandardTable$1.class
 com/google/common/collect/StandardTable$CellIterator.class
 com/google/common/collect/StandardTable$Column$EntrySet.class
 com/google/common/collect/StandardTable$Column$EntrySetIterator$1EntryImpl.class
 com/google/common/collect/StandardTable$Column$EntrySetIterator.class
 com/google/common/collect/StandardTable$Column$KeySet.class
 com/google/common/collect/StandardTable$Column$Values.class
 com/google/common/collect/StandardTable$Column.class
 com/google/common/collect/StandardTable$ColumnKeyIterator.class
 com/google/common/collect/StandardTable$ColumnKeySet.class
 com/google/common/collect/StandardTable$ColumnMap$ColumnMapEntrySet$1.class
 com/google/common/collect/StandardTable$ColumnMap$ColumnMapEntrySet.class
 com/google/common/collect/StandardTable$ColumnMap$ColumnMapValues.class
 com/google/common/collect/StandardTable$ColumnMap.class
 com/google/common/collect/StandardTable$Row$1.class
 com/google/common/collect/StandardTable$Row$2.class
 com/google/common/collect/StandardTable$Row.class
 com/google/common/collect/StandardTable$RowMap$EntrySet$1.class
 com/google/common/collect/StandardTable$RowMap$EntrySet.class
 com/google/common/collect/StandardTable$RowMap.class
 com/google/common/collect/StandardTable$TableSet.class
 com/google/common/collect/StandardTable.class
 com/google/common/collect/Tables$1.class
 com/google/common/collect/Tables$AbstractCell.class
 com/google/common/collect/Tables$ImmutableCell.class
 com/google/common/collect/Tables$TransformedTable$1.class
 com/google/common/collect/Tables$TransformedTable$2.class
 com/google/common/collect/Tables$TransformedTable$3.class
 com/google/common/collect/Tables$TransformedTable.class
 com/google/common/collect/Tables$TransposeTable$1.class
 com/google/common/collect/Tables$TransposeTable.class
 com/google/common/collect/Tables$UnmodifiableRowSortedMap.class
 com/google/common/collect/Tables$UnmodifiableTable.class
 com/google/common/collect/Tables.class
 com/google/common/collect/TreeBasedTable$1.class
 com/google/common/collect/TreeBasedTable$2.class
 com/google/common/collect/TreeBasedTable$Factory.class
 com/google/common/collect/TreeBasedTable$TreeRow.class
 com/google/common/collect/TreeBasedTable.class
 com/google/common/collect/TreeMultimap.class
 com/google/common/collect/TreeMultiset$1.class
 com/google/common/collect/TreeMultiset$2.class
 com/google/common/collect/TreeMultiset$3.class
 com/google/common/collect/TreeMultiset$4.class
 com/google/common/collect/TreeMultiset$Aggregate$1.class
 com/google/common/collect/TreeMultiset$Aggregate$2.class
 com/google/common/collect/TreeMultiset$Aggregate.class
 com/google/common/collect/TreeMultiset$AvlNode.class
 com/google/common/collect/TreeMultiset$Reference.class
 com/google/common/collect/TreeMultiset.class
 com/google/common/collect/TreeRangeMap$1.class
 com/google/common/collect/TreeRangeMap$AsMapOfRanges.class
 com/google/common/collect/TreeRangeMap$RangeMapEntry.class
 com/google/common/collect/TreeRangeMap$SubRangeMap$1$1.class
 com/google/common/collect/TreeRangeMap$SubRangeMap$1.class
 com/google/common/collect/TreeRangeMap$SubRangeMap$SubRangeMapAsMap$1.class
 com/google/common/collect/TreeRangeMap$SubRangeMap$SubRangeMapAsMap$2.class
 com/google/common/collect/TreeRangeMap$SubRangeMap$SubRangeMapAsMap$3.class
 com/google/common/collect/TreeRangeMap$SubRangeMap$SubRangeMapAsMap$4.class
 com/google/common/collect/TreeRangeMap$SubRangeMap$SubRangeMapAsMap.class
 com/google/common/collect/TreeRangeMap$SubRangeMap.class
 com/google/common/collect/TreeRangeMap.class
 com/google/common/collect/TreeTraverser$1.class
 com/google/common/collect/TreeTraverser$2$1.class
 com/google/common/collect/TreeTraverser$2.class
 com/google/common/collect/TreeTraverser$3$1.class
 com/google/common/collect/TreeTraverser$3.class
 com/google/common/collect/TreeTraverser$4.class
 com/google/common/collect/TreeTraverser$BreadthFirstIterator.class
 com/google/common/collect/TreeTraverser$PostOrderIterator.class
 com/google/common/collect/TreeTraverser$PostOrderNode.class
 com/google/common/collect/TreeTraverser$PreOrderIterator.class
 com/google/common/collect/TreeTraverser.class
@@ -0,0 +1,2 @@
 ch/qos/logback/core/db/**
 ch/qos/logback/classic/db/**
@@ -0,0 +1,5 @@
 org/checkerframework/**
 org/intellij/**
 com/google/errorprone/**
 com/google/thirdparty/**
 com/google/j2objc/**
@@ -11,7 +11,11 @@ simplenotes.be {
    import strict-transport
    header -Server
-    reverse_proxy http://localhost:8080
+    reverse_proxy http://localhost:8080 {
       health_path /health
       health_interval 5s
       health_timeout 200ms
   }
 }
 dev.simplenotes.be {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
hubert	195c7c10ac	Import feature	2023-05-09 22:46:07 +02:00
hubert	724fa0483e	Tailwind 3	2023-05-09 22:40:39 +02:00
hubert	f2bdc8d6c7	Update kotlin libs	2023-05-09 22:40:10 +02:00
hubert	5aa2e80c5f	JDK 19 + Gradle 8.1.1 + kotlin 1.8.21 + spotless	2023-05-09 22:39:34 +02:00
hubert	235e8b6e3c	Use gradle catalogs	2021-05-06 12:22:16 +02:00
hubert	1e0fe12396	Upgrade kotlin, kotlinx-html, gradle, shadow	2021-05-06 12:22:16 +02:00
hubert	7ad8b7039b	Update config	2021-04-12 21:15:42 +02:00
hubert	204ae7988e	Update ktorm, clean repositories and drop mariadb support	2021-04-12 18:35:21 +02:00
hubert	a4bf998c5b	Remove Boilerplate Use-case thingy	2021-03-03 16:57:53 +01:00
hubert	3e1683dfe5	Use a proper search input parser	2021-03-03 14:28:34 +01:00
hubert	51b682c593	Skip slow tests by default	2021-03-03 14:28:34 +01:00
hubert	ea110d51d3	Simplify configuration	2021-02-27 20:34:44 +01:00
hubert	f255064533	Upgrade versions, etc	2021-02-27 18:44:19 +01:00
hubert	761382da23	Fix typos	2021-02-27 18:07:22 +01:00
hubert	525e3a4a3f	Update kotlin + gradle + dependencies	2021-02-06 01:05:33 +01:00
hubert	69e50b158f	Update kotlin -> 1.4.20 & java -> 15	2020-11-29 22:22:09 +01:00
hubert	8997433974	Update dependencies	2020-11-29 22:20:40 +01:00
hubert	909fb482a8	Clean gradle build	2020-11-29 21:15:31 +01:00
hubert	90701dcdce	Refactor jwt	2020-11-11 23:48:27 +01:00
hubert	8439782430	Flatten packages Remove modules prefix	2020-11-11 23:48:27 +01:00
hubert	e6a7af840a	Fix db health check	2020-11-06 23:44:57 +01:00
hubert	568a2c6831	Move search parsing to domain layer	2020-11-06 23:44:37 +01:00
hubert	c39a20cf96	Move health check to domain layer	2020-11-05 14:44:59 +01:00
hubert	bf56314473	Move transactions to domain layer	2020-11-05 14:37:20 +01:00
hubert	11caff1634	Format	2020-11-03 18:36:09 +01:00
hubert	b1478fd154	Why ?!	2020-11-03 18:36:09 +01:00
hubert	dd174a6327	Log discarded html tags + small refactor	2020-11-03 18:36:09 +01:00
hubert	941380ad16	Load configuration with micronaut	2020-11-03 18:36:09 +01:00
hubert	4f395d254d	Merge branch 'micronaut' into master	2020-11-02 00:34:31 +01:00
hubert	6a43acfd46	Switch from koin to micronaut-inject	2020-11-02 00:33:57 +01:00
hubert	78b84dc62a	Add more persistance tests	2020-11-02 00:33:57 +01:00
hubert	1120bc9350	Add .sdkmanrc	2020-10-29 16:57:39 +01:00
hubert	a37254452b	Fix webmanifest	2020-10-28 02:58:30 +01:00
hubert	cd9fdd28e8	Gradle stuff	2020-10-28 02:01:16 +01:00
hubert	c3fc6a4e88	Clean gradle scripts	2020-10-28 00:42:51 +01:00
hubert	cb58a4fbe0	Fix lucene illegal reflective access warning	2020-10-26 22:35:27 +01:00
hubert	64059984d3	Nice	2020-10-26 22:24:56 +01:00
hubert	fdc8d34f82	Move postcss purge config to gradle	2020-10-26 22:19:15 +01:00
hubert	95ec674eb8	Fix ignored gradle wrapper jar	2020-10-26 21:18:02 +01:00
hubert	ea7be84ec3	Extract serialization plugin	2020-10-26 21:17:19 +01:00
hubert	c709f2b44d	Add ktlint plugin	2020-10-26 21:17:19 +01:00
hubert	7995a0b3e0	Change arrow core -> arrow core data	2020-10-26 21:15:59 +01:00
hubert	bfd562bc60	Add Gradle Wrapper	2020-10-26 02:10:22 +01:00
hubert	4fb85a52e4	Use Gradle !	2020-10-26 02:10:22 +01:00
hubert	e64352f54c	Fix arrow depreciations	2020-10-25 23:46:56 +01:00
hubert	c2c03e415e	Move Logback.xml	2020-10-24 01:36:51 +02:00
hubert	0260bea951	Move ConfigLoader	2020-10-24 01:36:51 +02:00
hubert	8b8dbd6fe5	Separate views into a maven module	2020-10-24 01:36:51 +02:00
hubert	536c6e7b79	Merge branch 'jigsaw' into master	2020-10-24 00:05:09 +02:00
hubert	e5a2b8993f	Remove module-infos 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	2020-10-23 23:20:58 +02:00
hubert	38750a588c	Move packages + remove circular dependencies	2020-10-23 23:20:58 +02:00
hubert	ee026ec829	Move junit config to simplenotes-test-resources	2020-10-23 16:36:44 +02:00
hubert	29b024d360	Move ArrowAssertions to simplenotes-domain	2020-10-23 16:30:43 +02:00
hubert	cd12d1561a	Move config into simplenotes-config module	2020-10-23 16:24:50 +02:00
hubert	c2eaf3d0cc	Move types into simplenotes-types module	2020-10-23 16:12:40 +02:00
hubert	4c9ac8944e	Prefix maven modules	2020-10-23 15:45:28 +02:00
hubert	4ff97044f0	Change public/private button css	2020-10-23 08:26:03 +02:00
hubert	ead1932d48	Fix some css	2020-10-23 07:16:07 +02:00
hubert	4a7dcec363	Use Json lenses	2020-10-23 06:22:44 +02:00
hubert	cb76a3253d	Use mapstruct	2020-10-21 22:55:36 +02:00
hubert	681fd635b3	Add health check	2020-10-21 16:30:42 +02:00
hubert	9467db2382	Use transactions at the http layer	2020-10-20 23:26:20 +02:00
hubert	7ed3494808	Clean pom common dependencies	2020-10-20 19:21:29 +02:00
hubert	ceb310bf02	Fix favicon extension	2020-10-20 16:10:13 +02:00
hubert	2c3106c5c1	Clean homepage html	2020-10-20 15:56:24 +02:00
hubert	4effa8231a	Change icons	2020-10-20 15:55:11 +02:00
hubert	b78420e106	Update some dependencies	2020-10-17 03:39:44 +02:00
hubert	dd08763161	We don't need that much RAM	2020-09-30 18:57:46 +02:00
hubert	e0b1514965	Unload bootstraping modules after startup	2020-09-30 18:56:52 +02:00
hubert	69c91ec86a	Proper shutdown	2020-09-30 00:18:09 +02:00
hubert	1bc45461c3	Small refactor	2020-09-30 00:10:37 +02:00
hubert	0dfb2a7e03	Add zip export	2020-09-28 19:21:53 +02:00
hubert	a7c8e63b11	Add radio input in order to select the export format	2020-09-28 18:29:07 +02:00
hubert	ad97ba029e	Fix small bug	2020-09-02 22:13:08 +02:00
		`@@ -0,0 +1 @@`
							`implementation-class=be.simplenotes.DockerPlugin`
		`@@ -0,0 +1 @@`
							`implementation-class=be.simplenotes.MicronautPlugin`
		`@@ -0,0 +1 @@`
							`implementation-class=be.simplenotes.PostcssPlugin`
		`@@ -0,0 +1,2 @@`
							`ch/qos/logback/core/db/**`
							`ch/qos/logback/classic/db/**`