@finos/legend-query-builder 0.4.1 → 0.4.3

package/src/stores/QueryBuilderResultState.ts

@@ -35,10 +35,10 @@ import {
   EXECUTION_SERIALIZATION_FORMAT,
   RawExecutionResult,
   buildRawLambdaFromLambdaFunction,
+  ParameterValue,
 } from '@finos/legend-graph';
 import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
 import { ExecutionPlanState } from '@finos/legend-application';
-import { buildParametersLetLambdaFunc } from './shared/LambdaParameterState.js';
 
 const DEFAULT_LIMIT = 1000;
 
@@ -125,31 +125,24 @@ export class QueryBuilderResultState {
         this.queryBuilderState.unsupportedQueryState.rawLambda,
         'Lambda is required to execute query',
       );
-      if (
-        !this.queryBuilderState.isParameterSupportDisabled &&
-        this.queryBuilderState.parametersState.parameterStates.length
-      ) {
-        const letlambdaFunction = buildParametersLetLambdaFunc(
-          this.queryBuilderState.graphManagerState.graph,
-          this.queryBuilderState.parametersState.parameterStates,
-        );
-        const letRawLambda = buildRawLambdaFromLambdaFunction(
-          letlambdaFunction,
-          this.queryBuilderState.graphManagerState,
-        );
-        // reset paramaters
-        if (Array.isArray(query.body) && Array.isArray(letRawLambda.body)) {
-          letRawLambda.body = [
-            ...(letRawLambda.body as object[]),
-            ...(query.body as object[]),
-          ];
-          query = letRawLambda;
-        }
-      }
     }
     return query;
   }
 
+  buildExecutionParameterValues(): ParameterValue[] {
+    return this.queryBuilderState.parametersState.parameterStates.map(
+      (queryParamState) => {
+        const paramValue = new ParameterValue();
+        paramValue.name = queryParamState.parameter.name;
+        paramValue.value =
+          this.queryBuilderState.graphManagerState.graphManager.serializeValueSpecification(
+            guaranteeNonNullable(queryParamState.value),
+          );
+        return paramValue;
+      },
+    );
+  }
+
   *exportData(
     serializationFormat: EXECUTION_SERIALIZATION_FORMAT,
   ): GeneratorFn<void> {
@@ -217,6 +210,7 @@ export class QueryBuilderResultState {
         `Runtime is required to execute query`,
       );
       const query = this.buildExecutionRawLambda();
+      const parameterValues = this.buildExecutionParameterValues();
       const startTime = Date.now();
       const promise =
         this.queryBuilderState.graphManagerState.graphManager.executeMapping(
@@ -224,6 +218,9 @@ export class QueryBuilderResultState {
           mapping,
           runtime,
           this.queryBuilderState.graphManagerState.graph,
+          {
+            parameterValues: parameterValues,
+          },
         );
       this.setQueryRunPromise(promise);
       const result = (yield promise) as ExecutionResult;

package/src/stores/QueryBuilderStateBuilder.ts

@@ -23,15 +23,9 @@ import {
 } from '@finos/legend-shared';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import {
-  type AlloySerializationConfigInstanceValue,
   type EnumValueInstanceValue,
   type FunctionExpression,
-  type MappingInstanceValue,
-  type PairInstanceValue,
-  type PropertyGraphFetchTreeInstanceValue,
-  type PureListInstanceValue,
-  type RootGraphFetchTreeInstanceValue,
-  type RuntimeInstanceValue,
+  type GraphFetchTreeInstanceValue,
   type ValueSpecificationVisitor,
   type InstanceValue,
   type INTERNAL__UnknownValueSpecification,
@@ -70,7 +64,7 @@ import {
 } from './fetch-structure/tds/projection/QueryBuilderProjectionStateBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import { LambdaParameterState } from './shared/LambdaParameterState.js';
-import { processTDSOlapGroupByExpression } from './fetch-structure/tds/olapGroupBy/QueryBuilderOlapGroupByStateBuilder.js';
+import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/olapGroupBy/QueryBuilderOLAPGroupByStateBuilder_.js';
 import { processWatermarkExpression } from './watermark/QueryBuilderWatermarkStateBuilder.js';
 
 const processGetAllExpression = (
@@ -278,54 +272,8 @@ export class QueryBuilderValueSpecificationProcessor
     );
   }
 
-  visit_RootGraphFetchTreeInstanceValue(
-    valueSpecification: RootGraphFetchTreeInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_PropertyGraphFetchTreeInstanceValue(
-    valueSpecification: PropertyGraphFetchTreeInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_AlloySerializationConfigInstanceValue(
-    valueSpecification: AlloySerializationConfigInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_PrimitiveInstanceValue(
-    valueSpecification: PrimitiveInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_EnumValueInstanceValue(
-    valueSpecification: EnumValueInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_RuntimeInstanceValue(valueSpecification: RuntimeInstanceValue): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_PairInstanceValue(valueSpecification: PairInstanceValue): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_MappingInstanceValue(valueSpecification: MappingInstanceValue): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_PureListInstanceValue(valueSpecification: PureListInstanceValue): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_CollectionInstanceValue(
-    valueSpecification: CollectionInstanceValue,
+  visit_INTERNAL__PropagatedValue(
+    valueSpecification: INTERNAL__PropagatedValue,
   ): void {
     throw new UnsupportedOperationError();
   }
@@ -334,12 +282,6 @@ export class QueryBuilderValueSpecificationProcessor
     throw new UnsupportedOperationError();
   }
 
-  visit_INTERNAL__PropagatedValue(
-    valueSpecification: INTERNAL__PropagatedValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
   visit_SimpleFunctionExpression(
     valueSpecification: SimpleFunctionExpression,
   ): void {
@@ -498,7 +440,7 @@ export class QueryBuilderValueSpecificationProcessor
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_GROUPBY,
       )
     ) {
-      processTDSOlapGroupByExpression(
+      processTDS_OLAPGroupByExpression(
         valueSpecification,
         this.queryBuilderState,
       );
@@ -532,21 +474,6 @@ export class QueryBuilderValueSpecificationProcessor
     throw new UnsupportedOperationError();
   }
 
-  visit_LambdaFunctionInstanceValue(
-    valueSpecification: LambdaFunctionInstanceValue,
-  ): void {
-    valueSpecification.values.forEach((value) =>
-      value.expressionSequence.forEach((expression) =>
-        expression.accept_ValueSpecificationVisitor(
-          new QueryBuilderValueSpecificationProcessor(
-            this.queryBuilderState,
-            this.parentExpression,
-          ),
-        ),
-      ),
-    );
-  }
-
   visit_AbstractPropertyExpression(
     valueSpecification: AbstractPropertyExpression,
   ): void {
@@ -577,6 +504,45 @@ export class QueryBuilderValueSpecificationProcessor
   visit_InstanceValue(valueSpecification: InstanceValue): void {
     throw new UnsupportedOperationError();
   }
+
+  visit_CollectionInstanceValue(
+    valueSpecification: CollectionInstanceValue,
+  ): void {
+    throw new UnsupportedOperationError();
+  }
+
+  visit_EnumValueInstanceValue(
+    valueSpecification: EnumValueInstanceValue,
+  ): void {
+    throw new UnsupportedOperationError();
+  }
+
+  visit_PrimitiveInstanceValue(
+    valueSpecification: PrimitiveInstanceValue,
+  ): void {
+    throw new UnsupportedOperationError();
+  }
+
+  visit_LambdaFunctionInstanceValue(
+    valueSpecification: LambdaFunctionInstanceValue,
+  ): void {
+    valueSpecification.values.forEach((value) =>
+      value.expressionSequence.forEach((expression) =>
+        expression.accept_ValueSpecificationVisitor(
+          new QueryBuilderValueSpecificationProcessor(
+            this.queryBuilderState,
+            this.parentExpression,
+          ),
+        ),
+      ),
+    );
+  }
+
+  visit_GraphFetchTreeInstanceValue(
+    valueSpecification: GraphFetchTreeInstanceValue,
+  ): void {
+    throw new UnsupportedOperationError();
+  }
 }
 
 export const processParameters = (

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -17,7 +17,7 @@
 import { guaranteeNonNullable } from '@finos/legend-shared';
 import {
   type Class,
-  type Multiplicity,
+  Multiplicity,
   getMilestoneTemporalStereotype,
   extractElementNameFromPath,
   InstanceValue,
@@ -28,7 +28,6 @@ import {
   GenericTypeExplicitReference,
   LambdaFunction,
   SimpleFunctionExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
   MILESTONING_STEREOTYPE,
 } from '@finos/legend-graph';
 import type { QueryBuilderState } from './QueryBuilderState.js';
@@ -36,7 +35,6 @@ import { buildFilterExpression } from './filter/QueryBuilderFilterValueSpecifica
 import type { LambdaFunctionBuilderOption } from './QueryBuilderValueSpecificationBuilderHelper.js';
 import type { QueryBuilderFetchStructureState } from './fetch-structure/QueryBuilderFetchStructureState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
-import { buildParametersLetLambdaFunc } from './shared/LambdaParameterState.js';
 import { buildWatermarkExpression } from './watermark/QueryBuilderWatermarkValueSpecificationBuilder.js';
 
 const buildGetAllFunction = (
@@ -45,7 +43,6 @@ const buildGetAllFunction = (
 ): SimpleFunctionExpression => {
   const _func = new SimpleFunctionExpression(
     extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL),
-    multiplicity,
   );
   const classInstance = new InstanceValue(
     multiplicity,
@@ -75,22 +72,17 @@ export const buildLambdaFunction = (
     queryBuilderState.class,
     'Class is required to build query',
   );
-  const multiplicityOne =
-    queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
-      TYPICAL_MULTIPLICITY_TYPE.ONE,
-    );
-  const typeAny = queryBuilderState.graphManagerState.graph.getType(
-    CORE_PURE_PATH.ANY,
-  );
   const lambdaFunction = new LambdaFunction(
     new FunctionType(
-      PackageableElementExplicitReference.create(typeAny),
-      multiplicityOne,
+      PackageableElementExplicitReference.create(
+        queryBuilderState.graphManagerState.graph.getType(CORE_PURE_PATH.ANY),
+      ),
+      Multiplicity.ONE,
     ),
   );
 
   // build getAll()
-  const getAllFunction = buildGetAllFunction(_class, multiplicityOne);
+  const getAllFunction = buildGetAllFunction(_class, Multiplicity.ONE);
 
   // build milestoning parameter(s) for getAll()
   const milestoningStereotype = getMilestoneTemporalStereotype(
@@ -167,25 +159,8 @@ export const buildLambdaFunction = (
     !queryBuilderState.isParameterSupportDisabled &&
     queryBuilderState.parametersState.parameterStates.length
   ) {
-    // NOTE: if we are executing:
-    // 1. set the parameters to empty
-    // 2. add let statements for each parameter
-    if (options?.isBuildingExecutionQuery) {
-      lambdaFunction.functionType.parameters = [];
-      const letsFuncs = buildParametersLetLambdaFunc(
-        queryBuilderState.graphManagerState.graph,
-        queryBuilderState.parametersState.parameterStates,
-      );
-      lambdaFunction.expressionSequence = [
-        ...letsFuncs.expressionSequence,
-        ...lambdaFunction.expressionSequence,
-      ];
-    } else {
-      lambdaFunction.functionType.parameters =
-        queryBuilderState.parametersState.parameterStates.map(
-          (e) => e.parameter,
-        );
-    }
+    lambdaFunction.functionType.parameters =
+      queryBuilderState.parametersState.parameterStates.map((e) => e.parameter);
   }
 
   return lambdaFunction;

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -23,7 +23,7 @@ import {
   matchFunctionName,
   MILESTONING_STEREOTYPE,
   SimpleFunctionExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
+  VariableExpression,
   type ValueSpecification,
 } from '@finos/legend-graph';
 import {
@@ -134,6 +134,7 @@ const isDefaultDatePropagationSupported = (
 export const buildPropertyExpressionChain = (
   propertyExpression: AbstractPropertyExpression,
   queryBuilderState: QueryBuilderState,
+  lambdaParameterName: string,
   /**
    * As of now, we don't support date propagation for aggregation-class functions
    * so we have this temporary flag to disable date propagation, there could be other
@@ -142,11 +143,7 @@ export const buildPropertyExpressionChain = (
    */
   TEMPORARY__disableDatePropagation?: boolean,
 ): ValueSpecification => {
-  const graph = queryBuilderState.graphManagerState.graph;
-  const newPropertyExpression = new AbstractPropertyExpression(
-    '',
-    graph.getTypicalMultiplicity(TYPICAL_MULTIPLICITY_TYPE.ONE),
-  );
+  const newPropertyExpression = new AbstractPropertyExpression('');
   newPropertyExpression.func = propertyExpression.func;
   newPropertyExpression.parametersValues = [
     ...propertyExpression.parametersValues,
@@ -159,10 +156,7 @@ export const buildPropertyExpressionChain = (
       currentExpression.parametersValues,
     );
     if (nextExpression instanceof AbstractPropertyExpression) {
-      const parameterValue = new AbstractPropertyExpression(
-        '',
-        graph.getTypicalMultiplicity(TYPICAL_MULTIPLICITY_TYPE.ONE),
-      );
+      const parameterValue = new AbstractPropertyExpression('');
       parameterValue.func = nextExpression.func;
       parameterValue.parametersValues = [...nextExpression.parametersValues];
       nextExpression = parameterValue;
@@ -231,6 +225,11 @@ export const buildPropertyExpressionChain = (
       );
     }
   }
+
+  // Update the root lambda name based on the parent's lambda parameter name.
+  if (currentExpression instanceof VariableExpression) {
+    currentExpression.name = lambdaParameterName;
+  }
   return newPropertyExpression;
 };
 

package/src/stores/QueryBuilderValueSpecificationHelper.ts

@@ -22,7 +22,6 @@ import {
   LambdaFunction,
   LambdaFunctionInstanceValue,
   PRIMITIVE_TYPE,
-  TYPICAL_MULTIPLICITY_TYPE,
   VariableExpression,
   DATE_FORMAT,
   DATE_TIME_FORMAT,
@@ -31,7 +30,7 @@ import {
   PrimitiveInstanceValue,
   EnumValueInstanceValue,
   SimpleFunctionExpression,
-  type PrimitiveType,
+  PrimitiveType,
   type Enumeration,
   extractElementNameFromPath,
   AbstractPropertyExpression,
@@ -41,6 +40,10 @@ import {
   DerivedProperty,
   MILESTONING_STEREOTYPE,
   PackageableElementExplicitReference,
+  Multiplicity,
+  CollectionInstanceValue,
+  GenericTypeExplicitReference,
+  GenericType,
 } from '@finos/legend-graph';
 import {
   addUniqueEntry,
@@ -79,19 +82,13 @@ export const getCollectionValueSpecificationType = (
       const primitiveType = val.genericType.value.rawType;
       switch (primitiveType.path) {
         case PRIMITIVE_TYPE.STRING:
-          addUniqueEntry(
-            valuePrimitiveTypes,
-            graph.getPrimitiveType(PRIMITIVE_TYPE.STRING),
-          );
+          addUniqueEntry(valuePrimitiveTypes, PrimitiveType.STRING);
           break;
         case PRIMITIVE_TYPE.INTEGER:
         case PRIMITIVE_TYPE.DECIMAL:
         case PRIMITIVE_TYPE.FLOAT:
         case PRIMITIVE_TYPE.NUMBER:
-          addUniqueEntry(
-            valuePrimitiveTypes,
-            graph.getPrimitiveType(PRIMITIVE_TYPE.NUMBER),
-          );
+          addUniqueEntry(valuePrimitiveTypes, PrimitiveType.NUMBER);
           break;
         default:
           valuePrimitiveTypes.push(undefined);
@@ -137,14 +134,9 @@ export const unwrapNotExpression = (
 
 export const buildNotExpression = (
   expression: ValueSpecification,
-  graph: PureModel,
 ): ValueSpecification => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
   const expressionNot = new SimpleFunctionExpression(
     extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.NOT),
-    multiplicityOne,
   );
   expressionNot.parametersValues.push(expression);
   return expressionNot;
@@ -235,19 +227,15 @@ export const buildGenericLambdaFunctionInstanceValue = (
   lambdaBodyExpressions: ValueSpecification[],
   graph: PureModel,
 ): LambdaFunctionInstanceValue => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
-  const typeAny = graph.getType(CORE_PURE_PATH.ANY);
-  const functionInstanceValue = new LambdaFunctionInstanceValue(
-    multiplicityOne,
-  );
+  const functionInstanceValue = new LambdaFunctionInstanceValue();
   const functionType = new FunctionType(
-    PackageableElementExplicitReference.create(typeAny),
-    multiplicityOne,
+    PackageableElementExplicitReference.create(
+      graph.getType(CORE_PURE_PATH.ANY),
+    ),
+    Multiplicity.ONE,
   );
   functionType.parameters.push(
-    new VariableExpression(lambdaParameterName, multiplicityOne),
+    new VariableExpression(lambdaParameterName, Multiplicity.ONE),
   );
   const lambdaFunction = new LambdaFunction(functionType);
   lambdaFunction.expressionSequence = lambdaBodyExpressions;
@@ -362,3 +350,14 @@ export const extractNullableNumberFromInstanceValue = (
   }
   return undefined;
 };
+
+/**
+ * NOTE: Pure doesn't have a nullish value, rather we use empty collection of type Nil
+ */
+export const createNullishValue = (graph: PureModel): CollectionInstanceValue =>
+  new CollectionInstanceValue(
+    Multiplicity.ZERO,
+    GenericTypeExplicitReference.create(
+      new GenericType(graph.getType(CORE_PURE_PATH.ANY)),
+    ),
+  );

package/src/stores/explorer/QueryBuilderExplorerState.ts

@@ -30,7 +30,6 @@ import {
   type MappingModelCoverageAnalysisResult,
   type EnumMappedProperty,
   type MappedEntity,
-  TYPICAL_MULTIPLICITY_TYPE,
   AbstractPropertyExpression,
   Class,
   VariableExpression,
@@ -198,19 +197,11 @@ export const buildPropertyExpressionFromExplorerTreeNodeData = (
   const treeData = explorerState.nonNullableTreeData;
   const propertySearchIndexedTreeNodes =
     explorerState.propertySearchState.indexedExplorerTreeNodes;
-
-  const multiplicityOne =
-    explorerState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
-      TYPICAL_MULTIPLICITY_TYPE.ONE,
-    );
   const projectionColumnLambdaVariable = new VariableExpression(
     DEFAULT_LAMBDA_VARIABLE_NAME,
-    multiplicityOne,
-  );
-  const propertyExpression = new AbstractPropertyExpression(
-    '',
-    multiplicityOne,
+    Multiplicity.ONE,
   );
+  const propertyExpression = new AbstractPropertyExpression('');
   propertyExpression_setFunc(
     propertyExpression,
     PropertyExplicitReference.create(guaranteeNonNullable(node.property)),
@@ -239,13 +230,9 @@ export const buildPropertyExpressionFromExplorerTreeNodeData = (
     if (parentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData) {
       parentPropertyExpression = new SimpleFunctionExpression(
         extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE),
-        multiplicityOne,
       );
     } else {
-      parentPropertyExpression = new AbstractPropertyExpression(
-        '',
-        multiplicityOne,
-      );
+      parentPropertyExpression = new AbstractPropertyExpression('');
       propertyExpression_setFunc(
         parentPropertyExpression,
         PropertyExplicitReference.create(
@@ -262,7 +249,7 @@ export const buildPropertyExpressionFromExplorerTreeNodeData = (
       )
     ) {
       const subclass = new InstanceValue(
-        multiplicityOne,
+        Multiplicity.ONE,
         GenericTypeExplicitReference.create(new GenericType(currentNode.type)),
       );
       currentExpression.parametersValues.push(subclass);
@@ -286,7 +273,7 @@ export const buildPropertyExpressionFromExplorerTreeNodeData = (
   currentExpression.parametersValues.push(projectionColumnLambdaVariable);
   if (currentExpression instanceof SimpleFunctionExpression) {
     const subclass = new InstanceValue(
-      multiplicityOne,
+      Multiplicity.ONE,
       GenericTypeExplicitReference.create(new GenericType(currentNode.type)),
     );
     currentExpression.parametersValues.push(subclass);
@@ -506,7 +493,7 @@ export const getQueryBuilderSubTypeNodeData = (
       ? parentNode.property.multiplicity
       : parentNode instanceof QueryBuilderExplorerTreeSubTypeNodeData
       ? parentNode.multiplicity
-      : new Multiplicity(1, 1),
+      : Multiplicity.ONE,
   );
   subTypeNode.childrenIds =
     generateExplorerTreeClassNodeChildrenIDs(subTypeNode);

package/src/stores/explorer/QueryBuilderPropertySearchState.ts

@@ -343,10 +343,7 @@ export class QueryBuilderPropertySearchState {
       if (
         this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.STRING)
       ) {
-        if (
-          node.type instanceof PrimitiveType &&
-          node.type.name === PRIMITIVE_TYPE.STRING
-        ) {
+        if (node.type === PrimitiveType.STRING) {
           return true;
         }
       }
@@ -370,10 +367,7 @@ export class QueryBuilderPropertySearchState {
       if (
         this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.BOOLEAN)
       ) {
-        if (
-          node.type instanceof PrimitiveType &&
-          node.type.name === PRIMITIVE_TYPE.BOOLEAN
-        ) {
+        if (node.type === PrimitiveType.BOOLEAN) {
           return true;
         }
       }

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

@@ -20,31 +20,24 @@ import {
   GenericTypeExplicitReference,
   matchFunctionName,
   PrimitiveInstanceValue,
-  PRIMITIVE_TYPE,
   SimpleFunctionExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
   type ValueSpecification,
   type LambdaFunction,
-  RootGraphFetchTreeInstanceValue,
+  GraphFetchTreeInstanceValue,
+  PrimitiveType,
 } from '@finos/legend-graph';
 import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graphManager/QueryBuilderSupportedFunctions.js';
-import type { QueryBuilderState } from '../../QueryBuilderState.js';
 import type { QueryBuilderGraphFetchTreeState } from './QueryBuilderGraphFetchTreeState.js';
 import { isGraphFetchTreeDataEmpty } from './QueryBuilderGraphFetchTreeUtil.js';
 
 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) {
@@ -56,18 +49,12 @@ const appendTakeLimit = (
       ) {
         const limit = new PrimitiveInstanceValue(
           GenericTypeExplicitReference.create(
-            new GenericType(
-              queryBuilderState.graphManagerState.graph.getPrimitiveType(
-                PRIMITIVE_TYPE.INTEGER,
-              ),
-            ),
+            new GenericType(PrimitiveType.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 need to
@@ -109,23 +96,16 @@ export const appendGraphFetch = (
     lambdaFunction.expressionSequence[0],
     `Can't build graph-fetch tree expression: preceding expression is not defined`,
   );
-  const multiplicityOne =
-    queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
-      TYPICAL_MULTIPLICITY_TYPE.ONE,
-    );
 
   // build graph-fetch tree
   if (
     graphFetchTreeState.treeData &&
     !isGraphFetchTreeDataEmpty(graphFetchTreeState.treeData)
   ) {
-    const graphFetchInstance = new RootGraphFetchTreeInstanceValue(
-      multiplicityOne,
-    );
+    const graphFetchInstance = new GraphFetchTreeInstanceValue();
     graphFetchInstance.values = [graphFetchTreeState.treeData.tree];
     const serializeFunction = new SimpleFunctionExpression(
       extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE),
-      multiplicityOne,
     );
     const graphFetchFunc = new SimpleFunctionExpression(
       graphFetchTreeState.isChecked
@@ -135,7 +115,6 @@ export const appendGraphFetch = (
         : extractElementNameFromPath(
             QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
           ),
-      multiplicityOne,
     );
     graphFetchFunc.parametersValues = [precedingExpression, graphFetchInstance];
     serializeFunction.parametersValues = [graphFetchFunc, graphFetchInstance];
@@ -144,10 +123,6 @@ export const appendGraphFetch = (
 
   // build result set modifier: i.e. preview limit
   if (options?.isBuildingExecutionQuery) {
-    appendTakeLimit(
-      queryBuilderState,
-      lambdaFunction,
-      queryBuilderState.resultState.previewLimit,
-    );
+    appendTakeLimit(lambdaFunction, queryBuilderState.resultState.previewLimit);
   }
 };