@finos/legend-application-query 6.0.0 → 7.0.1

package/src/stores/query-builder/fetch-structure/projection/post-filter/QueryBuilderPostFilterStateBuilder.ts

@@ -1,297 +0,0 @@
-/**
- * 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 {
-  LambdaFunctionInstanceValue,
-  AbstractPropertyExpression,
-  extractElementNameFromPath,
-  PrimitiveInstanceValue,
-  matchFunctionName,
-  VariableExpression,
-  FunctionExpression,
-  type SimpleFunctionExpression,
-} from '@finos/legend-graph';
-import {
-  assertTrue,
-  assertType,
-  guaranteeIsString,
-  guaranteeNonNullable,
-  guaranteeType,
-  UnsupportedOperationError,
-} from '@finos/legend-shared';
-import type { QueryBuilderAggregateColumnState } from '../aggregation/QueryBuilderAggregationState.js';
-import type { QueryBuilderPostFilterOperator } from './QueryBuilderPostFilterOperator.js';
-import {
-  type QueryBuilderPostFilterState,
-  getTDSColumnDerivedProperyFromType,
-  PostFilterConditionState,
-  QueryBuilderPostFilterTreeConditionNodeData,
-  QueryBuilderPostFilterTreeGroupNodeData,
-  TDS_COLUMN_GETTER,
-  getTypeFromDerivedProperty,
-} from './QueryBuilderPostFilterState.js';
-import {
-  type QueryBuilderProjectionColumnState,
-  QueryBuilderDerivationProjectionColumnState,
-} from '../QueryBuilderProjectionColumnState.js';
-import { toGroupOperation } from '../../../QueryBuilderGroupOperationHelper.js';
-import { QueryBuilderProjectionState } from '../QueryBuilderProjectionState.js';
-import type { QueryBuilderState } from '../../../QueryBuilderState.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graphManager/QueryBuilderSupportedFunctions.js';
-
-const findProjectionColumnState = (
-  propertyExpression: AbstractPropertyExpression,
-  postFilterState: QueryBuilderPostFilterState,
-): QueryBuilderProjectionColumnState | QueryBuilderAggregateColumnState => {
-  const projectionState = postFilterState.projectionState;
-  const properyExpressionName = propertyExpression.func.name;
-  assertTrue(
-    Object.values(TDS_COLUMN_GETTER).includes(
-      properyExpressionName as TDS_COLUMN_GETTER,
-    ),
-    `Can't process TDS column expression: TDS column property '${properyExpressionName}' not supported. Supported types are ${Object.values(
-      TDS_COLUMN_GETTER,
-    ).join(',')}`,
-  );
-  const tdsColumnGetter = properyExpressionName as TDS_COLUMN_GETTER;
-  const columnNameExpression = propertyExpression.parametersValues[1];
-  const columnName = guaranteeIsString(
-    guaranteeType(
-      columnNameExpression,
-      PrimitiveInstanceValue,
-      'Can`t process TDS column expression: Column should be a primitive instance value',
-    ).values[0],
-    'Can`t process TDS column expression: Column should be a string primitive instance value',
-  );
-  const columnStates = [
-    ...projectionState.aggregationState.columns,
-    ...projectionState.columns,
-  ];
-  const columnState = guaranteeNonNullable(
-    columnStates.find((c) => c.columnName === columnName),
-  );
-  if (
-    tdsColumnGetter !== TDS_COLUMN_GETTER.IS_NULL &&
-    tdsColumnGetter !== TDS_COLUMN_GETTER.IS_NOT_NULL
-  ) {
-    if (columnState instanceof QueryBuilderDerivationProjectionColumnState) {
-      const type = getTypeFromDerivedProperty(
-        tdsColumnGetter,
-        postFilterState.projectionState.queryBuilderState.graphManagerState
-          .graph,
-      );
-      if (type) {
-        columnState.setReturnType(type);
-      }
-      return columnState;
-    }
-    const columnType = guaranteeNonNullable(columnState.getReturnType());
-    assertTrue(
-      (getTDSColumnDerivedProperyFromType(columnType) as string) ===
-        tdsColumnGetter,
-      `Can't process TDS column expression: expected column type ${getTDSColumnDerivedProperyFromType(
-        columnType,
-      )} (got ${tdsColumnGetter})`,
-    );
-  }
-  return columnState;
-};
-
-export const buildPostFilterConditionState = (
-  postFilterState: QueryBuilderPostFilterState,
-  expression: FunctionExpression,
-  operatorFunctionFullPath: string | undefined,
-  operator: QueryBuilderPostFilterOperator,
-): PostFilterConditionState | undefined => {
-  let postConditionState: PostFilterConditionState | undefined;
-  const tdsColumnGetter = operator.getTdsColumnGetter();
-  if (
-    tdsColumnGetter &&
-    expression instanceof AbstractPropertyExpression &&
-    expression.func.name === tdsColumnGetter
-  ) {
-    const columnState = findProjectionColumnState(expression, postFilterState);
-    postConditionState = new PostFilterConditionState(
-      postFilterState,
-      columnState,
-      undefined,
-      operator,
-    );
-    return postConditionState;
-  } else if (
-    operatorFunctionFullPath &&
-    matchFunctionName(expression.functionName, operatorFunctionFullPath)
-  ) {
-    assertTrue(
-      expression.parametersValues.length === 2,
-      `Can't process ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() expression: ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() expects '1 argument'`,
-    );
-
-    // get projection column
-    const tdsColumnPropertyExpression = guaranteeType(
-      expression.parametersValues[0],
-      AbstractPropertyExpression,
-      `Can't process ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() expression: expects property expression in lambda body`,
-    );
-    const columnState = findProjectionColumnState(
-      tdsColumnPropertyExpression,
-      postFilterState,
-    );
-
-    // get operation value specification
-    const value = expression.parametersValues[1];
-    // create state
-    postConditionState = new PostFilterConditionState(
-      postFilterState,
-      columnState,
-      value,
-      operator,
-    );
-
-    //post checks
-    assertTrue(
-      operator.isCompatibleWithPostFilterColumn(postConditionState),
-      `Can't process ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() expression: property is not compatible with post-filter operator`,
-    );
-    assertTrue(
-      operator.isCompatibleWithConditionValue(postConditionState),
-      `Operator '${operator.getLabel()}' not compatible with value specification ${value?.toString()}`,
-    );
-  }
-  return postConditionState;
-};
-
-const processPostFilterTree = (
-  expression: FunctionExpression,
-  postFilterState: QueryBuilderPostFilterState,
-  parentPostFilterNodeId: string | undefined,
-): void => {
-  const parentNode = parentPostFilterNodeId
-    ? postFilterState.getNode(parentPostFilterNodeId)
-    : undefined;
-  if (
-    matchFunctionName(expression.functionName, [
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR,
-    ])
-  ) {
-    const groupNode = new QueryBuilderPostFilterTreeGroupNodeData(
-      parentPostFilterNodeId,
-      toGroupOperation(expression.functionName),
-    );
-    postFilterState.nodes.set(groupNode.id, groupNode);
-    expression.parametersValues.forEach((postFilterExpression) =>
-      processPostFilterTree(
-        guaranteeType(
-          postFilterExpression,
-          FunctionExpression,
-          `Can't process post-filter group expression: each child expression must be a function expression`,
-        ),
-        postFilterState,
-        groupNode.id,
-      ),
-    );
-    postFilterState.addNodeFromNode(groupNode, parentNode);
-  } else {
-    for (const operator of postFilterState.operators) {
-      // NOTE: this allow plugin author to either return `undefined`
-      const postFilterConditionState = operator.buildPostFilterConditionState(
-        postFilterState,
-        expression,
-      );
-      if (postFilterConditionState) {
-        postFilterState.addNodeFromNode(
-          new QueryBuilderPostFilterTreeConditionNodeData(
-            undefined,
-            postFilterConditionState,
-          ),
-          parentNode,
-        );
-        return;
-      }
-    }
-    throw new UnsupportedOperationError(
-      `Can't process post-filter expression: no compatible post-filter operator processer available from plugins`,
-    );
-  }
-};
-
-export const processTDSPostFilterExpression = (
-  expression: SimpleFunctionExpression,
-  queryBuilderState: QueryBuilderState,
-): void => {
-  if (
-    queryBuilderState.fetchStructureState.implementation instanceof
-    QueryBuilderProjectionState
-  ) {
-    const projectionState =
-      queryBuilderState.fetchStructureState.implementation;
-    const postFilterState = projectionState.postFilterState;
-    const fetchStructureState = projectionState.fetchStructureState;
-    const postFilterLambda = expression.parametersValues[1];
-    assertType(
-      postFilterLambda,
-      LambdaFunctionInstanceValue,
-      `Can't process post-filter expression: expects argument #1 to be a lambda function`,
-    );
-
-    assertType(
-      fetchStructureState.implementation,
-      QueryBuilderProjectionState,
-      `Can't process post-filter lambda: post-filter lambda must use projection fetch structure`,
-    );
-    assertTrue(
-      Boolean(projectionState.columns.length),
-      `Can't process post-filter lambda: post-filter lambda must have at least one projection column `,
-    );
-    const lambdaFunc = guaranteeNonNullable(
-      postFilterLambda.values[0],
-      `Can't process post-filter lambda: post-filter lambda function is missing`,
-    );
-    assertTrue(
-      lambdaFunc.expressionSequence.length === 1,
-      `Can't process post-filter lambda: only support post-filter lambda body with 1 expression`,
-    );
-    const rootExpression = guaranteeType(
-      lambdaFunc.expressionSequence[0],
-      FunctionExpression,
-      `Can't process post-filter lambda: only support post-filter lambda body of type 'FunctionExpression'`,
-    );
-    assertTrue(
-      lambdaFunc.functionType.parameters.length === 1,
-      `Can't process post-filter lambda: only support post-filter lambda with 1 parameter`,
-    );
-    postFilterState.setLambdaParameterName(
-      guaranteeType(
-        lambdaFunc.functionType.parameters[0],
-        VariableExpression,
-        `Can't process post-filter lambda: only support filter() lambda with 1 parameter of type 'VariableExpression'`,
-      ).name,
-    );
-    processPostFilterTree(rootExpression, postFilterState, undefined);
-
-    projectionState.setShowPostFilterPanel(true);
-    postFilterState.simplifyTree();
-  }
-};

package/src/stores/query-builder/fetch-structure/projection/post-filter/QueryBuilderPostFilterValueSpecificationBuilder.ts

@@ -1,121 +0,0 @@
-/**
- * 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 {
-  extractElementNameFromPath,
-  SimpleFunctionExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
-  type LambdaFunction,
-  type ValueSpecification,
-} from '@finos/legend-graph';
-import { guaranteeNonNullable, isNonNullable } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graphManager/QueryBuilderSupportedFunctions.js';
-import { fromGroupOperation } from '../../../QueryBuilderGroupOperationHelper.js';
-import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
-import {
-  QueryBuilderPostFilterTreeConditionNodeData,
-  QueryBuilderPostFilterTreeGroupNodeData,
-  type QueryBuilderPostFilterTreeNodeData,
-  type QueryBuilderPostFilterState,
-} from './QueryBuilderPostFilterState.js';
-
-const buildPostFilterExpression = (
-  filterState: QueryBuilderPostFilterState,
-  node: QueryBuilderPostFilterTreeNodeData,
-): ValueSpecification | undefined => {
-  if (node instanceof QueryBuilderPostFilterTreeConditionNodeData) {
-    return node.condition.operator.buildPostFilterConditionExpression(
-      node.condition,
-    );
-  } else if (node instanceof QueryBuilderPostFilterTreeGroupNodeData) {
-    const multiplicityOne =
-      filterState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
-        TYPICAL_MULTIPLICITY_TYPE.ONE,
-      );
-    const func = new SimpleFunctionExpression(
-      extractElementNameFromPath(fromGroupOperation(node.groupOperation)),
-      multiplicityOne,
-    );
-    const clauses = node.childrenIds
-      .map((e) => filterState.nodes.get(e))
-      .filter(isNonNullable)
-      .map((e) => buildPostFilterExpression(filterState, e))
-      .filter(isNonNullable);
-    /**
-     * NOTE: Due to a limitation (or perhaps design decision) in the engine, group operations
-     * like and/or do not take more than 2 parameters, as such, if we have more than 2, we need
-     * to create a chain of this operation to accomondate.
-     *
-     * This means that in the read direction, we might need to flatten the chains down to group with
-     * multiple clauses. This means user's intended grouping will not be kept.
-     */
-    if (clauses.length > 2) {
-      const firstClause = clauses[0] as ValueSpecification;
-      let currentClause: ValueSpecification = clauses[
-        clauses.length - 1
-      ] as ValueSpecification;
-      for (let i = clauses.length - 2; i > 0; --i) {
-        const clause1 = clauses[i] as ValueSpecification;
-        const clause2 = currentClause;
-        const groupClause = new SimpleFunctionExpression(
-          extractElementNameFromPath(fromGroupOperation(node.groupOperation)),
-          multiplicityOne,
-        );
-        groupClause.parametersValues = [clause1, clause2];
-        currentClause = groupClause;
-      }
-      func.parametersValues = [firstClause, currentClause];
-    } else {
-      func.parametersValues = clauses;
-    }
-    return func.parametersValues.length ? func : undefined;
-  }
-  return undefined;
-};
-
-export const appendPostFilter = (
-  postFilterState: QueryBuilderPostFilterState,
-  lambda: LambdaFunction,
-): LambdaFunction => {
-  const postFilterConditionExpressions = postFilterState.rootIds
-    .map((e) => guaranteeNonNullable(postFilterState.nodes.get(e)))
-    .map((e) => buildPostFilterExpression(postFilterState, e))
-    .filter(isNonNullable);
-  if (
-    !postFilterConditionExpressions.length ||
-    lambda.expressionSequence.length !== 1
-  ) {
-    return lambda;
-  }
-  const multiplicityOne =
-    postFilterState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
-      TYPICAL_MULTIPLICITY_TYPE.ONE,
-    );
-  const filterLambda = buildGenericLambdaFunctionInstanceValue(
-    postFilterState.lambdaParameterName,
-    postFilterConditionExpressions,
-    postFilterState.projectionState.queryBuilderState.graphManagerState.graph,
-  );
-  // main filter expression
-  const filterExpression = new SimpleFunctionExpression(
-    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER),
-    multiplicityOne,
-  );
-  const currentExpression = guaranteeNonNullable(lambda.expressionSequence[0]);
-  filterExpression.parametersValues = [currentExpression, filterLambda];
-  lambda.expressionSequence[0] = filterExpression;
-  return lambda;
-};

package/src/stores/query-builder/fetch-structure/projection/post-filter/operators/QueryBuilderPostFilterOperatorHelper.ts

@@ -1,129 +0,0 @@
-/**
- * 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,
-  CORE_PURE_PATH,
-} from '@finos/legend-graph';
-import {
-  guaranteeNonNullable,
-  UnsupportedOperationError,
-} from '@finos/legend-shared';
-import { QueryBuilderAggregateColumnState } from '../../aggregation/QueryBuilderAggregationState.js';
-import type { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
-import {
-  type PostFilterConditionState,
-  type TDS_COLUMN_GETTER,
-  getTDSColumnDerivedProperyFromType,
-} from '../QueryBuilderPostFilterState.js';
-import {
-  type QueryBuilderProjectionColumnState,
-  QueryBuilderSimpleProjectionColumnState,
-} from '../../QueryBuilderProjectionColumnState.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.projectionState.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(CORE_PURE_PATH.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/query-builder/fetch-structure/projection/post-filter/operators/QueryBuilderPostFilterOperator_Contain.ts

@@ -1,140 +0,0 @@
-/**
- * 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 { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterStateBuilder.js';
-import type {
-  PostFilterConditionState,
-  QueryBuilderPostFilterState,
-} from '../QueryBuilderPostFilterState.js';
-import {
-  buildNotExpression,
-  generateDefaultValueForPrimitiveType,
-  getNonCollectionValueSpecificationType,
-  unwrapNotExpression,
-} from '../../../../QueryBuilderValueSpecificationHelper.js';
-import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../../graphManager/QueryBuilderSupportedFunctions.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.projectionState
-            .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.projectionState
-            .queryBuilderState.graphManagerState.graph,
-          expression,
-        )
-      : undefined;
-  }
-
-  override buildPostFilterConditionState(
-    postFilterState: QueryBuilderPostFilterState,
-    expression: SimpleFunctionExpression,
-  ): PostFilterConditionState | undefined {
-    const innerExpression = unwrapNotExpression(expression);
-    return innerExpression
-      ? super.buildPostFilterConditionState(postFilterState, innerExpression)
-      : undefined;
-  }
-}