@finos/legend-query-builder 0.4.4 → 0.6.0

package/src/stores/QueryBuilderValueSpecificationHelper.ts

@@ -38,12 +38,12 @@ import {
   Class,
   getMilestoneTemporalStereotype,
   DerivedProperty,
-  MILESTONING_STEREOTYPE,
   PackageableElementExplicitReference,
   Multiplicity,
   CollectionInstanceValue,
   GenericTypeExplicitReference,
   GenericType,
+  INTERNAL__PropagatedValue,
 } from '@finos/legend-graph';
 import {
   addUniqueEntry,
@@ -55,7 +55,10 @@ import {
   UnsupportedOperationError,
 } from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
-import { getDerivedPropertyMilestoningSteoreotype } from './QueryBuilderPropertyEditorState.js';
+import {
+  getDerivedPropertyMilestoningSteoreotype,
+  validateMilestoningPropertyExpressionChain,
+} from './milestoning/QueryBuilderMilestoningHelper.js';
 
 export const getNonCollectionValueSpecificationType = (
   valueSpecification: ValueSpecification,
@@ -209,6 +212,7 @@ export const generateDefaultValueForPrimitiveType = (
     case PRIMITIVE_TYPE.DECIMAL:
     case PRIMITIVE_TYPE.FLOAT:
     case PRIMITIVE_TYPE.INTEGER:
+    case PRIMITIVE_TYPE.BINARY:
       return 0;
     case PRIMITIVE_TYPE.DATE:
     case PRIMITIVE_TYPE.STRICTDATE:
@@ -301,33 +305,11 @@ export const validatePropertyExpressionChain = (
           guaranteeType(func, DerivedProperty),
           graph,
         );
-        if (
-          sourceStereotype !== MILESTONING_STEREOTYPE.BITEMPORAL &&
-          targetStereotype !== sourceStereotype
-        ) {
-          if (targetStereotype === MILESTONING_STEREOTYPE.BITEMPORAL) {
-            if (
-              propertyExpression.parametersValues.length !== 3 &&
-              !sourceStereotype
-            ) {
-              throw new UnsupportedOperationError(
-                `Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should have exactly two parameters`,
-              );
-            } else if (propertyExpression.parametersValues.length < 2) {
-              throw new UnsupportedOperationError(
-                `Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should have at least one parameter`,
-              );
-            } else if (propertyExpression.parametersValues.length > 3) {
-              throw new UnsupportedOperationError(
-                `Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should not have more than two parameters`,
-              );
-            }
-          } else if (propertyExpression.parametersValues.length !== 2) {
-            throw new UnsupportedOperationError(
-              `Property of milestoning sterotype '${targetStereotype}' should have exactly one parameter`,
-            );
-          }
-        }
+        validateMilestoningPropertyExpressionChain(
+          sourceStereotype,
+          targetStereotype,
+          propertyExpression,
+        );
       }
     }
   }
@@ -361,3 +343,15 @@ export const createNullishValue = (graph: PureModel): CollectionInstanceValue =>
       new GenericType(graph.getType(CORE_PURE_PATH.ANY)),
     ),
   );
+
+export const isValueExpressionReferencesinValue = (
+  variable: VariableExpression,
+  value: ValueSpecification,
+): boolean => {
+  if (value instanceof VariableExpression) {
+    return value.name === variable.name;
+  } else if (value instanceof INTERNAL__PropagatedValue) {
+    return isValueExpressionReferencesinValue(variable, value.getValue());
+  }
+  return false;
+};

package/src/stores/fetch-structure/QueryBuilderFetchStructureImplementationState.ts

@@ -18,6 +18,7 @@ import type {
   Class,
   CompilationError,
   LambdaFunction,
+  VariableExpression,
 } from '@finos/legend-graph';
 import type { Hashable } from '@finos/legend-shared';
 import { computed, makeObservable } from 'mobx';
@@ -61,6 +62,7 @@ export abstract class QueryBuilderFetchStructureImplementationState
   abstract fetchProperties(
     nodes: QueryBuilderExplorerTreePropertyNodeData[],
   ): void;
+  abstract isVariableUsed(variable: VariableExpression): boolean;
   abstract checkBeforeChangingImplementation(onChange: () => void): void;
   abstract appendFetchStructure(
     lambdaFunction: LambdaFunction,

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts

@@ -18,10 +18,11 @@ import type { QueryBuilderState } from '../../QueryBuilderState.js';
 import { action, computed, makeObservable, observable } from 'mobx';
 import {
   type CompilationError,
-  PackageableElementExplicitReference,
-  RootGraphFetchTree,
   type Class,
   type LambdaFunction,
+  type VariableExpression,
+  PackageableElementExplicitReference,
+  RootGraphFetchTree,
   getAllSuperclasses,
 } from '@finos/legend-graph';
 import {
@@ -51,6 +52,7 @@ import {
   type Hashable,
 } from '@finos/legend-shared';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../graphManager/QueryBuilderHashUtils.js';
+import { isValueExpressionReferencesinValue } from '../../QueryBuilderValueSpecificationHelper.js';
 
 export class QueryBuilderGraphFetchTreeState
   extends QueryBuilderFetchStructureImplementationState
@@ -247,6 +249,16 @@ export class QueryBuilderGraphFetchTreeState
     }
   }
 
+  isVariableUsed(variable: VariableExpression): boolean {
+    return Boolean(
+      Array.from(this.treeData?.nodes.values() ?? []).find((node) =>
+        node.tree.parameters.find((p) =>
+          isValueExpressionReferencesinValue(variable, p),
+        ),
+      ),
+    );
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_HASH_STRUCTURE.GRAPH_FETCH_STATE,

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeStateBuilder.ts

@@ -15,6 +15,7 @@
  */
 
 import {
+  type LambdaFunction,
   GraphFetchTreeInstanceValue,
   matchFunctionName,
   RootGraphFetchTree,
@@ -31,6 +32,7 @@ import { buildGraphFetchTreeData } from './QueryBuilderGraphFetchTreeUtil.js';
 export const processGraphFetchExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
 ): void => {
   const functionName = expression.functionName;
 
@@ -55,6 +57,7 @@ export const processGraphFetchExpression = (
   );
   QueryBuilderValueSpecificationProcessor.process(
     precedingExpression,
+    parentLambda,
     queryBuilderState,
   );
 
@@ -77,6 +80,7 @@ export const processGraphFetchExpression = (
 export const processGraphFetchSerializeExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
 ): void => {
   // update fetch-structure
   queryBuilderState.fetchStructureState.changeImplementation(
@@ -104,6 +108,7 @@ export const processGraphFetchSerializeExpression = (
   );
   QueryBuilderValueSpecificationProcessor.process(
     precedingExpression,
+    parentLambda,
     queryBuilderState,
   );
 

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -39,14 +39,15 @@ import {
 import type { QueryBuilderState } from '../../QueryBuilderState.js';
 import {
   type CompilationError,
+  type LambdaFunction,
+  type ValueSpecification,
+  type VariableExpression,
   GRAPH_MANAGER_EVENT,
   extractSourceInformationCoordinates,
   LAMBDA_PIPE,
   RawLambda,
   isStubbed_RawLambda,
   Class,
-  type LambdaFunction,
-  type ValueSpecification,
   AbstractPropertyExpression,
   matchFunctionName,
   SimpleFunctionExpression,
@@ -91,9 +92,9 @@ import type { LambdaFunctionBuilderOption } from '../../QueryBuilderValueSpecifi
 import { appendProjection } from './projection/QueryBuilderProjectionValueSpecificationBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graphManager/QueryBuilderSupportedFunctions.js';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../graphManager/QueryBuilderHashUtils.js';
-import { QueryBuilderOLAPGroupByState } from './olapGroupBy/QueryBuilderOLAPGroupByState_.js';
+import { QueryBuilderOLAPGroupByState } from './olapGroupBy/QueryBuilderOLAPGroupByState.js';
 import type { QueryBuilderTDS_OLAPOperator } from './olapGroupBy/operators/QueryBuilderTDS_OLAPOperator.js';
-import { getQueryBuilderCoreOLAPGroupByOperators } from './olapGroupBy/QueryBuilderOLAPGroupByOperatorLoader_.js';
+import { getQueryBuilderCoreOLAPGroupByOperators } from './olapGroupBy/QueryBuilderOLAPGroupByOperatorLoader.js';
 import type { QueryBuilderTDSColumnState } from './QueryBuilderTDSColumnState.js';
 
 export class QueryBuilderTDSState
@@ -636,6 +637,22 @@ export class QueryBuilderTDSState
     }
   }
 
+  isVariableUsed(variable: VariableExpression): boolean {
+    const columns = this.projectionColumns;
+    const derivationColumns = columns.filter(
+      filterByType(QueryBuilderDerivationProjectionColumnState),
+    );
+    if (derivationColumns.length) {
+      // we will return false if any derivation cols are present as we can't verify is the variable is ued
+      return false;
+    }
+    const usedInProjection = columns
+      .filter(filterByType(QueryBuilderSimpleProjectionColumnState))
+      .find((col) => col.isVariableUsed(variable));
+    const usedInPostFilter = this.postFilterState.isVariableUsed(variable);
+    return Boolean(usedInProjection ?? usedInPostFilter);
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_HASH_STRUCTURE.PROJECTION_STATE,

package/src/stores/fetch-structure/tds/aggregation/QueryBuilderAggregationStateBuilder.ts

@@ -15,6 +15,7 @@
  */
 
 import {
+  type LambdaFunction,
   CollectionInstanceValue,
   LambdaFunctionInstanceValue,
   matchFunctionName,
@@ -41,6 +42,7 @@ export const processTDSAggregateExpression = (
   expression: SimpleFunctionExpression,
   parentExpression: SimpleFunctionExpression | undefined,
   queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
 ): void => {
   // check parent expression
   assertTrue(
@@ -65,6 +67,7 @@ export const processTDSAggregateExpression = (
     // TODO?: do we want to do more validation here for the shape of the column lambda?
     guaranteeNonNullable(expression.parametersValues[0]),
     expression,
+    parentLambda,
     queryBuilderState,
   );
 
@@ -137,6 +140,7 @@ export const processTDSAggregateExpression = (
 export const processTDSGroupByExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
 ): void => {
   // update fetch-structureTABULAR_DATA_STRUCTURE
   queryBuilderState.fetchStructureState.changeImplementation(
@@ -164,6 +168,7 @@ export const processTDSGroupByExpression = (
   );
   QueryBuilderValueSpecificationProcessor.process(
     precedingExpression,
+    parentLambda,
     queryBuilderState,
   );
 
@@ -178,6 +183,7 @@ export const processTDSGroupByExpression = (
     QueryBuilderValueSpecificationProcessor.processChild(
       value,
       expression,
+      parentLambda,
       queryBuilderState,
     ),
   );
@@ -193,6 +199,7 @@ export const processTDSGroupByExpression = (
     QueryBuilderValueSpecificationProcessor.processChild(
       value,
       expression,
+      parentLambda,
       queryBuilderState,
     ),
   );

package/src/stores/fetch-structure/tds/olapGroupBy/{QueryBuilderOLAPGroupByStateBuilder_.ts → QueryBuilderOLAPGroupByStateBuilder.ts}

@@ -44,11 +44,12 @@ import {
   QueryBuilderOLAPGroupByColumnState,
   QueryBuilderTDS_OLAPAggreationOperatorState,
   QueryBuilderTDS_OLAPRankOperatorState,
-} from './QueryBuilderOLAPGroupByState_.js';
+} from './QueryBuilderOLAPGroupByState.js';
 
 export const processTDS_OLAPGroupByExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
 ): void => {
   // check parameters
   const parametersLength = expression.parametersValues.length;
@@ -90,6 +91,7 @@ export const processTDS_OLAPGroupByExpression = (
   );
   QueryBuilderValueSpecificationProcessor.process(
     precedingExpression,
+    parentLambda,
     queryBuilderState,
   );
 

package/src/stores/fetch-structure/tds/olapGroupBy/{QueryBuilderOLAPGroupByValueSpecificationBuilder_.ts → QueryBuilderOLAPGroupByValueSpecificationBuilder.ts}

@@ -34,7 +34,7 @@ import {
   type QueryBuilderOLAPGroupByColumnState,
   type QueryBuilderOLAPGroupByState,
   QueryBuilderTDS_OLAPAggreationOperatorState,
-} from './QueryBuilderOLAPGroupByState_.js';
+} from './QueryBuilderOLAPGroupByState.js';
 
 const appendOLAPGroupByColumnState = (
   olapGroupByColumnState: QueryBuilderOLAPGroupByColumnState,

package/src/stores/fetch-structure/tds/post-filter/QueryBuilderPostFilterState.ts

@@ -20,6 +20,7 @@ import {
   type Type,
   type ValueSpecification,
   type ExecutionResult,
+  type VariableExpression,
   Enumeration,
   PRIMITIVE_TYPE,
   observe_ValueSpecification,
@@ -42,6 +43,7 @@ import {
   hashArray,
   uniq,
   type Hashable,
+  isNonNullable,
 } from '@finos/legend-shared';
 import {
   action,
@@ -68,6 +70,7 @@ import { QUERY_BUILDER_GROUP_OPERATION } from '../../../QueryBuilderGroupOperati
 import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../../graphManager/QueryBuilderHashUtils.js';
 import type { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState.js';
+import { isValueExpressionReferencesinValue } from '../../../QueryBuilderValueSpecificationHelper.js';
 
 export enum QUERY_BUILDER_POST_FILTER_DND_TYPE {
   GROUP_CONDITION = 'GROUP_CONDITION',
@@ -876,6 +879,16 @@ export class QueryBuilderPostFilterState
     Array.from(this.nodes.values()).forEach((node) => node.setIsOpen(true));
   }
 
+  isVariableUsed(variable: VariableExpression): boolean {
+    return Boolean(
+      Array.from(this.nodes.values())
+        .filter(filterByType(QueryBuilderPostFilterTreeConditionNodeData))
+        .map((node) => node.condition.value)
+        .filter(isNonNullable)
+        .find((value) => isValueExpressionReferencesinValue(variable, value)),
+    );
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_HASH_STRUCTURE.POST_FILTER_STATE,

package/src/stores/fetch-structure/tds/post-filter/operators/QueryBuilderPostFilterOperatorHelper.ts

@@ -17,7 +17,7 @@
 import { Multiplicity } from '@finos/legend-graph';
 import { UnsupportedOperationError } from '@finos/legend-shared';
 import { QueryBuilderAggregateColumnState } from '../../aggregation/QueryBuilderAggregationState.js';
-import { QueryBuilderOLAPGroupByColumnState } from '../../olapGroupBy/QueryBuilderOLAPGroupByState_.js';
+import { QueryBuilderOLAPGroupByColumnState } from '../../olapGroupBy/QueryBuilderOLAPGroupByState.js';
 import { QueryBuilderSimpleProjectionColumnState } from '../../projection/QueryBuilderProjectionColumnState.js';
 import type { QueryBuilderTDSColumnState } from '../../QueryBuilderTDSColumnState.js';
 

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionColumnState.ts

@@ -57,6 +57,7 @@ import {
 } from '../../../QueryBuilderConfig.js';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../../graphManager/QueryBuilderHashUtils.js';
 import { LambdaEditorState } from '../../../shared/LambdaEditorState.js';
+import { isValueExpressionReferencesinValue } from '../../../QueryBuilderValueSpecificationHelper.js';
 
 export const QUERY_BUILDER_PROJECTION_COLUMN_DND_TYPE = 'PROJECTION_COLUMN';
 
@@ -124,6 +125,17 @@ export class QueryBuilderSimpleProjectionColumnState
     this.lambdaParameterName = val;
   }
 
+  isVariableUsed(variable: VariableExpression): boolean {
+    return Boolean(
+      this.propertyExpressionState.derivedPropertyExpressionStates.find(
+        (derived) =>
+          derived.parameterValues.find((param) =>
+            isValueExpressionReferencesinValue(variable, param),
+          ),
+      ),
+    );
+  }
+
   changeProperty(
     node: QueryBuilderExplorerTreePropertyNodeData,
     humanizePropertyName: boolean,

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionStateBuilder.ts

@@ -17,6 +17,7 @@
 import {
   type INTERNAL__UnknownValueSpecification,
   type ValueSpecification,
+  type LambdaFunction,
   AbstractPropertyExpression,
   CollectionInstanceValue,
   DerivedProperty,
@@ -59,6 +60,7 @@ import {
 export const processTDSProjectExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
 ): void => {
   // update fetch-structure
   queryBuilderState.fetchStructureState.changeImplementation(
@@ -87,6 +89,7 @@ export const processTDSProjectExpression = (
   );
   QueryBuilderValueSpecificationProcessor.process(
     precedingExpression,
+    parentLambda,
     queryBuilderState,
   );
 
@@ -101,6 +104,7 @@ export const processTDSProjectExpression = (
     QueryBuilderValueSpecificationProcessor.processChild(
       value,
       expression,
+      parentLambda,
       queryBuilderState,
     ),
   );
@@ -236,6 +240,7 @@ export const processTDSProjectionDerivationExpression = (
 export const processTDSTakeExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
 ): void => {
   // check parameters
   assertTrue(
@@ -263,6 +268,7 @@ export const processTDSTakeExpression = (
   );
   QueryBuilderValueSpecificationProcessor.process(
     precedingExpression,
+    parentLambda,
     queryBuilderState,
   );
 
@@ -283,6 +289,7 @@ export const processTDSTakeExpression = (
 export const processTDSDistinctExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
 ): void => {
   // check parameters
   assertTrue(
@@ -309,6 +316,7 @@ export const processTDSDistinctExpression = (
   );
   QueryBuilderValueSpecificationProcessor.process(
     precedingExpression,
+    parentLambda,
     queryBuilderState,
   );
 
@@ -326,6 +334,7 @@ export const processTDSDistinctExpression = (
 export const processTDSSortExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
 ): void => {
   // check parameters
   assertTrue(
@@ -353,6 +362,7 @@ export const processTDSSortExpression = (
   );
   QueryBuilderValueSpecificationProcessor.process(
     precedingExpression,
+    parentLambda,
     queryBuilderState,
   );
 
@@ -367,6 +377,7 @@ export const processTDSSortExpression = (
     QueryBuilderValueSpecificationProcessor.processChild(
       value,
       expression,
+      parentLambda,
       queryBuilderState,
     ),
   );

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionValueSpecificationBuilder.ts

@@ -47,7 +47,7 @@ import {
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graphManager/QueryBuilderSupportedFunctions.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPropertyExpressionChain } from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
-import { appendOLAPGroupByState } from '../olapGroupBy/QueryBuilderOLAPGroupByValueSpecificationBuilder_.js';
+import { appendOLAPGroupByState } from '../olapGroupBy/QueryBuilderOLAPGroupByValueSpecificationBuilder.js';
 import { appendPostFilter } from '../post-filter/QueryBuilderPostFilterValueSpecificationBuilder.js';
 
 const buildSortExpression = (

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -31,6 +31,7 @@ import {
   ActionState,
   type Hashable,
   hashArray,
+  isNonNullable,
 } from '@finos/legend-shared';
 import type { QueryBuilderExplorerTreeDragSource } from '../explorer/QueryBuilderExplorerState.js';
 import { QueryBuilderPropertyExpressionState } from '../QueryBuilderPropertyEditorState.js';
@@ -39,6 +40,7 @@ import {
   type ExecutionResult,
   type AbstractPropertyExpression,
   type ValueSpecification,
+  type VariableExpression,
   observe_ValueSpecification,
 } from '@finos/legend-graph';
 import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../QueryBuilderConfig.js';
@@ -51,6 +53,7 @@ import {
 import type { QueryBuilderFilterOperator } from './QueryBuilderFilterOperator.js';
 import { QUERY_BUILDER_GROUP_OPERATION } from '../QueryBuilderGroupOperationHelper.js';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../graphManager/QueryBuilderHashUtils.js';
+import { isValueExpressionReferencesinValue } from '../QueryBuilderValueSpecificationHelper.js';
 
 export enum QUERY_BUILDER_FILTER_DND_TYPE {
   GROUP_CONDITION = 'GROUP_CONDITION',
@@ -791,6 +794,16 @@ export class QueryBuilderFilterState
     Array.from(this.nodes.values()).forEach((node) => node.setIsOpen(true));
   }
 
+  isVariableUsed(variable: VariableExpression): boolean {
+    return Boolean(
+      Array.from(this.nodes.values())
+        .filter(filterByType(QueryBuilderFilterTreeConditionNodeData))
+        .map((node) => node.condition.value)
+        .filter(isNonNullable)
+        .find((value) => isValueExpressionReferencesinValue(variable, value)),
+    );
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_HASH_STRUCTURE.FILTER_STATE,

package/src/stores/filter/QueryBuilderFilterValueSpecificationBuilder.ts

@@ -17,6 +17,7 @@
 import { isNonNullable, guaranteeNonNullable } from '@finos/legend-shared';
 import {
   type ValueSpecification,
+  type LambdaFunction,
   extractElementNameFromPath,
   SimpleFunctionExpression,
 } from '@finos/legend-graph';
@@ -80,22 +81,25 @@ const buildFilterConditionExpression = (
 
 export const buildFilterExpression = (
   filterState: QueryBuilderFilterState,
-  getAllFunc: SimpleFunctionExpression,
-): SimpleFunctionExpression | undefined => {
+  lambdaFunction: LambdaFunction,
+): void => {
   const filterConditionExpressions = filterState.rootIds
     .map((e) => guaranteeNonNullable(filterState.nodes.get(e)))
     .map((e) => buildFilterConditionExpression(filterState, e))
     .filter(isNonNullable);
 
   if (!filterConditionExpressions.length) {
-    return undefined;
+    return;
   }
   // main filter expression
   const filterExpression = new SimpleFunctionExpression(
     extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER),
   );
+  const currentExpression = guaranteeNonNullable(
+    lambdaFunction.expressionSequence[0],
+  );
   // param [0]
-  filterExpression.parametersValues.push(getAllFunc);
+  filterExpression.parametersValues.push(currentExpression);
   // param [1]
   filterExpression.parametersValues.push(
     buildGenericLambdaFunctionInstanceValue(
@@ -104,5 +108,6 @@ export const buildFilterExpression = (
       filterState.queryBuilderState.graphManagerState.graph,
     ),
   );
-  return filterExpression;
+  // reprocess filter as main expression
+  lambdaFunction.expressionSequence[0] = filterExpression;
 };