chore | adding the support for querying multi interaction filters

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/EntityDaoModule.java

@@ -65,6 +65,12 @@ protected void configure() {
             new TypeLiteral<
                 Converter<Collection<AttributeAssociation<FilterArgument>>, Filter>>() {}));
 
+    requireBinding(
+        Key.get(
+            new TypeLiteral<
+                Converter<
+                    Collection<Collection<AttributeAssociation<FilterArgument>>>, Filter>>() {}));
+
     requireBinding(
         Key.get(
             new TypeLiteral<

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityInteractionRequestBuilder.java

@@ -5,6 +5,7 @@
 import io.reactivex.rxjava3.core.Observable;
 import io.reactivex.rxjava3.core.Single;
 import java.util.Collection;
+import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -31,13 +32,15 @@ class GatewayServiceEntityInteractionRequestBuilder {
   private final Converter<Collection<AttributeRequest>, Set<Expression>> selectionConverter;
   private final Converter<Collection<MetricAggregationRequest>, Set<Expression>>
       aggregationConverter;
-  private final Converter<Collection<AttributeAssociation<FilterArgument>>, Filter> filterConverter;
+  private final Converter<Collection<Collection<AttributeAssociation<FilterArgument>>>, Filter>
+      filterConverter;
 
   @Inject
   GatewayServiceEntityInteractionRequestBuilder(
       Converter<Collection<AttributeRequest>, Set<Expression>> selectionConverter,
       Converter<Collection<MetricAggregationRequest>, Set<Expression>> aggregationConverter,
-      Converter<Collection<AttributeAssociation<FilterArgument>>, Filter> filterConverter) {
+      Converter<Collection<Collection<AttributeAssociation<FilterArgument>>>, Filter>
+          filterConverter) {
     this.selectionConverter = selectionConverter;
     this.aggregationConverter = aggregationConverter;
     this.filterConverter = filterConverter;
@@ -69,22 +72,28 @@ private Single<Set<Expression>> collectSelectionsAndAggregations(EdgeSetGroupReq
   }
 
   private Single<Filter> buildEntityInteractionFilter(EdgeSetGroupRequest request) {
-    return Observable.fromIterable(request.entityTypes()) // add entity types filter
-        .collect(Collectors.toUnmodifiableSet())
+    return this.filterConverter.convert(this.buildFilterArguments(request));
+  }
+
+  private Collection<Collection<AttributeAssociation<FilterArgument>>> buildFilterArguments(
+      EdgeSetGroupRequest request) {
+    return request.filterArguments().entrySet().stream()
         .map(
-            entityTypes ->
-                AttributeAssociation.<FilterArgument>of(
-                    request.neighborTypeAttribute().attributeExpressionAssociation().attribute(),
-                    new EntityNeighborTypeFilter(
-                        request.neighborTypeAttribute().attributeExpressionAssociation().value(),
-                        entityTypes)))
-        .flatMap(
-            filterAssociation ->
-                this.filterConverter.convert(
-                    Stream.concat(
-                            request.filterArguments().stream(), // add all other filters
-                            Stream.of(filterAssociation))
-                        .collect(Collectors.toUnmodifiableSet())));
+            entry ->
+                Stream.concat(
+                        Stream.of(buildEntityTypeFilter(request, entry.getKey())),
+                        entry.getValue().stream())
+                    .collect(Collectors.toUnmodifiableList()))
+        .collect(Collectors.toUnmodifiableList());
+  }
+
+  private AttributeAssociation<FilterArgument> buildEntityTypeFilter(
+      EdgeSetGroupRequest request, String entityType) {
+    return AttributeAssociation.of(
+        request.neighborTypeAttribute().attributeExpressionAssociation().attribute(),
+        new EntityNeighborTypeFilter(
+            request.neighborTypeAttribute().attributeExpressionAssociation().value(),
+            List.of(entityType)));
   }
 
   @Value

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/joiner/DefaultEntityJoinerBuilder.java

@@ -320,7 +320,8 @@ private static class EmptyEdgeSetGroupRequest implements EdgeSetGroupRequest {
     Set<String> entityTypes = Collections.emptySet();
     Collection<AttributeRequest> attributeRequests = Collections.emptyList();
     Collection<MetricAggregationRequest> metricAggregationRequests = Collections.emptyList();
-    Collection<AttributeAssociation<FilterArgument>> filterArguments = Collections.emptyList();
+    Map<String, Collection<AttributeAssociation<FilterArgument>>> filterArguments =
+        Collections.emptyMap();
     AttributeRequest neighborIdAttribute = null;
     AttributeRequest neighborTypeAttribute = null;
 

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/request/EdgeRequestBuilder.java

@@ -3,11 +3,11 @@
 import static io.reactivex.rxjava3.core.Single.zip;
 
 import graphql.schema.SelectedField;
-import io.grpc.Status;
 import io.reactivex.rxjava3.core.Single;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiFunction;
@@ -89,31 +89,30 @@ private Single<EdgeSetGroupRequest> buildEdgeRequest(
       Stream<SelectedField> edgeSetFields,
       EdgeType edgeType) {
     Set<SelectedField> edgeFields = edgeSetFields.collect(Collectors.toUnmodifiableSet());
-    List<FilterArgument> filterArguments = this.getFilters(edgeFields);
-
-    if (!filterArguments.isEmpty() && edgeFields.size() > 1) {
-      throw Status.UNIMPLEMENTED
-          .withDescription("Cannot specify more than one edge type with edge filters")
-          .asRuntimeException();
-    }
-
-    Map<String, Set<SelectedField>> edgesByType = this.getEdgesByType(edgeFields.stream());
-    Set<SelectedField> allEdges =
-        edgesByType.values().stream()
+    Map<String, Set<SelectedField>> edgesSelectionsByType =
+        this.getEdgesSelectionByType(edgeFields.stream());
+    Set<SelectedField> allEdgesSelections =
+        edgesSelectionsByType.values().stream()
             .flatMap(Collection::stream)
             .collect(Collectors.toUnmodifiableSet());
 
+    Map<String, Set<FilterArgument>> edgesFiltersByType =
+        getEdgesFiltersByType(edgeFields.stream());
+    Map<String, Collection<AttributeAssociation<FilterArgument>>> filterArguments =
+        edgesFiltersByType.entrySet().stream()
+            .collect(
+                Collectors.toMap(
+                    Entry::getKey, entry -> getFilterArguments(context, entry.getValue())));
     return zip(
-        this.getRequestedAndRequiredAttributes(context, allEdges, edgeType),
+        this.getRequestedAndRequiredAttributes(context, allEdgesSelections, edgeType),
         this.getNeighborIdAttribute(context, edgeType),
         this.getNeighborTypeAttribute(context, edgeType),
         this.metricAggregationRequestBuilder.build(
-            context, HypertraceAttributeScopeString.INTERACTION, allEdges.stream()),
-        this.filterRequestBuilder.build(
-            context, HypertraceAttributeScopeString.INTERACTION, filterArguments),
+            context, HypertraceAttributeScopeString.INTERACTION, allEdgesSelections.stream()),
+        Single.just(filterArguments),
         (attributeRequests, neighborIdRequest, neighborTypeRequest, metricRequests, filters) ->
             new DefaultEdgeSetGroupRequest(
-                edgesByType.keySet(),
+                edgesSelectionsByType.keySet(),
                 attributeRequests,
                 metricRequests,
                 neighborIdRequest,
@@ -127,12 +126,12 @@ private Single<EdgeSetGroupRequest> buildEdgeRequest(
                             timeRange,
                             space,
                             neighborIds,
-                            edgesByType.get(entityType)),
+                            edgesSelectionsByType.get(entityType)),
                 filters));
   }
 
-  private Map<String, Set<SelectedField>> getEdgesByType(Stream<SelectedField> edgeSetStream) {
-
+  private Map<String, Set<SelectedField>> getEdgesSelectionByType(
+      Stream<SelectedField> edgeSetStream) {
     return edgeSetStream.collect(
         Collectors.groupingBy(
             this::getEntityType,
@@ -183,15 +182,26 @@ private Single<AttributeRequest> getNeighborIdAttribute(
     }
   }
 
-  private List<FilterArgument> getFilters(Set<SelectedField> selectedFields) {
-    return selectedFields.stream()
-        .map(
-            selectedField ->
-                this.argumentDeserializer.deserializeObjectList(
-                    selectedField.getArguments(), FilterArgument.class))
-        .flatMap(Optional::stream)
-        .flatMap(Collection::stream)
-        .collect(Collectors.toUnmodifiableList());
+  private List<AttributeAssociation<FilterArgument>> getFilterArguments(
+      GraphQlRequestContext context, Set<FilterArgument> edgeFields) {
+    return this.filterRequestBuilder
+        .build(context, HypertraceAttributeScopeString.INTERACTION, edgeFields)
+        .blockingGet();
+  }
+
+  private Map<String, Set<FilterArgument>> getEdgesFiltersByType(
+      Stream<SelectedField> edgeSetStream) {
+    return edgeSetStream.collect(
+        Collectors.groupingBy(
+            this::getEntityType,
+            Collectors.flatMapping(this::getFilter, Collectors.toUnmodifiableSet())));
+  }
+
+  private Stream<FilterArgument> getFilter(SelectedField selectedField) {
+    return this.argumentDeserializer
+        .deserializeObjectList(selectedField.getArguments(), FilterArgument.class)
+        .stream()
+        .flatMap(Collection::stream);
   }
 
   private Single<AttributeRequest> getNeighborTypeAttribute(
@@ -227,7 +237,7 @@ private static class DefaultEdgeSetGroupRequest implements EdgeSetGroupRequest {
     AttributeRequest neighborIdAttribute;
     AttributeRequest neighborTypeAttribute;
     BiFunction<String, Collection<String>, Single<EntityRequest>> neighborRequestBuilder;
-    Collection<AttributeAssociation<FilterArgument>> filterArguments;
+    Map<String, Collection<AttributeAssociation<FilterArgument>>> filterArguments;
 
     @Override
     public Single<EntityRequest> buildNeighborRequest(

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/request/EdgeSetGroupRequest.java

@@ -2,6 +2,7 @@
 
 import io.reactivex.rxjava3.core.Single;
 import java.util.Collection;
+import java.util.Map;
 import java.util.Set;
 import org.hypertrace.core.graphql.common.request.AttributeAssociation;
 import org.hypertrace.core.graphql.common.request.AttributeRequest;
@@ -23,5 +24,6 @@ public interface EdgeSetGroupRequest {
 
   Single<EntityRequest> buildNeighborRequest(String entityType, Collection<String> neighborIds);
 
-  Collection<AttributeAssociation<FilterArgument>> filterArguments();
+  // map of filters. All map values will become OR filter and all filter arguments will be AND
+  Map<String, Collection<AttributeAssociation<FilterArgument>>> filterArguments();
 }

hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/DefaultEntityAndRuleJoinerBuilder.java

@@ -319,7 +319,8 @@ private static class EmptyEdgeSetGroupRequest implements EdgeSetGroupRequest {
     Set<String> entityTypes = Collections.emptySet();
     Collection<AttributeRequest> attributeRequests = Collections.emptyList();
     Collection<MetricAggregationRequest> metricAggregationRequests = Collections.emptyList();
-    Collection<AttributeAssociation<FilterArgument>> filterArguments = Collections.emptyList();
+    Map<String, Collection<AttributeAssociation<FilterArgument>>> filterArguments =
+        Collections.emptyMap();
     AttributeRequest neighborIdAttribute = null;
     AttributeRequest neighborTypeAttribute = null;