@finos/legend-query-builder 4.5.1 → 4.7.0

package/src/stores/QueryBuilderConstantsState.ts

@@ -21,6 +21,9 @@ import {
   GenericTypeExplicitReference,
   observe_ValueSpecification,
   VariableExpression,
+  buildSourceInformationSourceId,
+  ParserError,
+  GRAPH_MANAGER_EVENT,
 } from '@finos/legend-graph';
 import {
   type Hashable,
@@ -30,17 +33,48 @@ import {
   IllegalStateError,
   uuid,
   assertErrorThrown,
+  type GeneratorFn,
+  type PlainObject,
+  LogEvent,
+  changeEntry,
+  assertTrue,
 } from '@finos/legend-shared';
 import { action, makeObservable, observable } from 'mobx';
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from './QueryBuilderStateHashUtils.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
-import { buildDefaultInstanceValue } from './shared/ValueSpecificationEditorHelper.js';
+import {
+  buildDefaultEmptyStringRawLambda,
+  buildDefaultInstanceValue,
+} from './shared/ValueSpecificationEditorHelper.js';
 import { valueSpecification_setGenericType } from './shared/ValueSpecificationModifierHelper.js';
+import { LambdaEditorState } from './shared/LambdaEditorState.js';
+import { QUERY_BUILDER_SOURCE_ID_LABEL } from './QueryBuilderConfig.js';
 
-export class QueryBuilderConstantExpressionState implements Hashable {
+export abstract class QueryBuilderConstantExpressionState implements Hashable {
   readonly queryBuilderState: QueryBuilderState;
   readonly uuid = uuid();
   variable: VariableExpression;
+
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    variable: VariableExpression,
+  ) {
+    this.queryBuilderState = queryBuilderState;
+    this.variable = variable;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.CONSTANT_EXPRESSION_STATE,
+      this.variable.name,
+    ]);
+  }
+}
+
+export class QueryBuilderSimpleConstantExpressionState
+  extends QueryBuilderConstantExpressionState
+  implements Hashable
+{
   value: ValueSpecification;
 
   constructor(
@@ -48,13 +82,13 @@ export class QueryBuilderConstantExpressionState implements Hashable {
     variable: VariableExpression,
     value: ValueSpecification,
   ) {
+    super(queryBuilderState, variable);
     makeObservable(this, {
       variable: observable,
       value: observable,
       setValueSpec: action,
       changeValSpecType: action,
     });
-    this.queryBuilderState = queryBuilderState;
     this.value = observe_ValueSpecification(
       value,
       this.queryBuilderState.observerContext,
@@ -63,7 +97,6 @@ export class QueryBuilderConstantExpressionState implements Hashable {
       variable,
       this.queryBuilderState.observerContext,
     );
-    this.variable = variable;
   }
 
   changeValSpecType(type: Type): void {
@@ -107,7 +140,7 @@ export class QueryBuilderConstantExpressionState implements Hashable {
     }
   }
 
-  get hashCode(): string {
+  override get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.CONSTANT_EXPRESSION_STATE,
       this.variable.name,
@@ -116,6 +149,119 @@ export class QueryBuilderConstantExpressionState implements Hashable {
   }
 }
 
+export class QueryBuilderConstantLambdaEditorState extends LambdaEditorState {
+  readonly queryBuilderState: QueryBuilderState;
+  calculatedState: QueryBuilderCalculatedConstantExpressionState;
+  constructor(calculatedState: QueryBuilderCalculatedConstantExpressionState) {
+    super('', '');
+    makeObservable(this, {
+      calculatedState: observable,
+      buildEmptyValueSpec: observable,
+    });
+    this.calculatedState = calculatedState;
+    this.queryBuilderState = calculatedState.queryBuilderState;
+  }
+
+  buildEmptyValueSpec(): PlainObject {
+    return this.queryBuilderState.graphManagerState.graphManager.serializeRawValueSpecification(
+      buildDefaultEmptyStringRawLambda(
+        this.queryBuilderState.graphManagerState,
+        this.queryBuilderState.observerContext,
+      ),
+    );
+  }
+
+  get lambdaId(): string {
+    return buildSourceInformationSourceId([
+      // TODO: to be reworked
+      // See https://github.com/finos/legend-studio/issues/1168
+      QUERY_BUILDER_SOURCE_ID_LABEL.QUERY_BUILDER,
+      QUERY_BUILDER_SOURCE_ID_LABEL.CONSTANT,
+      this.calculatedState.uuid,
+    ]);
+  }
+
+  override *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
+    if (this.lambdaString) {
+      try {
+        const valSpec =
+          (yield this.queryBuilderState.graphManagerState.graphManager.pureCodeToValueSpecification(
+            this.fullLambdaString,
+          )) as PlainObject<ValueSpecification>;
+        this.setParserError(undefined);
+        this.calculatedState.setValue(valSpec);
+      } catch (error) {
+        assertErrorThrown(error);
+        if (error instanceof ParserError) {
+          this.setParserError(error);
+        }
+        this.queryBuilderState.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.calculatedState.setValue(this.buildEmptyValueSpec());
+    }
+  }
+  override *convertLambdaObjectToGrammarString(
+    options?:
+      | {
+          pretty?: boolean | undefined;
+          preserveCompilationError?: boolean | undefined;
+        }
+      | undefined,
+  ): GeneratorFn<void> {
+    try {
+      const value = this.calculatedState.value;
+      const grammarText =
+        (yield this.queryBuilderState.graphManagerState.graphManager.valueSpecificationToPureCode(
+          value,
+          options?.pretty,
+        )) as string;
+      this.setLambdaString(grammarText);
+      this.clearErrors({
+        preserveCompilationError: options?.preserveCompilationError,
+      });
+    } catch (error) {
+      assertErrorThrown(error);
+      this.queryBuilderState.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+        error,
+      );
+    }
+  }
+}
+
+export class QueryBuilderCalculatedConstantExpressionState
+  extends QueryBuilderConstantExpressionState
+  implements Hashable
+{
+  value: PlainObject;
+  lambdaState: QueryBuilderConstantLambdaEditorState;
+
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    variable: VariableExpression,
+    value: PlainObject,
+  ) {
+    super(queryBuilderState, variable);
+    makeObservable(this, {
+      variable: observable,
+      lambdaState: observable,
+      value: observable,
+      setValue: action,
+    });
+    this.value = value;
+    this.lambdaState = new QueryBuilderConstantLambdaEditorState(this);
+  }
+
+  setValue(val: PlainObject): void {
+    this.value = val;
+  }
+}
+
 export class QueryBuilderConstantsState implements Hashable {
   readonly queryBuilderState: QueryBuilderState;
   showConstantPanel = false;
@@ -133,6 +279,7 @@ export class QueryBuilderConstantsState implements Hashable {
       removeConstant: action,
       setShowConstantPanel: action,
       setSelectedConstant: action,
+      convertToCalculated: action,
     });
   }
 
@@ -167,6 +314,29 @@ export class QueryBuilderConstantsState implements Hashable {
     return false;
   }
 
+  convertToCalculated(val: QueryBuilderSimpleConstantExpressionState): void {
+    try {
+      const content =
+        this.queryBuilderState.graphManagerState.graphManager.serializeValueSpecification(
+          val.value,
+        );
+      const constantState = new QueryBuilderCalculatedConstantExpressionState(
+        this.queryBuilderState,
+        val.variable,
+        content,
+      );
+      assertTrue(
+        changeEntry(this.constants, val, constantState),
+        'Unable to convert to calculated constant',
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.queryBuilderState.applicationStore.notificationService.notifyError(
+        error,
+      );
+    }
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.CONSTANT_STATE,

package/src/stores/QueryBuilderStateBuilder.ts

@@ -31,7 +31,7 @@ import {
   type GraphFetchTreeInstanceValue,
   type ValueSpecificationVisitor,
   InstanceValue,
-  type INTERNAL__UnknownValueSpecification,
+  INTERNAL__UnknownValueSpecification,
   type LambdaFunction,
   type KeyExpressionInstanceValue,
   matchFunctionName,
@@ -81,7 +81,11 @@ import {
 import { LambdaParameterState } from './shared/LambdaParameterState.js';
 import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/window/QueryBuilderWindowStateBuilder.js';
 import { processWatermarkExpression } from './watermark/QueryBuilderWatermarkStateBuilder.js';
-import { QueryBuilderConstantExpressionState } from './QueryBuilderConstantsState.js';
+import {
+  type QueryBuilderConstantExpressionState,
+  QueryBuilderCalculatedConstantExpressionState,
+  QueryBuilderSimpleConstantExpressionState,
+} from './QueryBuilderConstantsState.js';
 import { checkIfEquivalent } from './milestoning/QueryBuilderMilestoningHelper.js';
 import type { QueryBuilderParameterValue } from './QueryBuilderParametersState.js';
 import { QueryBuilderEmbeddedFromExecutionContextState } from './QueryBuilderExecutionContextState.js';
@@ -143,12 +147,20 @@ const processLetExpression = (
   );
   // process right side (value)
   const rightSide = guaranteeNonNullable(parameters[1]);
-  // final
-  const constantExpression = new QueryBuilderConstantExpressionState(
-    queryBuilderState,
-    varExp,
-    rightSide,
-  );
+  let constantExpression: QueryBuilderConstantExpressionState;
+  if (rightSide instanceof INTERNAL__UnknownValueSpecification) {
+    constantExpression = new QueryBuilderCalculatedConstantExpressionState(
+      queryBuilderState,
+      varExp,
+      rightSide.content,
+    );
+  } else {
+    constantExpression = new QueryBuilderSimpleConstantExpressionState(
+      queryBuilderState,
+      varExp,
+      rightSide,
+    );
+  }
   queryBuilderState.constantState.setShowConstantPanel(true);
   queryBuilderState.constantState.addConstant(constantExpression);
 };

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -14,9 +14,14 @@
  * limitations under the License.
  */
 
-import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
+import {
+  UnsupportedOperationError,
+  guaranteeNonNullable,
+  guaranteeType,
+} from '@finos/legend-shared';
 import {
   type Class,
+  type ValueSpecification,
   Multiplicity,
   getMilestoneTemporalStereotype,
   extractElementNameFromPath,
@@ -32,6 +37,7 @@ import {
   PrimitiveType,
   SUPPORTED_FUNCTIONS,
   RuntimePointer,
+  INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import { buildFilterExpression } from './filter/QueryBuilderFilterValueSpecificationBuilder.js';
@@ -40,7 +46,11 @@ import type { QueryBuilderFetchStructureState } from './fetch-structure/QueryBui
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graph/QueryBuilderMetaModelConst.js';
 import { buildWatermarkExpression } from './watermark/QueryBuilderWatermarkValueSpecificationBuilder.js';
 import { buildExecutionQueryFromLambdaFunction } from './shared/LambdaParameterState.js';
-import type { QueryBuilderConstantExpressionState } from './QueryBuilderConstantsState.js';
+import {
+  QueryBuilderSimpleConstantExpressionState,
+  type QueryBuilderConstantExpressionState,
+  QueryBuilderCalculatedConstantExpressionState,
+} from './QueryBuilderConstantsState.js';
 import {
   QueryBuilderEmbeddedFromExecutionContextState,
   type QueryBuilderExecutionContextState,
@@ -84,7 +94,6 @@ const buildLetExpression = (
   constantExpressionState: QueryBuilderConstantExpressionState,
 ): SimpleFunctionExpression => {
   const varName = constantExpressionState.variable.name;
-  const value = constantExpressionState.value;
   const leftSide = new PrimitiveInstanceValue(
     GenericTypeExplicitReference.create(new GenericType(PrimitiveType.STRING)),
   );
@@ -92,6 +101,25 @@ const buildLetExpression = (
   const letFunc = new SimpleFunctionExpression(
     extractElementNameFromPath(SUPPORTED_FUNCTIONS.LET),
   );
+  let value: ValueSpecification;
+  if (
+    constantExpressionState instanceof QueryBuilderSimpleConstantExpressionState
+  ) {
+    value = constantExpressionState.value;
+  } else if (
+    constantExpressionState instanceof
+    QueryBuilderCalculatedConstantExpressionState
+  ) {
+    value = new INTERNAL__UnknownValueSpecification(
+      constantExpressionState.value,
+    );
+  } else {
+    throw new UnsupportedOperationError(
+      `Can't build let() expression: unsupported constant state`,
+      constantExpressionState,
+    );
+  }
+
   letFunc.parametersValues = [leftSide, value];
   return letFunc;
 };