@finos/legend-application-query 5.1.0 → 5.2.3

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperator_GreaterThanEqual.ts

@@ -21,8 +21,8 @@ import {
   PRIMITIVE_TYPE,
   SUPPORTED_FUNCTIONS,
 } from '@finos/legend-graph';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../QueryBuilder_Const.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterValueSpecificationProcessor.js';
 import type {
   PostFilterConditionState,
   QueryBuilderPostFilterState,

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperator_In.ts

@@ -28,19 +28,19 @@ import {
   TYPICAL_MULTIPLICITY_TYPE,
 } from '@finos/legend-graph';
 import { guaranteeNonNullable } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
-import {
-  buildNotExpression,
-  getCollectionValueSpecificationType,
-  unwrapNotExpression,
-} from '../QueryBuilderOperatorsHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../QueryBuilder_Const.js';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterValueSpecificationProcessor.js';
 import type {
   PostFilterConditionState,
   QueryBuilderPostFilterState,
 } from '../QueryBuilderPostFilterState.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
+import {
+  buildNotExpression,
+  getCollectionValueSpecificationType,
+  unwrapNotExpression,
+} from '../../../../QueryBuilderValueSpecificationHelper.js';
 
 export class QueryBuilderPostFilterOperator_In extends QueryBuilderPostFilterOperator {
   getLabel(): string {
@@ -75,8 +75,8 @@ export class QueryBuilderPostFilterOperator_In extends QueryBuilderPostFilterOpe
         return true;
       }
       const collectionType = getCollectionValueSpecificationType(
-        postFilterConditionState.postFilterState.queryBuilderState
-          .graphManagerState.graph,
+        postFilterConditionState.postFilterState.projectionState
+          .queryBuilderState.graphManagerState.graph,
         valueSpec.values,
       );
       if (!collectionType) {
@@ -116,7 +116,7 @@ export class QueryBuilderPostFilterOperator_In extends QueryBuilderPostFilterOpe
     postFilterConditionState: PostFilterConditionState,
   ): ValueSpecification {
     const multiplicityOne =
-      postFilterConditionState.postFilterState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      postFilterConditionState.postFilterState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
         TYPICAL_MULTIPLICITY_TYPE.ONE,
       );
     const propertyType = guaranteeNonNullable(
@@ -164,8 +164,8 @@ export class QueryBuilderPostFilterOperator_NotIn extends QueryBuilderPostFilter
     );
     return expression
       ? buildNotExpression(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           expression,
         )
       : undefined;

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperator_IsEmpty.ts

@@ -21,16 +21,16 @@ import {
   Enumeration,
   PRIMITIVE_TYPE,
 } from '@finos/legend-graph';
-import { isPropertyExpressionChainOptional } from '../QueryBuilderOperatorsHelper.js';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterValueSpecificationProcessor.js';
 import {
   type PostFilterConditionState,
   type QueryBuilderPostFilterState,
   TDS_COLUMN_GETTER,
 } from '../QueryBuilderPostFilterState.js';
-import { QueryBuilderSimpleProjectionColumnState } from '../QueryBuilderProjectionState.js';
+import { QueryBuilderSimpleProjectionColumnState } from '../../QueryBuilderProjectionColumnState.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
+import { isPropertyExpressionChainOptional } from '../../../../QueryBuilderValueSpecificationHelper.js';
 
 export class QueryBuilderPostFilterOperator_IsEmpty extends QueryBuilderPostFilterOperator {
   getLabel(): string {

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperator_LessThan.ts

@@ -27,18 +27,18 @@ import {
   guaranteeNonNullable,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
-import {
-  getNonCollectionValueSpecificationType,
-  isTypeCompatibleWithConditionValueType,
-} from '../QueryBuilderOperatorsHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../QueryBuilder_Const.js';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterValueSpecificationProcessor.js';
 import type {
   PostFilterConditionState,
   QueryBuilderPostFilterState,
 } from '../QueryBuilderPostFilterState.js';
-import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationBuilderHelper.js';
+import {
+  generateDefaultValueForPrimitiveType,
+  getNonCollectionValueSpecificationType,
+  isTypeCompatibleForAssignment,
+} from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
 
 export class QueryBuilderPostFilterOperator_LessThan extends QueryBuilderPostFilterOperator {
@@ -63,7 +63,7 @@ export class QueryBuilderPostFilterOperator_LessThan extends QueryBuilderPostFil
   isCompatibleWithConditionValue(
     postFilterConditionState: PostFilterConditionState,
   ): boolean {
-    return isTypeCompatibleWithConditionValueType(
+    return isTypeCompatibleForAssignment(
       postFilterConditionState.value
         ? getNonCollectionValueSpecificationType(postFilterConditionState.value)
         : undefined,
@@ -82,16 +82,23 @@ export class QueryBuilderPostFilterOperator_LessThan extends QueryBuilderPostFil
       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(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           propertyType.path,
           generateDefaultValueForPrimitiveType(propertyType.path),
         );
       }
+      case PRIMITIVE_TYPE.DATE: {
+        return buildPrimitiveInstanceValue(
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
+          PRIMITIVE_TYPE.STRICTDATE,
+          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 '${

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperator_LessThanEqual.ts

@@ -21,8 +21,8 @@ import {
   PRIMITIVE_TYPE,
   SUPPORTED_FUNCTIONS,
 } from '@finos/legend-graph';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../QueryBuilder_Const.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterValueSpecificationProcessor.js';
 import type {
   PostFilterConditionState,
   QueryBuilderPostFilterState,

package/src/stores/{postFilterOperators → fetch-structure/projection/post-filter/operators}/QueryBuilderPostFilterOperator_StartWith.ts

@@ -23,19 +23,19 @@ import {
   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 { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../QueryBuilder_Const.js';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
-import { buildPostFilterConditionState } from '../QueryBuilderPostFilterProcessor.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterValueSpecificationProcessor.js';
 import type {
   PostFilterConditionState,
   QueryBuilderPostFilterState,
 } from '../QueryBuilderPostFilterState.js';
-import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationBuilderHelper.js';
+import {
+  buildNotExpression,
+  generateDefaultValueForPrimitiveType,
+  getNonCollectionValueSpecificationType,
+  unwrapNotExpression,
+} from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
 
 export class QueryBuilderPostFilterOperator_StartWith extends QueryBuilderPostFilterOperator {
@@ -66,8 +66,8 @@ export class QueryBuilderPostFilterOperator_StartWith extends QueryBuilderPostFi
     switch (propertyType?.path) {
       case PRIMITIVE_TYPE.STRING: {
         return buildPrimitiveInstanceValue(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           propertyType.path,
           generateDefaultValueForPrimitiveType(propertyType.path),
         );
@@ -116,8 +116,8 @@ export class QueryBuilderPostFilterOperator_NotStartWith extends QueryBuilderPos
     );
     return expression
       ? buildNotExpression(
-          postFilterConditionState.postFilterState.queryBuilderState
-            .graphManagerState.graph,
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
           expression,
         )
       : undefined;

package/src/stores/filter/QueryBuilderFilterOperator.ts

@@ -0,0 +1,52 @@
+/**
+ * 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,
+  ValueSpecification,
+} from '@finos/legend-graph';
+import { uuid } from '@finos/legend-shared';
+import type {
+  FilterConditionState,
+  QueryBuilderFilterState,
+} from './QueryBuilderFilterState.js';
+
+export abstract class QueryBuilderFilterOperator {
+  readonly uuid = uuid();
+
+  abstract getLabel(filterConditionState: FilterConditionState): string;
+
+  abstract isCompatibleWithFilterConditionProperty(
+    filterConditionState: FilterConditionState,
+  ): boolean;
+
+  abstract isCompatibleWithFilterConditionValue(
+    filterConditionState: FilterConditionState,
+  ): boolean;
+
+  abstract getDefaultFilterConditionValue(
+    filterConditionState: FilterConditionState,
+  ): ValueSpecification | undefined;
+
+  abstract buildFilterConditionExpression(
+    filterConditionState: FilterConditionState,
+  ): ValueSpecification;
+
+  abstract buildFilterConditionState(
+    filterState: QueryBuilderFilterState,
+    expression: SimpleFunctionExpression,
+  ): FilterConditionState | undefined;
+}

package/src/stores/filter/QueryBuilderFilterOperatorLoader.ts

@@ -0,0 +1,65 @@
+/**
+ * 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_Equal,
+  QueryBuilderFilterOperator_NotEqual,
+} from './operators/QueryBuilderFilterOperator_Equal.js';
+import { QueryBuilderFilterOperator_GreaterThan } from './operators/QueryBuilderFilterOperator_GreaterThan.js';
+import {
+  QueryBuilderFilterOperator_NotStartWith,
+  QueryBuilderFilterOperator_StartWith,
+} from './operators/QueryBuilderFilterOperator_StartWith.js';
+import { QueryBuilderFilterOperator_GreaterThanEqual } from './operators/QueryBuilderFilterOperator_GreaterThanEqual.js';
+import { QueryBuilderFilterOperator_LessThanEqual } from './operators/QueryBuilderFilterOperator_LessThanEqual.js';
+import { QueryBuilderFilterOperator_LessThan } from './operators/QueryBuilderFilterOperator_LessThan.js';
+import {
+  QueryBuilderFilterOperator_EndWith,
+  QueryBuilderFilterOperator_NotEndWith,
+} from './operators/QueryBuilderFilterOperator_EndWith.js';
+import {
+  QueryBuilderFilterOperator_Contain,
+  QueryBuilderFilterOperator_NotContain,
+} from './operators/QueryBuilderFilterOperator_Contain.js';
+import {
+  QueryBuilderFilterOperator_IsEmpty,
+  QueryBuilderFilterOperator_IsNotEmpty,
+} from './operators/QueryBuilderFilterOperator_IsEmpty.js';
+import {
+  QueryBuilderFilterOperator_In,
+  QueryBuilderFilterOperator_NotIn,
+} from './operators/QueryBuilderFilterOperator_In.js';
+import type { QueryBuilderFilterOperator } from './QueryBuilderFilterOperator.js';
+
+export const getQueryBuilderCoreFilterOperators =
+  (): QueryBuilderFilterOperator[] => [
+    new QueryBuilderFilterOperator_Equal(),
+    new QueryBuilderFilterOperator_NotEqual(),
+    new QueryBuilderFilterOperator_LessThan(),
+    new QueryBuilderFilterOperator_LessThanEqual(),
+    new QueryBuilderFilterOperator_GreaterThan(),
+    new QueryBuilderFilterOperator_GreaterThanEqual(),
+    new QueryBuilderFilterOperator_StartWith(),
+    new QueryBuilderFilterOperator_NotStartWith(),
+    new QueryBuilderFilterOperator_Contain(),
+    new QueryBuilderFilterOperator_NotContain(),
+    new QueryBuilderFilterOperator_EndWith(),
+    new QueryBuilderFilterOperator_NotEndWith(),
+    new QueryBuilderFilterOperator_In(),
+    new QueryBuilderFilterOperator_NotIn(),
+    new QueryBuilderFilterOperator_IsEmpty(),
+    new QueryBuilderFilterOperator_IsNotEmpty(),
+  ];

package/src/stores/{QueryBuilderFilterState.ts → filter/QueryBuilderFilterState.ts}

@@ -30,7 +30,6 @@ import {
   guaranteeNonNullable,
   guaranteeType,
   IllegalStateError,
-  isNonNullable,
   uuid,
   addUniqueEntry,
   deleteEntry,
@@ -38,60 +37,24 @@ import {
   filterByType,
   ActionState,
 } from '@finos/legend-shared';
-import type { QueryBuilderExplorerTreeDragSource } from './QueryBuilderExplorerState.js';
-import { QueryBuilderPropertyExpressionState } from './QueryBuilderPropertyEditorState.js';
-import type { QueryBuilderState } from './QueryBuilderState.js';
+import type { QueryBuilderExplorerTreeDragSource } from '../explorer/QueryBuilderExplorerState.js';
+import { QueryBuilderPropertyExpressionState } from '../QueryBuilderPropertyEditorState.js';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
 import {
   type ExecutionResult,
   type AbstractPropertyExpression,
   type ValueSpecification,
-  extractElementNameFromPath,
-  SimpleFunctionExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
   observe_ValueSpecification,
 } from '@finos/legend-graph';
+import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../../QueryBuilder_Const.js';
+import type { QueryBuilderProjectionColumnDragSource } from '../fetch-structure/projection/QueryBuilderProjectionColumnState.js';
 import {
-  DEFAULT_LAMBDA_VARIABLE_NAME,
-  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
-} from '../QueryBuilder_Const.js';
-import { buildGenericLambdaFunctionInstanceValue } from './QueryBuilderValueSpecificationBuilderHelper.js';
-import {
-  fromGroupOperation,
-  QUERY_BUILDER_GROUP_OPERATION,
-} from './QueryBuilderOperatorsHelper.js';
-import type { QueryBuilderProjectionColumnDragSource } from './QueryBuilderProjectionState.js';
-import {
-  buildPropertyTypeAheadQuery,
-  buildTypeAheadOptions,
-  performTypeAhead,
-} from './QueryBuilderTypeaheadHelper.js';
-
-export abstract class QueryBuilderFilterOperator {
-  readonly uuid = uuid();
-
-  abstract getLabel(filterConditionState: FilterConditionState): string;
-
-  abstract isCompatibleWithFilterConditionProperty(
-    filterConditionState: FilterConditionState,
-  ): boolean;
-
-  abstract isCompatibleWithFilterConditionValue(
-    filterConditionState: FilterConditionState,
-  ): boolean;
-
-  abstract getDefaultFilterConditionValue(
-    filterConditionState: FilterConditionState,
-  ): ValueSpecification | undefined;
-
-  abstract buildFilterConditionExpression(
-    filterConditionState: FilterConditionState,
-  ): ValueSpecification;
-
-  abstract buildFilterConditionState(
-    filterState: QueryBuilderFilterState,
-    expression: SimpleFunctionExpression,
-  ): FilterConditionState | undefined;
-}
+  buildPropertyTypeaheadQuery,
+  buildTypeaheadOptions,
+  performTypeahead,
+} from '../QueryBuilderTypeaheadHelper.js';
+import type { QueryBuilderFilterOperator } from './QueryBuilderFilterOperator.js';
+import { QUERY_BUILDER_GROUP_OPERATION } from '../QueryBuilderGroupOperationHelper.js';
 
 export enum QUERY_BUILDER_FILTER_DND_TYPE {
   GROUP_CONDITION = 'GROUP_CONDITION',
@@ -161,20 +124,23 @@ export class FilterConditionState {
     try {
       this.typeaheadSearchState.inProgress();
       this.typeaheadSearchResults = undefined;
-      if (performTypeAhead(this.value)) {
-        const builderState = buildPropertyTypeAheadQuery(
-          this.filterState.queryBuilderState,
-          this.propertyExpressionState.propertyExpression,
-          this.value,
-        );
+      if (performTypeahead(this.value)) {
         const result =
-          (yield builderState.graphManagerState.graphManager.executeMapping(
-            builderState.resultState.buildExecutionRawLambda(),
-            guaranteeNonNullable(builderState.querySetupState.mapping),
-            guaranteeNonNullable(builderState.querySetupState.runtimeValue),
-            builderState.graphManagerState.graph,
+          (yield this.filterState.queryBuilderState.graphManagerState.graphManager.executeMapping(
+            buildPropertyTypeaheadQuery(
+              this.filterState.queryBuilderState,
+              this.propertyExpressionState.propertyExpression,
+              this.value,
+            ),
+            guaranteeNonNullable(
+              this.filterState.queryBuilderState.querySetupState.mapping,
+            ),
+            guaranteeNonNullable(
+              this.filterState.queryBuilderState.querySetupState.runtimeValue,
+            ),
+            this.filterState.queryBuilderState.graphManagerState.graph,
           )) as ExecutionResult;
-        this.typeaheadSearchResults = buildTypeAheadOptions(result);
+        this.typeaheadSearchResults = buildTypeaheadOptions(result);
       }
       this.typeaheadSearchState.pass();
     } catch (error) {
@@ -264,7 +230,7 @@ export abstract class QueryBuilderFilterTreeNodeData implements TreeNodeData {
     });
   }
 
-  abstract get dragLayerLabel(): string;
+  abstract get dragPreviewLabel(): string;
   setIsOpen(val: boolean): void {
     this.isOpen = val;
   }
@@ -289,14 +255,14 @@ export class QueryBuilderFilterTreeGroupNodeData extends QueryBuilderFilterTreeN
       setGroupOperation: action,
       addChildNode: action,
       removeChildNode: action,
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
 
     this.groupOperation = groupOperation;
     this.isOpen = true;
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return `${this.groupOperation.toUpperCase()} group`;
   }
 
@@ -328,13 +294,13 @@ export class QueryBuilderFilterTreeConditionNodeData extends QueryBuilderFilterT
 
     makeObservable(this, {
       condition: observable,
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
 
     this.condition = condition;
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return this.condition.propertyExpressionState.title;
   }
 }
@@ -344,103 +310,15 @@ export class QueryBuilderFilterTreeBlankConditionNodeData extends QueryBuilderFi
     super(parentId);
 
     makeObservable(this, {
-      dragLayerLabel: computed,
+      dragPreviewLabel: computed,
     });
   }
 
-  get dragLayerLabel(): string {
+  get dragPreviewLabel(): string {
     return '<blank>';
   }
 }
 
-const buildFilterConditionExpression = (
-  filterState: QueryBuilderFilterState,
-  node: QueryBuilderFilterTreeNodeData,
-): ValueSpecification | undefined => {
-  if (node instanceof QueryBuilderFilterTreeConditionNodeData) {
-    return node.condition.operator.buildFilterConditionExpression(
-      node.condition,
-    );
-  } else if (node instanceof QueryBuilderFilterTreeGroupNodeData) {
-    const multiplicityOne =
-      filterState.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) => buildFilterConditionExpression(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 buildFilterExpression = (
-  filterState: QueryBuilderFilterState,
-  getAllFunc: SimpleFunctionExpression,
-): SimpleFunctionExpression | undefined => {
-  const filterConditionExpressions = filterState.rootIds
-    .map((e) => guaranteeNonNullable(filterState.nodes.get(e)))
-    .map((e) => buildFilterConditionExpression(filterState, e))
-    .filter(isNonNullable);
-
-  if (!filterConditionExpressions.length) {
-    return undefined;
-  }
-  const multiplicityOne =
-    filterState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
-      TYPICAL_MULTIPLICITY_TYPE.ONE,
-    );
-  // main filter expression
-  const filterExpression = new SimpleFunctionExpression(
-    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER),
-    multiplicityOne,
-  );
-  // param [0]
-  filterExpression.parametersValues.push(getAllFunc);
-  // param [1]
-  filterExpression.parametersValues.push(
-    buildGenericLambdaFunctionInstanceValue(
-      filterState.lambdaParameterName,
-      filterConditionExpressions,
-      filterState.queryBuilderState.graphManagerState.graph,
-    ),
-  );
-  return filterExpression;
-};
-
 export class QueryBuilderFilterState
   implements TreeData<QueryBuilderFilterTreeNodeData>
 {
@@ -452,11 +330,6 @@ export class QueryBuilderFilterState
   isRearrangingConditions = false;
   operators: QueryBuilderFilterOperator[] = [];
   private _suppressClickawayEventListener = false;
-  /**
-   * This flag is for turning on/off dnd from projection panel to filter panel,
-   * and will be leveraged when the concepts of workflows are introduced into query builder.
-   */
-  allowDnDProjectionToFilter = true;
 
   constructor(
     queryBuilderState: QueryBuilderState,