@finos/legend-application-query 5.0.0

package/src/stores/filterOperators/QueryBuilderFilterOperator_LessThanEqual.ts

@@ -0,0 +1,164 @@
+/**
+ * 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 {
+  QueryBuilderFilterOperator,
+  type QueryBuilderFilterState,
+  type FilterConditionState,
+} from '../QueryBuilderFilterState.js';
+import {
+  PRIMITIVE_TYPE,
+  type ValueSpecification,
+  type SimpleFunctionExpression,
+  type AbstractPropertyExpression,
+  isSuperType,
+  SUPPORTED_FUNCTIONS,
+  buildPrimitiveInstanceValue,
+} from '@finos/legend-graph';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+import {
+  buildFilterConditionState,
+  buildFilterConditionExpression,
+} from './QueryBuilderFilterOperatorHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
+import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationBuilderHelper.js';
+import { getNonCollectionValueSpecificationType } from '../QueryBuilderOperatorsHelper.js';
+
+export class QueryBuilderFilterOperator_LessThanEqual extends QueryBuilderFilterOperator {
+  getLabel(filterConditionState: FilterConditionState): string {
+    return '<=';
+  }
+
+  isCompatibleWithFilterConditionProperty(
+    filterConditionState: FilterConditionState,
+  ): boolean {
+    const propertyType =
+      filterConditionState.propertyExpressionState.propertyExpression.func
+        .genericType.value.rawType;
+    return (
+      [
+        PRIMITIVE_TYPE.NUMBER,
+        PRIMITIVE_TYPE.INTEGER,
+        PRIMITIVE_TYPE.DECIMAL,
+        PRIMITIVE_TYPE.FLOAT,
+        PRIMITIVE_TYPE.DATE,
+        PRIMITIVE_TYPE.STRICTDATE,
+        PRIMITIVE_TYPE.DATETIME,
+      ] as string[]
+    ).includes(propertyType.path);
+  }
+
+  isCompatibleWithFilterConditionValue(
+    filterConditionState: FilterConditionState,
+  ): boolean {
+    const propertyType =
+      filterConditionState.propertyExpressionState.propertyExpression.func
+        .genericType.value.rawType;
+    const type = filterConditionState.value
+      ? getNonCollectionValueSpecificationType(filterConditionState.value)
+      : undefined;
+    const NUMERIC_PRIMITIVE_TYPES = [
+      PRIMITIVE_TYPE.NUMBER,
+      PRIMITIVE_TYPE.INTEGER,
+      PRIMITIVE_TYPE.DECIMAL,
+      PRIMITIVE_TYPE.FLOAT,
+    ] as string[];
+
+    const DATE_PRIMITIVE_TYPES = [
+      PRIMITIVE_TYPE.DATE,
+      PRIMITIVE_TYPE.DATETIME,
+      PRIMITIVE_TYPE.STRICTDATE,
+      PRIMITIVE_TYPE.LATESTDATE,
+    ] as string[];
+
+    // When changing the return type for LHS, the RHS value should be adjusted accordingly.
+    return (
+      type !== undefined &&
+      // Numeric value is handled loosely because of autoboxing
+      // e.g. LHS (integer) = RHS (float) is acceptable
+      ((NUMERIC_PRIMITIVE_TYPES.includes(type.path) &&
+        NUMERIC_PRIMITIVE_TYPES.includes(propertyType.path)) ||
+        // Date value is handled loosely as well if the LHS is of type DateTime
+        // This is because we would simulate auto-boxing for date by altering the
+        // Pure function used for the operation
+        // e.g. LHS(DateTime) = RHS(Date) -> we use isOnDay() instead of is()
+        DATE_PRIMITIVE_TYPES.includes(type.path) ||
+        type === propertyType ||
+        isSuperType(propertyType, type))
+    );
+  }
+
+  getDefaultFilterConditionValue(
+    filterConditionState: FilterConditionState,
+  ): ValueSpecification | undefined {
+    const propertyType =
+      filterConditionState.propertyExpressionState.propertyExpression.func
+        .genericType.value.rawType;
+    switch (propertyType.path) {
+      case PRIMITIVE_TYPE.NUMBER:
+      case PRIMITIVE_TYPE.DECIMAL:
+      case PRIMITIVE_TYPE.FLOAT:
+      case PRIMITIVE_TYPE.INTEGER:
+      case PRIMITIVE_TYPE.DATE:
+      case PRIMITIVE_TYPE.STRICTDATE:
+      case PRIMITIVE_TYPE.DATETIME: {
+        return buildPrimitiveInstanceValue(
+          filterConditionState.filterState.queryBuilderState.graphManagerState
+            .graph,
+          propertyType.path,
+          generateDefaultValueForPrimitiveType(propertyType.path),
+        );
+      }
+      default:
+        throw new UnsupportedOperationError(
+          `Can't get default value for filter operator '${this.getLabel(
+            filterConditionState,
+          )}' when the LHS property is of type '${propertyType.path}'`,
+        );
+    }
+  }
+
+  buildFilterConditionExpression(
+    filterConditionState: FilterConditionState,
+  ): ValueSpecification {
+    return buildFilterConditionExpression(
+      filterConditionState,
+      filterConditionState.propertyExpressionState.propertyExpression.func
+        .genericType.value.rawType.path === PRIMITIVE_TYPE.DATETIME &&
+        filterConditionState.value?.genericType?.value.rawType.path !==
+          PRIMITIVE_TYPE.DATETIME
+        ? SUPPORTED_FUNCTIONS.IS_ON_OR_BEFORE_DAY
+        : QUERY_BUILDER_SUPPORTED_FUNCTIONS.LESS_THAN_EQUAL,
+    );
+  }
+
+  buildFilterConditionState(
+    filterState: QueryBuilderFilterState,
+    expression: SimpleFunctionExpression,
+  ): FilterConditionState | undefined {
+    return buildFilterConditionState(
+      filterState,
+      expression,
+      (expression.parametersValues[0] as AbstractPropertyExpression).func
+        .genericType.value.rawType.path === PRIMITIVE_TYPE.DATETIME &&
+        expression.parametersValues[1]?.genericType?.value.rawType.path !==
+          PRIMITIVE_TYPE.DATETIME
+        ? SUPPORTED_FUNCTIONS.IS_ON_OR_BEFORE_DAY
+        : QUERY_BUILDER_SUPPORTED_FUNCTIONS.LESS_THAN_EQUAL,
+      this,
+    );
+  }
+}

package/src/stores/filterOperators/QueryBuilderFilterOperator_StartWith.ts

@@ -0,0 +1,134 @@
+/**
+ * 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 {
+  QueryBuilderFilterOperator,
+  type QueryBuilderFilterState,
+  type FilterConditionState,
+} from '../QueryBuilderFilterState.js';
+import {
+  PRIMITIVE_TYPE,
+  type ValueSpecification,
+  type SimpleFunctionExpression,
+  buildPrimitiveInstanceValue,
+} from '@finos/legend-graph';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+import {
+  buildFilterConditionState,
+  buildFilterConditionExpression,
+} from './QueryBuilderFilterOperatorHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
+import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationBuilderHelper.js';
+import {
+  buildNotExpression,
+  getNonCollectionValueSpecificationType,
+  unwrapNotExpression,
+} from '../QueryBuilderOperatorsHelper.js';
+
+export class QueryBuilderFilterOperator_StartWith extends QueryBuilderFilterOperator {
+  getLabel(filterConditionState: FilterConditionState): string {
+    return 'starts with';
+  }
+
+  isCompatibleWithFilterConditionProperty(
+    filterConditionState: FilterConditionState,
+  ): boolean {
+    const propertyType =
+      filterConditionState.propertyExpressionState.propertyExpression.func
+        .genericType.value.rawType;
+    return PRIMITIVE_TYPE.STRING === propertyType.path;
+  }
+
+  isCompatibleWithFilterConditionValue(
+    filterConditionState: FilterConditionState,
+  ): boolean {
+    const type = filterConditionState.value
+      ? getNonCollectionValueSpecificationType(filterConditionState.value)
+      : undefined;
+    return PRIMITIVE_TYPE.STRING === type?.path;
+  }
+
+  getDefaultFilterConditionValue(
+    filterConditionState: FilterConditionState,
+  ): ValueSpecification | undefined {
+    const propertyType =
+      filterConditionState.propertyExpressionState.propertyExpression.func
+        .genericType.value.rawType;
+    switch (propertyType.path) {
+      case PRIMITIVE_TYPE.STRING: {
+        return buildPrimitiveInstanceValue(
+          filterConditionState.filterState.queryBuilderState.graphManagerState
+            .graph,
+          propertyType.path,
+          generateDefaultValueForPrimitiveType(propertyType.path),
+        );
+      }
+      default:
+        throw new UnsupportedOperationError(
+          `Can't get default value for filter operator '${this.getLabel(
+            filterConditionState,
+          )}' when the LHS property is of type '${propertyType.path}'`,
+        );
+    }
+  }
+
+  buildFilterConditionExpression(
+    filterConditionState: FilterConditionState,
+  ): ValueSpecification {
+    return buildFilterConditionExpression(
+      filterConditionState,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.STARTS_WITH,
+    );
+  }
+
+  buildFilterConditionState(
+    filterState: QueryBuilderFilterState,
+    expression: SimpleFunctionExpression,
+  ): FilterConditionState | undefined {
+    return buildFilterConditionState(
+      filterState,
+      expression,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.STARTS_WITH,
+      this,
+    );
+  }
+}
+
+export class QueryBuilderFilterOperator_NotStartWith extends QueryBuilderFilterOperator_StartWith {
+  override getLabel(filterConditionState: FilterConditionState): string {
+    return `doesn't start with`;
+  }
+
+  override buildFilterConditionExpression(
+    filterConditionState: FilterConditionState,
+  ): ValueSpecification {
+    return buildNotExpression(
+      filterConditionState.filterState.queryBuilderState.graphManagerState
+        .graph,
+      super.buildFilterConditionExpression(filterConditionState),
+    );
+  }
+
+  override buildFilterConditionState(
+    filterState: QueryBuilderFilterState,
+    expression: SimpleFunctionExpression,
+  ): FilterConditionState | undefined {
+    const innerExpression = unwrapNotExpression(expression);
+    return innerExpression
+      ? super.buildFilterConditionState(filterState, innerExpression)
+      : undefined;
+  }
+}

package/src/stores/postFilterOperators/QueryBuilderPostFilterOperatorHelper.ts

@@ -0,0 +1,129 @@
+/**
+ * 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 Multiplicity,
+  type FunctionExpression,
+  AbstractPropertyExpression,
+  extractElementNameFromPath,
+  GenericType,
+  GenericTypeExplicitReference,
+  PrimitiveInstanceValue,
+  PRIMITIVE_TYPE,
+  SimpleFunctionExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  VariableExpression,
+  getAllClassDerivedProperties,
+} from '@finos/legend-graph';
+import {
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { TDS_ROW } from '../../QueryBuilder_Const.js';
+import { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import type { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
+import {
+  type PostFilterConditionState,
+  type TDS_COLUMN_GETTER,
+  getTDSColumnDerivedProperyFromType,
+} from '../QueryBuilderPostFilterState.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../QueryBuilderProjectionState.js';
+
+export const getColumnMultiplicity = (
+  columnState:
+    | QueryBuilderProjectionColumnState
+    | QueryBuilderAggregateColumnState,
+): Multiplicity => {
+  if (columnState instanceof QueryBuilderAggregateColumnState) {
+    return columnState.aggregationState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+  } else if (columnState instanceof QueryBuilderSimpleProjectionColumnState) {
+    return columnState.propertyExpressionState.propertyExpression.func
+      .multiplicity;
+  }
+  throw new UnsupportedOperationError(
+    `Can't get multiplicity for column`,
+    columnState,
+  );
+};
+
+export const buildPostFilterConditionExpression = (
+  filterConditionState: PostFilterConditionState,
+  operator: QueryBuilderPostFilterOperator,
+  /**
+   * If provided, this will be used to construct the simple
+   * function expression for the function with the specified
+   * name. If not provided, we will fall back to use the TDS column getter function expression.
+   * This is the case because with TDS, we are provided some filter-like operators, e.g. IS_NULL, IS_NOT_NULL, etc.
+   */
+  operatorFunctionFullPath: string | undefined,
+): FunctionExpression => {
+  // primitives
+  const graph =
+    filterConditionState.postFilterState.queryBuilderState.graphManagerState
+      .graph;
+  const multiplicityOne = graph.getTypicalMultiplicity(
+    TYPICAL_MULTIPLICITY_TYPE.ONE,
+  );
+  const typeString = graph.getPrimitiveType(PRIMITIVE_TYPE.STRING);
+  // property expression
+  const colState = filterConditionState.columnState;
+  const tdsPropertyExpression = new AbstractPropertyExpression(
+    '',
+    multiplicityOne,
+  );
+  let tdsDerivedPropertyName: TDS_COLUMN_GETTER;
+  const correspondingTdsDerivedProperty = operator.getTdsColumnGetter();
+  if (correspondingTdsDerivedProperty) {
+    tdsDerivedPropertyName = correspondingTdsDerivedProperty;
+  } else {
+    const type = guaranteeNonNullable(colState.getReturnType());
+    tdsDerivedPropertyName = getTDSColumnDerivedProperyFromType(type);
+  }
+  tdsPropertyExpression.func = guaranteeNonNullable(
+    getAllClassDerivedProperties(graph.getClass(TDS_ROW)).find(
+      (p) => p.name === tdsDerivedPropertyName,
+    ),
+  );
+  const variableName = new VariableExpression(
+    filterConditionState.postFilterState.lambdaParameterName,
+    multiplicityOne,
+  );
+  const colInstanceValue = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(new GenericType(typeString)),
+    multiplicityOne,
+  );
+  colInstanceValue.values = [colState.columnName];
+  tdsPropertyExpression.parametersValues = [variableName, colInstanceValue];
+
+  if (operatorFunctionFullPath) {
+    const expression = new SimpleFunctionExpression(
+      extractElementNameFromPath(operatorFunctionFullPath),
+      multiplicityOne,
+    );
+    expression.parametersValues.push(tdsPropertyExpression);
+    if (filterConditionState.value) {
+      expression.parametersValues.push(filterConditionState.value);
+    }
+    return expression;
+  } else {
+    return tdsPropertyExpression;
+  }
+};

package/src/stores/postFilterOperators/QueryBuilderPostFilterOperator_Contain.ts

@@ -0,0 +1,140 @@
+/**
+ * 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 SimpleFunctionExpression,
+  type Type,
+  type ValueSpecification,
+  type FunctionExpression,
+  PRIMITIVE_TYPE,
+  buildPrimitiveInstanceValue,
+} from '@finos/legend-graph';
+import {
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
+import {
+  buildNotExpression,
+  getNonCollectionValueSpecificationType,
+  unwrapNotExpression,
+} from '../QueryBuilderOperatorsHelper.js';
+import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import type {
+  PostFilterConditionState,
+  QueryBuilderPostFilterState,
+} from '../QueryBuilderPostFilterState.js';
+import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationBuilderHelper.js';
+import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
+
+export class QueryBuilderPostFilterOperator_Contain extends QueryBuilderPostFilterOperator {
+  getLabel(): string {
+    return 'contains';
+  }
+
+  isCompatibleWithType(type: Type): boolean {
+    if (type.path === PRIMITIVE_TYPE.STRING) {
+      return true;
+    }
+    return false;
+  }
+
+  isCompatibleWithConditionValue(
+    postFilterConditionState: PostFilterConditionState,
+  ): boolean {
+    const type = postFilterConditionState.value
+      ? getNonCollectionValueSpecificationType(postFilterConditionState.value)
+      : undefined;
+    return PRIMITIVE_TYPE.STRING === type?.path;
+  }
+
+  getDefaultFilterConditionValue(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification {
+    const propertyType = guaranteeNonNullable(
+      postFilterConditionState.columnState.getReturnType(),
+    );
+    switch (propertyType.path) {
+      case PRIMITIVE_TYPE.STRING: {
+        return buildPrimitiveInstanceValue(
+          postFilterConditionState.postFilterState.queryBuilderState
+            .graphManagerState.graph,
+          propertyType.path,
+          generateDefaultValueForPrimitiveType(propertyType.path),
+        );
+      }
+      default:
+        throw new UnsupportedOperationError(
+          `Can't get default value for post-filter operator '${this.getLabel()}' when the LHS property is of type '${
+            propertyType.path
+          }'`,
+        );
+    }
+  }
+
+  buildPostFilterConditionExpression(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification | undefined {
+    return buildPostFilterConditionExpression(
+      postFilterConditionState,
+      this,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.CONTAINS,
+    );
+  }
+
+  buildPostFilterConditionState(
+    postFilterState: QueryBuilderPostFilterState,
+    expression: FunctionExpression,
+  ): PostFilterConditionState | undefined {
+    return buildPostFilterConditionState(
+      postFilterState,
+      expression,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.CONTAINS,
+      this,
+    );
+  }
+}
+
+export class QueryBuilderPostFilterOperator_NotContain extends QueryBuilderPostFilterOperator_Contain {
+  override getLabel(): string {
+    return `doesn't contain`;
+  }
+  override buildPostFilterConditionExpression(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification | undefined {
+    const expression = super.buildPostFilterConditionExpression(
+      postFilterConditionState,
+    );
+    return expression
+      ? buildNotExpression(
+          postFilterConditionState.postFilterState.queryBuilderState
+            .graphManagerState.graph,
+          expression,
+        )
+      : undefined;
+  }
+
+  override buildPostFilterConditionState(
+    postFilterState: QueryBuilderPostFilterState,
+    expression: SimpleFunctionExpression,
+  ): PostFilterConditionState | undefined {
+    const innerExpression = unwrapNotExpression(expression);
+    return innerExpression
+      ? super.buildPostFilterConditionState(postFilterState, innerExpression)
+      : undefined;
+  }
+}

package/src/stores/postFilterOperators/QueryBuilderPostFilterOperator_EndWith.ts

@@ -0,0 +1,135 @@
+/**
+ * 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 SimpleFunctionExpression,
+  type Type,
+  type ValueSpecification,
+  type FunctionExpression,
+  PRIMITIVE_TYPE,
+  buildPrimitiveInstanceValue,
+} from '@finos/legend-graph';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
+import {
+  buildNotExpression,
+  getNonCollectionValueSpecificationType,
+  unwrapNotExpression,
+} from '../QueryBuilderOperatorsHelper.js';
+import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import type {
+  PostFilterConditionState,
+  QueryBuilderPostFilterState,
+} from '../QueryBuilderPostFilterState.js';
+import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationBuilderHelper.js';
+import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
+
+export class QueryBuilderPostFilterOperator_EndWith extends QueryBuilderPostFilterOperator {
+  getLabel(): string {
+    return 'ends with';
+  }
+
+  isCompatibleWithType(type: Type): boolean {
+    if (type.path === PRIMITIVE_TYPE.STRING) {
+      return true;
+    }
+    return false;
+  }
+
+  isCompatibleWithConditionValue(
+    postFilterConditionState: PostFilterConditionState,
+  ): boolean {
+    const type = postFilterConditionState.value
+      ? getNonCollectionValueSpecificationType(postFilterConditionState.value)
+      : undefined;
+    return PRIMITIVE_TYPE.STRING === type?.path;
+  }
+
+  getDefaultFilterConditionValue(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification {
+    const propertyType = postFilterConditionState.columnState.getReturnType();
+    switch (propertyType?.path) {
+      case PRIMITIVE_TYPE.STRING: {
+        return buildPrimitiveInstanceValue(
+          postFilterConditionState.postFilterState.queryBuilderState
+            .graphManagerState.graph,
+          propertyType.path,
+          generateDefaultValueForPrimitiveType(propertyType.path),
+        );
+      }
+      default:
+        throw new UnsupportedOperationError(
+          `Can't get default value for post-filter operator '${this.getLabel()}' when the LHS property is of type '${
+            propertyType?.path
+          }'`,
+        );
+    }
+  }
+
+  buildPostFilterConditionExpression(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification | undefined {
+    return buildPostFilterConditionExpression(
+      postFilterConditionState,
+      this,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.ENDS_WITH,
+    );
+  }
+
+  buildPostFilterConditionState(
+    postFilterState: QueryBuilderPostFilterState,
+    expression: FunctionExpression,
+  ): PostFilterConditionState | undefined {
+    return buildPostFilterConditionState(
+      postFilterState,
+      expression,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.ENDS_WITH,
+      this,
+    );
+  }
+}
+
+export class QueryBuilderPostFilterOperator_NotEndWith extends QueryBuilderPostFilterOperator_EndWith {
+  override getLabel(): string {
+    return `doesn't end with`;
+  }
+
+  override buildPostFilterConditionExpression(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification | undefined {
+    const expression = super.buildPostFilterConditionExpression(
+      postFilterConditionState,
+    );
+    return expression
+      ? buildNotExpression(
+          postFilterConditionState.postFilterState.queryBuilderState
+            .graphManagerState.graph,
+          expression,
+        )
+      : undefined;
+  }
+
+  override buildPostFilterConditionState(
+    postFilterState: QueryBuilderPostFilterState,
+    expression: SimpleFunctionExpression,
+  ): PostFilterConditionState | undefined {
+    const innerExpression = unwrapNotExpression(expression);
+    return innerExpression
+      ? super.buildPostFilterConditionState(postFilterState, innerExpression)
+      : undefined;
+  }
+}