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

.env.dist

@@ -6,4 +6,5 @@ MYSQL_ROOT_PASSWORD=
 #
 ## can be generated with `openssl rand -base64 32`
 MYSQL_PASSWORD=
-PASSWORD=${MYSQL_PASSWORD}
+# password should be the same as mysql_password
+PASSWORD=

.gitignore

@@ -125,11 +125,14 @@ data/
 letsencrypt/
 
 # generated resources
-app/src/main/resources/css-manifest.json
+simplenotes-app/src/main/resources/css-manifest.json
-app/src/main/resources/static/styles*
+simplenotes-app/src/main/resources/static/styles*
 
 # h2 db
 *.db
 
 # lucene index
 .lucene/
+
+# python
+__pycache__

Dockerfile

@@ -4,19 +4,23 @@ WORKDIR /tmp
 
 # Cache dependencies
 COPY pom.xml .
-COPY app/pom.xml app/pom.xml
+COPY simplenotes-test-resources/pom.xml simplenotes-test-resources/pom.xml
-COPY domain/pom.xml domain/pom.xml
+COPY simplenotes-types/pom.xml simplenotes-types/pom.xml
-COPY persistance/pom.xml persistance/pom.xml
+COPY simplenotes-config/pom.xml simplenotes-config/pom.xml
-COPY shared/pom.xml shared/pom.xml
+COPY simplenotes-persistance/pom.xml simplenotes-persistance/pom.xml
-COPY search/pom.xml search/pom.xml
+COPY simplenotes-search/pom.xml simplenotes-search/pom.xml
+COPY simplenotes-domain/pom.xml simplenotes-domain/pom.xml
+COPY simplenotes-app/pom.xml simplenotes-app/pom.xml
 
 RUN mvn verify clean --fail-never
 
-COPY app/src app/src
+COPY simplenotes-test-resources/src simplenotes-test-resources/src
-COPY domain/src domain/src
+COPY simplenotes-types/src simplenotes-types/src
-COPY persistance/src persistance/src
+COPY simplenotes-config/src simplenotes-config/src
-COPY shared/src shared/src
+COPY simplenotes-persistance/src simplenotes-persistance/src
-COPY search/src search/src
+COPY simplenotes-search/src simplenotes-search/src
+COPY simplenotes-domain/src simplenotes-domain/src
+COPY simplenotes-app/src simplenotes-app/src
 
 RUN mvn -Dstyle.color=always package
 
@@ -32,6 +36,8 @@ RUN strip -p --strip-unneeded /myjdk/lib/server/libjvm.so
 
 FROM alpine
 
+RUN apk add --no-cache curl
+
 ENV APPLICATION_USER simplenotes
 RUN adduser -D -g '' $APPLICATION_USER
 
@@ -40,8 +46,8 @@ RUN chown -R $APPLICATION_USER /app
 
 USER $APPLICATION_USER
 
-COPY --from=builder /tmp/app/target/app-*.jar /app/app.jar
+COPY --from=builder /tmp/simplenotes-app/target/simplenotes-app-*.jar /app/simplenotes.jar
 COPY --from=jdkbuilder /myjdk /myjdk
 WORKDIR /app
 
-CMD ["/myjdk/bin/java", "-server", "-XX:+UnlockExperimentalVMOptions", "-Xms256m", "-Xmx1g", "-XX:+UseG1GC", "-XX:MaxGCPauseMillis=100", "-XX:+UseStringDeduplication", "-jar", "app.jar"]
+CMD ["/myjdk/bin/java", "-server", "-XX:+UnlockExperimentalVMOptions", "-Xms64m", "-Xmx256m", "-XX:+UseG1GC", "-XX:MaxGCPauseMillis=100", "-XX:+UseStringDeduplication", "-jar", "simplenotes.jar"]

README.md

@@ -0,0 +1,19 @@
+# SimpleNotes, a simple markdown note taking website
+
+## Requirements
+
+- Docker
+- docker-compose
+
+## How to run
+
+- Copy the docker-compose.yml somewhere
+- In the same directory, copy the *.env.dist* file and rename it to *.env*
+- Edit the variables inside *.env* (see below)
+- Run it with `docker-compose up -d`
+
+## 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.

app/src/main/kotlin/Server.kt

@@ -1,32 +0,0 @@
-package be.simplenotes.app
-
-import org.eclipse.jetty.server.Server
-import org.eclipse.jetty.server.ServerConnector
-import org.http4k.routing.RoutingHttpHandler
-import org.http4k.server.ConnectorBuilder
-import org.http4k.server.Jetty
-import org.http4k.server.ServerConfig
-import org.http4k.server.asServer
-import org.slf4j.LoggerFactory
-import be.simplenotes.shared.config.ServerConfig as SimpleNotesServeConfig
-
-class Server(
-    private val config: SimpleNotesServeConfig,
-    private val serverConfig: ServerConfig,
-    private val router: RoutingHttpHandler,
-) {
-    fun start() {
-        router.asServer(serverConfig).start()
-        LoggerFactory.getLogger(javaClass).info("Listening on http://${config.host}:${config.port}")
-    }
-}
-
-fun serverConfig(config: SimpleNotesServeConfig): ServerConfig {
-    val builder: ConnectorBuilder = { server: Server ->
-        ServerConnector(server).apply {
-            port = config.port
-            host = config.host
-        }
-    }
-    return Jetty(config.port, builder)
-}

app/src/main/kotlin/SimpleNotes.kt

@@ -1,109 +0,0 @@
-package be.simplenotes.app
-
-import be.simplenotes.app.controllers.BaseController
-import be.simplenotes.app.controllers.NoteController
-import be.simplenotes.app.controllers.SettingsController
-import be.simplenotes.app.controllers.UserController
-import be.simplenotes.app.filters.AuthFilter
-import be.simplenotes.app.filters.AuthType
-import be.simplenotes.app.filters.ErrorFilter
-import be.simplenotes.app.routes.Router
-import be.simplenotes.app.utils.StaticFileResolver
-import be.simplenotes.app.utils.StaticFileResolverImpl
-import be.simplenotes.app.views.*
-import be.simplenotes.domain.domainModule
-import be.simplenotes.domain.usecases.NoteService
-import be.simplenotes.persistance.DbMigrations
-import be.simplenotes.persistance.persistanceModule
-import be.simplenotes.search.searchModule
-import be.simplenotes.shared.config.DataSourceConfig
-import be.simplenotes.shared.config.JwtConfig
-import org.http4k.core.RequestContexts
-import org.koin.core.context.startKoin
-import org.koin.core.qualifier.named
-import org.koin.core.qualifier.qualifier
-import org.koin.dsl.module
-import org.slf4j.LoggerFactory
-import be.simplenotes.shared.config.ServerConfig as SimpleNotesServeConfig
-
-fun main() {
-    val koin = startKoin {
-        modules(
-            persistanceModule,
-            configModule,
-            domainModule,
-            serverModule,
-            userModule,
-            baseModule,
-            noteModule,
-            settingsModule,
-            searchModule,
-        )
-    }.koin
-
-    val dataSourceConfig = koin.get<DataSourceConfig>()
-    val jwtConfig = koin.get<JwtConfig>()
-    val serverConfig = koin.get<SimpleNotesServeConfig>()
-    val logger = LoggerFactory.getLogger("SimpleNotes")
-    logger.info("datasource: $dataSourceConfig")
-    logger.info("jwt: $jwtConfig")
-    logger.info("server: $serverConfig")
-
-    val migrations = koin.get<DbMigrations>()
-    migrations.migrate()
-
-    val noteService = koin.get<NoteService>()
-    noteService.dropAllIndexes()
-    noteService.indexAll()
-
-    koin.get<Server>().start()
-}
-
-val serverModule = module {
-    single { Server(get(), get(), get()) }
-    single<StaticFileResolver> { StaticFileResolverImpl() }
-    single {
-        Router(
-            get(),
-            get(),
-            get(),
-            get(),
-            requiredAuth = get(AuthType.Required.qualifier),
-            optionalAuth = get(AuthType.Optional.qualifier),
-            errorFilter = get(named("ErrorFilter")),
-            get()
-        )()
-    }
-    single { serverConfig(get()) }
-    single { RequestContexts() }
-    single(AuthType.Optional.qualifier) { AuthFilter(get(), AuthType.Optional, get())() }
-    single(AuthType.Required.qualifier) { AuthFilter(get(), AuthType.Required, get())() }
-    single(named("ErrorFilter")) { ErrorFilter(get())() }
-    single { ErrorView(get()) }
-}
-
-val userModule = module {
-    single { UserController(get(), get(), get()) }
-    single { UserView(get()) }
-}
-
-val baseModule = module {
-    single { BaseController(get()) }
-    single { BaseView(get()) }
-}
-
-val noteModule = module {
-    single { NoteController(get(), get()) }
-    single { NoteView(get()) }
-}
-
-val settingsModule = module {
-    single { SettingsController(get(), get()) }
-    single { SettingView(get()) }
-}
-
-val configModule = module {
-    single { Config.dataSourceConfig }
-    single { Config.jwtConfig }
-    single { Config.serverConfig }
-}

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

@@ -1,15 +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.Companion.redirect(url: String, permanent: Boolean = false) =
-    Response(if (permanent) MOVED_PERMANENTLY else FOUND).header("Location", url)
-
-fun Request.isSecure() = header("X-Forwarded-Proto")?.contains("https") ?: false

app/src/main/kotlin/filters/AuthFilter.kt

@@ -1,42 +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.Filter
-import org.http4k.core.Request
-import org.http4k.core.RequestContexts
-import org.http4k.core.Response
-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
-) {
-    operator fun invoke() = Filter { next ->
-        {
-            val jwtPayload = it.bearerToken()?.let { token -> extractor(token) }
-            when {
-                jwtPayload != null -> {
-                    ctx[it][authKey] = jwtPayload
-                    next(it)
-                }
-                authType == AuthType.Required -> Response.redirect("/login")
-                else -> next(it)
-            }
-        }
-    }
-}
-
-fun Request.jwtPayload(ctx: RequestContexts): JwtPayload? = ctx[this][authKey]
-
-private fun Request.bearerToken(): String? = cookie("Bearer")
-    ?.value
-    ?.trim()

app/src/main/kotlin/filters/ErrorFilter.kt

@@ -1,33 +0,0 @@
-package be.simplenotes.app.filters
-
-import be.simplenotes.app.extensions.html
-import be.simplenotes.app.views.ErrorView
-import org.http4k.core.*
-import org.slf4j.LoggerFactory
-import java.sql.SQLTransientException
-
-class ErrorFilter(private val errorView: ErrorView) {
-
-    private val logger = LoggerFactory.getLogger(javaClass)
-
-    operator fun invoke(): Filter = Filter { next ->
-        {
-            try {
-                val response = next(it)
-                if (response.status == Status.NOT_FOUND) Response(Status.NOT_FOUND)
-                    .html(errorView.error(ErrorView.Type.NotFound))
-                else response
-            } catch (e: Exception) {
-                logger.error(e.stackTraceToString())
-                if (e is SQLTransientException)
-                    Response(Status.SERVICE_UNAVAILABLE).html(errorView.error(ErrorView.Type.SqlTransientError))
-                        .noCache()
-                else
-                    Response(Status.INTERNAL_SERVER_ERROR).html(errorView.error(ErrorView.Type.Other)).noCache()
-            } catch (e: NotImplementedError) {
-                logger.error(e.stackTraceToString())
-                Response(Status.NOT_IMPLEMENTED).html(errorView.error(ErrorView.Type.Other)).noCache()
-            }
-        }
-    }
-}

app/src/main/kotlin/filters/ImmutableFilter.kt

@@ -1,19 +0,0 @@
-package be.simplenotes.app.filters
-
-import org.http4k.core.Filter
-import org.http4k.core.HttpHandler
-import org.http4k.core.Method
-import org.http4k.core.Request
-
-object ImmutableFilter {
-    operator fun invoke(): Filter {
-        return Filter { next: HttpHandler ->
-            { request: Request ->
-                val response = next(request)
-                if (request.method == Method.GET)
-                    response.header("Cache-Control", "public, max-age=31536000, immutable")
-                else response
-            }
-        }
-    }
-}

app/src/main/kotlin/filters/SecurityFilter.kt

@@ -1,20 +0,0 @@
-package be.simplenotes.app.filters
-
-import org.http4k.core.Filter
-import org.http4k.core.HttpHandler
-import org.http4k.core.Request
-
-object SecurityFilter {
-    operator fun invoke() = Filter { next: HttpHandler ->
-        { request: Request ->
-            val response = next(request)
-                .header("X-Content-Type-Options", "nosniff")
-
-            if (response.header("Content-Type")?.contains("text/html") == true) {
-                response
-                    .header("Content-Security-Policy", "default-src 'self'")
-                    .header("Referrer-Policy", "no-referrer")
-            } else response
-        }
-    }
-}

app/src/main/kotlin/routes/Router.kt

@@ -1,79 +0,0 @@
-package be.simplenotes.app.routes
-
-import be.simplenotes.app.controllers.BaseController
-import be.simplenotes.app.controllers.NoteController
-import be.simplenotes.app.controllers.SettingsController
-import be.simplenotes.app.controllers.UserController
-import be.simplenotes.app.filters.ImmutableFilter
-import be.simplenotes.app.filters.SecurityFilter
-import be.simplenotes.app.filters.jwtPayload
-import be.simplenotes.domain.security.JwtPayload
-import org.http4k.core.*
-import org.http4k.core.Method.GET
-import org.http4k.core.Method.POST
-import org.http4k.filter.ResponseFilters
-import org.http4k.filter.ServerFilters.InitialiseRequestContext
-import org.http4k.routing.*
-
-class Router(
-    private val baseController: BaseController,
-    private val userController: UserController,
-    private val noteController: NoteController,
-    private val settingsController: SettingsController,
-    private val requiredAuth: Filter,
-    private val optionalAuth: Filter,
-    private val errorFilter: Filter,
-    private val contexts: RequestContexts,
-) {
-    operator fun invoke(): RoutingHttpHandler {
-
-        val resourceLoader = ResourceLoader.Classpath(("/static"))
-        val basicRoutes = routes(
-            ImmutableFilter().then(static(resourceLoader, "woff2" to ContentType("font/woff2"))),
-        )
-
-        infix fun PathMethod.public(handler: PublicHandler) = this to { handler(it, it.jwtPayload(contexts)) }
-        infix fun PathMethod.protected(handler: ProtectedHandler) = this to { handler(it, it.jwtPayload(contexts)!!) }
-
-        val publicRoutes: RoutingHttpHandler = routes(
-            "/" bind GET public baseController::index,
-            "/register" bind GET public userController::register,
-            "/register" bind POST public userController::register,
-            "/login" bind GET public userController::login,
-            "/login" bind POST public userController::login,
-            "/logout" bind POST to userController::logout,
-        )
-
-        val protectedRoutes = routes(
-            "/settings" bind GET protected settingsController::settings,
-            "/settings" bind POST protected settingsController::settings,
-            "/export" bind POST protected settingsController::export,
-            "/notes" bind GET protected noteController::list,
-            "/notes" bind POST protected noteController::search,
-            "/notes/new" bind GET protected noteController::new,
-            "/notes/new" bind POST protected noteController::new,
-            "/notes/trash" bind GET protected noteController::trash,
-            "/notes/{uuid}" bind GET protected noteController::note,
-            "/notes/{uuid}" bind POST protected noteController::note,
-            "/notes/{uuid}/edit" bind GET protected noteController::edit,
-            "/notes/{uuid}/edit" bind POST protected noteController::edit,
-            "/notes/deleted/{uuid}" bind POST protected noteController::deleted,
-        )
-
-        val routes = routes(
-            basicRoutes,
-            optionalAuth.then(publicRoutes),
-            requiredAuth.then(protectedRoutes),
-        )
-
-        val globalFilters = errorFilter
-            .then(InitialiseRequestContext(contexts))
-            .then(SecurityFilter())
-            .then(ResponseFilters.GZip())
-
-        return globalFilters.then(routes)
-    }
-}
-
-private typealias PublicHandler = (Request, JwtPayload?) -> Response
-private typealias ProtectedHandler = (Request, JwtPayload) -> Response

app/src/main/kotlin/views/BaseView.kt

@@ -1,115 +0,0 @@
-package be.simplenotes.app.views
-
-import be.simplenotes.app.utils.StaticFileResolver
-import be.simplenotes.domain.security.JwtPayload
-import kotlinx.html.*
-import kotlinx.html.div
-import org.intellij.lang.annotations.Language
-
-class BaseView(staticFileResolver: StaticFileResolver) : View(staticFileResolver) {
-    fun renderHome(jwtPayload: JwtPayload?) = renderPage(
-        title = "Home",
-        description = "A fast and simple note taking website",
-        jwtPayload = jwtPayload
-    ) {
-        section("text-center my-2 p-2") {
-            h1("text-5xl casual") {
-                span("text-teal-300") { +"Simplenotes " }
-                +"- access your notes anywhere"
-            }
-        }
-
-        div("container mx-auto flex flex-wrap justify-center content-center") {
-
-            unsafe {
-                @Language("html")
-                val html =
-                    """
-                    <div aria-label="demo" class="md:order-1 order-2 flipped p-4 my-10 w-full md:w-1/2">
-                        <div class="flex justify-between mb-4">
-                          <h1 class="text-2xl underline">Notes</h1>
-                            <span>
-                            <span class="btn btn-teal pointer-events-none">Trash (3)</span>
-                            <span class="ml-2 btn btn-green pointer-events-none">New</span>
-                            </span>
-                        </div>
-                        <form class="md:space-x-2" id="search">
-                        <input aria-label="demo-search" name="search" disabled="" value="tag:&quot;demo&quot;">
-                        <span id="buttons">
-                        <button type="button" disabled="" class="btn btn-green pointer-events-none">search</button>
-                        <span class="btn btn-red pointer-events-none">clear</span>
-                        </span>
-                        </form>
-                        <div class="overflow-x-auto">
-                          <table id="notes">
-                            <thead>
-                              <tr>
-                                <th scope="col" class="w-1/2">Title</th>
-                                <th scope="col" class="w-1/4">Updated</th>
-                                <th scope="col" class="w-1/4">Tags</th>
-                              </tr>
-                            </thead>
-                            <tbody>
-                              <tr>
-                                <td><span class="text-blue-200 font-semibold underline">Formula 1</span></td>
-                                <td class="text-center">moments ago</td>
-                                <td>
-                                  <ul class="inline flex flex-wrap justify-center">
-                                    <li class="mx-2 my-1"><span class="tag disabled">#demo</span ></li>
-                                  </ul>
-                                </td>
-                              </tr>
-                              <tr>
-                                <td><span class="text-blue-200 font-semibold underline">Syntax highlighting</span></td>
-                                <td class="text-center">2 hours ago</td>
-                                <td>
-                                  <ul class="inline flex flex-wrap justify-center">
-                                    <li class="mx-2 my-1"><span class="tag disabled">#features</span></li>
-                                    <li class="mx-2 my-1"><span class="tag disabled">#demo</span></li>
-                                  </ul>
-                                </td>
-                              </tr>
-                              <tr>
-                                <td><span class="text-blue-200 font-semibold underline">report</span></td>
-                                <td class="text-center">5 days ago</td>
-                                <td>
-                                  <ul class="inline flex flex-wrap justify-center">
-                                    <li class="mx-2 my-1"><span class="tag disabled">#study</span></li>
-                                    <li class="mx-2 my-1"><span class="tag disabled">#demo</span></li>
-                                  </ul>
-                                </td>
-                              </tr>
-                            </tbody>
-                          </table>
-                        </div>
-                    </div>
-                    """.trimIndent()
-
-                +html
-            }
-
-            welcome()
-        }
-    }
-
-    @Suppress("NOTHING_TO_INLINE")
-    private inline fun DIV.welcome() {
-        div("w-full my-auto md:w-1/2 md:order-2 order-1 text-center") {
-            div("m-4 rounded-lg p-6") {
-                p("text-teal-400") {
-                    h2("text-3xl text-teal-400 underline") { +"Features:" }
-                    ul("list-disc text-lg list-inside") {
-                        li { +"Markdown support" }
-                        li { +"Full text search" }
-                        li { +"Structured search" }
-                        li { +"Code highlighting" }
-                        li { +"Fast and lightweight" }
-                        li { +"No tracking" }
-                        li { +"Works without javascript" }
-                        li { +"Data export" }
-                    }
-                }
-            }
-        }
-    }
-}

app/src/test/kotlin/Empty.kt

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

caddy/Caddyfile

@@ -11,7 +11,11 @@ simplenotes.be {
     import strict-transport
     header -Server
 
-    reverse_proxy http://localhost:8080
+    reverse_proxy http://localhost:8080 {
+       health_path /health
+       health_interval 5s
+       health_timeout 200ms
+   }
 }
 
 dev.simplenotes.be {

cli/Config.py

@@ -0,0 +1,38 @@
+import configparser
+import os
+from pathlib import Path
+
+import appdirs
+import click
+
+
+class Config:
+    def __init__(self):
+        config_dir: str = appdirs.user_config_dir("SimpleNotesCli")
+        Path(config_dir).mkdir(exist_ok=True)
+        self.file = os.path.join(config_dir, "config.ini")
+        self.configparser = configparser.ConfigParser()
+
+        self.token = None
+        self.base_url = None
+
+    def load(self):
+        self.configparser.read(self.file)
+        self.token = self.configparser.get("DEFAULT", "token", fallback=None)
+        self.base_url = self.configparser.get(
+            "DEFAULT", "base_url", fallback="https://simplenotes.be"
+        )
+
+    def save(self):
+        if self.token:
+            self.configparser.set("DEFAULT", "token", self.token)
+
+        if self.base_url:
+            self.configparser.set("DEFAULT", "base_url", self.base_url)
+
+        try:
+            with open(self.file, "w") as f:
+                self.configparser.write(f)
+        except IOError:
+            click.secho("An error occurred while saving config", fg="red", err=True)
+            exit(1)

cli/SimpleNotesApi.py

@@ -0,0 +1,66 @@
+from typing import List, Optional
+
+import click
+import requests
+from requests.models import Response
+
+from domain import NoteMetadata
+
+
+class SimplenotesApi:
+    def __init__(self, base_url: str):
+        self.base_url = base_url
+        self.s = requests.Session()
+        self.s.hooks["response"] = [self.__exit_unauthorized]
+
+    def __url(self, path: str) -> str:
+        return f"{self.base_url}{path}"
+
+    def __exit_unauthorized(self, response: Response, *args, **kwargs):
+        if response.status_code == 401:
+            click.secho("Unauthorized, please login again", fg="red", err=True)
+            exit(1)
+
+    def login(self, username: str, password: str) -> Optional[str]:
+        url = self.__url("/api/login")
+        r = self.s.post(
+            url,
+            json={"username": username, "password": password},
+        )
+        if r.status_code == 200:
+            return r.json()["token"]
+
+    def set_token(self, token: str):
+        self.s.headers.update({"Authorization": f"Bearer {token}"})
+
+    def find_note(self, uuid: str) -> Optional[str]:
+        url = self.__url(f"/api/notes/{uuid}")
+        r = self.s.get(url)
+        if r.status_code == 200:
+            return r.json()["markdown"]
+
+    def list_notes(self) -> List[NoteMetadata]:
+        url = self.__url("/api/notes")
+        r = self.s.get(url)
+        return list(map(lambda x: NoteMetadata(**x), r.json()))
+
+    def search_notes(self, query: str) -> List[NoteMetadata]:
+        url = self.__url("/api/notes/search")
+        r = self.s.post(url, json={"query": query})
+
+        if r.status_code == 200:
+            j = r.json()
+            return list(map(lambda x: NoteMetadata(**x), j))
+        else:
+            return []
+
+    def create_note(self, content: str) -> Optional[str]:
+        url = self.__url("/api/notes/")
+        r = self.s.post(url, json={"content": content})
+        if r.status_code == 200:
+            return r.json()["uuid"]
+
+    def update_note(self, uuid: str, content: str) -> bool:
+        url = self.__url(f"/api/notes/{uuid}")
+        r = self.s.put(url, json={"content": content})
+        return r.status_code == 200

cli/SimpleNotesCli.py

@@ -0,0 +1,112 @@
+import click
+from click import Context
+
+import SimpleNotesApi
+import utils
+from Config import Config
+from jwtutils import is_expired
+from utils import edit_md
+
+api: SimpleNotesApi
+base_url: str
+conf = Config()
+
+
+@click.group()
+@click.pass_context
+def cli(ctx: Context):
+    global base_url
+    global api
+
+    conf.load()
+    base_url = conf.base_url
+    api = SimpleNotesApi.SimplenotesApi(base_url)
+
+    if ctx.invoked_subcommand == "login" or ctx.invoked_subcommand == "config":
+        return
+
+    token = conf.token
+    if token is None:
+        click.secho("Please login", err=True, fg="red")
+        exit(1)
+    elif is_expired(token):
+        click.secho("Login expired, please login again", err=True, fg="red")
+        exit(1)
+    else:
+        api.set_token(token)
+
+
+@cli.command()
+@click.option("--username", prompt=True)
+@click.option("--password", prompt=True, hide_input=True)
+def login(username: str, password: str):
+    token = api.login(username, password)
+    if token:
+        conf.token = token
+        conf.save()
+        click.secho(f"Welcome {username}", fg="green")
+    else:
+        click.echo("Invalid credentials")
+        exit(1)
+
+
+@cli.command()
+@click.option("--url", prompt=True)
+def config(url: str):
+    conf.base_url = url
+    conf.save()
+
+
+@cli.command(name="list")
+def list_notes():
+    utils.print_notes(api.list_notes())
+
+
+@cli.command()
+@click.argument("uuid")
+def edit(uuid: str):
+    note = api.find_note(uuid)
+    if not note:
+        click.secho("Note not found", err=True, fg="red")
+        exit(1)
+
+    edited = edit_md(note)
+
+    if edited == note:
+        exit(1)
+
+    if not api.update_note(uuid, edited):
+        click.secho("An error occurred", err=True, fg="red")
+        exit(1)
+    else:
+        utils.print_note_url(uuid, "updated", conf.base_url)
+
+
+@cli.command()
+def new():
+    placeholder = "---\ntitle: ''\ntags: []\n---\n"
+    md = edit_md(placeholder)
+    if md == placeholder:
+        exit(1)
+    uuid = api.create_note(md)
+    if uuid:
+        utils.print_note_url(uuid, "created", conf.base_url)
+    else:
+        click.secho("An error occurred", err=True, fg="red")
+        exit(1)
+
+
+@cli.command(name="search")
+@click.argument("search", nargs=-1, required=True)
+def search_notes(search: str):
+    query = " ".join(search)
+    notes = api.search_notes(query)
+
+    if not notes:
+        print("No match")
+    else:
+        utils.print_notes(notes)
+
+
+if __name__ == "__main__":
+    cli()

cli/domain.py

@@ -0,0 +1,12 @@
+from typing import List
+
+
+class NoteMetadata:
+    def __init__(self, uuid: str, title: str, tags: List[str], updatedAt: str):
+        self.uuid = uuid
+        self.title = title
+        self.tags = tags
+        self.updated_at = updatedAt
+
+    def __str__(self) -> str:
+        return f"NoteMetadata(uuid={self.uuid}, title={self.title}, tags={self.tags})"

cli/jwtutils.py

@@ -0,0 +1,10 @@
+from datetime import datetime
+
+import jwt
+
+
+def is_expired(token: str) -> bool:
+    exp = jwt.decode(token, verify=False)["exp"]
+    dt = datetime.utcfromtimestamp(exp)
+    now = datetime.utcnow()
+    return dt < now

cli/requirements.txt

@@ -0,0 +1,6 @@
+requests==2.24.0
+python-editor==1.0.4
+click==7.1.2
+PyJWT==1.7.1
+appdirs==1.4.4
+tabulate==0.8.7

cli/utils.py

@@ -0,0 +1,32 @@
+from typing import List
+
+import editor
+import click
+from tabulate import tabulate
+
+from domain import NoteMetadata
+
+
+def edit_md(content: str = "") -> str:
+    b = bytes(content, "utf-8")
+    result = editor.edit(contents=b, suffix=".md")
+    return result.decode("utf-8")
+
+
+def print_notes(notes: List[NoteMetadata]):
+    data = []
+    for n in notes:
+        uuid = click.style(n.uuid, fg="blue")
+        title = click.style(n.title, fg="green", bold=True)
+        tags = ["#" + e for e in n.tags]
+        tags = " ".join(tags)
+        data.append([uuid, title, tags])
+
+    headers = ["UUID", "title", "tags"]
+    click.echo(tabulate(data, headers=headers))
+
+
+def print_note_url(uuid: str, action: str, base_url: str):
+    url = f"{base_url}/notes/{uuid}"
+    s = click.style(url, fg="green", underline=True)
+    click.echo(f"Note {action}: {s}")

css/package.json

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

css/tailwind.config.js

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

deploy-docker-hub.sh

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

docker-compose.yml

@@ -19,8 +19,10 @@ services:
         volumes:
             - notes-db-volume:/var/lib/mysql
         healthcheck:
-            test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost"]
+            test: "mysql --protocol=tcp -u simplenotes -p$MYSQL_PASSWORD -e 'show databases'"
-            timeout: 10s
+            interval: 5s
+            timeout: 1s
+            start_period: 2s
             retries: 10
 
     simplenotes:
@@ -39,6 +41,12 @@ services:
             # - PASSWORD
         ports:
             - 127.0.0.1:8080:8080
+        healthcheck:
+            test: "curl --fail -s http://localhost:8080/health"
+            interval: 5s
+            timeout: 1s
+            start_period: 2s
+            retries: 3
         depends_on:
             db:
                 condition: service_healthy

domain/pom.xml

@@ -1,66 +0,0 @@
-<project>
-    <parent>
-        <artifactId>parent</artifactId>
-        <groupId>be.simplenotes</groupId>
-        <version>1.0-SNAPSHOT</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>domain</artifactId>
-
-    <dependencies>
-        <dependency>
-            <groupId>be.simplenotes</groupId>
-            <artifactId>shared</artifactId>
-            <version>1.0-SNAPSHOT</version>
-        </dependency>
-        <dependency>
-            <groupId>be.simplenotes</groupId>
-            <artifactId>shared</artifactId>
-            <version>1.0-SNAPSHOT</version>
-            <type>test-jar</type>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>io.konform</groupId>
-            <artifactId>konform-jvm</artifactId>
-            <version>0.2.0</version>
-        </dependency>
-        <dependency>
-            <groupId>org.mindrot</groupId>
-            <artifactId>jbcrypt</artifactId>
-            <version>0.4</version>
-        </dependency>
-        <dependency>
-            <groupId>com.auth0</groupId>
-            <artifactId>java-jwt</artifactId>
-            <version>3.10.3</version>
-        </dependency>
-        <dependency>
-            <groupId>com.vladsch.flexmark</groupId>
-            <artifactId>flexmark</artifactId>
-            <version>0.62.2</version>
-        </dependency>
-        <dependency>
-            <groupId>com.vladsch.flexmark</groupId>
-            <artifactId>flexmark-ext-gfm-tasklist</artifactId>
-            <version>0.62.2</version>
-        </dependency>
-        <dependency>
-            <groupId>org.yaml</groupId>
-            <artifactId>snakeyaml</artifactId>
-            <version>1.26</version>
-        </dependency>
-        <dependency>
-            <groupId>com.googlecode.owasp-java-html-sanitizer</groupId>
-            <artifactId>owasp-java-html-sanitizer</artifactId>
-            <version>20200713.1</version>
-        </dependency>
-        <dependency>
-            <groupId>org.jetbrains.kotlinx</groupId>
-            <artifactId>kotlinx-serialization-runtime</artifactId>
-        </dependency>
-    </dependencies>
-
-</project>

domain/src/main/kotlin/usecases/export/ExportUseCase.kt

@@ -1,5 +0,0 @@
-package be.simplenotes.domain.usecases.export
-
-interface ExportUseCase {
-    fun export(userId: Int): String
-}

domain/src/main/kotlin/usecases/export/ExportUseCaseImpl.kt

@@ -1,43 +0,0 @@
-package be.simplenotes.domain.usecases.export
-
-import be.simplenotes.domain.model.ExportedNote
-import be.simplenotes.domain.usecases.repositories.NoteRepository
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.ListSerializer
-import kotlinx.serialization.descriptors.PrimitiveKind
-import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.modules.SerializersModule
-import java.time.LocalDateTime
-
-internal class ExportUseCaseImpl(private val noteRepository: NoteRepository) : ExportUseCase {
-    override fun export(userId: Int): String {
-        val module = SerializersModule {
-            contextual(LocalDateTime::class, LocalDateTimeSerializer)
-        }
-
-        val json = Json {
-            prettyPrint = true
-            serializersModule = module
-        }
-
-        val notes = noteRepository.export(userId)
-        return json.encodeToString(ListSerializer(ExportedNote.serializer()), notes)
-    }
-}
-
-internal object LocalDateTimeSerializer : KSerializer<LocalDateTime> {
-    override val descriptor: SerialDescriptor
-        get() = PrimitiveSerialDescriptor("LocalDateTime", PrimitiveKind.STRING)
-
-    override fun serialize(encoder: Encoder, value: LocalDateTime) {
-        encoder.encodeString(value.toString())
-    }
-
-    override fun deserialize(decoder: Decoder): LocalDateTime {
-        TODO("Not implemented, isn't needed")
-    }
-}

domain/src/test/kotlin/Empty.kt

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

persistance/src/main/kotlin/DbMigrationsImpl.kt

@@ -1,24 +0,0 @@
-package be.simplenotes.persistance
-
-import be.simplenotes.shared.config.DataSourceConfig
-import org.flywaydb.core.Flyway
-import javax.sql.DataSource
-
-internal class DbMigrationsImpl(
-    private val dataSource: DataSource,
-    private val dataSourceConfig: DataSourceConfig
-) : DbMigrations {
-    override fun migrate() {
-
-        val migrationDir = when {
-            dataSourceConfig.jdbcUrl.contains("mariadb") -> "db/migration/mariadb"
-            else -> "db/migration/other"
-        }
-
-        Flyway.configure()
-            .dataSource(dataSource)
-            .locations(migrationDir)
-            .load()
-            .migrate()
-    }
-}

persistance/src/main/kotlin/PersistanceModule.kt

@@ -1,36 +0,0 @@
-package be.simplenotes.persistance
-
-import be.simplenotes.domain.usecases.repositories.NoteRepository
-import be.simplenotes.domain.usecases.repositories.UserRepository
-import be.simplenotes.persistance.notes.NoteRepositoryImpl
-import be.simplenotes.persistance.users.UserRepositoryImpl
-import be.simplenotes.shared.config.DataSourceConfig
-import com.zaxxer.hikari.HikariConfig
-import com.zaxxer.hikari.HikariDataSource
-import me.liuwj.ktorm.database.*
-import org.koin.dsl.module
-import javax.sql.DataSource
-
-interface DbMigrations {
-    fun migrate()
-}
-
-private fun hikariDataSource(conf: DataSourceConfig): HikariDataSource {
-    val hikariConfig = HikariConfig().also {
-        it.jdbcUrl = conf.jdbcUrl
-        it.driverClassName = conf.driverClassName
-        it.username = conf.username
-        it.password = conf.password
-        it.maximumPoolSize = conf.maximumPoolSize
-        it.connectionTimeout = conf.connectionTimeout
-    }
-    return HikariDataSource(hikariConfig)
-}
-
-val persistanceModule = module {
-    single<UserRepository> { UserRepositoryImpl(get()) }
-    single<NoteRepository> { NoteRepositoryImpl(get()) }
-    single<DbMigrations> { DbMigrationsImpl(get(), get()) }
-    single<DataSource> { hikariDataSource(get()) }
-    single { Database.connect(get<DataSource>()) }
-}

persistance/src/main/kotlin/users/UserRepositoryImpl.kt

@@ -1,32 +0,0 @@
-package be.simplenotes.persistance.users
-
-import be.simplenotes.domain.model.PersistedUser
-import be.simplenotes.domain.model.User
-import be.simplenotes.domain.usecases.repositories.UserRepository
-import me.liuwj.ktorm.database.*
-import me.liuwj.ktorm.dsl.*
-import me.liuwj.ktorm.entity.*
-import java.sql.SQLIntegrityConstraintViolationException
-
-internal class UserRepositoryImpl(private val db: Database) : UserRepository {
-    override fun create(user: User): PersistedUser? {
-        return try {
-            db.useTransaction {
-                val id = db.insertAndGenerateKey(Users) {
-                    it.username to user.username
-                    it.password to user.password
-                } as Int
-                PersistedUser(user.username, user.password, id)
-            }
-        } catch (e: SQLIntegrityConstraintViolationException) {
-            null
-        }
-    }
-
-    override fun find(username: String) = db.users.find { it.username eq username }?.toPersistedUser()
-    override fun find(id: Int) = db.users.find { it.id eq id }?.toPersistedUser()
-    override fun exists(username: String) = db.users.any { it.username eq username }
-    override fun exists(id: Int) = db.users.any { it.id eq id }
-    override fun delete(id: Int) = db.useTransaction { db.delete(Users) { it.id eq id } == 1 }
-    override fun findAll() = db.from(Users).select(Users.id).map { it[Users.id]!! }
-}

persistance/src/test/kotlin/Empty.kt

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

pom.xml

@@ -1,23 +1,27 @@
-<project>
+<?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">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>be.simplenotes</groupId>
-    <artifactId>parent</artifactId>
+    <artifactId>simplenotes-parent</artifactId>
     <version>1.0-SNAPSHOT</version>
 
     <modules>
-        <module>persistance</module>
+        <module>simplenotes-persistance</module>
-        <module>app</module>
+        <module>simplenotes-app</module>
-        <module>domain</module>
+        <module>simplenotes-domain</module>
-        <module>shared</module>
+        <module>simplenotes-search</module>
-        <module>search</module>
+        <module>simplenotes-types</module>
+        <module>simplenotes-config</module>
+        <module>simplenotes-test-resources</module>
     </modules>
 
     <packaging>pom</packaging>
 
     <properties>
         <java.version>14</java.version>
-        <kotlin.version>1.4.0</kotlin.version>
+        <kotlin.version>1.4.10</kotlin.version>
         <junit.version>5.6.2</junit.version>
 
         <kotlin.code.style>official</kotlin.code.style>
@@ -27,6 +31,8 @@
         <maven.compiler.source>${java.version}</maven.compiler.source>
         <maven.compiler.target>${java.version}</maven.compiler.target>
         <kotlin.compiler.jvmTarget>${java.version}</kotlin.compiler.jvmTarget>
+
+        <org.mapstruct.version>1.4.1.Final</org.mapstruct.version>
     </properties>
 
     <dependencies>
@@ -35,101 +41,83 @@
             <artifactId>kotlin-stdlib-jdk8</artifactId>
             <version>${kotlin.version}</version>
         </dependency>
-        <dependency>
-            <groupId>org.koin</groupId>
-            <artifactId>koin-core</artifactId>
-            <version>2.1.6</version>
-        </dependency>
-        <dependency>
-            <groupId>ch.qos.logback</groupId>
-            <artifactId>logback-classic</artifactId>
-            <version>1.2.3</version>
-        </dependency>
-        <dependency>
-            <groupId>io.arrow-kt</groupId>
-            <artifactId>arrow-core</artifactId>
-            <version>0.10.5</version>
-        </dependency>
-
-        <!-- region tests -->
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <version>${junit.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-params</artifactId>
-            <version>${junit.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.jetbrains.kotlin</groupId>
-            <artifactId>kotlin-test-junit</artifactId>
-            <version>${kotlin.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.mockk</groupId>
-            <artifactId>mockk</artifactId>
-            <version>1.10.0</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.koin</groupId>
-            <artifactId>koin-test</artifactId>
-            <version>2.1.6</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.natpryce</groupId>
-            <artifactId>hamkrest</artifactId>
-            <version>1.7.0.3</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <version>3.16.1</version>
-            <scope>test</scope>
-        </dependency>
-        <!-- endregion -->
-
     </dependencies>
 
     <build>
         <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
         <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
 
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-jar-plugin</artifactId>
+                    <version>3.2.0</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-shade-plugin</artifactId>
+                    <version>3.2.4</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-surefire-plugin</artifactId>
+                    <version>3.0.0-M5</version>
+                    <dependencies>
+                        <dependency>
+                            <groupId>org.apache.maven.surefire</groupId>
+                            <artifactId>surefire-junit-platform</artifactId>
+                            <version>3.0.0-M5</version>
+                        </dependency>
+                    </dependencies>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+
         <plugins>
+
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-surefire-plugin</artifactId>
+                <artifactId>maven-enforcer-plugin</artifactId>
-                <version>3.0.0-M4</version>
+                <version>3.0.0-M3</version>
-                <dependencies>
+                <executions>
-                    <dependency>
+                    <execution>
-                        <groupId>org.apache.maven.surefire</groupId>
+                        <id>enforce</id>
-                        <artifactId>surefire-junit-platform</artifactId>
+                        <goals>
-                        <version>3.0.0-M4</version>
+                            <goal>enforce</goal>
-                    </dependency>
+                        </goals>
-                </dependencies>
+                        <configuration>
-            </plugin>
+                            <rules>
-            <plugin>
+                                <banDuplicatePomDependencyVersions/>
-                <groupId>org.apache.maven.plugins</groupId>
+                                <requireMavenVersion>
-                <artifactId>maven-compiler-plugin</artifactId>
+                                    <version>3.6</version>
-                <version>3.8.1</version>
+                                </requireMavenVersion>
-            </plugin>
+                            </rules>
-            <plugin>
+                        </configuration>
-                <groupId>org.apache.maven.plugins</groupId>
+                    </execution>
-                <artifactId>maven-dependency-plugin</artifactId>
+                </executions>
-                <version>3.1.2</version>
             </plugin>
+
             <plugin>
                 <artifactId>kotlin-maven-plugin</artifactId>
                 <groupId>org.jetbrains.kotlin</groupId>
                 <version>${kotlin.version}</version>
                 <executions>
+                    <execution>
+                        <id>kapt</id>
+                        <goals>
+                            <goal>kapt</goal>
+                        </goals>
+                        <configuration>
+                            <annotationProcessorPaths>
+                                <annotationProcessorPath>
+                                    <groupId>org.mapstruct</groupId>
+                                    <artifactId>mapstruct-processor</artifactId>
+                                    <version>${org.mapstruct.version}</version>
+                                </annotationProcessorPath>
+                            </annotationProcessorPaths>
+                        </configuration>
+                    </execution>
                     <execution>
                         <id>compile</id>
                         <phase>process-sources</phase>
@@ -165,39 +153,81 @@
         </plugins>
     </build>
 
-
     <dependencyManagement>
         <dependencies>
             <dependency>
                 <groupId>org.jetbrains.kotlin</groupId>
-                <artifactId>kotlin-stdlib-jdk8</artifactId>
+                <artifactId>kotlin-bom</artifactId>
-                <version>${kotlin.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>org.jetbrains.kotlin</groupId>
-                <artifactId>kotlin-stdlib-jdk7</artifactId>
-                <version>${kotlin.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>org.jetbrains.kotlin</groupId>
-                <artifactId>kotlin-stdlib-common</artifactId>
-                <version>${kotlin.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>org.jetbrains.kotlin</groupId>
-                <artifactId>kotlin-stdlib</artifactId>
-                <version>${kotlin.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>org.jetbrains.kotlin</groupId>
-                <artifactId>kotlin-reflect</artifactId>
                 <version>${kotlin.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
             </dependency>
             <dependency>
                 <groupId>org.jetbrains.kotlinx</groupId>
-                <artifactId>kotlinx-serialization-runtime</artifactId>
+                <artifactId>kotlinx-serialization-json-jvm</artifactId>
-                <version>1.0-M1-1.4.0-rc</version>
+                <version>1.0.0</version>
             </dependency>
+
+            <dependency>
+                <groupId>org.koin</groupId>
+                <artifactId>koin-core</artifactId>
+                <version>2.1.6</version>
+            </dependency>
+            <dependency>
+                <groupId>ch.qos.logback</groupId>
+                <artifactId>logback-classic</artifactId>
+                <version>1.2.3</version>
+            </dependency>
+            <dependency>
+                <groupId>io.arrow-kt</groupId>
+                <artifactId>arrow-core</artifactId>
+                <version>0.11.0</version>
+            </dependency>
+            <dependency>
+                <groupId>org.slf4j</groupId>
+                <artifactId>slf4j-api</artifactId>
+                <version>1.7.25</version>
+            </dependency>
+
+            <dependency>
+                <groupId>me.liuwj.ktorm</groupId>
+                <artifactId>ktorm-core</artifactId>
+                <version>3.0.0</version>
+            </dependency>
+            <dependency>
+                <groupId>me.liuwj.ktorm</groupId>
+                <artifactId>ktorm-support-mysql</artifactId>
+                <version>3.0.0</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.mapstruct</groupId>
+                <artifactId>mapstruct</artifactId>
+                <version>${org.mapstruct.version}</version>
+            </dependency>
+
+            <!-- region tests -->
+            <dependency>
+                <groupId>org.junit.jupiter</groupId>
+                <artifactId>junit-jupiter</artifactId>
+                <version>${junit.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>io.mockk</groupId>
+                <artifactId>mockk</artifactId>
+                <version>1.10.0</version>
+            </dependency>
+            <dependency>
+                <groupId>com.natpryce</groupId>
+                <artifactId>hamkrest</artifactId>
+                <version>1.7.0.3</version>
+            </dependency>
+            <dependency>
+                <groupId>org.assertj</groupId>
+                <artifactId>assertj-core</artifactId>
+                <version>3.16.1</version>
+            </dependency>
+            <!-- endregion -->
         </dependencies>
     </dependencyManagement>
 

shared/src/test/kotlin/Empty.kt

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

simplenotes-app/pom.xml

@@ -1,48 +1,70 @@
-<project>
+<?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>
+        <artifactId>simplenotes-parent</artifactId>
         <groupId>be.simplenotes</groupId>
         <version>1.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>app</artifactId>
+    <artifactId>simplenotes-app</artifactId>
 
     <properties>
-        <http4k.version>3.258.0</http4k.version>
+        <http4k.version>3.268.0</http4k.version>
     </properties>
 
     <dependencies>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>persistance</artifactId>
+            <artifactId>simplenotes-persistance</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>search</artifactId>
+            <artifactId>simplenotes-search</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>domain</artifactId>
+            <artifactId>simplenotes-domain</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>be.simplenotes</groupId>
-            <artifactId>shared</artifactId>
+            <artifactId>simplenotes-config</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>org.http4k</groupId>
             <artifactId>http4k-core</artifactId>
-            <version>${http4k.version}</version>
         </dependency>
+
+        <!--
         <dependency>
             <groupId>org.http4k</groupId>
             <artifactId>http4k-server-jetty</artifactId>
-            <version>${http4k.version}</version>
         </dependency>
+        -->
+        <dependency>
+            <groupId>org.eclipse.jetty</groupId>
+            <artifactId>jetty-server</artifactId>
+            <version>9.4.32.v20200930</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.eclipse.jetty</groupId>
+            <artifactId>jetty-servlet</artifactId>
+            <version>9.4.32.v20200930</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>javax.servlet-api</artifactId>
+            <version>4.0.1</version>
+            <scope>compile</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.jetbrains.kotlinx</groupId>
             <artifactId>kotlinx-html-jvm</artifactId>
@@ -50,7 +72,7 @@
         </dependency>
         <dependency>
             <groupId>org.jetbrains.kotlinx</groupId>
-            <artifactId>kotlinx-serialization-runtime</artifactId>
+            <artifactId>kotlinx-serialization-json-jvm</artifactId>
         </dependency>
         <dependency>
             <groupId>org.ocpsoft.prettytime</groupId>
@@ -58,9 +80,24 @@
             <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>
+            <artifactId>simplenotes-test-resources</artifactId>
             <version>1.0-SNAPSHOT</version>
             <type>test-jar</type>
             <scope>test</scope>
@@ -68,17 +105,32 @@
         <dependency>
             <groupId>org.http4k</groupId>
             <artifactId>http4k-testing-hamkrest</artifactId>
-            <version>${http4k.version}</version>
             <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>
-                <version>3.2.4</version>
                 <executions>
                     <execution>
                         <phase>package</phase>

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

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

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

@@ -0,0 +1,23 @@
+package be.simplenotes.app
+
+import org.http4k.server.Http4kServer
+import org.slf4j.LoggerFactory
+import be.simplenotes.config.ServerConfig as SimpleNotesServerConfig
+
+class Server(
+    private val config: SimpleNotesServerConfig,
+    private val http4kServer: Http4kServer,
+) {
+    private val logger = LoggerFactory.getLogger(javaClass)
+
+    fun start(): Server {
+        http4kServer.start()
+        logger.info("Listening on http://${config.host}:${config.port}")
+        return this
+    }
+
+    fun stop() {
+        logger.info("Stopping server")
+        http4kServer.close()
+    }
+}

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

@@ -0,0 +1,31 @@
+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))
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+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)
+}

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

@@ -68,15 +68,28 @@ class NoteController(
     fun note(request: Request, jwtPayload: JwtPayload): Response {
         val noteUuid = request.uuidPath() ?: return Response(NOT_FOUND)
 
-        if (request.method == Method.POST && request.form("delete") != null) {
+        if (request.method == Method.POST) {
-            return if (noteService.trash(jwtPayload.userId, noteUuid))
+            if (request.form("delete") != null) {
-                Response.redirect("/notes") // TODO: flash cookie to show success ?
+                return if (noteService.trash(jwtPayload.userId, noteUuid))
-            else
+                    Response.redirect("/notes") // TODO: flash cookie to show success ?
-                Response(NOT_FOUND) // TODO: show an error
+                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))
+        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 {

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

@@ -7,10 +7,7 @@ import be.simplenotes.domain.security.JwtPayload
 import be.simplenotes.domain.usecases.UserService
 import be.simplenotes.domain.usecases.users.delete.DeleteError
 import be.simplenotes.domain.usecases.users.delete.DeleteForm
-import org.http4k.core.Method
+import org.http4k.core.*
-import org.http4k.core.Request
-import org.http4k.core.Response
-import org.http4k.core.Status
 import org.http4k.core.body.form
 import org.http4k.core.cookie.invalidateCookie
 
@@ -44,23 +41,34 @@ class SettingsController(
                 }
             },
             {
-                Response.redirect("/").invalidateCookie("Authorization")
+                Response.redirect("/").invalidateCookie("Bearer")
             }
         )
     }
 
-    fun export(request: Request, jwtPayload: JwtPayload): Response {
+    private fun attachment(filename: String, contentType: String) = { response: Response ->
-        val isDownload = request.form("download") != null
+        val name = filename.replace("[^a-zA-Z0-9-_.]".toRegex(), "_")
-        val json = userService.export(jwtPayload.userId)
+        response
-        val res = Response(Status.OK).body(json).header("Content-Type", "application/json")
+            .header("Content-Disposition", "attachment; filename=\"$name\"")
-        return if (isDownload) res.header(
+            .header("Content-Type", contentType)
-            "Content-Disposition",
-            "attachment; filename=\"simplenotes-export-${sanitizeFilename(jwtPayload.username)}.json\""
-        )
-        else res
     }
 
-    private fun sanitizeFilename(inputName: String): String = inputName.replace("[^a-zA-Z0-9-_.]".toRegex(), "_")
+    fun export(request: Request, jwtPayload: JwtPayload): Response {
+        val isDownload = request.form("download") != null
+
+        return if (isDownload) {
+            val filename = "simplenotes-export-${jwtPayload.username}"
+            if (request.form("format") == "zip") {
+                val zip = userService.exportAsZip(jwtPayload.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")
+    }
 
     private fun Request.deleteForm(jwtPayload: JwtPayload) =
         DeleteForm(jwtPayload.username, form("password"), form("checked") != null)

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

@@ -10,7 +10,7 @@ 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 org.http4k.core.Method.GET
 import org.http4k.core.Request
 import org.http4k.core.Response

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

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

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

@@ -0,0 +1,12 @@
+package be.simplenotes.app.extensions
+
+import org.koin.core.KoinApplication
+import kotlin.concurrent.thread
+
+fun KoinApplication.addShutdownHook() {
+    Runtime.getRuntime().addShutdownHook(
+        thread(start = false) {
+            close()
+        }
+    )
+}

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

@@ -0,0 +1,58 @@
+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()

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

@@ -0,0 +1,45 @@
+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 org.http4k.core.*
+import org.http4k.core.Status.Companion.INTERNAL_SERVER_ERROR
+import org.http4k.core.Status.Companion.NOT_FOUND
+import org.http4k.core.Status.Companion.NOT_IMPLEMENTED
+import org.http4k.core.Status.Companion.SERVICE_UNAVAILABLE
+import org.slf4j.LoggerFactory
+import java.sql.SQLTransientException
+
+class ErrorFilter(private val errorView: ErrorView) : Filter {
+
+    private val logger = LoggerFactory.getLogger(javaClass)
+
+    private fun errorResponse(status: Status): Response {
+        val type = when (status) {
+            SERVICE_UNAVAILABLE -> SqlTransientError
+            NOT_FOUND -> NotFound
+            NOT_IMPLEMENTED -> Other
+            else -> Other
+        }
+
+        return Response(status).html(errorView.error(type)).noCache()
+    }
+
+    override fun invoke(next: HttpHandler): HttpHandler = { request ->
+        try {
+            val response = next(request)
+            if (response.status == NOT_FOUND) errorResponse(NOT_FOUND)
+            else response
+        } catch (e: SQLTransientException) {
+            logger.error(e.stackTraceToString())
+            errorResponse(SERVICE_UNAVAILABLE)
+        } catch (e: Exception) {
+            logger.error(e.stackTraceToString())
+            errorResponse(INTERNAL_SERVER_ERROR)
+        } catch (e: NotImplementedError) {
+            logger.error(e.stackTraceToString())
+            errorResponse(NOT_IMPLEMENTED)
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+package be.simplenotes.app.filters
+
+import org.http4k.core.Filter
+import org.http4k.core.HttpHandler
+import org.http4k.core.Request
+
+object ImmutableFilter : Filter {
+    override fun invoke(next: HttpHandler) = { request: Request ->
+        next(request).header("Cache-Control", "public, max-age=31536000, immutable")
+    }
+}

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

@@ -0,0 +1,18 @@
+package be.simplenotes.app.filters
+
+import org.http4k.core.Filter
+import org.http4k.core.HttpHandler
+import org.http4k.core.Request
+
+object SecurityFilter : Filter {
+    override fun invoke(next: HttpHandler): HttpHandler = { request: Request ->
+        val response = next(request)
+            .header("X-Content-Type-Options", "nosniff")
+
+        if (response.header("Content-Type")?.contains("text/html") == true) {
+            response
+                .header("Content-Security-Policy", "default-src 'self'")
+                .header("Referrer-Policy", "no-referrer")
+        } else response
+    }
+}

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

@@ -0,0 +1,13 @@
+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)
+        }
+    }
+}

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

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

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

@@ -0,0 +1,24 @@
+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
+        )
+    }
+}

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

@@ -0,0 +1,11 @@
+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 }
+}

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

@@ -0,0 +1,29 @@
+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()) }
+}

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

@@ -0,0 +1,24 @@
+package be.simplenotes.app.modules
+
+import be.simplenotes.app.serialization.LocalDateTimeSerializer
+import be.simplenotes.app.serialization.UuidSerializer
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.modules.SerializersModule
+import org.koin.dsl.module
+import java.time.LocalDateTime
+import java.util.*
+
+val jsonModule = module {
+    single {
+        Json {
+            prettyPrint = true
+            serializersModule = get()
+        }
+    }
+    single {
+        SerializersModule {
+            contextual(LocalDateTime::class, LocalDateTimeSerializer())
+            contextual(UUID::class, UuidSerializer())
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+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.jetty.ConnectorBuilder
+import be.simplenotes.app.jetty.Jetty
+import be.simplenotes.app.routes.Router
+import be.simplenotes.app.utils.StaticFileResolver
+import be.simplenotes.app.utils.StaticFileResolverImpl
+import be.simplenotes.app.views.ErrorView
+import be.simplenotes.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.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()) }
+}

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

@@ -0,0 +1,106 @@
+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

simplenotes-app/src/main/kotlin/be/simplenotes/app/serialization/LocaleDateTimeSerializer.kt

@@ -0,0 +1,22 @@
+package be.simplenotes.app.serialization
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import java.time.LocalDateTime
+
+internal class LocalDateTimeSerializer : KSerializer<LocalDateTime> {
+    override val descriptor: SerialDescriptor
+        get() = PrimitiveSerialDescriptor("LocalDateTime", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: LocalDateTime) {
+        encoder.encodeString(value.toString())
+    }
+
+    override fun deserialize(decoder: Decoder): LocalDateTime {
+        TODO("Not implemented, isn't needed")
+    }
+}

simplenotes-app/src/main/kotlin/be/simplenotes/app/serialization/UuidSerializer.kt

@@ -0,0 +1,22 @@
+package be.simplenotes.app.serialization
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import java.util.*
+
+internal class UuidSerializer : KSerializer<UUID> {
+    override val descriptor: SerialDescriptor
+        get() = PrimitiveSerialDescriptor("LocalDateTime", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: UUID) {
+        encoder.encodeString(value.toString())
+    }
+
+    override fun deserialize(decoder: Decoder): UUID {
+        TODO()
+    }
+}

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

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

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

@@ -1,16 +1,17 @@
 package be.simplenotes.app.utils
 
-import kotlinx.serialization.json.*
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
 
 interface StaticFileResolver {
     fun resolve(name: String): String?
 }
 
-class StaticFileResolverImpl : StaticFileResolver {
+class StaticFileResolverImpl(json: Json) : StaticFileResolver {
     private val mappings: Map<String, String>
 
     init {
-        val json = Json {}
         val manifest = javaClass.getResource("/css-manifest.json").readText()
         val manifestObject = json.parseToJsonElement(manifest).jsonObject
         val keys = manifestObject.keys

simplenotes-app/src/main/kotlin/be/simplenotes/app/views/BaseView.kt

@@ -0,0 +1,108 @@
+package be.simplenotes.app.views
+
+import be.simplenotes.app.utils.StaticFileResolver
+import be.simplenotes.domain.security.JwtPayload
+import kotlinx.html.*
+import kotlinx.html.ThScope.col
+
+class BaseView(staticFileResolver: StaticFileResolver) : View(staticFileResolver) {
+    fun renderHome(jwtPayload: JwtPayload?) = renderPage(
+        title = "Home",
+        description = "A fast and simple note taking website",
+        jwtPayload = jwtPayload
+    ) {
+        section("text-center my-2 p-2") {
+            h1("text-5xl casual") {
+                span("text-teal-300") { +"SimpleNotes " }
+                +"- access your notes anywhere"
+            }
+        }
+
+        div("container mx-auto flex flex-wrap justify-center content-center") {
+
+            div("md:order-1 order-2 flipped p-4 my-10 w-full md:w-1/2") {
+                attributes["aria-label"] = "demo"
+                div("flex justify-between mb-4") {
+                    h1("text-2xl underline") { +"Notes" }
+                    span {
+                        span("btn btn-teal pointer-events-none") { +"Trash (3)" }
+                        span("ml-2 btn btn-green pointer-events-none") { +"New" }
+                    }
+                }
+                form(classes = "md:space-x-2") {
+                    id = "search"
+                    input {
+                        attributes["aria-label"] = "demo-search"
+                        attributes["name"] = "search"
+                        attributes["disabled"] = ""
+                        attributes["value"] = "tag:\"demo\""
+                    }
+                    span {
+                        id = "buttons"
+                        button(type = ButtonType.button, classes = "btn btn-green pointer-events-none") {
+                            attributes["disabled"] = ""
+                            +"search"
+                        }
+                        span("btn btn-red pointer-events-none") { +"clear" }
+                    }
+                }
+                div("overflow-x-auto") {
+                    demoTable()
+                }
+            }
+            welcome()
+        }
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun DIV.demoTable() {
+        table {
+            id = "notes"
+            thead {
+                tr {
+                    th(scope = col, classes = "w-1/2") { +"Title" }
+                    th(scope = col, classes = "w-1/4") { +"Updated" }
+                    th(scope = col, classes = "w-1/4") { +"Tags" }
+                }
+            }
+            tbody {
+                listOf(
+                    Triple("Formula 1", "moments ago", arrayOf("#demo")),
+                    Triple("Syntax highlighting", "2 hours ago", arrayOf("#features", "#demo")),
+                    Triple("report", "5 days ago", arrayOf("#study", "#demo")),
+                ).forEach { (title, ago, tags) ->
+                    tr {
+                        td { span("text-blue-200 font-semibold underline") { +title } }
+                        td("text-center") { +ago }
+                        td {
+                            ul("inline flex flex-wrap justify-center") {
+                                tags.forEach { tag ->
+                                    li("mx-2 my-1") { span("tag disabled") { +tag } }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun DIV.welcome() {
+        div("w-full my-auto md:w-1/2 md:order-2 order-1 text-center") {
+            div("m-4 rounded-lg p-6") {
+                h2("text-3xl text-teal-400 underline") { +"Features:" }
+                ul("list-disc text-lg list-inside") {
+                    li { +"Markdown support" }
+                    li { +"Full text search" }
+                    li { +"Structured search" }
+                    li { +"Code highlighting" }
+                    li { +"Fast and lightweight" }
+                    li { +"No tracking" }
+                    li { +"Works without javascript" }
+                    li { +"Data export" }
+                }
+            }
+        }
+    }
+}

simplenotes-app/src/main/kotlin/be/simplenotes/app/views/NoteView.kt

@@ -2,8 +2,8 @@ package be.simplenotes.app.views
 
 import be.simplenotes.app.utils.StaticFileResolver
 import be.simplenotes.app.views.components.*
-import be.simplenotes.domain.model.PersistedNote
+import be.simplenotes.types.PersistedNote
-import be.simplenotes.domain.model.PersistedNoteMetadata
+import be.simplenotes.types.PersistedNoteMetadata
 import be.simplenotes.domain.security.JwtPayload
 import io.konform.validation.ValidationError
 import kotlinx.html.*
@@ -116,12 +116,21 @@ class NoteView(staticFileResolver: StaticFileResolver) : View(staticFileResolver
         }
     }
 
-    fun renderedNote(jwtPayload: JwtPayload, note: PersistedNote) = renderPage(
+    fun renderedNote(jwtPayload: JwtPayload?, note: PersistedNote, shared: Boolean) = renderPage(
         note.meta.title,
         jwtPayload = jwtPayload,
         scripts = listOf("/highlight.10.1.2.js", "/init-highlight.0.0.1.js")
     ) {
         div("container mx-auto p-4") {
+
+            if (shared) {
+                p("p-4 bg-gray-800") {
+                    +"You are viewing a public note "
+                }
+
+                hr {  }
+            }
+
             div("flex items-center justify-between mb-4") {
                 h1("text-3xl fond-bold underline") { +note.meta.title }
                 span("space-x-2") {
@@ -132,19 +141,20 @@ class NoteView(staticFileResolver: StaticFileResolver) : View(staticFileResolver
                     }
                 }
             }
-            span("flex space-x-2 justify-end mb-4") {
+            if (!shared) {
-                a(
+                noteActionForm(note)
-                    href = "/notes/${note.uuid}/edit",
+
-                    classes = "btn btn-teal"
+                if (note.public) {
-                ) { +"Edit" }
+                    p("my-4") {
-                form(method = FormMethod.post, classes = "inline") {
+                        +"You can share this link : "
-                    button(
+                        a(href = "/notes/public/${note.uuid}", classes = "text-blue-300 underline") {
-                        type = ButtonType.submit,
+                            +"/notes/public/${note.uuid}"
-                        name = "delete",
+                        }
-                        classes = "btn btn-red"
+                    }
-                    ) { +"Delete" }
+                    hr {  }
                 }
             }
+
             div {
                 attributes["id"] = "note"
                 unsafe {
@@ -153,4 +163,36 @@ class NoteView(staticFileResolver: StaticFileResolver) : View(staticFileResolver
             }
         }
     }
+
+    private fun DIV.noteActionForm(note: PersistedNote) {
+        form(method = FormMethod.post, classes = "inline flex space-x-2 justify-end mb-4") {
+            a(
+                href = "/notes/${note.uuid}/edit",
+                classes = "btn btn-green"
+            ) { +"Edit" }
+            span {
+                button(
+                    type = ButtonType.submit,
+                    name = if (note.public) "private" else "public",
+                    classes = "font-semibold border-b-4 ${if (note.public) "border-teal-200" else "border-green-500"}" +
+                        " p-2 rounded-l bg-teal-200 text-gray-800"
+                ) {
+                    +"Private"
+                }
+                button(
+                    type = ButtonType.submit,
+                    name = if (note.public) "private" else "public",
+                    classes = "font-semibold border-b-4 ${if (!note.public) "border-teal-200" else "border-green-500"}" +
+                        " p-2 rounded-r bg-teal-200 text-gray-800"
+                ) {
+                    +"Public"
+                }
+            }
+            button(
+                type = ButtonType.submit,
+                name = "delete",
+                classes = "btn btn-red"
+            ) { +"Delete" }
+        }
+    }
 }

simplenotes-app/src/main/kotlin/be/simplenotes/app/views/SettingView.kt

@@ -26,14 +26,32 @@ class SettingView(staticFileResolver: StaticFileResolver) : View(staticFileResol
                 }
             }
 
-            section("m-4 p-4 bg-gray-800 rounded") {
+            section("m-4 p-2 bg-gray-800 rounded flex flex-wrap justify-around items-end") {
-                p(classes = "mb-4") {
+
-                    +"Export all my data"
+                form(classes = "m-2", 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") {
+                form(classes = "m-2", method = FormMethod.post, action = "/export") {
-                    button(name = "display", classes = "inline btn btn-teal block", type = submit) { +"Display my data" }
+
-                    button(name = "download", classes = "inline btn btn-green block ml-2 mt-2", type = submit) {
+                    div {
+                        listOf("json", "zip").forEach { format ->
+                            radioInput(name = "format") {
+                                id = format
+                                attributes["value"] = format
+                                if (format == "json") attributes["checked"] = ""
+                                else attributes["class"] = "ml-4"
+                            }
+                            label(classes = "ml-2") {
+                                attributes["for"] = format
+                                +format
+                            }
+                        }
+                    }
+
+                    button(name = "download", classes = "inline btn btn-green block mt-2", type = submit) {
                         +"Download my data"
                     }
                 }

simplenotes-app/src/main/kotlin/be/simplenotes/app/views/View.kt

@@ -31,7 +31,7 @@ abstract class View(staticFileResolver: StaticFileResolver) {
                     attributes["crossorigin"] = "anonymous"
                 }
                 link(rel = "stylesheet", href = styles)
-                link(rel = "shortcut icon", href = "/favicon.ico", type = "image/x-icon")
+                icons()
                 scripts.forEach { src ->
                     script(src = src) {}
                 }
@@ -42,4 +42,15 @@ abstract class View(staticFileResolver: StaticFileResolver) {
             }
         }
     }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun HEAD.icons() {
+        link(rel = "apple-touch-icon", href = "/apple-touch-icon.png") { attributes["sizes"] = "180x180" }
+        link(rel = "icon", href = "/favicon-32x32.png", type = "image/png") { attributes["sizes"] = "32x32" }
+        link(rel = "icon", href = "/favicon-16x16.png", type = "image/png") { attributes["sizes"] = "16x16" }
+        link(rel = "manifest", href = "/site.webmanifest")
+        link(rel = "mask-icon", href = "/safari-pinned-tab.svg") { attributes["color"] = "#2c7a7b" }
+        meta(name = "msapplication-TileColor", content = "#00aba9")
+        meta(name = "theme-color", content = "#2c7a7b")
+    }
 }

simplenotes-app/src/main/kotlin/be/simplenotes/app/views/components/DeletedNoteTable.kt

@@ -1,7 +1,7 @@
 package be.simplenotes.app.views.components
 
 import be.simplenotes.app.utils.toTimeAgo
-import be.simplenotes.domain.model.PersistedNoteMetadata
+import be.simplenotes.types.PersistedNoteMetadata
 import kotlinx.html.*
 import kotlinx.html.ButtonType.submit
 import kotlinx.html.FormMethod.post
@@ -25,8 +25,8 @@ fun FlowContent.deletedNoteTable(notes: List<PersistedNoteMetadata>) = div("over
                     td("text-center") { +updatedAt.toTimeAgo() }
                     td { tags(tags) }
                     td("text-center") {
-                        form(classes = "inline", method = post, action = "/notes/deleted/$uuid") {
+                        form(method = post, action = "/notes/deleted/$uuid") {
-                            button(classes = "btn btn-red", type = submit, name = "delete") {
+                            button(classes = "btn btn-red mb-2", type = submit, name = "delete") {
                                 +"Delete permanently"
                             }
                             button(classes = "ml-2 btn btn-green", type = submit, name = "restore") {

simplenotes-app/src/main/kotlin/be/simplenotes/app/views/components/NoteTable.kt

@@ -1,7 +1,7 @@
 package be.simplenotes.app.views.components
 
 import be.simplenotes.app.utils.toTimeAgo
-import be.simplenotes.domain.model.PersistedNoteMetadata
+import be.simplenotes.types.PersistedNoteMetadata
 import kotlinx.html.*
 import kotlinx.html.ThScope.col
 

simplenotes-app/src/main/resources/static/browserconfig.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<browserconfig>
+    <msapplication>
+        <tile>
+            <square150x150logo src="/mstile-150x150.png"/>
+            <TileColor>#00aba9</TileColor>
+        </tile>
+    </msapplication>
+</browserconfig>

simplenotes-app/src/main/resources/static/safari-pinned-tab.svg

@@ -0,0 +1,33 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
+ "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
+ width="700.000000pt" height="700.000000pt" viewBox="0 0 700.000000 700.000000"
+ preserveAspectRatio="xMidYMid meet">
+<metadata>
+Created by potrace 1.11, written by Peter Selinger 2001-2013
+</metadata>
+<g transform="translate(0.000000,700.000000) scale(0.100000,-0.100000)"
+fill="#000000" stroke="none">
+<path d="M1255 6993 c-179 -23 -313 -62 -461 -133 -396 -187 -665 -533 -766
+-981 l-23 -104 0 -2275 0 -2275 23 -102 c125 -565 530 -970 1095 -1095 l102
+-23 2275 0 2275 0 102 23 c565 125 970 530 1095 1095 l23 102 0 2275 0 2275
+-23 102 c-125 566 -521 964 -1090 1095 l-97 22 -2250 2 c-1237 1 -2263 -1
+-2280 -3z m1024 -1979 c128 -18 287 -70 394 -127 262 -139 448 -395 472 -649
+3 -34 8 -78 11 -95 l5 -33 -255 0 -254 0 -6 28 c-2 15 -7 44 -11 65 -27 168
+-204 335 -416 393 -94 26 -317 24 -421 -4 -218 -59 -345 -196 -356 -384 -6
+-105 16 -173 80 -243 81 -88 227 -148 563 -230 509 -123 742 -228 916 -412
+123 -131 170 -248 176 -448 9 -245 -55 -420 -212 -580 -162 -165 -387 -270
+-667 -311 -154 -22 -461 -15 -595 15 -280 62 -513 193 -662 373 -72 85 -162
+262 -185 358 -8 36 -18 95 -22 133 l-6 67 254 0 255 0 6 -53 c22 -179 135
+-332 310 -417 127 -61 195 -74 387 -75 195 0 279 16 399 76 179 89 260 234
+231 415 -22 137 -98 231 -243 302 -109 55 -202 84 -447 142 -237 57 -306 76
+-427 120 -340 125 -535 303 -600 550 -23 87 -23 271 0 360 87 335 409 595 827
+665 108 19 371 18 499 -1z m3170 0 c202 -35 325 -95 453 -224 77 -77 93 -100
+141 -201 30 -63 63 -143 72 -179 49 -183 48 -159 52 -1307 l4 -1083 -256 0
+-255 0 0 1034 c0 1160 1 1133 -70 1282 -92 192 -259 271 -548 262 -117 -4
+-149 -9 -221 -33 -177 -60 -340 -200 -440 -376 l-31 -56 0 -1056 0 -1057 -255
+0 -255 0 0 1480 0 1480 239 0 238 0 6 -82 c4 -46 7 -120 7 -165 0 -45 3 -88 6
+-97 4 -11 28 8 92 72 163 164 356 267 575 307 103 19 334 18 446 -1z"/>
+</g>
+</svg>

simplenotes-app/src/main/resources/static/site.webmanifest

@@ -0,0 +1,19 @@
+{
+    "name": "SimpleNotes",
+    "short_name": "SimpleNotes",
+    "icons": [
+        {
+            "src": "/android-chrome-192x192.png",
+            "sizes": "192x192",
+            "type": "image/png"
+        },
+        {
+            "src": "/android-chrome-512x512.png",
+            "sizes": "512x512",
+            "type": "image/png"
+        }
+    ],
+    "theme_color": "#ffffff",
+    "background_color": "#ffffff",
+    "display": "standalone"
+}

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

@@ -3,7 +3,7 @@ package be.simplenotes.app.filters
 import be.simplenotes.domain.security.JwtPayload
 import be.simplenotes.domain.security.JwtPayloadExtractor
 import be.simplenotes.domain.security.SimpleJwt
-import be.simplenotes.shared.config.JwtConfig
+import be.simplenotes.config.JwtConfig
 import com.natpryce.hamkrest.assertion.assertThat
 import org.http4k.core.*
 import org.http4k.core.Method.GET
@@ -27,8 +27,8 @@ internal class AuthFilterTest {
     private val simpleJwt = SimpleJwt(jwtConfig)
     private val extractor = JwtPayloadExtractor(simpleJwt)
     private val ctx = RequestContexts()
-    private val requiredAuth = AuthFilter(extractor, AuthType.Required, ctx)()
+    private val requiredAuth = AuthFilter(extractor, AuthType.Required, ctx)
-    private val optionalAuth = AuthFilter(extractor, AuthType.Optional, ctx)()
+    private val optionalAuth = AuthFilter(extractor, AuthType.Optional, ctx)
 
     private val echoJwtPayloadHandler = { request: Request -> Response(OK).body(request.jwtPayload(ctx).toString()) }