complete improvements in repos ktor parts

0.10.8

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.11.0
+
+* `Ktor`
+  * 
+* `Repos`
+  * `Ktor`:
+    * Fully rewritten work with all declared repositories
+
+## 0.10.8
+
+* `Common`
+    * Add `Element.isOverflow*` extension properties
+
 ## 0.10.7
 
 * `Pagination`:

common/src/jsMain/kotlin/dev/inmo/micro_utils/common/IsOverflow.kt

@@ -0,0 +1,12 @@
+package dev.inmo.micro_utils.common
+
+import org.w3c.dom.Element
+
+inline val Element.isOverflowWidth
+    get() = scrollWidth > clientWidth
+
+inline val Element.isOverflowHeight
+    get() = scrollHeight > clientHeight
+
+inline val Element.isOverflow
+    get() = isOverflowHeight || isOverflowWidth

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.10.7
-android_code_version=122
+version=0.11.0
+android_code_version=124

gradle/libs.versions.toml

@@ -37,17 +37,24 @@ kt-serialization-cbor = { module = "org.jetbrains.kotlinx:kotlinx-serialization-
 
 kt-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kt-coroutines" }
 kt-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kt-coroutines" }
+kt-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kt-coroutines" }
 
 
 ktor-io = { module = "io.ktor:ktor-io", version.ref = "ktor" }
+ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
 ktor-client = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
+ktor-client-cio = { module = "io.ktor:ktor-client-cio", version.ref = "ktor" }
 ktor-client-java = { module = "io.ktor:ktor-client-java", version.ref = "ktor" }
+ktor-client-websockets = { module = "io.ktor:ktor-client-websockets", version.ref = "ktor" }
+ktor-client-logging = { module = "io.ktor:ktor-client-logging", version.ref = "ktor" }
+ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
 ktor-server = { module = "io.ktor:ktor-server", version.ref = "ktor" }
 ktor-server-cio = { module = "io.ktor:ktor-server-cio", version.ref = "ktor" }
 ktor-server-host-common = { module = "io.ktor:ktor-server-host-common", version.ref = "ktor" }
 ktor-websockets = { module = "io.ktor:ktor-websockets", version.ref = "ktor" }
 ktor-server-websockets = { module = "io.ktor:ktor-server-websockets", version.ref = "ktor" }
 ktor-server-statusPages = { module = "io.ktor:ktor-server-status-pages", version.ref = "ktor" }
+ktor-server-content-negotiation = { module = "io.ktor:ktor-server-content-negotiation", version.ref = "ktor" }
 
 
 klock = { module = "com.soywiz.korlibs.klock:klock", version.ref = "klock" }

ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/ktor/client/HttpStatusCodeAsThrowable.kt

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.ktor.client
+
+import io.ktor.client.plugins.ClientRequestException
+import io.ktor.client.statement.HttpResponse
+import io.ktor.http.isSuccess
+
+inline fun HttpResponse.throwOnUnsuccess(
+    unsuccessMessage: () -> String
+) {
+    if (status.isSuccess()) {
+        return
+    }
+
+    throw ClientRequestException(this, unsuccessMessage())
+}

ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/ktor/client/NewFlowsWebsockets.kt

@@ -0,0 +1,55 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
+import dev.inmo.micro_utils.coroutines.safely
+import dev.inmo.micro_utils.ktor.common.*
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.pluginOrNull
+import io.ktor.client.plugins.websocket.*
+import io.ktor.client.request.HttpRequestBuilder
+import io.ktor.websocket.Frame
+import io.ktor.websocket.readBytes
+import io.ktor.websocket.serialization.sendSerializedBase
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.isActive
+import kotlinx.serialization.DeserializationStrategy
+
+/**
+ * @param checkReconnection This lambda will be called when it is required to reconnect to websocket to establish
+ * connection. Must return true in case if must be reconnected. By default always reconnecting
+ */
+inline fun <reified T> HttpClient.createStandardWebsocketFlow(
+    url: String,
+    noinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
+    noinline requestBuilder: HttpRequestBuilder.() -> Unit = {}
+): Flow<T> {
+    pluginOrNull(WebSockets) ?: error("Plugin $WebSockets must be installed for using createStandardWebsocketFlow")
+
+    val correctedUrl = url.asCorrectWebSocketUrl
+
+    return channelFlow {
+        do {
+            val reconnect = runCatchingSafely {
+                ws(correctedUrl, requestBuilder) {
+                    for (received in incoming) {
+                        sendSerialized(received.data)
+                    }
+                }
+                checkReconnection(null)
+            }.getOrElse { e ->
+                checkReconnection(e).also {
+                    if (!it) {
+                        close(e)
+                    }
+                }
+            }
+        } while (reconnect && isActive)
+
+        if (isActive) {
+            safely {
+                close()
+            }
+        }
+    }
+}

ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/server/ApplicationCallRespondWithTypeInfo.kt

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.ktor.server
+
+import io.ktor.server.application.ApplicationCall
+import io.ktor.server.response.responseType
+import io.ktor.util.InternalAPI
+import io.ktor.util.reflect.TypeInfo
+
+@InternalAPI
+suspend fun <T : Any> ApplicationCall.respond(
+    message: T,
+    typeInfo: TypeInfo
+) {
+    response.responseType = typeInfo
+    response.pipeline.execute(this, message as Any)
+}

ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/server/NewFlowsWebsocket.kt

@@ -0,0 +1,30 @@
+package dev.inmo.micro_utils.ktor.server
+
+import dev.inmo.micro_utils.coroutines.safely
+import dev.inmo.micro_utils.ktor.common.*
+import io.ktor.http.URLProtocol
+import io.ktor.server.application.install
+import io.ktor.server.application.pluginOrNull
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.application
+import io.ktor.server.websocket.*
+import io.ktor.websocket.send
+import kotlinx.coroutines.flow.Flow
+import kotlinx.serialization.SerializationStrategy
+
+inline fun <reified T : Any> Route.includeWebsocketHandling(
+    suburl: String,
+    flow: Flow<T>,
+    protocol: URLProtocol? = null
+) {
+    application.apply {
+        pluginOrNull(WebSockets) ?: install(WebSockets)
+    }
+    webSocket(suburl, protocol ?.name) {
+        safely {
+            flow.collect {
+                sendSerialized(it)
+            }
+        }
+    }
+}

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/OneToManyKeyValueRepo.kt

@@ -104,6 +104,13 @@ interface OneToManyKeyValueRepo<Key, Value> : ReadOneToManyKeyValueRepo<Key, Val
 }
 typealias KeyValuesRepo<Key,Value> = OneToManyKeyValueRepo<Key, Value>
 
+class DelegateBasedOneToManyKeyValueRepo<Key, Value>(
+    readDelegate: ReadOneToManyKeyValueRepo<Key, Value>,
+    writeDelegate: WriteOneToManyKeyValueRepo<Key, Value>
+) : OneToManyKeyValueRepo<Key, Value>,
+    ReadOneToManyKeyValueRepo<Key, Value> by readDelegate,
+    WriteOneToManyKeyValueRepo<Key, Value> by writeDelegate
+
 suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
     keysAndValues: List<Pair<Key, List<Value>>>
 ) = remove(keysAndValues.toMap())

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/StandartCRUDRepo.kt

@@ -42,4 +42,11 @@ suspend fun <ObjectType, IdType, InputValueType> WriteStandardCRUDRepo<ObjectTyp
 
 interface StandardCRUDRepo<ObjectType, IdType, InputValueType> : ReadStandardCRUDRepo<ObjectType, IdType>,
     WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
-typealias CRUDRepo<ObjectType, IdType, InputValueType> = StandardCRUDRepo<ObjectType, IdType, InputValueType>
+typealias CRUDRepo<ObjectType, IdType, InputValueType> = StandardCRUDRepo<ObjectType, IdType, InputValueType>
+
+class DelegateBasedStandardCRUDRepo<ObjectType, IdType, InputValueType>(
+    readDelegate: ReadStandardCRUDRepo<ObjectType, IdType>,
+    writeDelegate: WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
+) : StandardCRUDRepo<ObjectType, IdType, InputValueType>,
+    ReadStandardCRUDRepo<ObjectType, IdType> by readDelegate,
+    WriteStandardCRUDRepo<ObjectType, IdType, InputValueType> by writeDelegate

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/StandartKeyValueRepo.kt

@@ -50,3 +50,10 @@ interface StandardKeyValueRepo<Key, Value> : ReadStandardKeyValueRepo<Key, Value
     }
 }
 typealias KeyValueRepo<Key,Value> = StandardKeyValueRepo<Key, Value>
+
+class DelegateBasedStandardKeyValueRepo<Key, Value>(
+    readDelegate: ReadStandardKeyValueRepo<Key, Value>,
+    writeDelegate: WriteStandardKeyValueRepo<Key, Value>
+) : StandardKeyValueRepo<Key, Value>,
+    ReadStandardKeyValueRepo<Key, Value> by readDelegate,
+    WriteStandardKeyValueRepo<Key, Value> by writeDelegate

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapCRUDRepo.kt

@@ -74,19 +74,24 @@ abstract class MapCRUDRepo<ObjectType, IdType, InputValueType>(
 
 fun <ObjectType, IdType, InputValueType> MapCRUDRepo(
     map: MutableMap<IdType, ObjectType>,
-    updateCallback: suspend (newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType,
-    createCallback: suspend (newValue: InputValueType) -> Pair<IdType, ObjectType>
+    updateCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType,
+    createCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType) -> Pair<IdType, ObjectType>
 ) = object : MapCRUDRepo<ObjectType, IdType, InputValueType>(map) {
     override suspend fun updateObject(
         newValue: InputValueType,
         id: IdType,
         old: ObjectType
-    ): ObjectType = updateCallback(newValue, id, old)
+    ): ObjectType = map.updateCallback(newValue, id, old)
 
-    override suspend fun createObject(newValue: InputValueType): Pair<IdType, ObjectType> = createCallback(newValue)
+    override suspend fun createObject(newValue: InputValueType): Pair<IdType, ObjectType> = map.createCallback(newValue)
 }
 
+fun <ObjectType, IdType, InputValueType> MapCRUDRepo(
+    updateCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType,
+    createCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType) -> Pair<IdType, ObjectType>
+) = MapCRUDRepo(mutableMapOf(), updateCallback, createCallback)
+
 fun <ObjectType, IdType, InputValueType> MutableMap<IdType, ObjectType>.asCrudRepo(
-    updateCallback: suspend (newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType,
-    createCallback: suspend (newValue: InputValueType) -> Pair<IdType, ObjectType>
+    updateCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType,
+    createCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType) -> Pair<IdType, ObjectType>
 ) = MapCRUDRepo(this, updateCallback, createCallback)

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapKeyValueRepo.kt

@@ -78,11 +78,11 @@ class WriteMapKeyValueRepo<Key, Value>(
     }
 
     override suspend fun unsetWithValues(toUnset: List<Value>) {
-        map.forEach {
-            if (it.value in toUnset) {
-                map.remove(it.key)
-                _onValueRemoved.emit(it.key)
-            }
+        map.mapNotNull { (k, v) ->
+            k.takeIf { v in toUnset }
+        }.forEach {
+            map.remove(it)
+            _onValueRemoved.emit(it)
         }
     }
 }

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapOneToManyKeyValueRepo.kt

@@ -80,6 +80,10 @@ class MapWriteOneToManyKeyValueRepo<Key, Value>(
                     _onValueRemoved.emit(k to v)
                 }
             }
+            if (map[k] ?.isEmpty() == true) {
+                map.remove(k)
+                _onDataCleared.emit(k)
+            }
         }
     }
 

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorReadStandardCrudRepo.kt

@@ -4,11 +4,14 @@ import dev.inmo.micro_utils.ktor.client.*
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ktor.common.countRouting
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
+import dev.inmo.micro_utils.repos.ktor.common.idParameterName
 import io.ktor.client.HttpClient
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.serializer
 
+@Deprecated("Use KtorReadStandardCrudRepoClient instead")
 class KtorReadStandardCrudRepo<ObjectType, IdType> (
     private val baseUrl: String,
     private val unifiedRequester: UnifiedRequester,
@@ -38,9 +41,7 @@ class KtorReadStandardCrudRepo<ObjectType, IdType> (
         buildStandardUrl(
             baseUrl,
             getByIdRouting,
-            mapOf(
-                "id" to unifiedRequester.encodeUrlQueryValue(idsSerializer, id)
-            )
+            idParameterName to unifiedRequester.encodeUrlQueryValue(idsSerializer, id)
         ),
         objectsSerializerNullable
     )
@@ -49,9 +50,7 @@ class KtorReadStandardCrudRepo<ObjectType, IdType> (
         buildStandardUrl(
             baseUrl,
             containsRouting,
-            mapOf(
-                "id" to unifiedRequester.encodeUrlQueryValue(idsSerializer, id)
-            )
+            idParameterName to unifiedRequester.encodeUrlQueryValue(idsSerializer, id)
         ),
         Boolean.serializer()
     )

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorReadStandardCrudRepoClient.kt

@@ -0,0 +1,95 @@
+package dev.inmo.micro_utils.repos.ktor.client.crud
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ktor.common.countRouting
+import dev.inmo.micro_utils.repos.ktor.common.crud.*
+import dev.inmo.micro_utils.repos.ktor.common.idParameterName
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.request.get
+import io.ktor.http.*
+import io.ktor.util.reflect.TypeInfo
+import io.ktor.util.reflect.typeInfo
+import kotlinx.serialization.*
+
+class KtorReadStandardCrudRepoClient<ObjectType, IdType> (
+    private val baseUrl: String,
+    private val httpClient: HttpClient,
+    private val objectType: TypeInfo,
+    private val contentType: ContentType,
+    private val idSerializer: suspend (IdType) -> String
+) : ReadStandardCRUDRepo<ObjectType, IdType> {
+    override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = httpClient.get(
+        buildStandardUrl(baseUrl, getByPaginationRouting, pagination.asUrlQueryParts)
+    ) {
+        contentType(contentType)
+    }.body()
+
+    override suspend fun getById(id: IdType): ObjectType? = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            getByIdRouting,
+            mapOf(
+                idParameterName to idSerializer(id)
+            )
+        )
+    ) {
+        contentType(contentType)
+    }.takeIf { it.status != HttpStatusCode.NoContent } ?.body<ObjectType>(objectType)
+
+    override suspend fun contains(id: IdType): Boolean = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            containsRouting,
+            mapOf(
+                idParameterName to idSerializer(id)
+            )
+        )
+    ) {
+        contentType(contentType)
+    }.body()
+
+    override suspend fun count(): Long = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            countRouting
+        )
+    ) {
+        contentType(contentType)
+    }.body()
+}
+
+inline fun <reified ObjectType, IdType> KtorReadStandardCrudRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    contentType: ContentType,
+    noinline idSerializer: suspend (IdType) -> String
+) = KtorReadStandardCrudRepoClient<ObjectType, IdType>(
+    baseUrl,
+    httpClient,
+    typeInfo<ObjectType>(),
+    contentType,
+    idSerializer
+)
+
+inline fun <reified ObjectType, IdType> KtorReadStandardCrudRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StringFormat,
+    contentType: ContentType,
+) = KtorReadStandardCrudRepoClient<ObjectType, IdType>(baseUrl, httpClient, contentType) {
+    serialFormat.encodeToString(idsSerializer, it)
+}
+
+inline fun <reified ObjectType, IdType> KtorReadStandardCrudRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: BinaryFormat,
+    contentType: ContentType,
+) = KtorReadStandardCrudRepoClient<ObjectType, IdType>(baseUrl, httpClient, contentType) {
+    serialFormat.encodeHex(idsSerializer, it)
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorStandardCrudRepo.kt

@@ -7,6 +7,7 @@ import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
 import kotlinx.serialization.KSerializer
 
+@Deprecated("Use KtorStandardCrudRepoClient instead")
 class KtorStandardCrudRepo<ObjectType, IdType, InputValue> (
     baseUrl: String,
     baseSubpart: String,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorStandardCrudRepoClient.kt

@@ -0,0 +1,122 @@
+package dev.inmo.micro_utils.repos.ktor.client.crud
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.repos.*
+import io.ktor.client.HttpClient
+import io.ktor.client.utils.EmptyContent.contentType
+import io.ktor.http.ContentType
+import io.ktor.util.reflect.TypeInfo
+import io.ktor.util.reflect.typeInfo
+import kotlinx.serialization.*
+
+class KtorStandardCrudRepoClient<ObjectType, IdType, InputValue> (
+    readDelegate: ReadStandardCRUDRepo<ObjectType, IdType>,
+    writeDelegate: WriteStandardCRUDRepo<ObjectType, IdType, InputValue>
+) : StandardCRUDRepo<ObjectType, IdType, InputValue> by DelegateBasedStandardCRUDRepo(
+    readDelegate,
+    writeDelegate
+) {
+    companion object {
+        inline operator fun <reified ObjectType, reified IdType, reified InputValue> invoke(
+            baseUrl: String,
+            httpClient: HttpClient,
+            objectTypeInfo: TypeInfo,
+            contentType: ContentType,
+            noinline idSerializer: suspend (IdType) -> String
+        ) = KtorStandardCrudRepoClient(
+            KtorReadStandardCrudRepoClient(
+                baseUrl,
+                httpClient,
+                objectTypeInfo,
+                contentType,
+                idSerializer
+            ),
+            KtorWriteStandardCrudRepoClient<ObjectType, IdType, InputValue>(
+                baseUrl,
+                httpClient,
+                contentType
+            )
+        )
+
+        inline operator fun <reified ObjectType, reified IdType, reified InputValue> invoke(
+            baseUrl: String,
+            subpart: String,
+            httpClient: HttpClient,
+            objectTypeInfo: TypeInfo,
+            contentType: ContentType,
+            noinline idSerializer: suspend (IdType) -> String
+        ) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(
+            buildStandardUrl(baseUrl, subpart),
+            httpClient,
+            objectTypeInfo,
+            contentType,
+            idSerializer
+        )
+    }
+}
+
+
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    contentType: ContentType,
+    noinline idSerializer: suspend (IdType) -> String
+) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(
+    baseUrl,
+    httpClient,
+    typeInfo<ObjectType>(),
+    contentType,
+    idSerializer
+)
+
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StringFormat,
+    contentType: ContentType,
+) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(baseUrl, httpClient, contentType) {
+    serialFormat.encodeToString(idsSerializer, it)
+}
+
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: BinaryFormat,
+    contentType: ContentType,
+) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(baseUrl, httpClient, contentType) {
+    serialFormat.encodeHex(idsSerializer, it)
+}
+
+
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+    baseUrl: String,
+    subpart: String,
+    httpClient: HttpClient,
+    contentType: ContentType,
+    noinline idSerializer: suspend (IdType) -> String
+) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(
+    buildStandardUrl(baseUrl, subpart),
+    httpClient,
+    contentType,
+    idSerializer
+)
+
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+    baseUrl: String,
+    subpart: String,
+    httpClient: HttpClient,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StringFormat,
+    contentType: ContentType,
+) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(buildStandardUrl(baseUrl, subpart), httpClient, idsSerializer, serialFormat, contentType)
+
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+    baseUrl: String,
+    subpart: String,
+    httpClient: HttpClient,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: BinaryFormat,
+    contentType: ContentType,
+) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(buildStandardUrl(baseUrl, subpart), httpClient, idsSerializer, serialFormat, contentType)

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorWriteStandardCrudRepo.kt

@@ -10,6 +10,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.*
 
+@Deprecated("Use KtorWriteStandardCrudRepoClient instead")
 class KtorWriteStandardCrudRepo<ObjectType, IdType, InputValue> (
     private val baseUrl: String,
     private val unifiedRequester: UnifiedRequester,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorWriteStandardCrudRepoClient.kt

@@ -0,0 +1,85 @@
+package dev.inmo.micro_utils.repos.ktor.client.crud
+
+import dev.inmo.micro_utils.ktor.client.*
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.repos.UpdatedValuePair
+import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ktor.common.crud.*
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.request.*
+import io.ktor.client.statement.HttpResponse
+import io.ktor.http.ContentType
+import io.ktor.http.contentType
+import kotlinx.coroutines.flow.Flow
+
+class KtorWriteStandardCrudRepoClient<ObjectType, IdType, InputValue> (
+    private val baseUrl: String,
+    private val httpClient: HttpClient,
+    override val newObjectsFlow: Flow<ObjectType>,
+    override val updatedObjectsFlow: Flow<ObjectType>,
+    override val deletedObjectsIdsFlow: Flow<IdType>,
+    private val createSetup: suspend HttpRequestBuilder.(List<InputValue>) -> Unit,
+    private val updateSetup: suspend HttpRequestBuilder.(List<UpdatedValuePair<IdType, InputValue>>) -> Unit,
+    private val deleteByIdSetup: suspend HttpRequestBuilder.(List<IdType>) -> Unit,
+    private val createBodyGetter: suspend HttpResponse.() -> List<ObjectType>,
+    private val updateBodyGetter: suspend HttpResponse.() -> List<ObjectType>
+) : WriteStandardCRUDRepo<ObjectType, IdType, InputValue> {
+    override suspend fun create(values: List<InputValue>): List<ObjectType> = httpClient.post(
+        buildStandardUrl(baseUrl, createRouting)
+    ) {
+        createSetup(values)
+    }.createBodyGetter()
+
+    override suspend fun update(
+        values: List<UpdatedValuePair<IdType, InputValue>>
+    ): List<ObjectType> = httpClient.post(
+        buildStandardUrl(baseUrl, updateManyRouting)
+    ) {
+        updateSetup(values)
+    }.updateBodyGetter()
+
+    override suspend fun update(id: IdType, value: InputValue): ObjectType? = update(listOf(id to value)).firstOrNull()
+
+    override suspend fun deleteById(ids: List<IdType>) {
+        httpClient.post(
+            buildStandardUrl(baseUrl, deleteByIdRouting)
+        ) {
+            deleteByIdSetup(ids)
+        }.throwOnUnsuccess { "Unable to delete $ids" }
+    }
+
+    companion object {
+        inline operator fun <reified ObjectType, reified IdType, reified InputValue> invoke(
+            baseUrl: String,
+            httpClient: HttpClient,
+            contentType: ContentType
+        ) = KtorWriteStandardCrudRepoClient<ObjectType, IdType, InputValue>(
+            baseUrl,
+            httpClient,
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, newObjectsFlowRouting),
+            ),
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
+            ),
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
+            ),
+            {
+                contentType(contentType)
+                setBody(it)
+            },
+            {
+                contentType(contentType)
+                setBody(it)
+            },
+            {
+                contentType(contentType)
+                setBody(it)
+            },
+            { body() },
+            { body() }
+        )
+    }
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorReadStandardKeyValueRepo.kt

@@ -4,8 +4,12 @@ import dev.inmo.micro_utils.ktor.client.*
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.*
+import dev.inmo.micro_utils.repos.ktor.common.containsRoute
+import dev.inmo.micro_utils.repos.ktor.common.countRoute
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
-import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
+import dev.inmo.micro_utils.repos.ktor.common.key_value.keyParameterName
+import dev.inmo.micro_utils.repos.ktor.common.key_value.reversedParameterName
 import io.ktor.client.HttpClient
 import kotlinx.serialization.*
 import kotlinx.serialization.builtins.serializer

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorReadStandardKeyValueRepoClient.kt

@@ -0,0 +1,143 @@
+package dev.inmo.micro_utils.repos.ktor.client.key_value
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.*
+import dev.inmo.micro_utils.repos.ktor.common.containsRoute
+import dev.inmo.micro_utils.repos.ktor.common.key_value.*
+import dev.inmo.micro_utils.repos.ktor.common.reversedParameterName
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.request.get
+import io.ktor.http.*
+import io.ktor.util.reflect.TypeInfo
+import io.ktor.util.reflect.typeInfo
+import kotlinx.serialization.*
+
+class KtorReadStandardKeyValueRepoClient<Key, Value>(
+    private val baseUrl: String,
+    private val httpClient: HttpClient,
+    private val contentType: ContentType,
+    private val objectType: TypeInfo,
+    private val paginationResultObjectsTypeInfo: TypeInfo,
+    private val paginationResultIdsTypeInfo: TypeInfo,
+    private val idSerializer: suspend (Key) -> String,
+    private val valueSerializer: suspend (Value) -> String
+) : ReadStandardKeyValueRepo<Key, Value> {
+    override suspend fun get(k: Key): Value? = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            getRoute,
+            mapOf(
+                idParameterName to idSerializer(k)
+            )
+        )
+    ) {
+        contentType(contentType)
+    }.takeIf { it.status != HttpStatusCode.NoContent } ?.body<Value>(objectType)
+
+    override suspend fun contains(key: Key): Boolean = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            containsRoute,
+            idParameterName to idSerializer(key)
+        )
+    ) {
+        contentType(contentType)
+    }.body()
+
+    override suspend fun values(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Value> = httpClient.get(
+        buildStandardUrl(baseUrl, valuesRoute, pagination.asUrlQueryParts + (reversedParameterName to reversed.toString()))
+    ) {
+        contentType(contentType)
+    }.body(paginationResultObjectsTypeInfo)
+
+    override suspend fun keys(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> = httpClient.get(
+        buildStandardUrl(baseUrl, keysRoute, pagination.asUrlQueryParts + (reversedParameterName to reversed.toString()))
+    ) {
+        contentType(contentType)
+    }.body(paginationResultIdsTypeInfo)
+
+    override suspend fun keys(
+        v: Value,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            keysRoute,
+            pagination.asUrlQueryParts + (reversedParameterName to reversed.toString()) + (valueParameterName to valueSerializer(v))
+        )
+    ) {
+        contentType(contentType)
+    }.body(paginationResultIdsTypeInfo)
+
+    override suspend fun count(): Long = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            dev.inmo.micro_utils.repos.ktor.common.countRoute
+        )
+    ) {
+        contentType(contentType)
+    }.body()
+}
+
+inline fun <reified Key, reified Value> KtorReadStandardKeyValueRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    contentType: ContentType,
+    noinline idSerializer: suspend (Key) -> String,
+    noinline valueSerializer: suspend (Value) -> String
+) = KtorReadStandardKeyValueRepoClient<Key, Value>(
+    baseUrl,
+    httpClient,
+    contentType,
+    typeInfo<Value>(),
+    typeInfo<PaginationResult<Value>>(),
+    typeInfo<PaginationResult<Key>>(),
+    idSerializer,
+    valueSerializer
+)
+
+inline fun <reified Key, reified Value> KtorReadStandardKeyValueRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    idsSerializer: KSerializer<Key>,
+    valueSerializer: KSerializer<Value>,
+    serialFormat: StringFormat,
+    contentType: ContentType,
+) = KtorReadStandardKeyValueRepoClient<Key, Value>(
+    baseUrl,
+    httpClient,
+    contentType,
+    {
+        serialFormat.encodeToString(idsSerializer, it).encodeURLQueryComponent()
+    }
+) {
+    serialFormat.encodeToString(valueSerializer, it).encodeURLQueryComponent()
+}
+
+inline fun <reified Key, reified Value> KtorReadStandardKeyValueRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    idsSerializer: KSerializer<Key>,
+    valuesSerializer: KSerializer<Value>,
+    serialFormat: BinaryFormat,
+    contentType: ContentType,
+) = KtorReadStandardKeyValueRepoClient<Key, Value>(
+    baseUrl,
+    httpClient,
+    contentType,
+    {
+        serialFormat.encodeHex(idsSerializer, it)
+    }
+) {
+    serialFormat.encodeHex(valuesSerializer, it)
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorStandardKeyValueRepoClient.kt

@@ -0,0 +1,85 @@
+package dev.inmo.micro_utils.repos.ktor.client.key_value
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.repos.*
+import io.ktor.client.HttpClient
+import io.ktor.http.ContentType
+import io.ktor.http.encodeURLQueryComponent
+import kotlinx.serialization.*
+
+class KtorStandardKeyValueRepoClient<Key, Value> (
+    readDelegate: ReadStandardKeyValueRepo<Key, Value>,
+    writeDelegate: WriteStandardKeyValueRepo<Key, Value>
+) : StandardKeyValueRepo<Key, Value> by DelegateBasedStandardKeyValueRepo(
+    readDelegate,
+    writeDelegate
+) {
+    companion object {
+        inline operator fun <reified Key, reified Value> invoke(
+            baseUrl: String,
+            httpClient: HttpClient,
+            contentType: ContentType,
+            noinline idSerializer: suspend (Key) -> String,
+            noinline valueSerializer: suspend (Value) -> String
+        ) = KtorStandardKeyValueRepoClient(
+            KtorReadStandardKeyValueRepoClient(
+                baseUrl, httpClient, contentType, idSerializer, valueSerializer
+            ),
+            KtorWriteStandardKeyValueRepoClient(
+                baseUrl,
+                httpClient,
+                contentType
+            )
+        )
+        inline operator fun <reified Key, reified Value> invoke(
+            baseUrl: String,
+            subpart: String,
+            httpClient: HttpClient,
+            contentType: ContentType,
+            noinline idSerializer: suspend (Key) -> String,
+            noinline valueSerializer: suspend (Value) -> String
+        ) = KtorStandardKeyValueRepoClient(
+            buildStandardUrl(baseUrl, subpart),
+            httpClient,
+            contentType,
+            idSerializer,
+            valueSerializer
+        )
+    }
+}
+
+inline fun <reified Key, reified Value> KtorStandardKeyValueRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    contentType: ContentType,
+    idSerializer: SerializationStrategy<Key>,
+    valueSerializer: SerializationStrategy<Value>,
+    serialFormat: StringFormat,
+) = KtorStandardKeyValueRepoClient<Key, Value>(
+    baseUrl,
+    httpClient,
+    contentType,
+    {
+        serialFormat.encodeToString(idSerializer, it).encodeURLQueryComponent()
+    }
+) {
+    serialFormat.encodeToString(valueSerializer, it).encodeURLQueryComponent()
+}
+
+inline fun <reified Key, reified Value> KtorStandardKeyValueRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    contentType: ContentType,
+    idSerializer: SerializationStrategy<Key>,
+    valueSerializer: SerializationStrategy<Value>,
+    serialFormat: BinaryFormat,
+) = KtorStandardKeyValueRepoClient<Key, Value>(
+    baseUrl,
+    httpClient,
+    contentType,
+    {
+        serialFormat.encodeHex(idSerializer, it)
+    }
+) {
+    serialFormat.encodeHex(valueSerializer, it)
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorWriteStandardKeyValueRepoClient.kt

@@ -0,0 +1,79 @@
+package dev.inmo.micro_utils.repos.ktor.client.key_value
+
+import dev.inmo.micro_utils.ktor.client.createStandardWebsocketFlow
+import dev.inmo.micro_utils.ktor.client.throwOnUnsuccess
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.repos.WriteStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.key_value.*
+import io.ktor.client.HttpClient
+import io.ktor.client.request.post
+import io.ktor.http.*
+import io.ktor.util.InternalAPI
+import io.ktor.util.reflect.TypeInfo
+import io.ktor.util.reflect.typeInfo
+import kotlinx.coroutines.flow.Flow
+
+class KtorWriteStandardKeyValueRepoClient<Key, Value>(
+    private val baseUrl: String,
+    private val httpClient: HttpClient,
+    private val contentType: ContentType,
+    override val onNewValue: Flow<Pair<Key, Value>>,
+    override val onValueRemoved: Flow<Key>,
+    private val idsListTypeInfo: TypeInfo,
+    private val objectsListTypeInfo: TypeInfo,
+    private val idsToObjectsMapTypeInfo: TypeInfo
+) : WriteStandardKeyValueRepo<Key, Value> {
+    @OptIn(InternalAPI::class)
+    override suspend fun unsetWithValues(toUnset: List<Value>) {
+        httpClient.post(
+            buildStandardUrl(baseUrl, unsetWithValuesRoute)
+        ) {
+            body = toUnset
+            bodyType = objectsListTypeInfo
+            contentType(contentType)
+        }.throwOnUnsuccess { "Unable to unset data with values $toUnset" }
+    }
+
+    @OptIn(InternalAPI::class)
+    override suspend fun unset(toUnset: List<Key>) {
+        httpClient.post(
+            buildStandardUrl(baseUrl, unsetRoute)
+        ) {
+            body = toUnset
+            bodyType = idsListTypeInfo
+            contentType(contentType)
+        }.throwOnUnsuccess { "Unable to unset $toUnset" }
+    }
+
+    @OptIn(InternalAPI::class)
+    override suspend fun set(toSet: Map<Key, Value>) {
+        httpClient.post(
+            buildStandardUrl(baseUrl, setRoute)
+        ) {
+            body = toSet
+            bodyType = idsToObjectsMapTypeInfo
+            contentType(contentType)
+        }.throwOnUnsuccess { "Unable to set $toSet" }
+    }
+
+    companion object {
+        inline operator fun <reified Key, reified Value> invoke(
+            baseUrl: String,
+            httpClient: HttpClient,
+            contentType: ContentType
+        ) = KtorWriteStandardKeyValueRepoClient<Key, Value>(
+            baseUrl,
+            httpClient,
+            contentType,
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onNewValueRoute),
+            ),
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onValueRemovedRoute),
+            ),
+            typeInfo<List<Key>>(),
+            typeInfo<List<Value>>(),
+            typeInfo<Map<Key, Value>>()
+        )
+    }
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorReadStandardKeyValuesRepoClient.kt

@@ -0,0 +1,159 @@
+package dev.inmo.micro_utils.repos.ktor.client.one_to_many
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.*
+import dev.inmo.micro_utils.repos.ktor.common.crud.*
+import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
+import dev.inmo.micro_utils.repos.ktor.common.reversedParameterName
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.request.get
+import io.ktor.http.*
+import io.ktor.util.reflect.TypeInfo
+import io.ktor.util.reflect.typeInfo
+import kotlinx.serialization.*
+
+class KtorReadStandardKeyValuesRepoClient<Key, Value>(
+    private val baseUrl: String,
+    private val httpClient: HttpClient,
+    private val contentType: ContentType,
+    private val paginationResultValuesTypeInfo: TypeInfo,
+    private val paginationResultKeysTypeInfo: TypeInfo,
+    private val keySerializer: suspend (Key) -> String,
+    private val valueSerializer: suspend (Value) -> String
+) : ReadOneToManyKeyValueRepo<Key, Value> {
+    override suspend fun get(
+        k: Key,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Value> = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            getRoute,
+            pagination.asUrlQueryParts + (reversedParameterName to reversed.toString()) + (keyParameterName to keySerializer(k))
+        )
+    ) {
+        contentType(contentType)
+    }.body(paginationResultValuesTypeInfo)
+
+    override suspend fun keys(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            keysRoute,
+            pagination.asUrlQueryParts + (reversedParameterName to reversed.toString())
+        )
+    ) {
+        contentType(contentType)
+    }.body(paginationResultKeysTypeInfo)
+
+    override suspend fun keys(
+        v: Value,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            keysRoute,
+            pagination.asUrlQueryParts + (reversedParameterName to reversed.toString()) + (valueParameterName to valueSerializer(v))
+        )
+    ) {
+        contentType(contentType)
+    }.body(paginationResultKeysTypeInfo)
+
+    override suspend fun contains(k: Key): Boolean = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            containsRoute,
+            keyParameterName to keySerializer(k)
+        )
+    ) {
+        contentType(contentType)
+    }.body()
+
+    override suspend fun contains(k: Key, v: Value): Boolean = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            containsRoute,
+            keyParameterName to keySerializer(k),
+            valueParameterName to valueSerializer(v)
+        )
+    ) {
+        contentType(contentType)
+    }.body()
+
+    override suspend fun count(): Long = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            countRouting
+        )
+    ) {
+        contentType(contentType)
+    }.body()
+
+    override suspend fun count(k: Key): Long = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            countRouting,
+            keyParameterName to keySerializer(k),
+        )
+    ) {
+        contentType(contentType)
+    }.body()
+}
+
+inline fun <reified Key, reified Value> KtorReadStandardKeyValuesRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    contentType: ContentType,
+    noinline keySerializer: suspend (Key) -> String,
+    noinline valueSerializer: suspend (Value) -> String
+) = KtorReadStandardKeyValuesRepoClient<Key, Value>(
+    baseUrl,
+    httpClient,
+    contentType,
+    typeInfo<PaginationResult<Value>>(),
+    typeInfo<PaginationResult<Key>>(),
+    keySerializer,
+    valueSerializer
+)
+
+inline fun <reified Key, reified Value> KtorReadStandardKeyValuesRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    idsSerializer: KSerializer<Key>,
+    valueSerializer: KSerializer<Value>,
+    serialFormat: StringFormat,
+    contentType: ContentType,
+) = KtorReadStandardKeyValuesRepoClient<Key, Value>(
+    baseUrl,
+    httpClient,
+    contentType,
+    {
+        serialFormat.encodeToString(idsSerializer, it).encodeURLQueryComponent()
+    }
+) {
+    serialFormat.encodeToString(valueSerializer, it).encodeURLQueryComponent()
+}
+
+inline fun <reified Key, reified Value> KtorReadStandardKeyValuesRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    idsSerializer: KSerializer<Key>,
+    valuesSerializer: KSerializer<Value>,
+    serialFormat: BinaryFormat,
+    contentType: ContentType,
+) = KtorReadStandardKeyValuesRepoClient<Key, Value>(
+    baseUrl,
+    httpClient,
+    contentType,
+    {
+        serialFormat.encodeHex(idsSerializer, it)
+    }
+) {
+    serialFormat.encodeHex(valuesSerializer, it)
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorStandardKeyValuesRepoClient.kt

@@ -0,0 +1,89 @@
+package dev.inmo.micro_utils.repos.ktor.client.one_to_many
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.repos.*
+import io.ktor.client.HttpClient
+import io.ktor.http.ContentType
+import io.ktor.http.encodeURLQueryComponent
+import kotlinx.serialization.*
+
+class KtorStandardKeyValuesRepoClient<Key, Value> (
+    readDelegate: ReadOneToManyKeyValueRepo<Key, Value>,
+    writeDelegate: WriteOneToManyKeyValueRepo<Key, Value>
+) : OneToManyKeyValueRepo<Key, Value> by DelegateBasedOneToManyKeyValueRepo(
+    readDelegate,
+    writeDelegate
+) {
+    companion object {
+        inline operator fun <reified Key : Any, reified Value : Any> invoke(
+            baseUrl: String,
+            httpClient: HttpClient,
+            contentType: ContentType,
+            noinline keySerializer: suspend (Key) -> String,
+            noinline valueSerializer: suspend (Value) -> String
+        ) = KtorStandardKeyValuesRepoClient(
+            KtorReadStandardKeyValuesRepoClient(
+                baseUrl,
+                httpClient,
+                contentType,
+                keySerializer,
+                valueSerializer
+            ),
+            KtorWriteStandardKeyValuesRepoClient(
+                baseUrl,
+                httpClient,
+                contentType
+            )
+        )
+        inline operator fun <reified Key : Any, reified Value : Any> invoke(
+            baseUrl: String,
+            subpart: String,
+            httpClient: HttpClient,
+            contentType: ContentType,
+            noinline keySerializer: suspend (Key) -> String,
+            noinline valueSerializer: suspend (Value) -> String
+        ) = KtorStandardKeyValuesRepoClient(
+            buildStandardUrl(baseUrl, subpart),
+            httpClient,
+            contentType,
+            keySerializer,
+            valueSerializer
+        )
+    }
+}
+
+inline fun <reified Key : Any, reified Value : Any> KtorStandardKeyValuesRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    contentType: ContentType,
+    keySerializer: SerializationStrategy<Key>,
+    valueSerializer: SerializationStrategy<Value>,
+    serialFormat: StringFormat,
+) = KtorStandardKeyValuesRepoClient<Key, Value>(
+    baseUrl,
+    httpClient,
+    contentType,
+    {
+        serialFormat.encodeToString(keySerializer, it).encodeURLQueryComponent()
+    }
+) {
+    serialFormat.encodeToString(valueSerializer, it).encodeURLQueryComponent()
+}
+
+inline fun <reified Key : Any, reified Value : Any> KtorStandardKeyValuesRepoClient(
+    baseUrl: String,
+    httpClient: HttpClient,
+    contentType: ContentType,
+    keySerializer: SerializationStrategy<Key>,
+    valueSerializer: SerializationStrategy<Value>,
+    serialFormat: BinaryFormat,
+) = KtorStandardKeyValuesRepoClient<Key, Value>(
+    baseUrl,
+    httpClient,
+    contentType,
+    {
+        serialFormat.encodeHex(keySerializer, it)
+    }
+) {
+    serialFormat.encodeHex(valueSerializer, it)
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorWriteStandardKeyValuesRepoClient.kt

@@ -0,0 +1,106 @@
+package dev.inmo.micro_utils.repos.ktor.client.one_to_many
+
+import dev.inmo.micro_utils.ktor.client.createStandardWebsocketFlow
+import dev.inmo.micro_utils.ktor.client.throwOnUnsuccess
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.repos.WriteOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
+import io.ktor.client.HttpClient
+import io.ktor.client.request.post
+import io.ktor.http.*
+import io.ktor.util.InternalAPI
+import io.ktor.util.reflect.TypeInfo
+import io.ktor.util.reflect.typeInfo
+import kotlinx.coroutines.flow.Flow
+
+class KtorWriteStandardKeyValuesRepoClient<Key : Any, Value : Any>(
+    private val baseUrl: String,
+    private val httpClient: HttpClient,
+    private val contentType: ContentType,
+    override val onNewValue: Flow<Pair<Key, Value>>,
+    override val onValueRemoved: Flow<Pair<Key, Value>>,
+    override val onDataCleared: Flow<Key>,
+    private val keyTypeInfo: TypeInfo,
+    private val valueTypeInfo: TypeInfo,
+    private val keyToValuesMapTypeInfo: TypeInfo
+) : WriteOneToManyKeyValueRepo<Key, Value> {
+
+    @OptIn(InternalAPI::class)
+    override suspend fun add(toAdd: Map<Key, List<Value>>) {
+        httpClient.post(
+            buildStandardUrl(baseUrl, addRoute)
+        ) {
+            body = toAdd
+            bodyType = keyToValuesMapTypeInfo
+            contentType(contentType)
+        }.throwOnUnsuccess { "Unable to add $toAdd" }
+    }
+
+    @OptIn(InternalAPI::class)
+    override suspend fun remove(toRemove: Map<Key, List<Value>>) {
+        httpClient.post(
+            buildStandardUrl(baseUrl, removeRoute)
+        ) {
+            body = toRemove
+            bodyType = keyToValuesMapTypeInfo
+            contentType(contentType)
+        }.throwOnUnsuccess { "Unable to remove $toRemove" }
+    }
+
+    @OptIn(InternalAPI::class)
+    override suspend fun clear(k: Key) {
+        httpClient.post(
+            buildStandardUrl(baseUrl, clearRoute)
+        ) {
+            body = k
+            bodyType = keyTypeInfo
+            contentType(contentType)
+        }.throwOnUnsuccess { "Unable to clear data with key $k" }
+    }
+
+    @OptIn(InternalAPI::class)
+    override suspend fun clearWithValue(v: Value) {
+        httpClient.post(
+            buildStandardUrl(baseUrl, clearWithValueRoute)
+        ) {
+            body = v
+            bodyType = valueTypeInfo
+            contentType(contentType)
+        }.throwOnUnsuccess { "Unable to clear data with value $v" }
+    }
+
+    @OptIn(InternalAPI::class)
+    override suspend fun set(toSet: Map<Key, List<Value>>) {
+        httpClient.post(
+            buildStandardUrl(baseUrl, setRoute)
+        ) {
+            body = toSet
+            bodyType = keyToValuesMapTypeInfo
+            contentType(contentType)
+        }.throwOnUnsuccess { "Unable to set data $toSet" }
+    }
+
+    companion object {
+        inline operator fun <reified Key : Any, reified Value : Any> invoke(
+            baseUrl: String,
+            httpClient: HttpClient,
+            contentType: ContentType
+        ) = KtorWriteStandardKeyValuesRepoClient<Key, Value>(
+            baseUrl,
+            httpClient,
+            contentType,
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onNewValueRoute),
+            ),
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onValueRemovedRoute),
+            ),
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onDataClearedRoute),
+            ),
+            typeInfo<Key>(),
+            typeInfo<Value>(),
+            typeInfo<Map<Key, List<Value>>>()
+        )
+    }
+}

repos/ktor/common/build.gradle

@@ -13,5 +13,22 @@ kotlin {
                 api internalProject("micro_utils.repos.common")
             }
         }
+        jvmTest {
+            dependencies {
+                implementation internalProject("micro_utils.repos.common")
+                implementation internalProject("micro_utils.repos.ktor.client")
+                implementation internalProject("micro_utils.repos.ktor.server")
+                implementation internalProject("micro_utils.repos.inmemory")
+                implementation libs.kt.coroutines.test
+
+                implementation libs.ktor.server.cio
+                implementation libs.ktor.client.cio
+                implementation libs.ktor.server.content.negotiation
+                implementation libs.ktor.serialization.kotlinx.json
+                implementation libs.ktor.client.content.negotiation
+                implementation libs.ktor.client.logging
+                implementation libs.ktor.client.websockets
+            }
+        }
     }
 }

repos/ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/common/ContainsRoute.kt

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.repos.ktor.common
+
+const val containsRoute = "contains"

repos/ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/common/CountRoute.kt

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.repos.ktor.common
+
+const val countRoute = "count"

repos/ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/common/CountRouting.kt

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.repos.ktor.common
+
+const val countRouting = "count"

repos/ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/common/ParametersNames.kt

@@ -1,5 +1,6 @@
 package dev.inmo.micro_utils.repos.ktor.common
 
+const val idParameterName = "id"
 const val keyParameterName = "key"
 const val valueParameterName = "value"
-const val reversedParameterName = "reversed"
+const val reversedParameterName = "reversed"

repos/ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/common/crud/CrudReadRoutes.kt

@@ -3,4 +3,3 @@ package dev.inmo.micro_utils.repos.ktor.common.crud
 const val getByPaginationRouting = "getByPagination"
 const val getByIdRouting = "getById"
 const val containsRouting = "contains"
-const val countRouting = "count"

repos/ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/common/key_value/KeyValueRoutes.kt

@@ -3,11 +3,11 @@ package dev.inmo.micro_utils.repos.ktor.common.key_value
 const val getRoute = "get"
 const val valuesRoute = "values"
 const val keysRoute = "keys"
-const val containsRoute = "contains"
-const val countRoute = "count"
+const val containsRoute = dev.inmo.micro_utils.repos.ktor.common.containsRoute
+const val countRoute = dev.inmo.micro_utils.repos.ktor.common.countRoute
 
 const val onNewValueRoute = "onNewValue"
 const val onValueRemovedRoute = "onValueRemoved"
 const val setRoute = "set"
 const val unsetRoute = "unset"
-const val unsetWithValuesRoute = "unsetWithValues"
+const val unsetWithValuesRoute = "unsetWithValues"

repos/ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/common/one_to_many/OneToManyRoutes.kt

@@ -5,7 +5,7 @@ const val keysRoute = "keys"
 const val containsByKeyRoute = "containsByKey"
 const val containsByKeyValueRoute = "containsByKeyValue"
 const val countByKeyRoute = "countByKey"
-const val countRoute = "count"
+const val countRoute = dev.inmo.micro_utils.repos.ktor.common.countRoute
 
 const val onNewValueRoute = "onNewValue"
 const val onValueRemovedRoute = "onValueRemoved"

repos/ktor/common/src/jvmTest/kotlin/CRUDTests.kt

@@ -0,0 +1,89 @@
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.ktor.client.crud.KtorStandardCrudRepoClient
+import dev.inmo.micro_utils.repos.ktor.server.crud.configureStandardCrudRepoRoutes
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.logging.Logging
+import io.ktor.http.ContentType
+import io.ktor.serialization.kotlinx.KotlinxWebsocketSerializationConverter
+import io.ktor.serialization.kotlinx.json.json
+import io.ktor.server.application.install
+import io.ktor.server.cio.CIO
+import io.ktor.server.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.server.routing.routing
+import io.ktor.server.websocket.WebSockets
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.json.Json
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class CRUDTests {
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun testCRUDFunctions() {
+        runTest {
+            val map = mutableMapOf<Int, ComplexData>()
+            val repo = MapCRUDRepo<ComplexData, Int, SimpleData>(
+                map,
+                { newValue, id, oldValue ->
+                    oldValue.copy(title = newValue.title)
+                }
+            ) {
+                size to ComplexData(size, title = it.title)
+            }
+            val server = io.ktor.server.engine.embeddedServer(
+                CIO,
+                23456,
+                "127.0.0.1"
+            ) {
+                install(ContentNegotiation) {
+                    json()
+                }
+                install(WebSockets) {
+                    contentConverter = KotlinxWebsocketSerializationConverter(Json)
+                }
+                routing {
+                    configureStandardCrudRepoRoutes(
+                        repo
+                    ) {
+                        it.toInt()
+                    }
+                }
+            }.start(false)
+            val client = HttpClient {
+                install(io.ktor.client.plugins.contentnegotiation.ContentNegotiation) {
+                    json()
+                }
+                install(Logging)
+                install(io.ktor.client.plugins.websocket.WebSockets) {
+                    contentConverter = KotlinxWebsocketSerializationConverter(Json)
+                }
+            }
+            val crudClient = KtorStandardCrudRepoClient<ComplexData, Int, SimpleData>(
+                "http://127.0.0.1:23456",
+                client,
+                ContentType.Application.Json
+            ) {
+                it.toString()
+            }
+
+            val created = crudClient.create(SimpleData("Example")).single()
+            assertEquals(map.size, 1)
+            assertEquals(map.size.toLong(), crudClient.count())
+            assertEquals(1, crudClient.count())
+            assertEquals(map.getValue(map.keys.first()), created)
+
+            val updated = crudClient.update(created.id, SimpleData("Example2"))
+            assertEquals(map.size, 1)
+            assertEquals(map.size.toLong(), crudClient.count())
+            assertEquals(1, crudClient.count())
+            assertEquals(map.getValue(map.keys.first()), updated)
+
+            crudClient.deleteById(created.id)
+            assertEquals(map.size, 0)
+            assertEquals(map.size.toLong(), crudClient.count())
+            assertEquals(0, crudClient.count())
+            server.stop()
+        }
+    }
+}

repos/ktor/common/src/jvmTest/kotlin/ComplexData.kt

@@ -0,0 +1,10 @@
+import com.benasher44.uuid.uuid4
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ComplexData(
+    val id: Int,
+    val simple: SimpleData = SimpleData(),
+    val simples: List<SimpleData> = (0 until 100).map { SimpleData(("$it")) },
+    val title: String = uuid4().toString()
+)

repos/ktor/common/src/jvmTest/kotlin/KVTests.kt

@@ -0,0 +1,139 @@
+import dev.inmo.micro_utils.pagination.firstPageWithOneElementPagination
+import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.ktor.client.key_value.KtorStandardKeyValueRepoClient
+import dev.inmo.micro_utils.repos.ktor.server.key_value.configureStandardKeyValueRepoRoutes
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.logging.Logging
+import io.ktor.http.ContentType
+import io.ktor.serialization.kotlinx.KotlinxWebsocketSerializationConverter
+import io.ktor.serialization.kotlinx.json.json
+import io.ktor.server.application.install
+import io.ktor.server.cio.CIO
+import io.ktor.server.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.server.routing.routing
+import io.ktor.server.websocket.WebSockets
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.json.Json
+import kotlin.test.*
+
+class KVTests {
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun testKVFunctions() {
+        runTest {
+            val map = mutableMapOf<Int, ComplexData>()
+            val repo = MapKeyValueRepo<Int, ComplexData>(map)
+            val server = io.ktor.server.engine.embeddedServer(
+                CIO,
+                23456,
+                "127.0.0.1"
+            ) {
+                install(ContentNegotiation) {
+                    json()
+                }
+                install(WebSockets) {
+                    contentConverter = KotlinxWebsocketSerializationConverter(Json)
+                }
+                routing {
+                    configureStandardKeyValueRepoRoutes(
+                        repo,
+                        Int.serializer(),
+                        ComplexData.serializer(),
+                        Json {}
+                    )
+                }
+            }.start(false)
+            val client = HttpClient {
+                install(io.ktor.client.plugins.contentnegotiation.ContentNegotiation) {
+                    json()
+                }
+                install(Logging)
+                install(io.ktor.client.plugins.websocket.WebSockets) {
+                    contentConverter = KotlinxWebsocketSerializationConverter(Json)
+                }
+            }
+            val crudClient = KtorStandardKeyValueRepoClient<Int, ComplexData>(
+                "http://127.0.0.1:23456",
+                client,
+                ContentType.Application.Json,
+                Int.serializer(),
+                ComplexData.serializer(),
+                Json
+            )
+
+            val dataInOneKey = ComplexData(1, title = "Example1")
+            val dataInMultipleKeys = ComplexData(2, title = "Example2")
+            val repeatCount = 3
+
+            val dataList = listOf(
+                1 to dataInOneKey
+            ) + (0 until repeatCount).map {
+                (it + 2) to dataInMultipleKeys
+            }
+
+            dataList.forEachIndexed { i, (id, data) ->
+                crudClient.set(id, data)
+                assertEquals(map.size, i + 1)
+                assertEquals(map.size.toLong(), crudClient.count())
+                assertEquals(i + 1L, crudClient.count())
+                dataList.take(i + 1).forEach { (id, data) ->
+                    assertEquals(data, map[id])
+                    assertEquals(data, crudClient.get(id))
+                    assertEquals(map[id], crudClient.get(id))
+                }
+            }
+
+            dataList.forEach { (id, data) ->
+                assertTrue(crudClient.contains(id))
+                assertEquals(data, crudClient.get(id))
+            }
+
+            assertEquals(
+                dataList.mapNotNull { if (it.second == dataInMultipleKeys) it.first else null },
+                getAllWithNextPaging(firstPageWithOneElementPagination) {
+                    crudClient.keys(dataInMultipleKeys, it)
+                }
+            )
+
+            assertEquals(
+                dataList.mapNotNull { if (it.second == dataInOneKey) it.first else null },
+                getAllWithNextPaging(firstPageWithOneElementPagination) {
+                    crudClient.keys(dataInOneKey, it)
+                }
+            )
+
+            assertEquals(
+                dataList.map { it.first },
+                getAllWithNextPaging(firstPageWithOneElementPagination) {
+                    crudClient.keys(it)
+                }
+            )
+
+            assertEquals(
+                dataList.map { it.second },
+                getAllWithNextPaging(firstPageWithOneElementPagination) {
+                    crudClient.values(it)
+                }
+            )
+
+            assertEquals(dataList.size.toLong(), crudClient.count())
+
+            crudClient.unsetWithValues(dataInMultipleKeys)
+            assertEquals(
+                dataList.filter { it.second == dataInOneKey }.size.toLong(),
+                crudClient.count()
+            )
+
+            crudClient.unset(dataList.first { it.second == dataInOneKey }.first)
+            assertEquals(
+                0,
+                crudClient.count()
+            )
+
+            server.stop()
+        }
+    }
+}

repos/ktor/common/src/jvmTest/kotlin/KVsTests.kt

@@ -0,0 +1,141 @@
+import dev.inmo.micro_utils.pagination.firstPageWithOneElementPagination
+import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.ktor.client.key_value.KtorStandardKeyValueRepoClient
+import dev.inmo.micro_utils.repos.ktor.client.one_to_many.KtorStandardKeyValuesRepoClient
+import dev.inmo.micro_utils.repos.ktor.server.one_to_many.configureStandardKeyValuesRepoRoutes
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.logging.Logging
+import io.ktor.http.ContentType
+import io.ktor.serialization.kotlinx.KotlinxWebsocketSerializationConverter
+import io.ktor.serialization.kotlinx.json.json
+import io.ktor.server.application.install
+import io.ktor.server.cio.CIO
+import io.ktor.server.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.server.routing.routing
+import io.ktor.server.websocket.WebSockets
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.json.Json
+import kotlin.test.*
+
+class KVsTests {
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun testKVsFunctions() {
+        runTest {
+            val map = mutableMapOf<Int, MutableList<ComplexData>>()
+            val repo = MapOneToManyKeyValueRepo(map)
+            val server = io.ktor.server.engine.embeddedServer(
+                CIO,
+                23456,
+                "127.0.0.1"
+            ) {
+                install(ContentNegotiation) {
+                    json()
+                }
+                install(WebSockets) {
+                    contentConverter = KotlinxWebsocketSerializationConverter(Json)
+                }
+                routing {
+                    configureStandardKeyValuesRepoRoutes(
+                        repo,
+                        Int.serializer(),
+                        ComplexData.serializer(),
+                        Json {}
+                    )
+                }
+            }.start(false)
+            val client = HttpClient {
+                install(io.ktor.client.plugins.contentnegotiation.ContentNegotiation) {
+                    json()
+                }
+                install(Logging)
+                install(io.ktor.client.plugins.websocket.WebSockets) {
+                    contentConverter = KotlinxWebsocketSerializationConverter(Json)
+                }
+            }
+            val crudClient = KtorStandardKeyValuesRepoClient(
+                "http://127.0.0.1:23456",
+                client,
+                ContentType.Application.Json,
+                Int.serializer(),
+                ComplexData.serializer(),
+                Json
+            )
+
+            val dataInOneKey = ComplexData(1, title = "Example1")
+            val dataInMultipleKeys = ComplexData(2, title = "Example2")
+            val repeatCount = 3
+
+            val dataList = listOf(
+                1 to listOf(dataInOneKey)
+            ) + (0 until repeatCount).map {
+                (it + 2) to listOf(dataInMultipleKeys)
+            }
+
+            dataList.forEachIndexed { i, (id, data) ->
+                crudClient.set(id, data)
+                assertEquals(i + 1, map.size)
+                assertEquals(map.size.toLong(), crudClient.count())
+                assertEquals(i + 1L, crudClient.count())
+                dataList.take(i + 1).forEach { (id, data) ->
+                    assertContentEquals(data, map[id])
+                    assertContentEquals(data, crudClient.getAll(id))
+                    assertContentEquals(map[id], crudClient.getAll(id))
+                }
+            }
+
+            dataList.forEach { (key, data) ->
+                assertTrue(crudClient.contains(key))
+                assertContentEquals(data, crudClient.getAll(key))
+            }
+
+            assertEquals(
+                dataList.mapNotNull { if (it.second.contains(dataInMultipleKeys)) it.first else null },
+                getAllWithNextPaging(firstPageWithOneElementPagination) {
+                    crudClient.keys(dataInMultipleKeys, it)
+                }
+            )
+
+            assertEquals(
+                dataList.mapNotNull { if (it.second.contains(dataInOneKey)) it.first else null },
+                getAllWithNextPaging(firstPageWithOneElementPagination) {
+                    crudClient.keys(dataInOneKey, it)
+                }
+            )
+
+            assertEquals(
+                dataList.map { it.first },
+                getAllWithNextPaging(firstPageWithOneElementPagination) {
+                    crudClient.keys(it)
+                }
+            )
+
+            assertEquals(
+                dataList.map { it.first },
+                getAllWithNextPaging(firstPageWithOneElementPagination) {
+                    crudClient.keys(it)
+                }
+            )
+
+            assertEquals(dataList.size.toLong(), crudClient.count())
+
+            crudClient.remove(dataList.filter { it.second.contains(dataInMultipleKeys) })
+            println(map)
+            assertEquals(
+                dataList.filter { it.second.contains(dataInOneKey) }.size.toLong(),
+                crudClient.count()
+            )
+
+            crudClient.remove(dataList.filter { it.second.contains(dataInOneKey) })
+            assertEquals(
+                0,
+                crudClient.count()
+            )
+
+            server.stop()
+        }
+    }
+}

repos/ktor/common/src/jvmTest/kotlin/SimpleData.kt

@@ -0,0 +1,7 @@
+import com.benasher44.uuid.uuid4
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class SimpleData(
+    val title: String = uuid4().toString()
+)

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorReadStandardCrudRepo.kt

@@ -6,6 +6,7 @@ import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
 import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ktor.common.countRouting
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import io.ktor.http.ContentType
 import io.ktor.server.application.call

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/NewKtorReadStandardCrudRepo.kt

@@ -0,0 +1,73 @@
+package dev.inmo.micro_utils.repos.ktor.server.crud
+
+import dev.inmo.micro_utils.ktor.common.decodeHex
+import dev.inmo.micro_utils.ktor.server.*
+import dev.inmo.micro_utils.pagination.extractPagination
+import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ktor.common.countRouting
+import dev.inmo.micro_utils.repos.ktor.common.crud.*
+import dev.inmo.micro_utils.repos.ktor.common.idParameterName
+import io.ktor.http.ContentType
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.application.call
+import io.ktor.server.response.respond
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.get
+import kotlinx.serialization.*
+
+inline fun <reified ObjectType, reified IdType> Route.configureReadStandardCrudRepoRoutes(
+    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+    noinline idDeserializer: suspend (String) -> IdType
+) {
+    get(getByPaginationRouting) {
+        val pagination = call.request.queryParameters.extractPagination
+
+        call.respond(originalRepo.getByPagination(pagination))
+    }
+
+    get(getByIdRouting) {
+        val id = idDeserializer(
+            call.getQueryParameterOrSendError(idParameterName) ?: return@get
+        )
+
+        val result = originalRepo.getById(id)
+
+        if (result == null) {
+            call.respond(HttpStatusCode.NoContent)
+        } else {
+            call.respond(result)
+        }
+    }
+
+    get(containsRouting) {
+        val id = idDeserializer(
+            call.getQueryParameterOrSendError(idParameterName) ?: return@get
+        )
+
+        call.respond(
+            originalRepo.contains(id)
+        )
+    }
+
+    get(countRouting) {
+        call.respond(
+            originalRepo.count()
+        )
+    }
+}
+
+inline fun <reified ObjectType, reified IdType> Route.configureReadStandardCrudRepoRoutes(
+    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StringFormat
+) = configureReadStandardCrudRepoRoutes(originalRepo) {
+    serialFormat.decodeFromString(idsSerializer, it)
+}
+
+inline fun <reified ObjectType, reified IdType> Route.configureReadStandardCrudRepoRoutes(
+    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: BinaryFormat
+) = configureReadStandardCrudRepoRoutes(originalRepo) {
+    serialFormat.decodeHex(idsSerializer, it)
+}

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/NewKtorStandardCrudRepo.kt

@@ -0,0 +1,34 @@
+package dev.inmo.micro_utils.repos.ktor.server.crud
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.ktor.server.UnifiedRouter
+import dev.inmo.micro_utils.ktor.server.standardKtorSerialFormatContentType
+import dev.inmo.micro_utils.repos.StandardCRUDRepo
+import io.ktor.http.ContentType
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.route
+import kotlinx.serialization.*
+
+inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureStandardCrudRepoRoutes(
+    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
+    noinline idDeserializer: suspend (String) -> IdType
+) {
+    configureReadStandardCrudRepoRoutes(originalRepo, idDeserializer)
+    configureWriteStandardCrudRepoRoutes(originalRepo)
+}
+
+inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureStandardCrudRepoRoutes(
+    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StringFormat
+) = configureStandardCrudRepoRoutes(originalRepo) {
+    serialFormat.decodeFromString(idsSerializer, it)
+}
+
+inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureStandardCrudRepoRoutes(
+    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: BinaryFormat
+) = configureStandardCrudRepoRoutes(originalRepo) {
+    serialFormat.decodeHex(idsSerializer, it)
+}

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/NewKtorWriteStandardCrudRepo.kt

@@ -0,0 +1,39 @@
+package dev.inmo.micro_utils.repos.ktor.server.crud
+
+import dev.inmo.micro_utils.ktor.server.*
+import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ktor.common.crud.*
+import io.ktor.server.application.call
+import io.ktor.server.request.receive
+import io.ktor.server.response.respond
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.post
+
+inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureWriteStandardCrudRepoRoutes(
+    originalRepo: WriteStandardCRUDRepo<ObjectType, IdType, InputValue>
+) {
+    includeWebsocketHandling(
+        newObjectsFlowRouting,
+        originalRepo.newObjectsFlow,
+    )
+    includeWebsocketHandling(
+        updatedObjectsFlowRouting,
+        originalRepo.updatedObjectsFlow
+    )
+    includeWebsocketHandling(
+        deletedObjectsIdsFlowRouting,
+        originalRepo.deletedObjectsIdsFlow
+    )
+
+    post(createRouting) {
+        call.respond(originalRepo.create(call.receive()))
+    }
+
+    post(updateManyRouting) {
+        call.respond(originalRepo.update(call.receive()))
+    }
+
+    post(deleteByIdRouting) {
+        call.respond(originalRepo.deleteById(call.receive()))
+    }
+}

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartReadKeyValueRepo.kt

@@ -6,8 +6,12 @@ import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
 import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.*
+import dev.inmo.micro_utils.repos.ktor.common.containsRoute
+import dev.inmo.micro_utils.repos.ktor.common.countRoute
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
-import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
+import dev.inmo.micro_utils.repos.ktor.common.key_value.keyParameterName
+import dev.inmo.micro_utils.repos.ktor.common.key_value.reversedParameterName
 import io.ktor.http.ContentType
 import io.ktor.server.application.call
 import io.ktor.server.routing.Route

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/NewKtorStandartKeyValueRepo.kt

@@ -0,0 +1,58 @@
+package dev.inmo.micro_utils.repos.ktor.server.key_value
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.ktor.server.*
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.pagination.extractPagination
+import dev.inmo.micro_utils.repos.StandardCRUDRepo
+import dev.inmo.micro_utils.repos.StandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.idParameterName
+import dev.inmo.micro_utils.repos.ktor.common.key_value.*
+import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
+import io.ktor.http.*
+import io.ktor.server.application.call
+import io.ktor.server.response.respond
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.get
+import kotlinx.serialization.*
+import kotlinx.serialization.builtins.serializer
+
+inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValueRepoRoutes (
+    originalRepo: StandardKeyValueRepo<Key, Value>,
+    noinline idDeserializer: suspend (String) -> Key,
+    noinline valueDeserializer: suspend (String) -> Value
+) {
+    configureReadStandardKeyValueRepoRoutes(originalRepo, idDeserializer, valueDeserializer)
+    configureWriteStandardKeyValueRepoRoutes(originalRepo)
+}
+
+inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValueRepoRoutes(
+    originalRepo: StandardKeyValueRepo<Key, Value>,
+    idsSerializer: DeserializationStrategy<Key>,
+    valueSerializer: DeserializationStrategy<Value>,
+    serialFormat: StringFormat
+) = configureStandardKeyValueRepoRoutes(
+    originalRepo,
+    {
+        serialFormat.decodeFromString(idsSerializer, it.decodeURLQueryComponent())
+    },
+    {
+        serialFormat.decodeFromString(valueSerializer, it.decodeURLQueryComponent())
+    }
+)
+
+inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValueRepoRoutes(
+    originalRepo: StandardKeyValueRepo<Key, Value>,
+    idsSerializer: DeserializationStrategy<Key>,
+    valueSerializer: DeserializationStrategy<Value>,
+    serialFormat: BinaryFormat
+) = configureStandardKeyValueRepoRoutes(
+    originalRepo,
+    {
+        serialFormat.decodeHex(idsSerializer, it)
+    },
+    {
+        serialFormat.decodeHex(valueSerializer, it)
+    }
+)
+

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/NewKtorStandartReadKeyValueRepo.kt

@@ -0,0 +1,106 @@
+package dev.inmo.micro_utils.repos.ktor.server.key_value
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.ktor.server.*
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.pagination.extractPagination
+import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.*
+import dev.inmo.micro_utils.repos.ktor.common.containsRoute
+import dev.inmo.micro_utils.repos.ktor.common.countRoute
+import dev.inmo.micro_utils.repos.ktor.common.key_value.*
+import dev.inmo.micro_utils.repos.ktor.common.reversedParameterName
+import io.ktor.http.*
+import io.ktor.server.application.call
+import io.ktor.server.response.respond
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.get
+import io.ktor.util.InternalAPI
+import io.ktor.util.reflect.typeInfo
+import kotlinx.serialization.*
+
+@OptIn(InternalAPI::class)
+inline fun <reified Key, reified Value> Route.configureReadStandardKeyValueRepoRoutes (
+    originalRepo: ReadStandardKeyValueRepo<Key, Value>,
+    noinline idDeserializer: suspend (String) -> Key,
+    noinline valueDeserializer: suspend (String) -> Value
+) {
+    val paginationWithValuesTypeInfo = typeInfo<PaginationResult<Value>>()
+    val paginationWithKeysTypeInfo = typeInfo<PaginationResult<Key>>()
+
+    get(getRoute) {
+        val key = idDeserializer(
+            call.getQueryParameterOrSendError(idParameterName) ?: return@get
+        )
+
+        originalRepo.get(key) ?.let {
+            call.respond(it)
+        } ?: call.respond(HttpStatusCode.NoContent)
+    }
+
+    get(valuesRoute) {
+        val pagination = call.request.queryParameters.extractPagination
+        val reversed = call.getQueryParameter(reversedParameterName) ?.toBoolean() ?: false
+
+        call.respond(
+            originalRepo.values(pagination, reversed),
+            paginationWithValuesTypeInfo
+        )
+    }
+
+    get(keysRoute) {
+        val pagination = call.request.queryParameters.extractPagination
+        val reversed = call.getQueryParameterOrSendError(reversedParameterName) ?.toBoolean() ?: false
+        val value = call.getQueryParameter(valueParameterName) ?.let {
+            valueDeserializer(it)
+        }
+
+        call.respond(
+            value ?.let { originalRepo.keys(value, pagination, reversed) } ?: originalRepo.keys(pagination, reversed),
+            paginationWithKeysTypeInfo
+        )
+    }
+
+    get(containsRoute) {
+        val key = idDeserializer(
+            call.getQueryParameterOrSendError(idParameterName) ?: return@get
+        )
+
+        call.respond(originalRepo.contains(key))
+    }
+
+    get(countRoute) {
+        call.respond(originalRepo.count())
+    }
+}
+
+inline fun <reified Key, reified Value> Route.configureReadStandardKeyValueRepoRoutes(
+    originalRepo: ReadStandardKeyValueRepo<Key, Value>,
+    idsSerializer: DeserializationStrategy<Key>,
+    valueSerializer: DeserializationStrategy<Value>,
+    serialFormat: StringFormat
+) = configureReadStandardKeyValueRepoRoutes(
+    originalRepo,
+    {
+        serialFormat.decodeFromString(idsSerializer, it.decodeURLQueryComponent())
+    },
+    {
+        serialFormat.decodeFromString(valueSerializer, it.decodeURLQueryComponent())
+    }
+)
+
+inline fun <reified Key, reified Value> Route.configureReadStandardKeyValueRepoRoutes(
+    originalRepo: ReadStandardKeyValueRepo<Key, Value>,
+    idsSerializer: DeserializationStrategy<Key>,
+    valueSerializer: DeserializationStrategy<Value>,
+    serialFormat: BinaryFormat
+) = configureReadStandardKeyValueRepoRoutes(
+    originalRepo,
+    {
+        serialFormat.decodeHex(idsSerializer, it)
+    },
+    {
+        serialFormat.decodeHex(valueSerializer, it)
+    }
+)
+

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/NewKtorStandartWriteKeyValueRepo.kt

@@ -0,0 +1,45 @@
+package dev.inmo.micro_utils.repos.ktor.server.key_value
+
+import dev.inmo.micro_utils.ktor.server.*
+import dev.inmo.micro_utils.repos.WriteStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.key_value.*
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.application.call
+import io.ktor.server.request.receive
+import io.ktor.server.response.respond
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.post
+import io.ktor.util.reflect.typeInfo
+
+inline fun <reified Key : Any, reified Value : Any> Route.configureWriteStandardKeyValueRepoRoutes (
+    originalRepo: WriteStandardKeyValueRepo<Key, Value>
+) {
+    includeWebsocketHandling(
+        onNewValueRoute,
+        originalRepo.onNewValue
+    )
+
+    includeWebsocketHandling(
+        onValueRemovedRoute,
+        originalRepo.onValueRemoved
+    )
+
+    val mapType = typeInfo<Map<Key, Value>>()
+    val listKeysType = typeInfo<List<Key>>()
+    val listValuesType = typeInfo<List<Value>>()
+
+    post(setRoute) {
+        originalRepo.set(call.receive(mapType))
+        call.respond(HttpStatusCode.OK)
+    }
+
+    post(unsetRoute) {
+        originalRepo.unset(call.receive(listKeysType))
+        call.respond(HttpStatusCode.OK)
+    }
+
+    post(unsetWithValuesRoute) {
+        originalRepo.unsetWithValues(call.receive(listValuesType))
+        call.respond(HttpStatusCode.OK)
+    }
+}

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/NewKtorStandartKeyValuesRepo.kt

@@ -0,0 +1,47 @@
+package dev.inmo.micro_utils.repos.ktor.server.one_to_many
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.repos.*
+import io.ktor.http.*
+import io.ktor.server.routing.Route
+import kotlinx.serialization.*
+
+inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValuesRepoRoutes (
+    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+    noinline idDeserializer: suspend (String) -> Key,
+    noinline valueDeserializer: suspend (String) -> Value
+) {
+    configureReadStandardKeyValuesRepoRoutes(originalRepo, idDeserializer, valueDeserializer)
+    configureWriteStandardKeyValuesRepoRoutes(originalRepo)
+}
+
+inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValuesRepoRoutes(
+    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+    idsSerializer: DeserializationStrategy<Key>,
+    valueSerializer: DeserializationStrategy<Value>,
+    serialFormat: StringFormat
+) = configureStandardKeyValuesRepoRoutes(
+    originalRepo,
+    {
+        serialFormat.decodeFromString(idsSerializer, it.decodeURLQueryComponent())
+    },
+    {
+        serialFormat.decodeFromString(valueSerializer, it.decodeURLQueryComponent())
+    }
+)
+
+inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValuesRepoRoutes(
+    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+    idsSerializer: DeserializationStrategy<Key>,
+    valueSerializer: DeserializationStrategy<Value>,
+    serialFormat: BinaryFormat
+) = configureStandardKeyValuesRepoRoutes(
+    originalRepo,
+    {
+        serialFormat.decodeHex(idsSerializer, it)
+    },
+    {
+        serialFormat.decodeHex(valueSerializer, it)
+    }
+)
+

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/NewKtorStandartReadKeyValuesRepo.kt

@@ -0,0 +1,107 @@
+package dev.inmo.micro_utils.repos.ktor.server.one_to_many
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.ktor.server.*
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.pagination.extractPagination
+import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.*
+import dev.inmo.micro_utils.repos.ktor.common.containsRoute
+import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
+import io.ktor.http.*
+import io.ktor.server.application.call
+import io.ktor.server.response.respond
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.get
+import io.ktor.util.InternalAPI
+import io.ktor.util.reflect.typeInfo
+import kotlinx.serialization.*
+
+@OptIn(InternalAPI::class)
+inline fun <reified Key, reified Value> Route.configureReadStandardKeyValuesRepoRoutes (
+    originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
+    noinline idDeserializer: suspend (String) -> Key,
+    noinline valueDeserializer: suspend (String) -> Value
+) {
+    val paginationWithValuesTypeInfo = typeInfo<PaginationResult<Value>>()
+    val paginationWithKeysTypeInfo = typeInfo<PaginationResult<Key>>()
+
+    get(getRoute) {
+        val key = idDeserializer(
+            call.getQueryParameterOrSendError(keyParameterName) ?: return@get
+        )
+        val pagination = call.request.queryParameters.extractPagination
+        val reversed = call.getQueryParameter(reversedParameterName) ?.toBoolean() ?: false
+
+        call.respond(
+            originalRepo.get(key, pagination, reversed),
+            paginationWithValuesTypeInfo
+        )
+    }
+
+    get(keysRoute) {
+        val pagination = call.request.queryParameters.extractPagination
+        val reversed = call.getQueryParameterOrSendError(reversedParameterName) ?.toBoolean() ?: false
+        val value = call.getQueryParameter(valueParameterName) ?.let {
+            valueDeserializer(it)
+        }
+
+        call.respond(
+            value ?.let { originalRepo.keys(value, pagination, reversed) } ?: originalRepo.keys(pagination, reversed),
+            paginationWithKeysTypeInfo
+        )
+    }
+
+    get(containsRoute) {
+        val key = idDeserializer(
+            call.getQueryParameterOrSendError(keyParameterName) ?: return@get
+        )
+        val value = call.getQueryParameter(valueParameterName) ?.let {
+            valueDeserializer(it)
+        }
+
+        call.respond(
+            value ?.let { originalRepo.contains(key, value) } ?: originalRepo.contains(key)
+        )
+    }
+
+    get(dev.inmo.micro_utils.repos.ktor.common.countRoute) {
+        val id = call.getQueryParameter(keyParameterName) ?.let {
+            idDeserializer(it)
+        }
+        call.respond(
+            id ?.let { originalRepo.count(it) } ?: originalRepo.count()
+        )
+    }
+}
+
+inline fun <reified Key, reified Value> Route.configureReadStandardKeyValuesRepoRoutes(
+    originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
+    idsSerializer: DeserializationStrategy<Key>,
+    valueSerializer: DeserializationStrategy<Value>,
+    serialFormat: StringFormat
+) = configureReadStandardKeyValuesRepoRoutes(
+    originalRepo,
+    {
+        serialFormat.decodeFromString(idsSerializer, it.decodeURLQueryComponent())
+    },
+    {
+        serialFormat.decodeFromString(valueSerializer, it.decodeURLQueryComponent())
+    }
+)
+
+inline fun <reified Key, reified Value> Route.configureReadStandardKeyValuesRepoRoutes(
+    originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
+    idsSerializer: DeserializationStrategy<Key>,
+    valueSerializer: DeserializationStrategy<Value>,
+    serialFormat: BinaryFormat
+) = configureReadStandardKeyValuesRepoRoutes(
+    originalRepo,
+    {
+        serialFormat.decodeHex(idsSerializer, it)
+    },
+    {
+        serialFormat.decodeHex(valueSerializer, it)
+    }
+)
+

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/NewKtorStandartWriteKeyValuesRepo.kt

@@ -0,0 +1,58 @@
+package dev.inmo.micro_utils.repos.ktor.server.one_to_many
+
+import dev.inmo.micro_utils.ktor.server.*
+import dev.inmo.micro_utils.repos.WriteOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.application.call
+import io.ktor.server.request.receive
+import io.ktor.server.response.respond
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.post
+import io.ktor.util.reflect.typeInfo
+
+inline fun <reified Key : Any, reified Value : Any> Route.configureWriteStandardKeyValuesRepoRoutes (
+    originalRepo: WriteOneToManyKeyValueRepo<Key, Value>
+) {
+    includeWebsocketHandling(
+        onNewValueRoute,
+        originalRepo.onNewValue
+    )
+
+    includeWebsocketHandling(
+        onValueRemovedRoute,
+        originalRepo.onValueRemoved
+    )
+
+    includeWebsocketHandling(
+        onDataClearedRoute,
+        originalRepo.onDataCleared
+    )
+
+    val mapType = typeInfo<Map<Key, List<Value>>>()
+
+    post(addRoute) {
+        originalRepo.add(call.receive(mapType))
+        call.respond(HttpStatusCode.OK)
+    }
+
+    post(setRoute) {
+        originalRepo.set(call.receive(mapType))
+        call.respond(HttpStatusCode.OK)
+    }
+
+    post(removeRoute) {
+        originalRepo.remove(call.receive(mapType))
+        call.respond(HttpStatusCode.OK)
+    }
+
+    post(clearRoute) {
+        originalRepo.clear(call.receive())
+        call.respond(HttpStatusCode.OK)
+    }
+
+    post(clearWithValueRoute) {
+        originalRepo.clearWithValue(call.receive())
+        call.respond(HttpStatusCode.OK)
+    }
+}