@finos/legend-query-builder 0.1.2 → 0.2.1

package/src/stores/shared/LambdaEditorState.ts

@@ -0,0 +1,118 @@
+/**
+ * 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 { observable, action, computed, makeObservable, flow } from 'mobx';
+import { type GeneratorFn, uuid } from '@finos/legend-shared';
+import {
+  type ParserError,
+  type CompilationError,
+  SourceInformation,
+} from '@finos/legend-graph';
+
+/**
+ * This is not strictly meant for lambda. The idea is to create an editor that allows
+ * editing _something_ but allows user to edit via text.
+ */
+export abstract class LambdaEditorState {
+  readonly uuid = uuid();
+  lambdaPrefix: string;
+  lambdaString: string; // value shown in lambda editor which can be edited
+  parserError?: ParserError | undefined;
+  compilationError?: CompilationError | undefined;
+
+  constructor(lambdaString: string, lambdaPrefix: string) {
+    makeObservable(this, {
+      lambdaString: observable,
+      parserError: observable,
+      compilationError: observable,
+      lambdaId: computed,
+      fullLambdaString: computed,
+      setLambdaString: action,
+      clearErrors: action,
+      setCompilationError: action,
+      setParserError: action,
+      convertLambdaGrammarStringToObject: flow,
+      convertLambdaObjectToGrammarString: flow,
+    });
+
+    this.lambdaString = lambdaString;
+    this.lambdaPrefix = lambdaPrefix;
+  }
+
+  abstract get lambdaId(): string;
+
+  // value shown in lambda editor with the prefix, used to send to the server to transformation from text to JSON
+  get fullLambdaString(): string {
+    return `${this.lambdaPrefix}${this.lambdaString}`;
+  }
+
+  setLambdaString(val: string): void {
+    this.lambdaString = val;
+  }
+
+  clearErrors(): void {
+    this.setCompilationError(undefined);
+    this.setParserError(undefined);
+  }
+
+  setCompilationError(compilationError: CompilationError | undefined): void {
+    // account for the lambda prefix offset in source information
+    if (compilationError?.sourceInformation) {
+      compilationError.sourceInformation = this.processSourceInformation(
+        compilationError.sourceInformation,
+      );
+    }
+    this.compilationError = compilationError;
+  }
+
+  setParserError(parserError: ParserError | undefined): void {
+    // account for the lambda prefix offset in source information
+    if (parserError?.sourceInformation) {
+      parserError.sourceInformation = this.processSourceInformation(
+        parserError.sourceInformation,
+      );
+    }
+    this.parserError = parserError;
+  }
+
+  processSourceInformation(
+    sourceInformation: SourceInformation,
+  ): SourceInformation {
+    const { sourceId, startLine, startColumn, endLine, endColumn } =
+      sourceInformation;
+    const lineOffset = 0;
+    const columnOffset = this.lambdaPrefix.length;
+    return new SourceInformation(
+      sourceId,
+      startLine + lineOffset,
+      startColumn - (startLine === 1 ? columnOffset : 0),
+      endLine + lineOffset,
+      endColumn - (endLine === 1 ? columnOffset : 0),
+    );
+  }
+
+  extractLambdaString(fullLambdaString: string): string {
+    return fullLambdaString.substring(
+      fullLambdaString.indexOf(this.lambdaPrefix) + this.lambdaPrefix.length,
+      fullLambdaString.length,
+    );
+  }
+
+  abstract convertLambdaGrammarStringToObject(): GeneratorFn<void>;
+  abstract convertLambdaObjectToGrammarString(
+    pretty: boolean,
+  ): GeneratorFn<void>;
+}

package/src/stores/shared/LambdaParameterState.ts

@@ -0,0 +1,259 @@
+/**
+ * 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 ObserverContext,
+  type Type,
+  type ValueSpecification,
+  type PureModel,
+  GenericType,
+  GenericTypeExplicitReference,
+  observe_ValueSpecification,
+  observe_VariableExpression,
+  PrimitiveInstanceValue,
+  PRIMITIVE_TYPE,
+  VariableExpression,
+  LambdaFunction,
+  TYPICAL_MULTIPLICITY_TYPE,
+  CORE_PURE_PATH,
+  FunctionType,
+  SimpleFunctionExpression,
+  SUPPORTED_FUNCTIONS,
+  extractElementNameFromPath,
+  PackageableElementExplicitReference,
+} from '@finos/legend-graph';
+import {
+  addUniqueEntry,
+  deleteEntry,
+  type Hashable,
+  hashArray,
+  IllegalStateError,
+  isNonNullable,
+  uuid,
+} from '@finos/legend-shared';
+import { makeObservable, observable, action, computed } from 'mobx';
+import { generateVariableExpressionMockValue } from './ValueSpecificationEditorHelper.js';
+import {
+  valueSpecification_setGenericType,
+  valueSpecification_setMultiplicity,
+} from './ValueSpecificationModifierHelper.js';
+
+export enum PARAMETER_SUBMIT_ACTION {
+  EXECUTE = 'EXECUTE',
+  EXPORT = 'EXPORT',
+}
+
+enum LAMABA_PARAMETER_HASH_STRUCTURE {
+  LAMBDA_PARAMETER_STATE = 'LAMBDA_PARAMETER_STATE',
+  LAMBDA_PARAMETERS_STATE = 'LAMBDA_PARAMETERS_STATE',
+}
+
+export const buildParametersLetLambdaFunc = (
+  graph: PureModel,
+  lambdaParametersStates: LambdaParameterState[],
+): LambdaFunction => {
+  const multiplicityOne = graph.getTypicalMultiplicity(
+    TYPICAL_MULTIPLICITY_TYPE.ONE,
+  );
+  const typeString = graph.getPrimitiveType(PRIMITIVE_TYPE.STRING);
+  const typeAny = graph.getType(CORE_PURE_PATH.ANY);
+  const letlambdaFunction = new LambdaFunction(
+    new FunctionType(
+      PackageableElementExplicitReference.create(typeAny),
+      multiplicityOne,
+    ),
+  );
+  letlambdaFunction.expressionSequence = lambdaParametersStates
+    .map((queryParamState) => {
+      if (queryParamState.value) {
+        const letFunc = new SimpleFunctionExpression(
+          extractElementNameFromPath(SUPPORTED_FUNCTIONS.LET),
+          multiplicityOne,
+        );
+        const letVar = new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(new GenericType(typeString)),
+          multiplicityOne,
+        );
+        letVar.values = [queryParamState.variableName];
+        letFunc.parametersValues.push(letVar);
+        letFunc.parametersValues.push(queryParamState.value);
+        return letFunc;
+      }
+      return undefined;
+    })
+    .filter(isNonNullable);
+  return letlambdaFunction;
+};
+
+export class LambdaParameterState implements Hashable {
+  readonly uuid = uuid();
+  readonly parameter: VariableExpression;
+  readonly graph: PureModel;
+  readonly observableContext: ObserverContext;
+
+  value: ValueSpecification | undefined;
+
+  constructor(
+    variableExpression: VariableExpression,
+    observableContext: ObserverContext,
+    graph: PureModel,
+  ) {
+    makeObservable(this, {
+      value: observable,
+      setValue: action,
+      mockParameterValue: action,
+      hashCode: computed,
+    });
+    this.observableContext = observableContext;
+    this.parameter = observe_VariableExpression(variableExpression);
+    this.graph = graph;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      LAMABA_PARAMETER_HASH_STRUCTURE.LAMBDA_PARAMETER_STATE,
+      this.parameter,
+    ]);
+  }
+
+  mockParameterValue(): void {
+    this.setValue(
+      generateVariableExpressionMockValue(this.parameter, this.graph),
+    );
+  }
+
+  setValue(value: ValueSpecification | undefined): void {
+    if (value instanceof VariableExpression) {
+      throw new IllegalStateError(
+        'Can not assign a parameter to another parameter',
+      );
+    }
+    this.value = value
+      ? observe_ValueSpecification(value, this.observableContext)
+      : undefined;
+  }
+
+  changeVariableType(type: Type): void {
+    if (type !== this.variableType) {
+      valueSpecification_setGenericType(
+        this.parameter,
+        GenericTypeExplicitReference.create(new GenericType(type)),
+      );
+      this.mockParameterValue();
+    }
+  }
+
+  changeMultiplicity(
+    variableExpression: VariableExpression,
+    lowerBound: number,
+    uppderBound: number | undefined,
+  ): void {
+    const current = this.parameter.multiplicity;
+    if (
+      current.lowerBound !== lowerBound ||
+      current.upperBound !== uppderBound
+    ) {
+      valueSpecification_setMultiplicity(
+        variableExpression,
+        this.graph.getMultiplicity(lowerBound, uppderBound),
+      );
+      this.mockParameterValue();
+    }
+  }
+
+  get variableName(): string {
+    return this.parameter.name;
+  }
+
+  get variableType(): Type | undefined {
+    return this.parameter.genericType?.value.rawType;
+  }
+}
+
+export class ParameterInstanceValuesEditorState {
+  showModal = false;
+  submitAction:
+    | {
+        handler: () => Promise<void>;
+        label: string;
+      }
+    | undefined;
+
+  constructor() {
+    makeObservable(this, {
+      showModal: observable,
+      submitAction: observable,
+      setShowModal: action,
+      open: action,
+      setSubmitAction: action,
+    });
+  }
+
+  setShowModal(val: boolean): void {
+    this.showModal = val;
+  }
+
+  setSubmitAction(
+    val:
+      | {
+          handler: () => Promise<void>;
+          label: string;
+        }
+      | undefined,
+  ): void {
+    this.submitAction = val;
+  }
+
+  open(handler: () => Promise<void>, label: string): void {
+    this.setSubmitAction({ handler, label });
+    this.setShowModal(true);
+  }
+
+  close(): void {
+    this.setSubmitAction(undefined);
+    this.setShowModal(false);
+  }
+}
+
+export abstract class LambdaParametersState implements Hashable {
+  parameterStates: LambdaParameterState[] = [];
+  parameterValuesEditorState = new ParameterInstanceValuesEditorState();
+
+  constructor() {
+    makeObservable(this, {
+      hashCode: computed,
+    });
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      LAMABA_PARAMETER_HASH_STRUCTURE.LAMBDA_PARAMETERS_STATE,
+      hashArray(this.parameterStates),
+    ]);
+  }
+
+  addParameter(val: LambdaParameterState): void {
+    addUniqueEntry(this.parameterStates, val);
+  }
+
+  removeParameter(val: LambdaParameterState): void {
+    deleteEntry(this.parameterStates, val);
+  }
+
+  setParameters(val: LambdaParameterState[]): void {
+    this.parameterStates = val;
+  }
+}

package/src/stores/shared/ValueSpecificationEditorHelper.ts

@@ -0,0 +1,143 @@
+/**
+ * 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 InstanceValue,
+  type VariableExpression,
+  CollectionInstanceValue,
+  DATE_FORMAT,
+  DATE_TIME_FORMAT,
+  Enumeration,
+  EnumValueExplicitReference,
+  EnumValueInstanceValue,
+  GenericType,
+  GenericTypeExplicitReference,
+  getEnumValue,
+  PrimitiveInstanceValue,
+  PrimitiveType,
+  PRIMITIVE_TYPE,
+  TYPICAL_MULTIPLICITY_TYPE,
+} from '@finos/legend-graph';
+import { Randomizer } from '@finos/legend-shared';
+import { addDays, format } from 'date-fns';
+import { instanceValue_setValues } from './ValueSpecificationModifierHelper.js';
+
+const createMockPrimitiveProperty = (
+  primitiveType: PrimitiveType,
+  propertyName: string,
+): string | number | boolean => {
+  const randomizer = new Randomizer();
+  switch (primitiveType.name) {
+    case PRIMITIVE_TYPE.BOOLEAN:
+      return randomizer.getRandomItemInCollection([true, false]) ?? true;
+    case PRIMITIVE_TYPE.FLOAT:
+      return randomizer.getRandomFloat();
+    case PRIMITIVE_TYPE.DECIMAL:
+      return randomizer.getRandomDouble();
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.INTEGER:
+      return randomizer.getRandomWholeNumber(100);
+    // NOTE that `Date` is the umbrella type that comprises `StrictDate` and `DateTime`, but for simplicity, we will generate `Date` as `StrictDate`
+    case PRIMITIVE_TYPE.DATE:
+    case PRIMITIVE_TYPE.STRICTDATE:
+      return format(
+        randomizer.getRandomDate(
+          new Date(Date.now()),
+          addDays(Date.now(), 100),
+        ),
+        DATE_FORMAT,
+      );
+    case PRIMITIVE_TYPE.DATETIME:
+      return format(
+        randomizer.getRandomDate(
+          new Date(Date.now()),
+          addDays(Date.now(), 100),
+        ),
+        DATE_TIME_FORMAT,
+      );
+    case PRIMITIVE_TYPE.STRING:
+    default:
+      return `${propertyName} ${randomizer.getRandomWholeNumber(100)}`;
+  }
+};
+
+export const createMockEnumerationProperty = (
+  enumeration: Enumeration,
+): string =>
+  new Randomizer().getRandomItemInCollection(enumeration.values)?.name ?? '';
+
+export const buildPrimitiveInstanceValue = (
+  graph: PureModel,
+  type: PRIMITIVE_TYPE,
+  value: unknown,
+): PrimitiveInstanceValue => {
+  const multiplicityOne = graph.getTypicalMultiplicity(
+    TYPICAL_MULTIPLICITY_TYPE.ONE,
+  );
+  const instance = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(
+      new GenericType(graph.getPrimitiveType(type)),
+    ),
+    multiplicityOne,
+  );
+  instanceValue_setValues(instance, [value]);
+  return instance;
+};
+
+export const generateVariableExpressionMockValue = (
+  parameter: VariableExpression,
+  graph: PureModel,
+): InstanceValue | undefined => {
+  const varType = parameter.genericType?.value.rawType;
+  const multiplicity = parameter.multiplicity;
+  if ((!multiplicity.upperBound || multiplicity.upperBound > 1) && varType) {
+    return new CollectionInstanceValue(
+      multiplicity,
+      GenericTypeExplicitReference.create(new GenericType(varType)),
+    );
+  }
+  if (varType instanceof PrimitiveType) {
+    const primitiveInstanceValue = new PrimitiveInstanceValue(
+      GenericTypeExplicitReference.create(
+        varType.name === PRIMITIVE_TYPE.DATE
+          ? new GenericType(graph.getPrimitiveType(PRIMITIVE_TYPE.STRICTDATE))
+          : new GenericType(varType),
+      ),
+      multiplicity,
+    );
+    instanceValue_setValues(primitiveInstanceValue, [
+      createMockPrimitiveProperty(
+        varType,
+        parameter.name === '' ? 'myVar' : parameter.name,
+      ),
+    ]);
+    return primitiveInstanceValue;
+  } else if (varType instanceof Enumeration) {
+    const enumValueInstance = new EnumValueInstanceValue(
+      GenericTypeExplicitReference.create(new GenericType(varType)),
+      multiplicity,
+    );
+    const mock = createMockEnumerationProperty(varType);
+    if (mock !== '') {
+      instanceValue_setValues(enumValueInstance, [
+        EnumValueExplicitReference.create(getEnumValue(varType, mock)),
+      ]);
+    }
+    return enumValueInstance;
+  }
+  return undefined;
+};

package/src/stores/shared/ValueSpecificationModifierHelper.ts

@@ -0,0 +1,177 @@
+/**
+ * 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 Multiplicity,
+  type FunctionExpression,
+  type ValueSpecification,
+  type ObserverContext,
+  type VariableExpression,
+  type InstanceValue,
+  type GraphFetchTree,
+  type AbstractPropertyExpression,
+  type GenericTypeReference,
+  type SimpleFunctionExpression,
+  type PackageableElementReference,
+  type Function,
+  type LambdaFunction,
+  type FunctionType,
+  type CollectionInstanceValue,
+  type PropertyReference,
+  observe_ValueSpecification,
+  observe_GenericTypeReference,
+  observe_PackageableElementReference,
+  observe_VariableExpression,
+} from '@finos/legend-graph';
+import { addUniqueEntry, deleteEntry } from '@finos/legend-shared';
+import { action } from 'mobx';
+
+export const valueSpecification_setGenericType = action(
+  (target: ValueSpecification, val: GenericTypeReference | undefined): void => {
+    target.genericType = val ? observe_GenericTypeReference(val) : undefined;
+  },
+);
+
+export const valueSpecification_setMultiplicity = action(
+  (target: ValueSpecification, val: Multiplicity): void => {
+    target.multiplicity = val;
+  },
+);
+
+export const simpleFunctionExpression_setFunc = action(
+  (
+    target: SimpleFunctionExpression,
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    val: PackageableElementReference<Function> | undefined,
+  ): void => {
+    target.func = val ? observe_PackageableElementReference(val) : undefined;
+  },
+);
+
+export const functionExpression_setParametersValues = action(
+  (
+    target: FunctionExpression,
+    val: ValueSpecification[],
+    context: ObserverContext,
+  ): void => {
+    target.parametersValues = val.map((v) =>
+      observe_ValueSpecification(v, context),
+    );
+  },
+);
+
+export const functionExpression_setParameterValue = action(
+  (
+    target: FunctionExpression,
+    val: ValueSpecification,
+    idx: number,
+    context: ObserverContext,
+  ): void => {
+    target.parametersValues[idx] = observe_ValueSpecification(val, context);
+  },
+);
+
+export const functionExpression_addParameterValue = action(
+  (
+    target: FunctionExpression,
+    val: ValueSpecification,
+    context: ObserverContext,
+  ): void => {
+    target.parametersValues.push(observe_ValueSpecification(val, context));
+  },
+);
+
+export const propertyExpression_setFunc = action(
+  (target: AbstractPropertyExpression, val: PropertyReference): void => {
+    target.func = val;
+  },
+);
+
+export const variableExpression_setName = action(
+  (target: VariableExpression, val: string): void => {
+    target.name = val;
+  },
+);
+
+export const collectionInstanceValue_setValues = action(
+  (
+    target: CollectionInstanceValue,
+    val: ValueSpecification[],
+    observableContext: ObserverContext,
+  ) => {
+    target.values = val.map((v) =>
+      observe_ValueSpecification(v, observableContext),
+    );
+  },
+);
+
+export const instanceValue_setValue = action(
+  (target: InstanceValue, val: unknown, idx: number) => {
+    target.values[idx] = val;
+  },
+);
+
+export const instanceValue_setValues = action(
+  (target: InstanceValue, val: unknown[]) => {
+    // TODO?: do we have to observe the values here?
+    // we might need to do so when we refactor collection value
+    target.values = val;
+  },
+);
+
+export const graphFetchTree_addSubTree = action(
+  (target: GraphFetchTree, val: GraphFetchTree): void => {
+    addUniqueEntry(target.subTrees, val);
+  },
+);
+
+export const graphFetchTree_removeSubTree = action(
+  (target: GraphFetchTree, val: GraphFetchTree): void => {
+    deleteEntry(target.subTrees, val);
+  },
+);
+
+export const lambdaFunction_setExpressionSequence = action(
+  (
+    target: LambdaFunction,
+    val: ValueSpecification[],
+    observableContext: ObserverContext,
+  ) => {
+    target.expressionSequence = val.map((v) =>
+      observe_ValueSpecification(v, observableContext),
+    );
+  },
+);
+
+export const lambdaFunction_setExpression = action(
+  (
+    target: LambdaFunction,
+    val: ValueSpecification,
+    idx: number,
+    observableContext: ObserverContext,
+  ) => {
+    target.expressionSequence[idx] = observe_ValueSpecification(
+      val,
+      observableContext,
+    );
+  },
+);
+
+export const functionType_setParameters = action(
+  (target: FunctionType, val: VariableExpression[]) => {
+    target.parameters = val.map((v) => observe_VariableExpression(v));
+  },
+);