feat: proxy infrastructure for Lettuce command adapters

- LettuceResult: CompletionStage → Uni (lazy) and → blocking adapters
- QuarkusRedisCodec: bridges Quarkus Codec to Lettuce RedisCodec
- LettuceConverterRegistry: skeleton for arg/result converters

Unit tests for each class, plus an integration test against real Redis.

Author: vchomakov

extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/client/lettuce/LettuceConverterRegistry.java

@@ -0,0 +1,142 @@
+package io.quarkus.redis.runtime.client.lettuce;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+
+/**
+ * Central registry for type converters between Quarkus Redis types and Lettuce types.
+ * <p>
+ * Converters are registered by source type and looked up at command execution time.
+ * Each command story (Value Commands, Key Commands, etc.) registers its own converters
+ * when loaded.
+ * <p>
+ * Converters are stateless functions: {@code Function<QuarkusType, LettuceType>}.
+ *
+ * <h3>Usage</h3>
+ *
+ * <pre>{@code
+ * // Register (typically at startup)
+ * LettuceConverterRegistry.registerArgConverter(
+ *     io.quarkus.redis.datasource.value.SetArgs.class,
+ *     quarkusSetArgs -> { ... return lettuceSetArgs; }
+ * );
+ *
+ * // Lookup
+ * Function<Object, Object> converter = LettuceConverterRegistry.getArgConverter(
+ *     io.quarkus.redis.datasource.value.SetArgs.class
+ * );
+ * }</pre>
+ */
+public final class LettuceConverterRegistry {
+
+    /**
+     * Converters for command arguments: Quarkus arg type → Lettuce arg type.
+     */
+    private static final Map<Class<?>, Function<Object, Object>> ARG_CONVERTERS = new ConcurrentHashMap<>();
+
+    /**
+     * Converters for command results: Lettuce result type → Quarkus result type.
+     */
+    private static final Map<Class<?>, Function<Object, Object>> RESULT_CONVERTERS = new ConcurrentHashMap<>();
+
+    private LettuceConverterRegistry() {
+        // Utility class
+    }
+
+    /**
+     * Register a converter for a Quarkus command argument type.
+     *
+     * @param <S> the Quarkus source type
+     * @param <T> the Lettuce target type
+     * @param sourceType the Quarkus argument class
+     * @param converter the conversion function
+     */
+    @SuppressWarnings("unchecked")
+    public static <S, T> void registerArgConverter(Class<S> sourceType, Function<S, T> converter) {
+        ARG_CONVERTERS.put(sourceType, (Function<Object, Object>) converter);
+    }
+
+    /**
+     * Register a converter for a Lettuce result type.
+     *
+     * @param <S> the Lettuce source type
+     * @param <T> the Quarkus target type
+     * @param sourceType the Lettuce result class
+     * @param converter the conversion function
+     */
+    @SuppressWarnings("unchecked")
+    public static <S, T> void registerResultConverter(Class<S> sourceType, Function<S, T> converter) {
+        RESULT_CONVERTERS.put(sourceType, (Function<Object, Object>) converter);
+    }
+
+    /**
+     * Look up an argument converter by Quarkus source type.
+     *
+     * @param sourceType the Quarkus argument class
+     * @return the converter, or {@code null} if none is registered
+     */
+    public static Function<Object, Object> getArgConverter(Class<?> sourceType) {
+        return ARG_CONVERTERS.get(sourceType);
+    }
+
+    /**
+     * Look up a result converter by Lettuce source type.
+     *
+     * @param sourceType the Lettuce result class
+     * @return the converter, or {@code null} if none is registered
+     */
+    public static Function<Object, Object> getResultConverter(Class<?> sourceType) {
+        return RESULT_CONVERTERS.get(sourceType);
+    }
+
+    /**
+     * Convert a Quarkus argument to its Lettuce equivalent.
+     *
+     * @param <T> the expected Lettuce type
+     * @param arg the Quarkus argument
+     * @return the converted Lettuce argument
+     * @throws IllegalArgumentException if no converter is registered for the type
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T convertArg(Object arg) {
+        if (arg == null) {
+            return null;
+        }
+        Function<Object, Object> converter = ARG_CONVERTERS.get(arg.getClass());
+        if (converter == null) {
+            throw new IllegalArgumentException(
+                    "No Lettuce converter registered for argument type: " + arg.getClass().getName());
+        }
+        return (T) converter.apply(arg);
+    }
+
+    /**
+     * Convert a Lettuce result to its Quarkus equivalent.
+     *
+     * @param <T> the expected Quarkus type
+     * @param result the Lettuce result
+     * @return the converted Quarkus result
+     * @throws IllegalArgumentException if no converter is registered for the type
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T convertResult(Object result) {
+        if (result == null) {
+            return null;
+        }
+        Function<Object, Object> converter = RESULT_CONVERTERS.get(result.getClass());
+        if (converter == null) {
+            throw new IllegalArgumentException(
+                    "No Lettuce converter registered for result type: " + result.getClass().getName());
+        }
+        return (T) converter.apply(result);
+    }
+
+    /**
+     * Clear all registered converters. Intended for testing only.
+     */
+    public static void clear() {
+        ARG_CONVERTERS.clear();
+        RESULT_CONVERTERS.clear();
+    }
+}

extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/client/lettuce/LettuceResult.java

@@ -0,0 +1,51 @@
+package io.quarkus.redis.runtime.client.lettuce;
+
+import java.time.Duration;
+import java.util.concurrent.CompletionStage;
+
+import io.smallrye.mutiny.Uni;
+
+/**
+ * Utility for adapting Lettuce {@link CompletionStage} results to Mutiny {@link Uni}
+ * and to blocking calls.
+ * <p>
+ * Lettuce async commands return {@link io.lettuce.core.RedisFuture} which extends
+ * {@link CompletionStage}. This class provides the bridge to Quarkus APIs without
+ * exposing any Reactor types.
+ */
+public final class LettuceResult {
+
+    private LettuceResult() {
+        // Utility class
+    }
+
+    /**
+     * Converts a {@link CompletionStage} to a Mutiny {@link Uni}.
+     * <p>
+     * The returned {@code Uni} subscribes lazily — the {@code CompletionStage} supplier
+     * is invoked only when a subscriber requests it.
+     *
+     * @param <T> the result type
+     * @param supplier a supplier of the {@link CompletionStage} (typically a Lettuce async command call)
+     * @return a {@link Uni} that completes with the result of the {@link CompletionStage}
+     */
+    public static <T> Uni<T> toUni(java.util.function.Supplier<CompletionStage<T>> supplier) {
+        return Uni.createFrom().completionStage(supplier);
+    }
+
+    /**
+     * Blocks on a {@link CompletionStage} and returns the result.
+     * <p>
+     * This must only be called from a worker thread, never from an event loop thread.
+     *
+     * @param <T> the result type
+     * @param stage the {@link CompletionStage} to block on
+     * @param timeout the maximum time to wait
+     * @return the result
+     * @throws java.util.concurrent.CompletionException if the computation threw an exception
+     */
+    public static <T> T toBlocking(CompletionStage<T> stage, Duration timeout) {
+        return Uni.createFrom().completionStage(stage)
+                .await().atMost(timeout);
+    }
+}

extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/client/lettuce/QuarkusRedisCodec.java

@@ -0,0 +1,86 @@
+package io.quarkus.redis.runtime.client.lettuce;
+
+import java.lang.reflect.Type;
+import java.nio.ByteBuffer;
+
+import io.lettuce.core.codec.RedisCodec;
+import io.quarkus.redis.datasource.codecs.Codec;
+import io.quarkus.redis.datasource.codecs.Codecs;
+
+/**
+ * Adapts Quarkus {@link Codec} (byte[]-based) to Lettuce {@link RedisCodec} (ByteBuffer-based).
+ * <p>
+ * This allows Lettuce commands to use the same serialization logic as the existing Quarkus
+ * Redis extension, including custom user-provided codecs registered via CDI.
+ *
+ * @param <K> the key type
+ * @param <V> the value type
+ */
+public class QuarkusRedisCodec<K, V> implements RedisCodec<K, V> {
+
+    private final Codec keyCodec;
+    private final Codec valueCodec;
+    private final Type keyType;
+    private final Type valueType;
+
+    public QuarkusRedisCodec(Type keyType, Type valueType) {
+        this.keyType = keyType;
+        this.valueType = valueType;
+        this.keyCodec = Codecs.getDefaultCodecFor(keyType);
+        this.valueCodec = Codecs.getDefaultCodecFor(valueType);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public K decodeKey(ByteBuffer bytes) {
+        if (bytes == null || !bytes.hasRemaining()) {
+            return null;
+        }
+        return (K) keyCodec.decode(toBytes(bytes));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public V decodeValue(ByteBuffer bytes) {
+        if (bytes == null || !bytes.hasRemaining()) {
+            return null;
+        }
+        return (V) valueCodec.decode(toBytes(bytes));
+    }
+
+    @Override
+    public ByteBuffer encodeKey(K key) {
+        if (key == null) {
+            return ByteBuffer.allocate(0);
+        }
+        return ByteBuffer.wrap(keyCodec.encode(key));
+    }
+
+    @Override
+    public ByteBuffer encodeValue(V value) {
+        if (value == null) {
+            return ByteBuffer.allocate(0);
+        }
+        return ByteBuffer.wrap(valueCodec.encode(value));
+    }
+
+    /**
+     * @return the key type this codec handles
+     */
+    public Type keyType() {
+        return keyType;
+    }
+
+    /**
+     * @return the value type this codec handles
+     */
+    public Type valueType() {
+        return valueType;
+    }
+
+    private static byte[] toBytes(ByteBuffer buffer) {
+        byte[] bytes = new byte[buffer.remaining()];
+        buffer.get(bytes);
+        return bytes;
+    }
+}

extensions/redis-client/runtime/src/test/java/io/quarkus/redis/runtime/client/lettuce/LettuceConverterRegistryTest.java

@@ -0,0 +1,85 @@
+package io.quarkus.redis.runtime.client.lettuce;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.function.Function;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for {@link LettuceConverterRegistry}.
+ */
+class LettuceConverterRegistryTest {
+
+    @AfterEach
+    void cleanup() {
+        LettuceConverterRegistry.clear();
+    }
+
+    @Test
+    void registerAndLookupArgConverter() {
+        LettuceConverterRegistry.registerArgConverter(String.class, s -> s.toUpperCase());
+        Function<Object, Object> converter = LettuceConverterRegistry.getArgConverter(String.class);
+        assertThat(converter).isNotNull();
+        assertThat(converter.apply("hello")).isEqualTo("HELLO");
+    }
+
+    @Test
+    void registerAndLookupResultConverter() {
+        LettuceConverterRegistry.registerResultConverter(Integer.class, i -> i * 2);
+        Function<Object, Object> converter = LettuceConverterRegistry.getResultConverter(Integer.class);
+        assertThat(converter).isNotNull();
+        assertThat(converter.apply(5)).isEqualTo(10);
+    }
+
+    @Test
+    void lookupReturnsNullForUnregistered() {
+        assertThat(LettuceConverterRegistry.getArgConverter(Double.class)).isNull();
+        assertThat(LettuceConverterRegistry.getResultConverter(Double.class)).isNull();
+    }
+
+    @Test
+    void convertArgShouldApplyConverter() {
+        LettuceConverterRegistry.registerArgConverter(String.class, s -> s.length());
+        int result = LettuceConverterRegistry.convertArg("hello");
+        assertThat(result).isEqualTo(5);
+    }
+
+    @Test
+    void convertArgShouldReturnNullForNullInput() {
+        String result = LettuceConverterRegistry.convertArg(null);
+        assertThat(result).isNull();
+    }
+
+    @Test
+    void convertArgShouldThrowForUnregistered() {
+        assertThatThrownBy(() -> LettuceConverterRegistry.convertArg("no-converter"))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("No Lettuce converter registered for argument type");
+    }
+
+    @Test
+    void convertResultShouldApplyConverter() {
+        LettuceConverterRegistry.registerResultConverter(Long.class, l -> l.toString());
+        String result = LettuceConverterRegistry.convertResult(42L);
+        assertThat(result).isEqualTo("42");
+    }
+
+    @Test
+    void convertResultShouldThrowForUnregistered() {
+        assertThatThrownBy(() -> LettuceConverterRegistry.convertResult(3.14))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("No Lettuce converter registered for result type");
+    }
+
+    @Test
+    void clearShouldRemoveAllConverters() {
+        LettuceConverterRegistry.registerArgConverter(String.class, s -> s);
+        LettuceConverterRegistry.registerResultConverter(Integer.class, i -> i);
+        LettuceConverterRegistry.clear();
+        assertThat(LettuceConverterRegistry.getArgConverter(String.class)).isNull();
+        assertThat(LettuceConverterRegistry.getResultConverter(Integer.class)).isNull();
+    }
+}