@finos/legend-application-studio 22.5.0 → 23.0.0

package/src/stores/editor-state/element-editor-state/service/testable/ServiceTestDataState.ts

@@ -70,7 +70,7 @@ import {
 } from '../../data/DataEditorState.js';
 import { createEmbeddedData } from '../../data/EmbeddedDataState.js';
 import type { ServiceTestSuiteState } from './ServiceTestableState.js';
-import { LegendStudioTelemetry } from '../../../../LegendStudioTelemetry.js';
+import { LegendStudioTelemetryHelper } from '../../../../../application/LegendStudioTelemetryHelper.js';
 
 const buildTestDataParameters = (
   rawLambda: RawLambda,
@@ -146,7 +146,7 @@ export class ConnectionTestDataState {
         // NOTE: since we don't have a generic mechanism for test-data generation
         // we will only report metrics around API usage, when we genericize, we will
         // move this out
-        LegendStudioTelemetry.logEvent_TestDataGenerationLaunched(
+        LegendStudioTelemetryHelper.logEvent_TestDataGenerationLaunched(
           this.testDataState.editorStore.applicationStore.telemetryService,
         );
         const report = reportGraphAnalytics(
@@ -172,7 +172,7 @@ export class ConnectionTestDataState {
         // NOTE: since we don't have a generic mechanism for test-data generation
         // we will only report metrics around API usage, when we genericize, we will
         // move this out
-        LegendStudioTelemetry.logEvent_TestDataGenerationSucceeded(
+        LegendStudioTelemetryHelper.logEvent_TestDataGenerationSucceeded(
           this.editorStore.applicationStore.telemetryService,
           report,
         );

package/src/stores/editor-state/entity-diff-editor-state/EntityDiffViewState.ts

@@ -29,7 +29,7 @@ import {
   EntityDiffViewerState,
 } from './EntityDiffEditorState.js';
 import { type Entity, extractEntityNameFromPath } from '@finos/legend-storage';
-import { LEGEND_STUDIO_APP_EVENT } from '../../LegendStudioAppEvent.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../application/LegendStudioEvent.js';
 import type { PackageableElement } from '@finos/legend-graph';
 import type { EditorState } from '../EditorState.js';
 

package/src/stores/editor-state/project-configuration-editor-state/ProjectConfigurationEditorState.ts

@@ -40,7 +40,7 @@ import {
   UpdateProjectConfigurationCommand,
   UpdatePlatformConfigurationsCommand,
 } from '@finos/legend-server-sdlc';
-import { LEGEND_STUDIO_APP_EVENT } from '../../LegendStudioAppEvent.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../application/LegendStudioEvent.js';
 import { MASTER_SNAPSHOT_ALIAS, ProjectData } from '@finos/legend-server-depot';
 import { ProjectDependencyEditorState } from './ProjectDependencyEditorState.js';
 

package/src/stores/editor-state/project-configuration-editor-state/ProjectDependencyEditorState.ts

@@ -38,7 +38,7 @@ import {
   RawProjectDependencyReport,
 } from '@finos/legend-server-depot';
 import type { TreeData, TreeNodeData } from '@finos/legend-art';
-import { LEGEND_STUDIO_APP_EVENT } from '../../LegendStudioAppEvent.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../application/LegendStudioEvent.js';
 import type { ProjectConfiguration } from '@finos/legend-server-sdlc';
 
 export abstract class ProjectDependencyConflictTreeNodeData

package/src/stores/project-viewer/ProjectViewerEditorMode.ts

@@ -19,7 +19,7 @@ import {
   generateViewProjectByGAVRoute,
   generateViewRevisionRoute,
   generateViewVersionRoute,
-} from '../LegendStudioRouter.js';
+} from '../../application/LegendStudioNavigation.js';
 import { EditorMode } from '../editor/EditorMode.js';
 import type { ProjectViewerStore } from './ProjectViewerStore.js';
 import type { ProjectDependency } from '@finos/legend-server-sdlc';

package/src/stores/project-viewer/ProjectViewerStore.ts

@@ -31,7 +31,7 @@ import {
   generateViewVersionRoute,
   generateViewRevisionRoute,
   generateViewProjectRoute,
-} from '../LegendStudioRouter.js';
+} from '../../application/LegendStudioNavigation.js';
 import {
   type Entity,
   type ProjectGAVCoordinates,
@@ -46,8 +46,11 @@ import {
   Version,
   Workspace,
 } from '@finos/legend-server-sdlc';
-import { LEGEND_STUDIO_APP_EVENT } from '../LegendStudioAppEvent.js';
-import { ApplicationTelemetry, TAB_SIZE } from '@finos/legend-application';
+import { LEGEND_STUDIO_APP_EVENT } from '../../application/LegendStudioEvent.js';
+import {
+  LegendApplicationTelemetryHelper,
+  TAB_SIZE,
+} from '@finos/legend-application';
 import { ProjectData, resolveVersion } from '@finos/legend-server-depot';
 import {
   type WorkflowManagerState,
@@ -421,7 +424,7 @@ export class ProjectViewerStore {
             .numberOfDependencies,
         graph: graph_buildReport,
       };
-      ApplicationTelemetry.logEvent_GraphInitializationSucceeded(
+      LegendApplicationTelemetryHelper.logEvent_GraphInitializationSucceeded(
         this.editorStore.applicationStore.telemetryService,
         graphBuilderReportData,
       );
@@ -472,17 +475,12 @@ export class ProjectViewerStore {
         this.editorStore.applicationStore.notificationService.notifyError(
           `Can't build graph. Redirected to text mode for debugging. Error: ${error.message}`,
         );
-        try {
-          const editorGrammar =
-            (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(
-              entities,
-            )) as string;
-          yield flowResult(
-            this.editorStore.grammarTextEditorState.setGraphGrammarText(
-              editorGrammar,
-            ),
-          );
-        } catch {
+        yield flowResult(
+          this.editorStore.switchModes(GRAPH_EDITOR_MODE.GRAMMAR_TEXT, {
+            isGraphBuildFailure: true,
+          }),
+        );
+        if (this.editorStore.graphEditorMode.mode === GRAPH_EDITOR_MODE.FORM) {
           // nothing we can do here so we will just block the user
           this.editorStore.applicationStore.alertService.setBlockingAlert({
             message: `Can't compose Pure code from graph models`,
@@ -490,15 +488,6 @@ export class ProjectViewerStore {
           });
           return false;
         }
-        yield flowResult(
-          this.editorStore.setGraphEditMode(GRAPH_EDITOR_MODE.GRAMMAR_TEXT),
-        );
-        yield flowResult(
-          this.editorStore.graphState.globalCompileInTextMode({
-            ignoreBlocking: true,
-            suppressCompilationFailureMessage: true,
-          }),
-        );
       } else {
         this.editorStore.applicationStore.notificationService.notifyError(
           error,
@@ -580,7 +569,7 @@ export class ProjectViewerStore {
         this.initialEntityPath
       ) {
         try {
-          this.editorStore.tabManagerState.openElementEditor(
+          this.editorStore.graphEditorMode.openElement(
             this.editorStore.graphManagerState.graph.getElement(
               this.initialEntityPath,
             ),

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

@@ -0,0 +1,370 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { action, computed, makeObservable, observable, flow } from 'mobx';
+import type { EditorSDLCState } from '../EditorSDLCState.js';
+import type { EditorStore } from '../EditorStore.js';
+import {
+  type PureExecution,
+  areMultiplicitiesEqual,
+  buildLambdaVariableExpressions,
+  generateMultiplicityString,
+  Multiplicity,
+  VariableExpression,
+  ServiceExecutionMode,
+  type BulkRegistrationResultFail,
+  BulkRegistrationResultSuccess,
+  type BulkServiceRegistrationResult,
+} from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  ActionState,
+  assertNonEmptyString,
+  assertTrue,
+  filterByType,
+  getNullableFirstElement,
+  guaranteeNonNullable,
+  prettyCONSTName,
+  UnsupportedOperationError,
+  assertErrorThrown,
+  LogEvent,
+} from '@finos/legend-shared';
+import { Version } from '@finos/legend-server-sdlc';
+import { MINIMUM_SERVICE_OWNERS } from '../editor-state/element-editor-state/service/ServiceEditorState.js';
+import { ServiceRegistrationEnvironmentConfig } from '../../application/LegendStudioApplicationConfig.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../../application/LegendStudioEvent.js';
+import { generateServiceManagementUrl } from '../editor-state/element-editor-state/service/ServiceRegistrationState.js';
+
+export const LATEST_PROJECT_REVISION = 'Latest Project Revision';
+const getServiceExecutionMode = (mode: string): ServiceExecutionMode => {
+  switch (mode) {
+    case ServiceExecutionMode.FULL_INTERACTIVE:
+      return ServiceExecutionMode.FULL_INTERACTIVE;
+    case ServiceExecutionMode.SEMI_INTERACTIVE:
+      return ServiceExecutionMode.SEMI_INTERACTIVE;
+    case ServiceExecutionMode.PROD:
+      return ServiceExecutionMode.PROD;
+    default:
+      throw new UnsupportedOperationError(
+        `Encountered unsupported service execution mode '${mode}'`,
+      );
+  }
+};
+interface ServiceVersionOption {
+  label: string;
+  value: Version | string;
+}
+interface ServiceRegistrationResult {
+  successfulServices: string[];
+  failedServices: string[];
+  serviceLinks: string[];
+}
+export class ServiceConfigState {
+  readonly editorStore: EditorStore;
+  readonly registrationOptions: ServiceRegistrationEnvironmentConfig[] = [];
+  readonly registrationState = ActionState.create();
+  registrationResult: ServiceRegistrationResult | undefined;
+  serviceEnv?: string | undefined;
+  serviceExecutionMode?: ServiceExecutionMode | undefined;
+  projectVersion?: Version | string | undefined;
+  enableModesWithVersioning: boolean;
+  TEMPORARY__useStoreModel = false;
+
+  constructor(
+    editorStore: EditorStore,
+    registrationOptions: ServiceRegistrationEnvironmentConfig[],
+    enableModesWithVersioning: boolean,
+  ) {
+    makeObservable(this, {
+      serviceEnv: observable,
+      serviceExecutionMode: observable,
+      projectVersion: observable,
+      enableModesWithVersioning: observable,
+      TEMPORARY__useStoreModel: observable,
+      executionModes: computed,
+      options: computed,
+      versionOptions: computed,
+      setServiceEnv: action,
+      setServiceExecutionMode: action,
+      setProjectVersion: action,
+
+      setUseStoreModelWithFullInteractive: action,
+      initialize: action,
+
+      updateVersion: action,
+      updateType: action,
+      updateEnv: action,
+    });
+
+    this.editorStore = editorStore;
+    this.registrationOptions = registrationOptions;
+    this.enableModesWithVersioning = enableModesWithVersioning;
+    this.initialize();
+    this.registrationState.setMessageFormatter(prettyCONSTName);
+  }
+
+  get options(): ServiceRegistrationEnvironmentConfig[] {
+    if (this.enableModesWithVersioning) {
+      return this.registrationOptions;
+    }
+    return this.registrationOptions
+      .map((_envConfig) => {
+        const envConfig = new ServiceRegistrationEnvironmentConfig();
+        envConfig.env = _envConfig.env;
+        envConfig.executionUrl = _envConfig.executionUrl;
+        envConfig.managementUrl = _envConfig.managementUrl;
+        // NOTE: For projects that we cannot create a version for, only fully-interactive mode is supported
+        envConfig.modes = _envConfig.modes.filter(
+          (mode) => mode === ServiceExecutionMode.FULL_INTERACTIVE,
+        );
+        return envConfig;
+      })
+      .filter((envConfig) => envConfig.modes.length);
+  }
+
+  get executionModes(): ServiceExecutionMode[] {
+    return (
+      this.options.find((e) => e.env === this.serviceEnv)?.modes ?? []
+    ).map(getServiceExecutionMode);
+  }
+
+  get versionOptions(): ServiceVersionOption[] | undefined {
+    if (
+      this.enableModesWithVersioning &&
+      this.serviceExecutionMode !== ServiceExecutionMode.FULL_INTERACTIVE
+    ) {
+      const options: ServiceVersionOption[] =
+        this.editorStore.sdlcState.projectVersions.map((version) => ({
+          label: version.id.id,
+          value: version,
+        }));
+      if (this.serviceExecutionMode !== ServiceExecutionMode.PROD) {
+        return [
+          {
+            label: prettyCONSTName(LATEST_PROJECT_REVISION),
+            value: LATEST_PROJECT_REVISION,
+          },
+          ...options,
+        ];
+      }
+      return options;
+    }
+    return undefined;
+  }
+
+  setServiceEnv(val: string | undefined): void {
+    this.serviceEnv = val;
+  }
+
+  setServiceExecutionMode(val: ServiceExecutionMode | undefined): void {
+    this.serviceExecutionMode = val;
+  }
+
+  setProjectVersion(val: Version | string | undefined): void {
+    this.projectVersion = val;
+  }
+
+  setUseStoreModelWithFullInteractive(val: boolean): void {
+    this.TEMPORARY__useStoreModel = val;
+  }
+
+  initialize(): void {
+    this.serviceEnv = getNullableFirstElement(this.registrationOptions)?.env;
+    this.serviceExecutionMode = this.executionModes[0];
+    this.updateVersion();
+  }
+
+  updateVersion(): void {
+    if (this.serviceExecutionMode === ServiceExecutionMode.SEMI_INTERACTIVE) {
+      this.projectVersion = LATEST_PROJECT_REVISION;
+    } else if (this.serviceExecutionMode === ServiceExecutionMode.PROD) {
+      this.projectVersion = this.editorStore.sdlcState.projectVersions[0];
+    } else {
+      this.projectVersion = undefined;
+    }
+  }
+
+  updateType(val: ServiceExecutionMode | undefined): void {
+    this.setServiceExecutionMode(val);
+    this.updateVersion();
+  }
+
+  updateEnv(val: string | undefined): void {
+    this.setServiceEnv(val);
+    this.setServiceExecutionMode(this.executionModes[0]);
+  }
+}
+
+export class BulkServiceRegistrationState {
+  editorStore: EditorStore;
+  sdlcState: EditorSDLCState;
+  serviceConfigState: ServiceConfigState;
+  showSuccessModel = false;
+
+  constructor(editorStore: EditorStore, sdlcState: EditorSDLCState) {
+    makeObservable(this, {
+      showSuccessModel: observable,
+      editorStore: false,
+      sdlcState: false,
+      registerServices: flow,
+      setSuccessModal: action,
+    });
+    this.editorStore = editorStore;
+    this.sdlcState = sdlcState;
+    this.serviceConfigState = new ServiceConfigState(
+      editorStore,
+      editorStore.applicationStore.config.options.TEMPORARY__serviceRegistrationConfig,
+      editorStore.sdlcServerClient.featuresConfigHasBeenFetched &&
+        editorStore.sdlcServerClient.features.canCreateVersion,
+    );
+  }
+  setSuccessModal(val: boolean): void {
+    this.showSuccessModel = val;
+  }
+  *registerServices(): GeneratorFn<void> {
+    const successfulServices: string[] = [];
+    const failedServices: string[] = [];
+    const serviceManagementURL: string[] = [];
+
+    this.serviceConfigState.registrationState.inProgress();
+    this.validateServiceForRegistration();
+    try {
+      const projectConfig = guaranteeNonNullable(
+        this.editorStore.projectConfigurationEditorState.projectConfiguration,
+      );
+
+      const versionInput =
+        this.serviceConfigState.projectVersion instanceof Version
+          ? this.serviceConfigState.projectVersion.id.id
+          : undefined;
+
+      const config = guaranteeNonNullable(
+        this.serviceConfigState.options.find(
+          (info) => info.env === this.serviceConfigState.serviceEnv,
+        ),
+      );
+      const serviceRegistrationResult =
+        (yield this.editorStore.graphManagerState.graphManager.bulkServiceRegistration(
+          this.editorStore.graphManagerState.graph.ownServices,
+          this.editorStore.graphManagerState.graph,
+          projectConfig.groupId,
+          projectConfig.artifactId,
+          versionInput,
+          config.executionUrl,
+          guaranteeNonNullable(this.serviceConfigState.serviceExecutionMode),
+          {
+            TEMPORARY__useStoreModel:
+              this.serviceConfigState.TEMPORARY__useStoreModel,
+          },
+        )) as BulkServiceRegistrationResult[];
+
+      serviceRegistrationResult.forEach((result) => {
+        if (result instanceof BulkRegistrationResultSuccess) {
+          const serviceURL = generateServiceManagementUrl(
+            config.managementUrl,
+            result.pattern,
+          );
+          serviceManagementURL.push(serviceURL);
+          successfulServices.push(result.pattern);
+        } else {
+          failedServices.push(
+            `${result.servicePath} ERROR: ${
+              (result as BulkRegistrationResultFail).errorMessage
+            }`,
+          );
+        }
+      });
+      this.serviceConfigState.registrationResult = {
+        successfulServices: successfulServices,
+        serviceLinks: serviceManagementURL,
+        failedServices: failedServices,
+      };
+      this.showSuccessModel = true;
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.serviceConfigState.registrationState.reset();
+      this.serviceConfigState.registrationState.setMessage(undefined);
+    }
+  }
+
+  validateServiceForRegistration(): void {
+    const services = this.editorStore.graphManagerState.graph.ownServices;
+
+    services.forEach((service) => {
+      service.owners.forEach((owner) =>
+        assertNonEmptyString(owner, `Service can't have an empty owner name`),
+      );
+      assertTrue(
+        service.owners.length >= MINIMUM_SERVICE_OWNERS,
+        `Service needs to have at least 2 owners in order to be registered`,
+      );
+      guaranteeNonNullable(
+        this.serviceConfigState.serviceEnv,
+        'Service registration environment can not be empty',
+      );
+      guaranteeNonNullable(
+        this.serviceConfigState.serviceExecutionMode,
+        'Service type can not be empty',
+      );
+      if (
+        this.serviceConfigState.serviceExecutionMode ===
+          ServiceExecutionMode.PROD ||
+        this.serviceConfigState.serviceExecutionMode ===
+          ServiceExecutionMode.SEMI_INTERACTIVE
+      ) {
+        guaranteeNonNullable(
+          this.serviceConfigState.projectVersion,
+          'Service version can not be empty in Semi-interactive and Prod service type',
+        );
+      }
+
+      // validate service parameter multiplicities
+      const SUPPORTED_SERVICE_PARAMETER_MULTIPLICITIES = [
+        Multiplicity.ONE,
+        Multiplicity.ZERO_MANY,
+        Multiplicity.ZERO_ONE,
+      ];
+      const invalidParams = buildLambdaVariableExpressions(
+        (service.execution as PureExecution).func,
+        this.editorStore.graphManagerState,
+      )
+        .filter(filterByType(VariableExpression))
+        .filter(
+          (p) =>
+            !SUPPORTED_SERVICE_PARAMETER_MULTIPLICITIES.some((m) =>
+              areMultiplicitiesEqual(m, p.multiplicity),
+            ),
+        );
+      assertTrue(
+        invalidParams.length === 0,
+        `Parameter(s)${invalidParams.map(
+          (p) =>
+            ` ${p.name}: [${generateMultiplicityString(
+              p.multiplicity.lowerBound,
+              p.multiplicity.upperBound,
+            )}]`,
+        )} has/have unsupported multiplicity. Supported multiplicities include ${SUPPORTED_SERVICE_PARAMETER_MULTIPLICITIES.map(
+          (m) => ` [${generateMultiplicityString(m.lowerBound, m.upperBound)}]`,
+        )}.`,
+      );
+    });
+  }
+}

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

@@ -54,8 +54,9 @@ import {
   EntityDiff,
   EntityChange,
   Revision,
+  EntityChangeType,
 } from '@finos/legend-server-sdlc';
-import { LEGEND_STUDIO_APP_EVENT } from '../LegendStudioAppEvent.js';
+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';
@@ -213,7 +214,7 @@ export abstract class LocalChangesState {
     const content = JSON.stringify(
       {
         message: '', // TODO?
-        entityChanges: this.editorStore.graphState.computeLocalEntityChanges(),
+        entityChanges: this.computeLocalEntityChanges(),
         revisionId: this.sdlcState.activeRevision.id,
       },
       undefined,
@@ -226,7 +227,7 @@ export abstract class LocalChangesState {
     if (this.hasUnpushedChanges) {
       this.editorStore.applicationStore.alertService.setActionAlertInfo({
         message:
-          'Unsaved changes to your query will be lost if you continue. Do you still want to proceed?',
+          'Unsaved changes will be lost if you continue. Do you still want to proceed?',
         type: ActionAlertType.CAUTION,
         actions: [
           {
@@ -262,7 +263,7 @@ export abstract class LocalChangesState {
         this.sdlcState.activeRemoteWorkspaceRevision.id
       ) {
         if (this.sdlcState.isWorkspaceOutOfSync) {
-          this.editorStore.localChangesState.workspaceSyncState.fetchIncomingRevisions();
+          this.workspaceSyncState.fetchIncomingRevisions();
           const remoteWorkspaceEntities =
             (yield this.editorStore.sdlcServerClient.getEntitiesByRevision(
               this.sdlcState.activeProject.projectId,
@@ -310,14 +311,14 @@ export abstract class LocalChangesState {
 
   abstract processConflicts(): GeneratorFn<void>;
 
-  abstract getLocalChanges(): EntityChange[];
-
   abstract getCurrentHashIndexes(): Map<string, string>;
 
   abstract stopChangeDetection(): void;
 
   abstract restartChangeDetection(): GeneratorFn<void>;
 
+  abstract computeLocalEntityChanges(): EntityChange[];
+
   *pushLocalChanges(pushMessage?: string): GeneratorFn<void> {
     if (
       this.pushChangesState.isInProgress ||
@@ -330,7 +331,7 @@ export abstract class LocalChangesState {
 
     this.pushChangesState.inProgress();
     const startTime = Date.now();
-    const localChanges = this.getLocalChanges();
+    const localChanges = this.computeLocalEntityChanges();
     if (!localChanges.length) {
       this.pushChangesState.complete();
       return;
@@ -374,9 +375,9 @@ export abstract class LocalChangesState {
             default: true,
             handler: (): void => {
               this.editorStore.setActiveActivity(ACTIVITY_MODE.LOCAL_CHANGES);
-              flowResult(
-                this.editorStore.localChangesState.workspaceSyncState.pullChanges(),
-              ).catch(this.editorStore.applicationStore.alertUnhandledError);
+              flowResult(this.workspaceSyncState.pullChanges()).catch(
+                this.editorStore.applicationStore.alertUnhandledError,
+              );
             },
           },
           {
@@ -749,8 +750,48 @@ export class FormLocalChangesState extends LocalChangesState {
     }
   }
 
-  getLocalChanges(): EntityChange[] {
-    return this.editorStore.graphState.computeLocalEntityChanges();
+  /**
+   * 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> {
@@ -814,10 +855,6 @@ export class TextLocalChangesState extends LocalChangesState {
     return;
   }
 
-  getLocalChanges(): EntityChange[] {
-    return this.localChanges;
-  }
-
   getCurrentHashIndexes(): Map<string, string> {
     return this.editorStore.changeDetectionState
       .workspaceLocalLatestRevisionState.currentEntityHashesIndex;
@@ -827,6 +864,10 @@ export class TextLocalChangesState extends LocalChangesState {
     this.localChanges = [];
   }
 
+  computeLocalEntityChanges(): EntityChange[] {
+    return this.localChanges;
+  }
+
   *restartChangeDetection(): GeneratorFn<void> {
     this.editorStore.changeDetectionState.computeLocalChangesInTextMode(
       this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState

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

@@ -24,7 +24,7 @@ import {
   LogEvent,
   getNullableFirstElement,
 } from '@finos/legend-shared';
-import { generateSetupRoute } from '../LegendStudioRouter.js';
+import { generateSetupRoute } from '../../application/LegendStudioNavigation.js';
 import {
   type NewVersionType,
   CreateVersionCommand,
@@ -36,7 +36,7 @@ import {
   Review,
   areWorkspacesEquivalent,
 } from '@finos/legend-server-sdlc';
-import { LEGEND_STUDIO_APP_EVENT } from '../LegendStudioAppEvent.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../../application/LegendStudioEvent.js';
 import { ProjectDependantEditorState } from './ProjectDependantEditorState.js';
 import {
   ProjectData,