@finos/legend-query-builder 4.14.51 → 4.14.53

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

@@ -28,6 +28,7 @@ import {
   V1_RawLambda,
   VariableExpression,
   PrimitiveInstanceValue,
+  LambdaFunctionInstanceValue,
 } from '@finos/legend-graph';
 import {
   assertNonNullable,
@@ -59,22 +60,11 @@ import {
 import { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 import { SortColumnState } from '../QueryResultSetModifierState.js';
 
-export const processTDSProjectExpression = (
+const validateTDSProjectPrecedingExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
   parentLambda: LambdaFunction,
 ): void => {
-  // update fetch-structure
-  queryBuilderState.fetchStructureState.changeImplementation(
-    FETCH_STRUCTURE_IMPLEMENTATION.TABULAR_DATA_STRUCTURE,
-  );
-
-  // check parameters
-  assertTrue(
-    expression.parametersValues.length === 3,
-    `Can't process project() expression: project() expects 2 arguments`,
-  );
-
   // check preceding expression
   const precedingExpression = guaranteeType(
     expression.parametersValues[0],
@@ -96,47 +86,143 @@ export const processTDSProjectExpression = (
     parentLambda,
     queryBuilderState,
   );
+};
+
+// process project() that uses col()
+const processTDSProjectColExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
+): void => {
+  // update fetch-structure
+  queryBuilderState.fetchStructureState.changeImplementation(
+    FETCH_STRUCTURE_IMPLEMENTATION.TABULAR_DATA_STRUCTURE,
+  );
+  // check parameters
+  assertTrue(
+    expression.parametersValues.length === 2,
+    `Can't process project() expression: project() expects 2 arguments`,
+  );
+
+  validateTDSProjectPrecedingExpression(
+    expression,
+    queryBuilderState,
+    parentLambda,
+  );
 
   // check columns
   const columnLambdas = expression.parametersValues[1];
-  assertType(
-    columnLambdas,
-    CollectionInstanceValue,
-    `Can't process project() expression: project() expects argument #1 to be a collection`,
-  );
-  columnLambdas.values.map((value) =>
+  if (columnLambdas instanceof CollectionInstanceValue) {
+    columnLambdas.values.map((value) =>
+      QueryBuilderValueSpecificationProcessor.processChild(
+        value,
+        expression,
+        parentLambda,
+        queryBuilderState,
+      ),
+    );
+  } else {
+    assertType(
+      columnLambdas,
+      SimpleFunctionExpression,
+      `Can't process project() expression: project() expects argument #1 to be a function expression`,
+    );
     QueryBuilderValueSpecificationProcessor.processChild(
-      value,
+      columnLambdas,
       expression,
       parentLambda,
       queryBuilderState,
-    ),
-  );
+    );
+  }
+};
 
-  // check column aliases
-  const columnAliases = expression.parametersValues[2];
-  assertType(
-    columnAliases,
-    CollectionInstanceValue,
-    `Can't process project() expression: project() expects argument #2 to be a collection`,
-  );
-  assertTrue(
-    columnLambdas.values.length === columnAliases.values.length,
-    `Can't process project() expression: number of aliases does not match the number of columns`,
-  );
-  const aliases = columnAliases.values
-    .map(extractNullableStringFromInstanceValue)
-    .filter(isNonNullable);
+/**
+ *  process project()
+ *  variants could be:
+ *  Person.all()->project([x|x.firmID], ['Id'])
+ *  Person.all()->project(x|x.firmID, ['Id'])
+ *  Person.all()->project([x|x.firmID], 'Id')
+ *  Person.all()->project(x|x.firmID, 'Id')
+ *  Person.all()->project(col({p:my::Person[1]|$p.firmID}, 'Id'))
+ *  Person.all()->project([ col({p:my::Person[1]|$p.firmID}, 'Id') ])
+ */
+export const processTDSProjectExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
+): void => {
+  if (expression.parametersValues.length === 2) {
+    processTDSProjectColExpression(expression, queryBuilderState, parentLambda);
+  } else {
+    // update fetch-structure
+    queryBuilderState.fetchStructureState.changeImplementation(
+      FETCH_STRUCTURE_IMPLEMENTATION.TABULAR_DATA_STRUCTURE,
+    );
 
-  // build state
-  if (
-    queryBuilderState.fetchStructureState.implementation instanceof
-    QueryBuilderTDSState
-  ) {
-    const tdsState = queryBuilderState.fetchStructureState.implementation;
-    tdsState.projectionColumns.forEach((column, idx) =>
-      column.setColumnName(aliases[idx] as string),
+    // check parameters
+    assertTrue(
+      expression.parametersValues.length === 3,
+      `Can't process project() expression: project() expects 3 arguments`,
+    );
+
+    // check preceding expression
+    validateTDSProjectPrecedingExpression(
+      expression,
+      queryBuilderState,
+      parentLambda,
+    );
+
+    // check columns
+    const columnLambdas = expression.parametersValues[1];
+    assertType(
+      columnLambdas,
+      CollectionInstanceValue,
+      `Can't process project() expression: project() expects argument #1 to be a collection`,
+    );
+    columnLambdas.values.map((value) =>
+      QueryBuilderValueSpecificationProcessor.processChild(
+        value,
+        expression,
+        parentLambda,
+        queryBuilderState,
+      ),
+    );
+
+    // check column aliases
+    const columnAliases = expression.parametersValues[2];
+    let aliases: string[] = [];
+    if (columnAliases instanceof CollectionInstanceValue) {
+      assertType(
+        columnAliases,
+        CollectionInstanceValue,
+        `Can't process project() expression: project() expects argument #2 to be a collection or a string`,
+      );
+      aliases = columnAliases.values
+        .map(extractNullableStringFromInstanceValue)
+        .filter(isNonNullable);
+    } else {
+      assertType(
+        columnAliases,
+        PrimitiveInstanceValue,
+        `Can't process project() expression: project() expects argument #2 to be a collection or string`,
+      );
+      aliases = [columnAliases.values[0] as string];
+    }
+    assertTrue(
+      columnLambdas.values.length === aliases.length,
+      `Can't process project() expression: number of aliases does not match the number of columns`,
     );
+
+    // build state
+    if (
+      queryBuilderState.fetchStructureState.implementation instanceof
+      QueryBuilderTDSState
+    ) {
+      const tdsState = queryBuilderState.fetchStructureState.implementation;
+      tdsState.projectionColumns.forEach((column, idx) =>
+        column.setColumnName(aliases[idx] as string),
+      );
+    }
   }
 };
 
@@ -247,6 +333,44 @@ export const processTDSProjectionDerivationExpression = (
   }
 };
 
+export const processTDSColExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  // check parameters
+  assertTrue(
+    expression.parametersValues.length === 2,
+    `Can't process col() func expression: col() expects 2 argument`,
+  );
+  // check preceding expression
+  const lambdaFunc = guaranteeType(
+    expression.parametersValues[0],
+    LambdaFunctionInstanceValue,
+    `Can't process col() func expressionn: only support col() immediately following an lambda function`,
+  );
+  const colNameInstance = guaranteeType(
+    expression.parametersValues[1],
+    PrimitiveInstanceValue,
+    `Can't process col() func expression: the #2 argument of col() should be a string`,
+  );
+  processTDSProjectionColumnPropertyExpression(
+    guaranteeType(
+      lambdaFunc.values[0]?.expressionSequence[0],
+      AbstractPropertyExpression,
+      `Can't process col() func expression: lambda function of col() should contain AbstractPropertyExpression`,
+    ),
+    colNameInstance.values[0] as string,
+    queryBuilderState,
+  );
+  if (
+    queryBuilderState.fetchStructureState.implementation instanceof
+    QueryBuilderTDSState
+  ) {
+    const tdsState = queryBuilderState.fetchStructureState.implementation;
+    tdsState.setUseColFunc(true);
+  }
+};
+
 export const processTDSTakeExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,

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

@@ -16,13 +16,13 @@
 
 import {
   type LambdaFunction,
+  type ValueSpecification,
   CollectionInstanceValue,
   extractElementNameFromPath,
   GenericType,
   GenericTypeExplicitReference,
   PrimitiveInstanceValue,
   SimpleFunctionExpression,
-  type ValueSpecification,
   INTERNAL__UnknownValueSpecification,
   V1_serializeRawValueSpecification,
   V1_transformRawLambda,
@@ -35,6 +35,7 @@ import {
   UnsupportedOperationError,
 } from '@finos/legend-shared';
 import {
+  type QueryBuilderProjectionColumnState,
   QueryBuilderDerivationProjectionColumnState,
   QueryBuilderSimpleProjectionColumnState,
 } from './QueryBuilderProjectionColumnState.js';
@@ -175,6 +176,62 @@ const appendResultSetModifier = (
   return lambdaFunction;
 };
 
+const buildProjectColFunc = (
+  tdsState: QueryBuilderTDSState,
+  projectionColumnState: QueryBuilderProjectionColumnState,
+  options?: LambdaFunctionBuilderOption,
+): SimpleFunctionExpression => {
+  const colFunc = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_COL),
+  );
+  let columnLambda: ValueSpecification;
+  if (
+    projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
+  ) {
+    columnLambda = buildGenericLambdaFunctionInstanceValue(
+      projectionColumnState.lambdaParameterName,
+      [
+        buildPropertyExpressionChain(
+          projectionColumnState.propertyExpressionState.propertyExpression,
+          projectionColumnState.propertyExpressionState.queryBuilderState,
+          projectionColumnState.lambdaParameterName,
+          options,
+        ),
+      ],
+      tdsState.queryBuilderState.graphManagerState.graph,
+    );
+  } else if (
+    projectionColumnState instanceof QueryBuilderDerivationProjectionColumnState
+  ) {
+    columnLambda = new INTERNAL__UnknownValueSpecification(
+      V1_serializeRawValueSpecification(
+        V1_transformRawLambda(
+          projectionColumnState.lambda,
+          new V1_GraphTransformerContextBuilder(
+            // TODO?: do we need to include the plugins here?
+            [],
+          )
+            .withKeepSourceInformationFlag(
+              Boolean(options?.keepSourceInformation),
+            )
+            .build(),
+        ),
+      ),
+    );
+  } else {
+    throw new UnsupportedOperationError(
+      `Can't build project() column expression: unsupported projection column state`,
+      projectionColumnState,
+    );
+  }
+  const colAlias = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(new GenericType(PrimitiveType.STRING)),
+  );
+  colAlias.values.push(projectionColumnState.columnName);
+  colFunc.parametersValues = [columnLambda, colAlias];
+  return colFunc;
+};
+
 export const appendProjection = (
   tdsState: QueryBuilderTDSState,
   lambdaFunction: LambdaFunction,
@@ -330,79 +387,98 @@ export const appendProjection = (
           QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
         ),
       );
-      const colLambdas = new CollectionInstanceValue(
-        queryBuilderState.graphManagerState.graph.getMultiplicity(
-          tdsState.projectionColumns.length,
-          tdsState.projectionColumns.length,
-        ),
-      );
-      const colAliases = new CollectionInstanceValue(
-        queryBuilderState.graphManagerState.graph.getMultiplicity(
-          tdsState.projectionColumns.length,
-          tdsState.projectionColumns.length,
-        ),
-      );
-      tdsState.projectionColumns.forEach((projectionColumnState) => {
-        // column alias
-        const colAlias = new PrimitiveInstanceValue(
-          GenericTypeExplicitReference.create(
-            new GenericType(PrimitiveType.STRING),
+      if (tdsState.useColFunc) {
+        const colFuncCollection = new CollectionInstanceValue(
+          queryBuilderState.graphManagerState.graph.getMultiplicity(
+            tdsState.projectionColumns.length,
+            tdsState.projectionColumns.length,
           ),
         );
-        colAlias.values.push(projectionColumnState.columnName);
-        colAliases.values.push(colAlias);
-
-        // column projection
-        let columnLambda: ValueSpecification;
-        if (
-          projectionColumnState instanceof
-          QueryBuilderSimpleProjectionColumnState
-        ) {
-          columnLambda = buildGenericLambdaFunctionInstanceValue(
-            projectionColumnState.lambdaParameterName,
-            [
-              buildPropertyExpressionChain(
-                projectionColumnState.propertyExpressionState
-                  .propertyExpression,
-                projectionColumnState.propertyExpressionState.queryBuilderState,
-                projectionColumnState.lambdaParameterName,
-                options,
-              ),
-            ],
-            queryBuilderState.graphManagerState.graph,
+        tdsState.projectionColumns.forEach((projectionColumnState) => {
+          colFuncCollection.values.push(
+            buildProjectColFunc(tdsState, projectionColumnState, options),
           );
-        } else if (
-          projectionColumnState instanceof
-          QueryBuilderDerivationProjectionColumnState
-        ) {
-          columnLambda = new INTERNAL__UnknownValueSpecification(
-            V1_serializeRawValueSpecification(
-              V1_transformRawLambda(
-                projectionColumnState.lambda,
-                new V1_GraphTransformerContextBuilder(
-                  // TODO?: do we need to include the plugins here?
-                  [],
-                )
-                  .withKeepSourceInformationFlag(
-                    Boolean(options?.keepSourceInformation),
-                  )
-                  .build(),
-              ),
+        });
+        projectFunction.parametersValues = [
+          precedingExpression,
+          colFuncCollection,
+        ];
+      } else {
+        const colLambdas = new CollectionInstanceValue(
+          queryBuilderState.graphManagerState.graph.getMultiplicity(
+            tdsState.projectionColumns.length,
+            tdsState.projectionColumns.length,
+          ),
+        );
+        const colAliases = new CollectionInstanceValue(
+          queryBuilderState.graphManagerState.graph.getMultiplicity(
+            tdsState.projectionColumns.length,
+            tdsState.projectionColumns.length,
+          ),
+        );
+        tdsState.projectionColumns.forEach((projectionColumnState) => {
+          // column alias
+          const colAlias = new PrimitiveInstanceValue(
+            GenericTypeExplicitReference.create(
+              new GenericType(PrimitiveType.STRING),
             ),
           );
-        } else {
-          throw new UnsupportedOperationError(
-            `Can't build project() column expression: unsupported projection column state`,
-            projectionColumnState,
-          );
-        }
-        colLambdas.values.push(columnLambda);
-      });
-      projectFunction.parametersValues = [
-        precedingExpression,
-        colLambdas,
-        colAliases,
-      ];
+          colAlias.values.push(projectionColumnState.columnName);
+          colAliases.values.push(colAlias);
+
+          // column projection
+          let columnLambda: ValueSpecification;
+          if (
+            projectionColumnState instanceof
+            QueryBuilderSimpleProjectionColumnState
+          ) {
+            columnLambda = buildGenericLambdaFunctionInstanceValue(
+              projectionColumnState.lambdaParameterName,
+              [
+                buildPropertyExpressionChain(
+                  projectionColumnState.propertyExpressionState
+                    .propertyExpression,
+                  projectionColumnState.propertyExpressionState
+                    .queryBuilderState,
+                  projectionColumnState.lambdaParameterName,
+                  options,
+                ),
+              ],
+              queryBuilderState.graphManagerState.graph,
+            );
+          } else if (
+            projectionColumnState instanceof
+            QueryBuilderDerivationProjectionColumnState
+          ) {
+            columnLambda = new INTERNAL__UnknownValueSpecification(
+              V1_serializeRawValueSpecification(
+                V1_transformRawLambda(
+                  projectionColumnState.lambda,
+                  new V1_GraphTransformerContextBuilder(
+                    // TODO?: do we need to include the plugins here?
+                    [],
+                  )
+                    .withKeepSourceInformationFlag(
+                      Boolean(options?.keepSourceInformation),
+                    )
+                    .build(),
+                ),
+              ),
+            );
+          } else {
+            throw new UnsupportedOperationError(
+              `Can't build project() column expression: unsupported projection column state`,
+              projectionColumnState,
+            );
+          }
+          colLambdas.values.push(columnLambda);
+        });
+        projectFunction.parametersValues = [
+          precedingExpression,
+          colLambdas,
+          colAliases,
+        ];
+      }
       lambdaFunction.expressionSequence[0] = projectFunction;
     } else {
       const projectFunction = buildRelationProjection(

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -415,18 +415,26 @@ export class QueryBuilderFilterTreeConditionNodeData
   implements Hashable
 {
   condition: FilterConditionState;
+  isNewlyAdded: boolean;
 
   constructor(parentId: string | undefined, condition: FilterConditionState) {
     super(parentId);
 
     makeObservable(this, {
       condition: observable,
+      isNewlyAdded: observable,
+      setIsNewlyAdded: action,
       dragPreviewLabel: computed,
     });
 
+    this.isNewlyAdded = false;
     this.condition = condition;
   }
 
+  setIsNewlyAdded(val: boolean): void {
+    this.isNewlyAdded = val;
+  }
+
   get dragPreviewLabel(): string {
     return this.condition.propertyExpressionState.title;
   }

package/src/stores/milestoning/QueryBuilderMilestoningState.ts

@@ -482,20 +482,22 @@ export class QueryBuilderMilestoningState implements Hashable {
   }
 
   updateMilestoningParameterValue(
-    parameter: VariableExpression,
+    parameter: ValueSpecification | undefined,
     value: ValueSpecification | undefined,
   ): void {
-    const variableState =
-      this.queryBuilderState.parametersState.parameterStates.find(
-        (param) => param.parameter.name === parameter.name,
-      );
-    if (variableState) {
-      variableState.setValue(value);
+    if (parameter instanceof VariableExpression) {
+      const variableState =
+        this.queryBuilderState.parametersState.parameterStates.find(
+          (param) => param.parameter.name === parameter.name,
+        );
+      if (variableState) {
+        variableState.setValue(value);
+      }
     }
   }
 
   getMilestoningParameterValue(
-    milestoningParameter: ValueSpecification,
+    milestoningParameter: ValueSpecification | undefined,
   ): ValueSpecification | undefined {
     let value: ValueSpecification | undefined = milestoningParameter;
     if (milestoningParameter instanceof VariableExpression) {
@@ -515,7 +517,18 @@ export class QueryBuilderMilestoningState implements Hashable {
     const usedInProcessingDate = this.processingDate
       ? isValueExpressionReferencedInValue(variable, this.processingDate)
       : false;
-    return usedInBusiness || usedInProcessingDate;
+    const usedInStartDate = this.startDate
+      ? isValueExpressionReferencedInValue(variable, this.startDate)
+      : false;
+    const usedInEndState = this.endDate
+      ? isValueExpressionReferencedInValue(variable, this.endDate)
+      : false;
+    return (
+      usedInBusiness ||
+      usedInProcessingDate ||
+      usedInStartDate ||
+      usedInEndState
+    );
   }
 
   isMilestoningParameter(parameter: VariableExpression): boolean {