@finos/legend-application-query 5.0.0 → 5.1.0

package/src/stores/QueryBuilderProjectionState.ts

@@ -68,30 +68,22 @@ import {
   RawLambda,
   stub_RawLambda,
   isStubbed_RawLambda,
-  buildRawLambdaFromLambdaFunction,
 } from '@finos/legend-graph';
 import {
   DEFAULT_LAMBDA_VARIABLE_NAME,
   QUERY_BUILDER_SOURCE_ID_LABEL,
 } from '../QueryBuilder_Const.js';
-import { QueryBuilderAggregationState } from './QueryBuilderAggregationState.js';
-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 {
+  type QueryBuilderAggregateOperator,
+  QueryBuilderAggregationState,
+} from './QueryBuilderAggregationState.js';
+import { buildGenericLambdaFunctionInstanceValue } from './QueryBuilderValueSpecificationBuilderHelper.js';
+import { LambdaEditorState } from '@finos/legend-application';
 import {
   type QueryBuilderPreviewData,
-  buildNonNumericPreviewDataQuery,
   buildNumericPreviewDataQuery,
+  buildNonNumericPreviewDataQuery,
 } from './QueryBuilderPreviewDataHelper.js';
-import { buildGenericLambdaFunctionInstanceValue } from './QueryBuilderValueSpecificationBuilderHelper.js';
-import { LambdaEditorState } from '@finos/legend-application';
 
 export enum QUERY_BUILDER_PROJECTION_DND_TYPE {
   PROJECTION_COLUMN = 'PROJECTION_COLUMN',
@@ -380,7 +372,10 @@ export class QueryBuilderProjectionState {
   aggregationState: QueryBuilderAggregationState;
   isConvertDerivationProjectionObjects = false;
 
-  constructor(queryBuilderState: QueryBuilderState) {
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    operators: QueryBuilderAggregateOperator[],
+  ) {
     makeAutoObservable(this, {
       queryBuilderState: false,
       removeColumn: action,
@@ -390,18 +385,7 @@ export class QueryBuilderProjectionState {
     });
 
     this.queryBuilderState = queryBuilderState;
-    this.aggregationState = new QueryBuilderAggregationState(this, [
-      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(),
-    ]);
+    this.aggregationState = new QueryBuilderAggregationState(this, operators);
   }
 
   *convertDerivationProjectionObjects(): GeneratorFn<void> {
@@ -709,13 +693,9 @@ export class QueryBuilderProjectionState {
         case PRIMITIVE_TYPE.FLOAT: {
           const previewResult =
             (yield this.queryBuilderState.graphManagerState.graphManager.executeMapping(
-              buildRawLambdaFromLambdaFunction(
-                buildNumericPreviewDataQuery(
-                  propertyExpression,
-                  this.queryBuilderState.querySetupState._class,
-                  this.queryBuilderState.graphManagerState.graph,
-                ),
-                this.queryBuilderState.graphManagerState,
+              buildNumericPreviewDataQuery(
+                this.queryBuilderState,
+                propertyExpression,
               ),
               this.queryBuilderState.querySetupState.mapping,
               runtime,
@@ -752,13 +732,9 @@ export class QueryBuilderProjectionState {
         case PRIMITIVE_TYPE.DATETIME: {
           const previewResult =
             (yield this.queryBuilderState.graphManagerState.graphManager.executeMapping(
-              buildRawLambdaFromLambdaFunction(
-                buildNonNumericPreviewDataQuery(
-                  propertyExpression,
-                  this.queryBuilderState.querySetupState._class,
-                  this.queryBuilderState.graphManagerState.graph,
-                ),
-                this.queryBuilderState.graphManagerState,
+              buildNonNumericPreviewDataQuery(
+                this.queryBuilderState,
+                propertyExpression,
               ),
               this.queryBuilderState.querySetupState.mapping,
               runtime,
@@ -793,4 +769,26 @@ export class QueryBuilderProjectionState {
       );
     }
   }
+
+  isValidProjectionState(): boolean {
+    return Boolean(!this.getValidationErrorMessage());
+  }
+
+  getValidationErrorMessage(): string | undefined {
+    if (this.queryBuilderState.fetchStructureState.isProjectionMode()) {
+      const hasDuplicatedProjectionColumns = this.columns.some(
+        (column) =>
+          this.columns.filter((c) => c.columnName === column.columnName)
+            .length > 1,
+      );
+      if (hasDuplicatedProjectionColumns) {
+        return 'Query has duplicated projection columns';
+      }
+      const hasNoProjectionColumns = this.columns.length === 0;
+      if (hasNoProjectionColumns) {
+        return 'Query has no projection columns';
+      }
+    }
+    return undefined;
+  }
 }

package/src/stores/QueryBuilderPropertySearchPanelState.ts

@@ -262,7 +262,7 @@ export class QueryBuilderPropertySearchPanelState {
                 ),
               );
               if (
-                propertyTreeNodeData.mappingData.mapped &&
+                propertyTreeNodeData?.mappingData.mapped &&
                 !propertyTreeNodeData.isPartOfDerivedPropertyBranch
               ) {
                 nextLevelPropertyNodes.push(propertyTreeNodeData);

package/src/stores/QueryBuilderResultState.ts

@@ -48,16 +48,18 @@ export class QueryBuilderResultState {
   queryBuilderState: QueryBuilderState;
   exportDataState = ActionState.create();
   previewLimit = DEFAULT_LIMIT;
-  isExecutingQuery = false;
+  isRunningQuery = false;
   isGeneratingPlan = false;
   executionResult?: ExecutionResult | undefined;
   executionPlanState: ExecutionPlanState;
   executionDuration?: number | undefined;
+  queryRunPromise: Promise<ExecutionResult> | undefined = undefined;
 
   constructor(queryBuilderState: QueryBuilderState) {
     makeAutoObservable(this, {
       queryBuilderState: false,
       executionPlanState: false,
+      setIsRunningQuery: action,
       setExecutionResult: action,
     });
 
@@ -68,16 +70,28 @@ export class QueryBuilderResultState {
     );
   }
 
+  setIsRunningQuery = (val: boolean): void => {
+    this.isRunningQuery = val;
+  };
+
   setExecutionResult = (val: ExecutionResult | undefined): void => {
     this.executionResult = val;
   };
+
   setExecutionDuration = (val: number | undefined): void => {
     this.executionDuration = val;
   };
+
   setPreviewLimit = (val: number): void => {
     this.previewLimit = Math.max(1, val);
   };
 
+  setQueryRunPromise = (
+    promise: Promise<ExecutionResult> | undefined,
+  ): void => {
+    this.queryRunPromise = promise;
+  };
+
   buildExecutionRawLambda(): RawLambda {
     let query: RawLambda;
     if (this.queryBuilderState.isQuerySupported()) {
@@ -172,9 +186,9 @@ export class QueryBuilderResultState {
     }
   }
 
-  *execute(): GeneratorFn<void> {
+  *runQuery(): GeneratorFn<void> {
     try {
-      this.isExecutingQuery = true;
+      this.isRunningQuery = true;
       const mapping = guaranteeNonNullable(
         this.queryBuilderState.querySetupState.mapping,
         'Mapping is required to execute query',
@@ -185,15 +199,19 @@ export class QueryBuilderResultState {
       );
       const query = this.buildExecutionRawLambda();
       const startTime = Date.now();
-      const result =
-        (yield this.queryBuilderState.graphManagerState.graphManager.executeMapping(
+      const promise =
+        this.queryBuilderState.graphManagerState.graphManager.executeMapping(
           query,
           mapping,
           runtime,
           this.queryBuilderState.graphManagerState.graph,
-        )) as ExecutionResult;
-      this.setExecutionResult(result);
-      this.setExecutionDuration(Date.now() - startTime);
+        );
+      this.setQueryRunPromise(promise);
+      const result = (yield promise) as ExecutionResult;
+      if (this.queryRunPromise === promise) {
+        this.setExecutionResult(result);
+        this.setExecutionDuration(Date.now() - startTime);
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.queryBuilderState.applicationStore.log.error(
@@ -202,7 +220,7 @@ export class QueryBuilderResultState {
       );
       this.queryBuilderState.applicationStore.notifyError(error);
     } finally {
-      this.isExecutingQuery = false;
+      this.setIsRunningQuery(false);
     }
   }
 

package/src/stores/QueryBuilderState.ts

@@ -62,71 +62,20 @@ import {
   buildLambdaVariableExpressions,
   buildRawLambdaFromLambdaFunction,
 } from '@finos/legend-graph';
-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 { buildLambdaFunction } from './QueryBuilderLambdaBuilder.js';
 import {
   LambdaParameterState,
   type GenericLegendApplicationStore,
 } from '@finos/legend-application';
 import { QueryBuilderPostFilterState } from './QueryBuilderPostFilterState.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';
 import type { QueryBuilderPostFilterOperator } from './QueryBuilderPostFilterOperator.js';
-import {
-  QueryBuilderPostFilterOperator_In,
-  QueryBuilderPostFilterOperator_NotIn,
-} from './postFilterOperators/QueryBuilderPostFilterOperator_In.js';
-import {
-  QueryBuilderPostFilterOperator_IsEmpty,
-  QueryBuilderPostFilterOperator_IsNotEmpty,
-} from './postFilterOperators/QueryBuilderPostFilterOperator_IsEmpty.js';
 import { QueryFunctionsExplorerState } from './QueryFunctionsExplorerState.js';
 import { QueryParametersState } from './QueryParametersState.js';
+import {
+  AGGREGATION_OPERATORS,
+  FILTER_OPERATORS,
+  POST_FILTER_OPERATORS,
+} from './QueryBuilderOperatorLoader.js';
 
 export abstract class QueryBuilderMode {
   abstract get isParametersDisabled(): boolean;
@@ -179,42 +128,8 @@ export class QueryBuilderState {
   queryTextEditorState: QueryTextEditorState;
   queryUnsupportedState: QueryBuilderUnsupportedState;
   observableContext: ObserverContext;
-  filterOperators: QueryBuilderFilterOperator[] = [
-    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(),
-  ];
-  postFilterOperators: QueryBuilderPostFilterOperator[] = [
-    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(),
-  ];
+  filterOperators: QueryBuilderFilterOperator[] = FILTER_OPERATORS;
+  postFilterOperators: QueryBuilderPostFilterOperator[] = POST_FILTER_OPERATORS;
   isCompiling = false;
   backdrop = false;
   showFunctionPanel = false;
@@ -267,7 +182,10 @@ export class QueryBuilderState {
     this.explorerState = new QueryBuilderExplorerState(this);
     this.queryParametersState = new QueryParametersState(this);
     this.queryFunctionsExplorerState = new QueryFunctionsExplorerState(this);
-    this.fetchStructureState = new QueryBuilderFetchStructureState(this);
+    this.fetchStructureState = new QueryBuilderFetchStructureState(
+      this,
+      AGGREGATION_OPERATORS,
+    );
     this.filterState = new QueryBuilderFilterState(this, this.filterOperators);
     this.postFilterState = new QueryBuilderPostFilterState(
       this,
@@ -338,7 +256,10 @@ export class QueryBuilderState {
     this.explorerState.refreshTreeData();
     this.queryParametersState = new QueryParametersState(this);
     this.queryFunctionsExplorerState = new QueryFunctionsExplorerState(this);
-    const fetchStructureState = new QueryBuilderFetchStructureState(this);
+    const fetchStructureState = new QueryBuilderFetchStructureState(
+      this,
+      this.fetchStructureState.projectionState.aggregationState.operators,
+    );
     fetchStructureState.setFetchStructureMode(
       this.fetchStructureState.fetchStructureMode,
     );
@@ -558,4 +479,16 @@ export class QueryBuilderState {
       this.fetchStructureState.graphFetchTreeState.initialize();
     }
   }
+
+  isValidQueryBuilderState(): boolean {
+    return this.fetchStructureState.projectionState.isValidProjectionState();
+  }
+
+  createBareBuilderState(): QueryBuilderState {
+    return new QueryBuilderState(
+      this.applicationStore,
+      this.graphManagerState,
+      this.mode,
+    );
+  }
 }

package/src/stores/QueryBuilderTestUtils.ts

@@ -0,0 +1,93 @@
+/**
+ * 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 { TEST__getTestApplicationStore } from '@finos/legend-application';
+import {
+  type RawLambda,
+  type RawMappingModelCoverageAnalysisResult,
+  TEST__buildGraphWithEntities,
+  TEST__getTestGraphManagerState,
+} from '@finos/legend-graph';
+import type { Entity } from '@finos/legend-storage';
+import { jest } from '@jest/globals';
+import { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
+import { QueryBuilder_GraphManagerPreset } from '../graphManager/QueryBuilder_GraphManagerPreset.js';
+import {
+  QueryBuilderState,
+  StandardQueryBuilderMode,
+} from './QueryBuilderState.js';
+import { TEST__getTestLegendQueryApplicationConfig } from './QueryEditorStoreTestUtils.js';
+
+export const TEST_setUpQueryBuilderState = async (
+  entities: Entity[],
+  rawLambda?: RawLambda | undefined,
+  executionContext?:
+    | {
+        _class: string;
+        mapping: string;
+        runtime?: string | undefined;
+      }
+    | undefined,
+  rawMappingModelCoverageAnalysisResult?:
+    | RawMappingModelCoverageAnalysisResult
+    | undefined,
+): Promise<QueryBuilderState> => {
+  const pluginManager = LegendQueryPluginManager.create();
+  pluginManager.usePresets([new QueryBuilder_GraphManagerPreset()]).install();
+  const applicationStore = TEST__getTestApplicationStore(
+    TEST__getTestLegendQueryApplicationConfig(),
+    LegendQueryPluginManager.create(),
+  );
+  const graphManagerState = TEST__getTestGraphManagerState(pluginManager);
+  await TEST__buildGraphWithEntities(graphManagerState, entities);
+  const queryBuilderState = new QueryBuilderState(
+    applicationStore,
+    graphManagerState,
+    new StandardQueryBuilderMode(),
+  );
+  if (rawLambda) {
+    queryBuilderState.buildStateFromRawLambda(rawLambda);
+  }
+  if (executionContext) {
+    const graph = queryBuilderState.graphManagerState.graph;
+    queryBuilderState.querySetupState._class = graph.getClass(
+      executionContext._class,
+    );
+    queryBuilderState.querySetupState.mapping = graph.getMapping(
+      executionContext.mapping,
+    );
+    if (executionContext.runtime) {
+      queryBuilderState.querySetupState.runtimeValue = graph.getRuntime(
+        executionContext.runtime,
+      );
+    }
+  }
+  if (rawMappingModelCoverageAnalysisResult) {
+    jest
+      .spyOn(
+        queryBuilderState.graphManagerState.graphManager,
+        'analyzeMappingModelCoverage',
+      )
+      .mockResolvedValue(
+        queryBuilderState.graphManagerState.graphManager.buildMappingModelCoverageAnalysisResult(
+          rawMappingModelCoverageAnalysisResult,
+        ),
+      );
+
+    await queryBuilderState.explorerState.analyzeMappingModelCoverage();
+  }
+  return queryBuilderState;
+};

package/src/stores/QueryBuilderTypeaheadHelper.ts

@@ -0,0 +1,149 @@
+/**
+ * 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 {
+  type AbstractPropertyExpression,
+  type ExecutionResult,
+  type ValueSpecification,
+  PrimitiveInstanceValue,
+  PRIMITIVE_TYPE,
+  TdsExecutionResult,
+} from '@finos/legend-graph';
+import { guaranteeType, isNonNullable, isString } from '@finos/legend-shared';
+import { QueryBuilderPostFilterOperator_StartWith } from './postFilterOperators/QueryBuilderPostFilterOperator_StartWith.js';
+import type { QueryBuilderAggregateColumnState } from './QueryBuilderAggregationState.js';
+import {
+  PostFilterConditionState,
+  QueryBuilderPostFilterTreeConditionNodeData,
+} from './QueryBuilderPostFilterState.js';
+import {
+  QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from './QueryBuilderProjectionState.js';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+
+const TYPEAHEAD_TAKE_LIMIT = 10;
+const START_LENGTH = 3;
+
+const createAndSetupQueryBuilderStateForTypeAhead = (
+  queryBuilderState: QueryBuilderState,
+): QueryBuilderState => {
+  // builderState to build dummy query
+  const builderState = queryBuilderState.createBareBuilderState();
+  // setup
+  builderState.querySetupState = queryBuilderState.querySetupState;
+  // result modifiers
+  builderState.resultSetModifierState.distinct = true;
+  builderState.resultSetModifierState.limit = TYPEAHEAD_TAKE_LIMIT;
+  return builderState;
+};
+
+const buildColumnTypeAheadQuery = (
+  builderState: QueryBuilderState,
+  columnState:
+    | QueryBuilderProjectionColumnState
+    | QueryBuilderAggregateColumnState,
+  value: ValueSpecification | undefined,
+): QueryBuilderState => {
+  // projection column
+  let projectionState;
+  if (columnState instanceof QueryBuilderProjectionColumnState) {
+    projectionState = columnState;
+  } else {
+    projectionState = columnState.projectionColumnState;
+    const aggregationState =
+      builderState.fetchStructureState.projectionState.aggregationState;
+    aggregationState.columns = [columnState];
+  }
+  builderState.fetchStructureState.projectionState.columns = [projectionState];
+  // post filter
+  const postConditionState = new PostFilterConditionState(
+    builderState.postFilterState,
+    columnState,
+    value,
+    new QueryBuilderPostFilterOperator_StartWith(),
+  );
+  const postFilterNode = new QueryBuilderPostFilterTreeConditionNodeData(
+    undefined,
+    postConditionState,
+  );
+  builderState.postFilterState.addNodeFromNode(postFilterNode, undefined);
+  return builderState;
+};
+
+export const buildPropertyTypeAheadQuery = (
+  queryBuilderState: QueryBuilderState,
+  propertyExpression: AbstractPropertyExpression,
+  value: ValueSpecification | undefined,
+): QueryBuilderState => {
+  // builderState to build dummy query
+  const builderState =
+    createAndSetupQueryBuilderStateForTypeAhead(queryBuilderState);
+  const projectionState = new QueryBuilderSimpleProjectionColumnState(
+    builderState.fetchStructureState.projectionState,
+    propertyExpression,
+    false,
+  );
+  return buildColumnTypeAheadQuery(builderState, projectionState, value);
+};
+
+export const buildProjectionColumnTypeAheadQuery = (
+  queryBuilderState: QueryBuilderState,
+  columnState:
+    | QueryBuilderProjectionColumnState
+    | QueryBuilderAggregateColumnState,
+  value: ValueSpecification | undefined,
+): QueryBuilderState => {
+  // builderState to build dummy query
+  const builderState =
+    createAndSetupQueryBuilderStateForTypeAhead(queryBuilderState);
+  return buildColumnTypeAheadQuery(builderState, columnState, value);
+};
+
+export const buildTypeAheadOptions = (result: ExecutionResult): string[] => {
+  const tdsResult = guaranteeType(
+    result,
+    TdsExecutionResult,
+    'Type ahead search is only supported for tds result sets',
+  );
+  const options: string[] = [];
+  tdsResult.result.rows
+    .map((r) => r.values[0])
+    .filter(isNonNullable)
+    .forEach((r) => {
+      if (isString(r)) {
+        options.push(r);
+      }
+    });
+  return options;
+};
+
+export const performTypeAhead = (
+  val: ValueSpecification | undefined,
+): boolean => {
+  if (val instanceof PrimitiveInstanceValue) {
+    const _type = val.genericType.value.rawType;
+    switch (_type.path) {
+      case PRIMITIVE_TYPE.STRING: {
+        const value = val.values[0] as string;
+        return value.length >= START_LENGTH;
+      }
+      default:
+        return false;
+    }
+  }
+  return false;
+};

package/src/stores/QueryEditorStore.ts

@@ -443,22 +443,21 @@ export class CreateQueryEditorStore extends QueryEditorStore {
       ),
     );
     if (this.classPath) {
-      this.queryBuilderState.querySetupState._class =
-        this.queryBuilderState.graphManagerState.graph.getClass(this.classPath);
+      this.queryBuilderState.changeClass(
+        this.queryBuilderState.graphManagerState.graph.getClass(this.classPath),
+      );
       this.queryBuilderState.querySetupState.setClassIsReadOnly(true);
     } else {
-      this.queryBuilderState.querySetupState._class = getNullableFirstElement(
-        this.queryBuilderState.querySetupState.mapping
-          ? getAllClassMappings(
-              this.queryBuilderState.querySetupState.mapping,
-            ).map((classMapping) => classMapping.class.value)
-          : [],
+      this.queryBuilderState.changeClass(
+        getNullableFirstElement(
+          this.queryBuilderState.querySetupState.mapping
+            ? getAllClassMappings(
+                this.queryBuilderState.querySetupState.mapping,
+              ).map((classMapping) => classMapping.class.value)
+            : [],
+        ),
       );
     }
-
-    // initialize query builder state after setting up
-    this.queryBuilderState.resetQueryBuilder();
-    this.queryBuilderState.resetQuerySetup();
   }
 
   async getExportConfiguration(): Promise<QueryExportConfiguration> {