@finos/legend-application-studio 28.21.5 → 28.21.6

package/src/__lib__/LegendStudioUserDataHelper.ts

@@ -1,5 +1,12 @@
 import type { UserDataService } from '@finos/legend-application';
-import { returnUndefOnError } from '@finos/legend-shared';
+import {
+  type PlainObject,
+  SerializationFactory,
+  returnUndefOnError,
+  usingModelSchema,
+} from '@finos/legend-shared';
+import { WorkspaceType } from '@finos/legend-server-sdlc';
+import { createModelSchema, list, primitive } from 'serializr';
 
 /**
  * Copyright (c) 2020-present, Goldman Sachs
@@ -29,8 +36,104 @@ export enum LEGEND_STUDIO_USER_DATA_KEY {
   // drop the toggle button in the tab header, and retarget the SCSS
   // `.database-editor--light` block at the framework's color-theme tokens.
   DATABASE_EDITOR_THEME = 'studio-editor.database-editor.theme',
+  // Recently-opened projects and (non-patch) workspaces shown on the
+  // workspace setup screen to speed up re-opening common work.
+  WORKSPACE_SETUP_RECENTS = 'studio-editor.workspace-setup.recents',
 }
 
+// --- Workspace setup recents -------------------------------------------------
+
+const WORKSPACE_SETUP_RECENTS_VERSION = 1;
+const MAX_RECENT_PROJECTS = 10;
+const MAX_RECENT_WORKSPACES = 20;
+
+export class RecentProjectEntry {
+  projectId!: string;
+  name!: string;
+  lastOpenedAt!: number;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(RecentProjectEntry, {
+      lastOpenedAt: primitive(),
+      name: primitive(),
+      projectId: primitive(),
+    }),
+  );
+}
+
+export class RecentWorkspaceEntry {
+  projectId!: string;
+  workspaceId!: string;
+  workspaceType!: WorkspaceType;
+  lastOpenedAt!: number;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(RecentWorkspaceEntry, {
+      lastOpenedAt: primitive(),
+      projectId: primitive(),
+      workspaceId: primitive(),
+      // WorkspaceType is a string enum; stored/loaded as a plain string and
+      // validated when the entry is consumed.
+      workspaceType: primitive(),
+    }),
+  );
+}
+
+export class WorkspaceSetupRecents {
+  version: number = WORKSPACE_SETUP_RECENTS_VERSION;
+  projects: RecentProjectEntry[] = [];
+  workspaces: RecentWorkspaceEntry[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(WorkspaceSetupRecents, {
+      projects: list(usingModelSchema(RecentProjectEntry.serialization.schema)),
+      version: primitive(),
+      workspaces: list(
+        usingModelSchema(RecentWorkspaceEntry.serialization.schema),
+      ),
+    }),
+  );
+}
+
+const isValidWorkspaceType = (v: unknown): v is WorkspaceType =>
+  v === WorkspaceType.USER || v === WorkspaceType.GROUP;
+
+const emptyRecents = (): WorkspaceSetupRecents => new WorkspaceSetupRecents();
+
+const readRecents = (service: UserDataService): WorkspaceSetupRecents => {
+  const raw = returnUndefOnError(() =>
+    service.getObjectValue(LEGEND_STUDIO_USER_DATA_KEY.WORKSPACE_SETUP_RECENTS),
+  );
+  if (!raw) {
+    return emptyRecents();
+  }
+  const parsed = returnUndefOnError(() =>
+    WorkspaceSetupRecents.serialization.fromJson(
+      raw as PlainObject<WorkspaceSetupRecents>,
+    ),
+  );
+  if (!parsed) {
+    return emptyRecents();
+  }
+  // Defensive post-checks: drop entries with invalid enum values and enforce
+  // the LRU caps in case the persisted blob was tampered with.
+  parsed.workspaces = parsed.workspaces
+    .filter((w) => isValidWorkspaceType(w.workspaceType))
+    .slice(0, MAX_RECENT_WORKSPACES);
+  parsed.projects = parsed.projects.slice(0, MAX_RECENT_PROJECTS);
+  return parsed;
+};
+
+const writeRecents = (
+  service: UserDataService,
+  recents: WorkspaceSetupRecents,
+): void => {
+  service.persistValue(
+    LEGEND_STUDIO_USER_DATA_KEY.WORKSPACE_SETUP_RECENTS,
+    WorkspaceSetupRecents.serialization.toJson(recents),
+  );
+};
+
 export class LegendStudioUserDataHelper {
   static globalTestRunner_getShowDependencyPanel(
     service: UserDataService,
@@ -70,4 +173,104 @@ export class LegendStudioUserDataHelper {
       val,
     );
   }
+
+  // --- Workspace setup recents ---------------------------------------------
+
+  static workspaceSetup_getRecentProjects(
+    service: UserDataService,
+  ): RecentProjectEntry[] {
+    return readRecents(service).projects;
+  }
+
+  static workspaceSetup_getRecentWorkspaces(
+    service: UserDataService,
+  ): RecentWorkspaceEntry[] {
+    return readRecents(service).workspaces;
+  }
+
+  static workspaceSetup_recordRecentProject(
+    service: UserDataService,
+    entry: { projectId: string; name: string },
+  ): RecentProjectEntry[] {
+    const recents = readRecents(service);
+    const next = new RecentProjectEntry();
+    next.projectId = entry.projectId;
+    next.name = entry.name;
+    next.lastOpenedAt = Date.now();
+    recents.projects = [
+      next,
+      ...recents.projects.filter((p) => p.projectId !== entry.projectId),
+    ].slice(0, MAX_RECENT_PROJECTS);
+    writeRecents(service, recents);
+    return recents.projects;
+  }
+
+  static workspaceSetup_recordRecentWorkspace(
+    service: UserDataService,
+    entry: {
+      projectId: string;
+      workspaceId: string;
+      workspaceType: WorkspaceType;
+    },
+  ): RecentWorkspaceEntry[] {
+    const recents = readRecents(service);
+    const next = new RecentWorkspaceEntry();
+    next.projectId = entry.projectId;
+    next.workspaceId = entry.workspaceId;
+    next.workspaceType = entry.workspaceType;
+    next.lastOpenedAt = Date.now();
+    recents.workspaces = [
+      next,
+      ...recents.workspaces.filter(
+        (w) =>
+          !(
+            w.projectId === entry.projectId &&
+            w.workspaceId === entry.workspaceId &&
+            w.workspaceType === entry.workspaceType
+          ),
+      ),
+    ].slice(0, MAX_RECENT_WORKSPACES);
+    writeRecents(service, recents);
+    return recents.workspaces;
+  }
+
+  static workspaceSetup_removeRecentProject(
+    service: UserDataService,
+    projectId: string,
+  ): WorkspaceSetupRecents {
+    const recents = readRecents(service);
+    recents.projects = recents.projects.filter(
+      (p) => p.projectId !== projectId,
+    );
+    recents.workspaces = recents.workspaces.filter(
+      (w) => w.projectId !== projectId,
+    );
+    writeRecents(service, recents);
+    return recents;
+  }
+
+  static workspaceSetup_removeRecentWorkspace(
+    service: UserDataService,
+    entry: {
+      projectId: string;
+      workspaceId: string;
+      workspaceType: WorkspaceType;
+    },
+  ): RecentWorkspaceEntry[] {
+    const recents = readRecents(service);
+    recents.workspaces = recents.workspaces.filter(
+      (w) =>
+        !(
+          w.projectId === entry.projectId &&
+          w.workspaceId === entry.workspaceId &&
+          w.workspaceType === entry.workspaceType
+        ),
+    );
+    writeRecents(service, recents);
+    return recents.workspaces;
+  }
+
+  static workspaceSetup_clearRecents(service: UserDataService): void {
+    writeRecents(service, emptyRecents());
+  }
 }

package/src/components/editor/editor-group/data-editor/EmbeddedDataEditor.tsx

@@ -400,6 +400,7 @@ export function renderEmbeddedDataEditor(
         dataState={embeddedDataState}
         isReadOnly={isReadOnly}
         isSharedData={isSharedData}
+        hideColumnDefinitions={true}
       />
     );
   } else if (embeddedDataState instanceof DataElementReferenceState) {

package/src/components/editor/editor-group/data-editor/RelationElementsDataEditor.tsx

@@ -426,7 +426,8 @@ export const RelationElementEditor = observer(
               </div>
             </div>
           ) : null}
-          {embeddedData.rows.length === 0 ? (
+          {embeddedData.rows.length === 0 &&
+          embeddedData.columns.length === 0 ? (
             <div className="relation-test-data-editor__empty-data">
               <div className="relation-test-data-editor__empty-text">
                 No test data rows. Click &quot;+&quot; below to start entering
@@ -440,13 +441,20 @@ export const RelationElementEditor = observer(
                   <tr>
                     {embeddedData.columns.map((column, columnIndex) => (
                       <th
-                        key={column}
+                        key={`col-${guaranteeNonNullable(columnIndex)}`}
                         className="relation-test-data-editor__th"
                       >
                         <div className="relation-test-data-editor__th__inner">
-                          <span className="relation-test-data-editor__th__label">
-                            {column}
-                          </span>
+                          <input
+                            className="relation-test-data-editor__th__label relation-test-data-editor__th__label--editable"
+                            type="text"
+                            value={column}
+                            onChange={(e) =>
+                              updateColumn(columnIndex, e.target.value)
+                            }
+                            disabled={!canEditColumns}
+                            title={column}
+                          />
                           <button
                             className="relation-test-data-editor__th__delete"
                             onClick={() => removeColumn(columnIndex)}

package/src/components/editor/editor-group/dataProduct/DataProductEditor.tsx

@@ -661,6 +661,7 @@ const SampleValuesEditorModal = observer(
                             accessPointState.relationElementState
                           }
                           isReadOnly={isReadOnly}
+                          hideColumnDefinitions={true}
                         />
                       </div>
                     </Tooltip>

package/src/components/editor/editor-group/testable/TestableSharedComponents.tsx

@@ -595,6 +595,7 @@ const EqualToRelationAsssertionEditor = observer(
           equalToRelationAssertionState.expectedRelationElementState
         }
         isReadOnly={isReadOnly}
+        hideColumnDefinitions={true}
       />
     );
   },

package/src/components/workspace-setup/RecentWorkspacesPanel.tsx

@@ -0,0 +1,161 @@
+/**
+ * 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 { observer } from 'mobx-react-lite';
+import {
+  FolderIcon,
+  HistoryIcon,
+  TimesIcon,
+  UserIcon,
+  UsersIcon,
+} from '@finos/legend-art';
+import { WorkspaceType } from '@finos/legend-server-sdlc';
+import type { WorkspaceSetupStore } from '../../stores/workspace-setup/WorkspaceSetupStore.js';
+import { generateEditorRoute } from '../../__lib__/LegendStudioNavigation.js';
+
+const MAX_TILES = 6;
+
+const formatRelativeTime = (timestamp: number): string => {
+  const diffMs = Date.now() - timestamp;
+  if (diffMs < 0) {
+    return 'just now';
+  }
+  const minutes = Math.floor(diffMs / 60_000);
+  if (minutes < 1) {
+    return 'just now';
+  }
+  if (minutes < 60) {
+    return `${minutes}m ago`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h ago`;
+  }
+  const days = Math.floor(hours / 24);
+  if (days < 7) {
+    return `${days}d ago`;
+  }
+  const weeks = Math.floor(days / 7);
+  if (weeks < 4) {
+    return `${weeks}w ago`;
+  }
+  const months = Math.floor(days / 30);
+  if (months < 12) {
+    return `${months}mo ago`;
+  }
+  return `${Math.floor(days / 365)}y ago`;
+};
+
+export const RecentWorkspacesPanel = observer(
+  (props: { setupStore: WorkspaceSetupStore }) => {
+    const { setupStore } = props;
+    const applicationStore = setupStore.applicationStore;
+
+    // Recents are stored in LRU order (most-recent first). Show the top N
+    // workspaces; map each to its project name (or fall back to projectId
+    // if the matching project entry was evicted independently).
+    const tiles = setupStore.recentWorkspaces.slice(0, MAX_TILES);
+    if (tiles.length === 0) {
+      return null;
+    }
+
+    const projectNameById = new Map(
+      setupStore.recentProjects.map((p) => [p.projectId, p.name]),
+    );
+
+    const openWorkspace = (
+      projectId: string,
+      workspaceId: string,
+      workspaceType: WorkspaceType,
+    ): void => {
+      applicationStore.navigationService.navigator.goToLocation(
+        generateEditorRoute(projectId, undefined, workspaceId, workspaceType),
+      );
+    };
+
+    return (
+      <div className="workspace-setup__recents">
+        <div className="workspace-setup__recents__header">
+          <div className="workspace-setup__recents__header__title">
+            <HistoryIcon />
+            <span>Recent workspaces</span>
+          </div>
+        </div>
+        <div className="workspace-setup__recents__grid">
+          {tiles.map((entry) => {
+            const projectName =
+              projectNameById.get(entry.projectId) ?? entry.projectId;
+            const key = `${entry.projectId}::${entry.workspaceType}::${entry.workspaceId}`;
+            const handleRemove = (
+              event: React.MouseEvent<HTMLButtonElement>,
+            ): void => {
+              event.stopPropagation();
+              setupStore.removeRecentWorkspace({
+                projectId: entry.projectId,
+                workspaceId: entry.workspaceId,
+                workspaceType: entry.workspaceType,
+              });
+            };
+            return (
+              <button
+                key={key}
+                type="button"
+                className="workspace-setup__recents__tile"
+                title={`Open ${projectName} / ${entry.workspaceId}`}
+                onClick={() =>
+                  openWorkspace(
+                    entry.projectId,
+                    entry.workspaceId,
+                    entry.workspaceType,
+                  )
+                }
+              >
+                <button
+                  type="button"
+                  tabIndex={-1}
+                  className="workspace-setup__recents__tile__remove"
+                  title="Remove from recents"
+                  onClick={handleRemove}
+                >
+                  <TimesIcon />
+                </button>
+                <div className="workspace-setup__recents__tile__project">
+                  <FolderIcon />
+                  <span className="workspace-setup__recents__tile__project__name">
+                    {projectName}
+                  </span>
+                </div>
+                <div className="workspace-setup__recents__tile__workspace">
+                  {entry.workspaceType === WorkspaceType.GROUP ? (
+                    <UsersIcon />
+                  ) : (
+                    <UserIcon />
+                  )}
+                  <span className="workspace-setup__recents__tile__workspace__name">
+                    {entry.workspaceId}
+                  </span>
+                </div>
+                <div className="workspace-setup__recents__tile__time">
+                  {formatRelativeTime(entry.lastOpenedAt)}
+                </div>
+              </button>
+            );
+          })}
+        </div>
+      </div>
+    );
+  },
+);

package/src/components/workspace-setup/WorkspaceSetup.tsx

@@ -52,6 +52,7 @@ import { CreateProjectModal } from './CreateProjectModal.js';
 import { ActivityBarMenu } from '../editor/ActivityBar.js';
 import { LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY } from '../../__lib__/LegendStudioApplicationNavigationContext.js';
 import { CreateWorkspaceModal } from './CreateWorkspaceModal.js';
+import { RecentWorkspacesPanel } from './RecentWorkspacesPanel.js';
 import {
   useLegendStudioApplicationStore,
   useLegendStudioBaseStore,
@@ -66,7 +67,12 @@ import {
   buildWorkspaceOption,
   formatWorkspaceOptionLabel,
 } from './WorkspaceSelectorUtils.js';
-import { debounce, guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  debounce,
+  guaranteeNonNullable,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { Project } from '@finos/legend-server-sdlc';
 import { WorkspaceSetupStore } from '../../stores/workspace-setup/WorkspaceSetupStore.js';
 import { openShowcaseManager } from '../../stores/ShowcaseManagerState.js';
 
@@ -360,18 +366,57 @@ export const WorkspaceSetup = withWorkspaceSetupStore(
       applicationStore.assistantService.toggleAssistant();
 
     // projects
-    const projectOptions = setupStore.projects
+    // Build a unified option list: recent projects (that aren't already in the
+    // loaded set) are prepended so users can instantly re-open common work
+    // without waiting for the SDLC search to round-trip.
+    const loadedProjectOptions = setupStore.projects
       .map(buildProjectOption)
       .sort(compareLabelFn);
+    const loadedProjectIds = new Set(
+      setupStore.projects.map((p) => p.projectId),
+    );
+    const recentProjectOptions: ProjectOption[] = setupStore.recentProjects
+      .filter((r) => !loadedProjectIds.has(r.projectId))
+      .map((r) => {
+        // Construct a lightweight Project stand-in so the existing selector
+        // contract is preserved. The full project will be fetched on click
+        // via `selectRecentProject`.
+        const stub = Project.serialization.fromJson({
+          projectId: r.projectId,
+          name: r.name,
+          description: '',
+          webUrl: '',
+          tags: [],
+        } as PlainObject<Project>);
+        return { label: stub.name, value: stub };
+      });
+    const projectOptions: ProjectOption[] = [
+      ...recentProjectOptions,
+      ...loadedProjectOptions,
+    ];
+    const recentProjectIdSet = new Set(
+      setupStore.recentProjects.map((p) => p.projectId),
+    );
     const selectedProjectOption = setupStore.currentProject
       ? buildProjectOption(setupStore.currentProject)
       : null;
 
     const onProjectChange = (val: ProjectOption | null): void => {
       if (val) {
-        flowResult(setupStore.changeProject(val.value)).catch(
-          applicationStore.alertUnhandledError,
-        );
+        // If the selection corresponds to a recent that hasn't been loaded
+        // from search yet, fetch the project before switching.
+        const isUnloadedRecent =
+          !loadedProjectIds.has(val.value.projectId) &&
+          recentProjectIdSet.has(val.value.projectId);
+        if (isUnloadedRecent) {
+          flowResult(setupStore.selectRecentProject(val.value.projectId)).catch(
+            applicationStore.alertUnhandledError,
+          );
+        } else {
+          flowResult(setupStore.changeProject(val.value)).catch(
+            applicationStore.alertUnhandledError,
+          );
+        }
       } else {
         setupStore.resetProject();
       }
@@ -404,9 +449,40 @@ export const WorkspaceSetup = withWorkspaceSetupStore(
     };
 
     // workspaces
-    const workspaceOptions = setupStore.workspaces
-      .map(buildWorkspaceOption)
+    // Recent (non-patch) workspaces for the currently selected project are
+    // floated to the top of the dropdown so users can re-enter their
+    // typical work without scanning the full list.
+    const projectIdForRecents = setupStore.currentProject?.projectId;
+    const recentWorkspaceKeys = new Set(
+      projectIdForRecents
+        ? setupStore.recentWorkspaces
+            .filter((w) => w.projectId === projectIdForRecents)
+            .map((w) => `${w.workspaceType}::${w.workspaceId}`)
+        : [],
+    );
+    const allWorkspaceOptions = setupStore.workspaces.map(buildWorkspaceOption);
+    const recentWorkspaceOptions = allWorkspaceOptions
+      .filter(
+        (o) =>
+          o.value.source === undefined &&
+          recentWorkspaceKeys.has(
+            `${o.value.workspaceType}::${o.value.workspaceId}`,
+          ),
+      )
+      .sort(compareLabelFn);
+    const otherWorkspaceOptions = allWorkspaceOptions
+      .filter(
+        (o) =>
+          o.value.source !== undefined ||
+          !recentWorkspaceKeys.has(
+            `${o.value.workspaceType}::${o.value.workspaceId}`,
+          ),
+      )
       .sort(compareLabelFn);
+    const workspaceOptions = [
+      ...recentWorkspaceOptions,
+      ...otherWorkspaceOptions,
+    ];
     const selectedWorkspaceOption = setupStore.currentWorkspace
       ? buildWorkspaceOption(setupStore.currentWorkspace)
       : null;
@@ -489,11 +565,24 @@ export const WorkspaceSetup = withWorkspaceSetupStore(
                       Welcome to Legend Studio
                     </div>
                   </div>
+                  <RecentWorkspacesPanel setupStore={setupStore} />
                   <div className="workspace-setup__selectors">
                     <div className="workspace-setup__selectors__container">
                       <div className="workspace-setup__selector">
                         <div className="workspace-setup__selector__header">
-                          Search for an existing project
+                          <span>Search for an existing project</span>
+                          {(setupStore.recentProjects.length > 0 ||
+                            setupStore.recentWorkspaces.length > 0) && (
+                            <button
+                              type="button"
+                              className="workspace-setup__selector__header__clear-recents"
+                              tabIndex={-1}
+                              onClick={() => setupStore.clearRecents()}
+                              title="Clear recently-opened projects and workspaces"
+                            >
+                              Clear recents
+                            </button>
+                          )}
                         </div>
                         <div className="workspace-setup__selector__content">
                           <div

package/src/stores/editor/EditorStore.ts

@@ -93,6 +93,7 @@ import {
   DEFAULT_TAB_SIZE,
 } from '@finos/legend-application';
 import { LEGEND_STUDIO_APP_EVENT } from '../../__lib__/LegendStudioEvent.js';
+import { LegendStudioUserDataHelper } from '../../__lib__/LegendStudioUserDataHelper.js';
 import type { EditorMode } from './EditorMode.js';
 import { StandardEditorMode } from './StandardEditorMode.js';
 import { WorkspaceUpdateConflictResolutionState } from './sidebar-state/WorkspaceUpdateConflictResolutionState.js';
@@ -691,6 +692,12 @@ export class EditorStore implements CommandRegistrar {
       }),
     );
     if (!this.sdlcState.currentProject) {
+      // The project the user navigated to doesn't exist (or isn't accessible).
+      // Drop it from the recents cache so we don't keep offering a dead link.
+      LegendStudioUserDataHelper.workspaceSetup_removeRecentProject(
+        this.applicationStore.userDataService,
+        projectId,
+      );
       // If the project is not found or the user does not have access to it,
       // we will not automatically redirect them to the setup page as they will lose the URL
       // instead, we give them the option to:
@@ -740,6 +747,15 @@ export class EditorStore implements CommandRegistrar {
       ),
     );
     if (!this.sdlcState.currentWorkspace) {
+      // The workspace the user navigated to doesn't exist anymore. Drop
+      // the matching entry from the recents cache (no-op for patch
+      // workspaces, which are never cached in the first place).
+      if (patchReleaseVersionId === undefined) {
+        LegendStudioUserDataHelper.workspaceSetup_removeRecentWorkspace(
+          this.applicationStore.userDataService,
+          { projectId, workspaceId, workspaceType },
+        );
+      }
       // If the workspace is not found,
       // we will not automatically redirect the user to the setup page as they will lose the URL
       // instead, we give them the option to:
@@ -810,6 +826,34 @@ export class EditorStore implements CommandRegistrar {
       onLeave(false);
       return;
     }
+    // At this point both the project and the workspace have been confirmed
+    // to exist on the server (the guards above bail out otherwise), so this
+    // is the authoritative "the user actually opened this workspace" moment.
+    // Record it in the recents cache so the workspace setup screen can offer
+    // it instantly next time.
+    // NOTE: patch-based workspaces are intentionally excluded from recents
+    // (they are not surfaced in the recents UI). Sandbox projects ARE
+    // included — opening one is still a meaningful "I worked here" signal,
+    // and surfacing it alongside other recents gives a faster one-click
+    // re-entry than waiting for the dedicated sandbox loader.
+    if (this.sdlcState.currentWorkspace.source === undefined) {
+      LegendStudioUserDataHelper.workspaceSetup_recordRecentProject(
+        this.applicationStore.userDataService,
+        {
+          projectId: this.sdlcState.currentProject.projectId,
+          name: this.sdlcState.currentProject.name,
+        },
+      );
+      LegendStudioUserDataHelper.workspaceSetup_recordRecentWorkspace(
+        this.applicationStore.userDataService,
+        {
+          projectId: this.sdlcState.currentProject.projectId,
+          workspaceId: this.sdlcState.currentWorkspace.workspaceId,
+          workspaceType: this.sdlcState.currentWorkspace.workspaceType,
+        },
+      );
+    }
+
     yield Promise.all([
       this.sdlcState.fetchCurrentRevision(
         projectId,