@finos/legend-query-builder 4.14.30 → 4.14.32

package/src/stores/QueryBuilderStateBuilder.ts

@@ -26,7 +26,7 @@ import {
 } from '@finos/legend-shared';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import {
-  type AbstractPropertyExpression,
+  AbstractPropertyExpression,
   type EnumValueInstanceValue,
   type FunctionExpression,
   type GraphFetchTreeInstanceValue,
@@ -36,7 +36,8 @@ import {
   type INTERNAL__PropagatedValue,
   type ValueSpecification,
   type CollectionInstanceValue,
-  type LambdaFunctionInstanceValue,
+  LambdaFunctionInstanceValue,
+  type ColSpecArrayInstance,
   InstanceValue,
   INTERNAL__UnknownValueSpecification,
   matchFunctionName,
@@ -92,6 +93,10 @@ import {
 import { checkIfEquivalent } from './milestoning/QueryBuilderMilestoningHelper.js';
 import type { QueryBuilderParameterValue } from './QueryBuilderParametersState.js';
 import { QueryBuilderEmbeddedFromExecutionContextState } from './QueryBuilderExecutionContextState.js';
+import {
+  isTypedProjectionExpression,
+  processTypedTDSProjectExpression,
+} from './fetch-structure/tds/projection/QueryBuilderTypedProjectionStateBuilder.js';
 
 const processGetAllExpression = (
   expression: SimpleFunctionExpression,
@@ -481,6 +486,7 @@ export class QueryBuilderValueSpecificationProcessor
     ) {
       processTDSProjectionDerivationExpression(
         valueSpecification,
+        undefined,
         this.parentExpression,
         this.queryBuilderState,
       );
@@ -637,16 +643,25 @@ export class QueryBuilderValueSpecificationProcessor
       );
       return;
     } else if (
-      matchFunctionName(
-        functionName,
+      matchFunctionName(functionName, [
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-      )
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PROJECT,
+      ])
     ) {
-      processTDSProjectExpression(
-        valueSpecification,
-        this.queryBuilderState,
-        this.parentLambda,
-      );
+      if (isTypedProjectionExpression(valueSpecification)) {
+        processTypedTDSProjectExpression(
+          valueSpecification,
+          this.queryBuilderState,
+          this.parentLambda,
+        );
+      } else {
+        processTDSProjectExpression(
+          valueSpecification,
+          this.queryBuilderState,
+          this.parentLambda,
+        );
+      }
+
       return;
     } else if (
       matchFunctionName(
@@ -835,6 +850,7 @@ export class QueryBuilderValueSpecificationProcessor
     if (
       matchFunctionName(this.parentExpression.functionName, [
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PROJECT,
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
         ...Object.values(
@@ -844,6 +860,7 @@ export class QueryBuilderValueSpecificationProcessor
     ) {
       processTDSProjectionColumnPropertyExpression(
         valueSpecification,
+        undefined,
         this.queryBuilderState,
       );
       return;
@@ -903,6 +920,62 @@ export class QueryBuilderValueSpecificationProcessor
   ): void {
     throw new UnsupportedOperationError();
   }
+
+  visit_ColSpecArrayInstance(valueSpecification: ColSpecArrayInstance): void {
+    assertNonNullable(
+      this.parentExpression,
+      `Can't process col spec aray instance: parent expression cannot be retrieved`,
+    );
+
+    if (
+      matchFunctionName(this.parentExpression.functionName, [
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PROJECT,
+      ])
+    ) {
+      const spec = valueSpecification.values;
+      assertTrue(
+        spec.length === 1,
+        `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,
+          );
+        } 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,
+          );
+        }
+      });
+
+      return;
+    }
+    throw new UnsupportedOperationError(
+      `Can't process col spec array expression with parent expression of function ${this.parentExpression.functionName}()`,
+    );
+  }
 }
 
 export const processParameters = (

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -205,4 +205,9 @@ export type LambdaFunctionBuilderOption = {
    * limit for the query results if it exists so the exported results contain all the data
    */
   isExportingResult?: boolean | undefined;
+  /**
+   * Set this flag to `true` when you want to write to typed TDS function using the `Relation`
+   * typed in engine. This is still an experimental feature, hence we should only enable this flag when user wants to enable this directly.
+   */
+  useTypedRelationFunctions?: boolean | undefined;
 };

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

@@ -41,7 +41,7 @@ import {
   INTERNAL__BasicQueryBuilderState,
   type QueryBuilderState,
 } from '../QueryBuilderState.js';
-import { QueryBuilderAdvancedWorkflowState } from '../workflow/QueryBuilderWorkFlowState.js';
+import { QueryBuilderAdvancedWorkflowState } from '../query-workflow/QueryBuilderWorkFlowState.js';
 
 export class TEST__LegendApplicationPluginManager
   extends LegendApplicationPluginManager<LegendApplicationPlugin>

package/src/stores/fetch-structure/QueryBuilderFetchStructureImplementationState.ts

@@ -58,6 +58,7 @@ export abstract class QueryBuilderFetchStructureImplementationState
   abstract get usedExplorerTreePropertyNodeIDs(): string[];
   abstract get fetchStructureValidationIssues(): string[];
   abstract get allValidationIssues(): string[];
+  abstract get fetchLabel(): string;
 
   abstract onClassChange(_class: Class | undefined): void;
   abstract revealCompilationError(compilationError: CompilationError): boolean;

package/src/stores/fetch-structure/QueryBuilderFetchStructureState.ts

@@ -29,6 +29,21 @@ import {
   type QueryBuilderFetchStructureImplementationState,
 } from './QueryBuilderFetchStructureImplementationState.js';
 
+export const onChangeFetchStructureImplementation =
+  (
+    implementationType: FETCH_STRUCTURE_IMPLEMENTATION,
+    fetchStructureState: QueryBuilderFetchStructureState,
+  ): (() => void) =>
+  (): void => {
+    if (fetchStructureState.implementation.type !== implementationType) {
+      fetchStructureState.implementation.checkBeforeChangingImplementation(
+        () => {
+          fetchStructureState.changeImplementation(implementationType);
+        },
+      );
+    }
+  };
+
 export class QueryBuilderFetchStructureState {
   readonly queryBuilderState: QueryBuilderState;
   implementation: QueryBuilderFetchStructureImplementationState;

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts

@@ -292,6 +292,7 @@ export class QueryBuilderGraphFetchTreeState
       setSerializationState: action,
       setChecked: action,
       initialize: action,
+      checkBeforeChangingImplementation: action,
     });
 
     // try to initialize the graph-fetch tree data using the setup class
@@ -304,6 +305,10 @@ export class QueryBuilderGraphFetchTreeState
     return FETCH_STRUCTURE_IMPLEMENTATION.GRAPH_FETCH;
   }
 
+  override get fetchLabel(): string {
+    return 'Class Properties';
+  }
+
   get usedExplorerTreePropertyNodeIDs(): string[] {
     if (!this.treeData) {
       return [];

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -154,6 +154,7 @@ export class QueryBuilderTDSState
       initializeWithQuery: action,
       setShowPostFilterPanel: action,
       setShowWindowFuncPanel: action,
+      checkBeforeChangingImplementation: action,
       convertDerivationProjectionObjects: flow,
       fetchDerivedReturnTypes: flow,
     });
@@ -194,6 +195,10 @@ export class QueryBuilderTDSState
     );
   }
 
+  override get fetchLabel(): string {
+    return 'Columns';
+  }
+
   override get TEMPORARY__showPostFetchStructurePanel(): boolean {
     return (
       this.queryBuilderState.filterState.showPanel ||

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

@@ -44,7 +44,7 @@ import {
   QUERY_BUILDER_SUPPORTED_FUNCTIONS,
   QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
 } from '../../../../graph/QueryBuilderMetaModelConst.js';
-import type { QueryBuilderState } from '../../../QueryBuilderState.js';
+import { type QueryBuilderState } from '../../../QueryBuilderState.js';
 import { QueryBuilderValueSpecificationProcessor } from '../../../QueryBuilderStateBuilder.js';
 import {
   extractNullableNumberFromInstanceValue,
@@ -142,6 +142,7 @@ export const processTDSProjectExpression = (
 
 export const processTDSProjectionColumnPropertyExpression = (
   expression: AbstractPropertyExpression,
+  columnName: string | undefined,
   queryBuilderState: QueryBuilderState,
 ): void => {
   if (
@@ -200,7 +201,9 @@ export const processTDSProjectionColumnPropertyExpression = (
     );
 
     tdsState.addColumn(columnState, { skipSorting: true });
-
+    if (columnName) {
+      columnState.setColumnName(columnName);
+    }
     // NOTE: technically we should set the lambda parameter name when we process
     // the lambda, not when we process the lambda body like this, but that requires
     // some setup, so it's easier to do it here. The validation of this should have
@@ -211,6 +214,7 @@ export const processTDSProjectionColumnPropertyExpression = (
 
 export const processTDSProjectionDerivationExpression = (
   value: INTERNAL__UnknownValueSpecification,
+  columnName: string | undefined,
   parentExpression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
 ): void => {
@@ -236,6 +240,9 @@ export const processTDSProjectionDerivationExpression = (
       new RawLambda(rawLambdaProtocol.parameters, rawLambdaProtocol.body),
     );
     projectionState.addColumn(columnState, { skipSorting: true });
+    if (columnName) {
+      columnState.setColumnName(columnName);
+    }
   }
 };
 

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

@@ -45,10 +45,14 @@ import {
 } from '../QueryResultSetModifierState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
-import { buildPropertyExpressionChain } from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
+import {
+  buildPropertyExpressionChain,
+  type LambdaFunctionBuilderOption,
+} from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
 import { appendOLAPGroupByState } from '../window/QueryBuilderWindowValueSpecificationBuilder.js';
 import { appendPostFilter } from '../post-filter/QueryBuilderPostFilterValueSpecificationBuilder.js';
 import { buildTDSSortTypeExpression } from '../QueryBuilderTDSHelper.js';
+import { buildRelationProjection } from './QueryBuilderRelationProjectValueSpecBuidler.js';
 
 const buildSortExpression = (
   sortColumnState: SortColumnState,
@@ -174,15 +178,7 @@ const appendResultSetModifier = (
 export const appendProjection = (
   tdsState: QueryBuilderTDSState,
   lambdaFunction: LambdaFunction,
-  options?: {
-    /**
-     * Set queryBuilderState to `true` when we construct query for execution within the app.
-     * queryBuilderState will make the lambda function building process overrides several query values, such as the row limit.
-     */
-    isBuildingExecutionQuery?: boolean | undefined;
-    keepSourceInformation?: boolean | undefined;
-    isExportingResult?: boolean | undefined;
-  },
+  options?: LambdaFunctionBuilderOption,
 ): void => {
   const queryBuilderState = tdsState.queryBuilderState;
   const precedingExpression = guaranteeNonNullable(
@@ -327,82 +323,95 @@ export const appendProjection = (
     ];
     lambdaFunction.expressionSequence[0] = groupByFunction;
   } else if (tdsState.projectionColumns.length) {
-    // projection
-    const projectFunction = new SimpleFunctionExpression(
-      extractElementNameFromPath(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.queryBuilderState.isFetchStructureTyped) {
+      // projection
+      const projectFunction = new SimpleFunctionExpression(
+        extractElementNameFromPath(
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
         ),
       );
-      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,
+      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 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),
+        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?
+                  [],
                 )
-                .build(),
+                  .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 {
+          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(
+        precedingExpression,
+        tdsState,
+        options,
+      );
+      lambdaFunction.expressionSequence[0] = projectFunction;
+    }
   }
 
   // build olapGroupBy

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

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2020-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 {
+  ColSpecArray,
+  type ValueSpecification,
+  extractElementNameFromPath,
+  SimpleFunctionExpression,
+  ColSpecArrayInstance,
+  Multiplicity,
+  ColSpec,
+  INTERNAL__UnknownValueSpecification,
+  V1_serializeRawValueSpecification,
+  V1_transformRawLambda,
+  V1_GraphTransformerContextBuilder,
+} from '@finos/legend-graph';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
+import {
+  QueryBuilderDerivationProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from './QueryBuilderProjectionColumnState.js';
+import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
+import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
+import {
+  buildPropertyExpressionChain,
+  type LambdaFunctionBuilderOption,
+} from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+
+export const buildRelationProjection = (
+  precedingExpression: ValueSpecification,
+  tdsState: QueryBuilderTDSState,
+  options?: LambdaFunctionBuilderOption,
+): SimpleFunctionExpression => {
+  const projectFunction = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT),
+  );
+  const queryBuilderState = tdsState.queryBuilderState;
+
+  const instanceVal = new ColSpecArrayInstance(Multiplicity.ONE, undefined);
+
+  const colSepcArray = new ColSpecArray();
+  instanceVal.values = [colSepcArray];
+
+  tdsState.projectionColumns.forEach((projectionColumnState) => {
+    const colSpec = new ColSpec();
+    colSepcArray.colSpecs.push(colSpec);
+    colSpec.name = projectionColumnState.columnName;
+    // 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 relation project() column expression: unsupported projection column state`,
+        projectionColumnState,
+      );
+    }
+    colSpec.function1 = columnLambda;
+  });
+  projectFunction.parametersValues = [precedingExpression, instanceVal];
+  return projectFunction;
+};