@finos/legend-application-query 5.2.8 → 7.0.0

package/src/stores/filter/QueryBuilderFilterStateBuilder.ts

@@ -1,155 +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 {
-  AbstractPropertyExpression,
-  LambdaFunctionInstanceValue,
-  matchFunctionName,
-  SimpleFunctionExpression,
-  VariableExpression,
-} from '@finos/legend-graph';
-import {
-  assertTrue,
-  assertType,
-  guaranteeNonNullable,
-  guaranteeType,
-  returnUndefOnError,
-  UnsupportedOperationError,
-} from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
-import { toGroupOperation } from '../QueryBuilderGroupOperationHelper.js';
-import type { QueryBuilderState } from '../QueryBuilderState.js';
-import { validatePropertyExpressionChain } from '../QueryBuilderValueSpecificationHelper.js';
-import {
-  type QueryBuilderFilterState,
-  QueryBuilderFilterTreeConditionNodeData,
-  QueryBuilderFilterTreeGroupNodeData,
-} from './QueryBuilderFilterState.js';
-
-const processFilterTree = (
-  expression: SimpleFunctionExpression,
-  filterState: QueryBuilderFilterState,
-  parentFilterNodeId: string | undefined,
-): void => {
-  const parentNode = parentFilterNodeId
-    ? filterState.getNode(parentFilterNodeId)
-    : undefined;
-  if (
-    matchFunctionName(expression.functionName, [
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR,
-    ])
-  ) {
-    const groupNode = new QueryBuilderFilterTreeGroupNodeData(
-      parentFilterNodeId,
-      toGroupOperation(expression.functionName),
-    );
-    filterState.nodes.set(groupNode.id, groupNode);
-    expression.parametersValues.forEach((filterExpression) =>
-      processFilterTree(
-        guaranteeType(
-          filterExpression,
-          SimpleFunctionExpression,
-          `Can't process filter group expression: each child expression must be a function expression`,
-        ),
-        filterState,
-        groupNode.id,
-      ),
-    );
-    filterState.addNodeFromNode(groupNode, parentNode);
-  } else {
-    const propertyExpression = expression.parametersValues[0];
-    if (propertyExpression instanceof AbstractPropertyExpression) {
-      const currentPropertyExpression = propertyExpression.parametersValues[0];
-      if (currentPropertyExpression instanceof AbstractPropertyExpression) {
-        validatePropertyExpressionChain(
-          currentPropertyExpression,
-          filterState.queryBuilderState.graphManagerState.graph,
-        );
-      }
-    }
-    for (const operator of filterState.operators) {
-      // NOTE: this allow plugin author to either return `undefined` or throw error
-      // if there is a problem with building the lambda. Either case, the plugin is
-      // considered as not supporting the lambda.
-      const filterConditionState = returnUndefOnError(() =>
-        operator.buildFilterConditionState(filterState, expression),
-      );
-      if (filterConditionState) {
-        filterState.addNodeFromNode(
-          new QueryBuilderFilterTreeConditionNodeData(
-            undefined,
-            filterConditionState,
-          ),
-          parentNode,
-        );
-        return;
-      }
-    }
-    throw new UnsupportedOperationError(
-      `Can't process filter() expression: no compatible filter operator processer available from plugins`,
-    );
-  }
-};
-
-export const processFilterExpression = (
-  expression: SimpleFunctionExpression,
-  queryBuilderState: QueryBuilderState,
-): void => {
-  const filterState = queryBuilderState.filterState;
-  const filterLambda = expression.parametersValues[1];
-  assertType(
-    filterLambda,
-    LambdaFunctionInstanceValue,
-    `Can't process filter() expression: filter() expects argument #1 to be a lambda function`,
-  );
-
-  const lambdaFunc = guaranteeNonNullable(
-    filterLambda.values[0],
-    `Can't process filter() lambda: filter() lambda function is missing`,
-  );
-  assertTrue(
-    lambdaFunc.expressionSequence.length === 1,
-    `Can't process filter() lambda: only support filter() lambda body with 1 expression`,
-  );
-  const rootExpression = guaranteeType(
-    lambdaFunc.expressionSequence[0],
-    SimpleFunctionExpression,
-    `Can't process filter() lambda: only support filter() lambda body with 1 expression`,
-  );
-
-  assertTrue(
-    lambdaFunc.functionType.parameters.length === 1,
-    `Can't process filter() lambda: only support filter() lambda with 1 parameter`,
-  );
-  filterState.setLambdaParameterName(
-    guaranteeType(
-      lambdaFunc.functionType.parameters[0],
-      VariableExpression,
-      `Can't process filter() lambda: only support filter() lambda with 1 parameter`,
-    ).name,
-  );
-
-  processFilterTree(rootExpression, filterState, undefined);
-
-  /**
-   * NOTE: Since group operations like and/or do not take more than 2 parameters, if there are
-   * more than 2 clauses in each group operations, then these clauses are converted into an
-   * unbalanced tree. However, this would look quite bad for UX, as such, we simplify the tree.
-   * After building the filter state.
-   */
-  filterState.simplifyTree();
-};

package/src/stores/filter/QueryBuilderFilterValueSpecificationBuilder.ts

@@ -1,120 +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 { isNonNullable, guaranteeNonNullable } from '@finos/legend-shared';
-import {
-  type ValueSpecification,
-  extractElementNameFromPath,
-  SimpleFunctionExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
-} from '@finos/legend-graph';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilder_Const.js';
-import { buildGenericLambdaFunctionInstanceValue } from '../QueryBuilderValueSpecificationHelper.js';
-import { fromGroupOperation } from '../QueryBuilderGroupOperationHelper.js';
-import {
-  type QueryBuilderFilterState,
-  QueryBuilderFilterTreeConditionNodeData,
-  QueryBuilderFilterTreeGroupNodeData,
-  type QueryBuilderFilterTreeNodeData,
-} from './QueryBuilderFilterState.js';
-
-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;
-};