@finos/legend-application-query 5.0.1 → 5.2.1

package/src/stores/QueryBuilderState.ts

@@ -62,76 +62,33 @@ import {
   buildLambdaVariableExpressions,
   buildRawLambdaFromLambdaFunction,
 } from '@finos/legend-graph';
-import {
-  QueryBuilderFilterOperator_Equal,
-  QueryBuilderFilterOperator_NotEqual,
-} from './filterOperators/QueryBuilderFilterOperator_Equal.js';
-import { QueryBuilderFilterOperator_GreaterThan } from './filterOperators/QueryBuilderFilterOperator_GreaterThan.js';
-import {
-  QueryBuilderFilterOperator_NotStartWith,
-  QueryBuilderFilterOperator_StartWith,
-} from './filterOperators/QueryBuilderFilterOperator_StartWith.js';
-import { QueryBuilderFilterOperator_GreaterThanEqual } from './filterOperators/QueryBuilderFilterOperator_GreaterThanEqual.js';
-import { QueryBuilderFilterOperator_LessThanEqual } from './filterOperators/QueryBuilderFilterOperator_LessThanEqual.js';
-import { QueryBuilderFilterOperator_LessThan } from './filterOperators/QueryBuilderFilterOperator_LessThan.js';
-import {
-  QueryBuilderFilterOperator_EndWith,
-  QueryBuilderFilterOperator_NotEndWith,
-} from './filterOperators/QueryBuilderFilterOperator_EndWith.js';
-import {
-  QueryBuilderFilterOperator_Contain,
-  QueryBuilderFilterOperator_NotContain,
-} from './filterOperators/QueryBuilderFilterOperator_Contain.js';
-import {
-  QueryBuilderFilterOperator_IsEmpty,
-  QueryBuilderFilterOperator_IsNotEmpty,
-} from './filterOperators/QueryBuilderFilterOperator_IsEmpty.js';
-import {
-  QueryBuilderFilterOperator_In,
-  QueryBuilderFilterOperator_NotIn,
-} from './filterOperators/QueryBuilderFilterOperator_In.js';
 import { buildLambdaFunction } from './QueryBuilderLambdaBuilder.js';
 import {
   LambdaParameterState,
   type GenericLegendApplicationStore,
 } from '@finos/legend-application';
 import { QueryBuilderPostFilterState } from './QueryBuilderPostFilterState.js';
-import {
-  QueryBuilderPostFilterOperator_Equal,
-  QueryBuilderPostFilterOperator_NotEqual,
-} from './postFilterOperators/QueryBuilderPostFilterOperator_Equal.js';
-import { QueryBuilderPostFilterOperator_LessThan } from './postFilterOperators/QueryBuilderPostFilterOperator_LessThan.js';
-import { QueryBuilderPostFilterOperator_LessThanEqual } from './postFilterOperators/QueryBuilderPostFilterOperator_LessThanEqual.js';
-import { QueryBuilderPostFilterOperator_GreaterThan } from './postFilterOperators/QueryBuilderPostFilterOperator_GreaterThan.js';
-import { QueryBuilderPostFilterOperator_GreaterThanEqual } from './postFilterOperators/QueryBuilderPostFilterOperator_GreaterThanEqual.js';
-import {
-  QueryBuilderPostFilterOperator_NotStartWith,
-  QueryBuilderPostFilterOperator_StartWith,
-} from './postFilterOperators/QueryBuilderPostFilterOperator_StartWith.js';
-import {
-  QueryBuilderPostFilterOperator_Contain,
-  QueryBuilderPostFilterOperator_NotContain,
-} from './postFilterOperators/QueryBuilderPostFilterOperator_Contain.js';
-import {
-  QueryBuilderPostFilterOperator_EndWith,
-  QueryBuilderPostFilterOperator_NotEndWith,
-} from './postFilterOperators/QueryBuilderPostFilterOperator_EndWith.js';
 import type { QueryBuilderPostFilterOperator } from './QueryBuilderPostFilterOperator.js';
-import {
-  QueryBuilderPostFilterOperator_In,
-  QueryBuilderPostFilterOperator_NotIn,
-} from './postFilterOperators/QueryBuilderPostFilterOperator_In.js';
-import {
-  QueryBuilderPostFilterOperator_IsEmpty,
-  QueryBuilderPostFilterOperator_IsNotEmpty,
-} from './postFilterOperators/QueryBuilderPostFilterOperator_IsEmpty.js';
 import { QueryFunctionsExplorerState } from './QueryFunctionsExplorerState.js';
 import { QueryParametersState } from './QueryParametersState.js';
+import {
+  AGGREGATION_OPERATORS,
+  FILTER_OPERATORS,
+  POST_FILTER_OPERATORS,
+} from './QueryBuilderOperatorLoader.js';
 
 export abstract class QueryBuilderMode {
   abstract get isParametersDisabled(): boolean;
 
   abstract get isResultPanelHidden(): boolean;
+
+  /**
+   * This flag is for turning on/off dnd from projection panel to filter panel,
+   * and will be leveraged when the concepts of workflows are introduced into query builder.
+   */
+  get isDnDProjectionToFilterSupported(): boolean {
+    return true;
+  }
 }
 
 export class StandardQueryBuilderMode extends QueryBuilderMode {
@@ -179,42 +136,8 @@ export class QueryBuilderState {
   queryTextEditorState: QueryTextEditorState;
   queryUnsupportedState: QueryBuilderUnsupportedState;
   observableContext: ObserverContext;
-  filterOperators: QueryBuilderFilterOperator[] = [
-    new QueryBuilderFilterOperator_Equal(),
-    new QueryBuilderFilterOperator_NotEqual(),
-    new QueryBuilderFilterOperator_LessThan(),
-    new QueryBuilderFilterOperator_LessThanEqual(),
-    new QueryBuilderFilterOperator_GreaterThan(),
-    new QueryBuilderFilterOperator_GreaterThanEqual(),
-    new QueryBuilderFilterOperator_StartWith(),
-    new QueryBuilderFilterOperator_NotStartWith(),
-    new QueryBuilderFilterOperator_Contain(),
-    new QueryBuilderFilterOperator_NotContain(),
-    new QueryBuilderFilterOperator_EndWith(),
-    new QueryBuilderFilterOperator_NotEndWith(),
-    new QueryBuilderFilterOperator_In(),
-    new QueryBuilderFilterOperator_NotIn(),
-    new QueryBuilderFilterOperator_IsEmpty(),
-    new QueryBuilderFilterOperator_IsNotEmpty(),
-  ];
-  postFilterOperators: QueryBuilderPostFilterOperator[] = [
-    new QueryBuilderPostFilterOperator_Equal(),
-    new QueryBuilderPostFilterOperator_NotEqual(),
-    new QueryBuilderPostFilterOperator_LessThan(),
-    new QueryBuilderPostFilterOperator_LessThanEqual(),
-    new QueryBuilderPostFilterOperator_GreaterThan(),
-    new QueryBuilderPostFilterOperator_GreaterThanEqual(),
-    new QueryBuilderPostFilterOperator_StartWith(),
-    new QueryBuilderPostFilterOperator_NotStartWith(),
-    new QueryBuilderPostFilterOperator_Contain(),
-    new QueryBuilderPostFilterOperator_NotContain(),
-    new QueryBuilderPostFilterOperator_EndWith(),
-    new QueryBuilderPostFilterOperator_NotEndWith(),
-    new QueryBuilderPostFilterOperator_In(),
-    new QueryBuilderPostFilterOperator_NotIn(),
-    new QueryBuilderPostFilterOperator_IsEmpty(),
-    new QueryBuilderPostFilterOperator_IsNotEmpty(),
-  ];
+  filterOperators: QueryBuilderFilterOperator[] = FILTER_OPERATORS;
+  postFilterOperators: QueryBuilderPostFilterOperator[] = POST_FILTER_OPERATORS;
   isCompiling = false;
   backdrop = false;
   showFunctionPanel = false;
@@ -267,7 +190,10 @@ export class QueryBuilderState {
     this.explorerState = new QueryBuilderExplorerState(this);
     this.queryParametersState = new QueryParametersState(this);
     this.queryFunctionsExplorerState = new QueryFunctionsExplorerState(this);
-    this.fetchStructureState = new QueryBuilderFetchStructureState(this);
+    this.fetchStructureState = new QueryBuilderFetchStructureState(
+      this,
+      AGGREGATION_OPERATORS,
+    );
     this.filterState = new QueryBuilderFilterState(this, this.filterOperators);
     this.postFilterState = new QueryBuilderPostFilterState(
       this,
@@ -338,7 +264,10 @@ export class QueryBuilderState {
     this.explorerState.refreshTreeData();
     this.queryParametersState = new QueryParametersState(this);
     this.queryFunctionsExplorerState = new QueryFunctionsExplorerState(this);
-    const fetchStructureState = new QueryBuilderFetchStructureState(this);
+    const fetchStructureState = new QueryBuilderFetchStructureState(
+      this,
+      this.fetchStructureState.projectionState.aggregationState.operators,
+    );
     fetchStructureState.setFetchStructureMode(
       this.fetchStructureState.fetchStructureMode,
     );
@@ -558,4 +487,16 @@ export class QueryBuilderState {
       this.fetchStructureState.graphFetchTreeState.initialize();
     }
   }
+
+  get validationIssues(): string[] | undefined {
+    return this.fetchStructureState.validationIssues;
+  }
+
+  createBareBuilderState(): QueryBuilderState {
+    return new QueryBuilderState(
+      this.applicationStore,
+      this.graphManagerState,
+      this.mode,
+    );
+  }
 }

package/src/stores/QueryBuilderTestUtils.ts

@@ -0,0 +1,93 @@
+/**
+ * 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 { TEST__getTestApplicationStore } from '@finos/legend-application';
+import {
+  type RawLambda,
+  type RawMappingModelCoverageAnalysisResult,
+  TEST__buildGraphWithEntities,
+  TEST__getTestGraphManagerState,
+} from '@finos/legend-graph';
+import type { Entity } from '@finos/legend-storage';
+import { jest } from '@jest/globals';
+import { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
+import { QueryBuilder_GraphManagerPreset } from '../graphManager/QueryBuilder_GraphManagerPreset.js';
+import {
+  QueryBuilderState,
+  StandardQueryBuilderMode,
+} from './QueryBuilderState.js';
+import { TEST__getTestLegendQueryApplicationConfig } from './QueryEditorStoreTestUtils.js';
+
+export const TEST_setUpQueryBuilderState = async (
+  entities: Entity[],
+  rawLambda?: RawLambda | undefined,
+  executionContext?:
+    | {
+        _class: string;
+        mapping: string;
+        runtime?: string | undefined;
+      }
+    | undefined,
+  rawMappingModelCoverageAnalysisResult?:
+    | RawMappingModelCoverageAnalysisResult
+    | undefined,
+): Promise<QueryBuilderState> => {
+  const pluginManager = LegendQueryPluginManager.create();
+  pluginManager.usePresets([new QueryBuilder_GraphManagerPreset()]).install();
+  const applicationStore = TEST__getTestApplicationStore(
+    TEST__getTestLegendQueryApplicationConfig(),
+    LegendQueryPluginManager.create(),
+  );
+  const graphManagerState = TEST__getTestGraphManagerState(pluginManager);
+  await TEST__buildGraphWithEntities(graphManagerState, entities);
+  const queryBuilderState = new QueryBuilderState(
+    applicationStore,
+    graphManagerState,
+    new StandardQueryBuilderMode(),
+  );
+  if (rawLambda) {
+    queryBuilderState.buildStateFromRawLambda(rawLambda);
+  }
+  if (executionContext) {
+    const graph = queryBuilderState.graphManagerState.graph;
+    queryBuilderState.querySetupState._class = graph.getClass(
+      executionContext._class,
+    );
+    queryBuilderState.querySetupState.mapping = graph.getMapping(
+      executionContext.mapping,
+    );
+    if (executionContext.runtime) {
+      queryBuilderState.querySetupState.runtimeValue = graph.getRuntime(
+        executionContext.runtime,
+      );
+    }
+  }
+  if (rawMappingModelCoverageAnalysisResult) {
+    jest
+      .spyOn(
+        queryBuilderState.graphManagerState.graphManager,
+        'analyzeMappingModelCoverage',
+      )
+      .mockResolvedValue(
+        queryBuilderState.graphManagerState.graphManager.buildMappingModelCoverageAnalysisResult(
+          rawMappingModelCoverageAnalysisResult,
+        ),
+      );
+
+    await queryBuilderState.explorerState.analyzeMappingModelCoverage();
+  }
+  return queryBuilderState;
+};

package/src/stores/QueryBuilderTypeaheadHelper.ts

@@ -0,0 +1,149 @@
+/**
+ * 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 {
+  type AbstractPropertyExpression,
+  type ExecutionResult,
+  type ValueSpecification,
+  PrimitiveInstanceValue,
+  PRIMITIVE_TYPE,
+  TdsExecutionResult,
+} from '@finos/legend-graph';
+import { guaranteeType, isNonNullable, isString } from '@finos/legend-shared';
+import { QueryBuilderPostFilterOperator_StartWith } from './postFilterOperators/QueryBuilderPostFilterOperator_StartWith.js';
+import type { QueryBuilderAggregateColumnState } from './QueryBuilderAggregationState.js';
+import {
+  PostFilterConditionState,
+  QueryBuilderPostFilterTreeConditionNodeData,
+} from './QueryBuilderPostFilterState.js';
+import {
+  QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from './QueryBuilderProjectionState.js';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+
+const TYPEAHEAD_TAKE_LIMIT = 10;
+const START_LENGTH = 3;
+
+const createAndSetupQueryBuilderStateForTypeAhead = (
+  queryBuilderState: QueryBuilderState,
+): QueryBuilderState => {
+  // builderState to build dummy query
+  const builderState = queryBuilderState.createBareBuilderState();
+  // setup
+  builderState.querySetupState = queryBuilderState.querySetupState;
+  // result modifiers
+  builderState.resultSetModifierState.distinct = true;
+  builderState.resultSetModifierState.limit = TYPEAHEAD_TAKE_LIMIT;
+  return builderState;
+};
+
+const buildColumnTypeAheadQuery = (
+  builderState: QueryBuilderState,
+  columnState:
+    | QueryBuilderProjectionColumnState
+    | QueryBuilderAggregateColumnState,
+  value: ValueSpecification | undefined,
+): QueryBuilderState => {
+  // projection column
+  let projectionState;
+  if (columnState instanceof QueryBuilderProjectionColumnState) {
+    projectionState = columnState;
+  } else {
+    projectionState = columnState.projectionColumnState;
+    const aggregationState =
+      builderState.fetchStructureState.projectionState.aggregationState;
+    aggregationState.columns = [columnState];
+  }
+  builderState.fetchStructureState.projectionState.columns = [projectionState];
+  // post filter
+  const postConditionState = new PostFilterConditionState(
+    builderState.postFilterState,
+    columnState,
+    value,
+    new QueryBuilderPostFilterOperator_StartWith(),
+  );
+  const postFilterNode = new QueryBuilderPostFilterTreeConditionNodeData(
+    undefined,
+    postConditionState,
+  );
+  builderState.postFilterState.addNodeFromNode(postFilterNode, undefined);
+  return builderState;
+};
+
+export const buildPropertyTypeAheadQuery = (
+  queryBuilderState: QueryBuilderState,
+  propertyExpression: AbstractPropertyExpression,
+  value: ValueSpecification | undefined,
+): QueryBuilderState => {
+  // builderState to build dummy query
+  const builderState =
+    createAndSetupQueryBuilderStateForTypeAhead(queryBuilderState);
+  const projectionState = new QueryBuilderSimpleProjectionColumnState(
+    builderState.fetchStructureState.projectionState,
+    propertyExpression,
+    false,
+  );
+  return buildColumnTypeAheadQuery(builderState, projectionState, value);
+};
+
+export const buildProjectionColumnTypeAheadQuery = (
+  queryBuilderState: QueryBuilderState,
+  columnState:
+    | QueryBuilderProjectionColumnState
+    | QueryBuilderAggregateColumnState,
+  value: ValueSpecification | undefined,
+): QueryBuilderState => {
+  // builderState to build dummy query
+  const builderState =
+    createAndSetupQueryBuilderStateForTypeAhead(queryBuilderState);
+  return buildColumnTypeAheadQuery(builderState, columnState, value);
+};
+
+export const buildTypeAheadOptions = (result: ExecutionResult): string[] => {
+  const tdsResult = guaranteeType(
+    result,
+    TdsExecutionResult,
+    'Type ahead search is only supported for tds result sets',
+  );
+  const options: string[] = [];
+  tdsResult.result.rows
+    .map((r) => r.values[0])
+    .filter(isNonNullable)
+    .forEach((r) => {
+      if (isString(r)) {
+        options.push(r);
+      }
+    });
+  return options;
+};
+
+export const performTypeAhead = (
+  val: ValueSpecification | undefined,
+): boolean => {
+  if (val instanceof PrimitiveInstanceValue) {
+    const _type = val.genericType.value.rawType;
+    switch (_type.path) {
+      case PRIMITIVE_TYPE.STRING: {
+        const value = val.values[0] as string;
+        return value.length >= START_LENGTH;
+      }
+      default:
+        return false;
+    }
+  }
+  return false;
+};

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -64,13 +64,15 @@ export const buildGenericLambdaFunctionInstanceValue = (
     TYPICAL_MULTIPLICITY_TYPE.ONE,
   );
   const typeAny = graph.getType(CORE_PURE_PATH.ANY);
-  const aggregateLambda = new LambdaFunctionInstanceValue(multiplicityOne);
-  const colLambdaFunctionType = new FunctionType(typeAny, multiplicityOne);
-  colLambdaFunctionType.parameters.push(
+  const functionInstanceValue = new LambdaFunctionInstanceValue(
+    multiplicityOne,
+  );
+  const functionType = new FunctionType(typeAny, multiplicityOne);
+  functionType.parameters.push(
     new VariableExpression(lambdaParameterName, multiplicityOne),
   );
-  const colLambdaFunction = new LambdaFunction(colLambdaFunctionType);
-  colLambdaFunction.expressionSequence = lambdaBodyExpressions;
-  aggregateLambda.values.push(colLambdaFunction);
-  return aggregateLambda;
+  const lambdaFunction = new LambdaFunction(functionType);
+  lambdaFunction.expressionSequence = lambdaBodyExpressions;
+  functionInstanceValue.values.push(lambdaFunction);
+  return functionInstanceValue;
 };

package/src/stores/QueryEditorStore.ts

@@ -50,6 +50,7 @@ import {
   type GraphBuilderReport,
   GraphManagerTelemetry,
   extractElementNameFromPath,
+  isSystemElement,
 } from '@finos/legend-graph';
 import {
   QueryBuilderState,
@@ -448,15 +449,30 @@ export class CreateQueryEditorStore extends QueryEditorStore {
       );
       this.queryBuilderState.querySetupState.setClassIsReadOnly(true);
     } else {
-      this.queryBuilderState.changeClass(
+      // try to find a class to set
+      // first, find classes which is mapped by the mapping
+      // then, find any classes except for class coming from system
+      // if none found, default to a dummy blank query
+      const defaultClass =
         getNullableFirstElement(
           this.queryBuilderState.querySetupState.mapping
             ? getAllClassMappings(
                 this.queryBuilderState.querySetupState.mapping,
               ).map((classMapping) => classMapping.class.value)
             : [],
-        ),
-      );
+        ) ??
+        getNullableFirstElement(
+          this.queryBuilderState.graphManagerState.graph.classes.filter(
+            (el) => !isSystemElement(el),
+          ),
+        );
+      if (defaultClass) {
+        this.queryBuilderState.changeClass(defaultClass);
+      } else {
+        this.queryBuilderState.initialize(
+          this.queryBuilderState.graphManagerState.graphManager.createDefaultBasicRawLambda(),
+        );
+      }
     }
   }
 

package/src/stores/QueryFunctionsExplorerState.ts

@@ -31,10 +31,7 @@ import { action, makeObservable, observable } from 'mobx';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import type { TreeNodeData, TreeData } from '@finos/legend-art';
 
-export enum QUERY_BUILDER_FUNCTIONS_EXPLORER_TREE_DND_TYPE {
-  FUNCTION = 'FUNCTION',
-  PACKAGE = 'PACKAGE',
-}
+export const QUERY_BUILDER_FUNCTION_DND_TYPE = 'QUERY_BUILDER_FUNCTION';
 
 export interface QueryBuilderFunctionsExplorerDragSource {
   node: QueryBuilderFunctionsExplorerTreeNodeData;
@@ -43,7 +40,6 @@ export interface QueryBuilderFunctionsExplorerDragSource {
 export class QueryBuilderFunctionsExplorerTreeNodeData implements TreeNodeData {
   id: string;
   label: string;
-  dndType: string;
   childrenIds: string[] = [];
   isOpen?: boolean | undefined;
   packageableElement: PackageableElement;
@@ -51,12 +47,10 @@ export class QueryBuilderFunctionsExplorerTreeNodeData implements TreeNodeData {
   constructor(
     id: string,
     label: string,
-    dndType: string,
     packageableElement: PackageableElement,
   ) {
     this.id = id;
     this.label = label;
-    this.dndType = dndType;
     this.packageableElement = packageableElement;
   }
 }
@@ -81,10 +75,6 @@ export const generateFunctionsExplorerTreeNodeData = (
   rootPackageName: ROOT_PACKAGE_NAME,
 ): QueryBuilderFunctionsExplorerTreeNodeData => ({
   id: element.path,
-  dndType:
-    element instanceof Package
-      ? QUERY_BUILDER_FUNCTIONS_EXPLORER_TREE_DND_TYPE.PACKAGE
-      : QUERY_BUILDER_FUNCTIONS_EXPLORER_TREE_DND_TYPE.FUNCTION,
   label: element.name,
   childrenIds:
     element instanceof Package

package/src/stores/QueryParametersState.ts

@@ -21,9 +21,7 @@ import {
 import { observable, makeObservable, action } from 'mobx';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 
-export enum QUERY_BUILDER_PARAMETER_TREE_DND_TYPE {
-  VARIABLE = 'VARIABLE',
-}
+export const QUERY_BUILDER_PARAMETER_DND_TYPE = 'PARAMETER';
 
 export interface QueryBuilderParameterDragSource {
   variable: LambdaParameterState;

package/src/stores/filterOperators/QueryBuilderFilterOperator_Equal.ts

@@ -31,7 +31,6 @@ import {
   EnumValueExplicitReference,
   Enumeration,
   PRIMITIVE_TYPE,
-  isSuperType,
   SUPPORTED_FUNCTIONS,
   buildPrimitiveInstanceValue,
 } from '@finos/legend-graph';
@@ -46,6 +45,7 @@ import {
   buildNotExpression,
   unwrapNotExpression,
   getNonCollectionValueSpecificationType,
+  isTypeCompatibleWithConditionValueType,
 } from '../QueryBuilderOperatorsHelper.js';
 
 export class QueryBuilderFilterOperator_Equal extends QueryBuilderFilterOperator {
@@ -81,41 +81,12 @@ export class QueryBuilderFilterOperator_Equal extends QueryBuilderFilterOperator
   isCompatibleWithFilterConditionValue(
     filterConditionState: FilterConditionState,
   ): boolean {
-    const propertyType =
+    return isTypeCompatibleWithConditionValueType(
+      filterConditionState.value
+        ? getNonCollectionValueSpecificationType(filterConditionState.value)
+        : undefined,
       filterConditionState.propertyExpressionState.propertyExpression.func
-        .genericType.value.rawType;
-    const type = filterConditionState.value
-      ? getNonCollectionValueSpecificationType(filterConditionState.value)
-      : undefined;
-
-    const NUMERIC_PRIMITIVE_TYPES = [
-      PRIMITIVE_TYPE.NUMBER,
-      PRIMITIVE_TYPE.INTEGER,
-      PRIMITIVE_TYPE.DECIMAL,
-      PRIMITIVE_TYPE.FLOAT,
-    ] as string[];
-
-    const DATE_PRIMITIVE_TYPES = [
-      PRIMITIVE_TYPE.DATE,
-      PRIMITIVE_TYPE.DATETIME,
-      PRIMITIVE_TYPE.STRICTDATE,
-      PRIMITIVE_TYPE.LATESTDATE,
-    ] as string[];
-
-    // When changing the return type for LHS, the RHS value should be adjusted accordingly.
-    return (
-      type !== undefined &&
-      // Numeric value is handled loosely because of autoboxing
-      // e.g. LHS (integer) = RHS (float) is acceptable
-      ((NUMERIC_PRIMITIVE_TYPES.includes(type.path) &&
-        NUMERIC_PRIMITIVE_TYPES.includes(propertyType.path)) ||
-        // Date value is handled loosely as well if the LHS is of type DateTime
-        // This is because we would simulate auto-boxing for date by altering the
-        // Pure function used for the operation
-        // e.g. LHS(DateTime) = RHS(Date) -> we use isOnDay() instead of is()
-        DATE_PRIMITIVE_TYPES.includes(type.path) ||
-        type === propertyType ||
-        isSuperType(propertyType, type))
+        .genericType.value.rawType,
     );
   }
 
@@ -128,7 +99,6 @@ export class QueryBuilderFilterOperator_Equal extends QueryBuilderFilterOperator
     switch (propertyType.path) {
       case PRIMITIVE_TYPE.STRING:
       case PRIMITIVE_TYPE.BOOLEAN:
-      case PRIMITIVE_TYPE.DATE:
       case PRIMITIVE_TYPE.STRICTDATE:
       case PRIMITIVE_TYPE.DATETIME:
       case PRIMITIVE_TYPE.NUMBER:
@@ -142,6 +112,14 @@ export class QueryBuilderFilterOperator_Equal extends QueryBuilderFilterOperator
           generateDefaultValueForPrimitiveType(propertyType.path),
         );
       }
+      case PRIMITIVE_TYPE.DATE: {
+        return buildPrimitiveInstanceValue(
+          filterConditionState.filterState.queryBuilderState.graphManagerState
+            .graph,
+          PRIMITIVE_TYPE.STRICTDATE,
+          generateDefaultValueForPrimitiveType(propertyType.path),
+        );
+      }
       default:
         if (propertyType instanceof Enumeration) {
           if (propertyType.values.length > 0) {