@finos/legend-query-builder 4.18.0 → 4.18.1

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionValueSpecificationBuilder.ts

@@ -67,7 +67,7 @@ const buildProjectColFunc = (
     projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
   ) {
     columnLambda = buildGenericLambdaFunctionInstanceValue(
-      projectionColumnState.lambdaParameterName,
+      [projectionColumnState.lambdaParameterName],
       [
         buildPropertyExpressionChain(
           projectionColumnState.propertyExpressionState.propertyExpression,
@@ -172,7 +172,7 @@ export const appendProjection = (
         projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
       ) {
         columnLambda = buildGenericLambdaFunctionInstanceValue(
-          projectionColumnState.lambdaParameterName,
+          [projectionColumnState.lambdaParameterName],
           [
             buildPropertyExpressionChain(
               projectionColumnState.propertyExpressionState.propertyExpression,
@@ -222,7 +222,7 @@ export const appendProjection = (
           extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG),
         );
         const aggregateLambda = buildGenericLambdaFunctionInstanceValue(
-          aggregateColumnState.lambdaParameterName,
+          [aggregateColumnState.lambdaParameterName],
           [
             aggregateColumnState.operator.buildAggregateExpressionFromState(
               aggregateColumnState,
@@ -242,8 +242,10 @@ export const appendProjection = (
           aggregateCalendarLambdaState instanceof SimpleFunctionExpression
         ) {
           aggregateCalendarLambda = buildGenericLambdaFunctionInstanceValue(
-            guaranteeNonNullable(aggregateColumnState.calendarFunction)
-              .lambdaParameterName,
+            [
+              guaranteeNonNullable(aggregateColumnState.calendarFunction)
+                .lambdaParameterName,
+            ],
             [aggregateCalendarLambdaState],
             aggregateColumnState.aggregationState.tdsState.queryBuilderState
               .graphManagerState.graph,
@@ -348,7 +350,7 @@ export const appendProjection = (
             QueryBuilderSimpleProjectionColumnState
           ) {
             columnLambda = buildGenericLambdaFunctionInstanceValue(
-              projectionColumnState.lambdaParameterName,
+              [projectionColumnState.lambdaParameterName],
               [
                 buildPropertyExpressionChain(
                   projectionColumnState.propertyExpressionState

package/src/stores/fetch-structure/tds/projection/QueryBuilderRelationProjectValueSpecBuilder.ts

@@ -79,7 +79,7 @@ export const buildRelationProjection = (
       projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
     ) {
       columnLambda = buildGenericLambdaFunctionInstanceValue(
-        projectionColumnState.lambdaParameterName,
+        [projectionColumnState.lambdaParameterName],
         [
           buildPropertyExpressionChain(
             projectionColumnState.propertyExpressionState.propertyExpression,
@@ -104,7 +104,7 @@ export const buildRelationProjection = (
       simple.func = real;
       simple.parametersValues = [variable];
       columnLambda = buildGenericLambdaFunctionInstanceValue(
-        projectionColumnState.lambdaParameterName,
+        [projectionColumnState.lambdaParameterName],
         [simple],
         queryBuilderState.graphManagerState.graph,
       );

package/src/stores/fetch-structure/tds/window/QueryBuilderWindowGroupByOperatorLoader.ts

@@ -24,6 +24,7 @@ import { QueryBuilderTDS_WindowOperator_Count } from './operators/QueryBuilderTD
 import { QueryBuilderTDS_WindowOperator_Max } from './operators/QueryBuilderTDS_WindowOperator_Max.js';
 import { QueryBuilderTDS_WindowOperator_Min } from './operators/QueryBuilderTDS_WindowOperator_Min.js';
 import { QueryBuilderTDS_WindowOperator_Average } from './operators/QueryBuilderTDS_WindowOperator_Average.js';
+import { QueryBuilderTDS_WindowRankOperator_PercentRank } from './operators/QueryBuilderTDS_WindowOperator_PercentRank.js';
 
 export const getQueryBuilderCoreWindowOperators =
   (): QueryBuilderTDS_WindowOperator[] => [
@@ -36,4 +37,5 @@ export const getQueryBuilderCoreWindowOperators =
     new QueryBuilderTDS_WindowRankOperator_DenseRank(),
     new QueryBuilderTDS_WindowRankOperator_Rank(),
     new QueryBuilderTDS_WindowRankOperator_RowNumber(),
+    new QueryBuilderTDS_WindowRankOperator_PercentRank(),
   ];

package/src/stores/fetch-structure/tds/window/QueryBuilderWindowStateBuilder.ts

@@ -19,6 +19,7 @@ import {
   type ColSpec,
   ColSpecArrayInstance,
   ColSpecInstanceValue,
+  FunctionExpression,
   LambdaFunction,
   LambdaFunctionInstanceValue,
   matchFunctionName,
@@ -248,35 +249,94 @@ const process_WindowOperatorState = (
   colSpec: ColSpec,
   tdsState: QueryBuilderTDSState,
 ): QueryBuilderTDS_WindowOperatorState => {
-  //TODO: handle aggregation operators
-  const rankLambda = guaranteeType(
-    guaranteeType(colSpec.function1, LambdaFunctionInstanceValue).values[0],
-    LambdaFunction,
-  );
-  assertTrue(rankLambda.expressionSequence.length === 1);
-  const operationFunctionExp = guaranteeType(
-    rankLambda.expressionSequence[0],
-    SimpleFunctionExpression,
-  );
+  if (colSpec.function2) {
+    //process function 1
+    const function1Lambda = guaranteeType(
+      guaranteeType(colSpec.function1, LambdaFunctionInstanceValue).values[0],
+      LambdaFunction,
+    );
+    const function1Column = guaranteeType(
+      function1Lambda.expressionSequence[0],
+      FunctionExpression,
+      `Can't process typed window aggregation: expects function1 to be a Function Expression`,
+    );
+    const aggColumnState = getTDSColumnState(
+      tdsState,
+      function1Column.functionName,
+    );
 
-  const operation = guaranteeNonNullable(
-    tdsState.windowState.findOperator(operationFunctionExp.functionName, true),
-    `Operator '${operationFunctionExp.functionName}' not supported yet for typed TDS`,
-  );
+    //process function2
+    const aggLambda = guaranteeType(
+      guaranteeType(colSpec.function2, LambdaFunctionInstanceValue).values[0],
+      LambdaFunction,
+    );
+    const aggFunctionExp = guaranteeType(
+      aggLambda.expressionSequence[0],
+      SimpleFunctionExpression,
+    );
 
-  const operatorState = new QueryBuilderTDS_WindowRankOperatorState(
-    tdsState.windowState,
-    operation,
-  );
+    const operation = guaranteeNonNullable(
+      tdsState.windowState.findOperator(aggFunctionExp.functionName, true),
+      `Operator '${aggFunctionExp.functionName}' not supported yet for typed TDS`,
+    );
 
-  const operatorParameters: string[] = [];
-  rankLambda.functionType.parameters.forEach((param) => {
-    guaranteeType(param, VariableExpression);
-    operatorParameters.push(param.name);
-  });
-  operatorState.setLambdaParameterNames(operatorParameters);
+    const operatorState = new QueryBuilderTDS_WindowAggreationOperatorState(
+      tdsState.windowState,
+      operation,
+      aggColumnState,
+    );
 
-  return operatorState;
+    //add parameter vlaues
+    const lambdaParameters: string[] = [];
+    function1Lambda.functionType.parameters.forEach((param) => {
+      guaranteeType(param, VariableExpression);
+      lambdaParameters.push(param.name);
+    });
+    const aggLambdaParamName = guaranteeType(
+      aggLambda.functionType.parameters[0],
+      VariableExpression,
+    ).name;
+    lambdaParameters.push(aggLambdaParamName);
+    operatorState.setLambdaParameterNames(lambdaParameters);
+    return operatorState;
+  } else if (colSpec.function1) {
+    //TODO: implement rowNumber as part of rank functions
+    const rankLambda = guaranteeType(
+      guaranteeType(colSpec.function1, LambdaFunctionInstanceValue).values[0],
+      LambdaFunction,
+    );
+    assertTrue(rankLambda.expressionSequence.length === 1);
+    const operationFunctionExp = guaranteeType(
+      rankLambda.expressionSequence[0],
+      SimpleFunctionExpression,
+    );
+
+    const operation = guaranteeNonNullable(
+      tdsState.windowState.findOperator(
+        operationFunctionExp.functionName,
+        true,
+      ),
+      `Operator '${operationFunctionExp.functionName}' not supported yet for typed TDS`,
+    );
+
+    const operatorState = new QueryBuilderTDS_WindowRankOperatorState(
+      tdsState.windowState,
+      operation,
+    );
+
+    const operatorParameters: string[] = [];
+    rankLambda.functionType.parameters.forEach((param) => {
+      guaranteeType(param, VariableExpression);
+      operatorParameters.push(param.name);
+    });
+    operatorState.setLambdaParameterNames(operatorParameters);
+
+    return operatorState;
+  } else {
+    throw new UnsupportedOperationError(
+      `Only support aggregation and rank operators in extend() expression`,
+    );
+  }
 };
 
 export const processTDS_ExtendExpression = (

package/src/stores/fetch-structure/tds/window/QueryBuilderWindowValueSpecificationBuilder.ts

@@ -22,6 +22,7 @@ import {
   GenericTypeExplicitReference,
   PrimitiveInstanceValue,
   SimpleFunctionExpression,
+  FunctionExpression,
   VariableExpression,
   Multiplicity,
   PrimitiveType,
@@ -29,8 +30,12 @@ import {
   ColSpecArray,
   ColSpecArrayInstance,
   ColSpecInstanceValue,
+  RelationColumn,
 } from '@finos/legend-graph';
-import { guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
 import {
@@ -41,6 +46,7 @@ import {
   type QueryBuilderWindowColumnState,
   type QueryBuilderWindowState,
   QueryBuilderTDS_WindowAggreationOperatorState,
+  QueryBuilderTDS_WindowRankOperatorState,
 } from './QueryBuilderWindowState.js';
 import { DEFAULT_LAMBDA_VARIABLE_NAME } from '@finos/legend-data-cube';
 import {
@@ -93,13 +99,18 @@ const appendOLAPGroupByColumnState = (
   const operationState = olapGroupByColumnState.operatorState;
   const lambdaParameterName =
     operationState.lambdaParameterNames[0] ?? DEFAULT_LAMBDA_VARIABLE_NAME;
-  const olapFunc = extractElementNameFromPath(operationState.operator.pureFunc);
+  const olapFunc = extractElementNameFromPath(
+    guaranteeNonNullable(
+      operationState.operator.pureFunc,
+      `Operator '${operationState.operator.getLabel()}' does not have a compatible OLAP function`,
+    ),
+  );
   const olapFuncExpression = new SimpleFunctionExpression(olapFunc);
   olapFuncExpression.parametersValues = [
     new VariableExpression(lambdaParameterName, Multiplicity.ONE),
   ];
   const olapLambdaFuncInstance = buildGenericLambdaFunctionInstanceValue(
-    lambdaParameterName,
+    [lambdaParameterName],
     [olapFuncExpression],
     graph,
   );
@@ -216,47 +227,139 @@ const appendExtendColumnState = (
     ]);
   }
 
-  //TODO: handle aggregation operators
-  const operatorFunc = extractElementNameFromPath(
-    operatorState.operator.pureFunc,
-  );
-  const operatorFuncExpression = new SimpleFunctionExpression(operatorFunc);
+  if (
+    operatorState instanceof QueryBuilderTDS_WindowAggreationOperatorState &&
+    operatorState.operator.relationFunc
+  ) {
+    const operatorFunc = extractElementNameFromPath(
+      operatorState.operator.relationFunc,
+    );
 
-  const lambdaParameters: VariableExpression[] = [];
-  operatorState.lambdaParameterNames.forEach((paramName) => {
-    lambdaParameters.push(new VariableExpression(paramName, Multiplicity.ONE));
-  });
-  operatorFuncExpression.parametersValues = lambdaParameters;
+    //parameters
+    const [
+      partitionParam = DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME,
+      windowParam = DEFAULT_WINDOW_FUNCTION_WINDOW_VAR_NAME,
+      rowParam = DEFAULT_WINDOW_FUNCTION_ROW_VAR_NAME,
+      aggParam = DEFAULT_LAMBDA_VARIABLE_NAME,
+    ] = operatorState.lambdaParameterNames;
 
-  const rankLambda = buildGenericLambdaFunctionInstanceValue(
-    operatorState.lambdaParameterNames[0] ??
-      DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME,
-    [operatorFuncExpression],
-    graph,
-  );
+    // Build function1: the map lambda {p, w, r|$r.SOURCE_COL}
+    const columnAccessExpression = new FunctionExpression(
+      operatorState.columnState.columnName,
+    );
+    columnAccessExpression.func = new RelationColumn(
+      operatorState.columnState.columnName,
+      GenericTypeExplicitReference.create(
+        new GenericType(PrimitiveType.STRING),
+      ),
+    );
+    columnAccessExpression.parametersValues = [
+      new VariableExpression(rowParam, Multiplicity.ONE),
+    ];
 
-  //skip over the first parameter since it was added in buildGenericLambdaFunctionInstanceValue()
-  lambdaParameters.slice(1).forEach((param) => {
-    rankLambda.values[0]?.functionType.parameters.push(param);
-  });
-  operatorColSpec.function1 = rankLambda;
-  operatorColSpecArray.colSpecs.push(operatorColSpec);
+    const mapLambda = buildGenericLambdaFunctionInstanceValue(
+      [partitionParam, windowParam, rowParam],
+      [columnAccessExpression],
+      graph,
+    );
 
-  const extendExpression = new SimpleFunctionExpression(
-    extractElementNameFromPath(
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_EXTEND,
-    ),
-  );
+    operatorColSpec.function1 = mapLambda;
 
-  const currentExpression = guaranteeNonNullable(lambda.expressionSequence[0]);
-  extendExpression.parametersValues = [
-    currentExpression,
-    overExpression,
-    operatorColSpecArrayInst,
-  ];
+    // Build function2: the reduce lambda x|$x->operatorFunc()
+    const operatorFuncExpression = new SimpleFunctionExpression(operatorFunc);
+    operatorFuncExpression.parametersValues = [
+      new VariableExpression(aggParam, Multiplicity.ONE),
+    ];
 
-  lambda.expressionSequence[0] = extendExpression;
-  return lambda;
+    //build col spec
+    const function2 = buildGenericLambdaFunctionInstanceValue(
+      [aggParam],
+      [operatorFuncExpression],
+      graph,
+    );
+
+    operatorColSpec.function2 = function2;
+
+    operatorColSpecArray.colSpecs.push(operatorColSpec);
+
+    const extendExpression = new SimpleFunctionExpression(
+      extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_EXTEND,
+      ),
+    );
+    const currentExpression = guaranteeNonNullable(
+      lambda.expressionSequence[0],
+    );
+    extendExpression.parametersValues = [
+      currentExpression,
+      overExpression,
+      operatorColSpecArrayInst,
+    ];
+    lambda.expressionSequence[0] = extendExpression;
+    return lambda;
+  } else if (
+    operatorState instanceof QueryBuilderTDS_WindowRankOperatorState &&
+    operatorState.operator.relationFunc
+  ) {
+    const operatorFunc = extractElementNameFromPath(
+      operatorState.operator.relationFunc,
+    );
+    const operatorFuncExpression = new SimpleFunctionExpression(operatorFunc);
+    const [
+      partitionParam = DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME,
+      windowParam = DEFAULT_WINDOW_FUNCTION_WINDOW_VAR_NAME,
+      rowParam = DEFAULT_WINDOW_FUNCTION_ROW_VAR_NAME,
+    ] = operatorState.lambdaParameterNames;
+
+    if (
+      operatorFunc ===
+      extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_ROW_NUMBER,
+      )
+    ) {
+      operatorFuncExpression.parametersValues = [
+        new VariableExpression(partitionParam, Multiplicity.ONE),
+        new VariableExpression(rowParam, Multiplicity.ONE),
+      ];
+    } else {
+      operatorFuncExpression.parametersValues = [
+        new VariableExpression(partitionParam, Multiplicity.ONE),
+        new VariableExpression(windowParam, Multiplicity.ONE),
+        new VariableExpression(rowParam, Multiplicity.ONE),
+      ];
+    }
+
+    const rankLambda = buildGenericLambdaFunctionInstanceValue(
+      [partitionParam, windowParam, rowParam],
+      [operatorFuncExpression],
+      graph,
+    );
+
+    operatorColSpec.function1 = rankLambda;
+    operatorColSpecArray.colSpecs.push(operatorColSpec);
+
+    const extendExpression = new SimpleFunctionExpression(
+      extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_EXTEND,
+      ),
+    );
+
+    const currentExpression = guaranteeNonNullable(
+      lambda.expressionSequence[0],
+    );
+    extendExpression.parametersValues = [
+      currentExpression,
+      overExpression,
+      operatorColSpecArrayInst,
+    ];
+
+    lambda.expressionSequence[0] = extendExpression;
+    return lambda;
+  } else {
+    throw new UnsupportedOperationError(
+      `Unsupported window function. Function must be supported for typed TDS and be an aggregation or rank function.`,
+    );
+  }
 };
 
 export const appendWindowFunctionState = (

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator.ts

@@ -25,7 +25,7 @@ export abstract class QueryBuilderTDS_WindowOperator implements Hashable {
 
   abstract get hashCode(): string;
 
-  abstract get pureFunc(): string;
+  abstract get pureFunc(): string | undefined;
 
   abstract get relationFunc(): string | undefined;
 

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Average.ts

@@ -33,7 +33,7 @@ export class QueryBuilderTDS_WindowOperator_Average extends QueryBuilderTDS_Wind
   }
 
   get relationFunc(): string | undefined {
-    return undefined;
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.AVERAGE;
   }
 
   get hashCode(): string {

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Count.ts

@@ -33,7 +33,7 @@ export class QueryBuilderTDS_WindowOperator_Count extends QueryBuilderTDS_Window
   }
 
   get relationFunc(): string | undefined {
-    return undefined;
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.COUNT;
   }
 
   get hashCode(): string {

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Max.ts

@@ -33,7 +33,7 @@ export class QueryBuilderTDS_WindowOperator_Max extends QueryBuilderTDS_WindowOp
   }
 
   get relationFunc(): string | undefined {
-    return undefined;
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.MAX;
   }
 
   get hashCode(): string {

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Min.ts

@@ -33,7 +33,7 @@ export class QueryBuilderTDS_WindowOperator_Min extends QueryBuilderTDS_WindowOp
   }
 
   get relationFunc(): string | undefined {
-    return undefined;
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.MIN;
   }
 
   get hashCode(): string {

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_PercentRank.ts

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2026-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 { PRIMITIVE_TYPE, type Type } from '@finos/legend-graph';
+import { QueryBuilderTDS_WindowOperator } from './QueryBuilderTDS_WindowOperator.js';
+import { hashArray } from '@finos/legend-shared';
+import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graph/QueryBuilderMetaModelConst.js';
+
+export class QueryBuilderTDS_WindowRankOperator_PercentRank extends QueryBuilderTDS_WindowOperator {
+  override getLabel(): string {
+    return 'percent rank';
+  }
+  override get pureFunc(): string | undefined {
+    // percentRank() is only supported for typed TDS
+    return undefined;
+  }
+  override get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PERCENT_RANK;
+  }
+  override get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_PERCENT_RANK,
+    ]);
+  }
+  override isCompatibleWithType(type: Type | undefined): boolean {
+    if (type) {
+      return (
+        [
+          PRIMITIVE_TYPE.STRING,
+          PRIMITIVE_TYPE.BOOLEAN,
+          PRIMITIVE_TYPE.NUMBER,
+          PRIMITIVE_TYPE.INTEGER,
+          PRIMITIVE_TYPE.DECIMAL,
+          PRIMITIVE_TYPE.FLOAT,
+          PRIMITIVE_TYPE.DATE,
+          PRIMITIVE_TYPE.STRICTDATE,
+          PRIMITIVE_TYPE.DATETIME,
+        ] as string[]
+      ).includes(type.path);
+    }
+    return true;
+  }
+}

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Sum.ts

@@ -33,7 +33,7 @@ export class QueryBuilderTDS_WindowOperator_Sum extends QueryBuilderTDS_WindowOp
   }
 
   get relationFunc(): string | undefined {
-    return undefined;
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUM;
   }
 
   get hashCode(): string {

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_RowNumber.ts

@@ -30,7 +30,7 @@ export class QueryBuilderTDS_WindowRankOperator_RowNumber extends QueryBuilderTD
   }
 
   get relationFunc(): string | undefined {
-    return undefined;
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_ROW_NUMBER;
   }
 
   get hashCode(): string {

package/src/stores/filter/QueryBuilderFilterValueSpecificationBuilder.ts

@@ -156,7 +156,7 @@ export const buildFilterConditionExpression = (
     } else if (clauses.length === 1) {
       const lambdaFunctionInstanceValue =
         buildGenericLambdaFunctionInstanceValue(
-          node.lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME,
+          [node.lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME],
           clauses,
           filterState.queryBuilderState.graphManagerState.graph,
         );
@@ -175,7 +175,7 @@ export const buildFilterConditionExpression = (
     );
     simp.parametersValues = parametersValues;
     const lambdaFunctionInstanceValue = buildGenericLambdaFunctionInstanceValue(
-      node.lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME,
+      [node.lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME],
       [simp],
       filterState.queryBuilderState.graphManagerState.graph,
     );
@@ -209,7 +209,7 @@ export const buildFilterExpression = (
   // param [1]
   filterExpression.parametersValues.push(
     buildGenericLambdaFunctionInstanceValue(
-      filterState.lambdaParameterName,
+      [filterState.lambdaParameterName],
       filterConditionExpressions,
       filterState.queryBuilderState.graphManagerState.graph,
     ),

package/src/stores/workflows/accessor/AccessorQueryBuilderState.ts

@@ -63,6 +63,7 @@ export class AccessorQueryBuilderState extends QueryBuilderState {
       changeAccessorOwner: action,
       changeAccessor: action,
       accessorOwnerOptions: computed,
+      accessorLabel: computed,
       compatibleRuntimes: computed,
     });
     this.workflowState.updateActionConfig(actionConfig);
@@ -83,6 +84,10 @@ export class AccessorQueryBuilderState extends QueryBuilderState {
     ];
   }
 
+  get accessorLabel(): string {
+    return this.sourceAccessor?.accessorLabel ?? 'Accessor';
+  }
+
   get accessorOwnerOptions(): AccessorOwnerOption[] {
     return this.accessorOwners.map(buildElementOption);
   }