repos update

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

@@ -7,8 +7,7 @@ import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import io.ktor.client.HttpClient
 import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.PairSerializer
-import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.builtins.*
 
 class KtorWriteStandardKeyValueRepo<K, V> (
     private var baseUrl: String,
@@ -16,6 +15,8 @@ class KtorWriteStandardKeyValueRepo<K, V> (
     private var keySerializer: KSerializer<K>,
     private var valueSerializer: KSerializer<V>,
 ) : WriteStandardKeyValueRepo<K, V> {
+    private val keyValueMapSerializer = MapSerializer(keySerializer, valueSerializer)
+    private val keysListSerializer = ListSerializer(keySerializer)
     override val onNewValue: Flow<Pair<K, V>> = client.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onNewValueRoute),
         deserializer = PairSerializer(keySerializer, valueSerializer)
@@ -26,23 +27,25 @@ class KtorWriteStandardKeyValueRepo<K, V> (
         deserializer = keySerializer
     )
 
-    override suspend fun set(k: K, v: V) = client.unipost(
+    override suspend fun set(toSet: Map<K, V>) = client.unipost(
         buildStandardUrl(
             baseUrl,
             setRoute
         ),
-        BodyPair(KeyValuePostObject.serializer(keySerializer, valueSerializer), KeyValuePostObject(k, v)),
+        BodyPair(keyValueMapSerializer, toSet),
         Unit.serializer()
     )
+    override suspend fun set(k: K, v: V) = set(mapOf(k to v))
 
-    override suspend fun unset(k: K) = client.unipost(
+    override suspend fun unset(toUnset: List<K>) = client.unipost(
         buildStandardUrl(
             baseUrl,
             unsetRoute,
         ),
-        BodyPair(keySerializer, k),
+        BodyPair(keysListSerializer, toUnset),
         Unit.serializer()
     )
+    override suspend fun unset(k: K) = unset(listOf(k))
 }
 
 @Deprecated("Renamed", ReplaceWith("KtorWriteStandardKeyValueRepo", "dev.inmo.micro_utils.repos.ktor.client.key_value.KtorWriteStandardKeyValueRepo"))

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

@@ -7,8 +7,7 @@ import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import io.ktor.client.HttpClient
 import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.PairSerializer
-import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.builtins.*
 
 class KtorWriteOneToManyKeyValueRepo<Key, Value> (
     private val baseUrl: String,
@@ -17,6 +16,7 @@ class KtorWriteOneToManyKeyValueRepo<Key, Value> (
     private val valueSerializer: KSerializer<Value>
 ) : WriteOneToManyKeyValueRepo<Key, Value> {
     private val keyValueSerializer = PairSerializer(keySerializer, valueSerializer)
+    private val keyValueMapSerializer = MapSerializer(keySerializer, ListSerializer(valueSerializer))
     override val onNewValue: Flow<Pair<Key, Value>> = client.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onNewValueRoute),
         deserializer = keyValueSerializer
@@ -39,15 +39,23 @@ class KtorWriteOneToManyKeyValueRepo<Key, Value> (
         Unit.serializer(),
     )
 
-    override suspend fun remove(k: Key, v: Value) = client.unipost(
+    override suspend fun remove(toRemove: Map<Key, List<Value>>) = client.unipost(
         buildStandardUrl(
             baseUrl,
             removeRoute,
         ),
-        BodyPair(keyValueSerializer, k to v),
+        BodyPair(keyValueMapSerializer, toRemove),
         Unit.serializer(),
     )
 
+    override suspend fun add(toAdd: Map<Key, List<Value>>) = client.unipost(
+        buildStandardUrl(
+            baseUrl,
+            clearRoute,
+        ),
+        BodyPair(keyValueMapSerializer, toAdd),
+        Unit.serializer(),
+    )
     override suspend fun clear(k: Key)  = client.unipost(
         buildStandardUrl(
             baseUrl,

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

@@ -1,20 +1,21 @@
 package dev.inmo.micro_utils.repos.ktor.server.key_value
 
-import dev.inmo.micro_utils.ktor.server.includeWebsocketHandling
-import dev.inmo.micro_utils.ktor.server.uniload
+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.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.*
 
 fun <K, V> Route.configureWriteStandartKeyValueRepoRoutes (
     originalRepo: WriteStandardKeyValueRepo<K, V>,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
 ) {
+    val keyValueMapSerializer = MapSerializer(keySerializer, valueSerializer)
+    val keysListSerializer = ListSerializer(keySerializer)
     includeWebsocketHandling(
         onNewValueRoute,
         originalRepo.onNewValue,
@@ -28,18 +29,16 @@ fun <K, V> Route.configureWriteStandartKeyValueRepoRoutes (
     )
 
     post(setRoute) {
-        val (key, value) = call.uniload(
-            KeyValuePostObject.serializer(keySerializer, valueSerializer)
+        val toSet = call.uniload(
+            keyValueMapSerializer
         )
 
-        originalRepo.set(key, value)
+        call.unianswer(Unit.serializer(), originalRepo.set(toSet))
     }
 
     post(unsetRoute) {
-        val key = call.uniload(
-            keySerializer
-        )
+        val toUnset = call.uniload(keysListSerializer)
 
-        originalRepo.unset(key)
+        call.unianswer(Unit.serializer(), originalRepo.unset(toUnset))
     }
 }

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

@@ -7,15 +7,15 @@ 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
+import kotlinx.serialization.builtins.*
 
 fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
     originalRepo: WriteOneToManyKeyValueRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
-    valueSealizer: KSerializer<Value>,
+    valueSerializer: KSerializer<Value>,
 ) {
-    val keyValueSerializer = PairSerializer(keySerializer, valueSealizer)
+    val keyValueSerializer = PairSerializer(keySerializer, valueSerializer)
+    val keyValueMapSerializer = MapSerializer(keySerializer, ListSerializer(valueSerializer))
 
     includeWebsocketHandling(
         onNewValueRoute,
@@ -34,24 +34,22 @@ fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
     )
 
     post(addRoute) {
-        val obj = call.uniload(
-            keyValueSerializer
-        )
+        val obj = call.uniload(keyValueMapSerializer)
 
         call.unianswer(
             Unit.serializer(),
-            originalRepo.add(obj.first, obj.second)
+            originalRepo.add(obj)
         )
     }
 
     post(removeRoute) {
         val obj = call.uniload(
-            keyValueSerializer
+            keyValueMapSerializer
         )
 
         call.unianswer(
             Unit.serializer(),
-            originalRepo.remove(obj.first, obj.second),
+            originalRepo.remove(obj),
         )
     }