@finos/legend-query-builder 4.14.96 → 4.15.0

package/src/graph-manager/QueryBuilderConfig.ts

@@ -19,7 +19,12 @@ import { createModelSchema, optional, primitive } from 'serializr';
 
 export class QueryBuilderConfig {
   /**
-   * This flag is to disable query builder chat feature
+   * This flag is to enable export to cube
+   */
+  TEMPORARY__enableExportToCube = false;
+
+  /**
+   * This flag is to disable query builder chat features
    */
   TEMPORARY__disableQueryBuilderChat = false;
 
@@ -41,6 +46,7 @@ export class QueryBuilderConfig {
   static readonly serialization = new SerializationFactory(
     createModelSchema(QueryBuilderConfig, {
       TEMPORARY__disableQueryBuilderChat: optional(primitive()),
+      TEMPORARY__enableExportToCube: optional(primitive()),
       TEMPORARY__enableGridEnterpriseMode: optional(primitive()),
       legendAIServiceURL: optional(primitive()),
       zipkinTraceBaseURL: optional(primitive()),

package/src/index.ts

@@ -126,3 +126,5 @@ export * from './stores/filter/QueryBuilderFilterValueSpecificationBuilder.js';
 export * from './stores/QueryBuilderValueSpecificationHelper.js';
 export * from './stores/filter/QueryBuilderFilterState.js';
 export * from './stores/filter/QueryBuilderFilterStateBuilder.js';
+export * from './stores/data-cube/QueryBuilderDataCubeApplicationEngine.js';
+export * from './stores/data-cube/QueryBuilderDataCubeEngine.js';

package/src/stores/QueryBuilderState.ts

@@ -68,14 +68,10 @@ import {
   buildLambdaVariableExpressions,
   buildRawLambdaFromLambdaFunction,
   PrimitiveType,
-  SimpleFunctionExpression,
-  extractElementNameFromPath,
-  SUPPORTED_FUNCTIONS,
   PackageableElementExplicitReference,
-  InstanceValue,
-  Multiplicity,
   RuntimePointer,
   QueryExplicitExecutionContext,
+  attachFromQuery,
 } from '@finos/legend-graph';
 import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
 import type {
@@ -158,6 +154,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   isCheckingEntitlments = false;
   isCalendarEnabled = false;
   isLocalModeEnabled = false;
+  isCubeEnabled = false;
   INTERNAL__enableInitializingDefaultSimpleExpressionValue = false;
 
   lambdaWriteMode = QUERY_BUILDER_LAMBDA_WRITER_MODE.STANDARD;
@@ -208,6 +205,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       class: observable,
       isQueryChatOpened: observable,
       isLocalModeEnabled: observable,
+      isCubeEnabled: observable,
       getAllFunction: observable,
       lambdaWriteMode: observable,
       INTERNAL__enableInitializingDefaultSimpleExpressionValue: observable,
@@ -221,6 +219,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       setShowParametersPanel: action,
       setIsEditingWatermark: action,
       setIsCalendarEnabled: action,
+      setIsCubeEnabled: action,
       setIsCheckingEntitlments: action,
       setClass: action,
       setIsQueryChatOpened: action,
@@ -266,7 +265,6 @@ export abstract class QueryBuilderState implements CommandRegistrar {
 
     this.workflowState = workflowState;
     this.sourceInfo = sourceInfo;
-    //extra check for only QA currently.
     this.isQueryChatOpened =
       (!this.config?.TEMPORARY__disableQueryBuilderChat &&
         this.applicationStore.settingService.getBooleanValue(
@@ -383,6 +381,10 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.isLocalModeEnabled = val;
   }
 
+  setIsCubeEnabled(val: boolean): void {
+    this.isCubeEnabled = val;
+  }
+
   setInternalize(val: QueryBuilderInternalizeState | undefined): void {
     this.internalizeState = val;
   }
@@ -601,28 +603,12 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       RuntimePointer,
     ).packageableRuntime;
     const lambdaFunc = buildLambdaFunction(this);
-    const currentExpression = guaranteeNonNullable(
-      lambdaFunc.expressionSequence[0],
+    const fromQuery = attachFromQuery(
+      lambdaFunc,
+      mapping,
+      runtimePointer.value,
     );
-    const _func = new SimpleFunctionExpression(
-      extractElementNameFromPath(SUPPORTED_FUNCTIONS.FROM),
-    );
-
-    const mappingInstance = new InstanceValue(Multiplicity.ONE, undefined);
-    mappingInstance.values = [
-      PackageableElementExplicitReference.create(mapping),
-    ];
-    const runtimeInstance = new InstanceValue(Multiplicity.ONE, undefined);
-    runtimeInstance.values = [
-      PackageableElementExplicitReference.create(runtimePointer.value),
-    ];
-    _func.parametersValues = [
-      currentExpression,
-      mappingInstance,
-      runtimeInstance,
-    ];
-    lambdaFunc.expressionSequence = [_func];
-    return buildRawLambdaFromLambdaFunction(lambdaFunc, this.graphManagerState);
+    return buildRawLambdaFromLambdaFunction(fromQuery, this.graphManagerState);
   }
 
   getQueryReturnType(): Type {

package/src/stores/data-cube/QueryBuilderDataCubeApplicationEngine.ts

@@ -0,0 +1,109 @@
+/**
+ * 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 {
+  APPLICATION_EVENT,
+  shouldDisplayVirtualAssistantDocumentationEntry,
+  type GenericLegendApplicationStore,
+} from '@finos/legend-application';
+import {
+  DataCubeApplicationEngine,
+  type ActionAlert,
+} from '@finos/legend-data-cube';
+import { LogEvent, type DocumentationEntry } from '@finos/legend-shared';
+
+export class QueryBuilderDataCubeApplicationEngine extends DataCubeApplicationEngine {
+  private readonly application: GenericLegendApplicationStore;
+
+  constructor(application: GenericLegendApplicationStore) {
+    super();
+
+    this.application = application;
+  }
+
+  get documentationUrl(): string | undefined {
+    return this.application.documentationService.url;
+  }
+
+  getDocumentationEntry(key: string) {
+    return this.application.documentationService.getDocEntry(key);
+  }
+
+  openDocumentationEntry(entry: DocumentationEntry) {
+    this.currentDocumentationEntry = entry;
+  }
+
+  shouldDisplayDocumentationEntry(entry: DocumentationEntry) {
+    return shouldDisplayVirtualAssistantDocumentationEntry(entry);
+  }
+
+  openLink(url: string) {
+    this.application.navigationService.navigator.visitAddress(url);
+  }
+
+  setWindowTitle(title: string) {
+    this.application.layoutService.setWindowTitle(title);
+  }
+
+  alertAction(alertInfo: ActionAlert | undefined) {
+    this.currentActionAlert = alertInfo;
+  }
+
+  alertUnhandledError(error: Error) {
+    this.application.alertUnhandledError(error);
+  }
+
+  logDebug(message: string, ...data: unknown[]) {
+    this.application.logService.debug(
+      LogEvent.create(APPLICATION_EVENT.DEBUG),
+      message,
+      ...data,
+    );
+  }
+
+  debugProcess(processName: string, ...data: unknown[]) {
+    this.application.logService.debug(
+      LogEvent.create(APPLICATION_EVENT.DEBUG),
+      `\n------ START DEBUG PROCESS: ${processName} ------\n`,
+      ...data,
+      `\n------- END DEBUG PROCESS: ${processName} -------\n`,
+    );
+  }
+
+  logInfo(event: LogEvent, ...data: unknown[]) {
+    this.application.logService.info(event, ...data);
+  }
+
+  logWarning(event: LogEvent, ...data: unknown[]) {
+    this.application.logService.warn(event, ...data);
+  }
+
+  logError(event: LogEvent, ...data: unknown[]) {
+    this.application.logService.error(event, ...data);
+  }
+
+  logUnhandledError(error: Error) {
+    this.application.logUnhandledError(error);
+  }
+
+  logIllegalStateError(message: string, error?: Error) {
+    this.logError(
+      LogEvent.create(APPLICATION_EVENT.ILLEGAL_APPLICATION_STATE_OCCURRED),
+      message,
+      error,
+    );
+  }
+}

package/src/stores/data-cube/QueryBuilderDataCubeEngine.ts

@@ -0,0 +1,255 @@
+/**
+ * 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 {
+  SUPPORTED_FUNCTIONS,
+  V1_AppliedFunction,
+  V1_Lambda,
+  RawLambda,
+  RelationalExecutionActivities,
+  TDSExecutionResult,
+  V1_deserializeRawValueSpecification,
+  V1_deserializeValueSpecification,
+  V1_RawLambda,
+  V1_serializeValueSpecification,
+  type GraphManagerState,
+  type PureModel,
+  type V1_ValueSpecification,
+} from '@finos/legend-graph';
+import {
+  _elementPtr,
+  _functionName,
+  DataCubeGetBaseQueryResult,
+  DataCubeEngine,
+  type CompletionItem,
+  DataCubeQuerySource,
+  type DataCubeInfrastructureInfo,
+  type RelationType,
+  DataCubeQuery,
+} from '@finos/legend-data-cube';
+import { guaranteeType, LogService } from '@finos/legend-shared';
+
+export class _DataCubeQuery {
+  name: string;
+  query: string;
+  partialQuery: string;
+  source: DataCubeQuerySource;
+
+  constructor(
+    name: string,
+    query: string,
+    partialQuery: string,
+    source: DataCubeQuerySource,
+  ) {
+    this.name = name;
+    this.query = query;
+    this.partialQuery = partialQuery;
+    this.source = source;
+  }
+}
+
+export class QueryBuilderDataCubeQuerySource extends DataCubeQuerySource {}
+export class QueryBuilderDataCubeEngine extends DataCubeEngine {
+  readonly logService = new LogService();
+  readonly graphState: GraphManagerState;
+  readonly selectInitialQuery: RawLambda;
+  readonly mappingPath: string | undefined;
+  readonly runtimePath: string;
+  constructor(
+    selectQuery: RawLambda,
+    mappingPath: string | undefined,
+    runtimePath: string,
+    graphManagerState: GraphManagerState,
+  ) {
+    super();
+    this.graphState = graphManagerState;
+    this.selectInitialQuery = selectQuery;
+    this.mappingPath = mappingPath;
+    this.runtimePath = runtimePath;
+  }
+
+  get sourceLabel(): string {
+    return `Query Builder Report`;
+  }
+  override getBaseQuery(): Promise<DataCubeGetBaseQueryResult> {
+    return this.buildBaseQuery();
+  }
+
+  async buildBaseQuery(): Promise<DataCubeGetBaseQueryResult> {
+    const timestamp = Date.now();
+    let srcFuncExp = V1_deserializeValueSpecification(
+      this.graphState.graphManager.serializeRawValueSpecification(
+        this.selectInitialQuery,
+      ),
+      [],
+    );
+    // We could do a further check here to ensure the experssion is an applied funciton
+    // this is because data cube expects an expression to be able to built further upon the queery
+    if (
+      srcFuncExp instanceof V1_Lambda &&
+      srcFuncExp.body.length === 1 &&
+      srcFuncExp.body[0]
+    ) {
+      srcFuncExp = srcFuncExp.body[0];
+    }
+    const fromFuncExp = new V1_AppliedFunction();
+    fromFuncExp.function = _functionName(SUPPORTED_FUNCTIONS.FROM);
+    fromFuncExp.parameters = [srcFuncExp];
+    if (this.mappingPath) {
+      fromFuncExp.parameters.push(_elementPtr(this.mappingPath));
+    }
+    if (this.runtimePath) {
+      fromFuncExp.parameters.push(_elementPtr(this.runtimePath));
+    }
+    const [relationType, queryString, fromQuerystring] = await Promise.all([
+      this.getRelationalType(this.selectInitialQuery),
+      this.graphState.graphManager.valueSpecificationToPureCode(
+        V1_serializeValueSpecification(srcFuncExp, []),
+      ),
+      this.graphState.graphManager.valueSpecificationToPureCode(
+        V1_serializeValueSpecification(fromFuncExp, []),
+      ),
+    ]);
+    const columns = relationType.columns;
+    const source = new QueryBuilderDataCubeQuerySource();
+    source.columns = columns;
+    source.mapping = this.mappingPath;
+    source.runtime = this.runtimePath;
+    source.query = queryString;
+    const partialQuery = `~[${columns.map((e) => `'${e.name}'`)}]->select()`;
+    const result = new DataCubeQuery(this.sourceLabel, fromQuerystring);
+    result.partialQuery = partialQuery;
+    result.source = source;
+    const baseQueryResult = new DataCubeGetBaseQueryResult();
+    baseQueryResult.timestamp = timestamp;
+    baseQueryResult.query = result;
+    baseQueryResult.partialQuery = await this.parseQuery(partialQuery);
+    baseQueryResult.sourceQuery = srcFuncExp;
+    return baseQueryResult;
+  }
+
+  get graph(): PureModel {
+    return this.graphState.graph;
+  }
+
+  private buildRawLambdaFromValueSpec(query: V1_ValueSpecification): RawLambda {
+    const json = guaranteeType(
+      V1_deserializeRawValueSpecification(
+        V1_serializeValueSpecification(query, []),
+      ),
+      V1_RawLambda,
+    );
+    return new RawLambda(json.parameters, json.body);
+  }
+
+  override getInfrastructureInfo(): Promise<DataCubeInfrastructureInfo> {
+    // we return undefined as we assume the grid license is set at the application level where query builder is built
+    return Promise.resolve({
+      gridClientLicense: undefined,
+    });
+  }
+  override async getQueryTypeahead(
+    code: string,
+    query: V1_ValueSpecification,
+  ): Promise<CompletionItem[]> {
+    const lambda = this.buildRawLambdaFromValueSpec(query);
+    const queryString =
+      await this.graphState.graphManager.lambdaToPureCode(lambda);
+    const offset = queryString.length;
+    const codeBlock = queryString + code;
+    const result = await this.graphState.graphManager.getCodeComplete(
+      codeBlock,
+      this.graph,
+      offset,
+    );
+    return result.completions;
+  }
+
+  override async parseQuery(
+    code: string,
+    returnSourceInformation?: boolean,
+  ): Promise<V1_ValueSpecification> {
+    return V1_deserializeValueSpecification(
+      await this.graphState.graphManager.pureCodeToValueSpecification(
+        code,
+        returnSourceInformation,
+      ),
+      [],
+    );
+  }
+
+  override getQueryRelationType(
+    query: V1_ValueSpecification,
+  ): Promise<RelationType> {
+    const lambda = this.buildRawLambdaFromValueSpec(query);
+    return this.getRelationalType(lambda);
+  }
+
+  async getRelationalType(query: RawLambda): Promise<RelationType> {
+    const realtion_type =
+      await this.graphState.graphManager.getLambdaRelationType(
+        query,
+        this.graph,
+      );
+    return realtion_type;
+  }
+
+  override async getQueryCodeRelationReturnType(
+    code: string,
+    baseQuery: V1_ValueSpecification,
+  ): Promise<RelationType> {
+    const queryString =
+      await this.graphState.graphManager.valueSpecificationToPureCode(
+        V1_serializeValueSpecification(baseQuery, []),
+      );
+    const fullQuery = code + queryString;
+    return this.getRelationalType(
+      await this.graphState.graphManager.pureCodeToLambda(fullQuery),
+    );
+  }
+
+  override async executeQuery(query: V1_Lambda): Promise<{
+    result: TDSExecutionResult;
+    executedQuery: string;
+    executedSQL: string;
+  }> {
+    const lambda = this.buildRawLambdaFromValueSpec(query);
+    const [executionWithMetadata, queryString] = await Promise.all([
+      this.graphState.graphManager.runQuery(
+        lambda,
+        undefined,
+        undefined,
+        this.graph,
+      ),
+      this.graphState.graphManager.lambdaToPureCode(lambda),
+    ]);
+    const expectedTDS = guaranteeType(
+      executionWithMetadata.executionResult,
+      TDSExecutionResult,
+      'Query returned expected to be of tabular data set',
+    );
+    const sql = expectedTDS.activities?.[0];
+    let sqlString = '### NO SQL FOUND';
+    if (sql instanceof RelationalExecutionActivities) {
+      sqlString = sql.sql;
+    }
+    return {
+      result: expectedTDS,
+      executedQuery: queryString,
+      executedSQL: sqlString,
+    };
+  }
+}

package/src/stores/data-cube/QueryBuilderDataCubeEngineHelper.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { type DataCubeEngine } from '@finos/legend-data-cube';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
+import { RuntimePointer } from '@finos/legend-graph';
+import { QueryBuilderDataCubeEngine } from './QueryBuilderDataCubeEngine.js';
+
+export const createDataCubeEngineFromQueryBuilder = (
+  queryBuilderState: QueryBuilderState,
+): DataCubeEngine | undefined => {
+  const runtime =
+    queryBuilderState.executionContextState.runtimeValue instanceof
+    RuntimePointer
+      ? queryBuilderState.executionContextState.runtimeValue.packageableRuntime
+          .value.path
+      : undefined;
+  if (!runtime) {
+    return undefined;
+  }
+  const queryBuilderEngine = new QueryBuilderDataCubeEngine(
+    queryBuilderState.buildQuery(),
+    queryBuilderState.executionContextState.mapping?.path,
+    runtime,
+    queryBuilderState.graphManagerState,
+  );
+  return queryBuilderEngine;
+};

package/src/stores/fetch-structure/QueryBuilderFetchStructureImplementationState.ts

@@ -61,6 +61,7 @@ export abstract class QueryBuilderFetchStructureImplementationState
   abstract get fetchStructureValidationIssues(): string[];
   abstract get allValidationIssues(): string[];
   abstract get fetchLabel(): string;
+  abstract get canBeExportedToCube(): boolean;
 
   abstract onClassChange(_class: Class | undefined): void;
   abstract revealCompilationError(compilationError: CompilationError): boolean;

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts

@@ -309,6 +309,10 @@ export class QueryBuilderGraphFetchTreeState
     return 'Class Properties';
   }
 
+  override get canBeExportedToCube(): boolean {
+    return false;
+  }
+
   get usedExplorerTreePropertyNodeIDs(): string[] {
     if (!this.treeData) {
       return [];

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -205,6 +205,10 @@ export class QueryBuilderTDSState
     return 'Columns';
   }
 
+  override get canBeExportedToCube(): boolean {
+    return true;
+  }
+
   override get TEMPORARY__showPostFetchStructurePanel(): boolean {
     return (
       this.queryBuilderState.filterState.showPanel ||

package/src/stores/filter/QueryBuilderFilterOperator.ts

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

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -246,7 +246,6 @@ export class FilterConditionState implements Hashable {
   constructor(
     filterState: QueryBuilderFilterState,
     propertyExpression: AbstractPropertyExpression,
-    operator?: QueryBuilderFilterOperator,
   ) {
     makeObservable(this, {
       propertyExpressionState: observable,
@@ -272,15 +271,11 @@ export class FilterConditionState implements Hashable {
     );
 
     // operator
-    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;
-    }
+    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.operator.getLabel(filterConditionState),
           )}() 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(): string {
+  getLabel(filterConditionState: FilterConditionState): string {
     return 'contains';
   }
 
@@ -90,7 +90,9 @@ export class QueryBuilderFilterOperator_Contain
       }
       default:
         throw new UnsupportedOperationError(
-          `Can't get default value for filter operator '${this.getLabel()}' when the LHS property is of type '${propertyType.path}'`,
+          `Can't get default value for filter operator '${this.getLabel(
+            filterConditionState,
+          )}' when the LHS property is of type '${propertyType.path}'`,
         );
     }
   }
@@ -126,7 +128,7 @@ export class QueryBuilderFilterOperator_Contain
 }
 
 export class QueryBuilderFilterOperator_NotContain extends QueryBuilderFilterOperator_Contain {
-  override getLabel(): string {
+  override getLabel(filterConditionState: FilterConditionState): 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(): string {
+  getLabel(filterConditionState: FilterConditionState): string {
     return 'ends with';
   }
 
@@ -90,7 +90,9 @@ export class QueryBuilderFilterOperator_EndWith
       }
       default:
         throw new UnsupportedOperationError(
-          `Can't get default value for filter operator '${this.getLabel()}' when the LHS property is of type '${propertyType.path}'`,
+          `Can't get default value for filter operator '${this.getLabel(
+            filterConditionState,
+          )}' when the LHS property is of type '${propertyType.path}'`,
         );
     }
   }
@@ -126,7 +128,7 @@ export class QueryBuilderFilterOperator_EndWith
 }
 
 export class QueryBuilderFilterOperator_NotEndWith extends QueryBuilderFilterOperator_EndWith {
-  override getLabel(): string {
+  override getLabel(filterConditionState: FilterConditionState): 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(): string {
+  getLabel(filterConditionState: FilterConditionState): string {
     return 'is';
   }
 
@@ -143,7 +143,7 @@ export class QueryBuilderFilterOperator_Equal
 }
 
 export class QueryBuilderFilterOperator_NotEqual extends QueryBuilderFilterOperator_Equal {
-  override getLabel(): string {
+  override getLabel(filterConditionState: FilterConditionState): string {
     return `is not`;
   }