Add micronaut-redis module

Micronaut cache implementation using Jedis driver, providing drop-in
compatibility with the official Micronaut Redis (Lettuce) cache module.

Features:
- Works with @Cacheable, @cACHEpUT, @CacheInvalidate annotations
- Uses Jedis driver with JedisPool for connection pooling
- Same configuration namespace as official Lettuce implementation
- Supports expire-after-write and expire-after-access policies
- Custom expiration policy support
- Async cache operations via AsyncCache

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: pditommaso

.github/workflows/build.yml

@@ -83,6 +83,7 @@ jobs:
           bash publish.sh lib-serde-moshi
           bash publish.sh lib-serde-jackson
           bash publish.sh lib-trace
+          bash publish.sh micronaut-redis
 
         env:
           GRADLE_OPTS: '-Dorg.gradle.daemon=false'

.github/workflows/generate-submit-dependencies.yml

@@ -34,6 +34,7 @@ jobs:
           "lib-serde-jackson",
           "lib-trace",
           "lib-util-http",
+          "micronaut-redis",
           "wave-api",
           "wave-utils"
         ]

micronaut-redis/README.md

@@ -0,0 +1,179 @@
+# Micronaut Redis Cache
+
+A Micronaut cache implementation using the Jedis Redis driver, providing drop-in compatibility with the official Micronaut Redis (Lettuce) cache module.
+
+## Features
+
+- Works with Micronaut's `@Cacheable`, `@CachePut`, `@CacheInvalidate` annotations
+- Uses Jedis driver with JedisPool for connection pooling
+- Same configuration namespace as the official Lettuce implementation
+- Supports expiration policies (expire-after-write, expire-after-access)
+- Custom expiration policy support
+- Async cache operations via `AsyncCache`
+
+## Installation
+
+Add the dependency to your `build.gradle`:
+
+```groovy
+dependencies {
+    implementation 'io.seqera:micronaut-redis:1.0.0'
+}
+```
+
+## Configuration
+
+The module uses the same configuration as the official Micronaut Redis cache:
+
+```yaml
+redis:
+  caches:
+    my-cache:
+      expire-after-write: 1h
+    another-cache:
+      expire-after-access: 30m
+      invalidate-scan-count: 100
+```
+
+### Configuration Options
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `expire-after-write` | Duration | TTL after writing a value |
+| `expire-after-access` | Duration | TTL after accessing a value (touch-based) |
+| `expiration-after-write-policy` | String | Custom policy class name |
+| `invalidate-scan-count` | Long | SCAN batch size for invalidateAll (default: 100) |
+| `key-serializer` | Class | Custom key serializer |
+| `value-serializer` | Class | Custom value serializer |
+| `charset` | Charset | Character encoding for keys |
+
+### Default Configuration
+
+You can set defaults for all caches:
+
+```yaml
+redis:
+  cache:
+    expire-after-write: 2h
+    charset: UTF-8
+  caches:
+    my-cache:
+      # inherits defaults, can override
+      expire-after-write: 30m
+```
+
+## Usage
+
+### Provide a JedisPool Bean
+
+The module requires a `JedisPool` bean to be provided by your application:
+
+```java
+@Factory
+public class RedisFactory {
+
+    @Singleton
+    public JedisPool jedisPool() {
+        return new JedisPool("localhost", 6379);
+    }
+}
+```
+
+### Using with @Cacheable
+
+```java
+@Singleton
+public class UserService {
+
+    @Cacheable("users")
+    public User findById(Long id) {
+        // This will be cached
+        return userRepository.findById(id);
+    }
+
+    @CachePut("users")
+    public User update(Long id, User user) {
+        return userRepository.save(user);
+    }
+
+    @CacheInvalidate("users")
+    public void delete(Long id) {
+        userRepository.deleteById(id);
+    }
+}
+```
+
+### Programmatic Access
+
+```java
+@Singleton
+public class CacheService {
+
+    private final SyncCache<JedisPool> cache;
+
+    public CacheService(@Named("my-cache") SyncCache<JedisPool> cache) {
+        this.cache = cache;
+    }
+
+    public void example() {
+        // Put
+        cache.put("key", "value");
+
+        // Get
+        Optional<String> value = cache.get("key", String.class);
+
+        // Get with supplier
+        String result = cache.get("key", String.class, () -> "default");
+
+        // Put if absent
+        Optional<String> existing = cache.putIfAbsent("key", "value");
+
+        // Invalidate
+        cache.invalidate("key");
+        cache.invalidateAll();
+
+        // Async operations
+        cache.async().get("key", String.class)
+            .thenAccept(opt -> opt.ifPresent(System.out::println));
+    }
+}
+```
+
+### Custom Expiration Policy
+
+Implement `ExpirationAfterWritePolicy` for dynamic TTL:
+
+```java
+@Singleton
+public class TypeBasedExpirationPolicy implements ExpirationAfterWritePolicy {
+
+    @Override
+    public long getExpirationAfterWrite(Object value) {
+        if (value instanceof TemporaryData) {
+            return Duration.ofMinutes(5).toMillis();
+        }
+        return Duration.ofHours(1).toMillis();
+    }
+}
+```
+
+Configure it:
+
+```yaml
+redis:
+  caches:
+    my-cache:
+      expiration-after-write-policy: com.example.TypeBasedExpirationPolicy
+```
+
+## Migration from Lettuce
+
+This module is designed as a drop-in replacement for `micronaut-redis-lettuce` cache. To migrate:
+
+1. Replace the dependency
+2. Provide a `JedisPool` bean instead of Lettuce connection
+3. Configuration remains the same
+
+## License
+
+Apache License 2.0

micronaut-redis/VERSION

@@ -0,0 +1 @@
+1.0.0

micronaut-redis/build.gradle

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2026, Seqera Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+plugins {
+    id 'io.seqera.java-library-conventions'
+    id 'io.seqera.groovy-library-conventions'
+    // Micronaut minimal lib
+    // https://micronaut-projects.github.io/micronaut-gradle-plugin/latest/
+    id "io.micronaut.minimal.library" version '4.5.3'
+}
+
+group = 'io.seqera'
+version = "${project.file('VERSION').text.trim()}"
+
+dependencies {
+    // Micronaut cache core
+    api "io.micronaut.cache:micronaut-cache-core:4.3.1"
+
+    // Jedis Redis client
+    api 'redis.clients:jedis:5.1.5'
+
+    // Micronaut runtime
+    implementation "io.micronaut:micronaut-runtime:${micronautCoreVersion}"
+    implementation "io.micronaut:micronaut-context:${micronautCoreVersion}"
+    implementation "io.micronaut:micronaut-core:${micronautCoreVersion}"
+
+    // JSpecify annotations
+    compileOnly 'org.jspecify:jspecify:1.0.0'
+
+    // Groovy support for compilation
+    compileOnly "io.micronaut:micronaut-inject-groovy:${micronautCoreVersion}"
+
+    // Test dependencies
+    testImplementation testFixtures(project(':lib-fixtures-redis'))
+    testImplementation "io.micronaut:micronaut-inject-groovy:${micronautCoreVersion}"
+    testImplementation "io.micronaut.test:micronaut-test-spock:${micronautTestVersion}"
+    testImplementation 'org.testcontainers:testcontainers:1.20.6'
+}
+
+test {
+    useJUnitPlatform()
+}
+
+micronaut {
+    version '4.8.3'
+    runtime("netty")
+    processing {
+        incremental(true)
+    }
+    importMicronautPlatform = false
+}