chore | adding the support for querying multi interaction filters

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;
@@ -21,6 +22,7 @@
 import org.hypertrace.core.graphql.common.utils.Converter;
 import org.hypertrace.gateway.service.v1.common.Expression;
 import org.hypertrace.gateway.service.v1.common.Filter;
+import org.hypertrace.gateway.service.v1.common.Operator;
 import org.hypertrace.gateway.service.v1.entity.InteractionsRequest;
 import org.hypertrace.graphql.entity.request.EdgeSetGroupRequest;
 import org.hypertrace.graphql.metric.request.MetricAggregationRequest;
@@ -69,22 +71,30 @@
   }
 
   private Single<Filter> buildEntityInteractionFilter(EdgeSetGroupRequest request) {
-    return Observable.fromIterable(request.entityTypes()) // add entity types filter
-        .collect(Collectors.toUnmodifiableSet())
+    return Observable.fromIterable(request.filterArguments().entrySet())
         .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()))
+        .flatMapSingle(this.filterConverter::convert)
+        .collect(Collectors.toUnmodifiableList())
+        .map(
+            childFilters ->
+                Filter.newBuilder()
+                    .setOperator(Operator.OR)
+                    .addAllChildFilter(childFilters)
+                    .build());
+  }
+
+  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,12 @@
 import static io.reactivex.rxjava3.core.Single.zip;
 
 import graphql.schema.SelectedField;
-import io.grpc.Status;
+import io.reactivex.rxjava3.core.Observable;
 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 +90,26 @@
       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());
+
     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()),
+        this.getFilterArguments(context, edgesFiltersByType),
         (attributeRequests, neighborIdRequest, neighborTypeRequest, metricRequests, filters) ->
             new DefaultEdgeSetGroupRequest(
-                edgesByType.keySet(),
+                edgesSelectionsByType.keySet(),
                 attributeRequests,
                 metricRequests,
                 neighborIdRequest,
@@ -127,12 +123,12 @@
                             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 +179,34 @@
     }
   }
 
-  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 Single<Map<String, Collection<AttributeAssociation<FilterArgument>>>> getFilterArguments(
+      GraphQlRequestContext context, Map<String, Set<FilterArgument>> edgesFiltersByType) {
+    return Observable.fromIterable(edgesFiltersByType.entrySet())
+        .flatMapSingle(entry -> getFilterArgumentsEntry(context, entry.getKey(), entry.getValue()))
+        .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
+  }
+
+  private Single<Map.Entry<String, List<AttributeAssociation<FilterArgument>>>>
+      getFilterArgumentsEntry(
+          GraphQlRequestContext context, String key, Set<FilterArgument> edgeFields) {
+    return this.filterRequestBuilder
+        .build(context, HypertraceAttributeScopeString.INTERACTION, edgeFields)
+        .map(arguments -> Map.entry(key, arguments));
+  }
+
+  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 +242,7 @@
     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;