Redis value group (replacing the string group)

docs/src/main/asciidoc/redis-reference.adoc

@@ -275,7 +275,7 @@ As mentioned above, the API is divided into groups:
 - set - `.set(memberType)`
 - sorted-set - `.sortedSet(memberType)`
 - stream (not available yet)
-- string - `.string(valueType)`
+- string - `.value(valueType)`
 - transactions - `withTransaction`
 
 Each of these methods returns an object that lets you execute the commands related to the group.
@@ -317,9 +317,9 @@ In this case, `quarkus-jackson` is used.
 
 To store binary data, use `byte[]`.
 
-=== The `string` group
+=== The `value` group
 
-The `string` group is used to manipulate https://redis.io/docs/manual/data-types/#strings[Redis Strings].
+The `value` group is used to manipulate https://redis.io/docs/manual/data-types/#strings[Redis Strings].
 Thus, this group is not limited to Java Strings but can be used for integers (like a counter) or binary content (like images).
 
 ==== Caching values
@@ -332,10 +332,10 @@ The following snippet shows how such a command can be used to store `BusinessObj
 @ApplicationScoped
 public static class MyRedisCache {
 
-    private final StringCommands<String, BusinessObject> commands;
+    private final ValueCommands<String, BusinessObject> commands;
 
     public MyRedisCache(RedisDataSource ds) {
-        commands = ds.string(BusinessObject.class);
+        commands = ds.value(BusinessObject.class);
     }
 
     public BusinessObject get(String key) {
@@ -375,10 +375,10 @@ In this case, we will use `byte[]` as value type:
 @ApplicationScoped
 public static class MyBinaryRepository {
 
-    private final StringCommands<String, byte[]> commands;
+    private final ValueCommands<String, byte[]> commands;
 
     public MyBinaryRepository(RedisDataSource ds) {
-        commands = ds.string(byte[].class);
+        commands = ds.value(byte[].class);
     }
 
     public byte[] get(String key) {
@@ -408,10 +408,10 @@ You can store counters in Redis as demonstrated below:
 @ApplicationScoped
 public static class MyRedisCounter {
 
-    private final StringCommands<String, Long> commands;
+    private final ValueCommands<String, Long> commands;
 
     public MyRedisCounter(RedisDataSource ds) {
-        commands = ds.string(Long.class); // <1>
+        commands = ds.value(Long.class); // <1>
     }
 
     public long get(String key) {
@@ -490,11 +490,11 @@ public static class MySubscriber implements Consumer<Notification> {
 @ApplicationScoped
 public static class MyCache {
 
-    private final StringCommands<String, BusinessObject> commands;
+    private final ValueCommands<String, BusinessObject> commands;
     private final PubSubCommands<Notification> pub;
 
     public MyCache(RedisDataSource ds) {
-        commands = ds.string(BusinessObject.class);
+        commands = ds.value(BusinessObject.class);
         pub = ds.pubsub(Notification.class);
     }
 

docs/src/main/asciidoc/redis.adoc

@@ -120,10 +120,10 @@ public class IncrementService {
     // Regular applications will pick one of them.
 
     private ReactiveKeyCommands<String> keyCommands; // <1>
-    private StringCommands<String, Long> countCommands; // <2>
+    private ValueCommands<String, Long> countCommands; // <2>
 
     public IncrementService(RedisDataSource ds, ReactiveRedisDataSource reactive) { // <3>
-        countCommands = ds.string(Long.class); // <4>
+        countCommands = ds.value(Long.class); // <4>
         keyCommands = reactive.key();  // <5>
 
     }

extensions/redis-client/deployment/src/test/java/io/quarkus/redis/client/deployment/datasource/DataSourceInjectionTest.java

@@ -60,24 +60,24 @@ public static class MyRedisApp {
         ReactiveRedisDataSource myRedisReactive;
 
         public void set(String data) {
-            reactive.string(String.class, String.class)
+            reactive.value(String.class, String.class)
                     .set("foo", data)
                     .await().indefinitely();
         }
 
         public String get() {
-            return blocking.string(String.class, String.class)
+            return blocking.value(String.class, String.class)
                     .get("foo");
         }
 
         public void setMyRedis(String data) {
-            myRedisReactive.string(String.class, String.class)
+            myRedisReactive.value(String.class, String.class)
                     .set("foo", data)
                     .await().indefinitely();
         }
 
         public String getMyRedis() {
-            return myRedisBlocking.string(String.class, String.class)
+            return myRedisBlocking.value(String.class, String.class)
                     .get("foo");
         }
 

extensions/redis-client/deployment/src/test/java/io/quarkus/redis/client/deployment/datasource/DataSourceTest.java

@@ -11,7 +11,7 @@
 import io.quarkus.redis.client.RedisClientName;
 import io.quarkus.redis.client.deployment.RedisTestResource;
 import io.quarkus.redis.datasource.RedisDataSource;
-import io.quarkus.redis.datasource.string.StringCommands;
+import io.quarkus.redis.datasource.value.ValueCommands;
 import io.quarkus.test.QuarkusUnitTest;
 import io.quarkus.test.common.QuarkusTestResource;
 
@@ -34,8 +34,8 @@ public class DataSourceTest {
 
     @Test
     public void testThatTheDatasourceUseDifferentDatabases() {
-        StringCommands<String, String> r1s = r1.string(String.class);
-        StringCommands<String, String> r2s = r2.string(String.class);
+        ValueCommands<String, String> r1s = r1.value(String.class);
+        ValueCommands<String, String> r2s = r2.value(String.class);
 
         r1s.set("key", "hello");
         Assertions.assertThat(r2s.get("key")).isNull();

extensions/redis-client/deployment/src/test/java/io/quarkus/redis/client/deployment/devmode/IncrementResource.java

@@ -4,16 +4,16 @@
 import javax.ws.rs.Path;
 
 import io.quarkus.redis.datasource.RedisDataSource;
-import io.quarkus.redis.datasource.string.StringCommands;
+import io.quarkus.redis.datasource.value.ValueCommands;
 
 @Path("/inc")
 public class IncrementResource {
 
     public static final long INCREMENT = 1;
-    private final StringCommands<String, Integer> commands;
+    private final ValueCommands<String, Integer> commands;
 
     public IncrementResource(RedisDataSource ds) {
-        commands = ds.string(Integer.class);
+        commands = ds.value(Integer.class);
     }
 
     @GET

extensions/redis-client/deployment/src/test/java/io/quarkus/redis/client/deployment/patterns/BinaryTest.java

@@ -14,7 +14,7 @@
 
 import io.quarkus.redis.client.deployment.RedisTestResource;
 import io.quarkus.redis.datasource.RedisDataSource;
-import io.quarkus.redis.datasource.string.StringCommands;
+import io.quarkus.redis.datasource.value.ValueCommands;
 import io.quarkus.test.QuarkusUnitTest;
 import io.quarkus.test.common.QuarkusTestResource;
 
@@ -52,10 +52,10 @@ void binary() {
     @ApplicationScoped
     public static class MyBinaryRepository {
 
-        private final StringCommands<String, byte[]> commands;
+        private final ValueCommands<String, byte[]> commands;
 
         public MyBinaryRepository(RedisDataSource ds) {
-            commands = ds.string(byte[].class);
+            commands = ds.value(byte[].class);
         }
 
         public byte[] get(String key) {

extensions/redis-client/deployment/src/test/java/io/quarkus/redis/client/deployment/patterns/CacheTest.java

@@ -13,7 +13,7 @@
 
 import io.quarkus.redis.client.deployment.RedisTestResource;
 import io.quarkus.redis.datasource.RedisDataSource;
-import io.quarkus.redis.datasource.string.StringCommands;
+import io.quarkus.redis.datasource.value.ValueCommands;
 import io.quarkus.test.QuarkusUnitTest;
 import io.quarkus.test.common.QuarkusTestResource;
 
@@ -68,10 +68,10 @@ public BusinessObject(String v) {
     @ApplicationScoped
     public static class MyRedisCache {
 
-        private final StringCommands<String, BusinessObject> commands;
+        private final ValueCommands<String, BusinessObject> commands;
 
         public MyRedisCache(RedisDataSource ds) {
-            commands = ds.string(BusinessObject.class);
+            commands = ds.value(BusinessObject.class);
         }
 
         public BusinessObject get(String key) {

extensions/redis-client/deployment/src/test/java/io/quarkus/redis/client/deployment/patterns/CounterTest.java

@@ -11,7 +11,7 @@
 
 import io.quarkus.redis.client.deployment.RedisTestResource;
 import io.quarkus.redis.datasource.RedisDataSource;
-import io.quarkus.redis.datasource.string.StringCommands;
+import io.quarkus.redis.datasource.value.ValueCommands;
 import io.quarkus.test.QuarkusUnitTest;
 import io.quarkus.test.common.QuarkusTestResource;
 
@@ -47,10 +47,10 @@ void counter() {
     @ApplicationScoped
     public static class MyRedisCounter {
 
-        private final StringCommands<String, Long> commands;
+        private final ValueCommands<String, Long> commands;
 
         public MyRedisCounter(RedisDataSource ds) {
-            commands = ds.string(Long.class);
+            commands = ds.value(Long.class);
         }
 
         public long get(String key) {

extensions/redis-client/deployment/src/test/java/io/quarkus/redis/client/deployment/patterns/PubSubOnStartupTest.java

@@ -21,7 +21,7 @@
 import io.quarkus.redis.datasource.RedisDataSource;
 import io.quarkus.redis.datasource.pubsub.PubSubCommands;
 import io.quarkus.redis.datasource.pubsub.ReactivePubSubCommands;
-import io.quarkus.redis.datasource.string.StringCommands;
+import io.quarkus.redis.datasource.value.ValueCommands;
 import io.quarkus.runtime.Startup;
 import io.quarkus.test.QuarkusUnitTest;
 import io.quarkus.test.common.QuarkusTestResource;
@@ -115,11 +115,11 @@ public List<Notification> list() {
     @ApplicationScoped
     public static class MyCache {
 
-        private final StringCommands<String, BusinessObject> commands;
+        private final ValueCommands<String, BusinessObject> commands;
         private final PubSubCommands<Notification> pub;
 
         public MyCache(RedisDataSource ds) {
-            commands = ds.string(BusinessObject.class);
+            commands = ds.value(BusinessObject.class);
             pub = ds.pubsub(Notification.class);
         }
 

extensions/redis-client/deployment/src/test/java/io/quarkus/redis/client/deployment/patterns/PubSubTest.java

@@ -19,7 +19,7 @@
 import io.quarkus.redis.client.deployment.RedisTestResource;
 import io.quarkus.redis.datasource.RedisDataSource;
 import io.quarkus.redis.datasource.pubsub.PubSubCommands;
-import io.quarkus.redis.datasource.string.StringCommands;
+import io.quarkus.redis.datasource.value.ValueCommands;
 import io.quarkus.runtime.Startup;
 import io.quarkus.test.QuarkusUnitTest;
 import io.quarkus.test.common.QuarkusTestResource;
@@ -109,11 +109,11 @@ public List<Notification> list() {
     @ApplicationScoped
     public static class MyCache {
 
-        private final StringCommands<String, BusinessObject> commands;
+        private final ValueCommands<String, BusinessObject> commands;
         private final PubSubCommands<Notification> pub;
 
         public MyCache(RedisDataSource ds) {
-            commands = ds.string(BusinessObject.class);
+            commands = ds.value(BusinessObject.class);
             pub = ds.pubsub(Notification.class);
         }
 

extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/ReactiveRedisDataSource.java

@@ -17,6 +17,7 @@
 import io.quarkus.redis.datasource.transactions.ReactiveTransactionalRedisDataSource;
 import io.quarkus.redis.datasource.transactions.TransactionResult;
 import io.quarkus.redis.datasource.transactions.TransactionalRedisDataSource;
+import io.quarkus.redis.datasource.value.ReactiveValueCommands;
 import io.smallrye.mutiny.Uni;
 import io.vertx.mutiny.redis.client.Command;
 import io.vertx.mutiny.redis.client.Redis;
@@ -232,6 +233,34 @@ default <V> ReactiveSortedSetCommands<String, V> sortedSet(Class<V> valueType) {
         return sortedSet(String.class, valueType);
     }
 
+    /**
+     * Gets the object to execute commands manipulating stored strings.
+     * <p>
+     * <strong>NOTE:</strong> Instead of {@code string}, this group is named {@code value} to avoid the confusion with the
+     * Java String type. Indeed, Redis strings can be strings, numbers, byte arrays...
+     *
+     * @param redisKeyType the type of the keys
+     * @param valueType the type of the value, often String, or the value are encoded/decoded using codecs.
+     * @param <K> the type of the key
+     * @param <V> the type of the value
+     * @return the object to manipulate stored strings.
+     */
+    <K, V> ReactiveValueCommands<K, V> value(Class<K> redisKeyType, Class<V> valueType);
+
+    /**
+     * Gets the object to execute commands manipulating stored strings.
+     * <p>
+     * <strong>NOTE:</strong> Instead of {@code string}, this group is named {@code value} to avoid the confusion with the
+     * Java String type. Indeed, Redis strings can be strings, numbers, byte arrays...
+     *
+     * @param valueType the type of the value, often String, or the value are encoded/decoded using codecs.
+     * @param <V> the type of the value
+     * @return the object to manipulate stored strings.
+     */
+    default <V> ReactiveValueCommands<String, V> value(Class<V> valueType) {
+        return value(String.class, valueType);
+    }
+
     /**
      * Gets the object to execute commands manipulating stored strings.
      *
@@ -240,7 +269,9 @@ default <V> ReactiveSortedSetCommands<String, V> sortedSet(Class<V> valueType) {
      * @param <K> the type of the key
      * @param <V> the type of the value
      * @return the object to manipulate stored strings.
+     * @deprecated Use {@link #value(Class, Class)} instead
      */
+    @Deprecated
     <K, V> ReactiveStringCommands<K, V> string(Class<K> redisKeyType, Class<V> valueType);
 
     /**
@@ -249,7 +280,9 @@ default <V> ReactiveSortedSetCommands<String, V> sortedSet(Class<V> valueType) {
      * @param valueType the type of the value, often String, or the value are encoded/decoded using codecs.
      * @param <V> the type of the value
      * @return the object to manipulate stored strings.
+     * @deprecated Use {@link #value(Class)} instead
      */
+    @Deprecated
     default <V> ReactiveStringCommands<String, V> string(Class<V> valueType) {
         return string(String.class, valueType);
     }

extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/RedisDataSource.java

@@ -17,6 +17,7 @@
 import io.quarkus.redis.datasource.transactions.OptimisticLockingTransactionResult;
 import io.quarkus.redis.datasource.transactions.TransactionResult;
 import io.quarkus.redis.datasource.transactions.TransactionalRedisDataSource;
+import io.quarkus.redis.datasource.value.ValueCommands;
 import io.vertx.mutiny.redis.client.Command;
 import io.vertx.mutiny.redis.client.Response;
 
@@ -228,6 +229,36 @@ default <V> SortedSetCommands<String, V> sortedSet(Class<V> valueType) {
         return sortedSet(String.class, valueType);
     }
 
+    /**
+     * Gets the object to execute commands manipulating stored strings.
+     *
+     * <p>
+     * <strong>NOTE:</strong> Instead of {@code string}, this group is named {@code value} to avoid the confusion with the
+     * Java String type. Indeed, Redis strings can be strings, numbers, byte arrays...
+     *
+     * @param redisKeyType the type of the keys
+     * @param valueType the type of the value, often String, or the value are encoded/decoded using codecs.
+     * @param <K> the type of the key
+     * @param <V> the type of the value
+     * @return the object to manipulate stored strings.
+     */
+    <K, V> ValueCommands<K, V> value(Class<K> redisKeyType, Class<V> valueType);
+
+    /**
+     * Gets the object to execute commands manipulating stored strings.
+     *
+     * <p>
+     * <strong>NOTE:</strong> Instead of {@code string}, this group is named {@code value} to avoid the confusion with the
+     * Java String type. Indeed, Redis strings can be strings, numbers, byte arrays...
+     *
+     * @param valueType the type of the value, often String, or the value are encoded/decoded using codecs.
+     * @param <V> the type of the value
+     * @return the object to manipulate stored strings.
+     */
+    default <V> ValueCommands<String, V> value(Class<V> valueType) {
+        return value(String.class, valueType);
+    }
+
     /**
      * Gets the object to execute commands manipulating stored strings.
      *
@@ -236,7 +267,9 @@ default <V> SortedSetCommands<String, V> sortedSet(Class<V> valueType) {
      * @param <K> the type of the key
      * @param <V> the type of the value
      * @return the object to manipulate stored strings.
+     * @deprecated Use {@link #value(Class, Class)} instead
      */
+    @Deprecated
     <K, V> StringCommands<K, V> string(Class<K> redisKeyType, Class<V> valueType);
 
     /**
@@ -245,7 +278,9 @@ default <V> SortedSetCommands<String, V> sortedSet(Class<V> valueType) {
      * @param valueType the type of the value, often String, or the value are encoded/decoded using codecs.
      * @param <V> the type of the value
      * @return the object to manipulate stored strings.
+     * @deprecated Use {@link #value(Class)} instead
      */
+    @Deprecated
     default <V> StringCommands<String, V> string(Class<V> valueType) {
         return string(String.class, valueType);
     }