@finos/legend-query-builder 4.15.2 → 4.15.3

package/src/components/result/tds/QueryBuilderTDSGridResult.tsx

@@ -20,6 +20,7 @@ import { PRIMITIVE_TYPE, type TDSExecutionResult } from '@finos/legend-graph';
 import { useState, useCallback, useEffect } from 'react';
 import {
   DataGrid,
+  type DataGridCellSelectionChangedEvent,
   type DataGridApi,
   type DataGridCellRange,
   type DataGridColumnDefinition,
@@ -347,7 +348,7 @@ export const QueryBuilderTDSGridResult = observer(
                   resultState.mousedOverCell,
                   true,
                   fetchStructureImplementation,
-                );
+                ).catch(queryBuilderState.applicationStore.alertUnhandledError);
               },
             },
             {
@@ -358,7 +359,7 @@ export const QueryBuilderTDSGridResult = observer(
                   resultState.mousedOverCell,
                   false,
                   fetchStructureImplementation,
-                );
+                ).catch(queryBuilderState.applicationStore.alertUnhandledError);
               },
             },
             'copy',
@@ -377,6 +378,7 @@ export const QueryBuilderTDSGridResult = observer(
         applicationStore,
         resultState.mousedOverCell,
         resultState.queryBuilderState.fetchStructureState.implementation,
+        queryBuilderState.applicationStore.alertUnhandledError,
       ],
     );
 
@@ -554,7 +556,9 @@ export const QueryBuilderTDSGridResult = observer(
               onRowDataUpdated={(params) => {
                 params.api.refreshCells({ force: true });
               }}
-              onRangeSelectionChanged={(event) => {
+              onCellSelectionChanged={(
+                event: DataGridCellSelectionChangedEvent<QueryBuilderTDSRowDataType>,
+              ) => {
                 const selectedCells = getSelectedCells(event.api);
                 resultState.setSelectedCells([]);
                 selectedCells.forEach((cell) =>

package/src/components/result/tds/QueryBuilderTDSResultShared.tsx

@@ -22,12 +22,13 @@ import {
 import { observer } from 'mobx-react-lite';
 import { flowResult } from 'mobx';
 import {
-  type TDSExecutionResult,
+  type AbstractPropertyExpression,
   type Enumeration,
-  InstanceValue,
-  EnumValueInstanceValue,
-  EnumValueExplicitReference,
   type ExecutionResult,
+  type TDSExecutionResult,
+  EnumValueExplicitReference,
+  EnumValueInstanceValue,
+  InstanceValue,
   RelationalExecutionActivities,
 } from '@finos/legend-graph';
 import { format as formatSQL } from 'sql-formatter';
@@ -47,6 +48,7 @@ import { forwardRef } from 'react';
 import {
   QueryBuilderDerivationProjectionColumnState,
   QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
 } from '../../../stores/fetch-structure/tds/projection/QueryBuilderProjectionColumnState.js';
 import {
   type QueryBuilderPostFilterTreeNodeData,
@@ -81,6 +83,30 @@ import {
 } from '../../../stores/fetch-structure/tds/post-filter/operators/QueryBuilderPostFilterOperator_IsEmpty.js';
 import { getTDSColumnState } from '../../../stores/fetch-structure/tds/QueryBuilderTDSHelper.js';
 import type { QueryBuilderTDSColumnState } from '../../../stores/fetch-structure/tds/QueryBuilderTDSColumnState.js';
+import {
+  type QueryBuilderFilterState,
+  type QueryBuilderFilterTreeNodeData,
+  FilterConditionState,
+  FilterValueSpecConditionValueState,
+  isCollectionProperty,
+  QueryBuilderFilterTreeConditionNodeData,
+} from '../../../stores/filter/QueryBuilderFilterState.js';
+import { QueryBuilderAggregateColumnState } from '../../../stores/fetch-structure/tds/aggregation/QueryBuilderAggregationState.js';
+import type { QueryBuilderFilterOperator } from '../../../stores/filter/QueryBuilderFilterOperator.js';
+import {
+  QueryBuilderFilterOperator_Equal,
+  QueryBuilderFilterOperator_NotEqual,
+} from '../../../stores/filter/operators/QueryBuilderFilterOperator_Equal.js';
+import {
+  QueryBuilderFilterOperator_In,
+  QueryBuilderFilterOperator_NotIn,
+} from '../../../stores/filter/operators/QueryBuilderFilterOperator_In.js';
+import {
+  QueryBuilderFilterOperator_IsEmpty,
+  QueryBuilderFilterOperator_IsNotEmpty,
+} from '../../../stores/filter/operators/QueryBuilderFilterOperator_IsEmpty.js';
+import type { QueryBuilderState } from '../../../stores/QueryBuilderState.js';
+import type { QueryBuilderPropertyExpressionState } from '../../../stores/QueryBuilderPropertyEditorState.js';
 
 export const tryToFormatSql = (sql: string): string => {
   try {
@@ -139,6 +165,13 @@ export type IQueryRendererParamsWithGridType = DataGridCellRendererParams & {
   tdsExecutionResult: TDSExecutionResult;
 };
 
+const filterEqualOperator = new QueryBuilderFilterOperator_Equal();
+const filterNotEqualOperator = new QueryBuilderFilterOperator_NotEqual();
+const filterInOperator = new QueryBuilderFilterOperator_In();
+const filterNotInOperator = new QueryBuilderFilterOperator_NotIn();
+const filterEmptyOperator = new QueryBuilderFilterOperator_IsEmpty();
+const filterNotEmptyOperator = new QueryBuilderFilterOperator_IsNotEmpty();
+
 const postFilterEqualOperator = new QueryBuilderPostFilterOperator_Equal();
 const postFilterInOperator = new QueryBuilderPostFilterOperator_In();
 const postFilterEmptyOperator = new QueryBuilderPostFilterOperator_IsEmpty();
@@ -148,6 +181,22 @@ const postFilterNotEqualOperator =
   new QueryBuilderPostFilterOperator_NotEqual();
 const postFilterNotInOperator = new QueryBuilderPostFilterOperator_NotIn();
 
+const getExistingFilterNode = (
+  operators: QueryBuilderFilterOperator[],
+  propertyExpressionState: QueryBuilderPropertyExpressionState | undefined,
+  filterState: QueryBuilderFilterState,
+): QueryBuilderFilterTreeNodeData | undefined =>
+  Array.from(filterState.nodes.values())
+    .filter(filterByType(QueryBuilderFilterTreeConditionNodeData))
+    .filter(
+      (node) =>
+        node.condition.propertyExpressionState.path ===
+          propertyExpressionState?.path &&
+        operators
+          .map((op) => op.getLabel())
+          .includes(node.condition.operator.getLabel()),
+    )[0];
+
 const getExistingPostFilterNode = (
   operators: QueryBuilderPostFilterOperator[],
   projectionColumnName: string | undefined,
@@ -173,7 +222,7 @@ const getExistingPostFilterNode = (
 const updateFilterConditionValue = (
   conditionValue: InstanceValue,
   _cellData: QueryBuilderTDSResultCellData,
-  tdsState: QueryBuilderTDSState,
+  queryBuilderState: QueryBuilderState,
 ): void => {
   if (_cellData.value) {
     instanceValue_setValue(
@@ -188,11 +237,58 @@ const updateFilterConditionValue = (
           )
         : _cellData.value,
       0,
-      tdsState.queryBuilderState.observerContext,
+      queryBuilderState.observerContext,
     );
   }
 };
 
+const generateNewFilterConditionNodeData = (
+  applicationStore: ApplicationStore<
+    LegendApplicationConfig,
+    LegendApplicationPluginManager<LegendApplicationPlugin>
+  >,
+  operator: QueryBuilderFilterOperator,
+  _cellData: QueryBuilderTDSResultCellData,
+  filterState: QueryBuilderFilterState,
+  propertyExpression: AbstractPropertyExpression | undefined,
+): void => {
+  let filterConditionState: FilterConditionState;
+  try {
+    if (propertyExpression) {
+      filterConditionState = new FilterConditionState(
+        filterState,
+        propertyExpression,
+        operator,
+      );
+
+      const defaultFilterConditionValue =
+        filterConditionState.operator.getDefaultFilterConditionValue(
+          filterConditionState,
+        );
+
+      filterConditionState.buildRightConditionValueFromValueSpec(
+        defaultFilterConditionValue,
+      );
+      updateFilterConditionValue(
+        defaultFilterConditionValue as InstanceValue,
+        _cellData,
+        filterState.queryBuilderState,
+      );
+      filterState.addNodeFromNode(
+        new QueryBuilderFilterTreeConditionNodeData(
+          undefined,
+          filterConditionState,
+        ),
+        undefined,
+      );
+    }
+  } catch (error) {
+    assertErrorThrown(error);
+    applicationStore.notificationService.notifyWarning(error.message);
+    return;
+  }
+};
+
 const generateNewPostFilterConditionNodeData = async (
   applicationStore: ApplicationStore<
     LegendApplicationConfig,
@@ -235,7 +331,7 @@ const generateNewPostFilterConditionNodeData = async (
       updateFilterConditionValue(
         defaultFilterConditionValue as InstanceValue,
         _cellData,
-        tdsState,
+        tdsState.queryBuilderState,
       );
       tdsState.postFilterState.addNodeFromNode(
         new QueryBuilderPostFilterTreeConditionNodeData(
@@ -252,6 +348,91 @@ const generateNewPostFilterConditionNodeData = async (
   }
 };
 
+const updateExistingFilterConditionNodeData = (
+  existingPreFilterNode: QueryBuilderFilterTreeNodeData,
+  isFilterBy: boolean,
+  _cellData: QueryBuilderTDSResultCellData,
+  operator: QueryBuilderFilterOperator,
+  data: QueryBuilderTDSResultCellData | null,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  if (operator === filterEmptyOperator || operator === filterNotEmptyOperator) {
+    const conditionState = (
+      existingPreFilterNode as QueryBuilderFilterTreeConditionNodeData
+    ).condition;
+    if (conditionState.operator.getLabel() !== operator.getLabel()) {
+      conditionState.changeOperator(
+        isFilterBy ? filterEmptyOperator : filterNotEmptyOperator,
+      );
+    }
+    return;
+  }
+  const conditionState = (
+    existingPreFilterNode as QueryBuilderFilterTreeConditionNodeData
+  ).condition;
+
+  const rightSide = conditionState.rightConditionValue;
+  if (rightSide instanceof FilterValueSpecConditionValueState) {
+    if (conditionState.operator.getLabel() === operator.getLabel()) {
+      const doesValueAlreadyExist =
+        rightSide.value instanceof InstanceValue &&
+        (rightSide.value instanceof EnumValueInstanceValue
+          ? rightSide.value.values.map((ef) => ef.value.name)
+          : rightSide.value.values
+        ).includes(_cellData.value);
+
+      if (!doesValueAlreadyExist) {
+        const currentValueSpecificaton = rightSide.value;
+        const newValueSpecification =
+          conditionState.operator.getDefaultFilterConditionValue(
+            conditionState,
+          );
+        updateFilterConditionValue(
+          newValueSpecification as InstanceValue,
+          _cellData,
+          queryBuilderState,
+        );
+        conditionState.changeOperator(
+          isFilterBy ? filterInOperator : filterNotInOperator,
+        );
+        instanceValue_setValues(
+          rightSide.value as InstanceValue,
+          [currentValueSpecificaton, newValueSpecification],
+          queryBuilderState.observerContext,
+        );
+      }
+    } else {
+      const doesValueAlreadyExist =
+        rightSide.value instanceof InstanceValue &&
+        rightSide.value.values
+          .filter((v) => v instanceof InstanceValue)
+          .map((v) =>
+            v instanceof EnumValueInstanceValue
+              ? v.values.map((ef) => ef.value.name)
+              : v.values,
+          )
+          .flat()
+          .includes(_cellData.value ?? data?.value);
+
+      if (!doesValueAlreadyExist) {
+        const newValueSpecification = (
+          isFilterBy ? filterEqualOperator : filterNotEqualOperator
+        ).getDefaultFilterConditionValue(conditionState);
+        updateFilterConditionValue(
+          newValueSpecification as InstanceValue,
+          _cellData,
+          queryBuilderState,
+        );
+        instanceValue_setValues(
+          rightSide.value as InstanceValue,
+          [...(rightSide.value as InstanceValue).values, newValueSpecification],
+          queryBuilderState.observerContext,
+        );
+      }
+    }
+  }
+};
+
 const updateExistingPostFilterConditionNodeData = (
   existingPostFilterNode: QueryBuilderPostFilterTreeNodeData,
   isFilterBy: boolean,
@@ -297,7 +478,7 @@ const updateExistingPostFilterConditionNodeData = (
         updateFilterConditionValue(
           newValueSpecification as InstanceValue,
           _cellData,
-          tdsState,
+          tdsState.queryBuilderState,
         );
         conditionState.changeOperator(
           isFilterBy ? postFilterInOperator : postFilterNotInOperator,
@@ -328,7 +509,7 @@ const updateExistingPostFilterConditionNodeData = (
         updateFilterConditionValue(
           newValueSpecification as InstanceValue,
           _cellData,
-          tdsState,
+          tdsState.queryBuilderState,
         );
         instanceValue_setValues(
           rightSide.value as InstanceValue,
@@ -343,6 +524,25 @@ const updateExistingPostFilterConditionNodeData = (
 const getFilterOperator = (
   isFilterBy: boolean,
   _cellData: QueryBuilderTDSResultCellData,
+): QueryBuilderFilterOperator => {
+  if (isFilterBy) {
+    if (_cellData.value === null) {
+      return filterEmptyOperator;
+    } else {
+      return filterEqualOperator;
+    }
+  } else {
+    if (_cellData.value === null) {
+      return filterNotEmptyOperator;
+    } else {
+      return filterNotEqualOperator;
+    }
+  }
+};
+
+const getPostFilterOperator = (
+  isFilterBy: boolean,
+  _cellData: QueryBuilderTDSResultCellData,
 ): QueryBuilderPostFilterOperator => {
   if (isFilterBy) {
     if (_cellData.value === null) {
@@ -359,7 +559,7 @@ const getFilterOperator = (
   }
 };
 
-const filterByOrOutValue = (
+const preFilterByOrOutValue = (
   applicationStore: ApplicationStore<
     LegendApplicationConfig,
     LegendApplicationPluginManager<LegendApplicationPlugin>
@@ -367,13 +567,58 @@ const filterByOrOutValue = (
   isFilterBy: boolean,
   _cellData: QueryBuilderTDSResultCellData,
   data: QueryBuilderTDSResultCellData | null,
-  tdsState: QueryBuilderTDSState,
+  propertyExpressionState: QueryBuilderPropertyExpressionState,
+  queryBuilderState: QueryBuilderState,
 ): void => {
-  tdsState.setShowPostFilterPanel(true);
+  queryBuilderState.filterState.setShowPanel(true);
   const operator = getFilterOperator(isFilterBy, _cellData);
-  const tdsColState = data?.columnName
-    ? getTDSColumnState(tdsState, data.columnName)
-    : undefined;
+  const existingPreFilterNode = getExistingFilterNode(
+    _cellData.value === null
+      ? [filterEmptyOperator, filterNotEmptyOperator]
+      : isFilterBy
+        ? [filterEqualOperator, filterInOperator]
+        : [filterNotEqualOperator, filterNotInOperator],
+    propertyExpressionState,
+    queryBuilderState.filterState,
+  );
+  if (existingPreFilterNode) {
+    updateExistingFilterConditionNodeData(
+      existingPreFilterNode,
+      isFilterBy,
+      _cellData,
+      operator,
+      data,
+      queryBuilderState,
+    );
+  } else {
+    try {
+      generateNewFilterConditionNodeData(
+        applicationStore,
+        operator,
+        _cellData,
+        queryBuilderState.filterState,
+        propertyExpressionState.propertyExpression,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      applicationStore.alertUnhandledError(error);
+    }
+  }
+};
+
+const postFilterByOrOutValue = async (
+  applicationStore: ApplicationStore<
+    LegendApplicationConfig,
+    LegendApplicationPluginManager<LegendApplicationPlugin>
+  >,
+  isFilterBy: boolean,
+  _cellData: QueryBuilderTDSResultCellData,
+  data: QueryBuilderTDSResultCellData | null,
+  tdsColState: QueryBuilderTDSColumnState,
+  tdsState: QueryBuilderTDSState,
+): Promise<void> => {
+  tdsState.setShowPostFilterPanel(true);
+  const operator = getPostFilterOperator(isFilterBy, _cellData);
   const existingPostFilterNode = getExistingPostFilterNode(
     _cellData.value === null
       ? [postFilterEmptyOperator, postFilterNotEmptyOperator]
@@ -394,17 +639,69 @@ const filterByOrOutValue = (
       tdsState,
     );
   } else {
-    generateNewPostFilterConditionNodeData(
+    try {
+      await generateNewPostFilterConditionNodeData(
+        applicationStore,
+        operator,
+        _cellData,
+        tdsState,
+        tdsColState,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      applicationStore.alertUnhandledError(error);
+    }
+  }
+};
+
+const filterByOrOutValue = async (
+  applicationStore: ApplicationStore<
+    LegendApplicationConfig,
+    LegendApplicationPluginManager<LegendApplicationPlugin>
+  >,
+  isFilterBy: boolean,
+  _cellData: QueryBuilderTDSResultCellData,
+  data: QueryBuilderTDSResultCellData | null,
+  tdsState: QueryBuilderTDSState,
+): Promise<void> => {
+  const tdsColState = data?.columnName
+    ? getTDSColumnState(tdsState, _cellData.columnName)
+    : _cellData.columnName
+      ? getTDSColumnState(tdsState, _cellData.columnName)
+      : undefined;
+  if (
+    tdsColState instanceof QueryBuilderDerivationProjectionColumnState ||
+    tdsColState instanceof QueryBuilderAggregateColumnState ||
+    (tdsColState instanceof QueryBuilderSimpleProjectionColumnState &&
+      isCollectionProperty(
+        tdsColState.propertyExpressionState.propertyExpression,
+      ))
+  ) {
+    await postFilterByOrOutValue(
       applicationStore,
-      operator,
+      isFilterBy,
       _cellData,
-      tdsState,
+      data,
       tdsColState,
-    ).catch(applicationStore.alertUnhandledError);
+      tdsState,
+    );
+  } else if (tdsColState instanceof QueryBuilderSimpleProjectionColumnState) {
+    preFilterByOrOutValue(
+      applicationStore,
+      isFilterBy,
+      _cellData,
+      data,
+      tdsColState.propertyExpressionState,
+      tdsState.queryBuilderState,
+    );
+  } else {
+    applicationStore.notificationService.notifyError(
+      `Can't filter column '${data?.columnName ? data.columnName : _cellData.columnName}'`,
+    );
   }
 };
 
-export const filterByOrOutValues = (
+export const filterByOrOutValues = async (
   applicationStore: ApplicationStore<
     LegendApplicationConfig,
     LegendApplicationPluginManager<LegendApplicationPlugin>
@@ -412,10 +709,17 @@ export const filterByOrOutValues = (
   data: QueryBuilderTDSResultCellData | null,
   isFilterBy: boolean,
   tdsState: QueryBuilderTDSState,
-): void => {
-  tdsState.queryBuilderState.resultState.selectedCells.forEach((_cellData) => {
-    filterByOrOutValue(applicationStore, isFilterBy, _cellData, data, tdsState);
-  });
+): Promise<void> => {
+  for (const _cellData of tdsState.queryBuilderState.resultState
+    .selectedCells) {
+    await filterByOrOutValue(
+      applicationStore,
+      isFilterBy,
+      _cellData,
+      data,
+      tdsState,
+    );
+  }
 };
 
 export const QueryBuilderGridResultContextMenu = observer(
@@ -440,7 +744,9 @@ export const QueryBuilderGridResultContextMenu = observer(
         <MenuContentItem
           disabled={!tdsColState}
           onClick={(): void => {
-            filterByOrOutValues(applicationStore, data, true, tdsState);
+            filterByOrOutValues(applicationStore, data, true, tdsState).catch(
+              tdsState.queryBuilderState.applicationStore.alertUnhandledError,
+            );
           }}
         >
           Filter By
@@ -448,7 +754,9 @@ export const QueryBuilderGridResultContextMenu = observer(
         <MenuContentItem
           disabled={!tdsColState}
           onClick={(): void => {
-            filterByOrOutValues(applicationStore, data, false, tdsState);
+            filterByOrOutValues(applicationStore, data, false, tdsState).catch(
+              tdsState.queryBuilderState.applicationStore.alertUnhandledError,
+            );
           }}
         >
           Filter Out

package/src/stores/filter/QueryBuilderFilterOperator.ts

@@ -27,7 +27,7 @@ import type {
 export abstract class QueryBuilderFilterOperator implements Hashable {
   readonly uuid = uuid();
 
-  abstract getLabel(filterConditionState: FilterConditionState): string;
+  abstract getLabel(): string;
 
   abstract isCompatibleWithFilterConditionProperty(
     filterConditionState: FilterConditionState,

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -246,6 +246,7 @@ export class FilterConditionState implements Hashable {
   constructor(
     filterState: QueryBuilderFilterState,
     propertyExpression: AbstractPropertyExpression,
+    operator?: QueryBuilderFilterOperator,
   ) {
     makeObservable(this, {
       propertyExpressionState: observable,
@@ -271,11 +272,15 @@ export class FilterConditionState implements Hashable {
     );
 
     // operator
-    assertTrue(
-      this.operators.length !== 0,
-      `Can't find an operator for property '${this.propertyExpressionState.path}': no operators registered`,
-    );
-    this.operator = this.operators[0] as QueryBuilderFilterOperator;
+    if (operator) {
+      this.operator = operator;
+    } else {
+      assertTrue(
+        this.operators.length !== 0,
+        `Can't find an operator for property '${this.propertyExpressionState.path}': no operators registered`,
+      );
+      this.operator = this.operators[0] as QueryBuilderFilterOperator;
+    }
     this.buildRightConditionValueFromValueSpec(
       this.operator.getDefaultFilterConditionValue(this),
     );

package/src/stores/filter/QueryBuilderFilterStateBuilder.ts

@@ -332,7 +332,7 @@ const processFilterTree = (
         assertTrue(
           parentLambdaVariableName === variableName,
           `Can't process ${extractElementNameFromPath(
-            filterConditionState.operator.getLabel(filterConditionState),
+            filterConditionState.operator.getLabel(),
           )}() expression: expects variable used in lambda body '${variableName}' to match lambda parameter '${parentLambdaVariableName}'`,
         );
         filterState.addNodeFromNode(

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

@@ -46,7 +46,7 @@ export class QueryBuilderFilterOperator_Contain
   extends QueryBuilderFilterOperator
   implements Hashable
 {
-  getLabel(filterConditionState: FilterConditionState): string {
+  getLabel(): string {
     return 'contains';
   }
 
@@ -90,9 +90,7 @@ export class QueryBuilderFilterOperator_Contain
       }
       default:
         throw new UnsupportedOperationError(
-          `Can't get default value for filter operator '${this.getLabel(
-            filterConditionState,
-          )}' when the LHS property is of type '${propertyType.path}'`,
+          `Can't get default value for filter operator '${this.getLabel()}' when the LHS property is of type '${propertyType.path}'`,
         );
     }
   }
@@ -128,7 +126,7 @@ export class QueryBuilderFilterOperator_Contain
 }
 
 export class QueryBuilderFilterOperator_NotContain extends QueryBuilderFilterOperator_Contain {
-  override getLabel(filterConditionState: FilterConditionState): string {
+  override getLabel(): string {
     return `doesn't contain`;
   }
 

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

@@ -46,7 +46,7 @@ export class QueryBuilderFilterOperator_EndWith
   extends QueryBuilderFilterOperator
   implements Hashable
 {
-  getLabel(filterConditionState: FilterConditionState): string {
+  getLabel(): string {
     return 'ends with';
   }
 
@@ -90,9 +90,7 @@ export class QueryBuilderFilterOperator_EndWith
       }
       default:
         throw new UnsupportedOperationError(
-          `Can't get default value for filter operator '${this.getLabel(
-            filterConditionState,
-          )}' when the LHS property is of type '${propertyType.path}'`,
+          `Can't get default value for filter operator '${this.getLabel()}' when the LHS property is of type '${propertyType.path}'`,
         );
     }
   }
@@ -128,7 +126,7 @@ export class QueryBuilderFilterOperator_EndWith
 }
 
 export class QueryBuilderFilterOperator_NotEndWith extends QueryBuilderFilterOperator_EndWith {
-  override getLabel(filterConditionState: FilterConditionState): string {
+  override getLabel(): string {
     return `doesn't end with`;
   }
 

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

@@ -44,7 +44,7 @@ export class QueryBuilderFilterOperator_Equal
   extends QueryBuilderFilterOperator
   implements Hashable
 {
-  getLabel(filterConditionState: FilterConditionState): string {
+  getLabel(): string {
     return 'is';
   }
 
@@ -143,7 +143,7 @@ export class QueryBuilderFilterOperator_Equal
 }
 
 export class QueryBuilderFilterOperator_NotEqual extends QueryBuilderFilterOperator_Equal {
-  override getLabel(filterConditionState: FilterConditionState): string {
+  override getLabel(): string {
     return `is not`;
   }
 

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

@@ -43,7 +43,7 @@ export class QueryBuilderFilterOperator_GreaterThan
   extends QueryBuilderFilterOperator
   implements Hashable
 {
-  getLabel(filterConditionState: FilterConditionState): string {
+  getLabel(): string {
     return '>';
   }
 
@@ -104,9 +104,7 @@ export class QueryBuilderFilterOperator_GreaterThan
       }
       default:
         throw new UnsupportedOperationError(
-          `Can't get default value for filter operator '${this.getLabel(
-            filterConditionState,
-          )}' when the LHS property is of type '${propertyType.path}'`,
+          `Can't get default value for filter operator '${this.getLabel()}' when the LHS property is of type '${propertyType.path}'`,
         );
     }
   }