@finos/legend-query-builder 4.14.29 → 4.14.31

package/src/stores/QueryBuilderState.ts

@@ -109,6 +109,7 @@ import {
 import type { QueryBuilderConfig } from '../graph-manager/QueryBuilderConfig.js';
 import { QUERY_BUILDER_EVENT } from '../__lib__/QueryBuilderEvent.js';
 import { QueryBuilderChangeHistoryState } from './QueryBuilderChangeHistoryState.js';
+import { type QueryBuilderWorkflowState } from './query-workflow/QueryBuilderWorkFlowState.js';
 
 export interface QuerySDLC {}
 
@@ -118,6 +119,11 @@ export type QueryStateInfo = QuerySDLC & {
   runtime: string;
 };
 
+export enum QUERY_BUILDER_LAMBDA_WRITER_MODE {
+  STANDARD = 'STANDARD',
+  TYPED_FETCH_STRUCTURE = 'TYPED_FETCH_STRUCTURE',
+}
+
 export abstract class QueryBuilderState implements CommandRegistrar {
   readonly applicationStore: GenericLegendApplicationStore;
   readonly graphManagerState: GraphManagerState;
@@ -126,6 +132,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   readonly queryCompileState = ActionState.create();
   readonly observerContext: ObserverContext;
   readonly config: QueryBuilderConfig | undefined;
+  readonly workflowState: QueryBuilderWorkflowState;
 
   explorerState: QueryBuilderExplorerState;
   functionsExplorerState: QueryFunctionsExplorerState;
@@ -150,6 +157,8 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   isQueryChatOpened = false;
   isLocalModeEnabled = false;
 
+  lambdaWriteMode = QUERY_BUILDER_LAMBDA_WRITER_MODE.STANDARD;
+
   class?: Class | undefined;
   getAllFunction: QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS =
     QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL;
@@ -168,6 +177,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   constructor(
     applicationStore: GenericLegendApplicationStore,
     graphManagerState: GraphManagerState,
+    workflowState: QueryBuilderWorkflowState,
     config: QueryBuilderConfig | undefined,
     sourceInfo?: QuerySDLC | undefined,
   ) {
@@ -196,6 +206,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       isQueryChatOpened: observable,
       isLocalModeEnabled: observable,
       getAllFunction: observable,
+      lambdaWriteMode: observable,
 
       sideBarClassName: computed,
       isQuerySupported: computed,
@@ -210,6 +221,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       setIsQueryChatOpened: action,
       setIsLocalModeEnabled: action,
       setGetAllFunction: action,
+      setLambdaWriteMode: action,
 
       resetQueryResult: action,
       resetQueryContent: action,
@@ -245,6 +257,8 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.changeDetectionState = new QueryBuilderChangeDetectionState(this);
     this.changeHistoryState = new QueryBuilderChangeHistoryState(this);
     this.config = config;
+
+    this.workflowState = workflowState;
     this.sourceInfo = sourceInfo;
   }
 
@@ -290,6 +304,17 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     return this.allVariables.map((e) => e.name);
   }
 
+  get isFetchStructureTyped(): boolean {
+    return (
+      this.lambdaWriteMode ===
+      QUERY_BUILDER_LAMBDA_WRITER_MODE.TYPED_FETCH_STRUCTURE
+    );
+  }
+
+  setLambdaWriteMode(val: QUERY_BUILDER_LAMBDA_WRITER_MODE): void {
+    this.lambdaWriteMode = val;
+  }
+
   getQueryExecutionContext(): QueryExecutionContext {
     const queryExeContext = new QueryExplicitExecutionContext();
     const runtimeValue = guaranteeType(
@@ -528,6 +553,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     return buildRawLambdaFromLambdaFunction(
       buildLambdaFunction(this, {
         keepSourceInformation: Boolean(options?.keepSourceInformation),
+        useTypedRelationFunctions: this.isFetchStructureTyped,
       }),
       this.graphManagerState,
     );
@@ -789,6 +815,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     const basicState = new INTERNAL__BasicQueryBuilderState(
       this.applicationStore,
       this.graphManagerState,
+      this.workflowState,
       undefined,
     );
     basicState.class = this.class;

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,
@@ -481,6 +482,7 @@ export class QueryBuilderValueSpecificationProcessor
     ) {
       processTDSProjectionDerivationExpression(
         valueSpecification,
+        undefined,
         this.parentExpression,
         this.queryBuilderState,
       );
@@ -637,10 +639,10 @@ export class QueryBuilderValueSpecificationProcessor
       );
       return;
     } else if (
-      matchFunctionName(
-        functionName,
+      matchFunctionName(functionName, [
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-      )
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PROJECT,
+      ])
     ) {
       processTDSProjectExpression(
         valueSpecification,
@@ -835,6 +837,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 +847,7 @@ export class QueryBuilderValueSpecificationProcessor
     ) {
       processTDSProjectionColumnPropertyExpression(
         valueSpecification,
+        undefined,
         this.queryBuilderState,
       );
       return;
@@ -903,6 +907,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,6 +41,7 @@ import {
   INTERNAL__BasicQueryBuilderState,
   type QueryBuilderState,
 } from '../QueryBuilderState.js';
+import { QueryBuilderAdvancedWorkflowState } from '../query-workflow/QueryBuilderWorkFlowState.js';
 
 export class TEST__LegendApplicationPluginManager
   extends LegendApplicationPluginManager<LegendApplicationPlugin>
@@ -131,6 +132,7 @@ export const TEST__setUpQueryBuilderState = async (
   const queryBuilderState = new INTERNAL__BasicQueryBuilderState(
     applicationStore,
     graphManagerState,
+    QueryBuilderAdvancedWorkflowState.INSTANCE,
     undefined,
   );
   if (rawLambda) {

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

@@ -28,6 +28,7 @@ import {
   V1_RawLambda,
   VariableExpression,
   PrimitiveInstanceValue,
+  ColSpecArrayInstance,
 } from '@finos/legend-graph';
 import {
   assertNonNullable,
@@ -44,7 +45,10 @@ import {
   QUERY_BUILDER_SUPPORTED_FUNCTIONS,
   QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS,
 } from '../../../../graph/QueryBuilderMetaModelConst.js';
-import type { QueryBuilderState } from '../../../QueryBuilderState.js';
+import {
+  QUERY_BUILDER_LAMBDA_WRITER_MODE,
+  type QueryBuilderState,
+} from '../../../QueryBuilderState.js';
 import { QueryBuilderValueSpecificationProcessor } from '../../../QueryBuilderStateBuilder.js';
 import {
   extractNullableNumberFromInstanceValue,
@@ -59,11 +63,74 @@ import {
 import { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 import { SortColumnState } from '../QueryResultSetModifierState.js';
 
+export const processTypedTDSProjectExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
+): void => {
+  // check parameters
+  assertTrue(
+    expression.parametersValues.length === 2,
+    `Can't process project() expression: project() expects 2 arguments`,
+  );
+  // update fetch-structure
+  queryBuilderState.fetchStructureState.changeImplementation(
+    FETCH_STRUCTURE_IMPLEMENTATION.TABULAR_DATA_STRUCTURE,
+  );
+
+  // check preceding expression
+  const precedingExpression = guaranteeType(
+    expression.parametersValues[0],
+    SimpleFunctionExpression,
+    `Can't process project() expression: only support project() immediately following an expression`,
+  );
+  assertTrue(
+    matchFunctionName(precedingExpression.functionName, [
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
+      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.WATERMARK,
+    ]),
+    `Can't process project() expression: only support project() immediately following either getAll(), filter(), or forWatermark()`,
+  );
+  QueryBuilderValueSpecificationProcessor.process(
+    precedingExpression,
+    parentLambda,
+    queryBuilderState,
+  );
+  // check columns
+  const classInstance = expression.parametersValues[1];
+  assertType(
+    classInstance,
+    ColSpecArrayInstance,
+    `Can't process project() expression: project() expects argument #1 to be a ColSpecArrayInstance`,
+  );
+  queryBuilderState.setLambdaWriteMode(
+    QUERY_BUILDER_LAMBDA_WRITER_MODE.TYPED_FETCH_STRUCTURE,
+  );
+  QueryBuilderValueSpecificationProcessor.processChild(
+    classInstance,
+    expression,
+    parentLambda,
+    queryBuilderState,
+  );
+};
+
 export const processTDSProjectExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
   parentLambda: LambdaFunction,
 ): void => {
+  if (expression.parametersValues.length === 2) {
+    processTypedTDSProjectExpression(
+      expression,
+      queryBuilderState,
+      parentLambda,
+    );
+
+    return;
+  }
   // update fetch-structure
   queryBuilderState.fetchStructureState.changeImplementation(
     FETCH_STRUCTURE_IMPLEMENTATION.TABULAR_DATA_STRUCTURE,
@@ -142,6 +209,7 @@ export const processTDSProjectExpression = (
 
 export const processTDSProjectionColumnPropertyExpression = (
   expression: AbstractPropertyExpression,
+  columnName: string | undefined,
   queryBuilderState: QueryBuilderState,
 ): void => {
   if (
@@ -200,7 +268,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 +281,7 @@ export const processTDSProjectionColumnPropertyExpression = (
 
 export const processTDSProjectionDerivationExpression = (
   value: INTERNAL__UnknownValueSpecification,
+  columnName: string | undefined,
   parentExpression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,
 ): void => {
@@ -236,6 +307,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