repos rework

2025-09-03 15:19:44 +00:00 · 2020-11-09 00:46:26 +06:00
parent 5b5bfa02db
commit abfda3627c
18 changed files with 254 additions and 233 deletions
--- a/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapperRepo.kt
+++ b/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapperRepo.kt
@@ -0,0 +1,9 @@
+package dev.inmo.micro_utils.repos
+
+interface MapperRepo<FromKey, FromValue, ToKey, ToValue> {
+    suspend fun FromKey.toOutKey() = this as ToKey
+    suspend fun FromValue.toOutValue() = this as ToValue
+
+    suspend fun ToKey.toInnerKey() = this as FromKey
+    suspend fun ToValue.toInnerValue() = this as FromValue
+}
--- a/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/OneToManyKeyValueRepo.kt
+++ b/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/OneToManyKeyValueRepo.kt
@@ -35,8 +35,6 @@ interface ReadOneToManyKeyValueRepo<Key, Value> : Repo {
        }
    }
 }
-@Deprecated("Renamed", ReplaceWith("ReadOneToManyKeyValueRepo", "dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo"))
-typealias OneToManyReadKeyValueRepo<Key, Value> = ReadOneToManyKeyValueRepo<Key, Value>

 interface WriteOneToManyKeyValueRepo<Key, Value> : Repo {
    val onNewValue: Flow<Pair<Key, Value>>
@@ -44,42 +42,44 @@ interface WriteOneToManyKeyValueRepo<Key, Value> : Repo {
    val onDataCleared: Flow<Key>

    suspend fun add(toAdd: Map<Key, List<Value>>)
-    @Deprecated("Will be extracted as extension for other add method")
-    suspend fun add(k: Key, v: Value) = add(mapOf(k to listOf(v)))

    suspend fun remove(toRemove: Map<Key, List<Value>>)
-    @Deprecated("Will be extracted as extension for other remove method")
-    suspend fun remove(k: Key, v: Value) = remove(mapOf(k to listOf(v)))

    suspend fun clear(k: Key)
 }
-@Deprecated("Renamed", ReplaceWith("WriteOneToManyKeyValueRepo", "dev.inmo.micro_utils.repos.WriteOneToManyKeyValueRepo"))
-typealias OneToManyWriteKeyValueRepo<Key, Value> = WriteOneToManyKeyValueRepo<Key, Value>
+
+suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
+    keysAndValues: List<Pair<Key, List<Value>>>
+) = add(keysAndValues.toMap())
+
+suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
+    vararg keysAndValues: Pair<Key, List<Value>>
+) = add(keysAndValues.toMap())
+
+suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.add(
+    k: Key, v: List<Value>
+) = add(mapOf(k to v))
+
+suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.add(
+    k: Key, vararg v: Value
+) = add(k, v.toList())

 interface OneToManyKeyValueRepo<Key, Value> : ReadOneToManyKeyValueRepo<Key, Value>, WriteOneToManyKeyValueRepo<Key, Value>

-suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
-    k: Key,
-    vararg v: Value
-) = add(mapOf(k to v.toList()))
-
-suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
-    keysAndValues: List<Pair<Key, List<Value>>>
-) = add(keysAndValues.toMap())
-
-suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
-    vararg keysAndValues: Pair<Key, List<Value>>
-) = add(keysAndValues.toMap())
-
-suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.remove(
-    k: Key,
-    vararg v: Value
-) = remove(mapOf(k to v.toList()))
-
-suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.remove(
+suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
    keysAndValues: List<Pair<Key, List<Value>>>
 ) = remove(keysAndValues.toMap())

-suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.remove(
+suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
    vararg keysAndValues: Pair<Key, List<Value>>
 ) = remove(keysAndValues.toMap())
+
+suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
+    k: Key,
+    v: List<Value>
+) = remove(mapOf(k to v))
+
+suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
+    k: Key,
+    vararg v: Value
+) = remove(k, v.toList())
--- a/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/StandartKeyValueRepo.kt
+++ b/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/StandartKeyValueRepo.kt
@@ -16,16 +16,20 @@ interface WriteStandardKeyValueRepo<Key, Value> : Repo {
    val onNewValue: Flow<Pair<Key, Value>>
    val onValueRemoved: Flow<Key>

-    @Deprecated("Realize set with map instead")
-    suspend fun set(k: Key, v: Value)
-    suspend fun set(toSet: Map<Key, Value>) = toSet.forEach { (k, v) ->
-        set(k, v)
-    }
-    @Deprecated("Realize unset with list instead")
-    suspend fun unset(k: Key)
-    suspend fun unset(toUnset: List<Key>) = toUnset.forEach {
-        unset(it)
-    }
+    suspend fun set(toSet: Map<Key, Value>)
+    suspend fun unset(toUnset: List<Key>)
 }

+suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.set(
+    vararg toSet: Pair<Key, Value>
+) = set(toSet.toMap())
+
+suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.set(
+    k: Key, v: Value
+) = set(k to v)
+
+suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.unset(
+    vararg k: Key
+) = unset(k.toList())
+
 interface StandardKeyValueRepo<Key, Value> : ReadStandardKeyValueRepo<Key, Value>, WriteStandardKeyValueRepo<Key, Value>
--- a/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/KeyValueMappers.kt
+++ b/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/KeyValueMappers.kt
@@ -0,0 +1,84 @@
+package dev.inmo.micro_utils.repos.mappers
+
+import dev.inmo.micro_utils.pagination.Pagination
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.repos.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+open class MapperReadStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: ReadStandardKeyValueRepo<ToKey, ToValue>,
+    mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
+) : ReadStandardKeyValueRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
+    override suspend fun get(k: FromKey): FromValue? = to.get(
+        k.toOutKey()
+    ) ?.toInnerValue()
+
+    override suspend fun values(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<FromValue> = to.values(
+        pagination,
+        reversed
+    ).let {
+        PaginationResult(
+            it.page,
+            it.pagesNumber,
+            it.results.map { it.toInnerValue() },
+            it.size
+        )
+    }
+
+    override suspend fun keys(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<FromKey> = to.keys(
+        pagination,
+        reversed
+    ).let {
+        PaginationResult(
+            it.page,
+            it.pagesNumber,
+            it.results.map { it.toInnerKey() },
+            it.size
+        )
+    }
+
+    override suspend fun contains(key: FromKey): Boolean = to.contains(
+        key.toOutKey()
+    )
+
+    override suspend fun count(): Long = to.count()
+}
+
+open class MapperWriteStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: WriteStandardKeyValueRepo<ToKey, ToValue>,
+    mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
+) : WriteStandardKeyValueRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
+    override val onNewValue: Flow<Pair<FromKey, FromValue>> = to.onNewValue.map { (k, v) ->
+        k.toInnerKey() to v.toInnerValue()
+    }
+    override val onValueRemoved: Flow<FromKey> = to.onValueRemoved.map { k ->
+        k.toInnerKey()
+    }
+
+    override suspend fun set(toSet: Map<FromKey, FromValue>) = to.set(
+        toSet.map { (k, v) ->
+            k.toOutKey() to v.toOutValue()
+        }.toMap()
+    )
+
+    override suspend fun unset(toUnset: List<FromKey>) = to.unset(
+        toUnset.map { k ->
+            k.toOutKey()
+        }
+    )
+}
+
+open class MapperStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: StandardKeyValueRepo<ToKey, ToValue>,
+    mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
+) : StandardKeyValueRepo<FromKey, FromValue>,
+    MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper,
+    ReadStandardKeyValueRepo<FromKey, FromValue> by MapperReadStandardKeyValueRepo(to, mapper),
+    WriteStandardKeyValueRepo<FromKey, FromValue> by MapperWriteStandardKeyValueRepo(to, mapper)
--- a/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/OneToManyKeyValueMappers.kt
+++ b/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/OneToManyKeyValueMappers.kt
@@ -0,0 +1,87 @@
+package dev.inmo.micro_utils.repos.mappers
+
+import dev.inmo.micro_utils.pagination.Pagination
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.repos.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+open class MapperReadOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: ReadOneToManyKeyValueRepo<ToKey, ToValue>,
+    mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
+) : ReadOneToManyKeyValueRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
+    override suspend fun get(
+        k: FromKey,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<FromValue> = to.get(
+        k.toOutKey(),
+        pagination,
+        reversed
+    ).let {
+        PaginationResult(
+            it.page,
+            it.pagesNumber,
+            it.results.map { it.toInnerValue() },
+            it.size
+        )
+    }
+
+    override suspend fun keys(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<FromKey> = to.keys(
+        pagination,
+        reversed
+    ).let {
+        PaginationResult(
+            it.page,
+            it.pagesNumber,
+            it.results.map { it.toInnerKey() },
+            it.size
+        )
+    }
+
+    override suspend fun contains(k: FromKey): Boolean = to.contains(k.toOutKey())
+    override suspend fun contains(k: FromKey, v: FromValue): Boolean = to.contains(k.toOutKey(), v.toOutValue())
+
+    override suspend fun count(): Long = to.count()
+    override suspend fun count(k: FromKey): Long = to.count(k.toOutKey())
+}
+
+open class MapperWriteOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: WriteOneToManyKeyValueRepo<ToKey, ToValue>,
+    mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
+) : WriteOneToManyKeyValueRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
+    override val onNewValue: Flow<Pair<FromKey, FromValue>> = to.onNewValue.map { (k, v) ->
+        k.toInnerKey() to v.toInnerValue()
+    }
+    override val onValueRemoved: Flow<Pair<FromKey, FromValue>> = to.onValueRemoved.map { (k, v) ->
+        k.toInnerKey() to v.toInnerValue()
+    }
+    override val onDataCleared: Flow<FromKey> = to.onDataCleared.map { k ->
+        k.toInnerKey()
+    }
+
+    override suspend fun add(toAdd: Map<FromKey, List<FromValue>>) = to.add(
+        toAdd.map { (k, v) ->
+            k.toOutKey() to v.map { it.toOutValue() }
+        }.toMap()
+    )
+
+    override suspend fun remove(toRemove: Map<FromKey, List<FromValue>>) = to.remove(
+        toRemove.map { (k, v) ->
+            k.toOutKey() to v.map { it.toOutValue() }
+        }.toMap()
+    )
+
+    override suspend fun clear(k: FromKey) = to.clear(k.toOutKey())
+}
+
+open class MapperOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: OneToManyKeyValueRepo<ToKey, ToValue>,
+    mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
+) : OneToManyKeyValueRepo<FromKey, FromValue>,
+    MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper,
+    ReadOneToManyKeyValueRepo<FromKey, FromValue> by MapperReadOneToManyKeyValueRepo(to, mapper),
+    WriteOneToManyKeyValueRepo<FromKey, FromValue> by MapperWriteOneToManyKeyValueRepo(to, mapper)
--- a/repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/ExposedKeyValueRepo.kt
+++ b/repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/ExposedKeyValueRepo.kt
@@ -24,22 +24,6 @@ open class ExposedKeyValueRepo<Key, Value>(
    override val onNewValue: Flow<Pair<Key, Value>> = _onNewValue.asSharedFlow()
    override val onValueRemoved: Flow<Key> = _onValueRemoved.asSharedFlow()

-    override suspend fun set(k: Key, v: Value) {
-        transaction(database) {
-            if (select { keyColumn.eq(k) }.limit(1).any()) {
-                update({ keyColumn.eq(k) }) {
-                    it[valueColumn] = v
-                }
-            } else {
-                insert {
-                    it[keyColumn] = k
-                    it[valueColumn] = v
-                }
-            }
-        }
-        _onNewValue.emit(k to v)
-    }
-
    override suspend fun set(toSet: Map<Key, Value>) {
        transaction(database) {
            toSet.mapNotNull { (k, v) ->
@@ -62,13 +46,6 @@ open class ExposedKeyValueRepo<Key, Value>(
        }
    }

-    override suspend fun unset(k: Key) {
-        transaction(database) {
-            deleteWhere { keyColumn.eq(k) }
-        }
-        _onValueRemoved.emit(k)
-    }
-
    override suspend fun unset(toUnset: List<Key>) {
        transaction(database) {
            toUnset.mapNotNull {
@@ -83,6 +60,3 @@ open class ExposedKeyValueRepo<Key, Value>(
        }
    }
 }
-
-@Deprecated("Renamed", ReplaceWith("ExposedKeyValueRepo", "dev.inmo.micro_utils.repos.exposed.keyvalue.ExposedKeyValueRepo"))
-typealias AbstractExposedKeyValueRepo<Key, Value> = ExposedKeyValueRepo<Key, Value>
--- a/repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/ExposedReadKeyValueRepo.kt
+++ b/repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/ExposedReadKeyValueRepo.kt
@@ -39,6 +39,3 @@ open class ExposedReadKeyValueRepo<Key, Value>(
        }
    }.createPaginationResult(pagination, count())
 }
-
-@Deprecated("Renamed", ReplaceWith("ExposedReadKeyValueRepo", "dev.inmo.micro_utils.repos.exposed.keyvalue.ExposedReadKeyValueRepo"))
-typealias AbstractExposedReadKeyValueRepo<Key, Value> = ExposedReadKeyValueRepo<Key, Value>
--- a/repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/ExposedOneToManyKeyValueRepo.kt
+++ b/repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/ExposedOneToManyKeyValueRepo.kt
@@ -1,6 +1,5 @@
 package dev.inmo.micro_utils.repos.exposed.onetomany

-import dev.inmo.micro_utils.coroutines.BroadcastFlow
 import dev.inmo.micro_utils.repos.OneToManyKeyValueRepo
 import dev.inmo.micro_utils.repos.exposed.ColumnAllocator
 import kotlinx.coroutines.flow.*
@@ -28,15 +27,6 @@ open class ExposedOneToManyKeyValueRepo<Key, Value>(
    override val onDataCleared: Flow<Key>
        get() = _onDataCleared

-    override suspend fun add(k: Key, v: Value) {
-        transaction(database) {
-            insert {
-                it[keyColumn] = k
-                it[valueColumn] = v
-            }
-        }.also { _onNewValue.emit(k to v) }
-    }
-
    override suspend fun add(toAdd: Map<Key, List<Value>>) {
        transaction(database) {
            toAdd.keys.flatMap { k ->
@@ -72,9 +62,3 @@ open class ExposedOneToManyKeyValueRepo<Key, Value>(
        }.also { _onDataCleared.emit(k) }
    }
 }
-
-@Deprecated("Renamed", ReplaceWith("ExposedOneToManyKeyValueRepo", "dev.inmo.micro_utils.repos.exposed.onetomany.ExposedOneToManyKeyValueRepo"))
-typealias AbstractOneToManyExposedKeyValueRepo<Key, Value> = ExposedOneToManyKeyValueRepo<Key, Value>
-
-@Deprecated("Renamed", ReplaceWith("ExposedOneToManyKeyValueRepo", "dev.inmo.micro_utils.repos.exposed.onetomany.ExposedOneToManyKeyValueRepo"))
-typealias AbstractExposedOneToManyKeyValueRepo<Key, Value> = ExposedOneToManyKeyValueRepo<Key, Value>
--- a/repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/ExposedReadOneToManyKeyValueRepo.kt
+++ b/repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/ExposedReadOneToManyKeyValueRepo.kt
@@ -47,9 +47,3 @@ open class ExposedReadOneToManyKeyValueRepo<Key, Value>(
        select { keyColumn.eq(k).and(valueColumn.eq(v)) }.limit(1).any()
    }
 }
-
-@Deprecated("Renamed", ReplaceWith("ExposedReadOneToManyKeyValueRepo", "dev.inmo.micro_utils.repos.exposed.onetomany.ExposedReadOneToManyKeyValueRepo"))
-typealias AbstractOneToManyExposedReadKeyValueRepo<Key, Value> = ExposedReadOneToManyKeyValueRepo<Key, Value>
-
-@Deprecated("Renamed", ReplaceWith("ExposedReadOneToManyKeyValueRepo", "dev.inmo.micro_utils.repos.exposed.onetomany.ExposedReadOneToManyKeyValueRepo"))
-typealias AbstractExposedReadOneToManyKeyValueRepo<Key, Value> = ExposedReadOneToManyKeyValueRepo<Key, Value>
--- a/repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapKeyValueRepo.kt
+++ b/repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapKeyValueRepo.kt
@@ -1,6 +1,5 @@
 package dev.inmo.micro_utils.repos

-import dev.inmo.micro_utils.coroutines.BroadcastFlow
 import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.utils.paginate
@@ -55,20 +54,11 @@ class WriteMapKeyValueRepo<Key, Value>(
    override val onValueRemoved: Flow<Key>
        get() = _onValueRemoved

-    override suspend fun set(k: Key, v: Value) {
-        map[k] = v
-        _onNewValue.emit(k to v)
-    }
-
    override suspend fun set(toSet: Map<Key, Value>) {
        map.putAll(toSet)
        toSet.forEach { (k, v) -> _onNewValue.emit(k to v) }
    }

-    override suspend fun unset(k: Key) {
-        map.remove(k) ?.also { _onValueRemoved.emit(k) }
-    }
-
    override suspend fun unset(toUnset: List<Key>) {
        toUnset.forEach { k ->
            map.remove(k) ?.also { _ -> _onValueRemoved.emit(k) }
--- a/repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapOneToManyKeyValueRepo.kt
+++ b/repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapOneToManyKeyValueRepo.kt
@@ -5,6 +5,7 @@ import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.paginate
 import dev.inmo.micro_utils.pagination.utils.reverse
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow

 class MapReadOneToManyKeyValueRepo<Key, Value>(
    private val map: Map<Key, List<Value>> = emptyMap()
@@ -45,32 +46,38 @@ class MapReadOneToManyKeyValueRepo<Key, Value>(
 class MapWriteOneToManyKeyValueRepo<Key, Value>(
    private val map: MutableMap<Key, MutableList<Value>> = mutableMapOf()
 ) : WriteOneToManyKeyValueRepo<Key, Value> {
-    private val _onNewValue: BroadcastFlow<Pair<Key, Value>> = BroadcastFlow()
+    private val _onNewValue: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
    override val onNewValue: Flow<Pair<Key, Value>>
        get() = _onNewValue
-    private val _onValueRemoved: BroadcastFlow<Pair<Key, Value>> = BroadcastFlow()
+    private val _onValueRemoved: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
    override val onValueRemoved: Flow<Pair<Key, Value>>
        get() = _onValueRemoved
-    private val _onDataCleared: BroadcastFlow<Key> = BroadcastFlow()
+    private val _onDataCleared: MutableSharedFlow<Key> = MutableSharedFlow()
    override val onDataCleared: Flow<Key>
        get() = _onDataCleared

    override suspend fun add(toAdd: Map<Key, List<Value>>) {
-        toAdd.keys.forEach {
-            map.getOrPut(it) {
-                mutableListOf()
-            }.addAll(toAdd[it] ?: return@forEach)
+        toAdd.keys.forEach { k ->
+            if (map.getOrPut(k) { mutableListOf() }.addAll(toAdd[k] ?: return@forEach)) {
+                toAdd[k] ?.forEach { v ->
+                    _onNewValue.emit(k to v)
+                }
+            }
        }
    }

    override suspend fun remove(toRemove: Map<Key, List<Value>>) {
-        toRemove.keys.forEach {
-            map[it] ?.removeAll(toRemove[it] ?: return@forEach)
+        toRemove.keys.forEach { k ->
+            if (map[k] ?.removeAll(toRemove[k] ?: return@forEach) == true) {
+                toRemove[k] ?.forEach { v ->
+                    _onValueRemoved.emit(k to v)
+                }
+            }
        }
    }

    override suspend fun clear(k: Key) {
-        map.remove(k) ?.also { _onDataCleared.send(k) }
+        map.remove(k) ?.also { _onDataCleared.emit(k) }
    }
 }

--- a/repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorReadStandardKeyValueRepo.kt
+++ b/repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorReadStandardKeyValueRepo.kt
@@ -69,6 +69,3 @@ class KtorReadStandardKeyValueRepo<Key, Value> (
        Long.serializer()
    )
 }
-
-@Deprecated("Renamed", ReplaceWith("KtorReadStandardKeyValueRepo", "dev.inmo.micro_utils.repos.ktor.client.key_value.KtorReadStandardKeyValueRepo"))
-typealias KtorStandartReadKeyValueRepo<Key, Value> = KtorReadStandardKeyValueRepo<Key, Value>
--- a/repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorWriteStandardKeyValueRepo.kt
+++ b/repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorWriteStandardKeyValueRepo.kt
@@ -35,7 +35,6 @@ class KtorWriteStandardKeyValueRepo<K, V> (
        BodyPair(keyValueMapSerializer, toSet),
        Unit.serializer()
    )
-    override suspend fun set(k: K, v: V) = set(mapOf(k to v))

    override suspend fun unset(toUnset: List<K>) = client.unipost(
        buildStandardUrl(
@@ -45,8 +44,4 @@ class KtorWriteStandardKeyValueRepo<K, V> (
        BodyPair(keysListSerializer, toUnset),
        Unit.serializer()
    )
-    override suspend fun unset(k: K) = unset(listOf(k))
 }
-
-@Deprecated("Renamed", ReplaceWith("KtorWriteStandardKeyValueRepo", "dev.inmo.micro_utils.repos.ktor.client.key_value.KtorWriteStandardKeyValueRepo"))
-typealias KtorStandartWriteKeyValueRepo<K, V> = KtorWriteStandardKeyValueRepo<K, V>
--- a/repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorWriteOneToManyKeyValueRepo.kt
+++ b/repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorWriteOneToManyKeyValueRepo.kt
@@ -30,15 +30,6 @@ class KtorWriteOneToManyKeyValueRepo<Key, Value> (
        deserializer = keySerializer
    )

-    override suspend fun add(k: Key, v: Value) = client.unipost(
-        buildStandardUrl(
-            baseUrl,
-            addRoute,
-        ),
-        BodyPair(keyValueSerializer, k to v),
-        Unit.serializer(),
-    )
-
    override suspend fun remove(toRemove: Map<Key, List<Value>>) = client.unipost(
        buildStandardUrl(
            baseUrl,