@finos/legend-application-studio 13.0.0

package/lib/stores/shared/testable/TestableUtils.js

@@ -0,0 +1,142 @@
+/**
+ * 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 { ExternalFormatData, RelationalCSVData, ConnectionTestData, EngineRuntime, RuntimePointer, EqualToJson, DEFAULT_TEST_ASSERTION_PREFIX, RelationalCSVDataTable, } from '@finos/legend-graph';
+import { assertTrue, ContentType, generateEnumerableNameFromToken, guaranteeNonEmptyString, isNonNullable, returnUndefOnError, } from '@finos/legend-shared';
+import { EmbeddedDataType } from '../../editor-state/ExternalFormatState.js';
+import { createMockDataForMappingElementSource } from '../MockDataUtil.js';
+export const createBareExternalFormat = (contentType) => {
+    const data = new ExternalFormatData();
+    data.contentType = contentType ?? ContentType.APPLICATION_JSON;
+    data.data = '';
+    return data;
+};
+export const getAllIdentifiedConnectionsFromRuntime = (runtime) => {
+    const resolvedRuntimes = [];
+    if (runtime instanceof RuntimePointer) {
+        const engineRuntime = runtime.packageableRuntime.value.runtimeValue;
+        resolvedRuntimes.push(engineRuntime);
+    }
+    else if (runtime instanceof EngineRuntime) {
+        resolvedRuntimes.push(runtime);
+    }
+    return resolvedRuntimes
+        .flatMap((e) => e.connections.map((l) => l.storeConnections))
+        .flat();
+};
+// NOTE: this will all move to `engine` once engine support generating test data for all connections
+// Throws if unable to generate test data
+export class TEMPORARY_EmbeddedDataConnectionVisitor {
+    editorStore;
+    constructor(editorStore) {
+        this.editorStore = editorStore;
+    }
+    visit_Connection(connection) {
+        throw new Error('Method not implemented.');
+    }
+    visit_ConnectionPointer(connection) {
+        const packageableConnection = connection.packageableConnection.value.connectionValue;
+        return packageableConnection.accept_ConnectionVisitor(this);
+    }
+    visit_ModelChainConnection(connection) {
+        throw new Error('Method not implemented.');
+    }
+    visit_JsonModelConnection(connection) {
+        const _class = connection.class.value;
+        const _json = createMockDataForMappingElementSource(_class, this.editorStore);
+        const data = createBareExternalFormat();
+        data.data = _json;
+        return data;
+    }
+    visit_XmlModelConnection(connection) {
+        throw new Error('Method not implemented.');
+    }
+    visit_FlatDataConnection(connection) {
+        throw new Error('Method not implemented.');
+    }
+    visit_RelationalDatabaseConnection(connection) {
+        throw new Error('Method not implemented.');
+    }
+}
+export class EmbeddedDataConnectionTypeVisitor {
+    editorStore;
+    constructor(editorStore) {
+        this.editorStore = editorStore;
+    }
+    visit_Connection(connection) {
+        return EmbeddedDataType.EXTERNAL_FORMAT_DATA;
+    }
+    visit_ConnectionPointer(connection) {
+        const packageableConnection = connection.packageableConnection.value.connectionValue;
+        return packageableConnection.accept_ConnectionVisitor(this);
+    }
+    visit_ModelChainConnection(connection) {
+        return EmbeddedDataType.EXTERNAL_FORMAT_DATA;
+    }
+    visit_JsonModelConnection(connection) {
+        return EmbeddedDataType.EXTERNAL_FORMAT_DATA;
+    }
+    visit_XmlModelConnection(connection) {
+        return EmbeddedDataType.EXTERNAL_FORMAT_DATA;
+    }
+    visit_FlatDataConnection(connection) {
+        return EmbeddedDataType.EXTERNAL_FORMAT_DATA;
+    }
+    visit_RelationalDatabaseConnection(connection) {
+        return EmbeddedDataType.RELATIONAL_CSV;
+    }
+}
+export const initializeConnectionDataFromRuntime = (runtime, editorStore) => {
+    const identifiedConnections = getAllIdentifiedConnectionsFromRuntime(runtime);
+    return identifiedConnections
+        .map((identifiedConnection) => {
+        const connection = identifiedConnection.connection;
+        const embeddedData = returnUndefOnError(() => connection.accept_ConnectionVisitor(new TEMPORARY_EmbeddedDataConnectionVisitor(editorStore)));
+        if (embeddedData) {
+            const connectionTestData = new ConnectionTestData();
+            connectionTestData.connectionId = identifiedConnection.id;
+            connectionTestData.testData = embeddedData;
+            return connectionTestData;
+        }
+        return undefined;
+    })
+        .filter(isNonNullable);
+};
+export const createEmptyEqualToJsonAssertion = (test) => {
+    const assert = new EqualToJson();
+    assert.id = generateEnumerableNameFromToken(test.assertions.map((a) => a.id), DEFAULT_TEST_ASSERTION_PREFIX);
+    assert.expected = createBareExternalFormat();
+    assert.parentTest = test;
+    return assert;
+};
+export const createRelationalDataFromCSV = (val) => {
+    const data = new RelationalCSVData();
+    const separator = '\n-----\n';
+    const lineBreak = /\r?\n/;
+    const tables = val
+        .split(separator)
+        .filter((e) => !(e === '\n' || e === '\r' || e === ''));
+    tables.forEach((tableData) => {
+        const tableInfo = tableData.split(lineBreak);
+        assertTrue(tableInfo.length >= 2, 'Table and Schema Name required from test data');
+        const table = new RelationalCSVDataTable();
+        table.schema = guaranteeNonEmptyString(tableInfo.shift());
+        table.table = guaranteeNonEmptyString(tableInfo.shift());
+        table.values = tableInfo.join('\n');
+        data.tables.push(table);
+    });
+    return data;
+};
+//# sourceMappingURL=TestableUtils.js.map

package/lib/stores/shared/testable/TestableUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestableUtils.js","sourceRoot":"","sources":["../../../../src/stores/shared/testable/TestableUtils.ts"],"names":[],"mappings":"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"}

package/lib/stores/sidebar-state/LocalChangesState.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { EditorStore } from '../EditorStore.js';
+import type { EditorSDLCState } from '../EditorSDLCState.js';
+import { type GeneratorFn, ActionState } from '@finos/legend-shared';
+import { type EntityChangeConflict, EntityDiff, EntityChange } from '@finos/legend-server-sdlc';
+import { WorkspaceSyncState } from './WorkspaceSyncState.js';
+declare class PatchLoaderState {
+    editorStore: EditorStore;
+    sdlcState: EditorSDLCState;
+    changes: EntityChange[] | undefined;
+    currentChanges: EntityChange[];
+    isLoadingChanges: boolean;
+    showModal: boolean;
+    isValidPatch: boolean;
+    constructor(editorStore: EditorStore, sdlcState: EditorSDLCState);
+    openModal(localChanges: EntityChange[]): void;
+    closeModal(): void;
+    setIsValidPatch(val: boolean): void;
+    setPatchChanges(changes: EntityChange[] | undefined): void;
+    deleteChange(change: EntityChange): void;
+    get overiddingChanges(): EntityChange[];
+    loadPatchFile(file: File): GeneratorFn<void>;
+    applyChanges(): GeneratorFn<void>;
+}
+export declare class LocalChangesState {
+    editorStore: EditorStore;
+    sdlcState: EditorSDLCState;
+    workspaceSyncState: WorkspaceSyncState;
+    pushChangesState: ActionState;
+    refreshLocalChangesDetectorState: ActionState;
+    patchLoaderState: PatchLoaderState;
+    refreshWorkspaceSyncStatusState: ActionState;
+    constructor(editorStore: EditorStore, sdlcState: EditorSDLCState);
+    openLocalChange(diff: EntityDiff): void;
+    openWorkspacePullChange(diff: EntityDiff): void;
+    refreshLocalChanges(): GeneratorFn<void>;
+    refreshWorkspaceSyncStatus(): GeneratorFn<void>;
+    openPotentialWorkspacePullConflict(conflict: EntityChangeConflict): void;
+    downloadLocalChanges: () => void;
+    pushLocalChanges(pushMessage?: string): GeneratorFn<void>;
+}
+export {};
+//# sourceMappingURL=LocalChangesState.d.ts.map

package/lib/stores/sidebar-state/LocalChangesState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalChangesState.d.ts","sourceRoot":"","sources":["../../../src/stores/sidebar-state/LocalChangesState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EACL,KAAK,WAAW,EAYhB,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAS9B,OAAO,EACL,KAAK,oBAAoB,EACzB,UAAU,EACV,YAAY,EAEb,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAK7D,cAAM,gBAAgB;IACpB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,eAAe,CAAC;IAE3B,OAAO,EAAE,YAAY,EAAE,GAAG,SAAS,CAAC;IACpC,cAAc,EAAE,YAAY,EAAE,CAAM;IACpC,gBAAgB,UAAS;IACzB,SAAS,UAAS;IAClB,YAAY,UAAS;gBAET,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,eAAe;IAchE,SAAS,CAAC,YAAY,EAAE,YAAY,EAAE,GAAG,IAAI;IAK7C,UAAU,IAAI,IAAI;IAMlB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAInC,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,SAAS,GAAG,IAAI;IAI1D,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAMxC,IAAI,iBAAiB,IAAI,YAAY,EAAE,CAStC;IAEA,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC;IAyB5C,YAAY,IAAI,WAAW,CAAC,IAAI,CAAC;CAmBnC;AAED,qBAAa,iBAAiB;IAC5B,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,eAAe,CAAC;IAC3B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,gBAAgB,cAAwB;IACxC,gCAAgC,cAAwB;IACxD,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,+BAA+B,cAAwB;gBAE3C,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,eAAe;IAchE,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAwDvC,uBAAuB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAwD9C,mBAAmB,IAAI,WAAW,CAAC,IAAI,CAAC;IA8BxC,0BAA0B,IAAI,WAAW,CAAC,IAAI,CAAC;IA4DhD,kCAAkC,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IA+CxE,oBAAoB,QAAO,IAAI,CAc7B;IAED,gBAAgB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC;CA8O3D"}

package/lib/stores/sidebar-state/LocalChangesState.js

@@ -0,0 +1,409 @@
+/**
+ * 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, makeAutoObservable, flowResult, flow } from 'mobx';
+import { format } from 'date-fns';
+import { CHANGE_DETECTION_EVENT } from '../ChangeDetectionEvent.js';
+import { LogEvent, assertErrorThrown, downloadFileUsingDataURI, guaranteeNonNullable, ContentType, NetworkClientError, HttpStatus, deleteEntry, assertTrue, readFileAsText, ActionState, } 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 { EntityDiff, EntityChange, Revision, } from '@finos/legend-server-sdlc';
+import { LEGEND_STUDIO_APP_EVENT } from '../LegendStudioAppEvent.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 {
+    editorStore;
+    sdlcState;
+    changes;
+    currentChanges = [];
+    isLoadingChanges = false;
+    showModal = false;
+    isValidPatch = false;
+    constructor(editorStore, sdlcState) {
+        makeAutoObservable(this, {
+            editorStore: false,
+            sdlcState: false,
+            openModal: action,
+            closeModal: action,
+            deleteChange: action,
+            loadPatchFile: flow,
+        });
+        this.editorStore = editorStore;
+        this.sdlcState = sdlcState;
+    }
+    openModal(localChanges) {
+        this.currentChanges = localChanges;
+        this.showModal = true;
+    }
+    closeModal() {
+        this.currentChanges = [];
+        this.setPatchChanges(undefined);
+        this.showModal = false;
+    }
+    setIsValidPatch(val) {
+        this.isValidPatch = val;
+    }
+    setPatchChanges(changes) {
+        this.changes = changes;
+    }
+    deleteChange(change) {
+        if (this.changes) {
+            deleteEntry(this.changes, change);
+        }
+    }
+    get overiddingChanges() {
+        if (this.changes?.length) {
+            return this.changes.filter((change) => this.currentChanges.find((local) => local.entityPath === change.entityPath));
+        }
+        return [];
+    }
+    *loadPatchFile(file) {
+        try {
+            this.setPatchChanges(undefined);
+            assertTrue(file.type === ContentType.APPLICATION_JSON, `Patch file expected to be of type 'JSON'`);
+            const fileText = (yield readFileAsText(file));
+            const entityChanges = JSON.parse(fileText);
+            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.notifyError(`Can't load patch: Error: ${error.message}`);
+        }
+    }
+    *applyChanges() {
+        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.notifyError(`Can't apply patch changes: Error: ${error.message}`);
+            }
+        }
+    }
+}
+export class LocalChangesState {
+    editorStore;
+    sdlcState;
+    workspaceSyncState;
+    pushChangesState = ActionState.create();
+    refreshLocalChangesDetectorState = ActionState.create();
+    patchLoaderState;
+    refreshWorkspaceSyncStatusState = ActionState.create();
+    constructor(editorStore, sdlcState) {
+        makeAutoObservable(this, {
+            editorStore: false,
+            sdlcState: false,
+            openLocalChange: action,
+            refreshWorkspaceSyncStatus: flow,
+        });
+        this.editorStore = editorStore;
+        this.sdlcState = sdlcState;
+        this.patchLoaderState = new PatchLoaderState(editorStore, sdlcState);
+        this.workspaceSyncState = new WorkspaceSyncState(editorStore, sdlcState);
+    }
+    openLocalChange(diff) {
+        const fromEntityGetter = (entityPath) => entityPath
+            ? this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState.entities.find((e) => e.path === entityPath)
+            : undefined;
+        const toEntityGetter = (entityPath) => {
+            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.openEntityDiff(new EntityDiffViewState(this.editorStore, SPECIAL_REVISION_ALIAS.WORKSPACE_HEAD, SPECIAL_REVISION_ALIAS.LOCAL, diff.oldPath, diff.newPath, fromEntity, toEntity, fromEntityGetter, toEntityGetter));
+    }
+    openWorkspacePullChange(diff) {
+        const fromEntityGetter = (entityPath) => {
+            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 toEntityGetter = (entityPath) => entityPath
+            ? this.editorStore.changeDetectionState.workspaceRemoteLatestRevisionState.entities.find((e) => e.path === entityPath)
+            : 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.openEntityDiff(new EntityDiffViewState(this.editorStore, SPECIAL_REVISION_ALIAS.LOCAL, SPECIAL_REVISION_ALIAS.WORKSPACE_HEAD, diff.oldPath, diff.newPath, fromEntity, toEntity, fromEntityGetter, toEntityGetter));
+    }
+    *refreshLocalChanges() {
+        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() {
+        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.editorStore.localChangesState.workspaceSyncState.fetchIncomingRevisions();
+                    const remoteWorkspaceEntities = (yield this.editorStore.sdlcServerClient.getEntitiesByRevision(this.sdlcState.activeProject.projectId, this.sdlcState.activeWorkspace, this.sdlcState.activeRemoteWorkspaceRevision.id));
+                    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)));
+                    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.log.error(LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE), error);
+        }
+        finally {
+            this.refreshWorkspaceSyncStatusState.complete();
+        }
+    }
+    openPotentialWorkspacePullConflict(conflict) {
+        const baseEntityGetter = (entityPath) => entityPath
+            ? this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState.entities.find((e) => e.path === entityPath)
+            : undefined;
+        const currentChangeEntityGetter = (entityPath) => entityPath
+            ? this.editorStore.graphManagerState.graph.allOwnElements
+                .map((element) => this.editorStore.graphManagerState.graphManager.elementToEntity(element))
+                .find((e) => e.path === entityPath)
+            : undefined;
+        const incomingChangeEntityGetter = (entityPath) => 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.openEntityChangeConflict(conflictEditorState);
+    }
+    downloadLocalChanges = () => {
+        const fileName = `entityChanges_(${this.sdlcState.currentProject?.name}_${this.sdlcState.activeWorkspace.workspaceId})_${format(new Date(Date.now()), DATE_TIME_FORMAT)}.json`;
+        const content = JSON.stringify({
+            message: '',
+            entityChanges: this.editorStore.graphState.computeLocalEntityChanges(),
+            revisionId: this.sdlcState.activeRevision.id,
+        }, undefined, TAB_SIZE);
+        downloadFileUsingDataURI(fileName, content, ContentType.APPLICATION_JSON);
+    };
+    *pushLocalChanges(pushMessage) {
+        if (this.pushChangesState.isInProgress ||
+            this.editorStore.workspaceUpdaterState.isUpdatingWorkspace) {
+            return;
+        }
+        // check if the workspace is in conflict resolution mode
+        try {
+            const isInConflictResolutionMode = (yield flowResult(this.sdlcState.checkIfCurrentWorkspaceIsInConflictResolutionMode()));
+            if (isInConflictResolutionMode) {
+                this.editorStore.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;
+        }
+        this.pushChangesState.inProgress();
+        const startTime = Date.now();
+        const localChanges = this.editorStore.graphState.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));
+            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)));
+            yield flowResult(this.editorStore.changeDetectionState.computeAggregatedWorkspaceRemoteChanges());
+            this.editorStore.setActionAlertInfo({
+                message: 'Local workspace is out-of-sync',
+                prompt: 'Please pull remote changes before pushing your local changes',
+                type: ActionAlertType.CAUTION,
+                onEnter: () => this.editorStore.setBlockGlobalHotkeys(true),
+                onClose: () => this.editorStore.setBlockGlobalHotkeys(false),
+                actions: [
+                    {
+                        label: 'Pull remote changes',
+                        type: ActionAlertActionType.STANDARD,
+                        default: true,
+                        handler: () => {
+                            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;
+        }
+        const currentHashesIndex = this.editorStore.changeDetectionState.snapshotLocalEntityHashesIndex();
+        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,
+            }));
+            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.log.info(LogEvent.create(LEGEND_STUDIO_APP_EVENT.WORKSPACE_LOCAL_CHANGES_PUSHED), syncFinishedTime - startTime, 'ms');
+            // ======= (RE)START CHANGE DETECTION =======
+            this.editorStore.changeDetectionState.stop();
+            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));
+                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.refreshCurrentEntityDiffEditorState();
+            }
+            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.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,
+                        onEnter: () => this.editorStore.setBlockGlobalHotkeys(true),
+                        onClose: () => this.editorStore.setBlockGlobalHotkeys(false),
+                        actions: [
+                            {
+                                label: 'Use local hashes index',
+                                type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+                                handler: () => {
+                                    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 this.editorStore.changeDetectionState.preComputeGraphElementHashes();
+            this.editorStore.changeDetectionState.start();
+            yield Promise.all([
+                this.editorStore.changeDetectionState.computeAggregatedWorkspaceChanges(true),
+            ]);
+            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);
+            }
+        }
+        finally {
+            this.pushChangesState.complete();
+        }
+    }
+}
+//# sourceMappingURL=LocalChangesState.js.map