@finos/legend-application-studio 28.21.42 → 28.21.44

package/src/stores/ShowcaseManagerState.ts

@@ -18,6 +18,7 @@ import {
   type GeneratorFn,
   ActionState,
   LogEvent,
+  StopWatch,
   assertErrorThrown,
   guaranteeNonNullable,
   isNonNullable,
@@ -40,7 +41,11 @@ import {
 import type { TreeData, TreeNodeData } from '@finos/legend-art';
 import { DIRECTORY_PATH_DELIMITER } from '@finos/legend-graph';
 import { SHOWCASE_MANAGER_VIRTUAL_ASSISTANT_TAB_KEY } from '../components/extensions/Core_LegendStudioApplicationPlugin.js';
-import { LegendStudioTelemetryHelper } from '../__lib__/LegendStudioTelemetryHelper.js';
+import {
+  LegendStudioTelemetryHelper,
+  SHOWCASE_LAUNCH_ENTRY_POINT,
+  SHOWCASE_MANAGER_ENTRY_POINT,
+} from '../__lib__/LegendStudioTelemetryHelper.js';
 
 export enum SHOWCASE_MANAGER_VIEW {
   EXPLORER = 'EXPLORER',
@@ -164,6 +169,7 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
   allShowcases: ShowcaseMetadata[] | undefined;
   currentShowcase?: Showcase | undefined;
   showcaseLineToScroll?: number | undefined;
+  private currentShowcaseOpenedAt?: number | undefined;
 
   currentView = SHOWCASE_MANAGER_VIEW.EXPLORER;
   explorerTreeData?: TreeData<ShowcasesExplorerTreeNodeData> | undefined;
@@ -266,6 +272,7 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
   *openShowcase(
     metadata: ShowcaseMetadata,
     showcaseLineToScroll?: number | undefined,
+    entryPoint: SHOWCASE_LAUNCH_ENTRY_POINT = SHOWCASE_LAUNCH_ENTRY_POINT.EXPLORER,
   ): GeneratorFn<void> {
     this.fetchShowcaseState.inProgress();
 
@@ -274,10 +281,15 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
         metadata.path,
       )) as Showcase;
       this.currentShowcase = showcase;
+      this.currentShowcaseOpenedAt = Date.now();
       LegendStudioTelemetryHelper.logEvent_ShowcaseManagerShowcaseProjectLaunch(
         this.applicationStore.telemetryService,
         {
           showcasePath: showcase.path,
+          title: showcase.title,
+          isDevelopment: metadata.development,
+          entryPoint,
+          lineNumber: showcaseLineToScroll,
         },
       );
       this.showcaseLineToScroll = showcaseLineToScroll;
@@ -285,18 +297,28 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
     } catch (error) {
       assertErrorThrown(error);
       this.applicationStore.logService.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SHOWCASE_MANAGER_FAILURE),
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SHOWCASE_MANAGER_OPEN__FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_ShowcaseManagerOpenFailure(
+        this.applicationStore.telemetryService,
+        {
+          errorMessage: error.message,
+          showcasePath: metadata.path,
+        },
+      );
       this.fetchShowcaseState.fail();
     }
   }
 
-  logOpenManager(): void {
+  logOpenManager(
+    entryPoint: SHOWCASE_MANAGER_ENTRY_POINT = SHOWCASE_MANAGER_ENTRY_POINT.ACTIVITY_BAR,
+  ): void {
     if (this.allShowcases) {
       const report = {
         showcasesTotalCount: this.allShowcases.length,
         showcasesDevelopmentCount: this.nonDevShowcases.length,
+        entryPoint,
       };
       LegendStudioTelemetryHelper.logEvent_ShowcaseManagerLaunch(
         this.applicationStore.telemetryService,
@@ -306,7 +328,17 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
   }
 
   closeShowcase(): void {
+    if (this.currentShowcase && this.currentShowcaseOpenedAt !== undefined) {
+      LegendStudioTelemetryHelper.logEvent_ShowcaseViewerClose(
+        this.applicationStore.telemetryService,
+        {
+          showcasePath: this.currentShowcase.path,
+          dwellMs: Date.now() - this.currentShowcaseOpenedAt,
+        },
+      );
+    }
     this.currentShowcase = undefined;
+    this.currentShowcaseOpenedAt = undefined;
     this.showcaseLineToScroll = undefined;
   }
 
@@ -352,9 +384,13 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
     } catch (error) {
       assertErrorThrown(error);
       this.applicationStore.logService.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SHOWCASE_MANAGER_FAILURE),
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SHOWCASE_MANAGER_INIT__FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_ShowcaseManagerInitFailure(
+        this.applicationStore.telemetryService,
+        { errorMessage: error.message },
+      );
       this.initState.fail();
     }
   }
@@ -368,14 +404,16 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
     }
     this.textSearchState.inProgress();
 
+    const searchText = this.searchText;
     LegendStudioTelemetryHelper.logEvent_ShowcaseSearchInitiated(
       this.applicationStore.telemetryService,
-      { searchText: this.searchText },
+      { searchText },
     );
+    const stopWatch = new StopWatch();
 
     try {
       const result = (yield this.client.search(
-        this.searchText,
+        searchText,
       )) as ShowcaseTextSearchResult;
       this.textSearchResults = result.textMatches
         .map((match) => {
@@ -398,12 +436,32 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
           ),
         )
         .filter(isNonNullable);
+      const showcaseMatchCount = this.showcaseSearchResults.length;
+      const textMatchCount = this.textSearchResults.length;
+      const resultCount = showcaseMatchCount + textMatchCount;
+      LegendStudioTelemetryHelper.logEvent_ShowcaseSearchCompleted(
+        this.applicationStore.telemetryService,
+        {
+          searchText,
+          resultCount,
+          showcaseMatchCount,
+          textMatchCount,
+          durationMs: stopWatch.elapsed,
+          hadResults: resultCount > 0,
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.applicationStore.logService.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SHOWCASE_MANAGER_FAILURE),
+        LogEvent.create(
+          LEGEND_STUDIO_APP_EVENT.SHOWCASE_MANAGER_SEARCH__FAILURE,
+        ),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_ShowcaseManagerSearchFailure(
+        this.applicationStore.telemetryService,
+        { errorMessage: error.message, searchText },
+      );
     } finally {
       this.textSearchState.complete();
     }
@@ -412,6 +470,7 @@ export class ShowcaseManagerState extends ApplicationExtensionState {
 
 export const openShowcaseManager = (
   applicationStore: LegendStudioApplicationStore,
+  entryPoint: SHOWCASE_MANAGER_ENTRY_POINT,
 ): void => {
   const showcaseManagerState =
     ShowcaseManagerState.retrieveNullableState(applicationStore);
@@ -422,6 +481,6 @@ export const openShowcaseManager = (
     applicationStore.assistantService.setSelectedTab(
       SHOWCASE_MANAGER_VIRTUAL_ASSISTANT_TAB_KEY,
     );
-    showcaseManagerState.logOpenManager();
+    showcaseManagerState.logOpenManager(entryPoint);
   }
 };

package/src/stores/editor/EditorGraphState.ts

@@ -408,6 +408,7 @@ export class EditorGraphState {
       LegendStudioTelemetryHelper.logEvent_GraphInitializationSucceeded(
         this.editorStore.applicationStore.telemetryService,
         graphBuilderReportData,
+        this.editorStore.editorMode.getSourceInfo(),
       );
 
       this.editorStore.applicationStore.logService.info(

package/src/stores/editor/EditorStore.ts

@@ -93,6 +93,12 @@ import {
   DEFAULT_TAB_SIZE,
 } from '@finos/legend-application';
 import { LEGEND_STUDIO_APP_EVENT } from '../../__lib__/LegendStudioEvent.js';
+import {
+  LegendStudioTelemetryHelper,
+  TEXT_MODE_ENTER_TRIGGER,
+  TEXT_MODE_TOGGLE_DIRECTION,
+  TEXT_MODE_TOGGLE_SOURCE,
+} from '../../__lib__/LegendStudioTelemetryHelper.js';
 import { LegendStudioUserDataHelper } from '../../__lib__/LegendStudioUserDataHelper.js';
 import type { EditorMode } from './EditorMode.js';
 import { StandardEditorMode } from './StandardEditorMode.js';
@@ -491,9 +497,9 @@ export class EditorStore implements CommandRegistrar {
             this.conflictResolutionState.hasResolvedAllConflicts),
       ),
       action: () => {
-        flowResult(this.toggleTextMode()).catch(
-          this.applicationStore.alertUnhandledError,
-        );
+        flowResult(
+          this.toggleTextMode(TEXT_MODE_TOGGLE_SOURCE.KEYBOARD_SHORTCUT),
+        ).catch(this.applicationStore.alertUnhandledError);
       },
     });
     this.applicationStore.commandService.registerCommand({
@@ -873,8 +879,11 @@ export class EditorStore implements CommandRegistrar {
             queryBaseUrl:
               this.editorConfig?.engineQueryServerUrl ??
               this.applicationStore.config.engineQueryServerUrl,
+            queryClientName: this.applicationStore.config.engineQueryClientName,
             enableCompression: true,
             payloadDebugger,
+            useCookieAuthOnly:
+              this.applicationStore.config.engineUseCookieAuthOnly,
           },
         },
         {
@@ -1019,6 +1028,7 @@ export class EditorStore implements CommandRegistrar {
       yield flowResult(
         this.graphEditorMode.initialize({
           useStoredEntities: true,
+          trigger: TEXT_MODE_ENTER_TRIGGER.INITIAL_LAZY,
         }),
       );
     } catch (error) {
@@ -1215,7 +1225,9 @@ export class EditorStore implements CommandRegistrar {
     this.activePanelMode = val;
   }
 
-  *toggleTextMode(): GeneratorFn<void> {
+  *toggleTextMode(
+    source: TEXT_MODE_TOGGLE_SOURCE = TEXT_MODE_TOGGLE_SOURCE.BUTTON,
+  ): GeneratorFn<void> {
     if (this.graphState.checkIfApplicationUpdateOperationIsRunning()) {
       return;
     }
@@ -1224,12 +1236,22 @@ export class EditorStore implements CommandRegistrar {
       return;
     }
     if (this.graphEditorMode instanceof GraphEditFormModeState) {
+      LegendStudioTelemetryHelper.logEvent_TextModeToggleShortcutInvoked(
+        this.applicationStore.telemetryService,
+        this.editorMode.getSourceInfo(),
+        { source, direction: TEXT_MODE_TOGGLE_DIRECTION.TO_TEXT },
+      );
       this.applicationStore.alertService.setBlockingAlert({
         message: 'Switching to text mode...',
         showLoading: true,
       });
       yield flowResult(this.switchModes(GRAPH_EDITOR_MODE.GRAMMAR_TEXT));
     } else if (this.graphEditorMode instanceof GraphEditGrammarModeState) {
+      LegendStudioTelemetryHelper.logEvent_TextModeToggleShortcutInvoked(
+        this.applicationStore.telemetryService,
+        this.editorMode.getSourceInfo(),
+        { source, direction: TEXT_MODE_TOGGLE_DIRECTION.TO_FORM },
+      );
       yield flowResult(this.switchModes(GRAPH_EDITOR_MODE.FORM));
     } else {
       throw new UnsupportedOperationError(

package/src/stores/editor/GraphEditFormModeState.ts

@@ -416,6 +416,7 @@ export class GraphEditFormModeState extends GraphEditorMode {
     );
     LegendStudioTelemetryHelper.logEvent_GraphCompilationLaunched(
       this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
     );
 
     const currentGraphHash = this.getCurrentGraphHash();
@@ -472,6 +473,7 @@ export class GraphEditFormModeState extends GraphEditorMode {
       LegendStudioTelemetryHelper.logEvent_GraphCompilationSucceeded(
         this.editorStore.applicationStore.telemetryService,
         report,
+        this.editorStore.editorMode.getSourceInfo(),
       );
 
       this.editorStore.graphState.setMostRecentCompilationOutcome(

package/src/stores/editor/GraphEditGrammarModeState.ts

@@ -25,6 +25,7 @@ import {
   type GraphManagerOperationReport,
   GRAPH_MANAGER_EVENT,
   EngineError,
+  ParserError,
   GraphBuilderError,
   reportGraphAnalytics,
   INTERNAL__UnknownElement,
@@ -50,7 +51,14 @@ import { TextLocalChangesState } from './sidebar-state/LocalChangesState.js';
 import { GraphCompilationOutcome, type Problem } from './EditorGraphState.js';
 import { GRAPH_EDITOR_MODE, PANEL_MODE } from './EditorConfig.js';
 import { graph_dispose } from '../graph-modifier/GraphModifierHelper.js';
-import { LegendStudioTelemetryHelper } from '../../__lib__/LegendStudioTelemetryHelper.js';
+import {
+  LegendStudioTelemetryHelper,
+  TEXT_MODE_ACTION,
+  TEXT_MODE_ACTION_STATUS,
+  TEXT_MODE_COMPILATION_ERROR_KIND,
+  TEXT_MODE_ENTER_TRIGGER,
+  TEXT_MODE_LEAVE_OUTCOME,
+} from '../../__lib__/LegendStudioTelemetryHelper.js';
 import { GraphEditorMode } from './GraphEditorMode.js';
 import { ElementEditorState } from './editor-state/element-editor-state/ElementEditorState.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../__lib__/LegendStudioEvent.js';
@@ -64,6 +72,12 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
   grammarTextEditorState: GrammarTextEditorState;
   generatedFile: FileSystem_File | undefined;
 
+  // Text-mode session telemetry state (not observable; used for analytics only)
+  private textModeEnteredAt: number | undefined;
+  private textModeEditCount = 0;
+  private textModeCompilationCount = 0;
+  private textModeHasEmittedFirstEdit = false;
+
   constructor(editorStore: EditorStore) {
     super(editorStore);
     makeObservable(this, {
@@ -80,6 +94,81 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     return 'Text Mode';
   }
 
+  /**
+   * Whether this is the strict-text (lazy) variant. Overridden by
+   * `GraphEditLazyGrammarModeState` to return true.
+   */
+  protected get isStrictTextMode(): boolean {
+    return false;
+  }
+
+  private getCurrentElementPath(): string | undefined {
+    const currentTab = this.editorStore.tabManagerState.currentTab;
+    return currentTab instanceof ElementEditorState
+      ? currentTab.element.path
+      : undefined;
+  }
+
+  private startTextModeTelemetrySession(
+    trigger: TEXT_MODE_ENTER_TRIGGER,
+  ): void {
+    this.textModeEnteredAt = Date.now();
+    this.textModeEditCount = 0;
+    this.textModeCompilationCount = 0;
+    this.textModeHasEmittedFirstEdit = false;
+    LegendStudioTelemetryHelper.logEvent_TextModeEntered(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      {
+        trigger,
+        strict: this.isStrictTextMode,
+        elementPath: this.getCurrentElementPath(),
+      },
+    );
+    if (this.isStrictTextMode) {
+      LegendStudioTelemetryHelper.logEvent_TextModeStrictLaunch(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+      );
+    }
+  }
+
+  private emitTextModeLeaveTelemetry(outcome: TEXT_MODE_LEAVE_OUTCOME): void {
+    if (this.textModeEnteredAt === undefined) {
+      return;
+    }
+    LegendStudioTelemetryHelper.logEvent_TextModeLeft(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      {
+        outcome,
+        durationMs: Date.now() - this.textModeEnteredAt,
+        editCount: this.textModeEditCount,
+        compilationCount: this.textModeCompilationCount,
+      },
+    );
+    this.textModeEnteredAt = undefined;
+  }
+
+  /**
+   * Notify a user-driven edit in the grammar text buffer. Fires
+   * `text-mode.first-edit` once per session.
+   */
+  notifyGrammarTextEdited(): void {
+    if (this.textModeEnteredAt === undefined) {
+      return;
+    }
+    this.textModeEditCount += 1;
+    if (!this.textModeHasEmittedFirstEdit) {
+      this.textModeHasEmittedFirstEdit = true;
+      LegendStudioTelemetryHelper.logEvent_TextModeFirstEdit(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        Date.now() - this.textModeEnteredAt,
+      );
+    }
+  }
+
   setGeneratedFile(val: FileSystem_File | undefined): void {
     this.generatedFile = val;
   }
@@ -88,6 +177,7 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     isCompilationFailure?: boolean;
     isGraphBuildFailure?: boolean;
     useStoredEntities?: boolean;
+    trigger?: TEXT_MODE_ENTER_TRIGGER;
   }): GeneratorFn<void> {
     this.editorStore.localChangesState = new TextLocalChangesState(
       this.editorStore,
@@ -152,6 +242,16 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
         });
       }
     }
+
+    // emit text-mode session-start telemetry
+    const trigger: TEXT_MODE_ENTER_TRIGGER =
+      isFallback?.trigger ??
+      (isFallback?.isGraphBuildFailure
+        ? TEXT_MODE_ENTER_TRIGGER.FALLBACK_GRAPH_BUILD_FAILURE
+        : isFallback?.isCompilationFailure
+          ? TEXT_MODE_ENTER_TRIGGER.FALLBACK_FORM_COMPILATION_FAILURE
+          : TEXT_MODE_ENTER_TRIGGER.MANUAL_TOGGLE);
+    this.startTextModeTelemetrySession(trigger);
   }
 
   *goToElement(elementPath: string): GeneratorFn<void> {
@@ -181,6 +281,14 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
           LEGEND_STUDIO_APP_EVENT.TEXT_MODE_ACTION_KEYBOARD_SHORTCUT_GO_TO_DEFINITION__SUCCESS,
         ),
       );
+      LegendStudioTelemetryHelper.logEvent_TextModeAction(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          action: TEXT_MODE_ACTION.GO_TO_DEFINITION,
+          status: TEXT_MODE_ACTION_STATUS.SUCCESS,
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(
@@ -192,6 +300,15 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
         ),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_TextModeAction(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          action: TEXT_MODE_ACTION.GO_TO_DEFINITION,
+          status: TEXT_MODE_ACTION_STATUS.ERROR,
+          errorMessage: error.message,
+        },
+      );
     }
   }
 
@@ -372,7 +489,9 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     );
     LegendStudioTelemetryHelper.logEvent_TextCompilationLaunched(
       this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
     );
+    this.textModeCompilationCount += 1;
 
     const currentGraphHash = this.getCurrentGraphHash();
 
@@ -443,6 +562,7 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
       LegendStudioTelemetryHelper.logEvent_TextCompilationSucceeded(
         this.editorStore.applicationStore.telemetryService,
         report,
+        this.editorStore.editorMode.getSourceInfo(),
       );
     } catch (error) {
       assertErrorThrown(error);
@@ -472,6 +592,19 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
       this.editorStore.graphState.setMostRecentCompilationOutcome(
         GraphCompilationOutcome.FAILED,
       );
+      LegendStudioTelemetryHelper.logEvent_TextModeCompilationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          errorKind:
+            error instanceof ParserError
+              ? TEXT_MODE_COMPILATION_ERROR_KIND.PARSER
+              : error instanceof EngineError
+                ? TEXT_MODE_COMPILATION_ERROR_KIND.COMPILER
+                : TEXT_MODE_COMPILATION_ERROR_KIND.OTHER,
+          errorMessage: error.message,
+        },
+      );
     } finally {
       this.editorStore.graphState.isRunningGlobalCompile = false;
     }
@@ -533,6 +666,11 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
         message: 'Leaving text mode and rebuilding graph...',
         showLoading: true,
       });
+      this.emitTextModeLeaveTelemetry(
+        TEXT_MODE_LEAVE_OUTCOME.COMPILED_AND_LEFT,
+      );
+    } else {
+      this.emitTextModeLeaveTelemetry(TEXT_MODE_LEAVE_OUTCOME.DISCARDED);
     }
   }
 

package/src/stores/editor/GraphEditorMode.ts

@@ -56,6 +56,7 @@ export abstract class GraphEditorMode {
     isCompilationFailure?: boolean;
     isGraphBuildFailure?: boolean;
     useStoredEntities?: boolean;
+    trigger?: string;
   }): GeneratorFn<void>;
   abstract addElement(
     element: PackageableElement,

package/src/stores/editor/StandardEditorMode.ts

@@ -25,16 +25,27 @@ import {
   generateEditorRoute,
   generateViewProjectByGAVRoute,
 } from '../../__lib__/LegendStudioNavigation.js';
-import { EditorMode, type LegendStudioSourceType } from './EditorMode.js';
+import { EditorMode, LegendStudioSourceType } from './EditorMode.js';
 import type { LegendSourceInfo } from '@finos/legend-storage';
 
 export interface WorkspaceProjectQuerySDLC extends LegendSourceInfo {
   sourceType: LegendStudioSourceType.PROJECT_WORKSPACE;
   projectId: string;
   workspaceId: string;
-  WorkspaceType: string;
-  userId?: string;
-  source?: string;
+  workspaceType: string;
+  /** Set only for USER workspaces (owner id); undefined for GROUP. */
+  userId?: string | undefined;
+  /**
+   * Optional SDLC-side hint about where the workspace originated
+   * (e.g. `legend-query` productionization). Free-form string until SDLC
+   * formalizes a `SourceType` enum.
+   */
+  source?: string | undefined;
+  /**
+   * Patch release the workspace is targeting, when the workspace lives on a
+   * patch branch. Undefined for regular workspaces on main.
+   */
+  patchReleaseVersionId?: string | undefined;
 }
 
 export class StandardEditorMode extends EditorMode {
@@ -76,18 +87,21 @@ export class StandardEditorMode extends EditorMode {
     );
   }
 
-  getSourceInfo(): LegendSourceInfo | undefined {
+  getSourceInfo(): WorkspaceProjectQuerySDLC | undefined {
     if (this.isInitialized) {
       const workspace = guaranteeNonNullable(
         this.editorStore.sdlcState.currentWorkspace,
       );
       return {
+        sourceType: LegendStudioSourceType.PROJECT_WORKSPACE,
         projectId: this.editorStore.sdlcState.activeProject.projectId,
         workspaceId: workspace.workspaceId,
-        WorkspaceType: workspace.workspaceType,
+        workspaceType: workspace.workspaceType,
         userId: workspace.userId,
         source: workspace.source,
-      } as WorkspaceProjectQuerySDLC;
+        patchReleaseVersionId:
+          this.editorStore.sdlcState.activePatch?.patchReleaseVersionId.id,
+      };
     } else {
       return undefined;
     }