@finos/legend-application-studio 22.2.0 → 22.2.1

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

@@ -189,6 +189,8 @@ export abstract class LocalChangesState {
       refreshWorkspaceSyncStatus: flow,
       refreshLocalChanges: flow,
       pushLocalChanges: flow,
+      processConflicts: flow,
+      restartChangeDetection: flow,
     });
 
     this.editorStore = editorStore;
@@ -306,198 +308,15 @@ export abstract class LocalChangesState {
 
   abstract refreshLocalChanges(): GeneratorFn<void>;
 
-  abstract pushLocalChanges(pushMessage?: string): GeneratorFn<void>;
-}
+  abstract processConflicts(): GeneratorFn<void>;
 
-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,
-      ),
-    );
-  }
+  abstract getLocalChanges(): EntityChange[];
 
-  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,
-      ),
-    );
-  }
+  abstract getCurrentHashIndexes(): Map<string, string>;
 
-  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);
-  }
+  abstract stopChangeDetection(): void;
 
-  *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.log.info(
-        LogEvent.create(CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTARTED),
-        Date.now() - startTime,
-        'ms',
-      );
-      // ======= FINISHED (RE)START CHANGE DETECTION =======
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.log.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
-        error,
-      );
-      this.editorStore.applicationStore.notifyError(error);
-      this.sdlcState.handleChangeDetectionRefreshIssue(error);
-    } finally {
-      this.refreshLocalChangesDetectorState.complete();
-    }
-  }
+  abstract restartChangeDetection(): GeneratorFn<void>;
 
   *pushLocalChanges(pushMessage?: string): GeneratorFn<void> {
     if (
@@ -507,29 +326,11 @@ export class FormLocalChangesState extends LocalChangesState {
       return;
     }
     // check if the workspace is in conflict resolution mode
-    try {
-      const isInConflictResolutionMode = (yield flowResult(
-        this.sdlcState.checkIfCurrentWorkspaceIsInConflictResolutionMode(),
-      )) as boolean;
-      if (isInConflictResolutionMode) {
-        this.editorStore.applicationStore.setBlockingAlert({
-          message: 'Workspace is in conflict resolution mode',
-          prompt: 'Please refresh the application',
-        });
-        return;
-      }
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.notifyWarning(
-        'Failed to check if current workspace is in conflict resolution mode',
-      );
-      return;
-    }
+    yield flowResult(this.processConflicts());
 
     this.pushChangesState.inProgress();
     const startTime = Date.now();
-    const localChanges =
-      this.editorStore.graphState.computeLocalEntityChanges();
+    const localChanges = this.getLocalChanges();
     if (!localChanges.length) {
       this.pushChangesState.complete();
       return;
@@ -587,8 +388,7 @@ export class FormLocalChangesState extends LocalChangesState {
       this.pushChangesState.complete();
       return;
     }
-    const currentHashesIndex =
-      this.editorStore.changeDetectionState.snapshotLocalEntityHashesIndex();
+    const currentHashesIndex = this.getCurrentHashIndexes();
 
     try {
       const nullableRevisionChange =
@@ -626,7 +426,7 @@ export class FormLocalChangesState extends LocalChangesState {
 
       // ======= (RE)START CHANGE DETECTION =======
 
-      this.editorStore.changeDetectionState.stop();
+      this.stopChangeDetection();
 
       try {
         /**
@@ -700,14 +500,7 @@ export class FormLocalChangesState extends LocalChangesState {
           throw error;
         }
       }
-      yield this.editorStore.changeDetectionState.preComputeGraphElementHashes();
-      this.editorStore.changeDetectionState.start();
-      yield Promise.all([
-        this.editorStore.changeDetectionState.computeAggregatedWorkspaceChanges(
-          true,
-        ),
-      ]);
-
+      yield flowResult(this.restartChangeDetection());
       this.editorStore.applicationStore.log.info(
         LogEvent.create(CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTARTED),
         Date.now() - syncFinishedTime,
@@ -739,263 +532,299 @@ export class FormLocalChangesState extends LocalChangesState {
   }
 }
 
-export class TextLocalChangesState extends LocalChangesState {
-  localChanges: EntityChange[] = [];
-
+export class FormLocalChangesState extends LocalChangesState {
   constructor(editorStore: EditorStore, sdlcState: EditorSDLCState) {
     super(editorStore, sdlcState);
     makeObservable(this, {
-      setLocalChanges: action,
+      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,
+      ),
+    );
+  }
 
-  setLocalChanges(val: EntityChange[]): void {
-    this.localChanges = val;
-  }
-
-  *refreshLocalChanges(): GeneratorFn<void> {
-    const startTime = Date.now();
-    this.refreshLocalChangesDetectorState.inProgress();
-    try {
-      // ======= (RE)START CHANGE DETECTION =======
-      yield Promise.all([
-        this.sdlcState.buildWorkspaceLatestRevisionEntityHashesIndex(),
-        this.editorStore.changeDetectionState.preComputeGraphElementHashes(),
-      ]);
-      this.editorStore.changeDetectionState.computeLocalChangesInTextMode(
-        this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState
-          .entities,
-      );
-      this.editorStore.applicationStore.log.info(
-        LogEvent.create(CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTARTED),
-        Date.now() - startTime,
-        'ms',
-      );
-      // ======= FINISHED (RE)START CHANGE DETECTION =======
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.log.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
-        error,
-      );
-      this.editorStore.applicationStore.notifyError(error);
-      this.sdlcState.handleChangeDetectionRefreshIssue(error);
-    } finally {
-      this.refreshLocalChangesDetectorState.complete();
-    }
-  }
-
-  *pushLocalChanges(pushMessage?: string): GeneratorFn<void> {
-    if (
-      this.pushChangesState.isInProgress ||
-      this.editorStore.workspaceUpdaterState.isUpdatingWorkspace
-    ) {
-      return;
-    }
-
-    this.pushChangesState.inProgress();
-    const startTime = Date.now();
-    if (!this.localChanges.length) {
-      this.pushChangesState.complete();
-      return;
-    }
-    yield flowResult(
-      this.sdlcState.fetchRemoteWorkspaceRevision(
-        this.sdlcState.activeProject.projectId,
-        this.sdlcState.activeWorkspace,
+  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,
       ),
     );
-    if (this.sdlcState.isWorkspaceOutOfSync) {
-      // ensure changes 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_LOCAL_HASHES_INDEX_BUILT,
-          ),
-        ),
+  }
+
+  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.log.info(
+        LogEvent.create(CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTARTED),
+        Date.now() - startTime,
+        'ms',
       );
-      yield flowResult(
-        this.editorStore.changeDetectionState.computeAggregatedWorkspaceRemoteChanges(),
+      // ======= FINISHED (RE)START CHANGE DETECTION =======
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
       );
-      this.editorStore.applicationStore.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.editorStore.localChangesState.workspaceSyncState.pullChanges(),
-              ).catch(this.editorStore.applicationStore.alertUnhandledError);
-            },
-          },
-          {
-            label: 'Cancel',
-            type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-          },
-        ],
-      });
-      this.pushChangesState.complete();
-      return;
+      this.editorStore.applicationStore.notifyError(error);
+      this.sdlcState.handleChangeDetectionRefreshIssue(error);
+    } finally {
+      this.refreshLocalChangesDetectorState.complete();
     }
-    const currentHashesIndex =
-      this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState
-        .currentEntityHashesIndex;
+  }
+
+  *processConflicts(): GeneratorFn<void> {
     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 ${
-                this.localChanges.length === 1
-                  ? '1 entity'
-                  : `${this.localChanges.length} entities`
-              }]`,
-            entityChanges: this.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 isInConflictResolutionMode = (yield flowResult(
+        this.sdlcState.checkIfCurrentWorkspaceIsInConflictResolutionMode(),
+      )) as boolean;
+      if (isInConflictResolutionMode) {
+        this.editorStore.applicationStore.setBlockingAlert({
+          message: 'Workspace is in conflict resolution mode',
+          prompt: 'Please refresh the application',
+        });
+        return;
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notifyWarning(
+        'Failed to check if current workspace is in conflict resolution mode',
       );
-      const latestRevision = Revision.serialization.fromJson(revisionChange);
-      this.sdlcState.setCurrentRevision(latestRevision); // update current revision to the latest
-      this.sdlcState.setWorkspaceLatestRevision(latestRevision);
-      const syncFinishedTime = Date.now();
+      return;
+    }
+  }
 
-      this.editorStore.applicationStore.log.info(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.WORKSPACE_LOCAL_CHANGES_PUSHED),
-        syncFinishedTime - startTime,
-        'ms',
-      );
-      this.localChanges = [];
+  getLocalChanges(): EntityChange[] {
+    return this.editorStore.graphState.computeLocalEntityChanges();
+  }
 
-      // ======= (RE)START CHANGE DETECTION =======
-      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_LOCAL_HASHES_INDEX_BUILT,
-            ),
-          ),
-        );
-        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.log.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.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;
-        }
-      }
-      // compute the changes in text mode
+  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,
       );
-
-      this.editorStore.applicationStore.log.info(
-        LogEvent.create(CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTARTED),
-        Date.now() - syncFinishedTime,
-        'ms',
-      );
-      // ======= FINISHED (RE)START CHANGE DETECTION =======
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.log.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.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.notifyError(error);
-      }
+      this.editorStore.applicationStore.notifyError(error);
+      this.sdlcState.handleChangeDetectionRefreshIssue(error);
     } finally {
-      this.pushChangesState.complete();
+      this.refreshLocalChangesDetectorState.complete();
     }
   }
+
+  *processConflicts(): GeneratorFn<void> {
+    return;
+  }
+
+  getLocalChanges(): EntityChange[] {
+    return this.localChanges;
+  }
+
+  getCurrentHashIndexes(): Map<string, string> {
+    return this.editorStore.changeDetectionState
+      .workspaceLocalLatestRevisionState.currentEntityHashesIndex;
+  }
+
+  stopChangeDetection(): void {
+    this.localChanges = [];
+  }
+
+  *restartChangeDetection(): GeneratorFn<void> {
+    this.editorStore.changeDetectionState.computeLocalChangesInTextMode(
+      this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState
+        .entities,
+    );
+  }
 }