remove previous deprecations

This reverts commit b938b21395.

CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.18.0
+
+**ALL PREVIOUSLY DEPRECATED FUNCTIONALITY HAVE BEEN REMOVED**
+
+* `Versions`:
+    * `Android Fragments`: `1.5.6` -> `1.5.7`
+* `Ktor`:
+    * `Server`:
+        * Now it is possible to take query parameters as list
+* `Repos`:
+    * `Common`:
+        * New `WriteKeyValuesRepo.removeWithValue`
+    * `Cache`:
+        * Rename full caching factories functions to `fullyCached`
+
+## 0.17.8
+
+* `Versions`:
+    * `Ktor`: `2.2.4` -> `2.3.0`
+
+## 0.17.7
+
+* `Versions`:
+    * `Android CoreKtx`: `1.9.0` -> `1.10.0`
+* `Startup`:
+    * Add support of `linuxX64` and `mingwX64` platforms
+
 ## 0.17.6
 
 * `Versions`:

coroutines/compose/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/compose/FlowToMutableState.kt

@@ -1,21 +0,0 @@
-package dev.inmo.micro_utils.coroutines.compose
-
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.mutableStateOf
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.StateFlow
-
-@Deprecated("Duplicated functionality", ReplaceWith("asMutableComposeState(initial, scope)", "dev.inmo.micro_utils.coroutines.compose.asMutableComposeState"))
-fun <T> Flow<T>.toMutableState(
-    initial: T,
-    scope: CoroutineScope
-): MutableState<T> = asMutableComposeState(initial, scope)
-
-@Deprecated("Duplicated functionality", ReplaceWith("asMutableComposeState(scope)", "dev.inmo.micro_utils.coroutines.compose.asMutableComposeState"))
-@Suppress("NOTHING_TO_INLINE")
-inline fun <T> StateFlow<T>.toMutableState(
-    scope: CoroutineScope
-): MutableState<T> = asMutableComposeState(scope)
-

extensions.gradle

@@ -23,7 +23,7 @@ allprojects {
         mppProjectWithSerializationPresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerialization.gradle"
         mppProjectWithSerializationAndComposePresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerializationAndCompose.gradle"
         mppJavaProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJavaProject.gradle"
-        mppJsAndJavaProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJsAndJavaProject.gradle"
+        mppJvmJsLinuxMingwProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJvmJsLinuxMingwProject.gradle"
         mppAndroidProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppAndroidProject.gradle"
 
         defaultAndroidSettingsPresetPath = "${rootProject.projectDir.absolutePath}/defaultAndroidSettings.gradle"

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.17.6
-android_code_version=188
+version=0.18.0
+android_code_version=191

gradle/libs.versions.toml

@@ -13,7 +13,7 @@ jb-dokka = "1.8.10"
 korlibs = "3.4.0"
 uuid = "0.7.0"
 
-ktor = "2.2.4"
+ktor = "2.3.0"
 
 gh-release = "2.4.1"
 
@@ -21,22 +21,22 @@ koin = "3.4.0"
 
 okio = "3.3.0"
 
-ksp = "1.8.20-1.0.10"
+ksp = "1.8.20-1.0.11"
 kotlin-poet = "1.13.0"
 
-android-gradle = "7.3.1"
+android-gradle = "7.4.2"
 dexcount = "4.0.0"
 
-android-coreKtx = "1.9.0"
+android-coreKtx = "1.10.0"
 android-recyclerView = "1.3.0"
 android-appCompat = "1.6.1"
-android-fragment = "1.5.6"
+android-fragment = "1.5.7"
 android-espresso = "3.5.1"
 android-test = "1.1.5"
 
 android-props-minSdk = "21"
 android-props-compileSdk = "33"
-android-props-buildTools = "33.0.1"
+android-props-buildTools = "33.0.2"
 
 [libraries]
 

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

@@ -12,10 +12,22 @@ suspend fun ApplicationCall.getParameterOrSendError(
     }
 }
 
+suspend fun ApplicationCall.getParametersOrSendError(
+    field: String
+) = parameters.getAll(field).also {
+    if (it == null) {
+        respond(HttpStatusCode.BadRequest, "Request must contains $field")
+    }
+}
+
 fun ApplicationCall.getQueryParameter(
     field: String
 ) = request.queryParameters[field]
 
+fun ApplicationCall.getQueryParameters(
+    field: String
+) = request.queryParameters.getAll(field)
+
 suspend fun ApplicationCall.getQueryParameterOrSendError(
     field: String
 ) = getQueryParameter(field).also {
@@ -23,3 +35,11 @@ suspend fun ApplicationCall.getQueryParameterOrSendError(
         respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
     }
 }
+
+suspend fun ApplicationCall.getQueryParametersOrSendError(
+    field: String
+) = getQueryParameters(field).also {
+    if (it == null) {
+        respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
+    }
+}

mppJvmJsLinuxMingwProject.gradle

@@ -15,6 +15,8 @@ kotlin {
         browser()
         nodejs()
     }
+    linuxX64()
+    mingwX64()
 
     sourceSets {
         commonMain {

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:base"
+  ]
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/crud/AutoRecacheWriteCRUDRepo.kt

@@ -21,9 +21,9 @@ open class AutoRecacheWriteCRUDRepo<RegisteredObject, Id, InputObject>(
     protected val idGetter: (RegisteredObject) -> Id
 ) : WriteCRUDRepo<RegisteredObject, Id, InputObject>, FallbackCacheRepo {
     override val deletedObjectsIdsFlow: Flow<Id>
-        get() = (originalRepo.deletedObjectsIdsFlow + kvCache.onValueRemoved).distinctUntilChanged()
+        get() = (originalRepo.deletedObjectsIdsFlow).distinctUntilChanged()
     override val newObjectsFlow: Flow<RegisteredObject>
-        get() = (originalRepo.newObjectsFlow + kvCache.onNewValue.map { it.second }).distinctUntilChanged()
+        get() = (originalRepo.newObjectsFlow).distinctUntilChanged()
     override val updatedObjectsFlow: Flow<RegisteredObject>
         get() = originalRepo.updatedObjectsFlow
 

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalue/AutoRecacheWriteKeyValueRepo.kt

@@ -17,10 +17,10 @@ open class AutoRecacheWriteKeyValueRepo<Id, RegisteredObject>(
     protected val kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache()
 ) : WriteKeyValueRepo<Id, RegisteredObject>, FallbackCacheRepo {
     override val onValueRemoved: Flow<Id>
-        get() = (originalRepo.onValueRemoved + kvCache.onValueRemoved).distinctUntilChanged()
+        get() = (originalRepo.onValueRemoved).distinctUntilChanged()
 
     override val onNewValue: Flow<Pair<Id, RegisteredObject>>
-        get() = (originalRepo.onNewValue + kvCache.onNewValue).distinctUntilChanged()
+        get() = (originalRepo.onNewValue).distinctUntilChanged()
 
     private val onRemovingUpdatesListeningJob = originalRepo.onValueRemoved.subscribeSafelyWithoutExceptions(scope) {
         kvCache.unset(it)

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalues/AutoRecacheWriteKeyValuesRepo.kt

@@ -7,6 +7,7 @@ import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
 import dev.inmo.micro_utils.repos.WriteKeyValuesRepo
 import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
 import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
+import dev.inmo.micro_utils.repos.pagination.maxPagePagination
 import dev.inmo.micro_utils.repos.set
 import dev.inmo.micro_utils.repos.unset
 import kotlinx.coroutines.CoroutineScope
@@ -24,7 +25,7 @@ open class AutoRecacheWriteKeyValuesRepo<Id, RegisteredObject>(
     override val onNewValue: Flow<Pair<Id, RegisteredObject>>
         get() = originalRepo.onNewValue
     override val onDataCleared: Flow<Id>
-        get() = (originalRepo.onDataCleared + kvCache.onValueRemoved).distinctUntilChanged()
+        get() = (originalRepo.onDataCleared).distinctUntilChanged()
 
     private val onDataClearedListeningJob = originalRepo.onDataCleared.subscribeSafelyWithoutExceptions(scope) {
         kvCache.unset(it)
@@ -50,7 +51,7 @@ open class AutoRecacheWriteKeyValuesRepo<Id, RegisteredObject>(
 
     override suspend fun clearWithValue(v: RegisteredObject) {
         originalRepo.clearWithValue(v)
-        doForAllWithNextPaging(FirstPagePagination(kvCache.count().takeIf { it < Int.MAX_VALUE } ?.toInt() ?: Int.MAX_VALUE)) {
+        doForAllWithNextPaging(kvCache.maxPagePagination()) {
             kvCache.keys(it).also {
                 it.results.forEach { id ->
                     kvCache.get(id) ?.takeIf { it.contains(v) } ?.let {
@@ -73,6 +74,19 @@ open class AutoRecacheWriteKeyValuesRepo<Id, RegisteredObject>(
         }
     }
 
+    override suspend fun removeWithValue(v: RegisteredObject) {
+        originalRepo.removeWithValue(v)
+        doForAllWithNextPaging(kvCache.maxPagePagination()) {
+            kvCache.keys(it).also {
+                it.results.forEach { id ->
+                    kvCache.get(id) ?.takeIf { it.contains(v) } ?.let {
+                        kvCache.set(id, it - v)
+                    }
+                }
+            }
+        }
+    }
+
     override suspend fun add(toAdd: Map<Id, List<RegisteredObject>>) {
         originalRepo.add(toAdd)
         toAdd.forEach { (k, v) ->

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

@@ -102,8 +102,15 @@ open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
     }
 }
 
+fun <ObjectType, IdType, InputType> CRUDRepo<ObjectType, IdType, InputType>.fullyCached(
+    kvCache: FullKVCache<IdType, ObjectType> = FullKVCache(),
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    idGetter: (ObjectType) -> IdType
+) = FullCRUDCacheRepo(this, kvCache, scope, idGetter)
+
+@Deprecated("Renamed", ReplaceWith("this.fullyCached(kvCache, scope, idGetter)", "dev.inmo.micro_utils.repos.cache.full.fullyCached"))
 fun <ObjectType, IdType, InputType> CRUDRepo<ObjectType, IdType, InputType>.cached(
     kvCache: FullKVCache<IdType, ObjectType>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     idGetter: (ObjectType) -> IdType
-) = FullCRUDCacheRepo(this, kvCache, scope, idGetter)
+) = fullyCached(kvCache, scope, idGetter)

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

@@ -117,7 +117,13 @@ open class FullKeyValueCacheRepo<Key,Value>(
     }
 }
 
+fun <Key, Value> KeyValueRepo<Key, Value>.fullyCached(
+    kvCache: FullKVCache<Key, Value> = FullKVCache(),
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) = FullKeyValueCacheRepo(this, kvCache, scope)
+
+@Deprecated("Renamed", ReplaceWith("this.fullyCached(kvCache, scope)", "dev.inmo.micro_utils.repos.cache.full.fullyCached"))
 fun <Key, Value> KeyValueRepo<Key, Value>.cached(
     kvCache: FullKVCache<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-) = FullKeyValueCacheRepo(this, kvCache, scope)
+) = fullyCached(kvCache, scope)

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

@@ -157,8 +157,18 @@ open class FullKeyValuesCacheRepo<Key,Value>(
     override suspend fun invalidate() {
         kvCache.actualizeAll(parentRepo)
     }
+
+    override suspend fun removeWithValue(v: Value) {
+        super<FullWriteKeyValuesCacheRepo>.removeWithValue(v)
+    }
 }
 
+fun <Key, Value> KeyValuesRepo<Key, Value>.fullyCached(
+    kvCache: FullKVCache<Key, List<Value>> = FullKVCache(),
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) = FullKeyValuesCacheRepo(this, kvCache, scope)
+
+@Deprecated("Renamed", ReplaceWith("this.fullyCached(kvCache, scope)", "dev.inmo.micro_utils.repos.cache.full.fullyCached"))
 fun <Key, Value> KeyValuesRepo<Key, Value>.caching(
     kvCache: FullKVCache<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)

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

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.repos
 
 import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import kotlinx.coroutines.flow.Flow
 
@@ -44,9 +45,23 @@ interface WriteKeyValuesRepo<Key, Value> : Repo {
 
     suspend fun add(toAdd: Map<Key, List<Value>>)
 
+    /**
+     * Removes [Value]s by passed [Key]s without full clear of all data by [Key]
+     */
     suspend fun remove(toRemove: Map<Key, List<Value>>)
 
+    /**
+     * Removes [v] without full clear of all data by [Key]s with [v]
+     */
+    suspend fun removeWithValue(v: Value)
+
+    /**
+     * Fully clear all data by [k]
+     */
     suspend fun clear(k: Key)
+    /**
+     * Clear [v] **with** full clear of all data by [Key]s with [v]
+     */
     suspend fun clearWithValue(v: Value)
 
     suspend fun set(toSet: Map<Key, List<Value>>) {
@@ -100,6 +115,21 @@ interface KeyValuesRepo<Key, Value> : ReadKeyValuesRepo<Key, Value>, WriteKeyVal
             keysResult.currentPageIfNotEmpty()
         }
     }
+    suspend override fun removeWithValue(v: Value) {
+        val toRemove = mutableMapOf<Key, List<Value>>()
+
+        doForAllWithNextPaging {
+            keys(it).also {
+                it.results.forEach {
+                    if (contains(it, v)) {
+                        toRemove[it] = listOf(v)
+                    }
+                }
+            }
+        }
+
+        remove(toRemove)
+    }
 }
 typealias OneToManyKeyValueRepo<Key,Value> = KeyValuesRepo<Key, Value>
 

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/OneToManyKeyValueMappers.kt

@@ -97,6 +97,8 @@ open class MapperWriteKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>(
         }.toMap()
     )
 
+    override suspend fun removeWithValue(v: FromValue) = to.removeWithValue(v.toOutValue())
+
     override suspend fun set(toSet: Map<FromKey, List<FromValue>>) {
         to.set(
             toSet.map { (k, vs) -> k.toOutKey() to vs.map { v -> v.toOutValue() } }.toMap()

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/transforms/kvs/KeyValuesFromKeyValueRepo.kt

@@ -4,6 +4,7 @@ import dev.inmo.micro_utils.pagination.FirstPagePagination
 import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
 import dev.inmo.micro_utils.repos.KeyValueRepo
 import dev.inmo.micro_utils.repos.KeyValuesRepo
+import dev.inmo.micro_utils.repos.set
 import dev.inmo.micro_utils.repos.unset
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -60,6 +61,24 @@ open class KeyValuesFromKeyValueRepo<Key, Value, ValuesIterable : Iterable<Value
         }
     }
 
+    override suspend fun removeWithValue(v: Value) {
+        val toRemove = mutableMapOf<Key, List<Value>>()
+
+        doForAllWithNextPaging {
+            original.keys(it).also {
+                it.results.forEach {
+                    val data = original.get(it) ?: return@forEach
+
+                    if (v in data) {
+                        toRemove[it] = listOf(v)
+                    }
+                }
+            }
+        }
+
+        remove(toRemove)
+    }
+
     override suspend fun add(toAdd: Map<Key, List<Value>>) {
         original.set(
             toAdd.mapNotNull { (k, adding) ->

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/onetomany/OneToManyAndroidRepo.kt

@@ -6,6 +6,7 @@ import dev.inmo.micro_utils.common.mapNotNullA
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.reverse
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.crud.asId
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
@@ -260,6 +261,19 @@ class OneToManyAndroidRepo<Key, Value>(
             _onValueRemoved.emit(k to v)
         }
     }
+
+    override suspend fun removeWithValue(v: Value) {
+        helper.blockingWritableTransaction {
+            val keys = select(tableName, idColumnArray, "$valueColumnName=?", arrayOf(v.valueAsString())).map {
+                it.asId.keyFromString()
+            }
+            keys.filter {
+                delete(tableName, "$idColumnName=? AND $valueColumnName=?", arrayOf(it.keyAsString(), v.valueAsString())) > 0
+            }
+        }.forEach { k ->
+            _onValueRemoved.emit(k to v)
+        }
+    }
 }
 
 fun <Key, Value> OneToManyAndroidRepo(

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

@@ -5,6 +5,7 @@ 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
 
 typealias ExposedOneToManyKeyValueRepo1<Key, Value> = ExposedKeyValuesRepo<Key, Value>
@@ -66,9 +67,36 @@ open class ExposedKeyValuesRepo<Key, Value>(
         }
     }
 
+    override suspend fun removeWithValue(v: Value) {
+        transaction(database) {
+            val keys = select { selectByValue(v) }.map { it.asKey }
+            deleteWhere { SqlExpressionBuilder.selectByValue(v) }
+            keys
+        }.forEach {
+            _onValueRemoved.emit(it to v)
+        }
+    }
+
     override suspend fun clear(k: Key) {
         transaction(database) {
             deleteWhere { keyColumn.eq(k) }
         }.also { _onDataCleared.emit(k) }
     }
+
+    override suspend fun clearWithValue(v: Value) {
+        transaction(database) {
+            val toClear = select { selectByValue(v) }
+                .asSequence()
+                .map { it.asKey to it.asObject }
+                .groupBy { it.first }
+                .mapValues { it.value.map { it.second } }
+            deleteWhere { keyColumn.inList(toClear.keys) }
+            toClear
+        }.forEach {
+            it.value.forEach { v ->
+                _onValueRemoved.emit(it.key to v)
+            }
+            _onDataCleared.emit(it.key)
+        }
+    }
 }

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapKeyValuesRepo.kt

@@ -87,13 +87,27 @@ class MapWriteKeyValuesRepo<Key, Value>(
         }
     }
 
+    override suspend fun removeWithValue(v: Value) {
+        map.forEach { (k, values) ->
+            if (values.remove(v)) {
+                _onValueRemoved.emit(k to v)
+            }
+        }
+    }
+
     override suspend fun clear(k: Key) {
         map.remove(k) ?.also { _onDataCleared.emit(k) }
     }
 
     override suspend fun clearWithValue(v: Value) {
-        map.forEach { (k, values) ->
-            if (values.remove(v)) _onValueRemoved.emit(k to v)
+        map.filter { (_, values) ->
+            values.contains(v)
+        }.forEach {
+            map.remove(it.key) ?.onEach { v ->
+                _onValueRemoved.emit(it.key to v)
+            } ?.also { _ ->
+                _onDataCleared.emit(it.key)
+            }
         }
     }
 }

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

@@ -47,6 +47,17 @@ class KtorWriteKeyValuesRepoClient<Key : Any, Value : Any>(
         }.throwOnUnsuccess { "Unable to remove $toRemove" }
     }
 
+    @OptIn(InternalAPI::class)
+    override suspend fun removeWithValue(v: Value) {
+        httpClient.post(
+            buildStandardUrl(baseUrl, removeWithValueRoute)
+        ) {
+            body = v
+            bodyType = valueTypeInfo
+            contentType(contentType)
+        }.throwOnUnsuccess { "Unable to remove $v" }
+    }
+
     @OptIn(InternalAPI::class)
     override suspend fun clear(k: Key) {
         httpClient.post(

repos/ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/common/one_to_many/OneToManyRoutes.kt

@@ -13,6 +13,7 @@ const val onDataClearedRoute = "onDataCleared"
 
 const val addRoute = "add"
 const val removeRoute = "remove"
+const val removeWithValueRoute = "removeWithValue"
 const val clearRoute = "clear"
 const val clearWithValueRoute = "clearWithValue"
 const val setRoute = "set"

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

@@ -46,6 +46,11 @@ inline fun <reified Key : Any, reified Value : Any> Route.configureWriteKeyValue
         call.respond(HttpStatusCode.OK)
     }
 
+    post(removeWithValueRoute) {
+        originalRepo.removeWithValue(call.receive())
+        call.respond(HttpStatusCode.OK)
+    }
+
     post(clearRoute) {
         originalRepo.clear(call.receive())
         call.respond(HttpStatusCode.OK)

startup/launcher/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "application"
 }
 
-apply from: "$mppJsAndJavaProjectPresetPath"
+apply from: "$mppJvmJsLinuxMingwProjectPresetPath"
 
 kotlin {
     sourceSets {

startup/launcher/src/commonMain/kotlin/Start.kt

@@ -1,17 +0,0 @@
-package dev.inmo.micro_utils.startup.launcher
-
-import dev.inmo.micro_utils.startup.launcher.StartLauncherPlugin.setupDI
-import kotlinx.serialization.json.JsonObject
-import org.koin.core.KoinApplication
-
-/**
- * Will create [KoinApplication], init, load modules using [StartLauncherPlugin] and start plugins using the same base
- * plugin
- *
- * @param rawConfig It is expected that this [JsonObject] will contain serialized [Config] ([StartLauncherPlugin] will
- * deserialize it in its [StartLauncherPlugin.setupDI]
- */
-@Deprecated("Fully replaced with StartLauncherPlugin#start", ReplaceWith("StartLauncherPlugin.start(rawConfig)", "dev.inmo.micro_utils.startup.launcher.StartLauncherPlugin"))
-suspend fun start(rawConfig: JsonObject) {
-    StartLauncherPlugin.start(rawConfig)
-}

startup/launcher/src/jsMain/kotlin/PluginsStarter.kt

@@ -1,25 +0,0 @@
-package dev.inmo.micro_utils.startup.launcher
-
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.i
-import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.jsonObject
-
-@Deprecated("Useless due to including of the same functionality in StrtLauncherPlugin")
-object PluginsStarter {
-    init {
-        KSLog.default = KSLog("Launcher")
-    }
-
-    /**
-     * It is expected that you have registered all the [dev.inmo.micro_utils.startup.plugin.StartPlugin]s of your JS
-     * app inside of [dev.inmo.micro_utils.startup.plugin.StartPluginSerializer] using its
-     * [dev.inmo.micro_utils.startup.plugin.StartPluginSerializer.registerPlugin] method
-     */
-    suspend fun startPlugins(json: JsonObject) = StartLauncherPlugin.start(json)
-    /**
-     * Will convert [config] to [JsonObject] with auto registration of [dev.inmo.micro_utils.startup.plugin.StartPlugin]s
-     * in [dev.inmo.micro_utils.startup.plugin.StartPluginSerializer]
-     */
-    suspend fun startPlugins(config: Config) = StartLauncherPlugin.start(config)
-}

startup/plugin/build.gradle

@@ -3,7 +3,7 @@ plugins {
     id "org.jetbrains.kotlin.plugin.serialization"
 }
 
-apply from: "$mppJsAndJavaProjectPresetPath"
+apply from: "$mppJvmJsLinuxMingwProjectPresetPath"
 
 kotlin {
     sourceSets {
@@ -21,5 +21,15 @@ kotlin {
                 api libs.uuid
             }
         }
+        linuxX64Main {
+            dependencies {
+                api libs.uuid
+            }
+        }
+        mingwX64Main {
+            dependencies {
+                api libs.uuid
+            }
+        }
     }
 }

startup/plugin/src/linuxX64Main/kotlin/StartPluginSerializer.kt

@@ -0,0 +1,36 @@
+package dev.inmo.micro_utils.startup.plugin
+
+import com.benasher44.uuid.uuid4
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlin.reflect.KClass
+
+actual object StartPluginSerializer : KSerializer<StartPlugin> {
+    private val registeredPlugins = mutableMapOf<String, StartPlugin>()
+    private val registeredPluginsByPlugin = mutableMapOf<StartPlugin, String>()
+    override val descriptor: SerialDescriptor = String.serializer().descriptor
+
+    override fun deserialize(decoder: Decoder): StartPlugin {
+        val name = decoder.decodeString()
+        return registeredPlugins[name] ?: error("Unable to find startup plugin for $name")
+    }
+
+    override fun serialize(encoder: Encoder, value: StartPlugin) {
+        val name = registeredPluginsByPlugin[value] ?: uuid4().toString().also {
+            registeredPlugins[it] = value
+            registeredPluginsByPlugin[value] = it
+        }
+        encoder.encodeString(name)
+    }
+
+    /**
+     * Register plugin inside of this [KSerializer]. Since plugin has been registered, you may use its [name] in any
+     * serialized [dev.inmo.micro_utils.startup.launcher.Config] to retrieve [plugin] you passed here
+     */
+    fun registerPlugin(name: String, plugin: StartPlugin) {
+        registeredPlugins[name] = plugin
+    }
+}

startup/plugin/src/mingwX64Main/kotlin/StartPluginSerializer.kt

@@ -0,0 +1,36 @@
+package dev.inmo.micro_utils.startup.plugin
+
+import com.benasher44.uuid.uuid4
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlin.reflect.KClass
+
+actual object StartPluginSerializer : KSerializer<StartPlugin> {
+    private val registeredPlugins = mutableMapOf<String, StartPlugin>()
+    private val registeredPluginsByPlugin = mutableMapOf<StartPlugin, String>()
+    override val descriptor: SerialDescriptor = String.serializer().descriptor
+
+    override fun deserialize(decoder: Decoder): StartPlugin {
+        val name = decoder.decodeString()
+        return registeredPlugins[name] ?: error("Unable to find startup plugin for $name")
+    }
+
+    override fun serialize(encoder: Encoder, value: StartPlugin) {
+        val name = registeredPluginsByPlugin[value] ?: uuid4().toString().also {
+            registeredPlugins[it] = value
+            registeredPluginsByPlugin[value] = it
+        }
+        encoder.encodeString(name)
+    }
+
+    /**
+     * Register plugin inside of this [KSerializer]. Since plugin has been registered, you may use its [name] in any
+     * serialized [dev.inmo.micro_utils.startup.launcher.Config] to retrieve [plugin] you passed here
+     */
+    fun registerPlugin(name: String, plugin: StartPlugin) {
+        registeredPlugins[name] = plugin
+    }
+}