@finos/legend-application-query 5.2.2 → 5.2.3

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

@@ -0,0 +1,173 @@
+/**
+ * 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 { action, makeAutoObservable } from 'mobx';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
+import { QueryBuilderGraphFetchTreeState } from './graph-fetch/QueryBuilderGraphFetchTreeState.js';
+import { QueryBuilderProjectionState } from './projection/QueryBuilderProjectionState.js';
+import {
+  buildPropertyExpressionFromExplorerTreeNodeData,
+  type QueryBuilderExplorerTreeNodeData,
+  QueryBuilderExplorerTreePropertyNodeData,
+} from '../explorer/QueryBuilderExplorerState.js';
+import { Class } from '@finos/legend-graph';
+import { filterByType } from '@finos/legend-shared';
+import { addQueryBuilderPropertyNode } from './graph-fetch/QueryBuilderGraphFetchTreeUtil.js';
+import { QueryBuilderSimpleProjectionColumnState } from './projection/QueryBuilderProjectionColumnState.js';
+
+export enum FETCH_STRUCTURE_MODE {
+  PROJECTION = 'PROJECTION',
+  GRAPH_FETCH = 'GRAPH_FETCH',
+}
+
+export class QueryBuilderFetchStructureState {
+  queryBuilderState: QueryBuilderState;
+  /**
+   * TODO: refactor this so we could reduce this to
+   * `implementationState: QueryBuilderFetchStructureImplementationState`
+   * so we don't have graph fetch and projection at the same time
+   *
+   * TODO?: perhaps it would eventually make sense to default to
+   * graph-fetch since `getAll()` naturally works for graph-fetch case
+   * and graph-fetch allows somewhat an empty tree
+   */
+  fetchStructureMode = FETCH_STRUCTURE_MODE.PROJECTION;
+  projectionState: QueryBuilderProjectionState;
+  graphFetchTreeState: QueryBuilderGraphFetchTreeState;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    makeAutoObservable(this, {
+      queryBuilderState: false,
+      setFetchStructureMode: action,
+    });
+
+    this.queryBuilderState = queryBuilderState;
+    // TODO: we probably should modularize this a bit better
+    // See https://github.com/finos/legend-studio/issues/731
+    this.projectionState = new QueryBuilderProjectionState(
+      queryBuilderState,
+      this,
+    );
+    this.graphFetchTreeState = new QueryBuilderGraphFetchTreeState(
+      queryBuilderState,
+      this,
+    );
+  }
+
+  setFetchStructureMode(val: FETCH_STRUCTURE_MODE): void {
+    this.fetchStructureMode = val;
+  }
+
+  fetchProperty(node: QueryBuilderExplorerTreeNodeData): void {
+    if (
+      node instanceof QueryBuilderExplorerTreePropertyNodeData &&
+      !(node.type instanceof Class)
+    ) {
+      switch (this.fetchStructureMode) {
+        case FETCH_STRUCTURE_MODE.GRAPH_FETCH: {
+          this.graphFetchTreeState.addProperty(node);
+          return;
+        }
+        case FETCH_STRUCTURE_MODE.PROJECTION: {
+          this.projectionState.addColumn(
+            new QueryBuilderSimpleProjectionColumnState(
+              this.projectionState,
+              buildPropertyExpressionFromExplorerTreeNodeData(
+                this.queryBuilderState.explorerState.nonNullableTreeData,
+                node,
+                this.queryBuilderState.graphManagerState.graph,
+                this.queryBuilderState.explorerState.propertySearchPanelState
+                  .allMappedPropertyNodes,
+              ),
+              this.queryBuilderState.explorerState.humanizePropertyName,
+            ),
+          );
+          return;
+        }
+        default:
+          return;
+      }
+    }
+  }
+
+  fetchNodeChildrenProperties(node: QueryBuilderExplorerTreeNodeData): void {
+    if (node.type instanceof Class) {
+      // NOTE: here we require the node to already been expanded so the child nodes are generated
+      // we don't allow adding unopened node. Maybe if it helps, we can show a warning.
+      const nodesToAdd = node.childrenIds
+        .map((childId) =>
+          this.queryBuilderState.explorerState.nonNullableTreeData.nodes.get(
+            childId,
+          ),
+        )
+        .filter(filterByType(QueryBuilderExplorerTreePropertyNodeData))
+        .filter(
+          (childNode) =>
+            !(childNode.type instanceof Class) && childNode.mappingData.mapped,
+        );
+
+      switch (this.fetchStructureMode) {
+        case FETCH_STRUCTURE_MODE.GRAPH_FETCH: {
+          const graphFetchTreeData = this.graphFetchTreeState.treeData;
+          if (graphFetchTreeData) {
+            nodesToAdd.forEach((nodeToAdd) =>
+              addQueryBuilderPropertyNode(
+                graphFetchTreeData,
+                this.queryBuilderState.explorerState.nonNullableTreeData,
+                nodeToAdd,
+                this.queryBuilderState,
+              ),
+            );
+            this.graphFetchTreeState.setGraphFetchTree({
+              ...graphFetchTreeData,
+            });
+          }
+          return;
+        }
+        case FETCH_STRUCTURE_MODE.PROJECTION: {
+          nodesToAdd.forEach((nodeToAdd) => {
+            this.projectionState.addColumn(
+              new QueryBuilderSimpleProjectionColumnState(
+                this.projectionState,
+                buildPropertyExpressionFromExplorerTreeNodeData(
+                  this.queryBuilderState.explorerState.nonNullableTreeData,
+                  nodeToAdd,
+                  this.queryBuilderState.graphManagerState.graph,
+                  this.queryBuilderState.explorerState.propertySearchPanelState
+                    .allMappedPropertyNodes,
+                ),
+                this.queryBuilderState.explorerState.humanizePropertyName,
+              ),
+            );
+          });
+          return;
+        }
+        default:
+          return;
+      }
+    }
+  }
+
+  get validationIssues(): string[] | undefined {
+    switch (this.fetchStructureMode) {
+      case FETCH_STRUCTURE_MODE.PROJECTION:
+        return this.projectionState.validationIssues;
+      case FETCH_STRUCTURE_MODE.GRAPH_FETCH:
+      default:
+        return undefined;
+    }
+  }
+}

package/src/stores/{QueryBuilderGraphFetchTreeState.ts → fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts}

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import { makeAutoObservable, action } from 'mobx';
+import type { QueryBuilderState } from '../../QueryBuilderState.js';
+import { action, makeObservable, observable } from 'mobx';
 import {
   PackageableElementExplicitReference,
   RootGraphFetchTree,
@@ -25,11 +25,12 @@ import {
   addQueryBuilderPropertyNode,
   buildGraphFetchTreeData,
 } from './QueryBuilderGraphFetchTreeUtil.js';
-import type { QueryBuilderExplorerTreePropertyNodeData } from './QueryBuilderExplorerState.js';
+import type { QueryBuilderExplorerTreePropertyNodeData } from '../../explorer/QueryBuilderExplorerState.js';
 import { assertNonNullable } from '@finos/legend-shared';
+import { QueryBuilderFetchStructureImplementationState } from '../QueryBuilderFetchStructureImplementationState.js';
+import type { QueryBuilderFetchStructureState } from '../QueryBuilderFetchStructureState.js';
 
-export class QueryBuilderGraphFetchTreeState {
-  queryBuilderState: QueryBuilderState;
+export class QueryBuilderGraphFetchTreeState extends QueryBuilderFetchStructureImplementationState {
   treeData?: QueryBuilderGraphFetchTreeData | undefined;
   /**
    * If set to `true` we will use `graphFetchChecked` function instead of `graphFetch`.
@@ -38,14 +39,18 @@ export class QueryBuilderGraphFetchTreeState {
    */
   isChecked = false;
 
-  constructor(queryBuilderState: QueryBuilderState) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    fetchStructureState: QueryBuilderFetchStructureState,
+  ) {
+    super(queryBuilderState, fetchStructureState);
+
+    makeObservable(this, {
+      treeData: observable,
+      isChecked: observable,
       setGraphFetchTree: action,
       setChecked: action,
     });
-
-    this.queryBuilderState = queryBuilderState;
   }
 
   setGraphFetchTree(val: QueryBuilderGraphFetchTreeData | undefined): void {
@@ -56,23 +61,22 @@ export class QueryBuilderGraphFetchTreeState {
     this.isChecked = val;
   }
 
+  // TODO-BEFORE-PR: consider removing this
   initialize(tree?: RootGraphFetchTree): void {
-    if (this.queryBuilderState.fetchStructureState.isGraphFetchMode()) {
-      if (tree) {
-        this.setGraphFetchTree(buildGraphFetchTreeData(tree));
-      } else {
-        const _class = this.queryBuilderState.querySetupState._class;
-        if (_class) {
-          this.setGraphFetchTree(
-            buildGraphFetchTreeData(
-              new RootGraphFetchTree(
-                PackageableElementExplicitReference.create(_class),
-              ),
+    if (tree) {
+      this.setGraphFetchTree(buildGraphFetchTreeData(tree));
+    } else {
+      const _class = this.queryBuilderState.querySetupState._class;
+      if (_class) {
+        this.setGraphFetchTree(
+          buildGraphFetchTreeData(
+            new RootGraphFetchTree(
+              PackageableElementExplicitReference.create(_class),
             ),
-          );
-        } else {
-          this.setGraphFetchTree(undefined);
-        }
+          ),
+        );
+      } else {
+        this.setGraphFetchTree(undefined);
       }
     }
   }

package/src/stores/{QueryBuilderGraphFetchTreeUtil.ts → fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeUtil.ts}

@@ -30,8 +30,8 @@ import {
   type QueryBuilderExplorerTreeNodeData,
   QueryBuilderExplorerTreePropertyNodeData,
   QueryBuilderExplorerTreeSubTypeNodeData,
-} from './QueryBuilderExplorerState.js';
-import type { QueryBuilderState } from './QueryBuilderState.js';
+} from '../../explorer/QueryBuilderExplorerState.js';
+import type { QueryBuilderState } from '../../QueryBuilderState.js';
 import {
   graphFetchTree_addSubTree,
   graphFetchTree_removeSubTree,

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

@@ -0,0 +1,90 @@
+/**
+ * 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 {
+  extractElementNameFromPath,
+  GenericType,
+  GenericTypeExplicitReference,
+  matchFunctionName,
+  PrimitiveInstanceValue,
+  PRIMITIVE_TYPE,
+  SimpleFunctionExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  type ValueSpecification,
+  type LambdaFunction,
+} from '@finos/legend-graph';
+import { guaranteeType } from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../QueryBuilder_Const.js';
+import type { QueryBuilderState } from '../../QueryBuilderState.js';
+
+export const appendTakeLimit = (
+  queryBuilderState: QueryBuilderState,
+  lambda: LambdaFunction,
+  previewLimit?: number | undefined,
+): LambdaFunction => {
+  if (!previewLimit) {
+    return lambda;
+  }
+  const multiplicityOne =
+    queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+  if (lambda.expressionSequence.length === 1) {
+    const func = lambda.expressionSequence[0];
+    if (func instanceof SimpleFunctionExpression) {
+      if (
+        matchFunctionName(
+          func.functionName,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE,
+        )
+      ) {
+        const limit = new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(
+            new GenericType(
+              queryBuilderState.graphManagerState.graph.getPrimitiveType(
+                PRIMITIVE_TYPE.INTEGER,
+              ),
+            ),
+          ),
+          multiplicityOne,
+        );
+        limit.values = [previewLimit];
+        const takeFunction = new SimpleFunctionExpression(
+          extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TAKE),
+          multiplicityOne,
+        );
+
+        // NOTE: `take()` does not work on `graphFetch()` or `serialize()` so we will put it
+        // right next to `all()`
+        const serializeFunction = func;
+        const graphFetchFunc = guaranteeType(
+          serializeFunction.parametersValues[0],
+          SimpleFunctionExpression,
+        );
+        const getAllFunc = graphFetchFunc
+          .parametersValues[0] as ValueSpecification;
+        takeFunction.parametersValues[0] = getAllFunc;
+        takeFunction.parametersValues[1] = limit;
+        graphFetchFunc.parametersValues = [
+          takeFunction,
+          graphFetchFunc.parametersValues[1] as ValueSpecification,
+        ];
+        return lambda;
+      }
+    }
+  }
+  return lambda;
+};

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

@@ -0,0 +1,329 @@
+/**
+ * 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 { action, makeObservable, observable, flow } from 'mobx';
+import {
+  type GeneratorFn,
+  LogEvent,
+  assertErrorThrown,
+  uuid,
+  guaranteeNonNullable,
+  assertTrue,
+  assertNonEmptyString,
+} from '@finos/legend-shared';
+import {
+  type QueryBuilderExplorerTreePropertyNodeData,
+  buildPropertyExpressionFromExplorerTreeNodeData,
+} from '../../explorer/QueryBuilderExplorerState.js';
+import {
+  getPropertyChainName,
+  QueryBuilderPropertyExpressionState,
+} from '../../QueryBuilderPropertyEditorState.js';
+import type { QueryBuilderState } from '../../QueryBuilderState.js';
+import {
+  type AbstractPropertyExpression,
+  type Type,
+  type VariableExpression,
+  PackageableElementExplicitReference,
+  GRAPH_MANAGER_EVENT,
+  PRIMITIVE_TYPE,
+  buildSourceInformationSourceId,
+  ParserError,
+  TYPICAL_MULTIPLICITY_TYPE,
+  RawVariableExpression,
+  Enumeration,
+  RawLambda,
+  stub_RawLambda,
+} from '@finos/legend-graph';
+import {
+  DEFAULT_LAMBDA_VARIABLE_NAME,
+  QUERY_BUILDER_SOURCE_ID_LABEL,
+} from '../../../QueryBuilder_Const.js';
+import { LambdaEditorState } from '@finos/legend-application';
+import type { QueryBuilderProjectionState } from './QueryBuilderProjectionState.js';
+
+export const QUERY_BUILDER_PROJECTION_COLUMN_DND_TYPE = 'PROJECTION_COLUMN';
+
+export interface QueryBuilderProjectionColumnDragSource {
+  columnState: QueryBuilderProjectionColumnState;
+}
+
+export abstract class QueryBuilderProjectionColumnState {
+  readonly uuid = uuid();
+  projectionState: QueryBuilderProjectionState;
+  columnName: string;
+
+  constructor(
+    projectionState: QueryBuilderProjectionState,
+    columnName: string,
+  ) {
+    makeObservable(this, {
+      uuid: false,
+      projectionState: false,
+      columnName: observable,
+      setColumnName: action,
+    });
+
+    this.projectionState = projectionState;
+    this.columnName = columnName;
+  }
+
+  setColumnName(val: string): void {
+    this.columnName = val;
+  }
+
+  abstract getReturnType(): Type | undefined;
+}
+
+export class QueryBuilderSimpleProjectionColumnState extends QueryBuilderProjectionColumnState {
+  lambdaParameterName: string = DEFAULT_LAMBDA_VARIABLE_NAME;
+  propertyExpressionState: QueryBuilderPropertyExpressionState;
+
+  constructor(
+    projectionState: QueryBuilderProjectionState,
+    propertyExpression: AbstractPropertyExpression,
+    humanizePropertyName: boolean,
+  ) {
+    super(projectionState, '');
+
+    makeObservable(this, {
+      lambdaParameterName: observable,
+      propertyExpressionState: observable,
+      setLambdaParameterName: action,
+      changeProperty: action,
+    });
+
+    this.propertyExpressionState = new QueryBuilderPropertyExpressionState(
+      projectionState.queryBuilderState,
+      propertyExpression,
+    );
+    this.columnName = getPropertyChainName(
+      this.propertyExpressionState.propertyExpression,
+      humanizePropertyName,
+    );
+  }
+
+  setLambdaParameterName(val: string): void {
+    this.lambdaParameterName = val;
+  }
+
+  changeProperty(
+    node: QueryBuilderExplorerTreePropertyNodeData,
+    humanizePropertyName: boolean,
+  ): void {
+    this.propertyExpressionState = new QueryBuilderPropertyExpressionState(
+      this.projectionState.queryBuilderState,
+      buildPropertyExpressionFromExplorerTreeNodeData(
+        this.projectionState.queryBuilderState.explorerState
+          .nonNullableTreeData,
+        node,
+        this.projectionState.queryBuilderState.graphManagerState.graph,
+        this.projectionState.queryBuilderState.explorerState
+          .propertySearchPanelState.allMappedPropertyNodes,
+      ),
+    );
+    this.columnName = getPropertyChainName(
+      this.propertyExpressionState.propertyExpression,
+      humanizePropertyName,
+    );
+  }
+
+  override getReturnType(): Type | undefined {
+    return this.propertyExpressionState.propertyExpression.func.genericType
+      .value.rawType;
+  }
+}
+
+class QueryBuilderDerivationProjectionLambdaState extends LambdaEditorState {
+  queryBuilderState: QueryBuilderState;
+  derivationProjectionColumnState: QueryBuilderDerivationProjectionColumnState;
+  /**
+   * This is used to store the JSON string when viewing the query in JSON mode
+   * TODO: consider moving this to another state if we need to simplify the logic of text-mode
+   */
+  readOnlylambdaJson = '';
+
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    derivationProjectionColumnState: QueryBuilderDerivationProjectionColumnState,
+  ) {
+    super('', '');
+    this.queryBuilderState = queryBuilderState;
+    this.derivationProjectionColumnState = derivationProjectionColumnState;
+  }
+
+  get lambdaId(): string {
+    return buildSourceInformationSourceId([
+      // TODO: to be reworked
+      // See https://github.com/finos/legend-studio/issues/1168
+      QUERY_BUILDER_SOURCE_ID_LABEL.QUERY_BUILDER,
+      QUERY_BUILDER_SOURCE_ID_LABEL.PROJECTION,
+      this.derivationProjectionColumnState.uuid,
+    ]);
+  }
+
+  setLambdaJson(lambdaJson: string): void {
+    this.readOnlylambdaJson = lambdaJson;
+  }
+
+  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
+    const emptyLambda = stub_RawLambda();
+    if (this.lambdaString) {
+      try {
+        const lambda =
+          (yield this.queryBuilderState.graphManagerState.graphManager.pureCodeToLambda(
+            this.fullLambdaString,
+            this.lambdaId,
+          )) as RawLambda;
+        this.setParserError(undefined);
+        this.derivationProjectionColumnState.setLambda(lambda);
+      } catch (error) {
+        assertErrorThrown(error);
+        if (error instanceof ParserError) {
+          this.setParserError(error);
+        }
+        this.queryBuilderState.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.derivationProjectionColumnState.setLambda(emptyLambda);
+    }
+  }
+
+  *convertLambdaObjectToGrammarString(pretty: boolean): GeneratorFn<void> {
+    if (this.derivationProjectionColumnState.lambda.body) {
+      try {
+        const lambdas = new Map<string, RawLambda>();
+        lambdas.set(
+          this.lambdaId,
+          new RawLambda(
+            this.derivationProjectionColumnState.lambda.parameters,
+            this.derivationProjectionColumnState.lambda.body,
+          ),
+        );
+        const isolatedLambdas =
+          (yield this.queryBuilderState.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+            pretty,
+          )) as Map<string, string>;
+        const grammarText = isolatedLambdas.get(this.lambdaId);
+        this.setLambdaString(
+          grammarText !== undefined
+            ? this.extractLambdaString(grammarText)
+            : '',
+        );
+        this.clearErrors();
+      } catch (error) {
+        assertErrorThrown(error);
+        this.queryBuilderState.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.setLambdaString('');
+    }
+  }
+}
+
+export class QueryBuilderDerivationProjectionColumnState extends QueryBuilderProjectionColumnState {
+  derivationLambdaEditorState: QueryBuilderDerivationProjectionLambdaState;
+  lambda: RawLambda;
+  returnType: Type | undefined;
+
+  constructor(projectionState: QueryBuilderProjectionState, lambda: RawLambda) {
+    super(projectionState, '(derivation)');
+
+    makeObservable(this, {
+      lambda: observable,
+      returnType: observable,
+      setLambda: action,
+      fetchDerivationLambdaReturnType: flow,
+    });
+
+    this.derivationLambdaEditorState =
+      new QueryBuilderDerivationProjectionLambdaState(
+        projectionState.queryBuilderState,
+        this,
+      );
+    this.lambda = lambda;
+  }
+
+  setLambda(val: RawLambda): void {
+    this.lambda = val;
+  }
+
+  setReturnType(val: Type | undefined): void {
+    this.returnType = val;
+  }
+
+  /**
+   * Fetches lambda return type for derivation column.
+   * Throws error if unable to fetch type or if type is not primitive or an enumeration
+   * as expected by a projection column
+   */
+  *fetchDerivationLambdaReturnType(): GeneratorFn<void> {
+    assertTrue(Array.isArray(this.lambda.parameters));
+    const projectionParameter = this.lambda.parameters as object[];
+    const graph =
+      this.projectionState.queryBuilderState.graphManagerState.graph;
+    const multiplicityOne = graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+    assertTrue(projectionParameter.length === 1);
+    const variable = projectionParameter[0] as VariableExpression;
+    assertNonEmptyString(variable.name);
+    // assign variable to query class
+    const rawVariableExpression = new RawVariableExpression(
+      variable.name,
+      multiplicityOne,
+      PackageableElementExplicitReference.create(
+        guaranteeNonNullable(
+          this.projectionState.queryBuilderState.querySetupState._class,
+        ),
+      ),
+    );
+    const _rawVariableExpression =
+      this.projectionState.queryBuilderState.graphManagerState.graphManager.serializeRawValueSpecification(
+        rawVariableExpression,
+      );
+    const isolatedLambda = new RawLambda(
+      [_rawVariableExpression],
+      this.lambda.body,
+    );
+    const type =
+      (yield this.projectionState.queryBuilderState.graphManagerState.graphManager.getLambdaReturnType(
+        isolatedLambda,
+        graph,
+      )) as string;
+    const resolvedType = graph.getType(type);
+    assertTrue(
+      Object.values(PRIMITIVE_TYPE).includes(
+        resolvedType.path as PRIMITIVE_TYPE,
+      ) || resolvedType instanceof Enumeration,
+      'projection column must have primitive return type',
+    );
+    this.setReturnType(resolvedType);
+  }
+
+  override getReturnType(): Type | undefined {
+    return this.returnType;
+  }
+}