@finos/legend-query-builder 4.18.2 → 4.18.4

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -32,7 +32,10 @@ import {
   hashArray,
   isNonNullable,
 } from '@finos/legend-shared';
-import type { QueryBuilderExplorerTreeDragSource } from '../explorer/QueryBuilderExplorerState.js';
+import type {
+  QueryBuilderExplorerTreeDragSource,
+  QueryBuilderExplorerTreeRelationColumnDragSource,
+} from '../explorer/QueryBuilderExplorerState.js';
 import { QueryBuilderPropertyExpressionState } from '../QueryBuilderPropertyEditorState.js';
 import type { QueryBuilderState } from '../QueryBuilderState.js';
 import {
@@ -46,6 +49,9 @@ import {
   InstanceValue,
   SimpleFunctionExpression,
   matchFunctionName,
+  FunctionExpression,
+  Multiplicity,
+  VariableExpression as VariableExpressionClass,
 } from '@finos/legend-graph';
 import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../QueryBuilderConfig.js';
 import type { QueryBuilderProjectionColumnDragSource } from '../fetch-structure/tds/projection/QueryBuilderProjectionColumnState.js';
@@ -66,6 +72,7 @@ import {
 import { instanceValue_setValues } from '../shared/ValueSpecificationModifierHelper.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../graph/QueryBuilderMetaModelConst.js';
 import type { QueryBuilderVariableDragSource } from '../../components/shared/BasicValueSpecificationEditor.js';
+import { buildPropertyExpressionChain } from '../QueryBuilderValueSpecificationBuilderHelper.js';
 
 export enum QUERY_BUILDER_FILTER_DND_TYPE {
   GROUP_CONDITION = 'QUERY_BUILDER_FILTER_DND_TYPE.GROUP_CONDITION',
@@ -79,6 +86,7 @@ export interface QueryBuilderFilterConditionDragSource {
 
 export type QueryBuilderFilterNodeDropTarget =
   | QueryBuilderExplorerTreeDragSource
+  | QueryBuilderExplorerTreeRelationColumnDragSource
   | QueryBuilderProjectionColumnDragSource
   | QueryBuilderFilterConditionDragSource;
 
@@ -229,9 +237,137 @@ export class FilterPropertyExpressionStateConditionValueState extends FilterCond
   }
 }
 
+/**
+ * Abstract base class for the left-hand side (source) of a filter condition.
+ * This allows filtering on different source types (class properties, relation columns)
+ * without operators needing to know the specifics of the source.
+ */
+export abstract class FilterConditionSourceState implements Hashable {
+  abstract get type(): Type;
+  abstract get label(): string;
+  abstract get title(): string;
+  abstract get isValid(): boolean;
+  abstract get requiresExistsHandling(): boolean;
+  abstract buildLeftExpression(
+    queryBuilderState: QueryBuilderState,
+    lambdaParameterName: string,
+  ): ValueSpecification;
+  abstract get hashCode(): string;
+}
+
+export class FilterPropertyExpressionSourceState extends FilterConditionSourceState {
+  readonly propertyExpressionState: QueryBuilderPropertyExpressionState;
+
+  constructor(propertyExpressionState: QueryBuilderPropertyExpressionState) {
+    super();
+    this.propertyExpressionState = propertyExpressionState;
+  }
+
+  get type(): Type {
+    return this.propertyExpressionState.propertyExpression.func.value
+      .genericType.value.rawType;
+  }
+
+  get label(): string {
+    return this.propertyExpressionState.title;
+  }
+
+  get title(): string {
+    return this.propertyExpressionState.title;
+  }
+
+  get isValid(): boolean {
+    return this.propertyExpressionState.isValid;
+  }
+
+  get requiresExistsHandling(): boolean {
+    return this.propertyExpressionState.requiresExistsHandling;
+  }
+
+  buildLeftExpression(
+    queryBuilderState: QueryBuilderState,
+    lambdaParameterName: string,
+  ): ValueSpecification {
+    return guaranteeNonNullable(
+      buildPropertyExpressionChain(
+        this.propertyExpressionState.propertyExpression,
+        queryBuilderState,
+        lambdaParameterName,
+      ),
+    );
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.FILTER_CONDITION_SOURCE_PROPERTY_EXPRESSION,
+      this.propertyExpressionState,
+    ]);
+  }
+}
+
+export class FilterRelationColumnSourceState extends FilterConditionSourceState {
+  readonly columnName: string;
+  readonly columnType: Type;
+
+  constructor(columnName: string, columnType: Type) {
+    super();
+    this.columnName = columnName;
+    this.columnType = columnType;
+  }
+
+  get type(): Type {
+    return this.columnType;
+  }
+
+  get label(): string {
+    return this.columnName;
+  }
+
+  get title(): string {
+    return this.columnName;
+  }
+
+  get isValid(): boolean {
+    return true;
+  }
+
+  get requiresExistsHandling(): boolean {
+    return false;
+  }
+
+  buildLeftExpression(
+    queryBuilderState: QueryBuilderState,
+    lambdaParameterName: string,
+  ): ValueSpecification {
+    const relationType = queryBuilderState.sourceRelationType;
+    if (relationType) {
+      const col = guaranteeNonNullable(
+        relationType.columns.find((c) => c.name === this.columnName),
+        `Can't find column '${this.columnName}' in relation`,
+      );
+      const funcExp = new FunctionExpression(col.name);
+      funcExp.func = col;
+      funcExp.parametersValues = [
+        new VariableExpressionClass(lambdaParameterName, Multiplicity.ONE),
+      ];
+      return funcExp;
+    }
+    throw new IllegalStateError(
+      `Can't build expression for relation column '${this.columnName}': no source relation type`,
+    );
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.FILTER_CONDITION_SOURCE_RELATION_COLUMN,
+      this.columnName,
+    ]);
+  }
+}
+
 export class FilterConditionState implements Hashable {
   readonly filterState: QueryBuilderFilterState;
-  propertyExpressionState: QueryBuilderPropertyExpressionState;
+  sourceState: FilterConditionSourceState;
   operator!: QueryBuilderFilterOperator;
   rightConditionValue?: FilterConditionValueState | undefined;
   existsLambdaParamNames: string[] = [];
@@ -240,11 +376,11 @@ export class FilterConditionState implements Hashable {
 
   constructor(
     filterState: QueryBuilderFilterState,
-    propertyExpression: AbstractPropertyExpression,
+    source: AbstractPropertyExpression | FilterConditionSourceState,
     operator?: QueryBuilderFilterOperator,
   ) {
     makeObservable(this, {
-      propertyExpressionState: observable,
+      sourceState: observable,
       operator: observable,
       rightConditionValue: observable,
       existsLambdaParamNames: observable,
@@ -261,10 +397,16 @@ export class FilterConditionState implements Hashable {
     });
 
     this.filterState = filterState;
-    this.propertyExpressionState = new QueryBuilderPropertyExpressionState(
-      filterState.queryBuilderState,
-      propertyExpression,
-    );
+    if (source instanceof AbstractPropertyExpression) {
+      this.sourceState = new FilterPropertyExpressionSourceState(
+        new QueryBuilderPropertyExpressionState(
+          filterState.queryBuilderState,
+          source,
+        ),
+      );
+    } else {
+      this.sourceState = source;
+    }
 
     // operator
     if (operator) {
@@ -272,7 +414,7 @@ export class FilterConditionState implements Hashable {
     } else {
       assertTrue(
         this.operators.length !== 0,
-        `Can't find an operator for property '${this.propertyExpressionState.path}': no operators registered`,
+        `Can't find an operator for property '${this.sourceState.title}': no operators registered`,
       );
       this.operator = this.operators[0] as QueryBuilderFilterOperator;
     }
@@ -281,6 +423,25 @@ export class FilterConditionState implements Hashable {
     );
   }
 
+  /**
+   * Backward-compatible accessor for the property expression state.
+   * Only valid when the source is a property expression.
+   */
+  get propertyExpressionState(): QueryBuilderPropertyExpressionState {
+    return guaranteeType(
+      this.sourceState,
+      FilterPropertyExpressionSourceState,
+      `Filter condition source is not a property expression`,
+    ).propertyExpressionState;
+  }
+
+  /**
+   * The raw type of the left-hand side of the filter condition.
+   */
+  get leftConditionType(): Type {
+    return this.sourceState.type;
+  }
+
   get operators(): QueryBuilderFilterOperator[] {
     return this.filterState.operators.filter((op) =>
       op.isCompatibleWithFilterConditionProperty(this),
@@ -412,7 +573,7 @@ export class FilterConditionState implements Hashable {
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.FILTER_CONDITION_STATE,
-      this.propertyExpressionState,
+      this.sourceState,
       this.rightConditionValue ?? '',
       this.operator,
     ]);
@@ -636,7 +797,7 @@ export class QueryBuilderFilterTreeConditionNodeData
   }
 
   get dragPreviewLabel(): string {
-    return this.condition.propertyExpressionState.title;
+    return this.condition.sourceState.title;
   }
 
   get hashCode(): string {
@@ -1181,7 +1342,7 @@ export class QueryBuilderFilterState
   ): boolean {
     return (
       node instanceof QueryBuilderFilterTreeConditionNodeData &&
-      !node.condition.propertyExpressionState.isValid
+      !node.condition.sourceState.isValid
     );
   }
 
@@ -1212,12 +1373,12 @@ export class QueryBuilderFilterState
       if (node instanceof QueryBuilderFilterTreeConditionNodeData) {
         if (this.isInvalidValueSpecFilterValue(node)) {
           validationIssues.push(
-            `Filter value for ${node.condition.propertyExpressionState.title} is missing or invalid`,
+            `Filter value for ${node.condition.sourceState.title} is missing or invalid`,
           );
         }
         if (this.isInvalidFilterPropertyExpressionState(node)) {
           validationIssues.push(
-            `Derived property parameter value for ${node.condition.propertyExpressionState.title} is missing or invalid`,
+            `Derived property parameter value for ${node.condition.sourceState.title} is missing or invalid`,
           );
         }
         if (

package/src/stores/filter/QueryBuilderFilterStateBuilder.ts

@@ -23,6 +23,7 @@ import {
   SimpleFunctionExpression,
   type ValueSpecification,
   VariableExpression,
+  FunctionExpression,
 } from '@finos/legend-graph';
 import {
   assertTrue,
@@ -42,6 +43,7 @@ import {
   QueryBuilderFilterTreeGroupNodeData,
   QueryBuilderFilterTreeExistsNodeData,
   QueryBuilderFilterTreeOperationNodeData,
+  FilterRelationColumnSourceState,
 } from './QueryBuilderFilterState.js';
 
 const getPropertyExpressionChainVariable = (
@@ -321,9 +323,28 @@ const processFilterTree = (
         operator.buildFilterConditionState(filterState, expression),
       );
       if (filterConditionState) {
-        const variableName = getPropertyExpressionChainVariable(
-          filterConditionState.propertyExpressionState.propertyExpression,
-        ).name;
+        // Extract the variable name from the filter condition's left side.
+        // For relation column sources, the variable comes from the FunctionExpression's parameter;
+        // for property expression sources, it comes from the property expression chain.
+        let variableName: string;
+        if (
+          filterConditionState.sourceState instanceof
+          FilterRelationColumnSourceState
+        ) {
+          const leftSide = expression.parametersValues[0];
+          const varExpr = guaranteeType(
+            leftSide instanceof FunctionExpression
+              ? leftSide.parametersValues[0]
+              : undefined,
+            VariableExpression,
+            `Can't process filter expression: relation column filter must reference a variable`,
+          );
+          variableName = varExpr.name;
+        } else {
+          variableName = getPropertyExpressionChainVariable(
+            filterConditionState.propertyExpressionState.propertyExpression,
+          ).name;
+        }
         const parentLambdaVariableName =
           parentNode instanceof QueryBuilderFilterTreeOperationNodeData &&
           parentNode.lambdaParameterName

package/src/stores/filter/operators/QueryBuilderFilterOperatorValueSpecificationBuilder.ts

@@ -22,15 +22,14 @@ import {
   AbstractPropertyExpression,
   SimpleFunctionExpression,
   LambdaFunction,
+  FunctionExpression,
+  RelationColumn,
 } from '@finos/legend-graph';
-import {
-  guaranteeType,
-  guaranteeNonNullable,
-  assertTrue,
-} from '@finos/legend-shared';
+import { guaranteeType, assertTrue } from '@finos/legend-shared';
 import {
   FilterConditionState,
   FilterPropertyExpressionStateConditionValueState,
+  FilterRelationColumnSourceState,
   FilterValueSpecConditionValueState,
   type QueryBuilderFilterState,
 } from '../QueryBuilderFilterState.js';
@@ -48,12 +47,13 @@ export const buildFilterConditionExpression = (
   const expression = new SimpleFunctionExpression(
     extractElementNameFromPath(operatorFunctionFullPath),
   );
-  const propertyExpression = buildPropertyExpressionChain(
-    filterConditionState.propertyExpressionState.propertyExpression,
-    filterConditionState.propertyExpressionState.queryBuilderState,
-    lambdaParameterName ?? filterConditionState.filterState.lambdaParameterName,
+  const resolvedLambdaParameterName =
+    lambdaParameterName ?? filterConditionState.filterState.lambdaParameterName;
+  const leftExpression = filterConditionState.sourceState.buildLeftExpression(
+    filterConditionState.filterState.queryBuilderState,
+    resolvedLambdaParameterName,
   );
-  expression.parametersValues.push(guaranteeNonNullable(propertyExpression));
+  expression.parametersValues.push(leftExpression);
   // NOTE: there are simple operators which do not require any params (e.g. isEmpty)
   if (
     filterConditionState.rightConditionValue &&
@@ -72,15 +72,35 @@ export const buildFilterConditionExpression = (
     const rightConditionPropertyExpression = buildPropertyExpressionChain(
       filterConditionState.rightConditionValue.propertyExpressionState
         .propertyExpression,
-      filterConditionState.propertyExpressionState.queryBuilderState,
-      lambdaParameterName ??
-        filterConditionState.filterState.lambdaParameterName,
+      filterConditionState.filterState.queryBuilderState,
+      resolvedLambdaParameterName,
     );
     expression.parametersValues.push(rightConditionPropertyExpression);
   }
   return expression;
 };
 
+/**
+ * Extracts the raw type path from the left-hand side of a filter expression.
+ * Handles both AbstractPropertyExpression (class properties) and
+ * FunctionExpression with RelationColumn (relation column properties).
+ */
+export const getFilterExpressionLeftSideTypePath = (
+  expression: SimpleFunctionExpression,
+): string | undefined => {
+  const leftSide = expression.parametersValues[0];
+  if (leftSide instanceof AbstractPropertyExpression) {
+    return leftSide.func.value.genericType.value.rawType.path;
+  }
+  if (
+    leftSide instanceof FunctionExpression &&
+    leftSide.func instanceof RelationColumn
+  ) {
+    return leftSide.func.genericType.value.rawType.path;
+  }
+  return undefined;
+};
+
 export const buildFilterConditionState = (
   filterState: QueryBuilderFilterState,
   expression: SimpleFunctionExpression,
@@ -109,18 +129,29 @@ export const buildFilterConditionState = (
       )}() expects ${hasNoValue ? 'no argument' : '1 argument'}`,
     );
 
-    const propertyExpression = guaranteeType(
-      expression.parametersValues[0],
-      AbstractPropertyExpression,
-      `Can't process ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() expression: expects property expression in lambda body`,
-    );
+    const leftSide = expression.parametersValues[0];
+    if (leftSide instanceof AbstractPropertyExpression) {
+      filterConditionState = new FilterConditionState(filterState, leftSide);
+    } else if (
+      leftSide instanceof FunctionExpression &&
+      leftSide.func instanceof RelationColumn
+    ) {
+      const col = leftSide.func;
+      filterConditionState = new FilterConditionState(
+        filterState,
+        new FilterRelationColumnSourceState(
+          col.name,
+          col.genericType.value.rawType,
+        ),
+      );
+    } else {
+      throw new Error(
+        `Can't process ${extractElementNameFromPath(
+          operatorFunctionFullPath,
+        )}() expression: expects property expression or relation column in lambda body`,
+      );
+    }
 
-    filterConditionState = new FilterConditionState(
-      filterState,
-      propertyExpression,
-    );
     mainExpressionWithOperator = expression;
   } else if (
     matchFunctionName(

package/src/stores/filter/operators/QueryBuilderFilterOperator_Contain.ts

@@ -55,8 +55,7 @@ export class QueryBuilderFilterOperator_Contain
   ): boolean {
     return (
       getStandardPrimitiveTypeEquivalent(
-        filterConditionState.propertyExpressionState.propertyExpression.func
-          .value.genericType.value.rawType,
+        filterConditionState.leftConditionType,
       ) === PRIMITIVE_TYPE.STRING
     );
   }
@@ -78,9 +77,7 @@ export class QueryBuilderFilterOperator_Contain
   getDefaultFilterConditionValue(
     filterConditionState: FilterConditionState,
   ): ValueSpecification | undefined {
-    const propertyType =
-      filterConditionState.propertyExpressionState.propertyExpression.func.value
-        .genericType.value.rawType;
+    const propertyType = filterConditionState.leftConditionType;
     switch (propertyType.path) {
       case PRIMITIVE_TYPE.STRING: {
         return buildDefaultInstanceValue(

package/src/stores/filter/operators/QueryBuilderFilterOperator_EndWith.ts

@@ -55,8 +55,7 @@ export class QueryBuilderFilterOperator_EndWith
   ): boolean {
     return (
       getStandardPrimitiveTypeEquivalent(
-        filterConditionState.propertyExpressionState.propertyExpression.func
-          .value.genericType.value.rawType,
+        filterConditionState.leftConditionType,
       ) === PRIMITIVE_TYPE.STRING
     );
   }
@@ -78,9 +77,7 @@ export class QueryBuilderFilterOperator_EndWith
   getDefaultFilterConditionValue(
     filterConditionState: FilterConditionState,
   ): ValueSpecification | undefined {
-    const propertyType =
-      filterConditionState.propertyExpressionState.propertyExpression.func.value
-        .genericType.value.rawType;
+    const propertyType = filterConditionState.leftConditionType;
     switch (propertyType.path) {
       case PRIMITIVE_TYPE.STRING: {
         return buildDefaultInstanceValue(

package/src/stores/filter/operators/QueryBuilderFilterOperator_Equal.ts

@@ -22,7 +22,6 @@ import { QueryBuilderFilterOperator } from '../QueryBuilderFilterOperator.js';
 import {
   type ValueSpecification,
   type SimpleFunctionExpression,
-  type AbstractPropertyExpression,
   Enumeration,
   PRIMITIVE_TYPE,
 } from '@finos/legend-graph';
@@ -30,6 +29,7 @@ import { type Hashable, hashArray } from '@finos/legend-shared';
 import {
   buildFilterConditionState,
   buildFilterConditionExpression,
+  getFilterExpressionLeftSideTypePath,
 } from './QueryBuilderFilterOperatorValueSpecificationBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graph/QueryBuilderMetaModelConst.js';
 import {
@@ -52,9 +52,7 @@ export class QueryBuilderFilterOperator_Equal
   isCompatibleWithFilterConditionProperty(
     filterConditionState: FilterConditionState,
   ): boolean {
-    const propertyType =
-      filterConditionState.propertyExpressionState.propertyExpression.func.value
-        .genericType.value.rawType;
+    const propertyType = filterConditionState.leftConditionType;
     const normalizedType = getStandardPrimitiveTypeEquivalent(propertyType);
     return (
       (normalizedType !== undefined &&
@@ -84,17 +82,14 @@ export class QueryBuilderFilterOperator_Equal
         !filterConditionState.rightConditionValue.isCollection
         ? filterConditionState.rightConditionValue.type
         : undefined,
-      filterConditionState.propertyExpressionState.propertyExpression.func.value
-        .genericType.value.rawType,
+      filterConditionState.leftConditionType,
     );
   }
 
   getDefaultFilterConditionValue(
     filterConditionState: FilterConditionState,
   ): ValueSpecification | undefined {
-    const propertyType =
-      filterConditionState.propertyExpressionState.propertyExpression.func.value
-        .genericType.value.rawType;
+    const propertyType = filterConditionState.leftConditionType;
     return buildDefaultInstanceValue(
       filterConditionState.filterState.queryBuilderState.graphManagerState
         .graph,
@@ -111,8 +106,7 @@ export class QueryBuilderFilterOperator_Equal
   ): ValueSpecification {
     return buildFilterConditionExpression(
       filterConditionState,
-      filterConditionState.propertyExpressionState.propertyExpression.func.value
-        .genericType.value.rawType.path === PRIMITIVE_TYPE.DATETIME &&
+      filterConditionState.leftConditionType.path === PRIMITIVE_TYPE.DATETIME &&
         filterConditionState.rightConditionValue?.type?.path !==
           PRIMITIVE_TYPE.DATETIME
         ? QUERY_BUILDER_SUPPORTED_FUNCTIONS.IS_ON_DAY
@@ -128,8 +122,8 @@ export class QueryBuilderFilterOperator_Equal
     return buildFilterConditionState(
       filterState,
       expression,
-      (expression.parametersValues[0] as AbstractPropertyExpression).func.value
-        .genericType.value.rawType.path === PRIMITIVE_TYPE.DATETIME &&
+      getFilterExpressionLeftSideTypePath(expression) ===
+        PRIMITIVE_TYPE.DATETIME &&
         expression.parametersValues[1]?.genericType?.value.rawType.path !==
           PRIMITIVE_TYPE.DATETIME
         ? QUERY_BUILDER_SUPPORTED_FUNCTIONS.IS_ON_DAY

package/src/stores/filter/operators/QueryBuilderFilterOperator_GreaterThan.ts

@@ -22,7 +22,6 @@ import { QueryBuilderFilterOperator } from '../QueryBuilderFilterOperator.js';
 import {
   type ValueSpecification,
   type SimpleFunctionExpression,
-  type AbstractPropertyExpression,
   PRIMITIVE_TYPE,
 } from '@finos/legend-graph';
 import {
@@ -33,6 +32,7 @@ import {
 import {
   buildFilterConditionState,
   buildFilterConditionExpression,
+  getFilterExpressionLeftSideTypePath,
 } from './QueryBuilderFilterOperatorValueSpecificationBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graph/QueryBuilderMetaModelConst.js';
 import {
@@ -53,9 +53,7 @@ export class QueryBuilderFilterOperator_GreaterThan
   isCompatibleWithFilterConditionProperty(
     filterConditionState: FilterConditionState,
   ): boolean {
-    const propertyType =
-      filterConditionState.propertyExpressionState.propertyExpression.func.value
-        .genericType.value.rawType;
+    const propertyType = filterConditionState.leftConditionType;
     const normalizedType = getStandardPrimitiveTypeEquivalent(propertyType);
     return (
       normalizedType !== undefined &&
@@ -81,17 +79,14 @@ export class QueryBuilderFilterOperator_GreaterThan
         !filterConditionState.rightConditionValue.isCollection
         ? filterConditionState.rightConditionValue.type
         : undefined,
-      filterConditionState.propertyExpressionState.propertyExpression.func.value
-        .genericType.value.rawType,
+      filterConditionState.leftConditionType,
     );
   }
 
   getDefaultFilterConditionValue(
     filterConditionState: FilterConditionState,
   ): ValueSpecification | undefined {
-    const propertyType =
-      filterConditionState.propertyExpressionState.propertyExpression.func.value
-        .genericType.value.rawType;
+    const propertyType = filterConditionState.leftConditionType;
     switch (propertyType.path) {
       case PRIMITIVE_TYPE.NUMBER:
       case PRIMITIVE_TYPE.DECIMAL:
@@ -122,8 +117,7 @@ export class QueryBuilderFilterOperator_GreaterThan
   ): ValueSpecification {
     return buildFilterConditionExpression(
       filterConditionState,
-      filterConditionState.propertyExpressionState.propertyExpression.func.value
-        .genericType.value.rawType.path === PRIMITIVE_TYPE.DATETIME &&
+      filterConditionState.leftConditionType.path === PRIMITIVE_TYPE.DATETIME &&
         filterConditionState.rightConditionValue?.type?.path !==
           PRIMITIVE_TYPE.DATETIME
         ? QUERY_BUILDER_SUPPORTED_FUNCTIONS.IS_AFTER_DAY
@@ -139,8 +133,8 @@ export class QueryBuilderFilterOperator_GreaterThan
     return buildFilterConditionState(
       filterState,
       expression,
-      (expression.parametersValues[0] as AbstractPropertyExpression).func.value
-        .genericType.value.rawType.path === PRIMITIVE_TYPE.DATETIME &&
+      getFilterExpressionLeftSideTypePath(expression) ===
+        PRIMITIVE_TYPE.DATETIME &&
         expression.parametersValues[1]?.genericType?.value.rawType.path !==
           PRIMITIVE_TYPE.DATETIME
         ? QUERY_BUILDER_SUPPORTED_FUNCTIONS.IS_AFTER_DAY