@finos/legend-query-builder 4.14.35 → 4.14.37

package/src/index.ts

@@ -21,6 +21,7 @@ export * from './__lib__/QueryBuilderEvent.js';
 export { QueryBuilder_GraphManagerPreset } from './graph-manager/QueryBuilder_GraphManagerPreset.js';
 export { QueryBuilderConfig } from './graph-manager/QueryBuilderConfig.js';
 export { QUERY_BUILDER_TEST_ID } from './__lib__/QueryBuilderTesting.js';
+export { dragAndDrop } from './components/__test-utils__/QueryBuilderComponentTestUtils.js';
 export {
   type CheckEntitlementEditorRender,
   QueryBuilder_LegendApplicationPlugin,
@@ -29,8 +30,8 @@ export { QueryBuilderNavigationBlocker } from './components/QueryBuilderNavigati
 export { QueryBuilder } from './components/QueryBuilder.js';
 export { QUERY_BUILDER_COMPONENT_ELEMENT_ID } from './components/QueryBuilderComponentElement.js';
 export {
-  QueryBuilderState,
   type QuerySDLC,
+  QueryBuilderState,
 } from './stores/QueryBuilderState.js';
 export {
   getTDSColumnDerivedProperyFromType,

package/src/stores/QueryBuilderConstantsState.ts

@@ -131,6 +131,8 @@ export class QueryBuilderSimpleConstantExpressionState
           this.queryBuilderState.graphManagerState.graph,
           type,
           this.queryBuilderState.observerContext,
+          this.queryBuilderState
+            .INTERNAL__enableInitializingDefaultSimpleExpressionValue,
         );
         this.setValueSpec(valSpec);
       } catch (error) {

package/src/stores/QueryBuilderPropertyEditorState.ts

@@ -26,17 +26,13 @@ import {
 import {
   Class,
   type AbstractProperty,
-  type Enum,
   type ValueSpecification,
   type PureModel,
   AbstractPropertyExpression,
   DerivedProperty,
   Enumeration,
-  EnumValueExplicitReference,
-  EnumValueInstanceValue,
   InstanceValue,
   PrimitiveInstanceValue,
-  type PRIMITIVE_TYPE,
   VariableExpression,
   SimpleFunctionExpression,
   matchFunctionName,
@@ -50,7 +46,7 @@ import {
 } from '@finos/legend-graph';
 import {
   createNullishValue,
-  generateDefaultValueForPrimitiveType,
+  isValidInstanceValue,
 } from './QueryBuilderValueSpecificationHelper.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graph/QueryBuilderMetaModelConst.js';
@@ -58,9 +54,9 @@ import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from './QueryBuilderStateHashUtils
 import {
   propertyExpression_setFunc,
   functionExpression_setParametersValues,
-  instanceValue_setValues,
 } from './shared/ValueSpecificationModifierHelper.js';
 import { generateMilestonedPropertyParameterValue } from './milestoning/QueryBuilderMilestoningHelper.js';
+import { buildDefaultInstanceValue } from './shared/ValueSpecificationEditorHelper.js';
 
 export const getPropertyChainName = (
   propertyExpression: AbstractPropertyExpression,
@@ -141,44 +137,23 @@ export const getPropertyPath = (
 export const generateValueSpecificationForParameter = (
   parameter: VariableExpression,
   graph: PureModel,
+  initializeDefaultValue: boolean,
   observerContext: ObserverContext,
 ): ValueSpecification => {
   if (parameter.genericType) {
     const type = parameter.genericType.value.rawType;
-    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 === PrimitiveType.DATE ? PrimitiveType.STRICTDATE : type,
-          ),
-        ),
-      );
-      if (type !== PrimitiveType.LATESTDATE) {
-        instanceValue_setValues(
-          primitiveInstanceValue,
-          [generateDefaultValueForPrimitiveType(type.name as PRIMITIVE_TYPE)],
-          observerContext,
+    if (type instanceof PrimitiveType || type instanceof Enumeration) {
+      if (type === PrimitiveType.LATESTDATE) {
+        return new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(new GenericType(type)),
         );
       }
-      return primitiveInstanceValue;
-    } else if (type instanceof Enumeration) {
-      const enumValueInstanceValue = new EnumValueInstanceValue(
-        GenericTypeExplicitReference.create(new GenericType(type)),
+      return buildDefaultInstanceValue(
+        graph,
+        type,
+        observerContext,
+        initializeDefaultValue || parameter.multiplicity.lowerBound === 0,
       );
-      if (type.values.length) {
-        const enumValueRef = EnumValueExplicitReference.create(
-          type.values[0] as Enum,
-        );
-        instanceValue_setValues(
-          enumValueInstanceValue,
-          [enumValueRef],
-          observerContext,
-        );
-      }
-      return enumValueInstanceValue;
     }
   }
   // for arguments of types we don't support, we will fill them with `[]`
@@ -215,6 +190,8 @@ const fillDerivedPropertyParameterValues = (
           parameter,
           derivedPropertyExpressionState.queryBuilderState.graphManagerState
             .graph,
+          derivedPropertyExpressionState.queryBuilderState
+            .INTERNAL__enableInitializingDefaultSimpleExpressionValue,
           derivedPropertyExpressionState.queryBuilderState.observerContext,
         ),
     );
@@ -284,22 +261,7 @@ export class QueryBuilderDerivedPropertyExpressionState {
     // TODO: more type matching logic here (take into account multiplicity, type, etc.)
     return this.parameterValues.every((paramValue) => {
       if (paramValue instanceof InstanceValue) {
-        const isRequired = paramValue.multiplicity.lowerBound >= 1;
-        // required and no values provided. LatestDate doesn't have any values so we skip that check for it.
-        if (
-          isRequired &&
-          paramValue.genericType?.value.rawType !== PrimitiveType.LATESTDATE &&
-          !paramValue.values.length
-        ) {
-          return false;
-        }
-        // more values than allowed
-        if (
-          paramValue.multiplicity.upperBound &&
-          paramValue.values.length > paramValue.multiplicity.upperBound
-        ) {
-          return false;
-        }
+        return isValidInstanceValue(paramValue);
       }
       return true;
     });

package/src/stores/QueryBuilderState.ts

@@ -156,6 +156,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   isCalendarEnabled = false;
   isQueryChatOpened = false;
   isLocalModeEnabled = false;
+  INTERNAL__enableInitializingDefaultSimpleExpressionValue = false;
 
   lambdaWriteMode = QUERY_BUILDER_LAMBDA_WRITER_MODE.STANDARD;
 
@@ -207,10 +208,12 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       isLocalModeEnabled: observable,
       getAllFunction: observable,
       lambdaWriteMode: observable,
+      INTERNAL__enableInitializingDefaultSimpleExpressionValue: observable,
 
       sideBarClassName: computed,
       isQuerySupported: computed,
       allValidationIssues: computed,
+      canBuildQuery: computed,
 
       setShowFunctionsExplorerPanel: action,
       setShowParametersPanel: action,
@@ -222,6 +225,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       setIsLocalModeEnabled: action,
       setGetAllFunction: action,
       setLambdaWriteMode: action,
+      setINTERNAL__enableInitializingDefaultSimpleExpressionValue: action,
 
       resetQueryResult: action,
       resetQueryContent: action,
@@ -402,6 +406,12 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.getAllFunction = val;
   }
 
+  setINTERNAL__enableInitializingDefaultSimpleExpressionValue(
+    val: boolean,
+  ): void {
+    this.INTERNAL__enableInitializingDefaultSimpleExpressionValue = val;
+  }
+
   get isQuerySupported(): boolean {
     return !this.unsupportedQueryState.rawLambda;
   }
@@ -802,7 +812,19 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   }
 
   get allValidationIssues(): string[] {
-    return this.fetchStructureState.implementation.allValidationIssues;
+    return this.fetchStructureState.implementation.allValidationIssues.concat(
+      this.filterState.allValidationIssues,
+    );
+  }
+
+  get canBuildQuery(): boolean {
+    return (
+      !this.filterState.hasInvalidFilterValues &&
+      !this.filterState.hasInvalidDerivedPropertyParameters &&
+      !this.fetchStructureState.implementation.hasInvalidFilterValues &&
+      !this.fetchStructureState.implementation
+        .hasInvalidDerivedPropertyParameters
+    );
   }
 
   /**

package/src/stores/QueryBuilderValueSpecificationHelper.ts

@@ -46,6 +46,7 @@ import {
   INTERNAL__PropagatedValue,
   isSubType,
   type ObserverContext,
+  InstanceValue,
 } from '@finos/legend-graph';
 import {
   addUniqueEntry,
@@ -130,6 +131,37 @@ export const getCollectionValueSpecificationType = (
   return undefined;
 };
 
+export const isValidInstanceValue = (value: InstanceValue): boolean => {
+  const isRequired = value.multiplicity.lowerBound >= 1;
+  // required and no values provided. LatestDate doesn't have any values so we skip that check for it.
+  if (
+    isRequired &&
+    value.genericType?.value.rawType !== PrimitiveType.LATESTDATE &&
+    (!value.values.length ||
+      value.values.some((val) => val === null || val === undefined))
+  ) {
+    return false;
+  }
+  // more values than allowed
+  if (
+    !(value instanceof CollectionInstanceValue) &&
+    value.multiplicity.upperBound &&
+    value.values.length > value.multiplicity.upperBound
+  ) {
+    return false;
+  }
+  // collection instance with invalid values
+  if (
+    value instanceof CollectionInstanceValue &&
+    value.values.some(
+      (val) => val instanceof InstanceValue && !isValidInstanceValue(val),
+    )
+  ) {
+    return false;
+  }
+  return true;
+};
+
 export const unwrapNotExpression = (
   expression: SimpleFunctionExpression,
 ): SimpleFunctionExpression | undefined => {

package/src/stores/QueryBuilder_LegendApplicationPlugin_Extension.ts

@@ -75,6 +75,25 @@ export type TemplateQueryPanelContentRenderer = (
   queryBuilderState: QueryBuilderState,
 ) => React.ReactNode;
 
+export type QueryBuilderHeaderActionConfiguration = {
+  key: string;
+  category: number;
+  renderer: (
+    queryBuilderState: QueryBuilderState,
+  ) => React.ReactNode | undefined;
+};
+
+export type QueryBuilderMenuActionConfiguration = {
+  key: string;
+  title?: string;
+  label: string;
+  onClick: (queryBuilderState: QueryBuilderState) => void;
+  icon?: React.ReactNode;
+  renderExtraComponent?: (
+    queryBuilderState: QueryBuilderState,
+  ) => React.ReactNode;
+};
+
 export interface QueryBuilder_LegendApplicationPlugin_Extension
   extends LegendApplicationPlugin {
   /**
@@ -118,4 +137,24 @@ export interface QueryBuilder_LegendApplicationPlugin_Extension
    * Get the list of template query panel content render
    */
   getExtraTemplateQueryPanelContentRenderer?(): TemplateQueryPanelContentRenderer[];
+
+  /**
+   * Get the list of action configurations
+   */
+  getExtraQueryBuilderHeaderActionConfigurations?(): QueryBuilderHeaderActionConfiguration[];
+
+  /**
+   * Get the list of action configurations
+   */
+  getExtraQueryBuilderHeaderTitleConfigurations?(): QueryBuilderHeaderActionConfiguration[];
+
+  /**
+   * Get the list of help menu action configurations
+   */
+  getExtraQueryBuilderHelpMenuActionConfigurations?(): QueryBuilderMenuActionConfiguration[];
+
+  /**
+   * Get the list of export menu action configurations
+   */
+  getExtraQueryBuilderExportMenuActionConfigurations?(): QueryBuilderMenuActionConfiguration[];
 }

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

@@ -47,6 +47,8 @@ export abstract class QueryBuilderFetchStructureImplementationState
       usedExplorerTreePropertyNodeIDs: computed,
       fetchStructureValidationIssues: computed,
       allValidationIssues: computed,
+      hasInvalidFilterValues: computed,
+      hasInvalidDerivedPropertyParameters: computed,
       hashCode: computed,
     });
 
@@ -75,6 +77,8 @@ export abstract class QueryBuilderFetchStructureImplementationState
   ): void;
   abstract initialize(): void;
   abstract initializeWithQuery(): void;
+  abstract get hasInvalidFilterValues(): boolean;
+  abstract get hasInvalidDerivedPropertyParameters(): boolean;
   abstract get hashCode(): string;
 
   get TEMPORARY__showPostFetchStructurePanel(): boolean {

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

@@ -529,6 +529,14 @@ export class QueryBuilderGraphFetchTreeState
     );
   }
 
+  get hasInvalidFilterValues(): boolean {
+    return false;
+  }
+
+  get hasInvalidDerivedPropertyParameters(): boolean {
+    return false;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.GRAPH_FETCH_STATE,

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

@@ -329,6 +329,20 @@ export class QueryBuilderTDSState
     if (hasNoProjectionColumns) {
       validationIssues.push('Query has no projection columns');
     }
+
+    this.projectionColumns.forEach((column) => {
+      if (
+        column instanceof QueryBuilderSimpleProjectionColumnState &&
+        column.propertyExpressionState.derivedPropertyExpressionStates.some(
+          (p) => !p.isValid,
+        )
+      ) {
+        validationIssues.push(
+          `Derived property parameter value for ${column.propertyExpressionState.title} is missing`,
+        );
+      }
+    });
+
     return validationIssues;
   }
 
@@ -336,6 +350,7 @@ export class QueryBuilderTDSState
     const fetchStructureValidationIssues = [
       ...this.fetchStructureValidationIssues,
       ...this.windowState.windowValidationIssues,
+      ...this.postFilterState.allValidationIssues,
     ];
 
     return fetchStructureValidationIssues;
@@ -786,6 +801,23 @@ export class QueryBuilderTDSState
     return Boolean(usedInProjection ?? usedInPostFilter);
   }
 
+  get hasInvalidFilterValues(): boolean {
+    return (
+      this.postFilterState.hasInvalidFilterValues ||
+      this.postFilterState.hasInvalidDerivedPropertyParameters
+    );
+  }
+
+  get hasInvalidDerivedPropertyParameters(): boolean {
+    return this.projectionColumns.some(
+      (column) =>
+        column instanceof QueryBuilderSimpleProjectionColumnState &&
+        column.propertyExpressionState.derivedPropertyExpressionStates.some(
+          (p) => !p.isValid,
+        ),
+    );
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.PROJECTION_STATE,

package/src/stores/fetch-structure/tds/post-filter/QueryBuilderPostFilterState.ts

@@ -25,6 +25,7 @@ import {
   observe_ValueSpecification,
   PrimitiveType,
   CollectionInstanceValue,
+  InstanceValue,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -59,6 +60,7 @@ import {
   QueryBuilderProjectionColumnState,
   type QueryBuilderProjectionColumnDragSource,
   QueryBuilderDerivationProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
 } from '../projection/QueryBuilderProjectionColumnState.js';
 import {
   buildProjectionColumnTypeaheadQuery,
@@ -72,6 +74,7 @@ import type { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState.j
 import {
   getCollectionValueSpecificationType,
   getNonCollectionValueSpecificationType,
+  isValidInstanceValue,
   isValueExpressionReferencedInValue,
 } from '../../../QueryBuilderValueSpecificationHelper.js';
 import { buildtdsPropertyExpressionFromColState } from './operators/QueryBuilderPostFilterOperatorValueSpecificationBuilder.js';
@@ -604,6 +607,9 @@ export class QueryBuilderPostFilterState
       replaceBlankNodeWithNode: action,
       setRearrangingConditions: action,
       setDerivedColumnBeingDropped: action,
+      allValidationIssues: computed,
+      hasInvalidFilterValues: computed,
+      hasInvalidDerivedPropertyParameters: computed,
       hashCode: computed,
     });
 
@@ -986,6 +992,59 @@ export class QueryBuilderPostFilterState
     );
   }
 
+  get allValidationIssues(): string[] {
+    const validationIssues: string[] = [];
+    Array.from(this.nodes.values()).forEach((node) => {
+      if (node instanceof QueryBuilderPostFilterTreeConditionNodeData) {
+        if (
+          node.condition.rightConditionValue instanceof
+            PostFilterValueSpecConditionValueState &&
+          node.condition.rightConditionValue.value instanceof InstanceValue &&
+          !isValidInstanceValue(node.condition.rightConditionValue.value) &&
+          node.condition.leftConditionValue instanceof
+            QueryBuilderSimpleProjectionColumnState
+        ) {
+          validationIssues.push(
+            `Filter value for ${node.condition.leftConditionValue.propertyExpressionState.title} is missing or invalid`,
+          );
+        }
+        if (
+          node.condition.leftConditionValue instanceof
+            QueryBuilderSimpleProjectionColumnState &&
+          !node.condition.leftConditionValue.propertyExpressionState.isValid
+        ) {
+          validationIssues.push(
+            `Derived property parameter value for ${node.condition.leftConditionValue.propertyExpressionState.title} is missing or invalid`,
+          );
+        }
+      }
+    });
+    return validationIssues;
+  }
+
+  get hasInvalidFilterValues(): boolean {
+    return Array.from(this.nodes.values()).some(
+      (node) =>
+        node instanceof QueryBuilderPostFilterTreeConditionNodeData &&
+        node.condition.rightConditionValue instanceof
+          PostFilterValueSpecConditionValueState &&
+        node.condition.rightConditionValue.value instanceof InstanceValue &&
+        !isValidInstanceValue(node.condition.rightConditionValue.value) &&
+        node.condition.leftConditionValue instanceof
+          QueryBuilderSimpleProjectionColumnState,
+    );
+  }
+
+  get hasInvalidDerivedPropertyParameters(): boolean {
+    return Array.from(this.nodes.values()).some(
+      (node) =>
+        node instanceof QueryBuilderPostFilterTreeConditionNodeData &&
+        node.condition.leftConditionValue instanceof
+          QueryBuilderSimpleProjectionColumnState &&
+        !node.condition.leftConditionValue.propertyExpressionState.isValid,
+    );
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.POST_FILTER_STATE,

package/src/stores/fetch-structure/tds/post-filter/operators/QueryBuilderPostFilterOperator_Contain.ts

@@ -36,13 +36,12 @@ import type {
 } from '../QueryBuilderPostFilterState.js';
 import {
   buildNotExpression,
-  generateDefaultValueForPrimitiveType,
   unwrapNotExpression,
 } from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorValueSpecificationBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graph/QueryBuilderMetaModelConst.js';
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
-import { buildPrimitiveInstanceValue } from '../../../../shared/ValueSpecificationEditorHelper.js';
+import { buildDefaultInstanceValue } from '../../../../shared/ValueSpecificationEditorHelper.js';
 
 export class QueryBuilderPostFilterOperator_Contain
   extends QueryBuilderPostFilterOperator
@@ -73,13 +72,14 @@ export class QueryBuilderPostFilterOperator_Contain
     );
     switch (propertyType.path) {
       case PRIMITIVE_TYPE.STRING: {
-        return buildPrimitiveInstanceValue(
+        return buildDefaultInstanceValue(
           postFilterConditionState.postFilterState.tdsState.queryBuilderState
             .graphManagerState.graph,
-          propertyType.path,
-          generateDefaultValueForPrimitiveType(propertyType.path),
+          propertyType,
           postFilterConditionState.postFilterState.tdsState.queryBuilderState
             .observerContext,
+          postFilterConditionState.postFilterState.tdsState.queryBuilderState
+            .INTERNAL__enableInitializingDefaultSimpleExpressionValue,
         );
       }
       default:

package/src/stores/fetch-structure/tds/post-filter/operators/QueryBuilderPostFilterOperator_EndWith.ts

@@ -34,13 +34,12 @@ import type {
 } from '../QueryBuilderPostFilterState.js';
 import {
   buildNotExpression,
-  generateDefaultValueForPrimitiveType,
   unwrapNotExpression,
 } from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorValueSpecificationBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graph/QueryBuilderMetaModelConst.js';
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
-import { buildPrimitiveInstanceValue } from '../../../../shared/ValueSpecificationEditorHelper.js';
+import { buildDefaultInstanceValue } from '../../../../shared/ValueSpecificationEditorHelper.js';
 
 export class QueryBuilderPostFilterOperator_EndWith
   extends QueryBuilderPostFilterOperator
@@ -70,13 +69,14 @@ export class QueryBuilderPostFilterOperator_EndWith
       postFilterConditionState.leftConditionValue.getColumnType();
     switch (propertyType?.path) {
       case PRIMITIVE_TYPE.STRING: {
-        return buildPrimitiveInstanceValue(
+        return buildDefaultInstanceValue(
           postFilterConditionState.postFilterState.tdsState.queryBuilderState
             .graphManagerState.graph,
-          propertyType.path,
-          generateDefaultValueForPrimitiveType(propertyType.path),
+          propertyType,
           postFilterConditionState.postFilterState.tdsState.queryBuilderState
             .observerContext,
+          postFilterConditionState.postFilterState.tdsState.queryBuilderState
+            .INTERNAL__enableInitializingDefaultSimpleExpressionValue,
         );
       }
       default:

package/src/stores/fetch-structure/tds/post-filter/operators/QueryBuilderPostFilterOperator_Equal.ts

@@ -17,15 +17,10 @@
 import {
   type Type,
   type ValueSpecification,
-  type Enum,
   type SimpleFunctionExpression,
   type FunctionExpression,
   AbstractPropertyExpression,
   Enumeration,
-  EnumValueExplicitReference,
-  EnumValueInstanceValue,
-  GenericType,
-  GenericTypeExplicitReference,
   PRIMITIVE_TYPE,
   PrimitiveType,
 } from '@finos/legend-graph';
@@ -33,7 +28,6 @@ import {
   guaranteeNonNullable,
   type Hashable,
   hashArray,
-  UnsupportedOperationError,
 } from '@finos/legend-shared';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
 import { buildPostFilterConditionState } from '../QueryBuilderPostFilterStateBuilder.js';
@@ -43,15 +37,13 @@ import {
 } from '../QueryBuilderPostFilterState.js';
 import {
   buildNotExpression,
-  generateDefaultValueForPrimitiveType,
   isTypeCompatibleForAssignment,
   unwrapNotExpression,
 } from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorValueSpecificationBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graph/QueryBuilderMetaModelConst.js';
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
-import { buildPrimitiveInstanceValue } from '../../../../shared/ValueSpecificationEditorHelper.js';
-import { instanceValue_setValues } from '../../../../shared/ValueSpecificationModifierHelper.js';
+import { buildDefaultInstanceValue } from '../../../../shared/ValueSpecificationEditorHelper.js';
 
 export class QueryBuilderPostFilterOperator_Equal
   extends QueryBuilderPostFilterOperator
@@ -101,66 +93,15 @@ export class QueryBuilderPostFilterOperator_Equal
     const propertyType = guaranteeNonNullable(
       postFilterConditionState.leftConditionValue.getColumnType(),
     );
-    switch (propertyType.path) {
-      case PRIMITIVE_TYPE.STRING:
-      case PRIMITIVE_TYPE.BOOLEAN:
-      case PRIMITIVE_TYPE.STRICTDATE:
-      case PRIMITIVE_TYPE.DATETIME:
-      case PRIMITIVE_TYPE.NUMBER:
-      case PRIMITIVE_TYPE.DECIMAL:
-      case PRIMITIVE_TYPE.FLOAT:
-      case PRIMITIVE_TYPE.INTEGER: {
-        return buildPrimitiveInstanceValue(
-          postFilterConditionState.postFilterState.tdsState.queryBuilderState
-            .graphManagerState.graph,
-          propertyType.path,
-          generateDefaultValueForPrimitiveType(propertyType.path),
-          postFilterConditionState.postFilterState.tdsState.queryBuilderState
-            .observerContext,
-        );
-      }
-      case PRIMITIVE_TYPE.DATE: {
-        return buildPrimitiveInstanceValue(
-          postFilterConditionState.postFilterState.tdsState.queryBuilderState
-            .graphManagerState.graph,
-          PRIMITIVE_TYPE.STRICTDATE,
-          generateDefaultValueForPrimitiveType(propertyType.path),
-          postFilterConditionState.postFilterState.tdsState.queryBuilderState
-            .observerContext,
-        );
-      }
-      default:
-        if (propertyType instanceof Enumeration) {
-          if (propertyType.values.length > 0) {
-            const enumValueInstanceValue = new EnumValueInstanceValue(
-              GenericTypeExplicitReference.create(
-                new GenericType(propertyType),
-              ),
-            );
-            instanceValue_setValues(
-              enumValueInstanceValue,
-              [
-                EnumValueExplicitReference.create(
-                  propertyType.values[0] as Enum,
-                ),
-              ],
-              postFilterConditionState.postFilterState.tdsState
-                .queryBuilderState.observerContext,
-            );
-            return enumValueInstanceValue;
-          }
-          throw new UnsupportedOperationError(
-            `Can't get default value for post-filter operator '${this.getLabel()}' since enumeration '${
-              propertyType.path
-            }' has no value`,
-          );
-        }
-        throw new UnsupportedOperationError(
-          `Can't get default value for post-filter operator '${this.getLabel()}' when the LHS property is of type '${
-            propertyType.path
-          }'`,
-        );
-    }
+    return buildDefaultInstanceValue(
+      postFilterConditionState.postFilterState.tdsState.queryBuilderState
+        .graphManagerState.graph,
+      propertyType,
+      postFilterConditionState.postFilterState.tdsState.queryBuilderState
+        .observerContext,
+      postFilterConditionState.postFilterState.tdsState.queryBuilderState
+        .INTERNAL__enableInitializingDefaultSimpleExpressionValue,
+    );
   }
 
   buildPostFilterConditionExpression(