@finos/legend-query-builder 4.17.100 → 4.18.0

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

@@ -15,7 +15,6 @@
  */
 
 import type {
-  Class,
   CompilationError,
   LambdaFunction,
   VariableExpression,
@@ -63,7 +62,7 @@ export abstract class QueryBuilderFetchStructureImplementationState
   abstract get fetchLabel(): string;
   abstract get canBeExportedToCube(): boolean;
 
-  abstract onClassChange(_class: Class | undefined): void;
+  abstract onClassChange(): void;
   abstract revealCompilationError(compilationError: CompilationError): boolean;
   abstract clearCompilationError(): void;
   abstract fetchProperty(node: QueryBuilderExplorerTreePropertyNodeData): void;

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

@@ -296,7 +296,7 @@ export class QueryBuilderGraphFetchTreeState
     });
 
     // try to initialize the graph-fetch tree data using the setup class
-    this.updateTreeData(this.queryBuilderState.class);
+    this.updateTreeData(this.queryBuilderState.sourceClass);
     // we will default to standard pure serialization with no config
     this.serializationState = new GraphFetchPureSerializationState(this);
   }
@@ -426,8 +426,9 @@ export class QueryBuilderGraphFetchTreeState
     return;
   }
 
-  onClassChange(_class: Class | undefined): void {
-    this.updateTreeData(_class);
+  onClassChange(): void {
+    // graph-fetch is only applicable for Class sources
+    this.updateTreeData(this.queryBuilderState.sourceClass);
   }
 
   appendFetchStructure(

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

@@ -136,7 +136,7 @@ export const processInternalizeExpression = (
     `Can't process internalize() expression: internalize() return type is missing`,
   );
 
-  queryBuilderState.setClass(_class);
+  queryBuilderState.setSourceElement(_class);
   queryBuilderState.milestoningState.clearMilestoningDates();
   queryBuilderState.explorerState.refreshTreeData();
 

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

@@ -86,6 +86,48 @@ export const getFunctionNameFromTDSSortColumn = (
   }
 };
 
+export const getFunctionNameFromRelationSortColumn = (
+  columnSortType: COLUMN_SORT_TYPE,
+): string => {
+  switch (columnSortType) {
+    case COLUMN_SORT_TYPE.ASC:
+      return extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_ASC,
+      );
+    case COLUMN_SORT_TYPE.DESC:
+      return extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_DESC,
+      );
+    default:
+      throw new UnsupportedOperationError(
+        `Unsupported column sort type ${columnSortType}`,
+      );
+  }
+};
+
+export const getRelationSortColumnFromFunctionName = (
+  functionName: string,
+): COLUMN_SORT_TYPE => {
+  if (
+    matchFunctionName(
+      functionName,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_ASC,
+    )
+  ) {
+    return COLUMN_SORT_TYPE.ASC;
+  } else if (
+    matchFunctionName(
+      functionName,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_DESC,
+    )
+  ) {
+    return COLUMN_SORT_TYPE.DESC;
+  }
+  throw new UnsupportedOperationError(
+    `Unsupported relation sort function: ${functionName}`,
+  );
+};
+
 export const buildTDSSortTypeExpression = (
   sortType: COLUMN_SORT_TYPE,
   column: string,

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

@@ -37,13 +37,13 @@ import {
   hashArray,
   UnsupportedOperationError,
   ContentType,
+  type PlainObject,
 } from '@finos/legend-shared';
 import type { QueryBuilderState } from '../../QueryBuilderState.js';
 import {
   type CompilationError,
   type LambdaFunction,
   type ValueSpecification,
-  type VariableExpression,
   type EngineError,
   GRAPH_MANAGER_EVENT,
   extractSourceInformationCoordinates,
@@ -51,11 +51,16 @@ import {
   RawLambda,
   isStubbed_RawLambda,
   Class,
+  Accessor,
   AbstractPropertyExpression,
   matchFunctionName,
   SimpleFunctionExpression,
   getAllSuperclasses,
   EXECUTION_SERIALIZATION_FORMAT,
+  FunctionExpression,
+  VariableExpression,
+  Multiplicity,
+  type RelationTypeMetadata,
 } from '@finos/legend-graph';
 import {
   DEFAULT_LAMBDA_VARIABLE_NAME,
@@ -78,8 +83,11 @@ import type { QueryBuilderAggregateOperator } from './aggregation/QueryBuilderAg
 import { getQueryBuilderCoreAggregrationOperators } from './aggregation/QueryBuilderAggregateOperatorLoader.js';
 import {
   QueryBuilderDerivationProjectionColumnState,
+  QueryBuilderRelationColumnProjectionColumnState,
   QueryBuilderSimpleProjectionColumnState,
   type QueryBuilderProjectionColumnState,
+  _buildAccessorProjectRawLambda,
+  _decorateRawLambdaWithParametersAndLetExpressions,
 } from './projection/QueryBuilderProjectionColumnState.js';
 import type { QueryBuilderFetchStructureState } from '../QueryBuilderFetchStructureState.js';
 import {
@@ -284,6 +292,10 @@ export class QueryBuilderTDSState
         }
 
         nodeIDs = nodeIDs.concat(ids);
+      } else if (
+        column instanceof QueryBuilderRelationColumnProjectionColumnState
+      ) {
+        nodeIDs.push(column.column.name);
       }
     });
 
@@ -447,7 +459,7 @@ export class QueryBuilderTDSState
     );
   }
 
-  onClassChange(_class: Class | undefined): void {
+  onClassChange(): void {
     return;
   }
 
@@ -550,6 +562,55 @@ export class QueryBuilderTDSState
     ).catch(this.queryBuilderState.applicationStore.alertUnhandledError);
   }
 
+  transformRelationColumnProjectionToDerivation(
+    relationColumnProjectionColumnState: QueryBuilderRelationColumnProjectionColumnState,
+  ): void {
+    // setup new derivation column state
+    const column = relationColumnProjectionColumnState.column;
+    const funcExpression = new FunctionExpression(column.name);
+    funcExpression.func = column;
+    funcExpression.parametersValues = [
+      new VariableExpression(
+        relationColumnProjectionColumnState.lambdaParameterName,
+        Multiplicity.ONE,
+        undefined,
+      ),
+    ];
+    const columnColumnLambda = buildGenericLambdaFunctionInstanceValue(
+      relationColumnProjectionColumnState.lambdaParameterName,
+      [funcExpression],
+      this.queryBuilderState.graphManagerState.graph,
+    );
+    const derivationColumnState =
+      new QueryBuilderDerivationProjectionColumnState(
+        this,
+        guaranteeType(
+          this.queryBuilderState.graphManagerState.graphManager.transformValueSpecToRawValueSpec(
+            columnColumnLambda,
+            this.queryBuilderState.graphManagerState.graph,
+          ),
+          RawLambda,
+        ),
+      );
+    derivationColumnState.setColumnName(
+      relationColumnProjectionColumnState.columnName,
+    );
+
+    this.replaceColumn(
+      relationColumnProjectionColumnState,
+      derivationColumnState,
+    );
+
+    // convert to grammar for display
+    flowResult(
+      derivationColumnState.derivationLambdaEditorState.convertLambdaObjectToGrammarString(
+        {
+          pretty: false,
+        },
+      ),
+    ).catch(this.queryBuilderState.applicationStore.alertUnhandledError);
+  }
+
   replaceColumn(
     oldVal: QueryBuilderProjectionColumnState,
     newVal: QueryBuilderProjectionColumnState,
@@ -843,6 +904,25 @@ export class QueryBuilderTDSState
     );
   }
 
+  getParameters(): PlainObject[] {
+    return this.queryBuilderState.parametersState.parameterStates.map(
+      (_param) =>
+        this.queryBuilderState.graphManagerState.graphManager.serializeValueSpecification(
+          _param.parameter,
+        ),
+    );
+  }
+
+  getLetExpressions(): PlainObject[] {
+    return this.queryBuilderState.constantState.constants
+      .map((_const) => _const.buildLetExpression())
+      .map((expres) =>
+        this.queryBuilderState.graphManagerState.graphManager.serializeValueSpecification(
+          expres,
+        ),
+      );
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.PROJECTION_STATE,
@@ -855,28 +935,64 @@ export class QueryBuilderTDSState
 
   *fetchDerivedReturnTypes(): GeneratorFn<void> {
     try {
-      const input = new Map<string, RawLambda>();
       const graph = this.queryBuilderState.graphManagerState.graph;
       const derivedCols = this.projectionColumns.filter(
         filterByType(QueryBuilderDerivationProjectionColumnState),
       );
-      derivedCols.forEach((col) =>
-        input.set(col.columnName, col.getIsolatedRawLambda()),
-      );
-      const result =
-        (yield this.queryBuilderState.graphManagerState.graphManager.getLambdasReturnType(
-          input,
+      if (derivedCols.length === 0) {
+        return;
+      }
+      const sourceElement = this.queryBuilderState.sourceElement;
+      if (sourceElement instanceof Class) {
+        const input = new Map<string, RawLambda>();
+        derivedCols.forEach((col) =>
+          input.set(col.columnName, col.getIsolatedClassRawLambda()),
+        );
+        const result =
+          (yield this.queryBuilderState.graphManagerState.graphManager.getLambdasReturnType(
+            input,
+            graph,
+          )) as {
+            results: Map<string, string>;
+            errors: Map<string, EngineError>;
+          };
+        Array.from(result.results.entries()).forEach((res) => {
+          const col = derivedCols.find((d) => d.columnName === res[0]);
+          if (col) {
+            col.setLambdaReturnType(res[1]);
+          }
+        });
+      } else if (sourceElement instanceof Accessor) {
+        const columnsMap = new Map<string, RawLambda>();
+        derivedCols.forEach((col) =>
+          columnsMap.set(col.columnName, col.lambda),
+        );
+        const isolatedLambda = _buildAccessorProjectRawLambda(
           graph,
-        )) as {
-          results: Map<string, string>;
-          errors: Map<string, EngineError>;
-        };
-      Array.from(result.results.entries()).forEach((res) => {
-        const col = derivedCols.find((d) => d.columnName === res[0]);
-        if (col) {
-          col.setLambdaReturnType(res[1]);
-        }
-      });
+          this.queryBuilderState.graphManagerState,
+          sourceElement,
+          columnsMap,
+        );
+        const enrichedLambda =
+          _decorateRawLambdaWithParametersAndLetExpressions(
+            isolatedLambda,
+            this.getParameters(),
+            this.getLetExpressions(),
+          );
+        const relationTypeMetadata =
+          (yield this.queryBuilderState.graphManagerState.graphManager.getLambdaRelationType(
+            enrichedLambda,
+            graph,
+          )) as RelationTypeMetadata;
+        derivedCols.forEach((col) => {
+          const columnMeta = relationTypeMetadata.columns.find(
+            (c) => c.name === col.columnName,
+          );
+          if (columnMeta) {
+            col.setLambdaReturnType(columnMeta.type);
+          }
+        });
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.queryBuilderState.applicationStore.logService.info(

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

@@ -21,17 +21,21 @@ import {
   flow,
   computed,
   flowResult,
+  override,
 } from 'mobx';
 import {
   type GeneratorFn,
   LogEvent,
   assertErrorThrown,
   guaranteeNonNullable,
+  guaranteeType,
   assertTrue,
   assertNonEmptyString,
   type Hashable,
   hashArray,
   ActionState,
+  prettyCONSTName,
+  type PlainObject,
 } from '@finos/legend-shared';
 import {
   type QueryBuilderExplorerTreePropertyNodeData,
@@ -45,7 +49,10 @@ import type { QueryBuilderState } from '../../../QueryBuilderState.js';
 import {
   type AbstractPropertyExpression,
   type Type,
+  type RelationColumn,
   type VariableExpression,
+  type RelationTypeMetadata,
+  type PureModel,
   PackageableElementExplicitReference,
   GRAPH_MANAGER_EVENT,
   buildSourceInformationSourceId,
@@ -56,6 +63,23 @@ import {
   stub_RawLambda,
   Multiplicity,
   PrimitiveType,
+  Accessor,
+  Class,
+  LambdaFunction,
+  FunctionType,
+  CORE_PURE_PATH,
+  AccessorInstanceValue,
+  SimpleFunctionExpression,
+  ColSpec,
+  extractElementNameFromPath,
+  ColSpecArrayInstance,
+  ColSpecArray,
+  INTERNAL__UnknownValueSpecification,
+  V1_serializeRawValueSpecification,
+  V1_transformRawLambda,
+  V1_GraphTransformerContextBuilder,
+  buildRawLambdaFromLambdaFunction,
+  type GraphManagerState,
 } from '@finos/legend-graph';
 import { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState.js';
 import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
@@ -66,6 +90,74 @@ import {
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../QueryBuilderStateHashUtils.js';
 import { LambdaEditorState } from '../../../shared/LambdaEditorState.js';
 import { isValueExpressionReferencedInValue } from '../../../QueryBuilderValueSpecificationHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
+
+export const _buildAccessorProjectRawLambda = (
+  graph: PureModel,
+  graphManagerState: GraphManagerState,
+  accessor: Accessor,
+  columns: ReadonlyMap<string, RawLambda>,
+): RawLambda => {
+  const lambdaFunction = new LambdaFunction(
+    new FunctionType(
+      PackageableElementExplicitReference.create(
+        graph.getType(CORE_PURE_PATH.ANY),
+      ),
+      Multiplicity.ONE,
+    ),
+  );
+  const accessorInstanceValue = new AccessorInstanceValue();
+  accessorInstanceValue.values = [accessor];
+  const projectFunction = new SimpleFunctionExpression(
+    extractElementNameFromPath(
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PROJECT,
+    ),
+  );
+  const instanceVal = new ColSpecArrayInstance(Multiplicity.ONE, undefined);
+  const colSpecArray = new ColSpecArray();
+  instanceVal.values = [colSpecArray];
+  const transformerContext = new V1_GraphTransformerContextBuilder(
+    // TODO?: do we need to include the plugins here?
+    [],
+  ).build();
+  columns.forEach((lambda, columnName) => {
+    const colSpec = new ColSpec();
+    colSpec.name = columnName;
+    colSpec.function1 = new INTERNAL__UnknownValueSpecification(
+      V1_serializeRawValueSpecification(
+        V1_transformRawLambda(lambda, transformerContext),
+      ),
+    );
+    colSpecArray.colSpecs.push(colSpec);
+  });
+  projectFunction.parametersValues = [accessorInstanceValue, instanceVal];
+  lambdaFunction.expressionSequence = [projectFunction];
+  return buildRawLambdaFromLambdaFunction(lambdaFunction, graphManagerState);
+};
+
+export const _decorateRawLambdaWithParametersAndLetExpressions = (
+  rawLambda: RawLambda,
+  parameters: PlainObject[],
+  letExpressions: PlainObject[],
+): RawLambda => {
+  let lambdaBody = rawLambda.body;
+  if (letExpressions.length) {
+    if (Array.isArray(rawLambda.body)) {
+      lambdaBody = [...letExpressions, ...(rawLambda.body as object[])];
+    } else {
+      lambdaBody = [...letExpressions, rawLambda.body];
+    }
+  }
+  return new RawLambda(
+    [
+      ...(Array.isArray(rawLambda.parameters)
+        ? (rawLambda.parameters as object[])
+        : []),
+      ...parameters,
+    ],
+    lambdaBody,
+  );
+};
 
 export const QUERY_BUILDER_PROJECTION_COLUMN_DND_TYPE = 'PROJECTION_COLUMN';
 
@@ -182,6 +274,54 @@ export class QueryBuilderSimpleProjectionColumnState
   }
 }
 
+export class QueryBuilderRelationColumnProjectionColumnState
+  extends QueryBuilderProjectionColumnState
+  implements Hashable
+{
+  lambdaParameterName: string = DEFAULT_LAMBDA_VARIABLE_NAME;
+
+  readonly column: RelationColumn;
+
+  constructor(
+    tdsState: QueryBuilderTDSState,
+    column: RelationColumn,
+    humanizePropertyName: boolean = true,
+  ) {
+    super(tdsState, column.name);
+
+    makeObservable(this, {
+      hashCode: override,
+      lambdaParameterName: observable,
+      setLambdaParameterName: action,
+    });
+
+    this.column = column;
+    this.columnName = humanizePropertyName
+      ? prettyCONSTName(column.name)
+      : column.name;
+  }
+
+  override getColumnType(): Type | undefined {
+    return this.column.genericType.value.rawType;
+  }
+
+  setLambdaParameterName(val: string): void {
+    this.lambdaParameterName = val;
+  }
+
+  isVariableUsed(_variable: VariableExpression): boolean {
+    return false;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.RELATION_COLUMN_PROJECTION_COLUMN_STATE,
+      this.column.name,
+      this.columnName,
+    ]);
+  }
+}
+
 class QueryBuilderDerivationProjectionLambdaState extends LambdaEditorState {
   queryBuilderState: QueryBuilderState;
   derivationProjectionColumnState: QueryBuilderDerivationProjectionColumnState;
@@ -300,6 +440,7 @@ export class QueryBuilderDerivationProjectionColumnState
       returnType: observable,
       fetchingLambdaReturnTypeState: observable,
       setLambda: action,
+      setResolvedLambdaReturnType: action,
       fetchDerivationLambdaReturnType: flow,
       setLambdaReturnType: action,
     });
@@ -351,13 +492,29 @@ export class QueryBuilderDerivationProjectionColumnState
       }
       assertTrue(Array.isArray(this.lambda.parameters));
       const graph = this.tdsState.queryBuilderState.graphManagerState.graph;
-      const isolatedLambda = this.getIsolatedRawLambda();
-      const type =
-        (yield this.tdsState.queryBuilderState.graphManagerState.graphManager.getLambdaReturnType(
-          isolatedLambda,
-          graph,
-        )) as string;
-      this.setLambdaReturnType(type);
+      const sourceElement = this.tdsState.queryBuilderState.sourceElement;
+      if (sourceElement instanceof Class) {
+        const isolatedLambda = this.getIsolatedClassRawLambda();
+        const type =
+          (yield this.tdsState.queryBuilderState.graphManagerState.graphManager.getLambdaReturnType(
+            isolatedLambda,
+            graph,
+          )) as string;
+        this.setLambdaReturnType(type);
+      } else if (sourceElement instanceof Accessor) {
+        const isolatedLambda = this.getIsolatedAccessorRawLambda(sourceElement);
+        const relationTypeMetadata =
+          (yield this.tdsState.queryBuilderState.graphManagerState.graphManager.getLambdaRelationType(
+            isolatedLambda,
+            graph,
+          )) as RelationTypeMetadata;
+        const columnMetadata = relationTypeMetadata.columns.find(
+          (col) => col.name === this.columnName,
+        );
+        if (columnMetadata) {
+          this.setLambdaReturnType(columnMetadata.type);
+        }
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.tdsState.queryBuilderState.applicationStore.logService.info(
@@ -372,7 +529,28 @@ export class QueryBuilderDerivationProjectionColumnState
     }
   }
 
-  getIsolatedRawLambda(): RawLambda {
+  getIsolatedAccessorRawLambda(_accessor: Accessor): RawLambda {
+    const { graphManagerState } = this.tdsState.queryBuilderState;
+    const isolatedLambda = _buildAccessorProjectRawLambda(
+      graphManagerState.graph,
+      graphManagerState,
+      _accessor,
+      new Map([[this.columnName, this.lambda]]),
+    );
+    const enrichedLambda = _decorateRawLambdaWithParametersAndLetExpressions(
+      isolatedLambda,
+      this.tdsState.getParameters(),
+      this.tdsState.getLetExpressions(),
+    );
+    return enrichedLambda;
+  }
+
+  getIsolatedClassRawLambda(): RawLambda {
+    const _class = guaranteeType(
+      this.tdsState.queryBuilderState.sourceElement,
+      Class,
+      'Expected source element to be a class',
+    );
     assertTrue(Array.isArray(this.lambda.parameters));
     const projectionParameter = this.lambda.parameters as object[];
     assertTrue(projectionParameter.length === 1);
@@ -383,45 +561,26 @@ export class QueryBuilderDerivationProjectionColumnState
     const rawVariableExpression = new RawVariableExpression(
       variable.name,
       Multiplicity.ONE,
-      PackageableElementExplicitReference.create(
-        guaranteeNonNullable(queryBuilderState.class),
-      ),
+      PackageableElementExplicitReference.create(guaranteeNonNullable(_class)),
     );
     const _rawVariableExpression =
       queryBuilderState.graphManagerState.graphManager.serializeRawValueSpecification(
         rawVariableExpression,
       );
-    const parameters = queryBuilderState.parametersState.parameterStates.map(
-      (_param) =>
-        queryBuilderState.graphManagerState.graphManager.serializeValueSpecification(
-          _param.parameter,
-        ),
+    return _decorateRawLambdaWithParametersAndLetExpressions(
+      new RawLambda([_rawVariableExpression], this.lambda.body),
+      this.tdsState.getParameters(),
+      this.tdsState.getLetExpressions(),
     );
-    const letExpressions = queryBuilderState.constantState.constants
-      .map((_const) => _const.buildLetExpression())
-      .map((expres) =>
-        queryBuilderState.graphManagerState.graphManager.serializeValueSpecification(
-          expres,
-        ),
-      );
-    let lambdaBody = this.lambda.body;
-    if (letExpressions.length) {
-      if (Array.isArray(this.lambda.body)) {
-        lambdaBody = [...letExpressions, ...(this.lambda.body as object[])];
-      } else {
-        lambdaBody = [...letExpressions, this.lambda.body];
-      }
-    }
-    const isolatedLambda = new RawLambda(
-      [_rawVariableExpression, ...parameters],
-      lambdaBody,
-    );
-    return isolatedLambda;
   }
 
   setLambdaReturnType(type: string): void {
-    const resolvedType =
-      this.tdsState.queryBuilderState.graphManagerState.graph.getType(type);
+    this.setResolvedLambdaReturnType(
+      this.tdsState.queryBuilderState.graphManagerState.graph.getType(type),
+    );
+  }
+
+  setResolvedLambdaReturnType(resolvedType: Type): void {
     assertTrue(
       resolvedType instanceof PrimitiveType ||
         resolvedType instanceof Enumeration,

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

@@ -30,6 +30,8 @@ import {
   PrimitiveInstanceValue,
   LambdaFunctionInstanceValue,
   ColSpecInstanceValue,
+  type RelationColumn,
+  type FunctionExpression,
 } from '@finos/legend-graph';
 import {
   assertNonNullable,
@@ -56,6 +58,7 @@ import {
 import { FETCH_STRUCTURE_IMPLEMENTATION } from '../../QueryBuilderFetchStructureImplementationState.js';
 import {
   QueryBuilderDerivationProjectionColumnState,
+  QueryBuilderRelationColumnProjectionColumnState,
   QueryBuilderSimpleProjectionColumnState,
 } from './QueryBuilderProjectionColumnState.js';
 import { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
@@ -300,6 +303,33 @@ export const processTDSProjectionColumnPropertyExpression = (
   }
 };
 
+export const processTDSRelationColumn = (
+  parentExpression: FunctionExpression,
+  columnName: string | undefined,
+  col: RelationColumn,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  if (
+    queryBuilderState.fetchStructureState.implementation instanceof
+    QueryBuilderTDSState
+  ) {
+    const tdsState = queryBuilderState.fetchStructureState.implementation;
+    const columnState = new QueryBuilderRelationColumnProjectionColumnState(
+      tdsState,
+      col,
+      false,
+    );
+    tdsState.addColumn(columnState, { skipSorting: true });
+    if (columnName) {
+      columnState.setColumnName(columnName);
+    }
+    const parameter = parentExpression.parametersValues[0];
+    if (parameter instanceof VariableExpression) {
+      columnState.setLambdaParameterName(parameter.name);
+    }
+  }
+};
+
 export const processTDSProjectionDerivationExpression = (
   value: INTERNAL__UnknownValueSpecification,
   columnName: string | undefined,