@finos/legend-query-builder 4.18.18 → 4.18.20

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -93,7 +93,8 @@ export type QueryBuilderFilterNodeDropTarget =
 export type QueryBuilderFilterValueDropTarget =
   | QueryBuilderVariableDragSource
   | QueryBuilderProjectionColumnDragSource
-  | QueryBuilderExplorerTreeDragSource;
+  | QueryBuilderExplorerTreeDragSource
+  | QueryBuilderExplorerTreeRelationColumnDragSource;
 
 export type QueryBuilderFilterConditionRearrangeDropTarget =
   QueryBuilderFilterConditionDragSource;
@@ -237,6 +238,64 @@ export class FilterPropertyExpressionStateConditionValueState extends FilterCond
   }
 }
 
+// This class is used to represent the value of a filter condition when the value is
+// a relation column accessor (which comes from DND a relation column from the explorer
+// tree or from the fetch structure panel). Used when the filter source is also a
+// relation column, allowing expressions like `$x.colA == $x.colB`.
+export class FilterRelationColumnConditionValueState extends FilterConditionValueState {
+  columnName: string;
+  columnType: Type;
+  columnMultiplicity: Multiplicity;
+
+  constructor(
+    conditionState: FilterConditionState,
+    columnName: string,
+    columnType: Type,
+    columnMultiplicity: Multiplicity,
+  ) {
+    super(conditionState);
+    makeObservable(this, {
+      columnName: observable,
+      columnType: observable,
+      columnMultiplicity: observable,
+      changeColumn: action,
+    });
+    this.columnName = columnName;
+    this.columnType = columnType;
+    this.columnMultiplicity = columnMultiplicity;
+  }
+
+  override get type(): Type {
+    return this.columnType;
+  }
+
+  override get isCollection(): boolean {
+    return (
+      this.columnMultiplicity.upperBound === undefined ||
+      this.columnMultiplicity.upperBound > 1
+    );
+  }
+
+  changeColumn(
+    columnName: string,
+    columnType: Type,
+    columnMultiplicity: Multiplicity,
+  ): void {
+    this.columnName = columnName;
+    this.columnType = columnType;
+    this.columnMultiplicity = columnMultiplicity;
+  }
+
+  override get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.FILTER_CONDITION_RIGHT_VALUE_RELATION_COLUMN,
+      this.columnName,
+      this.columnMultiplicity.lowerBound,
+      this.columnMultiplicity.upperBound ?? '',
+    ]);
+  }
+}
+
 /**
  * Abstract base class for the left-hand side (source) of a filter condition.
  * This allows filtering on different source types (class properties, relation columns)
@@ -403,6 +462,7 @@ export class FilterConditionState implements Hashable {
       addExistsLambdaParamNames: action,
       buildRightConditionValueFromValueSpec: action,
       buildRightConditionValueFromPropertyExpressionState: action,
+      buildRightConditionValueFromRelationColumn: action,
       handleTypeaheadSearch: flow,
       operators: computed,
       hashCode: computed,
@@ -582,6 +642,32 @@ export class FilterConditionState implements Hashable {
     }
   }
 
+  buildRightConditionValueFromRelationColumn(
+    columnName: string,
+    columnType: Type,
+    columnMultiplicity: Multiplicity,
+  ): void {
+    if (
+      this.rightConditionValue instanceof
+      FilterRelationColumnConditionValueState
+    ) {
+      this.rightConditionValue.changeColumn(
+        columnName,
+        columnType,
+        columnMultiplicity,
+      );
+    } else {
+      this.setRightConditionValue(
+        new FilterRelationColumnConditionValueState(
+          this,
+          columnName,
+          columnType,
+          columnMultiplicity,
+        ),
+      );
+    }
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.FILTER_CONDITION_STATE,

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

@@ -24,11 +24,14 @@ import {
   LambdaFunction,
   FunctionExpression,
   RelationColumn,
+  Multiplicity,
+  VariableExpression,
 } from '@finos/legend-graph';
 import { guaranteeType, assertTrue } from '@finos/legend-shared';
 import {
   FilterConditionState,
   FilterPropertyExpressionStateConditionValueState,
+  FilterRelationColumnConditionValueState,
   FilterRelationColumnSourceState,
   FilterValueSpecConditionValueState,
   type QueryBuilderFilterState,
@@ -76,6 +79,33 @@ export const buildFilterConditionExpression = (
       resolvedLambdaParameterName,
     );
     expression.parametersValues.push(rightConditionPropertyExpression);
+  } else if (
+    filterConditionState.rightConditionValue &&
+    filterConditionState.rightConditionValue instanceof
+      FilterRelationColumnConditionValueState
+  ) {
+    const rightValue = filterConditionState.rightConditionValue;
+    const relationType =
+      filterConditionState.filterState.queryBuilderState.sourceRelationType;
+    if (!relationType) {
+      throw new Error(
+        `Can't build expression for relation column '${rightValue.columnName}': no source relation type`,
+      );
+    }
+    const col = relationType.columns.find(
+      (c) => c.name === rightValue.columnName,
+    );
+    if (!col) {
+      throw new Error(
+        `Can't find column '${rightValue.columnName}' in relation`,
+      );
+    }
+    const colFuncExp = new FunctionExpression(col.name);
+    colFuncExp.func = col;
+    colFuncExp.parametersValues = [
+      new VariableExpression(resolvedLambdaParameterName, Multiplicity.ONE),
+    ];
+    expression.parametersValues.push(colFuncExp);
   }
   return expression;
 };
@@ -221,6 +251,19 @@ export const buildFilterConditionState = (
           ),
         ),
       );
+    } else if (
+      value instanceof FunctionExpression &&
+      value.func instanceof RelationColumn
+    ) {
+      const col = value.func;
+      filterConditionState.setRightConditionValue(
+        new FilterRelationColumnConditionValueState(
+          filterConditionState,
+          col.name,
+          col.genericType.value.rawType,
+          col.multiplicity,
+        ),
+      );
     } else {
       filterConditionState.setRightConditionValue(
         new FilterValueSpecConditionValueState(

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

@@ -28,6 +28,7 @@ import {
   GenericTypeExplicitReference,
   GenericType,
   Enumeration,
+  getPrimitiveTypeInstanceFromEnum,
   PRIMITIVE_TYPE,
   Multiplicity,
 } from '@finos/legend-graph';
@@ -97,6 +98,15 @@ export class QueryBuilderFilterOperator_In
         if (!collectionType) {
           return false;
         }
+        // Compare standard primitive equivalents so columns declared with a
+        // precise primitive type (e.g. accessor relation columns: Varchar,
+        // BigInt, Timestamp) are still recognized as compatible with the
+        // standard primitives stored in the value collection.
+        const normalizedPropertyTypePath =
+          getStandardPrimitiveTypeEquivalent(propertyType) ?? propertyType.path;
+        const normalizedCollectionTypePath =
+          getStandardPrimitiveTypeEquivalent(collectionType) ??
+          collectionType.path;
         if (
           (
             [
@@ -108,10 +118,7 @@ export class QueryBuilderFilterOperator_In
               PRIMITIVE_TYPE.STRICTDATE,
               PRIMITIVE_TYPE.DATETIME,
             ] as string[]
-          ).includes(
-            getStandardPrimitiveTypeEquivalent(propertyType) ??
-              propertyType.path,
-          )
+          ).includes(normalizedPropertyTypePath)
         ) {
           return (
             [
@@ -123,12 +130,12 @@ export class QueryBuilderFilterOperator_In
               PRIMITIVE_TYPE.STRICTDATE,
               PRIMITIVE_TYPE.DATETIME,
             ] as string[]
-          ).includes(
-            getStandardPrimitiveTypeEquivalent(collectionType) ??
-              collectionType.path,
-          );
+          ).includes(normalizedCollectionTypePath);
         }
-        return collectionType === propertyType;
+        return (
+          collectionType === propertyType ||
+          normalizedPropertyTypePath === normalizedCollectionTypePath
+        );
       } else if (valueSpec instanceof VariableExpression) {
         // check if not a single value
         if (valueSpec.multiplicity.upperBound === 1) {
@@ -144,9 +151,17 @@ export class QueryBuilderFilterOperator_In
     filterConditionState: FilterConditionState,
   ): ValueSpecification | undefined {
     const propertyType = filterConditionState.leftConditionType;
+    // Normalize precise primitive types (e.g. Varchar, BigInt) to their
+    // standard equivalent so the collection's generic type matches the
+    // standard primitive values that downstream editors produce.
+    const standardPrimitive = getStandardPrimitiveTypeEquivalent(propertyType);
+    const collectionType =
+      standardPrimitive !== undefined
+        ? getPrimitiveTypeInstanceFromEnum(standardPrimitive)
+        : propertyType;
     return new CollectionInstanceValue(
       Multiplicity.ONE,
-      GenericTypeExplicitReference.create(new GenericType(propertyType)),
+      GenericTypeExplicitReference.create(new GenericType(collectionType)),
     );
   }
 

package/src/stores/shared/ValueSpecificationEditorHelper.ts

@@ -30,7 +30,9 @@ import {
   GenericType,
   GenericTypeExplicitReference,
   getEnumValue,
+  getPrimitiveTypeInstanceFromEnum,
   PrimitiveInstanceValue,
+  PrecisePrimitiveType,
   PrimitiveType,
   PRIMITIVE_TYPE,
   INTERNAL__PropagatedValue,
@@ -484,11 +486,25 @@ export const convertTextToPrimitiveInstanceValue = (
   observerContext: ObserverContext,
 ): PrimitiveInstanceValue | null => {
   let result = null;
+  // Normalize precise primitive types (e.g. Varchar, BigInt, Timestamp) to
+  // their standard primitive equivalent so values entered through the editor
+  // are stored as standard PrimitiveInstanceValue regardless of whether the
+  // source column was declared with a precise type (e.g. accessor relation
+  // columns).
+  let resolvedType: PrimitiveType | undefined;
   if (expectedType instanceof PrimitiveType) {
-    switch (expectedType.path) {
+    resolvedType = expectedType;
+  } else if (expectedType instanceof PrecisePrimitiveType) {
+    const standard = getStandardPrimitiveTypeEquivalent(expectedType);
+    resolvedType = standard
+      ? getPrimitiveTypeInstanceFromEnum(standard)
+      : undefined;
+  }
+  if (resolvedType) {
+    switch (resolvedType.path) {
       case PRIMITIVE_TYPE.STRING: {
         result = new PrimitiveInstanceValue(
-          GenericTypeExplicitReference.create(new GenericType(expectedType)),
+          GenericTypeExplicitReference.create(new GenericType(resolvedType)),
         );
         instanceValue_setValues(result, [value.toString()], observerContext);
         break;
@@ -501,11 +517,11 @@ export const convertTextToPrimitiveInstanceValue = (
           return null;
         }
         const formattedNumber =
-          expectedType.path === PRIMITIVE_TYPE.INTEGER
+          resolvedType.path === PRIMITIVE_TYPE.INTEGER
             ? Number.parseInt(Number(value).toString(), 10)
             : Number(value);
         result = new PrimitiveInstanceValue(
-          GenericTypeExplicitReference.create(new GenericType(expectedType)),
+          GenericTypeExplicitReference.create(new GenericType(resolvedType)),
         );
         instanceValue_setValues(result, [formattedNumber], observerContext);
         break;
@@ -516,7 +532,7 @@ export const convertTextToPrimitiveInstanceValue = (
           return null;
         }
         result = new PrimitiveInstanceValue(
-          GenericTypeExplicitReference.create(new GenericType(expectedType)),
+          GenericTypeExplicitReference.create(new GenericType(resolvedType)),
         );
         instanceValue_setValues(result, [value], observerContext);
         break;
@@ -532,7 +548,7 @@ export const convertTextToPrimitiveInstanceValue = (
           return null;
         }
         result = new PrimitiveInstanceValue(
-          GenericTypeExplicitReference.create(new GenericType(expectedType)),
+          GenericTypeExplicitReference.create(new GenericType(resolvedType)),
         );
         instanceValue_setValues(result, [value], observerContext);
         break;