@finos/legend-query-builder 4.7.4 → 4.8.0

package/src/stores/QueryBuilderTypeaheadHelper.ts

@@ -15,77 +15,356 @@
  */
 
 import {
-  type AbstractPropertyExpression,
+  AbstractPropertyExpression,
   type ExecutionResult,
   type ValueSpecification,
   PrimitiveInstanceValue,
   PRIMITIVE_TYPE,
   TDSExecutionResult,
   type RawLambda,
+  DerivedProperty,
+  Class,
+  SimpleFunctionExpression,
+  matchFunctionName,
+  PrimitiveType,
+  type ObserverContext,
+  Multiplicity,
+  getMilestoneTemporalStereotype,
+  extractElementNameFromPath,
+  CollectionInstanceValue,
+  GenericTypeExplicitReference,
+  GenericType,
+  CORE_PURE_PATH,
+  FunctionType,
+  LambdaFunction,
+  PackageableElementExplicitReference,
+  PropertyExplicitReference,
+  getAllClassDerivedProperties,
+  VariableExpression,
+  buildRawLambdaFromLambdaFunction,
+  type Type,
+  INTERNAL__UnknownValueSpecification,
+  V1_transformRawLambda,
+  V1_GraphTransformerContextBuilder,
+  V1_serializeRawValueSpecification,
 } from '@finos/legend-graph';
-import { guaranteeType, isNonNullable, isString } from '@finos/legend-shared';
+import {
+  getNullableFirstEntry,
+  guaranteeNonNullable,
+  guaranteeType,
+  isNonNullable,
+  isString,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
 import { QueryBuilderPostFilterOperator_StartWith } from './fetch-structure/tds/post-filter/operators/QueryBuilderPostFilterOperator_StartWith.js';
 import type { QueryBuilderAggregateColumnState } from './fetch-structure/tds/aggregation/QueryBuilderAggregationState.js';
 import {
-  PostFilterConditionState,
-  QueryBuilderPostFilterTreeConditionNodeData,
+  getTDSColumnDerivedProperyFromType,
+  type TDS_COLUMN_GETTER,
 } from './fetch-structure/tds/post-filter/QueryBuilderPostFilterState.js';
 import {
+  QueryBuilderDerivationProjectionColumnState,
   QueryBuilderProjectionColumnState,
   QueryBuilderSimpleProjectionColumnState,
 } from './fetch-structure/tds/projection/QueryBuilderProjectionColumnState.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
-import { QueryBuilderTDSState } from './fetch-structure/tds/QueryBuilderTDSState.js';
 import {
   DEFAULT_TYPEAHEAD_SEARCH_LIMIT,
   DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH,
 } from '@finos/legend-application';
+import {
+  QUERY_BUILDER_PURE_PATH,
+  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
+} from '../graph/QueryBuilderMetaModelConst.js';
+import {
+  functionExpression_setParametersValues,
+  variableExpression_setName,
+} from './shared/ValueSpecificationModifierHelper.js';
+import { createSupportedFunctionExpression } from './shared/ValueSpecificationEditorHelper.js';
+import { buildGetAllFunction } from './QueryBuilderValueSpecificationBuilder.js';
+import { getPropertyChainName } from './QueryBuilderPropertyEditorState.js';
+import { buildGenericLambdaFunctionInstanceValue } from './QueryBuilderValueSpecificationHelper.js';
+import {
+  DEFAULT_LAMBDA_VARIABLE_NAME,
+  DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME,
+} from './QueryBuilderConfig.js';
+import type { QueryBuilderAggregateOperator } from './fetch-structure/tds/aggregation/QueryBuilderAggregateOperator.js';
 
-const initializeQueryBuilderState = (
-  queryBuilderState: QueryBuilderState,
-): QueryBuilderState => {
-  const builderState = queryBuilderState.INTERNAL__toBasicQueryBuilderState();
-  const tdsState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderTDSState,
-  );
-  tdsState.resultSetModifierState.distinct = true;
-  tdsState.resultSetModifierState.limit = DEFAULT_TYPEAHEAD_SEARCH_LIMIT;
-  return builderState;
+const buildPropertyExpressionChainWithDefaultMilestoningDates = (
+  propertyExpression: AbstractPropertyExpression,
+  lambdaParameterName: string,
+  observerContext: ObserverContext,
+): AbstractPropertyExpression => {
+  const newPropertyExpression = new AbstractPropertyExpression('');
+  newPropertyExpression.func = propertyExpression.func;
+  newPropertyExpression.parametersValues = [
+    ...propertyExpression.parametersValues,
+  ];
+
+  let nextExpression: ValueSpecification | undefined;
+  let currentExpression: ValueSpecification | undefined = newPropertyExpression;
+  while (currentExpression instanceof AbstractPropertyExpression) {
+    nextExpression = getNullableFirstEntry(currentExpression.parametersValues);
+    if (nextExpression instanceof AbstractPropertyExpression) {
+      const parameterValue = new AbstractPropertyExpression('');
+      parameterValue.func = nextExpression.func;
+      parameterValue.parametersValues = [...nextExpression.parametersValues];
+      nextExpression = parameterValue;
+      currentExpression.parametersValues[0] = parameterValue;
+    }
+    if (
+      currentExpression instanceof AbstractPropertyExpression &&
+      currentExpression.func.value.genericType.value.rawType instanceof Class &&
+      currentExpression.func.value._OWNER._generatedMilestonedProperties
+        .length !== 0 &&
+      currentExpression.func.value instanceof DerivedProperty &&
+      !currentExpression.func.value._OWNER.derivedProperties.includes(
+        currentExpression.func.value,
+      )
+    ) {
+      const parameterValue = createSupportedFunctionExpression(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.NOW,
+        PrimitiveType.DATETIME,
+      );
+      const parameterValues =
+        currentExpression.parametersValues.length === 2
+          ? [parameterValue]
+          : [parameterValue, parameterValue];
+      functionExpression_setParametersValues(
+        currentExpression,
+        [
+          guaranteeNonNullable(currentExpression.parametersValues[0]),
+          ...parameterValues,
+        ],
+        observerContext,
+      );
+    }
+    currentExpression = nextExpression;
+    // 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 = getNullableFirstEntry(
+        currentExpression.parametersValues,
+      );
+    }
+  }
+
+  // Update the root lambda name based on the parent's lambda parameter name.
+  if (currentExpression instanceof VariableExpression) {
+    variableExpression_setName(currentExpression, lambdaParameterName);
+  }
+  return newPropertyExpression;
 };
 
-const buildColumnTypeaheadQuery = (
-  builderState: QueryBuilderState,
-  columnState:
-    | QueryBuilderProjectionColumnState
-    | QueryBuilderAggregateColumnState,
-  value: ValueSpecification | undefined,
+const buildRawLambda = (
+  queryBuilderState: QueryBuilderState,
+  propertyExpression?: AbstractPropertyExpression | undefined,
+  aggregationOperator?: QueryBuilderAggregateOperator | undefined,
+  colLambda?: ValueSpecification | undefined,
+  colType?: Type | undefined,
+  colName?: string | undefined,
+  value?: ValueSpecification | undefined,
 ): RawLambda => {
-  const tdsState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderTDSState,
+  if (!propertyExpression && !(colLambda && colType && colName)) {
+    throw new UnsupportedOperationError(`Can't build typeahead query`);
+  }
+
+  const lambdaFunction = new LambdaFunction(
+    new FunctionType(
+      PackageableElementExplicitReference.create(
+        queryBuilderState.graphManagerState.graph.getType(CORE_PURE_PATH.ANY),
+      ),
+      Multiplicity.ONE,
+    ),
   );
-  let projectionColumnState;
-  if (columnState instanceof QueryBuilderProjectionColumnState) {
-    projectionColumnState = columnState;
+
+  // build getAll function
+  const _class = guaranteeNonNullable(queryBuilderState.class);
+  const getAllFn = buildGetAllFunction(
+    guaranteeNonNullable(queryBuilderState.class),
+    Multiplicity.ONE,
+  );
+  const milestoningStereotype = getMilestoneTemporalStereotype(
+    _class,
+    queryBuilderState.graphManagerState.graph,
+  );
+  if (milestoningStereotype) {
+    // build milestoning parameter(s) for getAll()
+    queryBuilderState.milestoningState
+      .getMilestoningImplementation(milestoningStereotype)
+      .buildGetAllWithDefaultParameters(getAllFn);
+  }
+  lambdaFunction.expressionSequence[0] = getAllFn;
+
+  // projection
+  const columnName = propertyExpression
+    ? getPropertyChainName(propertyExpression, false)
+    : colName;
+  if (aggregationOperator) {
+    const groupByFunction = new SimpleFunctionExpression(
+      extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
+      ),
+    );
+
+    const colLambdas = new CollectionInstanceValue(Multiplicity.ZERO);
+    const aggregateLambdas = new CollectionInstanceValue(Multiplicity.ONE);
+    const colAliases = new CollectionInstanceValue(Multiplicity.ONE);
+    const colAlias = new PrimitiveInstanceValue(
+      GenericTypeExplicitReference.create(
+        new GenericType(PrimitiveType.STRING),
+      ),
+    );
+    colAlias.values.push(columnName);
+    colAliases.values.push(colAlias);
+    const columnLambda = propertyExpression
+      ? buildGenericLambdaFunctionInstanceValue(
+          DEFAULT_LAMBDA_VARIABLE_NAME,
+          [propertyExpression],
+          queryBuilderState.graphManagerState.graph,
+        )
+      : colLambda;
+    const aggregateFunctionExpression = new SimpleFunctionExpression(
+      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG),
+    );
+    const aggregateLambda = buildGenericLambdaFunctionInstanceValue(
+      DEFAULT_LAMBDA_VARIABLE_NAME,
+      [
+        aggregationOperator.buildAggregateExpression(
+          propertyExpression,
+          DEFAULT_LAMBDA_VARIABLE_NAME,
+          queryBuilderState.graphManagerState.graph,
+        ),
+      ],
+      queryBuilderState.graphManagerState.graph,
+    );
+    aggregateFunctionExpression.parametersValues = [
+      guaranteeNonNullable(columnLambda),
+      aggregateLambda,
+    ];
+    aggregateLambdas.values.push(aggregateFunctionExpression);
+    groupByFunction.parametersValues = [
+      lambdaFunction.expressionSequence[0],
+      colLambdas,
+      aggregateLambdas,
+      colAliases,
+    ];
+    lambdaFunction.expressionSequence[0] = groupByFunction;
   } else {
-    projectionColumnState = columnState.projectionColumnState;
-    const aggregationState = tdsState.aggregationState;
-    aggregationState.columns = [columnState];
+    const projectFunction = new SimpleFunctionExpression(
+      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT),
+    );
+    const colLambdas = new CollectionInstanceValue(Multiplicity.ONE);
+    const colAliases = new CollectionInstanceValue(Multiplicity.ONE);
+    // column alias
+    const colAlias = new PrimitiveInstanceValue(
+      GenericTypeExplicitReference.create(
+        new GenericType(PrimitiveType.STRING),
+      ),
+    );
+    colAlias.values.push(columnName);
+    colAliases.values.push(colAlias);
+    const columnLambda = propertyExpression
+      ? buildGenericLambdaFunctionInstanceValue(
+          DEFAULT_LAMBDA_VARIABLE_NAME,
+          [propertyExpression],
+          queryBuilderState.graphManagerState.graph,
+        )
+      : colLambda;
+    colLambdas.values.push(guaranteeNonNullable(columnLambda));
+    projectFunction.parametersValues = [
+      lambdaFunction.expressionSequence[0],
+      colLambdas,
+      colAliases,
+    ];
+    lambdaFunction.expressionSequence[0] = projectFunction;
   }
-  tdsState.projectionColumns = [projectionColumnState];
-  const postConditionState = new PostFilterConditionState(
-    tdsState.postFilterState,
-    columnState,
-    value,
-    new QueryBuilderPostFilterOperator_StartWith(),
+
+  // append post filter
+  const operator = new QueryBuilderPostFilterOperator_StartWith();
+  const tdsPropertyExpression = new AbstractPropertyExpression('');
+  let tdsDerivedPropertyName: TDS_COLUMN_GETTER;
+  const correspondingTDSDerivedProperty = operator.getTDSColumnGetter();
+  if (correspondingTDSDerivedProperty) {
+    tdsDerivedPropertyName = correspondingTDSDerivedProperty;
+  } else {
+    const type =
+      propertyExpression?.func.value.genericType.value.rawType ?? colType;
+    tdsDerivedPropertyName = getTDSColumnDerivedProperyFromType(
+      guaranteeNonNullable(type),
+    );
+  }
+  tdsPropertyExpression.func = PropertyExplicitReference.create(
+    guaranteeNonNullable(
+      getAllClassDerivedProperties(
+        queryBuilderState.graphManagerState.graph.getClass(
+          QUERY_BUILDER_PURE_PATH.TDS_ROW,
+        ),
+      ).find((p) => p.name === tdsDerivedPropertyName),
+    ),
   );
-  const postFilterNode = new QueryBuilderPostFilterTreeConditionNodeData(
-    undefined,
-    postConditionState,
+  const variableName = new VariableExpression(
+    DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME,
+    Multiplicity.ONE,
+  );
+  const colInstanceValue = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(new GenericType(PrimitiveType.STRING)),
+  );
+  colInstanceValue.values = [columnName];
+  tdsPropertyExpression.parametersValues = [variableName, colInstanceValue];
+
+  const postFilterExpression = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.STARTS_WITH),
+  );
+  postFilterExpression.parametersValues.push(tdsPropertyExpression);
+  if (value) {
+    postFilterExpression.parametersValues.push(value);
+  }
+  const filterLambda = buildGenericLambdaFunctionInstanceValue(
+    DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME,
+    [postFilterExpression],
+    queryBuilderState.graphManagerState.graph,
+  );
+
+  // build post-filter expression
+  const filterExpression = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER),
+  );
+  const projectExpression = guaranteeNonNullable(
+    lambdaFunction.expressionSequence[0],
+  );
+  filterExpression.parametersValues = [projectExpression, filterLambda];
+  lambdaFunction.expressionSequence[0] = filterExpression;
+
+  // append distinct and take
+  const postFilterExp = lambdaFunction.expressionSequence[0];
+  let currentExpression = postFilterExp;
+  const distinctFunction = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT),
+  );
+  distinctFunction.parametersValues[0] = currentExpression;
+  currentExpression = distinctFunction;
+  const limit = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(new GenericType(PrimitiveType.INTEGER)),
+  );
+  limit.values = [DEFAULT_TYPEAHEAD_SEARCH_LIMIT];
+  const takeFunction = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE),
+  );
+  takeFunction.parametersValues[0] = currentExpression;
+  takeFunction.parametersValues[1] = limit;
+  currentExpression = takeFunction;
+  lambdaFunction.expressionSequence[0] = currentExpression;
+  return buildRawLambdaFromLambdaFunction(
+    lambdaFunction,
+    queryBuilderState.graphManagerState,
   );
-  tdsState.postFilterState.addNodeFromNode(postFilterNode, undefined);
-  return builderState.resultState.buildExecutionRawLambda();
 };
 
 export const buildPropertyTypeaheadQuery = (
@@ -93,17 +372,22 @@ export const buildPropertyTypeaheadQuery = (
   propertyExpression: AbstractPropertyExpression,
   value: ValueSpecification | undefined,
 ): RawLambda => {
-  const builderState = initializeQueryBuilderState(queryBuilderState);
-  const tdsState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderTDSState,
-  );
-  const columnState = new QueryBuilderSimpleProjectionColumnState(
-    tdsState,
-    propertyExpression,
-    false,
+  const newPropertyExpression =
+    buildPropertyExpressionChainWithDefaultMilestoningDates(
+      propertyExpression,
+      DEFAULT_LAMBDA_VARIABLE_NAME,
+      queryBuilderState.observerContext,
+    );
+
+  return buildRawLambda(
+    queryBuilderState,
+    newPropertyExpression,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    value,
   );
-  return buildColumnTypeaheadQuery(builderState, columnState, value);
 };
 
 export const buildProjectionColumnTypeaheadQuery = (
@@ -113,8 +397,52 @@ export const buildProjectionColumnTypeaheadQuery = (
     | QueryBuilderAggregateColumnState,
   value: ValueSpecification | undefined,
 ): RawLambda => {
-  const builderState = initializeQueryBuilderState(queryBuilderState);
-  return buildColumnTypeaheadQuery(builderState, columnState, value);
+  let propertyExpression: AbstractPropertyExpression | undefined = undefined;
+  let aggregationOperator: QueryBuilderAggregateOperator | undefined =
+    undefined;
+  let columnLambda: ValueSpecification | undefined = undefined;
+  let columnName: string | undefined = undefined;
+  let columnType: Type | undefined = undefined;
+  let column: QueryBuilderProjectionColumnState;
+  if (columnState instanceof QueryBuilderProjectionColumnState) {
+    column = columnState;
+  } else {
+    column = columnState.projectionColumnState;
+    aggregationOperator = columnState.operator;
+  }
+  if (column instanceof QueryBuilderDerivationProjectionColumnState) {
+    columnLambda = new INTERNAL__UnknownValueSpecification(
+      V1_serializeRawValueSpecification(
+        V1_transformRawLambda(
+          column.lambda,
+          new V1_GraphTransformerContextBuilder(
+            // TODO?: do we need to include the plugins here?
+            [],
+          ).build(),
+        ),
+      ),
+    );
+    columnName = column.columnName;
+    columnType = column.returnType;
+  } else {
+    propertyExpression =
+      buildPropertyExpressionChainWithDefaultMilestoningDates(
+        guaranteeType(column, QueryBuilderSimpleProjectionColumnState)
+          .propertyExpressionState.propertyExpression,
+        DEFAULT_LAMBDA_VARIABLE_NAME,
+        queryBuilderState.observerContext,
+      );
+  }
+
+  return buildRawLambda(
+    queryBuilderState,
+    propertyExpression,
+    aggregationOperator,
+    columnLambda,
+    columnType,
+    columnName,
+    value,
+  );
 };
 
 export const buildTypeaheadOptions = (result: ExecutionResult): string[] => {

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

@@ -73,6 +73,7 @@ export abstract class QueryBuilderFetchStructureImplementationState
     options?: LambdaFunctionBuilderOption,
   ): void;
   abstract initialize(): void;
+  abstract initializeWithQuery(): void;
   abstract get hashCode(): string;
 
   get TEMPORARY__showPostFetchStructurePanel(): boolean {

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

@@ -37,6 +37,7 @@ export class QueryBuilderFetchStructureState {
     makeObservable(this, {
       implementation: observable,
       changeImplementation: action,
+      initializeWithQuery: action,
     });
 
     this.queryBuilderState = queryBuilderState;
@@ -77,6 +78,10 @@ export class QueryBuilderFetchStructureState {
     this.implementation.initialize();
   }
 
+  initializeWithQuery(): void {
+    this.implementation.initializeWithQuery();
+  }
+
   fetchProperty(node: QueryBuilderExplorerTreeNodeData): void {
     if (
       node instanceof QueryBuilderExplorerTreePropertyNodeData &&

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

@@ -413,6 +413,10 @@ export class QueryBuilderGraphFetchTreeState
     }
   }
 
+  override initializeWithQuery(): void {
+    return;
+  }
+
   onClassChange(_class: Class | undefined): void {
     this.updateTreeData(_class);
   }

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

@@ -44,6 +44,7 @@ import {
   type LambdaFunction,
   type ValueSpecification,
   type VariableExpression,
+  type EngineError,
   GRAPH_MANAGER_EVENT,
   extractSourceInformationCoordinates,
   LAMBDA_PIPE,
@@ -150,9 +151,11 @@ export class QueryBuilderTDSState
       removeAllColumns: action,
       replaceColumn: action,
       initialize: action,
+      initializeWithQuery: action,
       setShowPostFilterPanel: action,
       setShowWindowFuncPanel: action,
       convertDerivationProjectionObjects: flow,
+      fetchDerivedReturnTypes: flow,
     });
 
     this.resultSetModifierState = new QueryResultSetModifierState(this);
@@ -358,6 +361,12 @@ export class QueryBuilderTDSState
     this.setShowWindowFuncPanel(false);
   }
 
+  override initializeWithQuery(): void {
+    flowResult(this.fetchDerivedReturnTypes()).catch(
+      this.queryBuilderState.applicationStore.alertUnhandledError,
+    );
+  }
+
   isColumnInUse(tdsCol: QueryBuilderTDSColumnState): boolean {
     return Boolean(
       [
@@ -741,7 +750,7 @@ export class QueryBuilderTDSState
       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
+      // we will return false if any derivation cols are present as we can't verify is the variable is used
       return false;
     }
     const usedInProjection = columns
@@ -760,4 +769,37 @@ export class QueryBuilderTDSState
       this.resultSetModifierState,
     ]);
   }
+
+  *fetchDerivedReturnTypes(): GeneratorFn<void> {
+    try {
+      const input = new Map<string, RawLambda>();
+      const graph = this.queryBuilderState.graphManagerState.graph;
+      const derivedCols = this.projectionColumns.filter(
+        filterByType(QueryBuilderDerivationProjectionColumnState),
+      );
+      derivedCols.forEach((col) =>
+        input.set(col.columnName, col.getIsolatedRawLambda()),
+      );
+      const result =
+        (yield this.queryBuilderState.graphManagerState.graphManager.getLambdasReturnType(
+          input,
+          graph,
+        )) as {
+          results: Map<string, string>;
+          errors: Map<string, EngineError>;
+        };
+      Array.from(result.results.entries()).forEach((res) => {
+        const col = derivedCols.find((d) => d.columnName === res[0]);
+        if (col) {
+          col.setLambdaReturnType(res[1]);
+        }
+      });
+    } catch (error) {
+      assertErrorThrown(error);
+      this.queryBuilderState.applicationStore.logService.info(
+        LogEvent.create('Unable to fetch derived return types'),
+        error,
+      );
+    }
+  }
 }

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

@@ -480,6 +480,9 @@ export class QueryBuilderPostFilterState
   operators: QueryBuilderPostFilterOperator[] = [];
   rootIds: string[] = [];
   nodes = new Map<string, QueryBuilderPostFilterTreeNodeData>();
+  derivedColumnBeingDropped:
+    | QueryBuilderDerivationProjectionColumnState
+    | undefined;
 
   constructor(
     tdsState: QueryBuilderTDSState,
@@ -492,6 +495,7 @@ export class QueryBuilderPostFilterState
       rootIds: observable,
       nodes: observable,
       lambdaParameterName: observable,
+      derivedColumnBeingDropped: observable,
       setLambdaParameterName: action,
       setSelectedNode: action,
       addNodeFromNode: action,
@@ -504,6 +508,7 @@ export class QueryBuilderPostFilterState
       expandTree: action,
       replaceBlankNodeWithNode: action,
       setRearrangingConditions: action,
+      setDerivedColumnBeingDropped: action,
       hashCode: computed,
     });
 
@@ -526,6 +531,12 @@ export class QueryBuilderPostFilterState
     );
   }
 
+  setDerivedColumnBeingDropped(
+    val: QueryBuilderDerivationProjectionColumnState | undefined,
+  ): void {
+    this.derivedColumnBeingDropped = val;
+  }
+
   get isEmpty(): boolean {
     return !this.nodes.size && !this.rootIds.length;
   }