@finos/legend-query-builder 4.18.1 → 4.18.3

package/src/stores/__test-utils__/TEST_DATA__QueryBuilder_Accessors.ts

@@ -14,6 +14,163 @@
  * limitations under the License.
  */
 
+export const TEST_DATA__QueryBuilder_Accessors_SimpleProjection_WithFilter = {
+  _type: 'lambda',
+  body: [
+    {
+      _type: 'func',
+      function: 'from',
+      parameters: [
+        {
+          _type: 'func',
+          function: 'project',
+          parameters: [
+            {
+              _type: 'func',
+              function: 'filter',
+              parameters: [
+                {
+                  _type: 'classInstance',
+                  multiplicity: {
+                    lowerBound: 1,
+                    upperBound: 1,
+                  },
+                  type: '>',
+                  value: {
+                    path: ['database::TestDatabase', 'default', 'TEST0'],
+                  },
+                },
+                {
+                  _type: 'lambda',
+                  body: [
+                    {
+                      _type: 'func',
+                      function: 'and',
+                      parameters: [
+                        {
+                          _type: 'func',
+                          function: 'equal',
+                          parameters: [
+                            {
+                              _type: 'property',
+                              parameters: [
+                                {
+                                  _type: 'var',
+                                  name: 'x',
+                                },
+                              ],
+                              property: 'FIRSTNAME',
+                            },
+                            {
+                              _type: 'string',
+                              value: 'John',
+                            },
+                          ],
+                        },
+                        {
+                          _type: 'func',
+                          function: 'equal',
+                          parameters: [
+                            {
+                              _type: 'property',
+                              parameters: [
+                                {
+                                  _type: 'var',
+                                  name: 'x',
+                                },
+                              ],
+                              property: 'LASTNAME',
+                            },
+                            {
+                              _type: 'string',
+                              value: 'Doe',
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                  parameters: [
+                    {
+                      _type: 'var',
+                      name: 'x',
+                    },
+                  ],
+                },
+              ],
+            },
+            {
+              _type: 'classInstance',
+              multiplicity: {
+                lowerBound: 1,
+                upperBound: 1,
+              },
+              type: 'colSpecArray',
+              value: {
+                colSpecs: [
+                  {
+                    function1: {
+                      _type: 'lambda',
+                      body: [
+                        {
+                          _type: 'property',
+                          parameters: [
+                            {
+                              _type: 'var',
+                              name: 'x',
+                            },
+                          ],
+                          property: 'FIRSTNAME',
+                        },
+                      ],
+                      parameters: [
+                        {
+                          _type: 'var',
+                          name: 'x',
+                        },
+                      ],
+                    },
+                    name: 'Firstname',
+                  },
+                  {
+                    function1: {
+                      _type: 'lambda',
+                      body: [
+                        {
+                          _type: 'property',
+                          parameters: [
+                            {
+                              _type: 'var',
+                              name: 'x',
+                            },
+                          ],
+                          property: 'LASTNAME',
+                        },
+                      ],
+                      parameters: [
+                        {
+                          _type: 'var',
+                          name: 'x',
+                        },
+                      ],
+                    },
+                    name: 'Lastname',
+                  },
+                ],
+              },
+            },
+          ],
+        },
+        {
+          _type: 'packageableElementPtr',
+          fullPath: 'runtime::TestRuntime',
+        },
+      ],
+    },
+  ],
+  parameters: [],
+};
+
 export const TEST_DATA__QueryBuilder_Accessors_SimpleProjection_WithPostFilter =
   {
     _type: 'lambda',

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(