@finos/legend-application-studio 22.1.6 → 22.2.1

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

@@ -174,7 +174,7 @@ class PatchLoaderState {
   }
 }
 
-export class LocalChangesState {
+export abstract class LocalChangesState {
   readonly editorStore: EditorStore;
   readonly sdlcState: EditorSDLCState;
   readonly workspaceSyncState: WorkspaceSyncState;
@@ -186,10 +186,11 @@ export class LocalChangesState {
   constructor(editorStore: EditorStore, sdlcState: EditorSDLCState) {
     makeObservable(this, {
       hasUnpushedChanges: computed,
-      openPotentialWorkspacePullConflict: action,
       refreshWorkspaceSyncStatus: flow,
       refreshLocalChanges: flow,
       pushLocalChanges: flow,
+      processConflicts: flow,
+      restartChangeDetection: flow,
     });
 
     this.editorStore = editorStore;
@@ -245,189 +246,6 @@ export class LocalChangesState {
     }
   }
 
-  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.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();
-    }
-  }
-
   *refreshWorkspaceSyncStatus(): GeneratorFn<void> {
     try {
       this.refreshWorkspaceSyncStatusState.inProgress();
@@ -488,6 +306,18 @@ export class LocalChangesState {
     }
   }
 
+  abstract refreshLocalChanges(): GeneratorFn<void>;
+
+  abstract processConflicts(): GeneratorFn<void>;
+
+  abstract getLocalChanges(): EntityChange[];
+
+  abstract getCurrentHashIndexes(): Map<string, string>;
+
+  abstract stopChangeDetection(): void;
+
+  abstract restartChangeDetection(): GeneratorFn<void>;
+
   *pushLocalChanges(pushMessage?: string): GeneratorFn<void> {
     if (
       this.pushChangesState.isInProgress ||
@@ -496,29 +326,11 @@ export class 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;
@@ -576,8 +388,8 @@ export class LocalChangesState {
       this.pushChangesState.complete();
       return;
     }
-    const currentHashesIndex =
-      this.editorStore.changeDetectionState.snapshotLocalEntityHashesIndex();
+    const currentHashesIndex = this.getCurrentHashIndexes();
+
     try {
       const nullableRevisionChange =
         (yield this.editorStore.sdlcServerClient.performEntityChanges(
@@ -613,7 +425,9 @@ export class LocalChangesState {
       );
 
       // ======= (RE)START CHANGE DETECTION =======
-      this.editorStore.changeDetectionState.stop();
+
+      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
@@ -686,13 +500,7 @@ export class 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,
@@ -723,3 +531,300 @@ export class LocalChangesState {
     }
   }
 }
+
+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.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();
+    }
+  }
+
+  *processConflicts(): GeneratorFn<void> {
+    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;
+    }
+  }
+
+  getLocalChanges(): EntityChange[] {
+    return this.editorStore.graphState.computeLocalEntityChanges();
+  }
+
+  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.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();
+    }
+  }
+
+  *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,
+    );
+  }
+}