@finos/legend-query-builder 0.4.1 → 0.4.3

package/src/components/shared/CustomDatePicker.tsx

@@ -34,11 +34,11 @@ import {
   EnumValueExplicitReference,
   EnumValueInstanceValue,
   matchFunctionName,
-  TYPICAL_MULTIPLICITY_TYPE,
   SUPPORTED_FUNCTIONS,
   DAY_OF_WEEK,
   DURATION_UNIT,
   type ObserverContext,
+  PrimitiveType,
 } from '@finos/legend-graph';
 import {
   guaranteeNonNullable,
@@ -241,26 +241,18 @@ const buildPureDateFunctionExpression = (
   graph: PureModel,
   observerContext: ObserverContext,
 ): SimpleFunctionExpression => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
-  const strictDate = graph.getPrimitiveType(PRIMITIVE_TYPE.STRICTDATE);
-  const date = graph.getPrimitiveType(PRIMITIVE_TYPE.DATE);
-  const dateTime = graph.getPrimitiveType(PRIMITIVE_TYPE.DATETIME);
   if (datePickerOption instanceof CustomPreviousDayOfWeekOption) {
     const previousFridaySFE = new SimpleFunctionExpression(
       SUPPORTED_FUNCTIONS.PREVIOUS_DAY_OF_WEEK,
-      multiplicityOne,
     );
     valueSpecification_setGenericType(
       previousFridaySFE,
-      GenericTypeExplicitReference.create(new GenericType(date)),
+      GenericTypeExplicitReference.create(new GenericType(PrimitiveType.DATE)),
     );
     const dayOfWeekEnumIntanceValue = new EnumValueInstanceValue(
       GenericTypeExplicitReference.create(
         new GenericType(graph.getType(DAY_OF_WEEK)),
       ),
-      multiplicityOne,
     );
     instanceValue_setValues(dayOfWeekEnumIntanceValue, [
       ...dayOfWeekEnumIntanceValue.values,
@@ -283,44 +275,48 @@ const buildPureDateFunctionExpression = (
       case CUSTOM_DATE_FIRST_DAY_OF_UNIT.YEAR: {
         const firstDayOfYearSFE = new SimpleFunctionExpression(
           SUPPORTED_FUNCTIONS.FIRST_DAY_OF_YEAR,
-          multiplicityOne,
         );
         valueSpecification_setGenericType(
           firstDayOfYearSFE,
-          GenericTypeExplicitReference.create(new GenericType(date)),
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.DATE),
+          ),
         );
         return firstDayOfYearSFE;
       }
       case CUSTOM_DATE_FIRST_DAY_OF_UNIT.QUARTER: {
         const firstDayOfQuarterSFE = new SimpleFunctionExpression(
           SUPPORTED_FUNCTIONS.FIRST_DAY_OF_QUARTER,
-          multiplicityOne,
         );
         valueSpecification_setGenericType(
           firstDayOfQuarterSFE,
-          GenericTypeExplicitReference.create(new GenericType(strictDate)),
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.STRICTDATE),
+          ),
         );
         return firstDayOfQuarterSFE;
       }
       case CUSTOM_DATE_FIRST_DAY_OF_UNIT.MONTH: {
         const firstDayOfMonthSFE = new SimpleFunctionExpression(
           SUPPORTED_FUNCTIONS.FIRST_DAY_OF_MONTH,
-          multiplicityOne,
         );
         valueSpecification_setGenericType(
           firstDayOfMonthSFE,
-          GenericTypeExplicitReference.create(new GenericType(date)),
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.DATE),
+          ),
         );
         return firstDayOfMonthSFE;
       }
       case CUSTOM_DATE_FIRST_DAY_OF_UNIT.WEEK: {
         const firstDayOfWeekSFE = new SimpleFunctionExpression(
           SUPPORTED_FUNCTIONS.FIRST_DAY_OF_WEEK,
-          multiplicityOne,
         );
         valueSpecification_setGenericType(
           firstDayOfWeekSFE,
-          GenericTypeExplicitReference.create(new GenericType(date)),
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.DATE),
+          ),
         );
         return firstDayOfWeekSFE;
       }
@@ -334,66 +330,70 @@ const buildPureDateFunctionExpression = (
       case CUSTOM_DATE_PICKER_OPTION.TODAY: {
         const todaySFE = new SimpleFunctionExpression(
           SUPPORTED_FUNCTIONS.TODAY,
-          multiplicityOne,
         );
         valueSpecification_setGenericType(
           todaySFE,
-          GenericTypeExplicitReference.create(new GenericType(strictDate)),
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.STRICTDATE),
+          ),
         );
         return todaySFE;
       }
       case CUSTOM_DATE_PICKER_OPTION.NOW: {
-        const nowSFE = new SimpleFunctionExpression(
-          SUPPORTED_FUNCTIONS.NOW,
-          multiplicityOne,
-        );
+        const nowSFE = new SimpleFunctionExpression(SUPPORTED_FUNCTIONS.NOW);
         valueSpecification_setGenericType(
           nowSFE,
-          GenericTypeExplicitReference.create(new GenericType(dateTime)),
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.DATETIME),
+          ),
         );
         return nowSFE;
       }
       case CUSTOM_DATE_OPTION_REFERENCE_MOMENT.FIRST_DAY_OF_YEAR: {
         const firstDayOfYearSFE = new SimpleFunctionExpression(
           SUPPORTED_FUNCTIONS.FIRST_DAY_OF_YEAR,
-          multiplicityOne,
         );
         valueSpecification_setGenericType(
           firstDayOfYearSFE,
-          GenericTypeExplicitReference.create(new GenericType(date)),
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.DATE),
+          ),
         );
         return firstDayOfYearSFE;
       }
       case CUSTOM_DATE_OPTION_REFERENCE_MOMENT.FIRST_DAY_OF_QUARTER: {
         const firstDayOfQuarterSFE = new SimpleFunctionExpression(
           SUPPORTED_FUNCTIONS.FIRST_DAY_OF_QUARTER,
-          multiplicityOne,
         );
         valueSpecification_setGenericType(
           firstDayOfQuarterSFE,
-          GenericTypeExplicitReference.create(new GenericType(strictDate)),
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.STRICTDATE),
+          ),
         );
         return firstDayOfQuarterSFE;
       }
       case CUSTOM_DATE_OPTION_REFERENCE_MOMENT.FIRST_DAY_OF_MONTH: {
         const firstDayOfMonthSFE = new SimpleFunctionExpression(
           SUPPORTED_FUNCTIONS.FIRST_DAY_OF_MONTH,
-          multiplicityOne,
         );
         valueSpecification_setGenericType(
           firstDayOfMonthSFE,
-          GenericTypeExplicitReference.create(new GenericType(date)),
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.DATE),
+          ),
         );
         return firstDayOfMonthSFE;
       }
       case CUSTOM_DATE_OPTION_REFERENCE_MOMENT.FIRST_DAY_OF_WEEK: {
         const firstDayOfWeekSFE = new SimpleFunctionExpression(
           SUPPORTED_FUNCTIONS.FIRST_DAY_OF_WEEK,
-          multiplicityOne,
         );
         valueSpecification_setGenericType(
           firstDayOfWeekSFE,
-          GenericTypeExplicitReference.create(new GenericType(date)),
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.DATE),
+          ),
         );
         return firstDayOfWeekSFE;
       }
@@ -437,12 +437,8 @@ const buildPureAdjustDateFunction = (
   graph: PureModel,
   observerContext: ObserverContext,
 ): SimpleFunctionExpression => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
   const dateAdjustSimpleFunctionExpression = new SimpleFunctionExpression(
     SUPPORTED_FUNCTIONS.ADJUST,
-    multiplicityOne,
   );
   functionExpression_addParameterValue(
     dateAdjustSimpleFunctionExpression,
@@ -457,10 +453,7 @@ const buildPureAdjustDateFunction = (
     observerContext,
   );
   if (customDateOption.direction === CUSTOM_DATE_OPTION_DIRECTION.BEFORE) {
-    const minusFunc = new SimpleFunctionExpression(
-      SUPPORTED_FUNCTIONS.MINUS,
-      multiplicityOne,
-    );
+    const minusFunc = new SimpleFunctionExpression(SUPPORTED_FUNCTIONS.MINUS);
     functionExpression_addParameterValue(
       minusFunc,
       buildPrimitiveInstanceValue(
@@ -491,7 +484,6 @@ const buildPureAdjustDateFunction = (
     GenericTypeExplicitReference.create(
       new GenericType(graph.getType(DURATION_UNIT)),
     ),
-    multiplicityOne,
   );
   instanceValue_setValues(durationUnitEnumIntanceValue, [
     ...durationUnitEnumIntanceValue.values,
@@ -511,9 +503,7 @@ const buildPureAdjustDateFunction = (
   );
   valueSpecification_setGenericType(
     dateAdjustSimpleFunctionExpression,
-    GenericTypeExplicitReference.create(
-      new GenericType(graph.getPrimitiveType(PRIMITIVE_TYPE.DATE)),
-    ),
+    GenericTypeExplicitReference.create(new GenericType(PrimitiveType.DATE)),
   );
   return dateAdjustSimpleFunctionExpression;
 };
@@ -747,7 +737,7 @@ const AbsoluteDateValueSpecificationEditor: React.FC<{
         valueSpecification_setGenericType(
           valueSpecification,
           GenericTypeExplicitReference.create(
-            new GenericType(graph.getPrimitiveType(PRIMITIVE_TYPE.STRICTDATE)),
+            new GenericType(PrimitiveType.STRICTDATE),
           ),
         );
       }
@@ -816,7 +806,7 @@ const AbsoluteTimeValueSpecificationEditor: React.FC<{
         valueSpecification_setGenericType(
           valueSpecification,
           GenericTypeExplicitReference.create(
-            new GenericType(graph.getPrimitiveType(PRIMITIVE_TYPE.DATETIME)),
+            new GenericType(PrimitiveType.DATETIME),
           ),
         );
       }

package/src/components/shared/LambdaParameterValuesEditor.tsx

@@ -25,8 +25,8 @@ import {
 import {
   type PureModel,
   type ValueSpecification,
-  PRIMITIVE_TYPE,
   type ObserverContext,
+  PrimitiveType,
 } from '@finos/legend-graph';
 import { prettyCONSTName } from '@finos/legend-shared';
 import { observer } from 'mobx-react-lite';
@@ -68,8 +68,8 @@ export const LambdaParameterValuesEditor = observer(
           <ModalHeader title="Set Parameter Values" />
           <ModalBody className="lambda-parameter-values__modal__body">
             {lambdaParametersState.parameterStates.map((paramState) => {
-              const stringType = graph.getPrimitiveType(PRIMITIVE_TYPE.STRING);
-              const variableType = paramState.variableType ?? stringType;
+              const variableType =
+                paramState.variableType ?? PrimitiveType.STRING;
               return (
                 <div
                   key={paramState.uuid}
@@ -95,9 +95,7 @@ export const LambdaParameterValuesEditor = observer(
                       obseverContext={observerContext}
                       typeCheckOption={{
                         expectedType: variableType,
-                        match:
-                          variableType ===
-                          graph.getPrimitiveType(PRIMITIVE_TYPE.DATETIME),
+                        match: variableType === PrimitiveType.DATETIME,
                       }}
                       className="query-builder__parameters__value__editor"
                       resetValue={(): void => paramState.mockParameterValue()}

package/src/components/watermark/QueryBuilderWatermark.tsx

@@ -27,7 +27,13 @@ import {
   PanelFormListItems,
   PanelFormSection,
 } from '@finos/legend-art';
-import { PRIMITIVE_TYPE, type ValueSpecification } from '@finos/legend-graph';
+import {
+  areMultiplicitiesEqual,
+  Multiplicity,
+  PrimitiveType,
+  type VariableExpression,
+  type ValueSpecification,
+} from '@finos/legend-graph';
 import { observer } from 'mobx-react-lite';
 import { useCallback } from 'react';
 import { useDrop } from 'react-dnd';
@@ -40,6 +46,12 @@ import type { QueryBuilderWatermarkState } from '../../stores/watermark/QueryBui
 import { VariableExpressionViewer } from '../QueryBuilderParametersPanel.js';
 import { BasicValueSpecificationEditor } from '../shared/BasicValueSpecificationEditor.js';
 
+const isParamaterCompatibleWithWaterMark = (
+  parameter: VariableExpression,
+): boolean =>
+  PrimitiveType.STRING === parameter.genericType?.value.rawType &&
+  areMultiplicitiesEqual(parameter.multiplicity, Multiplicity.ONE);
+
 const WatermarkValueEditor = observer(
   (props: {
     watermarkValue: ValueSpecification;
@@ -67,9 +79,7 @@ const WatermarkValueEditor = observer(
           if (
             !monitor.didDrop() &&
             // Only allows parameters with muliplicity 1 and type string
-            watermarkState.isParamaterCompatibleWithWaterMark(
-              item.variable.parameter,
-            )
+            isParamaterCompatibleWithWaterMark(item.variable.parameter)
           ) {
             handleDrop(item);
           } // prevent drop event propagation to accomondate for nested DnD
@@ -100,7 +110,7 @@ const WatermarkValueEditor = observer(
                 watermarkState.queryBuilderState.observableContext
               }
               typeCheckOption={{
-                expectedType: graph.getPrimitiveType(PRIMITIVE_TYPE.STRING),
+                expectedType: PrimitiveType.STRING,
               }}
               resetValue={(): void => {
                 watermarkState.resetValue();
@@ -122,7 +132,7 @@ export const QueryBuilderWatermarkEditor = observer(
     };
     const compatibleParameters =
       queryBuilderState.parametersState.parameterStates.filter((p) =>
-        watermarkState.isParamaterCompatibleWithWaterMark(p.parameter),
+        isParamaterCompatibleWithWaterMark(p.parameter),
       );
 
     return (

package/src/graphManager/QueryBuilderHashUtils.ts

@@ -65,20 +65,20 @@ export enum QUERY_BUILDER_HASH_STRUCTURE {
   WATERMARK_STATE = 'WATERMARK_STATE',
 
   // OLAPGroup state
-  OLAP_GROUPBY_STATE = 'OLAP_GROUPBY_STATE',
-  OLAP_GROUPBY_OPERATION_STATE = 'OLAP_GROUPBY_OPERATION_STATE',
-  OLAP_GROUPBY_AGG_OPERATION_STATE = 'OLAP_GROUPBY_AGG_OPERATION_STATE',
-  OLAP_GROUPBY_COLUMN_STATE = 'OLAP_GROUPBY_COLUMN_STATE',
-  OLAP_GROUPBY_COLUMN_SORTBY_STATE = 'OLAP_GROUPBY_COLUMN_SORTBY_STATE',
-  OLAP_OPERATOR_RANK = 'OLAP_OPERATOR_RANK',
-  OLAP_OPERATOR_AVERAGE_RANK = 'OLAP_OPERATOR_AVERAGE_RANK',
-  OLAP_OPERATOR_DENSE_RANK = 'OLAP_OPERATOR_DENSE_RANK',
-  OLAP_OPERATOR_ROW_NUMBER = 'OLAP_OPERATOR_ROW_NUMBER',
-  OLAP_OPERATOR_SUM = 'OLAP_OPERATOR_SUM',
-  OLAP_OPERATOR_MAX = 'OLAP_OPERATOR_MAX',
-  OLAP_OPERATOR_MIN = 'OLAP_OPERATOR_MIN',
-  OLAP_OPERATOR_COUNT = 'OLAP_OPERATOR_COUNT',
-  OLAP_OPERATOR_AVERAGE = 'OLAP_OPERATOR_AVERAGE',
+  TDS_OLAP_GROUPBY_STATE = 'TDS_OLAP_GROUPBY_STATE',
+  TDS_OLAP_GROUPBY_OPERATION_STATE = 'TDS_OLAP_GROUPBY_OPERATION_STATE',
+  TDS_OLAP_GROUPBY_AGG_OPERATION_STATE = 'TDS_OLAP_GROUPBY_AGG_OPERATION_STATE',
+  TDS_OLAP_GROUPBY_COLUMN_STATE = 'TDS_OLAP_GROUPBY_COLUMN_STATE',
+  TDS_OLAP_GROUPBY_COLUMN_SORTBY_STATE = 'TDS_OLAP_GROUPBY_COLUMN_SORTBY_STATE',
+  TDS_OLAP_OPERATOR_RANK = 'TDS_OLAP_OPERATOR_RANK',
+  TDS_OLAP_OPERATOR_AVERAGE_RANK = 'TDS_OLAP_OPERATOR_AVERAGE_RANK',
+  TDS_OLAP_OPERATOR_DENSE_RANK = 'TDS_OLAP_OPERATOR_DENSE_RANK',
+  TDS_OLAP_OPERATOR_ROW_NUMBER = 'TDS_OLAP_OPERATOR_ROW_NUMBER',
+  TDS_OLAP_OPERATOR_SUM = 'TDS_OLAP_OPERATOR_SUM',
+  TDS_OLAP_OPERATOR_MAX = 'TDS_OLAP_OPERATOR_MAX',
+  TDS_OLAP_OPERATOR_MIN = 'TDS_OLAP_OPERATOR_MIN',
+  TDS_OLAP_OPERATOR_COUNT = 'TDS_OLAP_OPERATOR_COUNT',
+  TDS_OLAP_OPERATOR_AVERAGE = 'TDS_OLAP_OPERATOR_AVERAGE',
 
   // filter state
   FILTER_TREE_GROUP_NODE_DATA = 'FILTER_TREE_GROUP_NODE_DATA',

package/src/graphManager/protocol/pure/QueryBuilder_PureProtocolProcessorPlugin.ts

@@ -20,7 +20,7 @@ import {
   V1_buildFilterFunctionExpression,
   V1_buildGetAllFunctionExpression,
   V1_buildGroupByFunctionExpression,
-  V1_buildOlapGroupByFunctionExpression,
+  V1_buildOLAPGroupByFunctionExpression,
   V1_buildProjectFunctionExpression,
   V1_buildSubTypePropertyExpressionTypeInference,
   V1_buildWatermarkFunctionExpression,
@@ -142,7 +142,7 @@ export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProces
             QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_GROUPBY,
           )
         ) {
-          return V1_buildOlapGroupByFunctionExpression(
+          return V1_buildOLAPGroupByFunctionExpression(
             functionName,
             parameters,
             openVariables,

package/src/graphManager/protocol/pure/v1/V1_QueryBuilder_PureGraphManagerExtension.ts

@@ -18,7 +18,6 @@ import {
   EngineRuntime,
   GraphBuilderError,
   MappingInclude,
-  V1_getIncludedMappingPath,
   V1_GraphBuilderContextBuilder,
   V1_Mapping,
   V1_MAPPING_ELEMENT_PROTOCOL_TYPE,
@@ -95,12 +94,12 @@ export class V1_QueryBuilder_PureGraphManagerExtension extends QueryBuilder_Pure
         const mapping = mappings.find((e) => e.path === element.path);
         if (mapping) {
           mapping.includes = element.includedMappings.map(
-            (i) =>
+            (mappingInclude) =>
               new MappingInclude(
                 mapping,
                 context.resolveMapping(
                   guaranteeNonEmptyString(
-                    V1_getIncludedMappingPath(i),
+                    mappingInclude.includedMapping,
                     `Mapping include path is missing or empty`,
                   ),
                 ),
@@ -201,7 +200,7 @@ export class V1_QueryBuilder_PureGraphManagerExtension extends QueryBuilder_Pure
                 mapping,
                 context.resolveMapping(
                   guaranteeNonEmptyString(
-                    V1_getIncludedMappingPath(include),
+                    include.includedMapping,
                     `Mapping include path is missing or empty`,
                   ),
                 ),

package/src/graphManager/protocol/pure/v1/V1_QueryValueSpecificationBuilderHelper.ts

@@ -47,10 +47,10 @@ import {
   V1_Lambda,
   V1_ValueSpecificationBuilder,
   AbstractPropertyExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
   VariableExpression,
   CORE_PURE_PATH,
-  PRIMITIVE_TYPE,
+  Multiplicity,
+  PrimitiveType,
 } from '@finos/legend-graph';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../QueryBuilderSupportedFunctions.js';
 
@@ -168,7 +168,10 @@ const buildAggregationExpression = (
       ),
     ) ??
     new INTERNAL__UnknownValueSpecification(
-      V1_serializeValueSpecification(columnLambda),
+      V1_serializeValueSpecification(
+        columnLambda,
+        compileContext.extensions.plugins,
+      ),
     );
 
   // aggregate lambda
@@ -249,9 +252,7 @@ export const V1_buildExistsFunctionExpression = (
       if (variable.name && !variable.class) {
         const variableExpression = new VariableExpression(
           variable.name,
-          compileContext.graph.getTypicalMultiplicity(
-            TYPICAL_MULTIPLICITY_TYPE.ONE,
-          ),
+          Multiplicity.ONE,
         );
         variableExpression.genericType = precedingExpression.genericType;
         processingContext.addInferredVariables(
@@ -408,7 +409,10 @@ export const V1_buildProjectFunctionExpression = (
       );
     } catch {
       return new INTERNAL__UnknownValueSpecification(
-        V1_serializeValueSpecification(value),
+        V1_serializeValueSpecification(
+          value,
+          compileContext.extensions.plugins,
+        ),
       );
     }
   });
@@ -528,7 +532,10 @@ export const V1_buildGroupByFunctionExpression = (
       );
     } catch {
       return new INTERNAL__UnknownValueSpecification(
-        V1_serializeValueSpecification(value),
+        V1_serializeValueSpecification(
+          value,
+          compileContext.extensions.plugins,
+        ),
       );
     }
   });
@@ -630,9 +637,8 @@ export const V1_buildWatermarkFunctionExpression = (
   const watermarkValueParamType =
     watermarkValueParam.genericType?.value.rawType;
   assertTrue(
-    compileContext.graph.getPrimitiveType(PRIMITIVE_TYPE.STRING) ===
-      watermarkValueParamType,
-    "Can't build forWatermark() expression: watermark parameter is expected to be of type string.",
+    PrimitiveType.STRING === watermarkValueParamType,
+    "Can't build forWatermark() expression: parameter is expected to be a string",
   );
 
   const expression = V1_buildBaseSimpleFunctionExpression(
@@ -646,7 +652,7 @@ export const V1_buildWatermarkFunctionExpression = (
   return [expression, processedParams];
 };
 
-export const V1_buildOlapGroupByFunctionExpression = (
+export const V1_buildOLAPGroupByFunctionExpression = (
   functionName: string,
   parameters: V1_ValueSpecification[],
   openVariables: string[],

package/src/stores/QueryBuilderMilestoningState.ts

@@ -22,10 +22,10 @@ import {
   getMilestoneTemporalStereotype,
   MILESTONING_STEREOTYPE,
   observe_ValueSpecification,
-  PRIMITIVE_TYPE,
-  TYPICAL_MULTIPLICITY_TYPE,
   VariableExpression,
   type ValueSpecification,
+  Multiplicity,
+  PrimitiveType,
 } from '@finos/legend-graph';
 import { type Hashable, hashArray } from '@finos/legend-shared';
 import { action, computed, makeObservable, observable } from 'mobx';
@@ -138,16 +138,8 @@ export class QueryBuilderMilestoningState implements Hashable {
   buildMilestoningParameter(parameterName: string): ValueSpecification {
     const milestoningParameter = new VariableExpression(
       parameterName,
-      this.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
-        TYPICAL_MULTIPLICITY_TYPE.ONE,
-      ),
-      GenericTypeExplicitReference.create(
-        new GenericType(
-          this.queryBuilderState.parametersState.queryBuilderState.graphManagerState.graph.getPrimitiveType(
-            PRIMITIVE_TYPE.DATE,
-          ),
-        ),
-      ),
+      Multiplicity.ONE,
+      GenericTypeExplicitReference.create(new GenericType(PrimitiveType.DATE)),
     );
     if (
       !this.queryBuilderState.parametersState.parameterStates.find(

package/src/stores/QueryBuilderPropertyEditorState.ts

@@ -31,8 +31,6 @@ import {
   type Enum,
   type ValueSpecification,
   type PureModel,
-  TYPICAL_MULTIPLICITY_TYPE,
-  CollectionInstanceValue,
   AbstractPropertyExpression,
   DerivedProperty,
   Enumeration,
@@ -56,8 +54,12 @@ import {
   Association,
   getGeneratedMilestonedPropertiesForAssociation,
   PropertyExplicitReference,
+  PrimitiveType,
 } from '@finos/legend-graph';
-import { generateDefaultValueForPrimitiveType } from './QueryBuilderValueSpecificationHelper.js';
+import {
+  createNullishValue,
+  generateDefaultValueForPrimitiveType,
+} from './QueryBuilderValueSpecificationHelper.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import type { QueryBuilderMilestoningState } from './QueryBuilderMilestoningState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
@@ -369,42 +371,29 @@ export const getPropertyPath = (
   return propertyNameChain.join('.');
 };
 
+/**
+ * TODO: this currently ignores the multiplicity of the parameters
+ * we should check for the multiplicity and adaptively produce
+ * either simple primitive/enum instance value or collection
+ */
 export const generateValueSpecificationForParameter = (
   parameter: VariableExpression,
   graph: PureModel,
 ): ValueSpecification => {
   if (parameter.genericType) {
     const type = parameter.genericType.value.rawType;
-    if (
-      (
-        [
-          PRIMITIVE_TYPE.STRING,
-          PRIMITIVE_TYPE.BOOLEAN,
-          PRIMITIVE_TYPE.NUMBER,
-          PRIMITIVE_TYPE.FLOAT,
-          PRIMITIVE_TYPE.DECIMAL,
-          PRIMITIVE_TYPE.INTEGER,
-          PRIMITIVE_TYPE.DATE,
-          PRIMITIVE_TYPE.STRICTDATE,
-          PRIMITIVE_TYPE.DATETIME,
-          PRIMITIVE_TYPE.LATESTDATE,
-        ] as string[]
-      ).includes(type.name)
-    ) {
+    if (type instanceof PrimitiveType) {
       const primitiveInstanceValue = new PrimitiveInstanceValue(
         GenericTypeExplicitReference.create(
           new GenericType(
             // NOTE: since the default generated value for type Date is a StrictDate
             // we need to adjust the generic type accordingly
             // See https://github.com/finos/legend-studio/issues/1391
-            type.name === PRIMITIVE_TYPE.DATE
-              ? graph.getType(PRIMITIVE_TYPE.STRICTDATE)
-              : type,
+            type === PrimitiveType.DATE ? PrimitiveType.STRICTDATE : type,
           ),
         ),
-        parameter.multiplicity,
       );
-      if (type.name !== PRIMITIVE_TYPE.LATESTDATE) {
+      if (type !== PrimitiveType.LATESTDATE) {
         instanceValue_setValues(primitiveInstanceValue, [
           generateDefaultValueForPrimitiveType(type.name as PRIMITIVE_TYPE),
         ]);
@@ -413,7 +402,6 @@ export const generateValueSpecificationForParameter = (
     } else if (type instanceof Enumeration) {
       const enumValueInstanceValue = new EnumValueInstanceValue(
         GenericTypeExplicitReference.create(new GenericType(type)),
-        parameter.multiplicity,
       );
       if (type.values.length) {
         const enumValueRef = EnumValueExplicitReference.create(
@@ -426,9 +414,7 @@ export const generateValueSpecificationForParameter = (
   }
   // for arguments of types we don't support, we will fill them with `[]`
   // which in Pure is equivalent to `null` in other languages
-  return new CollectionInstanceValue(
-    graph.getTypicalMultiplicity(TYPICAL_MULTIPLICITY_TYPE.ZERO),
-  );
+  return createNullishValue(graph);
 };
 
 const fillDerivedPropertyParameterValues = (
@@ -529,8 +515,7 @@ export class QueryBuilderDerivedPropertyExpressionState {
         // required and no values provided. LatestDate doesn't have any values so we skip that check for it.
         if (
           isRequired &&
-          paramValue.genericType?.value.rawType.name !==
-            PRIMITIVE_TYPE.LATESTDATE &&
+          paramValue.genericType?.value.rawType !== PrimitiveType.LATESTDATE &&
           !paramValue.values.length
         ) {
           return false;