@finos/legend-query-builder 4.1.14 → 4.2.0

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -257,47 +257,36 @@ export abstract class QueryBuilderFilterTreeNodeData
   abstract get hashCode(): string;
 }
 
-export class QueryBuilderFilterTreeGroupNodeData
+export abstract class QueryBuilderFilterTreeOperationNodeData
   extends QueryBuilderFilterTreeNodeData
   implements Hashable
 {
-  groupOperation: QUERY_BUILDER_GROUP_OPERATION;
   childrenIds: string[] = [];
+  lambdaParameterName?: string | undefined;
 
-  constructor(
-    parentId: string | undefined,
-    groupOperation: QUERY_BUILDER_GROUP_OPERATION,
-  ) {
+  constructor(parentId: string | undefined) {
     super(parentId);
 
     makeObservable(this, {
-      groupOperation: observable,
       childrenIds: observable,
-      setGroupOperation: action,
       addChildNode: action,
       removeChildNode: action,
       dragPreviewLabel: computed,
     });
 
-    this.groupOperation = groupOperation;
     this.isOpen = true;
   }
 
-  get dragPreviewLabel(): string {
-    return `${this.groupOperation.toUpperCase()} group`;
-  }
-
-  setGroupOperation(val: QUERY_BUILDER_GROUP_OPERATION): void {
-    this.groupOperation = val;
-  }
   addChildNode(node: QueryBuilderFilterTreeNodeData): void {
     addUniqueEntry(this.childrenIds, node.id);
     node.setParentId(this.id);
   }
+
   removeChildNode(node: QueryBuilderFilterTreeNodeData): void {
     deleteEntry(this.childrenIds, node.id);
     node.setParentId(undefined);
   }
+
   addChildNodeAt(node: QueryBuilderFilterTreeNodeData, idx: number): void {
     if (!this.childrenIds.find((childId) => childId === node.id)) {
       idx = Math.max(0, Math.min(idx, this.childrenIds.length - 1));
@@ -305,6 +294,36 @@ export class QueryBuilderFilterTreeGroupNodeData
       node.setParentId(this.id);
     }
   }
+}
+
+export class QueryBuilderFilterTreeGroupNodeData
+  extends QueryBuilderFilterTreeOperationNodeData
+  implements Hashable
+{
+  groupOperation: QUERY_BUILDER_GROUP_OPERATION;
+
+  constructor(
+    parentId: string | undefined,
+    groupOperation: QUERY_BUILDER_GROUP_OPERATION,
+  ) {
+    super(parentId);
+
+    makeObservable(this, {
+      groupOperation: observable,
+      setGroupOperation: action,
+    });
+
+    this.groupOperation = groupOperation;
+    this.isOpen = true;
+  }
+
+  get dragPreviewLabel(): string {
+    return `${this.groupOperation.toUpperCase()} group`;
+  }
+
+  setGroupOperation(val: QUERY_BUILDER_GROUP_OPERATION): void {
+    this.groupOperation = val;
+  }
 
   get hashCode(): string {
     return hashArray([
@@ -312,6 +331,43 @@ export class QueryBuilderFilterTreeGroupNodeData
       this.parentId ?? '',
       hashArray(this.childrenIds),
       this.groupOperation,
+      this.lambdaParameterName ?? '',
+    ]);
+  }
+}
+
+export class QueryBuilderFilterTreeExistsNodeData
+  extends QueryBuilderFilterTreeOperationNodeData
+  implements Hashable
+{
+  propertyExpression!: AbstractPropertyExpression;
+
+  constructor(parentId: string | undefined) {
+    super(parentId);
+
+    makeObservable(this, {
+      propertyExpression: observable,
+      setPropertyExpression: action,
+    });
+
+    this.isOpen = true;
+  }
+
+  get dragPreviewLabel(): string {
+    return `exists`;
+  }
+
+  setPropertyExpression(val: AbstractPropertyExpression): void {
+    this.propertyExpression = val;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.FILTER_TREE_EXISTS_NODE_DATA,
+      this.parentId ?? '',
+      hashArray(this.childrenIds),
+      this.propertyExpression,
+      this.lambdaParameterName ?? '',
     ]);
   }
 }
@@ -449,11 +505,11 @@ export class QueryBuilderFilterState
 
   private getParentNode(
     node: QueryBuilderFilterTreeNodeData,
-  ): QueryBuilderFilterTreeGroupNodeData | undefined {
+  ): QueryBuilderFilterTreeOperationNodeData | undefined {
     return node.parentId
       ? guaranteeType(
           this.nodes.get(node.parentId),
-          QueryBuilderFilterTreeGroupNodeData,
+          QueryBuilderFilterTreeOperationNodeData,
         )
       : undefined;
   }
@@ -465,7 +521,8 @@ export class QueryBuilderFilterState
       rootNode.addChildNode(node);
     } else if (
       rootNode instanceof QueryBuilderFilterTreeConditionNodeData ||
-      rootNode instanceof QueryBuilderFilterTreeBlankConditionNodeData
+      rootNode instanceof QueryBuilderFilterTreeBlankConditionNodeData ||
+      rootNode instanceof QueryBuilderFilterTreeExistsNodeData
     ) {
       // if the root node is condition node, form a group between the root node and the new node and nominate the group node as the new root
       const groupNode = new QueryBuilderFilterTreeGroupNodeData(
@@ -489,6 +546,31 @@ export class QueryBuilderFilterState
     if (fromNode instanceof QueryBuilderFilterTreeGroupNodeData) {
       this.nodes.set(node.id, node);
       fromNode.addChildNode(node);
+    } else if (fromNode instanceof QueryBuilderFilterTreeExistsNodeData) {
+      // Here we check if there are any child nodes for exists node. The rationale
+      // behind doing this check is if there are no childs we can just add a child
+      // node to this otherwise we need to add a group condition for the existing
+      // child node and the node we are trying to add.
+      if (!fromNode.childrenIds.length) {
+        this.nodes.set(node.id, node);
+        fromNode.addChildNode(node);
+      } else {
+        this.nodes.set(node.id, node);
+        const groupNode = new QueryBuilderFilterTreeGroupNodeData(
+          undefined,
+          QUERY_BUILDER_GROUP_OPERATION.AND,
+        );
+        groupNode.addChildNode(
+          guaranteeNonNullable(
+            this.nodes.get(guaranteeNonNullable(fromNode.childrenIds[0])),
+          ),
+        );
+        groupNode.addChildNode(node);
+        groupNode.lambdaParameterName = fromNode.lambdaParameterName;
+        this.nodes.set(groupNode.id, groupNode);
+        fromNode.childrenIds = [];
+        fromNode.addChildNode(groupNode);
+      }
     } else if (
       fromNode instanceof QueryBuilderFilterTreeConditionNodeData ||
       fromNode instanceof QueryBuilderFilterTreeBlankConditionNodeData
@@ -563,6 +645,7 @@ export class QueryBuilderFilterState
         this.nodes.set(newGroupNode.id, newGroupNode);
         newGroupNode.addChildNode(fromNode);
         newGroupNode.addChildNode(newNode);
+        newGroupNode.lambdaParameterName = fromNodeParent.lambdaParameterName;
         fromNodeParent.addChildNodeAt(newGroupNode, fromNodeIdx);
       } else {
         this.addRootNode(newNode);
@@ -573,7 +656,7 @@ export class QueryBuilderFilterState
   private removeNode(node: QueryBuilderFilterTreeNodeData): void {
     this.nodes.delete(node.id);
     // remove relationship with children nodes
-    if (node instanceof QueryBuilderFilterTreeGroupNodeData) {
+    if (node instanceof QueryBuilderFilterTreeOperationNodeData) {
       // NOTE: we are deleting child node, i.e. modifying `childrenIds` as we iterate
       [...node.childrenIds].forEach((childId) =>
         node.removeChildNode(this.getNode(childId)),
@@ -644,9 +727,13 @@ export class QueryBuilderFilterState
     // squash parent node after the current node is deleted
     if (parentNode) {
       parentNode.removeChildNode(node);
-      let currentParentNode: QueryBuilderFilterTreeGroupNodeData | undefined =
-        parentNode;
-      while (currentParentNode) {
+      let currentParentNode:
+        | QueryBuilderFilterTreeOperationNodeData
+        | undefined = parentNode;
+      while (
+        currentParentNode &&
+        currentParentNode instanceof QueryBuilderFilterTreeGroupNodeData
+      ) {
         if (currentParentNode.childrenIds.length >= 2) {
           break;
         }
@@ -724,11 +811,12 @@ export class QueryBuilderFilterState
           if (!node.parentId || !this.nodes.has(node.parentId)) {
             return false;
           }
-          const parentGroupNode = guaranteeType(
-            this.nodes.get(node.parentId),
-            QueryBuilderFilterTreeGroupNodeData,
+          const parentGroupNode = this.nodes.get(node.parentId);
+
+          return (
+            parentGroupNode instanceof QueryBuilderFilterTreeGroupNodeData &&
+            parentGroupNode.groupOperation === node.groupOperation
           );
-          return parentGroupNode.groupOperation === node.groupOperation;
         });
     // Squash these unnecessary group nodes
     let nodesToProcess = getUnnecessaryNodes();

package/src/stores/filter/QueryBuilderFilterStateBuilder.ts

@@ -16,9 +16,12 @@
 
 import {
   AbstractPropertyExpression,
+  extractElementNameFromPath,
+  LambdaFunction,
   LambdaFunctionInstanceValue,
   matchFunctionName,
   SimpleFunctionExpression,
+  type ValueSpecification,
   VariableExpression,
 } from '@finos/legend-graph';
 import {
@@ -37,8 +40,35 @@ import {
   type QueryBuilderFilterState,
   QueryBuilderFilterTreeConditionNodeData,
   QueryBuilderFilterTreeGroupNodeData,
+  QueryBuilderFilterTreeExistsNodeData,
+  QueryBuilderFilterTreeOperationNodeData,
 } from './QueryBuilderFilterState.js';
 
+const getPropertyExpressionChainVariable = (
+  propertyExpression: AbstractPropertyExpression,
+): VariableExpression => {
+  let currentExpression: ValueSpecification = propertyExpression;
+  while (currentExpression instanceof AbstractPropertyExpression) {
+    currentExpression = guaranteeNonNullable(
+      currentExpression.parametersValues[0],
+    );
+    // Take care of chains of subtype (a pattern that is not useful, but we want to support and rectify)
+    // $x.employees->subType(@Person)->subType(@Staff)
+    while (
+      currentExpression instanceof SimpleFunctionExpression &&
+      matchFunctionName(
+        currentExpression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
+      )
+    ) {
+      currentExpression = guaranteeNonNullable(
+        currentExpression.parametersValues[0],
+      );
+    }
+  }
+  return guaranteeType(currentExpression, VariableExpression);
+};
+
 const processFilterTree = (
   expression: SimpleFunctionExpression,
   filterState: QueryBuilderFilterState,
@@ -58,6 +88,12 @@ const processFilterTree = (
       toGroupOperation(expression.functionName),
     );
     filterState.nodes.set(groupNode.id, groupNode);
+    if (parentNode) {
+      groupNode.lambdaParameterName = guaranteeType(
+        parentNode,
+        QueryBuilderFilterTreeOperationNodeData,
+      ).lambdaParameterName;
+    }
     expression.parametersValues.forEach((filterExpression) =>
       processFilterTree(
         guaranteeType(
@@ -70,6 +106,200 @@ const processFilterTree = (
       ),
     );
     filterState.addNodeFromNode(groupNode, parentNode);
+  } else if (
+    matchFunctionName(expression.functionName, [
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.EXISTS,
+    ])
+  ) {
+    const propertyExpression = guaranteeType(
+      expression.parametersValues[0],
+      AbstractPropertyExpression,
+    );
+    if (
+      propertyExpression.func.value.multiplicity.upperBound === undefined ||
+      propertyExpression.func.value.multiplicity.upperBound > 1
+    ) {
+      const existsNode = new QueryBuilderFilterTreeExistsNodeData(
+        parentFilterNodeId,
+      );
+      const lambdaFunctionInstance = guaranteeType(
+        expression.parametersValues[1],
+        LambdaFunctionInstanceValue,
+        `Can't process filter expression: only supports exists with second paramter as LambdaFunctionInstanceValue`,
+      );
+      const lambdaFunction = guaranteeType(
+        lambdaFunctionInstance.values[0],
+        LambdaFunction,
+      );
+      const filterExpression = guaranteeType(
+        lambdaFunction.expressionSequence[0],
+        SimpleFunctionExpression,
+      );
+      existsNode.setPropertyExpression(propertyExpression);
+      existsNode.lambdaParameterName =
+        lambdaFunction.functionType.parameters[0]?.name;
+      filterState.nodes.set(existsNode.id, existsNode);
+      processFilterTree(filterExpression, filterState, existsNode.id);
+      filterState.addNodeFromNode(existsNode, parentNode);
+    } else {
+      // Build property chain if we have exists filter() and the multiplicity of the property
+      // is of multiplicity less than or equal to one. This will auto-fix the exists into the
+      // desired filter expression
+
+      // 1. Decompose the exists() lambda chain into property expression chains
+      const existsLambdaParameterNames: string[] = [];
+
+      const existsLambdaExpressions: AbstractPropertyExpression[] = [];
+      let mainFilterExpression: SimpleFunctionExpression = expression;
+      while (
+        matchFunctionName(
+          mainFilterExpression.functionName,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.EXISTS,
+        )
+      ) {
+        const existsLambda = guaranteeNonNullable(
+          guaranteeType(
+            mainFilterExpression.parametersValues[1],
+            LambdaFunctionInstanceValue,
+          ).values[0],
+          `Can't process exists() expression: exists() lambda is missing`,
+        );
+        assertTrue(
+          existsLambda.expressionSequence.length === 1,
+          `Can't process exists() expression: exists() lambda body should hold an expression`,
+        );
+        mainFilterExpression = guaranteeType(
+          existsLambda.expressionSequence[0],
+          SimpleFunctionExpression,
+          `Can't process exists() expression: exists() lambda body should hold an expression`,
+        );
+
+        // record the lambda parameter name
+        assertTrue(
+          existsLambda.functionType.parameters.length === 1,
+          `Can't process exists() expression: exists() lambda should have 1 parameter`,
+        );
+        existsLambdaParameterNames.push(
+          guaranteeType(
+            existsLambda.functionType.parameters[0],
+            VariableExpression,
+            `Can't process exists() expression: exists() lambda should have 1 parameter`,
+          ).name,
+        );
+
+        // record the lambda property expression
+        if (
+          mainFilterExpression.parametersValues[0] instanceof
+            AbstractPropertyExpression &&
+          !(
+            mainFilterExpression.parametersValues[0].func.value.multiplicity
+              .upperBound === undefined ||
+            mainFilterExpression.parametersValues[0].func.value.multiplicity
+              .upperBound > 1
+          )
+        ) {
+          existsLambdaExpressions.push(
+            mainFilterExpression.parametersValues[0],
+          );
+        } else {
+          break;
+        }
+      }
+
+      // 2. Build the property expression
+      const initialPropertyExpression = guaranteeType(
+        expression.parametersValues[0],
+        AbstractPropertyExpression,
+      );
+      let flattenedPropertyExpressionChain = new AbstractPropertyExpression('');
+      flattenedPropertyExpressionChain.func = initialPropertyExpression.func;
+      flattenedPropertyExpressionChain.parametersValues = [
+        ...initialPropertyExpression.parametersValues,
+      ];
+      for (const exp of existsLambdaExpressions) {
+        // when rebuilding the property expression chain, disregard the initial variable that starts the chain
+        const expressions: (
+          | AbstractPropertyExpression
+          | SimpleFunctionExpression
+        )[] = [];
+        let currentExpression: ValueSpecification = exp;
+        while (
+          currentExpression instanceof AbstractPropertyExpression ||
+          (currentExpression instanceof SimpleFunctionExpression &&
+            matchFunctionName(
+              currentExpression.functionName,
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
+            ))
+        ) {
+          if (currentExpression instanceof SimpleFunctionExpression) {
+            const functionExpression = new SimpleFunctionExpression(
+              extractElementNameFromPath(
+                QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
+              ),
+            );
+            functionExpression.parametersValues.unshift(
+              guaranteeNonNullable(currentExpression.parametersValues[1]),
+            );
+            expressions.push(functionExpression);
+          } else if (currentExpression instanceof AbstractPropertyExpression) {
+            const propertyExp = new AbstractPropertyExpression('');
+            propertyExp.func = currentExpression.func;
+            // NOTE: we must retain the rest of the parameters as those are derived property parameters
+            propertyExp.parametersValues =
+              currentExpression.parametersValues.length > 1
+                ? currentExpression.parametersValues.slice(1)
+                : [];
+            expressions.push(propertyExp);
+          }
+          currentExpression = guaranteeNonNullable(
+            currentExpression.parametersValues[0],
+          );
+        }
+        assertTrue(
+          expressions.length > 0,
+          `Can't process exists() expression: exists() usage with non-chain property expression is not supported`,
+        );
+        for (let i = 0; i < expressions.length - 1; ++i) {
+          (
+            expressions[i] as
+              | AbstractPropertyExpression
+              | SimpleFunctionExpression
+          ).parametersValues.unshift(
+            expressions[i + 1] as
+              | AbstractPropertyExpression
+              | SimpleFunctionExpression,
+          );
+        }
+        (
+          expressions[expressions.length - 1] as
+            | AbstractPropertyExpression
+            | SimpleFunctionExpression
+        ).parametersValues.unshift(flattenedPropertyExpressionChain);
+        flattenedPropertyExpressionChain = guaranteeType(
+          expressions[0],
+          AbstractPropertyExpression,
+          `Can't process exists() expression: can't flatten to a property expression`,
+        );
+      }
+      mainFilterExpression.parametersValues =
+        mainFilterExpression.parametersValues.map((p) => {
+          if (
+            p instanceof SimpleFunctionExpression &&
+            p.parametersValues[0] instanceof AbstractPropertyExpression
+          ) {
+            p.parametersValues[0].parametersValues[0] =
+              flattenedPropertyExpressionChain;
+          } else if (p instanceof AbstractPropertyExpression) {
+            p.parametersValues[0] = guaranteeNonNullable(
+              flattenedPropertyExpressionChain.parametersValues[0],
+            );
+          } else if (p instanceof VariableExpression) {
+            return flattenedPropertyExpressionChain;
+          }
+          return p;
+        });
+      processFilterTree(mainFilterExpression, filterState, parentFilterNodeId);
+    }
   } else {
     const propertyExpression = expression.parametersValues[0];
     if (propertyExpression instanceof AbstractPropertyExpression) {
@@ -89,6 +319,20 @@ const processFilterTree = (
         operator.buildFilterConditionState(filterState, expression),
       );
       if (filterConditionState) {
+        const variableName = getPropertyExpressionChainVariable(
+          filterConditionState.propertyExpressionState.propertyExpression,
+        ).name;
+        const parentLambdaVariableName =
+          parentNode instanceof QueryBuilderFilterTreeOperationNodeData &&
+          parentNode.lambdaParameterName
+            ? parentNode.lambdaParameterName
+            : filterState.lambdaParameterName;
+        assertTrue(
+          parentLambdaVariableName === variableName,
+          `Can't process ${extractElementNameFromPath(
+            filterConditionState.operator.getLabel(filterConditionState),
+          )}() expression: expects variable used in lambda body '${variableName}' to match lambda parameter '${parentLambdaVariableName}'`,
+        );
         filterState.addNodeFromNode(
           new QueryBuilderFilterTreeConditionNodeData(
             undefined,

package/src/stores/filter/QueryBuilderFilterValueSpecificationBuilder.ts

@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-import { isNonNullable, guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  isNonNullable,
+  guaranteeNonNullable,
+  guaranteeType,
+} from '@finos/legend-shared';
 import {
   type ValueSpecification,
   type LambdaFunction,
@@ -28,16 +32,26 @@ import {
   QueryBuilderFilterTreeConditionNodeData,
   QueryBuilderFilterTreeGroupNodeData,
   type QueryBuilderFilterTreeNodeData,
+  QueryBuilderFilterTreeExistsNodeData,
+  QueryBuilderFilterTreeOperationNodeData,
 } from './QueryBuilderFilterState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../graph/QueryBuilderMetaModelConst.js';
+import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../QueryBuilderConfig.js';
 
 const buildFilterConditionExpression = (
   filterState: QueryBuilderFilterState,
   node: QueryBuilderFilterTreeNodeData,
 ): ValueSpecification | undefined => {
   if (node instanceof QueryBuilderFilterTreeConditionNodeData) {
+    const parentNode = node.parentId
+      ? guaranteeType(
+          filterState.nodes.get(node.parentId),
+          QueryBuilderFilterTreeOperationNodeData,
+        )
+      : undefined;
     return node.condition.operator.buildFilterConditionExpression(
       node.condition,
+      parentNode?.lambdaParameterName,
     );
   } else if (node instanceof QueryBuilderFilterTreeGroupNodeData) {
     const func = new SimpleFunctionExpression(
@@ -75,6 +89,85 @@ const buildFilterConditionExpression = (
       func.parametersValues = clauses;
     }
     return func.parametersValues.length ? func : undefined;
+  } else if (node instanceof QueryBuilderFilterTreeExistsNodeData) {
+    const func = new SimpleFunctionExpression(
+      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.EXISTS),
+    );
+    let parentNode = node.parentId
+      ? guaranteeType(
+          filterState.nodes.get(guaranteeNonNullable(node.parentId)),
+          QueryBuilderFilterTreeOperationNodeData,
+        )
+      : undefined;
+    while (
+      parentNode &&
+      !(parentNode instanceof QueryBuilderFilterTreeGroupNodeData)
+    ) {
+      parentNode = parentNode.parentId
+        ? guaranteeType(
+            filterState.nodes.get(guaranteeNonNullable(parentNode.parentId)),
+            QueryBuilderFilterTreeOperationNodeData,
+          )
+        : undefined;
+    }
+    const propertyExpression = guaranteeNonNullable(node.propertyExpression);
+    const clauses = node.childrenIds
+      .map((e) => filterState.nodes.get(e))
+      .filter(isNonNullable)
+      .map((e) => buildFilterConditionExpression(filterState, e))
+      .filter(isNonNullable);
+    /**
+     * NOTE: Due to a limitation (or perhaps design decision) in the engine, group operations
+     * like and/or do not take more than 2 parameters, as such, if we have more than 2, we need
+     * to create a chain of this operation to accomondate.
+     *
+     * This means that in the read direction, we might need to flatten the chains down to group with
+     * multiple clauses. This means user's intended grouping will not be kept.
+     */
+    let parametersValues;
+    if (clauses.length > 2) {
+      const firstClause = clauses[0] as ValueSpecification;
+      let currentClause: ValueSpecification = clauses[
+        clauses.length - 1
+      ] as ValueSpecification;
+      for (let i = clauses.length - 2; i > 0; --i) {
+        const clause1 = clauses[i] as ValueSpecification;
+        const clause2 = currentClause;
+        const groupClause = new SimpleFunctionExpression(
+          guaranteeNonNullable(parentNode).groupOperation,
+        );
+        groupClause.parametersValues = [clause1, clause2];
+        currentClause = groupClause;
+      }
+      parametersValues = [firstClause, currentClause];
+    } else if (clauses.length === 1) {
+      const lambdaFunctionInstanceValue =
+        buildGenericLambdaFunctionInstanceValue(
+          node.lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME,
+          clauses,
+          filterState.queryBuilderState.graphManagerState.graph,
+        );
+      func.parametersValues = [propertyExpression, lambdaFunctionInstanceValue];
+      return func;
+    } else {
+      parametersValues = clauses;
+    }
+    if (!parametersValues.length) {
+      return undefined;
+    }
+    const simp = new SimpleFunctionExpression(
+      extractElementNameFromPath(
+        fromGroupOperation(guaranteeNonNullable(parentNode).groupOperation),
+      ),
+    );
+    simp.parametersValues = parametersValues;
+    const lambdaFunctionInstanceValue = buildGenericLambdaFunctionInstanceValue(
+      node.lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME,
+      [simp],
+      filterState.queryBuilderState.graphManagerState.graph,
+    );
+    func.parametersValues = [propertyExpression, lambdaFunctionInstanceValue];
+    return func;
   }
   return undefined;
 };