@finos/legend-application-query 5.0.1 → 5.2.1

package/src/stores/QueryBuilderFetchStructureState.ts

@@ -18,6 +18,7 @@ import { action, makeAutoObservable } from 'mobx';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import { QueryBuilderGraphFetchTreeState } from './QueryBuilderGraphFetchTreeState.js';
 import { QueryBuilderProjectionState } from './QueryBuilderProjectionState.js';
+import type { QueryBuilderAggregateOperator } from './QueryBuilderAggregationState.js';
 
 export enum FETCH_STRUCTURE_MODE {
   PROJECTION = 'PROJECTION',
@@ -26,11 +27,19 @@ export enum FETCH_STRUCTURE_MODE {
 
 export class QueryBuilderFetchStructureState {
   queryBuilderState: QueryBuilderState;
+  /**
+   * TODO?: perhaps it would eventually make sense to default to
+   * graph-fetch since `getAll()` naturally works for graph-fetch case
+   * and graph-fetch allows somewhat an empty tree
+   */
   fetchStructureMode = FETCH_STRUCTURE_MODE.PROJECTION;
   projectionState: QueryBuilderProjectionState;
   graphFetchTreeState: QueryBuilderGraphFetchTreeState;
 
-  constructor(queryBuilderState: QueryBuilderState) {
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    operators: QueryBuilderAggregateOperator[],
+  ) {
     makeAutoObservable(this, {
       queryBuilderState: false,
       setFetchStructureMode: action,
@@ -39,7 +48,10 @@ export class QueryBuilderFetchStructureState {
     this.queryBuilderState = queryBuilderState;
     // TODO: we probably should modularize this a bit better
     // See https://github.com/finos/legend-studio/issues/731
-    this.projectionState = new QueryBuilderProjectionState(queryBuilderState);
+    this.projectionState = new QueryBuilderProjectionState(
+      queryBuilderState,
+      operators,
+    );
     this.graphFetchTreeState = new QueryBuilderGraphFetchTreeState(
       queryBuilderState,
     );
@@ -56,4 +68,8 @@ export class QueryBuilderFetchStructureState {
   isProjectionMode(): boolean {
     return this.fetchStructureMode === FETCH_STRUCTURE_MODE.PROJECTION;
   }
+
+  get validationIssues(): string[] | undefined {
+    return this.projectionState.validationIssues;
+  }
 }

package/src/stores/QueryBuilderFilterState.ts

@@ -20,9 +20,11 @@ import {
   makeAutoObservable,
   makeObservable,
   observable,
+  flow,
 } from 'mobx';
 import type { TreeNodeData, TreeData } from '@finos/legend-art';
 import {
+  type GeneratorFn,
   assertTrue,
   getNullableFirstElement,
   guaranteeNonNullable,
@@ -34,11 +36,13 @@ import {
   deleteEntry,
   assertErrorThrown,
   filterByType,
+  ActionState,
 } from '@finos/legend-shared';
 import type { QueryBuilderExplorerTreeDragSource } from './QueryBuilderExplorerState.js';
 import { QueryBuilderPropertyExpressionState } from './QueryBuilderPropertyEditorState.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import {
+  type ExecutionResult,
   type AbstractPropertyExpression,
   type ValueSpecification,
   extractElementNameFromPath,
@@ -55,6 +59,12 @@ import {
   fromGroupOperation,
   QUERY_BUILDER_GROUP_OPERATION,
 } from './QueryBuilderOperatorsHelper.js';
+import type { QueryBuilderProjectionColumnDragSource } from './QueryBuilderProjectionState.js';
+import {
+  buildPropertyTypeAheadQuery,
+  buildTypeAheadOptions,
+  performTypeAhead,
+} from './QueryBuilderTypeaheadHelper.js';
 
 export abstract class QueryBuilderFilterOperator {
   readonly uuid = uuid();
@@ -95,6 +105,7 @@ export interface QueryBuilderFilterConditionDragSource {
 
 export type QueryBuilderFilterDropTarget =
   | QueryBuilderExplorerTreeDragSource
+  | QueryBuilderProjectionColumnDragSource
   | QueryBuilderFilterConditionDragSource;
 export type QueryBuilderFilterConditionRearrangeDropTarget =
   QueryBuilderFilterConditionDragSource;
@@ -105,6 +116,8 @@ export class FilterConditionState {
   operator!: QueryBuilderFilterOperator;
   value?: ValueSpecification | undefined;
   existsLambdaParamNames: string[] = [];
+  typeaheadSearchResults: string[] | undefined;
+  typeaheadSearchState = ActionState.create();
 
   constructor(
     filterState: QueryBuilderFilterState,
@@ -117,7 +130,10 @@ export class FilterConditionState {
       changeOperator: action,
       setOperator: action,
       setValue: action,
+      typeaheadSearchResults: observable,
+      typeaheadSearchState: observable,
       addExistsLambdaParamNames: action,
+      handleTypeaheadSearch: flow,
     });
 
     this.filterState = filterState;
@@ -141,6 +157,35 @@ export class FilterConditionState {
     );
   }
 
+  *handleTypeaheadSearch(): GeneratorFn<void> {
+    try {
+      this.typeaheadSearchState.inProgress();
+      this.typeaheadSearchResults = undefined;
+      if (performTypeAhead(this.value)) {
+        const builderState = buildPropertyTypeAheadQuery(
+          this.filterState.queryBuilderState,
+          this.propertyExpressionState.propertyExpression,
+          this.value,
+        );
+        const result =
+          (yield builderState.graphManagerState.graphManager.executeMapping(
+            builderState.resultState.buildExecutionRawLambda(),
+            guaranteeNonNullable(builderState.querySetupState.mapping),
+            guaranteeNonNullable(builderState.querySetupState.runtimeValue),
+            builderState.graphManagerState.graph,
+          )) as ExecutionResult;
+        this.typeaheadSearchResults = buildTypeAheadOptions(result);
+      }
+      this.typeaheadSearchState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.typeaheadSearchResults = [];
+      this.typeaheadSearchState.fail();
+    } finally {
+      this.typeaheadSearchState.complete();
+    }
+  }
+
   changeProperty(propertyExpression: AbstractPropertyExpression): void {
     try {
       // first, check if the new property is supported
@@ -219,7 +264,7 @@ export abstract class QueryBuilderFilterTreeNodeData implements TreeNodeData {
     });
   }
 
-  abstract get dragLayerLabel(): string;
+  abstract get dragPreviewLabel(): string;
   setIsOpen(val: boolean): void {
     this.isOpen = val;
   }
@@ -244,14 +289,14 @@ export class QueryBuilderFilterTreeGroupNodeData extends QueryBuilderFilterTreeN
       setGroupOperation: action,
       addChildNode: action,
       removeChildNode: action,
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
 
     this.groupOperation = groupOperation;
     this.isOpen = true;
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return `${this.groupOperation.toUpperCase()} group`;
   }
 
@@ -283,13 +328,13 @@ export class QueryBuilderFilterTreeConditionNodeData extends QueryBuilderFilterT
 
     makeObservable(this, {
       condition: observable,
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
 
     this.condition = condition;
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return this.condition.propertyExpressionState.title;
   }
 }
@@ -299,11 +344,11 @@ export class QueryBuilderFilterTreeBlankConditionNodeData extends QueryBuilderFi
     super(parentId);
 
     makeObservable(this, {
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return '<blank>';
   }
 }

package/src/stores/QueryBuilderGraphFetchTreeState.ts

@@ -26,6 +26,7 @@ import {
   buildGraphFetchTreeData,
 } from './QueryBuilderGraphFetchTreeUtil.js';
 import type { QueryBuilderExplorerTreePropertyNodeData } from './QueryBuilderExplorerState.js';
+import { assertNonNullable } from '@finos/legend-shared';
 
 export class QueryBuilderGraphFetchTreeState {
   queryBuilderState: QueryBuilderState;
@@ -77,14 +78,19 @@ export class QueryBuilderGraphFetchTreeState {
   }
 
   addProperty(node: QueryBuilderExplorerTreePropertyNodeData): void {
-    if (this.treeData) {
-      addQueryBuilderPropertyNode(
-        this.treeData,
-        this.queryBuilderState.explorerState.nonNullableTreeData,
-        node,
-        this.queryBuilderState,
-      );
-      this.setGraphFetchTree({ ...this.treeData });
+    if (!this.treeData) {
+      this.initialize();
     }
+    assertNonNullable(
+      this.treeData,
+      `Graph-fetch tree has not been properly initialized`,
+    );
+    addQueryBuilderPropertyNode(
+      this.treeData,
+      this.queryBuilderState.explorerState.nonNullableTreeData,
+      node,
+      this.queryBuilderState,
+    );
+    this.setGraphFetchTree({ ...this.treeData });
   }
 }

package/src/stores/QueryBuilderLambdaProcessor.ts

@@ -693,6 +693,10 @@ export class QueryBuilderLambdaProcessor
         (e, idx) => e.setColumnName(aliases[idx] as string),
       );
 
+      this.queryBuilderState.fetchStructureState.setFetchStructureMode(
+        FETCH_STRUCTURE_MODE.PROJECTION,
+      );
+
       return;
     } else if (
       matchFunctionName(
@@ -943,6 +947,10 @@ export class QueryBuilderLambdaProcessor
         (e, idx) => e.setColumnName(aliases[idx] as string),
       );
 
+      this.queryBuilderState.fetchStructureState.setFetchStructureMode(
+        FETCH_STRUCTURE_MODE.PROJECTION,
+      );
+
       return;
     } else if (
       matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG)

package/src/stores/QueryBuilderOperatorLoader.ts

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { QueryBuilderAggregateOperator_Count } from './aggregateOperators/QueryBuilderAggregateOperator_Count.js';
+import { QueryBuilderAggregateOperator_Distinct } from './aggregateOperators/QueryBuilderAggregateOperator_Distinct.js';
+import { QueryBuilderAggregateOperator_Sum } from './aggregateOperators/QueryBuilderAggregateOperator_Sum.js';
+import { QueryBuilderAggregateOperator_Average } from './aggregateOperators/QueryBuilderAggregateOperator_Average.js';
+import { QueryBuilderAggregateOperator_StdDev_Population } from './aggregateOperators/QueryBuilderAggregateOperator_StdDev_Population.js';
+import { QueryBuilderAggregateOperator_StdDev_Sample } from './aggregateOperators/QueryBuilderAggregateOperator_StdDev_Sample.js';
+import { QueryBuilderAggregateOperator_DistinctCount } from './aggregateOperators/QueryBuilderAggregateOperator_DistinctCount.js';
+import { QueryBuilderAggregateOperator_Min } from './aggregateOperators/QueryBuilderAggregateOperator_Min.js';
+import { QueryBuilderAggregateOperator_Max } from './aggregateOperators/QueryBuilderAggregateOperator_Max.js';
+import { QueryBuilderAggregateOperator_JoinString } from './aggregateOperators/QueryBuilderAggregateOperator_JoinString.js';
+import {
+  QueryBuilderFilterOperator_Equal,
+  QueryBuilderFilterOperator_NotEqual,
+} from './filterOperators/QueryBuilderFilterOperator_Equal.js';
+import { QueryBuilderFilterOperator_GreaterThan } from './filterOperators/QueryBuilderFilterOperator_GreaterThan.js';
+import {
+  QueryBuilderFilterOperator_NotStartWith,
+  QueryBuilderFilterOperator_StartWith,
+} from './filterOperators/QueryBuilderFilterOperator_StartWith.js';
+import { QueryBuilderFilterOperator_GreaterThanEqual } from './filterOperators/QueryBuilderFilterOperator_GreaterThanEqual.js';
+import { QueryBuilderFilterOperator_LessThanEqual } from './filterOperators/QueryBuilderFilterOperator_LessThanEqual.js';
+import { QueryBuilderFilterOperator_LessThan } from './filterOperators/QueryBuilderFilterOperator_LessThan.js';
+import {
+  QueryBuilderFilterOperator_EndWith,
+  QueryBuilderFilterOperator_NotEndWith,
+} from './filterOperators/QueryBuilderFilterOperator_EndWith.js';
+import {
+  QueryBuilderFilterOperator_Contain,
+  QueryBuilderFilterOperator_NotContain,
+} from './filterOperators/QueryBuilderFilterOperator_Contain.js';
+import {
+  QueryBuilderFilterOperator_IsEmpty,
+  QueryBuilderFilterOperator_IsNotEmpty,
+} from './filterOperators/QueryBuilderFilterOperator_IsEmpty.js';
+import {
+  QueryBuilderFilterOperator_In,
+  QueryBuilderFilterOperator_NotIn,
+} from './filterOperators/QueryBuilderFilterOperator_In.js';
+import {
+  QueryBuilderPostFilterOperator_In,
+  QueryBuilderPostFilterOperator_NotIn,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_In.js';
+import {
+  QueryBuilderPostFilterOperator_IsEmpty,
+  QueryBuilderPostFilterOperator_IsNotEmpty,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_IsEmpty.js';
+import {
+  QueryBuilderPostFilterOperator_Equal,
+  QueryBuilderPostFilterOperator_NotEqual,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_Equal.js';
+import { QueryBuilderPostFilterOperator_LessThan } from './postFilterOperators/QueryBuilderPostFilterOperator_LessThan.js';
+import { QueryBuilderPostFilterOperator_LessThanEqual } from './postFilterOperators/QueryBuilderPostFilterOperator_LessThanEqual.js';
+import { QueryBuilderPostFilterOperator_GreaterThan } from './postFilterOperators/QueryBuilderPostFilterOperator_GreaterThan.js';
+import { QueryBuilderPostFilterOperator_GreaterThanEqual } from './postFilterOperators/QueryBuilderPostFilterOperator_GreaterThanEqual.js';
+import {
+  QueryBuilderPostFilterOperator_NotStartWith,
+  QueryBuilderPostFilterOperator_StartWith,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_StartWith.js';
+import {
+  QueryBuilderPostFilterOperator_Contain,
+  QueryBuilderPostFilterOperator_NotContain,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_Contain.js';
+import {
+  QueryBuilderPostFilterOperator_EndWith,
+  QueryBuilderPostFilterOperator_NotEndWith,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_EndWith.js';
+
+export const AGGREGATION_OPERATORS = [
+  new QueryBuilderAggregateOperator_Count(),
+  new QueryBuilderAggregateOperator_DistinctCount(),
+  new QueryBuilderAggregateOperator_Distinct(),
+  new QueryBuilderAggregateOperator_Sum(),
+  new QueryBuilderAggregateOperator_Average(),
+  new QueryBuilderAggregateOperator_Min(),
+  new QueryBuilderAggregateOperator_Max(),
+  new QueryBuilderAggregateOperator_StdDev_Population(),
+  new QueryBuilderAggregateOperator_StdDev_Sample(),
+  new QueryBuilderAggregateOperator_JoinString(),
+];
+
+export const FILTER_OPERATORS = [
+  new QueryBuilderFilterOperator_Equal(),
+  new QueryBuilderFilterOperator_NotEqual(),
+  new QueryBuilderFilterOperator_LessThan(),
+  new QueryBuilderFilterOperator_LessThanEqual(),
+  new QueryBuilderFilterOperator_GreaterThan(),
+  new QueryBuilderFilterOperator_GreaterThanEqual(),
+  new QueryBuilderFilterOperator_StartWith(),
+  new QueryBuilderFilterOperator_NotStartWith(),
+  new QueryBuilderFilterOperator_Contain(),
+  new QueryBuilderFilterOperator_NotContain(),
+  new QueryBuilderFilterOperator_EndWith(),
+  new QueryBuilderFilterOperator_NotEndWith(),
+  new QueryBuilderFilterOperator_In(),
+  new QueryBuilderFilterOperator_NotIn(),
+  new QueryBuilderFilterOperator_IsEmpty(),
+  new QueryBuilderFilterOperator_IsNotEmpty(),
+];
+
+export const POST_FILTER_OPERATORS = [
+  new QueryBuilderPostFilterOperator_Equal(),
+  new QueryBuilderPostFilterOperator_NotEqual(),
+  new QueryBuilderPostFilterOperator_LessThan(),
+  new QueryBuilderPostFilterOperator_LessThanEqual(),
+  new QueryBuilderPostFilterOperator_GreaterThan(),
+  new QueryBuilderPostFilterOperator_GreaterThanEqual(),
+  new QueryBuilderPostFilterOperator_StartWith(),
+  new QueryBuilderPostFilterOperator_NotStartWith(),
+  new QueryBuilderPostFilterOperator_Contain(),
+  new QueryBuilderPostFilterOperator_NotContain(),
+  new QueryBuilderPostFilterOperator_EndWith(),
+  new QueryBuilderPostFilterOperator_NotEndWith(),
+  new QueryBuilderPostFilterOperator_In(),
+  new QueryBuilderPostFilterOperator_NotIn(),
+  new QueryBuilderPostFilterOperator_IsEmpty(),
+  new QueryBuilderPostFilterOperator_IsNotEmpty(),
+];

package/src/stores/QueryBuilderOperatorsHelper.ts

@@ -29,6 +29,7 @@ import {
   EnumValueInstanceValue,
   VariableExpression,
   AbstractPropertyExpression,
+  isSuperType,
 } from '@finos/legend-graph';
 import {
   addUniqueEntry,
@@ -189,3 +190,37 @@ export const isPropertyExpressionChainOptional = (
   }
   return isOptional;
 };
+
+export const isTypeCompatibleWithConditionValueType = (
+  type: Type | undefined,
+  conditionValueType: Type,
+): boolean => {
+  const NUMERIC_PRIMITIVE_TYPES = [
+    PRIMITIVE_TYPE.NUMBER,
+    PRIMITIVE_TYPE.INTEGER,
+    PRIMITIVE_TYPE.DECIMAL,
+    PRIMITIVE_TYPE.FLOAT,
+  ] as string[];
+  const DATE_PRIMITIVE_TYPES = [
+    PRIMITIVE_TYPE.DATE,
+    PRIMITIVE_TYPE.DATETIME,
+    PRIMITIVE_TYPE.STRICTDATE,
+    PRIMITIVE_TYPE.LATESTDATE,
+  ] as string[];
+
+  // When changing the return type for LHS, the RHS value should be adjusted accordingly.
+  return (
+    type !== undefined &&
+    // Numeric value is handled loosely because of autoboxing
+    // e.g. LHS (integer) = RHS (float) is acceptable
+    ((NUMERIC_PRIMITIVE_TYPES.includes(type.path) &&
+      NUMERIC_PRIMITIVE_TYPES.includes(conditionValueType.path)) ||
+      // Date value is handled loosely as well if the LHS is of type DateTime
+      // This is because we would simulate auto-boxing for date by altering the
+      // Pure function used for the operation
+      // e.g. LHS(DateTime) = RHS(Date) -> we use isOnDay() instead of is()
+      DATE_PRIMITIVE_TYPES.includes(type.path) ||
+      type === conditionValueType ||
+      isSuperType(conditionValueType, type))
+  );
+};

package/src/stores/QueryBuilderPostFilterState.ts

@@ -19,6 +19,7 @@ import {
   type PureModel,
   type Type,
   type ValueSpecification,
+  type ExecutionResult,
   Enumeration,
   PRIMITIVE_TYPE,
   observe_ValueSpecification,
@@ -36,6 +37,7 @@ import {
   UnsupportedOperationError,
   uuid,
   filterByType,
+  ActionState,
 } from '@finos/legend-shared';
 import {
   action,
@@ -51,11 +53,16 @@ import type { QueryBuilderAggregateColumnState } from './QueryBuilderAggregation
 import { QUERY_BUILDER_GROUP_OPERATION } from './QueryBuilderOperatorsHelper.js';
 import type { QueryBuilderPostFilterOperator } from './QueryBuilderPostFilterOperator.js';
 import {
-  type QueryBuilderProjectionColumnDragSource,
   type QueryBuilderProjectionColumnState,
+  type QueryBuilderProjectionColumnDragSource,
   QueryBuilderDerivationProjectionColumnState,
 } from './QueryBuilderProjectionState.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
+import {
+  buildProjectionColumnTypeAheadQuery,
+  buildTypeAheadOptions,
+  performTypeAhead,
+} from './QueryBuilderTypeaheadHelper.js';
 
 export enum QUERY_BUILDER_POST_FILTER_DND_TYPE {
   GROUP_CONDITION = 'GROUP_CONDITION',
@@ -158,7 +165,7 @@ export abstract class QueryBuilderPostFilterTreeNodeData
     });
   }
 
-  abstract get dragLayerLabel(): string;
+  abstract get dragPreviewLabel(): string;
   setIsOpen(val: boolean): void {
     this.isOpen = val;
   }
@@ -190,13 +197,13 @@ export class QueryBuilderPostFilterTreeGroupNodeData extends QueryBuilderPostFil
       setGroupOperation: action,
       addChildNode: action,
       removeChildNode: action,
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
     this.groupOperation = groupOperation;
     this.isOpen = true;
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return `${this.groupOperation.toUpperCase()} group`;
   }
 
@@ -231,13 +238,13 @@ export class QueryBuilderPostFilterTreeConditionNodeData extends QueryBuilderPos
 
     makeObservable(this, {
       condition: observable,
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
 
     this.condition = condition;
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return this.condition.columnName;
   }
 }
@@ -247,11 +254,11 @@ export class QueryBuilderPostFilterTreeBlankConditionNodeData extends QueryBuild
     super(parentId);
 
     makeObservable(this, {
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return '<blank>';
   }
 }
@@ -262,6 +269,8 @@ export class PostFilterConditionState {
     | QueryBuilderAggregateColumnState;
   value?: ValueSpecification | undefined;
   operator: QueryBuilderPostFilterOperator;
+  typeaheadSearchResults: string[] | undefined;
+  typeaheadSearchState = ActionState.create();
 
   constructor(
     postFilterState: QueryBuilderPostFilterState,
@@ -273,11 +282,13 @@ export class PostFilterConditionState {
   ) {
     makeAutoObservable(this, {
       columnState: observable,
+      typeaheadSearchResults: observable,
       changeOperator: action,
       setColumnState: action,
       setValue: action,
       setOperator: action,
       changeColumn: flow,
+      handleTypeaheadSearch: flow,
     });
 
     this.postFilterState = postFilterState;
@@ -304,6 +315,34 @@ export class PostFilterConditionState {
     );
   }
 
+  *handleTypeaheadSearch(): GeneratorFn<void> {
+    try {
+      this.typeaheadSearchState.inProgress();
+      this.typeaheadSearchResults = undefined;
+      if (performTypeAhead(this.value)) {
+        const builderState = buildProjectionColumnTypeAheadQuery(
+          this.postFilterState.queryBuilderState,
+          this.columnState,
+          this.value,
+        );
+        const result =
+          (yield builderState.graphManagerState.graphManager.executeMapping(
+            builderState.resultState.buildExecutionRawLambda(),
+            guaranteeNonNullable(builderState.querySetupState.mapping),
+            guaranteeNonNullable(builderState.querySetupState.runtimeValue),
+            builderState.graphManagerState.graph,
+          )) as ExecutionResult;
+        this.typeaheadSearchResults = buildTypeAheadOptions(result);
+      }
+      this.typeaheadSearchState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.typeaheadSearchState.fail();
+    } finally {
+      this.typeaheadSearchState.complete();
+    }
+  }
+
   changeOperator(val: QueryBuilderPostFilterOperator): void {
     this.setOperator(val);
     if (!this.operator.isCompatibleWithConditionValue(this)) {