@finos/legend-graph 31.1.10 → 31.2.1

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/to/helpers/V1_ValueSpecificationBuilderHelper.ts

@@ -21,6 +21,7 @@ import {
   isNonNullable,
   uniq,
   returnUndefOnError,
+  assertTrue,
 } from '@finos/legend-shared';
 import {
   PRIMITIVE_TYPE,
@@ -95,13 +96,17 @@ import { getEnumValue } from '../../../../../../../../graph/helpers/DomainHelper
 import { matchFunctionName } from '../../../../../../../../graph/MetaModelUtils.js';
 import type { V1_ClassInstance } from '../../../../model/valueSpecification/raw/V1_ClassInstance.js';
 import type { V1_GenericTypeInstance } from '../../../../model/valueSpecification/raw/V1_GenericTypeInstance.js';
-import { V1_ClassInstanceType } from '../../../pureProtocol/serializationHelpers/V1_ValueSpecificationSerializer.js';
+import {
+  V1_ClassInstanceType,
+  V1_serializeValueSpecification,
+} from '../../../pureProtocol/serializationHelpers/V1_ValueSpecificationSerializer.js';
 import { Multiplicity } from '../../../../../../../../graph/metamodel/pure/packageableElements/domain/Multiplicity.js';
 import {
   KeyExpression,
   KeyExpressionInstanceValue,
 } from '../../../../../../../../graph/metamodel/pure/valueSpecification/KeyExpressionInstanceValue.js';
 import { V1_SubTypeGraphFetchTree } from '../../../../model/valueSpecification/raw/classInstance/graph/V1_SubTypeGraphFetchTree.js';
+import { findMappingLocalProperty } from '../../../../../../../../graph/helpers/DSL_Mapping_Helper.js';
 
 const buildPrimtiveInstanceValue = (
   type: PRIMITIVE_TYPE,
@@ -120,15 +125,18 @@ export class V1_ValueSpecificationBuilder
   context: V1_GraphBuilderContext;
   processingContext: V1_ProcessingContext;
   openVariables: string[] = [];
+  checkFunctionName?: boolean | undefined;
 
   constructor(
     context: V1_GraphBuilderContext,
     processingContext: V1_ProcessingContext,
     openVariables: string[],
+    checkFunctionName?: boolean | undefined,
   ) {
     this.context = context;
     this.processingContext = processingContext;
     this.openVariables = openVariables;
+    this.checkFunctionName = checkFunctionName;
   }
 
   visit_INTERNAL__UnknownValueSpecfication(
@@ -216,12 +224,15 @@ export class V1_ValueSpecificationBuilder
       `Applying function '${appliedFunction.function}'`,
     );
     if (matchFunctionName(appliedFunction.function, SUPPORTED_FUNCTIONS.LET)) {
+      // We will build the let parameters to assign the right side of the expression to the left side
       const parameters = appliedFunction.parameters.map((expression) =>
-        expression.accept_ValueSpecificationVisitor(
-          new V1_ValueSpecificationBuilder(
-            this.context,
-            this.processingContext,
-            this.openVariables,
+        returnUndefOnError(() =>
+          expression.accept_ValueSpecificationVisitor(
+            new V1_ValueSpecificationBuilder(
+              this.context,
+              this.processingContext,
+              this.openVariables,
+            ),
           ),
         ),
       );
@@ -230,13 +241,13 @@ export class V1_ValueSpecificationBuilder
         V1_CString,
       ).value;
       // right side (value spec)
-      const rightSide = guaranteeNonNullable(parameters[1]);
+      const rightSide = parameters[1];
       const variableExpression = new VariableExpression(
         letName,
-        rightSide.multiplicity,
+        rightSide?.multiplicity ?? Multiplicity.ONE,
       );
 
-      variableExpression.genericType = rightSide.genericType;
+      variableExpression.genericType = rightSide?.genericType;
       this.processingContext.addInferredVariables(letName, variableExpression);
       this.openVariables.push(letName);
     }
@@ -246,6 +257,7 @@ export class V1_ValueSpecificationBuilder
       this.openVariables,
       this.context,
       this.processingContext,
+      this.checkFunctionName,
     );
     this.processingContext.pop();
 
@@ -614,6 +626,63 @@ export const V1_buildGenericFunctionExpression = (
     functionName,
     compileContext,
   );
+
+export const V1_buildGenericLetFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): SimpleFunctionExpression => {
+  try {
+    return V1_buildGenericFunctionExpression(
+      functionName,
+      parameters,
+      openVariables,
+      compileContext,
+      processingContext,
+    );
+  } catch (error) {
+    // let statement
+    assertTrue(
+      matchFunctionName(functionName, SUPPORTED_FUNCTIONS.LET),
+      'Expected let() function for custom let() handling',
+    );
+    assertTrue(parameters.length === 2, 'Let() function expects 2 parameters');
+    const leftSide = guaranteeNonNullable(
+      parameters[0],
+      'Left side of let statement expected to be defined',
+    ).accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    );
+    const rightSideParam = guaranteeNonNullable(parameters[1]);
+    const rightSide =
+      returnUndefOnError(() =>
+        rightSideParam.accept_ValueSpecificationVisitor(
+          new V1_ValueSpecificationBuilder(
+            compileContext,
+            processingContext,
+            openVariables,
+          ),
+        ),
+      ) ??
+      new INTERNAL__UnknownValueSpecification(
+        V1_serializeValueSpecification(
+          rightSideParam,
+          compileContext.extensions.plugins,
+        ),
+      );
+    return V1_buildBaseSimpleFunctionExpression(
+      [leftSide, rightSide],
+      functionName,
+      compileContext,
+    );
+  }
+};
 /**
  * This is fairly similar to how engine does function matching in a way.
  * Notice that Studio core should not attempt to do any function inferencing/matching
@@ -628,8 +697,29 @@ export function V1_buildFunctionExpression(
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
+  // We don't want to throw error when we build valuespecification outside
+  // query context (for ex: while building execution plan)
+  checkFunctionName?: boolean | undefined,
 ): SimpleFunctionExpression {
+  if (checkFunctionName === false) {
+    return V1_buildGenericFunctionExpression(
+      functionName,
+      parameters,
+      openVariables,
+      compileContext,
+      processingContext,
+    );
+  }
   if (matchFunctionName(functionName, Object.values(SUPPORTED_FUNCTIONS))) {
+    if (matchFunctionName(functionName, SUPPORTED_FUNCTIONS.LET)) {
+      return V1_buildGenericLetFunctionExpression(
+        functionName,
+        parameters,
+        openVariables,
+        compileContext,
+        processingContext,
+      );
+    }
     // NOTE: this is a catch-all builder that is only meant for basic function expression
     // such as and(), or(), etc. It will fail when type-inferencing/function-matching is required
     // such as for project(), filter(), getAll(), etc.
@@ -688,6 +778,7 @@ export function V1_buildGraphFetchTree(
   parentClass: Class | undefined,
   openVariables: string[],
   processingContext: V1_ProcessingContext,
+  canResolveLocalProperty?: boolean | undefined,
 ): GraphFetchTree {
   if (graphFetchTree instanceof V1_PropertyGraphFetchTree) {
     return buildPropertyGraphFetchTree(
@@ -696,6 +787,7 @@ export function V1_buildGraphFetchTree(
       guaranteeNonNullable(parentClass),
       openVariables,
       processingContext,
+      canResolveLocalProperty,
     );
   } else if (graphFetchTree instanceof V1_RootGraphFetchTree) {
     return buildRootGraphFetchTree(
@@ -703,6 +795,7 @@ export function V1_buildGraphFetchTree(
       context,
       openVariables,
       processingContext,
+      canResolveLocalProperty,
     );
   } else if (graphFetchTree instanceof V1_SubTypeGraphFetchTree) {
     return buildSubTypeGraphFetchTree(
@@ -710,6 +803,7 @@ export function V1_buildGraphFetchTree(
       context,
       openVariables,
       processingContext,
+      canResolveLocalProperty,
     );
   }
   throw new UnsupportedOperationError(
@@ -734,6 +828,7 @@ function buildPropertyGraphFetchTree(
   parentClass: Class,
   openVariables: string[],
   processingContext: V1_ProcessingContext,
+  canResolveLocalProperty?: boolean | undefined,
 ): PropertyGraphFetchTree {
   let property: AbstractProperty;
   let pureParameters: ValueSpecification[] = [];
@@ -766,11 +861,38 @@ function buildPropertyGraphFetchTree(
     processingContext.flushVariable('this');
     processingContext.pop();
   } else {
-    property = V1_getAppliedProperty(
-      parentClass,
-      undefined,
-      propertyGraphFetchTree.property,
-    );
+    // While building property graph fetch tree, the Class of root graph
+    // fetch tree is passed as the parentClass of property graph fetch tree.
+    // This Class contains the properties of property graph fetch trees.
+    // But sometimes, a local property is missing in the parentClass and
+    // causing error in V1_getAppliedProperty.
+    // To fix this, we get the local property from PureModel context.graph
+    // mappings. The function findProperty() is used for this purpose.
+    if (canResolveLocalProperty) {
+      try {
+        property = V1_getAppliedProperty(
+          parentClass,
+          undefined,
+          propertyGraphFetchTree.property,
+        );
+      } catch (error) {
+        const newProperty = findMappingLocalProperty(
+          context.graph.mappings,
+          propertyGraphFetchTree.property,
+        );
+        if (newProperty) {
+          property = newProperty;
+        } else {
+          throw error;
+        }
+      }
+    } else {
+      property = V1_getAppliedProperty(
+        parentClass,
+        undefined,
+        propertyGraphFetchTree.property,
+      );
+    }
   }
   const _subType = propertyGraphFetchTree.subType
     ? context.resolveClass(propertyGraphFetchTree.subType)
@@ -790,6 +912,7 @@ function buildPropertyGraphFetchTree(
         _returnTypeClasss,
         openVariables,
         processingContext,
+        canResolveLocalProperty,
       ),
     );
   }
@@ -809,6 +932,7 @@ function buildRootGraphFetchTree(
   context: V1_GraphBuilderContext,
   openVariables: string[],
   processingContext: V1_ProcessingContext,
+  canResolveLocalProperty?: boolean | undefined,
 ): RootGraphFetchTree {
   const _class = context.resolveClass(rootGraphFetchTree.class);
   const subTreeChildren = rootGraphFetchTree.subTrees.map((subTree) =>
@@ -818,6 +942,7 @@ function buildRootGraphFetchTree(
       _class.value,
       openVariables,
       processingContext,
+      canResolveLocalProperty,
     ),
   );
   const subTypeTreeChildren = rootGraphFetchTree.subTypeTrees.map(
@@ -827,6 +952,7 @@ function buildRootGraphFetchTree(
         context,
         openVariables,
         processingContext,
+        canResolveLocalProperty,
       ),
   );
   const _rootGraphFetchTree = new RootGraphFetchTree(
@@ -842,6 +968,7 @@ function buildSubTypeGraphFetchTree(
   context: V1_GraphBuilderContext,
   openVariables: string[],
   processingContext: V1_ProcessingContext,
+  canResolveLocalProperty?: boolean | undefined,
 ): SubTypeGraphFetchTree {
   const subTypeClass = context.resolveClass(subTypeGraphFetchTree.subTypeClass);
   const children = subTypeGraphFetchTree.subTrees.map((subTree) =>
@@ -851,6 +978,7 @@ function buildSubTypeGraphFetchTree(
       subTypeClass.value,
       openVariables,
       processingContext,
+      canResolveLocalProperty,
     ),
   );
   const _subTypeGraphFetchTree = new SubTypeGraphFetchTree(

package/src/graph-manager/protocol/pure/v1/transformation/pureProtocol/serializationHelpers/V1_ValueSpecificationSerializer.ts

@@ -482,6 +482,12 @@ const propertyGraphFetchTreeModelSchema = (
         (val) => V1_deserializeGraphFetchTree(val, plugins),
       ),
     ),
+    subTypeTrees: list(
+      custom(
+        (val) => V1_serializeGraphFetchTree(val, plugins),
+        (val) => V1_deserializeGraphFetchTree(val, plugins),
+      ),
+    ),
     subType: optional(primitive()),
   });
 
@@ -501,7 +507,7 @@ const subTypeGraphFetchTreeModelSchema = (
     subTypeClass: primitive(),
   });
 
-function V1_serializeGraphFetchTree(
+export function V1_serializeGraphFetchTree(
   protocol: V1_GraphFetchTree,
   plugins: PureProtocolProcessorPlugin[],
 ): PlainObject<V1_GraphFetchTree> {
@@ -518,7 +524,7 @@ function V1_serializeGraphFetchTree(
   );
 }
 
-function V1_deserializeGraphFetchTree(
+export function V1_deserializeGraphFetchTree(
   json: PlainObject<V1_GraphFetchTree>,
   plugins: PureProtocolProcessorPlugin[],
 ): V1_GraphFetchTree {