@finos/legend-application-query 6.0.0 → 7.0.1

package/src/stores/query-builder/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -1,256 +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 '../../graphManager/QueryBuilderSupportedFunctions.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,
-): boolean => {
-  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,
-  /**
-   * As of now, we don't support date propagation for aggregation-class functions
-   * so we have this temporary flag to disable date propagation, there could be other
-   * functions that we need to handle, then we will revise this approach
-   * See https://github.com/finos/legend-studio/issues/1471
-   */
-  TEMPORARY__disableDatePropagation?: 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 (
-            !TEMPORARY__disableDatePropagation &&
-            isDefaultDatePropagationSupported(
-              guaranteeType(currentExpression, AbstractPropertyExpression),
-              queryBuilderState,
-              nextExpression instanceof AbstractPropertyExpression
-                ? nextExpression
-                : undefined,
-            )
-          ) {
-            // 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;
-};

package/src/stores/query-builder/QueryBuilderValueSpecificationHelper.ts

@@ -1,359 +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 PureModel,
-  type ValueSpecification,
-  CORE_PURE_PATH,
-  FunctionType,
-  LambdaFunction,
-  LambdaFunctionInstanceValue,
-  PRIMITIVE_TYPE,
-  TYPICAL_MULTIPLICITY_TYPE,
-  VariableExpression,
-  DATE_FORMAT,
-  DATE_TIME_FORMAT,
-  matchFunctionName,
-  type Type,
-  PrimitiveInstanceValue,
-  EnumValueInstanceValue,
-  SimpleFunctionExpression,
-  type PrimitiveType,
-  type Enumeration,
-  extractElementNameFromPath,
-  AbstractPropertyExpression,
-  isSuperType,
-  Class,
-  getMilestoneTemporalStereotype,
-  DerivedProperty,
-  MILESTONING_STEREOTYPE,
-} from '@finos/legend-graph';
-import {
-  addUniqueEntry,
-  guaranteeNonNullable,
-  guaranteeType,
-  isNumber,
-  isString,
-  UnsupportedOperationError,
-} from '@finos/legend-shared';
-import { format } from 'date-fns';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../graphManager/QueryBuilderSupportedFunctions.js';
-import { getDerivedPropertyMilestoningSteoreotype } from './QueryBuilderPropertyEditorState.js';
-
-export const getNonCollectionValueSpecificationType = (
-  valueSpecification: ValueSpecification,
-): Type | undefined => {
-  if (valueSpecification instanceof PrimitiveInstanceValue) {
-    return valueSpecification.genericType.value.rawType;
-  } else if (valueSpecification instanceof EnumValueInstanceValue) {
-    return guaranteeNonNullable(valueSpecification.values[0]).value._OWNER;
-  } else if (valueSpecification instanceof VariableExpression) {
-    return valueSpecification.genericType?.value.rawType;
-  } else if (valueSpecification instanceof SimpleFunctionExpression) {
-    return valueSpecification.genericType?.value.rawType;
-  }
-  return undefined;
-};
-
-export const getCollectionValueSpecificationType = (
-  graph: PureModel,
-  values: ValueSpecification[],
-): Type | undefined => {
-  if (values.every((val) => val instanceof PrimitiveInstanceValue)) {
-    const valuePrimitiveTypes: (PrimitiveType | undefined)[] = [];
-    (values as PrimitiveInstanceValue[]).forEach((val) => {
-      const primitiveType = val.genericType.value.rawType;
-      switch (primitiveType.path) {
-        case PRIMITIVE_TYPE.STRING:
-          addUniqueEntry(
-            valuePrimitiveTypes,
-            graph.getPrimitiveType(PRIMITIVE_TYPE.STRING),
-          );
-          break;
-        case PRIMITIVE_TYPE.INTEGER:
-        case PRIMITIVE_TYPE.DECIMAL:
-        case PRIMITIVE_TYPE.FLOAT:
-        case PRIMITIVE_TYPE.NUMBER:
-          addUniqueEntry(
-            valuePrimitiveTypes,
-            graph.getPrimitiveType(PRIMITIVE_TYPE.NUMBER),
-          );
-          break;
-        default:
-          valuePrimitiveTypes.push(undefined);
-          break;
-      }
-    });
-    if (valuePrimitiveTypes.length > 1) {
-      return undefined;
-    }
-    return valuePrimitiveTypes[0] as PrimitiveType;
-  } else if (values.every((val) => val instanceof EnumValueInstanceValue)) {
-    const valueEnumerationTypes: Enumeration[] = [];
-    (values as EnumValueInstanceValue[]).forEach((val) => {
-      addUniqueEntry(
-        valueEnumerationTypes,
-        guaranteeNonNullable(val.values[0]).value._OWNER,
-      );
-    });
-    if (valueEnumerationTypes.length > 1) {
-      return undefined;
-    }
-    return valueEnumerationTypes[0];
-  }
-  return undefined;
-};
-
-export const unwrapNotExpression = (
-  expression: SimpleFunctionExpression,
-): SimpleFunctionExpression | undefined => {
-  if (
-    matchFunctionName(
-      expression.functionName,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.NOT,
-    )
-  ) {
-    return guaranteeType(
-      expression.parametersValues[0],
-      SimpleFunctionExpression,
-    );
-  }
-  return undefined;
-};
-
-export const buildNotExpression = (
-  graph: PureModel,
-  expression: ValueSpecification,
-): ValueSpecification => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
-  const expressionNot = new SimpleFunctionExpression(
-    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.NOT),
-    multiplicityOne,
-  );
-  expressionNot.parametersValues.push(expression);
-  return expressionNot;
-};
-
-export const isPropertyExpressionChainOptional = (
-  expression: ValueSpecification | undefined,
-): boolean => {
-  let isOptional = false;
-  let propertyExpression = expression;
-  while (
-    propertyExpression &&
-    propertyExpression instanceof AbstractPropertyExpression
-  ) {
-    if (propertyExpression.func.multiplicity.lowerBound === 0) {
-      isOptional = true;
-      break;
-    }
-    propertyExpression = propertyExpression.parametersValues.at(0);
-    while (propertyExpression instanceof SimpleFunctionExpression) {
-      propertyExpression = propertyExpression.parametersValues.at(0);
-    }
-  }
-  return isOptional;
-};
-
-export const isTypeCompatibleForAssignment = (
-  type: Type | undefined,
-  assignmentType: Type,
-): boolean => {
-  const NUMERIC_PRIMITIVE_TYPES = [
-    PRIMITIVE_TYPE.NUMBER,
-    PRIMITIVE_TYPE.INTEGER,
-    PRIMITIVE_TYPE.DECIMAL,
-    PRIMITIVE_TYPE.FLOAT,
-  ] as string[];
-  const DATE_PRIMITIVE_TYPES = [
-    PRIMITIVE_TYPE.DATE,
-    PRIMITIVE_TYPE.DATETIME,
-    PRIMITIVE_TYPE.STRICTDATE,
-    PRIMITIVE_TYPE.LATESTDATE,
-  ] as string[];
-
-  // When changing the return type for LHS, the RHS value should be adjusted accordingly.
-  return (
-    type !== undefined &&
-    // Numeric value is handled loosely because of autoboxing
-    // e.g. LHS (integer) = RHS (float) is acceptable
-    ((NUMERIC_PRIMITIVE_TYPES.includes(type.path) &&
-      NUMERIC_PRIMITIVE_TYPES.includes(assignmentType.path)) ||
-      // Date value is handled loosely as well if the LHS is of type DateTime
-      // This is because we would simulate auto-boxing for date by altering the
-      // Pure function used for the operation
-      // e.g. LHS(DateTime) = RHS(Date) -> we use isOnDay() instead of is()
-      DATE_PRIMITIVE_TYPES.includes(type.path) ||
-      type === assignmentType ||
-      isSuperType(assignmentType, type))
-  );
-};
-
-export const generateDefaultValueForPrimitiveType = (
-  type: PRIMITIVE_TYPE,
-): unknown => {
-  switch (type) {
-    case PRIMITIVE_TYPE.STRING:
-      return '';
-    case PRIMITIVE_TYPE.BOOLEAN:
-      return false;
-    case PRIMITIVE_TYPE.NUMBER:
-    case PRIMITIVE_TYPE.DECIMAL:
-    case PRIMITIVE_TYPE.FLOAT:
-    case PRIMITIVE_TYPE.INTEGER:
-      return 0;
-    case PRIMITIVE_TYPE.DATE:
-    case PRIMITIVE_TYPE.STRICTDATE:
-      return format(new Date(Date.now()), DATE_FORMAT);
-    case PRIMITIVE_TYPE.DATETIME:
-      return format(new Date(Date.now()), DATE_TIME_FORMAT);
-    default:
-      throw new UnsupportedOperationError(
-        `Can't generate default value for primitive type '${type}'`,
-      );
-  }
-};
-
-export const buildGenericLambdaFunctionInstanceValue = (
-  lambdaParameterName: string,
-  lambdaBodyExpressions: ValueSpecification[],
-  graph: PureModel,
-): LambdaFunctionInstanceValue => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
-  const typeAny = graph.getType(CORE_PURE_PATH.ANY);
-  const functionInstanceValue = new LambdaFunctionInstanceValue(
-    multiplicityOne,
-  );
-  const functionType = new FunctionType(typeAny, multiplicityOne);
-  functionType.parameters.push(
-    new VariableExpression(lambdaParameterName, multiplicityOne),
-  );
-  const lambdaFunction = new LambdaFunction(functionType);
-  lambdaFunction.expressionSequence = lambdaBodyExpressions;
-  functionInstanceValue.values.push(lambdaFunction);
-  return functionInstanceValue;
-};
-
-/**
- * Checks if the milestoning property expression is valid in terms of number of parameter values provided
- * in relation to its milestoning type.
- *
- * 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
- */
-export const validatePropertyExpressionChain = (
-  propertyExpression: AbstractPropertyExpression,
-  graph: PureModel,
-): void => {
-  if (
-    propertyExpression.func.genericType.value.rawType instanceof Class &&
-    propertyExpression.func._OWNER._generatedMilestonedProperties.length !== 0
-  ) {
-    const name = propertyExpression.func.name;
-    const func =
-      propertyExpression.func._OWNER._generatedMilestonedProperties.find(
-        (e) => e.name === name,
-      );
-    if (func) {
-      const targetStereotype = getMilestoneTemporalStereotype(
-        propertyExpression.func.genericType.value.rawType,
-        graph,
-      );
-
-      if (targetStereotype) {
-        const sourceStereotype = getDerivedPropertyMilestoningSteoreotype(
-          guaranteeType(func, DerivedProperty),
-          graph,
-        );
-        if (
-          sourceStereotype !== MILESTONING_STEREOTYPE.BITEMPORAL &&
-          targetStereotype !== sourceStereotype
-        ) {
-          if (targetStereotype === MILESTONING_STEREOTYPE.BITEMPORAL) {
-            if (
-              propertyExpression.parametersValues.length !== 3 &&
-              !sourceStereotype
-            ) {
-              throw new UnsupportedOperationError(
-                `Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should have exactly two parameters`,
-              );
-            } else if (propertyExpression.parametersValues.length < 2) {
-              throw new UnsupportedOperationError(
-                `Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should have at least one parameter`,
-              );
-            } else if (propertyExpression.parametersValues.length > 3) {
-              throw new UnsupportedOperationError(
-                `Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should not have more than two parameters`,
-              );
-            }
-          } else if (propertyExpression.parametersValues.length !== 2) {
-            throw new UnsupportedOperationError(
-              `Property of milestoning sterotype '${targetStereotype}' should have exactly one parameter`,
-            );
-          }
-        }
-      }
-    }
-  }
-};
-
-export const extractNullableStringFromInstanceValue = (
-  value: ValueSpecification,
-): string | undefined => {
-  if (value instanceof PrimitiveInstanceValue && isString(value.values[0])) {
-    return value.values[0];
-  }
-  return undefined;
-};
-
-export const extractNullableNumberFromInstanceValue = (
-  value: ValueSpecification,
-): number | undefined => {
-  if (value instanceof PrimitiveInstanceValue && isNumber(value.values[0])) {
-    return value.values[0];
-  }
-  return undefined;
-};