upfix of default in includeWebsocketHandling

0.4.6

CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.4.7
+
+* `Ktor`
+    * `Client`
+        * New class `UnifiedRequester`
+    * `Server`
+        * New class `UnifiedRouter`
+* `Repos`
+    * `Ktor`
+        * `Client`
+            * Rewriting of all clients on new `UnifiedRequester`
+        * `Server`
+            * Rewriting of all clients on new `UnifiedRouter`
+
+## 0.4.6
+
+* `Common`
+    * New annotation `Warning` has been added
+* `Pagination`
+    * `Common`
+        * `Pagination` got new extension: `Pagination#isFirstPage`
+* `Coroutines`:
+    * New extension `FlowCollector#invoke` has been added
+* `Repos`
+    * `Common`
+        * `JVM` (and `Android` since `Android API 26`):
+            * `FileStandardKeyValueRepo` has been added
+        * Add several `typealias`es for each type of repos
+
 ## 0.4.5
 
 * `Android`

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/Annotations.kt

@@ -17,3 +17,21 @@ package dev.inmo.micro_utils.common
     AnnotationTarget.TYPE_PARAMETER
 )
 annotation class PreviewFeature
+
+@RequiresOptIn(
+    "This thing is marked as warned. See message of warn to get more info",
+    RequiresOptIn.Level.WARNING
+)
+@Target(
+    AnnotationTarget.CLASS,
+    AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.PROPERTY_GETTER,
+    AnnotationTarget.PROPERTY_SETTER,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.TYPE,
+    AnnotationTarget.TYPEALIAS,
+    AnnotationTarget.TYPE_PARAMETER
+)
+annotation class Warning(val message: String)

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/FlowCollectorInvoking.kt

@@ -0,0 +1,5 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.flow.FlowCollector
+
+suspend inline operator fun <T> FlowCollector<T>.invoke(value: T) = emit(value)

gradle.properties

@@ -41,5 +41,5 @@ dokka_version=1.4.0
 # Project data
 
 group=dev.inmo
-version=0.4.5
-android_code_version=9
+version=0.4.7
+android_code_version=11

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

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

@@ -64,10 +64,11 @@ inline fun <T> HttpClient.createStandardWebsocketFlow(
 inline fun <T> HttpClient.createStandardWebsocketFlow(
     url: String,
     crossinline checkReconnection: (Throwable?) -> Boolean = { true },
-    deserializer: DeserializationStrategy<T>
+    deserializer: DeserializationStrategy<T>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
 ) = createStandardWebsocketFlow(
     url,
     checkReconnection
 ) {
-    standardKtorSerialFormat.decodeDefault(deserializer, it)
+    serialFormat.decodeDefault(deserializer, it)
 }

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

@@ -4,32 +4,61 @@ import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.client.HttpClient
 import io.ktor.client.request.get
 import io.ktor.client.request.post
-import kotlinx.serialization.DeserializationStrategy
-import kotlinx.serialization.SerializationStrategy
+import kotlinx.serialization.*
 
 typealias BodyPair<T> = Pair<SerializationStrategy<T>, T>
 
+class UnifiedRequester(
+    private val client: HttpClient = HttpClient(),
+    private val serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+) {
+    suspend fun <ResultType> uniget(
+        url: String,
+        resultDeserializer: DeserializationStrategy<ResultType>
+    ): ResultType = client.get<StandardKtorSerialInputData>(
+        url
+    ).let {
+        serialFormat.decodeDefault(resultDeserializer, it)
+    }
+
+
+    fun <T> encodeUrlQueryValue(
+        serializationStrategy: SerializationStrategy<T>,
+        value: T
+    ) = serialFormat.encodeHex(
+        serializationStrategy,
+        value
+    )
+
+    suspend fun <BodyType, ResultType> unipost(
+        url: String,
+        bodyInfo: BodyPair<BodyType>,
+        resultDeserializer: DeserializationStrategy<ResultType>
+    ) = client.post<StandardKtorSerialInputData>(url) {
+        body = serialFormat.encodeDefault(bodyInfo.first, bodyInfo.second)
+    }.let {
+        serialFormat.decodeDefault(resultDeserializer, it)
+    }
+
+    fun <T> createStandardWebsocketFlow(
+        url: String,
+        checkReconnection: (Throwable?) -> Boolean = { true },
+        deserializer: DeserializationStrategy<T>
+    ) = client.createStandardWebsocketFlow(url, checkReconnection, deserializer, serialFormat)
+}
+
+val defaultRequester = UnifiedRequester()
+
 suspend fun <ResultType> HttpClient.uniget(
     url: String,
     resultDeserializer: DeserializationStrategy<ResultType>
-) = get<StandardKtorSerialInputData>(
-    url
-).let {
-    standardKtorSerialFormat.decodeDefault(resultDeserializer, it)
-}
+) = defaultRequester.uniget(url, resultDeserializer)
 
 
-fun <T> SerializationStrategy<T>.encodeUrlQueryValue(value: T) = standardKtorSerialFormat.encodeHex(
-    this,
-    value
-)
+fun <T> SerializationStrategy<T>.encodeUrlQueryValue(value: T) = defaultRequester.encodeUrlQueryValue(this, value)
 
 suspend fun <BodyType, ResultType> HttpClient.unipost(
     url: String,
     bodyInfo: BodyPair<BodyType>,
     resultDeserializer: DeserializationStrategy<ResultType>
-) = post<StandardKtorSerialInputData>(url) {
-    body = standardKtorSerialFormat.encodeDefault(bodyInfo.first, bodyInfo.second)
-}.let {
-    standardKtorSerialFormat.decodeDefault(resultDeserializer, it)
-}
+) = defaultRequester.unipost(url, bodyInfo, resultDeserializer)

ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/ktor/common/QueryParamsBuilder.kt

@@ -3,16 +3,28 @@ package dev.inmo.micro_utils.ktor.common
 typealias QueryParam = Pair<String, String?>
 typealias QueryParams = Map<String, String?>
 
+/**
+ * Create query part which includes key=value pairs separated with &
+ */
 val QueryParams.asUrlQuery: String
     get() = keys.joinToString("&") { "${it}${get(it) ?.let { value -> "=$value" }}" }
 
+/**
+ * Create query part which includes key=value pairs separated with &
+ */
 val List<QueryParam>.asUrlQuery: String
     get() = joinToString("&") { (key, value) -> "${key}${value ?.let { _ -> "=$value" }}" }
 
+/**
+ * Create query part which includes key=value pairs separated with & and attach to receiver
+ */
 fun String.includeQueryParams(
     queryParams: QueryParams
 ): String = "$this${if(queryParams.isNotEmpty()) "${if (contains("?")) "&" else "?"}${queryParams.asUrlQuery}" else ""}"
 
+/**
+ * Create query part which includes key=value pairs separated with & and attach to receiver
+ */
 fun String.includeQueryParams(
     queryParams: List<QueryParam>
 ): String = "$this${if (contains("?")) "&" else "?"}${queryParams.asUrlQuery}"

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

@@ -33,10 +33,11 @@ fun <T> Route.includeWebsocketHandling(
 fun <T> Route.includeWebsocketHandling(
     suburl: String,
     flow: Flow<T>,
-    serializer: SerializationStrategy<T>
+    serializer: SerializationStrategy<T>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
 ) = includeWebsocketHandling(
     suburl,
     flow
 ) {
-    standardKtorSerialFormat.encodeDefault(serializer, it)
+    serialFormat.encodeDefault(serializer, it)
 }

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

@@ -3,12 +3,87 @@ package dev.inmo.micro_utils.ktor.server
 import dev.inmo.micro_utils.coroutines.safely
 import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.application.ApplicationCall
+import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.http.HttpStatusCode
 import io.ktor.request.receive
 import io.ktor.response.respond
 import io.ktor.response.respondBytes
-import kotlinx.serialization.DeserializationStrategy
-import kotlinx.serialization.SerializationStrategy
+import io.ktor.routing.Route
+import io.ktor.util.pipeline.PipelineContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.serialization.*
+
+class UnifiedRouter(
+    private val serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    private val serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) {
+    fun <T> Route.includeWebsocketHandling(
+        suburl: String,
+        flow: Flow<T>,
+        serializer: SerializationStrategy<T>
+    ) = includeWebsocketHandling(suburl, flow, serializer, serialFormat)
+
+    suspend fun <T> PipelineContext<*, ApplicationCall>.unianswer(
+        answerSerializer: SerializationStrategy<T>,
+        answer: T
+    ) {
+        call.respondBytes (
+            serialFormat.encodeDefault(answerSerializer, answer),
+            serialFormatContentType
+        )
+    }
+
+    suspend fun <T> PipelineContext<*, ApplicationCall>.uniload(
+        deserializer: DeserializationStrategy<T>
+    ) = safely {
+        serialFormat.decodeDefault(
+            deserializer,
+            call.receive()
+        )
+    }
+
+    suspend fun PipelineContext<*, ApplicationCall>.getParameterOrSendError(
+        field: String
+    ) = call.parameters[field].also {
+        if (it == null) {
+            call.respond(HttpStatusCode.BadRequest, "Request must contains $field")
+        }
+    }
+
+    fun PipelineContext<*, ApplicationCall>.getQueryParameter(
+        field: String
+    ) = call.request.queryParameters[field]
+
+    suspend fun PipelineContext<*, ApplicationCall>.getQueryParameterOrSendError(
+        field: String
+    ) = getQueryParameter(field).also {
+        if (it == null) {
+            call.respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
+        }
+    }
+
+    fun <T> PipelineContext<*, ApplicationCall>.decodeUrlQueryValue(
+        field: String,
+        deserializer: DeserializationStrategy<T>
+    ) = getQueryParameter(field) ?.let {
+        serialFormat.decodeHex(
+            deserializer,
+            it
+        )
+    }
+
+    suspend fun <T> PipelineContext<*, ApplicationCall>.decodeUrlQueryValueOrSendError(
+        field: String,
+        deserializer: DeserializationStrategy<T>
+    ) = decodeUrlQueryValue(field, deserializer).also {
+        if (it == null) {
+            call.respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
+        }
+    }
+}
+
+val defaultUnifiedRouter = UnifiedRouter()
 
 suspend fun <T> ApplicationCall.unianswer(
     answerSerializer: SerializationStrategy<T>,

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/Pagination.kt

@@ -22,6 +22,12 @@ interface Pagination {
     val size: Int
 }
 
+/**
+ * Logical shortcut for comparison that page is 0
+ */
+inline val Pagination.isFirstPage
+    get() = page == 0
+
 /**
  * First number in index of objects. It can be used as offset for databases or other data sources
  */

publish.gradle

@@ -3,6 +3,9 @@ apply plugin: 'maven-publish'
 task javadocsJar(type: Jar) {
     classifier = 'javadoc'
 }
+task sourceJar (type : Jar) {
+    classifier = 'sources'
+}
 
 afterEvaluate {
     project.publishing.publications.all {
@@ -10,6 +13,7 @@ afterEvaluate {
         groupId "${project.group}"
         if (it.name.contains('kotlinMultiplatform')) {
             artifactId = "${project.name}"
+            artifact sourceJar
         } else {
             artifactId = "${project.name}-$name"
         }

repos/common/build.gradle

@@ -17,6 +17,11 @@ kotlin {
             }
         }
 
+        jvmMain {
+            dependencies {
+                api internalProject("micro_utils.common")
+            }
+        }
         androidMain {
             dependencies {
                 api "androidx.core:core-ktx:$core_ktx_version"

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

@@ -36,6 +36,7 @@ interface ReadOneToManyKeyValueRepo<Key, Value> : Repo {
         }
     }
 }
+typealias ReadKeyValuesRepo<Key,Value> = ReadOneToManyKeyValueRepo<Key, Value>
 
 interface WriteOneToManyKeyValueRepo<Key, Value> : Repo {
     val onNewValue: Flow<Pair<Key, Value>>
@@ -53,6 +54,7 @@ interface WriteOneToManyKeyValueRepo<Key, Value> : Repo {
         add(toSet)
     }
 }
+typealias WriteKeyValuesRepo<Key,Value> = WriteOneToManyKeyValueRepo<Key, Value>
 
 suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
     keysAndValues: List<Pair<Key, List<Value>>>
@@ -87,6 +89,7 @@ suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.set(
 ) = set(k, v.toList())
 
 interface OneToManyKeyValueRepo<Key, Value> : ReadOneToManyKeyValueRepo<Key, Value>, WriteOneToManyKeyValueRepo<Key, Value>
+typealias KeyValuesRepo<Key,Value> = OneToManyKeyValueRepo<Key, Value>
 
 suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
     keysAndValues: List<Pair<Key, List<Value>>>

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

@@ -10,6 +10,7 @@ interface ReadStandardCRUDRepo<ObjectType, IdType> : Repo {
     suspend fun contains(id: IdType): Boolean
     suspend fun count(): Long
 }
+typealias ReadCRUDRepo<ObjectType, IdType> = ReadStandardCRUDRepo<ObjectType, IdType>
 
 typealias UpdatedValuePair<IdType, ValueType> = Pair<IdType, ValueType>
 val <IdType> UpdatedValuePair<IdType, *>.id
@@ -27,6 +28,7 @@ interface WriteStandardCRUDRepo<ObjectType, IdType, InputValueType> : Repo {
     suspend fun update(values: List<UpdatedValuePair<IdType, InputValueType>>): List<ObjectType>
     suspend fun deleteById(ids: List<IdType>)
 }
+typealias WriteCRUDRepo<ObjectType, IdType, InputValueType> = WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
 
 suspend fun <ObjectType, IdType, InputValueType> WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>.create(
     vararg values: InputValueType
@@ -39,4 +41,5 @@ suspend fun <ObjectType, IdType, InputValueType> WriteStandardCRUDRepo<ObjectTyp
 ) = deleteById(ids.toList())
 
 interface StandardCRUDRepo<ObjectType, IdType, InputValueType> : ReadStandardCRUDRepo<ObjectType, IdType>,
-    WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
+    WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
+typealias CRUDRepo<ObjectType, IdType, InputValueType> = StandardCRUDRepo<ObjectType, IdType, InputValueType>

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

@@ -12,6 +12,7 @@ interface ReadStandardKeyValueRepo<Key, Value> : Repo {
     suspend fun contains(key: Key): Boolean
     suspend fun count(): Long
 }
+typealias ReadKeyValueRepo<Key,Value> = ReadStandardKeyValueRepo<Key, Value>
 
 interface WriteStandardKeyValueRepo<Key, Value> : Repo {
     val onNewValue: Flow<Pair<Key, Value>>
@@ -20,6 +21,7 @@ interface WriteStandardKeyValueRepo<Key, Value> : Repo {
     suspend fun set(toSet: Map<Key, Value>)
     suspend fun unset(toUnset: List<Key>)
 }
+typealias WriteKeyValueRepo<Key,Value> = WriteStandardKeyValueRepo<Key, Value>
 
 suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.set(
     vararg toSet: Pair<Key, Value>
@@ -33,4 +35,5 @@ suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.unset(
     vararg k: Key
 ) = unset(k.toList())
 
-interface StandardKeyValueRepo<Key, Value> : ReadStandardKeyValueRepo<Key, Value>, WriteStandardKeyValueRepo<Key, Value>
+interface StandardKeyValueRepo<Key, Value> : ReadStandardKeyValueRepo<Key, Value>, WriteStandardKeyValueRepo<Key, Value>
+typealias KeyValueRepo<Key,Value> = StandardKeyValueRepo<Key, Value>

repos/common/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/FileStandardKeyValueRepo.kt

@@ -0,0 +1,171 @@
+package dev.inmo.micro_utils.repos
+
+import dev.inmo.micro_utils.common.Warning
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.utils.reverse
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import java.io.File
+import java.nio.file.FileSystems
+import java.nio.file.Path
+import java.nio.file.StandardWatchEventKinds.*
+
+private inline val String.isAbsolute
+    get() = startsWith(File.separator)
+
+class FileReadStandardKeyValueRepo(
+    private val folder: File
+) : ReadStandardKeyValueRepo<String, File> {
+    init {
+        folder.mkdirs()
+    }
+
+    override suspend fun get(k: String): File? {
+        val file = File(folder, k)
+        if (file.exists()) {
+            return file
+        }
+        return null
+    }
+
+    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<File> {
+        val count = count()
+        val resultPagination = if (reversed) pagination.reverse(count) else pagination
+        val filesPaths = folder.list() ?.copyOfRange(resultPagination.firstIndex, resultPagination.lastIndex) ?: return emptyPaginationResult()
+        if (reversed) {
+            filesPaths.reverse()
+        }
+        return filesPaths.map { File(folder, it) }.createPaginationResult(
+            resultPagination,
+            count
+        )
+    }
+
+    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<String> {
+        val count = count()
+        val resultPagination = if (reversed) pagination.reverse(count) else pagination
+        val filesPaths = folder.list() ?.copyOfRange(resultPagination.firstIndex, resultPagination.lastIndex) ?: return emptyPaginationResult()
+        if (reversed) {
+            filesPaths.reverse()
+        }
+        return filesPaths.toList().createPaginationResult(
+            resultPagination,
+            count
+        )
+    }
+
+    override suspend fun keys(
+        v: File,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<String> {
+        val resultPagination = if (reversed) pagination.reverse(1L) else pagination
+        return if (resultPagination.isFirstPage) {
+            val fileSubpath = v.absolutePath.removePrefix(folder.absolutePath)
+            if (fileSubpath == v.absolutePath) {
+                emptyList()
+            } else {
+                listOf(fileSubpath)
+            }
+        } else {
+            emptyList()
+        }.createPaginationResult(resultPagination, 1L)
+    }
+
+    override suspend fun contains(key: String): Boolean {
+        return File(folder, key).exists()
+    }
+
+    override suspend fun count(): Long = folder.list() ?.size ?.toLong() ?: 0L
+}
+
+/**
+ * Files watching will not correctly works on Android with version of API lower than API 26
+ */
+@Warning("Files watching will not correctly works on Android Platform with version of API lower than API 26")
+class FileWriteStandardKeyValueRepo(
+    private val folder: File,
+    filesChangedProcessingScope: CoroutineScope? = null
+) : WriteStandardKeyValueRepo<String, File> {
+    private val _onNewValue = MutableSharedFlow<Pair<String, File>>()
+    override val onNewValue: Flow<Pair<String, File>> = _onNewValue.asSharedFlow()
+    private val _onValueRemoved = MutableSharedFlow<String>()
+    override val onValueRemoved: Flow<String> = _onValueRemoved.asSharedFlow()
+
+    init {
+        folder.mkdirs()
+        filesChangedProcessingScope ?.let {
+            it.launch {
+                try {
+                    val folderPath = folder.toPath()
+                    while (isActive) {
+                        val key = try {
+                            folderPath.register(FileSystems.getDefault().newWatchService(), ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE)
+                        } catch (e: Exception) {
+                            // add verbose way to show that file watching is not working
+                            return@launch
+                        }
+
+                        for (event in key.pollEvents()) {
+                            val relativeFilePath = (event.context() as? Path) ?: continue
+                            val file = relativeFilePath.toFile()
+                            val relativePath = file.toRelativeString(folder)
+
+                            when (event.kind()) {
+                                ENTRY_CREATE, ENTRY_MODIFY -> {
+                                    launch {
+                                        _onNewValue.emit(relativePath to file)
+                                    }
+                                }
+                                ENTRY_DELETE -> {
+                                    launch {
+                                        _onValueRemoved.emit(relativePath)
+                                    }
+                                }
+                            }
+                        }
+
+                        if (key.isValid || folder.exists()) {
+                            continue
+                        }
+                        break
+                    }
+                } catch (e: Throwable) {
+                    // add verbose way to notify that this functionality is disabled
+                }
+            }
+        }
+    }
+
+    override suspend fun set(toSet: Map<String, File>) {
+        supervisorScope {
+            toSet.map { (filename, fileSource) ->
+                launch {
+                    val file = File(folder, filename)
+
+                    file.delete()
+                    fileSource.copyTo(file, overwrite = true)
+                    _onNewValue.emit(filename to file)
+                }
+            }
+        }.joinAll()
+    }
+
+    override suspend fun unset(toUnset: List<String>) {
+        toUnset.forEach {
+            val file = File(folder, it)
+            if (file.exists()) {
+                file.delete()
+                _onValueRemoved.emit(it)
+            }
+        }
+    }
+}
+
+@Warning("Files watching will not correctly works on Android Platform with version of API lower than API 26")
+class FileStandardKeyValueRepo(
+    folder: File,
+    filesChangedProcessingScope: CoroutineScope? = null
+) : StandardKeyValueRepo<String, File>,
+    WriteStandardKeyValueRepo<String, File> by FileWriteStandardKeyValueRepo(folder, filesChangedProcessingScope),
+    ReadStandardKeyValueRepo<String, File> by FileReadStandardKeyValueRepo(folder)

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

@@ -1,8 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.client.crud
 
-import dev.inmo.micro_utils.ktor.client.encodeUrlQueryValue
-import dev.inmo.micro_utils.ktor.client.uniget
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+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.crud.*
@@ -12,41 +11,52 @@ import kotlinx.serialization.builtins.serializer
 
 class KtorReadStandardCrudRepo<ObjectType, IdType> (
     private val baseUrl: String,
-    private val client: HttpClient = HttpClient(),
+    private val unifiedRequester: UnifiedRequester,
     private val objectsSerializer: KSerializer<ObjectType>,
     private val objectsSerializerNullable: KSerializer<ObjectType?>,
     private val idsSerializer: KSerializer<IdType>
 ) : ReadStandardCRUDRepo<ObjectType, IdType> {
     private val paginationResultSerializer = PaginationResult.serializer(objectsSerializer)
 
-    override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = client.uniget(
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        objectsSerializer: KSerializer<ObjectType>,
+        objectsSerializerNullable: KSerializer<ObjectType?>,
+        idsSerializer: KSerializer<IdType>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (
+        baseUrl, UnifiedRequester(client, serialFormat), objectsSerializer, objectsSerializerNullable, idsSerializer
+    )
+
+    override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = unifiedRequester.uniget(
         buildStandardUrl(baseUrl, getByPaginationRouting, pagination.asUrlQueryParts),
         paginationResultSerializer
     )
 
-    override suspend fun getById(id: IdType): ObjectType? = client.uniget(
+    override suspend fun getById(id: IdType): ObjectType? = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             getByIdRouting,
             mapOf(
-                "id" to idsSerializer.encodeUrlQueryValue(id)
+                "id" to unifiedRequester.encodeUrlQueryValue(idsSerializer, id)
             )
         ),
         objectsSerializerNullable
     )
 
-    override suspend fun contains(id: IdType): Boolean = client.uniget(
+    override suspend fun contains(id: IdType): Boolean = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             containsRouting,
             mapOf(
-                "id" to idsSerializer.encodeUrlQueryValue(id)
+                "id" to unifiedRequester.encodeUrlQueryValue(idsSerializer, id)
             )
         ),
         Boolean.serializer()
     )
 
-    override suspend fun count(): Long = client.uniget(
+    override suspend fun count(): Long = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             countRouting

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

@@ -1,5 +1,8 @@
 package dev.inmo.micro_utils.repos.ktor.client.crud
 
+import dev.inmo.micro_utils.ktor.client.UnifiedRequester
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
 import kotlinx.serialization.KSerializer
@@ -7,7 +10,7 @@ import kotlinx.serialization.KSerializer
 class KtorStandardCrudRepo<ObjectType, IdType, InputValue> (
     baseUrl: String,
     baseSubpart: String,
-    client: HttpClient,
+    unifiedRequester: UnifiedRequester,
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
@@ -15,16 +18,29 @@ class KtorStandardCrudRepo<ObjectType, IdType, InputValue> (
 ) : StandardCRUDRepo<ObjectType, IdType, InputValue>,
     ReadStandardCRUDRepo<ObjectType, IdType> by KtorReadStandardCrudRepo(
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         objectsSerializer,
         objectsNullableSerializer,
         idsSerializer
     ),
     WriteStandardCRUDRepo<ObjectType, IdType, InputValue> by KtorWriteStandardCrudRepo(
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         objectsSerializer,
         objectsNullableSerializer,
         inputsSerializer,
         idsSerializer
+    ) {
+    constructor(
+        baseUrl: String,
+        baseSubpart: String,
+        client: HttpClient,
+        objectsSerializer: KSerializer<ObjectType>,
+        objectsNullableSerializer: KSerializer<ObjectType?>,
+        inputsSerializer: KSerializer<InputValue>,
+        idsSerializer: KSerializer<IdType>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this(
+        baseUrl, baseSubpart, UnifiedRequester(client, serialFormat), objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer
     )
+}

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

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.client.crud
 
 import dev.inmo.micro_utils.ktor.client.*
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+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.*
@@ -12,7 +12,7 @@ import kotlinx.serialization.builtins.*
 
 class KtorWriteStandardCrudRepo<ObjectType, IdType, InputValue> (
     private val baseUrl: String,
-    private val client: HttpClient = HttpClient(),
+    private val unifiedRequester: UnifiedRequester,
     private val objectsSerializer: KSerializer<ObjectType>,
     private val objectsNullableSerializer: KSerializer<ObjectType?>,
     private val inputsSerializer: KSerializer<InputValue>,
@@ -27,39 +27,51 @@ class KtorWriteStandardCrudRepo<ObjectType, IdType, InputValue> (
     )
     private val listInputUpdateSerializer = ListSerializer(inputUpdateSerializer)
 
-    override val newObjectsFlow: Flow<ObjectType> = client.createStandardWebsocketFlow(
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        objectsSerializer: KSerializer<ObjectType>,
+        objectsSerializerNullable: KSerializer<ObjectType?>,
+        inputsSerializer: KSerializer<InputValue>,
+        idsSerializer: KSerializer<IdType>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (
+        baseUrl, UnifiedRequester(client, serialFormat), objectsSerializer, objectsSerializerNullable, inputsSerializer, idsSerializer
+    )
+
+    override val newObjectsFlow: Flow<ObjectType> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, newObjectsFlowRouting),
         deserializer = objectsSerializer
     )
-    override val updatedObjectsFlow: Flow<ObjectType> = client.createStandardWebsocketFlow(
+    override val updatedObjectsFlow: Flow<ObjectType> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
         deserializer = objectsSerializer
     )
-    override val deletedObjectsIdsFlow: Flow<IdType> = client.createStandardWebsocketFlow(
+    override val deletedObjectsIdsFlow: Flow<IdType> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
         deserializer = idsSerializer
     )
 
 
-    override suspend fun create(values: List<InputValue>): List<ObjectType> = client.unipost(
+    override suspend fun create(values: List<InputValue>): List<ObjectType> = unifiedRequester.unipost(
         buildStandardUrl(baseUrl, createRouting),
         BodyPair(listInputSerializer, values),
         listObjectsSerializer
     )
 
-    override suspend fun update(id: IdType, value: InputValue): ObjectType? = client.unipost(
+    override suspend fun update(id: IdType, value: InputValue): ObjectType? = unifiedRequester.unipost(
         buildStandardUrl(baseUrl, updateRouting),
         BodyPair(inputUpdateSerializer, id to value),
         objectsNullableSerializer
     )
 
-    override suspend fun update(values: List<UpdatedValuePair<IdType, InputValue>>): List<ObjectType> = client.unipost(
+    override suspend fun update(values: List<UpdatedValuePair<IdType, InputValue>>): List<ObjectType> = unifiedRequester.unipost(
         buildStandardUrl(baseUrl, updateManyRouting),
         BodyPair(listInputUpdateSerializer, values),
         listObjectsSerializer
     )
 
-    override suspend fun deleteById(ids: List<IdType>) = client.unipost(
+    override suspend fun deleteById(ids: List<IdType>) = unifiedRequester.unipost(
         buildStandardUrl(baseUrl, deleteByIdRouting),
         BodyPair(listIdsSerializer, ids),
         Unit.serializer()

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

@@ -1,80 +1,90 @@
 package dev.inmo.micro_utils.repos.ktor.client.key_value
 
-import dev.inmo.micro_utils.ktor.client.encodeUrlQueryValue
-import dev.inmo.micro_utils.ktor.client.uniget
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+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.key_value.*
 import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
 import io.ktor.client.HttpClient
-import kotlinx.serialization.KSerializer
+import kotlinx.serialization.*
 import kotlinx.serialization.builtins.serializer
 
 class KtorReadStandardKeyValueRepo<Key, Value> (
-    private var baseUrl: String,
-    private var client: HttpClient = HttpClient(),
-    private var keySerializer: KSerializer<Key>,
-    private var valueSerializer: KSerializer<Value>,
-    private var valueNullableSerializer: KSerializer<Value?>,
+    private val baseUrl: String,
+    private val unifiedRequester: UnifiedRequester,
+    private val keySerializer: KSerializer<Key>,
+    private val valueSerializer: KSerializer<Value>,
+    private val valueNullableSerializer: KSerializer<Value?>
 ) : ReadStandardKeyValueRepo<Key, Value> {
-    override suspend fun get(k: Key): Value? = client.uniget(
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        keySerializer: KSerializer<Key>,
+        valueSerializer: KSerializer<Value>,
+        valueNullableSerializer: KSerializer<Value?>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (
+        baseUrl, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer, valueNullableSerializer
+    )
+
+    override suspend fun get(k: Key): Value? = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             getRoute,
             mapOf(
-                keyParameterName to keySerializer.encodeUrlQueryValue(k)
+                keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, k)
             )
         ),
         valueNullableSerializer
     )
 
-    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = client.uniget(
+    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             valuesRoute,
             mapOf(
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         PaginationResult.serializer(valueSerializer)
     )
 
-    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = client.uniget(
+    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             keysRoute,
             mapOf(
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         PaginationResult.serializer(keySerializer)
     )
 
-    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = client.uniget(
+    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             keysRoute,
             mapOf(
-                valueParameterName to valueSerializer.encodeUrlQueryValue(v),
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                valueParameterName to unifiedRequester.encodeUrlQueryValue(valueSerializer, v),
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         PaginationResult.serializer(keySerializer)
     )
 
-    override suspend fun contains(key: Key): Boolean = client.uniget(
+    override suspend fun contains(key: Key): Boolean = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             containsRoute,
             mapOf(
-                keyParameterName to keySerializer.encodeUrlQueryValue(key)
+                keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, key)
             ),
         ),
         Boolean.serializer(),
     )
 
-    override suspend fun count(): Long = client.uniget(
+    override suspend fun count(): Long = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             countRoute,

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

@@ -1,27 +1,40 @@
 package dev.inmo.micro_utils.repos.ktor.client.key_value
 
+import dev.inmo.micro_utils.ktor.client.UnifiedRequester
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
-import kotlinx.serialization.KSerializer
+import kotlinx.serialization.*
 
 class KtorStandartKeyValueRepo<K, V> (
     baseUrl: String,
     baseSubpart: String,
-    client: HttpClient = HttpClient(),
+    unifiedRequester: UnifiedRequester,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>
 ) : StandardKeyValueRepo<K, V>,
     ReadStandardKeyValueRepo<K, V> by KtorReadStandardKeyValueRepo(
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         keySerializer,
         valueSerializer,
         valueNullableSerializer
     ),
     WriteStandardKeyValueRepo<K, V> by KtorWriteStandardKeyValueRepo(
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         keySerializer,
         valueSerializer
-    )
+    ) {
+    constructor(
+        baseUrl: String,
+        baseSubpart: String,
+        client: HttpClient = HttpClient(),
+        keySerializer: KSerializer<K>,
+        valueSerializer: KSerializer<V>,
+        valueNullableSerializer: KSerializer<V?>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this(baseUrl, baseSubpart, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer, valueNullableSerializer)
+}

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

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.client.key_value
 
 import dev.inmo.micro_utils.ktor.client.*
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+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
@@ -11,23 +11,34 @@ import kotlinx.serialization.builtins.*
 
 class KtorWriteStandardKeyValueRepo<K, V> (
     private var baseUrl: String,
-    private var client: HttpClient = HttpClient(),
+    private var unifiedRequester: UnifiedRequester,
     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(
+
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        keySerializer: KSerializer<K>,
+        valueSerializer: KSerializer<V>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (
+        baseUrl, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer
+    )
+
+    override val onNewValue: Flow<Pair<K, V>> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onNewValueRoute),
         deserializer = PairSerializer(keySerializer, valueSerializer)
     )
 
-    override val onValueRemoved: Flow<K> = client.createStandardWebsocketFlow(
+    override val onValueRemoved: Flow<K> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onValueRemovedRoute),
         deserializer = keySerializer
     )
 
-    override suspend fun set(toSet: Map<K, V>) = client.unipost(
+    override suspend fun set(toSet: Map<K, V>) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             setRoute
@@ -36,7 +47,7 @@ class KtorWriteStandardKeyValueRepo<K, V> (
         Unit.serializer()
     )
 
-    override suspend fun unset(toUnset: List<K>) = client.unipost(
+    override suspend fun unset(toUnset: List<K>) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             unsetRoute,

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

@@ -1,5 +1,8 @@
 package dev.inmo.micro_utils.repos.ktor.client.one_to_many
 
+import dev.inmo.micro_utils.ktor.client.UnifiedRequester
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
 import kotlinx.serialization.KSerializer
@@ -7,19 +10,28 @@ import kotlinx.serialization.KSerializer
 class KtorOneToManyKeyValueRepo<Key, Value>(
     baseUrl: String,
     baseSubpart: String,
-    client: HttpClient,
+    unifiedRequester: UnifiedRequester,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
 ) : OneToManyKeyValueRepo<Key, Value>,
     ReadOneToManyKeyValueRepo<Key, Value> by KtorReadOneToManyKeyValueRepo<Key, Value> (
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         keySerializer,
         valueSerializer,
     ),
     WriteOneToManyKeyValueRepo<Key, Value> by KtorWriteOneToManyKeyValueRepo<Key, Value> (
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         keySerializer,
         valueSerializer,
-    )
+    ) {
+    constructor(
+        baseUrl: String,
+        baseSubpart: String,
+        client: HttpClient,
+        keySerializer: KSerializer<Key>,
+        valueSerializer: KSerializer<Value>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (baseUrl, baseSubpart, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer)
+}

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

@@ -1,8 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.client.one_to_many
 
-import dev.inmo.micro_utils.ktor.client.encodeUrlQueryValue
-import dev.inmo.micro_utils.ktor.client.uniget
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+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.ReadOneToManyKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.keyParameterName
@@ -15,81 +14,89 @@ import kotlinx.serialization.builtins.serializer
 
 class KtorReadOneToManyKeyValueRepo<Key, Value> (
     private val baseUrl: String,
-    private val client: HttpClient = HttpClient(),
+    private val unifiedRequester: UnifiedRequester,
     private val keySerializer: KSerializer<Key>,
-    private val valueSerializer: KSerializer<Value>,
+    private val valueSerializer: KSerializer<Value>
 ) : ReadOneToManyKeyValueRepo<Key, Value> {
     private val paginationValueResultSerializer = PaginationResult.serializer(valueSerializer)
     private val paginationKeyResultSerializer = PaginationResult.serializer(keySerializer)
 
-    override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> = client.uniget(
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        keySerializer: KSerializer<Key>,
+        valueSerializer: KSerializer<Value>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (baseUrl, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer)
+
+    override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             getRoute,
             mapOf(
-                keyParameterName to keySerializer.encodeUrlQueryValue(k),
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, k),
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         paginationValueResultSerializer
     )
 
-    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = client.uniget(
+    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             keysRoute,
             mapOf(
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         paginationKeyResultSerializer
     )
 
-    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = client.uniget(
+    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             keysRoute,
             mapOf(
-                valueParameterName to valueSerializer.encodeUrlQueryValue(v),
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                valueParameterName to unifiedRequester.encodeUrlQueryValue(valueSerializer, v),
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         paginationKeyResultSerializer
     )
 
-    override suspend fun contains(k: Key): Boolean = client.uniget(
+    override suspend fun contains(k: Key): Boolean = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             containsByKeyRoute,
-            mapOf(keyParameterName to keySerializer.encodeUrlQueryValue(k))
+            mapOf(keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, k))
         ),
         Boolean.serializer()
     )
 
-    override suspend fun contains(k: Key, v: Value): Boolean = client.uniget(
+    override suspend fun contains(k: Key, v: Value): Boolean = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             containsByKeyValueRoute,
             mapOf(
-                keyParameterName to keySerializer.encodeUrlQueryValue(k),
-                valueParameterName to valueSerializer.encodeUrlQueryValue(v),
+                keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, k),
+                valueParameterName to unifiedRequester.encodeUrlQueryValue(valueSerializer, v),
             )
         ),
         Boolean.serializer()
     )
 
-    override suspend fun count(k: Key): Long = client.uniget(
+    override suspend fun count(k: Key): Long = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             countByKeyRoute,
             mapOf(
-                keyParameterName to keySerializer.encodeUrlQueryValue(k)
+                keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, k)
             )
         ),
         Long.serializer()
     )
 
-    override suspend fun count(): Long = client.uniget(
+    override suspend fun count(): Long = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             countRoute,

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

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.client.one_to_many
 
 import dev.inmo.micro_utils.ktor.client.*
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+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
@@ -11,26 +11,37 @@ import kotlinx.serialization.builtins.*
 
 class KtorWriteOneToManyKeyValueRepo<Key, Value> (
     private val baseUrl: String,
-    private val client: HttpClient = HttpClient(),
+    private val unifiedRequester: UnifiedRequester,
     private val keySerializer: KSerializer<Key>,
     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(
+
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        keySerializer: KSerializer<Key>,
+        valueSerializer: KSerializer<Value>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (
+        baseUrl, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer
+    )
+
+    override val onNewValue: Flow<Pair<Key, Value>> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onNewValueRoute),
         deserializer = keyValueSerializer
     )
-    override val onValueRemoved: Flow<Pair<Key, Value>> = client.createStandardWebsocketFlow(
+    override val onValueRemoved: Flow<Pair<Key, Value>> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onValueRemovedRoute),
         deserializer = keyValueSerializer
     )
-    override val onDataCleared: Flow<Key> = client.createStandardWebsocketFlow(
+    override val onDataCleared: Flow<Key> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onDataClearedRoute),
         deserializer = keySerializer
     )
 
-    override suspend fun remove(toRemove: Map<Key, List<Value>>) = client.unipost(
+    override suspend fun remove(toRemove: Map<Key, List<Value>>) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             removeRoute,
@@ -39,7 +50,7 @@ class KtorWriteOneToManyKeyValueRepo<Key, Value> (
         Unit.serializer(),
     )
 
-    override suspend fun add(toAdd: Map<Key, List<Value>>) = client.unipost(
+    override suspend fun add(toAdd: Map<Key, List<Value>>) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             addRoute,
@@ -47,7 +58,7 @@ class KtorWriteOneToManyKeyValueRepo<Key, Value> (
         BodyPair(keyValueMapSerializer, toAdd),
         Unit.serializer(),
     )
-    override suspend fun clear(k: Key) = client.unipost(
+    override suspend fun clear(k: Key) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             clearRoute,
@@ -56,7 +67,7 @@ class KtorWriteOneToManyKeyValueRepo<Key, Value> (
         Unit.serializer(),
     )
 
-    override suspend fun set(toSet: Map<Key, List<Value>>) = client.unipost(
+    override suspend fun set(toSet: Map<Key, List<Value>>) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             setRoute,

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

@@ -1,12 +1,14 @@
 package dev.inmo.micro_utils.repos.ktor.server.crud
 
-import dev.inmo.micro_utils.ktor.server.decodeUrlQueryValueOrSendError
-import dev.inmo.micro_utils.ktor.server.unianswer
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
+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.crud.*
 import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.get
 import kotlinx.serialization.KSerializer
@@ -16,47 +18,65 @@ fun <ObjectType, IdType> Route.configureReadStandardCrudRepoRoutes(
     originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
-    idsSerializer: KSerializer<IdType>
+    idsSerializer: KSerializer<IdType>,
+    unifiedRouter: UnifiedRouter
 ) {
     val paginationResultSerializer = PaginationResult.serializer(objectsSerializer)
 
     get(getByPaginationRouting) {
-        val pagination = call.request.queryParameters.extractPagination
+        unifiedRouter.apply {
+            val pagination = call.request.queryParameters.extractPagination
 
-        call.unianswer(
-            paginationResultSerializer,
-            originalRepo.getByPagination(pagination)
-        )
+            unianswer(
+                paginationResultSerializer,
+                originalRepo.getByPagination(pagination)
+            )
+        }
     }
 
     get(getByIdRouting) {
-        val id = call.decodeUrlQueryValueOrSendError(
-            "id",
-            idsSerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val id = decodeUrlQueryValueOrSendError(
+                "id",
+                idsSerializer
+            ) ?: return@get
 
-        call.unianswer(
-            objectsNullableSerializer,
-            originalRepo.getById(id)
-        )
+            unianswer(
+                objectsNullableSerializer,
+                originalRepo.getById(id)
+            )
+        }
     }
 
     get(containsRouting) {
-        val id = call.decodeUrlQueryValueOrSendError(
-            "id",
-            idsSerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val id = decodeUrlQueryValueOrSendError(
+                "id",
+                idsSerializer
+            ) ?: return@get
 
-        call.unianswer(
-            Boolean.serializer(),
-            originalRepo.contains(id)
-        )
+            unianswer(
+                Boolean.serializer(),
+                originalRepo.contains(id)
+            )
+        }
     }
 
     get(countRouting) {
-        call.unianswer(
-            Long.serializer(),
-            originalRepo.count()
-        )
+        unifiedRouter.apply {
+            unianswer(
+                Long.serializer(),
+                originalRepo.count()
+            )
+        }
     }
 }
+
+inline fun <ObjectType, IdType> Route.configureReadStandardCrudRepoRoutes(
+    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+    objectsSerializer: KSerializer<ObjectType>,
+    objectsNullableSerializer: KSerializer<ObjectType?>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureReadStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

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

@@ -1,6 +1,11 @@
 package dev.inmo.micro_utils.repos.ktor.server.crud
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
+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.routing.Route
 import io.ktor.routing.route
 import kotlinx.serialization.KSerializer
@@ -11,10 +16,24 @@ fun <ObjectType, IdType, InputValue> Route.configureStandardCrudRepoRoutes(
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
-    idsSerializer: KSerializer<IdType>
+    idsSerializer: KSerializer<IdType>,
+    unifiedRouter: UnifiedRouter
 ) {
     route(baseSubpart) {
-        configureReadStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer)
-        configureWriteStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer)
+        configureReadStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer, unifiedRouter)
+        configureWriteStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, unifiedRouter)
     }
 }
+
+fun <ObjectType, IdType, InputValue> Route.configureStandardCrudRepoRoutes(
+    baseSubpart: String,
+    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
+    objectsSerializer: KSerializer<ObjectType>,
+    objectsNullableSerializer: KSerializer<ObjectType?>,
+    inputsSerializer: KSerializer<InputValue>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureStandardCrudRepoRoutes(
+    baseSubpart, originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, UnifiedRouter(serialFormat, serialFormatContentType)
+)

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

@@ -1,9 +1,12 @@
 package dev.inmo.micro_utils.repos.ktor.server.crud
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 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.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.post
 import kotlinx.serialization.KSerializer
@@ -14,7 +17,8 @@ fun <ObjectType, IdType, InputValue> Route.configureWriteStandardCrudRepoRoutes(
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
-    idsSerializer: KSerializer<IdType>
+    idsSerializer: KSerializer<IdType>,
+    unifiedRouter: UnifiedRouter
 ) {
     val listObjectsSerializer = ListSerializer(objectsSerializer)
     val listInputSerializer = ListSerializer(inputsSerializer)
@@ -25,58 +29,80 @@ fun <ObjectType, IdType, InputValue> Route.configureWriteStandardCrudRepoRoutes(
     )
     val listInputUpdateSerializer = ListSerializer(inputUpdateSerializer)
 
-    includeWebsocketHandling(
-        newObjectsFlowRouting,
-        originalRepo.newObjectsFlow,
-        objectsSerializer
-    )
-    includeWebsocketHandling(
-        updatedObjectsFlowRouting,
-        originalRepo.updatedObjectsFlow,
-        objectsSerializer
-    )
-    includeWebsocketHandling(
-        deletedObjectsIdsFlowRouting,
-        originalRepo.deletedObjectsIdsFlow,
-        idsSerializer
-    )
+    unifiedRouter.apply {
+        includeWebsocketHandling(
+            newObjectsFlowRouting,
+            originalRepo.newObjectsFlow,
+            objectsSerializer
+        )
+        includeWebsocketHandling(
+            updatedObjectsFlowRouting,
+            originalRepo.updatedObjectsFlow,
+            objectsSerializer
+        )
+        includeWebsocketHandling(
+            deletedObjectsIdsFlowRouting,
+            originalRepo.deletedObjectsIdsFlow,
+            idsSerializer
+        )
+    }
 
     post(createRouting) {
-        call.unianswer(
-            listObjectsSerializer,
-            originalRepo.create(
-                call.uniload(listInputSerializer)
+        unifiedRouter.apply {
+            unianswer(
+                listObjectsSerializer,
+                originalRepo.create(
+                    uniload(listInputSerializer)
+                )
             )
-        )
+        }
     }
 
     post(updateRouting) {
-        val (id, input) = call.uniload(inputUpdateSerializer)
-        call.unianswer(
-            objectsNullableSerializer,
-            originalRepo.update(
-                id, input
+        unifiedRouter.apply {
+            val (id, input) = uniload(inputUpdateSerializer)
+            unianswer(
+                objectsNullableSerializer,
+                originalRepo.update(
+                    id, input
+                )
             )
-        )
+        }
     }
 
     post(updateManyRouting) {
-        val updates = call.uniload(listInputUpdateSerializer)
-        call.unianswer(
-            listObjectsSerializer,
-            originalRepo.update(
-                updates
+        unifiedRouter.apply {
+            val updates = uniload(listInputUpdateSerializer)
+            unianswer(
+                listObjectsSerializer,
+                originalRepo.update(
+                    updates
+                )
             )
-        )
+        }
     }
 
     post(deleteByIdRouting) {
-        val ids = call.uniload(listIdsSerializer)
-        call.unianswer(
-            Unit.serializer(),
-            originalRepo.deleteById(
-                ids
+        unifiedRouter.apply {
+            val ids = uniload(listIdsSerializer)
+            unianswer(
+                Unit.serializer(),
+                originalRepo.deleteById(
+                    ids
+                )
             )
-        )
+        }
     }
 }
+
+fun <ObjectType, IdType, InputValue> Route.configureWriteStandardCrudRepoRoutes(
+    originalRepo: WriteStandardCRUDRepo<ObjectType, IdType, InputValue>,
+    objectsSerializer: KSerializer<ObjectType>,
+    objectsNullableSerializer: KSerializer<ObjectType?>,
+    inputsSerializer: KSerializer<InputValue>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureWriteStandardCrudRepoRoutes(
+    originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, UnifiedRouter(serialFormat, serialFormatContentType)
+)

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

@@ -1,16 +1,22 @@
 package dev.inmo.micro_utils.repos.ktor.server.key_value
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.server.UnifiedRouter
+import dev.inmo.micro_utils.ktor.server.standardKtorSerialFormatContentType
 import dev.inmo.micro_utils.repos.StandardKeyValueRepo
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.route
 import kotlinx.serialization.KSerializer
 
-fun <K, V> Route.configureStandartKeyValueRepoRoutes(
+fun <K, V> Route.configureStandardKeyValueRepoRoutes(
     baseSubpart: String,
     originalRepo: StandardKeyValueRepo<K, V>,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>,
+    unifiedRouter: UnifiedRouter
 ) {
     route(baseSubpart) {
         configureReadStandartKeyValueRepoRoutes(
@@ -18,11 +24,23 @@ fun <K, V> Route.configureStandartKeyValueRepoRoutes(
             keySerializer,
             valueSerializer,
             valueNullableSerializer,
+            unifiedRouter
         )
-        configureWriteStandartKeyValueRepoRoutes(
+        configureWriteStandardKeyValueRepoRoutes(
             originalRepo,
             keySerializer,
             valueSerializer,
+            unifiedRouter
         )
     }
-}
+}
+
+fun <K, V> Route.configureStandartKeyValueRepoRoutes(
+    baseSubpart: String,
+    originalRepo: StandardKeyValueRepo<K, V>,
+    keySerializer: KSerializer<K>,
+    valueSerializer: KSerializer<V>,
+    valueNullableSerializer: KSerializer<V?>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureStandardKeyValueRepoRoutes(baseSubpart, originalRepo, keySerializer, valueSerializer, valueNullableSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

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

@@ -1,5 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.server.key_value
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
@@ -7,6 +9,7 @@ import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
 import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.get
 import kotlinx.serialization.KSerializer
@@ -17,62 +20,84 @@ fun <K, V> Route.configureReadStandartKeyValueRepoRoutes (
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>,
+    unifiedRouter: UnifiedRouter
 ) {
     get(getRoute) {
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
 
-        call.unianswer(
-            valueNullableSerializer,
-            originalRepo.get(key)
-        )
+            unianswer(
+                valueNullableSerializer,
+                originalRepo.get(key)
+            )
+        }
     }
 
     get(valuesRoute) {
-        val parination = call.request.queryParameters.extractPagination;
-        val reversed = call.decodeUrlQueryValueOrSendError(
-            reversedParameterName,
-            Boolean.serializer()
-        ) ?: return@get
+        unifiedRouter.apply {
+            val parination = call.request.queryParameters.extractPagination;
+            val reversed = decodeUrlQueryValueOrSendError(
+                reversedParameterName,
+                Boolean.serializer()
+            ) ?: return@get
 
-        call.unianswer(
-            PaginationResult.serializer(valueSerializer),
-            originalRepo.values(parination, reversed)
-        )
+            unianswer(
+                PaginationResult.serializer(valueSerializer),
+                originalRepo.values(parination, reversed)
+            )
+        }
     }
 
     get(keysRoute) {
-        val parination = call.request.queryParameters.extractPagination;
-        val reversed = call.decodeUrlQueryValueOrSendError(
-            reversedParameterName,
-            Boolean.serializer()
-        ) ?: return@get
-        val value = call.decodeUrlQueryValue(valueParameterName, valueSerializer)
+        unifiedRouter.apply {
+            val parination = call.request.queryParameters.extractPagination;
+            val reversed = decodeUrlQueryValueOrSendError(
+                reversedParameterName,
+                Boolean.serializer()
+            ) ?: return@get
+            val value = decodeUrlQueryValue(valueParameterName, valueSerializer)
 
-        call.unianswer(
-            PaginationResult.serializer(keySerializer),
-            value ?.let { originalRepo.keys(value, parination, reversed) } ?: originalRepo.keys(parination, reversed)
-        )
+            unianswer(
+                PaginationResult.serializer(keySerializer),
+                value?.let { originalRepo.keys(value, parination, reversed) } ?: originalRepo.keys(parination, reversed)
+            )
+        }
     }
 
     get(containsRoute) {
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
 
-        call.unianswer(
-            Boolean.serializer(),
-            originalRepo.contains(key)
-        )
+            unianswer(
+                Boolean.serializer(),
+                originalRepo.contains(key)
+            )
+        }
     }
 
     get(countRoute) {
-        call.unianswer(
-            Long.serializer(),
-            originalRepo.count()
-        )
+        unifiedRouter.apply {
+            unianswer(
+                Long.serializer(),
+                originalRepo.count()
+            )
+        }
     }
-}
+}
+
+inline fun <K, V> Route.configureReadStandartKeyValueRepoRoutes (
+    originalRepo: ReadStandardKeyValueRepo<K, V>,
+    keySerializer: KSerializer<K>,
+    valueSerializer: KSerializer<V>,
+    valueNullableSerializer: KSerializer<V?>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureReadStandartKeyValueRepoRoutes(
+    originalRepo, keySerializer, valueSerializer, valueNullableSerializer, UnifiedRouter(serialFormat, serialFormatContentType)
+)

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

@@ -1,44 +1,61 @@
 package dev.inmo.micro_utils.repos.ktor.server.key_value
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 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.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.post
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.*
 
+fun <K, V> Route.configureWriteStandardKeyValueRepoRoutes (
+    originalRepo: WriteStandardKeyValueRepo<K, V>,
+    keySerializer: KSerializer<K>,
+    valueSerializer: KSerializer<V>,
+    unifiedRouter: UnifiedRouter
+) {
+    val keyValueMapSerializer = MapSerializer(keySerializer, valueSerializer)
+    val keysListSerializer = ListSerializer(keySerializer)
+    unifiedRouter.apply {
+        includeWebsocketHandling(
+            onNewValueRoute,
+            originalRepo.onNewValue,
+            PairSerializer(keySerializer, valueSerializer)
+        )
+
+        includeWebsocketHandling(
+            onValueRemovedRoute,
+            originalRepo.onValueRemoved,
+            keySerializer
+        )
+    }
+
+    post(setRoute) {
+        unifiedRouter.apply {
+            val toSet = uniload(
+                keyValueMapSerializer
+            )
+
+            unianswer(Unit.serializer(), originalRepo.set(toSet))
+        }
+    }
+
+    post(unsetRoute) {
+        unifiedRouter.apply {
+            val toUnset = uniload(keysListSerializer)
+
+            unianswer(Unit.serializer(), originalRepo.unset(toUnset))
+        }
+    }
+}
+
 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,
-        PairSerializer(keySerializer, valueSerializer)
-    )
-
-    includeWebsocketHandling(
-        onValueRemovedRoute,
-        originalRepo.onValueRemoved,
-        keySerializer
-    )
-
-    post(setRoute) {
-        val toSet = call.uniload(
-            keyValueMapSerializer
-        )
-
-        call.unianswer(Unit.serializer(), originalRepo.set(toSet))
-    }
-
-    post(unsetRoute) {
-        val toUnset = call.uniload(keysListSerializer)
-
-        call.unianswer(Unit.serializer(), originalRepo.unset(toUnset))
-    }
-}
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureWriteStandardKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

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

@@ -1,6 +1,11 @@
 package dev.inmo.micro_utils.repos.ktor.server.one_to_many
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.server.UnifiedRouter
+import dev.inmo.micro_utils.ktor.server.standardKtorSerialFormatContentType
 import dev.inmo.micro_utils.repos.OneToManyKeyValueRepo
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.route
 import kotlinx.serialization.KSerializer
@@ -9,10 +14,22 @@ fun <Key, Value> Route.configureOneToManyKeyValueRepoRoutes(
     baseSubpart: String,
     originalRepo: OneToManyKeyValueRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
-    valueSealizer: KSerializer<Value>,
+    valueSerializer: KSerializer<Value>,
+    unifiedRouter: UnifiedRouter
 ) {
     route(baseSubpart) {
-        configureOneToManyReadKeyValueRepoRoutes(originalRepo, keySerializer, valueSealizer)
-        configureOneToManyWriteKeyValueRepoRoutes(originalRepo, keySerializer, valueSealizer)
+        configureOneToManyReadKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, unifiedRouter)
+        configureOneToManyWriteKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, unifiedRouter)
     }
-}
+}
+
+fun <Key, Value> Route.configureOneToManyKeyValueRepoRoutes(
+    baseSubpart: String,
+    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+    keySerializer: KSerializer<Key>,
+    valueSerializer: KSerializer<Value>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureOneToManyKeyValueRepoRoutes(
+    baseSubpart, originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType)
+)

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

@@ -1,5 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.server.one_to_many
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
@@ -10,6 +12,7 @@ import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
 import dev.inmo.micro_utils.repos.ktor.common.reversedParameterName
 import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.get
 import kotlinx.serialization.KSerializer
@@ -18,89 +21,110 @@ import kotlinx.serialization.builtins.serializer
 fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
     originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
-    valueSealizer: KSerializer<Value>,
+    valueSerializer: KSerializer<Value>,
+    unifiedRouter: UnifiedRouter
 ) {
     val paginationKeyResult = PaginationResult.serializer(keySerializer)
-    val paginationValueResult = PaginationResult.serializer(valueSealizer)
+    val paginationValueResult = PaginationResult.serializer(valueSerializer)
 
     get(getRoute) {
-        val pagination = call.request.queryParameters.extractPagination
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
-        val reversed = call.decodeUrlQueryValue(
-            reversedParameterName,
-            Boolean.serializer()
-        ) ?: false
+        unifiedRouter.apply {
+            val pagination = call.request.queryParameters.extractPagination
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
+            val reversed = decodeUrlQueryValue(
+                reversedParameterName,
+                Boolean.serializer()
+            ) ?: false
 
-        call.unianswer(
-            paginationValueResult,
-            originalRepo.get(key, pagination, reversed)
-        )
+            unianswer(
+                paginationValueResult,
+                originalRepo.get(key, pagination, reversed)
+            )
+        }
     }
 
     get(keysRoute) {
-        val pagination = call.request.queryParameters.extractPagination
-        val reversed = call.decodeUrlQueryValue(
-            reversedParameterName,
-            Boolean.serializer()
-        ) ?: false
-        val value: Value? = call.decodeUrlQueryValue(
-            valueParameterName,
-            valueSealizer
-        )
+        unifiedRouter.apply {
+            val pagination = call.request.queryParameters.extractPagination
+            val reversed = decodeUrlQueryValue(
+                reversedParameterName,
+                Boolean.serializer()
+            ) ?: false
+            val value: Value? = decodeUrlQueryValue(
+                valueParameterName,
+                valueSerializer
+            )
 
-        call.unianswer(
-            paginationKeyResult,
-            value ?.let { originalRepo.keys(value, pagination, reversed) } ?: originalRepo.keys(pagination, reversed)
-        )
+            unianswer(
+                paginationKeyResult,
+                value?.let { originalRepo.keys(value, pagination, reversed) } ?: originalRepo.keys(pagination, reversed)
+            )
+        }
     }
 
     get(containsByKeyRoute) {
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
 
-        call.unianswer(
-            Boolean.serializer(),
-            originalRepo.contains(key)
-        )
+            unianswer(
+                Boolean.serializer(),
+                originalRepo.contains(key)
+            )
+        }
     }
 
     get(containsByKeyValueRoute) {
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
-        val value = call.decodeUrlQueryValueOrSendError(
-            valueParameterName,
-            valueSealizer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
+            val value = decodeUrlQueryValueOrSendError(
+                valueParameterName,
+                valueSerializer
+            ) ?: return@get
 
-        call.unianswer(
-            Boolean.serializer(),
-            originalRepo.contains(key, value)
-        )
+            unianswer(
+                Boolean.serializer(),
+                originalRepo.contains(key, value)
+            )
+        }
     }
 
     get(countByKeyRoute) {
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
 
-        call.unianswer(
-            Long.serializer(),
-            originalRepo.count(key)
-        )
+            unianswer(
+                Long.serializer(),
+                originalRepo.count(key)
+            )
+        }
     }
 
     get(countRoute) {
-        call.unianswer(
-            Long.serializer(),
-            originalRepo.count()
-        )
+        unifiedRouter.apply {
+            unianswer(
+                Long.serializer(),
+                originalRepo.count()
+            )
+        }
     }
-}
+}
+
+inline fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
+    originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
+    keySerializer: KSerializer<Key>,
+    valueSerializer: KSerializer<Value>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureOneToManyReadKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

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

@@ -1,9 +1,12 @@
 package dev.inmo.micro_utils.repos.ktor.server.one_to_many
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 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.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.post
 import kotlinx.serialization.KSerializer
@@ -13,61 +16,78 @@ fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
     originalRepo: WriteOneToManyKeyValueRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
+    unifiedRouter: UnifiedRouter
 ) {
     val keyValueSerializer = PairSerializer(keySerializer, valueSerializer)
     val keyValueMapSerializer = MapSerializer(keySerializer, ListSerializer(valueSerializer))
 
-    includeWebsocketHandling(
-        onNewValueRoute,
-        originalRepo.onNewValue,
-        keyValueSerializer
-    )
-    includeWebsocketHandling(
-        onValueRemovedRoute,
-        originalRepo.onValueRemoved,
-        keyValueSerializer
-    )
-    includeWebsocketHandling(
-        onDataClearedRoute,
-        originalRepo.onDataCleared,
-        keySerializer
-    )
+    unifiedRouter.apply {
+        includeWebsocketHandling(
+            onNewValueRoute,
+            originalRepo.onNewValue,
+            keyValueSerializer
+        )
+        includeWebsocketHandling(
+            onValueRemovedRoute,
+            originalRepo.onValueRemoved,
+            keyValueSerializer
+        )
+        includeWebsocketHandling(
+            onDataClearedRoute,
+            originalRepo.onDataCleared,
+            keySerializer
+        )
+    }
 
     post(addRoute) {
-        val obj = call.uniload(keyValueMapSerializer)
+        unifiedRouter.apply {
+            val obj = uniload(keyValueMapSerializer)
 
-        call.unianswer(
-            Unit.serializer(),
-            originalRepo.add(obj)
-        )
+            unianswer(
+                Unit.serializer(),
+                originalRepo.add(obj)
+            )
+        }
     }
 
     post(removeRoute) {
-        val obj = call.uniload(
-            keyValueMapSerializer
-        )
+        unifiedRouter.apply {
+            val obj = uniload(keyValueMapSerializer)
 
-        call.unianswer(
-            Unit.serializer(),
-            originalRepo.remove(obj),
-        )
+            unianswer(
+                Unit.serializer(),
+                originalRepo.remove(obj),
+            )
+        }
     }
 
     post(clearRoute) {
-        val key = call.uniload(keySerializer)
+        unifiedRouter.apply {
+            val key = uniload(keySerializer)
 
-        call.unianswer(
-            Unit.serializer(),
-            originalRepo.clear(key),
-        )
+            unianswer(
+                Unit.serializer(),
+                originalRepo.clear(key),
+            )
+        }
     }
 
     post(setRoute) {
-        val obj = call.uniload(keyValueMapSerializer)
+        unifiedRouter.apply {
+            val obj = uniload(keyValueMapSerializer)
 
-        call.unianswer(
-            Unit.serializer(),
-            originalRepo.set(obj)
-        )
+            unianswer(
+                Unit.serializer(),
+                originalRepo.set(obj)
+            )
+        }
     }
-}
+}
+
+fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
+    originalRepo: WriteOneToManyKeyValueRepo<Key, Value>,
+    keySerializer: KSerializer<Key>,
+    valueSerializer: KSerializer<Value>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureOneToManyWriteKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType))