add deprecations removing note

0.13.2

CHANGELOG.md

@@ -1,5 +1,55 @@
 # Changelog
 
+## 0.14.0
+
+**ALL DEPRECATIONS HAVE BEEN REMOVED**
+
+* `Versions`:
+    * `Kotlin`: `1.7.10` -> `1.7.20`
+    * `Klock`: `3.3.0` -> `3.3.1`
+    * `Compose`: `1.2.0` -> `1.2.1`
+    * `Exposed`: `0.39.2` -> `0.40.1`
+
+## 0.13.2
+
+* `Versions`:
+    * `Klock`: `3.1.0` -> `3.3.0`
+    * `Ktor`: `2.1.2` -> `2.1.3`
+
+## 0.13.1
+
+* `Repos`:
+    * `Exposed`:
+      * `AbstractExposedWriteCRUDRepo#createAndInsertId` now is optional and returns nullable value
+
+## 0.13.0
+
+**ALL DEPRECATIONS HAVE BEEN REMOVED**
+**A LOT OF KTOR METHODS RELATED TO UnifierRouter/UnifiedRequester HAVE BEEN REMOVED**
+
+* `Repos`:
+  * `Exposed`:
+    * `AbstractExposedWriteCRUDRepo` got two new methods: `update` with `it` as `UpdateBuilder<Int>` and `createAndInsertId`
+      * Old `update` method has been deprecated and not recommended to override anymore in realizations
+      * Old `insert` method now is `open` instead of `abstract` and can be omitted
+    * `AbstractExposedKeyValueRepo` got two new methods: `update` with `it` as `UpdateBuilder<Int>` and `insertKey`
+      * Old `update` method has been deprecated and not recommended to override anymore
+      * Old `insert` method now is `open` instead of `abstract` and can be omitted in realizations
+
+## 0.12.17
+
+* `Versions`:
+    * `JB Compose`: `1.2.0-alpha01-dev774` -> `1.2.0-beta02`
+    * `Ktor`: `2.1.1` -> `2.1.2`
+    * `Koin`: `3.2.0` -> `3.2.2`
+
+## 0.12.16
+
+* `Coroutines`:
+  * `Android`:
+    * Add class `FlowOnHierarchyChangeListener`
+    * Add `ViewGroup#setOnHierarchyChangeListenerRecursively(OnHierarchyChangeListener)`
+
 ## 0.12.15
 
 * `Common`:

coroutines/src/main/kotlin/FlowOnHierarchyChangeListener.kt

@@ -0,0 +1,50 @@
+package dev.inmo.micro_utils.coroutines
+
+import android.view.View
+import android.view.ViewGroup
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+
+/**
+ * [kotlinx.coroutines.flow.Flow]-based [android.view.ViewGroup.OnHierarchyChangeListener]
+ *
+ * @param recursive If set, any call of [onChildViewAdded] will check if child [View] is [ViewGroup] and subscribe to this
+ * [ViewGroup] too
+ * @param [_onChildViewAdded] Internal [MutableSharedFlow] which will be used to pass data to [onChildViewAdded] flow
+ * @param [_onChildViewRemoved] Internal [MutableSharedFlow] which will be used to pass data to [onChildViewRemoved] flow
+ */
+class FlowOnHierarchyChangeListener(
+    private val recursive: Boolean = false,
+    private val _onChildViewAdded: MutableSharedFlow<Pair<View, View>> = MutableSharedFlow(extraBufferCapacity = Int.MAX_VALUE),
+    private val _onChildViewRemoved: MutableSharedFlow<Pair<View, View>> = MutableSharedFlow(extraBufferCapacity = Int.MAX_VALUE)
+) : ViewGroup.OnHierarchyChangeListener {
+    val onChildViewAdded = _onChildViewAdded.asSharedFlow()
+    val onChildViewRemoved = _onChildViewRemoved.asSharedFlow()
+
+    /**
+     * Will emit data into [onChildViewAdded] flow. If [recursive] is true and [child] is [ViewGroup] will also
+     * subscribe to [child] hierarchy changes.
+     *
+     * Due to the fact that this method is not suspendable, [FlowOnHierarchyChangeListener] will use
+     * [MutableSharedFlow.tryEmit] to send data into [_onChildViewAdded]. That is why its default extraBufferCapacity is
+     * [Int.MAX_VALUE]
+     */
+    override fun onChildViewAdded(parent: View, child: View) {
+        _onChildViewAdded.tryEmit(parent to child)
+
+        if (recursive && child is ViewGroup) {
+            child.setOnHierarchyChangeListener(this)
+        }
+    }
+
+    /**
+     * Just emit data into [onChildViewRemoved]
+     *
+     * Due to the fact that this method is not suspendable, [FlowOnHierarchyChangeListener] will use
+     * [MutableSharedFlow.tryEmit] to send data into [_onChildViewRemoved]. That is why its default extraBufferCapacity is
+     * [Int.MAX_VALUE]
+     */
+    override fun onChildViewRemoved(parent: View, child: View) {
+        _onChildViewRemoved.tryEmit(parent to child)
+    }
+}

coroutines/src/main/kotlin/RecursiveHierarchySubscriber.kt

@@ -0,0 +1,17 @@
+package dev.inmo.micro_utils.coroutines
+
+import android.view.ViewGroup
+import android.view.ViewGroup.OnHierarchyChangeListener
+
+/**
+ * Use [ViewGroup.setOnHierarchyChangeListener] recursively for all available [ViewGroup]s starting with [this].
+ * This extension DO NOT guarantee that recursive subscription will happen after this method call
+ */
+fun ViewGroup.setOnHierarchyChangeListenerRecursively(
+    listener: OnHierarchyChangeListener
+) {
+    setOnHierarchyChangeListener(listener)
+    (0 until childCount).forEach {
+        (getChildAt(it) as? ViewGroup) ?.setOnHierarchyChangeListenerRecursively(listener)
+    }
+}

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.12.15
-android_code_version=154
+version=0.14.0
+android_code_version=161

gradle/libs.versions.toml

@@ -1,21 +1,21 @@
 [versions]
 
-kt = "1.7.10"
-kt-serialization = "1.4.0"
+kt = "1.7.20"
+kt-serialization = "1.4.1"
 kt-coroutines = "1.6.4"
 
-jb-compose = "1.2.0-alpha01-dev774"
-jb-exposed = "0.39.2"
-jb-dokka = "1.7.10"
+jb-compose = "1.2.1"
+jb-exposed = "0.40.1"
+jb-dokka = "1.7.20"
 
-klock = "3.1.0"
+klock = "3.3.1"
 uuid = "0.5.0"
 
-ktor = "2.1.1"
+ktor = "2.1.3"
 
 gh-release = "2.4.1"
 
-koin = "3.2.0"
+koin = "3.2.2"
 
 android-gradle = "7.2.2"
 dexcount = "3.1.0"

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

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

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

@@ -1,260 +0,0 @@
-package dev.inmo.micro_utils.ktor.client
-
-import dev.inmo.micro_utils.common.MPPFile
-import dev.inmo.micro_utils.common.filename
-import dev.inmo.micro_utils.ktor.common.*
-import io.ktor.client.HttpClient
-import io.ktor.client.call.body
-import io.ktor.client.request.*
-import io.ktor.client.request.forms.*
-import io.ktor.client.statement.readBytes
-import io.ktor.http.*
-import io.ktor.utils.io.core.ByteReadPacket
-import kotlinx.serialization.*
-
-@Deprecated("This class will be removed soon. It is now recommended to use built-in ktor features instead")
-class UnifiedRequester(
-    val client: HttpClient = HttpClient(),
-    val serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
-) {
-    suspend fun <ResultType> uniget(
-        url: String,
-        resultDeserializer: DeserializationStrategy<ResultType>
-    ): ResultType = client.uniget(url, resultDeserializer, serialFormat)
-
-    fun <T> encodeUrlQueryValue(
-        serializationStrategy: SerializationStrategy<T>,
-        value: T
-    ) = serializationStrategy.encodeUrlQueryValue(
-        value,
-        serialFormat
-    )
-
-    suspend fun <BodyType, ResultType> unipost(
-        url: String,
-        bodyInfo: Pair<SerializationStrategy<BodyType>, BodyType>,
-        resultDeserializer: DeserializationStrategy<ResultType>
-    ) = client.unipost(url, bodyInfo, resultDeserializer, serialFormat)
-
-    suspend fun <ResultType> unimultipart(
-        url: String,
-        filename: String,
-        inputProvider: InputProvider,
-        resultDeserializer: DeserializationStrategy<ResultType>,
-        mimetype: String = "*/*",
-        additionalParametersBuilder: FormBuilder.() -> Unit = {},
-        dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
-        requestBuilder: HttpRequestBuilder.() -> Unit = {},
-    ): ResultType = client.unimultipart(url, filename, inputProvider, resultDeserializer, mimetype, additionalParametersBuilder, dataHeadersBuilder, requestBuilder, serialFormat)
-
-    suspend fun <BodyType, ResultType> unimultipart(
-        url: String,
-        filename: String,
-        inputProvider: InputProvider,
-        otherData: Pair<SerializationStrategy<BodyType>, BodyType>,
-        resultDeserializer: DeserializationStrategy<ResultType>,
-        mimetype: String = "*/*",
-        additionalParametersBuilder: FormBuilder.() -> Unit = {},
-        dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
-        requestBuilder: HttpRequestBuilder.() -> Unit = {},
-    ): ResultType = client.unimultipart(url, filename, otherData, inputProvider, resultDeserializer, mimetype, additionalParametersBuilder, dataHeadersBuilder, requestBuilder, serialFormat)
-
-    suspend fun <ResultType> unimultipart(
-        url: String,
-        mppFile: MPPFile,
-        resultDeserializer: DeserializationStrategy<ResultType>,
-        mimetype: String = "*/*",
-        additionalParametersBuilder: FormBuilder.() -> Unit = {},
-        dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
-        requestBuilder: HttpRequestBuilder.() -> Unit = {}
-    ): ResultType = client.unimultipart(
-        url, mppFile, resultDeserializer, mimetype, additionalParametersBuilder, dataHeadersBuilder, requestBuilder, serialFormat
-    )
-
-    suspend fun <BodyType, ResultType> unimultipart(
-        url: String,
-        mppFile: MPPFile,
-        otherData: Pair<SerializationStrategy<BodyType>, BodyType>,
-        resultDeserializer: DeserializationStrategy<ResultType>,
-        mimetype: String = "*/*",
-        additionalParametersBuilder: FormBuilder.() -> Unit = {},
-        dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
-        requestBuilder: HttpRequestBuilder.() -> Unit = {}
-    ): ResultType = client.unimultipart(
-        url, mppFile, otherData, resultDeserializer, mimetype, additionalParametersBuilder, dataHeadersBuilder, requestBuilder, serialFormat
-    )
-
-    fun <T> createStandardWebsocketFlow(
-        url: String,
-        checkReconnection: suspend (Throwable?) -> Boolean,
-        deserializer: DeserializationStrategy<T>,
-        requestBuilder: HttpRequestBuilder.() -> Unit = {},
-    ) = client.createStandardWebsocketFlow(url, deserializer, checkReconnection, serialFormat, requestBuilder)
-
-    fun <T> createStandardWebsocketFlow(
-        url: String,
-        deserializer: DeserializationStrategy<T>,
-        requestBuilder: HttpRequestBuilder.() -> Unit = {},
-    ) = createStandardWebsocketFlow(url, { true }, deserializer, requestBuilder)
-}
-
-@Deprecated("This property will be removed soon. It is now recommended to use built-in ktor features instead")
-val defaultRequester = UnifiedRequester()
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <ResultType> HttpClient.uniget(
-    url: String,
-    resultDeserializer: DeserializationStrategy<ResultType>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
-) = get(url).let {
-    serialFormat.decodeDefault(resultDeserializer, it.body<StandardKtorSerialInputData>())
-}
-
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-fun <T> SerializationStrategy<T>.encodeUrlQueryValue(
-    value: T,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
-) = serialFormat.encodeHex(
-    this,
-    value
-)
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <BodyType, ResultType> HttpClient.unipost(
-    url: String,
-    bodyInfo: Pair<SerializationStrategy<BodyType>, BodyType>,
-    resultDeserializer: DeserializationStrategy<ResultType>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
-) = post(url) {
-    setBody(
-        serialFormat.encodeDefault(bodyInfo.first, bodyInfo.second)
-    )
-}.let {
-    serialFormat.decodeDefault(resultDeserializer, it.body<StandardKtorSerialInputData>())
-}
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <ResultType> HttpClient.unimultipart(
-    url: String,
-    filename: String,
-    inputProvider: InputProvider,
-    resultDeserializer: DeserializationStrategy<ResultType>,
-    mimetype: String = "*/*",
-    additionalParametersBuilder: FormBuilder.() -> Unit = {},
-    dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
-    requestBuilder: HttpRequestBuilder.() -> Unit = {},
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
-): ResultType = submitFormWithBinaryData(
-    url,
-    formData = formData {
-        append(
-            "bytes",
-            inputProvider,
-            Headers.build {
-                append(HttpHeaders.ContentType, mimetype)
-                append(HttpHeaders.ContentDisposition, "filename=\"$filename\"")
-                dataHeadersBuilder()
-            }
-        )
-        additionalParametersBuilder()
-    }
-) {
-    requestBuilder()
-}.let { serialFormat.decodeDefault(resultDeserializer, it.body<StandardKtorSerialInputData>()) }
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <BodyType, ResultType> HttpClient.unimultipart(
-    url: String,
-    filename: String,
-    otherData: Pair<SerializationStrategy<BodyType>, BodyType>,
-    inputProvider: InputProvider,
-    resultDeserializer: DeserializationStrategy<ResultType>,
-    mimetype: String = "*/*",
-    additionalParametersBuilder: FormBuilder.() -> Unit = {},
-    dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
-    requestBuilder: HttpRequestBuilder.() -> Unit = {},
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
-): ResultType = unimultipart(
-    url,
-    filename,
-    inputProvider,
-    resultDeserializer,
-    mimetype,
-    additionalParametersBuilder = {
-        val serialized = serialFormat.encodeDefault(otherData.first, otherData.second)
-        append(
-            "data",
-            InputProvider(serialized.size.toLong()) {
-                ByteReadPacket(serialized)
-            },
-            Headers.build {
-                append(HttpHeaders.ContentType, ContentType.Application.Cbor.contentType)
-                append(HttpHeaders.ContentDisposition, "filename=data.bytes")
-                dataHeadersBuilder()
-            }
-        )
-        additionalParametersBuilder()
-    },
-    dataHeadersBuilder,
-    requestBuilder,
-    serialFormat
-)
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <ResultType> HttpClient.unimultipart(
-    url: String,
-    mppFile: MPPFile,
-    resultDeserializer: DeserializationStrategy<ResultType>,
-    mimetype: String = "*/*",
-    additionalParametersBuilder: FormBuilder.() -> Unit = {},
-    dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
-    requestBuilder: HttpRequestBuilder.() -> Unit = {},
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
-): ResultType = unimultipart(
-    url,
-    mppFile.filename.string,
-    mppFile.inputProvider(),
-    resultDeserializer,
-    mimetype,
-    additionalParametersBuilder,
-    dataHeadersBuilder,
-    requestBuilder,
-    serialFormat
-)
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <BodyType, ResultType> HttpClient.unimultipart(
-    url: String,
-    mppFile: MPPFile,
-    otherData: Pair<SerializationStrategy<BodyType>, BodyType>,
-    resultDeserializer: DeserializationStrategy<ResultType>,
-    mimetype: String = "*/*",
-    additionalParametersBuilder: FormBuilder.() -> Unit = {},
-    dataHeadersBuilder: HeadersBuilder.() -> Unit = {},
-    requestBuilder: HttpRequestBuilder.() -> Unit = {},
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
-): ResultType = unimultipart(
-    url,
-    mppFile,
-    resultDeserializer,
-    mimetype,
-    additionalParametersBuilder = {
-        val serialized = serialFormat.encodeDefault(otherData.first, otherData.second)
-        append(
-            "data",
-            InputProvider(serialized.size.toLong()) {
-                ByteReadPacket(serialized)
-            },
-            Headers.build {
-                append(HttpHeaders.ContentType, ContentType.Application.Cbor.contentType)
-                append(HttpHeaders.ContentDisposition, "filename=data.bytes")
-                dataHeadersBuilder()
-            }
-        )
-        additionalParametersBuilder()
-    },
-    dataHeadersBuilder,
-    requestBuilder,
-    serialFormat
-)

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

@@ -9,11 +9,3 @@ expect suspend fun HttpClient.tempUpload(
     file: MPPFile,
     onUpload: (uploaded: Long, count: Long) -> Unit = { _, _ -> }
 ): TemporalFileId
-
-suspend fun UnifiedRequester.tempUpload(
-    fullTempUploadDraftPath: String,
-    file: MPPFile,
-    onUpload: (uploaded: Long, count: Long) -> Unit = { _, _ -> }
-): TemporalFileId = client.tempUpload(
-    fullTempUploadDraftPath, file, onUpload
-)

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

@@ -1,61 +0,0 @@
-package dev.inmo.micro_utils.ktor.server
-
-import dev.inmo.micro_utils.coroutines.safely
-import dev.inmo.micro_utils.ktor.common.*
-import io.ktor.http.URLProtocol
-import io.ktor.server.application.install
-import io.ktor.server.application.pluginOrNull
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.application
-import io.ktor.server.websocket.*
-import io.ktor.websocket.send
-import kotlinx.coroutines.flow.Flow
-import kotlinx.serialization.SerializationStrategy
-
-@Deprecated("This method will be removed soon")
-fun <T> Route.includeWebsocketHandling(
-    suburl: String,
-    flow: Flow<T>,
-    protocol: URLProtocol? = null,
-    converter: suspend WebSocketServerSession.(T) -> StandardKtorSerialInputData?
-) {
-    application.apply {
-        pluginOrNull(WebSockets) ?: install(WebSockets)
-    }
-    webSocket(suburl, protocol ?.name) {
-        safely {
-            flow.collect {
-                converter(it) ?.let { data ->
-                    send(data)
-                }
-            }
-        }
-    }
-}
-
-@Deprecated("This method will be removed soon")
-fun <T> Route.includeWebsocketHandling(
-    suburl: String,
-    flow: Flow<T>,
-    serializer: SerializationStrategy<T>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
-    protocol: URLProtocol? = null,
-    filter: (suspend WebSocketServerSession.(T) -> Boolean)? = null
-) = includeWebsocketHandling(
-    suburl,
-    flow,
-    protocol,
-    converter = if (filter == null) {
-        {
-            serialFormat.encodeDefault(serializer, it)
-        }
-    } else {
-        {
-            if (filter(it)) {
-                serialFormat.encodeDefault(serializer, it)
-            } else {
-                null
-            }
-        }
-    }
-)

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

@@ -19,106 +19,6 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.SerializationStrategy
 
-@Deprecated("This class method will be removed soon. It is now recommended to use built-in ktor features instead")
-class UnifiedRouter(
-    val serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
-    val serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) {
-    fun <T> Route.includeWebsocketHandling(
-        suburl: String,
-        flow: Flow<T>,
-        serializer: SerializationStrategy<T>,
-        protocol: URLProtocol? = null,
-        filter: (suspend WebSocketServerSession.(T) -> Boolean)? = null
-    ) = includeWebsocketHandling(suburl, flow, serializer, serialFormat, protocol, filter)
-
-    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")
-        }
-    }
-
-    companion object {
-        val default
-            get() = defaultUnifiedRouter
-    }
-}
-
-val defaultUnifiedRouter = UnifiedRouter()
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <T> ApplicationCall.unianswer(
-    answerSerializer: SerializationStrategy<T>,
-    answer: T
-) {
-    respondBytes (
-        standardKtorSerialFormat.encodeDefault(answerSerializer, answer),
-        standardKtorSerialFormatContentType
-    )
-}
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <T> ApplicationCall.uniload(
-    deserializer: DeserializationStrategy<T>
-) = safely {
-    standardKtorSerialFormat.decodeDefault(
-        deserializer,
-        receive()
-    )
-}
-
 suspend fun ApplicationCall.uniloadMultipart(
     onFormItem: (PartData.FormItem) -> Unit = {},
     onCustomFileItem: (PartData.FileItem) -> Unit = {},
@@ -146,82 +46,6 @@ suspend fun ApplicationCall.uniloadMultipart(
     resultInput ?: error("Bytes has not been received")
 }
 
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <T> ApplicationCall.uniloadMultipart(
-    deserializer: DeserializationStrategy<T>,
-    onFormItem: (PartData.FormItem) -> Unit = {},
-    onCustomFileItem: (PartData.FileItem) -> Unit = {},
-    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
-    onBinaryContent: (PartData.BinaryItem) -> Unit = {}
-): Pair<Input, T> {
-    var data: Optional<T>? = null
-    val resultInput = uniloadMultipart(
-        onFormItem,
-        {
-            if (it.name == "data") {
-                data = standardKtorSerialFormat.decodeDefault(deserializer, it.provider().readBytes()).optional
-            } else {
-                onCustomFileItem(it)
-            }
-        },
-        onBinaryChannelItem,
-        onBinaryContent
-    )
-
-    val completeData = data ?: error("Data has not been received")
-    return resultInput to (completeData.dataOrNull().let { it as T })
-}
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <T> ApplicationCall.uniloadMultipartFile(
-    deserializer: DeserializationStrategy<T>,
-    onFormItem: (PartData.FormItem) -> Unit = {},
-    onCustomFileItem: (PartData.FileItem) -> Unit = {},
-    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
-    onBinaryContent: (PartData.BinaryItem) -> Unit = {},
-) = safely {
-    val multipartData = receiveMultipart()
-
-    var resultInput: MPPFile? = null
-    var data: Optional<T>? = null
-
-    multipartData.forEachPart {
-        when (it) {
-            is PartData.FormItem -> onFormItem(it)
-            is PartData.FileItem -> {
-                when (it.name) {
-                    "bytes" -> {
-                        val name = FileName(it.originalFileName ?: error("File name is unknown for default part"))
-                        resultInput = MPPFile.createTempFile(
-                            name.nameWithoutExtension.let {
-                                var resultName = it
-                                while (resultName.length < 3) {
-                                    resultName += "_"
-                                }
-                                resultName
-                            },
-                            ".${name.extension}"
-                        ).apply {
-                            outputStream().use { fileStream ->
-                                it.streamProvider().use {
-                                    it.copyTo(fileStream)
-                                }
-                            }
-                        }
-                    }
-                    "data" -> data = standardKtorSerialFormat.decodeDefault(deserializer, it.provider().readBytes()).optional
-                    else -> onCustomFileItem(it)
-                }
-            }
-            is PartData.BinaryItem -> onBinaryContent(it)
-            is PartData.BinaryChannelItem -> onBinaryChannelItem(it)
-        }
-    }
-
-    val completeData = data ?: error("Data has not been received")
-    (resultInput ?: error("Bytes has not been received")) to (completeData.dataOrNull().let { it as T })
-}
-
 suspend fun ApplicationCall.uniloadMultipartFile(
     onFormItem: (PartData.FormItem) -> Unit = {},
     onCustomFileItem: (PartData.FileItem) -> Unit = {},
@@ -285,24 +109,3 @@ suspend fun ApplicationCall.getQueryParameterOrSendError(
         respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
     }
 }
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-fun <T> ApplicationCall.decodeUrlQueryValue(
-    field: String,
-    deserializer: DeserializationStrategy<T>
-) = getQueryParameter(field) ?.let {
-    standardKtorSerialFormat.decodeHex(
-        deserializer,
-        it
-    )
-}
-
-@Deprecated("This method will be removed soon. It is now recommended to use built-in ktor features instead")
-suspend fun <T> ApplicationCall.decodeUrlQueryValueOrSendError(
-    field: String,
-    deserializer: DeserializationStrategy<T>
-) = decodeUrlQueryValue(field, deserializer).also {
-    if (it == null) {
-        respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
-    }
-}

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

@@ -26,7 +26,6 @@ import java.nio.file.attribute.FileTime
 
 class TemporalFilesRoutingConfigurator(
     private val subpath: String = DefaultTemporalFilesSubPath,
-    private val unifiedRouter: UnifiedRouter = UnifiedRouter.default,
     private val temporalFilesUtilizer: TemporalFilesUtilizer = TemporalFilesUtilizer
 ) : ApplicationRoutingConfigurator.Element {
     interface TemporalFilesUtilizer {
@@ -80,42 +79,40 @@ class TemporalFilesRoutingConfigurator(
 
     override fun Route.invoke() {
         post(subpath) {
-            unifiedRouter.apply {
-                val multipart = call.receiveMultipart()
+            val multipart = call.receiveMultipart()
 
-                var fileInfo: Pair<TemporalFileId, MPPFile>? = null
-                var part = multipart.readPart()
+            var fileInfo: Pair<TemporalFileId, MPPFile>? = null
+            var part = multipart.readPart()
 
-                while (part != null) {
-                    if (part is PartData.FileItem) {
-                        break
-                    }
-                    part = multipart.readPart()
+            while (part != null) {
+                if (part is PartData.FileItem) {
+                    break
                 }
-
-                part ?.let {
-                    if (it is PartData.FileItem) {
-                        val fileId = TemporalFileId(uuid4().toString())
-                        val fileName = it.originalFileName ?.let { FileName(it) } ?: return@let
-                        fileInfo = fileId to File.createTempFile(fileId.string, ".${fileName.extension}").apply {
-                            outputStream().use { outputStream ->
-                                it.streamProvider().use {
-                                    it.copyTo(outputStream)
-                                }
-                            }
-                            deleteOnExit()
-                        }
-                    }
-                }
-
-                fileInfo ?.also { (fileId, file) ->
-                    temporalFilesMutex.withLock {
-                        temporalFilesMap[fileId] = file
-                    }
-                    call.respondText(fileId.string)
-                    launchSafelyWithoutExceptions { filesFlow.emit(fileId) }
-                } ?: call.respond(HttpStatusCode.BadRequest)
+                part = multipart.readPart()
             }
+
+            part ?.let {
+                if (it is PartData.FileItem) {
+                    val fileId = TemporalFileId(uuid4().toString())
+                    val fileName = it.originalFileName ?.let { FileName(it) } ?: return@let
+                    fileInfo = fileId to File.createTempFile(fileId.string, ".${fileName.extension}").apply {
+                        outputStream().use { outputStream ->
+                            it.streamProvider().use {
+                                it.copyTo(outputStream)
+                            }
+                        }
+                        deleteOnExit()
+                    }
+                }
+            }
+
+            fileInfo ?.also { (fileId, file) ->
+                temporalFilesMutex.withLock {
+                    temporalFilesMap[fileId] = file
+                }
+                call.respondText(fileId.string)
+                launchSafelyWithoutExceptions { filesFlow.emit(fileId) }
+            } ?: call.respond(HttpStatusCode.BadRequest)
         }
     }
 

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

@@ -33,18 +33,6 @@ data class PaginationResult<T>(
         results,
         (pagesNumber * size).toLong()
     )
-    @Deprecated("Replace with The other order of incoming parameters or objectsCount parameter")
-    constructor(
-        page: Int,
-        pagesNumber: Int,
-        results: List<T>,
-        size: Int
-    ) : this(
-        page,
-        results,
-        pagesNumber,
-        size
-    )
 }
 
 fun <T> emptyPaginationResult() = PaginationResult<T>(0, 0, emptyList(), 0L)

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

@@ -0,0 +1,138 @@
+package dev.inmo.micro_utils.repos
+
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.utils.doAllWithCurrentPaging
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * Read part of [KeyValueRepo]
+ *
+ * @param Key This type will be used as key in all operations related to searches of data
+ * @param Value This type will be used as returning data in most "get" operations
+ */
+interface ReadKeyValueRepo<Key, Value> : Repo {
+    /**
+     * @return Result [Value] in case when it is presented in repo by its [k] or null otherwise
+     */
+    suspend fun get(k: Key): Value?
+
+    /**
+     * This method should use sorted by [Key]s search and take the [PaginationResult]. By default, it should use
+     * ascending sort for [Key]s
+     */
+    suspend fun values(pagination: Pagination, reversed: Boolean = false): PaginationResult<Value>
+
+    /**
+     * This method should use sorted by [Key]s search and take the [PaginationResult]. By default, it should use
+     * ascending sort for [Key]s
+     */
+    suspend fun keys(pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
+
+    /**
+     * This method should use sorted by [Key]s search and take the [PaginationResult]. By default, it should use
+     * ascending sort for [Key]s
+     *
+     * @param v This value should be used to exclude from search the items with different [Value]s
+     */
+    suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
+
+    /**
+     * @return true if [key] is presented in current collection or false otherwise
+     */
+    suspend fun contains(key: Key): Boolean
+
+    /**
+     * @return count of all collection objects
+     */
+    suspend fun count(): Long
+}
+typealias ReadStandardKeyValueRepo<Key,Value> = ReadKeyValueRepo<Key, Value>
+
+/**
+ * Write part of [KeyValueRepo]
+ *
+ * @param Key This type will be used as key in all operations related to changes of data
+ * @param Value This type will be used as incoming data in most operations
+ */
+interface WriteKeyValueRepo<Key, Value> : Repo {
+    /**
+     * This flow must emit data each time when data by [Key] has been changed with [set] method or in any other way
+     * excluding cases of data removing
+     *
+     * @see onValueRemoved
+     */
+    val onNewValue: Flow<Pair<Key, Value>>
+
+    /**
+     * This flow must emit data each time when data by [Key] has been removed with [unset]/[unsetWithValues] methods or
+     * in any other way
+     *
+     * @see onNewValue
+     */
+    val onValueRemoved: Flow<Key>
+
+    /**
+     * Will set as batch [toSet] data in current repo. Must pass the data which were successfully updated in repo to
+     * [onNewValue]
+     */
+    suspend fun set(toSet: Map<Key, Value>)
+    /**
+     * Will unset as batch data with keys from [toUnset]. Must pass the [Key]s which were successfully removed in repo to
+     * [onValueRemoved]
+     */
+    suspend fun unset(toUnset: List<Key>)
+    /**
+     * Will unset as batch data with values from [toUnset]. Must pass the [Key]s which were successfully removed in repo
+     * to [onValueRemoved]
+     */
+    suspend fun unsetWithValues(toUnset: List<Value>)
+}
+typealias WriteStandardKeyValueRepo<Key,Value> = WriteKeyValueRepo<Key, Value>
+
+suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(
+    vararg toSet: Pair<Key, Value>
+) = set(toSet.toMap())
+
+suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(
+    k: Key, v: Value
+) = set(k to v)
+
+suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.unset(
+    vararg k: Key
+) = unset(k.toList())
+
+suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.unsetWithValues(
+    vararg v: Value
+) = unsetWithValues(v.toList())
+
+/**
+ * Full version of standard key-value repository with all set/unset/clear/get methods
+ */
+interface KeyValueRepo<Key, Value> : ReadKeyValueRepo<Key, Value>, WriteKeyValueRepo<Key, Value> {
+    /**
+     * By default, will walk throw all the [keys] with [Value]s from [toUnset] and run [doAllWithCurrentPaging] with
+     * [unset] of found data [Key]s
+     */
+    override suspend fun unsetWithValues(toUnset: List<Value>) = toUnset.forEach { v ->
+        doAllWithCurrentPaging {
+            keys(v, it).also {
+                unset(it.results)
+            }
+        }
+    }
+
+    /**
+     * By default, will remove all the data of current repo using [doAllWithCurrentPaging], [keys] and [unset]
+     */
+    suspend fun clear() {
+        doAllWithCurrentPaging { keys(it).also { unset(it.results) } }
+    }
+}
+typealias StandardKeyValueRepo<Key,Value> = KeyValueRepo<Key, Value>
+
+class DelegateBasedKeyValueRepo<Key, Value>(
+    readDelegate: ReadKeyValueRepo<Key, Value>,
+    writeDelegate: WriteKeyValueRepo<Key, Value>
+) : KeyValueRepo<Key, Value>,
+    ReadKeyValueRepo<Key, Value> by readDelegate,
+    WriteKeyValueRepo<Key, Value> by writeDelegate

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

@@ -1,63 +0,0 @@
-package dev.inmo.micro_utils.repos
-
-import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.pagination.utils.doAllWithCurrentPaging
-import kotlinx.coroutines.flow.Flow
-
-interface ReadKeyValueRepo<Key, Value> : Repo {
-    suspend fun get(k: Key): Value?
-    suspend fun values(pagination: Pagination, reversed: Boolean = false): PaginationResult<Value>
-    suspend fun keys(pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
-    suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
-    suspend fun contains(key: Key): Boolean
-    suspend fun count(): Long
-}
-typealias ReadStandardKeyValueRepo<Key,Value> = ReadKeyValueRepo<Key, Value>
-
-interface WriteKeyValueRepo<Key, Value> : Repo {
-    val onNewValue: Flow<Pair<Key, Value>>
-    val onValueRemoved: Flow<Key>
-
-    suspend fun set(toSet: Map<Key, Value>)
-    suspend fun unset(toUnset: List<Key>)
-    suspend fun unsetWithValues(toUnset: List<Value>)
-}
-typealias WriteStandardKeyValueRepo<Key,Value> = WriteKeyValueRepo<Key, Value>
-
-suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(
-    vararg toSet: Pair<Key, Value>
-) = set(toSet.toMap())
-
-suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(
-    k: Key, v: Value
-) = set(k to v)
-
-suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.unset(
-    vararg k: Key
-) = unset(k.toList())
-
-suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.unsetWithValues(
-    vararg v: Value
-) = unsetWithValues(v.toList())
-
-interface KeyValueRepo<Key, Value> : ReadKeyValueRepo<Key, Value>, WriteKeyValueRepo<Key, Value> {
-    override suspend fun unsetWithValues(toUnset: List<Value>) = toUnset.forEach { v ->
-        doAllWithCurrentPaging {
-            keys(v, it).also {
-                unset(it.results)
-            }
-        }
-    }
-
-    suspend fun clear() {
-        doAllWithCurrentPaging { keys(it).also { unset(it.results) } }
-    }
-}
-typealias StandardKeyValueRepo<Key,Value> = KeyValueRepo<Key, Value>
-
-class DelegateBasedKeyValueRepo<Key, Value>(
-    readDelegate: ReadKeyValueRepo<Key, Value>,
-    writeDelegate: WriteKeyValueRepo<Key, Value>
-) : KeyValueRepo<Key, Value>,
-    ReadKeyValueRepo<Key, Value> by readDelegate,
-    WriteKeyValueRepo<Key, Value> by writeDelegate

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/AbstractExposedWriteCRUDRepo.kt

@@ -4,9 +4,9 @@ import dev.inmo.micro_utils.repos.UpdatedValuePair
 import dev.inmo.micro_utils.repos.WriteCRUDRepo
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.statements.InsertStatement
-import org.jetbrains.exposed.sql.statements.UpdateStatement
+import org.jetbrains.exposed.sql.statements.*
 import org.jetbrains.exposed.sql.transactions.transaction
+import java.util.Objects
 
 abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
     flowsChannelsSize: Int = 0,
@@ -27,10 +27,39 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
 
     protected abstract fun InsertStatement<Number>.asObject(value: InputValueType): ObjectType
 
-    protected abstract fun insert(value: InputValueType, it: InsertStatement<Number>)
-    protected abstract fun update(id: IdType, value: InputValueType, it: UpdateStatement)
+    /**
+     * @param id Can be null only if [createAndInsertId] have returned null (it can be useful when you have
+     * autoincrement identifier)
+     * @param it Will be [UpdateStatement] when it is called from [update] method or [InsertStatement] from the [create]
+     * one. Anyway, it is main method where you should put the logic of table filling by [value] data
+     *
+     * @see createAndInsertId
+     */
+    protected abstract fun update(id: IdType?, value: InputValueType, it: UpdateBuilder<Int>)
+
+    /**
+     * Override this method to interact with [it] ([InsertStatement]) and put there new id with [IdType].
+     *
+     * By default, have null value due to the fact that in the most cases users have [autoIncrement]ing id columns
+     *
+     * @return In case when id for the model has been created new [IdType] should be returned
+     */
+    protected open fun createAndInsertId(value: InputValueType, it: InsertStatement<Number>): IdType? = null
+
+    protected open fun insert(value: InputValueType, it: InsertStatement<Number>) {
+        val id = createAndInsertId(value, it)
+        update(id, value, it as UpdateBuilder<Int>)
+    }
 
     protected open suspend fun onBeforeCreate(value: List<InputValueType>) {}
+
+    /**
+     * Use this method to do the something with [values]. You may change and output values in that list and return
+     * changed list of pairs
+     */
+    protected open suspend fun onAfterCreate(
+        values: List<Pair<InputValueType, ObjectType>>
+    ): List<ObjectType> = values.map { it.second }
     private fun createWithoutNotification(value: InputValueType): ObjectType {
         return transaction(database) {
             insert { insert(value, it) }.asObject(value)
@@ -40,13 +69,18 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
     override suspend fun create(values: List<InputValueType>): List<ObjectType> {
         onBeforeCreate(values)
         return transaction(db = database) {
-            values.map { value -> createWithoutNotification(value) }
+            values.map { value -> value to createWithoutNotification(value) }
+        }.let {
+            onAfterCreate(it)
         }.onEach {
             _newObjectsFlow.emit(it)
         }
     }
 
     protected open suspend fun onBeforeUpdate(value: List<UpdatedValuePair<IdType, InputValueType>>) {}
+    protected open suspend fun onAfterUpdate(
+        value: List<UpdatedValuePair<InputValueType, ObjectType>>
+    ): List<ObjectType> = value.map { it.second }
     private fun updateWithoutNotification(id: IdType, value: InputValueType): ObjectType? {
         return transaction(db = database) {
             update(
@@ -54,7 +88,7 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
                     selectById(this, id)
                 }
             ) {
-                update(id, value, it)
+                update(id, value, it as UpdateBuilder<Int>)
             }
         }.let {
             if (it > 0) {
@@ -71,7 +105,9 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
 
     override suspend fun update(id: IdType, value: InputValueType): ObjectType? {
         onBeforeUpdate(listOf(id to value))
-        return updateWithoutNotification(id, value).also {
+        return updateWithoutNotification(id, value).let {
+            onAfterUpdate(listOf(value to (it ?: return@let emptyList())))
+        }.firstOrNull().also {
             if (it != null) {
                 _updatedObjectsFlow.emit(it)
             }
@@ -81,9 +117,11 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
         onBeforeUpdate(values)
         return (
             transaction(db = database) {
-                values.map { (id, value) -> updateWithoutNotification(id, value) }
-            }.filterNotNull()
-        ).onEach {
+                values.mapNotNull { (id, value) -> value to (updateWithoutNotification(id, value) ?: return@mapNotNull null) }
+            }
+        ).let {
+            onAfterUpdate(it)
+        }.onEach {
             _updatedObjectsFlow.emit(it)
         }
     }
@@ -91,9 +129,7 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
     override suspend fun deleteById(ids: List<IdType>) {
         onBeforeDelete(ids)
         transaction(db = database) {
-            val deleted = deleteWhere(null, null) {
-                selectByIds(ids)
-            }
+            val deleted = deleteWhere(null, null) { selectByIds(it, ids) }
             if (deleted == ids.size) {
                 ids
             } else {

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/CommonExposedRepo.kt

@@ -4,8 +4,8 @@ import org.jetbrains.exposed.sql.*
 
 interface CommonExposedRepo<IdType, ObjectType> : ExposedRepo {
     val ResultRow.asObject: ObjectType
-    val selectById: SqlExpressionBuilder.(IdType) -> Op<Boolean>
-    val selectByIds: SqlExpressionBuilder.(List<IdType>) -> Op<Boolean>
+    val selectById: ISqlExpressionBuilder.(IdType) -> Op<Boolean>
+    val selectByIds: ISqlExpressionBuilder.(List<IdType>) -> Op<Boolean>
         get() = { list ->
             if (list.isEmpty()) {
                 Op.FALSE

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/AbstractExposedKeyValueRepo.kt

@@ -3,8 +3,7 @@ package dev.inmo.micro_utils.repos.exposed.keyvalue
 import dev.inmo.micro_utils.repos.KeyValueRepo
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.statements.InsertStatement
-import org.jetbrains.exposed.sql.statements.UpdateStatement
+import org.jetbrains.exposed.sql.statements.*
 import org.jetbrains.exposed.sql.transactions.transaction
 
 abstract class AbstractExposedKeyValueRepo<Key, Value>(
@@ -20,13 +19,18 @@ abstract class AbstractExposedKeyValueRepo<Key, Value>(
     override val onNewValue: Flow<Pair<Key, Value>> = _onNewValue.asSharedFlow()
     override val onValueRemoved: Flow<Key> = _onValueRemoved.asSharedFlow()
 
-    protected abstract fun update(k: Key, v: Value, it: UpdateStatement)
-    protected abstract fun insert(k: Key, v: Value, it: InsertStatement<Number>)
+    protected abstract fun update(k: Key, v: Value, it: UpdateBuilder<Int>)
+    protected abstract fun insertKey(k: Key, v: Value, it: InsertStatement<Number>)
+
+    protected open fun insert(k: Key, v: Value, it: InsertStatement<Number>) {
+        insertKey(k, v, it)
+        update(k, v, it as UpdateBuilder<Int>)
+    }
 
     override suspend fun set(toSet: Map<Key, Value>) {
         transaction(database) {
             toSet.mapNotNull { (k, v) ->
-                if (update({ selectById(k) }) { update(k, v, it) } > 0) {
+                if (update({ selectById(k) }) { update(k, v, it as UpdateBuilder<Int>) } > 0) {
                     k to v
                 } else {
                     val inserted = insert {
@@ -46,9 +50,9 @@ abstract class AbstractExposedKeyValueRepo<Key, Value>(
 
     override suspend fun unset(toUnset: List<Key>) {
         transaction(database) {
-            toUnset.mapNotNull {
-                if (deleteWhere { selectById(it) } > 0) {
-                    it
+            toUnset.mapNotNull { item ->
+                if (deleteWhere { selectById(it, item) } > 0) {
+                    item
                 } else {
                     null
                 }
@@ -62,7 +66,7 @@ abstract class AbstractExposedKeyValueRepo<Key, Value>(
         transaction(database) {
             toUnset.flatMap {
                 val keys = select { selectByValue(it) }.mapNotNull { it.asKey }
-                deleteWhere { selectByIds(keys) }
+                deleteWhere { selectByIds(it, keys) }
                 keys
             }
         }.distinct().forEach {

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/AbstractExposedReadKeyValueRepo.kt

@@ -16,7 +16,7 @@ abstract class AbstractExposedReadKeyValueRepo<Key, Value>(
     Table(tableName ?: "") {
     abstract val keyColumn: Column<*>
     abstract val ResultRow.asKey: Key
-    abstract val selectByValue: SqlExpressionBuilder.(Value) -> Op<Boolean>
+    abstract val selectByValue: ISqlExpressionBuilder.(Value) -> Op<Boolean>
 
     override suspend fun get(k: Key): Value? = transaction(database) {
         select { selectById(k) }.limit(1).firstOrNull() ?.asObject

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/ExposedKeyValueRepo.kt

@@ -4,6 +4,8 @@ import dev.inmo.micro_utils.repos.KeyValueRepo
 import dev.inmo.micro_utils.repos.exposed.ColumnAllocator
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.inList
 import org.jetbrains.exposed.sql.transactions.transaction
 
 open class ExposedKeyValueRepo<Key, Value>(
@@ -47,9 +49,9 @@ open class ExposedKeyValueRepo<Key, Value>(
 
     override suspend fun unset(toUnset: List<Key>) {
         transaction(database) {
-            toUnset.mapNotNull {
-                if (deleteWhere { keyColumn.eq(it) } > 0) {
-                    it
+            toUnset.mapNotNull { item ->
+                if (deleteWhere { keyColumn.eq(item) } > 0) {
+                    item
                 } else {
                     null
                 }

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/ExposedReadKeyValueRepo.kt

@@ -5,57 +5,27 @@ import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 import dev.inmo.micro_utils.repos.exposed.*
 import dev.inmo.micro_utils.repos.exposed.utils.selectPaginated
 import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.statements.InsertStatement
+import org.jetbrains.exposed.sql.statements.UpdateBuilder
 import org.jetbrains.exposed.sql.transactions.transaction
 
 open class ExposedReadKeyValueRepo<Key, Value>(
-    override val database: Database,
+    database: Database,
     keyColumnAllocator: ColumnAllocator<Key>,
     valueColumnAllocator: ColumnAllocator<Value>,
     tableName: String? = null
-) : ReadKeyValueRepo<Key, Value>, ExposedRepo, Table(tableName ?: "") {
-    val keyColumn: Column<Key> = keyColumnAllocator()
+) : ReadKeyValueRepo<Key, Value>, ExposedRepo, AbstractExposedReadKeyValueRepo<Key, Value>(database, tableName) {
+
+    override val keyColumn: Column<Key> = keyColumnAllocator()
     val valueColumn: Column<Value> = valueColumnAllocator()
-    override val primaryKey: PrimaryKey = PrimaryKey(keyColumn, valueColumn)
+    override val ResultRow.asKey: Key
+        get() = get(keyColumn)
+    override val selectByValue: ISqlExpressionBuilder.(Value) -> Op<Boolean> = { valueColumn.eq(it) }
+    override val ResultRow.asObject: Value
+        get() = get(valueColumn)
+    override val selectById: ISqlExpressionBuilder.(Key) -> Op<Boolean> = { keyColumn.eq(it) }
+    override val primaryKey: Table.PrimaryKey
+        get() = PrimaryKey(keyColumn, valueColumn)
 
     init { initTable() }
-
-    override suspend fun get(k: Key): Value? = transaction(database) {
-        select { keyColumn.eq(k) }.limit(1).firstOrNull() ?.getOrNull(valueColumn)
-    }
-
-    override suspend fun contains(key: Key): Boolean = transaction(database) {
-        select { keyColumn.eq(key) }.limit(1).any()
-    }
-
-    override suspend fun count(): Long = transaction(database) { selectAll().count() }
-
-    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = transaction(database) {
-        selectAll().selectPaginated(
-            pagination,
-            keyColumn,
-            reversed
-        ) {
-            it[keyColumn]
-        }
-    }
-
-    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = transaction(database) {
-        select { valueColumn.eq(v) }.selectPaginated(
-            pagination,
-            keyColumn,
-            reversed
-        ) {
-            it[keyColumn]
-        }
-    }
-
-    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = transaction(database) {
-        selectAll().selectPaginated(
-            pagination,
-            keyColumn,
-            reversed
-        ) {
-            it[valueColumn]
-        }
-    }
 }

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/AbstractExposedKeyValueRepo.kt

@@ -49,7 +49,7 @@ abstract class AbstractExposedKeyValuesRepo<Key, Value>(
         transaction(database) {
             toRemove.keys.flatMap { k ->
                 toRemove[k] ?.mapNotNull { v ->
-                    if (deleteWhere { selectById(k).and(selectByValue(v)) } > 0 ) {
+                    if (deleteWhere { selectById(it, k).and(SqlExpressionBuilder.selectByValue(v)) } > 0 ) {
                         k to v
                     } else {
                         null
@@ -63,7 +63,7 @@ abstract class AbstractExposedKeyValuesRepo<Key, Value>(
 
     override suspend fun clear(k: Key) {
         transaction(database) {
-            deleteWhere { selectById(k) }
+            deleteWhere { selectById(it, k) }
         }.also { _onDataCleared.emit(k) }
     }
 }

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/AbstractExposedReadKeyValueRepo.kt

@@ -17,7 +17,7 @@ abstract class AbstractExposedReadKeyValuesRepo<Key, Value>(
     Table(tableName ?: "") {
     abstract val keyColumn: Column<*>
     abstract val ResultRow.asKey: Key
-    abstract val selectByValue: SqlExpressionBuilder.(Value) -> Op<Boolean>
+    abstract val selectByValue: ISqlExpressionBuilder.(Value) -> Op<Boolean>
 
     override suspend fun count(k: Key): Long = transaction(database) { select { selectById(k) }.count() }
 

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/ExposedKeyValuesRepo.kt

@@ -4,6 +4,7 @@ import dev.inmo.micro_utils.repos.KeyValuesRepo
 import dev.inmo.micro_utils.repos.exposed.ColumnAllocator
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.transactions.transaction
 
 typealias ExposedOneToManyKeyValueRepo1<Key, Value> = ExposedKeyValuesRepo<Key, Value>

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/ExposedReadKeyValuesRepo.kt

@@ -1,10 +1,8 @@
 package dev.inmo.micro_utils.repos.exposed.onetomany
 
-import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
 import dev.inmo.micro_utils.repos.exposed.*
 import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.transactions.transaction
 
 typealias ExposedReadOneToManyKeyValueRepo<Key, Value> = ExposedReadKeyValuesRepo<Key, Value>
 
@@ -13,54 +11,15 @@ open class ExposedReadKeyValuesRepo<Key, Value>(
     keyColumnAllocator: ColumnAllocator<Key>,
     valueColumnAllocator: ColumnAllocator<Value>,
     tableName: String? = null
-) : ReadKeyValuesRepo<Key, Value>, ExposedRepo, Table(tableName ?: "") {
-    val keyColumn: Column<Key> = keyColumnAllocator()
+) : ReadKeyValuesRepo<Key, Value>, ExposedRepo, AbstractExposedReadKeyValuesRepo<Key, Value>(database, tableName) {
+    override val keyColumn: Column<Key> = keyColumnAllocator()
+    override val ResultRow.asKey: Key
+        get() = get(keyColumn)
+    override val selectByValue: ISqlExpressionBuilder.(Value) -> Op<Boolean> = { valueColumn.eq(it) }
+    override val ResultRow.asObject: Value
+        get() = get(valueColumn)
+    override val selectById: ISqlExpressionBuilder.(Key) -> Op<Boolean> = { keyColumn.eq(it) }
     val valueColumn: Column<Value> = valueColumnAllocator()
 
     init { initTable() }
-
-    override suspend fun count(k: Key): Long = transaction(database) { select { keyColumn.eq(k) }.count() }
-
-    override suspend fun count(): Long = transaction(database) { selectAll().count() }
-
-    override suspend fun get(
-        k: Key,
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<Value> = transaction(database) {
-        select { keyColumn.eq(k) }.paginate(pagination, keyColumn, reversed).map { it[valueColumn] }
-    }.createPaginationResult(
-        pagination,
-        count(k)
-    )
-
-    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = transaction(database) {
-        selectAll().paginate(pagination, keyColumn, reversed).map { it[keyColumn] }
-    }.createPaginationResult(
-        pagination,
-        count()
-    )
-
-    override suspend fun keys(
-        v: Value,
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<Key> = transaction(database) {
-        select { valueColumn.eq(v) }.let {
-            it.count() to it.paginate(pagination, keyColumn, reversed).map { it[keyColumn] }
-        }
-    }.let { (count, list) ->
-        list.createPaginationResult(
-            pagination,
-            count
-        )
-    }
-
-    override suspend fun contains(k: Key): Boolean = transaction(database) {
-        select { keyColumn.eq(k) }.limit(1).any()
-    }
-
-    override suspend fun contains(k: Key, v: Value): Boolean = transaction(database) {
-        select { keyColumn.eq(k).and(valueColumn.eq(v)) }.limit(1).any()
-    }
 }

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

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

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

@@ -1,39 +0,0 @@
-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.CRUDRepo
-import io.ktor.http.ContentType
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.route
-import kotlinx.serialization.KSerializer
-
-fun <ObjectType, IdType, InputValue> Route.configureCRUDRepoRoutes(
-    baseSubpart: String,
-    originalRepo: CRUDRepo<ObjectType, IdType, InputValue>,
-    objectsSerializer: KSerializer<ObjectType>,
-    objectsNullableSerializer: KSerializer<ObjectType?>,
-    inputsSerializer: KSerializer<InputValue>,
-    idsSerializer: KSerializer<IdType>,
-    unifiedRouter: UnifiedRouter
-) {
-    route(baseSubpart) {
-        configureReadCRUDRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer, unifiedRouter)
-        configureWriteCRUDRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, unifiedRouter)
-    }
-}
-
-fun <ObjectType, IdType, InputValue> Route.configureCRUDRepoRoutes(
-    baseSubpart: String,
-    originalRepo: CRUDRepo<ObjectType, IdType, InputValue>,
-    objectsSerializer: KSerializer<ObjectType>,
-    objectsNullableSerializer: KSerializer<ObjectType?>,
-    inputsSerializer: KSerializer<InputValue>,
-    idsSerializer: KSerializer<IdType>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
-    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) = configureCRUDRepoRoutes(
-    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,107 +0,0 @@
-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.WriteCRUDRepo
-import dev.inmo.micro_utils.repos.ktor.common.crud.*
-import io.ktor.http.ContentType
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.post
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.*
-
-fun <ObjectType, IdType, InputValue> Route.configureWriteCRUDRepoRoutes(
-    originalRepo: WriteCRUDRepo<ObjectType, IdType, InputValue>,
-    objectsSerializer: KSerializer<ObjectType>,
-    objectsNullableSerializer: KSerializer<ObjectType?>,
-    inputsSerializer: KSerializer<InputValue>,
-    idsSerializer: KSerializer<IdType>,
-    unifiedRouter: UnifiedRouter
-) {
-    val listObjectsSerializer = ListSerializer(objectsSerializer)
-    val listInputSerializer = ListSerializer(inputsSerializer)
-    val listIdsSerializer = ListSerializer(idsSerializer)
-    val inputUpdateSerializer = PairSerializer(
-        idsSerializer,
-        inputsSerializer
-    )
-    val listInputUpdateSerializer = ListSerializer(inputUpdateSerializer)
-
-    unifiedRouter.apply {
-        includeWebsocketHandling(
-            newObjectsFlowRouting,
-            originalRepo.newObjectsFlow,
-            objectsSerializer
-        )
-        includeWebsocketHandling(
-            updatedObjectsFlowRouting,
-            originalRepo.updatedObjectsFlow,
-            objectsSerializer
-        )
-        includeWebsocketHandling(
-            deletedObjectsIdsFlowRouting,
-            originalRepo.deletedObjectsIdsFlow,
-            idsSerializer
-        )
-    }
-
-    post(createRouting) {
-        unifiedRouter.apply {
-            unianswer(
-                listObjectsSerializer,
-                originalRepo.create(
-                    uniload(listInputSerializer)
-                )
-            )
-        }
-    }
-
-    post(updateRouting) {
-        unifiedRouter.apply {
-            val (id, input) = uniload(inputUpdateSerializer)
-            unianswer(
-                objectsNullableSerializer,
-                originalRepo.update(
-                    id, input
-                )
-            )
-        }
-    }
-
-    post(updateManyRouting) {
-        unifiedRouter.apply {
-            val updates = uniload(listInputUpdateSerializer)
-            unianswer(
-                listObjectsSerializer,
-                originalRepo.update(
-                    updates
-                )
-            )
-        }
-    }
-
-    post(deleteByIdRouting) {
-        unifiedRouter.apply {
-            val ids = uniload(listIdsSerializer)
-            unianswer(
-                Unit.serializer(),
-                originalRepo.deleteById(
-                    ids
-                )
-            )
-        }
-    }
-}
-
-fun <ObjectType, IdType, InputValue> Route.configureWriteCRUDRepoRoutes(
-    originalRepo: WriteCRUDRepo<ObjectType, IdType, InputValue>,
-    objectsSerializer: KSerializer<ObjectType>,
-    objectsNullableSerializer: KSerializer<ObjectType?>,
-    inputsSerializer: KSerializer<InputValue>,
-    idsSerializer: KSerializer<IdType>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
-    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) = configureWriteCRUDRepoRoutes(
-    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,46 +0,0 @@
-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.KeyValueRepo
-import io.ktor.http.ContentType
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.route
-import kotlinx.serialization.KSerializer
-
-fun <K, V> Route.configureKeyValueRepoRoutes(
-    baseSubpart: String,
-    originalRepo: KeyValueRepo<K, V>,
-    keySerializer: KSerializer<K>,
-    valueSerializer: KSerializer<V>,
-    valueNullableSerializer: KSerializer<V?>,
-    unifiedRouter: UnifiedRouter
-) {
-    route(baseSubpart) {
-        configureReadStandartKeyValueRepoRoutes(
-            originalRepo,
-            keySerializer,
-            valueSerializer,
-            valueNullableSerializer,
-            unifiedRouter
-        )
-        configureWriteKeyValueRepoRoutes(
-            originalRepo,
-            keySerializer,
-            valueSerializer,
-            unifiedRouter
-        )
-    }
-}
-
-fun <K, V> Route.configureStandartKeyValueRepoRoutes(
-    baseSubpart: String,
-    originalRepo: KeyValueRepo<K, V>,
-    keySerializer: KSerializer<K>,
-    valueSerializer: KSerializer<V>,
-    valueNullableSerializer: KSerializer<V?>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
-    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) = configureKeyValueRepoRoutes(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,107 +0,0 @@
-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
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-import dev.inmo.micro_utils.repos.ktor.common.*
-import dev.inmo.micro_utils.repos.ktor.common.containsRoute
-import dev.inmo.micro_utils.repos.ktor.common.countRoute
-import dev.inmo.micro_utils.repos.ktor.common.key_value.*
-import dev.inmo.micro_utils.repos.ktor.common.key_value.keyParameterName
-import dev.inmo.micro_utils.repos.ktor.common.key_value.reversedParameterName
-import io.ktor.http.ContentType
-import io.ktor.server.application.call
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.get
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.serializer
-
-fun <K, V> Route.configureReadStandartKeyValueRepoRoutes (
-    originalRepo: ReadKeyValueRepo<K, V>,
-    keySerializer: KSerializer<K>,
-    valueSerializer: KSerializer<V>,
-    valueNullableSerializer: KSerializer<V?>,
-    unifiedRouter: UnifiedRouter
-) {
-    get(getRoute) {
-        unifiedRouter.apply {
-            val key = decodeUrlQueryValueOrSendError(
-                keyParameterName,
-                keySerializer
-            ) ?: return@get
-
-            unianswer(
-                valueNullableSerializer,
-                originalRepo.get(key)
-            )
-        }
-    }
-
-    get(valuesRoute) {
-        unifiedRouter.apply {
-            val parination = call.request.queryParameters.extractPagination;
-            val reversed = decodeUrlQueryValueOrSendError(
-                reversedParameterName,
-                Boolean.serializer()
-            ) ?: return@get
-
-            unianswer(
-                PaginationResult.serializer(valueSerializer),
-                originalRepo.values(parination, reversed)
-            )
-        }
-    }
-
-    get(keysRoute) {
-        unifiedRouter.apply {
-            val parination = call.request.queryParameters.extractPagination;
-            val reversed = decodeUrlQueryValueOrSendError(
-                reversedParameterName,
-                Boolean.serializer()
-            ) ?: return@get
-            val value = decodeUrlQueryValue(valueParameterName, valueSerializer)
-
-            unianswer(
-                PaginationResult.serializer(keySerializer),
-                value?.let { originalRepo.keys(value, parination, reversed) } ?: originalRepo.keys(parination, reversed)
-            )
-        }
-    }
-
-    get(containsRoute) {
-        unifiedRouter.apply {
-            val key = decodeUrlQueryValueOrSendError(
-                keyParameterName,
-                keySerializer
-            ) ?: return@get
-
-            unianswer(
-                Boolean.serializer(),
-                originalRepo.contains(key)
-            )
-        }
-    }
-
-    get(countRoute) {
-        unifiedRouter.apply {
-            unianswer(
-                Long.serializer(),
-                originalRepo.count()
-            )
-        }
-    }
-}
-
-inline fun <K, V> Route.configureReadStandartKeyValueRepoRoutes (
-    originalRepo: ReadKeyValueRepo<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,70 +0,0 @@
-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.WriteKeyValueRepo
-import dev.inmo.micro_utils.repos.ktor.common.key_value.*
-import io.ktor.http.ContentType
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.post
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.*
-
-fun <K, V> Route.configureWriteKeyValueRepoRoutes (
-    originalRepo: WriteKeyValueRepo<K, V>,
-    keySerializer: KSerializer<K>,
-    valueSerializer: KSerializer<V>,
-    unifiedRouter: UnifiedRouter
-) {
-    val keyValueMapSerializer = MapSerializer(keySerializer, valueSerializer)
-    val keysListSerializer = ListSerializer(keySerializer)
-    val valuesListSerializer = ListSerializer(valueSerializer)
-    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))
-        }
-    }
-
-    post(unsetWithValuesRoute) {
-        unifiedRouter.apply {
-            val toUnset = uniload(valuesListSerializer)
-
-            unianswer(Unit.serializer(), originalRepo.unsetWithValues(toUnset))
-        }
-    }
-}
-
-fun <K, V> Route.configureWriteStandartKeyValueRepoRoutes (
-    originalRepo: WriteKeyValueRepo<K, V>,
-    keySerializer: KSerializer<K>,
-    valueSerializer: KSerializer<V>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
-    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) = configureWriteKeyValueRepoRoutes(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,35 +0,0 @@
-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.KeyValuesRepo
-import io.ktor.http.ContentType
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.route
-import kotlinx.serialization.KSerializer
-
-fun <Key, Value> Route.configureOneToManyKeyValueRepoRoutes(
-    baseSubpart: String,
-    originalRepo: KeyValuesRepo<Key, Value>,
-    keySerializer: KSerializer<Key>,
-    valueSerializer: KSerializer<Value>,
-    unifiedRouter: UnifiedRouter
-) {
-    route(baseSubpart) {
-        configureOneToManyReadKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, unifiedRouter)
-        configureOneToManyWriteKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, unifiedRouter)
-    }
-}
-
-fun <Key, Value> Route.configureOneToManyKeyValueRepoRoutes(
-    baseSubpart: String,
-    originalRepo: KeyValuesRepo<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,129 +0,0 @@
-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
-import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
-import dev.inmo.micro_utils.repos.ktor.common.keyParameterName
-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.http.ContentType
-import io.ktor.server.application.call
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.get
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.serializer
-
-fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
-    originalRepo: ReadKeyValuesRepo<Key, Value>,
-    keySerializer: KSerializer<Key>,
-    valueSerializer: KSerializer<Value>,
-    unifiedRouter: UnifiedRouter
-) {
-    val paginationKeyResult = PaginationResult.serializer(keySerializer)
-    val paginationValueResult = PaginationResult.serializer(valueSerializer)
-
-    get(getRoute) {
-        unifiedRouter.apply {
-            val pagination = call.request.queryParameters.extractPagination
-            val key = decodeUrlQueryValueOrSendError(
-                keyParameterName,
-                keySerializer
-            ) ?: return@get
-            val reversed = decodeUrlQueryValue(
-                reversedParameterName,
-                Boolean.serializer()
-            ) ?: false
-
-            unianswer(
-                paginationValueResult,
-                originalRepo.get(key, pagination, reversed)
-            )
-        }
-    }
-
-    get(keysRoute) {
-        unifiedRouter.apply {
-            val pagination = call.request.queryParameters.extractPagination
-            val reversed = decodeUrlQueryValue(
-                reversedParameterName,
-                Boolean.serializer()
-            ) ?: false
-            val value: Value? = decodeUrlQueryValue(
-                valueParameterName,
-                valueSerializer
-            )
-
-            unianswer(
-                paginationKeyResult,
-                value?.let { originalRepo.keys(value, pagination, reversed) } ?: originalRepo.keys(pagination, reversed)
-            )
-        }
-    }
-
-    get(containsByKeyRoute) {
-        unifiedRouter.apply {
-            val key = decodeUrlQueryValueOrSendError(
-                keyParameterName,
-                keySerializer
-            ) ?: return@get
-
-            unianswer(
-                Boolean.serializer(),
-                originalRepo.contains(key)
-            )
-        }
-    }
-
-    get(containsByKeyValueRoute) {
-        unifiedRouter.apply {
-            val key = decodeUrlQueryValueOrSendError(
-                keyParameterName,
-                keySerializer
-            ) ?: return@get
-            val value = decodeUrlQueryValueOrSendError(
-                valueParameterName,
-                valueSerializer
-            ) ?: return@get
-
-            unianswer(
-                Boolean.serializer(),
-                originalRepo.contains(key, value)
-            )
-        }
-    }
-
-    get(countByKeyRoute) {
-        unifiedRouter.apply {
-            val key = decodeUrlQueryValueOrSendError(
-                keyParameterName,
-                keySerializer
-            ) ?: return@get
-
-            unianswer(
-                Long.serializer(),
-                originalRepo.count(key)
-            )
-        }
-    }
-
-    get(countRoute) {
-        unifiedRouter.apply {
-            unianswer(
-                Long.serializer(),
-                originalRepo.count()
-            )
-        }
-    }
-}
-
-inline fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
-    originalRepo: ReadKeyValuesRepo<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,103 +0,0 @@
-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.WriteKeyValuesRepo
-import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
-import io.ktor.http.ContentType
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.post
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.*
-
-fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
-    originalRepo: WriteKeyValuesRepo<Key, Value>,
-    keySerializer: KSerializer<Key>,
-    valueSerializer: KSerializer<Value>,
-    unifiedRouter: UnifiedRouter
-) {
-    val keyValueSerializer = PairSerializer(keySerializer, valueSerializer)
-    val keyValueMapSerializer = MapSerializer(keySerializer, ListSerializer(valueSerializer))
-
-    unifiedRouter.apply {
-        includeWebsocketHandling(
-            onNewValueRoute,
-            originalRepo.onNewValue,
-            keyValueSerializer
-        )
-        includeWebsocketHandling(
-            onValueRemovedRoute,
-            originalRepo.onValueRemoved,
-            keyValueSerializer
-        )
-        includeWebsocketHandling(
-            onDataClearedRoute,
-            originalRepo.onDataCleared,
-            keySerializer
-        )
-    }
-
-    post(addRoute) {
-        unifiedRouter.apply {
-            val obj = uniload(keyValueMapSerializer)
-
-            unianswer(
-                Unit.serializer(),
-                originalRepo.add(obj)
-            )
-        }
-    }
-
-    post(removeRoute) {
-        unifiedRouter.apply {
-            val obj = uniload(keyValueMapSerializer)
-
-            unianswer(
-                Unit.serializer(),
-                originalRepo.remove(obj),
-            )
-        }
-    }
-
-    post(clearRoute) {
-        unifiedRouter.apply {
-            val key = uniload(keySerializer)
-
-            unianswer(
-                Unit.serializer(),
-                originalRepo.clear(key),
-            )
-        }
-    }
-
-    post(clearWithValueRoute) {
-        unifiedRouter.apply {
-            val v = uniload(valueSerializer)
-
-            unianswer(
-                Unit.serializer(),
-                originalRepo.clearWithValue(v),
-            )
-        }
-    }
-
-    post(setRoute) {
-        unifiedRouter.apply {
-            val obj = uniload(keyValueMapSerializer)
-
-            unianswer(
-                Unit.serializer(),
-                originalRepo.set(obj)
-            )
-        }
-    }
-}
-
-fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
-    originalRepo: WriteKeyValuesRepo<Key, Value>,
-    keySerializer: KSerializer<Key>,
-    valueSerializer: KSerializer<Value>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
-    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) = configureOneToManyWriteKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType))