new ReadOneToManyKeyValueRepo#keys

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## 0.4.0
 
+* `Repos`:
+    * `ReadOneToManyKeyValueRepo` got `keys` method with value parameter
+        * All implementations inside of this library has been updated
+
 ## 0.3.3
 
 * `Coroutines`:

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

@@ -6,6 +6,7 @@ import kotlinx.coroutines.flow.Flow
 interface ReadOneToManyKeyValueRepo<Key, Value> : Repo {
     suspend fun get(k: Key, pagination: Pagination, reversed: Boolean = false): PaginationResult<Value>
     suspend fun keys(pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
+    suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
     suspend fun contains(k: Key): Boolean
     suspend fun contains(k: Key, v: Value): Boolean
     suspend fun count(k: Key): Long

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

@@ -42,6 +42,23 @@ open class MapperReadOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
         )
     }
 
+    override suspend fun keys(
+        v: FromValue,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<FromKey> = to.keys(
+        v.toOutValue(),
+        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())
 

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

@@ -169,6 +169,33 @@ class OneToManyAndroidRepo<Key, Value>(
         )
     }
 
+    override suspend fun keys(
+        v: Value,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> = count().let { count ->
+        val resultPagination = pagination.let { if (reversed) pagination.reverse(count) else pagination }
+        helper.readableTransaction {
+            select(
+                tableName,
+                selection = "$valueColumnName=?",
+                selectionArgs = arrayOf(v.asValue()),
+                limit = resultPagination.limitClause()
+            ).use { c ->
+                mutableListOf<Key>().also {
+                    if (c.moveToFirst()) {
+                        do {
+                            it.add(c.getString(idColumnName).asKey())
+                        } while (c.moveToNext())
+                    }
+                }
+            }
+        }.createPaginationResult(
+            pagination,
+            count
+        )
+    }
+
     override suspend fun remove(toRemove: Map<Key, List<Value>>) {
         helper.writableTransaction {
             toRemove.flatMap { (k, vs) ->

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

@@ -39,6 +39,21 @@ open class ExposedReadOneToManyKeyValueRepo<Key, Value>(
         count()
     )
 
+    override suspend fun keys(
+        v: Value,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> = transaction(database) {
+        select { valueColumn.eq(v) }.let {
+            it.count() to it.paginate(pagination, keyColumn, reversed).map { it[keyColumn] }
+        }
+    }.let { (count, list) ->
+        list.createPaginationResult(
+            pagination,
+            count
+        )
+    }
+
     override suspend fun contains(k: Key): Boolean = transaction(database) {
         select { keyColumn.eq(k) }.limit(1).any()
     }

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

@@ -32,6 +32,18 @@ class MapReadOneToManyKeyValueRepo<Key, Value>(
         }
     }
 
+    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> {
+        val keys = map.keys.filter { map[it] ?.contains(v) == true }
+        val actualPagination = if (reversed) pagination.reverse(keys.size) else pagination
+        return keys.paginate(actualPagination).let {
+            if (reversed) {
+                it.copy(results = it.results.reversed())
+            } else {
+                it
+            }
+        }
+    }
+
     override suspend fun contains(k: Key): Boolean = map.containsKey(k)
 
     override suspend fun contains(k: Key, v: Value): Boolean = map[k] ?.contains(v) == true

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorReadOneToManyKeyValueRepo.kt

@@ -42,6 +42,18 @@ class KtorReadOneToManyKeyValueRepo<Key, Value> (
         paginationKeyResultSerializer
     )
 
+    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = client.uniget(
+        buildStandardUrl(
+            baseUrl,
+            keysRoute,
+            mapOf(
+                valueParameterName to valueSerializer.encodeUrlQueryValue(v),
+                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+            ) + pagination.asUrlQueryParts
+        ),
+        paginationKeyResultSerializer
+    )
+
     override suspend fun contains(k: Key): Boolean = client.uniget(
         buildStandardUrl(
             baseUrl,

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyReadKeyValueRepoRoutes.kt

@@ -42,8 +42,17 @@ fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
             reversedParameterName,
             Boolean.serializer()
         ) ?: false
+        val value: Value? = call.decodeUrlQueryValue(
+            valueParameterName,
+            valueSealizer
+        )
 
-        call.unianswer(
+        value ?.also {
+            call.unianswer(
+                paginationKeyResult,
+                originalRepo.keys(value, pagination, reversed)
+            )
+        } ?: call.unianswer(
             paginationKeyResult,
             originalRepo.keys(pagination, reversed)
         )