@finos/legend-query-builder 4.15.1 → 4.15.3

package/src/components/result/tds/QueryBuilderTDSResultShared.tsx

@@ -22,12 +22,13 @@ import {
 import { observer } from 'mobx-react-lite';
 import { flowResult } from 'mobx';
 import {
-  type TDSExecutionResult,
+  type AbstractPropertyExpression,
   type Enumeration,
-  InstanceValue,
-  EnumValueInstanceValue,
-  EnumValueExplicitReference,
   type ExecutionResult,
+  type TDSExecutionResult,
+  EnumValueExplicitReference,
+  EnumValueInstanceValue,
+  InstanceValue,
   RelationalExecutionActivities,
 } from '@finos/legend-graph';
 import { format as formatSQL } from 'sql-formatter';
@@ -47,6 +48,7 @@ import { forwardRef } from 'react';
 import {
   QueryBuilderDerivationProjectionColumnState,
   QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
 } from '../../../stores/fetch-structure/tds/projection/QueryBuilderProjectionColumnState.js';
 import {
   type QueryBuilderPostFilterTreeNodeData,
@@ -81,6 +83,30 @@ import {
 } from '../../../stores/fetch-structure/tds/post-filter/operators/QueryBuilderPostFilterOperator_IsEmpty.js';
 import { getTDSColumnState } from '../../../stores/fetch-structure/tds/QueryBuilderTDSHelper.js';
 import type { QueryBuilderTDSColumnState } from '../../../stores/fetch-structure/tds/QueryBuilderTDSColumnState.js';
+import {
+  type QueryBuilderFilterState,
+  type QueryBuilderFilterTreeNodeData,
+  FilterConditionState,
+  FilterValueSpecConditionValueState,
+  isCollectionProperty,
+  QueryBuilderFilterTreeConditionNodeData,
+} from '../../../stores/filter/QueryBuilderFilterState.js';
+import { QueryBuilderAggregateColumnState } from '../../../stores/fetch-structure/tds/aggregation/QueryBuilderAggregationState.js';
+import type { QueryBuilderFilterOperator } from '../../../stores/filter/QueryBuilderFilterOperator.js';
+import {
+  QueryBuilderFilterOperator_Equal,
+  QueryBuilderFilterOperator_NotEqual,
+} from '../../../stores/filter/operators/QueryBuilderFilterOperator_Equal.js';
+import {
+  QueryBuilderFilterOperator_In,
+  QueryBuilderFilterOperator_NotIn,
+} from '../../../stores/filter/operators/QueryBuilderFilterOperator_In.js';
+import {
+  QueryBuilderFilterOperator_IsEmpty,
+  QueryBuilderFilterOperator_IsNotEmpty,
+} from '../../../stores/filter/operators/QueryBuilderFilterOperator_IsEmpty.js';
+import type { QueryBuilderState } from '../../../stores/QueryBuilderState.js';
+import type { QueryBuilderPropertyExpressionState } from '../../../stores/QueryBuilderPropertyEditorState.js';
 
 export const tryToFormatSql = (sql: string): string => {
   try {
@@ -139,6 +165,13 @@ export type IQueryRendererParamsWithGridType = DataGridCellRendererParams & {
   tdsExecutionResult: TDSExecutionResult;
 };
 
+const filterEqualOperator = new QueryBuilderFilterOperator_Equal();
+const filterNotEqualOperator = new QueryBuilderFilterOperator_NotEqual();
+const filterInOperator = new QueryBuilderFilterOperator_In();
+const filterNotInOperator = new QueryBuilderFilterOperator_NotIn();
+const filterEmptyOperator = new QueryBuilderFilterOperator_IsEmpty();
+const filterNotEmptyOperator = new QueryBuilderFilterOperator_IsNotEmpty();
+
 const postFilterEqualOperator = new QueryBuilderPostFilterOperator_Equal();
 const postFilterInOperator = new QueryBuilderPostFilterOperator_In();
 const postFilterEmptyOperator = new QueryBuilderPostFilterOperator_IsEmpty();
@@ -148,6 +181,22 @@ const postFilterNotEqualOperator =
   new QueryBuilderPostFilterOperator_NotEqual();
 const postFilterNotInOperator = new QueryBuilderPostFilterOperator_NotIn();
 
+const getExistingFilterNode = (
+  operators: QueryBuilderFilterOperator[],
+  propertyExpressionState: QueryBuilderPropertyExpressionState | undefined,
+  filterState: QueryBuilderFilterState,
+): QueryBuilderFilterTreeNodeData | undefined =>
+  Array.from(filterState.nodes.values())
+    .filter(filterByType(QueryBuilderFilterTreeConditionNodeData))
+    .filter(
+      (node) =>
+        node.condition.propertyExpressionState.path ===
+          propertyExpressionState?.path &&
+        operators
+          .map((op) => op.getLabel())
+          .includes(node.condition.operator.getLabel()),
+    )[0];
+
 const getExistingPostFilterNode = (
   operators: QueryBuilderPostFilterOperator[],
   projectionColumnName: string | undefined,
@@ -173,7 +222,7 @@ const getExistingPostFilterNode = (
 const updateFilterConditionValue = (
   conditionValue: InstanceValue,
   _cellData: QueryBuilderTDSResultCellData,
-  tdsState: QueryBuilderTDSState,
+  queryBuilderState: QueryBuilderState,
 ): void => {
   if (_cellData.value) {
     instanceValue_setValue(
@@ -188,11 +237,58 @@ const updateFilterConditionValue = (
           )
         : _cellData.value,
       0,
-      tdsState.queryBuilderState.observerContext,
+      queryBuilderState.observerContext,
     );
   }
 };
 
+const generateNewFilterConditionNodeData = (
+  applicationStore: ApplicationStore<
+    LegendApplicationConfig,
+    LegendApplicationPluginManager<LegendApplicationPlugin>
+  >,
+  operator: QueryBuilderFilterOperator,
+  _cellData: QueryBuilderTDSResultCellData,
+  filterState: QueryBuilderFilterState,
+  propertyExpression: AbstractPropertyExpression | undefined,
+): void => {
+  let filterConditionState: FilterConditionState;
+  try {
+    if (propertyExpression) {
+      filterConditionState = new FilterConditionState(
+        filterState,
+        propertyExpression,
+        operator,
+      );
+
+      const defaultFilterConditionValue =
+        filterConditionState.operator.getDefaultFilterConditionValue(
+          filterConditionState,
+        );
+
+      filterConditionState.buildRightConditionValueFromValueSpec(
+        defaultFilterConditionValue,
+      );
+      updateFilterConditionValue(
+        defaultFilterConditionValue as InstanceValue,
+        _cellData,
+        filterState.queryBuilderState,
+      );
+      filterState.addNodeFromNode(
+        new QueryBuilderFilterTreeConditionNodeData(
+          undefined,
+          filterConditionState,
+        ),
+        undefined,
+      );
+    }
+  } catch (error) {
+    assertErrorThrown(error);
+    applicationStore.notificationService.notifyWarning(error.message);
+    return;
+  }
+};
+
 const generateNewPostFilterConditionNodeData = async (
   applicationStore: ApplicationStore<
     LegendApplicationConfig,
@@ -235,7 +331,7 @@ const generateNewPostFilterConditionNodeData = async (
       updateFilterConditionValue(
         defaultFilterConditionValue as InstanceValue,
         _cellData,
-        tdsState,
+        tdsState.queryBuilderState,
       );
       tdsState.postFilterState.addNodeFromNode(
         new QueryBuilderPostFilterTreeConditionNodeData(
@@ -252,6 +348,91 @@ const generateNewPostFilterConditionNodeData = async (
   }
 };
 
+const updateExistingFilterConditionNodeData = (
+  existingPreFilterNode: QueryBuilderFilterTreeNodeData,
+  isFilterBy: boolean,
+  _cellData: QueryBuilderTDSResultCellData,
+  operator: QueryBuilderFilterOperator,
+  data: QueryBuilderTDSResultCellData | null,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  if (operator === filterEmptyOperator || operator === filterNotEmptyOperator) {
+    const conditionState = (
+      existingPreFilterNode as QueryBuilderFilterTreeConditionNodeData
+    ).condition;
+    if (conditionState.operator.getLabel() !== operator.getLabel()) {
+      conditionState.changeOperator(
+        isFilterBy ? filterEmptyOperator : filterNotEmptyOperator,
+      );
+    }
+    return;
+  }
+  const conditionState = (
+    existingPreFilterNode as QueryBuilderFilterTreeConditionNodeData
+  ).condition;
+
+  const rightSide = conditionState.rightConditionValue;
+  if (rightSide instanceof FilterValueSpecConditionValueState) {
+    if (conditionState.operator.getLabel() === operator.getLabel()) {
+      const doesValueAlreadyExist =
+        rightSide.value instanceof InstanceValue &&
+        (rightSide.value instanceof EnumValueInstanceValue
+          ? rightSide.value.values.map((ef) => ef.value.name)
+          : rightSide.value.values
+        ).includes(_cellData.value);
+
+      if (!doesValueAlreadyExist) {
+        const currentValueSpecificaton = rightSide.value;
+        const newValueSpecification =
+          conditionState.operator.getDefaultFilterConditionValue(
+            conditionState,
+          );
+        updateFilterConditionValue(
+          newValueSpecification as InstanceValue,
+          _cellData,
+          queryBuilderState,
+        );
+        conditionState.changeOperator(
+          isFilterBy ? filterInOperator : filterNotInOperator,
+        );
+        instanceValue_setValues(
+          rightSide.value as InstanceValue,
+          [currentValueSpecificaton, newValueSpecification],
+          queryBuilderState.observerContext,
+        );
+      }
+    } else {
+      const doesValueAlreadyExist =
+        rightSide.value instanceof InstanceValue &&
+        rightSide.value.values
+          .filter((v) => v instanceof InstanceValue)
+          .map((v) =>
+            v instanceof EnumValueInstanceValue
+              ? v.values.map((ef) => ef.value.name)
+              : v.values,
+          )
+          .flat()
+          .includes(_cellData.value ?? data?.value);
+
+      if (!doesValueAlreadyExist) {
+        const newValueSpecification = (
+          isFilterBy ? filterEqualOperator : filterNotEqualOperator
+        ).getDefaultFilterConditionValue(conditionState);
+        updateFilterConditionValue(
+          newValueSpecification as InstanceValue,
+          _cellData,
+          queryBuilderState,
+        );
+        instanceValue_setValues(
+          rightSide.value as InstanceValue,
+          [...(rightSide.value as InstanceValue).values, newValueSpecification],
+          queryBuilderState.observerContext,
+        );
+      }
+    }
+  }
+};
+
 const updateExistingPostFilterConditionNodeData = (
   existingPostFilterNode: QueryBuilderPostFilterTreeNodeData,
   isFilterBy: boolean,
@@ -297,7 +478,7 @@ const updateExistingPostFilterConditionNodeData = (
         updateFilterConditionValue(
           newValueSpecification as InstanceValue,
           _cellData,
-          tdsState,
+          tdsState.queryBuilderState,
         );
         conditionState.changeOperator(
           isFilterBy ? postFilterInOperator : postFilterNotInOperator,
@@ -328,7 +509,7 @@ const updateExistingPostFilterConditionNodeData = (
         updateFilterConditionValue(
           newValueSpecification as InstanceValue,
           _cellData,
-          tdsState,
+          tdsState.queryBuilderState,
         );
         instanceValue_setValues(
           rightSide.value as InstanceValue,
@@ -343,6 +524,25 @@ const updateExistingPostFilterConditionNodeData = (
 const getFilterOperator = (
   isFilterBy: boolean,
   _cellData: QueryBuilderTDSResultCellData,
+): QueryBuilderFilterOperator => {
+  if (isFilterBy) {
+    if (_cellData.value === null) {
+      return filterEmptyOperator;
+    } else {
+      return filterEqualOperator;
+    }
+  } else {
+    if (_cellData.value === null) {
+      return filterNotEmptyOperator;
+    } else {
+      return filterNotEqualOperator;
+    }
+  }
+};
+
+const getPostFilterOperator = (
+  isFilterBy: boolean,
+  _cellData: QueryBuilderTDSResultCellData,
 ): QueryBuilderPostFilterOperator => {
   if (isFilterBy) {
     if (_cellData.value === null) {
@@ -359,7 +559,7 @@ const getFilterOperator = (
   }
 };
 
-const filterByOrOutValue = (
+const preFilterByOrOutValue = (
   applicationStore: ApplicationStore<
     LegendApplicationConfig,
     LegendApplicationPluginManager<LegendApplicationPlugin>
@@ -367,13 +567,58 @@ const filterByOrOutValue = (
   isFilterBy: boolean,
   _cellData: QueryBuilderTDSResultCellData,
   data: QueryBuilderTDSResultCellData | null,
-  tdsState: QueryBuilderTDSState,
+  propertyExpressionState: QueryBuilderPropertyExpressionState,
+  queryBuilderState: QueryBuilderState,
 ): void => {
-  tdsState.setShowPostFilterPanel(true);
+  queryBuilderState.filterState.setShowPanel(true);
   const operator = getFilterOperator(isFilterBy, _cellData);
-  const tdsColState = data?.columnName
-    ? getTDSColumnState(tdsState, data.columnName)
-    : undefined;
+  const existingPreFilterNode = getExistingFilterNode(
+    _cellData.value === null
+      ? [filterEmptyOperator, filterNotEmptyOperator]
+      : isFilterBy
+        ? [filterEqualOperator, filterInOperator]
+        : [filterNotEqualOperator, filterNotInOperator],
+    propertyExpressionState,
+    queryBuilderState.filterState,
+  );
+  if (existingPreFilterNode) {
+    updateExistingFilterConditionNodeData(
+      existingPreFilterNode,
+      isFilterBy,
+      _cellData,
+      operator,
+      data,
+      queryBuilderState,
+    );
+  } else {
+    try {
+      generateNewFilterConditionNodeData(
+        applicationStore,
+        operator,
+        _cellData,
+        queryBuilderState.filterState,
+        propertyExpressionState.propertyExpression,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      applicationStore.alertUnhandledError(error);
+    }
+  }
+};
+
+const postFilterByOrOutValue = async (
+  applicationStore: ApplicationStore<
+    LegendApplicationConfig,
+    LegendApplicationPluginManager<LegendApplicationPlugin>
+  >,
+  isFilterBy: boolean,
+  _cellData: QueryBuilderTDSResultCellData,
+  data: QueryBuilderTDSResultCellData | null,
+  tdsColState: QueryBuilderTDSColumnState,
+  tdsState: QueryBuilderTDSState,
+): Promise<void> => {
+  tdsState.setShowPostFilterPanel(true);
+  const operator = getPostFilterOperator(isFilterBy, _cellData);
   const existingPostFilterNode = getExistingPostFilterNode(
     _cellData.value === null
       ? [postFilterEmptyOperator, postFilterNotEmptyOperator]
@@ -394,17 +639,69 @@ const filterByOrOutValue = (
       tdsState,
     );
   } else {
-    generateNewPostFilterConditionNodeData(
+    try {
+      await generateNewPostFilterConditionNodeData(
+        applicationStore,
+        operator,
+        _cellData,
+        tdsState,
+        tdsColState,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      applicationStore.alertUnhandledError(error);
+    }
+  }
+};
+
+const filterByOrOutValue = async (
+  applicationStore: ApplicationStore<
+    LegendApplicationConfig,
+    LegendApplicationPluginManager<LegendApplicationPlugin>
+  >,
+  isFilterBy: boolean,
+  _cellData: QueryBuilderTDSResultCellData,
+  data: QueryBuilderTDSResultCellData | null,
+  tdsState: QueryBuilderTDSState,
+): Promise<void> => {
+  const tdsColState = data?.columnName
+    ? getTDSColumnState(tdsState, _cellData.columnName)
+    : _cellData.columnName
+      ? getTDSColumnState(tdsState, _cellData.columnName)
+      : undefined;
+  if (
+    tdsColState instanceof QueryBuilderDerivationProjectionColumnState ||
+    tdsColState instanceof QueryBuilderAggregateColumnState ||
+    (tdsColState instanceof QueryBuilderSimpleProjectionColumnState &&
+      isCollectionProperty(
+        tdsColState.propertyExpressionState.propertyExpression,
+      ))
+  ) {
+    await postFilterByOrOutValue(
       applicationStore,
-      operator,
+      isFilterBy,
       _cellData,
-      tdsState,
+      data,
       tdsColState,
-    ).catch(applicationStore.alertUnhandledError);
+      tdsState,
+    );
+  } else if (tdsColState instanceof QueryBuilderSimpleProjectionColumnState) {
+    preFilterByOrOutValue(
+      applicationStore,
+      isFilterBy,
+      _cellData,
+      data,
+      tdsColState.propertyExpressionState,
+      tdsState.queryBuilderState,
+    );
+  } else {
+    applicationStore.notificationService.notifyError(
+      `Can't filter column '${data?.columnName ? data.columnName : _cellData.columnName}'`,
+    );
   }
 };
 
-export const filterByOrOutValues = (
+export const filterByOrOutValues = async (
   applicationStore: ApplicationStore<
     LegendApplicationConfig,
     LegendApplicationPluginManager<LegendApplicationPlugin>
@@ -412,10 +709,17 @@ export const filterByOrOutValues = (
   data: QueryBuilderTDSResultCellData | null,
   isFilterBy: boolean,
   tdsState: QueryBuilderTDSState,
-): void => {
-  tdsState.queryBuilderState.resultState.selectedCells.forEach((_cellData) => {
-    filterByOrOutValue(applicationStore, isFilterBy, _cellData, data, tdsState);
-  });
+): Promise<void> => {
+  for (const _cellData of tdsState.queryBuilderState.resultState
+    .selectedCells) {
+    await filterByOrOutValue(
+      applicationStore,
+      isFilterBy,
+      _cellData,
+      data,
+      tdsState,
+    );
+  }
 };
 
 export const QueryBuilderGridResultContextMenu = observer(
@@ -440,7 +744,9 @@ export const QueryBuilderGridResultContextMenu = observer(
         <MenuContentItem
           disabled={!tdsColState}
           onClick={(): void => {
-            filterByOrOutValues(applicationStore, data, true, tdsState);
+            filterByOrOutValues(applicationStore, data, true, tdsState).catch(
+              tdsState.queryBuilderState.applicationStore.alertUnhandledError,
+            );
           }}
         >
           Filter By
@@ -448,7 +754,9 @@ export const QueryBuilderGridResultContextMenu = observer(
         <MenuContentItem
           disabled={!tdsColState}
           onClick={(): void => {
-            filterByOrOutValues(applicationStore, data, false, tdsState);
+            filterByOrOutValues(applicationStore, data, false, tdsState).catch(
+              tdsState.queryBuilderState.applicationStore.alertUnhandledError,
+            );
           }}
         >
           Filter Out

package/src/stores/data-cube/QueryBuilderDataCubeApplicationEngine.ts

@@ -19,10 +19,7 @@ import {
   shouldDisplayVirtualAssistantDocumentationEntry,
   type GenericLegendApplicationStore,
 } from '@finos/legend-application';
-import {
-  DataCubeApplicationEngine,
-  type ActionAlert,
-} from '@finos/legend-data-cube';
+import { DataCubeApplicationEngine } from '@finos/legend-data-cube';
 import { LogEvent, type DocumentationEntry } from '@finos/legend-shared';
 
 export class QueryBuilderDataCubeApplicationEngine extends DataCubeApplicationEngine {
@@ -58,14 +55,6 @@ export class QueryBuilderDataCubeApplicationEngine extends DataCubeApplicationEn
     this.application.layoutService.setWindowTitle(title);
   }
 
-  alertAction(alertInfo: ActionAlert | undefined) {
-    this.currentActionAlert = alertInfo;
-  }
-
-  alertUnhandledError(error: Error) {
-    this.application.alertUnhandledError(error);
-  }
-
   logDebug(message: string, ...data: unknown[]) {
     this.application.logService.debug(
       LogEvent.create(APPLICATION_EVENT.DEBUG),

package/src/stores/data-cube/QueryBuilderDataCubeEngine.ts

@@ -28,6 +28,7 @@ import {
   type GraphManagerState,
   type PureModel,
   type V1_ValueSpecification,
+  type ParameterValue,
 } from '@finos/legend-graph';
 import {
   _elementPtr,
@@ -67,9 +68,13 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
   readonly graphState: GraphManagerState;
   readonly selectInitialQuery: RawLambda;
   readonly mappingPath: string | undefined;
+  readonly parameterValues: ParameterValue[] | undefined;
   readonly runtimePath: string;
+  _parameters: object | undefined;
+
   constructor(
     selectQuery: RawLambda,
+    parameterValues: ParameterValue[] | undefined,
     mappingPath: string | undefined,
     runtimePath: string,
     graphManagerState: GraphManagerState,
@@ -79,6 +84,7 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
     this.selectInitialQuery = selectQuery;
     this.mappingPath = mappingPath;
     this.runtimePath = runtimePath;
+    this.parameterValues = parameterValues;
   }
 
   get sourceLabel(): string {
@@ -105,6 +111,7 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
     ) {
       srcFuncExp = srcFuncExp.body[0];
     }
+    this._parameters = this.selectInitialQuery.parameters;
     const fromFuncExp = new V1_AppliedFunction();
     fromFuncExp.function = _functionName(SUPPORTED_FUNCTIONS.FROM);
     fromFuncExp.parameters = [srcFuncExp];
@@ -159,6 +166,8 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
     // we return undefined as we assume the grid license is set at the application level where query builder is built
     return Promise.resolve({
       gridClientLicense: undefined,
+      simpleSampleDataTableName: '',
+      complexSampleDataTableName: '',
     });
   }
   override async getQueryTypeahead(
@@ -191,6 +200,16 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
     );
   }
 
+  override getQueryCode(
+    query: V1_ValueSpecification,
+    pretty?: boolean | undefined,
+  ): Promise<string> {
+    return this.graphState.graphManager.valueSpecificationToPureCode(
+      V1_serializeValueSpecification(query, []),
+      pretty,
+    );
+  }
+
   override getQueryRelationType(
     query: V1_ValueSpecification,
   ): Promise<RelationType> {
@@ -227,12 +246,16 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
     executedSQL: string;
   }> {
     const lambda = this.buildRawLambdaFromValueSpec(query);
+    lambda.parameters = this._parameters;
     const [executionWithMetadata, queryString] = await Promise.all([
       this.graphState.graphManager.runQuery(
         lambda,
         undefined,
         undefined,
         this.graph,
+        {
+          parameterValues: this.parameterValues ?? [],
+        },
       ),
       this.graphState.graphManager.lambdaToPureCode(lambda),
     ]);

package/src/stores/data-cube/QueryBuilderDataCubeEngineHelper.ts

@@ -15,9 +15,13 @@
  */
 
 import { type DataCubeEngine } from '@finos/legend-data-cube';
-import type { QueryBuilderState } from '../QueryBuilderState.js';
+import {
+  QUERY_BUILDER_LAMBDA_WRITER_MODE,
+  type QueryBuilderState,
+} from '../QueryBuilderState.js';
 import { RuntimePointer } from '@finos/legend-graph';
 import { QueryBuilderDataCubeEngine } from './QueryBuilderDataCubeEngine.js';
+import { buildExecutionParameterValues } from '../shared/LambdaParameterState.js';
 
 export const createDataCubeEngineFromQueryBuilder = (
   queryBuilderState: QueryBuilderState,
@@ -31,11 +35,22 @@ export const createDataCubeEngineFromQueryBuilder = (
   if (!runtime) {
     return undefined;
   }
+  const currentLambdaWriterMode = queryBuilderState.lambdaWriteMode;
+  // ensure we write in new tds mode
+  queryBuilderState.setLambdaWriteMode(
+    QUERY_BUILDER_LAMBDA_WRITER_MODE.TYPED_FETCH_STRUCTURE,
+  );
+  const parameterValues = buildExecutionParameterValues(
+    queryBuilderState.parametersState.parameterStates,
+    queryBuilderState.graphManagerState,
+  );
   const queryBuilderEngine = new QueryBuilderDataCubeEngine(
     queryBuilderState.buildQuery(),
+    parameterValues,
     queryBuilderState.executionContextState.mapping?.path,
     runtime,
     queryBuilderState.graphManagerState,
   );
+  queryBuilderState.setLambdaWriteMode(currentLambdaWriterMode);
   return queryBuilderEngine;
 };

package/src/stores/filter/QueryBuilderFilterOperator.ts

@@ -27,7 +27,7 @@ import type {
 export abstract class QueryBuilderFilterOperator implements Hashable {
   readonly uuid = uuid();
 
-  abstract getLabel(filterConditionState: FilterConditionState): string;
+  abstract getLabel(): string;
 
   abstract isCompatibleWithFilterConditionProperty(
     filterConditionState: FilterConditionState,

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -246,6 +246,7 @@ export class FilterConditionState implements Hashable {
   constructor(
     filterState: QueryBuilderFilterState,
     propertyExpression: AbstractPropertyExpression,
+    operator?: QueryBuilderFilterOperator,
   ) {
     makeObservable(this, {
       propertyExpressionState: observable,
@@ -271,11 +272,15 @@ export class FilterConditionState implements Hashable {
     );
 
     // operator
-    assertTrue(
-      this.operators.length !== 0,
-      `Can't find an operator for property '${this.propertyExpressionState.path}': no operators registered`,
-    );
-    this.operator = this.operators[0] as QueryBuilderFilterOperator;
+    if (operator) {
+      this.operator = operator;
+    } else {
+      assertTrue(
+        this.operators.length !== 0,
+        `Can't find an operator for property '${this.propertyExpressionState.path}': no operators registered`,
+      );
+      this.operator = this.operators[0] as QueryBuilderFilterOperator;
+    }
     this.buildRightConditionValueFromValueSpec(
       this.operator.getDefaultFilterConditionValue(this),
     );

package/src/stores/filter/QueryBuilderFilterStateBuilder.ts

@@ -332,7 +332,7 @@ const processFilterTree = (
         assertTrue(
           parentLambdaVariableName === variableName,
           `Can't process ${extractElementNameFromPath(
-            filterConditionState.operator.getLabel(filterConditionState),
+            filterConditionState.operator.getLabel(),
           )}() expression: expects variable used in lambda body '${variableName}' to match lambda parameter '${parentLambdaVariableName}'`,
         );
         filterState.addNodeFromNode(