@finos/legend-application-query 5.2.8 → 7.0.0

package/src/stores/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 '../QueryBuilder_Const.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;
-};

package/src/stores/QueryParametersState.ts

@@ -1,52 +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 {
-  LambdaParametersState,
-  type LambdaParameterState,
-} from '@finos/legend-application';
-import { observable, makeObservable, action } from 'mobx';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-
-export const QUERY_BUILDER_PARAMETER_DND_TYPE = 'PARAMETER';
-
-export interface QueryBuilderParameterDragSource {
-  variable: LambdaParameterState;
-}
-
-export class QueryParametersState extends LambdaParametersState {
-  selectedParameter: LambdaParameterState | undefined;
-  queryBuilderState: QueryBuilderState;
-
-  constructor(queryBuilderState: QueryBuilderState) {
-    super();
-    makeObservable(this, {
-      parameterValuesEditorState: observable,
-      parameterStates: observable,
-      addParameter: action,
-      removeParameter: action,
-      setParameters: action,
-      selectedParameter: observable,
-      setSelectedParameter: action,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-  }
-
-  setSelectedParameter(val: LambdaParameterState | undefined): void {
-    this.selectedParameter = val;
-  }
-}

package/src/stores/QueryTextEditorState.ts

@@ -1,203 +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 {
-  GRAPH_MANAGER_EVENT,
-  buildSourceInformationSourceId,
-  ParserError,
-  RawLambda,
-  stub_RawLambda,
-  pruneSourceInformation,
-} from '@finos/legend-graph';
-import {
-  type GeneratorFn,
-  assertErrorThrown,
-  LogEvent,
-} from '@finos/legend-shared';
-import { observable, action, flow, makeObservable, flowResult } from 'mobx';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import { LambdaEditorState, TAB_SIZE } from '@finos/legend-application';
-
-export class QueryRawLambdaState {
-  lambda: RawLambda;
-
-  constructor(lambda: RawLambda) {
-    this.lambda = lambda;
-
-    makeObservable(this, {
-      lambda: observable,
-      setLambda: action,
-    });
-  }
-
-  setLambda(lambda: RawLambda): void {
-    this.lambda = lambda;
-  }
-}
-
-export enum QueryTextEditorMode {
-  TEXT = 'TEXT',
-  JSON = 'JSON',
-}
-
-export class QueryTextEditorState extends LambdaEditorState {
-  queryBuilderState: QueryBuilderState;
-  rawLambdaState: QueryRawLambdaState;
-  isConvertingLambdaToString = false;
-  mode: QueryTextEditorMode | undefined;
-  /**
-   * This is used to store the JSON string when viewing the query in JSON mode
-   * TODO: consider moving this to another state if we need to simplify the logic of text-mode
-   */
-  readOnlylambdaJson = '';
-
-  constructor(queryBuilderState: QueryBuilderState) {
-    super('', '');
-
-    makeObservable(this, {
-      rawLambdaState: observable,
-      isConvertingLambdaToString: observable,
-      mode: observable,
-      setQueryRawLambdaState: action,
-      setMode: action,
-      openModal: action,
-      closeModal: flow,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-    this.rawLambdaState = new QueryRawLambdaState(stub_RawLambda());
-  }
-
-  get lambdaId(): string {
-    return buildSourceInformationSourceId(['query-builder']);
-  }
-
-  setQueryRawLambdaState(rawLambdaState: QueryRawLambdaState): void {
-    this.rawLambdaState = rawLambdaState;
-  }
-
-  setMode(openModal: QueryTextEditorMode | undefined): void {
-    this.mode = openModal;
-  }
-
-  setLambdaJson(lambdaJson: string): void {
-    this.readOnlylambdaJson = lambdaJson;
-  }
-
-  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
-    const emptyLambda = stub_RawLambda();
-    if (this.lambdaString) {
-      try {
-        const lambda =
-          (yield this.queryBuilderState.graphManagerState.graphManager.pureCodeToLambda(
-            this.fullLambdaString,
-            this.lambdaId,
-            { pruneSourceInformation: true },
-          )) as RawLambda;
-        this.setParserError(undefined);
-        this.rawLambdaState.setLambda(lambda);
-      } catch (error) {
-        assertErrorThrown(error);
-        if (error instanceof ParserError) {
-          this.setParserError(error);
-        }
-        this.queryBuilderState.applicationStore.log.error(
-          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
-          error,
-        );
-      }
-    } else {
-      this.clearErrors();
-      this.rawLambdaState.setLambda(emptyLambda);
-    }
-  }
-
-  *convertLambdaObjectToGrammarString(pretty: boolean): GeneratorFn<void> {
-    if (this.rawLambdaState.lambda.body) {
-      this.isConvertingLambdaToString = true;
-      try {
-        const lambdas = new Map<string, RawLambda>();
-        lambdas.set(
-          this.lambdaId,
-          new RawLambda(
-            this.rawLambdaState.lambda.parameters,
-            this.rawLambdaState.lambda.body,
-          ),
-        );
-        const isolatedLambdas =
-          (yield this.queryBuilderState.graphManagerState.graphManager.lambdasToPureCode(
-            lambdas,
-            pretty,
-          )) as Map<string, string>;
-        const grammarText = isolatedLambdas.get(this.lambdaId);
-        this.setLambdaString(
-          grammarText !== undefined
-            ? this.extractLambdaString(grammarText)
-            : '',
-        );
-        this.clearErrors();
-        this.isConvertingLambdaToString = false;
-      } catch (error) {
-        assertErrorThrown(error);
-        this.queryBuilderState.applicationStore.log.error(
-          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
-          error,
-        );
-        this.isConvertingLambdaToString = false;
-      }
-    } else {
-      this.clearErrors();
-      this.setLambdaString('');
-    }
-  }
-
-  openModal(mode: QueryTextEditorMode): void {
-    const rawLambda = this.queryBuilderState.getQuery();
-    if (mode === QueryTextEditorMode.TEXT) {
-      this.setQueryRawLambdaState(new QueryRawLambdaState(rawLambda));
-    }
-    if (mode === QueryTextEditorMode.JSON) {
-      this.setLambdaJson(
-        JSON.stringify(
-          pruneSourceInformation(
-            this.queryBuilderState.graphManagerState.graphManager.serializeRawValueSpecification(
-              rawLambda,
-            ),
-          ),
-          null,
-          TAB_SIZE,
-        ),
-      );
-    }
-    this.setMode(mode);
-  }
-
-  *closeModal(): GeneratorFn<void> {
-    if (this.mode === QueryTextEditorMode.TEXT) {
-      yield flowResult(this.convertLambdaGrammarStringToObject());
-      if (this.parserError) {
-        this.queryBuilderState.applicationStore.notifyError(
-          `Can't parse query. Please fix error before closing: ${this.parserError.message}`,
-        );
-      } else {
-        this.queryBuilderState.initialize(this.rawLambdaState.lambda);
-        this.setMode(undefined);
-      }
-      return;
-    }
-    this.setMode(undefined);
-  }
-}