@finos/legend-application-studio 23.0.0 → 23.0.1

package/src/stores/sidebar-state/LocalChangesState.ts

@@ -1,877 +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,
-  makeObservable,
-  flowResult,
-  flow,
-  observable,
-  computed,
-} from 'mobx';
-import type { EditorStore } from '../EditorStore.js';
-import type { EditorSDLCState } from '../EditorSDLCState.js';
-import { CHANGE_DETECTION_EVENT } from '../ChangeDetectionEvent.js';
-import {
-  type GeneratorFn,
-  type PlainObject,
-  LogEvent,
-  assertErrorThrown,
-  downloadFileUsingDataURI,
-  guaranteeNonNullable,
-  ContentType,
-  NetworkClientError,
-  HttpStatus,
-  deleteEntry,
-  assertTrue,
-  readFileAsText,
-  ActionState,
-  formatDate,
-} from '@finos/legend-shared';
-import {
-  TAB_SIZE,
-  ActionAlertType,
-  ActionAlertActionType,
-} from '@finos/legend-application';
-import { EntityDiffViewState } from '../editor-state/entity-diff-editor-state/EntityDiffViewState.js';
-import { SPECIAL_REVISION_ALIAS } from '../editor-state/entity-diff-editor-state/EntityDiffEditorState.js';
-import type { Entity } from '@finos/legend-storage';
-import {
-  type EntityChangeConflict,
-  EntityDiff,
-  EntityChange,
-  Revision,
-  EntityChangeType,
-} from '@finos/legend-server-sdlc';
-import { LEGEND_STUDIO_APP_EVENT } from '../../application/LegendStudioEvent.js';
-import { WorkspaceSyncState } from './WorkspaceSyncState.js';
-import { ACTIVITY_MODE } from '../EditorConfig.js';
-import { EntityChangeConflictEditorState } from '../editor-state/entity-diff-editor-state/EntityChangeConflictEditorState.js';
-import { DATE_TIME_FORMAT } from '@finos/legend-graph';
-
-class PatchLoaderState {
-  readonly editorStore: EditorStore;
-  readonly sdlcState: EditorSDLCState;
-
-  changes: EntityChange[] | undefined;
-  currentChanges: EntityChange[] = [];
-  isLoadingChanges = false;
-  showModal = false;
-  isValidPatch = false;
-
-  constructor(editorStore: EditorStore, sdlcState: EditorSDLCState) {
-    makeObservable(this, {
-      changes: observable,
-      currentChanges: observable,
-      isLoadingChanges: observable,
-      showModal: observable,
-      isValidPatch: observable,
-      overiddingChanges: computed,
-      openModal: action,
-      closeModal: action,
-      setIsValidPatch: action,
-      setPatchChanges: action,
-      deleteChange: action,
-      loadPatchFile: flow,
-      applyChanges: flow,
-    });
-
-    this.editorStore = editorStore;
-    this.sdlcState = sdlcState;
-  }
-
-  get overiddingChanges(): EntityChange[] {
-    if (this.changes?.length) {
-      return this.changes.filter((change) =>
-        this.currentChanges.find(
-          (local) => local.entityPath === change.entityPath,
-        ),
-      );
-    }
-    return [];
-  }
-
-  openModal(localChanges: EntityChange[]): void {
-    this.currentChanges = localChanges;
-    this.showModal = true;
-  }
-
-  closeModal(): void {
-    this.currentChanges = [];
-    this.setPatchChanges(undefined);
-    this.showModal = false;
-  }
-
-  setIsValidPatch(val: boolean): void {
-    this.isValidPatch = val;
-  }
-
-  setPatchChanges(changes: EntityChange[] | undefined): void {
-    this.changes = changes;
-  }
-
-  deleteChange(change: EntityChange): void {
-    if (this.changes) {
-      deleteEntry(this.changes, change);
-    }
-  }
-
-  *loadPatchFile(file: File): GeneratorFn<void> {
-    try {
-      this.setPatchChanges(undefined);
-      assertTrue(
-        file.type === ContentType.APPLICATION_JSON,
-        `Patch file expected to be of type 'JSON'`,
-      );
-      const fileText = (yield readFileAsText(file)) as string;
-      const entityChanges = JSON.parse(fileText) as {
-        entityChanges: PlainObject<EntityChange>[];
-      };
-      const changes = entityChanges.entityChanges.map((e) =>
-        EntityChange.serialization.fromJson(e),
-      );
-      this.setPatchChanges(changes);
-      this.setIsValidPatch(true);
-    } catch (error) {
-      assertErrorThrown(error);
-      this.setIsValidPatch(false);
-      this.editorStore.applicationStore.notificationService.notifyError(
-        `Can't load patch: Error: ${error.message}`,
-      );
-    }
-  }
-
-  *applyChanges(): GeneratorFn<void> {
-    if (this.changes?.length) {
-      try {
-        const changes = this.changes;
-        this.closeModal();
-        yield flowResult(
-          this.editorStore.graphState.loadEntityChangesToGraph(
-            changes,
-            undefined,
-          ),
-        );
-      } catch (error) {
-        assertErrorThrown(error);
-        this.editorStore.applicationStore.notificationService.notifyError(
-          `Can't apply patch changes: Error: ${error.message}`,
-        );
-      }
-    }
-  }
-}
-
-export abstract class LocalChangesState {
-  readonly editorStore: EditorStore;
-  readonly sdlcState: EditorSDLCState;
-  readonly workspaceSyncState: WorkspaceSyncState;
-  readonly pushChangesState = ActionState.create();
-  readonly refreshLocalChangesDetectorState = ActionState.create();
-  readonly refreshWorkspaceSyncStatusState = ActionState.create();
-  readonly patchLoaderState: PatchLoaderState;
-
-  constructor(editorStore: EditorStore, sdlcState: EditorSDLCState) {
-    makeObservable(this, {
-      hasUnpushedChanges: computed,
-      refreshWorkspaceSyncStatus: flow,
-      refreshLocalChanges: flow,
-      pushLocalChanges: flow,
-      processConflicts: flow,
-      restartChangeDetection: flow,
-    });
-
-    this.editorStore = editorStore;
-    this.sdlcState = sdlcState;
-    this.patchLoaderState = new PatchLoaderState(editorStore, sdlcState);
-    this.workspaceSyncState = new WorkspaceSyncState(editorStore, sdlcState);
-  }
-
-  get hasUnpushedChanges(): boolean {
-    return Boolean(
-      this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState
-        .changes.length,
-    );
-  }
-
-  downloadLocalChanges(): void {
-    const fileName = `entityChanges_(${this.sdlcState.currentProject?.name}_${
-      this.sdlcState.activeWorkspace.workspaceId
-    })_${formatDate(new Date(Date.now()), DATE_TIME_FORMAT)}.json`;
-    const content = JSON.stringify(
-      {
-        message: '', // TODO?
-        entityChanges: this.computeLocalEntityChanges(),
-        revisionId: this.sdlcState.activeRevision.id,
-      },
-      undefined,
-      TAB_SIZE,
-    );
-    downloadFileUsingDataURI(fileName, content, ContentType.APPLICATION_JSON);
-  }
-
-  alertUnsavedChanges(onProceed: () => void): void {
-    if (this.hasUnpushedChanges) {
-      this.editorStore.applicationStore.alertService.setActionAlertInfo({
-        message:
-          'Unsaved changes will be lost if you continue. Do you still want to proceed?',
-        type: ActionAlertType.CAUTION,
-        actions: [
-          {
-            label: 'Proceed',
-            type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-            handler: (): void => onProceed(),
-          },
-          {
-            label: 'Abort',
-            type: ActionAlertActionType.PROCEED,
-            default: true,
-          },
-        ],
-      });
-    } else {
-      onProceed();
-    }
-  }
-
-  *refreshWorkspaceSyncStatus(): GeneratorFn<void> {
-    try {
-      this.refreshWorkspaceSyncStatusState.inProgress();
-      const currentRemoteRevision =
-        this.sdlcState.activeRemoteWorkspaceRevision;
-      yield flowResult(
-        this.sdlcState.fetchRemoteWorkspaceRevision(
-          this.sdlcState.activeProject.projectId,
-          this.sdlcState.activeWorkspace,
-        ),
-      );
-      if (
-        currentRemoteRevision.id !==
-        this.sdlcState.activeRemoteWorkspaceRevision.id
-      ) {
-        if (this.sdlcState.isWorkspaceOutOfSync) {
-          this.workspaceSyncState.fetchIncomingRevisions();
-          const remoteWorkspaceEntities =
-            (yield this.editorStore.sdlcServerClient.getEntitiesByRevision(
-              this.sdlcState.activeProject.projectId,
-              this.sdlcState.activeWorkspace,
-              this.sdlcState.activeRemoteWorkspaceRevision.id,
-            )) as Entity[];
-          this.editorStore.changeDetectionState.workspaceRemoteLatestRevisionState.setEntities(
-            remoteWorkspaceEntities,
-          );
-          yield flowResult(
-            this.editorStore.changeDetectionState.workspaceRemoteLatestRevisionState.buildEntityHashesIndex(
-              remoteWorkspaceEntities,
-              LogEvent.create(
-                CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS,
-              ),
-            ),
-          );
-          yield flowResult(
-            this.editorStore.changeDetectionState.computeAggregatedWorkspaceRemoteChanges(),
-          );
-        } else {
-          this.editorStore.changeDetectionState.workspaceRemoteLatestRevisionState.setEntities(
-            [],
-          );
-          this.editorStore.changeDetectionState.setPotentialWorkspacePullConflicts(
-            [],
-          );
-          this.editorStore.changeDetectionState.setAggregatedWorkspaceRemoteChanges(
-            [],
-          );
-        }
-      }
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.logService.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
-        error,
-      );
-    } finally {
-      this.refreshWorkspaceSyncStatusState.complete();
-    }
-  }
-
-  abstract refreshLocalChanges(): GeneratorFn<void>;
-
-  abstract processConflicts(): GeneratorFn<void>;
-
-  abstract getCurrentHashIndexes(): Map<string, string>;
-
-  abstract stopChangeDetection(): void;
-
-  abstract restartChangeDetection(): GeneratorFn<void>;
-
-  abstract computeLocalEntityChanges(): EntityChange[];
-
-  *pushLocalChanges(pushMessage?: string): GeneratorFn<void> {
-    if (
-      this.pushChangesState.isInProgress ||
-      this.editorStore.workspaceUpdaterState.isUpdatingWorkspace
-    ) {
-      return;
-    }
-    // check if the workspace is in conflict resolution mode
-    yield flowResult(this.processConflicts());
-
-    this.pushChangesState.inProgress();
-    const startTime = Date.now();
-    const localChanges = this.computeLocalEntityChanges();
-    if (!localChanges.length) {
-      this.pushChangesState.complete();
-      return;
-    }
-    yield flowResult(
-      this.sdlcState.fetchRemoteWorkspaceRevision(
-        this.sdlcState.activeProject.projectId,
-        this.sdlcState.activeWorkspace,
-      ),
-    );
-    if (this.sdlcState.isWorkspaceOutOfSync) {
-      // ensure changes/conflicts have been computed for latest remote version
-      const remoteWorkspaceEntities =
-        (yield this.editorStore.sdlcServerClient.getEntitiesByRevision(
-          this.sdlcState.activeProject.projectId,
-          this.sdlcState.activeWorkspace,
-          this.sdlcState.activeRemoteWorkspaceRevision.id,
-        )) as Entity[];
-      this.editorStore.changeDetectionState.workspaceRemoteLatestRevisionState.setEntities(
-        remoteWorkspaceEntities,
-      );
-      yield flowResult(
-        this.editorStore.changeDetectionState.workspaceRemoteLatestRevisionState.buildEntityHashesIndex(
-          remoteWorkspaceEntities,
-          LogEvent.create(
-            CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS,
-          ),
-        ),
-      );
-      yield flowResult(
-        this.editorStore.changeDetectionState.computeAggregatedWorkspaceRemoteChanges(),
-      );
-      this.editorStore.applicationStore.alertService.setActionAlertInfo({
-        message: 'Local workspace is out-of-sync',
-        prompt: 'Please pull remote changes before pushing your local changes',
-        type: ActionAlertType.CAUTION,
-        actions: [
-          {
-            label: 'Pull remote changes',
-            type: ActionAlertActionType.STANDARD,
-            default: true,
-            handler: (): void => {
-              this.editorStore.setActiveActivity(ACTIVITY_MODE.LOCAL_CHANGES);
-              flowResult(this.workspaceSyncState.pullChanges()).catch(
-                this.editorStore.applicationStore.alertUnhandledError,
-              );
-            },
-          },
-          {
-            label: 'Cancel',
-            type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-          },
-        ],
-      });
-      this.pushChangesState.complete();
-      return;
-    }
-    const currentHashesIndex = this.getCurrentHashIndexes();
-
-    try {
-      const nullableRevisionChange =
-        (yield this.editorStore.sdlcServerClient.performEntityChanges(
-          this.sdlcState.activeProject.projectId,
-          this.sdlcState.activeWorkspace,
-          {
-            message:
-              pushMessage ??
-              `pushed new changes from ${
-                this.editorStore.applicationStore.config.appName
-              } [potentially affected ${
-                localChanges.length === 1
-                  ? '1 entity'
-                  : `${localChanges.length} entities`
-              }]`,
-            entityChanges: localChanges,
-            revisionId: this.sdlcState.activeRevision.id,
-          },
-        )) as PlainObject<Revision> | undefined;
-      const revisionChange = guaranteeNonNullable(
-        nullableRevisionChange,
-        `Can't push an empty change set. This may be due to an error with change detection`,
-      );
-      const latestRevision = Revision.serialization.fromJson(revisionChange);
-      this.sdlcState.setCurrentRevision(latestRevision); // update current revision to the latest
-      this.sdlcState.setWorkspaceLatestRevision(latestRevision);
-      const syncFinishedTime = Date.now();
-
-      this.editorStore.applicationStore.logService.info(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.PUSH_LOCAL_CHANGES__SUCCESS),
-        syncFinishedTime - startTime,
-        'ms',
-      );
-
-      // ======= (RE)START CHANGE DETECTION =======
-
-      this.stopChangeDetection();
-
-      try {
-        /**
-         * Here we try to rebuild local hash index. If failed, we will use local hash index, but for veracity, it's best to use entities
-         * coming from the server.
-         */
-        const entities =
-          (yield this.editorStore.sdlcServerClient.getEntitiesByRevision(
-            this.sdlcState.activeProject.projectId,
-            this.sdlcState.activeWorkspace,
-            latestRevision.id,
-          )) as Entity[];
-        this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState.setEntities(
-          entities,
-        );
-        yield flowResult(
-          this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState.buildEntityHashesIndex(
-            entities,
-            LogEvent.create(
-              CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS,
-            ),
-          ),
-        );
-        this.editorStore.tabManagerState.refreshCurrentEntityDiffViewer();
-      } catch (error) {
-        assertErrorThrown(error);
-        /**
-         * NOTE: there is a known problem with the SDLC server where if we try to fetch the entities right after syncing, there is a chance
-         * that we get entities from the older commit (i.e. potentially some caching issue). As such, to account for this case, we will
-         * not try to get entities for the workspace HEAD, but for the revision returned from the syncing call (i.e. this must be the latest revision)
-         * if we get a 404, we will do a refresh and warn user about this. Otherwise, if we get other types of error, we will assume this is a network
-         * failure and use local workspace hashes index
-         */
-        if (error instanceof NetworkClientError) {
-          if (error.response.status === HttpStatus.NOT_FOUND) {
-            this.editorStore.applicationStore.logService.error(
-              LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
-              `Can't fetch entities for the latest workspace revision immediately after syncing`,
-              error,
-            );
-          }
-          this.editorStore.applicationStore.alertService.setActionAlertInfo({
-            message: `Change detection engine failed to build hashes index for workspace after syncing`,
-            prompt:
-              'To fix this, you can either try to keep refreshing local changes until success or trust and reuse current workspace hashes index',
-            type: ActionAlertType.CAUTION,
-            actions: [
-              {
-                label: 'Use local hashes index',
-                type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-                handler: (): void => {
-                  this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState.setEntityHashesIndex(
-                    currentHashesIndex,
-                  );
-                  this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState.setIsBuildingEntityHashesIndex(
-                    false,
-                  );
-                },
-              },
-              {
-                label: 'Refresh changes',
-                type: ActionAlertActionType.STANDARD,
-                default: true,
-                handler: this.editorStore.applicationStore.guardUnhandledError(
-                  () => flowResult(this.refreshLocalChanges()),
-                ),
-              },
-            ],
-          });
-        } else {
-          throw error;
-        }
-      }
-      yield flowResult(this.restartChangeDetection());
-      this.editorStore.applicationStore.logService.info(
-        LogEvent.create(
-          CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTART__SUCCESS,
-        ),
-        Date.now() - syncFinishedTime,
-        'ms',
-      );
-      // ======= FINISHED (RE)START CHANGE DETECTION =======
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.logService.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
-        error,
-      );
-      if (
-        error instanceof NetworkClientError &&
-        error.response.status === HttpStatus.CONFLICT
-      ) {
-        // NOTE: a confict here indicates that the reference revision ID sent along with update call
-        // does not match the HEAD of the workspace, therefore, we need to prompt user to refresh the application
-        this.editorStore.applicationStore.notificationService.notifyWarning(
-          'Syncing failed. Current workspace revision is not the latest. Please backup your work and refresh the application',
-        );
-        // TODO: maybe we should do more here, e.g. prompt the user to download the patch, but that is for later
-      } else {
-        this.editorStore.applicationStore.notificationService.notifyError(
-          error,
-        );
-      }
-    } finally {
-      this.pushChangesState.complete();
-    }
-  }
-}
-
-export class FormLocalChangesState extends LocalChangesState {
-  constructor(editorStore: EditorStore, sdlcState: EditorSDLCState) {
-    super(editorStore, sdlcState);
-    makeObservable(this, {
-      openPotentialWorkspacePullConflict: action,
-    });
-  }
-  openLocalChange(diff: EntityDiff): void {
-    const fromEntityGetter = (
-      entityPath: string | undefined,
-    ): Entity | undefined => {
-      if (entityPath) {
-        return this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState.entities.find(
-          (e) => e.path === entityPath,
-        );
-      }
-      return undefined;
-    };
-    const toEntityGetter = (
-      entityPath: string | undefined,
-    ): Entity | undefined => {
-      if (!entityPath) {
-        return undefined;
-      }
-      const element =
-        this.editorStore.graphManagerState.graph.getNullableElement(entityPath);
-      if (!element) {
-        return undefined;
-      }
-      const entity =
-        this.editorStore.graphManagerState.graphManager.elementToEntity(
-          element,
-          {
-            pruneSourceInformation: true,
-          },
-        );
-      return entity;
-    };
-    const fromEntity = EntityDiff.shouldOldEntityExist(diff)
-      ? guaranteeNonNullable(
-          fromEntityGetter(diff.getValidatedOldPath()),
-          `Can't find entity with path '${diff.oldPath}'`,
-        )
-      : undefined;
-    const toEntity = EntityDiff.shouldNewEntityExist(diff)
-      ? guaranteeNonNullable(
-          toEntityGetter(diff.getValidatedNewPath()),
-          `Can't find entity with path  '${diff.newPath}'`,
-        )
-      : undefined;
-    this.editorStore.tabManagerState.openTab(
-      new EntityDiffViewState(
-        this.editorStore,
-        SPECIAL_REVISION_ALIAS.WORKSPACE_HEAD,
-        SPECIAL_REVISION_ALIAS.LOCAL,
-        diff.oldPath,
-        diff.newPath,
-        fromEntity,
-        toEntity,
-        fromEntityGetter,
-        toEntityGetter,
-      ),
-    );
-  }
-
-  openWorkspacePullChange(diff: EntityDiff): void {
-    const fromEntityGetter = (
-      entityPath: string | undefined,
-    ): Entity | undefined => {
-      if (entityPath) {
-        return this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState.entities.find(
-          (e) => e.path === entityPath,
-        );
-      }
-      return undefined;
-    };
-    const toEntityGetter = (
-      entityPath: string | undefined,
-    ): Entity | undefined => {
-      if (entityPath) {
-        return this.editorStore.changeDetectionState.workspaceRemoteLatestRevisionState.entities.find(
-          (e) => e.path === entityPath,
-        );
-      }
-      return undefined;
-    };
-    const fromEntity = EntityDiff.shouldOldEntityExist(diff)
-      ? guaranteeNonNullable(
-          fromEntityGetter(diff.getValidatedOldPath()),
-          `Can't find entity with path '${diff.oldPath}'`,
-        )
-      : undefined;
-    const toEntity = EntityDiff.shouldNewEntityExist(diff)
-      ? guaranteeNonNullable(
-          toEntityGetter(diff.getValidatedNewPath()),
-          `Can't find entity with path  '${diff.newPath}'`,
-        )
-      : undefined;
-    this.editorStore.tabManagerState.openTab(
-      new EntityDiffViewState(
-        this.editorStore,
-        SPECIAL_REVISION_ALIAS.LOCAL,
-        SPECIAL_REVISION_ALIAS.WORKSPACE_HEAD,
-        diff.oldPath,
-        diff.newPath,
-        fromEntity,
-        toEntity,
-        fromEntityGetter,
-        toEntityGetter,
-      ),
-    );
-  }
-
-  openPotentialWorkspacePullConflict(conflict: EntityChangeConflict): void {
-    const baseEntityGetter = (
-      entityPath: string | undefined,
-    ): Entity | undefined =>
-      entityPath
-        ? this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState.entities.find(
-            (e) => e.path === entityPath,
-          )
-        : undefined;
-    const currentChangeEntityGetter = (
-      entityPath: string | undefined,
-    ): Entity | undefined =>
-      entityPath
-        ? this.editorStore.graphManagerState.graph.allOwnElements
-            .map((element) =>
-              this.editorStore.graphManagerState.graphManager.elementToEntity(
-                element,
-              ),
-            )
-            .find((e) => e.path === entityPath)
-        : undefined;
-    const incomingChangeEntityGetter = (
-      entityPath: string | undefined,
-    ): Entity | undefined =>
-      entityPath
-        ? this.editorStore.changeDetectionState.workspaceRemoteLatestRevisionState.entities.find(
-            (e) => e.path === entityPath,
-          )
-        : undefined;
-    const conflictEditorState = new EntityChangeConflictEditorState(
-      this.editorStore,
-      this.editorStore.conflictResolutionState,
-      conflict.entityPath,
-      SPECIAL_REVISION_ALIAS.WORKSPACE_BASE,
-      SPECIAL_REVISION_ALIAS.LOCAL,
-      SPECIAL_REVISION_ALIAS.WORKSPACE_HEAD,
-      baseEntityGetter(conflict.entityPath),
-      currentChangeEntityGetter(conflict.entityPath),
-      incomingChangeEntityGetter(conflict.entityPath),
-      baseEntityGetter,
-      currentChangeEntityGetter,
-      incomingChangeEntityGetter,
-    );
-    conflictEditorState.setReadOnly(true);
-    this.editorStore.tabManagerState.openTab(conflictEditorState);
-  }
-
-  *refreshLocalChanges(): GeneratorFn<void> {
-    const startTime = Date.now();
-    this.refreshLocalChangesDetectorState.inProgress();
-    try {
-      // ======= (RE)START CHANGE DETECTION =======
-      this.editorStore.changeDetectionState.stop();
-      yield Promise.all([
-        this.sdlcState.buildWorkspaceLatestRevisionEntityHashesIndex(),
-        this.editorStore.changeDetectionState.preComputeGraphElementHashes(),
-      ]);
-      this.editorStore.changeDetectionState.start();
-      this.editorStore.applicationStore.logService.info(
-        LogEvent.create(
-          CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTART__SUCCESS,
-        ),
-        Date.now() - startTime,
-        'ms',
-      );
-      // ======= FINISHED (RE)START CHANGE DETECTION =======
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.logService.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
-        error,
-      );
-      this.editorStore.applicationStore.notificationService.notifyError(error);
-      this.sdlcState.handleChangeDetectionRefreshIssue(error);
-    } finally {
-      this.refreshLocalChangesDetectorState.complete();
-    }
-  }
-
-  *processConflicts(): GeneratorFn<void> {
-    try {
-      const isInConflictResolutionMode = (yield flowResult(
-        this.sdlcState.checkIfCurrentWorkspaceIsInConflictResolutionMode(),
-      )) as boolean;
-      if (isInConflictResolutionMode) {
-        this.editorStore.applicationStore.alertService.setBlockingAlert({
-          message: 'Workspace is in conflict resolution mode',
-          prompt: 'Please refresh the application',
-        });
-        return;
-      }
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.notificationService.notifyWarning(
-        'Failed to check if current workspace is in conflict resolution mode',
-      );
-      return;
-    }
-  }
-
-  /**
-   * Get entitiy changes to prepare for syncing
-   */
-  computeLocalEntityChanges(): EntityChange[] {
-    const baseHashesIndex = this.editorStore.isInConflictResolutionMode
-      ? this.editorStore.changeDetectionState
-          .conflictResolutionHeadRevisionState.entityHashesIndex
-      : this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState
-          .entityHashesIndex;
-    const originalPaths = new Set(Array.from(baseHashesIndex.keys()));
-    const entityChanges: EntityChange[] = [];
-    this.editorStore.graphManagerState.graph.allOwnElements.forEach(
-      (element) => {
-        const elementPath = element.path;
-        if (baseHashesIndex.get(elementPath) !== element.hashCode) {
-          const entity =
-            this.editorStore.graphManagerState.graphManager.elementToEntity(
-              element,
-              {
-                pruneSourceInformation: true,
-              },
-            );
-          entityChanges.push({
-            classifierPath: entity.classifierPath,
-            entityPath: element.path,
-            content: entity.content,
-            type:
-              baseHashesIndex.get(elementPath) !== undefined
-                ? EntityChangeType.MODIFY
-                : EntityChangeType.CREATE,
-          });
-        }
-        originalPaths.delete(elementPath);
-      },
-    );
-    Array.from(originalPaths).forEach((path) => {
-      entityChanges.push({
-        type: EntityChangeType.DELETE,
-        entityPath: path,
-      });
-    });
-    return entityChanges;
-  }
-
-  getCurrentHashIndexes(): Map<string, string> {
-    return this.editorStore.changeDetectionState.snapshotLocalEntityHashesIndex();
-  }
-
-  stopChangeDetection(): void {
-    this.editorStore.changeDetectionState.stop();
-  }
-
-  *restartChangeDetection(): GeneratorFn<void> {
-    yield this.editorStore.changeDetectionState.preComputeGraphElementHashes();
-    this.editorStore.changeDetectionState.start();
-    yield Promise.all([
-      this.editorStore.changeDetectionState.computeAggregatedWorkspaceChanges(
-        true,
-      ),
-    ]);
-  }
-}
-
-export class TextLocalChangesState extends LocalChangesState {
-  localChanges: EntityChange[] = [];
-
-  constructor(editorStore: EditorStore, sdlcState: EditorSDLCState) {
-    super(editorStore, sdlcState);
-    makeObservable(this, {
-      setLocalChanges: action,
-    });
-  }
-
-  setLocalChanges(val: EntityChange[]): void {
-    this.localChanges = val;
-  }
-
-  *refreshLocalChanges(): GeneratorFn<void> {
-    this.refreshLocalChangesDetectorState.inProgress();
-    try {
-      yield Promise.all([
-        this.sdlcState.buildWorkspaceLatestRevisionEntityHashesIndex(),
-        this.editorStore.changeDetectionState.preComputeGraphElementHashes(),
-      ]);
-      this.editorStore.changeDetectionState.computeLocalChangesInTextMode(
-        this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState
-          .entities,
-      );
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.logService.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
-        error,
-      );
-      this.editorStore.applicationStore.notificationService.notifyError(error);
-      this.sdlcState.handleChangeDetectionRefreshIssue(error);
-    } finally {
-      this.refreshLocalChangesDetectorState.complete();
-    }
-  }
-
-  *processConflicts(): GeneratorFn<void> {
-    return;
-  }
-
-  getCurrentHashIndexes(): Map<string, string> {
-    return this.editorStore.changeDetectionState
-      .workspaceLocalLatestRevisionState.currentEntityHashesIndex;
-  }
-
-  stopChangeDetection(): void {
-    this.localChanges = [];
-  }
-
-  computeLocalEntityChanges(): EntityChange[] {
-    return this.localChanges;
-  }
-
-  *restartChangeDetection(): GeneratorFn<void> {
-    this.editorStore.changeDetectionState.computeLocalChangesInTextMode(
-      this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState
-        .entities,
-    );
-  }
-}