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
240 changed files with 5140 additions and 5475 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
-kotlin_imports_layout = idea
+ktlint_standard_no-wildcard-imports = disabled
+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
-.mtj.tmp/
-*.class
-*.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
+# Gradle
+build/
+.gradle

 # 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
-
-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
+FROM eclipse-temurin:19-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

@@ -34,16 +12,28 @@ FROM alpine

 RUN apk add --no-cache curl

-ENV APPLICATION_USER simplenotes
-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", "-Xms64m", "-Xmx256m", "-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.
-Don't use the default values for secrets ! Every value inside *.env.dist* should be changed.
+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.
@@ -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,191 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>parent</artifactId>
-        <groupId>be.simplenotes</groupId>
-        <version>1.0-SNAPSHOT</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>app</artifactId>
-
-    <properties>
-        <http4k.version>3.268.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>
-        </dependency>
-        <dependency>
-            <groupId>org.http4k</groupId>
-            <artifactId>http4k-server-jetty</artifactId>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.eclipse.jetty.websocket</groupId>
-                    <artifactId>javax-websocket-server-impl</artifactId>
-                </exclusion>
-            </exclusions>
-        </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-json-jvm</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.ocpsoft.prettytime</groupId>
-            <artifactId>prettytime</artifactId>
-            <version>4.0.5.Final</version>
-        </dependency>
-
-        <dependency>
-            <groupId>ch.qos.logback</groupId>
-            <artifactId>logback-classic</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <scope>test</scope>
-        </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>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>me.liuwj.ktorm</groupId>
-            <artifactId>ktorm-core</artifactId>
-        </dependency>
-    </dependencies>
-
-    <dependencyManagement>
-        <dependencies>
-            <dependency>
-                <groupId>org.http4k</groupId>
-                <artifactId>http4k-bom</artifactId>
-                <version>${http4k.version}</version>
-                <type>pom</type>
-                <scope>import</scope>
-            </dependency>
-        </dependencies>
-    </dependencyManagement>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <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>
@@ -1,21 +1,27 @@
 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.shared.config.ServerConfig as SimpleNotesServerConfig
+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}:${config.port}")
+        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
+        }
+    }
+}
@@ -2,24 +2,26 @@ 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 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, jwtPayload: JwtPayload): Response {
+    fun settings(request: Request, loggedInUser: LoggedInUser): Response {
        if (request.method == Method.GET)
-            return Response(Status.OK).html(settingView.settings(jwtPayload))
+            return Response(Status.OK).html(settingView.settings(loggedInUser))

-        val deleteForm = request.deleteForm(jwtPayload)
+        val deleteForm = request.deleteForm(loggedInUser)
        val result = userService.delete(deleteForm)

        return result.fold(
@@ -28,21 +30,22 @@ class SettingsController(
                    DeleteError.Unregistered -> Response.redirect("/").invalidateCookie("Bearer")
                    DeleteError.WrongPassword -> Response(Status.OK).html(
                        settingView.settings(
-                            jwtPayload,
-                            error = "Wrong password"
-                        )
+                            loggedInUser,
+                            error = "Wrong password",
+                        ),
                    )
+
                    is DeleteError.InvalidForm -> Response(Status.OK).html(
                        settingView.settings(
-                            jwtPayload,
-                            validationErrors = it.validationErrors
-                        )
+                            loggedInUser,
+                            validationErrors = it.validationErrors,
+                        ),
                    )
                }
            },
            {
                Response.redirect("/").invalidateCookie("Bearer")
-            }
+            },
        )
    }

@@ -53,23 +56,34 @@ class SettingsController(
            .header("Content-Type", contentType)
    }

-    fun export(request: Request, jwtPayload: JwtPayload): Response {
+    fun export(request: Request, loggedInUser: LoggedInUser): Response {
        val isDownload = request.form("download") != null

        return if (isDownload) {
-            val filename = "simplenotes-export-${jwtPayload.username}"
+            val filename = "simplenotes-export-${loggedInUser.username}"
            if (request.form("format") == "zip") {
-                val zip = userService.exportAsZip(jwtPayload.userId)
+                val zip = 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(userService.exportAsJson(jwtPayload.userId))
-        } else Response(Status.OK).body(userService.exportAsJson(jwtPayload.userId)).header("Content-Type", "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(jwtPayload: JwtPayload) =
-        DeleteForm(jwtPayload.username, form("password"), form("checked") != null)
+    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.domain.security.JwtPayload
-import be.simplenotes.domain.usecases.UserService
-import be.simplenotes.domain.usecases.users.login.*
-import be.simplenotes.domain.usecases.users.register.InvalidRegisterForm
-import be.simplenotes.domain.usecases.users.register.RegisterForm
-import be.simplenotes.domain.usecases.users.register.UserExists
-import be.simplenotes.shared.config.JwtConfig
+import be.simplenotes.config.JwtConfig
+import be.simplenotes.domain.*
+import be.simplenotes.types.LoggedInUser
+import be.simplenotes.views.UserView
 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(
-                        jwtPayload,
-                        error = "User already exists"
+                    RegisterError.UserExists -> userView.register(
+                        loggedInUser,
+                        error = "User already exists",
                    )
-                    is InvalidRegisterForm ->
+                    is RegisterError.InvalidRegisterForm ->
                        userView.register(
-                            jwtPayload,
-                            validationErrors = it.validationErrors
+                            loggedInUser,
+                            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,
-                            error = "User does not exist"
+                            loggedInUser,
+                            error = "User does not exist",
                        )
-                    WrongPassword ->
+                    LoginError.WrongPassword ->
                        userView.login(
-                            jwtPayload,
-                            error = "Wrong password"
+                            loggedInUser,
+                            error = "Wrong password",
                        )
-                    is InvalidLoginForm ->
+                    is LoginError.InvalidLoginForm ->
                        userView.login(
-                            jwtPayload,
-                            validationErrors = it.validationErrors
+                            loggedInUser,
+                            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) },
+)
@@ -1,8 +1,8 @@
 package be.simplenotes.app.filters

 import be.simplenotes.app.extensions.html
-import be.simplenotes.app.views.ErrorView
-import be.simplenotes.app.views.ErrorView.Type.*
+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
@@ -10,7 +10,9 @@ 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)
@@ -3,9 +3,13 @@ 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 ->
-        next(request).header("Cache-Control", "public, max-age=31536000, immutable")
+        val res = next(request)
+        if (res.status == OK)
+            res.header("Cache-Control", "public, max-age=31536000, immutable")
+        else res
    }
 }
@@ -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
-
-class 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,31 +0,0 @@
-package be.simplenotes.app
-
-import be.simplenotes.app.extensions.addShutdownHook
-import be.simplenotes.app.modules.*
-import be.simplenotes.domain.domainModule
-import be.simplenotes.persistance.migrationModule
-import be.simplenotes.persistance.persistanceModule
-import be.simplenotes.search.searchModule
-import org.koin.core.context.startKoin
-import org.koin.core.context.unloadKoinModules
-
-fun main() {
-    startKoin {
-        modules(
-            serverModule,
-            persistanceModule,
-            migrationModule,
-            configModule,
-            baseModule,
-            userModule,
-            noteModule,
-            settingsModule,
-            domainModule,
-            searchModule,
-            apiModule,
-            jsonModule
-        )
-    }.addShutdownHook()
-
-    unloadKoinModules(listOf(migrationModule, configModule))
-}
@@ -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,12 +0,0 @@
-package be.simplenotes.app.controllers
-
-import be.simplenotes.persistance.DbHealthCheck
-import org.http4k.core.Request
-import org.http4k.core.Response
-import org.http4k.core.Status.Companion.OK
-import org.http4k.core.Status.Companion.SERVICE_UNAVAILABLE
-
-class HealthCheckController(private val dbHealthCheck: DbHealthCheck) {
-    fun healthCheck(request: Request) =
-        if (dbHealthCheck.isOk()) Response(OK) else Response(SERVICE_UNAVAILABLE)
-}
@@ -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,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,12 +0,0 @@
-package be.simplenotes.app.extensions
-
-import org.koin.core.KoinApplication
-import kotlin.concurrent.thread
-
-fun KoinApplication.addShutdownHook() {
-    Runtime.getRuntime().addShutdownHook(
-        thread(start = false) {
-            close()
-        }
-    )
-}
@@ -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,58 +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,
-) : Filter {
-    override fun invoke(next: HttpHandler): HttpHandler = {
-        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,13 +0,0 @@
-package be.simplenotes.app.filters
-
-import me.liuwj.ktorm.database.Database
-import org.http4k.core.Filter
-import org.http4k.core.HttpHandler
-
-class TransactionFilter(private val db: Database) : Filter {
-    override fun invoke(next: HttpHandler): HttpHandler = { request ->
-        db.useTransaction {
-            next(request)
-        }
-    }
-}
@@ -1,24 +0,0 @@
-package be.simplenotes.app.modules
-
-import be.simplenotes.app.api.ApiNoteController
-import be.simplenotes.app.api.ApiUserController
-import be.simplenotes.app.filters.AuthFilter
-import be.simplenotes.app.filters.AuthType
-import be.simplenotes.app.filters.JwtSource
-import org.http4k.core.Filter
-import org.koin.core.qualifier.named
-import org.koin.dsl.module
-
-val apiModule = module {
-    single { ApiUserController(get(), get()) }
-    single { ApiNoteController(get(), get()) }
-    single<Filter>(named("apiAuthFilter")) {
-        AuthFilter(
-            extractor = get(),
-            authType = AuthType.Required,
-            ctx = get(),
-            source = JwtSource.Header,
-            redirect = false
-        )
-    }
-}
@@ -1,11 +0,0 @@
-package be.simplenotes.app.modules
-
-import be.simplenotes.app.Config
-import org.koin.dsl.module
-
-val configModule = module {
-    single { Config() }
-    single { get<Config>().dataSourceConfig }
-    single { get<Config>().jwtConfig }
-    single { get<Config>().serverConfig }
-}
@@ -1,29 +0,0 @@
-package be.simplenotes.app.modules
-
-import be.simplenotes.app.controllers.*
-import be.simplenotes.app.views.BaseView
-import be.simplenotes.app.views.NoteView
-import be.simplenotes.app.views.SettingView
-import be.simplenotes.app.views.UserView
-import org.koin.dsl.module
-
-val userModule = module {
-    single { UserController(get(), get(), get()) }
-    single { UserView(get()) }
-}
-
-val baseModule = module {
-    single { HealthCheckController(get()) }
-    single { BaseController(get()) }
-    single { BaseView(get()) }
-}
-
-val noteModule = module {
-    single { NoteController(get(), get()) }
-    single { NoteView(get()) }
-}
-
-val settingsModule = module {
-    single { SettingsController(get(), get()) }
-    single { SettingView(get()) }
-}
@@ -1,63 +0,0 @@
-package be.simplenotes.app.modules
-
-import be.simplenotes.app.Server
-import be.simplenotes.app.filters.AuthFilter
-import be.simplenotes.app.filters.AuthType
-import be.simplenotes.app.filters.ErrorFilter
-import be.simplenotes.app.filters.TransactionFilter
-import be.simplenotes.app.routes.Router
-import be.simplenotes.app.utils.StaticFileResolver
-import be.simplenotes.app.utils.StaticFileResolverImpl
-import be.simplenotes.app.views.ErrorView
-import be.simplenotes.shared.config.ServerConfig
-import org.eclipse.jetty.server.ServerConnector
-import org.http4k.core.Filter
-import org.http4k.core.RequestContexts
-import org.http4k.routing.RoutingHttpHandler
-import org.http4k.server.ConnectorBuilder
-import org.http4k.server.Jetty
-import org.http4k.server.asServer
-import org.koin.core.qualifier.named
-import org.koin.core.qualifier.qualifier
-import org.koin.dsl.module
-import org.koin.dsl.onClose
-import org.http4k.server.ServerConfig as Http4kServerConfig
-
-val serverModule = module {
-    single(createdAtStart = true) { Server(get(), get()).start() } onClose { it?.stop() }
-    single { get<RoutingHttpHandler>().asServer(get()) }
-    single<Http4kServerConfig> {
-        val config = get<ServerConfig>()
-        val builder: ConnectorBuilder = { server: org.eclipse.jetty.server.Server ->
-            ServerConnector(server).apply {
-                port = config.port
-                host = config.host
-            }
-        }
-        Jetty(config.port, builder)
-    }
-    single<StaticFileResolver> { StaticFileResolverImpl(get()) }
-    single {
-        Router(
-            get(),
-            get(),
-            get(),
-            get(),
-            get(),
-            get(),
-            get(),
-            requiredAuth = get(AuthType.Required.qualifier),
-            optionalAuth = get(AuthType.Optional.qualifier),
-            apiAuth = get(named("apiAuthFilter")),
-            get(),
-            get(),
-            get(),
-        )()
-    }
-    single { RequestContexts() }
-    single<Filter>(AuthType.Optional.qualifier) { AuthFilter(get(), AuthType.Optional, get()) }
-    single<Filter>(AuthType.Required.qualifier) { AuthFilter(get(), AuthType.Required, get()) }
-    single { ErrorFilter(get()) }
-    single { TransactionFilter(get()) }
-    single { ErrorView(get()) }
-}
@@ -1,106 +0,0 @@
-package be.simplenotes.app.routes
-
-import be.simplenotes.app.api.ApiNoteController
-import be.simplenotes.app.api.ApiUserController
-import be.simplenotes.app.controllers.*
-import be.simplenotes.app.filters.*
-import be.simplenotes.domain.security.JwtPayload
-import org.http4k.core.*
-import org.http4k.core.Method.*
-import org.http4k.filter.ResponseFilters.GZip
-import org.http4k.filter.ServerFilters.InitialiseRequestContext
-import org.http4k.routing.*
-import org.http4k.routing.ResourceLoader.Companion.Classpath
-
-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 healthCheckController: HealthCheckController,
-    private val requiredAuth: Filter,
-    private val optionalAuth: Filter,
-    private val apiAuth: Filter,
-    private val errorFilter: ErrorFilter,
-    private val transactionFilter: TransactionFilter,
-    private val contexts: RequestContexts,
-) {
-    operator fun invoke(): RoutingHttpHandler {
-
-        val basicRoutes =
-            routes(
-                "/health" bind GET to healthCheckController::healthCheck,
-                ImmutableFilter.then(static(Classpath("/static"), "woff2" to ContentType("font/woff2")))
-            )
-
-        val publicRoutes = routes(
-            "/" bind GET public baseController::index,
-            "/register" bind GET public userController::register,
-            "/register" bind POST `public transactional` 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 transactional 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 transactional noteController::new,
-            "/notes/trash" bind GET protected noteController::trash,
-            "/notes/{uuid}" bind GET protected noteController::note,
-            "/notes/{uuid}" bind POST transactional noteController::note,
-            "/notes/{uuid}/edit" bind GET protected noteController::edit,
-            "/notes/{uuid}/edit" bind POST transactional noteController::edit,
-            "/notes/deleted/{uuid}" bind POST transactional 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 transactional apiNoteController::createNote,
-            "/api/notes/search" bind POST transactional apiNoteController::search,
-            "/api/notes/{uuid}" bind GET protected apiNoteController::note,
-            "/api/notes/{uuid}" bind PUT transactional 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(GZip())
-
-        return globalFilters.then(routes)
-    }
-
-    private inline infix fun PathMethod.public(crossinline handler: PublicHandler) =
-        this to { handler(it, it.jwtPayload(contexts)) }
-
-    private inline infix fun PathMethod.protected(crossinline handler: ProtectedHandler) =
-        this to { handler(it, it.jwtPayload(contexts)!!) }
-
-    private inline infix fun PathMethod.transactional(crossinline handler: ProtectedHandler) =
-        this to transactionFilter.then { handler(it, it.jwtPayload(contexts)!!) }
-
-    private inline infix fun PathMethod.`public transactional`(crossinline handler: PublicHandler) =
-        this to transactionFilter.then { handler(it, it.jwtPayload(contexts)) }
-}
-
-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,105 +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 flex justify-around") {
-
-                form(method = FormMethod.post, action = "/export") {
-                    button(name = "display",
-                        classes = "inline btn btn-teal block",
-                        type = submit) { +"Display my data" }
-                }
-
-                form(method = FormMethod.post, action = "/export") {
-
-                    listOf("json", "zip").forEach { format ->
-                        div {
-                            radioInput(name = "format") {
-                                id = format
-                                attributes["value"] = format
-                                if(format == "json") attributes["checked"] = ""
-                            }
-                            label(classes = "ml-2") {
-                                attributes["for"] = format
-                                +format
-                            }
-                        }
-                    }
-
-                    button(name = "download", classes = "inline btn btn-green block 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()
+}
@@ -2,21 +2,20 @@ 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 org.koin.dsl.module
 import java.time.LocalDateTime
 import java.util.*
+import jakarta.inject.Singleton

-val jsonModule = module {
-    single {
-        Json {
+@Factory
+class JsonModule {
+
+    @Singleton
+    fun json() = Json {
        prettyPrint = true
-            serializersModule = get()
-        }
-    }
-    single {
-        SerializersModule {
+        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,
+            ),
+        )
+    }
+}
@@ -17,6 +17,6 @@ internal class LocalDateTimeSerializer : KSerializer<LocalDateTime> {
    }

    override fun deserialize(decoder: Decoder): LocalDateTime {
-        TODO("Not implemented, isn't needed")
+        return LocalDateTime.parse(decoder.decodeString())
    }
 }
@@ -10,7 +10,7 @@ import java.util.*

 internal class UuidSerializer : KSerializer<UUID> {
    override val descriptor: SerialDescriptor
-        get() = PrimitiveSerialDescriptor("LocalDateTime", PrimitiveKind.STRING)
+        get() = PrimitiveSerialDescriptor("UUID", PrimitiveKind.STRING)

    override fun serialize(encoder: Encoder, value: UUID) {
        encoder.encodeString(value.toString())
@@ -3,11 +3,13 @@ package be.simplenotes.app.utils
 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?
 }

+@Singleton
 class StaticFileResolverImpl(json: Json) : StaticFileResolver {
    private val mappings: Map<String, String>

@@ -1,15 +1,24 @@
 package be.simplenotes.app.filters

-import be.simplenotes.domain.security.JwtPayload
-import be.simplenotes.domain.security.JwtPayloadExtractor
+import be.simplenotes.app.filters.auth.OptionalAuthFilter
+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 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 simpleJwt = SimpleJwt(jwtConfig, UserJwtMapper())

-    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),
-            "/protected" bind GET to requiredAuth.then(echoJwtPayloadHandler)
-        )
+            "/optional" bind GET to optionalAuth.then { request: Request ->
+                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"`() {
-            val jwtPayload = JwtPayload(1, "user")
+        fun `it should allow a valid token`() {
+            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/**
@@ -0,0 +1,14 @@
+import be.simplenotes.micronaut
+
+plugins {
+    id("be.simplenotes.base")
+    id("be.simplenotes.micronaut")
+}
+
+dependencies {
+    micronaut()
+    runtimeOnly(libs.yaml)
+
+    testImplementation(libs.bundles.test)
+    testRuntimeOnly(libs.slf4j.logback)
+}
--- 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
				`@@ -0,0 +1 @@`
				`implementation-class=be.simplenotes.DockerPlugin`
				`@@ -0,0 +1 @@`
				`implementation-class=be.simplenotes.MicronautPlugin`
				`@@ -0,0 +1 @@`
				`implementation-class=be.simplenotes.PostcssPlugin`