@finos/legend-application-query 5.1.0 → 5.2.3

package/src/stores/{QueryBuilderPostFilterState.ts → fetch-structure/projection/post-filter/QueryBuilderPostFilterState.ts}

@@ -48,21 +48,21 @@ import {
   makeObservable,
   observable,
 } from 'mobx';
-import { DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME } from '../QueryBuilder_Const.js';
-import type { QueryBuilderAggregateColumnState } from './QueryBuilderAggregationState.js';
-import { QUERY_BUILDER_GROUP_OPERATION } from './QueryBuilderOperatorsHelper.js';
+import { DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME } from '../../../../QueryBuilder_Const.js';
+import type { QueryBuilderAggregateColumnState } from '../aggregation/QueryBuilderAggregationState.js';
 import type { QueryBuilderPostFilterOperator } from './QueryBuilderPostFilterOperator.js';
 import {
   type QueryBuilderProjectionColumnState,
   type QueryBuilderProjectionColumnDragSource,
   QueryBuilderDerivationProjectionColumnState,
-} from './QueryBuilderProjectionState.js';
-import type { QueryBuilderState } from './QueryBuilderState.js';
+} from '../QueryBuilderProjectionColumnState.js';
 import {
-  buildProjectionColumnTypeAheadQuery,
-  buildTypeAheadOptions,
-  performTypeAhead,
-} from './QueryBuilderTypeaheadHelper.js';
+  buildProjectionColumnTypeaheadQuery,
+  buildTypeaheadOptions,
+  performTypeahead,
+} from '../../../QueryBuilderTypeaheadHelper.js';
+import { QUERY_BUILDER_GROUP_OPERATION } from '../../../QueryBuilderGroupOperationHelper.js';
+import type { QueryBuilderProjectionState } from '../QueryBuilderProjectionState.js';
 
 export enum QUERY_BUILDER_POST_FILTER_DND_TYPE {
   GROUP_CONDITION = 'GROUP_CONDITION',
@@ -165,7 +165,7 @@ export abstract class QueryBuilderPostFilterTreeNodeData
     });
   }
 
-  abstract get dragLayerLabel(): string;
+  abstract get dragPreviewLabel(): string;
   setIsOpen(val: boolean): void {
     this.isOpen = val;
   }
@@ -197,13 +197,13 @@ export class QueryBuilderPostFilterTreeGroupNodeData extends QueryBuilderPostFil
       setGroupOperation: action,
       addChildNode: action,
       removeChildNode: action,
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
     this.groupOperation = groupOperation;
     this.isOpen = true;
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return `${this.groupOperation.toUpperCase()} group`;
   }
 
@@ -238,13 +238,13 @@ export class QueryBuilderPostFilterTreeConditionNodeData extends QueryBuilderPos
 
     makeObservable(this, {
       condition: observable,
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
 
     this.condition = condition;
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return this.condition.columnName;
   }
 }
@@ -254,11 +254,11 @@ export class QueryBuilderPostFilterTreeBlankConditionNodeData extends QueryBuild
     super(parentId);
 
     makeObservable(this, {
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return '<blank>';
   }
 }
@@ -319,20 +319,26 @@ export class PostFilterConditionState {
     try {
       this.typeaheadSearchState.inProgress();
       this.typeaheadSearchResults = undefined;
-      if (performTypeAhead(this.value)) {
-        const builderState = buildProjectionColumnTypeAheadQuery(
-          this.postFilterState.queryBuilderState,
-          this.columnState,
-          this.value,
-        );
+      if (performTypeahead(this.value)) {
         const result =
-          (yield builderState.graphManagerState.graphManager.executeMapping(
-            builderState.resultState.buildExecutionRawLambda(),
-            guaranteeNonNullable(builderState.querySetupState.mapping),
-            guaranteeNonNullable(builderState.querySetupState.runtimeValue),
-            builderState.graphManagerState.graph,
+          (yield this.postFilterState.projectionState.queryBuilderState.graphManagerState.graphManager.executeMapping(
+            buildProjectionColumnTypeaheadQuery(
+              this.postFilterState.projectionState.queryBuilderState,
+              this.columnState,
+              this.value,
+            ),
+            guaranteeNonNullable(
+              this.postFilterState.projectionState.queryBuilderState
+                .querySetupState.mapping,
+            ),
+            guaranteeNonNullable(
+              this.postFilterState.projectionState.queryBuilderState
+                .querySetupState.runtimeValue,
+            ),
+            this.postFilterState.projectionState.queryBuilderState
+              .graphManagerState.graph,
           )) as ExecutionResult;
-        this.typeaheadSearchResults = buildTypeAheadOptions(result);
+        this.typeaheadSearchResults = buildTypeaheadOptions(result);
       }
       this.typeaheadSearchState.pass();
     } catch (error) {
@@ -354,7 +360,8 @@ export class PostFilterConditionState {
     this.value = val
       ? observe_ValueSpecification(
           val,
-          this.postFilterState.queryBuilderState.observableContext,
+          this.postFilterState.projectionState.queryBuilderState
+            .observableContext,
         )
       : undefined;
   }
@@ -374,7 +381,7 @@ export class PostFilterConditionState {
   ): GeneratorFn<void> {
     try {
       const aggregateColumnState =
-        this.postFilterState.queryBuilderState.fetchStructureState.projectionState.aggregationState.columns.find(
+        this.postFilterState.projectionState.aggregationState.columns.find(
           (column) => column.projectionColumnState === columnState,
         );
       const colState = aggregateColumnState ?? columnState;
@@ -396,7 +403,7 @@ export class PostFilterConditionState {
       }
     } catch (error) {
       assertErrorThrown(error);
-      this.postFilterState.queryBuilderState.applicationStore.notifyError(
+      this.postFilterState.projectionState.queryBuilderState.applicationStore.notifyError(
         `Can't drag column '${columnState.columnName}' due to: ${error.message}`,
       );
     }
@@ -406,7 +413,7 @@ export class PostFilterConditionState {
 export class QueryBuilderPostFilterState
   implements TreeData<QueryBuilderPostFilterTreeNodeData>
 {
-  queryBuilderState: QueryBuilderState;
+  projectionState: QueryBuilderProjectionState;
   lambdaParameterName = DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME;
   selectedNode?: QueryBuilderPostFilterTreeNodeData | undefined;
   isRearrangingConditions = false;
@@ -416,11 +423,11 @@ export class QueryBuilderPostFilterState
   _suppressClickawayEventListener = false;
 
   constructor(
-    queryBuilderState: QueryBuilderState,
+    projectionState: QueryBuilderProjectionState,
     operators: QueryBuilderPostFilterOperator[],
   ) {
     makeAutoObservable(this, {
-      queryBuilderState: false,
+      projectionState: false,
       setLambdaParameterName: action,
       setSelectedNode: action,
       addNodeFromNode: action,
@@ -435,7 +442,7 @@ export class QueryBuilderPostFilterState
       suppressClickawayEventListener: action,
     });
 
-    this.queryBuilderState = queryBuilderState;
+    this.projectionState = projectionState;
     this.operators = operators;
   }
 

package/src/stores/fetch-structure/projection/post-filter/QueryBuilderPostFilterValueSpecificationBuilder.ts

@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  extractElementNameFromPath,
+  SimpleFunctionExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  type LambdaFunction,
+  type ValueSpecification,
+} from '@finos/legend-graph';
+import {
+  assertTrue,
+  guaranteeNonNullable,
+  isNonNullable,
+} from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../QueryBuilder_Const.js';
+import { fromGroupOperation } from '../../../QueryBuilderGroupOperationHelper.js';
+import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
+import { FETCH_STRUCTURE_MODE } from '../../QueryBuilderFetchStructureState.js';
+import {
+  QueryBuilderPostFilterTreeConditionNodeData,
+  QueryBuilderPostFilterTreeGroupNodeData,
+  type QueryBuilderPostFilterTreeNodeData,
+  type QueryBuilderPostFilterState,
+} from './QueryBuilderPostFilterState.js';
+
+const buildPostFilterExpression = (
+  filterState: QueryBuilderPostFilterState,
+  node: QueryBuilderPostFilterTreeNodeData,
+): ValueSpecification | undefined => {
+  if (node instanceof QueryBuilderPostFilterTreeConditionNodeData) {
+    return node.condition.operator.buildPostFilterConditionExpression(
+      node.condition,
+    );
+  } else if (node instanceof QueryBuilderPostFilterTreeGroupNodeData) {
+    const multiplicityOne =
+      filterState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+        TYPICAL_MULTIPLICITY_TYPE.ONE,
+      );
+    const func = new SimpleFunctionExpression(
+      extractElementNameFromPath(fromGroupOperation(node.groupOperation)),
+      multiplicityOne,
+    );
+    const clauses = node.childrenIds
+      .map((e) => filterState.nodes.get(e))
+      .filter(isNonNullable)
+      .map((e) => buildPostFilterExpression(filterState, e))
+      .filter(isNonNullable);
+    /**
+     * NOTE: Due to a limitation (or perhaps design decision) in the engine, group operations
+     * like and/or do not take more than 2 parameters, as such, if we have more than 2, we need
+     * to create a chain of this operation to accomondate.
+     *
+     * This means that in the read direction, we might need to flatten the chains down to group with
+     * multiple clauses. This means user's intended grouping will not be kept.
+     */
+    if (clauses.length > 2) {
+      const firstClause = clauses[0] as ValueSpecification;
+      let currentClause: ValueSpecification = clauses[
+        clauses.length - 1
+      ] as ValueSpecification;
+      for (let i = clauses.length - 2; i > 0; --i) {
+        const clause1 = clauses[i] as ValueSpecification;
+        const clause2 = currentClause;
+        const groupClause = new SimpleFunctionExpression(
+          extractElementNameFromPath(fromGroupOperation(node.groupOperation)),
+          multiplicityOne,
+        );
+        groupClause.parametersValues = [clause1, clause2];
+        currentClause = groupClause;
+      }
+      func.parametersValues = [firstClause, currentClause];
+    } else {
+      func.parametersValues = clauses;
+    }
+    return func.parametersValues.length ? func : undefined;
+  }
+  return undefined;
+};
+
+export const appendPostFilter = (
+  postFilterState: QueryBuilderPostFilterState,
+  lambda: LambdaFunction,
+): LambdaFunction => {
+  const postFilterConditionExpressions = postFilterState.rootIds
+    .map((e) => guaranteeNonNullable(postFilterState.nodes.get(e)))
+    .map((e) => buildPostFilterExpression(postFilterState, e))
+    .filter(isNonNullable);
+  if (
+    !postFilterConditionExpressions.length ||
+    lambda.expressionSequence.length !== 1
+  ) {
+    return lambda;
+  }
+  assertTrue(
+    postFilterState.projectionState.fetchStructureState.fetchStructureMode ===
+      FETCH_STRUCTURE_MODE.PROJECTION,
+    'Can only apply post-filter while fetching projection columns',
+  );
+  const multiplicityOne =
+    postFilterState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+  const filterLambda = buildGenericLambdaFunctionInstanceValue(
+    postFilterState.lambdaParameterName,
+    postFilterConditionExpressions,
+    postFilterState.projectionState.queryBuilderState.graphManagerState.graph,
+  );
+  // main filter expression
+  const filterExpression = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER),
+    multiplicityOne,
+  );
+  const currentExpression = guaranteeNonNullable(lambda.expressionSequence[0]);
+  filterExpression.parametersValues = [currentExpression, filterLambda];
+  lambda.expressionSequence[0] = filterExpression;
+  return lambda;
+};

package/src/stores/{QueryBuilderPostFilterProcessor.ts → fetch-structure/projection/post-filter/QueryBuilderPostFilterValueSpecificationProcessor.ts}

@@ -30,9 +30,9 @@ import {
   guaranteeType,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
-import type { QueryBuilderAggregateColumnState } from './QueryBuilderAggregationState.js';
-import { toGroupOperation } from './QueryBuilderOperatorsHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../QueryBuilder_Const.js';
+import type { QueryBuilderAggregateColumnState } from '../aggregation/QueryBuilderAggregationState.js';
+import { FETCH_STRUCTURE_MODE } from '../../QueryBuilderFetchStructureState.js';
 import type { QueryBuilderPostFilterOperator } from './QueryBuilderPostFilterOperator.js';
 import {
   type QueryBuilderPostFilterState,
@@ -46,14 +46,15 @@ import {
 import {
   type QueryBuilderProjectionColumnState,
   QueryBuilderDerivationProjectionColumnState,
-} from './QueryBuilderProjectionState.js';
+} from '../QueryBuilderProjectionColumnState.js';
+import { toGroupOperation } from '../../../QueryBuilderGroupOperationHelper.js';
 
-export const findTdsColumnState = (
+const findProjectionColumnState = (
   propertyExpression: AbstractPropertyExpression,
   postFilterState: QueryBuilderPostFilterState,
 ): QueryBuilderProjectionColumnState | QueryBuilderAggregateColumnState => {
   const fetchStructureState =
-    postFilterState.queryBuilderState.fetchStructureState;
+    postFilterState.projectionState.fetchStructureState;
   const properyExpressionName = propertyExpression.func.name;
   assertTrue(
     Object.values(TDS_COLUMN_GETTER).includes(
@@ -87,7 +88,8 @@ export const findTdsColumnState = (
     if (columnState instanceof QueryBuilderDerivationProjectionColumnState) {
       const type = getTypeFromDerivedProperty(
         tdsColumnGetter,
-        postFilterState.queryBuilderState.graphManagerState.graph,
+        postFilterState.projectionState.queryBuilderState.graphManagerState
+          .graph,
       );
       if (type) {
         columnState.setReturnType(type);
@@ -119,7 +121,7 @@ export const buildPostFilterConditionState = (
     expression instanceof AbstractPropertyExpression &&
     expression.func.name === tdsColumnGetter
   ) {
-    const columnState = findTdsColumnState(expression, postFilterState);
+    const columnState = findProjectionColumnState(expression, postFilterState);
     postConditionState = new PostFilterConditionState(
       postFilterState,
       columnState,
@@ -148,7 +150,7 @@ export const buildPostFilterConditionState = (
         operatorFunctionFullPath,
       )}() expression: expects property expression in lambda body`,
     );
-    const columnState = findTdsColumnState(
+    const columnState = findProjectionColumnState(
       tdsColumnPropertyExpression,
       postFilterState,
     );
@@ -238,9 +240,9 @@ export const processPostFilterLambda = (
   postFilterState: QueryBuilderPostFilterState,
 ): void => {
   const fetchStructureState =
-    postFilterState.queryBuilderState.fetchStructureState;
+    postFilterState.projectionState.fetchStructureState;
   assertTrue(
-    fetchStructureState.isProjectionMode(),
+    fetchStructureState.fetchStructureMode === FETCH_STRUCTURE_MODE.PROJECTION,
     `Can't process post-filter lambda: post-filter lambda must use projection fetch structure`,
   );
   assertTrue(

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperatorHelper.ts

@@ -32,8 +32,8 @@ import {
   guaranteeNonNullable,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
-import { TDS_ROW } from '../../QueryBuilder_Const.js';
-import { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import { TDS_ROW } from '../../../../../QueryBuilder_Const.js';
+import { QueryBuilderAggregateColumnState } from '../../aggregation/QueryBuilderAggregationState.js';
 import type { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
 import {
   type PostFilterConditionState,
@@ -43,7 +43,7 @@ import {
 import {
   type QueryBuilderProjectionColumnState,
   QueryBuilderSimpleProjectionColumnState,
-} from '../QueryBuilderProjectionState.js';
+} from '../../QueryBuilderProjectionColumnState.js';
 
 export const getColumnMultiplicity = (
   columnState:
@@ -77,8 +77,8 @@ export const buildPostFilterConditionExpression = (
 ): FunctionExpression => {
   // primitives
   const graph =
-    filterConditionState.postFilterState.queryBuilderState.graphManagerState
-      .graph;
+    filterConditionState.postFilterState.projectionState.queryBuilderState
+      .graphManagerState.graph;
   const multiplicityOne = graph.getTypicalMultiplicity(
     TYPICAL_MULTIPLICITY_TYPE.ONE,
   );

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperator_Contain.ts

@@ -26,19 +26,19 @@ import {
   guaranteeNonNullable,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
-import {
-  buildNotExpression,
-  getNonCollectionValueSpecificationType,
-  unwrapNotExpression,
-} from '../QueryBuilderOperatorsHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../QueryBuilder_Const.js';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterValueSpecificationProcessor.js';
 import type {
   PostFilterConditionState,
   QueryBuilderPostFilterState,
 } from '../QueryBuilderPostFilterState.js';
-import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationBuilderHelper.js';
+import {
+  buildNotExpression,
+  generateDefaultValueForPrimitiveType,
+  getNonCollectionValueSpecificationType,
+  unwrapNotExpression,
+} from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
 
 export class QueryBuilderPostFilterOperator_Contain extends QueryBuilderPostFilterOperator {
@@ -71,8 +71,8 @@ export class QueryBuilderPostFilterOperator_Contain extends QueryBuilderPostFilt
     switch (propertyType.path) {
       case PRIMITIVE_TYPE.STRING: {
         return buildPrimitiveInstanceValue(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           propertyType.path,
           generateDefaultValueForPrimitiveType(propertyType.path),
         );
@@ -121,8 +121,8 @@ export class QueryBuilderPostFilterOperator_NotContain extends QueryBuilderPostF
     );
     return expression
       ? buildNotExpression(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           expression,
         )
       : undefined;

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperator_EndWith.ts

@@ -22,19 +22,19 @@ import {
   buildPrimitiveInstanceValue,
 } from '@finos/legend-graph';
 import { UnsupportedOperationError } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
-import {
-  buildNotExpression,
-  getNonCollectionValueSpecificationType,
-  unwrapNotExpression,
-} from '../QueryBuilderOperatorsHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../QueryBuilder_Const.js';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterValueSpecificationProcessor.js';
 import type {
   PostFilterConditionState,
   QueryBuilderPostFilterState,
 } from '../QueryBuilderPostFilterState.js';
-import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationBuilderHelper.js';
+import {
+  buildNotExpression,
+  generateDefaultValueForPrimitiveType,
+  getNonCollectionValueSpecificationType,
+  unwrapNotExpression,
+} from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
 
 export class QueryBuilderPostFilterOperator_EndWith extends QueryBuilderPostFilterOperator {
@@ -65,8 +65,8 @@ export class QueryBuilderPostFilterOperator_EndWith extends QueryBuilderPostFilt
     switch (propertyType?.path) {
       case PRIMITIVE_TYPE.STRING: {
         return buildPrimitiveInstanceValue(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           propertyType.path,
           generateDefaultValueForPrimitiveType(propertyType.path),
         );
@@ -116,8 +116,8 @@ export class QueryBuilderPostFilterOperator_NotEndWith extends QueryBuilderPostF
     );
     return expression
       ? buildNotExpression(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           expression,
         )
       : undefined;

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperator_Equal.ts

@@ -35,20 +35,20 @@ import {
   guaranteeNonNullable,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
-import {
-  buildNotExpression,
-  getNonCollectionValueSpecificationType,
-  isTypeCompatibleWithConditionValueType,
-  unwrapNotExpression,
-} from '../QueryBuilderOperatorsHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../QueryBuilder_Const.js';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterValueSpecificationProcessor.js';
 import type {
   PostFilterConditionState,
   QueryBuilderPostFilterState,
 } from '../QueryBuilderPostFilterState.js';
-import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationBuilderHelper.js';
+import {
+  buildNotExpression,
+  generateDefaultValueForPrimitiveType,
+  getNonCollectionValueSpecificationType,
+  isTypeCompatibleForAssignment,
+  unwrapNotExpression,
+} from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
 
 export class QueryBuilderPostFilterOperator_Equal extends QueryBuilderPostFilterOperator {
@@ -81,7 +81,7 @@ export class QueryBuilderPostFilterOperator_Equal extends QueryBuilderPostFilter
   ): boolean {
     const valueSpecification = postFilterConditionState.value;
     if (valueSpecification) {
-      return isTypeCompatibleWithConditionValueType(
+      return isTypeCompatibleForAssignment(
         getNonCollectionValueSpecificationType(valueSpecification),
         guaranteeNonNullable(
           postFilterConditionState.columnState.getReturnType(),
@@ -100,7 +100,6 @@ export class QueryBuilderPostFilterOperator_Equal extends QueryBuilderPostFilter
     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:
@@ -108,17 +107,25 @@ export class QueryBuilderPostFilterOperator_Equal extends QueryBuilderPostFilter
       case PRIMITIVE_TYPE.FLOAT:
       case PRIMITIVE_TYPE.INTEGER: {
         return buildPrimitiveInstanceValue(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           propertyType.path,
           generateDefaultValueForPrimitiveType(propertyType.path),
         );
       }
+      case PRIMITIVE_TYPE.DATE: {
+        return buildPrimitiveInstanceValue(
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
+          PRIMITIVE_TYPE.STRICTDATE,
+          generateDefaultValueForPrimitiveType(propertyType.path),
+        );
+      }
       default:
         if (propertyType instanceof Enumeration) {
           if (propertyType.values.length > 0) {
             const multiplicityOne =
-              postFilterConditionState.postFilterState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+              postFilterConditionState.postFilterState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
                 TYPICAL_MULTIPLICITY_TYPE.ONE,
               );
             const enumValueInstanceValue = new EnumValueInstanceValue(
@@ -192,8 +199,8 @@ export class QueryBuilderPostFilterOperator_NotEqual extends QueryBuilderPostFil
     );
     return expression
       ? buildNotExpression(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           expression,
         )
       : undefined;

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperator_GreaterThan.ts

@@ -27,18 +27,18 @@ import {
   guaranteeNonNullable,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
-import {
-  getNonCollectionValueSpecificationType,
-  isTypeCompatibleWithConditionValueType,
-} from '../QueryBuilderOperatorsHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../QueryBuilder_Const.js';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterValueSpecificationProcessor.js';
 import type {
   PostFilterConditionState,
   QueryBuilderPostFilterState,
 } from '../QueryBuilderPostFilterState.js';
-import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationBuilderHelper.js';
+import {
+  generateDefaultValueForPrimitiveType,
+  getNonCollectionValueSpecificationType,
+  isTypeCompatibleForAssignment,
+} from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
 
 export class QueryBuilderPostFilterOperator_GreaterThan extends QueryBuilderPostFilterOperator {
@@ -63,7 +63,7 @@ export class QueryBuilderPostFilterOperator_GreaterThan extends QueryBuilderPost
   isCompatibleWithConditionValue(
     postFilterConditionState: PostFilterConditionState,
   ): boolean {
-    return isTypeCompatibleWithConditionValueType(
+    return isTypeCompatibleForAssignment(
       postFilterConditionState.value
         ? getNonCollectionValueSpecificationType(postFilterConditionState.value)
         : undefined,
@@ -82,16 +82,23 @@ export class QueryBuilderPostFilterOperator_GreaterThan extends QueryBuilderPost
       case PRIMITIVE_TYPE.DECIMAL:
       case PRIMITIVE_TYPE.FLOAT:
       case PRIMITIVE_TYPE.INTEGER:
-      case PRIMITIVE_TYPE.DATE:
       case PRIMITIVE_TYPE.STRICTDATE:
       case PRIMITIVE_TYPE.DATETIME: {
         return buildPrimitiveInstanceValue(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           propertyType.path,
           generateDefaultValueForPrimitiveType(propertyType.path),
         );
       }
+      case PRIMITIVE_TYPE.DATE: {
+        return buildPrimitiveInstanceValue(
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
+          PRIMITIVE_TYPE.STRICTDATE,
+          generateDefaultValueForPrimitiveType(propertyType.path),
+        );
+      }
       default:
         throw new UnsupportedOperationError(
           `Can't get default value for post-filter operator '${this.getLabel()}' when the LHS property is of type '${