adding helper functions amd adjusting tests

Author: Diler Zaza

packages/core/src/stepFunctions/commands/downloadStateMachineDefinition.ts

@@ -35,7 +35,10 @@ export async function downloadStateMachineDefinition(params: {
             })
 
         if (params.isPreviewAndRender) {
-            await openWorkflowStudioWithDefinition(stateMachineDetails.definition)
+            await openWorkflowStudioWithDefinition(stateMachineDetails.definition, {
+                preserveFocus: true,
+                viewColumn: vscode.ViewColumn.Beside,
+            })
         } else {
             const wsPath = vscode.workspace.workspaceFolders
                 ? vscode.workspace.workspaceFolders[0].uri.fsPath

packages/core/src/stepFunctions/executionDetails/executionDetailProvider.ts

@@ -35,7 +35,7 @@ export class ExecutionDetailProvider {
         const panel = vscode.window.createWebviewPanel(
             ExecutionDetailProvider.viewType,
             `Execution: ${executionArn.split(':').pop() || executionArn}`,
-            vscode.ViewColumn.Beside,
+            vscode.ViewColumn.One,
             {
                 enableScripts: true,
                 retainContextWhenHidden: true,

packages/core/src/stepFunctions/executionDetails/handleMessage.ts

@@ -4,8 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as nls from 'vscode-nls'
-const localize = nls.loadMessageBundle()
 import {
     Command,
     Message,
@@ -19,10 +17,8 @@ import {
     handleUnsupportedMessage,
     apiCallMessageHandler,
 } from '../messageHandlers/handleMessageHelpers'
-import { parseExecutionArnForStateMachine, openWorkflowStudio } from '../utils'
-import { ExecuteStateMachineWebview } from '../vue/executeStateMachine/executeStateMachine'
-import { VueWebview } from '../../webviews/main'
-import globals from '../../shared/extensionGlobals'
+import { parseExecutionArnForStateMachine, openWorkflowStudio, showExecuteStateMachineWebview } from '../utils'
+import { getLogger } from '../../shared/logger/logger'
 
 /**
  * Handles messages received from the ExecutionDetails webview. Depending on the message type and command,
@@ -88,25 +84,24 @@ async function initMessageHandler(context: ExecutionDetailsContext) {
 }
 
 async function startExecutionMessageHandler(context: ExecutionDetailsContext) {
-    // Parsing execution ARN to get state machine info
-    const parsedArn = parseExecutionArnForStateMachine(context.executionArn)
-    if (!parsedArn) {
-        throw new Error(`Invalid execution ARN format: ${context.executionArn}`)
-    }
-
-    const { region, stateMachineName, stateMachineArn } = parsedArn
+    const logger = getLogger('stepfunctions')
+    try {
+        // Parsing execution ARN to get state machine info
+        const parsedArn = parseExecutionArnForStateMachine(context.executionArn)
+        if (!parsedArn) {
+            throw new Error(`Invalid execution ARN format: ${context.executionArn}`)
+        }
 
-    const Panel = VueWebview.compilePanel(ExecuteStateMachineWebview)
-    const wv = new Panel(globals.context, globals.outputChannel, {
-        arn: stateMachineArn,
-        name: stateMachineName,
-        region: region,
-    })
+        const { region, stateMachineName, stateMachineArn } = parsedArn
 
-    await wv.show({
-        title: localize('AWS.executeStateMachine.title', 'Start Execution'),
-        cssFiles: ['executeStateMachine.css'],
-    })
+        await showExecuteStateMachineWebview({
+            arn: stateMachineArn,
+            name: stateMachineName,
+            region: region,
+        })
+    } catch (error) {
+        logger.error('Start execution failed: %O', error)
+    }
 }
 
 async function editStateMachineMessageHandler(context: ExecutionDetailsContext) {

packages/core/src/stepFunctions/utils.ts

@@ -18,6 +18,9 @@ import {
 import { fromExtensionManifest } from '../shared/settings'
 import { IamRole } from '../shared/clients/iam'
 import { WorkflowStudioEditorProvider } from './workflowStudio/workflowStudioEditorProvider'
+import { VueWebview } from '../webviews/main'
+import { ExecuteStateMachineWebview } from './vue/executeStateMachine/executeStateMachine'
+import globals from '../shared/extensionGlobals'
 
 const documentSettings: DocumentLanguageSettings = { comments: 'error', trailingCommas: 'error' }
 const languageService = getLanguageService({})
@@ -149,20 +152,52 @@ export const openWorkflowStudio = async (stateMachineArn: string, region: string
 /**
  * Opens a state machine definition in Workflow Studio using pre-fetched definition content
  * @param definition The state machine definition content
+ * @param options Optional webview configuration options
  */
-export const openWorkflowStudioWithDefinition = async (definition: string | undefined) => {
+export const openWorkflowStudioWithDefinition = async (
+    definition: string | undefined,
+    preserveFocus?: boolean,
+    viewColumn?: vscode.ViewColumn
+) => {
     const doc = await vscode.workspace.openTextDocument({
         language: 'asl',
         content: definition,
     })
 
     const textEditor = await vscode.window.showTextDocument(doc)
     await WorkflowStudioEditorProvider.openWithWorkflowStudio(textEditor.document.uri, {
-        preserveFocus: false,
-        viewColumn: vscode.ViewColumn.One,
+        preserveFocus: preserveFocus ?? false,
+        viewColumn: viewColumn ?? vscode.ViewColumn.One,
     })
 }
 
+/**
+ * Shows the Execute State Machine webview with the provided state machine data
+ * @param extensionContext The extension context
+ * @param outputChannel The output channel for logging
+ * @param stateMachineData Object containing arn, name, and region of the state machine
+ * @returns The webview instance
+ */
+export const showExecuteStateMachineWebview = async (stateMachineData: {
+    arn: string
+    name: string
+    region: string
+}) => {
+    const Panel = VueWebview.compilePanel(ExecuteStateMachineWebview)
+    const wv = new Panel(globals.context, globals.outputChannel, {
+        arn: stateMachineData.arn,
+        name: stateMachineData.name,
+        region: stateMachineData.region,
+    })
+
+    await wv.show({
+        title: localize('AWS.executeStateMachine.title', 'Start Execution'),
+        cssFiles: ['executeStateMachine.css'],
+    })
+
+    return wv
+}
+
 const isInvalidJson = (content: string): boolean => {
     try {
         JSON.parse(content)

packages/core/src/stepFunctions/vue/executeStateMachine/executeStateMachine.ts

@@ -16,6 +16,7 @@ import { VueWebview } from '../../../webviews/main'
 import * as vscode from 'vscode'
 import { telemetry } from '../../../shared/telemetry/telemetry'
 import { ExecutionDetailProvider } from '../../executionDetails/executionDetailProvider'
+import { showExecuteStateMachineWebview } from '../../utils'
 
 interface StateMachine {
     arn: string
@@ -88,18 +89,11 @@ export class ExecuteStateMachineWebview extends VueWebview {
     }
 }
 
-const Panel = VueWebview.compilePanel(ExecuteStateMachineWebview)
-
 export async function executeStateMachine(context: ExtContext, node: StateMachineNode): Promise<void> {
-    const wv = new Panel(context.extensionContext, context.outputChannel, {
+    await showExecuteStateMachineWebview({
         arn: node.details.stateMachineArn || '',
         name: node.details.name || '',
         region: node.regionCode,
     })
-
-    await wv.show({
-        title: localize('AWS.executeStateMachine.title', 'Start Execution'),
-        cssFiles: ['executeStateMachine.css'],
-    })
     telemetry.stepfunctions_executeStateMachineView.emit()
 }