@finos/legend-application-studio 13.0.0

package/src/stores/editor-state/element-editor-state/ClassEditorState.ts

@@ -0,0 +1,140 @@
+/**
+ * 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 { computed, observable, makeObservable, override, action } from 'mobx';
+import { UMLEditorState, UML_EDITOR_TAB } from './UMLEditorState.js';
+import {
+  LogEvent,
+  guaranteeType,
+  assertErrorThrown,
+} from '@finos/legend-shared';
+import {
+  ClassState,
+  CONSTRAINT_SOURCE_ID_LABEL,
+  DERIVED_PROPERTY_SOURCE_ID_LABEL,
+} from './ClassState.js';
+import type { EditorStore } from '../../EditorStore.js';
+import {
+  type CompilationError,
+  type PackageableElement,
+  type AbstractProperty,
+  GRAPH_MANAGER_EVENT,
+  extractSourceInformationCoordinates,
+  Class,
+} from '@finos/legend-graph';
+
+export class ClassEditorState extends UMLEditorState {
+  classState: ClassState;
+  selectedProperty: AbstractProperty | undefined;
+
+  constructor(editorStore: EditorStore, element: PackageableElement) {
+    super(editorStore, element);
+
+    makeObservable(this, {
+      classState: observable,
+      selectedProperty: observable,
+      class: computed,
+      hasCompilationError: computed,
+      reprocess: override,
+      setSelectedProperty: action,
+    });
+
+    this.classState = new ClassState(editorStore, this.class);
+  }
+
+  get class(): Class {
+    return guaranteeType(
+      this.element,
+      Class,
+      'Element inside class editor state must be a class',
+    );
+  }
+
+  setSelectedProperty(val: AbstractProperty | undefined): void {
+    this.selectedProperty = val;
+  }
+
+  override revealCompilationError(compilationError: CompilationError): boolean {
+    try {
+      if (compilationError.sourceInformation) {
+        const elementCoordinates = extractSourceInformationCoordinates(
+          compilationError.sourceInformation,
+        );
+        if (elementCoordinates) {
+          const sourceId = compilationError.sourceInformation.sourceId;
+          const classTab = elementCoordinates[1];
+          if (classTab === CONSTRAINT_SOURCE_ID_LABEL) {
+            this.setSelectedTab(UML_EDITOR_TAB.CONSTRAINTS);
+            const constraintState = this.classState.constraintStates.find(
+              (state) => state.lambdaId === sourceId,
+            );
+            if (constraintState) {
+              constraintState.setCompilationError(compilationError);
+              return true;
+            }
+          } else if (classTab === DERIVED_PROPERTY_SOURCE_ID_LABEL) {
+            this.setSelectedTab(UML_EDITOR_TAB.DERIVED_PROPERTIES);
+            const derivedPropertyState =
+              this.classState.derivedPropertyStates.find(
+                (state) => state.lambdaId === sourceId,
+              );
+            if (derivedPropertyState) {
+              derivedPropertyState.setCompilationError(compilationError);
+              return true;
+            }
+          }
+        }
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.log.warn(
+        LogEvent.create(GRAPH_MANAGER_EVENT.COMPILATION_FAILURE),
+        `Can't locate error`,
+        error,
+      );
+    }
+    return false;
+  }
+
+  override get hasCompilationError(): boolean {
+    return (
+      this.classState.constraintStates.some((state) =>
+        Boolean(state.compilationError),
+      ) ||
+      this.classState.derivedPropertyStates.some((state) =>
+        Boolean(state.compilationError),
+      )
+    );
+  }
+
+  override clearCompilationError(): void {
+    this.classState.constraintStates.forEach((constraintState) =>
+      constraintState.setCompilationError(undefined),
+    );
+    this.classState.derivedPropertyStates.forEach((dpState) =>
+      dpState.setCompilationError(undefined),
+    );
+  }
+
+  override reprocess(
+    newElement: Class,
+    editorStore: EditorStore,
+  ): ClassEditorState {
+    const classEditorState = new ClassEditorState(editorStore, newElement);
+    classEditorState.selectedTab = this.selectedTab;
+    return classEditorState;
+  }
+}

package/src/stores/editor-state/element-editor-state/ClassState.ts

@@ -0,0 +1,419 @@
+/**
+ * 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, flow, makeObservable } from 'mobx';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  LogEvent,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+import type { EditorStore } from '../../EditorStore.js';
+import {
+  type Class,
+  type Constraint,
+  type DerivedProperty,
+  LAMBDA_PIPE,
+  GRAPH_MANAGER_EVENT,
+  ParserError,
+  RawLambda,
+  buildSourceInformationSourceId,
+  stub_RawLambda,
+  isStubbed_RawLambda,
+  getAllClassConstraints,
+  getAllClassDerivedProperties,
+} from '@finos/legend-graph';
+import { LambdaEditorState } from '@finos/legend-application';
+import {
+  constraint_setFunctionDefinition,
+  derivedProperty_setBody,
+  derivedProperty_setParameters,
+} from '../../graphModifier/DomainGraphModifierHelper.js';
+
+export const CONSTRAINT_SOURCE_ID_LABEL = 'constraint';
+export const DERIVED_PROPERTY_SOURCE_ID_LABEL = 'derivedProperty';
+
+export class DerivedPropertyState extends LambdaEditorState {
+  derivedProperty: DerivedProperty;
+  editorStore: EditorStore;
+
+  constructor(derivedProperty: DerivedProperty, editorStore: EditorStore) {
+    super(`${LAMBDA_PIPE}''`, '');
+
+    makeObservable(this, {
+      derivedProperty: observable,
+      editorStore: observable,
+      setBodyAndParameters: action,
+    });
+
+    this.derivedProperty = derivedProperty;
+    this.editorStore = editorStore;
+  }
+
+  get lambdaId(): string {
+    return buildSourceInformationSourceId([
+      this.derivedProperty._OWNER.path,
+      DERIVED_PROPERTY_SOURCE_ID_LABEL,
+      this.derivedProperty.name,
+      this.uuid, // in case of duplications
+    ]);
+  }
+
+  setBodyAndParameters(lambda: RawLambda): void {
+    derivedProperty_setBody(this.derivedProperty, lambda.body);
+    derivedProperty_setParameters(this.derivedProperty, lambda.parameters);
+  }
+
+  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
+    const emptyLambda = stub_RawLambda();
+    if (this.lambdaString) {
+      try {
+        const lambda =
+          (yield this.editorStore.graphManagerState.graphManager.pureCodeToLambda(
+            this.fullLambdaString,
+            this.lambdaId,
+          )) as RawLambda;
+        this.setParserError(undefined);
+        this.setBodyAndParameters(lambda);
+      } catch (error) {
+        assertErrorThrown(error);
+        if (error instanceof ParserError) {
+          this.setParserError(error);
+        }
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.setBodyAndParameters(emptyLambda);
+    }
+  }
+
+  *convertLambdaObjectToGrammarString(pretty: boolean): GeneratorFn<void> {
+    if (this.derivedProperty.body) {
+      try {
+        const lambdas = new Map<string, RawLambda>();
+        lambdas.set(
+          this.lambdaId,
+          new RawLambda(
+            this.derivedProperty.parameters,
+            this.derivedProperty.body,
+          ),
+        );
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+            pretty,
+          )) as Map<string, string>;
+        const grammarText = isolatedLambdas.get(this.lambdaId);
+        this.setLambdaString(
+          grammarText !== undefined
+            ? this.extractLambdaString(grammarText)
+            : '',
+        );
+        this.clearErrors();
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.setLambdaString('');
+    }
+  }
+}
+
+export class ConstraintState extends LambdaEditorState {
+  constraint: Constraint;
+  editorStore: EditorStore;
+
+  constructor(constraint: Constraint, editorStore: EditorStore) {
+    super('true', LAMBDA_PIPE);
+
+    makeObservable(this, {
+      constraint: observable,
+      editorStore: observable,
+    });
+
+    this.constraint = constraint;
+    this.editorStore = editorStore;
+  }
+
+  get lambdaId(): string {
+    return buildSourceInformationSourceId([
+      this.constraint._OWNER.path,
+      CONSTRAINT_SOURCE_ID_LABEL,
+      this.constraint.name,
+      this.uuid, // in case of duplications
+    ]);
+  }
+
+  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
+    const emptyFunctionDefinition = stub_RawLambda();
+    if (this.lambdaString) {
+      try {
+        const lambda =
+          (yield this.editorStore.graphManagerState.graphManager.pureCodeToLambda(
+            this.fullLambdaString,
+            this.lambdaId,
+          )) as RawLambda;
+        this.setParserError(undefined);
+        constraint_setFunctionDefinition(this.constraint, lambda);
+      } catch (error) {
+        assertErrorThrown(error);
+        if (error instanceof ParserError) {
+          this.setParserError(error);
+        }
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      constraint_setFunctionDefinition(
+        this.constraint,
+        emptyFunctionDefinition,
+      );
+    }
+  }
+
+  *convertLambdaObjectToGrammarString(pretty: boolean): GeneratorFn<void> {
+    if (!isStubbed_RawLambda(this.constraint.functionDefinition)) {
+      try {
+        const lambdas = new Map<string, RawLambda>();
+        lambdas.set(this.lambdaId, this.constraint.functionDefinition);
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+            pretty,
+          )) as Map<string, string>;
+        const grammarText = isolatedLambdas.get(this.lambdaId);
+        this.setLambdaString(
+          grammarText !== undefined
+            ? this.extractLambdaString(grammarText)
+            : '',
+        );
+        this.clearErrors();
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.setLambdaString('');
+    }
+  }
+}
+
+// NOTE: We went through the trouble of maintaining Class state outside of metamodel class prototype because we don't want to pollute
+// metamodel models with UI states, this requires more effort to maintain but it will help in the long run
+export class ClassState {
+  editorStore: EditorStore;
+  class: Class;
+  derivedPropertyStates: DerivedPropertyState[] = [];
+  constraintStates: ConstraintState[] = [];
+  isConvertingConstraintLambdaObjects = false;
+  isConvertingDerivedPropertyLambdaObjects = false;
+
+  constructor(editorStore: EditorStore, _class: Class) {
+    makeObservable(this, {
+      class: observable,
+      derivedPropertyStates: observable,
+      constraintStates: observable,
+      isConvertingConstraintLambdaObjects: observable,
+      isConvertingDerivedPropertyLambdaObjects: observable,
+      addConstraintState: action,
+      deleteConstraintState: action,
+      addDerivedPropertyState: action,
+      deleteDerivedPropertyState: action,
+      convertConstraintLambdaObjects: flow,
+      convertDerivedPropertyLambdaObjects: flow,
+      decorate: action,
+    });
+
+    this.editorStore = editorStore;
+    this.class = _class;
+    this.constraintStates = getAllClassConstraints(_class).map(
+      (constraint) => new ConstraintState(constraint, this.editorStore),
+    );
+    this.derivedPropertyStates = getAllClassDerivedProperties(_class).map(
+      (derivedProperty) =>
+        new DerivedPropertyState(derivedProperty, this.editorStore),
+    );
+  }
+
+  getNullableConstraintState = (
+    constraint: Constraint,
+  ): ConstraintState | undefined =>
+    this.constraintStates.find(
+      (constraintState) => constraintState.constraint === constraint,
+    );
+  getNullableDerivedPropertyState = (
+    dp: DerivedProperty,
+  ): DerivedPropertyState | undefined =>
+    this.derivedPropertyStates.find((state) => state.derivedProperty === dp);
+  getConstraintState = (constraint: Constraint): ConstraintState =>
+    guaranteeNonNullable(
+      this.getNullableConstraintState(constraint),
+      `Can't find constraint state for constraint ${constraint}`,
+    );
+  getDerivedPropertyState = (dp: DerivedProperty): DerivedPropertyState =>
+    guaranteeNonNullable(
+      this.getNullableDerivedPropertyState(dp),
+      `Can't find derived property state for derived property ${dp}`,
+    );
+
+  addConstraintState(constraint: Constraint): void {
+    if (
+      !this.constraintStates.find(
+        (constraintState) => constraintState.constraint === constraint,
+      )
+    ) {
+      this.constraintStates.push(
+        new ConstraintState(constraint, this.editorStore),
+      );
+    }
+  }
+
+  deleteConstraintState(constraint: Constraint): void {
+    const idx = this.constraintStates.findIndex(
+      (constraintState) => constraintState.constraint === constraint,
+    );
+    if (idx !== -1) {
+      this.constraintStates.splice(idx, 1);
+    }
+  }
+
+  addDerivedPropertyState(derivedProperty: DerivedProperty): void {
+    if (
+      !this.derivedPropertyStates.find(
+        (state) => state.derivedProperty === derivedProperty,
+      )
+    ) {
+      this.derivedPropertyStates.push(
+        new DerivedPropertyState(derivedProperty, this.editorStore),
+      );
+    }
+  }
+
+  deleteDerivedPropertyState(derivedProperty: DerivedProperty): void {
+    const idx = this.derivedPropertyStates.findIndex(
+      (state) => state.derivedProperty === derivedProperty,
+    );
+    if (idx !== -1) {
+      this.derivedPropertyStates.splice(idx, 1);
+    }
+  }
+
+  *convertConstraintLambdaObjects(): GeneratorFn<void> {
+    const lambdas = new Map<string, RawLambda>();
+    const index = new Map<string, ConstraintState>();
+    this.constraintStates.forEach((constraintState) => {
+      if (!isStubbed_RawLambda(constraintState.constraint.functionDefinition)) {
+        lambdas.set(
+          constraintState.lambdaId,
+          constraintState.constraint.functionDefinition,
+        );
+        index.set(constraintState.lambdaId, constraintState);
+      }
+    });
+    if (lambdas.size) {
+      this.isConvertingConstraintLambdaObjects = true;
+      try {
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+          )) as Map<string, string>;
+        isolatedLambdas.forEach((grammarText, key) => {
+          const constraintState = index.get(key);
+          constraintState?.setLambdaString(
+            constraintState.extractLambdaString(grammarText),
+          );
+        });
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      } finally {
+        this.isConvertingConstraintLambdaObjects = false;
+      }
+    }
+  }
+
+  *convertDerivedPropertyLambdaObjects(): GeneratorFn<void> {
+    const lambdas = new Map<string, RawLambda>();
+    const index = new Map<string, DerivedPropertyState>();
+    this.derivedPropertyStates.forEach((state) => {
+      const lambda = new RawLambda(
+        state.derivedProperty.parameters,
+        state.derivedProperty.body,
+      );
+      if (!isStubbed_RawLambda(lambda)) {
+        lambdas.set(state.lambdaId, lambda);
+        index.set(state.lambdaId, state);
+      }
+    });
+    if (lambdas.size) {
+      this.isConvertingDerivedPropertyLambdaObjects = true;
+      try {
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+          )) as Map<string, string>;
+        isolatedLambdas.forEach((grammarText, key) => {
+          const derivedPropertyState = index.get(key);
+          derivedPropertyState?.setLambdaString(
+            derivedPropertyState.extractLambdaString(grammarText),
+          );
+        });
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      } finally {
+        this.isConvertingDerivedPropertyLambdaObjects = false;
+      }
+    }
+  }
+
+  decorate(): void {
+    this.constraintStates = getAllClassConstraints(this.class).map(
+      (constraint) =>
+        this.constraintStates.find(
+          (constraintState) => constraintState.constraint === constraint,
+        ) ?? new ConstraintState(constraint, this.editorStore),
+    );
+    this.derivedPropertyStates = getAllClassDerivedProperties(this.class).map(
+      (dp) =>
+        this.derivedPropertyStates.find(
+          (state) => state.derivedProperty === dp,
+        ) ?? new DerivedPropertyState(dp, this.editorStore),
+    );
+  }
+}

package/src/stores/editor-state/element-editor-state/ElementEditorState.ts

@@ -0,0 +1,159 @@
+/**
+ * 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 { EditorStore } from '../../EditorStore.js';
+import { observable, action, flow, computed, makeObservable } from 'mobx';
+import { ELEMENT_NATIVE_VIEW_MODE } from '../../EditorConfig.js';
+import { EditorState } from '../../editor-state/EditorState.js';
+import {
+  type GeneratorFn,
+  LogEvent,
+  assertErrorThrown,
+} from '@finos/legend-shared';
+import {
+  type CompilationError,
+  type PackageableElement,
+  GRAPH_MANAGER_EVENT,
+} from '@finos/legend-graph';
+import { TAB_SIZE } from '@finos/legend-application';
+
+const generateMultiLineCommentForError = (
+  message: string,
+  error: Error,
+): string =>
+  `/**\n * ${message}. Error: ${error.message.replace(/\n/gu, '\n * ')}\n */`;
+
+export abstract class ElementEditorState extends EditorState {
+  element: PackageableElement;
+  editMode = ELEMENT_NATIVE_VIEW_MODE.FORM;
+  generationViewMode?: string | undefined;
+  textContent = '';
+  isReadOnly = false;
+
+  constructor(editorStore: EditorStore, element: PackageableElement) {
+    super(editorStore);
+
+    makeObservable(this, {
+      element: observable,
+      editMode: observable,
+      generationViewMode: observable,
+      textContent: observable,
+      isReadOnly: observable,
+      headerName: computed,
+      setTextContent: action,
+      setEditMode: action,
+      setGenerationViewMode: action,
+      generateElementProtocol: action,
+      generateElementGrammar: flow,
+    });
+
+    this.element = element;
+    this.isReadOnly =
+      editorStore.graphManagerState.isElementReadOnly(element) ||
+      editorStore.isInViewerMode;
+  }
+
+  get headerName(): string {
+    return this.element.name;
+  }
+
+  setTextContent(text: string): void {
+    this.textContent = text;
+  }
+  setEditMode(mode: ELEMENT_NATIVE_VIEW_MODE): void {
+    this.editMode = mode;
+    // changing edit mode will clear any existing generation view mode
+    // as edit mode always takes precedence
+    this.setGenerationViewMode(undefined);
+  }
+  setGenerationViewMode(mode: string | undefined): void {
+    this.generationViewMode = mode;
+  }
+
+  generateElementProtocol(): void {
+    try {
+      const elementEntity =
+        this.editorStore.graphManagerState.graphManager.elementToEntity(
+          this.element,
+          {
+            pruneSourceInformation: true,
+          },
+        );
+      this.setTextContent(
+        JSON.stringify(elementEntity.content, undefined, TAB_SIZE),
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.setTextContent(
+        generateMultiLineCommentForError(
+          `Can't generate protocol JSON for element`,
+          error,
+        ),
+      );
+      this.editorStore.applicationStore.log.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+        error,
+      );
+    }
+  }
+
+  *generateElementGrammar(): GeneratorFn<void> {
+    try {
+      const grammar =
+        (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(
+          [
+            this.editorStore.graphManagerState.graphManager.elementToEntity(
+              this.element,
+            ),
+          ],
+        )) as string;
+      this.setTextContent(grammar);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.setTextContent(
+        generateMultiLineCommentForError(
+          `Can't generate grammar text for element`,
+          error,
+        ),
+      );
+      this.editorStore.applicationStore.log.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+        error,
+      );
+    }
+  }
+
+  /**
+   * Takes the compilation and based on its source information, attempts to reveal the error
+   * in the editor. The return values indicates if the editor has revealed the error successfully or not.
+   */
+  revealCompilationError(compilationError: CompilationError): boolean {
+    return false;
+  }
+
+  get hasCompilationError(): boolean {
+    return false;
+  }
+
+  clearCompilationError(): void {
+    return;
+  }
+
+  abstract reprocess(
+    newElement: PackageableElement,
+    editorStore: EditorStore,
+  ): ElementEditorState;
+}