add repos ktor and exposed

2025-09-15 05:19:23 +00:00 · 2020-09-22 11:47:01 +10:00
parent dc9529310c
commit b84367f47c
39 changed files with 1369 additions and 0 deletions
--- a/repos/ktor/server/build.gradle
+++ b/repos/ktor/server/build.gradle
@@ -0,0 +1,23 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+}
+
+apply from: "$mppJavaProjectPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api internalProject("micro_utils.repos.ktor.common")
+            }
+        }
+
+        jvmMain {
+            dependencies {
+                api "io.ktor:ktor-server:$ktor_version"
+                api "io.ktor:ktor-server-host-common:$ktor_version"
+            }
+        }
+    }
+}
--- a/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorReadStandardCrudRepo.kt
+++ b/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorReadStandardCrudRepo.kt
@@ -0,0 +1,54 @@
+package dev.inmo.micro_utils.repos.ktor.server.crud
+
+import dev.inmo.micro_utils.repos.ktor.common.crud.containsRouting
+import dev.inmo.micro_utils.repos.ktor.common.crud.getByIdRouting
+import dev.inmo.micro_utils.repos.ktor.common.crud.getByPaginationRouting
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import io.ktor.application.call
+import io.ktor.routing.Route
+import io.ktor.routing.get
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.serializer
+
+fun <ObjectType, IdType> Route.configureReadStandardCrudRepoRoutes(
+    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+    objectsSerializer: KSerializer<ObjectType>,
+    objectsNullableSerializer: KSerializer<ObjectType?>,
+    idsSerializer: KSerializer<IdType>
+) {
+    val paginationResultSerializer = PaginationResult.serializer(objectsSerializer)
+
+    get(getByPaginationRouting) {
+        val pagination = call.request.queryParameters.extractPagination
+
+        call.unianswer(
+            paginationResultSerializer,
+            originalRepo.getByPagination(pagination)
+        )
+    }
+
+    get(getByIdRouting) {
+        val id = call.decodeUrlQueryValueOrSendError(
+            "id",
+            idsSerializer
+        ) ?: return@get
+
+        call.unianswer(
+            objectsNullableSerializer,
+            originalRepo.getById(id)
+        )
+    }
+
+    get(containsRouting) {
+        val id = call.decodeUrlQueryValueOrSendError(
+            "id",
+            idsSerializer
+        ) ?: return@get
+
+        call.unianswer(
+            Boolean.serializer(),
+            originalRepo.contains(id)
+        )
+    }
+}
--- a/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorStandardCrudRepo.kt
+++ b/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorStandardCrudRepo.kt
@@ -0,0 +1,20 @@
+package dev.inmo.micro_utils.repos.ktor.server.crud
+
+import dev.inmo.micro_utils.repos.StandardCRUDRepo
+import io.ktor.routing.Route
+import io.ktor.routing.route
+import kotlinx.serialization.KSerializer
+
+fun <ObjectType, IdType, InputValue> Route.configureStandardCrudRepoRoutes(
+    baseSubpart: String,
+    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
+    objectsSerializer: KSerializer<ObjectType>,
+    objectsNullableSerializer: KSerializer<ObjectType?>,
+    inputsSerializer: KSerializer<InputValue>,
+    idsSerializer: KSerializer<IdType>
+) {
+    route(baseSubpart) {
+        configureReadStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer)
+        configureWriteStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer)
+    }
+}
--- a/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorWriteStandardCrudRepo.kt
+++ b/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorWriteStandardCrudRepo.kt
@@ -0,0 +1,81 @@
+package dev.inmo.micro_utils.repos.ktor.server.crud
+
+import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ktor.common.crud.*
+import io.ktor.application.call
+import io.ktor.routing.Route
+import io.ktor.routing.post
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.*
+
+fun <ObjectType, IdType, InputValue> Route.configureWriteStandardCrudRepoRoutes(
+    originalRepo: WriteStandardCRUDRepo<ObjectType, IdType, InputValue>,
+    objectsSerializer: KSerializer<ObjectType>,
+    objectsNullableSerializer: KSerializer<ObjectType?>,
+    inputsSerializer: KSerializer<InputValue>,
+    idsSerializer: KSerializer<IdType>
+) {
+    val listObjectsSerializer = ListSerializer(objectsSerializer)
+    val listInputSerializer = ListSerializer(inputsSerializer)
+    val listIdsSerializer = ListSerializer(idsSerializer)
+    val inputUpdateSerializer = PairSerializer(
+        idsSerializer,
+        inputsSerializer
+    )
+    val listInputUpdateSerializer = ListSerializer(inputUpdateSerializer)
+
+    includeWebsocketHandling(
+        newObjectsFlowRouting,
+        originalRepo.newObjectsFlow,
+        objectsSerializer
+    )
+    includeWebsocketHandling(
+        updatedObjectsFlowRouting,
+        originalRepo.updatedObjectsFlow,
+        objectsSerializer
+    )
+    includeWebsocketHandling(
+        deletedObjectsIdsFlowRouting,
+        originalRepo.deletedObjectsIdsFlow,
+        idsSerializer
+    )
+
+    post(createRouting) {
+        call.unianswer(
+            listObjectsSerializer,
+            originalRepo.create(
+                call.uniload(listInputSerializer)
+            )
+        )
+    }
+
+    post(updateRouting) {
+        val (id, input) = call.uniload(inputUpdateSerializer)
+        call.unianswer(
+            objectsNullableSerializer,
+            originalRepo.update(
+                id, input
+            )
+        )
+    }
+
+    post(updateManyRouting) {
+        val updates = call.uniload(listInputUpdateSerializer)
+        call.unianswer(
+            listObjectsSerializer,
+            originalRepo.update(
+                updates
+            )
+        )
+    }
+
+    post(deleteByIdRouting) {
+        val ids = call.uniload(listIdsSerializer)
+        call.unianswer(
+            Unit.serializer(),
+            originalRepo.deleteById(
+                ids
+            )
+        )
+    }
+}
--- a/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartKeyValueRepo.kt
+++ b/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartKeyValueRepo.kt
@@ -0,0 +1,27 @@
+package dev.inmo.micro_utils.repos.ktor.server.key_value
+
+import dev.inmo.micro_utils.repos.StandardKeyValueRepo
+import io.ktor.routing.*
+import kotlinx.serialization.KSerializer
+
+fun <K, V> Route.configureStandartKeyValueRepoRoutes(
+    baseSubpart: String,
+    originalRepo: StandardKeyValueRepo<K, V>,
+    keySerializer: KSerializer<K>,
+    valueSerializer: KSerializer<V>,
+    valueNullableSerializer: KSerializer<V?>,
+) {
+    route(baseSubpart) {
+        configureReadStandartKeyValueRepoRoutes(
+            originalRepo,
+            keySerializer,
+            valueSerializer,
+            valueNullableSerializer,
+        )
+        configureWriteStandartKeyValueRepoRoutes(
+            originalRepo,
+            keySerializer,
+            valueSerializer,
+        )
+    }
+}
--- a/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartReadKeyValueRepo.kt
+++ b/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartReadKeyValueRepo.kt
@@ -0,0 +1,72 @@
+package dev.inmo.micro_utils.repos.ktor.server.key_value
+
+import dev.inmo.micro_utils.repos.StandardReadKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.key_value.*
+import io.ktor.application.*
+import io.ktor.routing.*
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.serializer
+
+fun <K, V> Route.configureReadStandartKeyValueRepoRoutes (
+    originalRepo: StandardReadKeyValueRepo<K, V>,
+    keySerializer: KSerializer<K>,
+    valueSerializer: KSerializer<V>,
+    valueNullableSerializer: KSerializer<V?>,
+) {
+    get(getRoute) {
+        val key = call.decodeUrlQueryValueOrSendError(
+            keyParameterName,
+            keySerializer
+        ) ?: return@get
+
+        call.unianswer(
+            valueNullableSerializer,
+            originalRepo.get(key)
+        )
+    }
+
+    get(valuesRoute) {
+        val parination = call.request.queryParameters.extractPagination;
+        val reversed = call.decodeUrlQueryValueOrSendError(
+            reversedParameterName,
+            Boolean.serializer()
+        ) ?: return@get
+
+        call.unianswer(
+            PaginationResult.serializer(valueSerializer),
+            originalRepo.values(parination, reversed)
+        )
+    }
+
+    get(keysRoute) {
+        val parination = call.request.queryParameters.extractPagination;
+        val reversed = call.decodeUrlQueryValueOrSendError(
+            reversedParameterName,
+            Boolean.serializer()
+        ) ?: return@get
+
+        call.unianswer(
+            PaginationResult.serializer(keySerializer),
+            originalRepo.keys(parination, reversed)
+        )
+    }
+
+    get(containsRoute) {
+        val key = call.decodeUrlQueryValueOrSendError(
+            keyParameterName,
+            keySerializer
+        ) ?: return@get
+
+        call.unianswer(
+            Boolean.serializer(),
+            originalRepo.contains(key)
+        )
+    }
+
+    get(countRoute) {
+        call.unianswer(
+            Long.serializer(),
+            originalRepo.count()
+        )
+    }
+}
--- a/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartWriteKeyValueRepo.kt
+++ b/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartWriteKeyValueRepo.kt
@@ -0,0 +1,42 @@
+package dev.inmo.micro_utils.repos.ktor.server.key_value
+
+import dev.inmo.micro_utils.repos.StandardWriteKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.key_value.*
+import io.ktor.application.*
+import io.ktor.routing.*
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.PairSerializer
+
+fun <K, V> Route.configureWriteStandartKeyValueRepoRoutes (
+    originalRepo: StandardWriteKeyValueRepo<K, V>,
+    keySerializer: KSerializer<K>,
+    valueSerializer: KSerializer<V>,
+) {
+    includeWebsocketHandling(
+        onNewValueRoute,
+        originalRepo.onNewValue,
+        PairSerializer(keySerializer, valueSerializer)
+    )
+
+    includeWebsocketHandling(
+        onValueRemovedRoute,
+        originalRepo.onValueRemoved,
+        keySerializer
+    )
+
+    post(setRoute) {
+        val (key, value) = call.uniload(
+            KeyValuePostObject.serializer(keySerializer, valueSerializer)
+        )
+
+        originalRepo.set(key, value)
+    }
+
+    post(unsetRoute) {
+        val key = call.uniload(
+            keySerializer
+        )
+
+        originalRepo.unset(key)
+    }
+}
--- a/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyKeyValueRepoRoutes.kt
+++ b/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyKeyValueRepoRoutes.kt
@@ -0,0 +1,18 @@
+package dev.inmo.micro_utils.repos.ktor.server.one_to_many
+
+import dev.inmo.micro_utils.repos.OneToManyKeyValueRepo
+import io.ktor.routing.Route
+import io.ktor.routing.route
+import kotlinx.serialization.KSerializer
+
+fun <Key, Value> Route.configureOneToManyKeyValueRepoRoutes(
+    baseSubpart: String,
+    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+    keySerializer: KSerializer<Key>,
+    valueSealizer: KSerializer<Value>,
+) {
+    route(baseSubpart) {
+        configureOneToManyReadKeyValueRepoRoutes(originalRepo, keySerializer, valueSealizer)
+        configureOneToManyWriteKeyValueRepoRoutes(originalRepo, keySerializer, valueSealizer)
+    }
+}
--- a/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyReadKeyValueRepoRoutes.kt
+++ b/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyReadKeyValueRepoRoutes.kt
@@ -0,0 +1,96 @@
+package dev.inmo.micro_utils.repos.ktor.server.one_to_many
+
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.repos.OneToManyReadKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
+import io.ktor.application.call
+import io.ktor.routing.Route
+import io.ktor.routing.get
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.serializer
+
+fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
+    originalRepo: OneToManyReadKeyValueRepo<Key, Value>,
+    keySerializer: KSerializer<Key>,
+    valueSealizer: KSerializer<Value>,
+) {
+    val paginationKeyResult = PaginationResult.serializer(keySerializer)
+    val paginationValueResult = PaginationResult.serializer(valueSealizer)
+
+    get(getRoute) {
+        val pagination = call.request.queryParameters.extractPagination
+        val key = call.decodeUrlQueryValueOrSendError(
+            keyParameterName,
+            keySerializer
+        ) ?: return@get
+        val reversed = call.decodeUrlQueryValue(
+            reversedParameterName,
+            Boolean.serializer()
+        ) ?: false
+
+        call.unianswer(
+            paginationValueResult,
+            originalRepo.get(key, pagination, reversed)
+        )
+    }
+
+    get(keysRoute) {
+        val pagination = call.request.queryParameters.extractPagination
+        val reversed = call.decodeUrlQueryValue(
+            reversedParameterName,
+            Boolean.serializer()
+        ) ?: false
+
+        call.unianswer(
+            paginationKeyResult,
+            originalRepo.keys(pagination, reversed)
+        )
+    }
+
+    get(containsByKeyRoute) {
+        val key = call.decodeUrlQueryValueOrSendError(
+            keyParameterName,
+            keySerializer
+        ) ?: return@get
+
+        call.unianswer(
+            Boolean.serializer(),
+            originalRepo.contains(key)
+        )
+    }
+
+    get(containsByKeyValueRoute) {
+        val key = call.decodeUrlQueryValueOrSendError(
+            keyParameterName,
+            keySerializer
+        ) ?: return@get
+        val value = call.decodeUrlQueryValueOrSendError(
+            valueParameterName,
+            valueSealizer
+        ) ?: return@get
+
+        call.unianswer(
+            Boolean.serializer(),
+            originalRepo.contains(key, value)
+        )
+    }
+
+    get(countByKeyRoute) {
+        val key = call.decodeUrlQueryValueOrSendError(
+            keyParameterName,
+            keySerializer
+        ) ?: return@get
+
+        call.unianswer(
+            Long.serializer(),
+            originalRepo.count(key)
+        )
+    }
+
+    get(countRoute) {
+        call.unianswer(
+            Long.serializer(),
+            originalRepo.count()
+        )
+    }
+}
--- a/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyWriteKeyValueRepoRoutes.kt
+++ b/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyWriteKeyValueRepoRoutes.kt
@@ -0,0 +1,49 @@
+package dev.inmo.micro_utils.repos.ktor.server.one_to_many
+
+import dev.inmo.micro_utils.repos.OneToManyWriteKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
+import io.ktor.application.call
+import io.ktor.routing.Route
+import io.ktor.routing.post
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.PairSerializer
+import kotlinx.serialization.builtins.serializer
+
+fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
+    originalRepo: OneToManyWriteKeyValueRepo<Key, Value>,
+    keySerializer: KSerializer<Key>,
+    valueSealizer: KSerializer<Value>,
+) {
+    val keyValueSerializer = PairSerializer(keySerializer, valueSealizer)
+
+    post(addRoute) {
+        val obj = call.uniload(
+            keyValueSerializer
+        )
+
+        call.unianswer(
+            Unit.serializer(),
+            originalRepo.add(obj.first, obj.second)
+        )
+    }
+
+    post(removeRoute) {
+        val obj = call.uniload(
+            keyValueSerializer
+        )
+
+        call.unianswer(
+            Unit.serializer(),
+            originalRepo.remove(obj.first, obj.second),
+        )
+    }
+
+    post(clearRoute) {
+        val key = call.uniload(keySerializer)
+
+        call.unianswer(
+            Unit.serializer(),
+            originalRepo.clear(key),
+        )
+    }
+}