done migration

0.19.9

CHANGELOG.md

@@ -1,5 +1,133 @@
 # Changelog
 
+## 0.20.0
+
+## 0.19.9
+
+* `Versions`:
+    * `Koin`: `3.4.2` -> `3.4.3`
+* `Startup`:
+    * Now it is possible to start application in synchronous way
+
+## 0.19.8
+
+* `Versions`:
+    * `Coroutines`: `1.7.2` -> `1.7.3`
+    * `Kotlin`: `1.8.20` -> `1.8.22`
+    * `Compose`: `1.4.1` -> `1.4.3`
+    * `Okio`: `3.3.0` -> `3.4.0`
+    * `RecyclerView`: `1.3.0` -> `1.3.1`
+    * `Fragment`: `1.6.0` -> `1.6.1`
+* `Repos`:
+    * Fixes In `KeyValueRepo.clear()` of almost all inheritors of `KeyValueRepo`
+    * `Cache`:
+        * All full caches got `skipStartInvalidate` property. By default, this property is `false` and fully caching repos
+          will be automatically invalidated on start of their work
+
+## 0.19.7
+
+* `Versions`:
+    * `Coroutines`: `1.7.1` -> `1.7.2`
+
+## 0.19.6
+
+* `Versions`:
+    * `Coroutines`: `1.6.4` -> `1.7.1`
+    * `Ktor`: `2.3.1` -> `2.3.2`
+    * `Compose`: `1.4.0` -> `1.4.1`
+
+## 0.19.5
+
+* `Repos`:
+    * `Generator`:
+        * Fixes in new type generation
+
+## 0.19.4
+
+* `Versions`:
+    * `Koin`: `3.4.1` -> `3.4.2`
+    * `Android Fragments`: `1.5.7` -> `1.6.0`
+* `Koin`
+    * `Generator`
+        * Fixes in new generic generator part
+
+## 0.19.3
+
+* `Koin`
+    * `Generator`
+        * New getter methods now available with opportunity to use parameters
+        * Old notation `*Single` and `*Factory` is deprecated since this release. With old
+          will be generated new `single*` and `factory*` notations for new generations
+        * Add opportunity to use generic-oriented koin definitions
+
+## 0.19.2
+
+* `Versions`:
+    * `Ktor`: `2.3.0` -> `2.3.1`
+    * `Koin`: `3.4.0` -> `3.4.1`
+    * `Uuid`: `0.7.0` -> `0.7.1`
+
+## 0.19.1
+
+* `Versions`:
+    * `Korlibs`: `4.0.1` -> `4.0.3`
+    * `Kotlin Poet`: `1.13.2` -> `1.14.0`
+
+## 0.19.0
+
+* `Versions`:
+    * `Korlibs`: `3.4.0` -> `4.0.1`
+
+## 0.18.4
+
+* `Koin`:
+    * New extension `lazyInject`
+
+## 0.18.3
+
+* `Versions`:
+    * `Serialization`: `1.5.0` -> `1.5.1`
+    * `Android Cor Ktx`: `1.10.0` -> `1.10.1`
+
+## 0.18.2
+
+* `Startup`:
+    * Now internal `Json` is fully customizable
+
+## 0.18.1
+
+* `Common`:
+    * Add `MapDiff`
+* `Coroutines`:
+    * Add `SmartMutex`
+
+## 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`:

build.gradle

@@ -17,6 +17,10 @@ buildscript {
     }
 }
 
+plugins {
+    alias(libs.plugins.versions)
+}
+
 allprojects {
     repositories {
         mavenLocal()
@@ -38,3 +42,4 @@ allprojects {
 
 apply from: "./extensions.gradle"
 apply from: "./github_release.gradle"
+apply from: "./versions_plugin_setup.gradle"

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

@@ -200,20 +200,18 @@ inline fun <T> Iterable<T>.calculateStrictDiff(
 ) = calculateDiff(other, strictComparison = true)
 
 /**
- * This method call [calculateDiff] with strict mode [strictComparison] and then apply differences to [this]
+ * Applies [diff] to [this] [MutableList]
- * mutable list
  */
 fun <T> MutableList<T>.applyDiff(
-    source: Iterable<T>,
+    diff: Diff<T>
-    strictComparison: Boolean = false
+) {
-): Diff<T> = calculateDiff(source, strictComparison).also {
+    for (i in diff.removed.indices.sortedDescending()) {
-    for (i in it.removed.indices.sortedDescending()) {
+        removeAt(diff.removed[i].index)
-        removeAt(it.removed[i].index)
     }
-    it.added.forEach { (i, t) ->
+    diff.added.forEach { (i, t) ->
         add(i, t)
     }
-    it.replaced.forEach { (_, new) ->
+    diff.replaced.forEach { (_, new) ->
         set(new.index, new.value)
     }
 }
@@ -222,17 +220,30 @@ fun <T> MutableList<T>.applyDiff(
  * This method call [calculateDiff] with strict mode [strictComparison] and then apply differences to [this]
  * mutable list
  */
+fun <T> MutableList<T>.applyDiff(
+    source: Iterable<T>,
+    strictComparison: Boolean = false
+): Diff<T> = calculateDiff(source, strictComparison).also {
+    applyDiff(it)
+}
+
+/**
+ * This method call [calculateDiff] and then apply differences to [this]
+ * mutable list
+ */
 fun <T> MutableList<T>.applyDiff(
     source: Iterable<T>,
     comparisonFun: (T?, T?) -> Boolean
 ): Diff<T> = calculateDiff(source, comparisonFun).also {
-    for (i in it.removed.indices.sortedDescending()) {
+    applyDiff(it)
-        removeAt(it.removed[i].index)
-    }
-    it.added.forEach { (i, t) ->
-        add(i, t)
-    }
-    it.replaced.forEach { (_, new) ->
-        set(new.index, new.value)
-    }
 }
+
+/**
+ * Reverse [this] [Diff]. Result will contain [Diff.added] on [Diff.removed] (and vice-verse), all the
+ * [Diff.replaced] values will be reversed too
+ */
+fun <T> Diff<T>.reversed() = Diff(
+    removed = added,
+    replaced = replaced.map { it.second to it.first },
+    added = removed
+)

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

@@ -0,0 +1,135 @@
+package dev.inmo.micro_utils.common
+
+/**
+ * Contains diff based on the comparison of objects with the same [K].
+ *
+ * @param removed Contains map with keys removed from parent map
+ * @param changed Contains map with keys values changed new map in comparison with old one
+ * @param added Contains map with new keys and values
+ */
+data class MapDiff<K, V> @Warning(warning) constructor(
+    val removed: Map<K, V>,
+    val changed: Map<K, Pair<V, V>>,
+    val added: Map<K, V>
+) {
+    fun isEmpty() = removed.isEmpty() && changed.isEmpty() && added.isEmpty()
+    inline fun isNotEmpty() = !isEmpty()
+
+    companion object {
+        private const val warning = "This feature can be changed without any warranties. Use with caution and only in case you know what you are doing"
+        fun <K, V> empty() = MapDiff<K, V>(emptyMap(), emptyMap(), emptyMap())
+    }
+}
+
+private inline fun <K, V> createCompareFun(
+    strictComparison: Boolean
+): (K, V, V) -> Boolean = if (strictComparison) {
+    { _, first, second -> first === second }
+} else {
+    { _, first, second -> first == second }
+}
+
+/**
+ * Compare [this] [Map] with the [other] one in principle when [other] is newer than [this]
+ *
+ * @param compareFun Will be used to determine changed values
+ */
+fun <K, V> Map<K, V>.diff(
+    other: Map<K, V>,
+    compareFun: (K, V, V) -> Boolean
+): MapDiff<K, V> {
+    val removed: Map<K, V> = (keys - other.keys).associateWith {
+        getValue(it)
+    }
+    val added: Map<K, V> = (other.keys - keys).associateWith {
+        other.getValue(it)
+    }
+    val changed = keys.intersect(other.keys).mapNotNull {
+        val old = getValue(it)
+        val new = other.getValue(it)
+        if (compareFun(it, old, new)) {
+            return@mapNotNull null
+        } else {
+            it to (old to new)
+        }
+    }.toMap()
+
+    return MapDiff(
+        removed,
+        changed,
+        added
+    )
+}
+
+/**
+ * Compare [this] [Map] with the [other] one in principle when [other] is newer than [this]
+ *
+ * @param strictComparison If true, will use strict (===) comparison for the values' comparison. Otherwise, standard
+ * `equals` will be used
+ */
+fun <K, V> Map<K, V>.diff(
+    other: Map<K, V>,
+    strictComparison: Boolean = false
+): MapDiff<K, V> = diff(
+    other,
+    compareFun = createCompareFun(strictComparison)
+)
+
+/**
+ * Will apply [mapDiff] to [this] [MutableMap]
+ */
+fun <K, V> MutableMap<K, V>.applyDiff(
+    mapDiff: MapDiff<K, V>
+) {
+    mapDiff.apply {
+        removed.keys.forEach { remove(it) }
+        changed.forEach { (k, oldNew) ->
+            put(k, oldNew.second)
+        }
+        added.forEach { (k, new) ->
+            put(k, new)
+        }
+    }
+}
+
+/**
+ * Will apply changes with [from] map into [this] one
+ *
+ * @param compareFun Will be used to determine changed values
+ *
+ * @return [MapDiff] applied to [this] [MutableMap]
+ */
+fun <K, V> MutableMap<K, V>.applyDiff(
+    from: Map<K, V>,
+    compareFun: (K, V, V) -> Boolean
+): MapDiff<K, V> {
+    return diff(from, compareFun).also {
+        applyDiff(it)
+    }
+}
+
+/**
+ * Will apply changes with [from] map into [this] one
+ *
+ * @param strictComparison If true, will use strict (===) comparison for the values' comparison. Otherwise, standard
+ * `equals` will be used
+ *
+ * @return [MapDiff] applied to [this] [MutableMap]
+ */
+fun <K, V> MutableMap<K, V>.applyDiff(
+    from: Map<K, V>,
+    strictComparison: Boolean = false
+): MapDiff<K, V> = applyDiff(
+    from,
+    compareFun = createCompareFun(strictComparison)
+)
+
+/**
+ * Reverse [this] [MapDiff]. Result will contain [MapDiff.added] on [MapDiff.removed] (and vice-verse), all the
+ * [MapDiff.changed] values will be reversed too
+ */
+fun <K, V> MapDiff<K, V>.reversed(): MapDiff<K, V> = MapDiff(
+    removed = added,
+    changed = changed.mapValues { (_, oldNew) -> oldNew.second to oldNew.first },
+    added = removed
+)

common/src/linuxX64Main/kotlin/fixed.kt

@@ -1,12 +1,10 @@
 package dev.inmo.micro_utils.common
 
-import kotlinx.cinterop.ByteVar
+import kotlinx.cinterop.*
-import kotlinx.cinterop.allocArray
-import kotlinx.cinterop.memScoped
-import kotlinx.cinterop.toKString
 import platform.posix.snprintf
 import platform.posix.sprintf
 
+@OptIn(ExperimentalForeignApi::class)
 actual fun Float.fixed(signs: Int): Float {
     return memScoped {
         val buff = allocArray<ByteVar>(Float.SIZE_BYTES * 2)
@@ -16,6 +14,7 @@ actual fun Float.fixed(signs: Int): Float {
     }
 }
 
+@OptIn(ExperimentalForeignApi::class)
 actual fun Double.fixed(signs: Int): Double {
     return memScoped {
         val buff = allocArray<ByteVar>(Double.SIZE_BYTES * 2)

common/src/mingwX64Main/kotlin/fixed.kt

@@ -1,12 +1,10 @@
 package dev.inmo.micro_utils.common
 
-import kotlinx.cinterop.ByteVar
+import kotlinx.cinterop.*
-import kotlinx.cinterop.allocArray
-import kotlinx.cinterop.memScoped
-import kotlinx.cinterop.toKString
 import platform.posix.snprintf
 import platform.posix.sprintf
 
+@OptIn(ExperimentalForeignApi::class)
 actual fun Float.fixed(signs: Int): Float {
     return memScoped {
         val buff = allocArray<ByteVar>(Float.SIZE_BYTES * 2)
@@ -16,6 +14,7 @@ actual fun Float.fixed(signs: Int): Float {
     }
 }
 
+@OptIn(ExperimentalForeignApi::class)
 actual fun Double.fixed(signs: Int): Double {
     return memScoped {
         val buff = allocArray<ByteVar>(Double.SIZE_BYTES * 2)

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)
-

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

@@ -0,0 +1,136 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+/**
+ * It is interface which will work like classic [Mutex], but in difference have [lockStateFlow] for listening of the
+ * [SmartMutex] state.
+ *
+ * There is [Mutable] and [Immutable] realizations. In case you are owner and manager current state of lock, you need
+ * [Mutable] [SmartMutex]. Otherwise, [Immutable].
+ *
+ * Any [Mutable] [SmartMutex] may produce its [Immutable] variant which will contains [lockStateFlow] equal to its
+ * [Mutable] creator
+ */
+sealed interface SmartMutex {
+    val lockStateFlow: StateFlow<Boolean>
+
+    /**
+     * * True - locked
+     * * False - unlocked
+     */
+    val isLocked: Boolean
+        get() = lockStateFlow.value
+
+    /**
+     * Immutable variant of [SmartMutex]. In fact will depend on the owner of [lockStateFlow]
+     */
+    class Immutable(override val lockStateFlow: StateFlow<Boolean>) : SmartMutex
+
+    /**
+     * Mutable variant of [SmartMutex]. With that variant you may [lock] and [unlock]. Besides, you may create
+     * [Immutable] variant of [this] instance with [immutable] factory
+     *
+     * @param locked Preset state of [isLocked] and its internal [_lockStateFlow]
+     */
+    class Mutable(locked: Boolean = false) : SmartMutex {
+        private val _lockStateFlow = MutableStateFlow<Boolean>(locked)
+        override val lockStateFlow: StateFlow<Boolean> = _lockStateFlow.asStateFlow()
+
+        private val internalChangesMutex = Mutex()
+
+        fun immutable() = Immutable(lockStateFlow)
+
+        /**
+         * Holds call until this [SmartMutex] will be re-locked. That means that while [isLocked] == true, [holds] will
+         * wait for [isLocked] == false and then try to lock
+         */
+        suspend fun lock() {
+            do {
+                waitUnlock()
+                val shouldContinue = internalChangesMutex.withLock {
+                    if (_lockStateFlow.value) {
+                        true
+                    } else {
+                        _lockStateFlow.value = true
+                        false
+                    }
+                }
+            } while (shouldContinue && currentCoroutineContext().isActive)
+        }
+
+        /**
+         * Will try to lock this [SmartMutex] immediataly
+         *
+         * @return True if lock was successful. False otherwise
+         */
+        suspend fun tryLock(): Boolean {
+            return if (!_lockStateFlow.value) {
+                internalChangesMutex.withLock {
+                    if (!_lockStateFlow.value) {
+                        _lockStateFlow.value = true
+                        true
+                    } else {
+                        false
+                    }
+                }
+            } else {
+                false
+            }
+        }
+
+        /**
+         * If [isLocked] == true - will change it to false and return true. If current call will not unlock this
+         * [SmartMutex] - false
+         */
+        suspend fun unlock(): Boolean {
+            return if (_lockStateFlow.value) {
+                internalChangesMutex.withLock {
+                    if (_lockStateFlow.value) {
+                        _lockStateFlow.value = false
+                        true
+                    } else {
+                        false
+                    }
+                }
+            } else {
+                false
+            }
+        }
+    }
+}
+
+/**
+ * Will call [SmartMutex.Mutable.lock], then execute [action] and return the result after [SmartMutex.Mutable.unlock]
+ */
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <T> SmartMutex.Mutable.withLock(action: () -> T): T {
+    contract {
+        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
+    }
+
+    lock()
+    try {
+        return action()
+    } finally {
+        unlock()
+    }
+}
+
+/**
+ * Will wait until the [SmartMutex.lockStateFlow] of [this] instance will be false.
+ *
+ * Anyway, after the end of this block there are no any guaranties that [SmartMutex.isLocked] == false due to the fact
+ * that some other parties may lock it again
+ */
+suspend fun SmartMutex.waitUnlock() = lockStateFlow.first { !it }

crypto/src/commonMain/kotlin/dev/inmo/micro_utils/crypto/MD5.kt

@@ -1,6 +1,6 @@
 package dev.inmo.micro_utils.crypto
 
-import com.soywiz.krypto.md5
+import korlibs.crypto.md5
 
 typealias MD5 = String
 

defaultAndroidSettings.gradle

@@ -29,8 +29,4 @@ android {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
-
-    kotlinOptions {
-        jvmTarget = JavaVersion.VERSION_1_8.toString()
-    }
 }

dokka/build.gradle

@@ -13,10 +13,10 @@ repositories {
 
 kotlin {
     jvm()
-//    js(IR) {
+    js(IR) {
-//        browser()
+        browser()
-//        nodejs()
+        nodejs()
-//    }
+    }
     android {}
 
     sourceSets {
@@ -26,44 +26,44 @@ kotlin {
 
                 project.parent.subprojects.forEach {
                     if (
-                        it != project
+                            it != project
-                        && it.hasProperty("kotlin")
+                                    && it.hasProperty("kotlin")
-                        && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
-//                        && it.kotlin.sourceSets.any { it.name.contains("jsMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("jsMain") }
-                        && it.kotlin.sourceSets.any { it.name.contains("jvmMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("jvmMain") }
-                        && it.kotlin.sourceSets.any { it.name.contains("androidMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("androidMain") }
                     ) {
                         api it
                     }
                 }
             }
         }
-//        jsMain {
+        jsMain {
-//            dependencies {
+            dependencies {
-//                implementation kotlin('stdlib')
+                implementation kotlin('stdlib')
 
-//                project.parent.subprojects.forEach {
+                project.parent.subprojects.forEach {
-//                    if (
+                    if (
-//                        it != project
+                            it != project
-//                        && it.hasProperty("kotlin")
+                                    && it.hasProperty("kotlin")
-//                        && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
-//                        && it.kotlin.sourceSets.any { it.name.contains("jsMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("jsMain") }
-//                    ) {
+                    ) {
-//                        api it
+                        api it
-//                    }
+                    }
-//                }
+                }
-//            }
+            }
-//        }
+        }
         jvmMain {
             dependencies {
                 implementation kotlin('stdlib')
 
                 project.parent.subprojects.forEach {
                     if (
-                        it != project
+                            it != project
-                        && it.hasProperty("kotlin")
+                                    && it.hasProperty("kotlin")
-                        && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
-                        && it.kotlin.sourceSets.any { it.name.contains("jvmMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("jvmMain") }
                     ) {
                         api it
                     }
@@ -76,10 +76,10 @@ kotlin {
 
                 project.parent.subprojects.forEach {
                     if (
-                        it != project
+                            it != project
-                        && it.hasProperty("kotlin")
+                                    && it.hasProperty("kotlin")
-                        && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
-                        && it.kotlin.sourceSets.any { it.name.contains("androidMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("androidMain") }
                     ) {
                         api it
                     }
@@ -116,9 +116,9 @@ tasks.dokkaHtml {
             sourceRoots.setFrom(findSourcesWithName("commonMain"))
         }
 
-//        named("jsMain") {
+        named("jsMain") {
-//            sourceRoots.setFrom(findSourcesWithName("jsMain", "commonMain"))
+            sourceRoots.setFrom(findSourcesWithName("jsMain"))
-//        }
+        }
 
         named("jvmMain") {
             sourceRoots.setFrom(findSourcesWithName("jvmMain"))

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

@@ -3,6 +3,7 @@ org.gradle.parallel=true
 kotlin.js.generate.externals=true
 kotlin.incremental=true
 kotlin.incremental.js=true
+#kotlin.experimental.tryK2=true
 android.useAndroidX=true
 android.enableJetifier=true
 org.gradle.jvmargs=-Xmx2g
@@ -14,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.17.6
+version=0.20.0
-android_code_version=188
+android_code_version=206

gradle/libs.versions.toml

@@ -1,42 +1,44 @@
 [versions]
 
-kt = "1.8.20"
+kt = "1.9.0"
-kt-serialization = "1.5.0"
+kt-serialization = "1.5.1"
-kt-coroutines = "1.6.4"
+kt-coroutines = "1.7.3"
 
-kslog = "1.1.1"
+kslog = "1.2.0"
 
-jb-compose = "1.4.0"
+jb-compose = "1.4.3"
-jb-exposed = "0.41.1"
+jb-exposed = "0.42.0"
-jb-dokka = "1.8.10"
+jb-dokka = "1.8.20"
 
-korlibs = "3.4.0"
+korlibs = "4.0.9"
-uuid = "0.7.0"
+uuid = "0.8.0"
 
-ktor = "2.2.4"
+ktor = "2.3.3"
 
 gh-release = "2.4.1"
 
-koin = "3.4.0"
+koin = "3.4.3"
 
-okio = "3.3.0"
+okio = "3.5.0"
 
-ksp = "1.8.20-1.0.10"
+ksp = "1.9.0-1.0.13"
-kotlin-poet = "1.13.0"
+kotlin-poet = "1.14.2"
 
-android-gradle = "7.3.1"
+versions = "0.47.0"
+
+android-gradle = "7.4.2"
 dexcount = "4.0.0"
 
-android-coreKtx = "1.9.0"
+android-coreKtx = "1.10.1"
-android-recyclerView = "1.3.0"
+android-recyclerView = "1.3.1"
 android-appCompat = "1.6.1"
-android-fragment = "1.5.6"
+android-fragment = "1.6.1"
 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]
 
@@ -109,3 +111,5 @@ buildscript-android-dexcount = { module = "com.getkeepsafe.dexcount:dexcount-gra
 [plugins]
 
 jb-compose = { id = "org.jetbrains.compose", version.ref = "jb-compose" }
+
+versions = { id = "com.github.ben-manes.versions", version.ref = "versions" }

gradle/wrapper/gradle-wrapper.properties

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

koin/generator/build.gradle

@@ -13,3 +13,8 @@ dependencies {
     api libs.kotlin.poet
     api libs.ksp
 }
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

koin/generator/src/main/kotlin/Processor.kt

@@ -9,19 +9,28 @@ import com.google.devtools.ksp.processing.Resolver
 import com.google.devtools.ksp.processing.SymbolProcessor
 import com.google.devtools.ksp.symbol.KSAnnotated
 import com.google.devtools.ksp.symbol.KSFile
+import com.google.devtools.ksp.symbol.Modifier
+import com.squareup.kotlinpoet.AnnotationSpec
 import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.CodeBlock
 import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.KModifier
 import com.squareup.kotlinpoet.ParameterSpec
+import com.squareup.kotlinpoet.ParameterizedTypeName
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.TypeName
+import com.squareup.kotlinpoet.TypeVariableName
 import com.squareup.kotlinpoet.asTypeName
 import com.squareup.kotlinpoet.ksp.toClassName
 import com.squareup.kotlinpoet.ksp.toTypeName
 import com.squareup.kotlinpoet.ksp.writeTo
+import dev.inmo.micro_utils.koin.annotations.GenerateGenericKoinDefinition
 import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition
 import org.koin.core.Koin
 import org.koin.core.module.Module
+import org.koin.core.parameter.ParametersDefinition
 import org.koin.core.scope.Scope
 import java.io.File
 import kotlin.reflect.KClass
@@ -32,11 +41,190 @@ class Processor(
     private val definitionClassName = ClassName("org.koin.core.definition", "Definition")
     private val koinDefinitionClassName = ClassName("org.koin.core.definition", "KoinDefinition")
 
+    private fun FileSpec.Builder.addCodeForType(
+        targetType: TypeName,
+        name: String,
+        nullable: Boolean,
+        generateSingle: Boolean,
+        generateFactory: Boolean,
+    ) {
+        val targetTypeAsGenericType = (targetType as? TypeVariableName) ?.copy(reified = true)
+
+        fun addGetterProperty(
+            receiver: KClass<*>
+        ) {
+            addProperty(
+                PropertySpec.builder(
+                    name,
+                    targetType,
+                ).apply {
+                    addKdoc(
+                        """
+                            @return Definition by key "${name}"
+                        """.trimIndent()
+                    )
+                    getter(
+                        FunSpec.getterBuilder().apply {
+                            targetTypeAsGenericType ?.let {
+                                addModifiers(KModifier.INLINE)
+                            }
+                            addCode(
+                                "return " + (if (nullable) {
+                                    "getOrNull"
+                                } else {
+                                    "get"
+                                }) + "(named(\"${name}\"))"
+                            )
+                        }.build()
+                    )
+                    targetTypeAsGenericType ?.let {
+                        addTypeVariable(it)
+                    }
+                    receiver(receiver)
+                }.build()
+            )
+        }
+
+        if (targetTypeAsGenericType == null) {
+            addGetterProperty(Scope::class)
+            addGetterProperty(Koin::class)
+        }
+
+        val parametersDefinitionClassName = ClassName(
+            "org.koin.core.parameter",
+            "ParametersDefinition"
+        )
+        fun addGetterMethod(
+            receiver: KClass<*>
+        ) {
+            addFunction(
+                FunSpec.builder(
+                    name
+                ).apply {
+                    addKdoc(
+                        """
+                            @return Definition by key "${name}" with [parameters]
+                        """.trimIndent()
+                    )
+                    receiver(receiver)
+                    addParameter(
+                        ParameterSpec(
+                            "parameters",
+                            parametersDefinitionClassName.let {
+                                if (targetTypeAsGenericType != null) {
+                                    it.copy(nullable = true)
+                                } else {
+                                    it
+                                }
+                            },
+                            KModifier.NOINLINE
+                        ).toBuilder().apply {
+                            if (targetTypeAsGenericType != null) {
+                                defaultValue("null")
+                            }
+                        }.build()
+                    )
+                    addModifiers(KModifier.INLINE)
+                    targetTypeAsGenericType ?.let {
+                        addTypeVariable(it)
+                        returns(it.copy(nullable = nullable))
+                    } ?: returns(targetType)
+                    addCode(
+                        "return " + (if (nullable) {
+                            "getOrNull"
+                        } else {
+                            "get"
+                        }) + "(named(\"${name}\"), parameters)"
+                    )
+                }.build()
+            )
+        }
+
+        addGetterMethod(Scope::class)
+        addGetterMethod(Koin::class)
+
+        fun FunSpec.Builder.addDefinitionParameter() {
+            val definitionModifiers = if (targetTypeAsGenericType == null) {
+                arrayOf()
+            } else {
+                arrayOf(KModifier.NOINLINE)
+            }
+            addParameter(
+                ParameterSpec.builder(
+                    "definition",
+                    definitionClassName.parameterizedBy(targetType.copy(nullable = false)),
+                    *definitionModifiers
+                ).build()
+            )
+        }
+
+        if (generateSingle) {
+            fun FunSpec.Builder.configure() {
+                addKdoc(
+                    """
+                        Will register [definition] with [org.koin.core.module.Module.single] and key "${name}"
+                    """.trimIndent()
+                )
+                receiver(Module::class)
+                addParameter(
+                    ParameterSpec.builder(
+                        "createdAtStart",
+                        Boolean::class
+                    ).apply {
+                        defaultValue("false")
+                    }.build()
+                )
+                addDefinitionParameter()
+                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
+                addCode(
+                    "return single(named(\"${name}\"), createdAtStart = createdAtStart, definition = definition)"
+                )
+                targetTypeAsGenericType ?.let {
+                    addTypeVariable(it)
+                    addModifiers(KModifier.INLINE)
+                }
+            }
+
+            val actualSingleName = "single${name.replaceFirstChar { it.uppercase() }}"
+
+            addFunction(
+                FunSpec.builder(actualSingleName).apply { configure() }.build()
+            )
+        }
+
+        if (generateFactory) {
+            fun FunSpec.Builder.configure() {
+                addKdoc(
+                    """
+                        Will register [definition] with [org.koin.core.module.Module.factory] and key "${name}"
+                    """.trimIndent()
+                )
+                receiver(Module::class)
+                addDefinitionParameter()
+                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
+                addCode(
+                    "return factory(named(\"${name}\"), definition = definition)"
+                )
+                targetTypeAsGenericType ?.let {
+                    addTypeVariable(it)
+                    addModifiers(KModifier.INLINE)
+                }
+            }
+            val actualFactoryName = "factory${name.replaceFirstChar { it.uppercase() }}"
+            addFunction(
+                FunSpec.builder(actualFactoryName).apply { configure() }.build()
+            )
+        }
+        addImport("org.koin.core.qualifier", "named")
+    }
+
     @OptIn(KspExperimental::class)
     override fun process(resolver: Resolver): List<KSAnnotated> {
-        resolver.getSymbolsWithAnnotation(
+        (resolver.getSymbolsWithAnnotation(
             GenerateKoinDefinition::class.qualifiedName!!
-        ).filterIsInstance<KSFile>().forEach { ksFile ->
+        ) + resolver.getSymbolsWithAnnotation(
+            GenerateGenericKoinDefinition::class.qualifiedName!!
+        )).filterIsInstance<KSFile>().forEach { ksFile ->
             FileSpec.builder(
                 ksFile.packageName.asString(),
                 "GeneratedDefinitions${ksFile.fileName.removeSuffix(".kt")}"
@@ -72,92 +260,12 @@ class Processor(
                     }.copy(
                         nullable = it.nullable
                     )
-                    fun addGetterProperty(
-                        receiver: KClass<*>
-                    ) {
-                        addProperty(
-                            PropertySpec.builder(
-                                it.name,
-                                targetType,
-                            ).apply {
-                                addKdoc(
-                                    """
-                                        @return Definition by key "${it.name}"
-                                    """.trimIndent()
-                                )
-                                getter(
-                                    FunSpec.getterBuilder().apply {
-                                        addCode(
-                                            "return " + (if (it.nullable) {
-                                                "getOrNull"
-                                            } else {
-                                                "get"
-                                            }) + "(named(\"${it.name}\"))"
-                                        )
-                                    }.build()
-                                )
-                                receiver(receiver)
-                            }.build()
-                        )
-                    }
 
-                    addGetterProperty(Scope::class)
+                    addCodeForType(targetType, it.name, it.nullable, it.generateSingle, it.generateFactory)
-                    addGetterProperty(Koin::class)
+                }
-
+                ksFile.getAnnotationsByType(GenerateGenericKoinDefinition::class).forEach {
-                    if (it.generateSingle) {
+                    val targetType = TypeVariableName("T", Any::class)
-                        addFunction(
+                    addCodeForType(targetType, it.name, it.nullable, it.generateSingle, it.generateFactory)
-                            FunSpec.builder("${it.name}Single").apply {
-                                addKdoc(
-                                    """
-                                        Will register [definition] with [org.koin.core.module.Module.single] and key "${it.name}"
-                                    """.trimIndent()
-                                )
-                                receiver(Module::class)
-                                addParameter(
-                                    ParameterSpec.builder(
-                                        "createdAtStart",
-                                        Boolean::class
-                                    ).apply {
-                                        defaultValue("false")
-                                    }.build()
-                                )
-                                addParameter(
-                                    ParameterSpec.builder(
-                                        "definition",
-                                        definitionClassName.parameterizedBy(targetType.copy(nullable = false))
-                                    ).build()
-                                )
-                                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
-                                addCode(
-                                    "return single(named(\"${it.name}\"), createdAtStart = createdAtStart, definition = definition)"
-                                )
-                            }.build()
-                        )
-                    }
-
-                    if (it.generateFactory) {
-                        addFunction(
-                            FunSpec.builder("${it.name}Factory").apply {
-                                addKdoc(
-                                    """
-                                        Will register [definition] with [org.koin.core.module.Module.factory] and key "${it.name}"
-                                    """.trimIndent()
-                                )
-                                receiver(Module::class)
-                                addParameter(
-                                    ParameterSpec.builder(
-                                        "definition",
-                                        definitionClassName.parameterizedBy(targetType.copy(nullable = false))
-                                    ).build()
-                                )
-                                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
-                                addCode(
-                                    "return factory(named(\"${it.name}\"), definition = definition)"
-                                )
-                            }.build()
-                        )
-                    }
-                    addImport("org.koin.core.qualifier", "named")
                 }
             }.build().let {
                 File(

koin/generator/test/src/commonMain/kotlin/GeneratedDefinitionsTest.kt

@@ -3,12 +3,15 @@
 // ORIGINAL FILE: Test.kt
 package dev.inmo.micro_utils.koin.generator.test
 
+import kotlin.Any
 import kotlin.Boolean
+import kotlin.Deprecated
 import kotlin.String
 import org.koin.core.Koin
 import org.koin.core.definition.Definition
 import org.koin.core.definition.KoinDefinition
 import org.koin.core.module.Module
+import org.koin.core.parameter.ParametersDefinition
 import org.koin.core.qualifier.named
 import org.koin.core.scope.Scope
 
@@ -24,15 +27,98 @@ public val Scope.sampleInfo: Test<String>
 public val Koin.sampleInfo: Test<String>
   get() = get(named("sampleInfo"))
 
+/**
+ * @return Definition by key "sampleInfo" with [parameters]
+ */
+public inline fun Scope.sampleInfo(noinline parameters: ParametersDefinition): Test<String> =
+    get(named("sampleInfo"), parameters)
+
+/**
+ * @return Definition by key "sampleInfo" with [parameters]
+ */
+public inline fun Koin.sampleInfo(noinline parameters: ParametersDefinition): Test<String> =
+    get(named("sampleInfo"), parameters)
+
 /**
  * Will register [definition] with [org.koin.core.module.Module.single] and key "sampleInfo"
  */
+@Deprecated(
+  "This definition is old style and should not be used anymore. Use singleSampleInfo instead",
+  ReplaceWith("singleSampleInfo"),
+)
 public fun Module.sampleInfoSingle(createdAtStart: Boolean = false,
     definition: Definition<Test<String>>): KoinDefinition<Test<String>> =
     single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
 
+/**
+ * Will register [definition] with [org.koin.core.module.Module.single] and key "sampleInfo"
+ */
+public fun Module.singleSampleInfo(createdAtStart: Boolean = false,
+    definition: Definition<Test<String>>): KoinDefinition<Test<String>> =
+    single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
+
 /**
  * Will register [definition] with [org.koin.core.module.Module.factory] and key "sampleInfo"
  */
+@Deprecated(
+  "This definition is old style and should not be used anymore. Use factorySampleInfo instead",
+  ReplaceWith("factorySampleInfo"),
+)
 public fun Module.sampleInfoFactory(definition: Definition<Test<String>>):
     KoinDefinition<Test<String>> = factory(named("sampleInfo"), definition = definition)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.factory] and key "sampleInfo"
+ */
+public fun Module.factorySampleInfo(definition: Definition<Test<String>>):
+    KoinDefinition<Test<String>> = factory(named("sampleInfo"), definition = definition)
+
+/**
+ * @return Definition by key "test" with [parameters]
+ */
+public inline fun <reified T : Any> Scope.test(noinline parameters: ParametersDefinition? = null): T
+    = get(named("test"), parameters)
+
+/**
+ * @return Definition by key "test" with [parameters]
+ */
+public inline fun <reified T : Any> Koin.test(noinline parameters: ParametersDefinition? = null): T
+    = get(named("test"), parameters)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.single] and key "test"
+ */
+public inline fun <reified T : Any> Module.singleTest(createdAtStart: Boolean = false, noinline
+    definition: Definition<T>): KoinDefinition<T> = single(named("test"), createdAtStart =
+    createdAtStart, definition = definition)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.factory] and key "test"
+ */
+public inline fun <reified T : Any> Module.factoryTest(noinline definition: Definition<T>):
+    KoinDefinition<T> = factory(named("test"), definition = definition)
+
+/**
+ * @return Definition by key "testNullable" with [parameters]
+ */
+public inline fun <reified T : Any> Scope.testNullable(noinline parameters: ParametersDefinition? =
+    null): T? = getOrNull(named("testNullable"), parameters)
+
+/**
+ * @return Definition by key "testNullable" with [parameters]
+ */
+public inline fun <reified T : Any> Koin.testNullable(noinline parameters: ParametersDefinition? =
+    null): T? = getOrNull(named("testNullable"), parameters)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.single] and key "testNullable"
+ */
+public inline fun <reified T : Any> Module.singleTestNullable(createdAtStart: Boolean = false,
+    noinline definition: Definition<T>): KoinDefinition<T> = single(named("testNullable"),
+    createdAtStart = createdAtStart, definition = definition)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.factory] and key "testNullable"
+ */
+public inline fun <reified T : Any> Module.factoryTestNullable(noinline definition: Definition<T>):
+    KoinDefinition<T> = factory(named("testNullable"), definition = definition)

koin/generator/test/src/commonMain/kotlin/Test.kt

@@ -1,6 +1,9 @@
 @file:GenerateKoinDefinition("sampleInfo", Test::class, String::class, nullable = false)
+@file:GenerateGenericKoinDefinition("test", nullable = false)
+@file:GenerateGenericKoinDefinition("testNullable", nullable = true)
 package dev.inmo.micro_utils.koin.generator.test
 
+import dev.inmo.micro_utils.koin.annotations.GenerateGenericKoinDefinition
 import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition
 import org.koin.core.Koin
 

koin/src/commonMain/kotlin/GetWithDefinition.kt

@@ -0,0 +1,40 @@
+package dev.inmo.micro_utils.koin
+
+import org.koin.core.Koin
+import org.koin.core.definition.BeanDefinition
+import org.koin.core.definition.KoinDefinition
+import org.koin.core.instance.InstanceFactory
+import org.koin.core.parameter.ParametersDefinition
+import org.koin.core.scope.Scope
+
+fun <T> Koin.get(definition: BeanDefinition<T>, parameters: ParametersDefinition? = null): T = get(
+    definition.primaryType,
+    definition.qualifier,
+    parameters
+)
+
+fun <T> Koin.get(definition: InstanceFactory<T>, parameters: ParametersDefinition? = null): T = get(
+    definition.beanDefinition,
+    parameters
+)
+
+fun <T> Koin.get(definition: KoinDefinition<T>, parameters: ParametersDefinition? = null): T = get(
+    definition.factory,
+    parameters
+)
+
+fun <T> Scope.get(definition: BeanDefinition<T>, parameters: ParametersDefinition? = null): T = get(
+    definition.primaryType,
+    definition.qualifier,
+    parameters
+)
+
+fun <T> Scope.get(definition: InstanceFactory<T>, parameters: ParametersDefinition? = null): T = get(
+    definition.beanDefinition,
+    parameters
+)
+
+fun <T> Scope.get(definition: KoinDefinition<T>, parameters: ParametersDefinition? = null): T = get(
+    definition.factory,
+    parameters
+)

koin/src/commonMain/kotlin/annotations/GenerateGenericKoinDefinition.kt

@@ -0,0 +1,26 @@
+package dev.inmo.micro_utils.koin.annotations
+
+import kotlin.reflect.KClass
+
+/**
+ * Use this annotation to mark files near to which generator should place generated extensions for koin [org.koin.core.scope.Scope]
+ * and [org.koin.core.Koin]
+ *
+ * @param name Name for definitions. This name will be available as extension for [org.koin.core.scope.Scope] and [org.koin.core.Koin]
+ * @param type Type of extensions. It is base star-typed class
+ * @param typeArgs Generic types for [type]. For example, if [type] == `Something::class` and [typeArgs] == `G1::class,
+ * G2::class`, the result type will be `Something<G1, G2>`
+ * @param nullable In case when true, extension will not throw error when definition has not been registered in koin
+ * @param generateSingle Generate definition factory with [org.koin.core.module.Module.single]. You will be able to use
+ * the extension [org.koin.core.module.Module].[name]Single(createdAtStart/* default false */) { /* your definition */ }
+ * @param generateFactory Generate definition factory with [org.koin.core.module.Module.factory]. You will be able to use
+ * the extension [org.koin.core.module.Module].[name]Factory { /* your definition */ }
+ */
+@Target(AnnotationTarget.FILE)
+@Repeatable
+annotation class GenerateGenericKoinDefinition(
+    val name: String,
+    val nullable: Boolean = true,
+    val generateSingle: Boolean = true,
+    val generateFactory: Boolean = true
+)

koin/src/jvmMain/kotlin/LazyInject.kt

@@ -0,0 +1,27 @@
+package dev.inmo.micro_utils.koin
+
+import org.koin.core.parameter.ParametersDefinition
+import org.koin.core.qualifier.Qualifier
+import org.koin.java.KoinJavaComponent
+import kotlin.reflect.KClass
+
+fun <T> lazyInject(
+    kClassFactory: () -> KClass<*>,
+    qualifier: Qualifier? = null,
+    parameters: ParametersDefinition? = null
+): Lazy<T> {
+    return lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
+        KoinJavaComponent.get(kClassFactory().java, qualifier, parameters)
+    }
+}
+
+fun <T> lazyInject(
+    kClass: KClass<*>,
+    qualifier: Qualifier? = null,
+    parameters: ParametersDefinition? = null
+): Lazy<T> = lazyInject({ kClass }, qualifier, parameters)
+
+inline fun <reified T> lazyInject(
+    qualifier: Qualifier? = null,
+    noinline parameters: ParametersDefinition? = null
+): Lazy<T> = lazyInject(T::class, qualifier, parameters)

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

@@ -1,6 +1,6 @@
 package dev.inmo.micro_utils.ktor.common
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 
 typealias FromToDateTime = Pair<DateTime?, DateTime?>
 

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

@@ -1,6 +1,6 @@
 package dev.inmo.micro_utils.ktor.server
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.micro_utils.ktor.common.FromToDateTime
 import io.ktor.http.Parameters
 

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")
+    }
+}

local.migrate.folder.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+function renameFolders() {
+  for folder in $(find . -depth -type d -name "$1");
+  do
+      sedString="s/$1/$2/g"
+      newFolder="$(echo $folder | sed $sedString)"
+      echo $folder "$newFolder"
+  done
+}
+
+renameFolders "androidTest" "androidUnitTest"

mppJvmJsLinuxMingwProject.gradle

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

mppProjectWithSerialization.gradle

@@ -45,7 +45,7 @@ kotlin {
                 implementation kotlin('test-junit')
             }
         }
-        androidTest {
+        androidUnitTest {
             dependencies {
                 implementation kotlin('test-junit')
                 implementation libs.android.test.junit

mppProjectWithSerializationAndCompose.gradle

@@ -54,7 +54,7 @@ kotlin {
                 implementation kotlin('test-junit')
             }
         }
-        androidTest {
+        androidUnitTest {
             dependencies {
                 implementation kotlin('test-junit')
                 implementation libs.android.test.junit

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/KeyValueCacheRepo.kt

@@ -38,7 +38,7 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
 ) = ReadKeyValueCacheRepo(this, kvCache)
 
 open class KeyValueCacheRepo<Key,Value>(
-    parentRepo: KeyValueRepo<Key, Value>,
+    override val parentRepo: KeyValueRepo<Key, Value>,
     kvCache: KVCache<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
 ) : ReadKeyValueCacheRepo<Key,Value>(parentRepo, kvCache), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo, CommonCacheRepo {
@@ -46,6 +46,11 @@ open class KeyValueCacheRepo<Key,Value>(
     protected val onRemoveJob = parentRepo.onValueRemoved.onEach { kvCache.unset(it) }.launchIn(scope)
 
     override suspend fun invalidate() = kvCache.clear()
+
+    override suspend fun clear() {
+        parentRepo.clear()
+        kvCache.clear()
+    }
 }
 
 fun <Key, Value> KeyValueRepo<Key, Value>.cached(

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/cache/SimpleFullKVCache.kt

@@ -21,6 +21,12 @@ open class SimpleFullKVCache<K, V>(
             kvParent.unset(toUnset)
         }
     }
+
+    override suspend fun clear() {
+        syncMutex.withLock {
+            kvParent.clear()
+        }
+    }
 }
 
 inline fun <K, V> FullKVCache(

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/cache/SimpleKVCache.kt

@@ -37,6 +37,10 @@ open class SimpleKVCache<K, V>(
     override suspend fun unset(toUnset: List<K>) {
         syncMutex.withLock { makeUnset(toUnset) }
     }
+
+    override suspend fun clear() {
+        syncMutex.withLock { makeUnset(cacheQueue) }
+    }
 }
 
 inline fun <K, V> KVCache(

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/AutoRecacheKeyValueRepo.kt

@@ -39,4 +39,9 @@ open class AutoRecacheKeyValueRepo<Id, RegisteredObject>(
     ).also {
         kvCache.unsetWithValues(toUnset)
     }
+
+    override suspend fun clear() {
+        originalRepo.clear()
+        kvCache.clear()
+    }
 }

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

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.repos.cache.full
 
 import dev.inmo.micro_utils.common.*
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
@@ -84,6 +85,7 @@ open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
     override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
     kvCache: FullKVCache<IdType, ObjectType>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    skipStartInvalidate: Boolean = false,
     idGetter: (ObjectType) -> IdType
 ) : FullReadCRUDCacheRepo<ObjectType, IdType>(
     parentRepo,
@@ -97,13 +99,28 @@ open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
         idGetter
     ),
     CRUDRepo<ObjectType, IdType, InputValueType> {
+    init {
+        if (!skipStartInvalidate) {
+            scope.launchSafelyWithoutExceptions { invalidate() }
+        }
+    }
+
     override suspend fun invalidate() {
         actualizeAll()
     }
 }
 
+fun <ObjectType, IdType, InputType> CRUDRepo<ObjectType, IdType, InputType>.fullyCached(
+    kvCache: FullKVCache<IdType, ObjectType> = FullKVCache(),
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    skipStartInvalidate: Boolean = false,
+    idGetter: (ObjectType) -> IdType
+) = FullCRUDCacheRepo(this, kvCache, scope, skipStartInvalidate, 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),
+    skipStartInvalidate: Boolean = false,
     idGetter: (ObjectType) -> IdType
-) = FullCRUDCacheRepo(this, kvCache, scope, idGetter)
+) = fullyCached(kvCache, scope, skipStartInvalidate, idGetter)

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

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.repos.cache.full
 
 import dev.inmo.micro_utils.common.*
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
@@ -106,18 +107,39 @@ fun <Key, Value> WriteKeyValueRepo<Key, Value>.caching(
 open class FullKeyValueCacheRepo<Key,Value>(
     protected open val parentRepo: KeyValueRepo<Key, Value>,
     kvCache: FullKVCache<Key, Value>,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    skipStartInvalidate: Boolean = false
 ) : FullWriteKeyValueCacheRepo<Key,Value>(parentRepo, kvCache, scope),
     KeyValueRepo<Key,Value>,
-    ReadKeyValueRepo<Key, Value> by FullReadKeyValueCacheRepo(parentRepo, kvCache) {
+    ReadKeyValueRepo<Key, Value> by FullReadKeyValueCacheRepo(
+        parentRepo,
+        kvCache
+) {
+    init {
+        if (!skipStartInvalidate) {
+            scope.launchSafelyWithoutExceptions { invalidate() }
+        }
+    }
+
     override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset)
 
     override suspend fun invalidate() {
         kvCache.actualizeAll(parentRepo)
     }
+
+    override suspend fun clear() {
+        parentRepo.clear()
+        kvCache.clear()
+    }
 }
 
+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

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.repos.cache.full
 
 import dev.inmo.micro_utils.common.*
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.*
 import dev.inmo.micro_utils.repos.*
@@ -142,10 +143,17 @@ fun <Key, Value> WriteKeyValuesRepo<Key, Value>.caching(
 open class FullKeyValuesCacheRepo<Key,Value>(
     protected open val parentRepo: KeyValuesRepo<Key, Value>,
     kvCache: FullKVCache<Key, List<Value>>,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    skipStartInvalidate: Boolean = false
 ) : FullWriteKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, scope),
     KeyValuesRepo<Key, Value>,
     ReadKeyValuesRepo<Key, Value> by FullReadKeyValuesCacheRepo(parentRepo, kvCache) {
+    init {
+        if (!skipStartInvalidate) {
+            scope.launchSafelyWithoutExceptions { invalidate() }
+        }
+    }
+
     override suspend fun clearWithValue(v: Value) {
         doAllWithCurrentPaging {
             keys(v, it).also {
@@ -157,8 +165,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/androidMain/kotlin/dev/inmo/micro_utils/repos/keyvalue/KeyValueStore.kt

@@ -7,6 +7,7 @@ import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.paginate
 import dev.inmo.micro_utils.pagination.utils.reverse
 import dev.inmo.micro_utils.repos.KeyValueRepo
+import dev.inmo.micro_utils.repos.pagination.maxPagePagination
 import kotlinx.coroutines.flow.*
 
 private val cache = HashMap<String, KeyValueStore<*>>()
@@ -159,6 +160,24 @@ class KeyValueStore<T : Any> internal constructor (
         }
     }
 
+    override suspend fun clear() {
+        val keys = mutableSetOf<String>()
+        doWithPagination(maxPagePagination()) {
+            keys(it).also {
+                keys.addAll(it.results)
+            }.nextPageIfNotEmpty()
+        }
+        val success = sharedPreferences.edit().apply {
+            clear()
+        }.commit()
+
+        if (success) {
+            keys.forEach {
+                _onValueRemovedFlow.emit(it)
+            }
+        }
+    }
+
     companion object {
         operator fun <T : Any> invoke(
             context: Context,

repos/common/src/androidMain/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(