Merge 333f91477c into f09d92be32

.github/workflows/build.yml

@@ -17,8 +17,8 @@ jobs:
           mv gradle.properties.tmp gradle.properties
       - name: Build
         run: ./gradlew build
-      - name: Publish to InmoNexus
+      - name: Publish
         continue-on-error: true
-        run: ./gradlew publishAllPublicationsToInmoNexusRepository
+        run: ./gradlew publishAllPublicationsToGiteaRepository
         env:
           GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}

CHANGELOG.md

@@ -1,29 +1,5 @@
 # Changelog
 
-## 0.23.0
-
-**THIS UPDATE MAY CONTAINS SOME BREAKING CHANGES (INCLUDING BREAKING CHANGES IN BYTECODE LAYER) RELATED TO UPDATE OF
-KTOR DEPENDENCY**
-
-**THIS UPDATE CONTAINS CHANGES ACCORDING TO MIGRATION [GUIDE FROM KTOR](https://ktor.io/docs/migrating-3.html)**
-
-* `Versions`:
-  * `Ktor`: `2.3.12` -> `3.0.1`
-* `Ktor`:
-  * `Common`:
-    * Extension `Input.downloadToTempFile` has changed its receiver to `Source`. Its API can be broken
-  * `Client`:
-    * Extension `HttpClient.tempUpload` has changed type of `onUpload` argument from `OnUploadCallback` to `ProgressListener`
-    * All extensions `HttpClient.uniUpload` have changed type of `onUpload` argument from `OnUploadCallback` to `ProgressListener`
-  * `Server`:
-    * Remove redundant `ApplicationCall.respond` extension due to its presence in the ktor library
-
-## 0.22.9
-
-* `Repos`:
-  * `Cache`:
-    * Add direct caching repos
-
 ## 0.22.8
 
 * `Common`:

gradle.properties

@@ -15,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.23.0
+version=0.22.8
-android_code_version=276
+android_code_version=274

gradle/libs.versions.toml

@@ -6,7 +6,7 @@ kt-coroutines = "1.9.0"
 
 kslog = "1.3.6"
 
-jb-compose = "1.7.1+build1910-release-1.7.1"
+jb-compose = "1.7.1+build1894-release-1.7.1"
 jb-exposed = "0.55.0"
 jb-dokka = "1.9.20"
 
@@ -15,7 +15,7 @@ sqlite = "3.46.1.3"
 korlibs = "5.4.0"
 uuid = "0.8.4"
 
-ktor = "3.0.1"
+ktor = "2.3.12"
 
 gh-release = "2.5.2"
 
@@ -23,7 +23,7 @@ koin = "4.0.0"
 
 okio = "3.9.1"
 
-ksp = "2.0.21-1.0.26"
+ksp = "2.0.21-1.0.25"
 kotlin-poet = "1.18.1"
 
 versions = "0.51.0"

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

@@ -3,10 +3,9 @@ package dev.inmo.micro_utils.ktor.client
 import dev.inmo.micro_utils.common.MPPFile
 import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.client.HttpClient
-import io.ktor.client.content.*
 
 expect suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: ProgressListener = ProgressListener { _, _ -> }
+    onUpload: OnUploadCallback = { _, _ -> }
 ): TemporalFileId

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

@@ -4,8 +4,8 @@ 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.client.content.*
 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
@@ -31,7 +31,7 @@ expect suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers = Headers.Empty,
     stringFormat: StringFormat = Json,
-    onUpload: ProgressListener = ProgressListener { _, _ -> }
+    onUpload: OnUploadCallback = { _, _ -> }
 ): T?
 
 /**
@@ -46,7 +46,7 @@ suspend fun <T> HttpClient.uniUpload(
     additionalData: Map<String, Any> = emptyMap(),
     headers: Headers = Headers.Empty,
     stringFormat: StringFormat = Json,
-    onUpload: ProgressListener = ProgressListener { _, _ -> }
+    onUpload: OnUploadCallback = { _, _ -> }
 ): T? = uniUpload(
     url,
     additionalData + ("bytes" to file),
@@ -68,7 +68,7 @@ suspend fun <T> HttpClient.uniUpload(
     additionalData: Map<String, Any> = emptyMap(),
     headers: Headers = Headers.Empty,
     stringFormat: StringFormat = Json,
-    onUpload: ProgressListener = ProgressListener { _, _ -> }
+    onUpload: OnUploadCallback = { _, _ -> }
 ): T? = uniUpload(
     url,
     additionalData + ("bytes" to info),
@@ -93,7 +93,7 @@ suspend fun <T> HttpClient.uniUpload(
     additionalData: Map<String, Any> = emptyMap(),
     headers: Headers = Headers.Empty,
     stringFormat: StringFormat = Json,
-    onUpload: ProgressListener = ProgressListener { _, _ -> }
+    onUpload: OnUploadCallback = { _, _ -> }
 ): T? = uniUpload(
     url,
     UniUploadFileInfo(fileName, mimeType, inputAllocator),

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

@@ -5,15 +5,16 @@ 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 io.ktor.client.content.*
 import kotlinx.coroutines.*
+import org.w3c.dom.mediasource.ENDED
+import org.w3c.dom.mediasource.ReadyState
 import org.w3c.xhr.*
 import org.w3c.xhr.XMLHttpRequest.Companion.DONE
 
 suspend fun tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: ProgressListener
+    onUpload: OnUploadCallback
 ): TemporalFileId {
     val formData = FormData()
     val answer = CompletableDeferred<TemporalFileId>(currentCoroutineContext().job)
@@ -27,7 +28,7 @@ suspend fun tempUpload(
     val request = XMLHttpRequest()
     request.responseType = XMLHttpRequestResponseType.TEXT
     request.upload.onprogress = {
-        subscope.launchSafelyWithoutExceptions { onUpload.onProgress(it.loaded.toLong(), it.total.toLong()) }
+        subscope.launchSafelyWithoutExceptions { onUpload(it.loaded.toLong(), it.total.toLong()) }
     }
     request.onload = {
         if (request.status == 200.toShort()) {
@@ -59,5 +60,5 @@ suspend fun tempUpload(
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: ProgressListener
+    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

@@ -1,10 +1,10 @@
 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.client.content.*
 import io.ktor.http.Headers
 import io.ktor.utils.io.core.readBytes
 import kotlinx.coroutines.CompletableDeferred
@@ -36,7 +36,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers,
     stringFormat: StringFormat,
-    onUpload: ProgressListener
+    onUpload: OnUploadCallback
 ): T? {
     val formData = FormData()
     val answer = CompletableDeferred<T?>(currentCoroutineContext().job)
@@ -66,7 +66,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     }
     request.responseType = XMLHttpRequestResponseType.TEXT
     request.upload.onprogress = {
-        subscope.launchSafelyWithoutExceptions { onUpload.onProgress(it.loaded.toLong(), it.total.toLong()) }
+        subscope.launchSafelyWithoutExceptions { onUpload(it.loaded.toLong(), it.total.toLong()) }
     }
     request.onload = {
         if (request.status == 200.toShort()) {

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

@@ -4,7 +4,6 @@ import dev.inmo.micro_utils.common.MPPFile
 import dev.inmo.micro_utils.common.filename
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import io.ktor.client.HttpClient
-import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.forms.formData
 import io.ktor.client.request.forms.submitFormWithBinaryData
@@ -19,7 +18,7 @@ internal val MPPFile.mimeType: String
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: ProgressListener
+    onUpload: OnUploadCallback
 ): TemporalFileId {
     val inputProvider = file.inputProvider()
     val fileId = submitFormWithBinaryData(

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

@@ -1,7 +1,8 @@
 package dev.inmo.micro_utils.ktor.client
 
+import dev.inmo.micro_utils.common.Progress
 import io.ktor.client.HttpClient
-import io.ktor.client.content.*
+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
@@ -19,6 +20,7 @@ import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.StringFormat
+import kotlinx.serialization.encodeToString
 import kotlinx.serialization.serializer
 import java.io.File
 
@@ -37,7 +39,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers,
     stringFormat: StringFormat,
-    onUpload: ProgressListener
+    onUpload: OnUploadCallback
 ): T? {
     val withBinary = data.values.any { it is File || it is UniUploadFileInfo }
 
@@ -74,7 +76,7 @@ actual suspend fun <T> HttpClient.uniUpload(
             appendAll(headers)
         }
         onUpload { bytesSentTotal, contentLength ->
-            onUpload.onProgress(bytesSentTotal, contentLength)
+            onUpload(bytesSentTotal, contentLength)
         }
     }
 

ktor/client/src/linuxArm64Main/kotlin/ActualTemporalUpload.kt

@@ -5,7 +5,6 @@ import dev.inmo.micro_utils.common.filename
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import dev.inmo.micro_utils.mime_types.getMimeTypeOrAny
 import io.ktor.client.HttpClient
-import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.forms.formData
 import io.ktor.client.request.forms.submitFormWithBinaryData
@@ -19,7 +18,7 @@ internal val MPPFile.mimeType: String
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: ProgressListener
+    onUpload: OnUploadCallback
 ): TemporalFileId {
     val inputProvider = file.inputProvider()
     val fileId = submitFormWithBinaryData(

ktor/client/src/linuxArm64Main/kotlin/ActualUniUpload.kt

@@ -1,8 +1,9 @@
 package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.Progress
 import io.ktor.client.HttpClient
-import io.ktor.client.content.*
+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
@@ -20,6 +21,7 @@ import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.StringFormat
+import kotlinx.serialization.encodeToString
 import kotlinx.serialization.serializer
 
 /**
@@ -37,7 +39,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers,
     stringFormat: StringFormat,
-    onUpload: ProgressListener
+    onUpload: OnUploadCallback
 ): T? {
     val withBinary = data.values.any { it is MPPFile || it is UniUploadFileInfo }
 
@@ -73,7 +75,9 @@ actual suspend fun <T> HttpClient.uniUpload(
         headers {
             appendAll(headers)
         }
-        onUpload(onUpload)
+        onUpload { bytesSentTotal, contentLength ->
+            onUpload(bytesSentTotal, contentLength)
+        }
     }
 
     val response = if (withBinary) {

ktor/client/src/linuxX64Main/kotlin/ActualTemporalUpload.kt

@@ -5,7 +5,6 @@ import dev.inmo.micro_utils.common.filename
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import dev.inmo.micro_utils.mime_types.getMimeTypeOrAny
 import io.ktor.client.HttpClient
-import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.forms.formData
 import io.ktor.client.request.forms.submitFormWithBinaryData
@@ -19,7 +18,7 @@ internal val MPPFile.mimeType: String
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: ProgressListener
+    onUpload: OnUploadCallback
 ): TemporalFileId {
     val inputProvider = file.inputProvider()
     val fileId = submitFormWithBinaryData(

ktor/client/src/linuxX64Main/kotlin/ActualUniUpload.kt

@@ -1,8 +1,9 @@
 package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.Progress
 import io.ktor.client.HttpClient
-import io.ktor.client.content.*
+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
@@ -20,6 +21,7 @@ import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.StringFormat
+import kotlinx.serialization.encodeToString
 import kotlinx.serialization.serializer
 
 /**
@@ -37,7 +39,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers,
     stringFormat: StringFormat,
-    onUpload: ProgressListener
+    onUpload: OnUploadCallback
 ): T? {
     val withBinary = data.values.any { it is MPPFile || it is UniUploadFileInfo }
 
@@ -73,7 +75,9 @@ actual suspend fun <T> HttpClient.uniUpload(
         headers {
             appendAll(headers)
         }
-        onUpload(onUpload)
+        onUpload { bytesSentTotal, contentLength ->
+            onUpload(bytesSentTotal, contentLength)
+        }
     }
 
     val response = if (withBinary) {

ktor/client/src/mingwX64Main/kotlin/ActualTemporalUpload.kt

@@ -5,7 +5,6 @@ import dev.inmo.micro_utils.common.filename
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import dev.inmo.micro_utils.mime_types.getMimeTypeOrAny
 import io.ktor.client.HttpClient
-import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.forms.formData
 import io.ktor.client.request.forms.submitFormWithBinaryData
@@ -19,7 +18,7 @@ internal val MPPFile.mimeType: String
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: ProgressListener
+    onUpload: OnUploadCallback
 ): TemporalFileId {
     val inputProvider = file.inputProvider()
     val fileId = submitFormWithBinaryData(

ktor/client/src/mingwX64Main/kotlin/ActualUniUpload.kt

@@ -1,8 +1,9 @@
 package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.Progress
 import io.ktor.client.HttpClient
-import io.ktor.client.content.*
+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
@@ -20,6 +21,7 @@ import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.StringFormat
+import kotlinx.serialization.encodeToString
 import kotlinx.serialization.serializer
 
 /**
@@ -37,7 +39,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers,
     stringFormat: StringFormat,
-    onUpload: ProgressListener
+    onUpload: OnUploadCallback
 ): T? {
     val withBinary = data.values.any { it is MPPFile || it is UniUploadFileInfo }
 
@@ -73,7 +75,9 @@ actual suspend fun <T> HttpClient.uniUpload(
         headers {
             appendAll(headers)
         }
-        onUpload(onUpload)
+        onUpload { bytesSentTotal, contentLength ->
+            onUpload(bytesSentTotal, contentLength)
+        }
     }
 
     val response = if (withBinary) {

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

@@ -1,12 +1,13 @@
 package dev.inmo.micro_utils.ktor.common
 
-import io.ktor.utils.io.streams.*
+import io.ktor.utils.io.core.Input
-import kotlinx.io.Source
+import io.ktor.utils.io.core.copyTo
-import kotlinx.io.readTo
+import io.ktor.utils.io.streams.asOutput
 import java.io.File
+import java.io.InputStream
 import java.util.UUID
 
-fun Source.downloadToTempFile(
+fun Input.downloadToTempFile(
     fileName: String = UUID.randomUUID().toString(),
     fileExtension: String? = ".temp",
     folder: File? = null
@@ -16,7 +17,7 @@ fun Source.downloadToTempFile(
     folder
 ).apply {
     outputStream().use {
-        it.writePacket(this@downloadToTempFile)
+        copyTo(it.asOutput())
     }
     deleteOnExit()
 }

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

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

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

@@ -4,13 +4,13 @@ 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.*
+import io.ktor.utils.io.jvm.javaio.copyTo
-import io.ktor.utils.io.streams.*
+import io.ktor.utils.io.streams.asOutput
 import java.io.File
 
 fun PartData.FileItem.download(target: File) {
-    provider().toInputStream().use { input ->
+    provider().use { input ->
-        target.outputStream().use {
+        target.outputStream().asOutput().use {
             input.copyTo(it)
         }
     }
@@ -25,9 +25,9 @@ fun PartData.FileItem.downloadToTemporalFile(): File {
 }
 
 fun PartData.BinaryItem.download(target: File) {
-    provider().inputStream().use { input ->
+    provider().use { input ->
         target.outputStream().use {
-            input.copyTo(it)
+            input.copyTo(it.asOutput())
         }
     }
 }

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

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.ktor.server
 
 import dev.inmo.micro_utils.ktor.server.configurators.KtorApplicationConfigurator
-import io.ktor.server.application.*
+import io.ktor.server.application.Application
 import io.ktor.server.cio.CIO
 import io.ktor.server.cio.CIOApplicationEngine
 import io.ktor.server.engine.*
@@ -11,22 +11,20 @@ fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configurati
     engine: ApplicationEngineFactory<TEngine, TConfiguration>,
     host: String = "localhost",
     port: Int = Random.nextInt(1024, 65535),
-    additionalEngineEnvironmentConfigurator: EngineConnectorBuilder.() -> Unit = {},
+    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
     additionalConfigurationConfigurator: TConfiguration.() -> Unit = {},
-    environment: ApplicationEnvironment = applicationEnvironment(),
     block: Application.() -> Unit
-): EmbeddedServer<TEngine, TConfiguration> = embeddedServer<TEngine, TConfiguration>(
+): TEngine = embeddedServer(
     engine,
-    environment,
+    applicationEngineEnvironment {
-    {
+        module(block)
         connector {
             this.host = host
             this.port = port
-            additionalEngineEnvironmentConfigurator()
         }
-        additionalConfigurationConfigurator()
+        additionalEngineEnvironmentConfigurator()
     },
-    module = block
+    additionalConfigurationConfigurator
 )
 
 /**
@@ -37,17 +35,15 @@ fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configurati
 fun createKtorServer(
     host: String = "localhost",
     port: Int = Random.nextInt(1024, 65535),
-    additionalEngineEnvironmentConfigurator: EngineConnectorBuilder.() -> Unit = {},
+    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
     additionalConfigurationConfigurator: CIOApplicationEngine.Configuration.() -> Unit = {},
-    environment: ApplicationEnvironment = applicationEnvironment(),
     block: Application.() -> Unit
-): EmbeddedServer<CIOApplicationEngine, CIOApplicationEngine.Configuration> = createKtorServer(
+): CIOApplicationEngine = createKtorServer(
     CIO,
     host,
     port,
     additionalEngineEnvironmentConfigurator,
     additionalConfigurationConfigurator,
-    environment,
     block
 )
 
@@ -55,17 +51,15 @@ fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configurati
     engine: ApplicationEngineFactory<TEngine, TConfiguration>,
     host: String = "localhost",
     port: Int = Random.nextInt(1024, 65535),
-    additionalEngineEnvironmentConfigurator: EngineConnectorBuilder.() -> Unit = {},
+    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
     additionalConfigurationConfigurator: TConfiguration.() -> Unit = {},
-    environment: ApplicationEnvironment = applicationEnvironment(),
     configurators: List<KtorApplicationConfigurator>
-): EmbeddedServer<TEngine, TConfiguration> = createKtorServer(
+): TEngine = createKtorServer(
     engine,
     host,
     port,
     additionalEngineEnvironmentConfigurator,
-    additionalConfigurationConfigurator,
+    additionalConfigurationConfigurator
-    environment,
 ) {
     configurators.forEach { it.apply { configure() } }
 }
@@ -79,7 +73,6 @@ fun createKtorServer(
     host: String = "localhost",
     port: Int = Random.nextInt(1024, 65535),
     configurators: List<KtorApplicationConfigurator>,
-    additionalEngineEnvironmentConfigurator: EngineConnectorBuilder.() -> Unit = {},
+    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
     additionalConfigurationConfigurator: CIOApplicationEngine.Configuration.() -> Unit = {},
-    environment: ApplicationEnvironment = applicationEnvironment(),
+): ApplicationEngine = createKtorServer(CIO, host, port, additionalEngineEnvironmentConfigurator, additionalConfigurationConfigurator, configurators)
-): EmbeddedServer<CIOApplicationEngine, CIOApplicationEngine.Configuration> = createKtorServer(CIO, host, port, additionalEngineEnvironmentConfigurator, additionalConfigurationConfigurator, environment, configurators)

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

@@ -17,7 +17,6 @@ import io.ktor.server.response.respondText
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.post
 import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -27,10 +26,7 @@ import java.nio.file.attribute.FileTime
 
 class TemporalFilesRoutingConfigurator(
     private val subpath: String = DefaultTemporalFilesSubPath,
-    private val temporalFilesUtilizer: TemporalFilesUtilizer = TemporalFilesUtilizer,
+    private val temporalFilesUtilizer: TemporalFilesUtilizer = TemporalFilesUtilizer
-    filesFlowReplay: Int = 0,
-    filesFlowExtraBufferCapacity: Int = Int.MAX_VALUE,
-    filesFlowOnBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND
 ) : ApplicationRoutingConfigurator.Element {
     interface TemporalFilesUtilizer {
         fun start(filesMap: MutableMap<TemporalFileId, MPPFile>, filesMutex: Mutex, onNewFileFlow: Flow<TemporalFileId>): Job
@@ -78,11 +74,7 @@ class TemporalFilesRoutingConfigurator(
 
     private val temporalFilesMap = mutableMapOf<TemporalFileId, MPPFile>()
     private val temporalFilesMutex = Mutex()
-    private val filesFlow = MutableSharedFlow<TemporalFileId>(
+    private val filesFlow = MutableSharedFlow<TemporalFileId>()
-        replay = filesFlowReplay,
-        extraBufferCapacity = filesFlowExtraBufferCapacity,
-        onBufferOverflow = filesFlowOnBufferOverflow
-    )
     val utilizerJob = temporalFilesUtilizer.start(temporalFilesMap, temporalFilesMutex, filesFlow.asSharedFlow())
 
     override fun Route.invoke() {
@@ -119,7 +111,7 @@ class TemporalFilesRoutingConfigurator(
                     temporalFilesMap[fileId] = file
                 }
                 call.respondText(fileId.string)
-                filesFlow.emit(fileId)
+                launchSafelyWithoutExceptions { filesFlow.emit(fileId) }
             } ?: call.respond(HttpStatusCode.BadRequest)
         }
     }

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

@@ -6,7 +6,6 @@ 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.*
 import io.ktor.utils.io.core.*
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.isActive
@@ -48,7 +47,7 @@ suspend fun ApplicationCall.uniloadMultipart(
         onBinaryChannelItem
     ) {
         when (it.name) {
-            "bytes" -> resultInput = it.provider().readBuffer()
+            "bytes" -> resultInput = it.provider()
             else -> onCustomFileItem(it)
         }
     }

ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/server/configurators/ApplicationRoutingConfigurator.kt

@@ -2,7 +2,8 @@ package dev.inmo.micro_utils.ktor.server.configurators
 
 import dev.inmo.micro_utils.ktor.server.configurators.ApplicationRoutingConfigurator.Element
 import io.ktor.server.application.*
-import io.ktor.server.routing.*
+import io.ktor.server.routing.Route
+import io.ktor.server.routing.Routing
 import kotlinx.serialization.Contextual
 import kotlinx.serialization.Serializable
 
@@ -18,7 +19,9 @@ class ApplicationRoutingConfigurator(
     }
 
     override fun Application.configure() {
-        routing {
+        pluginOrNull(Routing) ?.apply {
+            rootInstaller.apply { invoke() }
+        } ?: install(Routing) {
             rootInstaller.apply { invoke() }
         }
     }

ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/server/configurators/KtorApplicationConfigurator.kt

@@ -23,7 +23,9 @@ interface KtorApplicationConfigurator {
         }
 
         override fun Application.configure() {
-            routing {
+            pluginOrNull(io.ktor.server.routing.Routing) ?.apply {
+                rootInstaller.apply { invoke() }
+            } ?: install(io.ktor.server.routing.Routing) {
                 rootInstaller.apply { invoke() }
             }
         }

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullCRUDCacheRepo.kt

@@ -1,113 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.full.direct
-
-import dev.inmo.micro_utils.common.*
-import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
-import dev.inmo.micro_utils.coroutines.withReadAcquire
-import dev.inmo.micro_utils.coroutines.withWriteLock
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.repos.*
-import dev.inmo.micro_utils.repos.cache.*
-import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
-import dev.inmo.micro_utils.repos.cache.util.actualizeAll
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-open class DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
-    protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
-    protected open val kvCache: KeyValueRepo<IdType, ObjectType>,
-    protected val locker: SmartRWLocker = SmartRWLocker(),
-    protected open val idGetter: (ObjectType) -> IdType
-) : ReadCRUDRepo<ObjectType, IdType>, DirectFullCacheRepo {
-    protected open suspend fun actualizeAll() {
-        kvCache.actualizeAll(parentRepo, locker = locker)
-    }
-
-    override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = locker.withReadAcquire {
-        kvCache.values(pagination)
-    }
-
-    override suspend fun getIdsByPagination(pagination: Pagination): PaginationResult<IdType> = locker.withReadAcquire {
-        kvCache.keys(pagination)
-    }
-
-    override suspend fun count(): Long = locker.withReadAcquire {
-        kvCache.count()
-    }
-
-    override suspend fun contains(id: IdType): Boolean = locker.withReadAcquire {
-        kvCache.contains(id)
-    }
-
-    override suspend fun getAll(): Map<IdType, ObjectType> = locker.withReadAcquire {
-        kvCache.getAll()
-    }
-
-    override suspend fun getById(id: IdType): ObjectType? = locker.withReadAcquire {
-        kvCache.get(id)
-    }
-
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
-}
-
-fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.directlyCached(
-    kvCache: KeyValueRepo<IdType, ObjectType>,
-    locker: SmartRWLocker = SmartRWLocker(),
-    idGetter: (ObjectType) -> IdType
-) = DirectFullReadCRUDCacheRepo(this, kvCache, locker, idGetter)
-
-open class DirectFullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
-    override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
-    kvCache: KeyValueRepo<IdType, ObjectType>,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
-    skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
-    idGetter: (ObjectType) -> IdType
-) : DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
-    parentRepo,
-    kvCache,
-    locker,
-    idGetter
-),
-    WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
-        parentRepo,
-        kvCache,
-        scope,
-        locker,
-        idGetter
-    ),
-    CRUDRepo<ObjectType, IdType, InputValueType> {
-    init {
-        if (!skipStartInvalidate) {
-            scope.launchSafelyWithoutExceptions {
-                if (locker.writeMutex.isLocked) {
-                    initialInvalidate()
-                } else {
-                    invalidate()
-                }
-            }
-        }
-    }
-
-    protected open suspend fun initialInvalidate() {
-        try {
-            kvCache.actualizeAll(parentRepo, locker = null)
-        } finally {
-            locker.unlockWrite()
-        }
-    }
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
-}
-
-fun <ObjectType, IdType, InputType> CRUDRepo<ObjectType, IdType, InputType>.directFullyCached(
-    kvCache: KeyValueRepo<IdType, ObjectType> = MapKeyValueRepo(),
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
-    skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(),
-    idGetter: (ObjectType) -> IdType
-) = DirectFullCRUDCacheRepo(this, kvCache, scope, skipStartInvalidate, locker, idGetter)

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullCacheRepo.kt

@@ -1,13 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.full.direct
-
-import dev.inmo.micro_utils.repos.cache.full.FullCacheRepo
-
-/**
- * Repos-inheritors MUST realize their methods via next logic:
- *
- * * Reloading of data in cache must be reactive (e.g. via Flow) or direct mutation methods usage (override set and
- * mutate cache inside, for example)
- * * All reading methods must take data from cache via synchronization with [dev.inmo.micro_utils.coroutines.SmartRWLocker]
- */
-interface DirectFullCacheRepo : FullCacheRepo {
-}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullKeyValueCacheRepo.kt

@@ -1,177 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.full.direct
-
-import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
-import dev.inmo.micro_utils.coroutines.withReadAcquire
-import dev.inmo.micro_utils.coroutines.withWriteLock
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.repos.*
-import dev.inmo.micro_utils.repos.cache.full.FullKeyValueCacheRepo
-import dev.inmo.micro_utils.repos.cache.full.FullReadKeyValueCacheRepo
-import dev.inmo.micro_utils.repos.cache.full.FullWriteKeyValueCacheRepo
-import dev.inmo.micro_utils.repos.cache.util.actualizeAll
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
-
-open class DirectFullReadKeyValueCacheRepo<Key, Value>(
-    protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, Value>,
-    protected val locker: SmartRWLocker = SmartRWLocker()
-) : DirectFullCacheRepo, ReadKeyValueRepo<Key, Value> {
-    protected open suspend fun actualizeAll() {
-        kvCache.actualizeAll(parentRepo, locker)
-    }
-
-    override suspend fun get(k: Key): Value? = locker.withReadAcquire {
-        kvCache.get(k)
-    }
-
-    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = locker.withReadAcquire {
-        kvCache.values(pagination, reversed)
-    }
-
-    override suspend fun count(): Long = locker.withReadAcquire {
-        kvCache.count()
-    }
-
-    override suspend fun contains(key: Key): Boolean = locker.withReadAcquire {
-        kvCache.contains(key)
-    }
-
-    override suspend fun getAll(): Map<Key, Value> = locker.withReadAcquire {
-        kvCache.getAll()
-    }
-
-    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = locker.withReadAcquire {
-        kvCache.keys(pagination, reversed)
-    }
-
-    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = locker.withReadAcquire {
-        kvCache.keys(v, pagination, reversed)
-    }
-
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
-}
-
-fun <Key, Value> ReadKeyValueRepo<Key, Value>.directlyCached(
-    kvCache: KeyValueRepo<Key, Value>,
-    locker: SmartRWLocker = SmartRWLocker()
-) = DirectFullReadKeyValueCacheRepo(this, kvCache, locker)
-
-open class DirectFullWriteKeyValueCacheRepo<Key, Value>(
-    protected open val parentRepo: WriteKeyValueRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, Value>,
-    protected val locker: SmartRWLocker = SmartRWLocker(),
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
-) : DirectFullCacheRepo, WriteKeyValueRepo<Key, Value> by parentRepo {
-    override val onNewValue: Flow<Pair<Key, Value>>
-        get() = parentRepo.onNewValue
-    override val onValueRemoved: Flow<Key>
-        get() = parentRepo.onValueRemoved
-
-    protected val onNewJob = parentRepo.onNewValue.onEach {
-        locker.withWriteLock {
-            kvCache.set(it.first, it.second)
-        }
-    }.launchIn(scope)
-    protected val onRemoveJob = parentRepo.onValueRemoved.onEach {
-        locker.withWriteLock {
-            kvCache.unset(it)
-        }
-    }.launchIn(scope)
-
-    override suspend fun invalidate() {
-        locker.withWriteLock {
-            kvCache.clear()
-        }
-    }
-
-    override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset)
-}
-
-fun <Key, Value> WriteKeyValueRepo<Key, Value>.directlyCached(
-    kvCache: KeyValueRepo<Key, Value>,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-) = DirectFullWriteKeyValueCacheRepo(this, kvCache, scope = scope)
-
-open class DirectFullKeyValueCacheRepo<Key, Value>(
-    override val parentRepo: KeyValueRepo<Key, Value>,
-    kvCache: KeyValueRepo<Key, Value>,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
-    skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
-) : DirectFullCacheRepo,
-    KeyValueRepo<Key, Value> ,
-    WriteKeyValueRepo<Key, Value> by DirectFullWriteKeyValueCacheRepo(
-        parentRepo,
-        kvCache,
-        locker,
-        scope
-    ),
-    DirectFullReadKeyValueCacheRepo<Key, Value>(parentRepo, kvCache, locker) {
-    init {
-        if (!skipStartInvalidate) {
-            scope.launchSafelyWithoutExceptions {
-                if (locker.writeMutex.isLocked) {
-                    initialInvalidate()
-                } else {
-                    invalidate()
-                }
-            }
-        }
-    }
-
-
-    protected open suspend fun initialInvalidate() {
-        try {
-            kvCache.actualizeAll(parentRepo, locker = null)
-        } finally {
-            locker.unlockWrite()
-        }
-    }
-    override suspend fun invalidate() {
-        kvCache.actualizeAll(parentRepo, locker)
-    }
-
-    override suspend fun clear() {
-        parentRepo.clear()
-        kvCache.clear()
-    }
-
-    override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset)
-
-    override suspend fun set(toSet: Map<Key, Value>) {
-        locker.withWriteLock {
-            parentRepo.set(toSet)
-            kvCache.set(
-                toSet.filter {
-                    parentRepo.contains(it.key)
-                }
-            )
-        }
-    }
-
-    override suspend fun unset(toUnset: List<Key>) {
-        locker.withWriteLock {
-            parentRepo.unset(toUnset)
-            kvCache.unset(
-                toUnset.filter {
-                    !parentRepo.contains(it)
-                }
-            )
-        }
-    }
-}
-
-fun <Key, Value> KeyValueRepo<Key, Value>.directlyFullyCached(
-    kvCache: KeyValueRepo<Key, Value> = MapKeyValueRepo(),
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
-    skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker()
-) = DirectFullKeyValueCacheRepo(this, kvCache, scope, skipStartInvalidate, locker)

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullKeyValuesCacheRepo.kt

@@ -1,243 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.full.direct
-
-import dev.inmo.micro_utils.common.*
-import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
-import dev.inmo.micro_utils.coroutines.withReadAcquire
-import dev.inmo.micro_utils.coroutines.withWriteLock
-import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.pagination.utils.*
-import dev.inmo.micro_utils.repos.*
-import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
-import dev.inmo.micro_utils.repos.cache.util.actualizeAll
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.*
-
-open class DirectFullReadKeyValuesCacheRepo<Key,Value>(
-    protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, List<Value>>,
-    protected val locker: SmartRWLocker = SmartRWLocker(),
-) : ReadKeyValuesRepo<Key, Value>, DirectFullCacheRepo {
-    protected open suspend fun actualizeKey(k: Key) {
-        kvCache.actualizeAll(locker = locker, clearMode = ActualizeAllClearMode.Never) {
-            mapOf(k to parentRepo.getAll(k))
-        }
-    }
-
-    protected open suspend fun actualizeAll() {
-        kvCache.actualizeAll(parentRepo, locker = locker)
-    }
-
-    override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
-        return locker.withReadAcquire {
-            kvCache.get(k) ?.paginate(
-                pagination.let { if (reversed) it.reverse(count(k)) else it }
-            ) ?.let {
-                if (reversed) it.copy(results = it.results.reversed()) else it
-            }
-        } ?: emptyPaginationResult()
-    }
-
-    override suspend fun getAll(k: Key, reversed: Boolean): List<Value> {
-        return locker.withReadAcquire {
-            kvCache.get(k) ?.optionallyReverse(reversed)
-        } ?: emptyList()
-    }
-
-    override suspend fun getAll(reverseLists: Boolean): Map<Key, List<Value>> {
-        return locker.withReadAcquire {
-            kvCache.getAll().takeIf { it.isNotEmpty() } ?.let {
-                if (reverseLists) {
-                    it.mapValues { it.value.reversed() }
-                } else {
-                    it
-                }
-            }
-        } ?: emptyMap()
-    }
-    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> {
-        return locker.withReadAcquire {
-            kvCache.keys(pagination, reversed).takeIf { it.results.isNotEmpty() }
-        } ?: emptyPaginationResult()
-    }
-
-    override suspend fun count(): Long = locker.withReadAcquire { kvCache.count() }
-
-    override suspend fun count(k: Key): Long = locker.withReadAcquire { kvCache.get(k) ?.size } ?.toLong() ?: 0L
-
-    override suspend fun contains(k: Key, v: Value): Boolean = locker.withReadAcquire { kvCache.get(k) ?.contains(v) } == true
-
-    override suspend fun contains(k: Key): Boolean = locker.withReadAcquire { kvCache.contains(k) }
-
-    override suspend fun keys(
-        v: Value,
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<Key> {
-        val keys = locker.withReadAcquire {
-            getAllWithNextPaging { kvCache.keys(it) }.filter { kvCache.get(it)?.contains(v) == true }
-                .optionallyReverse(reversed)
-        }
-        val result = if (keys.isNotEmpty()) {
-            keys.paginate(pagination.optionallyReverse(keys.size, reversed)).takeIf { it.results.isNotEmpty() }
-        } else {
-            null
-        }
-
-        return result ?: emptyPaginationResult()
-    }
-
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
-}
-
-fun <Key, Value> ReadKeyValuesRepo<Key, Value>.directlyCached(
-    kvCache: KeyValueRepo<Key, List<Value>>,
-    locker: SmartRWLocker = SmartRWLocker(),
-) = DirectFullReadKeyValuesCacheRepo(this, kvCache, locker)
-
-open class DirectFullWriteKeyValuesCacheRepo<Key,Value>(
-    parentRepo: WriteKeyValuesRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, List<Value>>,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
-    protected val locker: SmartRWLocker = SmartRWLocker(),
-) : WriteKeyValuesRepo<Key, Value> by parentRepo, DirectFullCacheRepo {
-    protected val onNewJob = parentRepo.onNewValue.onEach {
-        locker.withWriteLock {
-            kvCache.set(
-                it.first,
-                kvCache.get(it.first) ?.plus(it.second) ?: listOf(it.second)
-            )
-        }
-    }.launchIn(scope)
-    protected val onRemoveJob = parentRepo.onValueRemoved.onEach {
-        locker.withWriteLock {
-            kvCache.set(
-                it.first,
-                kvCache.get(it.first)?.minus(it.second) ?: return@onEach
-            )
-        }
-    }.launchIn(scope)
-
-    override suspend fun invalidate() {
-        locker.withWriteLock {
-            kvCache.clear()
-        }
-    }
-}
-
-fun <Key, Value> WriteKeyValuesRepo<Key, Value>.directlyCached(
-    kvCache: KeyValueRepo<Key, List<Value>>,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
-    locker: SmartRWLocker = SmartRWLocker(),
-) = DirectFullWriteKeyValuesCacheRepo(this, kvCache, scope, locker)
-
-open class DirectFullKeyValuesCacheRepo<Key,Value>(
-    override val parentRepo: KeyValuesRepo<Key, Value>,
-    kvCache: KeyValueRepo<Key, List<Value>>,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
-    skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
-) : KeyValuesRepo<Key, Value>,
-    DirectFullReadKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, locker),
-    WriteKeyValuesRepo<Key, Value> by parentRepo {
-    init {
-        if (!skipStartInvalidate) {
-            scope.launchSafelyWithoutExceptions {
-                if (locker.writeMutex.isLocked) {
-                    initialInvalidate()
-                } else {
-                    invalidate()
-                }
-            }
-        }
-    }
-
-    override suspend fun clearWithValue(v: Value) {
-        doAllWithCurrentPaging {
-            keys(v, it).also {
-                remove(it.results.associateWith { listOf(v) })
-            }
-        }
-    }
-
-    protected open suspend fun initialInvalidate() {
-        try {
-            kvCache.actualizeAll(parentRepo, locker = null)
-        } finally {
-            locker.unlockWrite()
-        }
-    }
-    override suspend fun invalidate() {
-        kvCache.actualizeAll(parentRepo, locker = locker)
-    }
-
-    override suspend fun set(toSet: Map<Key, List<Value>>) {
-        locker.withWriteLock {
-            parentRepo.set(toSet)
-            kvCache.set(
-                toSet.filter {
-                    parentRepo.contains(it.key)
-                }
-            )
-        }
-    }
-
-    override suspend fun add(toAdd: Map<Key, List<Value>>) {
-        locker.withWriteLock {
-            parentRepo.add(toAdd)
-            toAdd.forEach {
-                val filtered = it.value.filter { v ->
-                    parentRepo.contains(it.key, v)
-                }.ifEmpty {
-                    return@forEach
-                }
-                kvCache.set(
-                    it.key,
-                    (kvCache.get(it.key) ?: emptyList()) + filtered
-                )
-            }
-        }
-    }
-
-    override suspend fun remove(toRemove: Map<Key, List<Value>>) {
-        locker.withWriteLock {
-            parentRepo.remove(toRemove)
-            toRemove.forEach {
-                val filtered = it.value.filter { v ->
-                    !parentRepo.contains(it.key, v)
-                }.ifEmpty {
-                    return@forEach
-                }.toSet()
-                val resultList = (kvCache.get(it.key) ?: emptyList()) - filtered
-                if (resultList.isEmpty()) {
-                    kvCache.unset(it.key)
-                } else {
-                    kvCache.set(
-                        it.key,
-                        resultList
-                    )
-                }
-            }
-        }
-    }
-
-    override suspend fun clear(k: Key) {
-        locker.withWriteLock {
-            parentRepo.clear(k)
-            if (parentRepo.contains(k)) {
-                return@withWriteLock
-            }
-            kvCache.unset(k)
-        }
-    }
-}
-
-fun <Key, Value> KeyValuesRepo<Key, Value>.directlyFullyCached(
-    kvCache: KeyValueRepo<Key, List<Value>> = MapKeyValueRepo(),
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
-    skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(),
-) = DirectFullKeyValuesCacheRepo(this, kvCache, scope, skipStartInvalidate, locker)

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key/value/KtorWriteKeyValueRepoClient.kt

@@ -8,7 +8,7 @@ import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import io.ktor.client.HttpClient
 import io.ktor.client.request.post
 import io.ktor.http.*
-import io.ktor.utils.io.InternalAPI
+import io.ktor.util.InternalAPI
 import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
 import kotlinx.coroutines.flow.Flow

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key/values/KtorWriteKeyValuesRepoClient.kt

@@ -8,7 +8,7 @@ import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import io.ktor.client.HttpClient
 import io.ktor.client.request.post
 import io.ktor.http.*
-import io.ktor.utils.io.InternalAPI
+import io.ktor.util.InternalAPI
 import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
 import kotlinx.coroutines.flow.Flow

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

@@ -25,7 +25,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 
 class KtorCRUDRepoTests : CommonCRUDRepoTests() {
-    private var engine: EmbeddedServer<*, *>? = null
+    private var engine: ApplicationEngine? = null
 
     @BeforeTest
     fun beforeTest() {

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

@@ -27,7 +27,7 @@ import kotlinx.serialization.json.Json
 import kotlin.test.*
 
 class KtorKeyValueRepoTests : CommonKeyValueRepoTests() {
-    private var engine: EmbeddedServer<*, *>? = null
+    private var engine: ApplicationEngine? = null
 
     override val repoCreator: suspend () -> KeyValueRepo<String, String> = {
         KtorKeyValueRepoClient(
@@ -77,7 +77,7 @@ class KtorKeyValueRepoTests : CommonKeyValueRepoTests() {
                         repo,
                         Int.serializer(),
                         ComplexData.serializer(),
-                        Json
+                        Json {}
                     )
                 }
             }.start(false)

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

@@ -23,7 +23,7 @@ import kotlinx.serialization.json.Json
 import kotlin.test.*
 
 class KtorKeyValuesRepoTests : CommonKeyValuesRepoTests() {
-    private var engine: EmbeddedServer<*, *>? = null
+    private var engine: ApplicationEngine? = null
     override val testSequencesSize: Int
         get() = 100
 

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

@@ -13,7 +13,7 @@ import io.ktor.server.websocket.*
 import kotlinx.serialization.json.Json
 
 object KtorRepoTestsHelper {
-    fun beforeTest(routingConfigurator: Routing.() -> Unit): EmbeddedServer<CIOApplicationEngine, CIOApplicationEngine.Configuration> {
+    fun beforeTest(routingConfigurator: Routing.() -> Unit): ApplicationEngine {
         return embeddedServer(
             CIO,
             23456,
@@ -28,7 +28,7 @@ object KtorRepoTestsHelper {
             routing(routingConfigurator)
         }.start(false)
     }
-    fun afterTest(engine: EmbeddedServer<*, *>) {
+    fun afterTest(engine: ApplicationEngine) {
         engine.stop()
     }
     fun client(): HttpClient = HttpClient {

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key/value/KtorReadKeyValueRepoRoutes.kt

@@ -16,7 +16,7 @@ import io.ktor.server.application.call
 import io.ktor.server.response.respond
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.get
-import io.ktor.utils.io.InternalAPI
+import io.ktor.util.InternalAPI
 import io.ktor.util.reflect.typeInfo
 import kotlinx.serialization.*
 

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key/values/KtorReadKeyValuesRepoRoutes.kt

@@ -14,7 +14,7 @@ import io.ktor.server.application.call
 import io.ktor.server.response.respond
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.get
-import io.ktor.utils.io.InternalAPI
+import io.ktor.util.InternalAPI
 import io.ktor.util.reflect.typeInfo
 import kotlinx.serialization.*
 

serialization/typed_serializer/src/commonTest/kotlin/dev/inmo/micro_utils/serialization/typed_serializer/TypedSerializerTests.kt

@@ -11,7 +11,7 @@ class TypedSerializerTests {
     interface Example {
         val number: Number
     }
-    val serialFormat = Json
+    val serialFormat = Json {  }
 
     @Serializable
     data class Example1(override val number: Long) : Example