@finos/legend-application-query 5.2.8 → 6.0.0

package/src/stores/QueryBuilderStateBuilder.ts

@@ -1,584 +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 {
-  assertNonNullable,
-  assertTrue,
-  assertType,
-  guaranteeType,
-  UnsupportedOperationError,
-} from '@finos/legend-shared';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import {
-  type AlloySerializationConfigInstanceValue,
-  type EnumValueInstanceValue,
-  type FunctionExpression,
-  type MappingInstanceValue,
-  type PairInstanceValue,
-  type PropertyGraphFetchTreeInstanceValue,
-  type PureListInstanceValue,
-  type RootGraphFetchTreeInstanceValue,
-  type RuntimeInstanceValue,
-  type ValueSpecificationVisitor,
-  type InstanceValue,
-  type INTERNAL__UnknownValueSpecification,
-  type LambdaFunction,
-  MILESTONING_STEREOTYPE,
-  matchFunctionName,
-  Class,
-  type CollectionInstanceValue,
-  type LambdaFunctionInstanceValue,
-  type PrimitiveInstanceValue,
-  SimpleFunctionExpression,
-  type VariableExpression,
-  type AbstractPropertyExpression,
-  getMilestoneTemporalStereotype,
-  type INTERNAL__PropagatedValue,
-  type ValueSpecification,
-} from '@finos/legend-graph';
-import { processTDSPostFilterExpression } from './fetch-structure/projection/post-filter/QueryBuilderPostFilterStateBuilder.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
-import { LambdaParameterState } from '@finos/legend-application';
-import { processFilterExpression } from './filter/QueryBuilderFilterStateBuilder.js';
-import {
-  processTDSAggregateExpression,
-  processTDSGroupByExpression,
-} from './fetch-structure/projection/aggregation/QueryBuilderAggregationStateBuilder.js';
-import {
-  processGraphFetchExpression,
-  processGraphFetchSerializeExpression,
-} from './fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeStateBuilder.js';
-import {
-  processTDSDistinctExpression,
-  processTDSProjectExpression,
-  processTDSProjectionColumnPropertyExpression,
-  processTDSProjectionDerivationExpression,
-  processTDSSortDirectionExpression,
-  processTDSSortExpression,
-  processTDSTakeExpression,
-} from './fetch-structure/projection/QueryBuilderProjectionStateBuilder.js';
-
-const processGetAllExpression = (
-  expression: SimpleFunctionExpression,
-  queryBuilderState: QueryBuilderState,
-): void => {
-  const _class = expression.genericType?.value.rawType;
-  assertType(
-    _class,
-    Class,
-    `Can't process getAll() expression: getAll() return type is missing`,
-  );
-  queryBuilderState.querySetupState.setClass(_class, true);
-  queryBuilderState.explorerState.refreshTreeData();
-
-  // check parameters (milestoning) and build state
-  let acceptedNoOfParameters = 1;
-  const stereotype = getMilestoneTemporalStereotype(
-    _class,
-    queryBuilderState.graphManagerState.graph,
-  );
-  switch (stereotype) {
-    case MILESTONING_STEREOTYPE.BITEMPORAL:
-      acceptedNoOfParameters = 3;
-      assertTrue(
-        expression.parametersValues.length === acceptedNoOfParameters,
-        `Can't process getAll() expression: when used with a bitemporal milestoned class getAll() expects two parameters`,
-      );
-      queryBuilderState.querySetupState.setProcessingDate(
-        expression.parametersValues[1],
-      );
-      queryBuilderState.querySetupState.setBusinessDate(
-        expression.parametersValues[2],
-      );
-      break;
-    case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL:
-      acceptedNoOfParameters = 2;
-      assertTrue(
-        expression.parametersValues.length === acceptedNoOfParameters,
-        `Can't process getAll() expression: when used with a milestoned class getAll() expects a parameter`,
-      );
-      queryBuilderState.querySetupState.setBusinessDate(
-        expression.parametersValues[1],
-      );
-      break;
-    case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL:
-      acceptedNoOfParameters = 2;
-      assertTrue(
-        expression.parametersValues.length === acceptedNoOfParameters,
-        `Can't process getAll() expression: when used with a milestoned class getAll() expects a parameter`,
-      );
-      queryBuilderState.querySetupState.setProcessingDate(
-        expression.parametersValues[1],
-      );
-      break;
-    default:
-      assertTrue(
-        expression.parametersValues.length === acceptedNoOfParameters,
-        `Can't process getAll() expression: getAll() expects no arguments`,
-      );
-  }
-};
-
-/**
- * This is the value specification processor (a.k.a state builder) for query builder.
- *
- * Unlike value specification builder which takes care of transforming the value specification
- * from `protocol` to `metamodel`, and doing some (naive) type-inferencing, the processor takes care
- * of traversing the query, analyzing it to build the query builder state. The processor represents
- * a particular way we want to look at the query, if the query is not like what the processor
- * expects, or understands, query builder state could not be built, i.e. the query will be deemed
- * unsupported by query builder
- *
- * NOTE: While traversing the expression, this processor also does a fair amount of
- * validations and assertions--enough to properly build the state. Unlike the builder,
- * the processor should NEVER modify the metamodel, just traversing it.
- */
-export class QueryBuilderValueSpecificationProcessor
-  implements ValueSpecificationVisitor<void>
-{
-  readonly queryBuilderState: QueryBuilderState;
-  /**
-   * A value specification is a tree of value specifications.
-   *
-   * This structure may not intuitively correspond to how we write it in Pure
-   * For example, consider the following expression in Pure:
-   *
-   * | Person.all()->filter(x|$x.age > 0)->project([x|$x.name], ['Name'])->sort([desc('Name')]);
-   *
-   * which is equivalent to the more cryptic version:
-   *
-   * | sort(project(filter(all(Person), x|$x.age > 0), [x|$x.name], ['Name']), [desc('Name')]);
-   *
-   * Hence, the metamodel looks something like this (with some parts redacted)
-   * {
-   *   "function": "sort",
-   *   "parameters": [
-   *     {
-   *       "function": "project",
-   *       "parameters": [
-   *         {
-   *           "function": "filter",
-   *           "parameters": [
-   *             {
-   *               "function": "getAll",
-   *               ...
-   *             },
-   *             ... // filter() expression
-   *           ]
-   *         },
-   *         ... // project() expression column and alias
-   *       ]
-   *     },
-   *     {
-   *       "_type": "collection",
-   *       "values": [
-   *         {
-   *           "function": "desc",
-   *           ... // desc() expression
-   *         }
-   *       ]
-   *     }
-   *   ]
-   * }
-   *
-   * The first grammar form is farily declarative in nature and perhaps more intuitive.
-   * We tend to think, in terms of order of running:
-   * all() --> filter() --> project() --> sort()
-   *
-   * However, in reality, when the expression is used or read, the order of traversal is reversed:
-   * sort() --> project() --> filter() --> all()
-   *
-   * Now, in the context of the value specification processor, we need information about preceding
-   * expression in order to validate the usage context of functions, (for example, we want to only
-   * support project() after all() or filter()). In the case of function expression chain,
-   * we have to look at the function expression first parameter. There are some other context,
-   * such as what happens within the second parameter of the sort() expression
-   * in this case, we have the desc() expression, but it's not part of the main expression chain;
-   * however, we need to verify desc() is used within sort(), in this case, we have to record
-   * the parent expression. This is when the following attribute comes into use when processing
-   * value specification.
-   */
-  readonly parentExpression?: SimpleFunctionExpression | undefined;
-
-  private constructor(
-    queryBuilderState: QueryBuilderState,
-    parentExpression: SimpleFunctionExpression | undefined,
-  ) {
-    this.queryBuilderState = queryBuilderState;
-    this.parentExpression = parentExpression;
-  }
-
-  static process(
-    valueSpecification: ValueSpecification,
-    queryBuilderState: QueryBuilderState,
-  ): void {
-    valueSpecification.accept_ValueSpecificationVisitor(
-      new QueryBuilderValueSpecificationProcessor(queryBuilderState, undefined),
-    );
-  }
-
-  /**
-   * Process value specification with information about parent function expression
-   * in order to be used in some validation/assertion
-   */
-  static processChild(
-    valueSpecification: ValueSpecification,
-    parentExpression: SimpleFunctionExpression,
-    queryBuilderState: QueryBuilderState,
-  ): void {
-    valueSpecification.accept_ValueSpecificationVisitor(
-      new QueryBuilderValueSpecificationProcessor(
-        queryBuilderState,
-        parentExpression,
-      ),
-    );
-  }
-
-  visit_INTERNAL__UnknownValueSpecification(
-    valueSpecification: INTERNAL__UnknownValueSpecification,
-  ): void {
-    assertNonNullable(
-      this.parentExpression,
-      `Can't process unknown value: parent expression cannot be retrieved`,
-    );
-
-    if (
-      matchFunctionName(this.parentExpression.functionName, [
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
-      ])
-    ) {
-      processTDSProjectionDerivationExpression(
-        valueSpecification,
-        this.parentExpression,
-        this.queryBuilderState,
-      );
-      return;
-    }
-
-    throw new UnsupportedOperationError(
-      `Can't process unknown value with parent expression of function ${this.parentExpression.functionName}()`,
-    );
-  }
-
-  visit_RootGraphFetchTreeInstanceValue(
-    valueSpecification: RootGraphFetchTreeInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_PropertyGraphFetchTreeInstanceValue(
-    valueSpecification: PropertyGraphFetchTreeInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_AlloySerializationConfigInstanceValue(
-    valueSpecification: AlloySerializationConfigInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_PrimitiveInstanceValue(
-    valueSpecification: PrimitiveInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_EnumValueInstanceValue(
-    valueSpecification: EnumValueInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_RuntimeInstanceValue(valueSpecification: RuntimeInstanceValue): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_PairInstanceValue(valueSpecification: PairInstanceValue): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_MappingInstanceValue(valueSpecification: MappingInstanceValue): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_PureListInstanceValue(valueSpecification: PureListInstanceValue): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_CollectionInstanceValue(
-    valueSpecification: CollectionInstanceValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_FunctionExpression(valueSpecification: FunctionExpression): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_INTERNAL__PropagatedValue(
-    valueSpecification: INTERNAL__PropagatedValue,
-  ): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_SimpleFunctionExpression(
-    valueSpecification: SimpleFunctionExpression,
-  ): void {
-    const functionName = valueSpecification.functionName;
-    if (
-      matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL)
-    ) {
-      processGetAllExpression(valueSpecification, this.queryBuilderState);
-      return;
-    } else if (
-      matchFunctionName(functionName, [
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER,
-      ])
-    ) {
-      // NOTE: for filter, since it sometimes can be ambiguous
-      // whether meta::pure::functions::collection::filter() was used
-      // or meta::pure::tds::filter() was used, we have to have custom logic
-      // to determine
-
-      // check parameters
-      assertTrue(
-        valueSpecification.parametersValues.length === 2,
-        `Can't process filter() expression: filter() expects 1 argument`,
-      );
-
-      // check preceding expression
-      const precedingExpression = guaranteeType(
-        valueSpecification.parametersValues[0],
-        SimpleFunctionExpression,
-        `Can't process filter() expression: only support filter() immediately following an expression`,
-      );
-      QueryBuilderValueSpecificationProcessor.process(
-        precedingExpression,
-        this.queryBuilderState,
-      );
-
-      if (
-        matchFunctionName(
-          precedingExpression.functionName,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
-        )
-      ) {
-        assertTrue(
-          matchFunctionName(
-            functionName,
-            QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
-          ),
-          `Can't process filter() expression: only supports ${QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER}() immediately following getAll() (got '${functionName}')`,
-        );
-        processFilterExpression(valueSpecification, this.queryBuilderState);
-        return;
-      } else if (
-        matchFunctionName(precedingExpression.functionName, [
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-        ])
-      ) {
-        assertTrue(
-          matchFunctionName(
-            functionName,
-            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER,
-          ),
-          `Can't process post-filter expression: only supports ${QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER}() immediately following project()/groupBy() (got '${functionName}')`,
-        );
-        processTDSPostFilterExpression(
-          valueSpecification,
-          this.queryBuilderState,
-        );
-        return;
-      } else {
-        throw new UnsupportedOperationError(
-          `Can't process filter() expression: only support filter() immediately following getAll() or project()/groupBy()`,
-        );
-      }
-    } else if (
-      matchFunctionName(
-        functionName,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-      )
-    ) {
-      processTDSProjectExpression(valueSpecification, this.queryBuilderState);
-      return;
-    } else if (
-      matchFunctionName(
-        functionName,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE,
-      )
-    ) {
-      processTDSTakeExpression(valueSpecification, this.queryBuilderState);
-      return;
-    } else if (
-      matchFunctionName(
-        functionName,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT,
-      )
-    ) {
-      processTDSDistinctExpression(valueSpecification, this.queryBuilderState);
-      return;
-    } else if (
-      matchFunctionName(
-        functionName,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT,
-      )
-    ) {
-      processTDSSortExpression(valueSpecification, this.queryBuilderState);
-      return;
-    } else if (
-      matchFunctionName(functionName, [
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_ASC,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DESC,
-      ])
-    ) {
-      processTDSSortDirectionExpression(
-        valueSpecification,
-        this.parentExpression,
-        this.queryBuilderState,
-      );
-      return;
-    } else if (
-      matchFunctionName(
-        functionName,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-      )
-    ) {
-      processTDSGroupByExpression(valueSpecification, this.queryBuilderState);
-      return;
-    } else if (
-      matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG)
-    ) {
-      processTDSAggregateExpression(
-        valueSpecification,
-        this.parentExpression,
-        this.queryBuilderState,
-      );
-      return;
-    } else if (
-      matchFunctionName(
-        functionName,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE,
-      )
-    ) {
-      processGraphFetchSerializeExpression(
-        valueSpecification,
-        this.queryBuilderState,
-      );
-      return;
-    } else if (
-      matchFunctionName(functionName, [
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
-      ])
-    ) {
-      processGraphFetchExpression(valueSpecification, this.queryBuilderState);
-      return;
-    }
-    throw new UnsupportedOperationError(
-      `Can't process expression of function ${functionName}()`,
-    );
-  }
-
-  visit_VariableExpression(valueSpecification: VariableExpression): void {
-    throw new UnsupportedOperationError();
-  }
-
-  visit_LambdaFunctionInstanceValue(
-    valueSpecification: LambdaFunctionInstanceValue,
-  ): void {
-    valueSpecification.values.forEach((value) =>
-      value.expressionSequence.forEach((expression) =>
-        expression.accept_ValueSpecificationVisitor(
-          new QueryBuilderValueSpecificationProcessor(
-            this.queryBuilderState,
-            this.parentExpression,
-          ),
-        ),
-      ),
-    );
-  }
-
-  visit_AbstractPropertyExpression(
-    valueSpecification: AbstractPropertyExpression,
-  ): void {
-    assertNonNullable(
-      this.parentExpression,
-      `Can't process property expression: parent expression cannot be retrieved`,
-    );
-
-    if (
-      matchFunctionName(this.parentExpression.functionName, [
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
-      ])
-    ) {
-      processTDSProjectionColumnPropertyExpression(
-        valueSpecification,
-        this.queryBuilderState,
-      );
-      return;
-    }
-
-    throw new UnsupportedOperationError(
-      `Can't process property expression with parent expression of function ${this.parentExpression.functionName}()`,
-    );
-  }
-
-  visit_InstanceValue(valueSpecification: InstanceValue): void {
-    throw new UnsupportedOperationError();
-  }
-}
-
-export const processParameters = (
-  parameters: VariableExpression[],
-  queryBuilderState: QueryBuilderState,
-): void => {
-  const queryParameterState = queryBuilderState.queryParametersState;
-  parameters.forEach((parameter) => {
-    const parameterState = new LambdaParameterState(
-      parameter,
-      queryBuilderState.observableContext,
-      queryBuilderState.graphManagerState.graph,
-    );
-    parameterState.mockParameterValue();
-    queryParameterState.addParameter(parameterState);
-  });
-};
-
-export const processQueryLambdaFunction = (
-  lambdaFunction: LambdaFunction,
-  queryBuilderState: QueryBuilderState,
-): void => {
-  if (lambdaFunction.functionType.parameters.length) {
-    processParameters(
-      lambdaFunction.functionType.parameters,
-      queryBuilderState,
-    );
-  }
-  lambdaFunction.expressionSequence.map((expression) =>
-    QueryBuilderValueSpecificationProcessor.process(
-      expression,
-      queryBuilderState,
-    ),
-  );
-};

package/src/stores/QueryBuilderStateTestUtils.ts

@@ -1,96 +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 { TEST__getTestApplicationStore } from '@finos/legend-application';
-import {
-  type RawLambda,
-  type RawMappingModelCoverageAnalysisResult,
-  TEST__buildGraphWithEntities,
-  TEST__getTestGraphManagerState,
-} from '@finos/legend-graph';
-import type { Entity } from '@finos/legend-storage';
-import { jest } from '@jest/globals';
-import { flowResult } from 'mobx';
-import { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
-import { QueryBuilder_GraphManagerPreset } from '../graphManager/QueryBuilder_GraphManagerPreset.js';
-import {
-  QueryBuilderState,
-  StandardQueryBuilderMode,
-} from './QueryBuilderState.js';
-import { TEST__getTestLegendQueryApplicationConfig } from './QueryEditorStoreTestUtils.js';
-
-export const TEST__setUpQueryBuilderState = async (
-  entities: Entity[],
-  rawLambda?: RawLambda | undefined,
-  executionContext?:
-    | {
-        _class: string;
-        mapping: string;
-        runtime?: string | undefined;
-      }
-    | undefined,
-  rawMappingModelCoverageAnalysisResult?:
-    | RawMappingModelCoverageAnalysisResult
-    | undefined,
-): Promise<QueryBuilderState> => {
-  const pluginManager = LegendQueryPluginManager.create();
-  pluginManager.usePresets([new QueryBuilder_GraphManagerPreset()]).install();
-  const applicationStore = TEST__getTestApplicationStore(
-    TEST__getTestLegendQueryApplicationConfig(),
-    LegendQueryPluginManager.create(),
-  );
-  const graphManagerState = TEST__getTestGraphManagerState(pluginManager);
-  await TEST__buildGraphWithEntities(graphManagerState, entities);
-  const queryBuilderState = new QueryBuilderState(
-    applicationStore,
-    graphManagerState,
-    new StandardQueryBuilderMode(),
-  );
-  if (rawLambda) {
-    queryBuilderState.buildStateFromRawLambda(rawLambda);
-  }
-  if (executionContext) {
-    const graph = queryBuilderState.graphManagerState.graph;
-    queryBuilderState.querySetupState._class = graph.getClass(
-      executionContext._class,
-    );
-    queryBuilderState.querySetupState.mapping = graph.getMapping(
-      executionContext.mapping,
-    );
-    if (executionContext.runtime) {
-      queryBuilderState.querySetupState.runtimeValue = graph.getRuntime(
-        executionContext.runtime,
-      );
-    }
-  }
-  if (rawMappingModelCoverageAnalysisResult) {
-    jest
-      .spyOn(
-        queryBuilderState.graphManagerState.graphManager,
-        'analyzeMappingModelCoverage',
-      )
-      .mockResolvedValue(
-        queryBuilderState.graphManagerState.graphManager.buildMappingModelCoverageAnalysisResult(
-          rawMappingModelCoverageAnalysisResult,
-        ),
-      );
-
-    await flowResult(
-      queryBuilderState.explorerState.analyzeMappingModelCoverage(),
-    );
-  }
-  return queryBuilderState;
-};