feature: implement metamodel @reference handling

redis-om-spring/src/main/java/com/redis/om/spring/metamodel/MetamodelGenerator.java

@@ -14,6 +14,7 @@
 import com.redis.om.spring.util.ObjectUtils;
 import com.squareup.javapoet.*;
 import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.Reference;
 import org.springframework.data.geo.Point;
 import org.springframework.data.redis.core.RedisHash;
 import org.springframework.util.ClassUtils;
@@ -226,8 +227,12 @@ private List<Triple<ObjectGraphFieldSpec, FieldSpec, CodeBlock>> processFieldMet
 
     var indexed = field.getAnnotation(Indexed.class);
     var searchable = field.getAnnotation(Searchable.class);
+    var reference = field.getAnnotation(Reference.class);
 
-    if (searchable != null) {
+    if (indexed != null && reference != null) {
+      targetInterceptor = ReferenceField.class;
+    }
+    else if (searchable != null) {
       targetInterceptor = TextField.class;
     } else if (indexed != null || field.getAnnotation(Id.class) != null) {
       try {

redis-om-spring/src/main/java/com/redis/om/spring/metamodel/indexed/ReferenceField.java

@@ -0,0 +1,20 @@
+package com.redis.om.spring.metamodel.indexed;
+
+import com.redis.om.spring.metamodel.MetamodelField;
+import com.redis.om.spring.metamodel.SearchFieldAccessor;
+import com.redis.om.spring.search.stream.predicates.reference.EqualPredicate;
+import com.redis.om.spring.search.stream.predicates.reference.NotEqualPredicate;
+
+public class ReferenceField<E, T> extends MetamodelField<E, T> {
+  public ReferenceField(SearchFieldAccessor field, boolean indexed) {
+    super(field, indexed);
+  }
+
+  public EqualPredicate<E,T> eq(T value) {
+    return new EqualPredicate<>(searchFieldAccessor,value);
+  }
+
+  public NotEqualPredicate<E,T> notEq(T value) {
+    return new NotEqualPredicate<>(searchFieldAccessor,value);
+  }
+}

redis-om-spring/src/main/java/com/redis/om/spring/search/stream/predicates/reference/EqualPredicate.java

@@ -0,0 +1,47 @@
+package com.redis.om.spring.search.stream.predicates.reference;
+
+import com.redis.om.spring.metamodel.SearchFieldAccessor;
+import com.redis.om.spring.search.stream.predicates.BaseAbstractPredicate;
+import com.redis.om.spring.search.stream.predicates.jedis.JedisValues;
+import org.apache.commons.lang3.ObjectUtils;
+import redis.clients.jedis.search.querybuilder.Node;
+import redis.clients.jedis.search.querybuilder.QueryBuilders;
+import redis.clients.jedis.search.querybuilder.Values;
+
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.Date;
+
+import static com.redis.om.spring.util.ObjectUtils.getIdFieldForEntity;
+
+public class EqualPredicate<E, T> extends BaseAbstractPredicate<E, T> {
+  private final Object referenceId;
+  private final T value;
+
+  public EqualPredicate(SearchFieldAccessor field, T value) {
+    super(field);
+    this.value = value;
+    this.referenceId = getIdFieldForEntity(value);
+  }
+
+  public T getValue() {
+    return value;
+  }
+
+  @Override
+  public Node apply(Node root) {
+    Class<?> cls = referenceId.getClass();
+    if (cls == Integer.class) {
+      return QueryBuilders.intersect(root).add(getSearchAlias(), Values.eq(Integer.parseInt(referenceId.toString())));
+    } else if (cls == Long.class) {
+      return QueryBuilders.intersect(root).add(getSearchAlias(), Values.eq(Long.parseLong(referenceId.toString())));
+    } else if (cls == Double.class) {
+      return QueryBuilders.intersect(root).add(getSearchAlias(), Values.eq(Double.parseDouble(referenceId.toString())));
+    } else if (CharSequence.class.isAssignableFrom(cls)) {
+      return QueryBuilders.intersect(root).add(getSearchAlias(), "{" + referenceId + "}");
+    } else {
+      return root;
+    }
+  }
+}

redis-om-spring/src/main/java/com/redis/om/spring/search/stream/predicates/reference/NotEqualPredicate.java

@@ -0,0 +1,40 @@
+package com.redis.om.spring.search.stream.predicates.reference;
+
+import com.redis.om.spring.metamodel.SearchFieldAccessor;
+import com.redis.om.spring.search.stream.predicates.BaseAbstractPredicate;
+import redis.clients.jedis.search.querybuilder.Node;
+import redis.clients.jedis.search.querybuilder.QueryBuilders;
+import redis.clients.jedis.search.querybuilder.Values;
+
+import static com.redis.om.spring.util.ObjectUtils.getIdFieldForEntity;
+
+public class NotEqualPredicate<E, T> extends BaseAbstractPredicate<E, T> {
+  private final Object referenceId;
+  private T value;
+
+  public NotEqualPredicate(SearchFieldAccessor field, T value) {
+    super(field);
+    this.value = value;
+    this.referenceId = getIdFieldForEntity(value);
+  }
+
+  public T getValue() {
+    return value;
+  }
+
+  @Override
+  public Node apply(Node root) {
+    Class<?> cls = referenceId.getClass();
+    if (cls == Integer.class) {
+      return QueryBuilders.intersect(root).add(QueryBuilders.disjunct(getSearchAlias(), Values.eq(Integer.parseInt(referenceId.toString()))));
+    } else if (cls == Long.class) {
+      return QueryBuilders.intersect(root).add(QueryBuilders.disjunct(getSearchAlias(), Values.eq(Long.parseLong(referenceId.toString()))));
+    } else if (cls == Double.class) {
+      return QueryBuilders.intersect(root).add(QueryBuilders.disjunct(getSearchAlias(), Values.eq(Double.parseDouble(referenceId.toString()))));
+    } else if (CharSequence.class.isAssignableFrom(cls)) {
+      return QueryBuilders.intersect(root).add(QueryBuilders.disjunct(getSearchAlias(), "{" + referenceId + "}"));
+    } else {
+      return root;
+    }
+  }
+}