@finos/legend-application-studio 13.0.0

package/src/stores/editor/StandardEditorMode.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { generateViewEntityRoute } from '../LegendStudioRouter.js';
+import { EditorMode } from './EditorMode.js';
+
+export class StandardEditorMode extends EditorMode {
+  editorStore: EditorStore;
+
+  constructor(editorStore: EditorStore) {
+    super();
+    this.editorStore = editorStore;
+  }
+
+  generateElementLink(elementPath: string): string {
+    return generateViewEntityRoute(
+      this.editorStore.sdlcState.activeProject.projectId,
+      elementPath,
+    );
+  }
+}

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

@@ -0,0 +1,32 @@
+/**
+ * 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 { uuid } from '@finos/legend-shared';
+
+export abstract class EditorState {
+  /**
+   * NOTE: used to detect when an element editor state changes so we can force a remount of the editor component
+   */
+  readonly uuid = uuid();
+  editorStore: EditorStore;
+
+  constructor(editorStore: EditorStore) {
+    this.editorStore = editorStore;
+  }
+
+  abstract get headerName(): string;
+}

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

@@ -0,0 +1,107 @@
+/**
+ * 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,
+  guaranteeNonNullable,
+  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 '../LegendStudioAppEvent.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[] = [];
+
+  constructor(editorStore: EditorStore) {
+    makeObservable<ExternalFormatState>(this, {
+      externalFormatsDescriptions: 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((e) => ({
+      value: e.name,
+      label: e.name,
+    }));
+  }
+
+  getFormatTypeForContentType(contentType: string): string | undefined {
+    return this.externalFormatsDescriptions.find(
+      (externalFormatDescription) =>
+        externalFormatDescription.contentTypes[0] === contentType,
+    )?.name;
+  }
+
+  get formatContentTypes(): string[] {
+    return this.externalFormatsDescriptions.map((e) => e.contentTypes).flat();
+  }
+
+  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.fetchingDescriptionsState.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.EXTERNAL_FORMAT_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notifyError(error);
+      this.fetchingDescriptionsState.fail();
+    }
+  }
+
+  getTypeDescription(type: string): ExternalFormatDescription {
+    return guaranteeNonNullable(
+      this.externalFormatsDescriptions.find((e) => e.name === type),
+    );
+  }
+}

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

@@ -0,0 +1,319 @@
+/**
+ * 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, makeAutoObservable } from 'mobx';
+import { LEGEND_STUDIO_APP_EVENT } from '../LegendStudioAppEvent.js';
+import type { TreeData } from '@finos/legend-art';
+import {
+  type GenerationTreeNodeData,
+  type GenerationFile,
+  type GenerationOutputResult,
+  GenerationDirectory,
+  GENERATION_FILE_ROOT_NAME,
+  getGenerationTreeData,
+  openNode,
+  populateDirectoryTreeNodeChildren,
+  buildGenerationDirectory,
+  reprocessOpenNodes,
+} from '../shared/FileGenerationTreeUtil.js';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  deepEqual,
+  isEmpty,
+  LogEvent,
+} 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,
+  fileGeneration_addConfigurationProperty,
+  fileGeneration_addScopeElement,
+  fileGeneration_deleteScopeElement,
+} from '../graphModifier/DSLGeneration_GraphModifierHelper.js';
+
+export class FileGenerationState {
+  editorStore: EditorStore;
+  fileGeneration: FileGenerationSpecification;
+  isGenerating = false;
+  root: GenerationDirectory;
+  directoryTreeData?: TreeData<GenerationTreeNodeData> | undefined;
+  selectedNode?: GenerationTreeNodeData | undefined;
+  filesIndex = new Map<string, GenerationFile>();
+
+  constructor(
+    editorStore: EditorStore,
+    fileGeneration: FileGenerationSpecification,
+  ) {
+    makeAutoObservable(this, {
+      editorStore: false,
+      fileGeneration: false,
+      directoryTreeData: observable.ref,
+      selectedNode: observable.ref,
+      resetFileGeneration: action,
+      setIsGeneration: action,
+      setDirectoryTreeData: action,
+      processGenerationResult: action,
+      reprocessNodeTree: action,
+      setSelectedNode: action,
+      onTreeNodeSelect: action,
+      addScopeElement: action,
+      deleteScopeElement: action,
+      updateFileGenerationParameters: action,
+    });
+
+    this.editorStore = editorStore;
+    this.fileGeneration = fileGeneration;
+    this.root = new GenerationDirectory(GENERATION_FILE_ROOT_NAME);
+  }
+
+  resetFileGeneration(): void {
+    this.fileGeneration.configurationProperties = [];
+  }
+  setIsGeneration(isGenerating: boolean): void {
+    this.isGenerating = isGenerating;
+  }
+  setDirectoryTreeData(
+    directoryTreeData: TreeData<GenerationTreeNodeData>,
+  ): void {
+    this.directoryTreeData = directoryTreeData;
+  }
+  getOrCreateDirectory = (directoryName: string): GenerationDirectory =>
+    GenerationDirectory.getOrCreateDirectory(this.root, directoryName, true);
+
+  *generate(): GeneratorFn<void> {
+    this.isGenerating = true;
+    try {
+      // avoid wasting a network call when the scope is empty, we can short-circuit this
+      if (!this.fileGeneration.scopeElements.length) {
+        this.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.selectedNode = undefined;
+      this.processGenerationResult([]);
+      this.editorStore.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notifyError(error);
+    } finally {
+      this.isGenerating = false;
+    }
+  }
+
+  processGenerationResult(output: GenerationOutput[]): void {
+    this.root = new GenerationDirectory(GENERATION_FILE_ROOT_NAME);
+    this.filesIndex = new Map<string, GenerationFile>();
+    const openedNodeIds = this.directoryTreeData
+      ? Array.from(this.directoryTreeData.nodes.values())
+          .filter((node) => node.isOpen)
+          .map((node) => node.id)
+      : [];
+    const generationResultIndex = new Map<string, GenerationOutputResult>();
+    const rootFolder =
+      this.fileGeneration.generationOutputPath ??
+      this.fileGeneration.path.split(ELEMENT_PATH_DELIMITER).join('_');
+    output.forEach((entry) => {
+      entry.cleanFileName(rootFolder);
+      if (generationResultIndex.has(entry.fileName)) {
+        this.editorStore.applicationStore.log.warn(
+          LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
+          'Found 2 generation outputs with same path',
+        );
+      }
+      generationResultIndex.set(entry.fileName, {
+        generationOutput: entry,
+        parentId: this.fileGeneration.path,
+      });
+    });
+    // take generation outputs and put them into the root directory
+    buildGenerationDirectory(this.root, generationResultIndex, this.filesIndex);
+    this.directoryTreeData = getGenerationTreeData(this.root);
+    this.reprocessNodeTree(
+      Array.from(generationResultIndex.values()),
+      this.directoryTreeData,
+      openedNodeIds,
+    );
+  }
+
+  reprocessNodeTree(
+    generationResult: GenerationOutputResult[],
+    treeData: TreeData<GenerationTreeNodeData>,
+    openedNodeIds: string[],
+  ): void {
+    reprocessOpenNodes(treeData, this.filesIndex, this.root, openedNodeIds);
+    // select the current file node if available, else select the first output
+    const selectedFileNodePath =
+      generationResult.length === 1 ||
+      (this.selectedNode === undefined && generationResult.length !== 0)
+        ? (generationResult[0] as GenerationOutputResult).generationOutput
+            .fileName
+        : this.selectedNode?.fileNode.path;
+    if (selectedFileNodePath) {
+      const file = this.filesIndex.get(selectedFileNodePath);
+      if (file) {
+        const node = openNode(file, treeData);
+        if (node) {
+          this.onTreeNodeSelect(node, treeData);
+        }
+      } else {
+        this.selectedNode = undefined;
+      }
+    }
+    this.setDirectoryTreeData({ ...treeData });
+  }
+
+  setSelectedNode(node?: GenerationTreeNodeData): void {
+    if (this.selectedNode) {
+      this.selectedNode.isSelected = false;
+    }
+    if (node) {
+      node.isSelected = true;
+    }
+    this.selectedNode = node;
+  }
+
+  onTreeNodeSelect(
+    node: GenerationTreeNodeData,
+    treeData: TreeData<GenerationTreeNodeData>,
+  ): void {
+    if (node.childrenIds?.length) {
+      node.isOpen = !node.isOpen;
+      if (node.fileNode instanceof GenerationDirectory) {
+        populateDirectoryTreeNodeChildren(node, treeData);
+      }
+    }
+    this.setSelectedNode(node);
+    this.setDirectoryTreeData({ ...treeData });
+  }
+
+  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);
+    }
+  }
+
+  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,
+          );
+          fileGeneration_addConfigurationProperty(fileGeneration, 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,
+          );
+          fileGeneration_addConfigurationProperty(fileGeneration, newItem);
+        }
+      } else {
+        fileGeneration.configurationProperties =
+          fileGeneration.configurationProperties.filter(
+            (e) => e.name !== generationProperty.name,
+          );
+      }
+    }
+  }
+}

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

@@ -0,0 +1,70 @@
+/**
+ * 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 { EditorState } from './EditorState.js';
+import { observable, makeObservable, computed } from 'mobx';
+import type { GenerationFile } from '../shared/FileGenerationTreeUtil.js';
+import { EDITOR_LANGUAGE, TAB_SIZE } from '@finos/legend-application';
+import { returnUndefOnError } from '@finos/legend-shared';
+
+export const getTextContent = (
+  content: string,
+  format: string | undefined,
+): string => {
+  switch (format?.toLowerCase()) {
+    case EDITOR_LANGUAGE.JSON:
+      return (
+        returnUndefOnError(() =>
+          JSON.stringify(JSON.parse(content), undefined, TAB_SIZE),
+        ) ?? content
+      );
+    default:
+      return content;
+  }
+};
+
+export const getEditorLanguageFromFormat = (
+  format?: string,
+): EDITOR_LANGUAGE => {
+  switch (format?.toLowerCase()) {
+    case EDITOR_LANGUAGE.JAVA:
+      return EDITOR_LANGUAGE.JAVA;
+    case EDITOR_LANGUAGE.JSON:
+      return EDITOR_LANGUAGE.JSON;
+    default:
+      return EDITOR_LANGUAGE.TEXT;
+  }
+};
+
+export class FileGenerationViewerState extends EditorState {
+  generatedFile: GenerationFile;
+
+  constructor(editorStore: EditorStore, generatedFile: GenerationFile) {
+    super(editorStore);
+
+    makeObservable(this, {
+      generatedFile: observable,
+      headerName: computed,
+    });
+
+    this.generatedFile = generatedFile;
+  }
+
+  get headerName(): string {
+    return this.generatedFile.name;
+  }
+}

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

@@ -0,0 +1,125 @@
+/**
+ * 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 { ElementEditorState } from './element-editor-state/ElementEditorState.js';
+import {
+  guaranteeType,
+  uuid,
+  addUniqueEntry,
+  deleteEntry,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+import {
+  computed,
+  observable,
+  makeObservable,
+  makeAutoObservable,
+  action,
+} from 'mobx';
+import type { EditorStore } from '../EditorStore.js';
+import {
+  GenerationSpecification,
+  type GenerationTreeNode,
+  type PackageableElement,
+} from '@finos/legend-graph';
+import {
+  generationSpecification_addNode,
+  generationSpecification_deleteGenerationNode,
+} from '../graphModifier/DSLGeneration_GraphModifierHelper.js';
+
+export interface GenerationSpecNodeDragSource {
+  nodeState: GenerationTreeNodeState;
+}
+
+export type GenerationSpecNodeDropTarget = GenerationSpecNodeDragSource;
+export class GenerationTreeNodeState {
+  readonly uuid = uuid();
+  node: GenerationTreeNode;
+  isBeingDragged = false;
+
+  constructor(node: GenerationTreeNode) {
+    makeAutoObservable(this, {
+      setIsBeingDragged: action,
+    });
+    this.node = node;
+  }
+
+  setIsBeingDragged(val: boolean): void {
+    this.isBeingDragged = val;
+  }
+}
+
+export class GenerationSpecificationEditorState extends ElementEditorState {
+  isGenerating = false;
+  generationTreeNodeStates: GenerationTreeNodeState[] = [];
+
+  constructor(editorStore: EditorStore, element: PackageableElement) {
+    super(editorStore, element);
+
+    makeObservable(this, {
+      isGenerating: observable,
+      generationTreeNodeStates: observable,
+      spec: computed,
+      deleteGenerationTreeNode: action,
+      addGenerationTreeNode: action,
+      moveGenerationNode: action,
+    });
+    this.generationTreeNodeStates = this.spec.generationNodes.map(
+      (node) => new GenerationTreeNodeState(node),
+    );
+  }
+
+  get spec(): GenerationSpecification {
+    return guaranteeType(
+      this.element,
+      GenerationSpecification,
+      'Element inside generation specification state must be a generation specification',
+    );
+  }
+
+  deleteGenerationTreeNode(node: GenerationTreeNode): void {
+    generationSpecification_deleteGenerationNode(this.spec, node);
+    const nodeState = this.generationTreeNodeStates.find(
+      (g) => g.node === node,
+    );
+    if (nodeState) {
+      deleteEntry(this.generationTreeNodeStates, nodeState);
+    }
+  }
+
+  addGenerationTreeNode(node: GenerationTreeNode): void {
+    generationSpecification_addNode(this.spec, node);
+    addUniqueEntry(
+      this.generationTreeNodeStates,
+      new GenerationTreeNodeState(node),
+    );
+  }
+
+  moveGenerationNode(dragIndex: number, hoverIndex: number): void {
+    const dragColumn = guaranteeNonNullable(
+      this.generationTreeNodeStates[dragIndex],
+    );
+    this.generationTreeNodeStates.splice(dragIndex, 1);
+    this.generationTreeNodeStates.splice(hoverIndex, 0, dragColumn);
+  }
+
+  reprocess(
+    newElement: PackageableElement,
+    editorStore: EditorStore,
+  ): ElementEditorState {
+    return new GenerationSpecificationEditorState(editorStore, newElement);
+  }
+}