@finos/legend-query-builder 1.0.3 → 1.0.5

package/src/graphManager/QueryBuilderSupportedFunctions.ts

@@ -24,6 +24,7 @@ export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
   OR = 'meta::pure::functions::boolean::or',
   TAKE = 'meta::pure::functions::collection::take',
   SUBTYPE = 'meta::pure::functions::lang::subType',
+  MINUS = 'meta::pure::functions::math::minus',
 
   // graph-fetch
   GRAPH_FETCH = 'meta::pure::graphFetch::execution::graphFetch',
@@ -53,6 +54,7 @@ export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
   LESS_THAN = 'meta::pure::functions::lang::tests::lessThan',
   LESS_THAN_EQUAL = 'meta::pure::functions::lang::tests::lessThanEqual',
   STARTS_WITH = 'meta::pure::functions::string::startsWith',
+
   // aggregation
   AVERAGE = 'meta::pure::functions::math::average',
   COUNT = 'meta::pure::functions::collection::count',
@@ -66,8 +68,10 @@ export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
   STD_DEV_SAMPLE = 'meta::pure::functions::math::stdDevSample',
   SUM = 'meta::pure::functions::math::sum',
   UNIQUE_VALUE_ONLY = 'meta::pure::functions::collection::uniqueValueOnly',
+
   // watermark
   WATERMARK = 'meta::datalake::functions::forWatermark',
+
   // OLAP
   OLAP_GROUPBY = 'meta::pure::tds::olapGroupBy',
   OLAP_RANK = 'meta::pure::functions::math::olap::rank',

package/src/graphManager/protocol/pure/QueryBuilder_PureProtocolProcessorPlugin.ts

@@ -57,7 +57,7 @@ export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProces
         openVariables: string[],
         compileContext: V1_GraphBuilderContext,
         processingContext: V1_ProcessingContext,
-      ): [SimpleFunctionExpression, ValueSpecification[]] | undefined => {
+      ): SimpleFunctionExpression | undefined => {
         if (
           matchFunctionName(
             functionName,

package/src/graphManager/protocol/pure/v1/V1_QueryValueSpecificationBuilderHelper.ts

@@ -201,8 +201,8 @@ export const V1_buildGetAllFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] => {
-  const [expression, processedParams] = V1_buildGenericFunctionExpression(
+): SimpleFunctionExpression => {
+  const expression = V1_buildGenericFunctionExpression(
     functionName,
     parameters,
     openVariables,
@@ -218,7 +218,8 @@ export const V1_buildGetAllFunctionExpression = (
   );
   expression.genericType = precedingExpression.genericType;
   expression.multiplicity = precedingExpression.multiplicity;
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildExistsFunctionExpression = (
@@ -227,7 +228,7 @@ export const V1_buildExistsFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] => {
+): SimpleFunctionExpression => {
   assertTrue(
     parameters.length === 2,
     `Can't build exists() expression: exists() expects 1 argument`,
@@ -262,22 +263,21 @@ export const V1_buildExistsFunctionExpression = (
       }
     });
   }
-  const processedParameters = [
-    precedingExpression,
-    (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
-      new V1_ValueSpecificationBuilder(
-        compileContext,
-        processingContext,
-        openVariables,
+
+  return V1_buildBaseSimpleFunctionExpression(
+    [
+      precedingExpression,
+      (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+        new V1_ValueSpecificationBuilder(
+          compileContext,
+          processingContext,
+          openVariables,
+        ),
       ),
-    ),
-  ];
-  const expression = V1_buildBaseSimpleFunctionExpression(
-    processedParameters,
+    ],
     functionName,
     compileContext,
   );
-  return [expression, processedParameters];
 };
 
 export const V1_buildFilterFunctionExpression = (
@@ -286,7 +286,7 @@ export const V1_buildFilterFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] => {
+): SimpleFunctionExpression => {
   assertTrue(
     parameters.length === 2,
     `Can't build filter() expression: filter() expects 1 argument`,
@@ -318,19 +318,18 @@ export const V1_buildFilterFunctionExpression = (
       });
     }
   }
-  const processedParams = [
-    precedingExpression,
-    (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
-      new V1_ValueSpecificationBuilder(
-        compileContext,
-        processingContext,
-        openVariables,
-      ),
-    ),
-  ];
 
   const expression = V1_buildBaseSimpleFunctionExpression(
-    processedParams,
+    [
+      precedingExpression,
+      (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+        new V1_ValueSpecificationBuilder(
+          compileContext,
+          processingContext,
+          openVariables,
+        ),
+      ),
+    ],
     functionName,
     compileContext,
   );
@@ -338,7 +337,8 @@ export const V1_buildFilterFunctionExpression = (
   // return type of filter() is the same as that of the function precedes it
   expression.genericType = precedingExpression.genericType;
   expression.multiplicity = precedingExpression.multiplicity;
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildProjectFunctionExpression = (
@@ -347,7 +347,7 @@ export const V1_buildProjectFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] => {
+): SimpleFunctionExpression => {
   assertTrue(
     parameters.length === 3,
     `Can't build project() expression: project() expects 2 arguments`,
@@ -417,26 +417,26 @@ export const V1_buildProjectFunctionExpression = (
     }
   });
 
-  const processedParams = [
-    precedingExperession,
-    processedColumnExpressions,
-    (parameters[2] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
-      new V1_ValueSpecificationBuilder(
-        compileContext,
-        processingContext,
-        openVariables,
-      ),
-    ),
-  ];
   const expression = V1_buildBaseSimpleFunctionExpression(
-    processedParams,
+    [
+      precedingExperession,
+      processedColumnExpressions,
+      (parameters[2] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+        new V1_ValueSpecificationBuilder(
+          compileContext,
+          processingContext,
+          openVariables,
+        ),
+      ),
+    ],
     functionName,
     compileContext,
   );
   expression.genericType = GenericTypeExplicitReference.create(
     new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
   );
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildGroupByFunctionExpression = (
@@ -445,7 +445,7 @@ export const V1_buildGroupByFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] => {
+): SimpleFunctionExpression => {
   let topLevelLambdaParameters: V1_Variable[] = [];
   assertTrue(
     parameters.length === 4,
@@ -557,27 +557,27 @@ export const V1_buildGroupByFunctionExpression = (
       ),
   );
 
-  const processedParams = [
-    precedingExperession,
-    processedColumnExpressions,
-    processedAggregationExpressions,
-    (parameters[3] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
-      new V1_ValueSpecificationBuilder(
-        compileContext,
-        processingContext,
-        openVariables,
-      ),
-    ),
-  ];
   const expression = V1_buildBaseSimpleFunctionExpression(
-    processedParams,
+    [
+      precedingExperession,
+      processedColumnExpressions,
+      processedAggregationExpressions,
+      (parameters[3] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+        new V1_ValueSpecificationBuilder(
+          compileContext,
+          processingContext,
+          openVariables,
+        ),
+      ),
+    ],
     functionName,
     compileContext,
   );
   expression.genericType = GenericTypeExplicitReference.create(
     new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
   );
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildWatermarkFunctionExpression = (
@@ -586,7 +586,7 @@ export const V1_buildWatermarkFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] | undefined => {
+): SimpleFunctionExpression | undefined => {
   assertTrue(
     parameters.length === 2,
     `Can't build forWatermark() expression: forWatermark() expects 1 argument`,
@@ -622,8 +622,7 @@ export const V1_buildWatermarkFunctionExpression = (
     });
   }
 
-  const processedParams = [
-    precedingExpression,
+  const watermarkValueParam = guaranteeNonNullable(
     (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
       new V1_ValueSpecificationBuilder(
         compileContext,
@@ -631,9 +630,7 @@ export const V1_buildWatermarkFunctionExpression = (
         openVariables,
       ),
     ),
-  ];
-
-  const watermarkValueParam = guaranteeNonNullable(processedParams[1]);
+  );
   const watermarkValueParamType =
     watermarkValueParam.genericType?.value.rawType;
   assertTrue(
@@ -642,14 +639,15 @@ export const V1_buildWatermarkFunctionExpression = (
   );
 
   const expression = V1_buildBaseSimpleFunctionExpression(
-    processedParams,
+    [precedingExpression, watermarkValueParam],
     functionName,
     compileContext,
   );
 
   expression.genericType = precedingExpression.genericType;
   expression.multiplicity = precedingExpression.multiplicity;
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildOLAPGroupByFunctionExpression = (
@@ -658,7 +656,7 @@ export const V1_buildOLAPGroupByFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] | undefined => {
+): SimpleFunctionExpression | undefined => {
   const processedParams: ValueSpecification[] = [];
   assertTrue(
     parameters.length === 5 || parameters.length === 4,
@@ -778,7 +776,8 @@ export const V1_buildOLAPGroupByFunctionExpression = (
   expression.genericType = GenericTypeExplicitReference.create(
     new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
   );
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildSubTypePropertyExpressionTypeInference = (

package/src/stores/QueryBuilderChangeDetectionState.ts

@@ -91,17 +91,19 @@ export class QueryBuilderDiffViewState {
 }
 
 export class QueryBuilderChangeDetectionState {
-  querybuilderState: QueryBuilderState;
-  initState = ActionState.create();
+  readonly querybuilderState: QueryBuilderState;
+
+  readonly initState = ActionState.create();
+
+  querySnapshot?: RawLambda | undefined;
+  hashCodeSnapshot?: string | undefined;
   diffViewState?: QueryBuilderDiffViewState | undefined;
-  initialQuery?: RawLambda | undefined;
-  initialHashCode?: string | undefined;
 
   constructor(queryBuilderState: QueryBuilderState) {
     makeObservable(this, {
       diffViewState: observable,
-      initialHashCode: observable,
-      initialQuery: observable,
+      querySnapshot: observable,
+      hashCodeSnapshot: observable,
       hasChanged: computed,
       initialize: action,
       showDiffViewPanel: action,
@@ -113,12 +115,12 @@ export class QueryBuilderChangeDetectionState {
 
   showDiffViewPanel(): void {
     assertNonNullable(
-      this.initialQuery,
+      this.querySnapshot,
       `Can't show changes: change detection is not properly initialized`,
     );
     this.diffViewState = new QueryBuilderDiffViewState(
       this,
-      this.initialQuery,
+      this.querySnapshot,
       this.querybuilderState.buildQuery(),
     );
   }
@@ -131,13 +133,13 @@ export class QueryBuilderChangeDetectionState {
     if (!this.initState.hasCompleted) {
       return false;
     }
-    return this.querybuilderState.hashCode !== this.initialHashCode;
+    return this.querybuilderState.hashCode !== this.hashCodeSnapshot;
   }
 
   initialize(initialQuery: RawLambda): void {
     this.initState.inProgress();
-    this.initialHashCode = this.querybuilderState.hashCode;
-    this.initialQuery = initialQuery;
+    this.hashCodeSnapshot = this.querybuilderState.hashCode;
+    this.querySnapshot = initialQuery;
     this.initState.complete();
   }
 

package/src/stores/QueryBuilderConstantsState.ts

@@ -57,11 +57,11 @@ export class QueryBuilderConstantExpressionState implements Hashable {
     this.queryBuilderState = queryBuilderState;
     this.value = observe_ValueSpecification(
       value,
-      this.queryBuilderState.observableContext,
+      this.queryBuilderState.observerContext,
     );
     observe_ValueSpecification(
       variable,
-      this.queryBuilderState.observableContext,
+      this.queryBuilderState.observerContext,
     );
     this.variable = variable;
   }
@@ -73,6 +73,7 @@ export class QueryBuilderConstantExpressionState implements Hashable {
         const valSpec = buildDefaultInstanceValue(
           this.queryBuilderState.graphManagerState.graph,
           type,
+          this.queryBuilderState.observerContext,
         );
         this.setValueSpec(valSpec);
       } catch (error) {
@@ -92,7 +93,7 @@ export class QueryBuilderConstantExpressionState implements Hashable {
     }
     this.value = observe_ValueSpecification(
       value,
-      this.queryBuilderState.observableContext,
+      this.queryBuilderState.observerContext,
     );
     const valueSpecType = value.genericType?.value.rawType;
     if (

package/src/stores/QueryBuilderPropertyEditorState.ts

@@ -21,8 +21,6 @@ import {
   guaranteeType,
   type Hashable,
   hashArray,
-  isCamelCase,
-  prettyCamelCase,
   prettyCONSTName,
 } from '@finos/legend-shared';
 import {
@@ -48,6 +46,7 @@ import {
   GenericType,
   PropertyExplicitReference,
   PrimitiveType,
+  type ObserverContext,
 } from '@finos/legend-graph';
 import {
   createNullishValue,
@@ -63,15 +62,12 @@ import {
 } from './shared/ValueSpecificationModifierHelper.js';
 import { generateMilestonedPropertyParameterValue } from './milestoning/QueryBuilderMilestoningHelper.js';
 
-export const prettyPropertyName = (value: string): string =>
-  isCamelCase(value) ? prettyCamelCase(value) : prettyCONSTName(value);
-
 export const getPropertyChainName = (
   propertyExpression: AbstractPropertyExpression,
   humanizePropertyName: boolean,
 ): string => {
   const propertyNameDecorator = humanizePropertyName
-    ? prettyPropertyName
+    ? prettyCONSTName
     : (val: string): string => val;
   const chunks = [propertyNameDecorator(propertyExpression.func.value.name)];
   let currentExpression: ValueSpecification | undefined = propertyExpression;
@@ -146,6 +142,7 @@ export const getPropertyPath = (
 export const generateValueSpecificationForParameter = (
   parameter: VariableExpression,
   graph: PureModel,
+  observerContext: ObserverContext,
 ): ValueSpecification => {
   if (parameter.genericType) {
     const type = parameter.genericType.value.rawType;
@@ -161,9 +158,11 @@ export const generateValueSpecificationForParameter = (
         ),
       );
       if (type !== PrimitiveType.LATESTDATE) {
-        instanceValue_setValues(primitiveInstanceValue, [
-          generateDefaultValueForPrimitiveType(type.name as PRIMITIVE_TYPE),
-        ]);
+        instanceValue_setValues(
+          primitiveInstanceValue,
+          [generateDefaultValueForPrimitiveType(type.name as PRIMITIVE_TYPE)],
+          observerContext,
+        );
       }
       return primitiveInstanceValue;
     } else if (type instanceof Enumeration) {
@@ -174,7 +173,11 @@ export const generateValueSpecificationForParameter = (
         const enumValueRef = EnumValueExplicitReference.create(
           type.values[0] as Enum,
         );
-        instanceValue_setValues(enumValueInstanceValue, [enumValueRef]);
+        instanceValue_setValues(
+          enumValueInstanceValue,
+          [enumValueRef],
+          observerContext,
+        );
       }
       return enumValueInstanceValue;
     }
@@ -213,6 +216,7 @@ const fillDerivedPropertyParameterValues = (
           parameter,
           derivedPropertyExpressionState.queryBuilderState.graphManagerState
             .graph,
+          derivedPropertyExpressionState.queryBuilderState.observerContext,
         ),
     );
   });
@@ -224,7 +228,7 @@ const fillDerivedPropertyParameterValues = (
       ),
       ...parameterValues,
     ],
-    derivedPropertyExpressionState.queryBuilderState.observableContext,
+    derivedPropertyExpressionState.queryBuilderState.observerContext,
   );
 };
 
@@ -246,7 +250,7 @@ export class QueryBuilderDerivedPropertyExpressionState {
     this.title = getPropertyChainName(propertyExpression, true);
     this.propertyExpression = observe_AbstractPropertyExpression(
       propertyExpression,
-      queryBuilderState.observableContext,
+      queryBuilderState.observerContext,
     );
     this.queryBuilderState = queryBuilderState;
     this.derivedProperty = guaranteeType(
@@ -341,7 +345,7 @@ export class QueryBuilderPropertyExpressionState implements Hashable {
     this.queryBuilderState = queryBuilderState;
     this.propertyExpression = observe_AbstractPropertyExpression(
       propertyExpression,
-      queryBuilderState.observableContext,
+      queryBuilderState.observerContext,
     );
     this.path = getPropertyPath(propertyExpression);
     this.title = getPropertyChainName(propertyExpression, true);

package/src/stores/QueryBuilderState.ts

@@ -86,7 +86,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
 
   readonly changeDetectionState: QueryBuilderChangeDetectionState;
   readonly queryCompileState = ActionState.create();
-  readonly observableContext: ObserverContext;
+  readonly observerContext: ObserverContext;
 
   explorerState: QueryBuilderExplorerState;
   functionsExplorerState: QueryFunctionsExplorerState;
@@ -183,7 +183,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.resultState = new QueryBuilderResultState(this);
     this.textEditorState = new QueryBuilderTextEditorState(this);
     this.unsupportedQueryState = new QueryBuilderUnsupportedQueryState(this);
-    this.observableContext = new ObserverContext(
+    this.observerContext = new ObserverContext(
       this.graphManagerState.pluginManager.getPureGraphManagerPlugins(),
     );
     this.changeDetectionState = new QueryBuilderChangeDetectionState(this);
@@ -295,10 +295,10 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     );
   }
 
-  resetQueryResult(preserveResult?: boolean): void {
+  resetQueryResult(options?: { preserveResult?: boolean | undefined }): void {
     const resultState = new QueryBuilderResultState(this);
     resultState.setPreviewLimit(this.resultState.previewLimit);
-    if (preserveResult) {
+    if (options?.preserveResult) {
       resultState.setExecutionResult(this.resultState.executionResult);
       resultState.setExecutionDuration(this.resultState.executionDuration);
       resultState.latestRunHashCode = this.resultState.latestRunHashCode;
@@ -408,7 +408,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
           previousStateParameterValues.set(ps.parameter, ps.value);
         });
       }
-      this.resetQueryResult(options?.preserveResult);
+      this.resetQueryResult({ preserveResult: options?.preserveResult });
       this.resetQueryContent();
 
       if (!isStubbed_RawLambda(query)) {
@@ -419,7 +419,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
             ),
             this.graphManagerState.graph,
           ),
-          this.observableContext,
+          this.observerContext,
         );
         const compiledValueSpecification = guaranteeType(
           valueSpec,
@@ -446,9 +446,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
         query,
         this.graphManagerState,
       )
-        .map((param) =>
-          observe_ValueSpecification(param, this.observableContext),
-        )
+        .map((param) => observe_ValueSpecification(param, this.observerContext))
         .filter(filterByType(VariableExpression));
       processParameters(parameters, this);
     }

package/src/stores/QueryBuilderStateBuilder.ts

@@ -607,27 +607,25 @@ export class QueryBuilderValueSpecificationProcessor
 export const processParameters = (
   parameters: VariableExpression[],
   queryBuilderState: QueryBuilderState,
-  preservedParameters?: Map<VariableExpression, ValueSpecification | undefined>,
+  parameterValues?: Map<VariableExpression, ValueSpecification | undefined>,
 ): void => {
   const queryParameterState = queryBuilderState.parametersState;
-  // Here we won't mock the values for parameters which are present in the previous state
-  // because we don't want to lose the parameter value
   parameters.forEach((parameter) => {
-    let oldParamterValue: ValueSpecification | undefined;
-    if (preservedParameters) {
-      Array.from(preservedParameters.entries()).forEach(([key, value]) => {
+    let matchingParameterValue: ValueSpecification | undefined;
+    if (parameterValues) {
+      Array.from(parameterValues.entries()).forEach(([key, value]) => {
         if (checkIfEquivalent(key, parameter)) {
-          oldParamterValue = value;
+          matchingParameterValue = value;
         }
       });
     }
     const parameterState = new LambdaParameterState(
       parameter,
-      queryBuilderState.observableContext,
+      queryBuilderState.observerContext,
       queryBuilderState.graphManagerState.graph,
     );
-    if (oldParamterValue) {
-      parameterState.setValue(oldParamterValue);
+    if (matchingParameterValue) {
+      parameterState.setValue(matchingParameterValue);
     } else {
       parameterState.mockParameterValue();
     }
@@ -639,13 +637,13 @@ export const processParameters = (
 export const processQueryLambdaFunction = (
   lambdaFunction: LambdaFunction,
   queryBuilderState: QueryBuilderState,
-  preservedParameters?: Map<VariableExpression, ValueSpecification | undefined>,
+  parameterValues?: Map<VariableExpression, ValueSpecification | undefined>,
 ): void => {
   if (lambdaFunction.functionType.parameters.length) {
     processParameters(
       lambdaFunction.functionType.parameters,
       queryBuilderState,
-      preservedParameters,
+      parameterValues,
     );
   }
   lambdaFunction.expressionSequence.map((expression) =>

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -114,7 +114,7 @@ export const buildPropertyExpressionChain = (
           functionExpression_setParametersValues(
             currentExpression,
             [guaranteeNonNullable(currentExpression.parametersValues[0])],
-            queryBuilderState.observableContext,
+            queryBuilderState.observerContext,
           );
         }
       } else {

package/src/stores/QueryBuilderValueSpecificationHelper.ts

@@ -44,6 +44,8 @@ import {
   GenericTypeExplicitReference,
   GenericType,
   INTERNAL__PropagatedValue,
+  isSubType,
+  type ObserverContext,
 } from '@finos/legend-graph';
 import {
   addUniqueEntry,
@@ -59,6 +61,7 @@ import {
   getDerivedPropertyMilestoningSteoreotype,
   validateMilestoningPropertyExpressionChain,
 } from './milestoning/QueryBuilderMilestoningHelper.js';
+import { instanceValue_setValues } from './shared/ValueSpecificationModifierHelper.js';
 
 export const getNonCollectionValueSpecificationType = (
   valueSpecification: ValueSpecification,
@@ -355,3 +358,36 @@ export const isValueExpressionReferencedInValue = (
   }
   return false;
 };
+
+/**
+ * Some expression which represents a value and can be simplified to make
+ * editing experience easier
+ *
+ * e.g. -5 is often represented as minus(5), which is a function expression
+ * but we want to simplify it to a primitive instance value with value -5
+ */
+export const simplifyValueExpression = (
+  value: ValueSpecification,
+  observerContext: ObserverContext,
+): ValueSpecification => {
+  if (
+    value instanceof SimpleFunctionExpression &&
+    matchFunctionName(
+      value.functionName,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.MINUS,
+    ) &&
+    value.parametersValues.length === 1 &&
+    value.parametersValues[0] instanceof PrimitiveInstanceValue
+  ) {
+    const val = value.parametersValues[0];
+    if (isSubType(val.genericType.value.rawType, PrimitiveType.NUMBER)) {
+      instanceValue_setValues(
+        val,
+        [(val.values[0] as number) * -1],
+        observerContext,
+      );
+    }
+    return val;
+  }
+  return value;
+};