Update CHANGELOG.md

0.12.7

CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## 0.12.8
+
+* `Versions`:
+    * `Ktor`: `2.1.0` -> `2.1.1`
+    * `Compose`: `1.2.0-alpha01-dev764` -> `1.2.0-alpha01-dev774`
+* `Ktor`:
+  * `Client`:
+    * New extension `HttpClient#bodyOrNull` which returns `null` in case when server responded with `No Content` (204)
+  * `Server`:
+    * New extension `ApplicationCall#respondOrNoContent` which responds `No Content` (204) when passed data is null
+
+## 0.12.7
+
+* `Repos`:
+  * `Cache`:
+    * Force `WriteCRUDCacheRepo` to subscribe on new and updated objects of parent repo
+* `Pagination`:
+  * New function `changeResultsUnchecked(Pagination)`
+
+## 0.12.6
+
+* `MimeeTypes>`:
+  * Fixed absence of `image/*` in known mime types
+
+## 0.12.5
+
+* `Repos`:
+  * `Exposed`:
+    * Fixes in `paginate` extensions
+
+## 0.12.4
+
+* `Versions`:
+    * `Kotlin`: `1.7.0` -> `1.7.10`
+    * `Compose`: `1.2.0-alpha01-dev755` -> `1.2.0-alpha01-dev764`
+
+## 0.12.3
+
+* `Repos`:
+  * `Exposed`:
+    * Add abstract exposed variants of `KeyValue` and `KeyValues` repos
+    * Add new extension `Query#selectPaginated`
+
 ## 0.12.2
 
 * `Versions`:

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.12.2
-android_code_version=141
+version=0.12.8
+android_code_version=147

gradle/libs.versions.toml

@@ -1,17 +1,17 @@
 [versions]
 
-kt = "1.7.0"
+kt = "1.7.10"
 kt-serialization = "1.4.0"
 kt-coroutines = "1.6.4"
 
-jb-compose = "1.2.0-alpha01-dev755"
+jb-compose = "1.2.0-alpha01-dev774"
 jb-exposed = "0.39.2"
-jb-dokka = "1.7.0"
+jb-dokka = "1.7.10"
 
 klock = "3.0.0"
 uuid = "0.5.0"
 
-ktor = "2.1.0"
+ktor = "2.1.1"
 
 gh-release = "2.4.1"
 

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

@@ -0,0 +1,9 @@
+package dev.inmo.micro_utils.ktor.client
+
+import io.ktor.client.call.body
+import io.ktor.client.statement.HttpResponse
+import io.ktor.http.HttpStatusCode
+
+suspend inline fun <reified T : Any> HttpResponse.bodyOrNull() = takeIf {
+    status == HttpStatusCode.OK
+} ?.body<T>()

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

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.ktor.server
+
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.application.ApplicationCall
+import io.ktor.server.response.respond
+
+suspend inline fun <reified T : Any> ApplicationCall.respondOrNoContent(
+    data: T?
+) {
+    if (data == null) {
+        respond(HttpStatusCode.NoContent)
+    } else {
+        respond(data)
+    }
+}

mime_types/src/commonMain/kotlin/dev/inmo/micro_utils/mime_types/KnownMimeTypes.kt

@@ -2017,6 +2017,7 @@ internal val knownMimeTypes: Set<MimeType> = setOf(
     KnownMimeTypes.Chemical.XCml,
     KnownMimeTypes.Chemical.XCsml,
     KnownMimeTypes.Chemical.XXyz,
+    KnownMimeTypes.Image.Any,
     KnownMimeTypes.Image.Bmp,
     KnownMimeTypes.Image.Cgm,
     KnownMimeTypes.Image.G3fax,

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

@@ -48,6 +48,14 @@ data class PaginationResult<T>(
 }
 
 fun <T> emptyPaginationResult() = PaginationResult<T>(0, 0, emptyList(), 0L)
+fun <T> emptyPaginationResult(
+    basePagination: Pagination
+) = PaginationResult<T>(
+    basePagination.page,
+    basePagination.size,
+    emptyList(),
+    0L
+)
 
 /**
  * @return New [PaginationResult] with [data] without checking of data sizes equality

pagination/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/pagination/QueryExtensions.kt

@@ -4,11 +4,7 @@ import org.jetbrains.exposed.sql.*
 
 fun Query.paginate(with: Pagination, orderBy: Pair<Expression<*>, SortOrder>? = null) = limit(
     with.size,
-    (if (orderBy ?.second == SortOrder.DESC) {
-        with.lastIndex
-    } else {
-        with.firstIndex
-    }).toLong()
+    with.firstIndex.toLong()
 ).let {
     if (orderBy != null) {
         it.orderBy(

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

@@ -33,6 +33,14 @@ open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>(
     override val updatedObjectsFlow: Flow<ObjectType> by parentRepo::updatedObjectsFlow
     override val deletedObjectsIdsFlow: Flow<IdType> by parentRepo::deletedObjectsIdsFlow
 
+    val createdObjectsFlowJob = parentRepo.newObjectsFlow.onEach {
+        kvCache.set(idGetter(it), it)
+    }.launchIn(scope)
+
+    val updatedObjectsFlowJob = parentRepo.updatedObjectsFlow.onEach {
+        kvCache.set(idGetter(it), it)
+    }.launchIn(scope)
+
     val deletedObjectsFlowJob = parentRepo.deletedObjectsIdsFlow.onEach {
         kvCache.unset(it)
     }.launchIn(scope)

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

@@ -26,7 +26,6 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
     override val deletedObjectsIdsFlow: Flow<IdType> = _deletedObjectsIdsFlow.asSharedFlow()
 
     protected abstract fun InsertStatement<Number>.asObject(value: InputValueType): ObjectType
-    abstract val selectByIds: SqlExpressionBuilder.(List<IdType>) -> Op<Boolean>
 
     protected abstract fun insert(value: InputValueType, it: InsertStatement<Number>)
     protected abstract fun update(id: IdType, value: InputValueType, it: UpdateStatement)

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

@@ -0,0 +1,20 @@
+package dev.inmo.micro_utils.repos.exposed
+
+import org.jetbrains.exposed.sql.*
+
+interface CommonExposedRepo<IdType, ObjectType> : ExposedRepo {
+    val ResultRow.asObject: ObjectType
+    val selectById: SqlExpressionBuilder.(IdType) -> Op<Boolean>
+    val selectByIds: SqlExpressionBuilder.(List<IdType>) -> Op<Boolean>
+        get() = { list ->
+            if (list.isEmpty()) {
+                Op.FALSE
+            } else {
+                var op = selectById(list.first())
+                (1 until list.size).forEach {
+                    op = op.or(selectById(list[it]))
+                }
+                op
+            }
+        }
+}

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

@@ -2,7 +2,4 @@ package dev.inmo.micro_utils.repos.exposed
 
 import org.jetbrains.exposed.sql.*
 
-interface ExposedCRUDRepo<ObjectType, IdType> : ExposedRepo {
-    val ResultRow.asObject: ObjectType
-    val selectById: SqlExpressionBuilder.(IdType) -> Op<Boolean>
-}
+interface ExposedCRUDRepo<ObjectType, IdType> : CommonExposedRepo<IdType, ObjectType>

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/AbstractExposedKeyValueRepo.kt

@@ -0,0 +1,72 @@
+package dev.inmo.micro_utils.repos.exposed.keyvalue
+
+import dev.inmo.micro_utils.repos.KeyValueRepo
+import kotlinx.coroutines.flow.*
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.statements.InsertStatement
+import org.jetbrains.exposed.sql.statements.UpdateStatement
+import org.jetbrains.exposed.sql.transactions.transaction
+
+abstract class AbstractExposedKeyValueRepo<Key, Value>(
+    override val database: Database,
+    tableName: String? = null
+) : KeyValueRepo<Key, Value>, AbstractExposedReadKeyValueRepo<Key, Value>(
+    database,
+    tableName
+) {
+    protected val _onNewValue = MutableSharedFlow<Pair<Key, Value>>()
+    protected val _onValueRemoved = MutableSharedFlow<Key>()
+
+    override val onNewValue: Flow<Pair<Key, Value>> = _onNewValue.asSharedFlow()
+    override val onValueRemoved: Flow<Key> = _onValueRemoved.asSharedFlow()
+
+    protected abstract fun update(k: Key, v: Value, it: UpdateStatement)
+    protected abstract fun insert(k: Key, v: Value, it: InsertStatement<Number>)
+
+    override suspend fun set(toSet: Map<Key, Value>) {
+        transaction(database) {
+            toSet.mapNotNull { (k, v) ->
+                if (update({ selectById(k) }) { update(k, v, it) } > 0) {
+                    k to v
+                } else {
+                    val inserted = insert {
+                        insert(k, v, it)
+                    }.getOrNull(keyColumn) != null
+                    if (inserted) {
+                        k to v
+                    } else {
+                        null
+                    }
+                }
+            }
+        }.forEach {
+            _onNewValue.emit(it)
+        }
+    }
+
+    override suspend fun unset(toUnset: List<Key>) {
+        transaction(database) {
+            toUnset.mapNotNull {
+                if (deleteWhere { selectById(it) } > 0) {
+                    it
+                } else {
+                    null
+                }
+            }
+        }.forEach {
+            _onValueRemoved.emit(it)
+        }
+    }
+
+    override suspend fun unsetWithValues(toUnset: List<Value>) {
+        transaction(database) {
+            toUnset.flatMap {
+                val keys = select { selectByValue(it) }.mapNotNull { it.asKey }
+                deleteWhere { selectByIds(keys) }
+                keys
+            }
+        }.distinct().forEach {
+            _onValueRemoved.emit(it)
+        }
+    }
+}

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/AbstractExposedReadKeyValueRepo.kt

@@ -0,0 +1,60 @@
+package dev.inmo.micro_utils.repos.exposed.keyvalue
+
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
+import dev.inmo.micro_utils.repos.exposed.*
+import dev.inmo.micro_utils.repos.exposed.utils.selectPaginated
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.transactions.transaction
+
+abstract class AbstractExposedReadKeyValueRepo<Key, Value>(
+    override val database: Database,
+    tableName: String? = null
+) : ReadKeyValueRepo<Key, Value>,
+    CommonExposedRepo<Key, Value>,
+    Table(tableName ?: "") {
+    abstract val keyColumn: Column<*>
+    abstract val ResultRow.asKey: Key
+    abstract val selectByValue: SqlExpressionBuilder.(Value) -> Op<Boolean>
+
+    override suspend fun get(k: Key): Value? = transaction(database) {
+        select { selectById(k) }.limit(1).firstOrNull() ?.asObject
+    }
+
+    override suspend fun contains(key: Key): Boolean = transaction(database) {
+        select { selectById(key) }.limit(1).any()
+    }
+
+    override suspend fun count(): Long = transaction(database) { selectAll().count() }
+
+    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = transaction(database) {
+        selectAll().selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asKey
+        }
+    }
+
+    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = transaction(database) {
+        select { selectByValue(v) }.selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asKey
+        }
+    }
+
+    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = transaction(database) {
+        selectAll().selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asObject
+        }
+    }
+}

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/ExposedReadKeyValueRepo.kt

@@ -3,6 +3,7 @@ package dev.inmo.micro_utils.repos.exposed.keyvalue
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 import dev.inmo.micro_utils.repos.exposed.*
+import dev.inmo.micro_utils.repos.exposed.utils.selectPaginated
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.transactions.transaction
 
@@ -29,24 +30,32 @@ open class ExposedReadKeyValueRepo<Key, Value>(
     override suspend fun count(): Long = transaction(database) { selectAll().count() }
 
     override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = transaction(database) {
-        selectAll().paginate(pagination, keyColumn to if (reversed) SortOrder.DESC else SortOrder.ASC).map {
+        selectAll().selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
             it[keyColumn]
         }
-    }.createPaginationResult(pagination, 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 to if (reversed) SortOrder.DESC else SortOrder.ASC).map {
-                it[keyColumn]
-            }
+        select { valueColumn.eq(v) }.selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it[keyColumn]
         }
-    }.let { (count, list) ->
-        list.createPaginationResult(pagination, count)
     }
 
     override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = transaction(database) {
-        selectAll().paginate(pagination, keyColumn to if (reversed) SortOrder.DESC else SortOrder.ASC).map {
+        selectAll().selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
             it[valueColumn]
         }
-    }.createPaginationResult(pagination, count())
+    }
 }

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

@@ -0,0 +1,69 @@
+package dev.inmo.micro_utils.repos.exposed.onetomany
+
+import dev.inmo.micro_utils.repos.KeyValuesRepo
+import kotlinx.coroutines.flow.*
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.statements.InsertStatement
+import org.jetbrains.exposed.sql.transactions.transaction
+
+abstract class AbstractExposedKeyValuesRepo<Key, Value>(
+    override val database: Database,
+    tableName: String? = null
+) : KeyValuesRepo<Key, Value>, AbstractExposedReadKeyValuesRepo<Key, Value>(
+    database,
+    tableName
+) {
+    protected val _onNewValue: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
+    override val onNewValue: Flow<Pair<Key, Value>>
+        get() = _onNewValue.asSharedFlow()
+    protected val _onValueRemoved: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
+    override val onValueRemoved: Flow<Pair<Key, Value>>
+        get() = _onValueRemoved.asSharedFlow()
+    protected val _onDataCleared: MutableSharedFlow<Key> = MutableSharedFlow()
+    override val onDataCleared: Flow<Key>
+        get() = _onDataCleared.asSharedFlow()
+
+    protected abstract fun insert(k: Key, v: Value, it: InsertStatement<Number>)
+
+    override suspend fun add(toAdd: Map<Key, List<Value>>) {
+        transaction(database) {
+            toAdd.keys.flatMap { k ->
+                toAdd[k] ?.mapNotNull { v ->
+                    if (select { selectById(k).and(selectByValue(v)) }.limit(1).any()) {
+                        return@mapNotNull null
+                    }
+                    val insertResult = insert {
+                        insert(k, v, it)
+                    }
+                    if (insertResult.insertedCount > 0) {
+                        k to v
+                    } else {
+                        null
+                    }
+                } ?: emptyList()
+            }
+        }.forEach { _onNewValue.emit(it) }
+    }
+
+    override suspend fun remove(toRemove: Map<Key, List<Value>>) {
+        transaction(database) {
+            toRemove.keys.flatMap { k ->
+                toRemove[k] ?.mapNotNull { v ->
+                    if (deleteWhere { selectById(k).and(selectByValue(v)) } > 0 ) {
+                        k to v
+                    } else {
+                        null
+                    }
+                } ?: emptyList()
+            }
+        }.forEach {
+            _onValueRemoved.emit(it)
+        }
+    }
+
+    override suspend fun clear(k: Key) {
+        transaction(database) {
+            deleteWhere { selectById(k) }
+        }.also { _onDataCleared.emit(k) }
+    }
+}

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

@@ -0,0 +1,74 @@
+package dev.inmo.micro_utils.repos.exposed.onetomany
+
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
+import dev.inmo.micro_utils.repos.exposed.*
+import dev.inmo.micro_utils.repos.exposed.utils.selectPaginated
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.transactions.transaction
+
+abstract class AbstractExposedReadKeyValuesRepo<Key, Value>(
+    override val database: Database,
+    tableName: String? = null
+) : ReadKeyValuesRepo<Key, Value>,
+    CommonExposedRepo<Key, Value>,
+    Table(tableName ?: "") {
+    abstract val keyColumn: Column<*>
+    abstract val ResultRow.asKey: Key
+    abstract val selectByValue: SqlExpressionBuilder.(Value) -> Op<Boolean>
+
+    override suspend fun count(k: Key): Long = transaction(database) { select { selectById(k) }.count() }
+
+    override suspend fun count(): Long = transaction(database) { selectAll().count() }
+
+    override suspend fun get(
+        k: Key,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Value> = transaction(database) {
+        select { selectById(k) }.selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asObject
+        }
+    }
+
+    override suspend fun keys(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> = transaction(database) {
+        selectAll().selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asKey
+        }
+    }
+
+    override suspend fun keys(
+        v: Value,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> = transaction(database) {
+        select { selectByValue(v) }.selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asKey
+        }
+    }
+
+    override suspend fun contains(k: Key): Boolean = transaction(database) {
+        select { selectById(k) }.limit(1).any()
+    }
+
+    override suspend fun contains(k: Key, v: Value): Boolean = transaction(database) {
+        select { selectById(k).and(selectByValue(v)) }.limit(1).any()
+    }
+}

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/utils/PaginatedSelect.kt

@@ -0,0 +1,21 @@
+package dev.inmo.micro_utils.repos.exposed.utils
+
+import dev.inmo.micro_utils.pagination.*
+import org.jetbrains.exposed.sql.*
+
+fun <T> Query.selectPaginated(
+    pagination: Pagination,
+    orderBy: Pair<Expression<*>, SortOrder>? = null,
+    createResult: (ResultRow) -> T
+): PaginationResult<T> {
+    val count = count()
+    val list = paginate(pagination, orderBy).map(createResult)
+    return list.createPaginationResult(pagination, count)
+}
+
+fun <T> Query.selectPaginated(
+    pagination: Pagination,
+    orderBy: Expression<*>?,
+    reversed: Boolean = false,
+    createResult: (ResultRow) -> T
+) = selectPaginated(pagination, orderBy ?.let { it to if (reversed) SortOrder.DESC else SortOrder.ASC }, createResult)