@finos/legend-application-studio 23.0.0 → 23.0.1

package/src/stores/EditorStore.ts

@@ -1,978 +0,0 @@
-/**
- * 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 {
-  action,
-  computed,
-  flow,
-  flowResult,
-  makeObservable,
-  observable,
-} from 'mobx';
-import { ExplorerTreeState } from './ExplorerTreeState.js';
-import {
-  ACTIVITY_MODE,
-  AUX_PANEL_MODE,
-  GRAPH_EDITOR_MODE,
-  EDITOR_MODE,
-} from './EditorConfig.js';
-import {
-  type GraphBuilderResult,
-  EditorGraphState,
-  GraphBuilderStatus,
-} from './EditorGraphState.js';
-import { ChangeDetectionState } from './ChangeDetectionState.js';
-import { NewElementState } from './editor/NewElementState.js';
-import { WorkspaceUpdaterState } from './sidebar-state/WorkspaceUpdaterState.js';
-import { ProjectOverviewState } from './sidebar-state/ProjectOverviewState.js';
-import { WorkspaceReviewState } from './sidebar-state/WorkspaceReviewState.js';
-import {
-  FormLocalChangesState,
-  type LocalChangesState,
-} from './sidebar-state/LocalChangesState.js';
-import { WorkspaceWorkflowManagerState } from './sidebar-state/WorkflowManagerState.js';
-import {
-  type GeneratorFn,
-  type PlainObject,
-  LogEvent,
-  isNonNullable,
-  assertErrorThrown,
-  guaranteeNonNullable,
-  UnsupportedOperationError,
-  ActionState,
-  AssertionError,
-  guaranteeType,
-  type Clazz,
-} from '@finos/legend-shared';
-import { EditorSDLCState } from './EditorSDLCState.js';
-import { ModelImporterState } from './editor-state/ModelImporterState.js';
-import { ProjectConfigurationEditorState } from './editor-state/project-configuration-editor-state/ProjectConfigurationEditorState.js';
-import { CHANGE_DETECTION_EVENT } from './ChangeDetectionEvent.js';
-import type { ElementFileGenerationState } from './editor-state/element-editor-state/ElementFileGenerationState.js';
-import { DevToolState } from './aux-panel-state/DevToolState.js';
-import {
-  generateEditorRoute,
-  generateSetupRoute,
-  generateViewProjectRoute,
-  type WorkspaceEditorPathParams,
-} from '../application/LegendStudioNavigation.js';
-import { NonBlockingDialogState, PanelDisplayState } from '@finos/legend-art';
-import type { DSL_LegendStudioApplicationPlugin_Extension } from './LegendStudioApplicationPlugin.js';
-import type { Entity } from '@finos/legend-storage';
-import {
-  ProjectConfiguration,
-  WorkspaceType,
-  type SDLCServerClient,
-} from '@finos/legend-server-sdlc';
-import { GraphManagerState, GRAPH_MANAGER_EVENT } from '@finos/legend-graph';
-import type { DepotServerClient } from '@finos/legend-server-depot';
-import type { LegendStudioPluginManager } from '../application/LegendStudioPluginManager.js';
-import {
-  type CommandRegistrar,
-  ActionAlertActionType,
-  ActionAlertType,
-  APPLICATION_EVENT,
-  TAB_SIZE,
-} from '@finos/legend-application';
-import { LEGEND_STUDIO_APP_EVENT } from '../application/LegendStudioEvent.js';
-import type { EditorMode } from './editor/EditorMode.js';
-import { StandardEditorMode } from './editor/StandardEditorMode.js';
-import { WorkspaceUpdateConflictResolutionState } from './sidebar-state/WorkspaceUpdateConflictResolutionState.js';
-import { PACKAGEABLE_ELEMENT_TYPE } from './shared/ModelClassifierUtils.js';
-import { GlobalTestRunnerState } from './sidebar-state/testable/GlobalTestRunnerState.js';
-import type { LegendStudioApplicationStore } from './LegendStudioBaseStore.js';
-import { EmbeddedQueryBuilderState } from './EmbeddedQueryBuilderState.js';
-import { LEGEND_STUDIO_COMMAND_KEY } from '../application/LegendStudioCommand.js';
-import { EditorTabManagerState } from './EditorTabManagerState.js';
-import type { ProjectViewerEditorMode } from './project-viewer/ProjectViewerEditorMode.js';
-import { GraphEditFormModeState } from './GraphEditFormModeState.js';
-import type { GraphEditorMode } from './GraphEditorMode.js';
-import { GraphEditGrammarModeState } from './GraphEditGrammarModeState.js';
-import { BulkServiceRegistrationState } from './sidebar-state/BulkServiceRegistrationState.js';
-
-export abstract class EditorExtensionState {
-  /**
-   * This helps to better type-check for this empty abtract type
-   * See https://github.com/finos/legend-studio/blob/master/docs/technical/typescript-usage.md#understand-typescript-structual-type-system
-   */
-  private readonly _$nominalTypeBrand!: 'EditorExtensionState';
-}
-
-export class EditorStore implements CommandRegistrar {
-  readonly applicationStore: LegendStudioApplicationStore;
-  readonly sdlcServerClient: SDLCServerClient;
-  readonly depotServerClient: DepotServerClient;
-  readonly pluginManager: LegendStudioPluginManager;
-
-  readonly initState = ActionState.create();
-  initialEntityPath?: string | undefined;
-  editorMode: EditorMode;
-  // NOTE: once we clear up the editor store to make modes more separated
-  // we should remove these sets of functions. They are basically hacks to
-  // ensure hiding parts of the UI based on the editing mode.
-  // Instead, we will gradually move these `boolean` flags into `EditorMode`
-  // See https://github.com/finos/legend-studio/issues/317
-  mode = EDITOR_MODE.STANDARD;
-
-  editorExtensionStates: EditorExtensionState[] = [];
-  explorerTreeState: ExplorerTreeState;
-  sdlcState: EditorSDLCState;
-  graphState: EditorGraphState;
-  graphManagerState: GraphManagerState;
-  graphEditorMode: GraphEditorMode;
-  changeDetectionState: ChangeDetectionState;
-  modelImporterState: ModelImporterState;
-  projectConfigurationEditorState: ProjectConfigurationEditorState;
-  projectOverviewState: ProjectOverviewState;
-  workspaceWorkflowManagerState: WorkspaceWorkflowManagerState;
-  globalTestRunnerState: GlobalTestRunnerState;
-  workspaceUpdaterState: WorkspaceUpdaterState;
-  workspaceReviewState: WorkspaceReviewState;
-  localChangesState: LocalChangesState;
-  conflictResolutionState: WorkspaceUpdateConflictResolutionState;
-  devToolState: DevToolState;
-  embeddedQueryBuilderState: EmbeddedQueryBuilderState;
-  newElementState: NewElementState;
-  bulkServiceRegistrationState: BulkServiceRegistrationState;
-  /**
-   * Since we want to share element generation state across all element in the editor, we will create 1 element generate state
-   * per file generation configuration type.
-   */
-  elementGenerationStates: ElementFileGenerationState[] = [];
-  searchElementCommandState = new NonBlockingDialogState();
-
-  activeAuxPanelMode: AUX_PANEL_MODE = AUX_PANEL_MODE.CONSOLE;
-  readonly auxPanelDisplayState = new PanelDisplayState({
-    initial: 0,
-    default: 300,
-    snap: 100,
-  });
-  activeActivity?: ACTIVITY_MODE = ACTIVITY_MODE.EXPLORER;
-  readonly sideBarDisplayState = new PanelDisplayState({
-    initial: 300,
-    default: 300,
-    snap: 150,
-  });
-  readonly tabManagerState = new EditorTabManagerState(this);
-
-  constructor(
-    applicationStore: LegendStudioApplicationStore,
-    sdlcServerClient: SDLCServerClient,
-    depotServerClient: DepotServerClient,
-  ) {
-    makeObservable<
-      EditorStore,
-      'initStandardMode' | 'initConflictResolutionMode'
-    >(this, {
-      editorMode: observable,
-      mode: observable,
-      activeAuxPanelMode: observable,
-      activeActivity: observable,
-      graphEditorMode: observable,
-
-      isInViewerMode: computed,
-      isInConflictResolutionMode: computed,
-      isInitialized: computed,
-
-      setEditorMode: action,
-      setMode: action,
-
-      setActiveAuxPanelMode: action,
-      cleanUp: action,
-      reset: action,
-      setActiveActivity: action,
-
-      initialize: flow,
-      initMode: flow,
-      initStandardMode: flow,
-      initConflictResolutionMode: flow,
-      buildGraph: flow,
-      toggleTextMode: flow,
-      switchModes: flow,
-    });
-
-    this.applicationStore = applicationStore;
-    this.sdlcServerClient = sdlcServerClient;
-    this.depotServerClient = depotServerClient;
-    this.pluginManager = applicationStore.pluginManager;
-
-    this.editorMode = new StandardEditorMode(this);
-
-    this.sdlcState = new EditorSDLCState(this);
-    this.graphState = new EditorGraphState(this);
-    this.graphManagerState = new GraphManagerState(
-      applicationStore.pluginManager,
-      applicationStore.logService,
-    );
-    this.graphEditorMode = new GraphEditFormModeState(this);
-    this.changeDetectionState = new ChangeDetectionState(this, this.graphState);
-    this.devToolState = new DevToolState(this);
-    this.embeddedQueryBuilderState = new EmbeddedQueryBuilderState(this);
-    // side bar panels
-    this.explorerTreeState = new ExplorerTreeState(this);
-    this.projectOverviewState = new ProjectOverviewState(this, this.sdlcState);
-    this.globalTestRunnerState = new GlobalTestRunnerState(
-      this,
-      this.sdlcState,
-    );
-    this.workspaceWorkflowManagerState = new WorkspaceWorkflowManagerState(
-      this,
-      this.sdlcState,
-    );
-    this.workspaceUpdaterState = new WorkspaceUpdaterState(
-      this,
-      this.sdlcState,
-    );
-    this.workspaceReviewState = new WorkspaceReviewState(this, this.sdlcState);
-    this.localChangesState = new FormLocalChangesState(this, this.sdlcState);
-    this.conflictResolutionState = new WorkspaceUpdateConflictResolutionState(
-      this,
-      this.sdlcState,
-    );
-    this.newElementState = new NewElementState(this);
-    this.bulkServiceRegistrationState = new BulkServiceRegistrationState(
-      this,
-      this.sdlcState,
-    );
-    // special (singleton) editors
-    this.modelImporterState = new ModelImporterState(this);
-    this.projectConfigurationEditorState = new ProjectConfigurationEditorState(
-      this,
-      this.sdlcState,
-    );
-    // extensions
-    this.editorExtensionStates = this.pluginManager
-      .getApplicationPlugins()
-      .flatMap(
-        (plugin) => plugin.getExtraEditorExtensionStateCreators?.() ?? [],
-      )
-      .map((creator) => creator(this))
-      .filter(isNonNullable);
-  }
-
-  get isInitialized(): boolean {
-    if (this.isInViewerMode) {
-      return (
-        (Boolean(
-          this.sdlcState.currentProject && this.sdlcState.currentWorkspace,
-        ) ||
-          Boolean(
-            (this.sdlcState.editorStore.editorMode as ProjectViewerEditorMode)
-              .viewerStore.projectGAVCoordinates,
-          )) &&
-        this.graphManagerState.systemBuildState.hasSucceeded
-      );
-    } else {
-      return (
-        Boolean(
-          this.sdlcState.currentProject &&
-            this.sdlcState.currentWorkspace &&
-            this.sdlcState.currentRevision &&
-            this.sdlcState.remoteWorkspaceRevision,
-        ) && this.graphManagerState.systemBuildState.hasSucceeded
-      );
-    }
-  }
-
-  get isInViewerMode(): boolean {
-    return this.mode === EDITOR_MODE.VIEWER;
-  }
-
-  get isInConflictResolutionMode(): boolean {
-    return this.mode === EDITOR_MODE.CONFLICT_RESOLUTION;
-  }
-
-  setEditorMode(val: EditorMode): void {
-    this.editorMode = val;
-  }
-
-  setMode(val: EDITOR_MODE): void {
-    this.mode = val;
-  }
-
-  cleanUp(): void {
-    // dismiss all the alerts as these are parts of application, if we don't do this, we might
-    // end up blocking other parts of the app
-    // e.g. trying going to an unknown workspace, we will be redirected to the home page
-    // but the blocking alert for not-found workspace will still block the app
-    this.applicationStore.alertService.setBlockingAlert(undefined);
-    this.applicationStore.alertService.setActionAlertInfo(undefined);
-    // stop change detection to avoid memory-leak
-    this.changeDetectionState.stop();
-  }
-
-  /**
-   * TODO?: we should really think of how we could simplify the trigger condition below
-   * after we refactor editor modes
-   *
-   * See https://github.com/finos/legend-studio/issues/317
-   */
-  createEditorCommandTrigger(additionalChecker?: () => boolean): () => boolean {
-    return (): boolean =>
-      // we don't want to leak any hotkeys when we have embedded query builder open
-      // TODO?: we probably should come up with a more generic mechanism for this
-      !this.embeddedQueryBuilderState.queryBuilderState &&
-      (!additionalChecker || additionalChecker());
-  }
-
-  registerCommands(): void {
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.COMPILE,
-      trigger: this.createEditorCommandTrigger(
-        () =>
-          this.isInitialized &&
-          (!this.isInConflictResolutionMode ||
-            this.conflictResolutionState.hasResolvedAllConflicts),
-      ),
-      action: () => {
-        flowResult(this.graphEditorMode.globalCompile()).catch(
-          this.applicationStore.alertUnhandledError,
-        );
-      },
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.GENERATE,
-      trigger: this.createEditorCommandTrigger(
-        () =>
-          this.isInitialized &&
-          (!this.isInConflictResolutionMode ||
-            this.conflictResolutionState.hasResolvedAllConflicts),
-      ),
-      action: () => {
-        flowResult(this.graphState.graphGenerationState.globalGenerate()).catch(
-          this.applicationStore.alertUnhandledError,
-        );
-      },
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.CREATE_ELEMENT,
-      trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-      action: () => this.newElementState.openModal(),
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.SEARCH_ELEMENT,
-      trigger: this.createEditorCommandTrigger(),
-      action: () => this.searchElementCommandState.open(),
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_TEXT_MODE,
-      trigger: this.createEditorCommandTrigger(
-        () =>
-          this.isInitialized &&
-          (!this.isInConflictResolutionMode ||
-            this.conflictResolutionState.hasResolvedAllConflicts),
-      ),
-      action: () => {
-        flowResult(this.toggleTextMode()).catch(
-          this.applicationStore.alertUnhandledError,
-        );
-      },
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_MODEL_LOADER,
-      trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-      action: () => this.tabManagerState.openTab(this.modelImporterState),
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.SYNC_WITH_WORKSPACE,
-      trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-      action: () => {
-        flowResult(this.localChangesState.pushLocalChanges()).catch(
-          this.applicationStore.alertUnhandledError,
-        );
-      },
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_AUX_PANEL,
-      trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-      action: () => this.auxPanelDisplayState.toggle(),
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_EXPLORER,
-      trigger: this.createEditorCommandTrigger(),
-      action: () => this.setActiveActivity(ACTIVITY_MODE.EXPLORER),
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_LOCAL_CHANGES,
-      trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-      action: () => this.setActiveActivity(ACTIVITY_MODE.LOCAL_CHANGES),
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_WORKSPACE_REVIEW,
-      trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-      action: () => this.setActiveActivity(ACTIVITY_MODE.WORKSPACE_REVIEW),
-    });
-    this.applicationStore.commandService.registerCommand({
-      key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_WORKSPACE_UPDATER,
-      trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-      action: () => this.setActiveActivity(ACTIVITY_MODE.WORKSPACE_UPDATER),
-    });
-  }
-
-  deregisterCommands(): void {
-    [
-      LEGEND_STUDIO_COMMAND_KEY.SYNC_WITH_WORKSPACE,
-      LEGEND_STUDIO_COMMAND_KEY.CREATE_ELEMENT,
-      LEGEND_STUDIO_COMMAND_KEY.SEARCH_ELEMENT,
-      LEGEND_STUDIO_COMMAND_KEY.TOGGLE_TEXT_MODE,
-      LEGEND_STUDIO_COMMAND_KEY.GENERATE,
-      LEGEND_STUDIO_COMMAND_KEY.COMPILE,
-      LEGEND_STUDIO_COMMAND_KEY.TOGGLE_AUX_PANEL,
-      LEGEND_STUDIO_COMMAND_KEY.TOGGLE_MODEL_LOADER,
-      LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_EXPLORER,
-      LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_LOCAL_CHANGES,
-      LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_WORKSPACE_REVIEW,
-      LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_WORKSPACE_UPDATER,
-    ].forEach((key) =>
-      this.applicationStore.commandService.deregisterCommand(key),
-    );
-  }
-
-  reset(): void {
-    this.tabManagerState.closeAllTabs();
-    this.projectConfigurationEditorState = new ProjectConfigurationEditorState(
-      this,
-      this.sdlcState,
-    );
-    this.explorerTreeState = new ExplorerTreeState(this);
-  }
-
-  internalizeEntityPath(params: WorkspaceEditorPathParams): void {
-    const { projectId, entityPath } = params;
-    const workspaceType = params.groupWorkspaceId
-      ? WorkspaceType.GROUP
-      : WorkspaceType.USER;
-    const workspaceId = guaranteeNonNullable(
-      params.groupWorkspaceId ?? params.workspaceId,
-      `Workspace/group workspace ID is not provided`,
-    );
-    if (entityPath) {
-      this.initialEntityPath = entityPath;
-      this.applicationStore.navigationService.navigator.updateCurrentLocation(
-        generateEditorRoute(projectId, workspaceId, workspaceType),
-      );
-    }
-  }
-
-  /**
-   * This is the entry of the app logic where the initialization of editor states happens
-   * Here, we ensure the order of calls after checking existence of current project and workspace
-   * If either of them does not exist, we cannot proceed.
-   */
-  *initialize(
-    projectId: string,
-    workspaceId: string,
-    workspaceType: WorkspaceType,
-  ): GeneratorFn<void> {
-    if (!this.initState.isInInitialState) {
-      /**
-       * Since React `fast-refresh` will sometimes cause `Editor` to rerender, this method will be called again
-       * as all hooks are recalled, as such, ONLY IN DEVELOPMENT mode we allow this to not fail-fast
-       * we also have to `undo` some of what the `cleanUp` does to this store as the cleanup part of all hooks will be triggered
-       * as well
-       */
-      // eslint-disable-next-line no-process-env
-      if (process.env.NODE_ENV === 'development') {
-        this.applicationStore.logService.info(
-          LogEvent.create(APPLICATION_EVENT.DEVELOPMENT_ISSUE),
-          `Fast-refreshing the app - undoing cleanUp() and preventing initialize() recall in editor store...`,
-        );
-        this.changeDetectionState.start();
-        return;
-      }
-      this.applicationStore.notificationService.notifyIllegalState(
-        'Editor store is re-initialized',
-      );
-      return;
-    }
-    this.initState.inProgress();
-    const onLeave = (hasBuildSucceeded: boolean): void => {
-      this.initState.complete(hasBuildSucceeded);
-      this.initState.setMessage(undefined);
-    };
-
-    this.initState.setMessage(`Setting up workspace...`);
-    yield flowResult(
-      this.sdlcState.fetchCurrentProject(projectId, {
-        suppressNotification: true,
-      }),
-    );
-    if (!this.sdlcState.currentProject) {
-      // If the project is not found or the user does not have access to it,
-      // we will not automatically redirect them to the setup page as they will lose the URL
-      // instead, we give them the option to:
-      // - reload the page (in case they later gain access)
-      // - back to the setup page
-      this.applicationStore.alertService.setActionAlertInfo({
-        message: `Project not found or inaccessible`,
-        prompt: 'Please check that the project exists and request access to it',
-        type: ActionAlertType.STANDARD,
-        actions: [
-          {
-            label: 'Reload application',
-            default: true,
-            type: ActionAlertActionType.STANDARD,
-            handler: (): void => {
-              this.applicationStore.navigationService.navigator.reload();
-            },
-          },
-          {
-            label: 'Back to workspace setup',
-            type: ActionAlertActionType.STANDARD,
-            handler: (): void => {
-              this.applicationStore.navigationService.navigator.goToLocation(
-                generateSetupRoute(undefined),
-              );
-            },
-          },
-        ],
-      });
-      onLeave(false);
-      return;
-    }
-    yield flowResult(
-      this.sdlcState.fetchCurrentWorkspace(
-        projectId,
-        workspaceId,
-        workspaceType,
-        {
-          suppressNotification: true,
-        },
-      ),
-    );
-    if (!this.sdlcState.currentWorkspace) {
-      // If the workspace is not found,
-      // we will not automatically redirect the user to the setup page as they will lose the URL
-      // instead, we give them the option to:
-      // - create the workspace
-      // - view project
-      // - back to the setup page
-      const createWorkspaceAndRelaunch = async (): Promise<void> => {
-        try {
-          this.applicationStore.alertService.setBlockingAlert({
-            message: 'Creating workspace...',
-            prompt: 'Please do not close the application',
-          });
-          const workspace = await this.sdlcServerClient.createWorkspace(
-            projectId,
-            workspaceId,
-            workspaceType,
-          );
-          this.applicationStore.alertService.setBlockingAlert(undefined);
-          this.applicationStore.notificationService.notifySuccess(
-            `Workspace '${workspace.workspaceId}' is succesfully created. Reloading application...`,
-          );
-          this.applicationStore.navigationService.navigator.reload();
-        } catch (error) {
-          assertErrorThrown(error);
-          this.applicationStore.logService.error(
-            LogEvent.create(LEGEND_STUDIO_APP_EVENT.WORKSPACE_SETUP_FAILURE),
-            error,
-          );
-          this.applicationStore.notificationService.notifyError(error);
-        }
-      };
-      this.applicationStore.alertService.setActionAlertInfo({
-        message: 'Workspace not found',
-        prompt: `Please note that you can check out the project in viewer mode. Workspace is only required if you need to work on the project.`,
-        type: ActionAlertType.STANDARD,
-        actions: [
-          {
-            label: 'View project',
-            default: true,
-            type: ActionAlertActionType.STANDARD,
-            handler: (): void => {
-              this.applicationStore.navigationService.navigator.goToLocation(
-                generateViewProjectRoute(projectId),
-              );
-            },
-          },
-          {
-            label: 'Create workspace',
-            type: ActionAlertActionType.STANDARD,
-            handler: (): void => {
-              createWorkspaceAndRelaunch().catch(
-                this.applicationStore.alertUnhandledError,
-              );
-            },
-          },
-          {
-            label: 'Back to workspace setup',
-            type: ActionAlertActionType.STANDARD,
-            handler: (): void => {
-              this.applicationStore.navigationService.navigator.goToLocation(
-                generateSetupRoute(projectId, workspaceId, workspaceType),
-              );
-            },
-          },
-        ],
-      });
-      onLeave(false);
-      return;
-    }
-    yield Promise.all([
-      this.sdlcState.fetchCurrentRevision(
-        projectId,
-        this.sdlcState.activeWorkspace,
-      ),
-      this.graphManagerState.initializeSystem(), // this can be moved inside of `setupEngine`
-      this.graphManagerState.graphManager.initialize(
-        {
-          env: this.applicationStore.config.env,
-          tabSize: TAB_SIZE,
-          clientConfig: {
-            baseUrl: this.applicationStore.config.engineServerUrl,
-            queryBaseUrl: this.applicationStore.config.engineQueryServerUrl,
-            enableCompression: true,
-          },
-        },
-        {
-          tracerService: this.applicationStore.tracerService,
-        },
-      ),
-    ]);
-    yield flowResult(this.initMode());
-
-    onLeave(true);
-  }
-
-  *initMode(): GeneratorFn<void> {
-    switch (this.mode) {
-      case EDITOR_MODE.STANDARD:
-        yield flowResult(this.initStandardMode());
-        return;
-      case EDITOR_MODE.CONFLICT_RESOLUTION:
-        yield flowResult(this.initConflictResolutionMode());
-        return;
-      default:
-        throw new UnsupportedOperationError(
-          `Can't initialize editor for unsupported mode '${this.mode}'`,
-        );
-    }
-  }
-
-  private *initStandardMode(): GeneratorFn<void> {
-    yield Promise.all([
-      this.buildGraph(),
-      this.sdlcState.checkIfWorkspaceIsOutdated(),
-      this.workspaceReviewState.fetchCurrentWorkspaceReview(),
-      this.workspaceUpdaterState.fetchLatestCommittedReviews(),
-      this.projectConfigurationEditorState.fetchLatestProjectStructureVersion(),
-      this.graphState.graphGenerationState.fetchAvailableFileGenerationDescriptions(),
-      this.graphState.graphGenerationState.externalFormatState.fetchExternalFormatsDescriptions(),
-      this.sdlcState.fetchProjectVersions(),
-    ]);
-  }
-
-  private *initConflictResolutionMode(): GeneratorFn<void> {
-    this.applicationStore.alertService.setActionAlertInfo({
-      message: 'Failed to update workspace.',
-      prompt:
-        'You can discard all of your changes or review them, resolve all merge conflicts and fix any potential compilation issues as well as test failures',
-      type: ActionAlertType.CAUTION,
-      actions: [
-        {
-          label: 'Discard your changes',
-          type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-          handler: (): void => {
-            this.setActiveActivity(ACTIVITY_MODE.CONFLICT_RESOLUTION);
-            flowResult(
-              this.conflictResolutionState.discardConflictResolutionChanges(),
-            ).catch((error) =>
-              this.applicationStore.alertUnhandledError(error),
-            );
-          },
-        },
-        {
-          label: 'Resolve merge conflicts',
-          default: true,
-          type: ActionAlertActionType.STANDARD,
-        },
-      ],
-    });
-    yield Promise.all([
-      this.conflictResolutionState.initialize(),
-      this.sdlcState.checkIfWorkspaceIsOutdated(),
-      this.projectConfigurationEditorState.fetchLatestProjectStructureVersion(),
-      this.graphState.graphGenerationState.fetchAvailableFileGenerationDescriptions(),
-      this.graphState.graphGenerationState.externalFormatState.fetchExternalFormatsDescriptions(),
-      this.sdlcState.fetchProjectVersions(),
-    ]);
-  }
-
-  *buildGraph(graphEntities?: Entity[]): GeneratorFn<void> {
-    const startTime = Date.now();
-    let entities: Entity[];
-    let projectConfiguration: PlainObject<ProjectConfiguration>;
-
-    this.initState.setMessage(`Fetching entities...`);
-    try {
-      // fetch workspace entities and config at the same time
-      const projectId = this.sdlcState.activeProject.projectId;
-      const activeWorkspace = this.sdlcState.activeWorkspace;
-      const result = (yield Promise.all([
-        this.sdlcServerClient.getEntities(projectId, activeWorkspace),
-        this.sdlcServerClient.getConfiguration(projectId, activeWorkspace),
-      ])) as [Entity[], PlainObject<ProjectConfiguration>];
-      entities = result[0];
-      projectConfiguration = result[1];
-      this.projectConfigurationEditorState.setProjectConfiguration(
-        ProjectConfiguration.serialization.fromJson(projectConfiguration),
-      );
-      // make sure we set the original project configuration to a different object
-      this.projectConfigurationEditorState.setOriginalProjectConfiguration(
-        ProjectConfiguration.serialization.fromJson(projectConfiguration),
-      );
-      this.changeDetectionState.workspaceLocalLatestRevisionState.setEntities(
-        entities,
-      );
-      this.applicationStore.logService.info(
-        LogEvent.create(GRAPH_MANAGER_EVENT.FETCH_GRAPH_ENTITIES__SUCCESS),
-        Date.now() - startTime,
-        'ms',
-      );
-    } catch {
-      return;
-    } finally {
-      this.initState.setMessage(undefined);
-    }
-
-    try {
-      const result = (yield flowResult(
-        // NOTE: if graph entities are provided, we will use that to build the graph.
-        // We use this method as a way to fully reset the application with the entities, but we still use
-        // the workspace entities for hashing as those are the base entities.
-        this.graphState.buildGraph(graphEntities ?? entities),
-      )) as GraphBuilderResult;
-
-      if (result.error) {
-        if (result.status === GraphBuilderStatus.REDIRECTED_TO_TEXT_MODE) {
-          yield flowResult(
-            this.changeDetectionState.workspaceLocalLatestRevisionState.buildEntityHashesIndex(
-              entities,
-              LogEvent.create(
-                CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS,
-              ),
-            ),
-          );
-        }
-        return;
-      }
-
-      this.initState.setMessage(`Starting change detection engine...`);
-
-      // build explorer tree
-      this.explorerTreeState.buildImmutableModelTrees();
-      this.explorerTreeState.build();
-
-      // open element if provided an element path
-      if (
-        this.graphManagerState.graphBuildState.hasSucceeded &&
-        this.explorerTreeState.buildState.hasCompleted &&
-        this.initialEntityPath
-      ) {
-        try {
-          this.graphEditorMode.openElement(
-            this.graphManagerState.graph.getElement(this.initialEntityPath),
-          );
-        } catch {
-          const elementPath = this.initialEntityPath;
-          this.initialEntityPath = undefined;
-          throw new AssertionError(
-            `Can't find element with path '${elementPath}'`,
-          );
-        }
-      }
-
-      // ======= (RE)START CHANGE DETECTION =======
-      this.changeDetectionState.stop();
-      yield flowResult(this.changeDetectionState.observeGraph());
-      yield Promise.all([
-        this.changeDetectionState.preComputeGraphElementHashes(), // for local changes detection
-        this.changeDetectionState.workspaceLocalLatestRevisionState.buildEntityHashesIndex(
-          entities,
-          LogEvent.create(
-            CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS,
-          ),
-        ),
-
-        this.sdlcState.buildWorkspaceBaseRevisionEntityHashesIndex(),
-        this.sdlcState.buildProjectLatestRevisionEntityHashesIndex(),
-      ]);
-      this.changeDetectionState.start();
-      yield Promise.all([
-        this.changeDetectionState.computeAggregatedWorkspaceChanges(true),
-        this.changeDetectionState.computeAggregatedProjectLatestChanges(true),
-      ]);
-      this.applicationStore.logService.info(
-        LogEvent.create(
-          CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTART__SUCCESS,
-        ),
-        '[ASNYC]',
-      );
-      // ======= FINISHED (RE)START CHANGE DETECTION =======
-    } catch (error) {
-      assertErrorThrown(error);
-      this.applicationStore.logService.error(
-        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
-        error,
-      );
-      // since errors have been handled accordingly, we don't need to do anything here
-      return;
-    } finally {
-      this.initState.setMessage(undefined);
-    }
-  }
-
-  setActiveActivity(
-    activity: ACTIVITY_MODE,
-    options?: { keepShowingIfMatchedCurrent?: boolean },
-  ): void {
-    if (!this.sideBarDisplayState.isOpen) {
-      this.sideBarDisplayState.open();
-    } else if (
-      activity === this.activeActivity &&
-      !options?.keepShowingIfMatchedCurrent
-    ) {
-      this.sideBarDisplayState.close();
-    }
-    this.activeActivity = activity;
-  }
-
-  setActiveAuxPanelMode(val: AUX_PANEL_MODE): void {
-    this.activeAuxPanelMode = val;
-  }
-
-  *toggleTextMode(): GeneratorFn<void> {
-    if (this.graphState.checkIfApplicationUpdateOperationIsRunning()) {
-      return;
-    }
-    this.applicationStore.alertService.setBlockingAlert({
-      message: 'Switching to text mode...',
-      showLoading: true,
-    });
-    if (this.graphEditorMode instanceof GraphEditFormModeState) {
-      yield flowResult(this.switchModes(GRAPH_EDITOR_MODE.GRAMMAR_TEXT));
-    } else if (this.graphEditorMode instanceof GraphEditGrammarModeState) {
-      yield flowResult(this.switchModes(GRAPH_EDITOR_MODE.FORM));
-    } else {
-      throw new UnsupportedOperationError(
-        'Editor only support form mode and text mode at the moment',
-      );
-    }
-  }
-
-  getSupportedElementTypes(): string[] {
-    return (
-      [
-        PACKAGEABLE_ELEMENT_TYPE.CLASS,
-        PACKAGEABLE_ELEMENT_TYPE.ENUMERATION,
-        PACKAGEABLE_ELEMENT_TYPE.PROFILE,
-        PACKAGEABLE_ELEMENT_TYPE.ASSOCIATION,
-        PACKAGEABLE_ELEMENT_TYPE.FUNCTION,
-        PACKAGEABLE_ELEMENT_TYPE.MEASURE,
-        PACKAGEABLE_ELEMENT_TYPE.MAPPING,
-        PACKAGEABLE_ELEMENT_TYPE.RUNTIME,
-        PACKAGEABLE_ELEMENT_TYPE.CONNECTION,
-        PACKAGEABLE_ELEMENT_TYPE.SERVICE,
-        PACKAGEABLE_ELEMENT_TYPE.GENERATION_SPECIFICATION,
-        PACKAGEABLE_ELEMENT_TYPE.FILE_GENERATION,
-        PACKAGEABLE_ELEMENT_TYPE.FLAT_DATA_STORE,
-        PACKAGEABLE_ELEMENT_TYPE.DATABASE,
-        PACKAGEABLE_ELEMENT_TYPE.DATA,
-      ] as string[]
-    ).concat(
-      this.pluginManager
-        .getApplicationPlugins()
-        .flatMap(
-          (plugin) =>
-            (
-              plugin as DSL_LegendStudioApplicationPlugin_Extension
-            ).getExtraSupportedElementTypes?.() ?? [],
-        ),
-    );
-  }
-
-  *switchModes(
-    to: GRAPH_EDITOR_MODE,
-    fallbackOptions?: {
-      isCompilationFailure?: boolean;
-      isGraphBuildFailure?: boolean;
-    },
-  ): GeneratorFn<void> {
-    switch (to) {
-      case GRAPH_EDITOR_MODE.GRAMMAR_TEXT: {
-        const graphEditorMode = new GraphEditGrammarModeState(this);
-        try {
-          yield flowResult(
-            graphEditorMode.cleanupBeforeEntering(fallbackOptions),
-          );
-          this.graphEditorMode = graphEditorMode;
-          yield flowResult(
-            this.graphEditorMode.initialize(Boolean(fallbackOptions)),
-          );
-        } catch (error) {
-          assertErrorThrown(error);
-          this.applicationStore.notificationService.notifyWarning(
-            `Can't enter text mode: transformation to grammar text failed. Error: ${error.message}`,
-          );
-          this.applicationStore.alertService.setBlockingAlert(undefined);
-          return;
-        }
-        break;
-      }
-      case GRAPH_EDITOR_MODE.FORM: {
-        if (this.graphState.checkIfApplicationUpdateOperationIsRunning()) {
-          return;
-        }
-        try {
-          try {
-            yield flowResult(this.graphEditorMode.onLeave(fallbackOptions));
-            this.graphEditorMode = new GraphEditFormModeState(this);
-            yield flowResult(this.graphEditorMode.initialize());
-          } catch (error) {
-            yield flowResult(this.graphEditorMode.handleCleanupFailure(error));
-          }
-        } catch (error) {
-          assertErrorThrown(error);
-          this.applicationStore.logService.error(
-            LogEvent.create(GRAPH_MANAGER_EVENT.COMPILATION_FAILURE),
-            error,
-          );
-        } finally {
-          this.graphState.isApplicationLeavingGraphEditMode = false;
-          this.applicationStore.alertService.setBlockingAlert(undefined);
-          this.changeDetectionState.workspaceLocalLatestRevisionState.currentEntityHashesIndex =
-            new Map<string, string>();
-        }
-
-        break;
-      }
-      default:
-        throw new UnsupportedOperationError(
-          `Editor does not support ${to} mode at the moment `,
-        );
-    }
-  }
-
-  getGraphEditorMode<T extends GraphEditorMode>(clazz: Clazz<T>): T {
-    return guaranteeType(
-      this.graphEditorMode,
-      clazz,
-      `Graph editor mode is not of the specified type (this is likely caused by calling this method at the wrong place)`,
-    );
-  }
-}