@finos/legend-query-builder 4.17.100 → 4.18.1

package/src/stores/QueryBuilderStateBuilder.ts

@@ -27,8 +27,8 @@ import {
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import {
   AbstractPropertyExpression,
+  FunctionExpression,
   type EnumValueInstanceValue,
-  type FunctionExpression,
   type GraphFetchTreeInstanceValue,
   type ValueSpecificationVisitor,
   type LambdaFunction,
@@ -55,6 +55,8 @@ import {
   PackageableElementExplicitReference,
   MILESTONING_STEREOTYPE,
   type ColSpecInstanceValue,
+  type AccessorInstanceValue,
+  RelationColumn,
 } from '@finos/legend-graph';
 import { processTDSPostFilterExpression } from './fetch-structure/tds/post-filter/QueryBuilderPostFilterStateBuilder.js';
 import { processFilterExpression } from './filter/QueryBuilderFilterStateBuilder.js';
@@ -76,6 +78,7 @@ import {
   processTDSProjectExpression,
   processTDSProjectionColumnPropertyExpression,
   processTDSProjectionDerivationExpression,
+  processTDSRelationColumn,
   processTDSSliceExpression,
   processTDSSortDirectionExpression,
   processTDSSortExpression,
@@ -87,7 +90,10 @@ import {
   QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
 } from '../graph/QueryBuilderMetaModelConst.js';
 import { LambdaParameterState } from './shared/LambdaParameterState.js';
-import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/window/QueryBuilderWindowStateBuilder.js';
+import {
+  processTDS_ExtendExpression,
+  processTDS_OLAPGroupByExpression,
+} from './fetch-structure/tds/window/QueryBuilderWindowStateBuilder.js';
 import { processWatermarkExpression } from './watermark/QueryBuilderWatermarkStateBuilder.js';
 import {
   type QueryBuilderConstantExpressionState,
@@ -117,7 +123,7 @@ const processGetAllExpression = (
     Class,
     `Can't process getAll() expression: getAll() return type is missing`,
   );
-  queryBuilderState.setClass(_class);
+  queryBuilderState.setSourceElement(_class);
   queryBuilderState.milestoningState.clearMilestoningDates();
   queryBuilderState.explorerState.refreshTreeData();
 
@@ -149,7 +155,7 @@ const processGetAllVersionsExpression = (
     Class,
     `Can't process getAllVersions() expression: getAllVersions() return type is missing`,
   );
-  queryBuilderState.setClass(_class);
+  queryBuilderState.setSourceElement(_class);
   queryBuilderState.milestoningState.clearMilestoningDates();
   queryBuilderState.explorerState.refreshTreeData();
 
@@ -183,7 +189,7 @@ const processGetAllVersionsInRangeExpression = (
     Class,
     `Can't process getAllVersionsInRange() expression: getAllVersionsInRange() return type is missing`,
   );
-  queryBuilderState.setClass(_class);
+  queryBuilderState.setSourceElement(_class);
   queryBuilderState.milestoningState.clearMilestoningDates();
   queryBuilderState.explorerState.refreshTreeData();
 
@@ -309,24 +315,34 @@ const processFromFunction = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
 ): void => {
-  // mapping
-  const mappingInstanceExpression = guaranteeType(
-    expression.parametersValues[1],
-    InstanceValue,
-    `Can't process from() expression: only support from() with 1st parameter as instance value`,
-  );
-  const mapping = guaranteeType(
-    guaranteeType(
-      mappingInstanceExpression.values[0],
-      PackageableElementReference,
-      `Can't process from() expression: only support from() with 1st parameter as packagableElement value`,
-    ).value,
-    Mapping,
-    `Can't process from() expression: only support from() with 1st parameter as mapping value`,
-  );
+  const mappingParameter =
+    expression.parametersValues[2] !== undefined
+      ? expression.parametersValues[1]
+      : undefined;
+  const runtimeParameter = mappingParameter
+    ? expression.parametersValues[2]
+    : expression.parametersValues[1];
+  let mapping: Mapping | undefined;
+  if (mappingParameter) {
+    // mapping
+    const mappingInstanceExpression = guaranteeType(
+      mappingParameter,
+      InstanceValue,
+      `Can't process from() expression: only support from() with 1st parameter as instance value`,
+    );
+    mapping = guaranteeType(
+      guaranteeType(
+        mappingInstanceExpression.values[0],
+        PackageableElementReference,
+        `Can't process from() expression: only support from() with 1st parameter as packagableElement value`,
+      ).value,
+      Mapping,
+      `Can't process from() expression: only support from() with 1st parameter as mapping value`,
+    );
+  }
   // runtime
   const runtimeInstanceExpression = guaranteeType(
-    expression.parametersValues[2],
+    runtimeParameter,
     InstanceValue,
     `Can't process from() expression: only support from() with 2nd parameter as instance value`,
   );
@@ -516,6 +532,16 @@ export class QueryBuilderValueSpecificationProcessor
     throw new UnsupportedOperationError();
   }
 
+  visit_AccessorInstanceValue(
+    valueAccessorInstanceValue: AccessorInstanceValue,
+  ): void {
+    const value = guaranteeNonNullable(
+      valueAccessorInstanceValue.values[0],
+      `Accessor instance value must have a value`,
+    );
+    this.queryBuilderState.setSourceElement(value);
+  }
+
   visit_SimpleFunctionExpression(
     valueSpecification: SimpleFunctionExpression,
   ): void {
@@ -832,8 +858,8 @@ export class QueryBuilderValueSpecificationProcessor
     } else if (matchFunctionName(functionName, [SUPPORTED_FUNCTIONS.FROM])) {
       const parameters = valueSpecification.parametersValues;
       assertTrue(
-        parameters.length === 3,
-        'From function expects 2 parameters (mapping and runtime)',
+        parameters.length === 3 || parameters.length === 2,
+        'From function expects an optional mapping with required runtime',
       );
       processFromFunction(valueSpecification, this.queryBuilderState);
       QueryBuilderValueSpecificationProcessor.processChild(
@@ -874,6 +900,18 @@ export class QueryBuilderValueSpecificationProcessor
         this.parentLambda,
       );
       return;
+    } else if (
+      matchFunctionName(
+        functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_EXTEND,
+      )
+    ) {
+      processTDS_ExtendExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
+      return;
     }
     throw new UnsupportedOperationError(
       `Can't process expression of function ${functionName}()`,
@@ -983,38 +1021,64 @@ export class QueryBuilderValueSpecificationProcessor
         `Can't process col spec array instance: value expected to be of size 1`,
       );
       guaranteeNonNullable(spec[0]).colSpecs.forEach((col) => {
-        const _function1 = guaranteeType(
-          col.function1,
-          LambdaFunctionInstanceValue,
-          `Can't process col spec: function1 not a lambda function instance value`,
-        );
-        assertTrue(_function1.values.length === 1);
-        const lambdaVal = guaranteeNonNullable(_function1.values[0]);
-        assertTrue(lambdaVal.expressionSequence.length === 1);
-        const expression = guaranteeNonNullable(
-          lambdaVal.expressionSequence[0],
-        );
-
-        if (expression instanceof AbstractPropertyExpression) {
-          processTDSProjectionColumnPropertyExpression(
-            expression,
-            col.name,
-            this.queryBuilderState,
+        const _function1 = col.function1;
+        if (_function1 instanceof LambdaFunctionInstanceValue) {
+          assertTrue(_function1.values.length === 1);
+          const lambdaVal = guaranteeNonNullable(_function1.values[0]);
+          assertTrue(lambdaVal.expressionSequence.length === 1);
+          const expression = guaranteeNonNullable(
+            lambdaVal.expressionSequence[0],
           );
-        } else if (expression instanceof INTERNAL__UnknownValueSpecification) {
+          if (expression instanceof AbstractPropertyExpression) {
+            processTDSProjectionColumnPropertyExpression(
+              expression,
+              col.name,
+              this.queryBuilderState,
+            );
+          } else if (expression instanceof FunctionExpression) {
+            const func = expression.func;
+            const relationCol = guaranteeType(
+              func,
+              RelationColumn,
+              'Can`t process col spec: function1 lambda function does not contain a relation column',
+            );
+            processTDSRelationColumn(
+              expression,
+              col.name,
+              relationCol,
+              this.queryBuilderState,
+            );
+          } else if (
+            expression instanceof INTERNAL__UnknownValueSpecification
+          ) {
+            assertNonNullable(
+              this.parentExpression,
+              `Can't process unknown value: parent expression cannot be retrieved`,
+            );
+            processTDSProjectionDerivationExpression(
+              expression,
+              col.name,
+              this.parentExpression,
+              this.queryBuilderState,
+            );
+          }
+        } else if (_function1 instanceof INTERNAL__UnknownValueSpecification) {
           assertNonNullable(
             this.parentExpression,
             `Can't process unknown value: parent expression cannot be retrieved`,
           );
           processTDSProjectionDerivationExpression(
-            expression,
+            _function1,
             col.name,
             this.parentExpression,
             this.queryBuilderState,
           );
+        } else {
+          throw new UnsupportedOperationError(
+            `Can't process col spec: only support col spec with function lambda value`,
+          );
         }
       });
-
       return;
     } else if (
       matchFunctionName(this.parentExpression.functionName, [

package/src/stores/QueryBuilderStateHashUtils.ts

@@ -36,6 +36,7 @@ export enum QUERY_BUILDER_STATE_HASH_STRUCTURE {
   AGGREGATE_OPERATOR_PERCENTILE = 'AGGREGATE_OPERATOR_PERCENTILE',
   AGGREGATION_STATE = 'AGGREGATION_STATE',
   SIMPLE_PROJECTION_COLUMN_STATE = 'SIMPLE_PROJECTION_COLUMN_STATE',
+  RELATION_COLUMN_PROJECTION_COLUMN_STATE = 'RELATION_COLUMN_PROJECTION_COLUMN_STATE',
   PROPERTY_EXPRESSION_STATE = 'PROPERTY_EXPRESSION_STATE',
   DERIVATION_PROJECTION_COLUMN_STATE = 'DERIVATION_PROJECTION_COLUMN_STATE',
   RESULT_SET_MODIFIER_STATE = 'RESULT_SET_MODIFIER_STATE',
@@ -85,6 +86,7 @@ export enum QUERY_BUILDER_STATE_HASH_STRUCTURE {
   TDS_WINDOW_OPERATOR_MIN = 'TDS_WINDOW_OPERATOR_MIN',
   TDS_WINDOW_OPERATOR_COUNT = 'TDS_WINDOW_OPERATOR_COUNT',
   TDS_WINDOW_OPERATOR_AVERAGE = 'TDS_WINDOW_OPERATOR_AVERAGE',
+  TDS_WINDOW_OPERATOR_PERCENT_RANK = 'TDS_WINDOW_OPERATOR_PERCENT_RANK',
 
   // filter state
   FILTER_TREE_GROUP_NODE_DATA = 'FILTER_TREE_GROUP_NODE_DATA',

package/src/stores/QueryBuilderTypeaheadHelper.ts

@@ -180,9 +180,9 @@ const buildRawLambda = (
   );
 
   // build getAll function
-  const _class = guaranteeNonNullable(queryBuilderState.class);
+  const _class = guaranteeNonNullable(queryBuilderState.sourceClass);
   const getAllFn = buildGetAllFunction(
-    guaranteeNonNullable(queryBuilderState.class),
+    guaranteeNonNullable(queryBuilderState.sourceClass),
     Multiplicity.ONE,
   );
   const milestoningStereotype = getMilestoneTemporalStereotype(
@@ -220,7 +220,7 @@ const buildRawLambda = (
     colAliases.values.push(colAlias);
     const columnLambda = propertyExpression
       ? buildGenericLambdaFunctionInstanceValue(
-          DEFAULT_LAMBDA_VARIABLE_NAME,
+          [DEFAULT_LAMBDA_VARIABLE_NAME],
           [propertyExpression],
           queryBuilderState.graphManagerState.graph,
         )
@@ -229,7 +229,7 @@ const buildRawLambda = (
       extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG),
     );
     const aggregateLambda = buildGenericLambdaFunctionInstanceValue(
-      DEFAULT_LAMBDA_VARIABLE_NAME,
+      [DEFAULT_LAMBDA_VARIABLE_NAME],
       [
         aggregationOperator.buildAggregateExpression(
           propertyExpression,
@@ -267,7 +267,7 @@ const buildRawLambda = (
     colAliases.values.push(colAlias);
     const columnLambda = propertyExpression
       ? buildGenericLambdaFunctionInstanceValue(
-          DEFAULT_LAMBDA_VARIABLE_NAME,
+          [DEFAULT_LAMBDA_VARIABLE_NAME],
           [propertyExpression],
           queryBuilderState.graphManagerState.graph,
         )
@@ -322,7 +322,7 @@ const buildRawLambda = (
     postFilterExpression.parametersValues.push(value);
   }
   const filterLambda = buildGenericLambdaFunctionInstanceValue(
-    DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME,
+    [DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME],
     [postFilterExpression],
     queryBuilderState.graphManagerState.graph,
   );

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -20,7 +20,7 @@ import {
   isNonNullable,
 } from '@finos/legend-shared';
 import {
-  type Class,
+  Class,
   Multiplicity,
   getMilestoneTemporalStereotype,
   extractElementNameFromPath,
@@ -34,6 +34,7 @@ import {
   SimpleFunctionExpression,
   SUPPORTED_FUNCTIONS,
   RuntimePointer,
+  AccessorInstanceValue,
 } from '@finos/legend-graph';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import { buildFilterExpression } from './filter/QueryBuilderFilterValueSpecificationBuilder.js';
@@ -154,10 +155,6 @@ export const buildLambdaFunction = (
   queryBuilderState: QueryBuilderState,
   options?: LambdaFunctionBuilderOption,
 ): LambdaFunction => {
-  const _class = guaranteeNonNullable(
-    queryBuilderState.class,
-    'Class is required to build query',
-  );
   const lambdaFunction = new LambdaFunction(
     new FunctionType(
       PackageableElementExplicitReference.create(
@@ -167,70 +164,86 @@ export const buildLambdaFunction = (
     ),
   );
 
-  const milestoningStereotype = getMilestoneTemporalStereotype(
-    _class,
-    queryBuilderState.graphManagerState.graph,
+  const sourceElement = guaranteeNonNullable(
+    queryBuilderState.sourceElement,
+    'Source element of type class or accessor is required to build query',
   );
+  if (sourceElement instanceof Class) {
+    const _class = guaranteeNonNullable(
+      queryBuilderState.sourceClass,
+      'Class is required to build query',
+    );
 
-  if (milestoningStereotype && options?.useAllVersionsForMilestoning) {
-    // build getAllVersions() when we preview data for milestoned classes
-    // because if we use getAll() we need to pass in data to execute the query
-    // but we don't give user that option in this flow.
-    const getAllVersionsFunction = buildGetAllVersionsFunction(
+    const milestoningStereotype = getMilestoneTemporalStereotype(
       _class,
-      Multiplicity.ONE,
+      queryBuilderState.graphManagerState.graph,
     );
-    lambdaFunction.expressionSequence[0] = getAllVersionsFunction;
-  } else {
-    switch (queryBuilderState.getAllFunction) {
-      case QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS: {
-        if (milestoningStereotype) {
-          const getAllVersionsFunction = buildGetAllVersionsFunction(
-            _class,
-            Multiplicity.ONE,
-          );
-          lambdaFunction.expressionSequence[0] = getAllVersionsFunction;
-        } else {
-          throw new UnsupportedOperationError(
-            `Unable to build query lamdba: getAllVersions() expects source class to be milestoned`,
-          );
+
+    if (milestoningStereotype && options?.useAllVersionsForMilestoning) {
+      // build getAllVersions() when we preview data for milestoned classes
+      // because if we use getAll() we need to pass in data to execute the query
+      // but we don't give user that option in this flow.
+      const getAllVersionsFunction = buildGetAllVersionsFunction(
+        _class,
+        Multiplicity.ONE,
+      );
+      lambdaFunction.expressionSequence[0] = getAllVersionsFunction;
+    } else {
+      switch (queryBuilderState.getAllFunction) {
+        case QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS: {
+          if (milestoningStereotype) {
+            const getAllVersionsFunction = buildGetAllVersionsFunction(
+              _class,
+              Multiplicity.ONE,
+            );
+            lambdaFunction.expressionSequence[0] = getAllVersionsFunction;
+          } else {
+            throw new UnsupportedOperationError(
+              `Unable to build query lamdba: getAllVersions() expects source class to be milestoned`,
+            );
+          }
+          break;
         }
-        break;
-      }
-      case QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE: {
-        if (milestoningStereotype) {
-          const getAllVersionsInRangeFunction =
-            buildGetAllVersionsInRangeFunction(_class, Multiplicity.ONE);
-          queryBuilderState.milestoningState
-            .getMilestoningImplementation(milestoningStereotype)
-            .buildGetAllVersionsInRangeParameters(
-              getAllVersionsInRangeFunction,
+        case QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE: {
+          if (milestoningStereotype) {
+            const getAllVersionsInRangeFunction =
+              buildGetAllVersionsInRangeFunction(_class, Multiplicity.ONE);
+            queryBuilderState.milestoningState
+              .getMilestoningImplementation(milestoningStereotype)
+              .buildGetAllVersionsInRangeParameters(
+                getAllVersionsInRangeFunction,
+              );
+            lambdaFunction.expressionSequence[0] =
+              getAllVersionsInRangeFunction;
+          } else {
+            throw new UnsupportedOperationError(
+              `Unable to build query lamdba: getAllVersionsInRange() expects source class to be milestoned`,
             );
-          lambdaFunction.expressionSequence[0] = getAllVersionsInRangeFunction;
-        } else {
-          throw new UnsupportedOperationError(
-            `Unable to build query lamdba: getAllVersionsInRange() expects source class to be milestoned`,
-          );
+          }
+          break;
         }
-        break;
-      }
-      case QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL: {
-        // build getAll()
-        const getAllFunction = buildGetAllFunction(_class, Multiplicity.ONE);
-        if (milestoningStereotype) {
-          // build milestoning parameter(s) for getAll()
-          queryBuilderState.milestoningState
-            .getMilestoningImplementation(milestoningStereotype)
-            .buildGetAllParameters(getAllFunction);
+        case QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL: {
+          // build getAll()
+          const getAllFunction = buildGetAllFunction(_class, Multiplicity.ONE);
+          if (milestoningStereotype) {
+            // build milestoning parameter(s) for getAll()
+            queryBuilderState.milestoningState
+              .getMilestoningImplementation(milestoningStereotype)
+              .buildGetAllParameters(getAllFunction);
+          }
+          lambdaFunction.expressionSequence[0] = getAllFunction;
+          break;
         }
-        lambdaFunction.expressionSequence[0] = getAllFunction;
-        break;
+        default:
+          throw new UnsupportedOperationError(
+            `Unable to build query lambda: unknown ${queryBuilderState.getAllFunction} function`,
+          );
       }
-      default:
-        throw new UnsupportedOperationError(
-          `Unable to build query lambda: unknown ${queryBuilderState.getAllFunction} function`,
-        );
     }
+  } else {
+    const accessorInstanceValue = new AccessorInstanceValue();
+    accessorInstanceValue.values = [sourceElement];
+    lambdaFunction.expressionSequence[0] = accessorInstanceValue;
   }
 
   // build watermark

package/src/stores/QueryBuilderValueSpecificationHelper.ts

@@ -299,7 +299,7 @@ export const generateDefaultValueForPrimitiveType = (
 };
 
 export const buildGenericLambdaFunctionInstanceValue = (
-  lambdaParameterName: string,
+  lambdaParameterNames: string[],
   lambdaBodyExpressions: ValueSpecification[],
   graph: PureModel,
 ): LambdaFunctionInstanceValue => {
@@ -310,9 +310,11 @@ export const buildGenericLambdaFunctionInstanceValue = (
     ),
     Multiplicity.ONE,
   );
-  functionType.parameters.push(
-    new VariableExpression(lambdaParameterName, Multiplicity.ONE),
+
+  functionType.parameters = lambdaParameterNames.map(
+    (parameterName) => new VariableExpression(parameterName, Multiplicity.ONE),
   );
+
   const lambdaFunction = new LambdaFunction(functionType);
   lambdaFunction.expressionSequence = lambdaBodyExpressions;
   functionInstanceValue.values.push(lambdaFunction);

package/src/stores/__test-utils__/QueryBuilderStateTestUtils.ts

@@ -140,7 +140,7 @@ export const TEST__setUpQueryBuilderState = async (
   }
   if (executionContext) {
     const graph = queryBuilderState.graphManagerState.graph;
-    queryBuilderState.class = graph.getClass(executionContext._class);
+    queryBuilderState.sourceElement = graph.getClass(executionContext._class);
     queryBuilderState.executionContextState.mapping = graph.getMapping(
       executionContext.mapping,
     );