@finos/legend-application-query 5.0.2 → 5.1.0

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,
@@ -56,6 +60,11 @@ import {
   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();
@@ -107,6 +116,8 @@ export class FilterConditionState {
   operator!: QueryBuilderFilterOperator;
   value?: ValueSpecification | undefined;
   existsLambdaParamNames: string[] = [];
+  typeaheadSearchResults: string[] | undefined;
+  typeaheadSearchState = ActionState.create();
 
   constructor(
     filterState: QueryBuilderFilterState,
@@ -119,7 +130,10 @@ export class FilterConditionState {
       changeOperator: action,
       setOperator: action,
       setValue: action,
+      typeaheadSearchResults: observable,
+      typeaheadSearchState: observable,
       addExistsLambdaParamNames: action,
+      handleTypeaheadSearch: flow,
     });
 
     this.filterState = filterState;
@@ -143,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

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/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',
@@ -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)) {