@finos/legend-query-builder 0.4.3 → 0.5.0

package/src/stores/QueryBuilderStateBuilder.ts

@@ -18,6 +18,8 @@ import {
   assertNonNullable,
   assertTrue,
   assertType,
+  guaranteeIsString,
+  guaranteeNonNullable,
   guaranteeType,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
@@ -30,18 +32,18 @@ import {
   type InstanceValue,
   type INTERNAL__UnknownValueSpecification,
   type LambdaFunction,
-  MILESTONING_STEREOTYPE,
   matchFunctionName,
   Class,
   type CollectionInstanceValue,
   type LambdaFunctionInstanceValue,
-  type PrimitiveInstanceValue,
+  PrimitiveInstanceValue,
   SimpleFunctionExpression,
   type VariableExpression,
   type AbstractPropertyExpression,
   getMilestoneTemporalStereotype,
   type INTERNAL__PropagatedValue,
   type ValueSpecification,
+  SUPPORTED_FUNCTIONS,
 } from '@finos/legend-graph';
 import { processTDSPostFilterExpression } from './fetch-structure/tds/post-filter/QueryBuilderPostFilterStateBuilder.js';
 import { processFilterExpression } from './filter/QueryBuilderFilterStateBuilder.js';
@@ -64,8 +66,9 @@ import {
 } from './fetch-structure/tds/projection/QueryBuilderProjectionStateBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import { LambdaParameterState } from './shared/LambdaParameterState.js';
-import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/olapGroupBy/QueryBuilderOLAPGroupByStateBuilder_.js';
+import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/olapGroupBy/QueryBuilderOLAPGroupByStateBuilder.js';
 import { processWatermarkExpression } from './watermark/QueryBuilderWatermarkStateBuilder.js';
+import { QueryBuilderConstantExpressionState } from './QueryBuilderConstantsState.js';
 
 const processGetAllExpression = (
   expression: SimpleFunctionExpression,
@@ -78,57 +81,62 @@ const processGetAllExpression = (
     `Can't process getAll() expression: getAll() return type is missing`,
   );
   queryBuilderState.setClass(_class);
-  queryBuilderState.milestoningState.updateMilestoningConfiguration();
+  queryBuilderState.milestoningState.clearMilestoningDates();
   queryBuilderState.explorerState.refreshTreeData();
 
   // check parameters (milestoning) and build state
-  let acceptedNoOfParameters = 1;
+  const acceptedNoOfParameters = 1;
   const stereotype = getMilestoneTemporalStereotype(
     _class,
     queryBuilderState.graphManagerState.graph,
   );
-  switch (stereotype) {
-    case MILESTONING_STEREOTYPE.BITEMPORAL:
-      acceptedNoOfParameters = 3;
-      assertTrue(
-        expression.parametersValues.length === acceptedNoOfParameters,
-        `Can't process getAll() expression: when used with a bitemporal milestoned class getAll() expects two parameters`,
-      );
-      queryBuilderState.milestoningState.setProcessingDate(
-        expression.parametersValues[1],
-      );
-      queryBuilderState.milestoningState.setBusinessDate(
-        expression.parametersValues[2],
-      );
-      break;
-    case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL:
-      acceptedNoOfParameters = 2;
-      assertTrue(
-        expression.parametersValues.length === acceptedNoOfParameters,
-        `Can't process getAll() expression: when used with a milestoned class getAll() expects a parameter`,
-      );
-      queryBuilderState.milestoningState.setBusinessDate(
-        expression.parametersValues[1],
-      );
-      break;
-    case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL:
-      acceptedNoOfParameters = 2;
-      assertTrue(
-        expression.parametersValues.length === acceptedNoOfParameters,
-        `Can't process getAll() expression: when used with a milestoned class getAll() expects a parameter`,
-      );
-      queryBuilderState.milestoningState.setProcessingDate(
-        expression.parametersValues[1],
-      );
-      break;
-    default:
-      assertTrue(
-        expression.parametersValues.length === acceptedNoOfParameters,
-        `Can't process getAll() expression: getAll() expects no arguments`,
-      );
+  if (stereotype) {
+    queryBuilderState.milestoningState
+      .getMilestoningImplementation(stereotype)
+      .processGetAllParamaters(expression.parametersValues);
+  } else {
+    assertTrue(
+      expression.parametersValues.length === acceptedNoOfParameters,
+      `Can't process getAll() expression: getAll() expects no arguments`,
+    );
   }
 };
 
+const processLetExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
+): void => {
+  const parameters = expression.parametersValues;
+  assertTrue(
+    expression.parametersValues.length === 2,
+    'Let function expected to have two parameters (left and right side value)',
+  );
+  // process left side (var)
+  const letVariable = guaranteeIsString(
+    guaranteeType(
+      parameters[0],
+      PrimitiveInstanceValue,
+      'Can`t process let function: left side should be a primitive instance value',
+    ).values[0],
+    'Can`t process let function: left side should be a string primitive instance value',
+  );
+  const varExp = guaranteeNonNullable(
+    parentLambda.openVariables.get(letVariable),
+    `Unable to find variable ${letVariable} in lambda function`,
+  );
+  // process right side (value)
+  const rightSide = guaranteeNonNullable(parameters[1]);
+  // final
+  const constantExpression = new QueryBuilderConstantExpressionState(
+    queryBuilderState,
+    varExp,
+    rightSide,
+  );
+  queryBuilderState.constantState.setShowConstantPanel(true);
+  queryBuilderState.constantState.addConstant(constantExpression);
+};
+
 /**
  * This is the value specification processor (a.k.a state builder) for query builder.
  *
@@ -209,21 +217,29 @@ export class QueryBuilderValueSpecificationProcessor
    * value specification.
    */
   readonly parentExpression?: SimpleFunctionExpression | undefined;
+  readonly parentLambda: LambdaFunction;
 
   private constructor(
     queryBuilderState: QueryBuilderState,
+    parentLambda: LambdaFunction,
     parentExpression: SimpleFunctionExpression | undefined,
   ) {
     this.queryBuilderState = queryBuilderState;
     this.parentExpression = parentExpression;
+    this.parentLambda = parentLambda;
   }
 
   static process(
     valueSpecification: ValueSpecification,
+    parentLambda: LambdaFunction,
     queryBuilderState: QueryBuilderState,
   ): void {
     valueSpecification.accept_ValueSpecificationVisitor(
-      new QueryBuilderValueSpecificationProcessor(queryBuilderState, undefined),
+      new QueryBuilderValueSpecificationProcessor(
+        queryBuilderState,
+        parentLambda,
+        undefined,
+      ),
     );
   }
 
@@ -234,11 +250,13 @@ export class QueryBuilderValueSpecificationProcessor
   static processChild(
     valueSpecification: ValueSpecification,
     parentExpression: SimpleFunctionExpression,
+    parentLambda: LambdaFunction,
     queryBuilderState: QueryBuilderState,
   ): void {
     valueSpecification.accept_ValueSpecificationVisitor(
       new QueryBuilderValueSpecificationProcessor(
         queryBuilderState,
+        parentLambda,
         parentExpression,
       ),
     );
@@ -316,6 +334,7 @@ export class QueryBuilderValueSpecificationProcessor
       );
       QueryBuilderValueSpecificationProcessor.process(
         precedingExpression,
+        this.parentLambda,
         this.queryBuilderState,
       );
 
@@ -371,7 +390,11 @@ export class QueryBuilderValueSpecificationProcessor
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.WATERMARK,
       )
     ) {
-      processWatermarkExpression(valueSpecification, this.queryBuilderState);
+      processWatermarkExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
       return;
     } else if (
       matchFunctionName(
@@ -379,7 +402,11 @@ export class QueryBuilderValueSpecificationProcessor
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
       )
     ) {
-      processTDSProjectExpression(valueSpecification, this.queryBuilderState);
+      processTDSProjectExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
       return;
     } else if (
       matchFunctionName(
@@ -387,7 +414,11 @@ export class QueryBuilderValueSpecificationProcessor
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE,
       )
     ) {
-      processTDSTakeExpression(valueSpecification, this.queryBuilderState);
+      processTDSTakeExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
       return;
     } else if (
       matchFunctionName(
@@ -395,7 +426,11 @@ export class QueryBuilderValueSpecificationProcessor
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT,
       )
     ) {
-      processTDSDistinctExpression(valueSpecification, this.queryBuilderState);
+      processTDSDistinctExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
       return;
     } else if (
       matchFunctionName(
@@ -403,7 +438,11 @@ export class QueryBuilderValueSpecificationProcessor
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT,
       )
     ) {
-      processTDSSortExpression(valueSpecification, this.queryBuilderState);
+      processTDSSortExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
       return;
     } else if (
       matchFunctionName(functionName, [
@@ -423,7 +462,11 @@ export class QueryBuilderValueSpecificationProcessor
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
       )
     ) {
-      processTDSGroupByExpression(valueSpecification, this.queryBuilderState);
+      processTDSGroupByExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
       return;
     } else if (
       matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG)
@@ -432,6 +475,7 @@ export class QueryBuilderValueSpecificationProcessor
         valueSpecification,
         this.parentExpression,
         this.queryBuilderState,
+        this.parentLambda,
       );
       return;
     } else if (
@@ -443,6 +487,7 @@ export class QueryBuilderValueSpecificationProcessor
       processTDS_OLAPGroupByExpression(
         valueSpecification,
         this.queryBuilderState,
+        this.parentLambda,
       );
       return;
     } else if (
@@ -454,6 +499,7 @@ export class QueryBuilderValueSpecificationProcessor
       processGraphFetchSerializeExpression(
         valueSpecification,
         this.queryBuilderState,
+        this.parentLambda,
       );
       return;
     } else if (
@@ -462,7 +508,18 @@ export class QueryBuilderValueSpecificationProcessor
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
       ])
     ) {
-      processGraphFetchExpression(valueSpecification, this.queryBuilderState);
+      processGraphFetchExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
+      return;
+    } else if (matchFunctionName(functionName, [SUPPORTED_FUNCTIONS.LET])) {
+      processLetExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
       return;
     }
     throw new UnsupportedOperationError(
@@ -531,6 +588,7 @@ export class QueryBuilderValueSpecificationProcessor
         expression.accept_ValueSpecificationVisitor(
           new QueryBuilderValueSpecificationProcessor(
             this.queryBuilderState,
+            this.parentLambda,
             this.parentExpression,
           ),
         ),
@@ -574,6 +632,7 @@ export const processQueryLambdaFunction = (
   lambdaFunction.expressionSequence.map((expression) =>
     QueryBuilderValueSpecificationProcessor.process(
       expression,
+      lambdaFunction,
       queryBuilderState,
     ),
   );

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -28,7 +28,9 @@ import {
   GenericTypeExplicitReference,
   LambdaFunction,
   SimpleFunctionExpression,
-  MILESTONING_STEREOTYPE,
+  PrimitiveInstanceValue,
+  PrimitiveType,
+  SUPPORTED_FUNCTIONS,
 } from '@finos/legend-graph';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import { buildFilterExpression } from './filter/QueryBuilderFilterValueSpecificationBuilder.js';
@@ -36,6 +38,8 @@ import type { LambdaFunctionBuilderOption } from './QueryBuilderValueSpecificati
 import type { QueryBuilderFetchStructureState } from './fetch-structure/QueryBuilderFetchStructureState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import { buildWatermarkExpression } from './watermark/QueryBuilderWatermarkValueSpecificationBuilder.js';
+import { buildExecutionQueryFromLambdaFunction } from './shared/LambdaParameterState.js';
+import type { QueryBuilderConstantExpressionState } from './QueryBuilderConstantsState.js';
 
 const buildGetAllFunction = (
   _class: Class,
@@ -53,6 +57,22 @@ const buildGetAllFunction = (
   return _func;
 };
 
+const buildLetExpression = (
+  constantExpressionState: QueryBuilderConstantExpressionState,
+): SimpleFunctionExpression => {
+  const varName = constantExpressionState.variable.name;
+  const value = constantExpressionState.value;
+  const leftSide = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(new GenericType(PrimitiveType.STRING)),
+  );
+  leftSide.values = [varName];
+  const letFunc = new SimpleFunctionExpression(
+    extractElementNameFromPath(SUPPORTED_FUNCTIONS.LET),
+  );
+  letFunc.parametersValues = [leftSide, value];
+  return letFunc;
+};
+
 const buildFetchStructure = (
   fetchStructureState: QueryBuilderFetchStructureState,
   lambdaFunction: LambdaFunction,
@@ -90,62 +110,17 @@ export const buildLambdaFunction = (
     queryBuilderState.graphManagerState.graph,
   );
   if (milestoningStereotype) {
-    switch (milestoningStereotype) {
-      case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL: {
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.milestoningState.businessDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        break;
-      }
-      case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL: {
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.milestoningState.processingDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        break;
-      }
-      case MILESTONING_STEREOTYPE.BITEMPORAL: {
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.milestoningState.processingDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.milestoningState.businessDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        break;
-      }
-      default:
-    }
+    queryBuilderState.milestoningState
+      .getMilestoningImplementation(milestoningStereotype)
+      .buildGetAllParameters(getAllFunction);
   }
   lambdaFunction.expressionSequence[0] = getAllFunction;
 
   // build watermark
-  const watermarkFunction = buildWatermarkExpression(
-    queryBuilderState.watermarkState,
-    getAllFunction,
-  );
-  if (watermarkFunction) {
-    lambdaFunction.expressionSequence[0] = watermarkFunction;
-  }
+  buildWatermarkExpression(queryBuilderState.watermarkState, lambdaFunction);
 
   // build filter
-  const filterFunction = buildFilterExpression(
-    queryBuilderState.filterState,
-    watermarkFunction ?? getAllFunction,
-  );
-  if (filterFunction) {
-    lambdaFunction.expressionSequence[0] = filterFunction;
-  }
+  buildFilterExpression(queryBuilderState.filterState, lambdaFunction);
 
   // build fetch-structure
   buildFetchStructure(
@@ -154,14 +129,29 @@ export const buildLambdaFunction = (
     options,
   );
 
+  // build variable expressions
+  if (queryBuilderState.constantState.constants.length) {
+    const letExpressions =
+      queryBuilderState.constantState.constants.map(buildLetExpression);
+    lambdaFunction.expressionSequence = [
+      ...letExpressions,
+      ...lambdaFunction.expressionSequence,
+    ];
+  }
   // build parameters
-  if (
-    !queryBuilderState.isParameterSupportDisabled &&
-    queryBuilderState.parametersState.parameterStates.length
-  ) {
-    lambdaFunction.functionType.parameters =
-      queryBuilderState.parametersState.parameterStates.map((e) => e.parameter);
+  if (queryBuilderState.parametersState.parameterStates.length) {
+    if (options?.isBuildingExecutionQuery) {
+      buildExecutionQueryFromLambdaFunction(
+        lambdaFunction,
+        queryBuilderState.parametersState.parameterStates,
+        queryBuilderState.graphManagerState,
+      );
+    } else {
+      lambdaFunction.functionType.parameters =
+        queryBuilderState.parametersState.parameterStates.map(
+          (e) => e.parameter,
+        );
+    }
   }
-
   return lambdaFunction;
 };

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -16,12 +16,9 @@
 
 import {
   AbstractPropertyExpression,
-  Class,
   DerivedProperty,
-  getMilestoneTemporalStereotype,
   INTERNAL__PropagatedValue,
   matchFunctionName,
-  MILESTONING_STEREOTYPE,
   SimpleFunctionExpression,
   VariableExpression,
   type ValueSpecification,
@@ -32,103 +29,21 @@ import {
   guaranteeType,
 } from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
-import { getDerivedPropertyMilestoningSteoreotype } from './QueryBuilderPropertyEditorState.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
+import { variableExpression_setName } from './shared/ValueSpecificationModifierHelper.js';
 
 /**
- * Checks if the provided property expression match the criteria for default
- * date propagation so we know whether we need to fill in values for the parameter
- * or just propgate values from the parent's expression
- *
- * NOTE: this takes date propgation into account. See the table below for all
- * the combination:
- *
- *             | [source] |          |          |          |          |
- * ----------------------------------------------------------------------
- *   [target]  |          |   NONE   |  PR_TMP  |  BI_TMP  |  BU_TMP  |
- * ----------------------------------------------------------------------
- *             |   NONE   |   N.A.   |   PRD    | PRD,BUD  |    BUD   |
- * ----------------------------------------------------------------------
- *             |  PR_TMP  |   N.A.   |    X     | PRD,BUD  |    BUD   |
- * ----------------------------------------------------------------------
- *             |  BI_TMP  |   N.A.   |    X     |    X     |    X     |
- * ----------------------------------------------------------------------
- *             |  BU_TMP  |   N.A.   |   PRD    | PRD,BUD  |    X     |
- * ----------------------------------------------------------------------
- *
- * Annotations:
- *
- * [source]: source temporal type
- * [target]: target temporal type
- *
- * PR_TMP  : processing temporal
- * BI_TMP  : bitemporal
- * BU_TMP  : business temporal
- *
- * X       : no default date propagated
- * PRD     : default processing date is propagated
- * BUD     : default business date is propgated
+ * Gets the value of ValueSpecification given INTERNAL__PropagatedValue is pointing to.
  */
-const isDefaultDatePropagationSupported = (
-  currentPropertyExpression: AbstractPropertyExpression,
-  queryBuilderState: QueryBuilderState,
-  prevPropertyExpression?: AbstractPropertyExpression | undefined,
-): boolean => {
-  const property = currentPropertyExpression.func.value;
-  const graph = queryBuilderState.graphManagerState.graph;
-  // Default date propagation is not supported for current expression when the previous property expression is a derived property.
-  if (
-    prevPropertyExpression &&
-    prevPropertyExpression.func.value instanceof DerivedProperty &&
-    prevPropertyExpression.func.value._OWNER.derivedProperties.includes(
-      prevPropertyExpression.func.value,
-    )
-  ) {
-    return false;
-  }
-  // Default date propagation is not supported for current expression when the milestonedParameterValues of
-  // the previous property expression doesn't match with the global milestonedParameterValues
-  if (
-    prevPropertyExpression &&
-    prevPropertyExpression.func.value.genericType.value.rawType instanceof Class
-  ) {
-    const milestoningStereotype = getMilestoneTemporalStereotype(
-      prevPropertyExpression.func.value.genericType.value.rawType,
-      graph,
-    );
-    if (
-      milestoningStereotype &&
-      !prevPropertyExpression.parametersValues
-        .slice(1)
-        .every(
-          (parameterValue) =>
-            parameterValue instanceof INTERNAL__PropagatedValue,
-        )
-    ) {
-      return false;
-    }
-  }
-  if (property.genericType.value.rawType instanceof Class) {
-    // the stereotype of source class of current property expression.
-    const sourceStereotype =
-      property instanceof DerivedProperty
-        ? getDerivedPropertyMilestoningSteoreotype(property, graph)
-        : undefined;
-    // Default date propagation is always supported if the source is `bitemporal`
-    if (sourceStereotype === MILESTONING_STEREOTYPE.BITEMPORAL) {
-      return true;
-    }
-    // the stereotype (if exists) of the generic type of current property expression.
-    const targetStereotype = getMilestoneTemporalStereotype(
-      property.genericType.value.rawType,
-      graph,
+const getValueOfInternalPropagatedValue = (
+  valueSpec: INTERNAL__PropagatedValue,
+): ValueSpecification => {
+  if (valueSpec.getValue() instanceof INTERNAL__PropagatedValue) {
+    return getValueOfInternalPropagatedValue(
+      guaranteeType(valueSpec.getValue(), INTERNAL__PropagatedValue),
     );
-    // Default date propagation is supported when stereotype of both source and target matches
-    if (sourceStereotype && targetStereotype) {
-      return sourceStereotype === targetStereotype;
-    }
   }
-  return false;
+  return valueSpec.getValue();
 };
 
 export const buildPropertyExpressionChain = (
@@ -173,13 +88,7 @@ export const buildPropertyExpressionChain = (
           // Replace with argumentless derived property expression only when default date propagation is supported
           if (
             !TEMPORARY__disableDatePropagation &&
-            isDefaultDatePropagationSupported(
-              currentPropertyExpression,
-              queryBuilderState,
-              nextExpression instanceof AbstractPropertyExpression
-                ? nextExpression
-                : undefined,
-            )
+            parameterValue.isPropagatedValue
           ) {
             // NOTE: For `bitemporal` property check if the property expression has parameters which are not instance of
             // `INTERNAL_PropagatedValue` then pass the parameters as user explicitly changed values of either of the parameters.
@@ -190,11 +99,13 @@ export const buildPropertyExpressionChain = (
                 currentPropertyExpression.parametersValues.length === 3 &&
                 !(
                   currentPropertyExpression.parametersValues[2] instanceof
-                  INTERNAL__PropagatedValue
+                    INTERNAL__PropagatedValue &&
+                  currentPropertyExpression.parametersValues[2]
+                    .isPropagatedValue === true
                 ))
             ) {
               currentPropertyExpression.parametersValues[index + 1] =
-                parameterValue.getValue();
+                getValueOfInternalPropagatedValue(parameterValue);
             } else {
               currentPropertyExpression.parametersValues = [
                 guaranteeNonNullable(
@@ -205,7 +116,7 @@ export const buildPropertyExpressionChain = (
             }
           } else {
             currentPropertyExpression.parametersValues[index + 1] =
-              parameterValue.getValue();
+              getValueOfInternalPropagatedValue(parameterValue);
           }
         }
       });
@@ -228,7 +139,7 @@ export const buildPropertyExpressionChain = (
 
   // Update the root lambda name based on the parent's lambda parameter name.
   if (currentExpression instanceof VariableExpression) {
-    currentExpression.name = lambdaParameterName;
+    variableExpression_setName(currentExpression, lambdaParameterName);
   }
   return newPropertyExpression;
 };