@finos/legend-application-query 5.0.2 → 5.1.0

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,
     );
@@ -562,4 +483,12 @@ export class QueryBuilderState {
   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/tsconfig.json

@@ -61,6 +61,7 @@
     "./src/stores/QueryBuilderGraphFetchTreeUtil.ts",
     "./src/stores/QueryBuilderLambdaBuilder.ts",
     "./src/stores/QueryBuilderLambdaProcessor.ts",
+    "./src/stores/QueryBuilderOperatorLoader.ts",
     "./src/stores/QueryBuilderOperatorsHelper.ts",
     "./src/stores/QueryBuilderPostFilterOperator.ts",
     "./src/stores/QueryBuilderPostFilterProcessor.ts",
@@ -72,6 +73,8 @@
     "./src/stores/QueryBuilderResultState.ts",
     "./src/stores/QueryBuilderSetupState.ts",
     "./src/stores/QueryBuilderState.ts",
+    "./src/stores/QueryBuilderTestUtils.ts",
+    "./src/stores/QueryBuilderTypeaheadHelper.ts",
     "./src/stores/QueryBuilderUnsupportedState.ts",
     "./src/stores/QueryBuilderValueSpecificationBuilderHelper.ts",
     "./src/stores/QueryEditorStore.ts",