Move instantiation to top-level functions. Use Lettuce's coroutines i…

…mplementation. Extract default GetNameStrategy to DefaultGetNameStrategy. Update README.md with more details and new instantiation.
dave08 · Feb 18, 2024 · 2d38124 · 2d38124
1 parent 3b0042c
commit 2d38124
Show file tree

Hide file tree

Showing 10 changed files with 105 additions and 65 deletions.
diff --git a/README.md b/README.md
@@ -4,7 +4,7 @@
 > This library is still experimental and actively being developed, it may change until it is released. For now, it's just released as snapshots on Jitpack.io.
 
 > [!NOTE]
-> For now, this library depends on KotlinX Serialization to serialize computation results to Json for storage in the cache.
+> For now, this library depends on KotlinX Serialization to serialize computation results to Json for storage in the cache. So all classes being stored in the caches should be annotated with `@Serializable`, and the plugin should be enabled in the module using the cache.
 
 # Kacheable
 
@@ -24,7 +24,7 @@ class Foo() {
     val conn = client.connect()
 
     // Use the redis store with Kacheable
-    val cache = KacheableImpl(RedisKacheableStore(conn))
+    val cache = Kacheable(RedisKacheableStore(conn))
 
     suspend fun getUser(userId: Int) = cache("user-cache", userId) {
         // some db query to retrieve user... this will be cached the first
@@ -42,7 +42,7 @@ Any cache without a configuration uses defaults, but can be configured per cache
 val configs = listOf(CacheConfig("foo", ExpiryType.after_write, 30.minutes)).associateBy { it.name }
 
 // Then initialize the cache with them:
-val cache = KacheableImpl(RedisKacheableStore(conn), configs)
+val cache = Kacheable(RedisKacheableStore(conn), configs)
 ```
 
 The options are:
@@ -74,3 +74,23 @@ suspend fun dontSaveBar(shouldSave: Boolean = false): Bar = cache("foo", saveRes
         Bar(32, "something")
     }
 ```
+
+You can also provide your own implementation for naming the cache's key:
+
+```kotlin
+// This interface needs to be implemented:
+fun interface GetNameStrategy {
+    fun getName(name: String, params: Array<out Any>): String
+}
+
+// Instantiate Kacheable with it.
+val MyGetNameStrategy = GetNameStrategy { name, params ->
+    // This is the default implementation in `DefaultGetNameStrategy`
+    if (params.isEmpty())
+        name
+    else
+        "$name:${params.joinToString(",")}"
+}
+
+val cache = Kacheable(RedisKacheableStore(conn), getNameStrategy = MyGetNameStrategy)
+```
diff --git a/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/GetNameStrategy.kt b/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/GetNameStrategy.kt
@@ -2,4 +2,11 @@ package com.github.dave08.kacheable
 
 fun interface GetNameStrategy {
     fun getName(name: String, params: Array<out Any>): String
+}
+
+val DefaultGetNameStrategy: GetNameStrategy = GetNameStrategy { name, params ->
+    if (params.isEmpty())
+        name
+    else
+        "$name:${params.joinToString(",")}"
 }
diff --git a/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/Kacheable.kt b/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/Kacheable.kt
@@ -1,6 +1,7 @@
 package  com.github.dave08.kacheable
 
 import kotlinx.serialization.KSerializer
+import kotlinx.serialization.json.Json
 import kotlinx.serialization.serializer
 
 interface Kacheable {

diff --git a/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/KacheableImpl.kt b/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/KacheableImpl.kt
@@ -3,16 +3,11 @@ package com.github.dave08.kacheable
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.json.Json
 
-class KacheableImpl(
-    val store: KacheableStore,
-    val configs: Map<String, CacheConfig> = emptyMap(),
-    val getNameStrategy: GetNameStrategy = GetNameStrategy { name, params ->
-        if (params.isEmpty())
-            name
-        else
-            "$name:${params.joinToString(",")}"
-    },
-    private val jsonParser: Json = Json
+internal class KacheableImpl(
+    private val store: KacheableStore,
+    private val configs: Map<String, CacheConfig>,
+    private val getNameStrategy: GetNameStrategy,
+    private val jsonParser: Json,
 ) : Kacheable {
     /**
      * Don't use * in this list yet... I don't think del supports it properly.
@@ -65,4 +60,11 @@ class KacheableImpl(
                 jsonParser.decodeFromString(type, result)
         }
     }
-}
+}
+
+fun Kacheable(
+    store: KacheableStore,
+    configs: Map<String, CacheConfig> = emptyMap(),
+    getNameStrategy: GetNameStrategy = DefaultGetNameStrategy,
+    jsonParser: Json = Json
+): Kacheable = KacheableImpl(store, configs, getNameStrategy, jsonParser)
diff --git a/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/NoopKacheable.kt b/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/NoopKacheable.kt
@@ -2,7 +2,7 @@ package com.github.dave08.kacheable
 
 import kotlinx.serialization.KSerializer
 
-object NoopKacheable : Kacheable {
+internal object NoopKacheable : Kacheable {
     override suspend fun <R> invalidate(vararg keys: Pair<String, List<Any>>, block: suspend () -> R): R =
         block()
 
@@ -13,4 +13,6 @@ object NoopKacheable : Kacheable {
         saveResultIf: (R) -> Boolean,
         block: suspend () -> R
     ): R = block()
-}
+}
+
+fun KacheableNoOp(): Kacheable = NoopKacheable
diff --git a/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/blocking/BlockingKacheableImpl.kt b/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/blocking/BlockingKacheableImpl.kt
@@ -1,21 +1,17 @@
 package com.github.dave08.kacheable.blocking
 
 import com.github.dave08.kacheable.CacheConfig
+import com.github.dave08.kacheable.DefaultGetNameStrategy
 import com.github.dave08.kacheable.ExpiryType
 import com.github.dave08.kacheable.GetNameStrategy
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.json.Json
 
-class BlockingKacheableImpl(
-    val store: BlockingKacheableStore,
-    val configs: Map<String, CacheConfig> = emptyMap(),
-    val getNameStrategy: GetNameStrategy = GetNameStrategy { name, params ->
-        if (params.isEmpty())
-            name
-        else
-            "$name:${params.joinToString(",")}"
-    },
-    private val jsonParser: Json = Json
+internal class BlockingKacheableImpl(
+    private val store: BlockingKacheableStore,
+    private val configs: Map<String, CacheConfig>,
+    private val getNameStrategy: GetNameStrategy,
+    private val jsonParser: Json
 ) : BlockingKacheable {
     /**
      * Don't use * in this list yet... I don't think del supports it properly.
@@ -68,4 +64,11 @@ class BlockingKacheableImpl(
                 jsonParser.decodeFromString(type, result)
         }
     }
-}
+}
+
+fun BlockingKacheable(
+    store: BlockingKacheableStore,
+    configs: Map<String, CacheConfig> = emptyMap(),
+    getNameStrategy: GetNameStrategy = DefaultGetNameStrategy,
+    jsonParser: Json = Json
+) : BlockingKacheable = BlockingKacheableImpl(store, configs, getNameStrategy, jsonParser)
diff --git a/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/blocking/NoopBlockingKacheable.kt b/kacheable-core/src/main/kotlin/com/github/dave08/kacheable/blocking/NoopBlockingKacheable.kt
@@ -1,8 +1,9 @@
 package com.github.dave08.kacheable.blocking
 
+import com.github.dave08.kacheable.Kacheable
 import kotlinx.serialization.KSerializer
 
-object NoopBlockingKacheable : BlockingKacheable {
+internal object NoopBlockingKacheable : BlockingKacheable {
     override fun <R> invalidate(vararg keys: Pair<String, List<Any>>, block: () -> R): R =
         block()
 
@@ -13,4 +14,6 @@ object NoopBlockingKacheable : BlockingKacheable {
         saveResultIf: (R) -> Boolean,
         block: () -> R
     ): R = block()
-}
+}
+
+fun BlockingKacheableNoOp(): BlockingKacheable = NoopBlockingKacheable
diff --git a/kacheable-lettuce/src/main/kotlin/com/github/dave08/kacheable/RedisKacheableStore.kt b/kacheable-lettuce/src/main/kotlin/com/github/dave08/kacheable/RedisKacheableStore.kt
@@ -1,22 +1,25 @@
 package com.github.dave08.kacheable
 
+import io.lettuce.core.ExperimentalLettuceCoroutinesApi
 import io.lettuce.core.api.StatefulRedisConnection
+import io.lettuce.core.api.coroutines
 import kotlinx.coroutines.future.await
 import kotlin.time.Duration
 
+@OptIn(ExperimentalLettuceCoroutinesApi::class)
 class RedisKacheableStore(private val conn: StatefulRedisConnection<String, String>) : KacheableStore {
+
     override suspend fun delete(key: String) {
-        conn.async().del(key).await()
+        conn.coroutines().del(key)
     }
 
     override suspend fun set(key: String, value: String) {
-        conn.async().set(key, value).await()
+        conn.coroutines().set(key, value)
     }
 
-    override suspend fun get(key: String): String? =
-        conn.async().get(key).await()
+    override suspend fun get(key: String): String? = conn.coroutines().get(key)
 
     override suspend fun setExpire(key: String, expiry: Duration) {
-        conn.async().pexpire(key, expiry.inWholeMilliseconds).await()
+        conn.coroutines().pexpire(key, expiry.inWholeMilliseconds)
     }
 }
diff --git a/kacheable-lettuce/src/test/kotlin/kacheable/BlockingCacheableTest.kt b/kacheable-lettuce/src/test/kotlin/kacheable/BlockingCacheableTest.kt
@@ -3,7 +3,6 @@ package  kacheable
 import com.github.dave08.kacheable.CacheConfig
 import com.github.dave08.kacheable.ExpiryType
 import com.github.dave08.kacheable.blocking.BlockingKacheable
-import com.github.dave08.kacheable.blocking.BlockingKacheableImpl
 import com.github.dave08.kacheable.blocking.RedisBlockingKacheableStore
 import io.kotest.core.spec.style.FreeSpec
 import io.kotest.extensions.testcontainers.perTest
@@ -28,7 +27,7 @@ class BlockingCacheableTest : FreeSpec() {
         extensions(container.perTest())
 
         "Saves the result of a function with no parameters" {
-            val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn)))
+            val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn)))
             val results = mutableListOf<Bar>()
 
             results += (1..5).map { testClass.bar() }
@@ -43,7 +42,7 @@ class BlockingCacheableTest : FreeSpec() {
         }
 
         "Saves the result of a function with multiple parameters" {
-            val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn)))
+            val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn)))
 
             testClass.baz(32, "something")
 
@@ -52,15 +51,15 @@ class BlockingCacheableTest : FreeSpec() {
 
         "Sets expiry from last write" {
             val config = listOf(CacheConfig("BlockingFoo", ExpiryType.after_write, 30.minutes)).associateBy { it.name }
-            val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+            val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
             testClass.bar()
 
             expectThat(conn.sync().ttl("BlockingFoo")).isEqualTo((30.minutes).inWholeSeconds)
         }
 
         "Saves cache with default configs when not specified" {
-            val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), emptyMap()))
+            val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), emptyMap()))
 
             testClass.bar()
 
@@ -69,7 +68,7 @@ class BlockingCacheableTest : FreeSpec() {
 
         "Sets expiry from last access" {
             val config = listOf(CacheConfig("BlockingFoo", ExpiryType.after_access, 30.minutes)).associateBy { it.name }
-            val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+            val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
             testClass.bar()
             delay(100)
@@ -81,7 +80,7 @@ class BlockingCacheableTest : FreeSpec() {
         "When function result is null" - {
             "and nullPlaceholder setting is not set, the cache entry isn't saved" {
                 val config = listOf(CacheConfig("BlockingFoo", nullPlaceholder = null)).associateBy { it.name }
-                val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+                val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
                 testClass.nullBar()
 
@@ -90,7 +89,7 @@ class BlockingCacheableTest : FreeSpec() {
             "and nullPlaceholder setting is set, the cache value is the placeholder" {
                 val placeholder = "--placeholder--"
                 val config = listOf(CacheConfig("BlockingFoo", nullPlaceholder = placeholder)).associateBy { it.name }
-                val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+                val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
                 testClass.nullBar()
 
@@ -99,7 +98,7 @@ class BlockingCacheableTest : FreeSpec() {
             "and nullPlaceholder setting is set, null is returned when retrieving the value" {
                 val placeholder = "--placeholder--"
                 val config = listOf(CacheConfig("BlockingFoo", nullPlaceholder = placeholder)).associateBy { it.name }
-                val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+                val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
                 testClass.nullBar()
                 val result = testClass.nullBar()
@@ -111,7 +110,7 @@ class BlockingCacheableTest : FreeSpec() {
         "Invalidates a cache entry" - {
             "without parameters" {
                 val config = listOf(CacheConfig("BlockingFoo")).associateBy { it.name }
-                val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+                val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
                 testClass.bar()
                 testClass.invBar()
@@ -121,7 +120,7 @@ class BlockingCacheableTest : FreeSpec() {
 
             "with same parameters" {
                 val config = listOf(CacheConfig("BlockingFoo")).associateBy { it.name }
-                val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+                val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
                 testClass.baz(32, "something")
                 testClass.invBaz(32, "something")
@@ -132,7 +131,7 @@ class BlockingCacheableTest : FreeSpec() {
 
         "Save when condition is fullfilled" {
             val config = listOf(CacheConfig("BlockingFoo")).associateBy { it.name }
-            val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+            val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
             testClass.dontSaveBar()
             val result = testClass.dontSaveBar()
@@ -156,7 +155,7 @@ class BlockingCacheableTest : FreeSpec() {
         "Cache results that are not serializable" - {
             "int" {
                 val config = listOf(CacheConfig("BlockingFoo")).associateBy { it.name }
-                val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+                val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
                 testClass.primitiveInt()
 
@@ -167,7 +166,7 @@ class BlockingCacheableTest : FreeSpec() {
 
             "null int" {
                 val config = listOf(CacheConfig("BlockingFoo", nullPlaceholder = "null")).associateBy { it.name }
-                val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+                val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
                 testClass.primitiveNullInt()
 
@@ -178,7 +177,7 @@ class BlockingCacheableTest : FreeSpec() {
 
             "boolean" {
                 val config = listOf(CacheConfig("BlockingFoo")).associateBy { it.name }
-                val testClass = BlockingFoo(BlockingKacheableImpl(RedisBlockingKacheableStore(conn), config))
+                val testClass = BlockingFoo(BlockingKacheable(RedisBlockingKacheableStore(conn), config))
 
                 testClass.primitiveBoolean()