fill changelog

0.14.3

.github/workflows/build.yml

@@ -9,9 +9,6 @@ jobs:
       - uses: actions/setup-java@v1
         with:
           java-version: 11
-      - name: Fix android 32.0.0 dx
-        continue-on-error: true
-        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
       - name: Rewrite version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
@@ -20,9 +17,8 @@ jobs:
           mv gradle.properties.tmp gradle.properties
       - name: Build
         run: ./gradlew build
-#      - name: Publish
-#        continue-on-error: true
-#        run: ./gradlew --no-parallel publishAllPublicationsToGithubPackagesRepository
-#        env:
-#          GITHUBPACKAGES_USER: ${{ github.actor }}
-#          GITHUBPACKAGES_PASSWORD: ${{ secrets.GITHUB_TOKEN }}
+      - name: Publish
+        continue-on-error: true
+        run: ./gradlew publishAllPublicationsToGiteaRepository
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}

.space.kts

@@ -1,8 +0,0 @@
-job("Build and run tests") {
-    container(displayName = "Run gradle build", image = "openjdk:11") {
-        kotlinScript { api ->
-            // here can be your complex logic
-            api.gradlew("build")
-        }
-    }
-}

CHANGELOG.md

@@ -1,5 +1,64 @@
 # Changelog
 
+## 0.14.4
+
+* `Common`:
+    * `JVM`:
+        * New extension `downloadToTempFile`
+* `Ktor`:
+    * `Server`:
+        * Small fix in `handleUniUpload`
+        * `ApplicationCall#uniloadMultipartFile` now uses `uniloadMultipart`
+    * `Common`:
+        * New extension `downloadToTempFile`
+    * `Client`:
+        * New extensions on top of `uniUpload`
+
+## 0.14.3
+
+* `Common`:
+    * New type `Progress`
+* `Ktor`:
+    * `Client`:
+        * New universal `uniUpload` extension for `HttpClient`
+    * `Server`:
+        * New universal `handleUniUpload` extension for `ApplicationCall`
+        * Add extensions `download` and `downloadToTemporalFile`
+
+## 0.14.2
+
+* `Versions`:
+    * `Exposed`: `0.40.1` -> `0.41.1`
+
+
+## 0.14.1
+
+* `Versions`:
+    * `Klock`: `3.3.1` -> `3.4.0`
+    * `UUID`: `0.5.0` -> `0.6.0`
+
+## 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**

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

@@ -0,0 +1,37 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.serialization.Serializable
+import kotlin.jvm.JvmInline
+
+@Serializable
+@JvmInline
+value class Progress private constructor(
+    val of1: Double
+) {
+    val of1Float
+        get() = of1.toFloat()
+    val of100
+        get() = of1 * 100
+    val of100Float
+        get() = of100.toFloat()
+    val of100Int
+        get() = of100.toInt()
+
+    init {
+        require(of1 in rangeOfValues) {
+            "Progress main value should be in $rangeOfValues, but incoming value is $of1"
+        }
+    }
+
+    companion object {
+        val rangeOfValues = 0.0 .. 1.0
+
+        val START = Progress(rangeOfValues.start)
+        val COMPLETED = Progress(rangeOfValues.endInclusive)
+
+        operator fun invoke(of1: Double) = Progress(of1.coerceIn(rangeOfValues))
+        operator fun invoke(part: Number, total: Number) = Progress(
+            part.toDouble() / total.toDouble()
+        )
+    }
+}

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

@@ -0,0 +1,80 @@
+@file:Suppress(
+  "RemoveRedundantCallsOfConversionMethods",
+  "RedundantVisibilityModifier",
+)
+
+package dev.inmo.micro_utils.common
+
+import kotlin.Byte
+import kotlin.Double
+import kotlin.Float
+import kotlin.Int
+import kotlin.Long
+import kotlin.Short
+import kotlin.Suppress
+
+public operator fun Progress.plus(other: Progress): Progress = Progress(of1 + other.of1)
+
+public operator fun Progress.minus(other: Progress): Progress = Progress(of1 - other.of1)
+
+public operator fun Progress.plus(i: Byte): Progress = Progress((of1 + i).toDouble())
+
+public operator fun Progress.minus(i: Byte): Progress = Progress((of1 - i).toDouble())
+
+public operator fun Progress.times(i: Byte): Progress = Progress((of1 * i).toDouble())
+
+public operator fun Progress.div(i: Byte): Progress = Progress((of1 / i).toDouble())
+
+public operator fun Progress.rem(i: Byte): Progress = Progress((of1 % i).toDouble())
+
+public operator fun Progress.plus(i: Short): Progress = Progress((of1 + i).toDouble())
+
+public operator fun Progress.minus(i: Short): Progress = Progress((of1 - i).toDouble())
+
+public operator fun Progress.times(i: Short): Progress = Progress((of1 * i).toDouble())
+
+public operator fun Progress.div(i: Short): Progress = Progress((of1 / i).toDouble())
+
+public operator fun Progress.rem(i: Short): Progress = Progress((of1 % i).toDouble())
+
+public operator fun Progress.plus(i: Int): Progress = Progress((of1 + i).toDouble())
+
+public operator fun Progress.minus(i: Int): Progress = Progress((of1 - i).toDouble())
+
+public operator fun Progress.times(i: Int): Progress = Progress((of1 * i).toDouble())
+
+public operator fun Progress.div(i: Int): Progress = Progress((of1 / i).toDouble())
+
+public operator fun Progress.rem(i: Int): Progress = Progress((of1 % i).toDouble())
+
+public operator fun Progress.plus(i: Long): Progress = Progress((of1 + i).toDouble())
+
+public operator fun Progress.minus(i: Long): Progress = Progress((of1 - i).toDouble())
+
+public operator fun Progress.times(i: Long): Progress = Progress((of1 * i).toDouble())
+
+public operator fun Progress.div(i: Long): Progress = Progress((of1 / i).toDouble())
+
+public operator fun Progress.rem(i: Long): Progress = Progress((of1 % i).toDouble())
+
+public operator fun Progress.plus(i: Float): Progress = Progress((of1 + i).toDouble())
+
+public operator fun Progress.minus(i: Float): Progress = Progress((of1 - i).toDouble())
+
+public operator fun Progress.times(i: Float): Progress = Progress((of1 * i).toDouble())
+
+public operator fun Progress.div(i: Float): Progress = Progress((of1 / i).toDouble())
+
+public operator fun Progress.rem(i: Float): Progress = Progress((of1 % i).toDouble())
+
+public operator fun Progress.plus(i: Double): Progress = Progress((of1 + i).toDouble())
+
+public operator fun Progress.minus(i: Double): Progress = Progress((of1 - i).toDouble())
+
+public operator fun Progress.times(i: Double): Progress = Progress((of1 * i).toDouble())
+
+public operator fun Progress.div(i: Double): Progress = Progress((of1 / i).toDouble())
+
+public operator fun Progress.rem(i: Double): Progress = Progress((of1 % i).toDouble())
+
+public operator fun Progress.compareTo(other: Progress): Int = (of1 - other.of1).toInt()

common/src/jvmMain/kotlin/dev/inmo/micro_utils/common/CreateTempFileFromInput.kt

@@ -0,0 +1,20 @@
+package dev.inmo.micro_utils.common
+
+import java.io.File
+import java.io.InputStream
+import java.util.UUID
+
+fun InputStream.downloadToTempFile(
+    fileName: String = UUID.randomUUID().toString(),
+    fileExtension: String? = ".temp",
+    folder: File? = null
+) = File.createTempFile(
+    fileName,
+    fileExtension,
+    folder
+).apply {
+    outputStream().use {
+        copyTo(it)
+    }
+    deleteOnExit()
+}

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.13.0
-android_code_version=158
+version=0.14.4
+android_code_version=165

gradle/libs.versions.toml

@@ -1,17 +1,17 @@
 [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-beta02"
-jb-exposed = "0.39.2"
-jb-dokka = "1.7.10"
+jb-compose = "1.2.1"
+jb-exposed = "0.41.1"
+jb-dokka = "1.7.20"
 
-klock = "3.1.0"
-uuid = "0.5.0"
+klock = "3.4.0"
+uuid = "0.6.0"
 
-ktor = "2.1.2"
+ktor = "2.1.3"
 
 gh-release = "2.4.1"
 

ktor/client/build.gradle

@@ -15,5 +15,9 @@ kotlin {
                 api libs.ktor.client
             }
         }
+
+        androidMain {
+            dependsOn jvmMain
+        }
     }
 }

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

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.ktor.client
+
+typealias OnUploadCallback = suspend (uploaded: Long, count: Long) -> Unit

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

@@ -7,5 +7,5 @@ import io.ktor.client.HttpClient
 expect suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: (uploaded: Long, count: Long) -> Unit = { _, _ -> }
+    onUpload: OnUploadCallback = { _, _ -> }
 ): TemporalFileId

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

@@ -0,0 +1,105 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.FileName
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.ktor.common.LambdaInputProvider
+import io.ktor.client.HttpClient
+import io.ktor.http.Headers
+import io.ktor.utils.io.core.Input
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.StringFormat
+import kotlinx.serialization.json.Json
+
+data class UniUploadFileInfo(
+    val fileName: FileName,
+    val mimeType: String,
+    val inputAllocator: LambdaInputProvider
+)
+
+/**
+ * Will execute submitting of multipart data request
+ *
+ * @param data [Map] where keys will be used as names for multipart parts and values as values. If you will pass
+ * [dev.inmo.micro_utils.common.MPPFile] (File from JS or JVM platform). Also you may pass [UniUploadFileInfo] as value
+ * in case you wish to pass other source of multipart binary data than regular file
+ *
+ * @see dev.inmo.micro_utils.ktor.server.handleUniUpload
+ */
+expect suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    data: Map<String, Any>,
+    resultDeserializer: DeserializationStrategy<T>,
+    headers: Headers = Headers.Empty,
+    stringFormat: StringFormat = Json,
+    onUpload: OnUploadCallback = { _, _ -> }
+): T?
+
+/**
+ * Additional variant of [uniUpload] which will unify sending of some [MPPFile] with the server
+ *
+ * @see dev.inmo.micro_utils.ktor.server.uniloadMultipartFile
+ */
+suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    file: MPPFile,
+    resultDeserializer: DeserializationStrategy<T>,
+    additionalData: Map<String, Any> = emptyMap(),
+    headers: Headers = Headers.Empty,
+    stringFormat: StringFormat = Json,
+    onUpload: OnUploadCallback = { _, _ -> }
+): T? = uniUpload(
+    url,
+    additionalData + ("bytes" to file),
+    resultDeserializer,
+    headers,
+    stringFormat,
+    onUpload
+)
+
+/**
+ * Additional variant of [uniUpload] which will unify sending of some [UniUploadFileInfo] with the server
+ *
+ * @see dev.inmo.micro_utils.ktor.server.uniloadMultipartFile
+ */
+suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    info: UniUploadFileInfo,
+    resultDeserializer: DeserializationStrategy<T>,
+    additionalData: Map<String, Any> = emptyMap(),
+    headers: Headers = Headers.Empty,
+    stringFormat: StringFormat = Json,
+    onUpload: OnUploadCallback = { _, _ -> }
+): T? = uniUpload(
+    url,
+    additionalData + ("bytes" to info),
+    resultDeserializer,
+    headers,
+    stringFormat,
+    onUpload
+)
+
+/**
+ * Additional variant of [uniUpload] which will unify sending of some [UniUploadFileInfo] (built from [fileName],
+ * [mimeType] and [inputAllocator]) with the server
+ *
+ * @see dev.inmo.micro_utils.ktor.server.uniloadMultipartFile
+ */
+suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    fileName: FileName,
+    mimeType: String,
+    inputAllocator: LambdaInputProvider,
+    resultDeserializer: DeserializationStrategy<T>,
+    additionalData: Map<String, Any> = emptyMap(),
+    headers: Headers = Headers.Empty,
+    stringFormat: StringFormat = Json,
+    onUpload: OnUploadCallback = { _, _ -> }
+): T? = uniUpload(
+    url,
+    UniUploadFileInfo(fileName, mimeType, inputAllocator),
+    resultDeserializer,
+    additionalData,
+    headers,
+    stringFormat,
+    onUpload
+)

ktor/client/src/jsMain/kotlin/dev/inmo/micro_utils/ktor/client/ActualTemporalUpload.kt

@@ -1,6 +1,8 @@
 package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.coroutines.LinkedSupervisorJob
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import io.ktor.client.HttpClient
 import kotlinx.coroutines.*
@@ -12,10 +14,11 @@ import org.w3c.xhr.XMLHttpRequest.Companion.DONE
 suspend fun tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: (Long, Long) -> Unit
+    onUpload: OnUploadCallback
 ): TemporalFileId {
     val formData = FormData()
     val answer = CompletableDeferred<TemporalFileId>(currentCoroutineContext().job)
+    val subscope = CoroutineScope(currentCoroutineContext().LinkedSupervisorJob())
 
     formData.append(
         "data",
@@ -25,7 +28,7 @@ suspend fun tempUpload(
     val request = XMLHttpRequest()
     request.responseType = XMLHttpRequestResponseType.TEXT
     request.upload.onprogress = {
-        onUpload(it.loaded.toLong(), it.total.toLong())
+        subscope.launchSafelyWithoutExceptions { onUpload(it.loaded.toLong(), it.total.toLong()) }
     }
     request.onload = {
         if (request.status == 200.toShort()) {
@@ -48,12 +51,14 @@ suspend fun tempUpload(
         }
     }
 
-    return answer.await()
+    return answer.await().also {
+        subscope.cancel()
+    }
 }
 
 
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: (uploaded: Long, count: Long) -> Unit
+    onUpload: OnUploadCallback
 ): TemporalFileId = dev.inmo.micro_utils.ktor.client.tempUpload(fullTempUploadDraftPath, file, onUpload)

ktor/client/src/jsMain/kotlin/dev/inmo/micro_utils/ktor/client/ActualUniUpload.kt

@@ -0,0 +1,96 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.Progress
+import dev.inmo.micro_utils.coroutines.LinkedSupervisorJob
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import io.ktor.client.HttpClient
+import io.ktor.http.Headers
+import io.ktor.utils.io.core.readBytes
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.job
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.StringFormat
+import kotlinx.serialization.encodeToString
+import org.khronos.webgl.Int8Array
+import org.w3c.files.Blob
+import org.w3c.xhr.FormData
+import org.w3c.xhr.TEXT
+import org.w3c.xhr.XMLHttpRequest
+import org.w3c.xhr.XMLHttpRequestResponseType
+
+/**
+ * Will execute submitting of multipart data request
+ *
+ * @param data [Map] where keys will be used as names for multipart parts and values as values. If you will pass
+ * [dev.inmo.micro_utils.common.MPPFile] (File from JS or JVM platform). Also you may pass [UniUploadFileInfo] as value
+ * in case you wish to pass other source of multipart binary data than regular file
+ */
+actual suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    data: Map<String, Any>,
+    resultDeserializer: DeserializationStrategy<T>,
+    headers: Headers,
+    stringFormat: StringFormat,
+    onUpload: OnUploadCallback
+): T? {
+    val formData = FormData()
+    val answer = CompletableDeferred<T?>(currentCoroutineContext().job)
+    val subscope = CoroutineScope(currentCoroutineContext().LinkedSupervisorJob())
+
+    data.forEach { (k, v) ->
+        when (v) {
+            is MPPFile -> formData.append(
+                k,
+                v
+            )
+            is UniUploadFileInfo -> formData.append(
+                k,
+                Blob(arrayOf(Int8Array(v.inputAllocator().readBytes().toTypedArray()))),
+                v.fileName.name
+            )
+            else -> formData.append(
+                k,
+                stringFormat.encodeToString(v)
+            )
+        }
+    }
+
+    val request = XMLHttpRequest()
+    headers.forEach { s, strings ->
+        request.setRequestHeader(s, strings.joinToString())
+    }
+    request.responseType = XMLHttpRequestResponseType.TEXT
+    request.upload.onprogress = {
+        subscope.launchSafelyWithoutExceptions { onUpload(it.loaded.toLong(), it.total.toLong()) }
+    }
+    request.onload = {
+        if (request.status == 200.toShort()) {
+            answer.complete(
+                stringFormat.decodeFromString(resultDeserializer, request.responseText)
+            )
+        } else {
+            answer.completeExceptionally(Exception("Something went wrong: $it"))
+        }
+    }
+    request.onerror = {
+        answer.completeExceptionally(Exception("Something went wrong: $it"))
+    }
+    request.open("POST", url, true)
+    request.send(formData)
+
+    answer.invokeOnCompletion {
+        runCatching {
+            if (request.readyState != XMLHttpRequest.DONE) {
+                request.abort()
+            }
+        }
+    }
+
+    return answer.await().also {
+        subscope.cancel()
+    }
+}

ktor/client/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/client/ActualMPPFileInputProvider.kt

@@ -4,6 +4,8 @@ import dev.inmo.micro_utils.common.MPPFile
 import io.ktor.client.request.forms.InputProvider
 import io.ktor.utils.io.streams.asInput
 
-actual suspend fun MPPFile.inputProvider(): InputProvider = InputProvider(length()) {
+fun MPPFile.inputProviderSync(): InputProvider = InputProvider(length()) {
     inputStream().asInput()
 }
+
+actual suspend fun MPPFile.inputProvider(): InputProvider = inputProviderSync()

ktor/client/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/client/ActualTemporalUpload.kt

@@ -18,7 +18,7 @@ internal val MPPFile.mimeType: String
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: (Long, Long) -> Unit
+    onUpload: OnUploadCallback
 ): TemporalFileId {
     val inputProvider = file.inputProvider()
     val fileId = submitFormWithBinaryData(

ktor/client/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/client/ActualUniUpload.kt

@@ -0,0 +1,101 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.Progress
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.mergeHeaders
+import io.ktor.client.plugins.onUpload
+import io.ktor.client.request.HttpRequestBuilder
+import io.ktor.client.request.forms.InputProvider
+import io.ktor.client.request.forms.formData
+import io.ktor.client.request.forms.submitForm
+import io.ktor.client.request.forms.submitFormWithBinaryData
+import io.ktor.client.request.headers
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.Headers
+import io.ktor.http.HttpHeaders
+import io.ktor.http.HttpStatusCode
+import io.ktor.http.Parameters
+import io.ktor.http.content.PartData
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.StringFormat
+import kotlinx.serialization.encodeToString
+import java.io.File
+
+/**
+ * Will execute submitting of multipart data request
+ *
+ * @param data [Map] where keys will be used as names for multipart parts and values as values. If you will pass
+ * [dev.inmo.micro_utils.common.MPPFile] (File from JS or JVM platform). Also you may pass [UniUploadFileInfo] as value
+ * in case you wish to pass other source of multipart binary data than regular file
+ */
+actual suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    data: Map<String, Any>,
+    resultDeserializer: DeserializationStrategy<T>,
+    headers: Headers,
+    stringFormat: StringFormat,
+    onUpload: OnUploadCallback
+): T? {
+    val withBinary = data.values.any { it is File || it is UniUploadFileInfo }
+
+    val formData = formData {
+        data.forEach { (k, v) ->
+            when (v) {
+                is File -> append(
+                    k,
+                    v.inputProviderSync(),
+                    Headers.build {
+                        append(HttpHeaders.ContentType, v.mimeType)
+                        append(HttpHeaders.ContentDisposition, "filename=\"${v.name}\"")
+                    }
+                )
+                is UniUploadFileInfo -> append(
+                    k,
+                    InputProvider(block = v.inputAllocator),
+                    Headers.build {
+                        append(HttpHeaders.ContentType, v.mimeType)
+                        append(HttpHeaders.ContentDisposition, "filename=\"${v.fileName.name}\"")
+                    }
+                )
+                else -> append(
+                    k,
+                    stringFormat.encodeToString(v)
+                )
+            }
+        }
+    }
+
+    val requestBuilder: HttpRequestBuilder.() -> Unit = {
+        headers {
+            appendAll(headers)
+        }
+        onUpload { bytesSentTotal, contentLength ->
+            onUpload(bytesSentTotal, contentLength)
+        }
+    }
+
+    val response = if (withBinary) {
+        submitFormWithBinaryData(
+            url,
+            formData,
+            block = requestBuilder
+        )
+    } else {
+        submitForm(
+            url,
+            Parameters.build {
+                formData.forEach {
+                    val formItem = (it as PartData.FormItem)
+                    append(it.name!!, it.value)
+                }
+            },
+            block = requestBuilder
+        )
+    }
+
+    return if (response.status == HttpStatusCode.OK) {
+        stringFormat.decodeFromString(resultDeserializer, response.bodyAsText())
+    } else {
+        null
+    }
+}

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

@@ -0,0 +1,5 @@
+package dev.inmo.micro_utils.ktor.common
+
+import io.ktor.utils.io.core.Input
+
+typealias LambdaInputProvider = () -> Input

ktor/common/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/common/CreateTempFileFromInput.kt

@@ -0,0 +1,23 @@
+package dev.inmo.micro_utils.ktor.common
+
+import io.ktor.utils.io.core.Input
+import io.ktor.utils.io.core.copyTo
+import io.ktor.utils.io.streams.asOutput
+import java.io.File
+import java.io.InputStream
+import java.util.UUID
+
+fun Input.downloadToTempFile(
+    fileName: String = UUID.randomUUID().toString(),
+    fileExtension: String? = ".temp",
+    folder: File? = null
+) = File.createTempFile(
+    fileName,
+    fileExtension,
+    folder
+).apply {
+    outputStream().use {
+        copyTo(it.asOutput())
+    }
+    deleteOnExit()
+}

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

@@ -0,0 +1,56 @@
+package dev.inmo.micro_utils.ktor.server
+
+import com.benasher44.uuid.uuid4
+import io.ktor.http.content.PartData
+import io.ktor.utils.io.copyTo
+import io.ktor.utils.io.core.copyTo
+import io.ktor.utils.io.jvm.javaio.copyTo
+import io.ktor.utils.io.streams.asOutput
+import java.io.File
+
+fun PartData.FileItem.download(target: File) {
+    provider().use { input ->
+        target.outputStream().use {
+            input.copyTo(it.asOutput())
+        }
+    }
+}
+
+fun PartData.FileItem.downloadToTemporalFile(): File {
+    val outputFile = File.createTempFile(uuid4().toString(), ".temp").apply {
+        deleteOnExit()
+    }
+    download(outputFile)
+    return outputFile
+}
+
+fun PartData.BinaryItem.download(target: File) {
+    provider().use { input ->
+        target.outputStream().use {
+            input.copyTo(it.asOutput())
+        }
+    }
+}
+
+fun PartData.BinaryItem.downloadToTemporalFile(): File {
+    val outputFile = File.createTempFile(uuid4().toString(), ".temp").apply {
+        deleteOnExit()
+    }
+    download(outputFile)
+    return outputFile
+}
+
+suspend fun PartData.BinaryChannelItem.download(target: File) {
+    val input = provider()
+    target.outputStream().use {
+        input.copyTo(it)
+    }
+}
+
+suspend fun PartData.BinaryChannelItem.downloadToTemporalFile(): File {
+    val outputFile = File.createTempFile(uuid4().toString(), ".temp").apply {
+        deleteOnExit()
+    }
+    download(outputFile)
+    return outputFile
+}

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

@@ -0,0 +1,25 @@
+package dev.inmo.micro_utils.ktor.server
+
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.application.ApplicationCall
+import io.ktor.server.response.respond
+
+suspend fun ApplicationCall.getParameterOrSendError(
+    field: String
+) = parameters[field].also {
+    if (it == null) {
+        respond(HttpStatusCode.BadRequest, "Request must contains $field")
+    }
+}
+
+fun ApplicationCall.getQueryParameter(
+    field: String
+) = request.queryParameters[field]
+
+suspend fun ApplicationCall.getQueryParameterOrSendError(
+    field: String
+) = getQueryParameter(field).also {
+    if (it == null) {
+        respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
+    }
+}

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

@@ -1,111 +0,0 @@
-package dev.inmo.micro_utils.ktor.server
-
-import dev.inmo.micro_utils.common.*
-import dev.inmo.micro_utils.coroutines.safely
-import dev.inmo.micro_utils.ktor.common.*
-import io.ktor.http.*
-import io.ktor.http.content.*
-import io.ktor.server.application.ApplicationCall
-import io.ktor.server.application.call
-import io.ktor.server.request.receive
-import io.ktor.server.request.receiveMultipart
-import io.ktor.server.response.respond
-import io.ktor.server.response.respondBytes
-import io.ktor.server.routing.Route
-import io.ktor.server.websocket.WebSocketServerSession
-import io.ktor.util.pipeline.PipelineContext
-import io.ktor.utils.io.core.*
-import kotlinx.coroutines.flow.Flow
-import kotlinx.serialization.DeserializationStrategy
-import kotlinx.serialization.SerializationStrategy
-
-suspend fun ApplicationCall.uniloadMultipart(
-    onFormItem: (PartData.FormItem) -> Unit = {},
-    onCustomFileItem: (PartData.FileItem) -> Unit = {},
-    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
-    onBinaryContent: (PartData.BinaryItem) -> Unit = {}
-) = safely {
-    val multipartData = receiveMultipart()
-
-    var resultInput: Input? = null
-
-    multipartData.forEachPart {
-        when (it) {
-            is PartData.FormItem -> onFormItem(it)
-            is PartData.FileItem -> {
-                when (it.name) {
-                    "bytes" -> resultInput = it.provider()
-                    else -> onCustomFileItem(it)
-                }
-            }
-            is PartData.BinaryItem -> onBinaryContent(it)
-            is PartData.BinaryChannelItem -> onBinaryChannelItem(it)
-        }
-    }
-
-    resultInput ?: error("Bytes has not been received")
-}
-
-suspend fun ApplicationCall.uniloadMultipartFile(
-    onFormItem: (PartData.FormItem) -> Unit = {},
-    onCustomFileItem: (PartData.FileItem) -> Unit = {},
-    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
-    onBinaryContent: (PartData.BinaryItem) -> Unit = {},
-) = safely {
-    val multipartData = receiveMultipart()
-
-    var resultInput: MPPFile? = null
-
-    multipartData.forEachPart {
-        when (it) {
-            is PartData.FormItem -> onFormItem(it)
-            is PartData.FileItem -> {
-                if (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)
-                            }
-                        }
-                    }
-                } else {
-                    onCustomFileItem(it)
-                }
-            }
-            is PartData.BinaryItem -> onBinaryContent(it)
-            is PartData.BinaryChannelItem -> onBinaryChannelItem(it)
-        }
-    }
-
-    resultInput ?: error("Bytes has not been received")
-}
-
-suspend fun ApplicationCall.getParameterOrSendError(
-    field: String
-) = parameters[field].also {
-    if (it == null) {
-        respond(HttpStatusCode.BadRequest, "Request must contains $field")
-    }
-}
-
-fun ApplicationCall.getQueryParameter(
-    field: String
-) = request.queryParameters[field]
-
-suspend fun ApplicationCall.getQueryParameterOrSendError(
-    field: String
-) = getQueryParameter(field).also {
-    if (it == null) {
-        respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
-    }
-}

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

@@ -0,0 +1,70 @@
+package dev.inmo.micro_utils.ktor.server
+
+import dev.inmo.micro_utils.common.*
+import dev.inmo.micro_utils.coroutines.safely
+import dev.inmo.micro_utils.ktor.common.downloadToTempFile
+import io.ktor.http.content.*
+import io.ktor.server.application.ApplicationCall
+import io.ktor.server.request.receiveMultipart
+import io.ktor.utils.io.core.*
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.isActive
+
+/**
+ * Server-side part which receives [dev.inmo.micro_utils.ktor.client.uniUpload] request
+ */
+suspend inline fun ApplicationCall.handleUniUpload(
+    onFormItem: (PartData.FormItem) -> Unit = {},
+    onBinaryContent: (PartData.BinaryItem) -> Unit = {},
+    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
+    onFileItem: (PartData.FileItem) -> Unit = {}
+) {
+    val multipartData = receiveMultipart()
+
+    while (currentCoroutineContext().isActive) {
+        val partData = multipartData.readPart() ?: break
+        when (partData) {
+            is PartData.FormItem -> onFormItem(partData)
+            is PartData.FileItem -> onFileItem(partData)
+            is PartData.BinaryItem -> onBinaryContent(partData)
+            is PartData.BinaryChannelItem -> onBinaryChannelItem(partData)
+        }
+        partData.dispose()
+    }
+}
+
+suspend fun ApplicationCall.uniloadMultipart(
+    onFormItem: (PartData.FormItem) -> Unit = {},
+    onCustomFileItem: (PartData.FileItem) -> Unit = {},
+    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
+    onBinaryContent: (PartData.BinaryItem) -> Unit = {}
+): Input = safely {
+    var resultInput: Input? = null
+
+    handleUniUpload(
+        onFormItem,
+        onBinaryContent,
+        onBinaryChannelItem
+    ) {
+        when (it.name) {
+            "bytes" -> resultInput = it.provider()
+            else -> onCustomFileItem(it)
+        }
+    }
+
+    resultInput ?: error("Bytes has not been received")
+}
+
+suspend fun ApplicationCall.uniloadMultipartFile(
+    onFormItem: (PartData.FormItem) -> Unit = {},
+    onCustomFileItem: (PartData.FileItem) -> Unit = {},
+    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
+    onBinaryContent: (PartData.BinaryItem) -> Unit = {},
+): MPPFile = safely {
+    uniloadMultipart(
+        onFormItem,
+        onCustomFileItem,
+        onBinaryChannelItem,
+        onBinaryContent
+    ).downloadToTempFile()
+}

publish.gradle

@@ -19,29 +19,29 @@ publishing {
             }
 
             developers {
-                
+
                     developer {
                         id = "InsanusMokrassar"
                         name = "Aleksei Ovsiannikov"
                         email = "ovsyannikov.alexey95@gmail.com"
                     }
-                
+
 
                     developer {
                         id = "000Sanya"
                         name = "Syrov Aleksandr"
                         email = "000sanya.000sanya@gmail.com"
                     }
-                
+
             }
 
             licenses {
-                
+
                     license {
                         name = "Apache Software License 2.0"
                         url = "https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"
                     }
-                
+
             }
         }
         repositories {
@@ -49,35 +49,54 @@ publishing {
                 maven {
                     name = "GithubPackages"
                     url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
+
                     credentials {
                         username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
                         password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
                     }
+
+                }
+            }
+            if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
+                maven {
+                    name = "Gitea"
+                    url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
+
+                    credentials(HttpHeaderCredentials) {
+                        name = "Authorization"
+                        value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
+                    }
+
+                    authentication {
+                        header(HttpHeaderAuthentication)
+                    }
                 }
             }
             if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
                 maven {
                     name = "sonatype"
                     url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+
                     credentials {
                         username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
                         password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
                     }
+
                 }
             }
         }
     }
 }
-    
+
 if (project.hasProperty("signing.gnupg.keyName")) {
     apply plugin: 'signing'
-    
+
     signing {
         useGpgCmd()
-    
+
         sign publishing.publications
     }
-    
+
     task signAll {
         tasks.withType(Sign).forEach {
             dependsOn(it)

publish.kpsb

@@ -1 +1 @@
-{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"It is set of projects with micro tools for avoiding of routines coding","url":"https://github.com/InsanusMokrassar/MicroUtils/","vcsUrl":"https://github.com/InsanusMokrassar/MicroUtils.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"},{"id":"000Sanya","name":"Syrov Aleksandr","eMail":"000sanya.000sanya@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/MicroUtils"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}
+{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"It is set of projects with micro tools for avoiding of routines coding","url":"https://github.com/InsanusMokrassar/MicroUtils/","vcsUrl":"https://github.com/InsanusMokrassar/MicroUtils.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"},{"id":"000Sanya","name":"Syrov Aleksandr","eMail":"000sanya.000sanya@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/MicroUtils"},{"name":"Gitea","url":"https://git.inmo.dev/api/packages/InsanusMokrassar/maven","credsType":{"type":"dev.inmo.kmppscriptbuilder.core.models.MavenPublishingRepository.CredentialsType.HttpHeaderCredentials","headerName":"Authorization","headerValueProperty":"GITEA_TOKEN"}},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}

repos/common/build.gradle

@@ -28,6 +28,7 @@ kotlin {
                 api internalProject("micro_utils.common")
                 api internalProject("micro_utils.coroutines")
             }
+            dependsOn jvmMain
         }
     }
 }

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

@@ -27,21 +27,29 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
 
     protected abstract fun InsertStatement<Number>.asObject(value: InputValueType): ObjectType
 
-    protected abstract fun update(id: IdType, value: InputValueType, it: UpdateBuilder<Int>)
-    protected abstract fun createAndInsertId(value: InputValueType, it: InsertStatement<Number>): IdType
+    /**
+     * @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>)
     }
-    @Deprecated(
-        "Replace its \"it\" parameter type with \"UpdateBuilder<Int>\" to actualize method signature. Method with current signature will be removed soon and do not recommended to override anymore"
-    )
-    protected open fun update(id: IdType, value: InputValueType, it: UpdateStatement) = update(
-        id,
-        value,
-        it as UpdateBuilder<Int>
-    )
 
     protected open suspend fun onBeforeCreate(value: List<InputValueType>) {}
 
@@ -121,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

@@ -27,15 +27,6 @@ abstract class AbstractExposedKeyValueRepo<Key, Value>(
         update(k, v, it as UpdateBuilder<Int>)
     }
 
-    @Deprecated(
-        "Replace its \"it\" parameter type with \"UpdateBuilder<Int>\" to actualize method signature. Method with current signature will be removed soon and do not recommended to override anymore"
-    )
-    protected open fun update(k: Key, v: Value, it: UpdateStatement) = update(
-        k,
-        v,
-        it as UpdateBuilder<Int>
-    )
-
     override suspend fun set(toSet: Map<Key, Value>) {
         transaction(database) {
             toSet.mapNotNull { (k, v) ->
@@ -59,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
                 }
@@ -75,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

@@ -20,10 +20,10 @@ open class ExposedReadKeyValueRepo<Key, Value>(
     val valueColumn: Column<Value> = valueColumnAllocator()
     override val ResultRow.asKey: Key
         get() = get(keyColumn)
-    override val selectByValue: SqlExpressionBuilder.(Value) -> Op<Boolean> = { valueColumn.eq(it) }
+    override val selectByValue: ISqlExpressionBuilder.(Value) -> Op<Boolean> = { valueColumn.eq(it) }
     override val ResultRow.asObject: Value
         get() = get(valueColumn)
-    override val selectById: SqlExpressionBuilder.(Key) -> Op<Boolean> = { keyColumn.eq(it) }
+    override val selectById: ISqlExpressionBuilder.(Key) -> Op<Boolean> = { keyColumn.eq(it) }
     override val primaryKey: Table.PrimaryKey
         get() = PrimaryKey(keyColumn, 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

@@ -15,10 +15,10 @@ open class ExposedReadKeyValuesRepo<Key, Value>(
     override val keyColumn: Column<Key> = keyColumnAllocator()
     override val ResultRow.asKey: Key
         get() = get(keyColumn)
-    override val selectByValue: SqlExpressionBuilder.(Value) -> Op<Boolean> = { valueColumn.eq(it) }
+    override val selectByValue: ISqlExpressionBuilder.(Value) -> Op<Boolean> = { valueColumn.eq(it) }
     override val ResultRow.asObject: Value
         get() = get(valueColumn)
-    override val selectById: SqlExpressionBuilder.(Key) -> Op<Boolean> = { keyColumn.eq(it) }
+    override val selectById: ISqlExpressionBuilder.(Key) -> Op<Boolean> = { keyColumn.eq(it) }
     val valueColumn: Column<Value> = valueColumnAllocator()
 
     init { initTable() }