launchInCurrentThread

CHANGELOG.md

@@ -1,129 +1,9 @@
 # Changelog
 
-## 0.17.2
-
-* `FSM`:
-    * `DefaultStatesManager.onUpdateContextsConflictResolver` and `DefaultStatesManager.onStartContextsConflictResolver` now return `false` by default
-
-## 0.17.1
-
-* **Hotfix** for absence of jvm dependencies in android modules
-* `Versions`:
-    * `Ktor`: `2.2.3` -> `2.2.4`
-
-## 0.17.0
-
-* `Versions`:
-    * `Kotlin`: `1.7.20` -> `1.8.10`
-    * `Serialization`: `1.4.1` -> `1.5.0`
-    * `KSLog`: `0.5.4` -> `1.0.0`
-    * `AppCompat`: `1.6.0` -> `1.6.1`
-
-## 0.16.13
-
-* `Repos`:
-    * `Generator`:
-        * Module has been created
-
-## 0.16.12
-
-* `Repos`:
-    * `Exposed`:
-        * `CommonExposedRepo.selectByIds` uses `foldRight` by default instead of raw foreach
-* `Koin`:
-    * `Generator`:
-        * Module has been created
-
-## 0.16.11
-
-* `LanguageCodes`:
-    * In android and JVM targets now available `toJavaLocale` and from Java `Locale` conversations from/to
-      `IetfLanguageCode`
-
-## 0.16.10
-
-* `Repos`:
-    * `Cache`:
-        * New transformer type: `ReadCRUDFromKeyValueRepo`
-        * New transformer type: `ReadKeyValueFromCRUDRepo`
-* `Pagination`:
-    * New `paginate` extensions with `reversed` support for `List`/`Set`
-
-## 0.16.9
-
-* `Versions`:
-    * `Koin`: `3.2.2` -> `3.3.2`
-    * `AppCompat`: `1.5.1` -> `1.6.0`
-* `Ktor`:
-    * `Client`
-        * `HttpResponse.bodyOrNull` now retrieve callback to check if body should be received or null
-        * New extension `HttpResponse.bodyOrNullOnNoContent`
-
-## 0.16.8
-
-* `Versions`:
-    * `Ktor`: `2.2.2` -> `2.2.3`
-* `Ktor`:
-    * `Client`
-        * Fixes in `HttpClient.uniUpload`
-    * `Server`
-        * Fixes in `PartData.FileItem.download`
-* `Repos`:
-    * `Cache`:
-        * New type of caches: `FallbackCacheRepo`
-        * Fixes in `Write*` variants of cached repos
-        * New type `ActionWrapper`
-        * New `AutoRecache*` classes for all types of repos as `FallbackCacheRepo`s
-    * `Common`:
-        * New transformations for key-value and key-values vice-verse
-        * Fixes in `FileReadKeyValueRepo`
-
-## 0.16.7
-
-* `Common`:
-    * New extensions `ifTrue`/`ifFalse`/`alsoIfTrue`/`alsoIfFalse`/`letIfTrue`/`letIfFalse`
-    * `Diff` now is serializable
-    * Add `IndexedValue` serializer
-    * `repeatOnFailure` extending: now you may pass any lambda to check if continue to try/do something
-    * `Compose`:
-        * New extension `MutableState.asState`
-* `Coroutines`:
-    * `Compose`:
-        * All the `Flow` conversations to compose `State`/`MutableState`/`SnapshotStateList`/`List` got several new
-        parameters
-        * `Flow.toMutableState` now is deprecated in favor to `asMutableComposeState`
-* `Repos`:
-    * `Cache`:
-        * New type `FullCacheRepo`
-        * New type `CommonCacheRepo`
-        * `CacheRepo` got `invalidate` method. It will fully reload `FullCacheRepo` and just clear `CommonCacheRepo`
-        * New extensions `KVCache.actualizeAll`
-
-## 0.16.6
-
-* `Startup`:
-    * `Launcher`:
-        * Improvements in `StartLauncherPlugin#start` methods
-        * Add opportunity to pass second argument on `JVM` platform as log level
-* `Repos`:
-    * `Ktor`:
-        * `Client`:
-            * All clients repos got opportunity to customize their flows
-    * `Exposed`:
-        * Extensions `eqOrIsNull` and `neqOrIsNotNull` for `Column`
-
-## 0.16.5
-
-* `Versions`:
-    * `Ktor`: `2.2.1` -> `2.2.2`
-
-## 0.16.4
-
-* `Coroutines`:
-    * Create `launchInCurrentThread`
-
 ## 0.16.3
 
+* `Coroutines`:
+    * Create `launchInCurrentThread`
 * `Startup`:
     * `Launcher`:
         * All starting API have been moved into `StartLauncherPlugin` and do not require serialize/deserialize cycle for now

build.gradle

@@ -9,7 +9,6 @@ buildscript {
     dependencies {
         classpath libs.buildscript.kt.gradle
         classpath libs.buildscript.kt.serialization
-        classpath libs.buildscript.kt.ksp
         classpath libs.buildscript.jb.dokka
         classpath libs.buildscript.gh.release
         classpath libs.buildscript.android.gradle

common/build.gradle

@@ -18,7 +18,6 @@ kotlin {
                 api project(":micro_utils.coroutines")
                 api libs.android.fragment
             }
-            dependsOn jvmMain
         }
     }
 }

common/compose/src/commonMain/kotlin/dev/inmo/micro_utils/common/compose/MutableStateAsState.kt

@@ -1,10 +0,0 @@
-package dev.inmo.micro_utils.common.compose
-
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.State
-import androidx.compose.runtime.derivedStateOf
-
-/**
- * Converts current [MutableState] to immutable [State] using [derivedStateOf]
- */
-fun <T> MutableState<T>.asState(): State<T> = derivedStateOf { this.value }

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

@@ -2,8 +2,6 @@
 
 package dev.inmo.micro_utils.common
 
-import kotlinx.serialization.Serializable
-
 private inline fun <T> getObject(
     additional: MutableList<T>,
     iterator: Iterator<T>
@@ -26,14 +24,13 @@ private inline fun <T> getObject(
  *
  * @see calculateDiff
  */
-@Serializable
 data class Diff<T> internal constructor(
-    val removed: List<@Serializable(IndexedValueSerializer::class) IndexedValue<T>>,
+    val removed: List<IndexedValue<T>>,
     /**
      * Old-New values pairs
      */
-    val replaced: List<Pair<@Serializable(IndexedValueSerializer::class) IndexedValue<T>, @Serializable(IndexedValueSerializer::class) IndexedValue<T>>>,
-    val added: List<@Serializable(IndexedValueSerializer::class) IndexedValue<T>>
+    val replaced: List<Pair<IndexedValue<T>, IndexedValue<T>>>,
+    val added: List<IndexedValue<T>>
 )
 
 private inline fun <T> performChanges(

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

@@ -1,43 +0,0 @@
-package dev.inmo.micro_utils.common
-
-inline fun <T> Boolean.letIfTrue(block: () -> T): T? {
-    return if (this) {
-        block()
-    } else {
-        null
-    }
-}
-
-inline fun <T> Boolean.letIfFalse(block: () -> T): T? {
-    return if (this) {
-        null
-    } else {
-        block()
-    }
-}
-
-inline fun Boolean.alsoIfTrue(block: () -> Unit): Boolean {
-    letIfTrue(block)
-    return this
-}
-
-inline fun Boolean.alsoIfFalse(block: () -> Unit): Boolean {
-    letIfFalse(block)
-    return this
-}
-
-inline fun <T> Boolean.ifTrue(block: () -> T): T? {
-    return if (this) {
-        block()
-    } else {
-        null
-    }
-}
-
-inline fun <T> Boolean.ifFalse(block: () -> T): T? {
-    return if (this) {
-        null
-    } else {
-        block()
-    }
-}

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

@@ -1,30 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.Serializer
-import kotlinx.serialization.builtins.PairSerializer
-import kotlinx.serialization.builtins.serializer
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-
-class IndexedValueSerializer<T>(private val subSerializer: KSerializer<T>) : KSerializer<IndexedValue<T>> {
-    private val originalSerializer = PairSerializer(Int.serializer(), subSerializer)
-    override val descriptor: SerialDescriptor
-        get() = originalSerializer.descriptor
-
-    override fun deserialize(decoder: Decoder): IndexedValue<T> {
-        val pair = originalSerializer.deserialize(decoder)
-        return IndexedValue(
-            pair.first,
-            pair.second
-        )
-    }
-
-    override fun serialize(encoder: Encoder, value: IndexedValue<T>) {
-        originalSerializer.serialize(
-            encoder,
-            Pair(value.index, value.value)
-        )
-    }
-}

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

@@ -1,27 +1,5 @@
 package dev.inmo.micro_utils.common
 
-/**
- * Executes the given [action] until getting of successful result specified number of [times].
- *
- * A zero-based index of current iteration is passed as a parameter to [action].
- */
-inline fun <R> repeatOnFailure(
-    onFailure: (Throwable) -> Boolean,
-    action: () -> R
-): Result<R> {
-    do {
-        runCatching {
-            action()
-        }.onFailure {
-            if (!onFailure(it)) {
-                return Result.failure(it)
-            }
-        }.onSuccess {
-            return Result.success(it)
-        }
-    } while (true)
-}
-
 /**
  * Executes the given [action] until getting of successful result specified number of [times].
  *
@@ -32,23 +10,12 @@ inline fun <R> repeatOnFailure(
     onEachFailure: (Throwable) -> Unit = {},
     action: (Int) -> R
 ): Optional<R> {
-    var i = 0
-    val result = repeatOnFailure(
-        {
-            onEachFailure(it)
-            if (i < times) {
-                i++
-                true
-            } else {
-                false
-            }
+    repeat(times) {
+        runCatching {
+            action(it)
+        }.onFailure(onEachFailure).onSuccess {
+            return Optional.presented(it)
         }
-    ) {
-        action(i)
-    }
-    return if (result.isSuccess) {
-        Optional.presented(result.getOrThrow())
-    } else {
-        Optional.absent()
     }
+    return Optional.absent()
 }

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

@@ -3,58 +3,24 @@ package dev.inmo.micro_utils.coroutines.compose
 import androidx.compose.runtime.*
 import androidx.compose.runtime.snapshots.SnapshotStateList
 import dev.inmo.micro_utils.common.applyDiff
-import dev.inmo.micro_utils.coroutines.ExceptionHandler
-import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandlerWithNull
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.withContext
-import kotlin.coroutines.CoroutineContext
 
-/**
- * Each value of [this] [Flow] will trigger [applyDiff] to the result [SnapshotStateList]
- *
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [SnapshotStateList]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- */
 @Suppress("NOTHING_TO_INLINE")
 inline fun <reified T> Flow<List<T>>.asMutableComposeListState(
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    noinline onException: ExceptionHandler<List<T>?> = defaultSafelyWithoutExceptionHandlerWithNull,
+    scope: CoroutineScope
 ): SnapshotStateList<T> {
     val state = mutableStateListOf<T>()
-    val changeBlock: suspend (List<T>) -> Unit = useContextOnChange ?.let {
-        {
-            withContext(useContextOnChange) {
-                state.applyDiff(it)
-            }
-        }
-    } ?: {
+    subscribeSafelyWithoutExceptions(scope) {
         state.applyDiff(it)
     }
-    subscribeSafelyWithoutExceptions(scope, onException, changeBlock)
     return state
 }
 
-/**
- * In fact, it is just classcast of [asMutableComposeListState] to [List]
- *
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [List]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- *
- * @return Changing in time [List] which follow [Flow] values
- */
 @Suppress("NOTHING_TO_INLINE")
 inline fun <reified T> Flow<List<T>>.asComposeList(
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    noinline onException: ExceptionHandler<List<T>?> = defaultSafelyWithoutExceptionHandlerWithNull,
-): List<T> = asMutableComposeListState(scope, useContextOnChange, onException)
+    scope: CoroutineScope
+): List<T> = asMutableComposeListState(scope)
 

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

@@ -1,94 +1,35 @@
 package dev.inmo.micro_utils.coroutines.compose
 
 import androidx.compose.runtime.*
-import dev.inmo.micro_utils.common.compose.asState
-import dev.inmo.micro_utils.coroutines.ExceptionHandler
-import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandlerWithNull
-import dev.inmo.micro_utils.coroutines.doInUI
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.withContext
-import kotlin.coroutines.CoroutineContext
 
-/**
- * Will map [this] [Flow] as [MutableState]. Returned [MutableState] WILL NOT change source [Flow]
- *
- * @param initial First value which will be passed to the result [MutableState]
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [MutableState]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- */
 fun <T> Flow<T>.asMutableComposeState(
     initial: T,
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
+    scope: CoroutineScope
 ): MutableState<T> {
     val state = mutableStateOf(initial)
-    val changeBlock: suspend (T) -> Unit = useContextOnChange ?.let {
-        {
-            withContext(useContextOnChange) {
-                state.value = it
-            }
-        }
-    } ?: {
-        state.value = it
-    }
-    subscribeSafelyWithoutExceptions(scope, onException, block = changeBlock)
+    subscribeSafelyWithoutExceptions(scope) { state.value = it }
     return state
 }
 
-/**
- * Will map [this] [StateFlow] as [MutableState]. Returned [MutableState] WILL NOT change source [StateFlow].
- * This conversation will pass its [StateFlow.value] as the first value
- *
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [MutableState]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- */
 @Suppress("NOTHING_TO_INLINE")
 inline fun <T> StateFlow<T>.asMutableComposeState(
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-): MutableState<T> = asMutableComposeState(value, scope, useContextOnChange, onException)
+    scope: CoroutineScope
+): MutableState<T> = asMutableComposeState(value, scope)
 
-/**
- * Will create [MutableState] using [asMutableComposeState] and use [asState] to convert it as immutable state
- *
- * @param initial First value which will be passed to the result [State]
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [State]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- */
 fun <T> Flow<T>.asComposeState(
     initial: T,
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
+    scope: CoroutineScope
 ): State<T> {
-    val state = asMutableComposeState(initial, scope, useContextOnChange, onException)
-    return state.asState()
+    val state = asMutableComposeState(initial, scope)
+    return derivedStateOf { state.value }
 }
 
-/**
- * Will map [this] [StateFlow] as [State]. This conversation will pass its [StateFlow.value] as the first value
- *
- * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [State]
- * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
- * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
- * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
- */
 @Suppress("NOTHING_TO_INLINE")
 inline fun <T> StateFlow<T>.asComposeState(
-    scope: CoroutineScope,
-    useContextOnChange: CoroutineContext? = Dispatchers.Main,
-    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-): State<T> = asComposeState(value, scope, useContextOnChange, onException)
+    scope: CoroutineScope
+): State<T> = asComposeState(value, scope)
 

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

@@ -7,15 +7,17 @@ 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)
+): MutableState<T> {
+    val state = mutableStateOf(initial)
+    subscribeSafelyWithoutExceptions(scope) { state.value = it }
+    return state
+}
 
-@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)
+): MutableState<T> = toMutableState(value, scope)
 

defaultAndroidSettings.gradle

@@ -1,5 +1,30 @@
 apply plugin: 'com.getkeepsafe.dexcount'
 
+ext {
+    jvmKotlinFolderFile = {
+        String sep = File.separator
+        return new File("${project.projectDir}${sep}src${sep}jvmMain${sep}kotlin")
+    }
+
+    enableIncludingJvmCodeInAndroidPart = {
+        File jvmKotlinFolder = jvmKotlinFolderFile()
+        if (jvmKotlinFolder.exists()) {
+            android.sourceSets.main.java.srcDirs += jvmKotlinFolder.path
+        }
+    }
+
+    disableIncludingJvmCodeInAndroidPart = {
+        File jvmKotlinFolder = jvmKotlinFolderFile()
+        String[] oldDirs = android.sourceSets.main.java.srcDirs
+        android.sourceSets.main.java.srcDirs = []
+        for (oldDir in oldDirs) {
+            if (oldDir != jvmKotlinFolder.path) {
+                android.sourceSets.main.java.srcDirs += oldDir
+            }
+        }
+    }
+}
+
 android {
     compileSdkVersion libs.versions.android.props.compileSdk.get().toInteger()
     buildToolsVersion libs.versions.android.props.buildTools.get()
@@ -33,4 +58,10 @@ android {
     kotlinOptions {
         jvmTarget = JavaVersion.VERSION_1_8.toString()
     }
+
+    sourceSets {
+        String sep = File.separator
+        main.java.srcDirs += "src${sep}main${sep}kotlin"
+        enableIncludingJvmCodeInAndroidPart()
+    }
 }

extensions.gradle

@@ -29,6 +29,6 @@ allprojects {
         defaultAndroidSettingsPresetPath = "${rootProject.projectDir.absolutePath}/defaultAndroidSettings.gradle"
 
         publishGradlePath = "${rootProject.projectDir.absolutePath}/publish.gradle"
-        publishJvmOnlyPath = "${rootProject.projectDir.absolutePath}/jvm.publish.gradle"
+        publishMavenPath = "${rootProject.projectDir.absolutePath}/maven.publish.gradle"
     }
 }

fsm/common/src/commonMain/kotlin/dev/inmo/micro_utils/fsm/common/managers/DefaultStatesManager.kt

@@ -48,8 +48,8 @@ interface DefaultStatesManagerRepo<T : State> {
  */
 open class DefaultStatesManager<T : State>(
     protected val repo: DefaultStatesManagerRepo<T> = InMemoryDefaultStatesManagerRepo(),
-    protected val onStartContextsConflictResolver: suspend (current: T, new: T) -> Boolean = { _, _ -> false },
-    protected val onUpdateContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean = { _, _, _ -> false }
+    protected val onStartContextsConflictResolver: suspend (current: T, new: T) -> Boolean = { _, _ -> true },
+    protected val onUpdateContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean = { _, _, _ -> true }
 ) : StatesManager<T> {
     protected val _onChainStateUpdated = MutableSharedFlow<Pair<T, T>>(0)
     override val onChainStateUpdated: Flow<Pair<T, T>> = _onChainStateUpdated.asSharedFlow()

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.17.2
-android_code_version=184
+version=0.16.3
+android_code_version=171

gradle/libs.versions.toml

@@ -1,40 +1,37 @@
 [versions]
 
-kt = "1.8.10"
-kt-serialization = "1.5.0"
+kt = "1.7.20"
+kt-serialization = "1.4.1"
 kt-coroutines = "1.6.4"
 
-kslog = "1.0.0"
+kslog = "0.5.4"
 
-jb-compose = "1.3.1-rc01"
+jb-compose = "1.2.2"
 jb-exposed = "0.41.1"
 jb-dokka = "1.7.20"
 
 klock = "3.4.0"
-uuid = "0.7.0"
+uuid = "0.6.0"
 
-ktor = "2.2.4"
+ktor = "2.2.1"
 
 gh-release = "2.4.1"
 
-koin = "3.3.2"
+koin = "3.2.2"
 
-ksp = "1.8.10-1.0.9"
-kotlin-poet = "1.12.0"
-
-android-gradle = "7.3.1"
-dexcount = "4.0.0"
+android-gradle = "7.3.0"
+dexcount = "3.1.0"
 
 android-coreKtx = "1.9.0"
 android-recyclerView = "1.2.1"
-android-appCompat = "1.6.1"
+android-appCompat = "1.5.1"
 android-fragment = "1.5.5"
-android-espresso = "3.5.1"
-android-test = "1.1.5"
+android-espresso = "3.4.0"
+android-test = "1.1.3"
 
 android-props-minSdk = "21"
 android-props-compileSdk = "33"
-android-props-buildTools = "33.0.1"
+android-props-buildTools = "33.0.0"
 
 [libraries]
 
@@ -86,16 +83,9 @@ android-test-junit = { module = "androidx.test.ext:junit", version.ref = "androi
 kt-test-js = { module = "org.jetbrains.kotlin:kotlin-test-js", version.ref = "kt" }
 kt-test-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kt" }
 
-# ksp dependencies
-
-kotlin-poet = { module = "com.squareup:kotlinpoet-ksp", version.ref = "kotlin-poet" }
-ksp = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp" }
-
-# Buildscript
 
 buildscript-kt-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kt" }
 buildscript-kt-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kt" }
-buildscript-kt-ksp = { module = "com.google.devtools.ksp:symbol-processing-gradle-plugin", version.ref = "ksp" }
 buildscript-jb-dokka = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "jb-dokka" }
 buildscript-gh-release = { module = "com.github.breadmoirai:github-release", version.ref = "gh-release" }
 buildscript-android-gradle = { module = "com.android.tools.build:gradle", version.ref = "android-gradle" }

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.5.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

jvm.publish.gradle

@@ -1,118 +0,0 @@
-apply plugin: 'maven-publish'
-
-task javadocJar(type: Jar) {
-    from javadoc
-    classifier = 'javadoc'
-}
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    classifier = 'sources'
-}
-
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from components.java
-
-            artifact javadocJar
-            artifact sourcesJar
-
-            pom {
-                resolveStrategy = Closure.DELEGATE_FIRST
-
-                description = "It is set of projects with micro tools for avoiding of routines coding"
-                name = "${project.name}"
-                url = "https://github.com/InsanusMokrassar/MicroUtils/"
-
-                scm {
-                    developerConnection = "scm:git:[fetch=]https://github.com/InsanusMokrassar/MicroUtils.git[push=]https://github.com/InsanusMokrassar/MicroUtils.git"
-                    url = "https://github.com/InsanusMokrassar/MicroUtils.git"
-                }
-
-                developers {
-                    
-                        developer {
-                            id = "InsanusMokrassar"
-                            name = "Aleksei Ovsiannikov"
-                            email = "ovsyannikov.alexey95@gmail.com"
-                        }
-                    
-
-                        developer {
-                            id = "000Sanya"
-                            name = "Syrov Aleksandr"
-                            email = "000sanya.000sanya@gmail.com"
-                        }
-                    
-                }
-
-                licenses {
-                    
-                        license {
-                            name = "Apache Software License 2.0"
-                            url = "https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"
-                        }
-                    
-                }
-            }
-            repositories {
-                if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
-                    maven {
-                        name = "GithubPackages"
-                        url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
-                
-                        credentials {
-                            username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
-                            password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
-                        }
-                
-                    }
-                }
-                if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
-                    maven {
-                        name = "Gitea"
-                        url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
-                
-                        credentials(HttpHeaderCredentials) {
-                            name = "Authorization"
-                            value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
-                        }
-                
-                        authentication {
-                            header(HttpHeaderAuthentication)
-                        }
-                
-                    }
-                }
-                if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
-                    maven {
-                        name = "sonatype"
-                        url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
-                
-                        credentials {
-                            username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
-                            password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
-                        }
-                
-                    }
-                }
-            }
-        }
-    }
-}
-
-if (project.hasProperty("signing.gnupg.keyName")) {
-    apply plugin: 'signing'
-    
-    signing {
-        useGpgCmd()
-    
-        sign publishing.publications
-    }
-    
-    task signAll {
-        tasks.withType(Sign).forEach {
-            dependsOn(it)
-        }
-    }
-}

jvm.publish.kpsb

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

koin/generator/README.md

@@ -1,100 +0,0 @@
-# Koin generator
-
-It is Kotlin Symbol Processing generator for `Koin` module in `MicroUtils`.
-
-1. [What may do this generator](#what-may-do-this-generator)
-2. [How to add generator](#how-to-add-generator)
-
-## What may do this generator
-
-Let's imagine you want to have shortcuts in koin, to get something easily:
-
-```kotlin
-val koin: Koin// some initialization
-
-val someUrl = koin.serverUrl
-```
-
-So, in that case you may mark containing file with next annotation (in the beginning of file):
-
-```kotlin
-@file:GenerateKoinDefinition("serverUrl", String::class, nullable = false)
-```
-
-If file is called like `Sample.kt`, will be generated file `GeneratedDefinitionsSample.kt` with next content:
-
-```kotlin
-public val Scope.serverUrl: String
-  get() = get(named("serverUrl"))
-
-public val Koin.serverUrl: String
-  get() = get(named("serverUrl"))
-
-public fun Module.serverUrlSingle(createdAtStart: Boolean = false,
-    definition: Definition<String>): KoinDefinition<String> =
-    single(named("serverUrl"), createdAtStart = createdAtStart, definition = definition)
-
-public fun Module.serverUrlFactory(definition: Definition<String>):
-    KoinDefinition<String> = factory(named("serverUrl"), definition = definition)
-```
-
-Besides, you may use the generics:
-
-```kotlin
-@file:GenerateKoinDefinition("sampleInfo", Sample::class, G1::class, G2::class, nullable = false)
-```
-
-Will generate:
-
-```kotlin
-public val Scope.sampleInfo: Sample<G1, G2>
-  get() = get(named("sampleInfo"))
-
-public val Koin.sampleInfo: Sample<G1, G2>
-  get() = get(named("sampleInfo"))
-
-public fun Module.sampleInfoSingle(createdAtStart: Boolean = false,
-    definition: Definition<Sample<G1, G2>>): KoinDefinition<Sample<G1, G2>> =
-    single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
-
-public fun Module.sampleInfoFactory(definition: Definition<Sample<G1, G2>>):
-    KoinDefinition<Sample<G1, G2>> = factory(named("sampleInfo"), definition = definition)
-```
-
-In case you wish not to generate single:
-
-```kotlin
-@file:GenerateKoinDefinition("sampleInfo", Sample::class, G1::class, G2::class, nullable = false, generateSingle = false)
-```
-
-And you will take next code:
-
-```kotlin
-public val Scope.sampleInfo: Sample<G1, G2>
-  get() = get(named("sampleInfo"))
-
-public val Koin.sampleInfo: Sample<G1, G2>
-  get() = get(named("sampleInfo"))
-
-public fun Module.sampleInfoFactory(definition: Definition<Sample<G1, G2>>):
-    KoinDefinition<Sample<G1, G2>> = factory(named("sampleInfo"), definition = definition)
-```
-
-## How to add generator
-
-**Note: $ksp_version in the samples above is equal to supported `ksp` version presented in `/gradle/libs.versions.toml` of project**
-
-**Note: $microutils_version in the version of MicroUtils library in your project**
-
-1. Add `classpath` in `build.gradle` (`classpath "com.google.devtools.ksp:symbol-processing-gradle-plugin:$ksp_version"`)
-2. Add plugin to the plugins list of your module: `id "com.google.devtools.ksp"`
-3. In `dependencies` block add to the required target/compile the dependency `dev.inmo:micro_utils.koin.generator:$microutils_version`:
-   ```groovy
-    dependencies {
-        add("kspCommonMainMetadata", "dev.inmo:micro_utils.koin.generator:$microutils_version") // will work in commonMain of your multiplatform module
-        add("kspJvm", "dev.inmo:micro_utils.koin.generator:$microutils_version") // will work in main of your JVM module
-    }
-    
-    ksp { // this generator do not require any arguments and we should left `ksp` empty
-    }
-    ```

koin/generator/build.gradle

@@ -1,15 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.jvm"
-}
-
-apply from: "$publishJvmOnlyPath"
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    api project(":micro_utils.koin")
-    api libs.kotlin.poet
-    api libs.ksp
-}

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

@@ -1,178 +0,0 @@
-package dev.inmo.micro_utils.koin.generator
-
-import com.google.devtools.ksp.KSTypeNotPresentException
-import com.google.devtools.ksp.KSTypesNotPresentException
-import com.google.devtools.ksp.KspExperimental
-import com.google.devtools.ksp.getAnnotationsByType
-import com.google.devtools.ksp.processing.CodeGenerator
-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.squareup.kotlinpoet.ClassName
-import com.squareup.kotlinpoet.FileSpec
-import com.squareup.kotlinpoet.FunSpec
-import com.squareup.kotlinpoet.ParameterSpec
-import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
-import com.squareup.kotlinpoet.PropertySpec
-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.GenerateKoinDefinition
-import org.koin.core.Koin
-import org.koin.core.module.Module
-import org.koin.core.scope.Scope
-import java.io.File
-import kotlin.reflect.KClass
-
-class Processor(
-    private val codeGenerator: CodeGenerator
-) : SymbolProcessor {
-    private val definitionClassName = ClassName("org.koin.core.definition", "Definition")
-    private val koinDefinitionClassName = ClassName("org.koin.core.definition", "KoinDefinition")
-
-    @OptIn(KspExperimental::class)
-    override fun process(resolver: Resolver): List<KSAnnotated> {
-        resolver.getSymbolsWithAnnotation(
-            GenerateKoinDefinition::class.qualifiedName!!
-        ).filterIsInstance<KSFile>().forEach { ksFile ->
-            FileSpec.builder(
-                ksFile.packageName.asString(),
-                "GeneratedDefinitions${ksFile.fileName.removeSuffix(".kt")}"
-            ).apply {
-                addFileComment(
-                    """
-                        THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
-                        TO REGENERATE IT JUST DELETE FILE
-                        ORIGINAL FILE: ${ksFile.fileName}
-                    """.trimIndent()
-                )
-                ksFile.getAnnotationsByType(GenerateKoinDefinition::class).forEach {
-                    val type = runCatching {
-                        it.type.asTypeName()
-                    }.getOrElse { e ->
-                        if (e is KSTypeNotPresentException) {
-                            e.ksType.toClassName()
-                        } else {
-                            throw e
-                        }
-                    }
-                    val targetType = runCatching {
-                        type.parameterizedBy(*(it.typeArgs.takeIf { it.isNotEmpty() } ?.map { it.asTypeName() } ?.toTypedArray() ?: return@runCatching type))
-                    }.getOrElse { e ->
-                        when (e) {
-                            is KSTypeNotPresentException -> e.ksType.toClassName()
-                        }
-                        if (e is KSTypesNotPresentException) {
-                            type.parameterizedBy(*e.ksTypes.map { it.toTypeName() }.toTypedArray())
-                        } else {
-                            throw e
-                        }
-                    }.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)
-                    addGetterProperty(Koin::class)
-
-                    if (it.generateSingle) {
-                        addFunction(
-                            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(
-                    File(ksFile.filePath).parent,
-                    "GeneratedDefinitions${ksFile.fileName}"
-                ).takeIf { !it.exists() } ?.apply {
-                    parentFile.mkdirs()
-
-                    writer().use { writer ->
-                        it.writeTo(writer)
-                    }
-                }
-            }
-        }
-
-        return emptyList()
-    }
-}

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

@@ -1,11 +0,0 @@
-package dev.inmo.micro_utils.koin.generator
-
-import com.google.devtools.ksp.processing.SymbolProcessor
-import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
-import com.google.devtools.ksp.processing.SymbolProcessorProvider
-
-class Provider : SymbolProcessorProvider {
-    override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor = Processor(
-        environment.codeGenerator
-    )
-}

koin/generator/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

@@ -1 +0,0 @@
-dev.inmo.micro_utils.koin.generator.Provider

koin/generator/test/build.gradle

@@ -1,27 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.multiplatform"
-    id "org.jetbrains.kotlin.plugin.serialization"
-    id "com.android.library"
-    id "com.google.devtools.ksp"
-}
-
-apply from: "$mppProjectWithSerializationPresetPath"
-
-
-kotlin {
-    sourceSets {
-        commonMain {
-            dependencies {
-                api project(":micro_utils.koin")
-            }
-        }
-    }
-}
-
-
-dependencies {
-    add("kspCommonMainMetadata", project(":micro_utils.koin.generator"))
-}
-
-ksp {
-}

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

@@ -1,38 +0,0 @@
-// THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
-// TO REGENERATE IT JUST DELETE FILE
-// ORIGINAL FILE: Test.kt
-package dev.inmo.micro_utils.koin.generator.test
-
-import kotlin.Boolean
-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.qualifier.named
-import org.koin.core.scope.Scope
-
-/**
- * @return Definition by key "sampleInfo"
- */
-public val Scope.sampleInfo: Test<String>
-  get() = get(named("sampleInfo"))
-
-/**
- * @return Definition by key "sampleInfo"
- */
-public val Koin.sampleInfo: Test<String>
-  get() = get(named("sampleInfo"))
-
-/**
- * Will register [definition] with [org.koin.core.module.Module.single] and key "sampleInfo"
- */
-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.factory] and key "sampleInfo"
- */
-public fun Module.sampleInfoFactory(definition: Definition<Test<String>>):
-    KoinDefinition<Test<String>> = factory(named("sampleInfo"), definition = definition)

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

@@ -1,13 +0,0 @@
-@file:GenerateKoinDefinition("sampleInfo", Test::class, String::class, nullable = false)
-package dev.inmo.micro_utils.koin.generator.test
-
-import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition
-import org.koin.core.Koin
-
-class Test<T>(
-    koin: Koin
-) {
-    init {
-        koin.sampleInfo
-    }
-}

koin/generator/test/src/main/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest package="dev.inmo.micro_utils.koin.generator.test"/>

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

@@ -1,28 +0,0 @@
-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 GenerateKoinDefinition(
-    val name: String,
-    val type: KClass<*>,
-    vararg val typeArgs: KClass<*>,
-    val nullable: Boolean = true,
-    val generateSingle: Boolean = true,
-    val generateFactory: Boolean = true
-)

koin/src/jvmMain/kotlin/FactoryWithBinds.kt

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.koin
 
 import org.koin.core.definition.Definition
-import org.koin.core.definition.KoinDefinition
 import org.koin.core.instance.InstanceFactory
 import org.koin.core.module.Module
 import org.koin.core.qualifier.Qualifier
@@ -14,7 +13,7 @@ inline fun <reified T : Any> Module.factoryWithBinds(
     qualifier: Qualifier? = null,
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): KoinDefinition<*> {
+): Pair<Module, InstanceFactory<*>> {
     return factory(qualifier, definition) binds (T::class.allSuperclasses.filter(bindFilter).toTypedArray())
 }
 
@@ -22,7 +21,7 @@ inline fun <reified T : Any> Module.factoryWithBinds(
     qualifier: String,
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): KoinDefinition<*> {
+): Pair<Module, InstanceFactory<*>> {
     return factory(qualifier, definition) binds (T::class.allSuperclasses.filter(bindFilter).toTypedArray())
 }
 

koin/src/jvmMain/kotlin/FactoryWithBindsAndRandomQualifier.kt

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.koin
 
 import org.koin.core.definition.Definition
-import org.koin.core.definition.KoinDefinition
 import org.koin.core.instance.InstanceFactory
 import org.koin.core.module.Module
 import kotlin.reflect.KClass
@@ -9,6 +8,6 @@ import kotlin.reflect.KClass
 inline fun <reified T : Any> Module.factoryWithRandomQualifierAndBinds(
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): KoinDefinition<*> {
+): Pair<Module, InstanceFactory<*>> {
     return factoryWithBinds(RandomQualifier(), bindFilter, definition)
 }

koin/src/jvmMain/kotlin/SignleWithBinds.kt

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.koin
 
 import org.koin.core.definition.Definition
-import org.koin.core.definition.KoinDefinition
 import org.koin.core.instance.InstanceFactory
 import org.koin.core.module.Module
 import org.koin.core.qualifier.Qualifier
@@ -15,7 +14,7 @@ inline fun <reified T : Any> Module.singleWithBinds(
     createdAtStart: Boolean = false,
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): KoinDefinition<*> {
+): Pair<Module, InstanceFactory<*>> {
     return single(qualifier, createdAtStart, definition) binds (T::class.allSuperclasses.filter(bindFilter).toTypedArray())
 }
 
@@ -25,7 +24,7 @@ inline fun <reified T : Any> Module.singleWithBinds(
     createdAtStart: Boolean = false,
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): KoinDefinition<*> {
+): Pair<Module, InstanceFactory<*>> {
     return single(qualifier, createdAtStart, definition) binds (T::class.allSuperclasses.filter(bindFilter).toTypedArray())
 }
 

koin/src/jvmMain/kotlin/SingleWithBindsAndRandomQualifier.kt

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.koin
 
 import org.koin.core.definition.Definition
-import org.koin.core.definition.KoinDefinition
 import org.koin.core.instance.InstanceFactory
 import org.koin.core.module.Module
 import kotlin.reflect.KClass
@@ -10,6 +9,6 @@ inline fun <reified T : Any> Module.singleWithRandomQualifierAndBinds(
     createdAtStart: Boolean = false,
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): KoinDefinition<*> {
+): Pair<Module, InstanceFactory<*>> {
     return singleWithBinds(RandomQualifier(), createdAtStart, bindFilter, definition)
 }

ktor/client/build.gradle

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

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

@@ -4,10 +4,6 @@ import io.ktor.client.call.body
 import io.ktor.client.statement.HttpResponse
 import io.ktor.http.HttpStatusCode
 
-suspend inline fun <reified T : Any> HttpResponse.bodyOrNull(
-    statusFilter: (HttpResponse) -> Boolean = { it.status == HttpStatusCode.OK }
-) = takeIf(statusFilter) ?.body<T>()
-
-suspend inline fun <reified T : Any> HttpResponse.bodyOrNullOnNoContent() = bodyOrNull<T> {
-    it.status != HttpStatusCode.NoContent
-}
+suspend inline fun <reified T : Any> HttpResponse.bodyOrNull() = takeIf {
+    status == HttpStatusCode.OK
+} ?.body<T>()

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

@@ -19,7 +19,7 @@ import kotlinx.coroutines.isActive
  * connection. Must return true in case if must be reconnected. By default always reconnecting
  */
 @Warning("This feature is internal and should not be used directly. It is can be changed without any notification and warranty on compile-time or other guaranties")
-inline fun <T : Any> openBaseWebSocketFlow(
+inline fun <reified T : Any> openBaseWebSocketFlow(
     noinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
     noinline webSocketSessionRequest: suspend SendChannel<T>.() -> Unit
 ): Flow<T> {
@@ -57,7 +57,7 @@ inline fun <reified T : Any> HttpClient.openWebSocketFlow(
 ): Flow<T> {
     pluginOrNull(WebSockets) ?: error("Plugin $WebSockets must be installed for using createStandardWebsocketFlow")
 
-    return openBaseWebSocketFlow(checkReconnection) {
+    return openBaseWebSocketFlow<T>(checkReconnection) {
         val block: suspend DefaultClientWebSocketSession.() -> Unit = {
             while (isActive) {
                 send(receiveDeserialized<T>())

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

@@ -17,11 +17,8 @@ import io.ktor.http.HttpStatusCode
 import io.ktor.http.Parameters
 import io.ktor.http.content.PartData
 import kotlinx.serialization.DeserializationStrategy
-import kotlinx.serialization.InternalSerializationApi
-import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.StringFormat
 import kotlinx.serialization.encodeToString
-import kotlinx.serialization.serializer
 import java.io.File
 
 /**
@@ -32,7 +29,6 @@ import java.io.File
  * in case you wish to pass other source of multipart binary data than regular file
  * @suppress
  */
-@OptIn(InternalSerializationApi::class)
 actual suspend fun <T> HttpClient.uniUpload(
     url: String,
     data: Map<String, Any>,
@@ -44,8 +40,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     val withBinary = data.values.any { it is File || it is UniUploadFileInfo }
 
     val formData = formData {
-        for (k in data.keys) {
-            val v = data[k] ?: continue
+        data.forEach { (k, v) ->
             when (v) {
                 is File -> append(
                     k,
@@ -65,7 +60,7 @@ actual suspend fun <T> HttpClient.uniUpload(
                 )
                 else -> append(
                     k,
-                    stringFormat.encodeToString(v::class.serializer() as SerializationStrategy<in Any>, v)
+                    stringFormat.encodeToString(v)
                 )
             }
         }
@@ -90,7 +85,7 @@ actual suspend fun <T> HttpClient.uniUpload(
         submitForm(
             url,
             Parameters.build {
-                for (it in formData) {
+                formData.forEach {
                     val formItem = (it as PartData.FormItem)
                     append(it.name!!, it.value)
                 }

ktor/common/build.gradle

@@ -17,8 +17,5 @@ kotlin {
                 api libs.ktor.io
             }
         }
-        androidMain {
-            dependsOn jvmMain
-        }
     }
 }

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

@@ -10,8 +10,8 @@ import java.io.File
 
 fun PartData.FileItem.download(target: File) {
     provider().use { input ->
-        target.outputStream().asOutput().use {
-            input.copyTo(it)
+        target.outputStream().use {
+            input.copyTo(it.asOutput())
         }
     }
 }

language_codes/build.gradle

@@ -5,11 +5,3 @@ plugins {
 }
 
 apply from: "$mppProjectWithSerializationPresetPath"
-
-kotlin {
-    sourceSets {
-        androidMain {
-            dependsOn jvmMain
-        }
-    }
-}

language_codes/src/jvmMain/kotlin/Locale.kt

@@ -1,8 +0,0 @@
-package dev.inmo.micro_utils.language_codes
-
-import java.util.Locale
-
-fun IetfLanguageCode.toJavaLocale(): Locale = Locale.forLanguageTag(code)
-fun IetfLanguageCode?.toJavaLocaleOrDefault(): Locale = this ?.toJavaLocale() ?: Locale.getDefault()
-
-fun Locale.toIetfLanguageCode(): IetfLanguageCode = IetfLanguageCode(toLanguageTag())

mppProjectWithSerialization.gradle

@@ -50,8 +50,6 @@ kotlin {
                 implementation libs.android.espresso
             }
         }
-
-        androidMain.dependsOn jvmMain
     }
 }
 

mppProjectWithSerializationAndCompose.gradle

@@ -61,8 +61,6 @@ kotlin {
                 implementation libs.android.espresso
             }
         }
-
-        androidMain.dependsOn jvmMain
     }
 }
 

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/utils/IterableExtensions.kt

@@ -32,24 +32,6 @@ fun <T> List<T>.paginate(with: Pagination): PaginationResult<T> {
     )
 }
 
-fun <T> List<T>.paginate(with: Pagination, reversed: Boolean): PaginationResult<T> {
-    val actualPagination = with.optionallyReverse(
-        size,
-        reversed
-    )
-
-    val firstIndex = maxOf(actualPagination.firstIndex, 0)
-    val lastIndex = minOf(actualPagination.lastIndexExclusive, size)
-    if (firstIndex > lastIndex) {
-        return emptyPaginationResult()
-    }
-
-    return subList(firstIndex, lastIndex).optionallyReverse(reversed).createPaginationResult(
-        with,
-        size.toLong()
-    )
-}
-
 fun <T> Set<T>.paginate(with: Pagination): PaginationResult<T> {
     return this.drop(with.firstIndex).take(with.size).createPaginationResult(
         with,
@@ -57,20 +39,30 @@ fun <T> Set<T>.paginate(with: Pagination): PaginationResult<T> {
     )
 }
 
-fun <T> Set<T>.paginate(with: Pagination, reversed: Boolean): PaginationResult<T> {
-    val actualPagination = with.optionallyReverse(
-        size,
-        reversed
-    )
-
-    val firstIndex = maxOf(actualPagination.firstIndex, 0)
-    val lastIndex = minOf(actualPagination.lastIndexExclusive, size)
-    if (firstIndex > lastIndex) {
-        return emptyPaginationResult()
+fun <T> Iterable<T>.optionallyReverse(reverse: Boolean): Iterable<T> = when (this) {
+    is List<T> -> optionallyReverse(reverse)
+    is Set<T> -> optionallyReverse(reverse)
+    else -> if (reverse) {
+        reversed()
+    } else {
+        this
     }
-
-    return this.drop(firstIndex).take(lastIndex - firstIndex).optionallyReverse(reversed).createPaginationResult(
-        with,
-        size.toLong()
-    )
+}
+fun <T> List<T>.optionallyReverse(reverse: Boolean): List<T> = if (reverse) {
+    reversed()
+} else {
+    this
+}
+fun <T> Set<T>.optionallyReverse(reverse: Boolean): Set<T> = if (reverse) {
+    reversed().toSet()
+} else {
+    this
+}
+
+inline fun <reified T> Array<T>.optionallyReverse(reverse: Boolean) = if (reverse) {
+    Array(size) {
+        get(lastIndex - it)
+    }
+} else {
+    this
 }

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/utils/OptionallyReverse.kt

@@ -1,29 +0,0 @@
-package dev.inmo.micro_utils.pagination.utils
-
-fun <T> Iterable<T>.optionallyReverse(reverse: Boolean): Iterable<T> = when (this) {
-    is List<T> -> optionallyReverse(reverse)
-    is Set<T> -> optionallyReverse(reverse)
-    else -> if (reverse) {
-        reversed()
-    } else {
-        this
-    }
-}
-fun <T> List<T>.optionallyReverse(reverse: Boolean): List<T> = if (reverse) {
-    reversed()
-} else {
-    this
-}
-fun <T> Set<T>.optionallyReverse(reverse: Boolean): Set<T> = if (reverse) {
-    reversed().toSet()
-} else {
-    this
-}
-
-inline fun <reified T> Array<T>.optionallyReverse(reverse: Boolean) = if (reverse) {
-    Array(size) {
-        get(lastIndex - it)
-    }
-} else {
-    this
-}

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

@@ -10,14 +10,12 @@ open class ReadCRUDCacheRepo<ObjectType, IdType>(
     protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
     protected open val kvCache: KVCache<IdType, ObjectType>,
     protected open val idGetter: (ObjectType) -> IdType
-) : ReadCRUDRepo<ObjectType, IdType> by parentRepo, CommonCacheRepo {
+) : ReadCRUDRepo<ObjectType, IdType> by parentRepo, CacheRepo {
     override suspend fun getById(id: IdType): ObjectType? = kvCache.get(id) ?: (parentRepo.getById(id) ?.also {
         kvCache.set(id, it)
     })
 
     override suspend fun contains(id: IdType): Boolean = kvCache.contains(id) || parentRepo.contains(id)
-
-    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.cached(
@@ -30,7 +28,7 @@ open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>(
     protected open val kvCache: KVCache<IdType, ObjectType>,
     protected open val scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     protected open val idGetter: (ObjectType) -> IdType
-) : WriteCRUDRepo<ObjectType, IdType, InputValueType>, CommonCacheRepo {
+) : WriteCRUDRepo<ObjectType, IdType, InputValueType>, CacheRepo {
     override val newObjectsFlow: Flow<ObjectType> by parentRepo::newObjectsFlow
     override val updatedObjectsFlow: Flow<ObjectType> by parentRepo::updatedObjectsFlow
     override val deletedObjectsIdsFlow: Flow<IdType> by parentRepo::deletedObjectsIdsFlow
@@ -74,8 +72,6 @@ open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>(
 
         return created
     }
-
-    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <ObjectType, IdType, InputType> WriteCRUDRepo<ObjectType, IdType, InputType>.caching(

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

@@ -1,5 +1,3 @@
 package dev.inmo.micro_utils.repos.cache
 
-interface CacheRepo {
-    suspend fun invalidate()
-}
+interface CacheRepo

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

@@ -1,7 +0,0 @@
-package dev.inmo.micro_utils.repos.cache
-
-/**
- * Any inheritor of this should work with next logic: try to take data from some [dev.inmo.micro_utils.repos.cache.cache.KVCache] and,
- * if not exists, take from origin and save to the cache for future reuse
- */
-interface CommonCacheRepo : CacheRepo

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

@@ -1,7 +0,0 @@
-package dev.inmo.micro_utils.repos.cache
-
-/**
- * Any inheritor of this should work with next logic: try to take data from their original repo, if successful - save data to internal
- * [dev.inmo.micro_utils.repos.cache.cache.FullKVCache] or try to take data from that internal cache
- */
-interface FallbackCacheRepo : CacheRepo

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

@@ -10,7 +10,7 @@ import kotlinx.coroutines.flow.*
 open class ReadKeyValueCacheRepo<Key,Value>(
     protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
     protected open val kvCache: KVCache<Key, Value>,
-) : ReadKeyValueRepo<Key,Value> by parentRepo, CommonCacheRepo {
+) : ReadKeyValueRepo<Key,Value> by parentRepo, CacheRepo {
     override suspend fun get(k: Key): Value? = kvCache.get(k) ?: parentRepo.get(k) ?.also { kvCache.set(k, it) }
     override suspend fun contains(key: Key): Boolean = kvCache.contains(key) || parentRepo.contains(key)
 
@@ -23,8 +23,6 @@ open class ReadKeyValueCacheRepo<Key,Value>(
             )
         }
     }
-
-    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
@@ -35,11 +33,9 @@ open class KeyValueCacheRepo<Key,Value>(
     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 {
+) : ReadKeyValueCacheRepo<Key,Value>(parentRepo, kvCache), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo, CacheRepo {
     protected val onNewJob = parentRepo.onNewValue.onEach { kvCache.set(it.first, it.second) }.launchIn(scope)
     protected val onRemoveJob = parentRepo.onValueRemoved.onEach { kvCache.unset(it) }.launchIn(scope)
-
-    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <Key, Value> KeyValueRepo<Key, Value>.cached(

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

@@ -11,7 +11,7 @@ import kotlinx.coroutines.flow.*
 open class ReadKeyValuesCacheRepo<Key,Value>(
     protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
     protected open val kvCache: KVCache<Key, List<Value>>
-) : ReadKeyValuesRepo<Key,Value> by parentRepo, CommonCacheRepo {
+) : ReadKeyValuesRepo<Key,Value> by parentRepo, CacheRepo {
     override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
         return getAll(k, reversed).paginate(
             pagination
@@ -30,8 +30,6 @@ open class ReadKeyValuesCacheRepo<Key,Value>(
         }
     })
     override suspend fun contains(k: Key): Boolean = kvCache.contains(k) || parentRepo.contains(k)
-
-    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <Key, Value> ReadKeyValuesRepo<Key, Value>.cached(
@@ -42,7 +40,7 @@ open class KeyValuesCacheRepo<Key,Value>(
     parentRepo: KeyValuesRepo<Key, Value>,
     kvCache: KVCache<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-) : ReadKeyValuesCacheRepo<Key,Value>(parentRepo, kvCache), KeyValuesRepo<Key,Value>, WriteKeyValuesRepo<Key,Value> by parentRepo, CommonCacheRepo {
+) : ReadKeyValuesCacheRepo<Key,Value>(parentRepo, kvCache), KeyValuesRepo<Key,Value>, WriteKeyValuesRepo<Key,Value> by parentRepo, CacheRepo {
     protected val onNewJob = parentRepo.onNewValue.onEach { (k, v) ->
         kvCache.set(
             k,
@@ -58,8 +56,6 @@ open class KeyValuesCacheRepo<Key,Value>(
     protected val onDataClearedJob = parentRepo.onDataCleared.onEach {
         kvCache.unset(it)
     }.launchIn(scope)
-
-    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <Key, Value> KeyValuesRepo<Key, Value>.cached(

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

@@ -1,37 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.fallback
-
-import dev.inmo.micro_utils.coroutines.runCatchingSafely
-import kotlinx.coroutines.withTimeout
-
-/**
- * Realizations should [wrap] the work with some conditions like retries on exceptions, calling timeout, etc.
- * 
- * @see Timeouted
- * @see Direct
- */
-interface ActionWrapper {
-    /**
-     * Should execute [block] to take the result [T], but may return failure in case when something went wrong.
-     * This method should never throw any [Exception]
-     */
-    suspend fun <T> wrap(block: suspend () -> T): Result<T>
-
-    /**
-     * This type of [ActionWrapper]s will use [withTimeout]([timeoutMillis]) and if original call
-     * will not return anything in that timeout just return [Result] with failure
-     */
-    class Timeouted(private val timeoutMillis: Long) : ActionWrapper {
-        override suspend fun <T> wrap(block: suspend () -> T): Result<T> = runCatchingSafely {
-            withTimeout(timeoutMillis) {
-                block()
-            }
-        }
-    }
-    /**
-     * It is passthrough variant of [ActionWrapper] which will just call incoming block with wrapping into [runCatchingSafely]
-     */
-    object Direct : ActionWrapper {
-
-        override suspend fun <T> wrap(block: suspend () -> T): Result<T> = runCatchingSafely { block() }
-    }
-}

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

@@ -1,36 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.fallback.crud
-
-import dev.inmo.micro_utils.repos.CRUDRepo
-import dev.inmo.micro_utils.repos.WriteCRUDRepo
-import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
-import kotlinx.coroutines.CoroutineScope
-import kotlin.time.Duration.Companion.seconds
-
-open class AutoRecacheCRUDRepo<RegisteredObject, Id, InputObject>(
-    originalRepo: CRUDRepo<RegisteredObject, Id, InputObject>,
-    scope: CoroutineScope,
-    kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
-    recacheDelay: Long = 60.seconds.inWholeMilliseconds,
-    actionWrapper: ActionWrapper = ActionWrapper.Direct,
-    idGetter: (RegisteredObject) -> Id
-) : AutoRecacheReadCRUDRepo<RegisteredObject, Id>(
-    originalRepo,
-    scope,
-    kvCache,
-    recacheDelay,
-    actionWrapper,
-    idGetter
-),
-    WriteCRUDRepo<RegisteredObject, Id, InputObject> by AutoRecacheWriteCRUDRepo(originalRepo, scope, kvCache, idGetter),
-    CRUDRepo<RegisteredObject, Id, InputObject> {
-
-    constructor(
-        originalRepo: CRUDRepo<RegisteredObject, Id, InputObject>,
-        scope: CoroutineScope,
-        originalCallTimeoutMillis: Long,
-        kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
-        recacheDelay: Long = 60.seconds.inWholeMilliseconds,
-        idGetter: (RegisteredObject) -> Id
-    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis), idGetter)
-}

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

@@ -1,86 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.fallback.crud
-
-import dev.inmo.micro_utils.coroutines.runCatchingSafely
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.repos.ReadCRUDRepo
-import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
-import dev.inmo.micro_utils.repos.cache.util.actualizeAll
-import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
-import dev.inmo.micro_utils.repos.set
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import kotlin.time.Duration.Companion.seconds
-
-open class AutoRecacheReadCRUDRepo<RegisteredObject, Id>(
-    protected open val originalRepo: ReadCRUDRepo<RegisteredObject, Id>,
-    protected val scope: CoroutineScope,
-    protected val kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
-    protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,
-    protected val actionWrapper: ActionWrapper = ActionWrapper.Direct,
-    protected val idGetter: (RegisteredObject) -> Id
-) : ReadCRUDRepo<RegisteredObject, Id>, FallbackCacheRepo {
-    val autoUpdateJob = scope.launch {
-        while (isActive) {
-            actualizeAll()
-
-            delay(recacheDelay)
-        }
-    }
-
-    constructor(
-        originalRepo: ReadCRUDRepo<RegisteredObject, Id>,
-        scope: CoroutineScope,
-        originalCallTimeoutMillis: Long,
-        kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
-        recacheDelay: Long = 60.seconds.inWholeMilliseconds,
-        idGetter: (RegisteredObject) -> Id
-    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis), idGetter)
-
-    protected open suspend fun actualizeAll(): Result<Unit> {
-        return runCatchingSafely {
-            kvCache.actualizeAll(originalRepo)
-        }
-    }
-
-    override suspend fun contains(id: Id): Boolean = actionWrapper.wrap {
-        originalRepo.contains(id)
-    }.getOrElse {
-        kvCache.contains(id)
-    }
-
-    override suspend fun count(): Long = actionWrapper.wrap {
-        originalRepo.count()
-    }.getOrElse {
-        kvCache.count()
-    }
-
-    override suspend fun getByPagination(
-        pagination: Pagination
-    ): PaginationResult<RegisteredObject> = actionWrapper.wrap {
-        originalRepo.getByPagination(pagination)
-    }.getOrNull() ?.also {
-        it.results.forEach {
-            kvCache.set(idGetter(it), it)
-        }
-    } ?: kvCache.values(pagination)
-
-    override suspend fun getIdsByPagination(
-        pagination: Pagination
-    ): PaginationResult<Id> = actionWrapper.wrap {
-        originalRepo.getIdsByPagination(pagination)
-    }.getOrElse { kvCache.keys(pagination) }
-
-    override suspend fun getById(id: Id): RegisteredObject? = actionWrapper.wrap {
-        originalRepo.getById(id)
-    }.getOrNull() ?.also {
-        kvCache.set(idGetter(it), it)
-    } ?: kvCache.get(id)
-
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
-}

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

@@ -1,65 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.fallback.crud
-
-import dev.inmo.micro_utils.coroutines.plus
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.micro_utils.repos.UpdatedValuePair
-import dev.inmo.micro_utils.repos.WriteCRUDRepo
-import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
-import dev.inmo.micro_utils.repos.set
-import dev.inmo.micro_utils.repos.unset
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.merge
-
-open class AutoRecacheWriteCRUDRepo<RegisteredObject, Id, InputObject>(
-    protected val originalRepo: WriteCRUDRepo<RegisteredObject, Id, InputObject>,
-    protected val scope: CoroutineScope,
-    protected val kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
-    protected val idGetter: (RegisteredObject) -> Id
-) : WriteCRUDRepo<RegisteredObject, Id, InputObject>, FallbackCacheRepo {
-    override val deletedObjectsIdsFlow: Flow<Id>
-        get() = (originalRepo.deletedObjectsIdsFlow + kvCache.onValueRemoved).distinctUntilChanged()
-    override val newObjectsFlow: Flow<RegisteredObject>
-        get() = (originalRepo.newObjectsFlow + kvCache.onNewValue.map { it.second }).distinctUntilChanged()
-    override val updatedObjectsFlow: Flow<RegisteredObject>
-        get() = originalRepo.updatedObjectsFlow
-
-    private val onRemovingUpdatesListeningJob = originalRepo.deletedObjectsIdsFlow.subscribeSafelyWithoutExceptions(scope) {
-        kvCache.unset(it)
-    }
-
-    private val onNewAndUpdatedObjectsListeningJob = merge(
-        originalRepo.newObjectsFlow,
-        originalRepo.updatedObjectsFlow,
-    ).subscribeSafelyWithoutExceptions(scope) {
-        kvCache.set(idGetter(it), it)
-    }
-
-    override suspend fun update(
-        values: List<UpdatedValuePair<Id, InputObject>>
-    ): List<RegisteredObject> = originalRepo.update(values).onEach {
-        kvCache.set(idGetter(it), it)
-    }
-
-    override suspend fun update(
-        id: Id,
-        value: InputObject
-    ): RegisteredObject? = originalRepo.update(id, value) ?.also {
-        kvCache.set(idGetter(it), it)
-    }
-
-    override suspend fun deleteById(ids: List<Id>) = originalRepo.deleteById(ids).also {
-        kvCache.unset(ids)
-    }
-
-    override suspend fun create(values: List<InputObject>): List<RegisteredObject> = originalRepo.create(values).onEach {
-        kvCache.set(idGetter(it), it)
-    }
-
-    override suspend fun invalidate() {
-        kvCache.clear()
-    }
-}

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

@@ -1,42 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.fallback.keyvalue
-
-import dev.inmo.micro_utils.repos.KeyValueRepo
-import dev.inmo.micro_utils.repos.WriteKeyValueRepo
-import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
-import kotlinx.coroutines.CoroutineScope
-import kotlin.time.Duration.Companion.seconds
-
-open class AutoRecacheKeyValueRepo<Id, RegisteredObject>(
-    override val originalRepo: KeyValueRepo<Id, RegisteredObject>,
-    scope: CoroutineScope,
-    kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
-    recacheDelay: Long = 60.seconds.inWholeMilliseconds,
-    actionWrapper: ActionWrapper = ActionWrapper.Direct,
-    idGetter: (RegisteredObject) -> Id
-) : AutoRecacheReadKeyValueRepo<Id, RegisteredObject> (
-    originalRepo,
-    scope,
-    kvCache,
-    recacheDelay,
-    actionWrapper,
-    idGetter
-),
-    WriteKeyValueRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValueRepo(originalRepo, scope, kvCache),
-    KeyValueRepo<Id, RegisteredObject> {
-
-    constructor(
-        originalRepo: KeyValueRepo<Id, RegisteredObject>,
-        scope: CoroutineScope,
-        originalCallTimeoutMillis: Long,
-        kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
-        recacheDelay: Long = 60.seconds.inWholeMilliseconds,
-        idGetter: (RegisteredObject) -> Id
-    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis), idGetter)
-
-    override suspend fun unsetWithValues(toUnset: List<RegisteredObject>) = originalRepo.unsetWithValues(
-        toUnset
-    ).also {
-        kvCache.unsetWithValues(toUnset)
-    }
-}

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

@@ -1,96 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.fallback.keyvalue
-
-import dev.inmo.micro_utils.coroutines.runCatchingSafely
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
-import dev.inmo.micro_utils.repos.cache.util.actualizeAll
-import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
-import dev.inmo.micro_utils.repos.set
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import kotlin.time.Duration.Companion.seconds
-
-open class AutoRecacheReadKeyValueRepo<Id, RegisteredObject>(
-    protected open val originalRepo: ReadKeyValueRepo<Id, RegisteredObject>,
-    protected val scope: CoroutineScope,
-    protected val kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
-    protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,
-    protected val actionWrapper: ActionWrapper = ActionWrapper.Direct,
-    protected val idGetter: (RegisteredObject) -> Id
-) : ReadKeyValueRepo<Id, RegisteredObject>, FallbackCacheRepo {
-    val autoUpdateJob = scope.launch {
-        while (isActive) {
-            actualizeAll()
-
-            delay(recacheDelay)
-        }
-    }
-
-    constructor(
-        originalRepo: ReadKeyValueRepo<Id, RegisteredObject>,
-        scope: CoroutineScope,
-        originalCallTimeoutMillis: Long,
-        kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
-        recacheDelay: Long = 60.seconds.inWholeMilliseconds,
-        idGetter: (RegisteredObject) -> Id
-    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis), idGetter)
-
-    protected open suspend fun actualizeAll(): Result<Unit> {
-        return runCatchingSafely {
-            kvCache.actualizeAll(originalRepo)
-        }
-    }
-
-    override suspend fun contains(key: Id): Boolean = actionWrapper.wrap {
-        originalRepo.contains(key)
-    }.getOrElse {
-        kvCache.contains(key)
-    }
-
-    override suspend fun count(): Long = actionWrapper.wrap {
-        originalRepo.count()
-    }.getOrElse {
-        kvCache.count()
-    }
-
-    override suspend fun get(k: Id): RegisteredObject? = actionWrapper.wrap {
-        originalRepo.get(k)
-    }.getOrNull() ?.also {
-        kvCache.set(k, it)
-    } ?: kvCache.get(k)
-
-    override suspend fun values(
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<RegisteredObject> = actionWrapper.wrap {
-        originalRepo.values(pagination, reversed)
-    }.getOrNull() ?.also {
-        it.results.forEach {
-            kvCache.set(idGetter(it), it)
-        }
-    } ?: kvCache.values(pagination, reversed)
-
-    override suspend fun keys(
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<Id> = actionWrapper.wrap {
-        originalRepo.keys(pagination, reversed)
-    }.getOrElse { kvCache.keys(pagination, reversed) }
-
-    override suspend fun keys(
-        v: RegisteredObject,
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<Id> = actionWrapper.wrap {
-        originalRepo.keys(v, pagination, reversed)
-    }.getOrElse { kvCache.keys(v, pagination, reversed) }
-
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
-}

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

@@ -1,54 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.fallback.keyvalue
-
-import dev.inmo.micro_utils.coroutines.plus
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.micro_utils.repos.WriteKeyValueRepo
-import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
-import dev.inmo.micro_utils.repos.set
-import dev.inmo.micro_utils.repos.unset
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.distinctUntilChanged
-
-open class AutoRecacheWriteKeyValueRepo<Id, RegisteredObject>(
-    protected val originalRepo: WriteKeyValueRepo<Id, RegisteredObject>,
-    protected val scope: CoroutineScope,
-    protected val kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache()
-) : WriteKeyValueRepo<Id, RegisteredObject>, FallbackCacheRepo {
-    override val onValueRemoved: Flow<Id>
-        get() = (originalRepo.onValueRemoved + kvCache.onValueRemoved).distinctUntilChanged()
-
-    override val onNewValue: Flow<Pair<Id, RegisteredObject>>
-        get() = (originalRepo.onNewValue + kvCache.onNewValue).distinctUntilChanged()
-
-    private val onRemovingUpdatesListeningJob = originalRepo.onValueRemoved.subscribeSafelyWithoutExceptions(scope) {
-        kvCache.unset(it)
-    }
-
-    private val onNewAndUpdatedObjectsListeningJob = originalRepo.onNewValue.subscribeSafelyWithoutExceptions(scope) {
-        kvCache.set(it.first, it.second)
-    }
-
-    override suspend fun unsetWithValues(toUnset: List<RegisteredObject>) = originalRepo.unsetWithValues(
-        toUnset
-    ).also {
-        kvCache.unsetWithValues(toUnset)
-    }
-
-    override suspend fun unset(toUnset: List<Id>) = originalRepo.unset(
-        toUnset
-    ).also {
-        kvCache.unset(toUnset)
-    }
-
-    override suspend fun set(toSet: Map<Id, RegisteredObject>) = originalRepo.set(
-        toSet
-    ).also {
-        kvCache.set(toSet)
-    }
-
-    override suspend fun invalidate() {
-        kvCache.clear()
-    }
-}

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

@@ -1,37 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.fallback.keyvalues
-
-import dev.inmo.micro_utils.repos.KeyValuesRepo
-import dev.inmo.micro_utils.repos.WriteKeyValuesRepo
-import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
-import kotlinx.coroutines.CoroutineScope
-import kotlin.time.Duration.Companion.seconds
-
-open class AutoRecacheKeyValuesRepo<Id, RegisteredObject>(
-    override val originalRepo: KeyValuesRepo<Id, RegisteredObject>,
-    scope: CoroutineScope,
-    kvCache: FullKVCache<Id, List<RegisteredObject>> = FullKVCache(),
-    recacheDelay: Long = 60.seconds.inWholeMilliseconds,
-    actionWrapper: ActionWrapper = ActionWrapper.Direct
-) : AutoRecacheReadKeyValuesRepo<Id, RegisteredObject> (
-    originalRepo,
-    scope,
-    kvCache,
-    recacheDelay,
-    actionWrapper
-),
-    WriteKeyValuesRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValuesRepo(originalRepo, scope, kvCache),
-    KeyValuesRepo<Id, RegisteredObject> {
-
-    constructor(
-        originalRepo: KeyValuesRepo<Id, RegisteredObject>,
-        scope: CoroutineScope,
-        originalCallTimeoutMillis: Long,
-        kvCache: FullKVCache<Id, List<RegisteredObject>> = FullKVCache(),
-        recacheDelay: Long = 60.seconds.inWholeMilliseconds
-    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis))
-
-    override suspend fun clearWithValue(v: RegisteredObject) {
-        super.clearWithValue(v)
-    }
-}

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

@@ -1,145 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.fallback.keyvalues
-
-import dev.inmo.micro_utils.coroutines.runCatchingSafely
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.pagination.changeResultsUnchecked
-import dev.inmo.micro_utils.pagination.createPaginationResult
-import dev.inmo.micro_utils.pagination.emptyPaginationResult
-import dev.inmo.micro_utils.pagination.firstIndex
-import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
-import dev.inmo.micro_utils.pagination.utils.optionallyReverse
-import dev.inmo.micro_utils.pagination.utils.paginate
-import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
-import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
-import dev.inmo.micro_utils.repos.cache.util.actualizeAll
-import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
-import dev.inmo.micro_utils.repos.set
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import kotlin.time.Duration.Companion.seconds
-
-open class AutoRecacheReadKeyValuesRepo<Id, RegisteredObject>(
-    protected open val originalRepo: ReadKeyValuesRepo<Id, RegisteredObject>,
-    protected val scope: CoroutineScope,
-    protected val kvCache: FullKVCache<Id, List<RegisteredObject>> = FullKVCache(),
-    protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,
-    protected val actionWrapper: ActionWrapper = ActionWrapper.Direct
-) : ReadKeyValuesRepo<Id, RegisteredObject>, FallbackCacheRepo {
-    val autoUpdateJob = scope.launch {
-        while (isActive) {
-            actualizeAll()
-
-            delay(recacheDelay)
-        }
-    }
-
-    constructor(
-        originalRepo: ReadKeyValuesRepo<Id, RegisteredObject>,
-        scope: CoroutineScope,
-        originalCallTimeoutMillis: Long,
-        kvCache: FullKVCache<Id, List<RegisteredObject>> = FullKVCache(),
-        recacheDelay: Long = 60.seconds.inWholeMilliseconds
-    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis))
-
-    protected open suspend fun actualizeAll(): Result<Unit> {
-        return runCatchingSafely {
-            kvCache.actualizeAll(originalRepo)
-        }
-    }
-
-    override suspend fun contains(k: Id): Boolean = actionWrapper.wrap {
-        originalRepo.contains(k)
-    }.getOrElse {
-        kvCache.contains(k)
-    }
-
-    override suspend fun count(): Long = actionWrapper.wrap {
-        originalRepo.count()
-    }.getOrElse {
-        kvCache.count()
-    }
-
-    override suspend fun keys(
-        v: RegisteredObject,
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<Id> = actionWrapper.wrap {
-        originalRepo.keys(v, pagination, reversed)
-    }.getOrElse {
-        val results = mutableListOf<Id>()
-
-        val toSkip = pagination.firstIndex
-        var count = 0
-
-        doForAllWithNextPaging {
-            kvCache.keys(pagination, reversed).also {
-                it.results.forEach {
-                    if (kvCache.get(it) ?.contains(v) == true) {
-                        count++
-                        if (count < toSkip || results.size >= pagination.size) {
-                            return@forEach
-                        } else {
-                            results.add(it)
-                        }
-                    }
-                }
-            }
-        }
-
-        return@getOrElse results.createPaginationResult(
-            pagination,
-            count.toLong()
-        )
-    }
-
-    override suspend fun keys(
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<Id> = actionWrapper.wrap {
-        originalRepo.keys(pagination, reversed)
-    }.getOrElse { kvCache.keys(pagination, reversed) }
-
-    override suspend fun get(
-        k: Id,
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<RegisteredObject> = actionWrapper.wrap {
-        originalRepo.get(k, pagination, reversed)
-    }.getOrNull() ?.also {
-        it.results.forEach {
-            kvCache.set(k, ((kvCache.get(k) ?: return@also) + it).distinct())
-        }
-    } ?: kvCache.get(k) ?.run {
-        paginate(pagination.optionallyReverse(size, reversed)).let {
-            if (reversed) {
-                it.changeResultsUnchecked(
-                    it.results.reversed()
-                )
-            } else {
-                it
-            }
-        }
-    } ?: emptyPaginationResult()
-
-    override suspend fun count(k: Id): Long = actionWrapper.wrap {
-        originalRepo.count(k)
-    }.getOrElse {
-        kvCache.get(k) ?.size ?.toLong() ?: 0L
-    }
-
-    override suspend fun contains(k: Id, v: RegisteredObject): Boolean {
-        return (actionWrapper.wrap {
-            originalRepo.contains(k, v)
-        }.getOrNull() ?.also {
-            kvCache.set(k, ((kvCache.get(k) ?: return@also) + v).distinct())
-        }) ?: (kvCache.get(k) ?.contains(v) == true)
-    }
-
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
-}

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

@@ -1,86 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.fallback.keyvalues
-
-import dev.inmo.micro_utils.coroutines.plus
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.micro_utils.pagination.FirstPagePagination
-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.set
-import dev.inmo.micro_utils.repos.unset
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.distinctUntilChanged
-
-open class AutoRecacheWriteKeyValuesRepo<Id, RegisteredObject>(
-    protected val originalRepo: WriteKeyValuesRepo<Id, RegisteredObject>,
-    protected val scope: CoroutineScope,
-    protected val kvCache: FullKVCache<Id, List<RegisteredObject>> = FullKVCache()
-) : WriteKeyValuesRepo<Id, RegisteredObject>, FallbackCacheRepo {
-    override val onValueRemoved: Flow<Pair<Id, RegisteredObject>>
-        get() = originalRepo.onValueRemoved
-
-    override val onNewValue: Flow<Pair<Id, RegisteredObject>>
-        get() = originalRepo.onNewValue
-    override val onDataCleared: Flow<Id>
-        get() = (originalRepo.onDataCleared + kvCache.onValueRemoved).distinctUntilChanged()
-
-    private val onDataClearedListeningJob = originalRepo.onDataCleared.subscribeSafelyWithoutExceptions(scope) {
-        kvCache.unset(it)
-    }
-
-    private val onRemovingUpdatesListeningJob = originalRepo.onValueRemoved.subscribeSafelyWithoutExceptions(scope) {
-        kvCache.set(
-            it.first,
-            (kvCache.get(
-                it.first
-            ) ?: return@subscribeSafelyWithoutExceptions) - it.second
-        )
-    }
-
-    private val onNewAndUpdatedObjectsListeningJob = originalRepo.onNewValue.subscribeSafelyWithoutExceptions(scope) {
-        kvCache.set(
-            it.first,
-            (kvCache.get(
-                it.first
-            ) ?: return@subscribeSafelyWithoutExceptions) + it.second
-        )
-    }
-
-    override suspend fun clearWithValue(v: RegisteredObject) {
-        originalRepo.clearWithValue(v)
-        doForAllWithNextPaging(FirstPagePagination(kvCache.count().takeIf { it < Int.MAX_VALUE } ?.toInt() ?: Int.MAX_VALUE)) {
-            kvCache.keys(it).also {
-                it.results.forEach { id ->
-                    kvCache.get(id) ?.takeIf { it.contains(v) } ?.let {
-                        kvCache.unset(id)
-                    }
-                }
-            }
-        }
-    }
-
-    override suspend fun clear(k: Id) {
-        originalRepo.clear(k)
-        kvCache.unset(k)
-    }
-
-    override suspend fun remove(toRemove: Map<Id, List<RegisteredObject>>) {
-        originalRepo.remove(toRemove)
-        toRemove.forEach { (k, v) ->
-            kvCache.set(k, (kvCache.get(k) ?: return@forEach) - v)
-        }
-    }
-
-    override suspend fun add(toAdd: Map<Id, List<RegisteredObject>>) {
-        originalRepo.add(toAdd)
-        toAdd.forEach { (k, v) ->
-            kvCache.set(k, (kvCache.get(k) ?: return@forEach) + v)
-        }
-    }
-
-    override suspend fun invalidate() {
-        kvCache.clear()
-    }
-}

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

@@ -3,10 +3,11 @@ package dev.inmo.micro_utils.repos.cache.full
 import dev.inmo.micro_utils.common.*
 import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.micro_utils.repos.cache.*
 import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.util.actualizeAll
+import dev.inmo.micro_utils.repos.cache.cache.KVCache
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 
@@ -31,7 +32,12 @@ open class FullReadCRUDCacheRepo<ObjectType, IdType>(
     }
 
     protected open suspend fun actualizeAll() {
-        kvCache.actualizeAll(parentRepo)
+        kvCache.clear()
+        doForAllWithNextPaging {
+            parentRepo.getByPagination(it).also {
+                kvCache.set(it.results.associateBy { idGetter(it) })
+            }
+        }
     }
 
     override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = doOrTakeAndActualize(
@@ -63,10 +69,6 @@ open class FullReadCRUDCacheRepo<ObjectType, IdType>(
         { getById(id) },
         { it ?.let { set(idGetter(it), it) } }
     )
-
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
 }
 
 fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.cached(
@@ -90,11 +92,7 @@ open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
         scope,
         idGetter
     ),
-    CRUDRepo<ObjectType, IdType, InputValueType> {
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
-}
+    CRUDRepo<ObjectType, IdType, InputValueType>
 
 fun <ObjectType, IdType, InputType> CRUDRepo<ObjectType, IdType, InputType>.cached(
     kvCache: FullKVCache<IdType, ObjectType>,

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

@@ -5,11 +5,9 @@ import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import dev.inmo.micro_utils.repos.pagination.getAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.*
 
 open class FullReadKeyValueCacheRepo<Key,Value>(
@@ -70,10 +68,6 @@ open class FullReadKeyValueCacheRepo<Key,Value>(
         { parentRepo.keys(v, pagination, reversed) },
         { if (it.results.isNotEmpty()) actualizeAll() }
     )
-
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
 }
 
 fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
@@ -81,16 +75,12 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
 ) = FullReadKeyValueCacheRepo(this, kvCache)
 
 open class FullWriteKeyValueCacheRepo<Key,Value>(
-    parentRepo: WriteKeyValueRepo<Key, Value>,
+    protected open val parentRepo: WriteKeyValueRepo<Key, Value>,
     protected open val kvCache: FullKVCache<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
 ) : WriteKeyValueRepo<Key, Value> by parentRepo, FullCacheRepo {
     protected val onNewJob = parentRepo.onNewValue.onEach { kvCache.set(it.first, it.second) }.launchIn(scope)
     protected val onRemoveJob = parentRepo.onValueRemoved.onEach { kvCache.unset(it) }.launchIn(scope)
-
-    override suspend fun invalidate() {
-        kvCache.clear()
-    }
 }
 
 fun <Key, Value> WriteKeyValueRepo<Key, Value>.caching(
@@ -99,17 +89,13 @@ fun <Key, Value> WriteKeyValueRepo<Key, Value>.caching(
 ) = FullWriteKeyValueCacheRepo(this, kvCache, scope)
 
 open class FullKeyValueCacheRepo<Key,Value>(
-    protected open val parentRepo: KeyValueRepo<Key, Value>,
+    parentRepo: KeyValueRepo<Key, Value>,
     kvCache: FullKVCache<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
 ) : FullWriteKeyValueCacheRepo<Key,Value>(parentRepo, kvCache, scope),
     KeyValueRepo<Key,Value>,
     ReadKeyValueRepo<Key, Value> by FullReadKeyValueCacheRepo(parentRepo, kvCache) {
     override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset)
-
-    override suspend fun invalidate() {
-        kvCache.actualizeAll(parentRepo)
-    }
 }
 
 fun <Key, Value> KeyValueRepo<Key, Value>.cached(

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

@@ -5,7 +5,6 @@ import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.*
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
-import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
@@ -34,7 +33,8 @@ open class FullReadKeyValuesCacheRepo<Key,Value>(
     }
 
     protected open suspend fun actualizeAll() {
-        kvCache.actualizeAll(parentRepo)
+        doAllWithCurrentPaging { kvCache.keys(it).also { kvCache.unset(it.results) } }
+        kvCache.set(parentRepo.getAll())
     }
 
     override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
@@ -102,9 +102,6 @@ open class FullReadKeyValuesCacheRepo<Key,Value>(
         { if (it.results.isNotEmpty()) actualizeAll() }
     )
 
-    override suspend fun invalidate() {
-        actualizeAll()
-    }
 }
 
 fun <Key, Value> ReadKeyValuesRepo<Key, Value>.cached(
@@ -112,7 +109,7 @@ fun <Key, Value> ReadKeyValuesRepo<Key, Value>.cached(
 ) = FullReadKeyValuesCacheRepo(this, kvCache)
 
 open class FullWriteKeyValuesCacheRepo<Key,Value>(
-    parentRepo: WriteKeyValuesRepo<Key, Value>,
+    protected open val parentRepo: WriteKeyValuesRepo<Key, Value>,
     protected open val kvCache: FullKVCache<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
 ) : WriteKeyValuesRepo<Key, Value> by parentRepo, FullCacheRepo {
@@ -128,10 +125,6 @@ open class FullWriteKeyValuesCacheRepo<Key,Value>(
             kvCache.get(it.first) ?.minus(it.second) ?: return@onEach
         )
     }.launchIn(scope)
-
-    override suspend fun invalidate() {
-        kvCache.clear()
-    }
 }
 
 fun <Key, Value> WriteKeyValuesRepo<Key, Value>.caching(
@@ -140,7 +133,7 @@ fun <Key, Value> WriteKeyValuesRepo<Key, Value>.caching(
 ) = FullWriteKeyValuesCacheRepo(this, kvCache, scope)
 
 open class FullKeyValuesCacheRepo<Key,Value>(
-    protected open val parentRepo: KeyValuesRepo<Key, Value>,
+    parentRepo: KeyValuesRepo<Key, Value>,
     kvCache: FullKVCache<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
 ) : FullWriteKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, scope),
@@ -153,10 +146,6 @@ open class FullKeyValuesCacheRepo<Key,Value>(
             }
         }
     }
-
-    override suspend fun invalidate() {
-        kvCache.actualizeAll(parentRepo)
-    }
 }
 
 fun <Key, Value> KeyValuesRepo<Key, Value>.caching(

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/util/ActualizeAll.kt

@@ -1,53 +0,0 @@
-package dev.inmo.micro_utils.repos.cache.util
-
-import dev.inmo.micro_utils.pagination.FirstPagePagination
-import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
-import dev.inmo.micro_utils.pagination.utils.getAllByWithNextPaging
-import dev.inmo.micro_utils.repos.ReadCRUDRepo
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
-import dev.inmo.micro_utils.repos.cache.cache.KVCache
-import dev.inmo.micro_utils.repos.pagination.getAll
-import dev.inmo.micro_utils.repos.set
-
-suspend inline fun <K, V> KVCache<K, V>.actualizeAll(
-    clear: Boolean = true,
-    getAll: () -> Map<K, V>
-) {
-    set(
-        getAll().also {
-            if (clear) {
-                clear()
-            }
-        }
-    )
-}
-
-suspend inline fun <K, V> KVCache<K, V>.actualizeAll(
-    repo: ReadKeyValueRepo<K, V>,
-    clear: Boolean = true,
-) {
-    actualizeAll(clear) {
-        repo.getAll { keys(it) }.toMap()
-    }
-}
-
-suspend inline fun <K, V> KVCache<K, List<V>>.actualizeAll(
-    repo: ReadKeyValuesRepo<K, V>,
-    clear: Boolean = true,
-) {
-    actualizeAll(clear) {
-        repo.getAll { keys(it) }.toMap()
-    }
-}
-
-suspend inline fun <K, V> KVCache<K, V>.actualizeAll(
-    repo: ReadCRUDRepo<V, K>,
-    clear: Boolean = true,
-) {
-    actualizeAll(clear) {
-        repo.getAllByWithNextPaging {
-            getIdsByPagination(it)
-        }.mapNotNull { it to (repo.getById(it) ?: return@mapNotNull null) }.toMap()
-    }
-}

repos/common/build.gradle

@@ -32,3 +32,5 @@ kotlin {
         }
     }
 }
+
+disableIncludingJvmCodeInAndroidPart()

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

@@ -2,8 +2,6 @@ package dev.inmo.micro_utils.repos
 
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.doAllWithCurrentPaging
-import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
-import dev.inmo.micro_utils.pagination.utils.paginate
 import kotlinx.coroutines.flow.Flow
 
 /**
@@ -19,32 +17,24 @@ interface ReadKeyValueRepo<Key, Value> : Repo {
     suspend fun get(k: Key): Value?
 
     /**
-     * This method should use sorted by [Key]s search and return the [PaginationResult]. By default, it should use
+     * This method should use sorted by [Key]s search and take the [PaginationResult]. By default, it should use
      * ascending sort for [Key]s
      */
     suspend fun values(pagination: Pagination, reversed: Boolean = false): PaginationResult<Value>
 
     /**
-     * This method should use sorted by [Key]s search and return the [PaginationResult]. By default, it should use
+     * This method should use sorted by [Key]s search and take the [PaginationResult]. By default, it should use
      * ascending sort for [Key]s
      */
     suspend fun keys(pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
 
     /**
-     * This method should use sorted by [Key]s search and return the [PaginationResult]. By default, it should use
-     * ascending sort for [Key]s.
-     *
-     * **DEFAULT REALIZATION IS NOT OPTIMAL AND HAS BEEN ADDED TO COVER CASES OF DIFFERENT COMMON MAPPINGS AND TRANSFORMATIONS**
+     * This method should use sorted by [Key]s search and take the [PaginationResult]. By default, it should use
+     * ascending sort for [Key]s
      *
      * @param v This value should be used to exclude from search the items with different [Value]s
      */
-    suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean = false): PaginationResult<Key> {
-        return getAllWithNextPaging {
-            keys(it)
-        }.filter {
-            get(it) == v
-        }.paginate(pagination, reversed)
-    }
+    suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
 
     /**
      * @return true if [key] is presented in current collection or false otherwise
@@ -103,10 +93,6 @@ suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(
     vararg toSet: Pair<Key, Value>
 ) = set(toSet.toMap())
 
-suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(
-    toSet: List<Pair<Key, Value>>
-) = set(toSet.toMap())
-
 suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(
     k: Key, v: Value
 ) = set(k to v)
@@ -139,11 +125,7 @@ interface KeyValueRepo<Key, Value> : ReadKeyValueRepo<Key, Value>, WriteKeyValue
      * By default, will remove all the data of current repo using [doAllWithCurrentPaging], [keys] and [unset]
      */
     suspend fun clear() {
-        var count: Int
-        do {
-            count = count().takeIf { it < Int.MAX_VALUE } ?.toInt() ?: Int.MAX_VALUE
-            keys(FirstPagePagination(count)).also { unset(it.results) }
-        } while(count > 0)
+        doAllWithCurrentPaging { keys(it).also { unset(it.results) } }
     }
 }
 typealias StandardKeyValueRepo<Key,Value> = KeyValueRepo<Key, Value>

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/annotations/GenerateCRUDModel.kt

@@ -1,35 +0,0 @@
-package dev.inmo.micro_utils.repos.annotations
-
-import kotlin.reflect.KClass
-
-/**
- * Use this annotation and ksp generator (module `micro_utils.repos.generator`) to create the next hierarchy of models:
- *
- * * New model. For example: data class NewTest
- * * Registered model. For example: data class RegisteredTest
- *
- * @param registeredSupertypes These [KClass]es will be used as supertypes for registered model
- * @param serializable If true (default) will generate @[kotlinx.serialization.Serializable] for models. Affects [generateSerialName]
- * @param serializable If true (default) will generate @[kotlinx.serialization.SerialName] for models with their names as values
- *
- * @see GenerateCRUDModelExcludeOverride
- */
-@Retention(AnnotationRetention.BINARY)
-@Target(AnnotationTarget.CLASS)
-annotation class GenerateCRUDModel(
-    vararg val registeredSupertypes: KClass<*>,
-    val serializable: Boolean = true,
-    val generateSerialName: Boolean = true
-)
-
-
-/**
- * Use this annotation on properties which should be excluded from overriding in models.
- *
- * @see GenerateCRUDModel
- */
-@Retention(AnnotationRetention.BINARY)
-@Target(AnnotationTarget.PROPERTY)
-annotation class GenerateCRUDModelExcludeOverride
-
-

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/transforms/crud/Factories.kt

@@ -1,10 +0,0 @@
-package dev.inmo.micro_utils.repos.transforms.crud
-
-import dev.inmo.micro_utils.repos.KeyValueRepo
-import dev.inmo.micro_utils.repos.KeyValuesRepo
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
-import kotlin.js.JsName
-import kotlin.jvm.JvmName
-
-fun <K, V> ReadKeyValueRepo<K, V>.asReadCRUDRepo() = ReadCRUDFromKeyValueRepo(this)

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/transforms/crud/ReadCRUDFromKeyValueRepo.kt

@@ -1,20 +0,0 @@
-package dev.inmo.micro_utils.repos.transforms.crud
-
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.repos.ReadCRUDRepo
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-
-open class ReadCRUDFromKeyValueRepo<RegisteredType, IdType>(
-    protected open val original: ReadKeyValueRepo<IdType, RegisteredType>
-) : ReadCRUDRepo<RegisteredType, IdType> {
-    override suspend fun contains(id: IdType): Boolean = original.contains(id)
-
-    override suspend fun count(): Long = original.count()
-
-    override suspend fun getByPagination(pagination: Pagination): PaginationResult<RegisteredType> = original.values(pagination)
-
-    override suspend fun getIdsByPagination(pagination: Pagination): PaginationResult<IdType> = original.keys(pagination)
-
-    override suspend fun getById(id: IdType): RegisteredType? = original.get(id)
-}

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/transforms/kv/Factories.kt

@@ -1,15 +0,0 @@
-package dev.inmo.micro_utils.repos.transforms.kv
-
-import dev.inmo.micro_utils.repos.KeyValueRepo
-import dev.inmo.micro_utils.repos.KeyValuesRepo
-import dev.inmo.micro_utils.repos.ReadCRUDRepo
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
-import kotlin.js.JsName
-import kotlin.jvm.JvmName
-
-fun <K, V> ReadKeyValuesRepo<K, V>.asReadKeyValueRepo() = ReadKeyValueFromKeyValuesRepo(this)
-
-fun <K, V> KeyValuesRepo<K, V>.asKeyValueRepo() = KeyValueFromKeyValuesRepo(this)
-
-fun <K, V> ReadCRUDRepo<K, V>.asReadKeyValueRepo() = ReadKeyValueFromCRUDRepo(this)

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/transforms/kv/KeyValueFromKeyValuesRepo.kt

@@ -1,41 +0,0 @@
-package dev.inmo.micro_utils.repos.transforms.kv
-
-import dev.inmo.micro_utils.pagination.FirstPagePagination
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.pagination.changeResults
-import dev.inmo.micro_utils.pagination.changeResultsUnchecked
-import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
-import dev.inmo.micro_utils.pagination.utils.optionallyReverse
-import dev.inmo.micro_utils.pagination.utils.paginate
-import dev.inmo.micro_utils.repos.KeyValueRepo
-import dev.inmo.micro_utils.repos.KeyValuesRepo
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
-import dev.inmo.micro_utils.repos.transforms.kvs.ReadKeyValuesFromKeyValueRepo
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.mapNotNull
-import kotlinx.coroutines.flow.merge
-
-open class KeyValueFromKeyValuesRepo<Key, Value>(
-    private val original: KeyValuesRepo<Key, Value>
-) : KeyValueRepo<Key, List<Value>>, ReadKeyValueFromKeyValuesRepo<Key, Value>(original) {
-    override val onNewValue: Flow<Pair<Key, List<Value>>> = merge(
-        original.onNewValue,
-        original.onValueRemoved
-    ).mapNotNull {
-        it.first to (get(it.first) ?: return@mapNotNull null)
-    }
-    override val onValueRemoved: Flow<Key> = original.onDataCleared
-
-    override suspend fun unset(toUnset: List<Key>) {
-        toUnset.forEach {
-            original.clear(it)
-        }
-    }
-
-    override suspend fun set(toSet: Map<Key, List<Value>>) {
-        original.set(toSet)
-    }
-}

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/transforms/kv/ReadKeyValueFromCRUDRepo.kt

@@ -1,46 +0,0 @@
-package dev.inmo.micro_utils.repos.transforms.kv
-
-import dev.inmo.micro_utils.pagination.FirstPagePagination
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.pagination.changeResults
-import dev.inmo.micro_utils.pagination.changeResultsUnchecked
-import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
-import dev.inmo.micro_utils.pagination.utils.optionallyReverse
-import dev.inmo.micro_utils.pagination.utils.paginate
-import dev.inmo.micro_utils.repos.ReadCRUDRepo
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
-import dev.inmo.micro_utils.repos.transforms.kvs.ReadKeyValuesFromKeyValueRepo
-import kotlin.jvm.JvmInline
-
-@JvmInline
-value class ReadKeyValueFromCRUDRepo<Key, Value>(
-    private val original: ReadCRUDRepo<Value, Key>
-) : ReadKeyValueRepo<Key, Value> {
-    override suspend fun get(k: Key): Value? = original.getById(k)
-
-    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = original.getByPagination(
-        pagination.optionallyReverse(count(), reversed)
-    ).let {
-        if (reversed) {
-            it.changeResultsUnchecked(it.results.reversed())
-        } else {
-            it
-        }
-    }
-
-    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = original.getIdsByPagination(
-        pagination.optionallyReverse(count(), reversed)
-    ).let {
-        if (reversed) {
-            it.changeResultsUnchecked(it.results.reversed())
-        } else {
-            it
-        }
-    }
-
-    override suspend fun count(): Long = original.count()
-
-    override suspend fun contains(key: Key): Boolean = original.contains(key)
-}

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/transforms/kv/ReadKeyValueFromKeyValuesRepo.kt

@@ -1,67 +0,0 @@
-package dev.inmo.micro_utils.repos.transforms.kv
-
-import dev.inmo.micro_utils.pagination.FirstPagePagination
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.pagination.changeResults
-import dev.inmo.micro_utils.pagination.changeResultsUnchecked
-import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
-import dev.inmo.micro_utils.pagination.utils.optionallyReverse
-import dev.inmo.micro_utils.pagination.utils.paginate
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
-import dev.inmo.micro_utils.repos.transforms.kvs.ReadKeyValuesFromKeyValueRepo
-
-open class ReadKeyValueFromKeyValuesRepo<Key, Value>(
-    private val original: ReadKeyValuesRepo<Key, Value>
-) : ReadKeyValueRepo<Key, List<Value>> {
-    override suspend fun get(k: Key): List<Value>? = original.getAll(k)
-
-    override suspend fun values(
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<List<Value>> {
-        val keys = keys(pagination, reversed)
-        return keys.changeResults(
-            keys.results.mapNotNull {
-                get(it)
-            }
-        )
-    }
-
-    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> {
-        return original.keys(pagination, reversed)
-    }
-
-    override suspend fun count(): Long {
-        return original.count()
-    }
-
-    override suspend fun contains(key: Key): Boolean {
-        return original.contains(key)
-    }
-
-    override suspend fun keys(v: List<Value>, pagination: Pagination, reversed: Boolean): PaginationResult<Key> {
-        val keys = mutableSetOf<Key>()
-
-        doForAllWithNextPaging(FirstPagePagination(count().toInt())) {
-            original.keys(it).also {
-                it.results.forEach {
-                    val values = get(it) ?: return@forEach
-                    if (values.containsAll(v) && v.containsAll(values)) {
-                        keys.add(it)
-                    }
-                }
-            }
-        }
-
-        val paginated = keys.paginate(
-            pagination.optionallyReverse(keys.count(), reversed)
-        )
-        return if (reversed) {
-            paginated.changeResultsUnchecked(paginated.results.reversed())
-        } else {
-            paginated
-        }
-    }
-}

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

@@ -1,21 +0,0 @@
-package dev.inmo.micro_utils.repos.transforms.kvs
-
-import dev.inmo.micro_utils.repos.KeyValueRepo
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-import kotlin.js.JsName
-import kotlin.jvm.JvmName
-
-
-fun <K, V, VI : Iterable<V>> ReadKeyValueRepo<K, VI>.asReadKeyValuesRepo() = ReadKeyValuesFromKeyValueRepo(this)
-
-fun <K, V, VI : Iterable<V>> KeyValueRepo<K, VI>.asKeyValuesRepo(
-    listToValuesIterable: suspend (List<V>) -> VI
-): KeyValuesFromKeyValueRepo<K, V, VI> = KeyValuesFromKeyValueRepo(this, listToValuesIterable)
-
-@JvmName("asListKeyValuesRepo")
-@JsName("asListKeyValuesRepo")
-fun <K, V> KeyValueRepo<K, List<V>>.asKeyValuesRepo(): KeyValuesFromKeyValueRepo<K, V, List<V>> = asKeyValuesRepo { it }
-
-@JvmName("asSetKeyValuesRepo")
-@JsName("asSetKeyValuesRepo")
-fun <K, V> KeyValueRepo<K, Set<V>>.asKeyValuesRepo(): KeyValuesFromKeyValueRepo<K, V, Set<V>> = asKeyValuesRepo { it.toSet() }

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

@@ -1,77 +0,0 @@
-package dev.inmo.micro_utils.repos.transforms.kvs
-
-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.unset
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.asSharedFlow
-import kotlin.js.JsName
-import kotlin.jvm.JvmName
-
-open class KeyValuesFromKeyValueRepo<Key, Value, ValuesIterable : Iterable<Value>>(
-    private val original: KeyValueRepo<Key, ValuesIterable>,
-    private val listToValuesIterable: suspend (List<Value>) -> ValuesIterable
-) : KeyValuesRepo<Key, Value>, ReadKeyValuesFromKeyValueRepo<Key, Value, ValuesIterable>(original) {
-    private val _onNewValue = MutableSharedFlow<Pair<Key, Value>>()
-    private val _onValueRemoved = MutableSharedFlow<Pair<Key, Value>>()
-    override val onNewValue: Flow<Pair<Key, Value>> = _onNewValue.asSharedFlow()
-    override val onValueRemoved: Flow<Pair<Key, Value>> = _onValueRemoved.asSharedFlow()
-    override val onDataCleared: Flow<Key> = original.onValueRemoved
-
-    override suspend fun clearWithValue(v: Value) {
-        val keys = mutableSetOf<Key>()
-
-        doForAllWithNextPaging(FirstPagePagination(count().toInt())) {
-            original.keys(it).also {
-                it.results.forEach {
-                    if (contains(it, v)) {
-                        keys.add(it)
-                    }
-                }
-            }
-        }
-
-        original.unset(keys.toList())
-    }
-
-    override suspend fun clear(k: Key) {
-        original.unset(k)
-    }
-
-    override suspend fun remove(toRemove: Map<Key, List<Value>>) {
-        original.set(
-            toRemove.mapNotNull { (k, removing) ->
-                val exists = original.get(k) ?: return@mapNotNull null
-                k to listToValuesIterable(exists - removing).also {
-                    if (it.firstOrNull() == null) {
-                        original.unset(k)
-                        return@mapNotNull null
-                    }
-                }
-            }.toMap()
-        )
-        toRemove.forEach { (k, v) ->
-            v.forEach {
-                _onValueRemoved.emit(k to it)
-            }
-        }
-    }
-
-    override suspend fun add(toAdd: Map<Key, List<Value>>) {
-        original.set(
-            toAdd.mapNotNull { (k, adding) ->
-                val exists = original.get(k) ?: emptyList()
-                k to listToValuesIterable(exists + adding)
-            }.toMap()
-        )
-        toAdd.forEach { (k, v) ->
-            v.forEach {
-                _onNewValue.emit(k to it)
-            }
-        }
-    }
-
-}

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

@@ -1,72 +0,0 @@
-package dev.inmo.micro_utils.repos.transforms.kvs
-
-import dev.inmo.micro_utils.pagination.FirstPagePagination
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.pagination.changeResultsUnchecked
-import dev.inmo.micro_utils.pagination.emptyPaginationResult
-import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
-import dev.inmo.micro_utils.pagination.utils.optionallyReverse
-import dev.inmo.micro_utils.pagination.utils.paginate
-import dev.inmo.micro_utils.repos.ReadKeyValueRepo
-import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
-
-open class ReadKeyValuesFromKeyValueRepo<Key, Value, ValuesIterable : Iterable<Value>>(
-    private val original: ReadKeyValueRepo<Key, ValuesIterable>
-) : ReadKeyValuesRepo<Key, Value> {
-    override suspend fun get(
-        k: Key,
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<Value> {
-        val iterable = original.get(k) ?: return emptyPaginationResult(pagination)
-        val paginated = iterable.paginate(
-            pagination.optionallyReverse(iterable.count(), reversed)
-        )
-        return if (reversed) {
-            paginated.changeResultsUnchecked(paginated.results.reversed())
-        } else {
-            paginated
-        }
-    }
-
-    override suspend fun keys(
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<Key> = original.keys(pagination, reversed)
-
-    override suspend fun count(): Long = original.count()
-
-    override suspend fun count(k: Key): Long = original.get(k) ?.count() ?.toLong() ?: 0L
-
-    override suspend fun contains(k: Key, v: Value): Boolean = original.get(k) ?.contains(v) == true
-
-    override suspend fun contains(k: Key): Boolean = original.contains(k)
-
-    override suspend fun keys(
-        v: Value,
-        pagination: Pagination,
-        reversed: Boolean
-    ): PaginationResult<Key> {
-        val keys = mutableSetOf<Key>()
-
-        doForAllWithNextPaging(FirstPagePagination(count().toInt())) {
-            original.keys(it).also {
-                it.results.forEach {
-                    if (contains(it, v)) {
-                        keys.add(it)
-                    }
-                }
-            }
-        }
-
-        val paginated = keys.paginate(
-            pagination.optionallyReverse(keys.count(), reversed)
-        )
-        return if (reversed) {
-            paginated.changeResultsUnchecked(paginated.results.reversed())
-        } else {
-            paginated
-        }
-    }
-}

repos/common/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/FileKeyValueRepo.kt

@@ -31,19 +31,11 @@ class FileReadKeyValueRepo(
     override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<File> {
         val count = count()
         val resultPagination = if (reversed) pagination.reverse(count) else pagination
-        val filesList = folder.list()
-        val files: Array<String> = if (resultPagination.firstIndex < count) {
-            val filesPaths = filesList.copyOfRange(resultPagination.firstIndex, resultPagination.lastIndexExclusive.coerceAtMost(filesList.size))
-
-            if (reversed) {
-                filesPaths.reversedArray()
-            } else {
-                filesPaths
-            }
-        } else {
-            emptyArray<String>()
+        val filesPaths = folder.list() ?.copyOfRange(resultPagination.firstIndex, resultPagination.lastIndexExclusive) ?: return emptyPaginationResult()
+        if (reversed) {
+            filesPaths.reverse()
         }
-        return files.map { File(folder, it) }.createPaginationResult(
+        return filesPaths.map { File(folder, it) }.createPaginationResult(
             resultPagination,
             count
         )
@@ -52,21 +44,11 @@ class FileReadKeyValueRepo(
     override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<String> {
         val count = count()
         val resultPagination = if (reversed) pagination.reverse(count) else pagination
-        val filesList = folder.list()
-
-        val files: Array<String> = if (resultPagination.firstIndex < count) {
-            val filesPaths = filesList.copyOfRange(resultPagination.firstIndex, resultPagination.lastIndexExclusive.coerceAtMost(filesList.size))
-
-            if (reversed) {
-                filesPaths.reversedArray()
-            } else {
-                filesPaths
-            }
-        } else {
-            emptyArray<String>()
+        val filesPaths = folder.list() ?.copyOfRange(resultPagination.firstIndex, resultPagination.lastIndexExclusive) ?: return emptyPaginationResult()
+        if (reversed) {
+            filesPaths.reverse()
         }
-
-        return files.toList().createPaginationResult(
+        return filesPaths.toList().createPaginationResult(
             resultPagination,
             count
         )

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

@@ -1,23 +0,0 @@
-package dev.inmo.micro_utils.repos.exposed
-
-import org.jetbrains.exposed.sql.Column
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.isNotNull
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.isNull
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.neq
-
-fun <T> Column<T?>.eqOrIsNull(
-    value: T?
-) = if (value == null) {
-    isNull()
-} else {
-    eq(value)
-}
-
-fun <T> Column<T?>.neqOrIsNotNull(
-    value: T?
-) = if (value == null) {
-    isNotNull()
-} else {
-    neq(value)
-}

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

@@ -7,9 +7,15 @@ interface CommonExposedRepo<IdType, ObjectType> : ExposedRepo {
     val ResultRow.asId: IdType
     val selectById: ISqlExpressionBuilder.(IdType) -> Op<Boolean>
     val selectByIds: ISqlExpressionBuilder.(List<IdType>) -> Op<Boolean>
-        get() = {
-            it.foldRight<IdType, Op<Boolean>?>(null) { id, acc ->
-                acc ?.or(selectById(id)) ?: selectById(id)
-            } ?: Op.FALSE
+        get() = { list ->
+            if (list.isEmpty()) {
+                Op.FALSE
+            } else {
+                var op = selectById(list.first())
+                (1 until list.size).forEach {
+                    op = op.or(selectById(list[it]))
+                }
+                op
+            }
         }
 }

repos/generator/README.md

@@ -1,154 +0,0 @@
-# Koin generator
-
-It is Kotlin Symbol Processing generator for simple creating of typical models: `New` and `Registered`.
-
-1. [What may do this generator](#what-may-do-this-generator)
-2. [How to add generator](#how-to-add-generator)
-
-## What may do this generator
-
-So, you have several known things related to models:
-
-* Interface with all necessary properties
-* Id class or some registered marker
-
-Minimal sample will be next:
-
-```kotlin
-@GenerateCRUDModel
-interface Sample {
-   val property1: String
-   val property2: Int
-}
-```
-
-And generator will create:
-
-```kotlin
-@Serializable
-@SerialName("NewSample")
-data class NewSample(
-    override val property1: String,
-    override val property2: Int,
-) : Sample
-
-@Serializable
-@SerialName("RegisteredSample")
-data class RegisteredSample(
-    override val property1: String,
-    override val property2: Int,
-) : Sample
-
-fun Sample.asNew(): NewSample = NewSample(property1, property2)
-
-fun Sample.asRegistered(): RegisteredSample = RegisteredSample(property1, property2)
-```
-
-But in most cases you will need to create some id class and registered interface:
-
-```kotlin
-@Serializable
-@JvmInline
-value class SampleId(
-   val long: Long
-)
-
-sealed interface IRegisteredSample : Sample {
-   val id: SampleId
-
-   @GenerateCRUDModelExcludeOverride
-   val excludedProperty2: Boolean
-      get() = false
-}
-```
-
-As you may see, we have added `GenerateCRUDModelExcludeOverride` annotation. Properties marked with this annotation
-WILL NOT be inclued into overriding in registered class (or your base interface if used there). So, if you will wish to
-create model with id, use next form:
-
-```kotlin
-@GenerateCRUDModel(IRegisteredSample::class)
-interface Sample {
-   val property1: String
-   val property2: Int
-}
-```
-
-And generated registered class will be changed:
-
-```kotlin
-@Serializable
-@SerialName(value = "NewSample")
-data class NewSample(
-  override val property1: String,
-  override val property2: Int,
-) : Sample
-
-@Serializable
-@SerialName(value = "RegisteredSample")
-data class RegisteredSample(
-  override val id: SampleId,
-  override val property1: String,
-  override val property2: Int,
-) : Sample, IRegisteredSample
-
-fun Sample.asNew(): NewSample = NewSample(property1, property2)
-
-fun Sample.asRegistered(id: SampleId): RegisteredSample = RegisteredSample(id, property1, property2)
-```
-
-So, full sample will look like:
-
-```kotlin
-/**
- * Your id value class. In fact, but it is not necessary
- */
-@Serializable
-@JvmInline
-value class SampleId(
-   val long: Long
-)
-
-@GenerateCRUDModel(IRegisteredSample::class)
-sealed interface Sample {
-   val property1: String
-   val property2: Int
-
-   @GenerateCRUDModelExcludeOverride
-   val excludedProperty: String
-      get() = "excluded"
-}
-
-sealed interface IRegisteredSample : Sample {
-   val id: SampleId
-
-   @GenerateCRUDModelExcludeOverride
-   val excludedProperty2: Boolean
-      get() = false
-}
-```
-
-You always may:
-
-* Use any number of registered classes
-* Disable serialization for models
-* Disable serial names generation
-
-## How to add generator
-
-**Note: $ksp_version in the samples above is equal to supported `ksp` version presented in `/gradle/libs.versions.toml` of project**
-
-**Note: $microutils_version in the version of MicroUtils library in your project**
-
-1. Add `classpath` in `build.gradle` (`classpath "com.google.devtools.ksp:symbol-processing-gradle-plugin:$ksp_version"`)
-2. Add plugin to the plugins list of your module: `id "com.google.devtools.ksp"`
-3. In `dependencies` block add to the required target/compile the dependency `dev.inmo:micro_utils.repos.generator:$microutils_version`:
-   ```groovy
-    dependencies {
-        add("kspCommonMainMetadata", "dev.inmo:micro_utils.repos.generator:$microutils_version") // will work in commonMain of your multiplatform module
-        add("kspJvm", "dev.inmo:micro_utils.repos.generator:$microutils_version") // will work in main of your JVM module
-    }
-    
-    ksp { // this generator do not require any arguments and we should left `ksp` empty
-    }
-    ```

repos/generator/build.gradle

@@ -1,16 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.jvm"
-}
-
-apply from: "$publishJvmOnlyPath"
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    api libs.kt.reflect
-    api project(":micro_utils.repos.common")
-    api libs.kotlin.poet
-    api libs.ksp
-}

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

@@ -1,217 +0,0 @@
-package dev.inmo.micro_utils.repos.generator
-
-import com.google.devtools.ksp.KspExperimental
-import com.google.devtools.ksp.getAnnotationsByType
-import com.google.devtools.ksp.isAnnotationPresent
-import com.google.devtools.ksp.processing.CodeGenerator
-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.KSClassDeclaration
-import com.google.devtools.ksp.symbol.KSClassifierReference
-import com.google.devtools.ksp.symbol.KSPropertyDeclaration
-import com.google.devtools.ksp.symbol.KSReferenceElement
-import com.google.devtools.ksp.symbol.KSType
-import com.google.devtools.ksp.symbol.KSTypeAlias
-import com.google.devtools.ksp.symbol.KSValueArgument
-import com.google.devtools.ksp.symbol.Nullability
-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.PropertySpec
-import com.squareup.kotlinpoet.TypeName
-import com.squareup.kotlinpoet.TypeSpec
-import com.squareup.kotlinpoet.asTypeName
-import com.squareup.kotlinpoet.ksp.toAnnotationSpec
-import com.squareup.kotlinpoet.ksp.toClassName
-import com.squareup.kotlinpoet.ksp.toTypeName
-import dev.inmo.micro_utils.repos.annotations.GenerateCRUDModel
-import dev.inmo.micro_utils.repos.annotations.GenerateCRUDModelExcludeOverride
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-import java.io.File
-import kotlin.reflect.KProperty1
-import kotlin.reflect.full.memberProperties
-
-private fun KSClassifierReference.quilifiedName(): String = "${qualifier ?.let { "${it.quilifiedName()}." } ?: ""}${referencedName()}"
-
-class Processor(
-    private val codeGenerator: CodeGenerator
-) : SymbolProcessor {
-    private val KSPropertyDeclaration.typeName: TypeName
-        get() {
-            return runCatching {
-                type.toTypeName()
-            }.getOrElse {
-                val element = type.element as KSClassifierReference
-                (type.element as KSClassifierReference).let {
-                    ClassName(
-                        element.qualifier ?.quilifiedName() ?: "",
-                        element.referencedName()
-                    )
-                }
-            }
-        }
-    @OptIn(KspExperimental::class)
-    override fun process(resolver: Resolver): List<KSAnnotated> {
-        val toRetry = resolver.getSymbolsWithAnnotation(
-            GenerateCRUDModel::class.qualifiedName!!
-        ).filterIsInstance<KSClassDeclaration>().filterNot { ksClassDeclaration ->
-            val ksFile = ksClassDeclaration.containingFile ?: return@filterNot false
-            runCatching {
-                FileSpec.builder(
-                    ksClassDeclaration.packageName.asString(),
-                    "GeneratedModels${ksFile.fileName.removeSuffix(".kt")}"
-                ).apply {
-                    val annotation = ksClassDeclaration.getAnnotationsByType(GenerateCRUDModel::class).first()
-                    addFileComment(
-                        """
-                        THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
-                        TO REGENERATE IT JUST DELETE FILE
-                        ORIGINAL FILE: ${ksFile.fileName}
-                    """.trimIndent()
-                    )
-                    val newName = "New${ksClassDeclaration.simpleName.getShortName()}"
-                    val registeredName = "Registered${ksClassDeclaration.simpleName.getShortName()}"
-
-                    val allKSClassProperties = ksClassDeclaration.getAllProperties()
-                    val excludedKSClassProperties = allKSClassProperties.filter {
-                        it.isAnnotationPresent(GenerateCRUDModelExcludeOverride::class)
-                    }
-                    val excludedKSClassPropertiesNames = excludedKSClassProperties.map { it.simpleName.asString() }
-                    val ksClassProperties = allKSClassProperties.filter {
-                        it !in excludedKSClassProperties
-                    }
-                    val ksClassPropertiesNames = ksClassProperties.map { it.simpleName.asString() }
-                    val newNewType = TypeSpec.classBuilder(newName).apply {
-                        val typeBuilder = this
-                        addSuperinterface(ksClassDeclaration.toClassName())
-                        addModifiers(KModifier.DATA)
-                        if (annotation.serializable) {
-                            addAnnotation(Serializable::class)
-                            if (annotation.generateSerialName) {
-                                addAnnotation(AnnotationSpec.get(SerialName(newName)))
-                            }
-                        }
-                        primaryConstructor(
-                            FunSpec.constructorBuilder().apply {
-                                ksClassProperties.forEach {
-                                    addParameter(it.simpleName.getShortName(), it.typeName)
-                                    typeBuilder.addProperty(
-                                        PropertySpec.builder(it.simpleName.getShortName(), it.typeName, KModifier.OVERRIDE).apply {
-                                            initializer(it.simpleName.getShortName())
-                                        }.build()
-                                    )
-                                }
-                            }.build()
-                        )
-                    }.build()
-                    addType(
-                        newNewType
-                    )
-
-                    val registeredSupertypes = ksClassDeclaration.annotations.filter {
-                        it.shortName.asString() == GenerateCRUDModel::class.simpleName &&
-                            it.annotationType.resolve().declaration.qualifiedName ?.asString() == GenerateCRUDModel::class.qualifiedName
-                    }.flatMap {
-                        (it.arguments.first().value as List<KSType>).map { it.declaration as KSClassDeclaration }
-                    }.toList()
-
-
-                    val registeredTypesProperties: List<KSPropertyDeclaration> = registeredSupertypes.flatMap { registeredType ->
-                        registeredType.getAllProperties()
-                    }.filter {
-                        it.simpleName.asString() !in excludedKSClassPropertiesNames && it.getAnnotationsByType(GenerateCRUDModelExcludeOverride::class).none()
-                    }
-                    val allProperties: List<KSPropertyDeclaration> = ksClassProperties.toList() + registeredTypesProperties
-                    val propertiesToOverrideInRegistered = allProperties.distinctBy { it.simpleName.asString() }.sortedBy { property ->
-                        val name = property.simpleName.asString()
-
-                        ksClassPropertiesNames.indexOf(name).takeIf { it > -1 } ?.let {
-                            it + allProperties.size
-                        } ?: allProperties.indexOfFirst { it.simpleName.asString() == name }
-                    }
-
-                    val newRegisteredType = TypeSpec.classBuilder(registeredName).apply {
-                        val typeBuilder = this
-                        addSuperinterface(ksClassDeclaration.toClassName())
-                        if (annotation.serializable) {
-                            addAnnotation(Serializable::class)
-
-                            if (annotation.generateSerialName) {
-                                addAnnotation(
-                                    AnnotationSpec.get(SerialName(registeredName))
-                                )
-                            }
-                        }
-                        addSuperinterfaces(registeredSupertypes.map { it.toClassName() })
-                        addModifiers(KModifier.DATA)
-                        primaryConstructor(
-                            FunSpec.constructorBuilder().apply {
-                                propertiesToOverrideInRegistered.forEach {
-                                    addParameter(
-                                        ParameterSpec.builder(it.simpleName.getShortName(), it.typeName).apply {
-                                            annotations += it.annotations.map { it.toAnnotationSpec() }
-                                        }.build()
-                                    )
-                                    typeBuilder.addProperty(
-                                        PropertySpec.builder(it.simpleName.getShortName(), it.typeName, KModifier.OVERRIDE).apply {
-                                            initializer(it.simpleName.getShortName())
-                                        }.build()
-                                    )
-                                }
-                            }.build()
-                        )
-                    }.build()
-                    addType(
-                        newRegisteredType
-                    )
-
-                    addFunction(
-                        FunSpec.builder("asNew").apply {
-                            receiver(ksClassDeclaration.toClassName())
-                            addCode(
-                                CodeBlock.of(
-                                    "return ${newNewType.name}(${newNewType.propertySpecs.joinToString { it.name }})"
-                                )
-                            )
-                            returns(ClassName(packageName, newNewType.name!!))
-                        }.build()
-                    )
-
-                    addFunction(
-                        FunSpec.builder("asRegistered").apply {
-                            receiver(ksClassDeclaration.toClassName())
-                            (registeredTypesProperties.filter { it.simpleName.asString() !in ksClassPropertiesNames }).forEach {
-                                addParameter(it.simpleName.asString(), it.typeName)
-                            }
-                            addCode(
-                                CodeBlock.of(
-                                    "return ${newRegisteredType.name}(${newRegisteredType.propertySpecs.joinToString { it.name }})"
-                                )
-                            )
-                            returns(ClassName(packageName, newRegisteredType.name!!))
-                        }.build()
-                    )
-                }.build().let {
-                    File(
-                        File(ksFile.filePath).parent,
-                        "GeneratedModels${ksFile.fileName}"
-                    ).takeIf { !it.exists() } ?.apply {
-                        parentFile.mkdirs()
-
-                        writer().use { writer ->
-                            it.writeTo(writer)
-                        }
-                    }
-                }
-            }.isSuccess
-        }.toList()
-
-        return toRetry
-    }
-}

repos/generator/src/main/kotlin/Provider.kt

@@ -1,11 +0,0 @@
-package dev.inmo.micro_utils.repos.generator
-
-import com.google.devtools.ksp.processing.SymbolProcessor
-import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
-import com.google.devtools.ksp.processing.SymbolProcessorProvider
-
-class Provider : SymbolProcessorProvider {
-    override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor = Processor(
-        environment.codeGenerator
-    )
-}

repos/generator/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

@@ -1 +0,0 @@
-dev.inmo.micro_utils.repos.generator.Provider

repos/generator/test/build.gradle

@@ -1,27 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.multiplatform"
-    id "org.jetbrains.kotlin.plugin.serialization"
-    id "com.android.library"
-    id "com.google.devtools.ksp"
-}
-
-apply from: "$mppProjectWithSerializationPresetPath"
-
-
-kotlin {
-    sourceSets {
-        commonMain {
-            dependencies {
-                api project(":micro_utils.repos.common")
-            }
-        }
-    }
-}
-
-
-dependencies {
-    add("kspCommonMainMetadata", project(":micro_utils.repos.generator"))
-}
-
-ksp {
-}

repos/generator/test/src/commonMain/kotlin/GeneratedModelsTest.kt

@@ -1,31 +0,0 @@
-// THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
-// TO REGENERATE IT JUST DELETE FILE
-// ORIGINAL FILE: Test.kt
-package dev.inmo.micro_utils.repos.generator.test
-
-import kotlin.Int
-import kotlin.String
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-@Serializable
-@SerialName(value = "NewTest")
-public data class NewTest(
-  public override val property1: String,
-  public override val property2: Int,
-  public override val parent: ParentTypeId?,
-) : Test
-
-@Serializable
-@SerialName(value = "RegisteredTest")
-public data class RegisteredTest(
-  public override val id: TestId,
-  public override val property1: String,
-  public override val property2: Int,
-  public override val parent: ParentTypeId?,
-) : Test, IRegisteredTest
-
-public fun Test.asNew(): NewTest = NewTest(property1, property2, parent)
-
-public fun Test.asRegistered(id: TestId): RegisteredTest = RegisteredTest(id, property1, property2,
-    parent)

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

@@ -1,33 +0,0 @@
-package dev.inmo.micro_utils.repos.generator.test
-
-import dev.inmo.micro_utils.repos.annotations.GenerateCRUDModel
-import dev.inmo.micro_utils.repos.annotations.GenerateCRUDModelExcludeOverride
-import kotlinx.serialization.Serializable
-import kotlin.jvm.JvmInline
-
-@Serializable
-@JvmInline
-value class TestId(
-    val long: Long
-)
-
-typealias ParentTypeId = TestId
-
-@GenerateCRUDModel(IRegisteredTest::class)
-sealed interface Test {
-    val property1: String
-    val property2: Int
-    val parent: ParentTypeId?
-
-    @GenerateCRUDModelExcludeOverride
-    val excludedProperty: String
-        get() = "excluded"
-}
-
-sealed interface IRegisteredTest : Test {
-    val id: TestId
-
-    @GenerateCRUDModelExcludeOverride
-    val excludedProperty2: Boolean
-        get() = false
-}

repos/generator/test/src/main/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest package="dev.inmo.micro_utils.repos.generator.test"/>

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorCRUDRepoClient.kt

@@ -1,17 +1,12 @@
 package dev.inmo.micro_utils.repos.ktor.client.crud
 
-import dev.inmo.micro_utils.ktor.client.createStandardWebsocketFlow
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
-import dev.inmo.micro_utils.repos.ktor.common.crud.deletedObjectsIdsFlowRouting
-import dev.inmo.micro_utils.repos.ktor.common.crud.newObjectsFlowRouting
-import dev.inmo.micro_utils.repos.ktor.common.crud.updatedObjectsFlowRouting
 import io.ktor.client.HttpClient
 import io.ktor.http.ContentType
 import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
-import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.*
 
 class KtorCRUDRepoClient<ObjectType, IdType, InputValue> (
@@ -26,15 +21,6 @@ class KtorCRUDRepoClient<ObjectType, IdType, InputValue> (
             baseUrl: String,
             httpClient: HttpClient,
             contentType: ContentType,
-            newObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, newObjectsFlowRouting),
-            ),
-            updatedObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
-            ),
-            deletedObjectsIdsFlow: Flow<IdType> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
-            ),
             noinline idSerializer: suspend (IdType) -> String
         ) = KtorCRUDRepoClient(
             KtorReadCRUDRepoClient(
@@ -49,10 +35,7 @@ class KtorCRUDRepoClient<ObjectType, IdType, InputValue> (
             KtorWriteCrudRepoClient<ObjectType, IdType, InputValue>(
                 baseUrl,
                 httpClient,
-                contentType,
-                newObjectsFlow,
-                updatedObjectsFlow,
-                deletedObjectsIdsFlow
+                contentType
             )
         )
 
@@ -61,23 +44,11 @@ class KtorCRUDRepoClient<ObjectType, IdType, InputValue> (
             subpart: String,
             httpClient: HttpClient,
             contentType: ContentType,
-            newObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, newObjectsFlowRouting),
-            ),
-            updatedObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
-            ),
-            deletedObjectsIdsFlow: Flow<IdType> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
-            ),
             noinline idSerializer: suspend (IdType) -> String
         ) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(
             buildStandardUrl(baseUrl, subpart),
             httpClient,
             contentType,
-            newObjectsFlow,
-            updatedObjectsFlow,
-            deletedObjectsIdsFlow,
             idSerializer
         )
     }
@@ -109,23 +80,11 @@ inline fun <reified ObjectType, reified IdType, reified InputValue> KtorCRUDRepo
     subpart: String,
     httpClient: HttpClient,
     contentType: ContentType,
-    newObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
-        buildStandardUrl(baseUrl, newObjectsFlowRouting),
-    ),
-    updatedObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
-        buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
-    ),
-    deletedObjectsIdsFlow: Flow<IdType> = httpClient.createStandardWebsocketFlow(
-        buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
-    ),
     noinline idSerializer: suspend (IdType) -> String
 ) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(
     buildStandardUrl(baseUrl, subpart),
     httpClient,
     contentType,
-    newObjectsFlow,
-    updatedObjectsFlow,
-    deletedObjectsIdsFlow,
     idSerializer
 )
 

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorWriteCrudRepoClient.kt

@@ -53,22 +53,19 @@ class KtorWriteCrudRepoClient<ObjectType, IdType, InputValue> (
         inline operator fun <reified ObjectType, reified IdType, reified InputValue> invoke(
             baseUrl: String,
             httpClient: HttpClient,
-            contentType: ContentType,
-            newObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, newObjectsFlowRouting),
-            ),
-            updatedObjectsFlow: Flow<ObjectType> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
-            ),
-            deletedObjectsIdsFlow: Flow<IdType> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
-            ),
+            contentType: ContentType
         ) = KtorWriteCrudRepoClient<ObjectType, IdType, InputValue>(
             baseUrl,
             httpClient,
-            newObjectsFlow,
-            updatedObjectsFlow,
-            deletedObjectsIdsFlow,
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, newObjectsFlowRouting),
+            ),
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
+            ),
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
+            ),
             {
                 contentType(contentType)
                 setBody(it)

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

@@ -1,14 +1,10 @@
 package dev.inmo.micro_utils.repos.ktor.client.key.value
 
-import dev.inmo.micro_utils.ktor.client.createStandardWebsocketFlow
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.repos.*
-import dev.inmo.micro_utils.repos.ktor.common.key_value.onNewValueRoute
-import dev.inmo.micro_utils.repos.ktor.common.key_value.onValueRemovedRoute
 import io.ktor.client.HttpClient
 import io.ktor.http.ContentType
 import io.ktor.http.encodeURLQueryComponent
-import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.*
 
 class KtorKeyValueRepoClient<Key, Value> (
@@ -24,12 +20,6 @@ class KtorKeyValueRepoClient<Key, Value> (
             httpClient: HttpClient,
             contentType: ContentType,
             noinline idSerializer: suspend (Key) -> String,
-            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onNewValueRoute),
-            ),
-            onValueRemoved: Flow<Key> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onValueRemovedRoute),
-            ),
             noinline valueSerializer: suspend (Value) -> String
         ) = KtorKeyValueRepoClient(
             KtorReadKeyValueRepoClient(
@@ -38,9 +28,7 @@ class KtorKeyValueRepoClient<Key, Value> (
             KtorWriteKeyValueRepoClient(
                 baseUrl,
                 httpClient,
-                contentType,
-                onNewValue,
-                onValueRemoved
+                contentType
             )
         )
         inline operator fun <reified Key, reified Value> invoke(
@@ -49,20 +37,12 @@ class KtorKeyValueRepoClient<Key, Value> (
             httpClient: HttpClient,
             contentType: ContentType,
             noinline idSerializer: suspend (Key) -> String,
-            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onNewValueRoute),
-            ),
-            onValueRemoved: Flow<Key> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onValueRemovedRoute),
-            ),
             noinline valueSerializer: suspend (Value) -> String
         ) = KtorKeyValueRepoClient(
             buildStandardUrl(baseUrl, subpart),
             httpClient,
             contentType,
             idSerializer,
-            onNewValue,
-            onValueRemoved,
             valueSerializer
         )
     }

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

@@ -60,19 +60,17 @@ class KtorWriteKeyValueRepoClient<Key, Value>(
         inline operator fun <reified Key, reified Value> invoke(
             baseUrl: String,
             httpClient: HttpClient,
-            contentType: ContentType,
-            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onNewValueRoute),
-            ),
-            onValueRemoved: Flow<Key> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onValueRemovedRoute),
-            ),
+            contentType: ContentType
         ) = KtorWriteKeyValueRepoClient<Key, Value>(
             baseUrl,
             httpClient,
             contentType,
-            onNewValue,
-            onValueRemoved,
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onNewValueRoute),
+            ),
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onValueRemovedRoute),
+            ),
             typeInfo<List<Key>>(),
             typeInfo<List<Value>>(),
             typeInfo<Map<Key, Value>>()

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

@@ -1,15 +1,10 @@
 package dev.inmo.micro_utils.repos.ktor.client.key.values
 
-import dev.inmo.micro_utils.ktor.client.createStandardWebsocketFlow
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.repos.*
-import dev.inmo.micro_utils.repos.ktor.common.one_to_many.onDataClearedRoute
-import dev.inmo.micro_utils.repos.ktor.common.one_to_many.onNewValueRoute
-import dev.inmo.micro_utils.repos.ktor.common.one_to_many.onValueRemovedRoute
 import io.ktor.client.HttpClient
 import io.ktor.http.ContentType
 import io.ktor.http.encodeURLQueryComponent
-import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.*
 
 class KtorKeyValuesRepoClient<Key, Value> (
@@ -25,15 +20,6 @@ class KtorKeyValuesRepoClient<Key, Value> (
             httpClient: HttpClient,
             contentType: ContentType,
             noinline keySerializer: suspend (Key) -> String,
-            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onNewValueRoute),
-            ),
-            onValueRemoved: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onValueRemovedRoute),
-            ),
-            onDataCleared: Flow<Key> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onDataClearedRoute),
-            ),
             noinline valueSerializer: suspend (Value) -> String
         ) = KtorKeyValuesRepoClient(
             KtorReadKeyValuesRepoClient(
@@ -46,10 +32,7 @@ class KtorKeyValuesRepoClient<Key, Value> (
             KtorWriteKeyValuesRepoClient(
                 baseUrl,
                 httpClient,
-                contentType,
-                onNewValue,
-                onValueRemoved,
-                onDataCleared
+                contentType
             )
         )
         inline operator fun <reified Key : Any, reified Value : Any> invoke(
@@ -58,24 +41,12 @@ class KtorKeyValuesRepoClient<Key, Value> (
             httpClient: HttpClient,
             contentType: ContentType,
             noinline keySerializer: suspend (Key) -> String,
-            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onNewValueRoute),
-            ),
-            onValueRemoved: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onValueRemovedRoute),
-            ),
-            onDataCleared: Flow<Key> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onDataClearedRoute),
-            ),
             noinline valueSerializer: suspend (Value) -> String
         ) = KtorKeyValuesRepoClient(
             buildStandardUrl(baseUrl, subpart),
             httpClient,
             contentType,
             keySerializer,
-            onNewValue,
-            onValueRemoved,
-            onDataCleared,
             valueSerializer
         )
     }
@@ -88,25 +59,13 @@ inline fun <reified Key : Any, reified Value : Any> KtorKeyValuesRepoClient(
     keySerializer: SerializationStrategy<Key>,
     valueSerializer: SerializationStrategy<Value>,
     serialFormat: StringFormat,
-    onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-        buildStandardUrl(baseUrl, onNewValueRoute),
-    ),
-    onValueRemoved: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-        buildStandardUrl(baseUrl, onValueRemovedRoute),
-    ),
-    onDataCleared: Flow<Key> = httpClient.createStandardWebsocketFlow(
-        buildStandardUrl(baseUrl, onDataClearedRoute),
-    ),
 ) = KtorKeyValuesRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,
     {
         serialFormat.encodeToString(keySerializer, it).encodeURLQueryComponent()
-    },
-    onNewValue,
-    onValueRemoved,
-    onDataCleared
+    }
 ) {
     serialFormat.encodeToString(valueSerializer, it).encodeURLQueryComponent()
 }
@@ -118,25 +77,13 @@ inline fun <reified Key : Any, reified Value : Any> KtorKeyValuesRepoClient(
     keySerializer: SerializationStrategy<Key>,
     valueSerializer: SerializationStrategy<Value>,
     serialFormat: BinaryFormat,
-    onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-        buildStandardUrl(baseUrl, onNewValueRoute),
-    ),
-    onValueRemoved: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-        buildStandardUrl(baseUrl, onValueRemovedRoute),
-    ),
-    onDataCleared: Flow<Key> = httpClient.createStandardWebsocketFlow(
-        buildStandardUrl(baseUrl, onDataClearedRoute),
-    ),
 ) = KtorKeyValuesRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,
     {
         serialFormat.encodeHex(keySerializer, it)
-    },
-    onNewValue,
-    onValueRemoved,
-    onDataCleared
+    }
 ) {
     serialFormat.encodeHex(valueSerializer, it)
 }

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

@@ -84,23 +84,20 @@ class KtorWriteKeyValuesRepoClient<Key : Any, Value : Any>(
         inline operator fun <reified Key : Any, reified Value : Any> invoke(
             baseUrl: String,
             httpClient: HttpClient,
-            contentType: ContentType,
-            onNewValue: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onNewValueRoute),
-            ),
-            onValueRemoved: Flow<Pair<Key, Value>> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onValueRemovedRoute),
-            ),
-            onDataCleared: Flow<Key> = httpClient.createStandardWebsocketFlow(
-                buildStandardUrl(baseUrl, onDataClearedRoute),
-            ),
+            contentType: ContentType
         ) = KtorWriteKeyValuesRepoClient<Key, Value>(
             baseUrl,
             httpClient,
             contentType,
-            onNewValue,
-            onValueRemoved,
-            onDataCleared,
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onNewValueRoute),
+            ),
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onValueRemovedRoute),
+            ),
+            httpClient.createStandardWebsocketFlow(
+                buildStandardUrl(baseUrl, onDataClearedRoute),
+            ),
             typeInfo<Key>(),
             typeInfo<Value>(),
             typeInfo<Map<Key, List<Value>>>()

settings.gradle

@@ -7,8 +7,6 @@ String[] includes = [
     ":safe_wrapper",
     ":crypto",
     ":koin",
-    ":koin:generator",
-    ":koin:generator:test",
     ":selector:common",
     ":pagination:common",
     ":pagination:exposed",
@@ -18,8 +16,6 @@ String[] includes = [
     ":language_codes",
     ":language_codes:generator",
     ":repos:common",
-    ":repos:generator",
-    ":repos:generator:test",
     ":repos:cache",
     ":repos:exposed",
     ":repos:inmemory",

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

@@ -14,7 +14,6 @@ import kotlinx.coroutines.launch
 import kotlinx.serialization.SerialFormat
 import kotlinx.serialization.StringFormat
 import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.decodeFromJsonElement
 import kotlinx.serialization.json.jsonObject
 import org.koin.core.Koin
 import org.koin.core.KoinApplication
@@ -39,18 +38,14 @@ object StartLauncherPlugin : StartPlugin {
 
         includes(
             config.plugins.mapNotNull {
-                val pluginName = it::class.simpleName ?: it.toString()
                 runCatching {
-                    logger.i { "Start koin module registration for $pluginName" }
                     module {
                         with(it) {
                             setupDI(rawJsonObject)
                         }
                     }
                 }.onFailure { e ->
-                    logger.w("Unable to register koin module of $pluginName", e)
-                }.onSuccess {
-                    logger.i("Successfully registered koin module of $pluginName")
+                    logger.w("Unable to load DI part of $it", e)
                 }.getOrNull()
             }
         )
@@ -80,17 +75,16 @@ object StartLauncherPlugin : StartPlugin {
         logger.i("Start starting of subplugins")
         val scope = koin.get<CoroutineScope>()
         koin.get<Config>().plugins.map { plugin ->
-            val pluginName = plugin::class.simpleName ?: plugin.toString()
             scope.launch {
                 runCatchingSafely {
-                    logger.i("Start loading of $pluginName")
+                    logger.i("Start loading of $plugin")
                     with(plugin) {
                         startPlugin(koin)
                     }
                 }.onFailure { e ->
-                    logger.w("Unable to start plugin $pluginName", e)
+                    logger.w("Unable to start plugin $plugin", e)
                 }.onSuccess {
-                    logger.i("Complete loading of $pluginName")
+                    logger.i("Complete loading of $plugin")
                 }
             }
         }.joinAll()
@@ -99,19 +93,18 @@ object StartLauncherPlugin : StartPlugin {
 
     /**
      * Will create [KoinApplication], init, load modules using [StartLauncherPlugin] and start plugins using the same base
-     * plugin. It is basic [start] method which accepts both [config] and [rawConfig] which suppose to be the same or
-     * at least [rawConfig] must contain serialized variant of [config]
+     * plugin
      *
      * @param rawConfig It is expected that this [JsonObject] will contain serialized [Config] ([StartLauncherPlugin] will
      * deserialize it in its [StartLauncherPlugin.setupDI]
      */
-    suspend fun start(config: Config, rawConfig: JsonObject) {
+    suspend fun start(rawConfig: JsonObject) {
 
         logger.i("Start initialization")
         val koinApp = KoinApplication.init()
         koinApp.modules(
             module {
-                setupDI(config, rawConfig)
+                setupDI(rawConfig)
             }
         )
         logger.i("Modules loaded")
@@ -123,26 +116,26 @@ object StartLauncherPlugin : StartPlugin {
     }
 
     /**
-     * Call [start] with deserialized [Config] as config and [rawConfig] as is
+     * 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]
-     */
-    suspend fun start(rawConfig: JsonObject) {
-
-        start(defaultJson.decodeFromJsonElement(Config.serializer(), rawConfig), rawConfig)
-
-    }
-
-    /**
-     * Call [start] with deserialized [Config] as is and serialize it to [JsonObject] to pass as the first parameter
-     * to the basic [start] method
-     *
-     * @param config Will be converted to [JsonObject] as raw config. That means that all plugins from [config] will
-     * receive serialized version of [config] in [StartPlugin.setupDI] method
+     * @param config In difference with other [start] method here config is already deserialized and this config will
+     * be converted to [JsonObject] as raw config. That means that all plugins from [config] will receive
+     * serialized version of [config] in [StartPlugin.setupDI] method
      */
     suspend fun start(config: Config) {
 
-        start(config, defaultJson.encodeToJsonElement(Config.serializer(), config).jsonObject)
+        logger.i("Start initialization")
+        val koinApp = KoinApplication.init()
+        logger.i("Koin app created")
+        koinApp.modules(
+            module {
+                setupDI(config)
+            }
+        )
+        startKoin(koinApp)
+        logger.i("Koin started")
+        startPlugin(koinApp.koin)
 
     }
 }

startup/launcher/src/jvmMain/kotlin/Main.kt

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.startup.launcher
 
 import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.i
 import kotlinx.serialization.json.jsonObject
 import java.io.File
@@ -24,25 +23,10 @@ import java.io.File
  * In that case in `build/distributions` folder you will be able to find zip and tar files with all required
  * tools for application running (via their `bin/app_name` binary). In that case yoy will not need to pass
  * `--args=...` and launch will look like `./bin/app_name sample.config.json`
- *
- * ## Debug mode
- *
- * You may pass the second parameter, one of [LogLevel] enum variants to setup [KSLog] minimal logging level. Sample:
- *
- * ```bash
- * ./gradlew run --args="sample.config.json DEBUG" // enable debugging output
- * ```
- *
- * OR
- * ```bash
- * ./gradlew run --args="sample.config.json WARNING" // enable logging since WARNING
- * ```
- *
- * **Default level is [LogLevel.INFO]**
  */
 suspend fun main(args: Array<String>) {
 
-    KSLog.default = KSLog("Launcher", args.getOrNull(1) ?.let { LogLevel.valueOf(it) } ?: LogLevel.INFO)
+    KSLog.default = KSLog("Launcher")
     val (configPath) = args
     val file = File(configPath)
     KSLog.i("Start read config from ${file.absolutePath}")

startup/template/README.md

@@ -1,10 +0,0 @@
-# How to use
-
-In case you have multiplatform project and wish to use startup plugin, this template may help you to create new modules.
-
-1. Copy-paste whole template folder (you may clone this folder to your project and actualize some data to copy your prepared template)
-2. Replace `group_name` by your project (or root module) group name
-3. Replace `module_name` by the name of your new module name
-
-You may read about the `build.gradle` structure in these templates in project
-[KotlinMultiplatformProjectTemplate](https://github.com/InsanusMokrassar/KotlinMultiplatformProjectTemplate).

startup/template/client/build.gradle

@@ -1,18 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.multiplatform"
-    id "org.jetbrains.kotlin.plugin.serialization"
-    id "com.android.library"
-    alias(libs.plugins.compose)
-}
-
-apply from: "$mppProjectWithSerializationPresetPath"
-
-kotlin {
-    sourceSets {
-        commonMain {
-            dependencies {
-                api project(":${rootProject.name}.module_name.common")
-            }
-        }
-    }
-}