@finos/legend-application-query 5.2.8 → 7.0.0

package/src/stores/QueryBuilderTypeaheadHelper.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 {
-  type AbstractPropertyExpression,
-  type ExecutionResult,
-  type ValueSpecification,
-  PrimitiveInstanceValue,
-  PRIMITIVE_TYPE,
-  TdsExecutionResult,
-  type RawLambda,
-} from '@finos/legend-graph';
-import { guaranteeType, isNonNullable, isString } from '@finos/legend-shared';
-import { QueryBuilderPostFilterOperator_StartWith } from './fetch-structure/projection/post-filter/operators/QueryBuilderPostFilterOperator_StartWith.js';
-import type { QueryBuilderAggregateColumnState } from './fetch-structure/projection/aggregation/QueryBuilderAggregationState.js';
-import {
-  PostFilterConditionState,
-  QueryBuilderPostFilterTreeConditionNodeData,
-} from './fetch-structure/projection/post-filter/QueryBuilderPostFilterState.js';
-import {
-  QueryBuilderProjectionColumnState,
-  QueryBuilderSimpleProjectionColumnState,
-} from './fetch-structure/projection/QueryBuilderProjectionColumnState.js';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import { QueryBuilderProjectionState } from './fetch-structure/projection/QueryBuilderProjectionState.js';
-
-const TYPEAHEAD_TAKE_LIMIT = 10;
-const START_LENGTH = 3;
-
-const createAndSetupQueryBuilderStateForTypeahead = (
-  queryBuilderState: QueryBuilderState,
-): QueryBuilderState => {
-  const builderState = queryBuilderState.cloneQueryBuilderState();
-  builderState.querySetupState = queryBuilderState.querySetupState;
-  const projectionState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderProjectionState,
-  );
-  projectionState.resultSetModifierState.distinct = true;
-  projectionState.resultSetModifierState.limit = TYPEAHEAD_TAKE_LIMIT;
-  return builderState;
-};
-
-const buildColumnTypeaheadQuery = (
-  builderState: QueryBuilderState,
-  columnState:
-    | QueryBuilderProjectionColumnState
-    | QueryBuilderAggregateColumnState,
-  value: ValueSpecification | undefined,
-): RawLambda => {
-  const projectionState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderProjectionState,
-  );
-  let projectionColumnState;
-  if (columnState instanceof QueryBuilderProjectionColumnState) {
-    projectionColumnState = columnState;
-  } else {
-    projectionColumnState = columnState.projectionColumnState;
-    const aggregationState = projectionState.aggregationState;
-    aggregationState.columns = [columnState];
-  }
-  projectionState.columns = [projectionColumnState];
-  const postConditionState = new PostFilterConditionState(
-    projectionState.postFilterState,
-    columnState,
-    value,
-    new QueryBuilderPostFilterOperator_StartWith(),
-  );
-  const postFilterNode = new QueryBuilderPostFilterTreeConditionNodeData(
-    undefined,
-    postConditionState,
-  );
-  projectionState.postFilterState.addNodeFromNode(postFilterNode, undefined);
-  return builderState.resultState.buildExecutionRawLambda();
-};
-
-export const buildPropertyTypeaheadQuery = (
-  queryBuilderState: QueryBuilderState,
-  propertyExpression: AbstractPropertyExpression,
-  value: ValueSpecification | undefined,
-): RawLambda => {
-  const builderState =
-    createAndSetupQueryBuilderStateForTypeahead(queryBuilderState);
-  const projectionState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderProjectionState,
-  );
-  const columnState = new QueryBuilderSimpleProjectionColumnState(
-    projectionState,
-    propertyExpression,
-    false,
-  );
-  return buildColumnTypeaheadQuery(builderState, columnState, value);
-};
-
-export const buildProjectionColumnTypeaheadQuery = (
-  queryBuilderState: QueryBuilderState,
-  columnState:
-    | QueryBuilderProjectionColumnState
-    | QueryBuilderAggregateColumnState,
-  value: ValueSpecification | undefined,
-): RawLambda => {
-  const builderState =
-    createAndSetupQueryBuilderStateForTypeahead(queryBuilderState);
-  return buildColumnTypeaheadQuery(builderState, columnState, value);
-};
-
-export const buildTypeaheadOptions = (result: ExecutionResult): string[] => {
-  const tdsResult = guaranteeType(
-    result,
-    TdsExecutionResult,
-    'Typeahead search is only supported for TDS result sets',
-  );
-  const options: string[] = [];
-  tdsResult.result.rows
-    .map((r) => r.values[0])
-    .filter(isNonNullable)
-    .forEach((r) => {
-      if (isString(r)) {
-        options.push(r);
-      }
-    });
-  return options;
-};
-
-export const performTypeahead = (
-  val: ValueSpecification | undefined,
-): boolean => {
-  if (val instanceof PrimitiveInstanceValue) {
-    const _type = val.genericType.value.rawType;
-    switch (_type.path) {
-      case PRIMITIVE_TYPE.STRING: {
-        const value = val.values[0] as string;
-        return value.length >= START_LENGTH;
-      }
-      default:
-        return false;
-    }
-  }
-  return false;
-};

package/src/stores/QueryBuilderUnsupportedState.ts

@@ -1,42 +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 { makeAutoObservable, action } from 'mobx';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import type { RawLambda } from '@finos/legend-graph';
-
-export class QueryBuilderUnsupportedState {
-  queryBuilderState: QueryBuilderState;
-  rawLambda?: RawLambda | undefined;
-  lambdaError?: Error | undefined;
-
-  constructor(queryBuilderState: QueryBuilderState) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
-      setRawLambda: action,
-      setLambdaError: action,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-  }
-
-  setRawLambda(rawLambda: RawLambda | undefined): void {
-    this.rawLambda = rawLambda;
-  }
-  setLambdaError(lambdaError: Error | undefined): void {
-    this.lambdaError = lambdaError;
-  }
-}

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -1,179 +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 { guaranteeNonNullable } from '@finos/legend-shared';
-import {
-  type Class,
-  type Multiplicity,
-  getMilestoneTemporalStereotype,
-  extractElementNameFromPath,
-  InstanceValue,
-  PackageableElementExplicitReference,
-  CORE_PURE_PATH,
-  FunctionType,
-  GenericType,
-  GenericTypeExplicitReference,
-  LambdaFunction,
-  SimpleFunctionExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
-  MILESTONING_STEREOTYPE,
-} from '@finos/legend-graph';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import { buildParametersLetLambdaFunc } from '@finos/legend-application';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
-import { buildFilterExpression } from './filter/QueryBuilderFilterValueSpecificationBuilder.js';
-import type { LambdaFunctionBuilderOption } from './QueryBuilderValueSpecificationBuilderHelper.js';
-import type { QueryBuilderFetchStructureState } from './fetch-structure/QueryBuilderFetchStructureState.js';
-
-const buildGetAllFunction = (
-  _class: Class,
-  multiplicity: Multiplicity,
-): SimpleFunctionExpression => {
-  const _func = new SimpleFunctionExpression(
-    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL),
-    multiplicity,
-  );
-  const classInstance = new InstanceValue(
-    multiplicity,
-    GenericTypeExplicitReference.create(new GenericType(_class)),
-  );
-  classInstance.values[0] = PackageableElementExplicitReference.create(_class);
-  _func.parametersValues.push(classInstance);
-  return _func;
-};
-
-const buildFetchStructure = (
-  fetchStructureState: QueryBuilderFetchStructureState,
-  lambdaFunction: LambdaFunction,
-  options?: LambdaFunctionBuilderOption,
-): void => {
-  fetchStructureState.implementation.appendFetchStructure(
-    lambdaFunction,
-    options,
-  );
-};
-
-export const buildLambdaFunction = (
-  queryBuilderState: QueryBuilderState,
-  options?: LambdaFunctionBuilderOption,
-): LambdaFunction => {
-  const _class = guaranteeNonNullable(
-    queryBuilderState.querySetupState._class,
-    'Class is required to build query',
-  );
-  const multiplicityOne =
-    queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
-      TYPICAL_MULTIPLICITY_TYPE.ONE,
-    );
-  const typeAny = queryBuilderState.graphManagerState.graph.getType(
-    CORE_PURE_PATH.ANY,
-  );
-  const lambdaFunction = new LambdaFunction(
-    new FunctionType(typeAny, multiplicityOne),
-  );
-
-  // build getAll()
-  const getAllFunction = buildGetAllFunction(_class, multiplicityOne);
-
-  // build milestoning parameter(s) for getAll()
-  const milestoningStereotype = getMilestoneTemporalStereotype(
-    _class,
-    queryBuilderState.graphManagerState.graph,
-  );
-  if (milestoningStereotype) {
-    switch (milestoningStereotype) {
-      case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL: {
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.querySetupState.businessDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        break;
-      }
-      case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL: {
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.querySetupState.processingDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        break;
-      }
-      case MILESTONING_STEREOTYPE.BITEMPORAL: {
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.querySetupState.processingDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.querySetupState.businessDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        break;
-      }
-      default:
-    }
-  }
-  lambdaFunction.expressionSequence[0] = getAllFunction;
-
-  // build filter
-  const filterFunction = buildFilterExpression(
-    queryBuilderState.filterState,
-    getAllFunction,
-  );
-  if (filterFunction) {
-    lambdaFunction.expressionSequence[0] = filterFunction;
-  }
-
-  // build fetch-structure
-  buildFetchStructure(
-    queryBuilderState.fetchStructureState,
-    lambdaFunction,
-    options,
-  );
-
-  // build parameters
-  if (
-    !queryBuilderState.mode.isParametersDisabled &&
-    queryBuilderState.queryParametersState.parameterStates.length
-  ) {
-    // NOTE: if we are executing:
-    // 1. set the parameters to empty
-    // 2. add let statements for each parameter
-    if (options?.isBuildingExecutionQuery) {
-      lambdaFunction.functionType.parameters = [];
-      const letsFuncs = buildParametersLetLambdaFunc(
-        queryBuilderState.graphManagerState.graph,
-        queryBuilderState.queryParametersState.parameterStates,
-      );
-      lambdaFunction.expressionSequence = [
-        ...letsFuncs.expressionSequence,
-        ...lambdaFunction.expressionSequence,
-      ];
-    } else {
-      lambdaFunction.functionType.parameters =
-        queryBuilderState.queryParametersState.parameterStates.map(
-          (e) => e.parameter,
-        );
-    }
-  }
-
-  return lambdaFunction;
-};

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -1,254 +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 {
-  functionExpression_setParametersValues,
-  propertyExpression_setParametersValue,
-} from '@finos/legend-application';
-import {
-  AbstractPropertyExpression,
-  Class,
-  DerivedProperty,
-  getMilestoneTemporalStereotype,
-  INTERNAL__PropagatedValue,
-  matchFunctionName,
-  MILESTONING_STEREOTYPE,
-  SimpleFunctionExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
-  type ValueSpecification,
-} from '@finos/legend-graph';
-import {
-  getNullableFirstElement,
-  guaranteeNonNullable,
-  guaranteeType,
-} from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
-import { getDerivedPropertyMilestoningSteoreotype } from './QueryBuilderPropertyEditorState.js';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-
-/**
- * Checks if the provided property expression match the criteria for default
- * date propagation so we know whether we need to fill in values for the parameter
- * or just propgate values from the parent's expression
- *
- * NOTE: this takes date propgation into account. See the table below for all
- * the combination:
- *
- *             | [source] |          |          |          |          |
- * ----------------------------------------------------------------------
- *   [target]  |          |   NONE   |  PR_TMP  |  BI_TMP  |  BU_TMP  |
- * ----------------------------------------------------------------------
- *             |   NONE   |   N.A.   |   PRD    | PRD,BUD  |    BUD   |
- * ----------------------------------------------------------------------
- *             |  PR_TMP  |   N.A.   |    X     | PRD,BUD  |    BUD   |
- * ----------------------------------------------------------------------
- *             |  BI_TMP  |   N.A.   |    X     |    X     |    X     |
- * ----------------------------------------------------------------------
- *             |  BU_TMP  |   N.A.   |   PRD    | PRD,BUD  |    X     |
- * ----------------------------------------------------------------------
- *
- * Annotations:
- *
- * [source]: source temporal type
- * [target]: target temporal type
- *
- * PR_TMP  : processing temporal
- * BI_TMP  : bitemporal
- * BU_TMP  : business temporal
- *
- * X       : no default date propagated
- * PRD     : default processing date is propagated
- * BUD     : default business date is propgated
- */
-const isDefaultDatePropagationSupported = (
-  currentPropertyExpression: AbstractPropertyExpression,
-  queryBuilderState: QueryBuilderState,
-  prevPropertyExpression?: AbstractPropertyExpression | undefined,
-  isDatePropagationNotSupported?: boolean,
-): boolean => {
-  if (isDatePropagationNotSupported) {
-    return false;
-  }
-  const property = currentPropertyExpression.func;
-  const graph = queryBuilderState.graphManagerState.graph;
-  // Default date propagation is not supported for current expression when the previous property expression is a derived property.
-  if (
-    prevPropertyExpression &&
-    prevPropertyExpression.func instanceof DerivedProperty &&
-    prevPropertyExpression.func._OWNER.derivedProperties.includes(
-      prevPropertyExpression.func,
-    )
-  ) {
-    return false;
-  }
-  // Default date propagation is not supported for current expression when the milestonedParameterValues of
-  // the previous property expression doesn't match with the global milestonedParameterValues
-  if (
-    prevPropertyExpression &&
-    prevPropertyExpression.func.genericType.value.rawType instanceof Class
-  ) {
-    const milestoningStereotype = getMilestoneTemporalStereotype(
-      prevPropertyExpression.func.genericType.value.rawType,
-      graph,
-    );
-    if (
-      milestoningStereotype &&
-      !prevPropertyExpression.parametersValues
-        .slice(1)
-        .every(
-          (parameterValue) =>
-            parameterValue instanceof INTERNAL__PropagatedValue,
-        )
-    ) {
-      return false;
-    }
-  }
-  if (property.genericType.value.rawType instanceof Class) {
-    // the stereotype of source class of current property expression.
-    const sourceStereotype =
-      property instanceof DerivedProperty
-        ? getDerivedPropertyMilestoningSteoreotype(property, graph)
-        : undefined;
-    // Default date propagation is always supported if the source is `bitemporal`
-    if (sourceStereotype === MILESTONING_STEREOTYPE.BITEMPORAL) {
-      return true;
-    }
-    // the stereotype (if exists) of the generic type of current property expression.
-    const targetStereotype = getMilestoneTemporalStereotype(
-      property.genericType.value.rawType,
-      graph,
-    );
-    // Default date propagation is supported when stereotype of both source and target matches
-    if (sourceStereotype && targetStereotype) {
-      return sourceStereotype === targetStereotype;
-    }
-  }
-  return false;
-};
-
-export const buildPropertyExpressionChain = (
-  propertyExpression: AbstractPropertyExpression,
-  queryBuilderState: QueryBuilderState,
-  isDatePropagationNotSupported?: boolean,
-): ValueSpecification => {
-  const graph = queryBuilderState.graphManagerState.graph;
-  const newPropertyExpression = new AbstractPropertyExpression(
-    '',
-    graph.getTypicalMultiplicity(TYPICAL_MULTIPLICITY_TYPE.ONE),
-  );
-  newPropertyExpression.func = propertyExpression.func;
-  newPropertyExpression.parametersValues = propertyExpression.parametersValues;
-
-  let nextExpression: ValueSpecification | undefined;
-  let currentExpression: ValueSpecification | undefined = newPropertyExpression;
-  while (currentExpression instanceof AbstractPropertyExpression) {
-    nextExpression = getNullableFirstElement(
-      currentExpression.parametersValues,
-    );
-    if (nextExpression instanceof AbstractPropertyExpression) {
-      const parameterValue = new AbstractPropertyExpression(
-        '',
-        graph.getTypicalMultiplicity(TYPICAL_MULTIPLICITY_TYPE.ONE),
-      );
-      parameterValue.func = nextExpression.func;
-      parameterValue.parametersValues = nextExpression.parametersValues;
-      nextExpression = parameterValue;
-      currentExpression.parametersValues[0] = parameterValue;
-    }
-    if (currentExpression.func instanceof DerivedProperty) {
-      const parameterValues = currentExpression.parametersValues.slice(1);
-      parameterValues.forEach((parameterValue, index) => {
-        if (parameterValue instanceof INTERNAL__PropagatedValue) {
-          // Replace with argumentless derived property expression only when default date propagation is supported
-          if (
-            isDefaultDatePropagationSupported(
-              guaranteeType(currentExpression, AbstractPropertyExpression),
-              queryBuilderState,
-              nextExpression instanceof AbstractPropertyExpression
-                ? nextExpression
-                : undefined,
-              isDatePropagationNotSupported,
-            )
-          ) {
-            // NOTE: For `bitemporal` property check if the property expression has parameters which are not instance of
-            // `INTERNAL_PropagatedValue` then pass the parameters as user explicitly changed values of either of the parameters.
-            if (
-              (index === 1 &&
-                guaranteeType(currentExpression, AbstractPropertyExpression)
-                  .parametersValues.length === 3) ||
-              (index === 0 &&
-                guaranteeType(currentExpression, AbstractPropertyExpression)
-                  .parametersValues.length === 3 &&
-                !(
-                  guaranteeType(currentExpression, AbstractPropertyExpression)
-                    .parametersValues[2] instanceof INTERNAL__PropagatedValue
-                ))
-            ) {
-              propertyExpression_setParametersValue(
-                guaranteeType(currentExpression, AbstractPropertyExpression),
-                index + 1,
-                parameterValue.getValue(),
-                queryBuilderState.observableContext,
-              );
-            } else {
-              functionExpression_setParametersValues(
-                guaranteeType(currentExpression, AbstractPropertyExpression),
-                [
-                  guaranteeNonNullable(
-                    guaranteeType(currentExpression, AbstractPropertyExpression)
-                      .parametersValues[0],
-                  ),
-                ],
-                queryBuilderState.observableContext,
-              );
-            }
-          } else {
-            propertyExpression_setParametersValue(
-              guaranteeType(currentExpression, AbstractPropertyExpression),
-              index + 1,
-              parameterValue.getValue(),
-              queryBuilderState.observableContext,
-            );
-          }
-        }
-      });
-    }
-    currentExpression = nextExpression;
-    // Take care of chains of subtype (a pattern that is not useful, but we want to support and rectify)
-    // $x.employees->subType(@Person)->subType(@Staff)
-    while (
-      currentExpression instanceof SimpleFunctionExpression &&
-      matchFunctionName(
-        currentExpression.functionName,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
-      )
-    ) {
-      currentExpression = getNullableFirstElement(
-        currentExpression.parametersValues,
-      );
-    }
-  }
-  return newPropertyExpression;
-};
-
-export type LambdaFunctionBuilderOption = {
-  /**
-   * Set queryBuilderState to `true` when we construct query for execution within the app.
-   * queryBuilderState will make the lambda function building process overrides several query values, such as the row limit.
-   */
-  isBuildingExecutionQuery?: boolean | undefined;
-  keepSourceInformation?: boolean | undefined;
-};