@finos/legend-application-studio 22.2.1 → 22.3.1

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

@@ -17,25 +17,21 @@
 import type { EditorStore } from '../EditorStore.js';
 import { observable, action, makeObservable, flow } 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,
+  type FileSystem_File,
+  type FileResult,
+  FileSystem_Directory,
   GENERATION_FILE_ROOT_NAME,
-  getGenerationTreeData,
-  openNode,
-  populateDirectoryTreeNodeChildren,
-  buildGenerationDirectory,
-  reprocessOpenNodes,
-} from '../shared/FileGenerationTreeUtils.js';
+  getFileSystemTreeData,
+  buildFileSystemDirectory,
+} from '../shared/FileSystemTreeUtils.js';
 import {
   type GeneratorFn,
   assertErrorThrown,
   deepEqual,
   isEmpty,
   LogEvent,
+  ActionState,
 } from '@finos/legend-shared';
 import {
   type FileGenerationSpecification,
@@ -55,113 +51,40 @@ import {
   fileGeneration_addScopeElement,
   fileGeneration_deleteScopeElement,
 } from '../shared/modifier/DSL_Generation_GraphModifierHelper.js';
+import { FileSystemState } from './FileSystemState.js';
 
-export class FileGenerationState {
+export abstract class GeneratedFileStructureState {
   readonly editorStore: EditorStore;
-  readonly fileGeneration: FileGenerationSpecification;
-
-  isGenerating = false;
-  root: GenerationDirectory;
-  directoryTreeData?: TreeData<GenerationTreeNodeData> | undefined;
-  selectedNode?: GenerationTreeNodeData | undefined;
-  filesIndex = new Map<string, GenerationFile>();
-
-  constructor(
-    editorStore: EditorStore,
-    fileGeneration: FileGenerationSpecification,
-  ) {
-    makeObservable(this, {
-      isGenerating: observable,
-      root: observable,
-      directoryTreeData: observable.ref,
-      selectedNode: observable.ref,
-      filesIndex: observable,
-      resetFileGeneration: action,
-      setIsGeneration: action,
-      setDirectoryTreeData: action,
-      processGenerationResult: action,
-      reprocessNodeTree: action,
-      setSelectedNode: action,
-      onTreeNodeSelect: action,
-      addScopeElement: action,
-      deleteScopeElement: action,
-      updateFileGenerationParameters: action,
-      generate: flow,
-    });
+  fileSystemState: FileSystemState;
+  generatingAction = ActionState.create();
+  rootDirectoryName: string;
 
+  constructor(rootDirectory: string, editorStore: EditorStore) {
+    this.rootDirectoryName = rootDirectory;
+    this.fileSystemState = new FileSystemState(rootDirectory);
     this.editorStore = editorStore;
-    this.fileGeneration = fileGeneration;
-    this.root = new GenerationDirectory(GENERATION_FILE_ROOT_NAME);
   }
 
-  getOrCreateDirectory(directoryName: string): GenerationDirectory {
-    return GenerationDirectory.getOrCreateDirectory(
-      this.root,
-      directoryName,
-      true,
-    );
-  }
+  abstract resetGenerator(): void;
 
-  resetFileGeneration(): void {
-    this.fileGeneration.configurationProperties = [];
-  }
+  abstract generate(): GeneratorFn<void>;
 
-  setIsGeneration(isGenerating: boolean): void {
-    this.isGenerating = isGenerating;
-  }
+  abstract get rootFolder(): string;
 
-  setDirectoryTreeData(
-    directoryTreeData: TreeData<GenerationTreeNodeData>,
-  ): void {
-    this.directoryTreeData = directoryTreeData;
-  }
-
-  *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;
-    }
-  }
+  abstract get generationParentId(): string | undefined;
 
   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())
+    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, GenerationOutputResult>();
-    const rootFolder =
-      this.fileGeneration.generationOutputPath ??
-      this.fileGeneration.path.split(ELEMENT_PATH_DELIMITER).join('_');
+    const generationResultIndex = new Map<string, FileResult>();
+    const rootFolder = this.rootFolder;
     output.forEach((entry) => {
       entry.cleanFileName(rootFolder);
       if (generationResultIndex.has(entry.fileName)) {
@@ -171,98 +94,61 @@ export class FileGenerationState {
         );
       }
       generationResultIndex.set(entry.fileName, {
-        generationOutput: entry,
-        parentId: this.fileGeneration.path,
+        value: entry,
+        parentId: this.generationParentId,
       });
     });
     // take generation outputs and put them into the root directory
-    buildGenerationDirectory(this.root, generationResultIndex, this.filesIndex);
-    this.directoryTreeData = getGenerationTreeData(this.root);
-    this.reprocessNodeTree(
+    buildFileSystemDirectory(
+      this.fileSystemState.root,
+      generationResultIndex,
+      this.fileSystemState.filesIndex,
+    );
+    this.fileSystemState.directoryTreeData = getFileSystemTreeData(
+      this.fileSystemState.root,
+    );
+    this.fileSystemState.reprocessNodeTree(
       Array.from(generationResultIndex.values()),
-      this.directoryTreeData,
+      this.fileSystemState.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;
-  }
+export class FileGenerationState extends GeneratedFileStructureState {
+  readonly fileGeneration: FileGenerationSpecification;
 
-  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 });
+  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;
   }
 
-  getScopeElement(
-    element: PackageableElement | string,
-  ): PackageableElementReference<PackageableElement> | string | undefined {
-    return this.fileGeneration.scopeElements.find((el) =>
-      el instanceof PackageableElementReference
-        ? el.value === element
-        : element === el,
+  get rootFolder(): string {
+    return (
+      this.fileGeneration.generationOutputPath ??
+      this.fileGeneration.path.split(ELEMENT_PATH_DELIMITER).join('_')
     );
   }
 
-  addScopeElement(element: PackageableElement | string): void {
-    const el = this.getScopeElement(element);
-    if (!el) {
-      fileGeneration_addScopeElement(
-        this.fileGeneration,
-        element instanceof PackageableElement
-          ? PackageableElementExplicitReference.create(element)
-          : element,
-      );
-    }
+  get generationParentId(): string | undefined {
+    return this.fileGeneration.path;
   }
 
-  deleteScopeElement(element: PackageableElement | string): void {
-    const el = this.getScopeElement(element);
-    if (el) {
-      fileGeneration_deleteScopeElement(this.fileGeneration, el);
-    }
+  resetGenerator(): void {
+    this.fileGeneration.configurationProperties = [];
   }
 
   updateFileGenerationParameters(
@@ -333,4 +219,67 @@ export class FileGenerationState {
       }
     }
   }
+
+  *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.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.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-state/FileGenerationViewerState.ts

@@ -17,7 +17,7 @@
 import type { EditorStore } from '../EditorStore.js';
 import { EditorState } from './EditorState.js';
 import { observable, makeObservable, computed } from 'mobx';
-import type { GenerationFile } from '../shared/FileGenerationTreeUtils.js';
+import type { FileSystem_File } from '../shared/FileSystemTreeUtils.js';
 import { EDITOR_LANGUAGE, TAB_SIZE } from '@finos/legend-application';
 import { returnUndefOnError } from '@finos/legend-shared';
 
@@ -51,9 +51,9 @@ export const getEditorLanguageForFormat = (
 };
 
 export class FileGenerationViewerState extends EditorState {
-  file: GenerationFile;
+  file: FileSystem_File;
 
-  constructor(editorStore: EditorStore, file: GenerationFile) {
+  constructor(editorStore: EditorStore, file: FileSystem_File) {
     super(editorStore);
 
     makeObservable(this, {

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

@@ -0,0 +1,111 @@
+/**
+ * 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 { TreeData } from '@finos/legend-art';
+import { action, makeObservable, observable } from 'mobx';
+import {
+  type FileResult,
+  type FileSystemTreeNodeData,
+  type FileSystem_File,
+  FileSystem_Directory,
+  openNode,
+  populateDirectoryTreeNodeChildren,
+  reprocessOpenNodes,
+} from '../shared/FileSystemTreeUtils.js';
+
+export class FileSystemState {
+  root: FileSystem_Directory;
+  directoryTreeData?: TreeData<FileSystemTreeNodeData> | undefined;
+  selectedNode?: FileSystemTreeNodeData | undefined;
+  filesIndex = new Map<string, FileSystem_File>();
+
+  constructor(root: string) {
+    this.root = new FileSystem_Directory(root);
+    makeObservable(this, {
+      root: observable,
+      directoryTreeData: observable.ref,
+      selectedNode: observable.ref,
+      reprocessNodeTree: action,
+      setDirectoryTreeData: action,
+      onTreeNodeSelect: action,
+      setSelectedNode: action,
+    });
+  }
+
+  getOrCreateDirectory(directoryName: string): FileSystem_Directory {
+    return FileSystem_Directory.getOrCreateDirectory(
+      this.root,
+      directoryName,
+      true,
+    );
+  }
+
+  setDirectoryTreeData(
+    directoryTreeData: TreeData<FileSystemTreeNodeData>,
+  ): void {
+    this.directoryTreeData = directoryTreeData;
+  }
+
+  reprocessNodeTree(
+    generationResult: FileResult[],
+    treeData: TreeData<FileSystemTreeNodeData>,
+    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 FileResult).value.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 });
+  }
+
+  onTreeNodeSelect(
+    node: FileSystemTreeNodeData,
+    treeData: TreeData<FileSystemTreeNodeData>,
+  ): void {
+    if (node.childrenIds?.length) {
+      node.isOpen = !node.isOpen;
+      if (node.fileNode instanceof FileSystem_Directory) {
+        populateDirectoryTreeNodeChildren(node, treeData);
+      }
+    }
+    this.setSelectedNode(node);
+    this.setDirectoryTreeData({ ...treeData });
+  }
+
+  setSelectedNode(node?: FileSystemTreeNodeData): void {
+    if (this.selectedNode) {
+      this.selectedNode.isSelected = false;
+    }
+    if (node) {
+      node.isSelected = true;
+    }
+    this.selectedNode = node;
+  }
+}

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

@@ -29,20 +29,21 @@ import {
   assertErrorThrown,
   guaranteeNonNullable,
   isNonNullable,
+  ActionState,
 } from '@finos/legend-shared';
 import { LEGEND_STUDIO_APP_EVENT } from '../LegendStudioAppEvent.js';
 import {
-  type GenerationTreeNodeData,
-  type GenerationOutputResult,
-  GenerationDirectory,
+  type FileSystemTreeNodeData,
+  type FileResult,
+  FileSystem_Directory,
   GENERATION_FILE_ROOT_NAME,
-  GenerationFile,
+  FileSystem_File,
   openNode,
   populateDirectoryTreeNodeChildren,
-  buildGenerationDirectory,
+  buildFileSystemDirectory,
   reprocessOpenNodes,
-  getGenerationTreeData,
-} from '../shared/FileGenerationTreeUtils.js';
+  getFileSystemTreeData,
+} from '../shared/FileSystemTreeUtils.js';
 import type { TreeData } from '@finos/legend-art';
 import type { EditorStore } from '../EditorStore.js';
 import { FileGenerationViewerState } from './FileGenerationViewerState.js';
@@ -80,21 +81,21 @@ export class GraphGenerationState {
   editorStore: EditorStore;
   isRunningGlobalGenerate = false;
   generatedEntities = new Map<string, Entity[]>();
-  isClearingGenerationEntities = false;
+  clearingGenerationEntitiesState = ActionState.create();
   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: GenerationDirectory;
-  filesIndex = new Map<string, GenerationFile>();
-  selectedNode?: GenerationTreeNodeData | undefined;
+  rootFileDirectory: FileSystem_Directory;
+  filesIndex = new Map<string, FileSystem_File>();
+  selectedNode?: FileSystemTreeNodeData | undefined;
 
   constructor(editorStore: EditorStore) {
     makeObservable<GraphGenerationState>(this, {
       isRunningGlobalGenerate: observable,
       generatedEntities: observable.shallow,
-      isClearingGenerationEntities: observable,
+      clearingGenerationEntitiesState: observable,
       fileGenerationConfigurations: observable,
       externalFormatState: observable,
       rootFileDirectory: observable,
@@ -118,7 +119,9 @@ export class GraphGenerationState {
     });
 
     this.editorStore = editorStore;
-    this.rootFileDirectory = new GenerationDirectory(GENERATION_FILE_ROOT_NAME);
+    this.rootFileDirectory = new FileSystem_Directory(
+      GENERATION_FILE_ROOT_NAME,
+    );
     this.externalFormatState = new ExternalFormatState(editorStore);
   }
 
@@ -349,13 +352,13 @@ export class GraphGenerationState {
    * Used to clear generation entities as well as the generation model
    */
   *clearGenerations(): GeneratorFn<void> {
-    this.isClearingGenerationEntities = true;
+    this.clearingGenerationEntitiesState.inProgress();
     this.generatedEntities = new Map<string, Entity[]>();
     this.emptyFileGeneration();
     yield flowResult(
       this.editorStore.graphState.updateGenerationGraphAndApplication(),
     );
-    this.isClearingGenerationEntities = false;
+    this.clearingGenerationEntitiesState.complete();
   }
 
   /**
@@ -416,7 +419,7 @@ export class GraphGenerationState {
           .map((node) => node.id)
       : [];
     // we read the generation outputs and clean
-    const generationResultIndex = new Map<string, GenerationOutputResult>();
+    const generationResultIndex = new Map<string, FileResult>();
     Array.from(generationOutputIndex.entries()).forEach((entry) => {
       const fileGeneration =
         this.editorStore.graphManagerState.graph.getNullableFileGeneration(
@@ -435,20 +438,20 @@ export class GraphGenerationState {
           );
         }
         generationResultIndex.set(genOutput.fileName, {
-          generationOutput: genOutput,
+          value: genOutput,
           parentId: fileGeneration?.path,
         });
       });
     });
     // take generation outputs and put them into the root directory
-    buildGenerationDirectory(
+    buildFileSystemDirectory(
       this.rootFileDirectory,
       generationResultIndex,
       this.filesIndex,
     );
     // after building root directory set the generation tree data
     this.editorStore.graphState.editorStore.explorerTreeState.setFileGenerationTreeData(
-      getGenerationTreeData(
+      getFileSystemTreeData(
         this.editorStore.graphState.graphGenerationState.rootFileDirectory,
         ExplorerTreeRootPackageLabel.FILE_GENERATION,
       ),
@@ -482,10 +485,10 @@ export class GraphGenerationState {
   }
 
   reprocessNodeTree(
-    generationResult: GenerationOutputResult[],
-    treeData: TreeData<GenerationTreeNodeData>,
+    generationResult: FileResult[],
+    treeData: TreeData<FileSystemTreeNodeData>,
     openedNodeIds: string[],
-  ): TreeData<GenerationTreeNodeData> {
+  ): TreeData<FileSystemTreeNodeData> {
     reprocessOpenNodes(
       treeData,
       this.filesIndex,
@@ -496,8 +499,7 @@ export class GraphGenerationState {
     const selectedFileNodePath =
       this.selectedNode?.fileNode.path ??
       (generationResult.length === 1
-        ? (generationResult[0] as GenerationOutputResult).generationOutput
-            .fileName
+        ? (generationResult[0] as FileResult).value.fileName
         : undefined);
     if (selectedFileNodePath) {
       const file = this.filesIndex.get(selectedFileNodePath);
@@ -514,17 +516,17 @@ export class GraphGenerationState {
   }
 
   onTreeNodeSelect(
-    node: GenerationTreeNodeData,
-    treeData: TreeData<GenerationTreeNodeData>,
+    node: FileSystemTreeNodeData,
+    treeData: TreeData<FileSystemTreeNodeData>,
     reprocess?: boolean,
   ): void {
     if (node.childrenIds?.length) {
       node.isOpen = !node.isOpen;
-      if (node.fileNode instanceof GenerationDirectory) {
+      if (node.fileNode instanceof FileSystem_Directory) {
         populateDirectoryTreeNodeChildren(node, treeData);
       }
     }
-    if (!reprocess && node.fileNode instanceof GenerationFile) {
+    if (!reprocess && node.fileNode instanceof FileSystem_File) {
       this.editorStore.tabManagerState.openTab(
         new FileGenerationViewerState(this.editorStore, node.fileNode),
       );
@@ -535,7 +537,7 @@ export class GraphGenerationState {
     );
   }
 
-  setSelectedNode(node?: GenerationTreeNodeData): void {
+  setSelectedNode(node?: FileSystemTreeNodeData): void {
     if (this.selectedNode) {
       this.selectedNode.isSelected = false;
     }
@@ -546,7 +548,9 @@ export class GraphGenerationState {
   }
 
   emptyFileGeneration(): void {
-    this.filesIndex = new Map<string, GenerationFile>();
-    this.rootFileDirectory = new GenerationDirectory(GENERATION_FILE_ROOT_NAME);
+    this.filesIndex = new Map<string, FileSystem_File>();
+    this.rootFileDirectory = new FileSystem_Directory(
+      GENERATION_FILE_ROOT_NAME,
+    );
   }
 }