fix transactions dsl

0.25.3

CHANGELOG.md

@@ -1,5 +1,85 @@
 # Changelog
 
+## 0.25.4
+
+* `Versions`:
+  * `Ktor`: `3.1.1` -> `3.1.2`
+  * `Koin`: `4.0.2` -> `4.0.4`
+* `Coroutines`:
+  * Add `SmartKeyRWLocker.withWriteLocks` extension with vararg keys
+* `Transactions`:
+  * Fix order of rollback actions calling
+
+## 0.25.3
+
+* `Coroutines`:
+  * Add extensions `SmartRWLocker.alsoWithUnlockingOnSuccessAsync` and `SmartRWLocker.alsoWithUnlockingOnSuccess`
+  * Fix of `SmartRWLocker.lockWrite` issue when it could lock write mutex without unlocking
+  * Add tool `SmartKeyRWLocker`
+  * `SmartSemaphore` got new property `maxPermits`
+  * New extension `SmartSemaphore.waitReleaseAll()`
+* `Transactions`:
+  * Add `TransactionsDSL`
+
+## 0.25.2
+
+* `Versions`:
+  * `Exposed`: `0.59.0` -> `0.60.0`
+* `Repo`:
+  * `Cache`:
+    * Add extensions `alsoInvalidate`, `alsoInvalidateAsync`, `alsoInvalidateSync` and `alsoInvalidateSyncLogging`
+* `Koin`:
+  * Add extensions `singleSuspend` and `factorySuspend` for defining of dependencies with suspendable blocks
+
+## 0.25.1
+
+* `Coroutines`:
+  * Add `SortedMapLikeBinaryTreeNode`
+* `Pagination`:
+  * `Compose`:
+    * One more rework of `InfinityPagedComponent` and `PagedComponent`
+
+## 0.25.0
+
+* `Repos`:
+  * `Cache`:
+    * All cache repos now do not have `open` vals - to avoid collisions in runtime
+
+## 0.24.9
+
+* `Pagination`:
+  * Make alternative constructor parameter `size` of `PaginationResult` with default value
+  * Add `Pagination.previousPage` extension
+  * `Compose`:
+    * Rework of `InfinityPagedComponentContext`
+    * Rework of `PagedComponent`
+
+## 0.24.8
+
+* `Versions`:
+  * `Ktor`: `3.1.0` -> `3.1.1`
+  * `KSP`: `2.1.10-1.0.30` -> `2.1.10-1.0.31`
+* `Common`:
+  * `Compose`:
+    * Add component `LoadableComponent`
+* `Coroutines`:
+  * Add `SortedBinaryTreeNode`
+* `Pagination`:
+  * `Compose`:
+    * Add components `PagedComponent` and `InfinityPagedComponent`
+
+## 0.24.7
+
+* `Versions`:
+  * `SQLite`: `3.49.0.0` -> `3.49.1.0`
+* `Common`:
+  * Add `retryOnFailure` utility for simple retries code writing
+* `Repos`:
+  * `Cache`:
+    * Fix of `FullKeyValueCacheRepo` fields usage
+  * `Exposed`:
+    * `AbstractExposedKeyValuesRepo` will produce `onValueRemoved` event on `set` if some data has been removed
+
 ## 0.24.6
 
 * `Versions`:

colors/common/src/commonMain/kotlin/HEXAColor.kt

@@ -13,7 +13,7 @@ import kotlin.math.floor
  *
  * Anyway it is recommended to use
  *
- * @param hexaUInt rgba [UInt] in format `0xFFEEBBAA` where FF - red, EE - green, BB - blue` and AA - alpha
+ * @param hexaUInt rgba [UInt] in format `0xRRGGBBAA` where RR - red, GG - green, BB - blue` and AA - alpha
  */
 @Serializable
 @JvmInline
@@ -21,18 +21,18 @@ value class HEXAColor (
     val hexaUInt: UInt
 ) : Comparable<HEXAColor> {
     /**
-     * @returns [hexaUInt] as a string with format `#FFEEBBAA` where FF - red, EE - green, BB - blue and AA - alpha
+     * @returns [hexaUInt] as a string with format `#RRGGBBAA` where RR - red, GG - green, BB - blue and AA - alpha
      */
     val hexa: String
         get() = "#${hexaUInt.toString(16).padStart(8, '0')}"
 
     /**
-     * @returns [hexaUInt] as a string with format `#FFEEBB` where FF - red, EE - green and BB - blue
+     * @returns [hexaUInt] as a string with format `#RRGGBB` where RR - red, GG - green and BB - blue
      */
     val hex: String
         get() = hexa.take(7)
     /**
-     * @returns [hexaUInt] as a string with format `#AAFFEEBB` where AA - alpha, FF - red, EE - green and BB - blue
+     * @returns [hexaUInt] as a string with format `#AARRGGBB` where AA - alpha, RR - red, GG - green and BB - blue
      */
     val ahex: String
         get() = "#${a.toString(16).padStart(2, '2')}${hex.drop(1)}"
@@ -140,12 +140,12 @@ value class HEXAColor (
         }.lowercase().toUInt(16).let(::HEXAColor)
 
         /**
-         * Creates [HEXAColor] from [uint] presume it is in format `0xFFEEBBAA` where FF - red, EE - green, BB - blue` and AA - alpha
+         * Creates [HEXAColor] from [uint] presume it is in format `0xRRGGBBAA` where RR - red, GG - green, BB - blue` and AA - alpha
          */
         fun fromHexa(uint: UInt) = HEXAColor(uint)
 
         /**
-         * Creates [HEXAColor] from [uint] presume it is in format `0xAAFFEEBB` where AA - alpha, FF - red, EE - green and BB - blue`
+         * Creates [HEXAColor] from [uint] presume it is in format `0xAARRGGBB` where AA - alpha, RR - red, GG - green and BB - blue`
          */
         fun fromAhex(uint: UInt) = HEXAColor(
             a = ((uint and 0xff000000u) / 0x1000000u).toInt(),

common/compose/build.gradle

@@ -13,6 +13,7 @@ kotlin {
         commonMain {
             dependencies {
                 api project(":micro_utils.common")
+                api libs.kt.coroutines
             }
         }
     }

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

@@ -0,0 +1,74 @@
+package dev.inmo.micro_utils.common.compose
+
+import androidx.compose.runtime.*
+import dev.inmo.micro_utils.common.Optional
+import dev.inmo.micro_utils.common.dataOrThrow
+import dev.inmo.micro_utils.common.optional
+
+class LoadableComponentContext<T> internal constructor(
+    presetOptional: Optional<T>,
+) {
+    internal val iterationState: MutableState<Int> = mutableStateOf(0)
+
+    internal var dataOptional: Optional<T> = if (presetOptional.dataPresented) presetOptional else Optional.absent()
+        private set
+    internal val dataState: MutableState<Optional<T>> = mutableStateOf(dataOptional)
+
+    fun reload() {
+        iterationState.value++
+    }
+}
+
+/**
+ * Showing data with ability to reload data
+ *
+ * [block] will be shown when [loader] will complete loading. If you want to reload data, just call
+ * [LoadableComponentContext.reload]
+ */
+@Composable
+fun <T> LoadableComponent(
+    preload: Optional<T>,
+    loader: suspend LoadableComponentContext<T>.() -> T,
+    block: @Composable LoadableComponentContext<T>.(T) -> Unit
+) {
+    val context = remember { LoadableComponentContext(preload) }
+
+    LaunchedEffect(context.iterationState.value) {
+        context.dataState.value = loader(context).optional
+    }
+
+    context.dataState.let {
+        if (it.value.dataPresented) {
+            context.block(it.value.dataOrThrow(IllegalStateException("Data must be presented, but optional has been changed by some way")))
+        }
+    }
+}
+
+/**
+ * Showing data with ability to reload data
+ *
+ * [block] will be shown when [loader] will complete loading. If you want to reload data, just call
+ * [LoadableComponentContext.reload]
+ */
+@Composable
+fun <T> LoadableComponent(
+    preload: T,
+    loader: suspend LoadableComponentContext<T>.() -> T,
+    block: @Composable LoadableComponentContext<T>.(T) -> Unit
+) {
+    LoadableComponent(preload.optional, loader, block)
+}
+
+/**
+ * Showing data with ability to reload data
+ *
+ * [block] will be shown when [loader] will complete loading. If you want to reload data, just call
+ * [LoadableComponentContext.reload]
+ */
+@Composable
+fun <T> LoadableComponent(
+    loader: suspend LoadableComponentContext<T>.() -> T,
+    block: @Composable LoadableComponentContext<T>.(T) -> Unit
+) {
+    LoadableComponent(Optional.absent(), loader, block)
+}

common/compose/src/jvmTest/kotlin/LoadableComponentTests.kt

@@ -0,0 +1,42 @@
+import androidx.compose.runtime.remember
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.runComposeUiTest
+import dev.inmo.micro_utils.common.compose.LoadableComponent
+import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.firstOrNull
+import org.jetbrains.annotations.TestOnly
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class LoadableComponentTests {
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    @TestOnly
+    fun testSimpleLoad() = runComposeUiTest {
+        val loadingFlow = SpecialMutableStateFlow<Int>(0)
+        val loadedFlow = SpecialMutableStateFlow<Int>(0)
+        setContent {
+            LoadableComponent<Int>({
+                loadingFlow.filter { it == 1 }.first()
+            }) {
+                assert(dataState.value.data == 1)
+                remember {
+                    loadedFlow.value = 2
+                }
+            }
+        }
+
+        waitForIdle()
+
+        assertTrue(loadedFlow.value == 0)
+
+        loadingFlow.value = 1
+
+        waitForIdle()
+
+        assertTrue(loadedFlow.value == 2)
+    }
+}

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

@@ -0,0 +1,6 @@
+package dev.inmo.micro_utils.common
+
+/**
+ * Creates simple [Comparator] which will use [compareTo] of [T] for both objects
+ */
+fun <T : Comparable<C>, C : T> T.createComparator() = Comparator<C> { o1, o2 -> o1.compareTo(o2) }

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

@@ -0,0 +1,26 @@
+package dev.inmo.micro_utils.common
+
+/**
+ * Will try to execute [action] and, if any exception will happen, execution will be retried.
+ * This process will happen at most [count] times. There is no any limits on [count] value, but [action] will run at
+ * least once and [retryOnFailure] will return its result if it is successful
+ */
+inline fun <T> retryOnFailure(count: Int, action: () -> T): T {
+    var triesCount = 0
+    while (true) {
+        val result = runCatching {
+            action()
+        }.onFailure {
+            triesCount++
+
+            if (triesCount >= count) {
+                throw it
+            } else {
+                null
+            }
+        }
+
+        if (result.isSuccess) return result.getOrThrow()
+    }
+    error("Unreachable code: retry must throw latest exception if error happen or success value if not")
+}

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

@@ -71,7 +71,7 @@ fun <T, M> Flow<T>.subscribeAsync(
         it.invoke(markersMap)
     }
 
-    val job = subscribeSafelyWithoutExceptions(subscope) { data ->
+    val job = subscribeLoggingDropExceptions(subscope) { data ->
         val dataCommand = AsyncSubscriptionCommandData(data, subscope, markerFactory, block) { marker ->
             actor.send(
                 AsyncSubscriptionCommandClearReceiver(marker)

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

@@ -0,0 +1,226 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+/**
+ * Combining [globalRWLocker] and internal map of [SmartRWLocker] associated by [T] to provide next logic:
+ *
+ * * Locker by key, for reading: waiting for [globalRWLocker] unlock write by acquiring read permit in it and then
+ * taking or creating locker for key [T] and lock its reading too
+ * * Locker by key, for writing: waiting for [globalRWLocker] unlock write by acquiring read permit in it and then
+ * taking or creating locker for key [T] and lock its writing
+ * * [globalRWLocker], for reading: using [SmartRWLocker.acquireRead], will be suspended until its
+ * [SmartRWLocker.lockWrite] will not be unlocked
+ * * [globalRWLocker], for writing: using [SmartRWLocker.lockWrite], will be paused by other reading and writing
+ * operations and will pause other operations until the end of operation (calling of [unlockWrite])
+ *
+ * You may see, that lockers by key still will use global locker permits - it is required to prevent [globalRWLocker]
+ * write locking during all other operations are not done. In fact, all the keys works like a simple [SmartRWLocker] as
+ * well, as [globalRWLocker], but they are linked with [globalRWLocker] [SmartRWLocker.acquireRead] permissions
+ */
+class SmartKeyRWLocker<T>(
+    globalLockerReadPermits: Int = Int.MAX_VALUE,
+    globalLockerWriteIsLocked: Boolean = false,
+    private val perKeyReadPermits: Int = Int.MAX_VALUE
+) {
+    private val globalRWLocker: SmartRWLocker = SmartRWLocker(
+        readPermits = globalLockerReadPermits,
+        writeIsLocked = globalLockerWriteIsLocked
+    )
+    private val lockers = mutableMapOf<T, SmartRWLocker>()
+    private val lockersMutex = Mutex()
+    private val lockersWritingLocker = SmartSemaphore.Mutable(Int.MAX_VALUE)
+    private val globalWritingLocker = SmartSemaphore.Mutable(Int.MAX_VALUE)
+
+    private fun allocateLockerWithoutLock(key: T) = lockers.getOrPut(key) {
+        SmartRWLocker(perKeyReadPermits)
+    }
+    private suspend fun allocateLocker(key: T) = lockersMutex.withLock {
+        lockers.getOrPut(key) {
+            SmartRWLocker(perKeyReadPermits)
+        }
+    }
+
+    suspend fun writeMutex(key: T): SmartMutex.Immutable = globalRWLocker.withReadAcquire {
+        allocateLockerWithoutLock(key).writeMutex
+    }
+    suspend fun readSemaphore(key: T): SmartSemaphore.Immutable = globalRWLocker.withReadAcquire {
+        allocateLockerWithoutLock(key).readSemaphore
+    }
+    fun writeMutexOrNull(key: T): SmartMutex.Immutable? = lockers[key] ?.writeMutex
+    fun readSemaphoreOrNull(key: T): SmartSemaphore.Immutable? = lockers[key] ?.readSemaphore
+
+    fun writeMutex(): SmartMutex.Immutable = globalRWLocker.writeMutex
+    fun readSemaphore(): SmartSemaphore.Immutable = globalRWLocker.readSemaphore
+
+    suspend fun acquireRead() {
+        globalWritingLocker.acquire()
+        try {
+            lockersWritingLocker.waitReleaseAll()
+            globalRWLocker.acquireRead()
+        } catch (e: CancellationException) {
+            globalWritingLocker.release()
+            throw e
+        }
+    }
+    suspend fun releaseRead(): Boolean {
+        globalWritingLocker.release()
+        return globalRWLocker.releaseRead()
+    }
+
+    suspend fun lockWrite() {
+        globalRWLocker.lockWrite()
+    }
+    suspend fun unlockWrite(): Boolean {
+        return globalRWLocker.unlockWrite()
+    }
+    fun isWriteLocked(): Boolean = globalRWLocker.writeMutex.isLocked == true
+
+
+    suspend fun acquireRead(key: T) {
+        globalRWLocker.acquireRead()
+        val locker = allocateLocker(key)
+        try {
+            locker.acquireRead()
+        } catch (e: CancellationException) {
+            globalRWLocker.releaseRead()
+            throw e
+        }
+    }
+    suspend fun releaseRead(key: T): Boolean {
+        val locker = allocateLocker(key)
+        return locker.releaseRead() && globalRWLocker.releaseRead()
+    }
+
+    suspend fun lockWrite(key: T) {
+        globalWritingLocker.withAcquire(globalWritingLocker.maxPermits) {
+            lockersWritingLocker.acquire()
+        }
+        try {
+            globalRWLocker.acquireRead()
+            try {
+                val locker = allocateLocker(key)
+                locker.lockWrite()
+            } catch (e: CancellationException) {
+                globalRWLocker.releaseRead()
+                throw e
+            }
+        } catch (e: CancellationException) {
+            lockersWritingLocker.release()
+            throw e
+        }
+    }
+    suspend fun unlockWrite(key: T): Boolean {
+        val locker = allocateLocker(key)
+        return (locker.unlockWrite() && globalRWLocker.releaseRead()).also {
+            if (it) {
+                lockersWritingLocker.release()
+            }
+        }
+    }
+    fun isWriteLocked(key: T): Boolean = lockers[key] ?.writeMutex ?.isLocked == true
+}
+
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <T, R> SmartKeyRWLocker<T>.withReadAcquire(action: () -> R): R {
+    contract {
+        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
+    }
+
+    acquireRead()
+    try {
+        return action()
+    } finally {
+        releaseRead()
+    }
+}
+
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <T, R> SmartKeyRWLocker<T>.withWriteLock(action: () -> R): R {
+    contract {
+        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
+    }
+
+    lockWrite()
+    try {
+        return action()
+    } finally {
+        unlockWrite()
+    }
+}
+
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <T, R> SmartKeyRWLocker<T>.withReadAcquire(key: T, action: () -> R): R {
+    contract {
+        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
+    }
+
+    acquireRead(key)
+    try {
+        return action()
+    } finally {
+        releaseRead(key)
+    }
+}
+
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <T, R> SmartKeyRWLocker<T>.withReadAcquires(keys: Iterable<T>, action: () -> R): R {
+    contract {
+        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
+    }
+
+    val acquired = mutableSetOf<T>()
+    try {
+        keys.forEach {
+            acquireRead(it)
+            acquired.add(it)
+        }
+        return action()
+    } finally {
+        acquired.forEach {
+            releaseRead(it)
+        }
+    }
+}
+suspend inline fun <T, R> SmartKeyRWLocker<T>.withReadAcquires(vararg keys: T, action: () -> R): R = withReadAcquires(keys.asIterable(), action)
+
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <T, R> SmartKeyRWLocker<T>.withWriteLock(key: T, action: () -> R): R {
+    contract {
+        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
+    }
+
+    lockWrite(key)
+    try {
+        return action()
+    } finally {
+        unlockWrite(key)
+    }
+}
+
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <T, R> SmartKeyRWLocker<T>.withWriteLocks(keys: Iterable<T>, action: () -> R): R {
+    contract {
+        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
+    }
+
+    val locked = mutableSetOf<T>()
+    try {
+        keys.forEach {
+            lockWrite(it)
+            locked.add(it)
+        }
+        return action()
+    } finally {
+        locked.forEach {
+            unlockWrite(it)
+        }
+    }
+}
+
+suspend inline fun <T, R> SmartKeyRWLocker<T>.withWriteLocks(vararg keys: T, action: () -> R): R = withWriteLocks(keys.asIterable(), action)

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

@@ -1,5 +1,6 @@
 package dev.inmo.micro_utils.coroutines
 
+import kotlinx.coroutines.CancellationException
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -7,9 +8,10 @@ import kotlin.contracts.contract
 /**
  * Composite mutex which works with next rules:
  *
- * * [acquireRead] require to [writeMutex] be free. Then it will take one lock from [readSemaphore]
+ * * [acquireRead] require to [writeMutex] to be free. Then it will take one lock from [readSemaphore]
  * * [releaseRead] will just free up one permit in [readSemaphore]
- * * [lockWrite] will lock [writeMutex] and then await while all [readSemaphore] will be freed
+ * * [lockWrite] will lock [writeMutex] and then await while all [readSemaphore] will be freed. If coroutine will be
+ * cancelled during read semaphore freeing, locking will be cancelled too with [SmartMutex.Mutable.unlock]ing of [writeMutex]
  * * [unlockWrite] will just unlock [writeMutex]
  */
 class SmartRWLocker(private val readPermits: Int = Int.MAX_VALUE, writeIsLocked: Boolean = false) {
@@ -39,7 +41,12 @@ class SmartRWLocker(private val readPermits: Int = Int.MAX_VALUE, writeIsLocked:
      */
     suspend fun lockWrite() {
         _writeMutex.lock()
-        _readSemaphore.acquire(readPermits)
+        try {
+            _readSemaphore.acquire(readPermits)
+        } catch (e: CancellationException) {
+            _writeMutex.unlock()
+            throw e
+        }
     }
 
     /**

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

@@ -0,0 +1,23 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+
+suspend inline fun alsoWithUnlockingOnSuccess(
+    vararg lockers: SmartRWLocker,
+    block: suspend () -> Unit
+): Result<Unit> {
+    return runCatching {
+        block()
+    }.onSuccess {
+        lockers.forEach { it.unlockWrite() }
+    }
+}
+
+fun alsoWithUnlockingOnSuccessAsync(
+    scope: CoroutineScope,
+    vararg lockers: SmartRWLocker,
+    block: suspend () -> Unit
+): Job = scope.launchLoggingDropExceptions {
+    alsoWithUnlockingOnSuccess(*lockers, block = block)
+}

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

@@ -24,6 +24,7 @@ import kotlin.contracts.contract
  * [Mutable] creator
  */
 sealed interface SmartSemaphore {
+    val maxPermits: Int
     val permitsStateFlow: StateFlow<Int>
 
     /**
@@ -36,7 +37,7 @@ sealed interface SmartSemaphore {
     /**
      * Immutable variant of [SmartSemaphore]. In fact will depend on the owner of [permitsStateFlow]
      */
-    class Immutable(override val permitsStateFlow: StateFlow<Int>) : SmartSemaphore
+    class Immutable(override val permitsStateFlow: StateFlow<Int>, override val maxPermits: Int) : SmartSemaphore
 
     /**
      * Mutable variant of [SmartSemaphore]. With that variant you may [lock] and [unlock]. Besides, you may create
@@ -44,15 +45,16 @@ sealed interface SmartSemaphore {
      *
      * @param locked Preset state of [freePermits] and its internal [_freePermitsStateFlow]
      */
-    class Mutable(private val permits: Int, acquiredPermits: Int = 0) : SmartSemaphore {
+    class Mutable(permits: Int, acquiredPermits: Int = 0) : SmartSemaphore {
+        override val maxPermits: Int = permits
         private val _freePermitsStateFlow = SpecialMutableStateFlow<Int>(permits - acquiredPermits)
         override val permitsStateFlow: StateFlow<Int> = _freePermitsStateFlow.asStateFlow()
 
         private val internalChangesMutex = Mutex(false)
 
-        fun immutable() = Immutable(permitsStateFlow)
+        fun immutable() = Immutable(permitsStateFlow, maxPermits)
 
-        private fun checkedPermits(permits: Int) = permits.coerceIn(1 .. this.permits)
+        private fun checkedPermits(permits: Int) = permits.coerceIn(1 .. this.maxPermits)
 
         /**
          * Holds call until this [SmartSemaphore] will be re-locked. That means that current method will
@@ -126,10 +128,10 @@ sealed interface SmartSemaphore {
          */
         suspend fun release(permits: Int = 1): Boolean {
             val checkedPermits = checkedPermits(permits)
-            return if (_freePermitsStateFlow.value < this.permits) {
+            return if (_freePermitsStateFlow.value < this.maxPermits) {
                 internalChangesMutex.withLock {
-                    if (_freePermitsStateFlow.value < this.permits) {
+                    if (_freePermitsStateFlow.value < this.maxPermits) {
-                        _freePermitsStateFlow.value = minOf(_freePermitsStateFlow.value + checkedPermits, this.permits)
+                        _freePermitsStateFlow.value = minOf(_freePermitsStateFlow.value + checkedPermits, this.maxPermits)
                         true
                     } else {
                         false
@@ -166,3 +168,4 @@ suspend inline fun <T> SmartSemaphore.Mutable.withAcquire(permits: Int = 1, acti
  * the fact that some other parties may lock it again
  */
 suspend fun SmartSemaphore.waitRelease(permits: Int = 1) = permitsStateFlow.first { it >= permits }
+suspend fun SmartSemaphore.waitReleaseAll() = permitsStateFlow.first { it == maxPermits }

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/collections/SortedBinaryTreeNode.kt

@@ -0,0 +1,318 @@
+package dev.inmo.micro_utils.coroutines.collections
+
+import dev.inmo.micro_utils.coroutines.SmartRWLocker
+import dev.inmo.micro_utils.coroutines.withReadAcquire
+import dev.inmo.micro_utils.coroutines.withWriteLock
+import kotlinx.coroutines.job
+import kotlinx.serialization.Serializable
+import kotlin.coroutines.coroutineContext
+
+/**
+ * Creates simple [Comparator] which will use [compareTo] of [T] for both objects
+ */
+private fun <T : Comparable<C>, C : T> T.createComparator() = Comparator<C> { o1, o2 -> o1.compareTo(o2) }
+
+@Serializable
+class SortedBinaryTreeNode<T>(
+    val data: T,
+    internal val comparator: Comparator<T>,
+) : Iterable<SortedBinaryTreeNode<T>> {
+    internal var leftNode: SortedBinaryTreeNode<T>? = null
+    internal var rightNode: SortedBinaryTreeNode<T>? = null
+    internal val locker: SmartRWLocker by lazy {
+        SmartRWLocker()
+    }
+
+    suspend fun getLeftNode() = locker.withReadAcquire {
+        leftNode
+    }
+
+    suspend fun getRightNode() = locker.withReadAcquire {
+        rightNode
+    }
+
+    suspend fun getLeft() = getLeftNode() ?.data
+
+    suspend fun getRight() = getRightNode() ?.data
+
+    override fun equals(other: Any?): Boolean {
+        return other === this || (other is SortedBinaryTreeNode<*> && other.data == data && other.rightNode == rightNode && other.leftNode == leftNode)
+    }
+
+    override fun hashCode(): Int {
+        return data.hashCode() * 31 + rightNode.hashCode() + leftNode.hashCode()
+    }
+
+    suspend fun size(): Int {
+        return locker.withReadAcquire {
+            1 + (leftNode ?.size() ?: 0) + (rightNode ?.size() ?: 0)
+        }
+    }
+
+    /**
+     * This [Iterator] will run from less to greater values of nodes starting the
+     * [dev.inmo.micro_utils.coroutines.collections.SortedBinaryTreeNode]-receiver. Due to non-suspending
+     * nature of [iterator] builder, this [Iterator] **DO NOT** guarantee consistent content due to iterations. It
+     * means, that tree can be changed during to iteration process
+     */
+    override fun iterator(): Iterator<SortedBinaryTreeNode<T>> = iterator {
+        leftNode ?.let {
+            it.iterator().forEach { yield(it) }
+        }
+        yield(this@SortedBinaryTreeNode)
+        rightNode ?.let {
+            it.iterator().forEach { yield(it) }
+        }
+    }
+
+    override fun toString(): String {
+        return "$data($leftNode;$rightNode)"
+    }
+
+    companion object {
+        operator fun <T : Comparable<T>> invoke(
+            data: T,
+        ) = SortedBinaryTreeNode(
+            data,
+            data.createComparator()
+        )
+    }
+}
+
+/**
+ * Will add subnode in tree if there are no any node with [newData]
+ *
+ * * If [newData] is greater than [SortedBinaryTreeNode.data] of currently checking node,
+ * will be used [SortedBinaryTreeNode.rightNode]
+ * * If [newData] is equal to [SortedBinaryTreeNode.data] of currently
+ * checking node - will be returned currently checking node
+ * * If [newData] is less than [SortedBinaryTreeNode.data] of currently
+ * checking node - will be used [SortedBinaryTreeNode.leftNode]
+ *
+ * This process will continue until function will not find place to put [SortedBinaryTreeNode] with data or
+ * [SortedBinaryTreeNode] with [SortedBinaryTreeNode.data] same as [newData] will be found
+ */
+private suspend fun <T> SortedBinaryTreeNode<T>.upsertSubNode(
+    subNode: SortedBinaryTreeNode<T>,
+    skipLockers: Set<SmartRWLocker> = emptySet()
+): SortedBinaryTreeNode<T> {
+    var currentlyChecking = this
+    val lockedLockers = mutableSetOf<SmartRWLocker>()
+    try {
+        while (coroutineContext.job.isActive) {
+            if (currentlyChecking.locker !in lockedLockers && currentlyChecking.locker !in skipLockers) {
+                currentlyChecking.locker.lockWrite()
+                lockedLockers.add(currentlyChecking.locker)
+            }
+            val left = currentlyChecking.leftNode
+            val right = currentlyChecking.rightNode
+            val comparingResult = currentlyChecking.comparator.compare(subNode.data, currentlyChecking.data)
+            val isGreater = comparingResult > 0
+            when {
+                comparingResult == 0 -> return currentlyChecking
+                isGreater && right == null -> {
+                    currentlyChecking.rightNode = subNode
+                    return subNode
+                }
+                isGreater && right != null -> {
+                    currentlyChecking = right
+                }
+                left == null -> {
+                    currentlyChecking.leftNode = subNode
+                    return subNode
+                }
+                else -> {
+                    currentlyChecking = left
+                }
+            }
+        }
+    } finally {
+        lockedLockers.forEach {
+            runCatching { it.unlockWrite() }
+        }
+    }
+    error("Unable to add node")
+}
+
+/**
+ * Will add subnode in tree if there are no any node with [newData]
+ *
+ * * If [newData] is greater than [SortedBinaryTreeNode.data] of currently checking node,
+ * will be used [SortedBinaryTreeNode.rightNode]
+ * * If [newData] is equal to [SortedBinaryTreeNode.data] of currently
+ * checking node - will be returned currently checking node
+ * * If [newData] is less than [SortedBinaryTreeNode.data] of currently
+ * checking node - will be used [SortedBinaryTreeNode.leftNode]
+ *
+ * This process will continue until function will not find place to put [SortedBinaryTreeNode] with data or
+ * [SortedBinaryTreeNode] with [SortedBinaryTreeNode.data] same as [newData] will be found
+ */
+suspend fun <T> SortedBinaryTreeNode<T>.addSubNode(newData: T): SortedBinaryTreeNode<T> {
+    return upsertSubNode(
+        SortedBinaryTreeNode(newData, comparator)
+    )
+}
+
+suspend fun <T> SortedBinaryTreeNode<T>.findParentNode(data: T): SortedBinaryTreeNode<T>? {
+    var currentParent: SortedBinaryTreeNode<T>? = null
+    var currentlyChecking: SortedBinaryTreeNode<T>? = this
+    val lockedLockers = mutableSetOf<SmartRWLocker>()
+    try {
+        while (coroutineContext.job.isActive) {
+            if (currentlyChecking == null) {
+                return null
+            }
+            if (currentlyChecking.locker !in lockedLockers) {
+                currentlyChecking.locker.acquireRead()
+                lockedLockers.add(currentlyChecking.locker)
+            }
+            val comparingResult = currentlyChecking.comparator.compare(data, currentlyChecking.data)
+            when {
+                comparingResult > 0 -> {
+                    currentParent = currentlyChecking
+                    currentlyChecking = currentlyChecking.rightNode
+                    continue
+                }
+                comparingResult < 0 -> {
+                    currentParent = currentlyChecking
+                    currentlyChecking = currentlyChecking.leftNode
+                    continue
+                }
+                else -> return currentParent
+            }
+        }
+    } finally {
+        lockedLockers.forEach {
+            runCatching { it.releaseRead() }
+        }
+    }
+    error("Unable to find node")
+}
+
+/**
+ * Will remove (detach) node from tree starting with [this] [SortedBinaryTreeNode]
+ *
+ * @return If data were found, [Pair] where [Pair.first] is the parent node where from [Pair.second] has been detached;
+ *         null otherwise
+ */
+suspend fun <T> SortedBinaryTreeNode<T>.removeSubNode(data: T): Pair<SortedBinaryTreeNode<T>, SortedBinaryTreeNode<T>>? {
+    val onFoundToRemoveCallback: suspend SortedBinaryTreeNode<T>.(left: SortedBinaryTreeNode<T>?, right: SortedBinaryTreeNode<T>?) -> Unit = { left, right ->
+        left ?.also { leftNode -> upsertSubNode(leftNode, setOf(locker)) }
+        right ?.also { rightNode -> upsertSubNode(rightNode, setOf(locker)) }
+    }
+    while (coroutineContext.job.isActive) {
+        val foundParentNode = findParentNode(data) ?: return null
+        foundParentNode.locker.withWriteLock {
+            val left = foundParentNode.leftNode
+            val right = foundParentNode.rightNode
+            when {
+                left != null && left.comparator.compare(data, left.data) == 0 -> {
+                    foundParentNode.leftNode = null
+                    foundParentNode.onFoundToRemoveCallback(left.leftNode, left.rightNode)
+                    return foundParentNode to left
+                }
+                right != null && right.comparator.compare(data, right.data) == 0 -> {
+                    foundParentNode.rightNode = null
+                    foundParentNode.onFoundToRemoveCallback(right.leftNode, right.rightNode)
+                    return foundParentNode to right
+                }
+                else -> {
+                    return@withWriteLock // data has been changed, new search required
+                }
+            }
+        }
+    }
+    error("Unable to remove node")
+}
+suspend fun <T> SortedBinaryTreeNode<T>.findNode(data: T): SortedBinaryTreeNode<T>? {
+    var currentlyChecking: SortedBinaryTreeNode<T>? = this
+    val lockedLockers = mutableSetOf<SmartRWLocker>()
+    try {
+        while (coroutineContext.job.isActive) {
+            if (currentlyChecking == null) {
+                return null
+            }
+            if (currentlyChecking.locker !in lockedLockers) {
+                currentlyChecking.locker.acquireRead()
+                lockedLockers.add(currentlyChecking.locker)
+            }
+            val comparingResult = currentlyChecking.comparator.compare(data, currentlyChecking.data)
+            when {
+                comparingResult > 0 -> {
+                    currentlyChecking = currentlyChecking.rightNode
+                    continue
+                }
+                comparingResult < 0 -> {
+                    currentlyChecking = currentlyChecking.leftNode
+                    continue
+                }
+                else -> return currentlyChecking
+            }
+        }
+    } finally {
+        lockedLockers.forEach {
+            runCatching { it.releaseRead() }
+        }
+    }
+    error("Unable to find node")
+}
+suspend fun <T> SortedBinaryTreeNode<T>.contains(data: T): Boolean = findNode(data) != null
+
+suspend fun <T> SortedBinaryTreeNode<T>.findNodesInRange(from: T, to: T, fromInclusiveMode: Boolean, toInclusiveMode: Boolean): Set<SortedBinaryTreeNode<T>> {
+    val results = mutableSetOf<SortedBinaryTreeNode<T>>()
+    val leftToCheck = mutableSetOf(this)
+    val lockedLockers = mutableSetOf<SmartRWLocker>()
+    val fromComparingFun: (SortedBinaryTreeNode<T>) -> Boolean = if (fromInclusiveMode) {
+        { it.comparator.compare(from, it.data) <= 0 }
+    } else {
+        { it.comparator.compare(from, it.data) < 0 }
+    }
+    val toComparingFun: (SortedBinaryTreeNode<T>) -> Boolean = if (toInclusiveMode) {
+        { it.comparator.compare(to, it.data) >= 0 }
+    } else {
+        { it.comparator.compare(to, it.data) > 0 }
+    }
+    try {
+        while (coroutineContext.job.isActive && leftToCheck.isNotEmpty()) {
+            val currentlyChecking = leftToCheck.first()
+            leftToCheck.remove(currentlyChecking)
+            if (currentlyChecking in results) {
+                continue
+            }
+            currentlyChecking.locker.acquireRead()
+            lockedLockers.add(currentlyChecking.locker)
+            if (fromComparingFun(currentlyChecking) && toComparingFun(currentlyChecking)) {
+                results.add(currentlyChecking)
+                currentlyChecking.leftNode ?.let { leftToCheck.add(it) }
+                currentlyChecking.rightNode ?.let { leftToCheck.add(it) }
+                continue
+            }
+            when {
+                currentlyChecking.comparator.compare(to, currentlyChecking.data) < 0 -> currentlyChecking.leftNode ?.let { leftToCheck.add(it) }
+                currentlyChecking.comparator.compare(from, currentlyChecking.data) > 0 -> currentlyChecking.rightNode ?.let { leftToCheck.add(it) }
+            }
+        }
+        return results.toSet()
+    } finally {
+        lockedLockers.forEach {
+            runCatching { it.releaseRead() }
+        }
+    }
+    error("Unable to find nodes range")
+}
+suspend fun <T> SortedBinaryTreeNode<T>.findNodesInRange(from: T, to: T): Set<SortedBinaryTreeNode<T>> = findNodesInRange(
+    from = from,
+    to = to,
+    fromInclusiveMode = true,
+    toInclusiveMode = true
+)
+suspend fun <T> SortedBinaryTreeNode<T>.findNodesInRangeExcluding(from: T, to: T): Set<SortedBinaryTreeNode<T>> = findNodesInRange(
+    from = from,
+    to = to,
+    fromInclusiveMode = false,
+    toInclusiveMode = false
+)
+suspend fun <T : Comparable<T>> SortedBinaryTreeNode<T>.findNodesInRange(range: ClosedRange<T>): Set<SortedBinaryTreeNode<T>> = findNodesInRange(
+    from = range.start,
+    to = range.endInclusive,
+)

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/collections/SortedMapLikeBinaryTreeNode.kt

@@ -0,0 +1,401 @@
+package dev.inmo.micro_utils.coroutines.collections
+
+import dev.inmo.micro_utils.coroutines.SmartRWLocker
+import dev.inmo.micro_utils.coroutines.withReadAcquire
+import dev.inmo.micro_utils.coroutines.withWriteLock
+import kotlinx.coroutines.job
+import kotlinx.serialization.Serializable
+import kotlin.coroutines.coroutineContext
+
+/**
+ * Creates simple [Comparator] which will use [compareTo] of [T] for both objects
+ */
+private fun <T : Comparable<C>, C : T> T.createComparator() = Comparator<C> { o1, o2 -> o1.compareTo(o2) }
+
+@Serializable
+class SortedMapLikeBinaryTreeNode<K, V>(
+    val key: K,
+    val value: V,
+    internal val comparator: Comparator<K>,
+) : Iterable<SortedMapLikeBinaryTreeNode<K, V>> {
+    internal var leftNode: SortedMapLikeBinaryTreeNode<K, V>? = null
+    internal var rightNode: SortedMapLikeBinaryTreeNode<K, V>? = null
+    internal val locker: SmartRWLocker by lazy {
+        SmartRWLocker()
+    }
+
+    suspend fun getLeftNode() = locker.withReadAcquire {
+        leftNode
+    }
+
+    suspend fun getRightNode() = locker.withReadAcquire {
+        rightNode
+    }
+
+    suspend fun getLeftKey() = getLeftNode() ?.key
+    suspend fun getLeftValue() = getLeftNode() ?.value
+
+    suspend fun getRightKey() = getRightNode() ?.value
+    suspend fun getRightValue() = getRightNode() ?.value
+
+    override fun equals(other: Any?): Boolean {
+        return other === this || (other is SortedMapLikeBinaryTreeNode<*, *> && other.key == key && other.rightNode == rightNode && other.leftNode == leftNode)
+    }
+
+    override fun hashCode(): Int {
+        return key.hashCode() * 31 + rightNode.hashCode() + leftNode.hashCode()
+    }
+
+    suspend fun size(): Int {
+        return locker.withReadAcquire {
+            1 + (leftNode ?.size() ?: 0) + (rightNode ?.size() ?: 0)
+        }
+    }
+
+    /**
+     * This [Iterator] will run from less to greater values of nodes starting the
+     * [dev.inmo.micro_utils.coroutines.collections.SortedMapLikeBinaryTreeNode]-receiver. Due to non-suspending
+     * nature of [iterator] builder, this [Iterator] **DO NOT** guarantee consistent content due to iterations. It
+     * means, that tree can be changed during to iteration process
+     */
+    override fun iterator(): Iterator<SortedMapLikeBinaryTreeNode<K, V>> = iterator {
+        leftNode ?.let {
+            it.iterator().forEach { yield(it) }
+        }
+        yield(this@SortedMapLikeBinaryTreeNode)
+        rightNode ?.let {
+            it.iterator().forEach { yield(it) }
+        }
+    }
+
+    override fun toString(): String {
+        return "$key($leftNode;$rightNode)"
+    }
+
+    companion object {
+        operator fun <K : Comparable<K>, V> invoke(
+            key: K,
+            value: V
+        ) = SortedMapLikeBinaryTreeNode(
+            key,
+            value,
+            key.createComparator()
+        )
+    }
+}
+
+/**
+ * Will add subnode in tree if there are no any node with [newData]
+ *
+ * * If [newData] is greater than [SortedMapLikeBinaryTreeNode.key] of currently checking node,
+ * will be used [SortedMapLikeBinaryTreeNode.rightNode]
+ * * If [newData] is equal to [SortedMapLikeBinaryTreeNode.key] of currently
+ * checking node - will be returned currently checking node
+ * * If [newData] is less than [SortedMapLikeBinaryTreeNode.key] of currently
+ * checking node - will be used [SortedMapLikeBinaryTreeNode.leftNode]
+ *
+ * This process will continue until function will not find place to put [SortedMapLikeBinaryTreeNode] with data or
+ * [SortedMapLikeBinaryTreeNode] with [SortedMapLikeBinaryTreeNode.key] same as [newData] will be found
+ *
+ * @param replaceMode Will replace only value if node already exists
+ */
+private suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.upsertSubNode(
+    subNode: SortedMapLikeBinaryTreeNode<K, V>,
+    skipLockers: Set<SmartRWLocker> = emptySet(),
+    replaceMode: Boolean
+): SortedMapLikeBinaryTreeNode<K, V> {
+    var currentlyChecking = this
+    var latestParent: SortedMapLikeBinaryTreeNode<K, V>? = null
+    val lockedLockers = mutableSetOf<SmartRWLocker>()
+    try {
+        while (coroutineContext.job.isActive) {
+            if (currentlyChecking.locker !in lockedLockers && currentlyChecking.locker !in skipLockers) {
+                currentlyChecking.locker.lockWrite()
+                lockedLockers.add(currentlyChecking.locker)
+            }
+            val left = currentlyChecking.leftNode
+            val right = currentlyChecking.rightNode
+            val comparingResult = currentlyChecking.comparator.compare(subNode.key, currentlyChecking.key)
+            val isGreater = comparingResult > 0
+            when {
+                comparingResult == 0 -> {
+                    val resultNode = if (replaceMode) {
+                        subNode
+                    } else {
+                        val newNode = SortedMapLikeBinaryTreeNode(
+                            subNode.key,
+                            subNode.value,
+                            currentlyChecking.comparator,
+                        )
+                        newNode.leftNode = currentlyChecking.leftNode
+                        newNode.rightNode = currentlyChecking.rightNode
+                        newNode
+                    }
+
+                    latestParent ?.let {
+                        when {
+                            it.leftNode === currentlyChecking -> it.leftNode = resultNode
+                            it.rightNode === currentlyChecking -> it.rightNode = resultNode
+                        }
+                    }
+
+                    return resultNode
+                }
+                isGreater && right == null -> {
+                    currentlyChecking.rightNode = subNode
+                    return subNode
+                }
+                isGreater && right != null -> {
+                    latestParent = currentlyChecking
+                    currentlyChecking = right
+                }
+                left == null -> {
+                    currentlyChecking.leftNode = subNode
+                    return subNode
+                }
+                else -> {
+                    latestParent = currentlyChecking
+                    currentlyChecking = left
+                }
+            }
+        }
+    } finally {
+        lockedLockers.forEach {
+            runCatching { it.unlockWrite() }
+        }
+    }
+    error("Unable to add node")
+}
+
+/**
+ * Will add subnode in tree if there are no any node with [key]
+ *
+ * * If [key] is greater than [SortedMapLikeBinaryTreeNode.key] of currently checking node,
+ * will be used [SortedMapLikeBinaryTreeNode.rightNode]
+ * * If [key] is equal to [SortedMapLikeBinaryTreeNode.key] of currently
+ * checking node - will be returned currently checking node
+ * * If [key] is less than [SortedMapLikeBinaryTreeNode.key] of currently
+ * checking node - will be used [SortedMapLikeBinaryTreeNode.leftNode]
+ *
+ * This process will continue until function will not find place to put [SortedMapLikeBinaryTreeNode] with data or
+ * [SortedMapLikeBinaryTreeNode] with [SortedMapLikeBinaryTreeNode.key] same as [key] will be found
+ */
+suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.upsertSubNode(
+    key: K,
+    value: V
+): SortedMapLikeBinaryTreeNode<K, V> {
+    return upsertSubNode(
+        SortedMapLikeBinaryTreeNode(key, value, comparator),
+        replaceMode = false
+    )
+}
+
+suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.findParentNode(data: K): SortedMapLikeBinaryTreeNode<K, V>? {
+    var currentParent: SortedMapLikeBinaryTreeNode<K, V>? = null
+    var currentlyChecking: SortedMapLikeBinaryTreeNode<K, V>? = this
+    val lockedLockers = mutableSetOf<SmartRWLocker>()
+    try {
+        while (coroutineContext.job.isActive) {
+            if (currentlyChecking == null) {
+                return null
+            }
+            if (currentlyChecking.locker !in lockedLockers) {
+                currentlyChecking.locker.acquireRead()
+                lockedLockers.add(currentlyChecking.locker)
+            }
+            val comparingResult = currentlyChecking.comparator.compare(data, currentlyChecking.key)
+            when {
+                comparingResult > 0 -> {
+                    currentParent = currentlyChecking
+                    currentlyChecking = currentlyChecking.rightNode
+                    continue
+                }
+                comparingResult < 0 -> {
+                    currentParent = currentlyChecking
+                    currentlyChecking = currentlyChecking.leftNode
+                    continue
+                }
+                else -> return currentParent
+            }
+        }
+    } finally {
+        lockedLockers.forEach {
+            runCatching { it.releaseRead() }
+        }
+    }
+    error("Unable to find node")
+}
+
+/**
+ * Will remove (detach) node from tree starting with [this] [SortedMapLikeBinaryTreeNode]
+ *
+ * @return If data were found, [Pair] where [Pair.first] is the parent node where from [Pair.second] has been detached;
+ *         null otherwise
+ */
+suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.removeSubNode(data: K): Pair<SortedMapLikeBinaryTreeNode<K, V>, SortedMapLikeBinaryTreeNode<K, V>>? {
+    val onFoundToRemoveCallback: suspend SortedMapLikeBinaryTreeNode<K, V>.(left: SortedMapLikeBinaryTreeNode<K, V>?, right: SortedMapLikeBinaryTreeNode<K, V>?) -> Unit = { left, right ->
+        left ?.also { leftNode -> upsertSubNode(leftNode, setOf(locker), replaceMode = true) }
+        right ?.also { rightNode -> upsertSubNode(rightNode, setOf(locker), replaceMode = true) }
+    }
+    while (coroutineContext.job.isActive) {
+        val foundParentNode = findParentNode(data) ?: return null
+        foundParentNode.locker.withWriteLock {
+            val left = foundParentNode.leftNode
+            val right = foundParentNode.rightNode
+            when {
+                left != null && left.comparator.compare(data, left.key) == 0 -> {
+                    foundParentNode.leftNode = null
+                    foundParentNode.onFoundToRemoveCallback(left.leftNode, left.rightNode)
+                    return foundParentNode to left
+                }
+                right != null && right.comparator.compare(data, right.key) == 0 -> {
+                    foundParentNode.rightNode = null
+                    foundParentNode.onFoundToRemoveCallback(right.leftNode, right.rightNode)
+                    return foundParentNode to right
+                }
+                else -> {
+                    return@withWriteLock // data has been changed, new search required
+                }
+            }
+        }
+    }
+    error("Unable to remove node")
+}
+suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.findNode(key: K): SortedMapLikeBinaryTreeNode<K, V>? {
+    var currentlyChecking: SortedMapLikeBinaryTreeNode<K, V>? = this
+    val lockedLockers = mutableSetOf<SmartRWLocker>()
+    try {
+        while (coroutineContext.job.isActive) {
+            if (currentlyChecking == null) {
+                return null
+            }
+            if (currentlyChecking.locker !in lockedLockers) {
+                currentlyChecking.locker.acquireRead()
+                lockedLockers.add(currentlyChecking.locker)
+            }
+            val comparingResult = currentlyChecking.comparator.compare(key, currentlyChecking.key)
+            when {
+                comparingResult > 0 -> {
+                    currentlyChecking = currentlyChecking.rightNode
+                    continue
+                }
+                comparingResult < 0 -> {
+                    currentlyChecking = currentlyChecking.leftNode
+                    continue
+                }
+                else -> return currentlyChecking
+            }
+        }
+    } finally {
+        lockedLockers.forEach {
+            runCatching { it.releaseRead() }
+        }
+    }
+    error("Unable to find node")
+}
+suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.contains(data: K): Boolean = findNode(data) != null
+
+suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.findNodesInRange(from: K, to: K, fromInclusiveMode: Boolean, toInclusiveMode: Boolean): Set<SortedMapLikeBinaryTreeNode<K, V>> {
+    val results = mutableSetOf<SortedMapLikeBinaryTreeNode<K, V>>()
+    val leftToCheck = mutableSetOf(this)
+    val lockedLockers = mutableSetOf<SmartRWLocker>()
+    val fromComparingFun: (SortedMapLikeBinaryTreeNode<K, V>) -> Boolean = if (fromInclusiveMode) {
+        { it.comparator.compare(from, it.key) <= 0 }
+    } else {
+        { it.comparator.compare(from, it.key) < 0 }
+    }
+    val toComparingFun: (SortedMapLikeBinaryTreeNode<K, V>) -> Boolean = if (toInclusiveMode) {
+        { it.comparator.compare(to, it.key) >= 0 }
+    } else {
+        { it.comparator.compare(to, it.key) > 0 }
+    }
+    try {
+        while (coroutineContext.job.isActive && leftToCheck.isNotEmpty()) {
+            val currentlyChecking = leftToCheck.first()
+            leftToCheck.remove(currentlyChecking)
+            if (currentlyChecking in results) {
+                continue
+            }
+            currentlyChecking.locker.acquireRead()
+            lockedLockers.add(currentlyChecking.locker)
+            if (fromComparingFun(currentlyChecking) && toComparingFun(currentlyChecking)) {
+                results.add(currentlyChecking)
+                currentlyChecking.leftNode ?.let { leftToCheck.add(it) }
+                currentlyChecking.rightNode ?.let { leftToCheck.add(it) }
+                continue
+            }
+            when {
+                currentlyChecking.comparator.compare(to, currentlyChecking.key) < 0 -> currentlyChecking.leftNode ?.let { leftToCheck.add(it) }
+                currentlyChecking.comparator.compare(from, currentlyChecking.key) > 0 -> currentlyChecking.rightNode ?.let { leftToCheck.add(it) }
+            }
+        }
+        return results.toSet()
+    } finally {
+        lockedLockers.forEach {
+            runCatching { it.releaseRead() }
+        }
+    }
+    error("Unable to find nodes range")
+}
+suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.deepEquals(other: SortedMapLikeBinaryTreeNode<K, V>): Boolean {
+    val leftToCheck = mutableSetOf(this)
+    val othersToCheck = mutableSetOf(other)
+    val lockedLockers = mutableSetOf<SmartRWLocker>()
+    try {
+        while (leftToCheck.isNotEmpty() && othersToCheck.isNotEmpty()) {
+            val thisToCheck = leftToCheck.first()
+            leftToCheck.remove(thisToCheck)
+
+            val otherToCheck = othersToCheck.first()
+            othersToCheck.remove(otherToCheck)
+
+            if (thisToCheck.locker !in lockedLockers) {
+                thisToCheck.locker.acquireRead()
+                lockedLockers.add(thisToCheck.locker)
+            }
+            if (otherToCheck.locker !in lockedLockers) {
+                otherToCheck.locker.acquireRead()
+                lockedLockers.add(otherToCheck.locker)
+            }
+
+            if (thisToCheck.key != otherToCheck.key || thisToCheck.value != otherToCheck.value) {
+                return false
+            }
+
+            if ((thisToCheck.leftNode == null).xor(otherToCheck.leftNode == null)) {
+                return false
+            }
+            if ((thisToCheck.rightNode == null).xor(otherToCheck.rightNode == null)) {
+                return false
+            }
+
+            thisToCheck.leftNode?.let { leftToCheck.add(it) }
+            thisToCheck.rightNode?.let { leftToCheck.add(it) }
+
+            otherToCheck.leftNode?.let { othersToCheck.add(it) }
+            otherToCheck.rightNode?.let { othersToCheck.add(it) }
+        }
+    } finally {
+        lockedLockers.forEach {
+            runCatching { it.releaseRead() }
+        }
+    }
+
+    return leftToCheck.isEmpty() && othersToCheck.isEmpty()
+}
+suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.findNodesInRange(from: K, to: K): Set<SortedMapLikeBinaryTreeNode<K, V>> = findNodesInRange(
+    from = from,
+    to = to,
+    fromInclusiveMode = true,
+    toInclusiveMode = true
+)
+suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.findNodesInRangeExcluding(from: K, to: K): Set<SortedMapLikeBinaryTreeNode<K, V>> = findNodesInRange(
+    from = from,
+    to = to,
+    fromInclusiveMode = false,
+    toInclusiveMode = false
+)
+suspend fun <K : Comparable<K>, V> SortedMapLikeBinaryTreeNode<K, V>.findNodesInRange(range: ClosedRange<K>): Set<SortedMapLikeBinaryTreeNode<K, V>> = findNodesInRange(
+    from = range.start,
+    to = range.endInclusive,
+)

coroutines/src/commonTest/kotlin/RealTimeOut.kt

@@ -0,0 +1,12 @@
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+import kotlin.time.Duration
+
+suspend fun <T> realWithTimeout(time: Duration, block: suspend () -> T): T {
+    return withContext(Dispatchers.Default.limitedParallelism(1)) {
+        withTimeout(time) {
+            block()
+        }
+    }
+}

coroutines/src/commonTest/kotlin/SmartKeyRWLockerTests.kt

@@ -0,0 +1,196 @@
+import dev.inmo.micro_utils.coroutines.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFails
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
+
+class SmartKeyRWLockerTests {
+    @Test
+    fun writeLockKeyFailedOnGlobalWriteLockTest() = runTest {
+        val locker = SmartKeyRWLocker<String>()
+        val testKey = "test"
+        locker.lockWrite()
+
+        assertTrue { locker.isWriteLocked() }
+
+        assertFails {
+            realWithTimeout(1.seconds) {
+                locker.lockWrite(testKey)
+            }
+        }
+        assertFalse { locker.isWriteLocked(testKey) }
+
+        locker.unlockWrite()
+        assertFalse { locker.isWriteLocked() }
+
+        realWithTimeout(1.seconds) {
+            locker.lockWrite(testKey)
+        }
+        assertTrue { locker.isWriteLocked(testKey) }
+        assertTrue { locker.unlockWrite(testKey) }
+        assertFalse { locker.isWriteLocked(testKey) }
+    }
+    @Test
+    fun writeLockKeyFailedOnGlobalReadLockTest() = runTest {
+        val locker = SmartKeyRWLocker<String>()
+        val testKey = "test"
+        locker.acquireRead()
+
+        assertEquals(Int.MAX_VALUE - 1, locker.readSemaphore().freePermits)
+
+        assertFails {
+            realWithTimeout(1.seconds) {
+                locker.lockWrite(testKey)
+            }
+        }
+        assertFalse { locker.isWriteLocked(testKey) }
+
+        locker.releaseRead()
+        assertEquals(Int.MAX_VALUE, locker.readSemaphore().freePermits)
+
+        realWithTimeout(1.seconds) {
+            locker.lockWrite(testKey)
+        }
+        assertTrue { locker.isWriteLocked(testKey) }
+        assertTrue { locker.unlockWrite(testKey) }
+        assertFalse { locker.isWriteLocked(testKey) }
+    }
+    @Test
+    fun readLockFailedOnWriteLockKeyTest() = runTest {
+        val locker = SmartKeyRWLocker<String>()
+        val testKey = "test"
+        locker.lockWrite(testKey)
+
+        assertTrue { locker.isWriteLocked(testKey) }
+
+        assertFails {
+            realWithTimeout(1.seconds) {
+                locker.acquireRead()
+            }
+        }
+        assertEquals(locker.readSemaphore().maxPermits - 1, locker.readSemaphore().freePermits)
+
+        locker.unlockWrite(testKey)
+        assertFalse { locker.isWriteLocked(testKey) }
+
+        realWithTimeout(1.seconds) {
+            locker.acquireRead()
+        }
+        assertEquals(locker.readSemaphore().maxPermits - 1, locker.readSemaphore().freePermits)
+        assertTrue { locker.releaseRead() }
+        assertEquals(locker.readSemaphore().maxPermits, locker.readSemaphore().freePermits)
+    }
+    @Test
+    fun writeLockFailedOnWriteLockKeyTest() = runTest {
+        val locker = SmartKeyRWLocker<String>()
+        val testKey = "test"
+        locker.lockWrite(testKey)
+
+        assertTrue { locker.isWriteLocked(testKey) }
+
+        assertFails {
+            realWithTimeout(1.seconds) {
+                locker.lockWrite()
+            }
+        }
+        assertFalse(locker.isWriteLocked())
+
+        locker.unlockWrite(testKey)
+        assertFalse { locker.isWriteLocked(testKey) }
+
+        realWithTimeout(1.seconds) {
+            locker.lockWrite()
+        }
+        assertTrue(locker.isWriteLocked())
+        assertTrue { locker.unlockWrite() }
+        assertFalse(locker.isWriteLocked())
+    }
+    @Test
+    fun readsBlockingGlobalWrite() = runTest {
+        val locker = SmartKeyRWLocker<String>()
+
+        val testKeys = (0 until 100).map { "test$it" }
+
+        for (i in testKeys.indices) {
+            val it = testKeys[i]
+            locker.acquireRead(it)
+            val previous = testKeys.take(i)
+            val next = testKeys.drop(i + 1)
+
+            previous.forEach {
+                assertTrue { locker.readSemaphoreOrNull(it) ?.freePermits == Int.MAX_VALUE - 1 }
+            }
+            next.forEach {
+                assertTrue { locker.readSemaphoreOrNull(it) ?.freePermits == null }
+            }
+        }
+
+        for (i in testKeys.indices) {
+            val it = testKeys[i]
+            assertFails {
+                realWithTimeout(13.milliseconds) { locker.lockWrite() }
+            }
+            val readPermitsBeforeLock = locker.readSemaphore().freePermits
+            realWithTimeout(1.seconds) { locker.acquireRead() }
+            locker.releaseRead()
+            assertEquals(readPermitsBeforeLock, locker.readSemaphore().freePermits)
+
+            locker.releaseRead(it)
+        }
+
+        assertTrue { locker.readSemaphore().freePermits == Int.MAX_VALUE }
+        realWithTimeout(1.seconds) { locker.lockWrite() }
+        assertFails {
+            realWithTimeout(13.milliseconds) { locker.acquireRead() }
+        }
+        assertTrue { locker.unlockWrite() }
+        assertTrue { locker.readSemaphore().freePermits == Int.MAX_VALUE }
+    }
+    @Test
+    fun writesBlockingGlobalWrite() = runTest {
+        val locker = SmartKeyRWLocker<String>()
+
+        val testKeys = (0 until 100).map { "test$it" }
+
+        for (i in testKeys.indices) {
+            val it = testKeys[i]
+            locker.lockWrite(it)
+            val previous = testKeys.take(i)
+            val next = testKeys.drop(i + 1)
+
+            previous.forEach {
+                assertTrue { locker.writeMutexOrNull(it) ?.isLocked == true }
+            }
+            next.forEach {
+                assertTrue { locker.writeMutexOrNull(it) ?.isLocked != true }
+            }
+        }
+
+        for (i in testKeys.indices) {
+            val it = testKeys[i]
+            assertFails { realWithTimeout(13.milliseconds) { locker.lockWrite() } }
+
+            val readPermitsBeforeLock = locker.readSemaphore().freePermits
+            assertFails { realWithTimeout(13.milliseconds) { locker.acquireRead() } }
+            assertEquals(readPermitsBeforeLock, locker.readSemaphore().freePermits)
+
+            locker.unlockWrite(it)
+        }
+
+        assertTrue { locker.readSemaphore().freePermits == Int.MAX_VALUE }
+        realWithTimeout(1.seconds) { locker.lockWrite() }
+        assertFails {
+            realWithTimeout(13.milliseconds) { locker.acquireRead() }
+        }
+        assertTrue { locker.unlockWrite() }
+        assertTrue { locker.readSemaphore().freePermits == Int.MAX_VALUE }
+    }
+}

coroutines/src/commonTest/kotlin/SmartRWLockerTests.kt

@@ -6,7 +6,10 @@ import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.test.runTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFails
+import kotlin.test.assertFalse
 import kotlin.test.assertTrue
+import kotlin.time.Duration.Companion.seconds
 
 class SmartRWLockerTests {
     @Test
@@ -148,4 +151,17 @@ class SmartRWLockerTests {
             assertEquals(false, locker.writeMutex.isLocked)
         }
     }
+
+    @Test
+    fun exceptionOnLockingWillNotLockLocker() = runTest {
+        val locker = SmartRWLocker()
+
+        locker.acquireRead()
+        assertFails {
+            realWithTimeout(1.seconds) {
+                locker.lockWrite()
+            }
+        }
+        assertFalse { locker.writeMutex.isLocked }
+    }
 }

coroutines/src/jvmMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchSynchronously.kt

@@ -7,7 +7,9 @@ fun <T> CoroutineScope.launchSynchronously(block: suspend CoroutineScope.() -> T
     val objectToSynchronize = Object()
     synchronized(objectToSynchronize) {
         launch(start = CoroutineStart.UNDISPATCHED) {
-            result = safelyWithResult(block)
+            result = runCatching {
+                block()
+            }
         }.invokeOnCompletion {
             synchronized(objectToSynchronize) {
                 objectToSynchronize.notifyAll()

coroutines/src/jvmTest/kotlin/dev/inmo/micro_utils/coroutines/HandleSafelyCoroutineContextTest.kt

@@ -1,25 +1,20 @@
 package dev.inmo.micro_utils.coroutines
 
 import kotlinx.coroutines.*
+import kotlinx.coroutines.test.runTest
 import kotlin.test.Test
 
 class HandleSafelyCoroutineContextTest {
     @Test
-    fun testHandleSafelyCoroutineContext() {
+    fun testHandleSafelyCoroutineContext() = runTest {
-        val scope = CoroutineScope(Dispatchers.Default)
+        val scope = this
         var contextHandlerHappen = false
         var localHandlerHappen = false
-        var defaultHandlerHappen = false
-        defaultSafelyExceptionHandler = {
-            defaultHandlerHappen = true
-            throw it
-        }
-        val contextHandler: ExceptionHandler<Unit> = {
-            contextHandlerHappen = true
-        }
         val checkJob = scope.launch {
-            safelyWithContextExceptionHandler(contextHandler) {
+            runCatchingLogging ({
-                safely(
+                contextHandlerHappen = true
+            }) {
+                runCatchingLogging (
                     {
                         localHandlerHappen = true
                     }
@@ -29,10 +24,8 @@ class HandleSafelyCoroutineContextTest {
                 println(coroutineContext)
                 error("That must happen too:)")
             }
-        }
+        }.join()
-        launchSynchronously { checkJob.join() }
         assert(contextHandlerHappen)
         assert(localHandlerHappen)
-        assert(defaultHandlerHappen)
     }
 }

coroutines/src/jvmTest/kotlin/dev/inmo/micro_utils/coroutines/SortedBinaryTreeNodeTests.kt

@@ -0,0 +1,176 @@
+package dev.inmo.micro_utils.coroutines
+
+import dev.inmo.micro_utils.coroutines.collections.SortedBinaryTreeNode
+import dev.inmo.micro_utils.coroutines.collections.addSubNode
+import dev.inmo.micro_utils.coroutines.collections.findNode
+import dev.inmo.micro_utils.coroutines.collections.findNodesInRange
+import dev.inmo.micro_utils.coroutines.collections.findParentNode
+import dev.inmo.micro_utils.coroutines.collections.removeSubNode
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.time.Duration.Companion.seconds
+
+class SortedBinaryTreeNodeTests {
+    @Test
+    fun insertOnZeroLevelWorks() = runTest {
+        val zeroNode = SortedBinaryTreeNode(0)
+        zeroNode.addSubNode(1)
+        zeroNode.addSubNode(-1)
+
+        assertEquals(0, zeroNode.data)
+        assertEquals(1, zeroNode.getRightNode() ?.data)
+        assertEquals(-1, zeroNode.getLeftNode() ?.data)
+    }
+    @Test
+    fun searchOnZeroLevelWorks() = runTest {
+        val zeroNode = SortedBinaryTreeNode(0)
+        val oneNode = zeroNode.addSubNode(1)
+        val minusOneNode = zeroNode.addSubNode(-1)
+
+        val assertingNodesToSearchQuery = mapOf(
+            setOf(oneNode) to (1 .. 1),
+            setOf(zeroNode, oneNode) to (0 .. 1),
+            setOf(minusOneNode, zeroNode, oneNode) to (-1 .. 1),
+            setOf(minusOneNode, zeroNode) to (-1 .. 0),
+            setOf(minusOneNode) to (-1 .. -1),
+            setOf(zeroNode) to (0 .. 0),
+        )
+
+        assertingNodesToSearchQuery.forEach {
+            val foundData = zeroNode.findNodesInRange(it.value)
+            assertTrue(foundData.containsAll(it.key))
+            assertTrue(it.key.containsAll(foundData))
+        }
+    }
+    @Test
+    fun deepReInsertOnWorks() = runTest(timeout = 300.seconds) {
+        val zeroNode = SortedBinaryTreeNode(0)
+        val rangeRadius = 500
+        val nodes = mutableMapOf<Int, SortedBinaryTreeNode<Int>>()
+        for (i in -rangeRadius .. rangeRadius) {
+            nodes[i] = zeroNode.addSubNode(i)
+        }
+
+        for (i in -rangeRadius .. rangeRadius) {
+            val expectedNode = nodes.getValue(i)
+            val foundNode = zeroNode.findNode(i)
+
+            assertTrue(expectedNode === foundNode)
+
+            if (expectedNode === zeroNode) continue
+
+            val parentNode = zeroNode.findParentNode(i)
+            assertTrue(
+                parentNode ?.getLeftNode() === expectedNode || parentNode ?.getRightNode() === expectedNode,
+                "It is expected, that parent node with data ${parentNode ?.data} will be parent of ${expectedNode.data}, but its left subnode is ${parentNode ?.getLeftNode() ?.data} and right one is ${parentNode ?.getRightNode() ?.data}"
+            )
+        }
+
+        val sourceTreeSize = zeroNode.size()
+        assertTrue(sourceTreeSize == nodes.size)
+        assertTrue(sourceTreeSize == (rangeRadius * 2 + 1))
+
+        for (i in -rangeRadius .. rangeRadius) {
+            val expectedNode = nodes.getValue(i)
+            val parentNode = zeroNode.findParentNode(i)
+
+            if (parentNode == null && i == zeroNode.data && expectedNode === zeroNode) continue
+
+            assertTrue(parentNode != null, "It is expected, that parent node of ${expectedNode.data} will not be null")
+
+            assertTrue(
+                parentNode.getLeftNode() === expectedNode || parentNode.getRightNode() === expectedNode,
+                "It is expected, that parent node with data ${parentNode ?.data} will be parent of ${expectedNode.data}, but its left subnode is ${parentNode ?.getLeftNode() ?.data} and right one is ${parentNode ?.getRightNode() ?.data}"
+            )
+
+            val removeResult = zeroNode.removeSubNode(i)
+            assertTrue(removeResult ?.first === parentNode)
+            assertTrue(removeResult.second === expectedNode)
+
+            nodes[i] = zeroNode.addSubNode(i)
+            assertTrue(nodes[i] != null)
+            assertTrue(nodes[i] != expectedNode)
+            assertTrue(nodes[i] ?.data == i)
+        }
+
+        assertTrue(sourceTreeSize == zeroNode.size())
+
+        for (i in -rangeRadius .. rangeRadius) {
+            val expectedNode = nodes.getValue(i)
+            val foundNode = zeroNode.findNode(i)
+
+            assertTrue(expectedNode === foundNode)
+
+            if (expectedNode === zeroNode) continue
+
+            val parentNode = zeroNode.findParentNode(i)
+            assertTrue(
+                parentNode ?.getLeftNode() === expectedNode || parentNode ?.getRightNode() === expectedNode,
+                "It is expected, that parent node with data ${parentNode ?.data} will be parent of ${expectedNode.data}, but its left subnode is ${parentNode ?.getLeftNode() ?.data} and right one is ${parentNode ?.getRightNode() ?.data}"
+            )
+        }
+
+        var previousData = -rangeRadius - 1
+        for (node in zeroNode) {
+            assertTrue(nodes[node.data] === node)
+            assertTrue(previousData == node.data - 1)
+            previousData = node.data
+        }
+
+        assertTrue(sourceTreeSize == zeroNode.size())
+    }
+    @Test
+    fun deepInsertOnWorks() = runTest(timeout = 240.seconds) {
+        val zeroNode = SortedBinaryTreeNode(0)
+        val rangeRadius = 500
+        val nodes = mutableMapOf<Int, SortedBinaryTreeNode<Int>>()
+        for (i in -rangeRadius .. rangeRadius) {
+            nodes[i] = zeroNode.addSubNode(i)
+        }
+
+        for (i in -rangeRadius .. rangeRadius) {
+            val expectedNode = nodes.getValue(i)
+            val foundNode = zeroNode.findNode(i)
+
+            assertTrue(expectedNode === foundNode)
+
+            if (expectedNode === zeroNode) continue
+
+            val parentNode = zeroNode.findParentNode(i)
+            assertTrue(
+                parentNode ?.getLeftNode() === expectedNode || parentNode ?.getRightNode() === expectedNode,
+                "It is expected, that parent node with data ${parentNode ?.data} will be parent of ${expectedNode.data}, but its left subnode is ${parentNode ?.getLeftNode() ?.data} and right one is ${parentNode ?.getRightNode() ?.data}"
+            )
+        }
+
+        val sourceTreeSize = zeroNode.size()
+
+        var previousData = -rangeRadius - 1
+        for (node in zeroNode) {
+            assertTrue(nodes[node.data] === node)
+            assertTrue(previousData == node.data - 1)
+            previousData = node.data
+        }
+
+        assertTrue(sourceTreeSize == zeroNode.size())
+    }
+    @Test
+    fun deepInsertIteratorWorking() = runTest {
+        val zeroNode = SortedBinaryTreeNode(0)
+        val rangeRadius = 500
+        val nodes = mutableMapOf<Int, SortedBinaryTreeNode<Int>>()
+        for (i in -rangeRadius .. rangeRadius) {
+            nodes[i] = zeroNode.addSubNode(i)
+        }
+
+        var previousData = -rangeRadius - 1
+        for (node in zeroNode) {
+            assertTrue(nodes[node.data] === node)
+            assertTrue(previousData == node.data - 1)
+            previousData = node.data
+        }
+        assertTrue(previousData == rangeRadius)
+    }
+}

coroutines/src/jvmTest/kotlin/dev/inmo/micro_utils/coroutines/SortedMapLikeBinaryTreeNodeTests.kt

@@ -0,0 +1,118 @@
+package dev.inmo.micro_utils.coroutines
+
+import dev.inmo.micro_utils.coroutines.collections.*
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.time.Duration.Companion.seconds
+
+class SortedMapLikeBinaryTreeNodeTests {
+    @Test
+    fun insertOnZeroLevelWorks() = runTest {
+        val zeroNode = SortedMapLikeBinaryTreeNode(0, 0)
+        zeroNode.upsertSubNode(1, 1)
+        zeroNode.upsertSubNode(-1, -1)
+
+        assertEquals(0, zeroNode.key)
+        assertEquals(1, zeroNode.getRightNode() ?.key)
+        assertEquals(-1, zeroNode.getLeftNode() ?.key)
+
+        assertEquals(0, zeroNode.findNode(0) ?.value)
+        assertEquals(1, zeroNode.findNode(1) ?.value)
+        assertEquals(-1, zeroNode.findNode(-1) ?.value)
+    }
+    @Test
+    fun searchOnZeroLevelWorks() = runTest {
+        val zeroNode = SortedMapLikeBinaryTreeNode(0, 0)
+        val oneNode = zeroNode.upsertSubNode(1, 1)
+        val minusOneNode = zeroNode.upsertSubNode(-1, -1)
+
+        val assertingNodesToSearchQuery = mapOf(
+            setOf(oneNode) to (1 .. 1),
+            setOf(zeroNode, oneNode) to (0 .. 1),
+            setOf(minusOneNode, zeroNode, oneNode) to (-1 .. 1),
+            setOf(minusOneNode, zeroNode) to (-1 .. 0),
+            setOf(minusOneNode) to (-1 .. -1),
+            setOf(zeroNode) to (0 .. 0),
+        )
+
+        assertingNodesToSearchQuery.forEach {
+            val foundData = zeroNode.findNodesInRange(it.value)
+            assertTrue(foundData.containsAll(it.key))
+            assertTrue(it.key.containsAll(foundData))
+        }
+    }
+    @Test
+    fun deepReInsertOnWorks() = runTest(timeout = 300.seconds) {
+        var zeroNode = SortedMapLikeBinaryTreeNode(0, 0)
+        val rangeRadius = 500
+        val nodes = mutableMapOf<Int, SortedMapLikeBinaryTreeNode<Int, Int>>()
+        for (i in -rangeRadius .. rangeRadius) {
+            nodes[i] = zeroNode.upsertSubNode(i, i)
+            if (i == zeroNode.key) {
+                zeroNode = nodes.getValue(i)
+            }
+        }
+
+        for (i in -rangeRadius .. rangeRadius) {
+            val expectedNode = nodes.getValue(i)
+            val foundNode = zeroNode.findNode(i)
+
+            assertEquals(expectedNode, foundNode)
+
+            if (expectedNode === zeroNode) continue
+
+            val parentNode = zeroNode.findParentNode(i)
+            assertTrue(
+                parentNode ?.getLeftNode() === expectedNode || parentNode ?.getRightNode() === expectedNode,
+                "It is expected, that parent node with data ${parentNode ?.key} will be parent of ${expectedNode.key}, but its left subnode is ${parentNode ?.getLeftNode() ?.key} and right one is ${parentNode ?.getRightNode() ?.key}"
+            )
+            assertTrue(
+                foundNode != null && expectedNode.deepEquals(foundNode)
+            )
+
+            zeroNode.upsertSubNode(i, -i)
+            val foundModifiedNode = zeroNode.findNode(i)
+            assertEquals(foundNode ?.value, foundModifiedNode ?.value ?.times(-1))
+        }
+    }
+    @Test
+    fun deepInsertOnWorks() = runTest(timeout = 240.seconds) {
+        val zeroNode = SortedMapLikeBinaryTreeNode(0, 0)
+        val rangeRadius = 500
+        val nodes = mutableMapOf<Int, SortedMapLikeBinaryTreeNode<Int, Int>>()
+        for (i in -rangeRadius .. rangeRadius) {
+            if (zeroNode.key != i) {
+                nodes[i] = zeroNode.upsertSubNode(i, i)
+            }
+        }
+        nodes[zeroNode.key] = zeroNode
+
+        for (i in -rangeRadius .. rangeRadius) {
+            val expectedNode = nodes.getValue(i)
+            val foundNode = zeroNode.findNode(i)
+
+            assertTrue(expectedNode === foundNode)
+
+            if (expectedNode === zeroNode) continue
+
+            val parentNode = zeroNode.findParentNode(i)
+            assertTrue(
+                parentNode ?.getLeftNode() === expectedNode || parentNode ?.getRightNode() === expectedNode,
+                "It is expected, that parent node with data ${parentNode ?.key} will be parent of ${expectedNode.key}, but its left subnode is ${parentNode ?.getLeftNode() ?.key} and right one is ${parentNode ?.getRightNode() ?.key}"
+            )
+        }
+
+        val sourceTreeSize = zeroNode.size()
+
+        var previousData = -rangeRadius - 1
+        for (node in zeroNode) {
+            assertTrue(nodes[node.key] === node)
+            assertTrue(previousData == node.key - 1)
+            previousData = node.key
+        }
+
+        assertTrue(sourceTreeSize == zeroNode.size())
+    }
+}

gradle.properties

@@ -15,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.24.6
+version=0.25.4
-android_code_version=286
+android_code_version=294

gradle/libs.versions.toml

@@ -1,29 +1,29 @@
 [versions]
 
-kt = "2.1.10"
+kt = "2.1.20"
 kt-serialization = "1.8.0"
 kt-coroutines = "1.10.1"
 
 kslog = "1.4.1"
 
 jb-compose = "1.7.3"
-jb-exposed = "0.59.0"
+jb-exposed = "0.60.0"
 jb-dokka = "2.0.0"
 
-sqlite = "3.49.0.0"
+sqlite = "3.49.1.0"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
 
-ktor = "3.1.0"
+ktor = "3.1.2"
 
 gh-release = "2.5.2"
 
-koin = "4.0.2"
+koin = "4.0.4"
 
 okio = "3.10.2"
 
-ksp = "2.1.10-1.0.29"
+ksp = "2.1.20-1.0.31"
 kotlin-poet = "1.18.1"
 
 versions = "0.51.0"

gradle/templates/mppComposeJvmJsAndroidLinuxMingwLinuxArm64Project.gradle

@@ -15,14 +15,14 @@ kotlin {
         browser {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }
         nodejs {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }

gradle/templates/mppJvmJsAndroidLinuxMingwLinuxArm64Project.gradle

@@ -15,14 +15,14 @@ kotlin {
         browser {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }
         nodejs {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }

gradle/templates/mppJvmJsLinuxMingwProject.gradle

@@ -15,14 +15,14 @@ kotlin {
         browser {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }
         nodejs {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }

gradle/templates/mppProjectWithSerializationAndCompose.gradle

@@ -15,14 +15,14 @@ kotlin {
         browser {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }
         nodejs {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }

koin/build.gradle

@@ -17,11 +17,13 @@ kotlin {
         jvmMain {
             dependencies {
                 api libs.kt.reflect
+                api project(":micro_utils.coroutines")
             }
         }
         androidMain {
             dependencies {
                 api libs.kt.reflect
+                api project(":micro_utils.coroutines")
             }
         }
     }

koin/src/jvmMain/kotlin/FactorySuspend.kt

@@ -0,0 +1,32 @@
+package dev.inmo.micro_utils.koin
+
+import dev.inmo.micro_utils.coroutines.doSynchronously
+import kotlinx.coroutines.CoroutineScope
+import org.koin.core.module.Module
+import org.koin.core.parameter.ParametersHolder
+import org.koin.core.qualifier.Qualifier
+import org.koin.core.qualifier.StringQualifier
+import org.koin.core.scope.Scope
+import kotlin.reflect.KClass
+
+inline fun <reified T : Any> Module.factorySuspend(
+    qualifier: Qualifier? = null,
+    coroutineScope: CoroutineScope? = null,
+    noinline definition: suspend Scope.(ParametersHolder) -> T
+) = factory(
+    qualifier,
+    if (coroutineScope == null) {
+        {
+            doSynchronously {
+                definition(it)
+            }
+        }
+    } else {
+        {
+            coroutineScope.doSynchronously {
+                definition(it)
+            }
+        }
+    }
+)
+

koin/src/jvmMain/kotlin/SingleSuspend.kt

@@ -0,0 +1,32 @@
+package dev.inmo.micro_utils.koin
+
+import dev.inmo.micro_utils.coroutines.doSynchronously
+import kotlinx.coroutines.CoroutineScope
+import org.koin.core.module.Module
+import org.koin.core.parameter.ParametersHolder
+import org.koin.core.qualifier.StringQualifier
+import org.koin.core.scope.Scope
+
+inline fun <reified T : Any> Module.singleSuspend(
+    qualifier: StringQualifier,
+    createdAtStart: Boolean = false,
+    coroutineScope: CoroutineScope? = null,
+    noinline definition: suspend Scope.(ParametersHolder) -> T
+) = single(
+    qualifier,
+    createdAtStart,
+    if (coroutineScope == null) {
+        {
+            doSynchronously {
+                definition(it)
+            }
+        }
+    } else {
+        {
+            coroutineScope.doSynchronously {
+                definition(it)
+            }
+        }
+    }
+)
+

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/Pagination.kt

@@ -40,6 +40,8 @@ fun Pagination.intersect(
 inline val Pagination.isFirstPage
     get() = page == 0
 
+fun Pagination.firstPage() = if (isFirstPage) this else SimplePagination(0, size)
+
 /**
  * First number in index of objects. It can be used as offset for databases or other data sources
  */

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/PaginationResult.kt

@@ -32,7 +32,7 @@ data class PaginationResult<T>(
         page: Int,
         results: List<T>,
         pagesNumber: Int,
-        size: Int
+        size: Int = results.size
     ) : this(
         page,
         size,

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/SimplePagination.kt

@@ -26,6 +26,16 @@ inline fun Pagination.nextPage() =
         size
     )
 
+/**
+ * This method DO NOT check [Pagination.page] of receiver. Returns pagination for previous page
+ */
+@Suppress("NOTHING_TO_INLINE")
+inline fun Pagination.previousPage() =
+    SimplePagination(
+        page - 1,
+        size
+    )
+
 /**
  * @param page Current page number
  * @param size Current page size

pagination/compose/build.gradle

@@ -0,0 +1,21 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+    alias(libs.plugins.jb.compose)
+    alias(libs.plugins.kt.jb.compose)
+}
+
+apply from: "$mppComposeJvmJsAndroidLinuxMingwLinuxArm64Project"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api project(":micro_utils.pagination.common")
+                api project(":micro_utils.common.compose")
+                api project(":micro_utils.coroutines")
+            }
+        }
+    }
+}

pagination/compose/src/commonMain/kotlin/InfinityPagedComponent.kt

@@ -0,0 +1,138 @@
+package dev.inmo.micro_utils.pagination.compose
+
+import androidx.compose.runtime.*
+import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.runCatchingLogging
+import dev.inmo.micro_utils.pagination.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * Context for managing infinite pagination in a Compose UI.
+ *
+ * @param T The type of the data being paginated.
+ * @property iterationState Holds the current pagination state and iteration count.
+ * @property dataState Stores the loaded data, initially null.
+ * @constructor Internal constructor to initialize pagination.
+ * @param page Initial page number.
+ * @param size Number of items per page.
+ */
+class InfinityPagedComponentContext<T> internal constructor(
+    page: Int,
+    size: Int,
+    private val scope: CoroutineScope,
+    private val loader: suspend InfinityPagedComponentContext<T>.(Pagination) -> PaginationResult<T>
+) {
+    internal val startPage = SimplePagination(page, size)
+    internal val latestLoadedPage = SpecialMutableStateFlow<PaginationResult<T>?>(null)
+    internal val dataState = SpecialMutableStateFlow<List<T>?>(null)
+    internal var loadingJob: Job? = null
+    internal val loadingMutex = Mutex()
+
+    /**
+     * Loads the next page of data. If the current page is the last one, the function returns early.
+     */
+    fun loadNext(): Job {
+        return scope.launchLoggingDropExceptions {
+            loadingMutex.withLock {
+                if (latestLoadedPage.value ?.isLastPage == true) return@launchLoggingDropExceptions
+                loadingJob = loadingJob ?: scope.launchLoggingDropExceptions {
+                    runCatching {
+                        loader(latestLoadedPage.value ?.nextPage() ?: startPage)
+                    }.onSuccess {
+                        latestLoadedPage.value = it
+                        dataState.value = (dataState.value ?: emptyList()) + it.results
+                    }
+                    loadingMutex.withLock {
+                        loadingJob = null
+                    }
+                }
+                loadingJob
+            } ?.join()
+        }
+    }
+
+    /**
+     * Reloads the pagination from the first page, clearing previously loaded data.
+     */
+    fun reload(): Job {
+        latestLoadedPage.value = null
+        dataState.value = null
+        return loadNext()
+    }
+}
+
+/**
+ * Composable function for managing an infinitely paged component.
+ *
+ * @param T The type of the paginated data.
+ * @param page Initial page number.
+ * @param size Number of items per page.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data. When data is in loading state, block will
+ * receive null as `it` parameter
+ */
+@Composable
+internal fun <T> InfinityPagedComponent(
+    page: Int,
+    size: Int,
+    loader: suspend InfinityPagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    predefinedScope: CoroutineScope? = null,
+    block: @Composable InfinityPagedComponentContext<T>.(List<T>?) -> Unit
+) {
+    val scope = predefinedScope ?: rememberCoroutineScope()
+    val context = remember { InfinityPagedComponentContext<T>(page, size, scope, loader) }
+    remember {
+        context.reload()
+    }
+
+    val dataState = context.dataState.collectAsState()
+    context.block(dataState.value)
+}
+
+/**
+ * Overloaded composable function for an infinitely paged component.
+ *
+ * @param T The type of the paginated data.
+ * @param pageInfo Initial pagination information.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data. When data is in loading state, block will
+ * receive null as `it` parameter
+ */
+@Composable
+fun <T> InfinityPagedComponent(
+    pageInfo: Pagination,
+    loader: suspend InfinityPagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    predefinedScope: CoroutineScope? = null,
+    block: @Composable InfinityPagedComponentContext<T>.(List<T>?) -> Unit
+) {
+    InfinityPagedComponent(
+        pageInfo.page,
+        pageInfo.size,
+        loader,
+        predefinedScope,
+        block
+    )
+}
+
+/**
+ * Overloaded composable function for an infinitely paged component.
+ *
+ * @param T The type of the paginated data.
+ * @param size Number of items per page.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data. When data is in loading state, block will
+ * receive null as `it` parameter
+ */
+@Composable
+fun <T> InfinityPagedComponent(
+    size: Int,
+    loader: suspend InfinityPagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    predefinedScope: CoroutineScope? = null,
+    block: @Composable InfinityPagedComponentContext<T>.(List<T>?) -> Unit
+) {
+    InfinityPagedComponent(0, size, loader, predefinedScope, block)
+}

pagination/compose/src/commonMain/kotlin/PagedComponent.kt

@@ -0,0 +1,166 @@
+package dev.inmo.micro_utils.pagination.compose
+
+import androidx.compose.runtime.*
+import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
+import dev.inmo.micro_utils.pagination.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * Context for managing paginated data in a Compose UI.
+ *
+ * @param T The type of data being paginated.
+ * @property iterationState Holds the current pagination state and iteration count.
+ * @property dataOptional Stores the optional preloaded pagination result.
+ * @property dataState Stores the current pagination result.
+ * @constructor Internal constructor for setting up pagination.
+ * @param preset Optional preset pagination result.
+ * @param initialPage Initial page number.
+ * @param size Number of items per page.
+ */
+class PagedComponentContext<T> internal constructor(
+    initialPage: Int,
+    size: Int,
+    private val scope: CoroutineScope,
+    private val loader: suspend PagedComponentContext<T>.(Pagination) -> PaginationResult<T>
+) {
+    internal val startPage = SimplePagination(initialPage, size)
+    internal val latestLoadedPage = SpecialMutableStateFlow<PaginationResult<T>?>(null)
+    internal val dataState = SpecialMutableStateFlow<PaginationResult<T>?>(null)
+    internal var loadingJob: Job? = null
+    internal val loadingMutex = Mutex()
+
+    private fun initLoadingJob(
+        skipCheckerInLock: () -> Boolean,
+        pageGetter: () -> Pagination
+    ): Job {
+        return scope.launchLoggingDropExceptions {
+            loadingMutex.withLock {
+                if (skipCheckerInLock()) return@launchLoggingDropExceptions
+                loadingJob = loadingJob ?: scope.launchLoggingDropExceptions {
+                    runCatching {
+                        loader(pageGetter())
+                    }.onSuccess {
+                        latestLoadedPage.value = it
+                        dataState.value = it
+                    }
+                    loadingMutex.withLock {
+                        loadingJob = null
+                    }
+                }
+                loadingJob
+            } ?.join()
+        }
+    }
+
+    /**
+     * Loads the next page of data. If the last page is reached, this function returns early.
+     */
+    fun loadNext(): Job {
+        return initLoadingJob(
+            { latestLoadedPage.value ?.isLastPage == true }
+        ) {
+            latestLoadedPage.value ?.nextPage() ?: startPage
+        }
+    }
+
+    /**
+     * Loads the previous page of data if available.
+     */
+    fun loadPrevious(): Job {
+        return initLoadingJob(
+            { latestLoadedPage.value ?.isFirstPage == true }
+        ) {
+            latestLoadedPage.value ?.previousPage() ?: startPage
+        }
+    }
+
+    /**
+     * Reloads the current page, refreshing the data.
+     */
+    fun reload(): Job {
+        return initLoadingJob(
+            {
+                latestLoadedPage.value = null
+                true
+            }
+        ) {
+            startPage
+        }
+    }
+}
+
+/**
+ * Composable function for paginated data displaying in a Compose UI.
+ *
+ * @param T The type of paginated data.
+ * @param preload Optional preloaded pagination result.
+ * @param initialPage Initial page number.
+ * @param size Number of items per page.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data.
+ */
+@Composable
+internal fun <T> PagedComponent(
+    initialPage: Int,
+    size: Int,
+    loader: suspend PagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    predefinedScope: CoroutineScope? = null,
+    block: @Composable PagedComponentContext<T>.(PaginationResult<T>) -> Unit
+) {
+    val scope = predefinedScope ?: rememberCoroutineScope()
+    val context = remember { PagedComponentContext<T>(initialPage, size, scope, loader) }
+    remember {
+        context.reload()
+    }
+
+    val pageState = context.dataState.collectAsState()
+    pageState.value ?.let {
+        context.block(it)
+    }
+}
+
+/**
+ * Overloaded composable function for paginated components with pagination info.
+ *
+ * @param T The type of paginated data.
+ * @param pageInfo Initial pagination information.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data.
+ */
+@Composable
+fun <T> PagedComponent(
+    pageInfo: Pagination,
+    loader: suspend PagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    predefinedScope: CoroutineScope? = null,
+    block: @Composable PagedComponentContext<T>.(PaginationResult<T>) -> Unit
+) {
+    PagedComponent(
+        pageInfo.page,
+        pageInfo.size,
+        loader,
+        predefinedScope,
+        block
+    )
+}
+
+/**
+ * Overloaded composable function for paginated components with only a size parameter.
+ *
+ * @param T The type of paginated data.
+ * @param size Number of items per page.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data.
+ */
+@Composable
+fun <T> PagedComponent(
+    size: Int,
+    loader: suspend PagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    predefinedScope: CoroutineScope? = null,
+    block: @Composable PagedComponentContext<T>.(PaginationResult<T>) -> Unit
+) {
+    PagedComponent(0, size, loader, predefinedScope, block)
+}

pagination/compose/src/jvmTest/kotlin/InfinityPagedComponentTests.kt

@@ -0,0 +1,51 @@
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.runComposeUiTest
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.compose.InfinityPagedComponent
+import dev.inmo.micro_utils.pagination.compose.PagedComponent
+import org.jetbrains.annotations.TestOnly
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+
+class InfinityPagedComponentTests {
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    @TestOnly
+    fun testSimpleLoad() = runComposeUiTest {
+        var expectedList = listOf<Int>()
+        setContent {
+            InfinityPagedComponent<Int>(
+                size = 1,
+                loader = {
+                    PaginationResult(
+                        page = it.page,
+                        size = it.size,
+                        results = (it.firstIndex .. it.lastIndex).toList(),
+                        objectsNumber = 3
+                    ).also {
+                        expectedList += it.results
+                    }
+                }
+            ) {
+                if (it == null) {
+                    assertEquals(null, it)
+                } else {
+                    assertEquals(expectedList, it)
+                }
+
+                LaunchedEffect(it ?.size) {
+                    loadNext().join()
+                }
+            }
+        }
+
+        waitForIdle()
+
+        assertContentEquals(
+            listOf(0, 1, 2),
+            expectedList
+        )
+    }
+}

pagination/compose/src/jvmTest/kotlin/PagedComponentTests.kt

@@ -0,0 +1,64 @@
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.runComposeUiTest
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.compose.PagedComponent
+import org.jetbrains.annotations.TestOnly
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class PagedComponentTests {
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    @TestOnly
+    fun testSimpleLoad() = runComposeUiTest {
+        var expectedPage = PaginationResult(
+            page = 0,
+            size = 1,
+            results = listOf(0),
+            objectsNumber = 3
+        )
+        var previousPage = expectedPage
+        setContent {
+            PagedComponent<Int>(
+                initialPage = 0,
+                size = 1,
+                loader = {
+                    previousPage = expectedPage
+                    expectedPage = PaginationResult(
+                        page = it.page,
+                        size = it.size,
+                        results = (it.firstIndex .. it.lastIndex).toList(),
+                        objectsNumber = 3
+                    )
+                    expectedPage
+                }
+            ) {
+                assertEquals(expectedPage, it)
+                assertEquals(expectedPage.results, it.results)
+
+                if (it.isLastPage || it.page < previousPage.page) {
+                    if (it.isFirstPage) {
+                        // do nothing - end of test
+                    } else {
+                        loadPrevious()
+                    }
+                } else {
+                    loadNext()
+                }
+            }
+        }
+
+        waitForIdle()
+
+        assertEquals(
+            PaginationResult(
+                page = 0,
+                size = 1,
+                results = listOf(0),
+                objectsNumber = 3
+            ),
+            expectedPage
+        )
+    }
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/annotations/OverrideRequireManualInvalidation.kt

@@ -0,0 +1,14 @@
+package dev.inmo.micro_utils.repos.annotations
+
+
+@RequiresOptIn(
+    "Overriding of this invalidate message requires manual launching of invalidation on class initialization process",
+    RequiresOptIn.Level.WARNING
+)
+@Target(
+    AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.FUNCTION,
+)
+annotation class OverrideRequireManualInvalidation

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

@@ -4,6 +4,7 @@ import dev.inmo.micro_utils.coroutines.SmartRWLocker
 import dev.inmo.micro_utils.coroutines.withReadAcquire
 import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.cache.KVCache
 import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
@@ -12,10 +13,10 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
 
 open class ReadCRUDCacheRepo<ObjectType, IdType>(
-    protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
+    protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
-    protected open val kvCache: KVCache<IdType, ObjectType>,
+    protected val kvCache: KVCache<IdType, ObjectType>,
     protected val locker: SmartRWLocker = SmartRWLocker(),
-    protected open val idGetter: (ObjectType) -> IdType
+    protected val idGetter: (ObjectType) -> IdType
 ) : ReadCRUDRepo<ObjectType, IdType> by parentRepo, CommonCacheRepo {
     override suspend fun getById(id: IdType): ObjectType? = locker.withReadAcquire {
         kvCache.get(id)
@@ -39,6 +40,7 @@ open class ReadCRUDCacheRepo<ObjectType, IdType>(
         kvCache.contains(id)
     } || parentRepo.contains(id)
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() = locker.withWriteLock {
         kvCache.clear()
     }
@@ -51,11 +53,11 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.cached(
 ) = ReadCRUDCacheRepo(this, kvCache, locker, idGetter)
 
 open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>(
-    protected open val parentRepo: WriteCRUDRepo<ObjectType, IdType, InputValueType>,
+    protected val parentRepo: WriteCRUDRepo<ObjectType, IdType, InputValueType>,
-    protected open val kvCache: KeyValueRepo<IdType, ObjectType>,
+    protected val kvCache: KeyValueRepo<IdType, ObjectType>,
-    protected open val scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    protected val scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     protected val locker: SmartRWLocker = SmartRWLocker(),
-    protected open val idGetter: (ObjectType) -> IdType
+    protected val idGetter: (ObjectType) -> IdType
 ) : WriteCRUDRepo<ObjectType, IdType, InputValueType>, CommonCacheRepo {
     override val newObjectsFlow: Flow<ObjectType> by parentRepo::newObjectsFlow
     override val updatedObjectsFlow: Flow<ObjectType> by parentRepo::updatedObjectsFlow
@@ -117,6 +119,7 @@ open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>(
         return created
     }
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() = locker.withWriteLock {
         kvCache.clear()
     }
@@ -131,25 +134,26 @@ fun <ObjectType, IdType, InputType> WriteCRUDRepo<ObjectType, IdType, InputType>
 
 
 open class CRUDCacheRepo<ObjectType, IdType, InputValueType>(
-    override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
+    protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
     kvCache: KVCache<IdType, ObjectType>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     locker: SmartRWLocker = SmartRWLocker(),
     idGetter: (ObjectType) -> IdType
 ) : ReadCRUDCacheRepo<ObjectType, IdType>(
-    parentRepo,
+    crudRepo,
     kvCache,
     locker,
     idGetter
 ),
-    WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
+WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
-    parentRepo,
+    crudRepo,
     kvCache,
     scope,
     locker,
     idGetter
 ),
-    CRUDRepo<ObjectType, IdType, InputValueType> {
+CRUDRepo<ObjectType, IdType, InputValueType> {
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() = kvCache.actualizeAll(parentRepo, locker = locker)
 }
 

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

@@ -1,5 +1,10 @@
 package dev.inmo.micro_utils.repos.cache
 
+import dev.inmo.micro_utils.coroutines.SmartRWLocker
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+
 interface InvalidatableRepo {
     /**
      * Invalidates its internal data. It __may__ lead to autoreload of data. In case when repo makes autoreload,
@@ -8,4 +13,14 @@ interface InvalidatableRepo {
     suspend fun invalidate()
 }
 
+suspend fun <T : InvalidatableRepo> T.alsoInvalidate() = also {
+    invalidate()
+}
+
+fun <T : InvalidatableRepo> T.alsoInvalidateAsync(scope: CoroutineScope) = also {
+    scope.launchLoggingDropExceptions {
+        invalidate()
+    }
+}
+
 typealias CacheRepo = InvalidatableRepo

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

@@ -5,6 +5,7 @@ import dev.inmo.micro_utils.coroutines.withReadAcquire
 import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.cache.KVCache
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
@@ -12,8 +13,8 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
 
 open class ReadKeyValueCacheRepo<Key,Value>(
-    protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
+    protected val parentRepo: ReadKeyValueRepo<Key, Value>,
-    protected open val kvCache: KVCache<Key, Value>,
+    protected val kvCache: KVCache<Key, Value>,
     protected val locker: SmartRWLocker = SmartRWLocker(),
 ) : ReadKeyValueRepo<Key,Value> by parentRepo, CommonCacheRepo {
     override suspend fun get(k: Key): Value? = locker.withReadAcquire {
@@ -49,6 +50,7 @@ open class ReadKeyValueCacheRepo<Key,Value>(
         }
     }
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() = kvCache.actualizeAll(parentRepo, locker = locker)
 }
 
@@ -58,24 +60,24 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
 ) = ReadKeyValueCacheRepo(this, kvCache, locker)
 
 open class KeyValueCacheRepo<Key,Value>(
-    override val parentRepo: KeyValueRepo<Key, Value>,
+    protected val kvRepo: KeyValueRepo<Key, Value>,
     kvCache: KVCache<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     locker: SmartRWLocker = SmartRWLocker(),
-) : ReadKeyValueCacheRepo<Key,Value>(parentRepo, kvCache, locker), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo, CommonCacheRepo {
+) : ReadKeyValueCacheRepo<Key,Value>(kvRepo, kvCache, locker), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by kvRepo, CommonCacheRepo {
-    protected val onNewJob = parentRepo.onNewValue.onEach {
+    protected val onNewJob = kvRepo.onNewValue.onEach {
         locker.withWriteLock {
             kvCache.set(it.first, it.second)
         }
     }.launchIn(scope)
-    protected val onRemoveJob = parentRepo.onValueRemoved.onEach {
+    protected val onRemoveJob = kvRepo.onValueRemoved.onEach {
         locker.withWriteLock {
             kvCache.unset(it)
         }
     }.launchIn(scope)
 
     override suspend fun clear() {
-        parentRepo.clear()
+        kvRepo.clear()
         locker.withWriteLock {
             kvCache.clear()
         }

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

@@ -6,6 +6,7 @@ import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.*
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.cache.KVCache
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
@@ -13,8 +14,8 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
 
 open class ReadKeyValuesCacheRepo<Key,Value>(
-    protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
+    protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
-    protected open val kvCache: KVCache<Key, List<Value>>,
+    protected val kvCache: KVCache<Key, List<Value>>,
     protected val locker: SmartRWLocker = SmartRWLocker(),
 ) : ReadKeyValuesRepo<Key,Value> by parentRepo, CommonCacheRepo {
     override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
@@ -48,6 +49,7 @@ open class ReadKeyValuesCacheRepo<Key,Value>(
         kvCache.contains(k)
     } || parentRepo.contains(k)
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() = kvCache.actualizeAll(parentRepo, locker = locker)
 }
 

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

@@ -6,6 +6,7 @@ import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.KeyValueRepo
 import dev.inmo.micro_utils.repos.MapKeyValueRepo
 import dev.inmo.micro_utils.repos.ReadCRUDRepo
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 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
@@ -18,7 +19,7 @@ import kotlinx.coroutines.launch
 import kotlin.time.Duration.Companion.seconds
 
 open class AutoRecacheReadCRUDRepo<RegisteredObject, Id>(
-    protected open val originalRepo: ReadCRUDRepo<RegisteredObject, Id>,
+    protected val originalRepo: ReadCRUDRepo<RegisteredObject, Id>,
     protected val scope: CoroutineScope,
     protected val kvCache: KeyValueRepo<Id, RegisteredObject> = MapKeyValueRepo(),
     protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,
@@ -90,6 +91,7 @@ open class AutoRecacheReadCRUDRepo<RegisteredObject, Id>(
         kvCache.set(idGetter(it), it)
     } ?: kvCache.get(id)
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         actualizeAll()
     }

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

@@ -2,6 +2,7 @@ package dev.inmo.micro_utils.repos.cache.fallback.crud
 
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
@@ -53,6 +54,7 @@ open class AutoRecacheWriteCRUDRepo<RegisteredObject, Id, InputObject>(
         kvCache.set(idGetter(it), it)
     }
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         kvCache.clear()
     }

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

@@ -8,21 +8,21 @@ import kotlinx.coroutines.CoroutineScope
 import kotlin.time.Duration.Companion.seconds
 
 open class AutoRecacheKeyValueRepo<Id, RegisteredObject>(
-    override val originalRepo: KeyValueRepo<Id, RegisteredObject>,
+    protected val kvRepo: KeyValueRepo<Id, RegisteredObject>,
     scope: CoroutineScope,
     kvCache: KeyValueRepo<Id, RegisteredObject> = MapKeyValueRepo(),
     recacheDelay: Long = 60.seconds.inWholeMilliseconds,
     actionWrapper: ActionWrapper = ActionWrapper.Direct,
     idGetter: (RegisteredObject) -> Id
 ) : AutoRecacheReadKeyValueRepo<Id, RegisteredObject> (
-    originalRepo,
+    kvRepo,
     scope,
     kvCache,
     recacheDelay,
     actionWrapper,
     idGetter
 ),
-    WriteKeyValueRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValueRepo(originalRepo, scope, kvCache),
+    WriteKeyValueRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValueRepo(kvRepo, scope, kvCache),
     KeyValueRepo<Id, RegisteredObject> {
 
     constructor(
@@ -34,14 +34,14 @@ open class AutoRecacheKeyValueRepo<Id, RegisteredObject>(
         idGetter: (RegisteredObject) -> Id
     ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis), idGetter)
 
-    override suspend fun unsetWithValues(toUnset: List<RegisteredObject>) = originalRepo.unsetWithValues(
+    override suspend fun unsetWithValues(toUnset: List<RegisteredObject>) = kvRepo.unsetWithValues(
         toUnset
     ).also {
         kvCache.unsetWithValues(toUnset)
     }
 
     override suspend fun clear() {
-        originalRepo.clear()
+        kvRepo.clear()
         kvCache.clear()
     }
 }

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

@@ -6,6 +6,7 @@ import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.KeyValueRepo
 import dev.inmo.micro_utils.repos.MapKeyValueRepo
 import dev.inmo.micro_utils.repos.ReadKeyValueRepo
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 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
@@ -18,7 +19,7 @@ import kotlinx.coroutines.launch
 import kotlin.time.Duration.Companion.seconds
 
 open class AutoRecacheReadKeyValueRepo<Id, RegisteredObject>(
-    protected open val originalRepo: ReadKeyValueRepo<Id, RegisteredObject>,
+    protected val originalRepo: ReadKeyValueRepo<Id, RegisteredObject>,
     protected val scope: CoroutineScope,
     protected val kvCache: KeyValueRepo<Id, RegisteredObject> = MapKeyValueRepo(),
     protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,
@@ -100,6 +101,7 @@ open class AutoRecacheReadKeyValueRepo<Id, RegisteredObject>(
         originalRepo.keys(v, pagination, reversed)
     }.getOrElse { kvCache.keys(v, pagination, reversed) }
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         actualizeAll()
     }

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

@@ -2,6 +2,7 @@ package dev.inmo.micro_utils.repos.cache.fallback.keyvalue
 
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
@@ -44,6 +45,7 @@ open class AutoRecacheWriteKeyValueRepo<Id, RegisteredObject>(
         kvCache.set(toSet)
     }
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         kvCache.clear()
     }

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

@@ -9,19 +9,19 @@ import kotlinx.coroutines.CoroutineScope
 import kotlin.time.Duration.Companion.seconds
 
 open class AutoRecacheKeyValuesRepo<Id, RegisteredObject>(
-    override val originalRepo: KeyValuesRepo<Id, RegisteredObject>,
+    protected val kvsRepo: KeyValuesRepo<Id, RegisteredObject>,
     scope: CoroutineScope,
     kvCache: KeyValueRepo<Id, List<RegisteredObject>> = MapKeyValueRepo(),
     recacheDelay: Long = 60.seconds.inWholeMilliseconds,
     actionWrapper: ActionWrapper = ActionWrapper.Direct
 ) : AutoRecacheReadKeyValuesRepo<Id, RegisteredObject> (
-    originalRepo,
+    kvsRepo,
     scope,
     kvCache,
     recacheDelay,
     actionWrapper
 ),
-    WriteKeyValuesRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValuesRepo(originalRepo, scope, kvCache),
+    WriteKeyValuesRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValuesRepo(kvsRepo, scope, kvCache),
     KeyValuesRepo<Id, RegisteredObject> {
 
     constructor(

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

@@ -13,6 +13,7 @@ import dev.inmo.micro_utils.pagination.utils.paginate
 import dev.inmo.micro_utils.repos.KeyValueRepo
 import dev.inmo.micro_utils.repos.MapKeyValueRepo
 import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 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
@@ -24,7 +25,7 @@ import kotlinx.coroutines.launch
 import kotlin.time.Duration.Companion.seconds
 
 open class AutoRecacheReadKeyValuesRepo<Id, RegisteredObject>(
-    protected open val originalRepo: ReadKeyValuesRepo<Id, RegisteredObject>,
+    protected val originalRepo: ReadKeyValuesRepo<Id, RegisteredObject>,
     protected val scope: CoroutineScope,
     protected val kvCache: KeyValueRepo<Id, List<RegisteredObject>> = MapKeyValueRepo(),
     protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,
@@ -140,6 +141,7 @@ open class AutoRecacheReadKeyValuesRepo<Id, RegisteredObject>(
         }) ?: (kvCache.get(k) ?.contains(v) == true)
     }
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         actualizeAll()
     }

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

@@ -3,6 +3,7 @@ package dev.inmo.micro_utils.repos.cache.fallback.keyvalues
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
 import dev.inmo.micro_utils.repos.pagination.maxPagePagination
 import kotlinx.coroutines.CoroutineScope
@@ -89,6 +90,7 @@ open class AutoRecacheWriteKeyValuesRepo<Id, RegisteredObject>(
         }
     }
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         kvCache.clear()
     }

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

@@ -8,6 +8,7 @@ import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.*
 import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
@@ -15,10 +16,10 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 
 open class FullReadCRUDCacheRepo<ObjectType, IdType>(
-    protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
+    protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
-    protected open val kvCache: KeyValueRepo<IdType, ObjectType>,
+    protected val kvCache: KeyValueRepo<IdType, ObjectType>,
     protected val locker: SmartRWLocker = SmartRWLocker(),
-    protected open val idGetter: (ObjectType) -> IdType
+    protected val idGetter: (ObjectType) -> IdType
 ) : ReadCRUDRepo<ObjectType, IdType>, FullCacheRepo {
     protected suspend inline fun <T> doOrTakeAndActualize(
         action: KeyValueRepo<IdType, ObjectType>.() -> Optional<T>,
@@ -94,20 +95,20 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.cached(
 ) = FullReadCRUDCacheRepo(this, kvCache, locker, idGetter)
 
 open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
-    override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
+    protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
     kvCache: KeyValueRepo<IdType, ObjectType>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
     locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
     idGetter: (ObjectType) -> IdType
 ) : FullReadCRUDCacheRepo<ObjectType, IdType>(
-    parentRepo,
+    crudRepo,
     kvCache,
     locker,
     idGetter
 ),
     WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
-        parentRepo,
+        crudRepo,
         kvCache,
         scope,
         locker,
@@ -128,11 +129,12 @@ open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
 
     protected open suspend fun initialInvalidate() {
         try {
-            kvCache.actualizeAll(parentRepo, locker = null)
+            kvCache.actualizeAll(crudRepo, locker = null)
         } finally {
             locker.unlockWrite()
         }
     }
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         actualizeAll()
     }

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

@@ -8,6 +8,7 @@ import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
@@ -15,8 +16,8 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
 
 open class FullReadKeyValueCacheRepo<Key,Value>(
-    protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
+    protected val parentRepo: ReadKeyValueRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, Value>,
+    protected val kvCache: KeyValueRepo<Key, Value>,
     protected val locker: SmartRWLocker = SmartRWLocker()
 ) : ReadKeyValueRepo<Key, Value>, FullCacheRepo {
     protected suspend inline fun <T> doOrTakeAndActualize(
@@ -86,6 +87,7 @@ open class FullReadKeyValueCacheRepo<Key,Value>(
         { if (it.results.isNotEmpty()) actualizeAll() }
     )
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         actualizeAll()
     }
@@ -98,7 +100,7 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
 
 open class FullWriteKeyValueCacheRepo<Key,Value>(
     parentRepo: WriteKeyValueRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, Value>,
+    protected val kvCache: KeyValueRepo<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     protected val locker: SmartRWLocker = SmartRWLocker()
 ) : WriteKeyValueRepo<Key, Value> by parentRepo, FullCacheRepo {
@@ -126,16 +128,16 @@ fun <Key, Value> WriteKeyValueRepo<Key, Value>.caching(
 ) = FullWriteKeyValueCacheRepo(this, kvCache, scope)
 
 open class FullKeyValueCacheRepo<Key,Value>(
-    override val parentRepo: KeyValueRepo<Key, Value>,
+    protected val kvRepo: KeyValueRepo<Key, Value>,
     kvCache: KeyValueRepo<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
     locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
 ) : //FullWriteKeyValueCacheRepo<Key,Value>(parentRepo, kvCache, scope),
     KeyValueRepo<Key,Value>,
-    WriteKeyValueRepo<Key,Value> by parentRepo,
+    WriteKeyValueRepo<Key,Value> by kvRepo,
     FullReadKeyValueCacheRepo<Key, Value>(
-        parentRepo,
+        kvRepo,
         kvCache,
         locker
 ) {
@@ -151,7 +153,7 @@ open class FullKeyValueCacheRepo<Key,Value>(
         }
     }
 
-    override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset)
+    override suspend fun unsetWithValues(toUnset: List<Value>) = kvRepo.unsetWithValues(toUnset)
 
     protected open suspend fun initialInvalidate() {
         try {
@@ -160,18 +162,19 @@ open class FullKeyValueCacheRepo<Key,Value>(
             locker.unlockWrite()
         }
     }
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         kvCache.actualizeAll(parentRepo, locker)
     }
 
     override suspend fun clear() {
-        parentRepo.clear()
+        kvRepo.clear()
         kvCache.clear()
     }
 
     override suspend fun set(toSet: Map<Key, Value>) {
         locker.withWriteLock {
-            parentRepo.set(toSet)
+            kvRepo.set(toSet)
             kvCache.set(
                 toSet.filter {
                     parentRepo.contains(it.key)
@@ -182,7 +185,7 @@ open class FullKeyValueCacheRepo<Key,Value>(
 
     override suspend fun unset(toUnset: List<Key>) {
         locker.withWriteLock {
-            parentRepo.unset(toUnset)
+            kvRepo.unset(toUnset)
             kvCache.unset(
                 toUnset.filter {
                     !parentRepo.contains(it)

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

@@ -8,16 +8,16 @@ import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.*
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
-import dev.inmo.micro_utils.repos.pagination.maxPagePagination
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
 
 open class FullReadKeyValuesCacheRepo<Key,Value>(
-    protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
+    protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, List<Value>>,
+    protected val kvCache: KeyValueRepo<Key, List<Value>>,
     protected val locker: SmartRWLocker = SmartRWLocker(),
 ) : ReadKeyValuesRepo<Key, Value>, FullCacheRepo {
     protected suspend inline fun <T> doOrTakeAndActualize(
@@ -153,6 +153,7 @@ open class FullReadKeyValuesCacheRepo<Key,Value>(
         { if (it.results.isNotEmpty()) actualizeAll() }
     )
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         actualizeAll()
     }
@@ -165,7 +166,7 @@ fun <Key, Value> ReadKeyValuesRepo<Key, Value>.cached(
 
 open class FullWriteKeyValuesCacheRepo<Key,Value>(
     parentRepo: WriteKeyValuesRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, List<Value>>,
+    protected val kvCache: KeyValueRepo<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     protected val locker: SmartRWLocker = SmartRWLocker(),
 ) : WriteKeyValuesRepo<Key, Value> by parentRepo, FullCacheRepo {
@@ -200,14 +201,14 @@ fun <Key, Value> WriteKeyValuesRepo<Key, Value>.caching(
 ) = FullWriteKeyValuesCacheRepo(this, kvCache, scope, locker)
 
 open class FullKeyValuesCacheRepo<Key,Value>(
-    override val parentRepo: KeyValuesRepo<Key, Value>,
+    protected val kvsRepo: KeyValuesRepo<Key, Value>,
     kvCache: KeyValueRepo<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
     locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
 ) : KeyValuesRepo<Key, Value>,
-    FullReadKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, locker),
+    FullReadKeyValuesCacheRepo<Key, Value>(kvsRepo, kvCache, locker),
-    WriteKeyValuesRepo<Key, Value> by parentRepo {
+    WriteKeyValuesRepo<Key, Value> by kvsRepo {
     init {
         if (!skipStartInvalidate) {
             scope.launchLoggingDropExceptions {
@@ -235,13 +236,14 @@ open class FullKeyValuesCacheRepo<Key,Value>(
             locker.unlockWrite()
         }
     }
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         kvCache.actualizeAll(parentRepo, locker = locker)
     }
 
     override suspend fun set(toSet: Map<Key, List<Value>>) {
         locker.withWriteLock {
-            parentRepo.set(toSet)
+            kvsRepo.set(toSet)
             kvCache.set(
                 toSet.filter {
                     parentRepo.contains(it.key)
@@ -252,7 +254,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
 
     override suspend fun add(toAdd: Map<Key, List<Value>>) {
         locker.withWriteLock {
-            parentRepo.add(toAdd)
+            kvsRepo.add(toAdd)
             toAdd.forEach {
                 val filtered = it.value.filter { v ->
                     parentRepo.contains(it.key, v)
@@ -269,7 +271,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
 
     override suspend fun remove(toRemove: Map<Key, List<Value>>) {
         locker.withWriteLock {
-            parentRepo.remove(toRemove)
+            kvsRepo.remove(toRemove)
             toRemove.forEach {
                 val filtered = it.value.filter { v ->
                     !parentRepo.contains(it.key, v)
@@ -291,7 +293,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
 
     override suspend fun clear(k: Key) {
         locker.withWriteLock {
-            parentRepo.clear(k)
+            kvsRepo.clear(k)
             if (parentRepo.contains(k)) {
                 return@withWriteLock
             }

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

@@ -1,24 +1,23 @@
 package dev.inmo.micro_utils.repos.cache.full.direct
 
-import dev.inmo.micro_utils.common.*
+import dev.inmo.micro_utils.common.Warning
 import dev.inmo.micro_utils.coroutines.SmartRWLocker
 import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.withReadAcquire
-import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.*
-import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 
 open class DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
-    protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
+    protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
-    protected open val kvCache: KeyValueRepo<IdType, ObjectType>,
+    protected val kvCache: KeyValueRepo<IdType, ObjectType>,
     protected val locker: SmartRWLocker = SmartRWLocker(),
-    protected open val idGetter: (ObjectType) -> IdType
+    protected val idGetter: (ObjectType) -> IdType
 ) : ReadCRUDRepo<ObjectType, IdType>, DirectFullCacheRepo {
     protected open suspend fun actualizeAll() {
         kvCache.actualizeAll(parentRepo, locker = locker)
@@ -60,20 +59,20 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.directlyCached(
 ) = DirectFullReadCRUDCacheRepo(this, kvCache, locker, idGetter)
 
 open class DirectFullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
-    override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
+    protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
     kvCache: KeyValueRepo<IdType, ObjectType>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
     locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
     idGetter: (ObjectType) -> IdType
 ) : DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
-    parentRepo,
+    crudRepo,
     kvCache,
     locker,
     idGetter
 ),
     WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
-        parentRepo,
+        crudRepo,
         kvCache,
         scope,
         locker,
@@ -99,6 +98,8 @@ open class DirectFullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
             locker.unlockWrite()
         }
     }
+
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         actualizeAll()
     }

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

@@ -7,9 +7,7 @@ import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.repos.*
-import dev.inmo.micro_utils.repos.cache.full.FullKeyValueCacheRepo
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
-import dev.inmo.micro_utils.repos.cache.full.FullReadKeyValueCacheRepo
-import dev.inmo.micro_utils.repos.cache.full.FullWriteKeyValueCacheRepo
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -18,8 +16,8 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 
 open class DirectFullReadKeyValueCacheRepo<Key, Value>(
-    protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
+    protected val parentRepo: ReadKeyValueRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, Value>,
+    protected val kvCache: KeyValueRepo<Key, Value>,
     protected val locker: SmartRWLocker = SmartRWLocker()
 ) : DirectFullCacheRepo, ReadKeyValueRepo<Key, Value> {
     protected open suspend fun actualizeAll() {
@@ -54,6 +52,7 @@ open class DirectFullReadKeyValueCacheRepo<Key, Value>(
         kvCache.keys(v, pagination, reversed)
     }
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         actualizeAll()
     }
@@ -65,8 +64,8 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.directlyCached(
 ) = DirectFullReadKeyValueCacheRepo(this, kvCache, locker)
 
 open class DirectFullWriteKeyValueCacheRepo<Key, Value>(
-    protected open val parentRepo: WriteKeyValueRepo<Key, Value>,
+    protected val parentRepo: WriteKeyValueRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, Value>,
+    protected val kvCache: KeyValueRepo<Key, Value>,
     protected val locker: SmartRWLocker = SmartRWLocker(),
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
 ) : DirectFullCacheRepo, WriteKeyValueRepo<Key, Value> by parentRepo {
@@ -86,6 +85,7 @@ open class DirectFullWriteKeyValueCacheRepo<Key, Value>(
         }
     }.launchIn(scope)
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         locker.withWriteLock {
             kvCache.clear()
@@ -101,7 +101,7 @@ fun <Key, Value> WriteKeyValueRepo<Key, Value>.directlyCached(
 ) = DirectFullWriteKeyValueCacheRepo(this, kvCache, scope = scope)
 
 open class DirectFullKeyValueCacheRepo<Key, Value>(
-    override val parentRepo: KeyValueRepo<Key, Value>,
+    protected val kvRepo: KeyValueRepo<Key, Value>,
     kvCache: KeyValueRepo<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
@@ -109,12 +109,12 @@ open class DirectFullKeyValueCacheRepo<Key, Value>(
 ) : DirectFullCacheRepo,
     KeyValueRepo<Key, Value> ,
     WriteKeyValueRepo<Key, Value> by DirectFullWriteKeyValueCacheRepo(
-        parentRepo,
+        kvRepo,
         kvCache,
         locker,
         scope
     ),
-    DirectFullReadKeyValueCacheRepo<Key, Value>(parentRepo, kvCache, locker) {
+    DirectFullReadKeyValueCacheRepo<Key, Value>(kvRepo, kvCache, locker) {
     init {
         if (!skipStartInvalidate) {
             scope.launchLoggingDropExceptions {
@@ -135,20 +135,21 @@ open class DirectFullKeyValueCacheRepo<Key, Value>(
             locker.unlockWrite()
         }
     }
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         kvCache.actualizeAll(parentRepo, locker)
     }
 
     override suspend fun clear() {
-        parentRepo.clear()
+        kvRepo.clear()
         kvCache.clear()
     }
 
-    override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset)
+    override suspend fun unsetWithValues(toUnset: List<Value>) = kvRepo.unsetWithValues(toUnset)
 
     override suspend fun set(toSet: Map<Key, Value>) {
         locker.withWriteLock {
-            parentRepo.set(toSet)
+            kvRepo.set(toSet)
             kvCache.set(
                 toSet.filter {
                     parentRepo.contains(it.key)
@@ -159,7 +160,7 @@ open class DirectFullKeyValueCacheRepo<Key, Value>(
 
     override suspend fun unset(toUnset: List<Key>) {
         locker.withWriteLock {
-            parentRepo.unset(toUnset)
+            kvRepo.unset(toUnset)
             kvCache.unset(
                 toUnset.filter {
                     !parentRepo.contains(it)

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

@@ -1,6 +1,5 @@
 package dev.inmo.micro_utils.repos.cache.full.direct
 
-import dev.inmo.micro_utils.common.*
 import dev.inmo.micro_utils.coroutines.SmartRWLocker
 import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.withReadAcquire
@@ -8,6 +7,7 @@ import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.*
 import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.annotations.OverrideRequireManualInvalidation
 import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
 import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
@@ -15,8 +15,8 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
 
 open class DirectFullReadKeyValuesCacheRepo<Key,Value>(
-    protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
+    protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, List<Value>>,
+    protected val kvCache: KeyValueRepo<Key, List<Value>>,
     protected val locker: SmartRWLocker = SmartRWLocker(),
 ) : ReadKeyValuesRepo<Key, Value>, DirectFullCacheRepo {
     protected open suspend fun actualizeKey(k: Key) {
@@ -88,6 +88,7 @@ open class DirectFullReadKeyValuesCacheRepo<Key,Value>(
         return result ?: emptyPaginationResult()
     }
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         actualizeAll()
     }
@@ -100,7 +101,7 @@ fun <Key, Value> ReadKeyValuesRepo<Key, Value>.directlyCached(
 
 open class DirectFullWriteKeyValuesCacheRepo<Key,Value>(
     parentRepo: WriteKeyValuesRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<Key, List<Value>>,
+    protected val kvCache: KeyValueRepo<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     protected val locker: SmartRWLocker = SmartRWLocker(),
 ) : WriteKeyValuesRepo<Key, Value> by parentRepo, DirectFullCacheRepo {
@@ -121,6 +122,7 @@ open class DirectFullWriteKeyValuesCacheRepo<Key,Value>(
         }
     }.launchIn(scope)
 
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         locker.withWriteLock {
             kvCache.clear()
@@ -135,14 +137,14 @@ fun <Key, Value> WriteKeyValuesRepo<Key, Value>.directlyCached(
 ) = DirectFullWriteKeyValuesCacheRepo(this, kvCache, scope, locker)
 
 open class DirectFullKeyValuesCacheRepo<Key,Value>(
-    override val parentRepo: KeyValuesRepo<Key, Value>,
+    protected val kvsRepo: KeyValuesRepo<Key, Value>,
     kvCache: KeyValueRepo<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
     locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
 ) : KeyValuesRepo<Key, Value>,
-    DirectFullReadKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, locker),
+    DirectFullReadKeyValuesCacheRepo<Key, Value>(kvsRepo, kvCache, locker),
-    WriteKeyValuesRepo<Key, Value> by parentRepo {
+    WriteKeyValuesRepo<Key, Value> by kvsRepo {
     init {
         if (!skipStartInvalidate) {
             scope.launchLoggingDropExceptions {
@@ -170,13 +172,14 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
             locker.unlockWrite()
         }
     }
+    @OverrideRequireManualInvalidation
     override suspend fun invalidate() {
         kvCache.actualizeAll(parentRepo, locker = locker)
     }
 
     override suspend fun set(toSet: Map<Key, List<Value>>) {
         locker.withWriteLock {
-            parentRepo.set(toSet)
+            kvsRepo.set(toSet)
             kvCache.set(
                 toSet.filter {
                     parentRepo.contains(it.key)
@@ -187,7 +190,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
 
     override suspend fun add(toAdd: Map<Key, List<Value>>) {
         locker.withWriteLock {
-            parentRepo.add(toAdd)
+            kvsRepo.add(toAdd)
             toAdd.forEach {
                 val filtered = it.value.filter { v ->
                     parentRepo.contains(it.key, v)
@@ -204,7 +207,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
 
     override suspend fun remove(toRemove: Map<Key, List<Value>>) {
         locker.withWriteLock {
-            parentRepo.remove(toRemove)
+            kvsRepo.remove(toRemove)
             toRemove.forEach {
                 val filtered = it.value.filter { v ->
                     !parentRepo.contains(it.key, v)
@@ -226,7 +229,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
 
     override suspend fun clear(k: Key) {
         locker.withWriteLock {
-            parentRepo.clear(k)
+            kvsRepo.clear(k)
             if (parentRepo.contains(k)) {
                 return@withWriteLock
             }

repos/cache/src/jvmMain/kotlin/InvalidateSynchronously.kt

@@ -0,0 +1,54 @@
+package dev.inmo.micro_utils.repos.cache
+
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.micro_utils.coroutines.doSynchronously
+import dev.inmo.micro_utils.coroutines.runCatchingLogging
+import kotlinx.coroutines.CoroutineScope
+
+fun <T : InvalidatableRepo> T.alsoInvalidateSync(
+    scope: CoroutineScope,
+    onFailure: suspend (Throwable) -> Unit = {},
+) = also {
+    scope.doSynchronously {
+        runCatching {
+            invalidate()
+        }.onFailure {
+            onFailure(it)
+        }
+    }
+}
+
+fun <T : InvalidatableRepo> T.alsoInvalidateSync(
+    onFailure: suspend (Throwable) -> Unit = {},
+) = also {
+    doSynchronously {
+        runCatching {
+            invalidate()
+        }.onFailure {
+            onFailure(it)
+        }
+    }
+}
+
+fun <T : InvalidatableRepo> T.alsoInvalidateSyncLogging(
+    scope: CoroutineScope,
+    errorMessageBuilder: CoroutineScope.(Throwable) -> Any = { "Something web wrong" },
+    logger: KSLog = KSLog,
+) = also {
+    scope.doSynchronously {
+        runCatchingLogging(errorMessageBuilder, logger) {
+            invalidate()
+        }
+    }
+}
+
+fun <T : InvalidatableRepo> T.alsoInvalidateSyncLogging(
+    errorMessageBuilder: CoroutineScope.(Throwable) -> Any = { "Something web wrong" },
+    logger: KSLog = KSLog,
+) = also {
+    doSynchronously {
+        runCatchingLogging(errorMessageBuilder, logger) {
+            invalidate()
+        }
+    }
+}

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

@@ -4,7 +4,6 @@ import dev.inmo.micro_utils.repos.KeyValuesRepo
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.statements.InsertStatement
 import org.jetbrains.exposed.sql.statements.UpdateBuilder
 import org.jetbrains.exposed.sql.transactions.transaction
 
@@ -57,18 +56,48 @@ abstract class AbstractExposedKeyValuesRepo<Key, Value>(
             }
         }
 
-        transaction(database) {
+        val (oldObjects, insertedResults) = transaction(database) {
+            val oldObjects = selectAll().where { selectByIds(toSet.keys.toList()) }.map { it.asKey to it.asObject }
+
             deleteWhere {
                 selectByIds(it, toSet.keys.toList())
             }
-            batchInsert(
+            val inserted = batchInsert(
                 prepreparedData,
             ) { (k, v) ->
                 insert(k, v, this)
             }.map {
                 it.asKey to it.asObject
             }
-        }.forEach { _onNewValue.emit(it) }
+            oldObjects to inserted
+        }.let {
+            val mappedFirst = it
+                .first
+                .asSequence()
+                .groupBy { it.first }
+                .mapValues { it.value.map { it.second }.toSet() }
+            val mappedSecond = it
+                .second
+                .asSequence()
+                .groupBy { it.first }
+                .mapValues { it.value.map { it.second }.toSet() }
+            mappedFirst to mappedSecond
+        }
+        val deletedResults = oldObjects.mapNotNull { (k, vs) ->
+            k to vs.filter { v ->
+                insertedResults[k] ?.contains(v) != true
+            }.ifEmpty { return@mapNotNull null }
+        }
+        deletedResults.forEach { (k, vs) ->
+            vs.forEach { v ->
+                _onValueRemoved.emit(k to v)
+            }
+        }
+        insertedResults.forEach { (k, vs) ->
+            vs.forEach { v ->
+                _onNewValue.emit(k to v)
+            }
+        }
     }
 
     override suspend fun remove(toRemove: Map<Key, List<Value>>) {

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

@@ -73,7 +73,7 @@ class KtorCRUDRepoTests : CommonCRUDRepoTests() {
             }
             val server = io.ktor.server.engine.embeddedServer(
                 CIO,
-                34567,
+                34568,
                 "127.0.0.1"
             ) {
                 install(ContentNegotiation) {
@@ -100,7 +100,7 @@ class KtorCRUDRepoTests : CommonCRUDRepoTests() {
                 }
             }
             val crudClient = KtorCRUDRepoClient<ComplexData, Int, SimpleData>(
-                "http://127.0.0.1:34567",
+                "http://127.0.0.1:34568",
                 client,
                 ContentType.Application.Json
             ) {

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

@@ -63,7 +63,7 @@ class KtorKeyValueRepoTests : CommonKeyValueRepoTests() {
             val repo = MapKeyValueRepo<Int, ComplexData>(map)
             val server = io.ktor.server.engine.embeddedServer(
                 CIO,
-                34567,
+                34569,
                 "127.0.0.1"
             ) {
                 install(ContentNegotiation) {
@@ -91,7 +91,7 @@ class KtorKeyValueRepoTests : CommonKeyValueRepoTests() {
                 }
             }
             val crudClient = KtorKeyValueRepoClient<Int, ComplexData>(
-                "http://127.0.0.1:34567",
+                "http://127.0.0.1:34569",
                 client,
                 ContentType.Application.Json,
                 Int.serializer(),

settings.gradle

@@ -3,6 +3,7 @@ rootProject.name='micro_utils'
 String[] includes = [
     ":common",
     ":common:compose",
+    ":transactions",
     ":matrix",
     ":safe_wrapper",
     ":crypto",
@@ -11,6 +12,7 @@ String[] includes = [
     ":koin:generator:test",
     ":selector:common",
     ":pagination:common",
+    ":pagination:compose",
     ":pagination:exposed",
     ":pagination:ktor:common",
     ":pagination:ktor:server",

startup/launcher/build.gradle

@@ -1,13 +1,19 @@
 plugins {
     id "org.jetbrains.kotlin.multiplatform"
     id "org.jetbrains.kotlin.plugin.serialization"
-    id "application"
     id "com.google.devtools.ksp"
 }
 
 apply from: "$mppJvmJsLinuxMingwProject"
 
 kotlin {
+    jvm {
+        binaries {
+            executable {
+                mainClass.set("dev.inmo.micro_utils.startup.launcher.MainKt")
+            }
+        }
+    }
     sourceSets {
         commonMain {
             dependencies {
@@ -23,10 +29,6 @@ kotlin {
     }
 }
 
-application {
-    mainClassName = "dev.inmo.micro_utils.startup.launcher.MainKt"
-}
-
 java {
     sourceCompatibility = JavaVersion.VERSION_17
     targetCompatibility = JavaVersion.VERSION_17

transactions/build.gradle

@@ -0,0 +1,7 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"

transactions/src/commonMain/kotlin/TransactionsDSL.kt

@@ -0,0 +1,83 @@
+package dev.inmo.micro_utils.transactions
+
+typealias TransactionDSLRollbackLambda = suspend (Throwable) -> Unit
+class TransactionsDSL internal constructor() {
+    internal val rollbackActions = ArrayList<TransactionDSLRollbackLambda>()
+
+    internal fun addRollbackAction(rollbackAction: TransactionDSLRollbackLambda) {
+        rollbackActions.add(rollbackAction)
+    }
+}
+class RollbackContext<T> internal constructor (
+    val actionResult: T,
+    val error: Throwable
+)
+
+/**
+ * Calls [action] and, if it succeeded - saving [rollback] action for future usage for cases when some other
+ * action or even main one throwing an error
+ *
+ * @param rollback Will be called if
+ */
+suspend fun <T> TransactionsDSL.rollableBackOperation(
+    rollback: suspend RollbackContext<T>.() -> Unit,
+    action: suspend () -> T
+): T {
+    return runCatching { action() }
+        .onSuccess {
+            addRollbackAction { e ->
+                val context = RollbackContext(it, e)
+                context.rollback()
+            }
+        }
+        .getOrThrow()
+}
+
+/**
+ * Starts transaction with opportunity to add actions [rollableBackOperation]. How to use:
+ *
+ * ```kotlin
+ * doSuspendTransaction {
+ *     println("start of action")
+ *
+ *     withRollback({ // it - result of action
+ *         // some rollback action
+ *     }) {
+ *         // Some action with rollback
+ *     }
+ *
+ *     withRollback({
+ *          repository.delete(it) // it - result of createSomething, if it completes successfully
+ *     }) {
+ *          repository.createSomething()
+ *     }
+ *
+ *     withRollback({
+ *         // will not be triggered due to error in action
+ *     }) {
+ *         error("It is just a simple error") // Will trigger rolling back previously successfully completed actions
+ *     }
+ * }
+ * ```
+ *
+ * @param onRollbackStepError Will be called if rollback action throwing some error
+ */
+suspend fun <T> doSuspendTransaction(
+    onRollbackStepError: suspend (Throwable) -> Unit = { },
+    block: suspend TransactionsDSL.() -> T
+): Result<T> {
+    val transactionsDSL = TransactionsDSL()
+
+    return runCatching {
+        transactionsDSL.block()
+    }.onFailure { e ->
+        for (i in transactionsDSL.rollbackActions.lastIndex downTo 0) {
+            val rollbackAction = transactionsDSL.rollbackActions[i]
+            runCatching {
+                rollbackAction.invoke(e)
+            }.onFailure { ee ->
+                onRollbackStepError(ee)
+            }
+        }
+    }
+}

transactions/src/commonTest/kotlin/TransactionsDSLTests.kt

@@ -0,0 +1,93 @@
+import dev.inmo.micro_utils.transactions.doSuspendTransaction
+import dev.inmo.micro_utils.transactions.rollableBackOperation
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class TransactionsDSLTests {
+    @Test
+    fun successfulTest() = runTest {
+        val dataCollections = Array(100) {
+            Triple(
+                it, // expected data
+                false, // has rollback happen or not
+                -1 // actual data
+            )
+        }
+
+        val actionResult = doSuspendTransaction {
+            dataCollections.forEachIndexed { i, _ ->
+                val resultData = rollableBackOperation({
+                    dataCollections[i] = actionResult.copy(second = true)
+                }) {
+                    val result = dataCollections[i]
+                    dataCollections[i] = result.copy(
+                        third = i
+                    )
+                    dataCollections[i]
+                }
+                assertEquals(dataCollections[i], resultData)
+                assertTrue(dataCollections[i] === resultData)
+            }
+            true
+        }.getOrThrow()
+
+        dataCollections.forEachIndexed { i, triple ->
+            assertFalse(triple.second)
+            assertEquals(triple.first, i)
+            assertEquals(i, triple.third)
+        }
+        assertTrue(actionResult)
+    }
+    @Test
+    fun fullTest() = runTest {
+        val testsCount = 100
+        for (testNumber in 0 until testsCount) {
+            val error = IllegalStateException("Test must fail at $testNumber")
+            val dataCollections = Array(testsCount) {
+                Triple(
+                    it, // expected data
+                    false, // has rollback happen or not
+                    -1 // actual data
+                )
+            }
+
+            val actionResult = doSuspendTransaction {
+                dataCollections.forEachIndexed { i, _ ->
+                    val resultData = rollableBackOperation({
+                        assertTrue(error === this.error)
+                        dataCollections[i] = actionResult.copy(second = true)
+                    }) {
+                        if (i == testNumber) throw error
+                        val result = dataCollections[i]
+                        dataCollections[i] = result.copy(
+                            third = i
+                        )
+                        dataCollections[i]
+                    }
+                    assertEquals(dataCollections[i], resultData)
+                    assertTrue(dataCollections[i] === resultData)
+                }
+                true
+            }.getOrElse {
+                assertTrue(it === error)
+                true
+            }
+
+            dataCollections.forEachIndexed { i, triple ->
+                if (i < testNumber) {
+                    assertTrue(triple.second)
+                    assertEquals(triple.first, i)
+                    assertEquals(i, triple.third)
+                } else {
+                    assertFalse(triple.second)
+                    assertEquals(triple.first, i)
+                    assertEquals(-1, triple.third)
+                }
+            }
+            assertTrue(actionResult)
+        }
+    }
+}