Added Array, Set and operator 'IN'

thunx-bom/build.gradle

@@ -17,7 +17,7 @@ dependencies {
         api project(':thunx-encoding-json')
         api project(':thunx-predicates-querydsl')
 
-        api 'com.contentgrid.opa-java-client:opa-async-java-client:0.4.0'
+        api 'com.contentgrid.opa-java-client:opa-async-java-client:0.4.1-SNAPSHOT'
     }
 }
 

thunx-model/src/main/java/com/contentgrid/thunx/predicates/model/CollectionValue.java

@@ -0,0 +1,30 @@
+package com.contentgrid.thunx.predicates.model;
+
+import lombok.EqualsAndHashCode;
+
+import java.util.Collection;
+
+@EqualsAndHashCode
+public class CollectionValue implements Scalar<Collection<Scalar<?>>> {
+
+    private final Collection<Scalar<?>> value;
+
+    @Override
+    public Collection<Scalar<?>> getValue() {
+        return value;
+    }
+
+    protected CollectionValue(Collection<Scalar<?>> value) {
+        this.value = value;
+    }
+
+    @Override
+    public Class<? extends Collection<Scalar<?>>> getResultType() {
+        return null;
+    }
+
+    @Override
+    public <R, C> R accept(ThunkExpressionVisitor<R, C> visitor, C context) {
+        return visitor.visit(this, context);
+    }
+}

thunx-model/src/main/java/com/contentgrid/thunx/predicates/model/Comparison.java

@@ -83,6 +83,18 @@ public static Comparison lessOrEquals(ThunkExpression<?> left, ThunkExpression<?
         return new Comparison(Operator.LESS_THEN_OR_EQUAL_TO, left, right);
     }
 
+    public static Comparison in (@NonNull List<ThunkExpression<?>> terms) {
+        assertTermSizeIsTwo(terms);
+        return in(terms.get(0), terms.get(1));
+    }
+
+    public static Comparison in (ThunkExpression<?> left, ThunkExpression<?> right) {
+        if (right == null || ((CollectionValue) right).getValue().isEmpty()) {
+            return null;
+        }
+        return new Comparison(Operator.IN, left, right);
+    }
+
     private static void assertTermSizeIsTwo(List<ThunkExpression<?>> terms) {
         if (terms.size() == 2) {
             return;

thunx-model/src/main/java/com/contentgrid/thunx/predicates/model/FunctionExpression.java

@@ -36,6 +36,7 @@ enum Operator {
         GREATER_THAN_OR_EQUAL_TO("gte", Boolean.class, (FunctionExpressionFactory<Boolean>) Comparison::greaterOrEquals),
         LESS_THAN("lt", Boolean.class, (FunctionExpressionFactory<Boolean>) Comparison::less),
         LESS_THEN_OR_EQUAL_TO("lte", Boolean.class, (FunctionExpressionFactory<Boolean>) Comparison::lessOrEquals),
+        IN("internal.member_2", Boolean.class, (FunctionExpressionFactory<Boolean>) Comparison::in),
 
         // Logical operator
         AND("and", Boolean.class, (FunctionExpressionFactory<Boolean>) LogicalOperation::uncheckedConjunction),

thunx-model/src/main/java/com/contentgrid/thunx/predicates/model/Scalar.java

@@ -1,6 +1,7 @@
 package com.contentgrid.thunx.predicates.model;
 
 import java.math.BigDecimal;
+import java.util.Collection;
 
 public interface Scalar<T> extends ThunkExpression<T> {
 
@@ -30,6 +31,10 @@ static BooleanValue of(boolean value) {
         return new BooleanValue(value);
     }
 
+    static CollectionValue of(Collection<Scalar<?>> value) {
+        return new CollectionValue(value);
+    }
+
     static NullValue nullValue() {
         return NullValue.INSTANCE;
     }

thunx-model/src/main/java/com/contentgrid/thunx/predicates/model/ThunkExpressionVisitor.java

@@ -6,5 +6,8 @@ public interface ThunkExpressionVisitor<T, C> {
     T visit(FunctionExpression<?> functionExpression, C context);
     T visit(SymbolicReference symbolicReference, C context);
     T visit(Variable variable, C context);
+    default T visit(CollectionValue collection, C context) {
+        throw new UnsupportedOperationException("Visit for CollectionValue is not yet implemented.");
+    }
 
 }

thunx-pdp-opa/src/main/java/com/contentgrid/thunx/pdp/opa/QuerySetToThunkExpressionConverter.java

@@ -1,6 +1,7 @@
 package com.contentgrid.thunx.pdp.opa;
 
 
+import com.contentgrid.opa.rego.ast.Expression;
 import com.contentgrid.opa.rego.ast.Query;
 import com.contentgrid.opa.rego.ast.QuerySet;
 import com.contentgrid.opa.rego.ast.RegoVisitor;
@@ -11,6 +12,7 @@
 import com.contentgrid.opa.rego.ast.Term.Null;
 import com.contentgrid.opa.rego.ast.Term.Numeric;
 import com.contentgrid.opa.rego.ast.Term.Ref;
+import com.contentgrid.opa.rego.ast.Term.SetTerm;
 import com.contentgrid.opa.rego.ast.Term.Text;
 import com.contentgrid.opa.rego.ast.Term.Var;
 import com.contentgrid.thunx.predicates.model.Comparison;
@@ -21,8 +23,12 @@
 import com.contentgrid.thunx.predicates.model.SymbolicReference.StringPathElement;
 import com.contentgrid.thunx.predicates.model.ThunkExpression;
 import com.contentgrid.thunx.predicates.model.Variable;
+import lombok.Getter;
+
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -57,6 +63,7 @@ public ThunkExpression<Boolean> convert(Query query) {
 
         var expressions = query.stream()
                 .map(this::convert)
+                .filter(Objects::nonNull)
                 .peek(expr -> {
                     if (!Boolean.class.isAssignableFrom(expr.getResultType())) {
                         // there are non-boolean expressions in here ?
@@ -92,7 +99,8 @@ static class PredicatesVisitor implements RegoVisitor<ThunkExpression<?>> {
                 Map.entry("gt", Comparison::greater),
                 Map.entry("gte", Comparison::greaterOrEquals),
                 Map.entry("lt", Comparison::less),
-                Map.entry("lte", Comparison::lessOrEquals)
+                Map.entry("lte", Comparison::lessOrEquals),
+                Map.entry("internal.member_2", Comparison::in)
         );
 
         @Override
@@ -279,6 +287,89 @@ public ThunkExpression<?> visit(Null nullValue) {
 
         @Override
         public ThunkExpression<?> visit(ArrayTerm arrayTerm) {
+            ScalarCollectingRegoVisitor collectingRegoVisitor = new ScalarCollectingRegoVisitor();
+            arrayTerm.getValue().forEach(scalarTerm -> scalarTerm.accept(collectingRegoVisitor));
+            return Scalar.of(collectingRegoVisitor.getScalars());
+        }
+
+        @Override
+        public ThunkExpression<?> visit(SetTerm setTerm) {
+            ScalarCollectingRegoVisitor collectingRegoVisitor = new ScalarCollectingRegoVisitor();
+            setTerm.getValue().forEach(scalarTerm -> scalarTerm.accept(collectingRegoVisitor));
+            return Scalar.of(collectingRegoVisitor.getScalars());
+        }
+    }
+
+    static class ScalarCollectingRegoVisitor implements RegoVisitor<ThunkExpression<?>> {
+
+        @Getter
+        List<Scalar<?>> scalars = new ArrayList<>();
+
+        @Override
+        public ThunkExpression<?> visit(QuerySet querySet) {
+            return null;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(Query query) {
+            return null;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(Expression expression) {
+            return null;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(Ref ref) {
+            return null;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(Call call) {
+            return null;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(Var var) {
+            return null;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(Numeric numeric) {
+            Scalar<?> scalar = Scalar.of(numeric.getValue());
+            scalars.add(scalar);
+            return scalar;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(Text text) {
+            Scalar<?> scalar = Scalar.of(text.getValue());
+            scalars.add(scalar);
+            return scalar;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(Bool bool) {
+            return null;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(Null aNull) {
+            Scalar<?> scalar = Scalar.nullValue();
+            scalars.add(scalar);
+            return scalar;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(ArrayTerm arrayTerm) {
+            arrayTerm.getValue().forEach(scalarTerm -> scalarTerm.accept(this));
+            return null;
+        }
+
+        @Override
+        public ThunkExpression<?> visit(SetTerm setTerm) {
+            setTerm.getValue().forEach(scalarTerm -> scalarTerm.accept(this));
             return null;
         }
     }

thunx-pdp-opa/src/test/java/com/contentgrid/thunx/pdp/opa/QuerySetToThunkExpressionConverterTest.java

@@ -11,6 +11,8 @@
 import com.contentgrid.thunx.predicates.model.Scalar;
 import com.contentgrid.thunx.predicates.model.SymbolicReference;
 import java.util.List;
+import java.util.Set;
+
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
@@ -135,6 +137,25 @@ void less_or_equals() {
             ));
         }
 
+        @Test
+        void in() {
+            // input.entity.security in {4, 5}
+            var opaExpr = new Expression(0, List.of(
+                    new Term.Ref(List.of(new Term.Var("internal"), new Term.Text("member_2"))),
+                    new Term.Ref(List.of(
+                            new Term.Var("input"),
+                            new Term.Text("entity"),
+                            new Term.Text("security")
+                    )),
+                    new Term.SetTerm(Set.of(new Term.Numeric(4), new Term.Numeric(5)))
+            ));
+
+            assertThat(converter.convert(opaExpr)).isEqualTo(Comparison.in(
+                    SymbolicReference.of("entity", path -> path.string("security")),
+                    Scalar.of(Set.of(new Term.Numeric(4), new Term.Numeric(5)))
+            ));
+        }
+
 
     }
 

thunx-predicates-querydsl/src/main/java/com/contentgrid/thunx/predicates/querydsl/QueryDslConvertingVisitor.java

@@ -1,5 +1,7 @@
 package com.contentgrid.thunx.predicates.querydsl;
 
+import com.contentgrid.opa.rego.ast.Term;
+import com.contentgrid.thunx.predicates.model.CollectionValue;
 import com.contentgrid.thunx.predicates.model.FunctionExpression;
 import com.contentgrid.thunx.predicates.model.Scalar;
 import com.contentgrid.thunx.predicates.model.SymbolicReference;
@@ -13,18 +15,19 @@
 import com.querydsl.core.types.Predicate;
 import com.querydsl.core.types.dsl.Expressions;
 import com.querydsl.core.types.dsl.PathBuilder;
-import java.lang.reflect.Field;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
 import javax.persistence.Embedded;
 import javax.persistence.ManyToMany;
 import javax.persistence.ManyToOne;
 import javax.persistence.OneToMany;
 import javax.persistence.OneToOne;
-import lombok.AccessLevel;
-import lombok.NonNull;
-import lombok.RequiredArgsConstructor;
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 @RequiredArgsConstructor(access = AccessLevel.PACKAGE)
 class QueryDslConvertingVisitor implements ThunkExpressionVisitor<Expression<?>, QueryDslConversionContext> {
@@ -70,6 +73,9 @@ public Expression<?> visit(FunctionExpression<?> function, QueryDslConversionCon
             case LESS_THAN:
                 assertTwoTerms(terms);
                 return Expressions.booleanOperation(Ops.LT, terms.toArray(new Expression[0]));
+            case IN:
+                assertTwoTerms(terms);
+                return ExpressionUtils.predicate(Ops.IN, terms.get(0), terms.get(1));
             case OR:
                 return ExpressionUtils.anyOf(terms.stream().map(term -> (Predicate) term).collect(Collectors.toList()));
             case AND:
@@ -121,21 +127,21 @@ public Expression<?> visit(SymbolicReference symbolicReference, QueryDslConversi
      * annotations
      */
     private static void assertNotReferencingEntity(@NonNull SymbolicReference symbolicReference,
-            @NonNull PathBuilder<?> builder) {
+                                                   @NonNull PathBuilder<?> builder) {
 
         var blacklist = Set.of(OneToOne.class, OneToMany.class, ManyToOne.class, ManyToMany.class, Embedded.class);
         var element = builder.getAnnotatedElement();
         if (blacklist.stream().anyMatch(element::isAnnotationPresent)) {
             var msg = String.format("Cannot use `%s` as an expression, because it refers to a relation, not an attribute.",
                     symbolicReference,
-                    element instanceof Field ? ((Field)element).getType().getName() + " " + ((Field)element).getName() : element);
+                    element instanceof Field ? ((Field) element).getType().getName() + " " + ((Field) element).getName() : element);
 
             throw new IllegalArgumentException(msg);
         }
     }
 
     private PathBuilder<?> traversePath(SymbolicReference symbolicReference, PathBuilder<?> builder,
-            String pathElement) {
+                                        String pathElement) {
 
         // we want to build a typed path, making sure the segments in the path are valid
         var property = this.accessStrategy.getProperty(builder.getType(), pathElement).orElseThrow(() -> {
@@ -173,4 +179,9 @@ public Expression<?> visit(Variable variable, QueryDslConversionContext context)
         // TODO could there be more variables available, than just the subject-path-builder ?
         throw new UnsupportedOperationException("converting variable to querydsl is not yet implemented");
     }
+
+    @Override
+    public Expression<?> visit(CollectionValue collection, QueryDslConversionContext context) {
+        return Expressions.constant(collection.getValue().stream().map(Scalar::getValue).collect(Collectors.toList()));
+    }
 }

thunx-visitor-reducer/src/main/java/com/contentgrid/thunx/visitor/reducer/ThunkReducerVisitor.java

@@ -1,5 +1,6 @@
 package com.contentgrid.thunx.visitor.reducer;
 
+import com.contentgrid.thunx.predicates.model.CollectionValue;
 import com.contentgrid.thunx.predicates.model.FunctionExpression;
 import com.contentgrid.thunx.predicates.model.FunctionExpression.Operator;
 import com.contentgrid.thunx.predicates.model.LogicalOperation;
@@ -54,4 +55,9 @@ public ThunkExpression<?> visit(SymbolicReference symbolicReference) {
     public ThunkExpression<?> visit(Variable variable) {
         return variable;
     }
+
+    @Override
+    public ThunkExpression<?> visit(CollectionValue collection, Void context) {
+        return collection;
+    }
 }