@finos/legend-application-studio 28.4.4 → 28.5.0

package/src/stores/editor/EditorSDLCState.ts

@@ -46,6 +46,7 @@ import {
   Version,
   Workspace,
   WorkspaceAccessType,
+  Patch,
 } from '@finos/legend-server-sdlc';
 import { LEGEND_STUDIO_APP_EVENT } from '../../__lib__/LegendStudioEvent.js';
 
@@ -65,6 +66,7 @@ export class EditorSDLCState {
   isFetchingProject = false;
 
   currentProject?: Project | undefined;
+  currentPatch?: Patch | undefined;
   currentWorkspace?: Workspace | undefined;
   remoteWorkspaceRevision?: Revision | undefined;
   currentRevision?: Revision | undefined;
@@ -75,6 +77,7 @@ export class EditorSDLCState {
   constructor(editorStore: EditorStore) {
     makeObservable(this, {
       currentProject: observable,
+      currentPatch: observable,
       currentWorkspace: observable,
       remoteWorkspaceRevision: observable,
       currentRevision: observable,
@@ -88,9 +91,11 @@ export class EditorSDLCState {
       activeProject: computed,
       activeWorkspace: computed,
       activeRevision: computed,
+      activePatch: computed,
       activeRemoteWorkspaceRevision: computed,
       isWorkspaceOutOfSync: computed,
       setCurrentProject: action,
+      setCurrentPatch: action,
       setCurrentWorkspace: action,
       setCurrentRevision: action,
       setWorkspaceLatestRevision: action,
@@ -100,6 +105,7 @@ export class EditorSDLCState {
       checkIfCurrentWorkspaceIsInConflictResolutionMode: flow,
       fetchRemoteWorkspaceRevision: flow,
       fetchCurrentRevision: flow,
+      fetchCurrentPatch: flow,
       checkIfWorkspaceIsOutdated: flow,
       buildWorkspaceLatestRevisionEntityHashesIndex: flow,
       buildWorkspaceBaseRevisionEntityHashesIndex: flow,
@@ -125,6 +131,10 @@ export class EditorSDLCState {
     );
   }
 
+  get activePatch(): Patch | undefined {
+    return this.currentPatch;
+  }
+
   get activeRevision(): Revision {
     return guaranteeNonNullable(
       this.currentRevision,
@@ -147,6 +157,10 @@ export class EditorSDLCState {
     this.currentProject = val;
   }
 
+  setCurrentPatch(val: Patch): void {
+    this.currentPatch = val;
+  }
+
   setCurrentWorkspace(val: Workspace): void {
     this.currentWorkspace = val;
   }
@@ -204,8 +218,37 @@ export class EditorSDLCState {
     }
   }
 
+  *fetchCurrentPatch(
+    projectId: string,
+    patchReleaseVersionId: string | undefined,
+    options?: { suppressNotification?: boolean },
+  ): GeneratorFn<void> {
+    if (patchReleaseVersionId) {
+      try {
+        this.currentPatch = Patch.serialization.fromJson(
+          (yield this.editorStore.sdlcServerClient.getPatch(
+            projectId,
+            patchReleaseVersionId,
+          )) as PlainObject<Patch>,
+        );
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+          error,
+        );
+        if (!options?.suppressNotification) {
+          this.editorStore.applicationStore.notificationService.notifyError(
+            error,
+          );
+        }
+      }
+    }
+  }
+
   *fetchCurrentWorkspace(
     projectId: string,
+    patchReleaseVersionId: string | undefined,
     workspaceId: string,
     workspaceType: WorkspaceType,
     options?: { suppressNotification?: boolean },
@@ -214,10 +257,12 @@ export class EditorSDLCState {
       this.currentWorkspace = Workspace.serialization.fromJson(
         (yield this.editorStore.sdlcServerClient.getWorkspace(
           projectId,
+          patchReleaseVersionId,
           workspaceId,
           workspaceType,
         )) as PlainObject<Workspace>,
       );
+      this.currentWorkspace.source = patchReleaseVersionId;
       const isInConflictResolutionMode = (yield flowResult(
         this.checkIfCurrentWorkspaceIsInConflictResolutionMode(),
       )) as boolean;

package/src/stores/editor/EditorStore.ts

@@ -501,7 +501,12 @@ export class EditorStore implements CommandRegistrar {
     if (entityPath) {
       this.initialEntityPath = entityPath;
       this.applicationStore.navigationService.navigator.updateCurrentLocation(
-        generateEditorRoute(projectId, workspaceId, workspaceType),
+        generateEditorRoute(
+          projectId,
+          params.patchReleaseVersionId,
+          workspaceId,
+          workspaceType,
+        ),
       );
     }
   }
@@ -513,6 +518,7 @@ export class EditorStore implements CommandRegistrar {
    */
   *initialize(
     projectId: string,
+    patchReleaseVersionId: string | undefined,
     workspaceId: string,
     workspaceType: WorkspaceType,
   ): GeneratorFn<void> {
@@ -577,7 +583,7 @@ export class EditorStore implements CommandRegistrar {
             type: ActionAlertActionType.STANDARD,
             handler: (): void => {
               this.applicationStore.navigationService.navigator.goToLocation(
-                generateSetupRoute(undefined),
+                generateSetupRoute(undefined, undefined),
               );
             },
           },
@@ -586,9 +592,15 @@ export class EditorStore implements CommandRegistrar {
       onLeave(false);
       return;
     }
+    yield flowResult(
+      this.sdlcState.fetchCurrentPatch(projectId, patchReleaseVersionId, {
+        suppressNotification: true,
+      }),
+    );
     yield flowResult(
       this.sdlcState.fetchCurrentWorkspace(
         projectId,
+        patchReleaseVersionId,
         workspaceId,
         workspaceType,
         {
@@ -611,6 +623,7 @@ export class EditorStore implements CommandRegistrar {
           });
           const workspace = await this.sdlcServerClient.createWorkspace(
             projectId,
+            patchReleaseVersionId,
             workspaceId,
             workspaceType,
           );

package/src/stores/editor/StandardEditorMode.ts

@@ -38,6 +38,7 @@ export class StandardEditorMode extends EditorMode {
   generateElementLink(elementPath: string): string {
     return generateEditorRoute(
       this.editorStore.sdlcState.activeProject.projectId,
+      this.editorStore.sdlcState.activePatch?.patchReleaseVersionId.id,
       this.editorStore.sdlcState.activeWorkspace.workspaceId,
       this.editorStore.sdlcState.activeWorkspace.workspaceType,
       elementPath,

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

@@ -246,6 +246,7 @@ export class ProjectConfigurationEditorState extends EditorState {
       yield flowResult(
         this.editorStore.sdlcState.fetchCurrentWorkspace(
           this.editorStore.sdlcState.activeProject.projectId,
+          this.editorStore.sdlcState.activePatch?.patchReleaseVersionId.id,
           this.editorStore.sdlcState.activeWorkspace.workspaceId,
           this.editorStore.sdlcState.activeWorkspace.workspaceType,
         ),

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

@@ -23,8 +23,12 @@ import {
   assertErrorThrown,
   LogEvent,
   getNullableFirstEntry,
+  ActionState,
 } from '@finos/legend-shared';
-import { generateSetupRoute } from '../../../__lib__/LegendStudioNavigation.js';
+import {
+  generateEditorRoute,
+  generateSetupRoute,
+} from '../../../__lib__/LegendStudioNavigation.js';
 import {
   type NewVersionType,
   CreateVersionCommand,
@@ -35,6 +39,8 @@ import {
   Workspace,
   Review,
   areWorkspacesEquivalent,
+  Patch,
+  type WorkspaceType,
 } from '@finos/legend-server-sdlc';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
 
@@ -43,6 +49,7 @@ export enum PROJECT_OVERVIEW_ACTIVITY_MODE {
   OVERVIEW = 'OVERVIEW',
   VERSIONS = 'VERSIONS',
   WORKSPACES = 'WORKSPACES',
+  PATCH = 'PATCH',
 }
 
 export class ProjectOverviewState {
@@ -55,6 +62,8 @@ export class ProjectOverviewState {
   currentProjectRevision?: Revision | undefined;
   projectWorkspaces: Workspace[] = [];
 
+  patches: Patch[] = [];
+
   isCreatingVersion = false;
   isFetchingProjectWorkspaces = false;
   isDeletingWorkspace = false;
@@ -62,8 +71,11 @@ export class ProjectOverviewState {
   isFetchingLatestVersion = false;
   isFetchingCurrentProjectRevision = false;
 
+  createPatchState = ActionState.create();
+
   constructor(editorStore: EditorStore, sdlcState: EditorSDLCState) {
     makeObservable(this, {
+      patches: observable,
       activityMode: observable,
       releaseVersion: observable,
       committedReviewsBetweenMostRecentVersionAndProjectLatest: observable,
@@ -82,6 +94,9 @@ export class ProjectOverviewState {
       updateProject: flow,
       fetchLatestProjectVersion: flow,
       createVersion: flow,
+      createPatchVersion: flow,
+      createPatch: flow,
+      fetchPatches: flow,
     });
 
     this.editorStore = editorStore;
@@ -96,11 +111,30 @@ export class ProjectOverviewState {
   *fetchProjectWorkspaces(): GeneratorFn<void> {
     try {
       this.isFetchingProjectWorkspaces = true;
+      this.patches = (
+        (yield this.editorStore.sdlcServerClient.getPatches(
+          this.sdlcState.activeProject.projectId,
+        )) as PlainObject<Patch>[]
+      ).map((v) => Patch.serialization.fromJson(v));
       this.projectWorkspaces = (
         (yield this.editorStore.sdlcServerClient.getWorkspaces(
           this.sdlcState.activeProject.projectId,
         )) as PlainObject<Workspace>[]
       ).map((v) => Workspace.serialization.fromJson(v));
+      for (const patch of this.patches) {
+        this.projectWorkspaces = this.projectWorkspaces.concat(
+          (
+            (yield this.editorStore.sdlcServerClient.getWorkspaces(
+              this.sdlcState.activeProject.projectId,
+              patch.patchReleaseVersionId.id,
+            )) as PlainObject<Workspace>[]
+          ).map((v) => {
+            const w = Workspace.serialization.fromJson(v);
+            w.source = patch.patchReleaseVersionId.id;
+            return w;
+          }),
+        );
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
@@ -135,6 +169,7 @@ export class ProjectOverviewState {
         this.editorStore.applicationStore.navigationService.navigator.goToLocation(
           generateSetupRoute(
             this.editorStore.sdlcState.activeProject.projectId,
+            undefined,
           ),
           {
             ignoreBlocking: true,
@@ -183,6 +218,23 @@ export class ProjectOverviewState {
     }
   }
 
+  *fetchPatches(): GeneratorFn<void> {
+    try {
+      this.patches = (
+        (yield this.editorStore.sdlcServerClient.getPatches(
+          this.sdlcState.activeProject.projectId,
+        )) as PlainObject<Patch>[]
+      ).map((v: PlainObject<Patch>) => Patch.serialization.fromJson(v));
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    }
+  }
+
   *fetchLatestProjectVersion(): GeneratorFn<void> {
     try {
       this.isFetchingLatestVersion = true;
@@ -219,6 +271,7 @@ export class ProjectOverviewState {
         const latestProjectVersionRevisionReviewObj = getNullableFirstEntry(
           (yield this.editorStore.sdlcServerClient.getReviews(
             this.sdlcState.activeProject.projectId,
+            undefined,
             {
               state: ReviewState.COMMITTED,
               revisionIds: [latestProjectVersionRevision.id],
@@ -235,6 +288,7 @@ export class ProjectOverviewState {
         this.committedReviewsBetweenMostRecentVersionAndProjectLatest = (
           (yield this.editorStore.sdlcServerClient.getReviews(
             this.sdlcState.activeProject.projectId,
+            undefined,
             {
               state: ReviewState.COMMITTED,
               since:
@@ -253,6 +307,7 @@ export class ProjectOverviewState {
         this.committedReviewsBetweenMostRecentVersionAndProjectLatest = (
           (yield this.editorStore.sdlcServerClient.getReviews(
             this.sdlcState.activeProject.projectId,
+            undefined,
             {
               state: ReviewState.COMMITTED,
             },
@@ -299,4 +354,83 @@ export class ProjectOverviewState {
       this.isCreatingVersion = false;
     }
   }
+
+  *createPatchVersion(id: string): GeneratorFn<void> {
+    this.isCreatingVersion = true;
+    try {
+      const version = Version.serialization.fromJson(
+        (yield this.editorStore.sdlcServerClient.releasePatch(
+          this.sdlcState.activeProject.projectId,
+          id,
+        )) as PlainObject<Version>,
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        `${version.id.id} is released successfully`,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.isCreatingVersion = false;
+    }
+  }
+
+  *createPatch(
+    sourceVersion: string,
+    workspaceName: string,
+    workspaceType: WorkspaceType,
+  ): GeneratorFn<void> {
+    if (!workspaceName) {
+      this.editorStore.applicationStore.notificationService.notify(
+        `Please provide workspace name`,
+      );
+    }
+    this.createPatchState.inProgress();
+    this.createPatchState.setMessage(`Creating patch...`);
+    try {
+      const newPatch = Patch.serialization.fromJson(
+        (yield this.editorStore.sdlcServerClient.createPatch(
+          this.sdlcState.activeProject.projectId,
+          sourceVersion,
+        )) as PlainObject<Patch>,
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        `Patch '${newPatch.patchReleaseVersionId.id}' is succesfully created`,
+      );
+      this.createPatchState.setMessage(`Creating workspace...`);
+      const newWorkspace = Workspace.serialization.fromJson(
+        (yield this.editorStore.sdlcServerClient.createWorkspace(
+          this.sdlcState.activeProject.projectId,
+          newPatch.patchReleaseVersionId.id,
+          workspaceName,
+          workspaceType,
+        )) as PlainObject<Workspace>,
+      );
+      newWorkspace.source = newPatch.patchReleaseVersionId.id;
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        `Workspace '${newWorkspace.workspaceId}' is succesfully created`,
+      );
+      this.editorStore.applicationStore.navigationService.navigator.goToLocation(
+        generateEditorRoute(
+          this.sdlcState.activeProject.projectId,
+          newPatch.patchReleaseVersionId.id,
+          workspaceName,
+          workspaceType,
+        ),
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.createPatchState.reset();
+    }
+  }
 }

package/src/stores/editor/sidebar-state/WorkspaceReviewState.ts

@@ -182,7 +182,7 @@ export class WorkspaceReviewState {
         )) as Revision;
       const reviews = (yield this.editorStore.sdlcServerClient.getReviews(
         this.sdlcState.activeProject.projectId,
-
+        this.sdlcState.activePatch?.patchReleaseVersionId.id,
         {
           state: ReviewState.OPEN,
           revisionIds: [
@@ -236,6 +236,7 @@ export class WorkspaceReviewState {
       });
       yield this.editorStore.sdlcServerClient.createWorkspace(
         this.sdlcState.activeProject.projectId,
+        this.sdlcState.activePatch?.patchReleaseVersionId.id,
         this.sdlcState.activeWorkspace.workspaceId,
         this.sdlcState.activeWorkspace.workspaceType,
       );
@@ -265,6 +266,7 @@ export class WorkspaceReviewState {
     try {
       yield this.editorStore.sdlcServerClient.rejectReview(
         this.sdlcState.activeProject.projectId,
+        this.sdlcState.activePatch?.patchReleaseVersionId.id,
         this.workspaceReview.id,
       );
       this.workspaceReview = undefined;
@@ -308,6 +310,7 @@ export class WorkspaceReviewState {
       this.workspaceReview = Review.serialization.fromJson(
         (yield this.editorStore.sdlcServerClient.createReview(
           this.sdlcState.activeProject.projectId,
+          this.sdlcState.activePatch?.patchReleaseVersionId.id,
           {
             workspaceId: this.sdlcState.activeWorkspace.workspaceId,
             title,
@@ -367,6 +370,7 @@ export class WorkspaceReviewState {
     try {
       yield this.editorStore.sdlcServerClient.commitReview(
         this.sdlcState.activeProject.projectId,
+        this.sdlcState.activePatch?.patchReleaseVersionId.id,
         review.id,
         { message: `${review.title} [review]` },
       );
@@ -389,6 +393,7 @@ export class WorkspaceReviewState {
               this.editorStore.applicationStore.navigationService.navigator.goToLocation(
                 generateSetupRoute(
                   this.editorStore.sdlcState.activeProject.projectId,
+                  this.sdlcState.activePatch?.patchReleaseVersionId.id,
                 ),
                 {
                   ignoreBlocking: true,

package/src/stores/editor/sidebar-state/WorkspaceUpdaterState.ts

@@ -331,6 +331,7 @@ export class WorkspaceUpdaterState {
       const baseReviewObj = getNullableFirstEntry(
         (yield this.editorStore.sdlcServerClient.getReviews(
           this.sdlcState.activeProject.projectId,
+          this.sdlcState.activePatch?.patchReleaseVersionId.id,
           {
             state: ReviewState.COMMITTED,
             revisionIds: [workspaceBaseRevision.id],
@@ -344,6 +345,7 @@ export class WorkspaceUpdaterState {
       this.committedReviewsBetweenWorkspaceBaseAndProjectLatest = (
         (yield this.editorStore.sdlcServerClient.getReviews(
           this.sdlcState.activeProject.projectId,
+          this.sdlcState.activePatch?.patchReleaseVersionId.id,
           {
             state: ReviewState.COMMITTED,
             since: baseReview

package/src/stores/workspace-review/WorkspaceReviewStore.ts

@@ -32,7 +32,7 @@ import {
 import type { EditorStore } from '../editor/EditorStore.js';
 import { ACTIVITY_MODE } from '../editor/EditorConfig.js';
 import type { Entity } from '@finos/legend-storage';
-import { Project, Review } from '@finos/legend-server-sdlc';
+import { Project, Review, type Patch } from '@finos/legend-server-sdlc';
 import { LEGEND_STUDIO_APP_EVENT } from '../../__lib__/LegendStudioEvent.js';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
 
@@ -41,6 +41,7 @@ export class WorkspaceReviewStore {
 
   currentProjectId?: string | undefined;
   currentProject?: Project | undefined;
+  currentPatch?: Patch | undefined;
   currentReviewId?: string | undefined;
   currentReview?: Review | undefined;
   isFetchingCurrentReview = false;
@@ -54,6 +55,7 @@ export class WorkspaceReviewStore {
     makeObservable(this, {
       currentProjectId: observable,
       currentProject: observable,
+      currentPatch: observable,
       currentReviewId: observable,
       currentReview: observable,
       isFetchingCurrentReview: observable,
@@ -63,6 +65,7 @@ export class WorkspaceReviewStore {
       isCommittingReview: observable,
       isReopeningReview: observable,
       projectId: computed,
+      patchReleaseVersionId: computed,
       reviewId: computed,
       review: computed,
       setProjectIdAndReviewId: action,
@@ -84,6 +87,10 @@ export class WorkspaceReviewStore {
     return guaranteeNonNullable(this.currentProjectId, 'Project ID must exist');
   }
 
+  get patchReleaseVersionId(): string | undefined {
+    return this.currentPatch?.patchReleaseVersionId.id;
+  }
+
   get reviewId(): string {
     return guaranteeNonNullable(this.currentReviewId, 'Review ID must exist');
   }
@@ -131,10 +138,12 @@ export class WorkspaceReviewStore {
       const [fromEntities, toEntities] = (yield Promise.all([
         this.editorStore.sdlcServerClient.getReviewFromEntities(
           this.projectId,
+          this.patchReleaseVersionId,
           this.review.id,
         ),
         this.editorStore.sdlcServerClient.getReviewToEntities(
           this.projectId,
+          this.patchReleaseVersionId,
           this.review.id,
         ),
       ])) as [Entity[], Entity[]];
@@ -196,6 +205,7 @@ export class WorkspaceReviewStore {
       this.currentReview = Review.serialization.fromJson(
         (yield this.editorStore.sdlcServerClient.getReview(
           this.projectId,
+          this.patchReleaseVersionId,
           this.reviewId,
         )) as PlainObject<Review>,
       );
@@ -217,6 +227,7 @@ export class WorkspaceReviewStore {
       this.currentReview = Review.serialization.fromJson(
         (yield this.editorStore.sdlcServerClient.approveReview(
           this.projectId,
+          this.patchReleaseVersionId,
           this.review.id,
         )) as PlainObject<Review>,
       );
@@ -238,6 +249,7 @@ export class WorkspaceReviewStore {
       this.currentReview = Review.serialization.fromJson(
         (yield this.editorStore.sdlcServerClient.commitReview(
           this.projectId,
+          this.patchReleaseVersionId,
           this.review.id,
           { message: `${this.review.title} [review]` },
         )) as PlainObject<Review>,
@@ -260,6 +272,7 @@ export class WorkspaceReviewStore {
       this.currentReview = Review.serialization.fromJson(
         (yield this.editorStore.sdlcServerClient.reopenReview(
           this.projectId,
+          this.patchReleaseVersionId,
           this.review.id,
         )) as PlainObject<Review>,
       );
@@ -281,6 +294,7 @@ export class WorkspaceReviewStore {
       this.currentReview = Review.serialization.fromJson(
         (yield this.editorStore.sdlcServerClient.closeReview(
           this.projectId,
+          this.patchReleaseVersionId,
           this.review.id,
         )) as PlainObject<Review>,
       );

package/src/stores/workspace-setup/ProjectConfigurationStatus.ts

@@ -31,6 +31,7 @@ export class ProjectConfigurationStatus {
 
 export const fetchProjectConfigurationStatus = async (
   projectId: string,
+  patchReleaseVersionId: string | undefined,
   applicationStore: GenericLegendApplicationStore,
   sdlcServerClient: SDLCServerClient,
 ): Promise<ProjectConfigurationStatus> => {
@@ -45,6 +46,7 @@ export const fetchProjectConfigurationStatus = async (
       const review = Review.serialization.fromJson(
         await sdlcServerClient.getReview(
           projectId,
+          patchReleaseVersionId,
           guaranteeNonNullable(status.reviewIds[0]),
         ),
       );