@finos/legend-application-studio 23.0.0 → 23.0.2

package/src/stores/editor/editor-state/ExternalFormatState.ts

@@ -0,0 +1,119 @@
+/**
+ * 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 { ExternalFormatDescription } from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  LogEvent,
+  ActionState,
+} from '@finos/legend-shared';
+import { flow, action, makeObservable, observable } from 'mobx';
+import type { EditorStore } from '../EditorStore.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../application/LegendStudioEvent.js';
+import { ElementXTSchemaGenerationState } from './element-editor-state/ElementExternalFormatGenerationState.js';
+
+export type ExternalFormatTypeOption = {
+  value: string;
+  label: string;
+};
+
+export enum EmbeddedDataType {
+  EXTERNAL_FORMAT_DATA = 'EXTERNAL_FORMAT',
+  MODEL_STORE_DATA = 'MODEL_STORE',
+  RELATIONAL_CSV = 'RELATIONAL',
+  DATA_ELEMENT = 'DATA_ELEMENT',
+}
+
+export class ExternalFormatState {
+  fetchingDescriptionsState = ActionState.create();
+  editorStore: EditorStore;
+  externalFormatsDescriptions: ExternalFormatDescription[] = [];
+  schemaGenerationStates: ElementXTSchemaGenerationState[] = [];
+
+  constructor(editorStore: EditorStore) {
+    makeObservable<ExternalFormatState>(this, {
+      externalFormatsDescriptions: observable,
+      schemaGenerationStates: observable,
+      setExternalFormatsDescriptions: action,
+      fetchExternalFormatsDescriptions: flow,
+    });
+
+    this.editorStore = editorStore;
+  }
+
+  get formatTypes(): string[] {
+    return this.externalFormatsDescriptions.map((e) => e.name);
+  }
+
+  get formatTypeOptions(): ExternalFormatTypeOption[] {
+    return this.externalFormatsDescriptions.map((types) => ({
+      value: types.name,
+      label: types.name,
+    }));
+  }
+
+  get formatContentTypes(): string[] {
+    return this.externalFormatsDescriptions.map((e) => e.contentTypes).flat();
+  }
+
+  get externalFormatDescriptionsWithModelGenerationSupport(): ExternalFormatDescription[] {
+    return this.externalFormatsDescriptions.filter(
+      (d) => d.supportsModelGeneration,
+    );
+  }
+
+  getFormatTypeForContentType(contentType: string): string | undefined {
+    return this.externalFormatsDescriptions.find(
+      (externalFormatDescription) =>
+        externalFormatDescription.contentTypes[0] === contentType,
+    )?.name;
+  }
+
+  setExternalFormatsDescriptions(
+    externalFormatsDescriptions: ExternalFormatDescription[],
+  ): void {
+    this.externalFormatsDescriptions = externalFormatsDescriptions;
+  }
+
+  *fetchExternalFormatsDescriptions(): GeneratorFn<void> {
+    try {
+      this.fetchingDescriptionsState.inProgress();
+      const externalFormatDescriptions =
+        (yield this.editorStore.graphManagerState.graphManager.getAvailableExternalFormatsDescriptions()) as ExternalFormatDescription[];
+      this.setExternalFormatsDescriptions(externalFormatDescriptions);
+      this.schemaGenerationStates = externalFormatDescriptions
+        .filter((s) => s.supportsSchemaGeneration)
+        .map(
+          (descr) =>
+            new ElementXTSchemaGenerationState(this.editorStore, descr),
+        );
+      this.fetchingDescriptionsState.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.EXTERNAL_FORMAT_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+      this.fetchingDescriptionsState.fail();
+    }
+  }
+
+  getTypeDescription(type: string): ExternalFormatDescription | undefined {
+    return this.externalFormatsDescriptions.find((e) => e.name === type);
+  }
+}

package/src/stores/editor/editor-state/FileGenerationState.ts

@@ -0,0 +1,285 @@
+/**
+ * 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, makeObservable, flow } from 'mobx';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../application/LegendStudioEvent.js';
+import {
+  type FileSystem_File,
+  type FileResult,
+  FileSystem_Directory,
+  GENERATION_FILE_ROOT_NAME,
+  getFileSystemTreeData,
+  buildFileSystemDirectory,
+} from '../shared/FileSystemTreeUtils.js';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  deepEqual,
+  isEmpty,
+  LogEvent,
+  ActionState,
+} from '@finos/legend-shared';
+import {
+  type FileGenerationSpecification,
+  type GenerationOutput,
+  type GenerationProperty,
+  ConfigurationProperty,
+  GenerationPropertyItemType,
+  PackageableElement,
+  PackageableElementReference,
+  PackageableElementExplicitReference,
+  ELEMENT_PATH_DELIMITER,
+  getNullableFileGenerationConfig,
+} from '@finos/legend-graph';
+import {
+  configurationProperty_setValue,
+  configurationProperty_addConfigurationProperty,
+  fileGeneration_addScopeElement,
+  fileGeneration_deleteScopeElement,
+} from '../shared/modifier/DSL_Generation_GraphModifierHelper.js';
+import { FileSystemState } from './FileSystemState.js';
+
+export abstract class GeneratedFileStructureState {
+  readonly editorStore: EditorStore;
+  fileSystemState: FileSystemState;
+  generatingAction = ActionState.create();
+  rootDirectoryName: string;
+
+  constructor(rootDirectory: string, editorStore: EditorStore) {
+    this.rootDirectoryName = rootDirectory;
+    this.fileSystemState = new FileSystemState(rootDirectory);
+    this.editorStore = editorStore;
+  }
+
+  abstract resetGenerator(): void;
+
+  abstract generate(): GeneratorFn<void>;
+
+  abstract get rootFolder(): string;
+
+  abstract get generationParentId(): string | undefined;
+
+  processGenerationResult(output: GenerationOutput[]): void {
+    this.fileSystemState.root = new FileSystem_Directory(
+      this.rootDirectoryName,
+    );
+    this.fileSystemState.filesIndex = new Map<string, FileSystem_File>();
+    const openedNodeIds = this.fileSystemState.directoryTreeData
+      ? Array.from(this.fileSystemState.directoryTreeData.nodes.values())
+          .filter((node) => node.isOpen)
+          .map((node) => node.id)
+      : [];
+    const generationResultIndex = new Map<string, FileResult>();
+    const rootFolder = this.rootFolder;
+    output.forEach((entry) => {
+      entry.cleanFileName(rootFolder);
+      if (generationResultIndex.has(entry.fileName)) {
+        this.editorStore.applicationStore.logService.warn(
+          LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
+          'Found 2 generation outputs with same path',
+        );
+      }
+      generationResultIndex.set(entry.fileName, {
+        value: entry,
+        parentId: this.generationParentId,
+      });
+    });
+    // take generation outputs and put them into the root directory
+    buildFileSystemDirectory(
+      this.fileSystemState.root,
+      generationResultIndex,
+      this.fileSystemState.filesIndex,
+    );
+    this.fileSystemState.directoryTreeData = getFileSystemTreeData(
+      this.fileSystemState.root,
+    );
+    this.fileSystemState.reprocessNodeTree(
+      Array.from(generationResultIndex.values()),
+      this.fileSystemState.directoryTreeData,
+      openedNodeIds,
+    );
+  }
+}
+
+export class FileGenerationState extends GeneratedFileStructureState {
+  readonly fileGeneration: FileGenerationSpecification;
+
+  constructor(
+    editorStore: EditorStore,
+    fileGeneration: FileGenerationSpecification,
+  ) {
+    super(GENERATION_FILE_ROOT_NAME, editorStore);
+    makeObservable(this, {
+      generatingAction: observable,
+      fileSystemState: observable,
+      resetGenerator: action,
+      processGenerationResult: action,
+      addScopeElement: action,
+      deleteScopeElement: action,
+      updateFileGenerationParameters: action,
+      generate: flow,
+    });
+    this.fileGeneration = fileGeneration;
+  }
+
+  get rootFolder(): string {
+    return (
+      this.fileGeneration.generationOutputPath ??
+      this.fileGeneration.path.split(ELEMENT_PATH_DELIMITER).join('_')
+    );
+  }
+
+  get generationParentId(): string | undefined {
+    return this.fileGeneration.path;
+  }
+
+  resetGenerator(): void {
+    this.fileGeneration.configurationProperties = [];
+  }
+
+  updateFileGenerationParameters(
+    fileGeneration: FileGenerationSpecification,
+    generationProperty: GenerationProperty,
+    newValue: unknown,
+  ): void {
+    if (generationProperty.type === GenerationPropertyItemType.MAP) {
+      if (
+        !newValue ||
+        isEmpty(newValue) ||
+        deepEqual(newValue, generationProperty.defaultValue)
+      ) {
+        fileGeneration.configurationProperties =
+          fileGeneration.configurationProperties.filter(
+            (e) => e.name !== generationProperty.name,
+          );
+      } else {
+        const configProperty = getNullableFileGenerationConfig(
+          fileGeneration,
+          generationProperty.name,
+        );
+        if (configProperty) {
+          configurationProperty_setValue(configProperty, {
+            ...(newValue as object),
+          });
+        } else {
+          const newItem = new ConfigurationProperty(
+            generationProperty.name,
+            newValue,
+          );
+          configurationProperty_addConfigurationProperty(
+            fileGeneration.configurationProperties,
+            newItem,
+          );
+        }
+      }
+    } else {
+      const configProperty = getNullableFileGenerationConfig(
+        fileGeneration,
+        generationProperty.name,
+      );
+      let useDefaultValue = generationProperty.defaultValue === newValue;
+      if (generationProperty.type === GenerationPropertyItemType.BOOLEAN) {
+        useDefaultValue =
+          (generationProperty.defaultValue === 'true') ===
+          (newValue as boolean);
+      }
+      const newConfigValue = useDefaultValue ? undefined : newValue;
+      if (newConfigValue !== undefined) {
+        if (configProperty) {
+          configurationProperty_setValue(configProperty, newConfigValue);
+        } else {
+          const newItem = new ConfigurationProperty(
+            generationProperty.name,
+            newConfigValue,
+          );
+          configurationProperty_addConfigurationProperty(
+            fileGeneration.configurationProperties,
+            newItem,
+          );
+        }
+      } else {
+        fileGeneration.configurationProperties =
+          fileGeneration.configurationProperties.filter(
+            (e) => e.name !== generationProperty.name,
+          );
+      }
+    }
+  }
+
+  *generate(): GeneratorFn<void> {
+    this.generatingAction.inProgress();
+    try {
+      // avoid wasting a network call when the scope is empty, we can short-circuit this
+      if (!this.fileGeneration.scopeElements.length) {
+        this.fileSystemState.selectedNode = undefined;
+        this.processGenerationResult([]);
+        return;
+      }
+      const mode =
+        this.editorStore.graphState.graphGenerationState.getFileGenerationConfiguration(
+          this.fileGeneration.type,
+        ).generationMode;
+      const result =
+        (yield this.editorStore.graphManagerState.graphManager.generateFile(
+          this.fileGeneration,
+          mode,
+          this.editorStore.graphManagerState.graph,
+        )) as GenerationOutput[];
+      this.processGenerationResult(result);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.fileSystemState.selectedNode = undefined;
+      this.processGenerationResult([]);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.generatingAction.complete();
+    }
+  }
+
+  getScopeElement(
+    element: PackageableElement | string,
+  ): PackageableElementReference<PackageableElement> | string | undefined {
+    return this.fileGeneration.scopeElements.find((el) =>
+      el instanceof PackageableElementReference
+        ? el.value === element
+        : element === el,
+    );
+  }
+
+  addScopeElement(element: PackageableElement | string): void {
+    const el = this.getScopeElement(element);
+    if (!el) {
+      fileGeneration_addScopeElement(
+        this.fileGeneration,
+        element instanceof PackageableElement
+          ? PackageableElementExplicitReference.create(element)
+          : element,
+      );
+    }
+  }
+
+  deleteScopeElement(element: PackageableElement | string): void {
+    const el = this.getScopeElement(element);
+    if (el) {
+      fileGeneration_deleteScopeElement(this.fileGeneration, el);
+    }
+  }
+}

package/src/stores/editor/editor-state/GrammarTextEditorState.ts

@@ -0,0 +1,201 @@
+/**
+ * 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 { action, makeObservable, observable } from 'mobx';
+import { hashValue, UnsupportedOperationError } from '@finos/legend-shared';
+import {
+  type PackageableElement,
+  type DSL_Mapping_PureGraphManagerPlugin_Extension,
+  Profile,
+  Enumeration,
+  Class,
+  Association,
+  Mapping,
+  ConcreteFunctionDefinition,
+  Service,
+  FlatData,
+  PackageableConnection,
+  PackageableRuntime,
+  JsonModelConnection,
+  XmlModelConnection,
+  FlatDataConnection,
+  FileGenerationSpecification,
+  GenerationSpecification,
+  Measure,
+  Database,
+  RelationalDatabaseConnection,
+  DataElement,
+  ModelChainConnection,
+  PURE_ELEMENT_NAME,
+  PURE_CONNECTION_NAME,
+} from '@finos/legend-graph';
+import type { TextEditorPosition } from '@finos/legend-art';
+import { generatePackageableElementTreeNodeDataLabel } from '../shared/PackageTreeUtils.js';
+import { LEGEND_STUDIO_SETTING_KEY } from '../../../application/LegendStudioSetting.js';
+
+const getGrammarElementTypeLabelRegexString = (
+  typeLabel: string,
+  elementPath: string,
+): string =>
+  (
+    `^([^\\S\\n])*${typeLabel}` + // start with type label (accounted for spaces, but not newline)
+    `(\\s+<<.*>>)?` + // account for stereotype
+    `(\\s+\\{.*\\})?` + // account for tagged value
+    `\\s+${elementPath
+      .replaceAll('*', '\\*')
+      .replaceAll('(', '\\(')
+      .replaceAll(')', '\\)')
+      .replaceAll('[', '\\[')
+      .replaceAll(']', '\\]')}` + // element path (might contain [],(),*)
+    `[\\s\\n]`
+  ) // account for termination after element path
+    .replace(/\$/g, '\\$'); // replace special character $ by \\$
+export class GrammarTextEditorState {
+  readonly editorStore: EditorStore;
+
+  graphGrammarText = '';
+  currentElementLabelRegexString?: string | undefined;
+  wrapText: boolean;
+  forcedCursorPosition?: TextEditorPosition | undefined;
+
+  constructor(editorStore: EditorStore) {
+    makeObservable(this, {
+      graphGrammarText: observable,
+      currentElementLabelRegexString: observable,
+      wrapText: observable,
+      forcedCursorPosition: observable,
+      setGraphGrammarText: action,
+      setWrapText: action,
+      setForcedCursorPosition: action,
+      resetCurrentElementLabelRegexString: action,
+      setCurrentElementLabelRegexString: action,
+    });
+
+    this.editorStore = editorStore;
+    this.wrapText =
+      this.editorStore.applicationStore.settingService.getBooleanValue(
+        LEGEND_STUDIO_SETTING_KEY.EDITOR_WRAP_TEXT,
+      ) ?? false;
+  }
+
+  get currentTextGraphHash(): string {
+    return hashValue(this.graphGrammarText);
+  }
+
+  setGraphGrammarText(code: string): void {
+    this.graphGrammarText = code;
+  }
+
+  setWrapText(val: boolean): void {
+    this.wrapText = val;
+  }
+
+  setForcedCursorPosition(position: TextEditorPosition | undefined): void {
+    this.forcedCursorPosition = position;
+  }
+
+  resetCurrentElementLabelRegexString(): void {
+    this.currentElementLabelRegexString = undefined;
+  }
+
+  setCurrentElementLabelRegexString(element: PackageableElement): void {
+    let typeLabel: string | undefined;
+    if (element instanceof Class) {
+      typeLabel = PURE_ELEMENT_NAME.CLASS;
+    } else if (element instanceof Association) {
+      typeLabel = PURE_ELEMENT_NAME.ASSOCIATION;
+    } else if (element instanceof Enumeration) {
+      typeLabel = PURE_ELEMENT_NAME.ENUMERATION;
+    } else if (element instanceof Measure) {
+      typeLabel = PURE_ELEMENT_NAME.MEASURE;
+    } else if (element instanceof Profile) {
+      typeLabel = PURE_ELEMENT_NAME.PROFILE;
+    } else if (element instanceof ConcreteFunctionDefinition) {
+      typeLabel = PURE_ELEMENT_NAME.FUNCTION;
+    } else if (element instanceof FlatData) {
+      typeLabel = PURE_ELEMENT_NAME.FLAT_DATA;
+    } else if (element instanceof Database) {
+      typeLabel = PURE_ELEMENT_NAME.DATABASE;
+    } else if (element instanceof Mapping) {
+      typeLabel = PURE_ELEMENT_NAME.MAPPING;
+    } else if (element instanceof Service) {
+      typeLabel = PURE_ELEMENT_NAME.SERVICE;
+    } else if (element instanceof FileGenerationSpecification) {
+      typeLabel = PURE_ELEMENT_NAME.FILE_GENERATION;
+    } else if (element instanceof GenerationSpecification) {
+      typeLabel = PURE_ELEMENT_NAME.GENERATION_SPECIFICATION;
+    } else if (element instanceof PackageableConnection) {
+      if (element.connectionValue instanceof JsonModelConnection) {
+        typeLabel = PURE_CONNECTION_NAME.JSON_MODEL_CONNECTION;
+      } else if (element.connectionValue instanceof XmlModelConnection) {
+        typeLabel = PURE_CONNECTION_NAME.XML_MODEL_CONNECTION;
+      } else if (element.connectionValue instanceof FlatDataConnection) {
+        typeLabel = PURE_CONNECTION_NAME.FLAT_DATA_CONNECTION;
+      } else if (element.connectionValue instanceof ModelChainConnection) {
+        typeLabel = PURE_CONNECTION_NAME.MODEL_CHAIN_CONNECTION;
+      } else if (
+        element.connectionValue instanceof RelationalDatabaseConnection
+      ) {
+        typeLabel = PURE_CONNECTION_NAME.RELATIONAL_DATABASE_CONNECTION;
+      }
+      const extraPureGrammarConnectionLabelers = this.editorStore.pluginManager
+        .getPureGraphManagerPlugins()
+        .flatMap(
+          (plugin) =>
+            (
+              plugin as DSL_Mapping_PureGraphManagerPlugin_Extension
+            ).getExtraPureGrammarConnectionLabelers?.() ?? [],
+        );
+      for (const labeler of extraPureGrammarConnectionLabelers) {
+        const _typeLabel = labeler(element.connectionValue);
+        if (_typeLabel) {
+          typeLabel = _typeLabel;
+          break;
+        }
+      }
+    } else if (element instanceof PackageableRuntime) {
+      typeLabel = PURE_ELEMENT_NAME.RUNTIME;
+    } else if (element instanceof DataElement) {
+      typeLabel = PURE_ELEMENT_NAME.DATA_ELEMENT;
+    } else {
+      const extraPureGrammarElementLabelers = this.editorStore.pluginManager
+        .getPureGraphManagerPlugins()
+        .flatMap(
+          (plugin) => plugin.getExtraPureGrammarElementLabelers?.() ?? [],
+        );
+      for (const labeler of extraPureGrammarElementLabelers) {
+        const _typeLabel = labeler(element);
+        if (_typeLabel) {
+          typeLabel = _typeLabel;
+          break;
+        }
+      }
+    }
+    if (!typeLabel) {
+      throw new UnsupportedOperationError(
+        `Can't construct label for element type in Pure grammar: no compatible labeler available from plugins`,
+        element,
+      );
+    }
+    this.currentElementLabelRegexString = getGrammarElementTypeLabelRegexString(
+      typeLabel,
+      `${element.package?.path}::${generatePackageableElementTreeNodeDataLabel(
+        element,
+      )}`,
+    );
+  }
+}