@finos/legend-application-studio 26.1.9 → 26.1.10

package/src/stores/editor/editor-state/{FileGenerationViewerState.ts → ArtifactGenerationViewerState.ts}

@@ -17,10 +17,10 @@
 import type { EditorStore } from '../EditorStore.js';
 import { EditorState } from './EditorState.js';
 import { observable, makeObservable, computed } from 'mobx';
-import type { FileSystem_File } from '../utils/FileSystemTreeUtils.js';
-import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
 import { returnUndefOnError } from '@finos/legend-shared';
+import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
 import { CODE_EDITOR_LANGUAGE } from '@finos/legend-lego/code-editor';
+import type { FileSystem_File } from '../utils/FileSystemTreeUtils.js';
 
 export const getTextContent = (
   content: string,
@@ -51,30 +51,33 @@ export const getEditorLanguageForFormat = (
   }
 };
 
-export class FileGenerationViewerState extends EditorState {
-  file: FileSystem_File;
+export class ArtifactGenerationViewerState extends EditorState {
+  artifact: FileSystem_File;
 
   constructor(editorStore: EditorStore, file: FileSystem_File) {
     super(editorStore);
 
     makeObservable(this, {
-      file: observable,
+      artifact: observable,
       label: computed,
       generatedFilePath: computed,
     });
 
-    this.file = file;
+    this.artifact = file;
   }
 
   get label(): string {
-    return this.file.name;
+    return this.artifact.name;
   }
 
   override match(tab: EditorState): boolean {
-    return tab instanceof FileGenerationViewerState && tab.file === this.file;
+    return (
+      tab instanceof ArtifactGenerationViewerState &&
+      tab.artifact === this.artifact
+    );
   }
 
   get generatedFilePath(): string {
-    return this.file.path;
+    return this.artifact.path;
   }
 }

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

@@ -230,7 +230,7 @@ export class FileGenerationState extends GeneratedFileStructureState {
         return;
       }
       const mode =
-        this.editorStore.graphState.graphGenerationState.getFileGenerationConfiguration(
+        this.editorStore.graphState.graphGenerationState.globalFileGenerationState.getFileGenerationConfiguration(
           this.fileGeneration.type,
         ).generationMode;
       const result =

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

@@ -31,22 +31,8 @@ import {
   isNonNullable,
   ActionState,
 } from '@finos/legend-shared';
-import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
-import {
-  type FileSystemTreeNodeData,
-  type FileResult,
-  FileSystem_Directory,
-  GENERATION_FILE_ROOT_NAME,
-  FileSystem_File,
-  openNode,
-  populateDirectoryTreeNodeChildren,
-  buildFileSystemDirectory,
-  reprocessOpenNodes,
-  getFileSystemTreeData,
-} from '../utils/FileSystemTreeUtils.js';
 import type { TreeData } from '@finos/legend-art';
 import type { EditorStore } from '../EditorStore.js';
-import { FileGenerationViewerState } from './FileGenerationViewerState.js';
 import type { EditorState } from './EditorState.js';
 import { ElementEditorState } from './element-editor-state/ElementEditorState.js';
 import { ElementFileGenerationState } from './element-editor-state/ElementFileGenerationState.js';
@@ -56,77 +42,66 @@ import {
   type GenerationOutput,
   type DSL_Generation_PureGraphManagerPlugin_Extension,
   type GenerationTreeNode,
+  ArtifactGenerationExtensionResult,
   Class,
   Enumeration,
   GenerationSpecification,
   ELEMENT_PATH_DELIMITER,
 } from '@finos/legend-graph';
-import type { DSL_Generation_LegendStudioApplicationPlugin_Extension } from '../../extensions/DSL_Generation_LegendStudioApplicationPlugin_Extension.js';
 import { ExternalFormatState } from './ExternalFormatState.js';
+import { ExplorerTreeRootPackageLabel } from '../ExplorerTreeState.js';
+import type { DSL_Generation_LegendStudioApplicationPlugin_Extension } from '../../extensions/DSL_Generation_LegendStudioApplicationPlugin_Extension.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
+import {
+  FileSystem_Directory,
+  type FileSystemTreeNodeData,
+  FileSystem_File,
+  GENERATION_FILE_ROOT_NAME,
+  buildFileSystemDirectory,
+  getFileSystemTreeData,
+  reprocessOpenNodes,
+  type FileResult,
+  openNode,
+  populateDirectoryTreeNodeChildren,
+} from '../utils/FileSystemTreeUtils.js';
+import { ArtifactGenerationViewerState } from './ArtifactGenerationViewerState.js';
 import {
   generationSpecification_addFileGeneration,
   generationSpecification_addGenerationElement,
 } from '../../graph-modifier/DSL_Generation_GraphModifierHelper.js';
-import { ExplorerTreeRootPackageLabel } from '../ExplorerTreeState.js';
 
 export const DEFAULT_GENERATION_SPECIFICATION_NAME =
   'MyGenerationSpecification';
 
-export type FileGenerationTypeOption = {
+export type GenerationTypeOption = {
   value: string;
   label: string;
 };
 
-export class GraphGenerationState {
+export class DEPREACTED_GlobalFileGenerationState {
+  readonly graphGenerationState: GraphGenerationState;
   readonly editorStore: EditorStore;
-  readonly clearingGenerationEntitiesState = ActionState.create();
-
-  isRunningGlobalGenerate = false;
-  generatedEntities = new Map<string, Entity[]>();
-  externalFormatState: ExternalFormatState;
   // NOTE: this will eventually be removed once we also do model/schema import using external format
   // See https://github.com/finos/legend-studio/issues/866
   fileGenerationConfigurations: GenerationConfigurationDescription[] = [];
-  // file generation output
-  rootFileDirectory: FileSystem_Directory;
-  filesIndex = new Map<string, FileSystem_File>();
-  selectedNode?: FileSystemTreeNodeData | undefined;
 
-  constructor(editorStore: EditorStore) {
-    makeObservable<GraphGenerationState>(this, {
-      isRunningGlobalGenerate: observable,
-      generatedEntities: observable.shallow,
-      clearingGenerationEntitiesState: observable,
+  constructor(
+    graphGenerationState: GraphGenerationState,
+    editorStore: EditorStore,
+  ) {
+    makeObservable(this, {
       fileGenerationConfigurations: observable,
-      externalFormatState: observable,
-      rootFileDirectory: observable,
-      filesIndex: observable,
-      selectedNode: observable.ref,
       fileGenerationConfigurationOptions: computed,
       supportedFileGenerationConfigurationsForCurrentElement: computed,
       setFileGenerationConfigurations: action,
-      processGenerationResult: action,
-      reprocessGenerationFileState: action,
-      reprocessNodeTree: action,
-      onTreeNodeSelect: action,
-      setSelectedNode: action,
-      emptyFileGeneration: action,
-      possiblyAddMissingGenerationSpecifications: flow,
       fetchAvailableFileGenerationDescriptions: flow,
-      globalGenerate: flow,
-      generateModels: flow,
-      generateFiles: flow,
-      clearGenerations: flow,
+      DEPREACTED_generateFiles: flow,
     });
-
+    this.graphGenerationState = graphGenerationState;
     this.editorStore = editorStore;
-    this.rootFileDirectory = new FileSystem_Directory(
-      GENERATION_FILE_ROOT_NAME,
-    );
-    this.externalFormatState = new ExternalFormatState(editorStore);
   }
 
-  get fileGenerationConfigurationOptions(): FileGenerationTypeOption[] {
+  get fileGenerationConfigurationOptions(): GenerationTypeOption[] {
     return this.fileGenerationConfigurations
       .slice()
       .sort((a, b): number => a.label.localeCompare(b.label))
@@ -172,11 +147,57 @@ export class GraphGenerationState {
     return [];
   }
 
-  findGenerationParentPath(genChildPath: string): string | undefined {
-    const genEntity = Array.from(this.generatedEntities.entries()).find(
-      ([, genEntities]) => genEntities.find((m) => m.path === genChildPath),
-    );
-    return genEntity?.[0];
+  /**
+   * Generated file generations in the graph.
+   * NOTE: This method does not update graph and application only the files are generated.
+   */
+  *DEPREACTED_generateFiles(
+    generationOutputIndex: Map<string, GenerationOutput[]>,
+  ): GeneratorFn<void> {
+    try {
+      const generationSpecs =
+        this.editorStore.graphManagerState.graph.ownGenerationSpecifications;
+      if (!generationSpecs.length) {
+        return;
+      }
+      assertTrue(
+        generationSpecs.length === 1,
+        `Can't generate models: only one generation specification permitted to generate`,
+      );
+      const generationSpec = generationSpecs[0] as GenerationSpecification;
+      const fileGenerations = generationSpec.fileGenerations;
+      // we don't need to keep 'fetching' the main model as it won't grow with each file generation
+      for (const fileGeneration of fileGenerations) {
+        let result: GenerationOutput[] = [];
+        try {
+          const mode =
+            this.editorStore.graphState.graphGenerationState.globalFileGenerationState.getFileGenerationConfiguration(
+              fileGeneration.value.type,
+            ).generationMode;
+          result =
+            (yield this.editorStore.graphManagerState.graphManager.generateFile(
+              fileGeneration.value,
+              mode,
+              this.editorStore.graphManagerState.graph,
+            )) as GenerationOutput[];
+        } catch (error) {
+          assertErrorThrown(error);
+          throw new Error(
+            `Can't generate files using specification '${fileGeneration.value.path}'. Error: ${error.message}`,
+          );
+        }
+        generationOutputIndex.set(fileGeneration.value.path, result);
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
+        error,
+      );
+      this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
+        `${error.message}`,
+      );
+    }
   }
 
   setFileGenerationConfigurations(
@@ -213,6 +234,70 @@ export class GraphGenerationState {
       this.editorStore.applicationStore.notificationService.notifyError(error);
     }
   }
+}
+
+export class GraphGenerationState {
+  editorStore: EditorStore;
+  isRunningGlobalGenerate = false;
+  generatedEntities = new Map<string, Entity[]>();
+  clearingGenerationEntitiesState = ActionState.create();
+  externalFormatState: ExternalFormatState;
+  globalFileGenerationState: DEPREACTED_GlobalFileGenerationState;
+  // file generation output
+  rootFileDirectory: FileSystem_Directory;
+  filesIndex = new Map<string, FileSystem_File>();
+  selectedNode?: FileSystemTreeNodeData | undefined;
+  // Note for now generation of artifact generations is set to false.
+  // This is to explore the performance impact of inlcuding this in the generation action and whether we always
+  // generate artifacts or add inputs to the api to choose which ones we generate.
+  enableArtifactGeneration = false;
+
+  constructor(editorStore: EditorStore) {
+    makeObservable<GraphGenerationState>(this, {
+      isRunningGlobalGenerate: observable,
+      generatedEntities: observable.shallow,
+      clearingGenerationEntitiesState: observable,
+      externalFormatState: observable,
+      enableArtifactGeneration: observable,
+      globalFileGenerationState: observable,
+      rootFileDirectory: observable,
+      filesIndex: observable,
+      selectedNode: observable.ref,
+      processGenerationResult: action,
+      reprocessGenerationFileState: action,
+      setEnableArtifactGeneration: action,
+      reprocessNodeTree: action,
+      onTreeNodeSelect: action,
+      setSelectedNode: action,
+      emptyGeneratedArtifacts: action,
+      possiblyAddMissingGenerationSpecifications: flow,
+      globalGenerate: flow,
+      generateModels: flow,
+      generateArtifacts: flow,
+      clearGenerations: flow,
+    });
+
+    this.editorStore = editorStore;
+    this.externalFormatState = new ExternalFormatState(editorStore);
+    this.globalFileGenerationState = new DEPREACTED_GlobalFileGenerationState(
+      this,
+      editorStore,
+    );
+    this.rootFileDirectory = new FileSystem_Directory(
+      GENERATION_FILE_ROOT_NAME,
+    );
+  }
+
+  setEnableArtifactGeneration(val: boolean): void {
+    this.enableArtifactGeneration = val;
+  }
+
+  findGenerationParentPath(genChildPath: string): string | undefined {
+    const genEntity = Array.from(this.generatedEntities.entries()).find(
+      ([, genEntities]) => genEntities.find((m) => m.path === genChildPath),
+    );
+    return genEntity?.[0];
+  }
 
   /**
    * Global generation is tied to the generation specification of the project. Every time a generation element
@@ -227,7 +312,7 @@ export class GraphGenerationState {
     this.isRunningGlobalGenerate = true;
     try {
       yield flowResult(this.generateModels());
-      yield flowResult(this.generateFiles());
+      yield flowResult(this.generateArtifacts());
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
@@ -296,47 +381,29 @@ export class GraphGenerationState {
   }
 
   /**
-   * Generated file generations in the graph.
+   * Generated artifacts generations in graph
    * NOTE: This method does not update graph and application only the files are generated.
    */
-  *generateFiles(): GeneratorFn<void> {
+  *generateArtifacts(): GeneratorFn<void> {
     try {
-      this.emptyFileGeneration();
+      this.emptyGeneratedArtifacts();
       const generationOutputIndex = new Map<string, GenerationOutput[]>();
-      const generationSpecs =
-        this.editorStore.graphManagerState.graph.ownGenerationSpecifications;
-      if (!generationSpecs.length) {
-        return;
-      }
-      assertTrue(
-        generationSpecs.length === 1,
-        `Can't generate models: only one generation specification permitted to generate`,
+      // handle deprecated file generations
+      yield flowResult(
+        this.globalFileGenerationState.DEPREACTED_generateFiles(
+          generationOutputIndex,
+        ),
       );
-      const generationSpec = generationSpecs[0] as GenerationSpecification;
-      const fileGenerations = generationSpec.fileGenerations;
-      // we don't need to keep 'fetching' the main model as it won't grow with each file generation
-      for (const fileGeneration of fileGenerations) {
-        let result: GenerationOutput[] = [];
-        try {
-          const mode =
-            this.editorStore.graphState.graphGenerationState.getFileGenerationConfiguration(
-              fileGeneration.value.type,
-            ).generationMode;
-          result =
-            (yield this.editorStore.graphManagerState.graphManager.generateFile(
-              fileGeneration.value,
-              mode,
-              this.editorStore.graphManagerState.graph,
-            )) as GenerationOutput[];
-        } catch (error) {
-          assertErrorThrown(error);
-          throw new Error(
-            `Can't generate files using specification '${fileGeneration.value.path}'. Error: ${error.message}`,
-          );
-        }
-        generationOutputIndex.set(fileGeneration.value.path, result);
+      let artifacts = new ArtifactGenerationExtensionResult();
+      if (this.enableArtifactGeneration) {
+        artifacts =
+          (yield this.editorStore.graphManagerState.graphManager.generateArtifacts(
+            this.editorStore.graphManagerState.graph,
+          )) as ArtifactGenerationExtensionResult;
       }
-      this.processGenerationResult(generationOutputIndex);
+
+      // handle results
+      this.processGenerationResult(artifacts, generationOutputIndex);
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
@@ -349,75 +416,16 @@ export class GraphGenerationState {
     }
   }
 
-  /**
-   * Used to clear generation entities as well as the generation model
-   */
-  *clearGenerations(): GeneratorFn<void> {
-    this.clearingGenerationEntitiesState.inProgress();
-    this.generatedEntities = new Map<string, Entity[]>();
-    this.emptyFileGeneration();
-    yield flowResult(
-      this.editorStore.graphState.updateGenerationGraphAndApplication(),
-    );
-    this.clearingGenerationEntitiesState.complete();
-  }
-
-  /**
-   * Method adds generation specification if
-   * 1. no generation specification has been defined in graph
-   * 2. there exists a generation element
-   */
-  *possiblyAddMissingGenerationSpecifications(): GeneratorFn<void> {
-    if (
-      !this.editorStore.graphManagerState.graph.ownGenerationSpecifications
-        .length
-    ) {
-      const modelGenerationElements = this.editorStore.pluginManager
-        .getPureGraphManagerPlugins()
-        .flatMap(
-          (plugin) =>
-            (
-              plugin as DSL_Generation_PureGraphManagerPlugin_Extension
-            ).getExtraModelGenerationElementGetters?.() ?? [],
-        )
-        .flatMap((getter) => getter(this.editorStore.graphManagerState.graph));
-      const fileGenerations =
-        this.editorStore.graphManagerState.graph.ownFileGenerations;
-      if (modelGenerationElements.length || fileGenerations.length) {
-        const generationSpec = new GenerationSpecification(
-          DEFAULT_GENERATION_SPECIFICATION_NAME,
-        );
-        modelGenerationElements.forEach((e) =>
-          generationSpecification_addGenerationElement(generationSpec, e),
-        );
-        fileGenerations.forEach((e) =>
-          generationSpecification_addFileGeneration(generationSpec, e),
-        );
-        // NOTE: add generation specification at the same package as the first generation element found.
-        // we might want to revisit this decision?
-        const specPackage = guaranteeNonNullable(
-          [...modelGenerationElements, ...fileGenerations][0]?.package,
-        );
-        yield flowResult(
-          this.editorStore.graphEditorMode.addElement(
-            generationSpec,
-            specPackage.path,
-            false,
-          ),
-        );
-      }
-    }
-  }
-
-  // File Generation Tree
+  // Artifact Generation Tree
   processGenerationResult(
+    artifacts: ArtifactGenerationExtensionResult,
     generationOutputIndex: Map<string, GenerationOutput[]>,
   ): void {
     // empty file index and the directory, we keep the open nodes to reprocess them
-    this.emptyFileGeneration();
+    this.emptyGeneratedArtifacts();
     const directoryTreeData =
       this.editorStore.graphState.editorStore.explorerTreeState
-        .fileGenerationTreeData;
+        .artifactsGenerationTreeData;
     const openedNodeIds = directoryTreeData
       ? Array.from(directoryTreeData.nodes.values())
           .filter((node) => node.isOpen)
@@ -425,14 +433,15 @@ export class GraphGenerationState {
       : [];
     // we read the generation outputs and clean
     const generationResultIndex = new Map<string, FileResult>();
+    // handle DEPRECATED file gen for backward compatible
     Array.from(generationOutputIndex.entries()).forEach((entry) => {
-      const fileGeneration =
+      const generator =
         this.editorStore.graphManagerState.graph.getNullableFileGeneration(
           entry[0],
         );
       const rootFolder =
-        fileGeneration?.generationOutputPath ??
-        fileGeneration?.path.split(ELEMENT_PATH_DELIMITER).join('_');
+        generator?.generationOutputPath ??
+        generator?.path.split(ELEMENT_PATH_DELIMITER).join('_');
       const generationOutputs = entry[1];
       generationOutputs.forEach((genOutput) => {
         genOutput.cleanFileName(rootFolder);
@@ -444,10 +453,29 @@ export class GraphGenerationState {
         }
         generationResultIndex.set(genOutput.fileName, {
           value: genOutput,
-          parentId: fileGeneration?.path,
+          parentId: generator?.path,
         });
       });
     });
+    artifacts.values
+      .map((v) => v.artifactsByExtensionElements)
+      .flat()
+      .forEach((artifactByElement) => {
+        artifactByElement.files.forEach((genOutput) => {
+          genOutput.cleanFileName();
+          if (generationResultIndex.has(genOutput.fileName)) {
+            this.editorStore.applicationStore.logService.warn(
+              LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
+              `Found 2 generation outputs with same path '${genOutput.fileName}'`,
+            );
+          }
+          generationResultIndex.set(genOutput.fileName, {
+            value: genOutput,
+            parentId: artifactByElement.element,
+          });
+        });
+      });
+
     // take generation outputs and put them into the root directory
     buildFileSystemDirectory(
       this.rootFileDirectory,
@@ -455,16 +483,16 @@ export class GraphGenerationState {
       this.filesIndex,
     );
     // after building root directory set the generation tree data
-    this.editorStore.graphState.editorStore.explorerTreeState.setFileGenerationTreeData(
+    this.editorStore.graphState.editorStore.explorerTreeState.setArtifactsGenerationTreeData(
       getFileSystemTreeData(
         this.editorStore.graphState.graphGenerationState.rootFileDirectory,
         ExplorerTreeRootPackageLabel.FILE_GENERATION,
       ),
     );
-    this.editorStore.graphState.editorStore.explorerTreeState.setFileGenerationTreeData(
+    this.editorStore.graphState.editorStore.explorerTreeState.setArtifactsGenerationTreeData(
       this.reprocessNodeTree(
         Array.from(generationResultIndex.values()),
-        this.editorStore.graphState.editorStore.explorerTreeState.getFileGenerationTreeData(),
+        this.editorStore.graphState.editorStore.explorerTreeState.getArtifactsGenerationTreeData(),
         openedNodeIds,
       ),
     );
@@ -477,10 +505,10 @@ export class GraphGenerationState {
   reprocessGenerationFileState(
     editorState: EditorState,
   ): EditorState | undefined {
-    if (editorState instanceof FileGenerationViewerState) {
-      const fileNode = this.filesIndex.get(editorState.file.path);
+    if (editorState instanceof ArtifactGenerationViewerState) {
+      const fileNode = this.filesIndex.get(editorState.artifact.path);
       if (fileNode) {
-        editorState.file = fileNode;
+        editorState.artifact = fileNode;
         return editorState;
       } else {
         return undefined;
@@ -533,11 +561,11 @@ export class GraphGenerationState {
     }
     if (!reprocess && node.fileNode instanceof FileSystem_File) {
       this.editorStore.tabManagerState.openTab(
-        new FileGenerationViewerState(this.editorStore, node.fileNode),
+        new ArtifactGenerationViewerState(this.editorStore, node.fileNode),
       );
     }
     this.setSelectedNode(node);
-    this.editorStore.graphState.editorStore.explorerTreeState.setFileGenerationTreeData(
+    this.editorStore.graphState.editorStore.explorerTreeState.setArtifactsGenerationTreeData(
       { ...treeData },
     );
   }
@@ -552,10 +580,70 @@ export class GraphGenerationState {
     this.selectedNode = node;
   }
 
-  emptyFileGeneration(): void {
+  emptyGeneratedArtifacts(): void {
     this.filesIndex = new Map<string, FileSystem_File>();
     this.rootFileDirectory = new FileSystem_Directory(
       GENERATION_FILE_ROOT_NAME,
     );
   }
+
+  /**
+   * Used to clear generation entities as well as the generation model
+   */
+  *clearGenerations(): GeneratorFn<void> {
+    this.clearingGenerationEntitiesState.inProgress();
+    this.generatedEntities = new Map<string, Entity[]>();
+    this.emptyGeneratedArtifacts();
+    yield flowResult(
+      this.editorStore.graphState.updateGenerationGraphAndApplication(),
+    );
+    this.clearingGenerationEntitiesState.complete();
+  }
+
+  /**
+   * Method adds generation specification if
+   * 1. no generation specification has been defined in graph
+   * 2. there exists a generation element
+   */
+  *possiblyAddMissingGenerationSpecifications(): GeneratorFn<void> {
+    if (
+      !this.editorStore.graphManagerState.graph.ownGenerationSpecifications
+        .length
+    ) {
+      const modelGenerationElements = this.editorStore.pluginManager
+        .getPureGraphManagerPlugins()
+        .flatMap(
+          (plugin) =>
+            (
+              plugin as DSL_Generation_PureGraphManagerPlugin_Extension
+            ).getExtraModelGenerationElementGetters?.() ?? [],
+        )
+        .flatMap((getter) => getter(this.editorStore.graphManagerState.graph));
+      const fileGenerations =
+        this.editorStore.graphManagerState.graph.ownFileGenerations;
+      if (modelGenerationElements.length || fileGenerations.length) {
+        const generationSpec = new GenerationSpecification(
+          DEFAULT_GENERATION_SPECIFICATION_NAME,
+        );
+        modelGenerationElements.forEach((e) =>
+          generationSpecification_addGenerationElement(generationSpec, e),
+        );
+        fileGenerations.forEach((e) =>
+          generationSpecification_addFileGeneration(generationSpec, e),
+        );
+        // NOTE: add generation specification at the same package as the first generation element found.
+        // we might want to revisit this decision?
+        const specPackage = guaranteeNonNullable(
+          [...modelGenerationElements, ...fileGenerations][0]?.package,
+        );
+        yield flowResult(
+          this.editorStore.graphEditorMode.addElement(
+            generationSpec,
+            specPackage.path,
+            false,
+          ),
+        );
+      }
+    }
+  }
 }

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

@@ -88,7 +88,7 @@ export class FileGenerationViewModeState extends ElementGenerationModeState {
   }
 
   get label(): string {
-    return this.editorStore.graphState.graphGenerationState.getFileGenerationConfiguration(
+    return this.editorStore.graphState.graphGenerationState.globalFileGenerationState.getFileGenerationConfiguration(
       this.elementGenerationState.fileGenerationType,
     ).label;
   }

package/src/stores/project-view/ProjectViewerStore.ts

@@ -439,7 +439,7 @@ export class ProjectViewerStore {
 
       // fetch available editor configurations
       yield Promise.all([
-        this.editorStore.graphState.graphGenerationState.fetchAvailableFileGenerationDescriptions(),
+        this.editorStore.graphState.graphGenerationState.globalFileGenerationState.fetchAvailableFileGenerationDescriptions(),
         this.editorStore.graphState.graphGenerationState.externalFormatState.fetchExternalFormatDescriptions(),
         this.editorStore.graphState.graphGenerationState.externalFormatState.fetchExternalFormatDescriptions(),
         this.editorStore.graphState.fetchAvailableFunctionActivatorConfigurations(),