@finos/legend-query-builder 0.0.2 → 0.1.1

package/src/stores/QueryBuilderState.ts

@@ -23,6 +23,7 @@ import {
   guaranteeType,
   filterByType,
   ActionState,
+  hashArray,
 } from '@finos/legend-shared';
 import { QueryBuilderFilterState } from './filter/QueryBuilderFilterState.js';
 import { QueryBuilderFetchStructureState } from './fetch-structure/QueryBuilderFetchStructureState.js';
@@ -62,6 +63,7 @@ import type { QueryBuilderFilterOperator } from './filter/QueryBuilderFilterOper
 import { getQueryBuilderCoreFilterOperators } from './filter/QueryBuilderFilterOperatorLoader.js';
 import { QueryBuilderChangeDetectionState } from './QueryBuilderChangeDetectionState.js';
 import { QueryBuilderMilestoningState } from './QueryBuilderMilestoningState.js';
+import { QUERY_BUILDER_HASH_STRUCTURE } from '../graphManager/QueryBuilderHashUtils.js';
 
 export abstract class QueryBuilderState {
   applicationStore: GenericLegendApplicationStore;
@@ -134,6 +136,7 @@ export abstract class QueryBuilderState {
       rebuildWithQuery: action,
       saveQuery: action,
       compileQuery: flow,
+      hashCode: computed,
     });
 
     this.applicationStore = applicationStore;
@@ -278,9 +281,39 @@ export abstract class QueryBuilderState {
     );
   }
 
-  initializeWithQuery(rawLambda: RawLambda): void {
+  initializeWithQuery(query: RawLambda): void {
+    this.rebuildWithQuery(query);
+    this.changeDetectionState.initialize(query);
+  }
+
+  /**
+   * Process the provided query, and rebuild the query builder state.
+   */
+  rebuildWithQuery(query: RawLambda): void {
     try {
-      this.rebuildWithQuery(rawLambda);
+      this.resetQueryResult();
+      this.resetQueryContent();
+
+      if (!isStubbed_RawLambda(query)) {
+        const valueSpec = observe_ValueSpecification(
+          this.graphManagerState.graphManager.buildValueSpecification(
+            this.graphManagerState.graphManager.serializeRawValueSpecification(
+              query,
+            ),
+            this.graphManagerState.graph,
+          ),
+          this.observableContext,
+        );
+        const compiledValueSpecification = guaranteeType(
+          valueSpec,
+          LambdaFunctionInstanceValue,
+          `Can't build query state: query builder only support lambda`,
+        );
+        processQueryLambdaFunction(
+          guaranteeNonNullable(compiledValueSpecification.values[0]),
+          this,
+        );
+      }
       if (this.parametersState.parameterStates.length > 0) {
         this.setShowParametersPanel(true);
       }
@@ -289,10 +322,10 @@ export abstract class QueryBuilderState {
       this.resetQueryContent();
       this.resetQueryResult();
       this.unsupportedQueryState.setLambdaError(error);
-      this.unsupportedQueryState.setRawLambda(rawLambda);
+      this.unsupportedQueryState.setRawLambda(query);
       this.setClass(undefined);
       const parameters = buildLambdaVariableExpressions(
-        rawLambda,
+        query,
         this.graphManagerState,
       )
         .map((param) =>
@@ -303,43 +336,12 @@ export abstract class QueryBuilderState {
     }
   }
 
-  /**
-   * Process the provided query, and rebuild the query builder state.
-   *
-   * @throws error if there is an issue building the compiled lambda or rebuilding the state.
-   * consumers of function should handle the errors.
-   */
-  rebuildWithQuery(val: RawLambda): void {
-    this.resetQueryResult();
-    this.resetQueryContent();
-    if (!isStubbed_RawLambda(val)) {
-      const valueSpec = observe_ValueSpecification(
-        this.graphManagerState.graphManager.buildValueSpecification(
-          this.graphManagerState.graphManager.serializeRawValueSpecification(
-            val,
-          ),
-          this.graphManagerState.graph,
-        ),
-        this.observableContext,
-      );
-      const compiledValueSpecification = guaranteeType(
-        valueSpec,
-        LambdaFunctionInstanceValue,
-        `Can't build query state: query builder only support lambda`,
-      );
-      processQueryLambdaFunction(
-        guaranteeNonNullable(compiledValueSpecification.values[0]),
-        this,
-      );
-    }
-  }
-
   async saveQuery(
     onSaveQuery: (lambda: RawLambda) => Promise<void>,
   ): Promise<void> {
     try {
-      const rawLambda = this.buildQuery();
-      await onSaveQuery(rawLambda);
+      const query = this.buildQuery();
+      await onSaveQuery(query);
     } catch (error) {
       assertErrorThrown(error);
       this.applicationStore.notifyError(`Can't save query: ${error.message}`);
@@ -450,6 +452,17 @@ export abstract class QueryBuilderState {
     basicState.runtimeValue = this.runtimeValue;
     return basicState;
   }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.QUERY_BUILDER_STATE,
+      this.unsupportedQueryState,
+      this.milestoningState,
+      this.parametersState,
+      this.filterState,
+      this.fetchStructureState.implementation,
+    ]);
+  }
 }
 
 /**

package/src/stores/QueryBuilderStateTestUtils.ts

@@ -61,7 +61,7 @@ export const TEST__setUpQueryBuilderState = async (
     graphManagerState,
   );
   if (rawLambda) {
-    queryBuilderState.rebuildWithQuery(rawLambda);
+    queryBuilderState.initializeWithQuery(rawLambda);
   }
   if (executionContext) {
     const graph = queryBuilderState.graphManagerState.graph;

package/src/stores/QueryBuilderTextEditorState.ts

@@ -193,7 +193,7 @@ export class QueryBuilderTextEditorState extends LambdaEditorState {
           `Can't parse query. Please fix error before closing: ${this.parserError.message}`,
         );
       } else {
-        this.queryBuilderState.initializeWithQuery(this.rawLambdaState.lambda);
+        this.queryBuilderState.rebuildWithQuery(this.rawLambdaState.lambda);
         this.setMode(undefined);
       }
       return;

package/src/stores/QueryBuilderTypeaheadHelper.ts

@@ -36,9 +36,10 @@ import {
 } from './fetch-structure/projection/QueryBuilderProjectionColumnState.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import { QueryBuilderProjectionState } from './fetch-structure/projection/QueryBuilderProjectionState.js';
-
-const TYPEAHEAD_TAKE_LIMIT = 10;
-const START_LENGTH = 3;
+import {
+  DEFAULT_TYPEAHEAD_SEARCH_LIMIT,
+  DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH,
+} from '@finos/legend-application';
 
 const initializeQueryBuilderState = (
   queryBuilderState: QueryBuilderState,
@@ -49,7 +50,7 @@ const initializeQueryBuilderState = (
     QueryBuilderProjectionState,
   );
   projectionState.resultSetModifierState.distinct = true;
-  projectionState.resultSetModifierState.limit = TYPEAHEAD_TAKE_LIMIT;
+  projectionState.resultSetModifierState.limit = DEFAULT_TYPEAHEAD_SEARCH_LIMIT;
   return builderState;
 };
 
@@ -142,7 +143,7 @@ export const performTypeahead = (
     switch (_type.path) {
       case PRIMITIVE_TYPE.STRING: {
         const value = val.values[0] as string;
-        return value.length >= START_LENGTH;
+        return value.length >= DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH;
       }
       default:
         return false;

package/src/stores/QueryBuilderUnsupportedQueryState.ts

@@ -14,12 +14,14 @@
  * limitations under the License.
  */
 
-import { makeObservable, action, observable } from 'mobx';
+import { makeObservable, action, observable, computed } from 'mobx';
+import { type Hashable, hashArray } from '@finos/legend-shared';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import type { RawLambda } from '@finos/legend-graph';
+import { QUERY_BUILDER_HASH_STRUCTURE } from '../graphManager/QueryBuilderHashUtils.js';
 
-export class QueryBuilderUnsupportedQueryState {
-  queryBuilderState: QueryBuilderState;
+export class QueryBuilderUnsupportedQueryState implements Hashable {
+  readonly queryBuilderState: QueryBuilderState;
   rawLambda?: RawLambda | undefined;
   lambdaError?: Error | undefined;
 
@@ -29,6 +31,7 @@ export class QueryBuilderUnsupportedQueryState {
       lambdaError: observable,
       setRawLambda: action,
       setLambdaError: action,
+      hashCode: computed,
     });
 
     this.queryBuilderState = queryBuilderState;
@@ -41,4 +44,11 @@ export class QueryBuilderUnsupportedQueryState {
   setLambdaError(val: Error | undefined): void {
     this.lambdaError = val;
   }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.UNSUPPORTED_QUERY_STATE,
+      this.rawLambda ?? '',
+    ]);
+  }
 }

package/src/stores/ServiceInfo.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 {
+  MASTER_SNAPSHOT_ALIAS,
+  SNAPSHOT_VERSION_ALIAS,
+  type StoredEntity,
+} from '@finos/legend-server-depot';
+import { isString } from '@finos/legend-shared';
+import { type Entity, extractEntityNameFromPath } from '@finos/legend-storage';
+
+export interface ServiceInfo {
+  groupId: string;
+  artifactId: string;
+  versionId: string;
+  path: string;
+  name: string;
+  entity: Entity;
+  urlPattern?: string | undefined;
+}
+
+export const extractServiceInfo = (
+  storedEntity: StoredEntity,
+): ServiceInfo => ({
+  groupId: storedEntity.groupId,
+  artifactId: storedEntity.artifactId,
+  versionId:
+    storedEntity.versionId === MASTER_SNAPSHOT_ALIAS
+      ? SNAPSHOT_VERSION_ALIAS
+      : storedEntity.versionId,
+  path: storedEntity.entity.path,
+  name: extractEntityNameFromPath(storedEntity.entity.path),
+  entity: storedEntity.entity,
+  // NOTE: we don't want to assert the existence of this field even when it
+  // is required in the specification of service to avoid throwing error here
+  urlPattern: isString(storedEntity.entity.content.pattern)
+    ? storedEntity.entity.content.pattern
+    : undefined,
+});

package/src/stores/explorer/QueryBuilderExplorerState.ts

@@ -26,7 +26,6 @@ import {
 } from '@finos/legend-shared';
 import {
   type AbstractProperty,
-  type PureModel,
   type Type,
   type MappingModelCoverageAnalysisResult,
   type EnumMappedProperty,
@@ -60,14 +59,7 @@ import {
   getAllSubclasses,
 } from '@finos/legend-graph';
 import type { QueryBuilderState } from '../QueryBuilderState.js';
-import {
-  action,
-  flow,
-  flowResult,
-  makeAutoObservable,
-  makeObservable,
-  observable,
-} from 'mobx';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../QueryBuilderConfig.js';
 import {
   buildNonNumericPreviewDataQuery,
@@ -198,14 +190,17 @@ export class QueryBuilderExplorerTreeSubTypeNodeData extends QueryBuilderExplore
 }
 
 export const buildPropertyExpressionFromExplorerTreeNodeData = (
-  treeData: TreeData<QueryBuilderExplorerTreeNodeData>,
   node: QueryBuilderExplorerTreePropertyNodeData,
-  graph: PureModel,
-  allMappedPropertyNodes: QueryBuilderExplorerTreeNodeData[],
+  explorerState: QueryBuilderExplorerState,
 ): AbstractPropertyExpression => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
+  const treeData = explorerState.nonNullableTreeData;
+  const propertySearchIndexedTreeNodes =
+    explorerState.propertySearchState.indexedExplorerTreeNodes;
+
+  const multiplicityOne =
+    explorerState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
   const projectionColumnLambdaVariable = new VariableExpression(
     DEFAULT_LAMBDA_VARIABLE_NAME,
     multiplicityOne,
@@ -219,13 +214,13 @@ export const buildPropertyExpressionFromExplorerTreeNodeData = (
     propertyExpression;
   let parentNode =
     treeData.nodes.get(node.parentId) ??
-    allMappedPropertyNodes.find((n) => n.id === node.parentId);
+    propertySearchIndexedTreeNodes.find((n) => n.id === node.parentId);
   let currentNode: QueryBuilderExplorerTreeNodeData = node;
   while (
     parentNode instanceof QueryBuilderExplorerTreePropertyNodeData ||
     parentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData
   ) {
-    // NOTE: here, we deliverately simplify subtypes chain
+    // NOTE: here, we deliberately simplify subtypes chain
     // $x.employees->subType(@Person)->subType(@Staff).department will be simplified to $x.employees->subType(@Staff).department
     if (
       parentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData &&
@@ -270,7 +265,7 @@ export const buildPropertyExpressionFromExplorerTreeNodeData = (
       (currentNode instanceof QueryBuilderExplorerTreePropertyNodeData ||
         currentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData)
     ) {
-      for (const propertyNode of allMappedPropertyNodes) {
+      for (const propertyNode of propertySearchIndexedTreeNodes) {
         if (propertyNode.id === currentNode.parentId) {
           parentNode = propertyNode;
           break;
@@ -566,8 +561,10 @@ export class QueryBuilderExplorerPreviewDataState {
   previewData?: QueryBuilderPreviewData | undefined;
 
   constructor() {
-    makeAutoObservable(this, {
+    makeObservable(this, {
       previewData: observable.ref,
+      isGeneratingPreviewData: observable,
+      propertyName: observable,
       setPropertyName: action,
       setIsGeneratingPreviewData: action,
       setPreviewData: action,
@@ -588,30 +585,31 @@ export class QueryBuilderExplorerPreviewDataState {
 }
 
 export class QueryBuilderExplorerState {
-  queryBuilderState: QueryBuilderState;
-  previewDataState = new QueryBuilderExplorerPreviewDataState();
+  readonly queryBuilderState: QueryBuilderState;
+  readonly previewDataState = new QueryBuilderExplorerPreviewDataState();
+  readonly propertySearchState: QueryBuilderPropertySearchState;
   treeData?: TreeData<QueryBuilderExplorerTreeNodeData> | undefined;
   humanizePropertyName = true;
   showUnmappedProperties = false;
   highlightUsedProperties = true;
-  propertySearchState: QueryBuilderPropertySearchState;
-  mappingModelCoverageAnalysisResult?: MappingModelCoverageAnalysisResult;
   mappingModelCoverageAnalysisState = ActionState.create();
+  mappingModelCoverageAnalysisResult?: MappingModelCoverageAnalysisResult;
 
   constructor(queryBuilderState: QueryBuilderState) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
-      previewDataState: false,
+    makeObservable(this, {
       treeData: observable.ref,
+      humanizePropertyName: observable,
+      showUnmappedProperties: observable,
       highlightUsedProperties: observable,
+      mappingModelCoverageAnalysisResult: observable,
       setTreeData: action,
       refreshTree: action,
       refreshTreeData: action,
       setHumanizePropertyName: action,
       setShowUnmappedProperties: action,
-      previewData: flow,
       setHighlightUsedProperties: action,
       analyzeMappingModelCoverage: flow,
+      previewData: flow,
     });
 
     this.queryBuilderState = queryBuilderState;
@@ -711,10 +709,8 @@ export class QueryBuilderExplorerState {
     this.previewDataState.setPropertyName(node.property.name);
     this.previewDataState.setIsGeneratingPreviewData(true);
     const propertyExpression = buildPropertyExpressionFromExplorerTreeNodeData(
-      this.nonNullableTreeData,
       node,
-      this.queryBuilderState.graphManagerState.graph,
-      this.propertySearchState.allMappedPropertyNodes,
+      this,
     );
     const propertyType = node.property.genericType.value.rawType;
     try {