@finos/legend-query-builder 0.4.4 → 0.5.0

package/src/components/watermark/QueryBuilderWatermark.tsx

@@ -24,7 +24,6 @@ import {
   ModalBody,
   ModalFooter,
   ModalHeader,
-  PanelFormListItems,
   PanelFormSection,
 } from '@finos/legend-art';
 import {
@@ -37,14 +36,14 @@ import {
 import { observer } from 'mobx-react-lite';
 import { useCallback } from 'react';
 import { useDrop } from 'react-dnd';
-import {
-  type QueryBuilderParameterDragSource,
-  QUERY_BUILDER_PARAMETER_DND_TYPE,
-} from '../../stores/QueryBuilderParametersState.js';
 import type { QueryBuilderState } from '../../stores/QueryBuilderState.js';
 import type { QueryBuilderWatermarkState } from '../../stores/watermark/QueryBuilderWatermarkState.js';
-import { VariableExpressionViewer } from '../QueryBuilderParametersPanel.js';
-import { BasicValueSpecificationEditor } from '../shared/BasicValueSpecificationEditor.js';
+import {
+  BasicValueSpecificationEditor,
+  QUERY_BUILDER_VARIABLE_DND_TYPE,
+  type QueryBuilderVariableDragSource,
+} from '../shared/BasicValueSpecificationEditor.js';
+import { VariableSelector } from '../shared/QueryBuilderVariableSelector.js';
 
 const isParamaterCompatibleWithWaterMark = (
   parameter: VariableExpression,
@@ -62,24 +61,24 @@ const WatermarkValueEditor = observer(
     const graph = watermarkState.queryBuilderState.graphManagerState.graph;
 
     const handleDrop = useCallback(
-      (item: QueryBuilderParameterDragSource): void => {
-        watermarkState.setValue(item.variable.parameter);
+      (item: QueryBuilderVariableDragSource): void => {
+        watermarkState.setValue(item.variable);
       },
       [watermarkState],
     );
 
     const [{ isParameterValueDragOver }, dropTargetConnector] = useDrop<
-      QueryBuilderParameterDragSource,
+      QueryBuilderVariableDragSource,
       void,
       { isParameterValueDragOver: boolean }
     >(
       () => ({
-        accept: [QUERY_BUILDER_PARAMETER_DND_TYPE],
+        accept: [QUERY_BUILDER_VARIABLE_DND_TYPE],
         drop: (item, monitor): void => {
           if (
             !monitor.didDrop() &&
             // Only allows parameters with muliplicity 1 and type string
-            isParamaterCompatibleWithWaterMark(item.variable.parameter)
+            isParamaterCompatibleWithWaterMark(item.variable)
           ) {
             handleDrop(item);
           } // prevent drop event propagation to accomondate for nested DnD
@@ -95,7 +94,7 @@ const WatermarkValueEditor = observer(
 
     return (
       <PanelFormSection>
-        <div className="query-builder__parameter-editor">
+        <div className="query-builder__variable-editor">
           <PanelDropZone
             isDragOver={isParameterValueDragOver}
             dropTargetConnector={dropTargetConnector}
@@ -115,6 +114,9 @@ const WatermarkValueEditor = observer(
               resetValue={(): void => {
                 watermarkState.resetValue();
               }}
+              isConstant={watermarkState.queryBuilderState.constantState.isValueSpecConstant(
+                watermarkValue,
+              )}
             />
           </PanelDropZone>
         </div>
@@ -130,10 +132,6 @@ export const QueryBuilderWatermarkEditor = observer(
     const handleClose = (): void => {
       watermarkState.setIsEditingWatermark(false);
     };
-    const compatibleParameters =
-      queryBuilderState.parametersState.parameterStates.filter((p) =>
-        isParamaterCompatibleWithWaterMark(p.parameter),
-      );
 
     return (
       <Dialog
@@ -162,20 +160,10 @@ export const QueryBuilderWatermarkEditor = observer(
                     watermarkValue={watermarkState.value}
                   />
                   <PanelDivider />
-                  <PanelFormListItems title="List of available parameters">
-                    {compatibleParameters.length === 0 && (
-                      <> No available parameters </>
-                    )}
-                    {compatibleParameters.map((parameter) => (
-                      <VariableExpressionViewer
-                        key={parameter.uuid}
-                        queryBuilderState={queryBuilderState}
-                        variableExpressionState={parameter}
-                        isReadOnly={true}
-                        hideActions={true}
-                      />
-                    ))}
-                  </PanelFormListItems>
+                  <VariableSelector
+                    filterBy={isParamaterCompatibleWithWaterMark}
+                    queryBuilderState={queryBuilderState}
+                  />
                 </>
               )}
             </PanelForm>

package/src/graphManager/QueryBuilderHashUtils.ts

@@ -17,6 +17,8 @@
 export enum QUERY_BUILDER_HASH_STRUCTURE {
   // parameters state
   PARAMETERS_STATE = 'PARAMETERS_STATE',
+  CONSTANT_STATE = 'CONSTANT_STATE',
+  CONSTANT_EXPRESSION_STATE = 'CONSTANT_EXPRESSION_STATE',
 
   // projection state
   AGGREGATE_OPERATOR_AVERAGE = 'AGGREGATE_OPERATOR_AVERAGE',

package/src/stores/QueryBuilderConfig.ts

@@ -21,6 +21,7 @@ export enum QUERY_BUILDER_SOURCE_ID_LABEL {
 
 export const DEFAULT_LAMBDA_VARIABLE_NAME = 'x';
 export const DEFAULT_VARIABLE_NAME = 'var';
+export const DEFAULT_CONSTANT_VARIABLE_NAME = 'c_var';
 export const DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME = 'row';
 
 export const QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH = 5;

package/src/stores/QueryBuilderConstantsState.ts

@@ -0,0 +1,173 @@
+/**
+ * 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 Type,
+  type ValueSpecification,
+  GenericType,
+  GenericTypeExplicitReference,
+  observe_ValueSpecification,
+  VariableExpression,
+} from '@finos/legend-graph';
+import {
+  type Hashable,
+  hashArray,
+  deleteEntry,
+  addUniqueEntry,
+  IllegalStateError,
+  uuid,
+  assertErrorThrown,
+} from '@finos/legend-shared';
+import { action, makeObservable, observable } from 'mobx';
+import { QUERY_BUILDER_HASH_STRUCTURE } from '../graphManager/QueryBuilderHashUtils.js';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+import { buildDefaultInstanceValue } from './shared/ValueSpecificationEditorHelper.js';
+import { valueSpecification_setGenericType } from './shared/ValueSpecificationModifierHelper.js';
+
+export class QueryBuilderConstantExpressionState implements Hashable {
+  readonly queryBuilderState: QueryBuilderState;
+  readonly uuid = uuid();
+  variable: VariableExpression;
+  value: ValueSpecification;
+
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    variable: VariableExpression,
+    value: ValueSpecification,
+  ) {
+    makeObservable(this, {
+      variable: observable,
+      value: observable,
+      setValueSpec: action,
+      changeValSpecType: action,
+    });
+    this.queryBuilderState = queryBuilderState;
+    this.value = observe_ValueSpecification(
+      value,
+      this.queryBuilderState.observableContext,
+    );
+    observe_ValueSpecification(
+      variable,
+      this.queryBuilderState.observableContext,
+    );
+    this.variable = variable;
+  }
+
+  changeValSpecType(type: Type): void {
+    const variableType = this.value.genericType?.value.rawType;
+    if (variableType !== type) {
+      try {
+        const valSpec = buildDefaultInstanceValue(
+          this.queryBuilderState.graphManagerState.graph,
+          type,
+        );
+        this.setValueSpec(valSpec);
+      } catch (error) {
+        assertErrorThrown(error);
+        this.queryBuilderState.applicationStore.notifyError(error.message);
+      }
+    }
+  }
+
+  setValueSpec(value: ValueSpecification): void {
+    if (value instanceof VariableExpression) {
+      throw new IllegalStateError(
+        'Can not assign a parameter to another parameter',
+      );
+    }
+    this.value = observe_ValueSpecification(
+      value,
+      this.queryBuilderState.observableContext,
+    );
+    const valueSpecType = value.genericType?.value.rawType;
+    if (
+      valueSpecType &&
+      valueSpecType !== this.variable.genericType?.value.rawType
+    ) {
+      valueSpecification_setGenericType(
+        this.variable,
+        GenericTypeExplicitReference.create(new GenericType(valueSpecType)),
+      );
+    }
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.CONSTANT_EXPRESSION_STATE,
+      this.variable.name,
+      this.value,
+    ]);
+  }
+}
+
+export class QueryBuilderConstantsState implements Hashable {
+  readonly queryBuilderState: QueryBuilderState;
+  showConstantPanel = false;
+  constants: QueryBuilderConstantExpressionState[] = [];
+  selectedConstant: QueryBuilderConstantExpressionState | undefined;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    this.queryBuilderState = queryBuilderState;
+
+    makeObservable(this, {
+      constants: observable,
+      showConstantPanel: observable,
+      selectedConstant: observable,
+      addConstant: action,
+      removeConstant: action,
+      setShowConstantPanel: action,
+      setSelectedConstant: action,
+    });
+  }
+
+  get isEmpty(): boolean {
+    return !this.constants.length;
+  }
+
+  setShowConstantPanel(val: boolean): void {
+    this.showConstantPanel = val;
+  }
+
+  addConstant(val: QueryBuilderConstantExpressionState): void {
+    addUniqueEntry(this.constants, val);
+  }
+
+  removeConstant(val: QueryBuilderConstantExpressionState): void {
+    deleteEntry(this.constants, val);
+  }
+
+  setSelectedConstant(
+    val: QueryBuilderConstantExpressionState | undefined,
+  ): void {
+    this.selectedConstant = val;
+  }
+
+  isValueSpecConstant(value: ValueSpecification): boolean {
+    if (value instanceof VariableExpression) {
+      return Boolean(
+        this.constants.find((v) => v.variable.name === value.name),
+      );
+    }
+    return false;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.CONSTANT_STATE,
+      hashArray(this.constants),
+    ]);
+  }
+}

package/src/stores/QueryBuilderParametersState.ts

@@ -23,12 +23,6 @@ import {
   LambdaParametersState,
 } from './shared/LambdaParameterState.js';
 
-export const QUERY_BUILDER_PARAMETER_DND_TYPE = 'PARAMETER';
-
-export interface QueryBuilderParameterDragSource {
-  variable: LambdaParameterState;
-}
-
 export class QueryBuilderParametersState
   extends LambdaParametersState
   implements Hashable

package/src/stores/QueryBuilderPropertyEditorState.ts

@@ -38,21 +38,14 @@ import {
   EnumValueInstanceValue,
   InstanceValue,
   PrimitiveInstanceValue,
-  PRIMITIVE_TYPE,
+  type PRIMITIVE_TYPE,
   VariableExpression,
-  getMilestoneTemporalStereotype,
-  MILESTONING_STEREOTYPE,
   SimpleFunctionExpression,
   matchFunctionName,
   TYPE_CAST_TOKEN,
   observe_AbstractPropertyExpression,
   GenericTypeExplicitReference,
   GenericType,
-  BUSINESS_DATE_MILESTONING_PROPERTY_NAME,
-  PROCESSING_DATE_MILESTONING_PROPERTY_NAME,
-  INTERNAL__PropagatedValue,
-  Association,
-  getGeneratedMilestonedPropertiesForAssociation,
   PropertyExplicitReference,
   PrimitiveType,
 } from '@finos/legend-graph';
@@ -61,7 +54,6 @@ import {
   generateDefaultValueForPrimitiveType,
 } from './QueryBuilderValueSpecificationHelper.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
-import type { QueryBuilderMilestoningState } from './QueryBuilderMilestoningState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../graphManager/QueryBuilderHashUtils.js';
 import {
@@ -69,236 +61,11 @@ import {
   functionExpression_setParametersValues,
   instanceValue_setValues,
 } from './shared/ValueSpecificationModifierHelper.js';
-
-export const getDerivedPropertyMilestoningSteoreotype = (
-  property: DerivedProperty,
-  graph: PureModel,
-): MILESTONING_STEREOTYPE | undefined => {
-  const owner = property._OWNER;
-  if (owner instanceof Class) {
-    return getMilestoneTemporalStereotype(owner, graph);
-  } else if (owner instanceof Association) {
-    const generatedMilestonedProperties =
-      getGeneratedMilestonedPropertiesForAssociation(owner, property);
-    if (generatedMilestonedProperties.length) {
-      const ownerClass =
-        generatedMilestonedProperties[0]?.genericType.value.rawType;
-      return getMilestoneTemporalStereotype(
-        guaranteeType(ownerClass, Class),
-        graph,
-      );
-    }
-  }
-  return undefined;
-};
-
-/**
- * Check if the parameter value of the milestoned property is
- * the same as those specified in global scope, so that we can
- * potentially replace them with propgated value.
- */
-const matchMilestoningParameterValue = (
-  stereotype: MILESTONING_STEREOTYPE,
-  idx: number,
-  parameterValue: ValueSpecification,
-  milestoningDate: QueryBuilderMilestoningState,
-): boolean => {
-  const checkIfEquivalent = (
-    param1: ValueSpecification | undefined,
-    param2: ValueSpecification | undefined,
-  ): boolean => {
-    if (
-      param1 instanceof VariableExpression &&
-      param2 instanceof VariableExpression
-    ) {
-      return param1.name === param2.name;
-    } else if (
-      param1 instanceof PrimitiveInstanceValue &&
-      param2 instanceof PrimitiveInstanceValue
-    ) {
-      if (
-        param1.genericType.value.rawType.name === PRIMITIVE_TYPE.LATESTDATE &&
-        param2.genericType.value.rawType.name === PRIMITIVE_TYPE.LATESTDATE
-      ) {
-        return true;
-      }
-      return (
-        param1.genericType.value.rawType.name ===
-          param2.genericType.value.rawType.name &&
-        param1.values[0] === param2.values[0]
-      );
-    }
-    return false;
-  };
-  switch (stereotype) {
-    case MILESTONING_STEREOTYPE.BITEMPORAL:
-      return (
-        (idx === 0 &&
-          checkIfEquivalent(parameterValue, milestoningDate.processingDate)) ||
-        (idx === 1 &&
-          checkIfEquivalent(parameterValue, milestoningDate.businessDate))
-      );
-    case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL:
-      return checkIfEquivalent(parameterValue, milestoningDate.processingDate);
-    case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL:
-      return checkIfEquivalent(parameterValue, milestoningDate.businessDate);
-    default:
-  }
-  return false;
-};
+import { generateMilestonedPropertyParameterValue } from './milestoning/QueryBuilderMilestoningHelper.js';
 
 export const prettyPropertyName = (value: string): string =>
   isCamelCase(value) ? prettyCamelCase(value) : prettyCONSTName(value);
 
-/**
- * Generate a parameter value for the derived property given the index if the property is milestoned.
- *
- * This method considers different scenarios for milestoning and take into account date propagation
- * See https://github.com/finos/legend-studio/pull/891
- */
-export const generateMilestonedPropertyParameterValue = (
-  derivedPropertyExpressionState: QueryBuilderDerivedPropertyExpressionState,
-  idx: number,
-): ValueSpecification | undefined => {
-  // Milestoning transformations should not be done on actual derived properties.
-  if (
-    derivedPropertyExpressionState.derivedProperty._OWNER.derivedProperties.includes(
-      derivedPropertyExpressionState.derivedProperty,
-    )
-  ) {
-    return undefined;
-  }
-  const milestoningState =
-    derivedPropertyExpressionState.queryBuilderState.milestoningState;
-  const temporalSource = getDerivedPropertyMilestoningSteoreotype(
-    derivedPropertyExpressionState.derivedProperty,
-    derivedPropertyExpressionState.queryBuilderState.graphManagerState.graph,
-  );
-  const temporalTarget =
-    derivedPropertyExpressionState.propertyExpression.func.value.genericType
-      .value.rawType instanceof Class &&
-    derivedPropertyExpressionState.propertyExpression.func.value._OWNER
-      ._generatedMilestonedProperties.length !== 0
-      ? getMilestoneTemporalStereotype(
-          derivedPropertyExpressionState.propertyExpression.func.value
-            .genericType.value.rawType,
-          derivedPropertyExpressionState.queryBuilderState.graphManagerState
-            .graph,
-        )
-      : undefined;
-  const shouldReturnMilestoningParameter =
-    temporalTarget &&
-    ((idx < derivedPropertyExpressionState.parameterValues.length &&
-      (matchMilestoningParameterValue(
-        temporalTarget,
-        idx,
-        guaranteeNonNullable(
-          derivedPropertyExpressionState.parameterValues[idx],
-        ),
-        milestoningState,
-      ) ||
-        /**
-         * Checks if the given milestoning needs to be overwritten or not.
-         * Specially, we would need to rewrite the query if the user passes a single parameter
-         * to the `bitemporal` property expression with `processing temporal` source.
-         */
-        (getDerivedPropertyMilestoningSteoreotype(
-          derivedPropertyExpressionState.derivedProperty,
-          derivedPropertyExpressionState.queryBuilderState.graphManagerState
-            .graph,
-        ) === MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL &&
-          temporalTarget === MILESTONING_STEREOTYPE.BITEMPORAL &&
-          derivedPropertyExpressionState.parameterValues.length === 1))) ||
-      idx >= derivedPropertyExpressionState.parameterValues.length);
-
-  if (!shouldReturnMilestoningParameter) {
-    return undefined;
-  }
-
-  switch (temporalTarget) {
-    case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL: {
-      if (!milestoningState.businessDate) {
-        milestoningState.setBusinessDate(
-          derivedPropertyExpressionState.queryBuilderState.milestoningState.buildMilestoningParameter(
-            BUSINESS_DATE_MILESTONING_PROPERTY_NAME,
-          ),
-        );
-      }
-      const parameter = new INTERNAL__PropagatedValue(() =>
-        guaranteeNonNullable(milestoningState.businessDate),
-      );
-      return parameter;
-    }
-    case MILESTONING_STEREOTYPE.BITEMPORAL: {
-      if (!milestoningState.processingDate) {
-        milestoningState.setProcessingDate(
-          derivedPropertyExpressionState.queryBuilderState.milestoningState.buildMilestoningParameter(
-            PROCESSING_DATE_MILESTONING_PROPERTY_NAME,
-          ),
-        );
-      }
-      if (!milestoningState.businessDate) {
-        milestoningState.setBusinessDate(
-          derivedPropertyExpressionState.queryBuilderState.milestoningState.buildMilestoningParameter(
-            BUSINESS_DATE_MILESTONING_PROPERTY_NAME,
-          ),
-        );
-      }
-      if (idx === 0) {
-        if (
-          temporalSource === MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL &&
-          derivedPropertyExpressionState.parameterValues.length === 1
-        ) {
-          return guaranteeType(
-            derivedPropertyExpressionState.propertyExpression
-              .parametersValues[0],
-            AbstractPropertyExpression,
-          ).parametersValues[1];
-        }
-        const parameter = new INTERNAL__PropagatedValue(() =>
-          guaranteeNonNullable(milestoningState.processingDate),
-        );
-        return parameter;
-      } else {
-        if (
-          temporalSource === MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL &&
-          derivedPropertyExpressionState.parameterValues.length === 1
-        ) {
-          return derivedPropertyExpressionState.parameterValues[0];
-        } else if (
-          temporalSource === MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL &&
-          derivedPropertyExpressionState.parameterValues.length === 1
-        ) {
-          return guaranteeType(
-            derivedPropertyExpressionState.propertyExpression
-              .parametersValues[0],
-            AbstractPropertyExpression,
-          ).parametersValues[1];
-        }
-        const parameter = new INTERNAL__PropagatedValue(() =>
-          guaranteeNonNullable(milestoningState.businessDate),
-        );
-        return parameter;
-      }
-    }
-    case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL: {
-      if (!milestoningState.processingDate) {
-        milestoningState.setProcessingDate(
-          derivedPropertyExpressionState.queryBuilderState.milestoningState.buildMilestoningParameter(
-            PROCESSING_DATE_MILESTONING_PROPERTY_NAME,
-          ),
-        );
-      }
-      const parameter = new INTERNAL__PropagatedValue(() =>
-        guaranteeNonNullable(milestoningState.processingDate),
-      );
-      return parameter;
-    }
-    default:
-      return undefined;
-  }
-};
-
 export const getPropertyChainName = (
   propertyExpression: AbstractPropertyExpression,
   humanizePropertyName: boolean,
@@ -468,10 +235,12 @@ export class QueryBuilderDerivedPropertyExpressionState {
   readonly propertyExpression: AbstractPropertyExpression;
   readonly derivedProperty: DerivedProperty;
   readonly parameters: VariableExpression[] = [];
+  readonly propertyExpressionState: QueryBuilderPropertyExpressionState;
 
   constructor(
     queryBuilderState: QueryBuilderState,
     propertyExpression: AbstractPropertyExpression,
+    propertyExpressionState: QueryBuilderPropertyExpressionState,
   ) {
     this.path = getPropertyPath(propertyExpression);
     this.title = getPropertyChainName(propertyExpression, true);
@@ -484,6 +253,7 @@ export class QueryBuilderDerivedPropertyExpressionState {
       propertyExpression.func.value,
       DerivedProperty,
     );
+    this.propertyExpressionState = propertyExpressionState;
     // build the parameters of the derived properties
     if (Array.isArray(this.derivedProperty.parameters)) {
       this.parameters = this.derivedProperty.parameters.map((parameter) =>
@@ -625,6 +395,7 @@ export class QueryBuilderPropertyExpressionState implements Hashable {
           new QueryBuilderDerivedPropertyExpressionState(
             this.queryBuilderState,
             currentExpression,
+            this,
           );
         result.push(derivedPropertyExpressionState);
       }

package/src/stores/QueryBuilderState.ts

@@ -72,10 +72,11 @@ import { QueryBuilderParametersState } from './QueryBuilderParametersState.js';
 import type { QueryBuilderFilterOperator } from './filter/QueryBuilderFilterOperator.js';
 import { getQueryBuilderCoreFilterOperators } from './filter/QueryBuilderFilterOperatorLoader.js';
 import { QueryBuilderChangeDetectionState } from './QueryBuilderChangeDetectionState.js';
-import { QueryBuilderMilestoningState } from './QueryBuilderMilestoningState.js';
+import { QueryBuilderMilestoningState } from './milestoning/QueryBuilderMilestoningState.js';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../graphManager/QueryBuilderHashUtils.js';
 import { QUERY_BUILDER_COMMAND_KEY } from './QueryBuilderCommand.js';
 import { QueryBuilderWatermarkState } from './watermark/QueryBuilderWatermarkState.js';
+import { QueryBuilderConstantsState } from './QueryBuilderConstantsState.js';
 
 export abstract class QueryBuilderState implements CommandRegistrar {
   applicationStore: GenericLegendApplicationStore;
@@ -85,6 +86,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   explorerState: QueryBuilderExplorerState;
   functionsExplorerState: QueryFunctionsExplorerState;
   parametersState: QueryBuilderParametersState;
+  constantState: QueryBuilderConstantsState;
   milestoningState: QueryBuilderMilestoningState;
   fetchStructureState: QueryBuilderFetchStructureState;
   filterState: QueryBuilderFilterState;
@@ -116,6 +118,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     makeObservable(this, {
       explorerState: observable,
       parametersState: observable,
+      constantState: observable,
       functionsExplorerState: observable,
       fetchStructureState: observable,
       filterState: observable,
@@ -159,6 +162,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.milestoningState = new QueryBuilderMilestoningState(this);
     this.explorerState = new QueryBuilderExplorerState(this);
     this.parametersState = new QueryBuilderParametersState(this);
+    this.constantState = new QueryBuilderConstantsState(this);
     this.functionsExplorerState = new QueryFunctionsExplorerState(this);
     this.fetchStructureState = new QueryBuilderFetchStructureState(this);
     this.filterState = new QueryBuilderFilterState(this, this.filterOperators);
@@ -200,6 +204,20 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     return true;
   }
 
+  get allVariables(): VariableExpression[] {
+    const parameterVars = this.parametersState.parameterStates.map(
+      (paramState) => paramState.parameter,
+    );
+    const letVars = this.constantState.constants.map(
+      (letVar) => letVar.variable,
+    );
+    return [...parameterVars, ...letVars];
+  }
+
+  get allVariableNames(): string[] {
+    return this.allVariables.map((e) => e.name);
+  }
+
   setShowFunctionsExplorerPanel(val: boolean): void {
     this.showFunctionsExplorerPanel = val;
   }
@@ -258,6 +276,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.explorerState = new QueryBuilderExplorerState(this);
     this.explorerState.refreshTreeData();
     this.parametersState = new QueryBuilderParametersState(this);
+    this.constantState = new QueryBuilderConstantsState(this);
     this.functionsExplorerState = new QueryFunctionsExplorerState(this);
     this.filterState = new QueryBuilderFilterState(this, this.filterOperators);
     this.watermarkState = new QueryBuilderWatermarkState(this);
@@ -284,10 +303,12 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.milestoningState.updateMilestoningConfiguration();
   }
 
-  changeMapping(val: Mapping): void {
+  changeMapping(val: Mapping, options?: { keepQueryContent?: boolean }): void {
     this.resetQueryResult();
-    this.resetQueryContent();
-    this.milestoningState.updateMilestoningConfiguration();
+    if (!options?.keepQueryContent) {
+      this.resetQueryContent();
+      this.milestoningState.updateMilestoningConfiguration();
+    }
     this.setMapping(val);
   }