@finos/legend-query-builder 0.0.1

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -0,0 +1,256 @@
+/**
+ * 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/QueryBuilderValueSpecificationHelper.ts

@@ -0,0 +1,359 @@
+/**
+ * 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;
+};