Deprecate the Redis string group (because it's misleading, as it refe…

…rs to Redis strings, not Java strings) and rename it to "value."

This change is backward compatible, it adds the new groups and deprecates the previous one.

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);
     }