refactor: fix deprecations and other build warnings

Migrate from deprecated RedisZSetCommands.Range to org.springframework.data.domain.Range
in all lexicographic query implementations to fix deprecation warnings marked for removal
in Spring Data Redis 3.4.5.
enabled. Also added lombok.config to configure Lombok behavior for the tests module.

- Fixed text-blocks trailing whitespace warning in MetamodelGeneratorTest
- Added AutoService dependency to test annotation processor classpath to
  resolve "Cannot find annotation method" warning
- Updated lombok.config documentation to clarify that @nonnull warnings on
  primitives are intentional for constructor generation in test fixtures

Author: bsbodden

redis-om-spring/src/main/java/com/redis/om/spring/repository/query/lexicographic/LexicographicQueryExecutor.java

@@ -6,6 +6,8 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.springframework.data.domain.Range;
+import org.springframework.data.redis.connection.Limit;
 import org.springframework.data.util.Pair;
 import org.springframework.util.ReflectionUtils;
 
@@ -176,9 +178,8 @@ private Set<String> executeRangeQuery(String sortedSetKey, QueryClause queryClau
         // When doing greater than, we need to exclude exact matches with the same prefix
         // Since our format is "value#id", we append a high character to ensure we skip all entries with this prefix
         String gtParam = params[0].toString() + "\uffff"; // Unicode max character
-        Set<String> results = modulesOperations.template().opsForZSet().rangeByLex(sortedSetKey,
-            org.springframework.data.redis.connection.RedisZSetCommands.Range.range().gt(gtParam),
-            org.springframework.data.redis.connection.RedisZSetCommands.Limit.unlimited());
+        Set<String> results = modulesOperations.template().opsForZSet().rangeByLex(sortedSetKey, Range.rightUnbounded(
+            Range.Bound.exclusive(gtParam)), Limit.unlimited());
         logger.debug(String.format("ZRANGEBYLEX %s (%s +inf returned: %s", sortedSetKey, gtParam, results));
         return results;
 
@@ -187,37 +188,33 @@ private Set<String> executeRangeQuery(String sortedSetKey, QueryClause queryClau
         // For less than, we need to ensure we don't include the value itself
         // Since format is "value#id", we need to get everything before "value#" (excluded)
         String ltParam = params[0].toString() + "#"; // Exclude exact matches with this prefix
-        return modulesOperations.template().opsForZSet().rangeByLex(sortedSetKey,
-            org.springframework.data.redis.connection.RedisZSetCommands.Range.range().lt(ltParam),
-            org.springframework.data.redis.connection.RedisZSetCommands.Limit.unlimited());
+        return modulesOperations.template().opsForZSet().rangeByLex(sortedSetKey, Range.leftUnbounded(Range.Bound
+            .exclusive(ltParam)), Limit.unlimited());
 
       case TEXT_GREATER_THAN_EQUAL:
       case TAG_GREATER_THAN_EQUAL:
         // For greater than or equal, we include the value itself
         // Since format is "value#id", we start from exactly "value#"
         String gteParam = params[0].toString() + "#"; // Include exact matches with this prefix
-        return modulesOperations.template().opsForZSet().rangeByLex(sortedSetKey,
-            org.springframework.data.redis.connection.RedisZSetCommands.Range.range().gte(gteParam),
-            org.springframework.data.redis.connection.RedisZSetCommands.Limit.unlimited());
+        return modulesOperations.template().opsForZSet().rangeByLex(sortedSetKey, Range.rightUnbounded(Range.Bound
+            .inclusive(gteParam)), Limit.unlimited());
 
       case TEXT_LESS_THAN_EQUAL:
       case TAG_LESS_THAN_EQUAL:
         // For less than or equal, we include all values with this prefix
         // Since format is "value#id", we use high unicode char to include all IDs with this value
         String lteParam = params[0].toString() + "\uffff"; // Include all exact matches with this prefix
-        return modulesOperations.template().opsForZSet().rangeByLex(sortedSetKey,
-            org.springframework.data.redis.connection.RedisZSetCommands.Range.range().lte(lteParam),
-            org.springframework.data.redis.connection.RedisZSetCommands.Limit.unlimited());
+        return modulesOperations.template().opsForZSet().rangeByLex(sortedSetKey, Range.leftUnbounded(Range.Bound
+            .inclusive(lteParam)), Limit.unlimited());
 
       case TEXT_BETWEEN:
       case TAG_BETWEEN:
         // For between queries, we include both bounds
         // Start from exactly "minValue#" (inclusive) to "maxValue\uffff" (inclusive of all with maxValue)
         String minParam = params[0].toString() + "#";
         String maxParam = params[1].toString() + "\uffff";
-        return modulesOperations.template().opsForZSet().rangeByLex(sortedSetKey,
-            org.springframework.data.redis.connection.RedisZSetCommands.Range.range().gte(minParam).lte(maxParam),
-            org.springframework.data.redis.connection.RedisZSetCommands.Limit.unlimited());
+        return modulesOperations.template().opsForZSet().rangeByLex(sortedSetKey, Range.closed(minParam, maxParam),
+            Limit.unlimited());
 
       default:
         return Collections.emptySet();

redis-om-spring/src/main/java/com/redis/om/spring/search/stream/predicates/lexicographic/LexicographicBetweenPredicate.java

@@ -5,6 +5,9 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import org.springframework.data.domain.Range;
+import org.springframework.data.redis.connection.Limit;
+
 import com.redis.om.spring.indexing.RediSearchIndexer;
 import com.redis.om.spring.metamodel.SearchFieldAccessor;
 import com.redis.om.spring.ops.RedisModulesOperations;
@@ -121,9 +124,8 @@ public Node apply(Node root) {
     // Start from exactly "minValue#" (inclusive) to "maxValue\uffff" (inclusive of all with maxValue)
     String minParam = min.toString() + "#";
     String maxParam = max.toString() + "\uffff";
-    Set<String> matches = rmo.template().opsForZSet().rangeByLex(sortedSetKey,
-        org.springframework.data.redis.connection.RedisZSetCommands.Range.range().gte(minParam).lte(maxParam),
-        org.springframework.data.redis.connection.RedisZSetCommands.Limit.unlimited());
+    Set<String> matches = rmo.template().opsForZSet().rangeByLex(sortedSetKey, Range.closed(minParam, maxParam), Limit
+        .unlimited());
 
     if (matches == null || matches.isEmpty()) {
       // No matches, return a query that matches nothing by using an impossible ID

redis-om-spring/src/main/java/com/redis/om/spring/search/stream/predicates/lexicographic/LexicographicGreaterThanPredicate.java

@@ -5,6 +5,9 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import org.springframework.data.domain.Range;
+import org.springframework.data.redis.connection.Limit;
+
 import com.redis.om.spring.indexing.RediSearchIndexer;
 import com.redis.om.spring.metamodel.SearchFieldAccessor;
 import com.redis.om.spring.ops.RedisModulesOperations;
@@ -107,9 +110,8 @@ public Node apply(Node root) {
     // For greater than, we need to exclude exact matches with the same prefix
     // Since our format is "value#id", we append a high character to ensure we skip all entries with this prefix
     String gtParam = value.toString() + "\uffff"; // Unicode max character
-    Set<String> matches = rmo.template().opsForZSet().rangeByLex(sortedSetKey,
-        org.springframework.data.redis.connection.RedisZSetCommands.Range.range().gt(gtParam),
-        org.springframework.data.redis.connection.RedisZSetCommands.Limit.unlimited());
+    Set<String> matches = rmo.template().opsForZSet().rangeByLex(sortedSetKey, Range.rightUnbounded(Range.Bound
+        .exclusive(gtParam)), Limit.unlimited());
 
     if (matches == null || matches.isEmpty()) {
       // No matches, return a query that matches nothing by using an impossible ID

redis-om-spring/src/main/java/com/redis/om/spring/search/stream/predicates/lexicographic/LexicographicLessThanPredicate.java

@@ -5,6 +5,9 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import org.springframework.data.domain.Range;
+import org.springframework.data.redis.connection.Limit;
+
 import com.redis.om.spring.indexing.RediSearchIndexer;
 import com.redis.om.spring.metamodel.SearchFieldAccessor;
 import com.redis.om.spring.ops.RedisModulesOperations;
@@ -107,9 +110,8 @@ public Node apply(Node root) {
     // For less than, we need to ensure we don't include the value itself
     // Since format is "value#id", we need to get everything before "value#" (excluded)
     String ltParam = value.toString() + "#"; // Exclude exact matches with this prefix
-    Set<String> matches = rmo.template().opsForZSet().rangeByLex(sortedSetKey,
-        org.springframework.data.redis.connection.RedisZSetCommands.Range.range().lt(ltParam),
-        org.springframework.data.redis.connection.RedisZSetCommands.Limit.unlimited());
+    Set<String> matches = rmo.template().opsForZSet().rangeByLex(sortedSetKey, Range.leftUnbounded(Range.Bound
+        .exclusive(ltParam)), Limit.unlimited());
 
     if (matches == null || matches.isEmpty()) {
       // No matches, return a query that matches nothing by using an impossible ID

tests/build.gradle

@@ -39,6 +39,7 @@ dependencies {
 	// Important for RedisOM annotation processing!
 	annotationProcessor project(':redis-om-spring')
 	testAnnotationProcessor project(':redis-om-spring')
+	testAnnotationProcessor "com.google.auto.service:auto-service:${autoServiceVersion}"
 
 	// Lombok
 	compileOnly 'org.projectlombok:lombok'

tests/lombok.config

@@ -0,0 +1,10 @@
+# Lombok configuration for tests module
+
+# Note: @NonNull on primitive types generates warnings but is used intentionally
+# to include primitive fields in @RequiredArgsConstructor.
+# These warnings are expected and can be ignored as they don't affect functionality.
+# The primitives are used in test fixtures where we want them included in the
+# constructor for test data setup.
+
+lombok.nonNull.exceptionType = IllegalArgumentException
+config.stopBubbling = true

tests/src/test/java/com/redis/om/spring/annotations/LexicographicLessThanDebugTest.java

@@ -7,6 +7,7 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Range;
 import org.springframework.data.redis.core.RedisTemplate;
 
 import java.util.Arrays;
@@ -56,7 +57,7 @@ void setup() {
 
     // Test direct ZRANGEBYLEX
     Set<String> directQuery = redisTemplate.opsForZSet().rangeByLex(nameLexKey,
-        org.springframework.data.redis.connection.RedisZSetCommands.Range.range().lt("Product Delta#"));
+        Range.leftUnbounded(Range.Bound.exclusive("Product Delta#")));
     System.out.println("Direct ZRANGEBYLEX LT 'Product Delta#': " + directQuery);
   }
 

tests/src/test/java/com/redis/om/spring/annotations/LexicographicQueryDebugTest.java

@@ -9,6 +9,7 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Range;
 import org.springframework.data.redis.core.RedisTemplate;
 
 import java.util.Arrays;
@@ -78,7 +79,7 @@ void setup() {
 
     // Test direct sorted set query
     Set<String> directQuery = redisTemplate.opsForZSet().rangeByLex(skuLexKey,
-        org.springframework.data.redis.connection.RedisZSetCommands.Range.range().gt("product002"));
+        Range.rightUnbounded(Range.Bound.exclusive("product002")));
     System.out.println("Direct ZRANGEBYLEX result: " + directQuery);
   }
 

tests/src/test/java/com/redis/om/spring/metamodel/MetamodelGeneratorTest.java

@@ -429,7 +429,7 @@ public final class IdOnly$ {
              _THIS = new MetamodelField<IdOnly, IdOnly>("__this", IdOnly.class, true);
            }
          }
-         """;
+        """;
 
     assertThat(fileContents).containsIgnoringWhitespaces(expected);
   }