@finos/legend-query-builder 0.0.2 → 0.1.0

package/src/graphManager/QueryBuilderHashUtils.ts

@@ -0,0 +1,95 @@
+/**
+ * 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.
+ */
+
+export enum QUERY_BUILDER_HASH_STRUCTURE {
+  // parameters state
+  PARAMETERS_STATE = 'PARAMETERS_STATE',
+
+  // projection state
+  AGGREGATE_OPERATOR_AVERAGE = 'AGGREGATE_OPERATOR_AVERAGE',
+  AGGREGATE_OPERATOR_COUNT = 'AGGREGATE_OPERATOR_COUNT',
+  AGGREGATE_OPERATOR_DISTINCT = 'AGGREGATE_OPERATOR_DISTINCT',
+  AGGREGATE_OPERATOR_DISTINCT_COUNT = 'AGGREGATE_OPERATOR_DISTINCT_COUNT',
+  AGGREGATE_OPERATOR_JOIN_STRING = 'AGGREGATE_OPERATOR_JOIN_STRING',
+  AGGREGATE_OPERATOR_MAX = 'AGGREGATE_OPERATOR_MAX',
+  AGGREGATE_OPERATOR_MIN = 'AGGREGATE_OPERATOR_MIN',
+  AGGREGATE_OPERATOR_STD_DEV_POPULATION = 'AGGREGATE_OPERATOR_STD_DEV_POPULATION',
+  AGGREGATE_OPERATOR_STD_DEV_SAMPLE = 'AGGREGATE_OPERATOR_STD_DEV_SAMPLE',
+  AGGREGATE_OPERATOR_SUM = 'AGGREGATE_OPERATOR_SUM',
+  AGGREGATE_COLUMN_STATE = 'AGGREGATE_COLUMN_STATE',
+  AGGREGATION_STATE = 'AGGREGATION_STATE',
+  SIMPLE_PROJECTION_COLUMN_STATE = 'SIMPLE_PROJECTION_COLUMN_STATE',
+  PROPERTY_EXPRESSION_STATE = 'PROPERTY_EXPRESSION_STATE',
+  DERIVATION_PROJECTION_COLUMN_STATE = 'DERIVATION_PROJECTION_COLUMN_STATE',
+  RESULT_SET_MODIFIER_STATE = 'RESULT_SET_MODIFIER_STATE',
+  SORT_COLUMN_STATE = 'SORT_COLUMN_STATE',
+  PROJECTION_STATE = 'PROJECTION_STATE',
+
+  // post-filter
+  POST_FILTER_TREE_GROUP_NODE_DATA = 'POST_FILTER_TREE_GROUP_NODE_DATA',
+  POST_FILTER_TREE_CONDIITION_NODE_DATA = 'POST_FILTER_TREE_CONDITION_NODE_DATA',
+  POST_FILTER_TREE_BLANK_CONDITION_NODE_DATA = 'POST_FILTER_TREE_BLANK_CONDITION_NODE_DATA',
+  POST_FILTER_CONDITION_STATE = 'POST_FILTER_CONDITION_STATE',
+  POST_FILTER_OPERATOR_CONTAIN = 'POST_FILTER_OPERATOR_CONTAIN',
+  POST_FILTER_OPERATOR_NOT_CONTAIN = 'POST_FILTER_OPERATOR_NOT_CONTAIN',
+  POST_FILTER_OPERATOR_END_WITH = 'POST_FILTER_OPERATOR_END_WITH',
+  POST_FILTER_OPERATOR_NOT_END_WITH = 'POST_FILTER_OPERATOR_NOT_END_WITH',
+  POST_FILTER_OPERATOR_EQUAL = 'POST_FILTER_OPERATOR_EQUAL',
+  POST_FILTER_OPERATOR_NOT_EQUAL = 'POST_FILTER_OPERATOR_NOT_EQUAL',
+  POST_FILTER_OPERATOR_GREATER_THAN = 'POST_FILTER_OPERATOR_GREATER_THAN',
+  POST_FILTER_OPERATOR_GREATER_THAN_EQUAL = 'POST_FILTER_OPERATOR_GREATER_THAN_EQUAL',
+  POST_FILTER_OPERATOR_IN = 'POST_FILTER_OPERATOR_IN',
+  POST_FILTER_OPERATOR_NOT_IN = 'POST_FILTER_OPERATOR_IN',
+  POST_FILTER_OPERATOR_IS_EMPTY = 'POST_FILTER_OPERATOR_IS_EMPTY',
+  POST_FILTER_OPERATOR_IS_NOT_EMPTY = 'POST_FILTER_OPERATOR_IS_NOT_EMPTY',
+  POST_FILTER_OPERATOR_LESS_THAN = 'POST_FILTER_OPERATOR_LESS_THAN',
+  POST_FILTER_OPERATOR_LESS_THAN_EQUAL = 'POST_FILTER_OPERATOR_LESS_THAN_EQUAL',
+  POST_FILTER_OPERATOR_START_WITH = 'POST_FILTER_OPERATOR_START_WITH',
+  POST_FILTER_OPERATOR_NOT_START_WITH = 'POST_FILTER_OPERATOR_NOT_START_WITH',
+  POST_FILTER_STATE = 'POST_FILTER_STATE',
+
+  // filter state
+  FILTER_TREE_GROUP_NODE_DATA = 'FILTER_TREE_GROUP_NODE_DATA',
+  FILTER_TREE_CONDIITION_NODE_DATA = 'FILTER_TREE_CONDITION_NODE_DATA',
+  FILTER_TREE_BLANK_CONDITION_NODE_DATA = 'FILTER_TREE_BLANK_CONDITION_NODE_DATA',
+  FILTER_CONDITION_STATE = 'FILTER_CONDITION_STATE',
+  FILTER_OPERATOR_CONTAIN = 'FILTER_OPERATOR_CONTAIN',
+  FILTER_OPERATOR_NOT_CONTAIN = 'FILTER_OPERATOR_NOT_CONTAIN',
+  FILTER_OPERATOR_END_WITH = 'FILTER_OPERATOR_END_WITH',
+  FILTER_OPERATOR_NOT_END_WITH = 'FILTER_OPERATOR_NOT_END_WITH',
+  FILTER_OPERATOR_EQUAL = 'FILTER_OPERATOR_EQUAL',
+  FILTER_OPERATOR_NOT_EQUAL = 'FILTER_OPERATOR_NOT_EQUAL',
+  FILTER_OPERATOR_GREATER_THAN = 'FILTER_OPERATOR_GREATER_THAN',
+  FILTER_OPERATOR_GREATER_THAN_EQUAL = 'FILTER_OPERATOR_GREATER_THAN_EQUAL',
+  FILTER_OPERATOR_IN = 'FILTER_OPERATOR_IN',
+  FILTER_OPERATOR_NOT_IN = 'FILTER_OPERATOR_IN',
+  FILTER_OPERATOR_IS_EMPTY = 'FILTER_OPERATOR_IS_EMPTY',
+  FILTER_OPERATOR_IS_NOT_EMPTY = 'FILTER_OPERATOR_IS_NOT_EMPTY',
+  FILTER_OPERATOR_LESS_THAN = 'FILTER_OPERATOR_LESS_THAN',
+  FILTER_OPERATOR_LESS_THAN_EQUAL = 'FILTER_OPERATOR_LESS_THAN_EQUAL',
+  FILTER_OPERATOR_START_WITH = 'FILTER_OPERATOR_START_WITH',
+  FILTER_OPERATOR_NOT_START_WITH = 'FILTER_OPERATOR_NOT_START_WITH',
+  FILTER_STATE = 'FILTER_STATE',
+
+  // graph fetch state
+  GRAPH_FETCH_STATE = 'GRAPH_FETCH_STATE',
+  GRAPH_FETCH_TREE_NODE_DATA = 'GRAPH_FETCH_TREE_NODE_DATA',
+
+  // general
+  MILESTONING_STATE = 'MILESTONING_STATE',
+  UNSUPPORTED_QUERY_STATE = 'UNSUPPORTED_QUERY_STATE',
+  QUERY_BUILDER_STATE = 'QUERY_BUILDER_STATE',
+}

package/src/index.ts

@@ -21,6 +21,7 @@ export { QUERY_BUILDER_TEST_ID } from './components//QueryBuilder_TestID.js';
 export { QueryBuilder } from './components//QueryBuilder.js';
 export { QueryBuilderState } from './stores//QueryBuilderState.js';
 
+export { QueryBuilderPropertySearchState } from './stores/explorer/QueryBuilderPropertySearchState.js';
 export {
   QueryBuilderClassSelector,
   buildRuntimeValueOption,
@@ -36,3 +37,5 @@ export {
 export { getQueryBuilderGraphManagerExtension } from './graphManager/protocol/pure/QueryBuilder_PureGraphManagerExtension.js';
 export type { ServiceExecutionAnalysisResult } from './graphManager/action/analytics/ServiceExecutionAnalysis.js';
 export type { MappingRuntimeCompatibilityAnalysisResult } from './graphManager/action/analytics/MappingRuntimeCompatibilityAnalysis.js';
+export * from './stores/ServiceInfo.js';
+export * from './components/ServiceQuerySetupUtils.js';

package/src/stores/QueryBuilderChangeDetectionState.ts

@@ -14,24 +14,126 @@
  * limitations under the License.
  */
 
-import { RawLambda } from '@finos/legend-graph';
-import { hashObject } from '@finos/legend-shared';
+import type { RawLambda } from '@finos/legend-graph';
+import {
+  ActionState,
+  assertErrorThrown,
+  assertNonNullable,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import { action, computed, flow, makeObservable, observable } from 'mobx';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 
+export enum QueryBuilderDiffViewMode {
+  JSON = 'JSON',
+  GRAMMAR = 'Grammar',
+}
+
+export class QueryBuilderDiffViewState {
+  readonly changeDetectionState: QueryBuilderChangeDetectionState;
+  readonly initialQuery: RawLambda;
+  readonly currentQuery: RawLambda;
+
+  mode = QueryBuilderDiffViewMode.GRAMMAR;
+  initialQueryGrammarText?: string | undefined;
+  currentQueryGrammarText?: string | undefined;
+
+  constructor(
+    changeDetectionState: QueryBuilderChangeDetectionState,
+    initialQuery: RawLambda,
+    currentQuery: RawLambda,
+  ) {
+    makeObservable(this, {
+      mode: observable,
+      initialQueryGrammarText: observable,
+      currentQueryGrammarText: observable,
+      setMode: action,
+      generateGrammarDiff: flow,
+    });
+
+    this.changeDetectionState = changeDetectionState;
+    this.initialQuery = initialQuery;
+    this.currentQuery = currentQuery;
+  }
+
+  setMode(val: QueryBuilderDiffViewMode): void {
+    this.mode = val;
+  }
+
+  *generateGrammarDiff(): GeneratorFn<void> {
+    try {
+      this.initialQueryGrammarText =
+        (yield this.changeDetectionState.querybuilderState.graphManagerState.graphManager.lambdaToPureCode(
+          this.initialQuery,
+          true,
+        )) as string;
+    } catch (error) {
+      assertErrorThrown(error);
+      this.initialQueryGrammarText =
+        '/* Failed to transform grammar text, see JSON diff instead */';
+    }
+    try {
+      this.currentQueryGrammarText =
+        (yield this.changeDetectionState.querybuilderState.graphManagerState.graphManager.lambdaToPureCode(
+          this.currentQuery,
+          true,
+        )) as string;
+    } catch (error) {
+      assertErrorThrown(error);
+      this.currentQueryGrammarText =
+        '/* Failed to transform grammar text, see JSON diff instead */';
+    }
+  }
+}
+
 export class QueryBuilderChangeDetectionState {
-  querybuildState: QueryBuilderState;
-  queryHashCode = hashObject(new RawLambda(undefined, undefined));
-  isEnabled = false;
+  querybuilderState: QueryBuilderState;
+  initState = ActionState.create();
+  diffViewState?: QueryBuilderDiffViewState | undefined;
+  initialQuery?: RawLambda | undefined;
+  initialHashCode?: string | undefined;
 
   constructor(queryBuilderState: QueryBuilderState) {
-    this.querybuildState = queryBuilderState;
+    makeObservable(this, {
+      diffViewState: observable,
+      initialHashCode: observable,
+      initialQuery: observable,
+      hasChanged: computed,
+      initialize: action,
+      showDiffViewPanel: action,
+      hideDiffViewPanel: action,
+    });
+
+    this.querybuilderState = queryBuilderState;
+  }
+
+  showDiffViewPanel(): void {
+    assertNonNullable(
+      this.initialQuery,
+      `Can't show changes: change detection is not properly initialized`,
+    );
+    this.diffViewState = new QueryBuilderDiffViewState(
+      this,
+      this.initialQuery,
+      this.querybuilderState.buildQuery(),
+    );
+  }
+
+  hideDiffViewPanel(): void {
+    this.diffViewState = undefined;
   }
 
-  setQueryHashCode(val: string): void {
-    this.queryHashCode = val;
+  get hasChanged(): boolean {
+    if (!this.initState.hasCompleted) {
+      return false;
+    }
+    return this.querybuilderState.hashCode !== this.initialHashCode;
   }
 
-  setIsEnabled(val: boolean): void {
-    this.isEnabled = val;
+  initialize(initialQuery: RawLambda): void {
+    this.initState.inProgress();
+    this.initialHashCode = this.querybuilderState.hashCode;
+    this.initialQuery = initialQuery;
+    this.initState.complete();
   }
 }

package/src/stores/QueryBuilderConfig.ts

@@ -24,7 +24,9 @@ export const DEFAULT_VARIABLE_NAME = 'var';
 export const DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME = 'row';
 
 export const QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH = 5;
+export const QUERY_BUILDER_PROPERTY_SEARCH_MAX_NODES = 10000;
 export const QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT = 100;
+
 export enum QUERY_BUILDER_PROPERTY_SEARCH_TYPE {
   CLASS = 'CLASS',
   STRING = 'STRING',

package/src/stores/QueryBuilderMilestoningState.ts

@@ -28,10 +28,12 @@ import {
   VariableExpression,
   type ValueSpecification,
 } from '@finos/legend-graph';
+import { type Hashable, hashArray } from '@finos/legend-shared';
 import { action, computed, makeObservable, observable } from 'mobx';
+import { QUERY_BUILDER_HASH_STRUCTURE } from '../graphManager/QueryBuilderHashUtils.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 
-export class QueryBuilderMilestoningState {
+export class QueryBuilderMilestoningState implements Hashable {
   queryBuilderState: QueryBuilderState;
 
   showMilestoningEditor = false;
@@ -49,6 +51,7 @@ export class QueryBuilderMilestoningState {
       setProcessingDate: action,
       setBusinessDate: action,
       setShowMilestoningEditor: action,
+      hashCode: computed,
     });
 
     this.queryBuilderState = queryBuilderState;
@@ -161,4 +164,12 @@ export class QueryBuilderMilestoningState {
     }
     return milestoningParameter;
   }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.MILESTONING_STATE,
+      this.businessDate ?? '',
+      this.processingDate ?? '',
+    ]);
+  }
 }

package/src/stores/QueryBuilderParametersState.ts

@@ -18,7 +18,9 @@ import {
   LambdaParametersState,
   type LambdaParameterState,
 } from '@finos/legend-application';
-import { observable, makeObservable, action } from 'mobx';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+import { observable, makeObservable, action, override } from 'mobx';
+import { QUERY_BUILDER_HASH_STRUCTURE } from '../graphManager/QueryBuilderHashUtils.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 
 export const QUERY_BUILDER_PARAMETER_DND_TYPE = 'PARAMETER';
@@ -27,7 +29,10 @@ export interface QueryBuilderParameterDragSource {
   variable: LambdaParameterState;
 }
 
-export class QueryBuilderParametersState extends LambdaParametersState {
+export class QueryBuilderParametersState
+  extends LambdaParametersState
+  implements Hashable
+{
   selectedParameter: LambdaParameterState | undefined;
   queryBuilderState: QueryBuilderState;
 
@@ -41,11 +46,19 @@ export class QueryBuilderParametersState extends LambdaParametersState {
       setParameters: action,
       selectedParameter: observable,
       setSelectedParameter: action,
+      hashCode: override,
     });
 
     this.queryBuilderState = queryBuilderState;
   }
 
+  override get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.PARAMETERS_STATE,
+      hashArray(this.parameterStates),
+    ]);
+  }
+
   setSelectedParameter(val: LambdaParameterState | undefined): void {
     this.selectedParameter = val;
   }

package/src/stores/QueryBuilderPropertyEditorState.ts

@@ -14,11 +14,13 @@
  * limitations under the License.
  */
 
-import { action, makeAutoObservable } from 'mobx';
+import { action, computed, makeObservable, observable } from 'mobx';
 import {
   getNullableFirstElement,
   guaranteeNonNullable,
   guaranteeType,
+  type Hashable,
+  hashArray,
   isCamelCase,
   prettyCamelCase,
   prettyCONSTName,
@@ -59,6 +61,7 @@ import type { QueryBuilderState } from './QueryBuilderState.js';
 import { functionExpression_setParametersValues } from '@finos/legend-application';
 import type { QueryBuilderMilestoningState } from './QueryBuilderMilestoningState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
+import { QUERY_BUILDER_HASH_STRUCTURE } from '../graphManager/QueryBuilderHashUtils.js';
 
 export const getDerivedPropertyMilestoningSteoreotype = (
   property: DerivedProperty,
@@ -556,12 +559,11 @@ export class QueryBuilderDerivedPropertyExpressionState {
   }
 }
 
-export class QueryBuilderPropertyExpressionState {
-  queryBuilderState: QueryBuilderState;
+export class QueryBuilderPropertyExpressionState implements Hashable {
+  readonly queryBuilderState: QueryBuilderState;
+  readonly propertyExpression: AbstractPropertyExpression;
   path: string;
   title: string;
-  readonly propertyExpression: AbstractPropertyExpression;
-
   isEditingDerivedPropertyExpression = false;
   // Since this property is a chain expression, some link of the chain can be
   // derived property, as such, we need to keep track of the derived properties state in an array
@@ -580,13 +582,16 @@ export class QueryBuilderPropertyExpressionState {
     queryBuilderState: QueryBuilderState,
     propertyExpression: AbstractPropertyExpression,
   ) {
-    makeAutoObservable<
+    makeObservable<
       QueryBuilderPropertyExpressionState,
       'initDerivedPropertyExpressionStates'
     >(this, {
-      queryBuilderState: false,
+      isEditingDerivedPropertyExpression: observable,
+      derivedPropertyExpressionStates: observable,
       setIsEditingDerivedProperty: action,
       initDerivedPropertyExpressionStates: action,
+      isValid: computed,
+      hashCode: computed,
     });
 
     this.queryBuilderState = queryBuilderState;
@@ -665,4 +670,11 @@ export class QueryBuilderPropertyExpressionState {
     this.requiresExistsHandling = requiresExistsHandling;
     this.derivedPropertyExpressionStates = result.slice().reverse();
   }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.PROPERTY_EXPRESSION_STATE,
+      this.propertyExpression,
+    ]);
+  }
 }

package/src/stores/QueryBuilderResultState.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { action, makeAutoObservable } from 'mobx';
+import { action, flow, makeObservable, observable } from 'mobx';
 import {
   type GeneratorFn,
   assertErrorThrown,
@@ -45,22 +45,35 @@ import {
 const DEFAULT_LIMIT = 1000;
 
 export class QueryBuilderResultState {
-  queryBuilderState: QueryBuilderState;
-  exportDataState = ActionState.create();
+  readonly queryBuilderState: QueryBuilderState;
+  readonly exportDataState = ActionState.create();
+  readonly executionPlanState: ExecutionPlanState;
+
   previewLimit = DEFAULT_LIMIT;
   isRunningQuery = false;
   isGeneratingPlan = false;
   executionResult?: ExecutionResult | undefined;
-  executionPlanState: ExecutionPlanState;
   executionDuration?: number | undefined;
+  latestRunHashCode?: string | undefined;
   queryRunPromise: Promise<ExecutionResult> | undefined = undefined;
 
   constructor(queryBuilderState: QueryBuilderState) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
-      executionPlanState: false,
+    makeObservable(this, {
+      executionResult: observable,
+      previewLimit: observable,
+      executionDuration: observable,
+      latestRunHashCode: observable,
+      queryRunPromise: observable,
+      isGeneratingPlan: observable,
+      isRunningQuery: observable,
       setIsRunningQuery: action,
       setExecutionResult: action,
+      setExecutionDuration: action,
+      setPreviewLimit: action,
+      setQueryRunPromise: action,
+      exportData: flow,
+      runQuery: flow,
+      generatePlan: flow,
     });
 
     this.queryBuilderState = queryBuilderState;
@@ -92,6 +105,13 @@ export class QueryBuilderResultState {
     this.queryRunPromise = promise;
   };
 
+  get checkForStaleResults(): boolean {
+    if (this.latestRunHashCode !== this.queryBuilderState.hashCode) {
+      return true;
+    }
+    return false;
+  }
+
   buildExecutionRawLambda(): RawLambda {
     let query: RawLambda;
     if (this.queryBuilderState.isQuerySupported) {
@@ -188,7 +208,8 @@ export class QueryBuilderResultState {
 
   *runQuery(): GeneratorFn<void> {
     try {
-      this.isRunningQuery = true;
+      this.setIsRunningQuery(true);
+      const currentHashCode = this.queryBuilderState.hashCode;
       const mapping = guaranteeNonNullable(
         this.queryBuilderState.mapping,
         'Mapping is required to execute query',
@@ -210,6 +231,7 @@ export class QueryBuilderResultState {
       const result = (yield promise) as ExecutionResult;
       if (this.queryRunPromise === promise) {
         this.setExecutionResult(result);
+        this.latestRunHashCode = currentHashCode;
         this.setExecutionDuration(Date.now() - startTime);
       }
     } catch (error) {

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/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 ?? '',
+    ]);
+  }
 }