Updating wizard file

Author: Vandita Patidar

packages/core/src/awsService/appBuilder/serverlessLand/main.ts

@@ -17,6 +17,7 @@ import { addFolderToWorkspace } from '../../../shared/utilities/workspaceUtils'
 import { ToolkitError } from '../../../shared/errors'
 import { fs } from '../../../shared/fs/fs'
 import { getPattern } from '../../../shared/utilities/downloadPatterns'
+import { MetadataManager } from './metadataManager'
 
 export const readmeFile: string = 'README.md'
 const serverlessLandOwner = 'aws-samples'
@@ -38,17 +39,20 @@ const serverlessLandRepo = 'serverless-patterns'
 export async function createNewServerlessLandProject(extContext: ExtContext): Promise<void> {
     let createResult: Result = 'Succeeded'
     let reason: string | undefined
+    let metadataManager: MetadataManager
 
     try {
+        metadataManager = MetadataManager.getInstance()
         // Launch the project creation wizard
         const config = await launchProjectCreationWizard(extContext)
         if (!config) {
             createResult = 'Cancelled'
             reason = 'userCancelled'
             return
         }
+        const assetName = metadataManager.getAssetName(config.pattern, config.runtime, config.iac)
 
-        await downloadPatternCode(config)
+        await downloadPatternCode(config, assetName)
         await openReadmeFile(config)
         await addFolderToWorkspace(
             {
@@ -91,11 +95,11 @@ async function launchProjectCreationWizard(
     }).run()
 }
 
-async function downloadPatternCode(config: CreateServerlessLandWizardForm): Promise<void> {
-    const assetName = config.assetName + '.zip'
+async function downloadPatternCode(config: CreateServerlessLandWizardForm, assetName: string): Promise<void> {
+    const fullAssetName = assetName + '.zip'
     const location = vscode.Uri.joinPath(config.location, config.name)
     try {
-        await getPattern(serverlessLandOwner, serverlessLandRepo, assetName, location, true)
+        await getPattern(serverlessLandOwner, serverlessLandRepo, fullAssetName, location, true)
     } catch (error) {
         if (error instanceof ToolkitError) {
             throw error

packages/core/src/awsService/appBuilder/serverlessLand/wizard.ts

@@ -10,6 +10,7 @@ import { createInputBox } from '../../../shared/ui/inputPrompter'
 import { createCommonButtons } from '../../../shared/ui/buttons'
 import { createQuickPick } from '../../../shared/ui/pickerPrompter'
 import { createFolderPrompt } from '../../../shared/ui/common/location'
+import { createExitPrompter } from '../../../shared/ui/common/exitPrompter'
 import { MetadataManager } from './metadataManager'
 import { ToolkitError } from '../../../shared/errors'
 
@@ -19,158 +20,138 @@ export interface CreateServerlessLandWizardForm {
     pattern: string
     runtime: string
     iac: string
-    assetName: string
 }
 
-/**
- * Wizard for creating Serverless Land applications
- * Guides users through the project creation process
- */
-export class CreateServerlessLandWizard extends Wizard<CreateServerlessLandWizardForm> {
-    private metadataManager: MetadataManager
-
-    public constructor(context: { defaultRegion?: string; credentials?: AWS.Credentials }) {
-        super()
-        this.metadataManager = MetadataManager.getInstance()
-
-        // Bind the steps
-        this.form.pattern.bindPrompter(() => this.promptPattern())
-        this.form.runtime.bindPrompter((state) => this.promptRuntime(state.pattern))
-        this.form.iac.bindPrompter((state) => this.promptIac(state.pattern))
-        this.form.location.bindPrompter(() => this.promptLocation())
-        this.form.name.bindPrompter(() => this.promptName())
-    }
+async function loadMetadata(): Promise<MetadataManager> {
+    const metadataManager = MetadataManager.getInstance()
+    const projectRoot = path.resolve(__dirname, '../../../../../')
+    const metadataPath = path.join(projectRoot, 'src', 'awsService', 'appBuilder', 'serverlessLand', 'metadata.json')
+    await metadataManager.loadMetadata(metadataPath)
+    return metadataManager
+}
 
-    private async loadMetadata(): Promise<void> {
-        const projectRoot = path.resolve(__dirname, '../../../../../')
-        const metadataPath = path.join(
-            projectRoot,
-            'src',
-            'awsService',
-            'appBuilder',
-            'serverlessLand',
-            'metadata.json'
-        )
-        await this.metadataManager.loadMetadata(metadataPath)
+function promptPattern(metadataManager: MetadataManager) {
+    const patterns = metadataManager.getPatterns()
+    if (patterns.length === 0) {
+        throw new Error('No patterns found in metadata')
     }
 
-    private async promptPattern() {
-        const patterns = this.metadataManager.getPatterns()
-        if (patterns.length === 0) {
-            throw new Error('No patterns found in metadata')
+    return createQuickPick<string>(
+        patterns.map((p) => ({
+            label: p.label,
+            detail: p.description,
+            data: p.label,
+            buttons: [
+                {
+                    iconPath: new vscode.ThemeIcon('github'),
+                    tooltip: 'Open in GitHub',
+                },
+                {
+                    iconPath: new vscode.ThemeIcon('open-preview'),
+                    tooltip: 'Open in Serverless Land',
+                },
+            ],
+        })),
+        {
+            title: 'Select a Pattern for your application',
+            placeholder: 'Choose a pattern for your project',
+            buttons: createCommonButtons(),
+            matchOnDescription: true,
+            matchOnDetail: true,
         }
+    )
+}
 
-        return createQuickPick<string>(
-            patterns.map((p) => ({
-                label: p.label,
-                detail: p.description,
-                data: p.label,
-                buttons: [
-                    {
-                        iconPath: new vscode.ThemeIcon('github'),
-                        tooltip: 'Open in GitHub',
-                    },
-                    {
-                        iconPath: new vscode.ThemeIcon('open-preview'),
-                        tooltip: 'Open in Serverless Land',
-                    },
-                ],
-            })),
-            {
-                title: 'Select a Pattern for your application',
-                placeholder: 'Choose a pattern for your project',
-                buttons: createCommonButtons(),
-                matchOnDescription: true,
-                matchOnDetail: true,
-            }
-        )
+function promptRuntime(metadataManager: MetadataManager, pattern: string | undefined) {
+    if (!pattern || typeof pattern !== 'string') {
+        throw new Error('Pattern not selected')
     }
 
-    private async promptRuntime(pattern: string | undefined) {
-        if (!pattern || typeof pattern !== 'string') {
-            throw new Error('Pattern not selected')
-        }
-
-        const runtimes = this.metadataManager.getRuntimes(pattern)
-        if (runtimes.length === 0) {
-            throw new Error('No runtimes found for the selected pattern')
-        }
-
-        return createQuickPick<string>(
-            runtimes.map((r) => ({
-                label: r.label,
-                data: r.label,
-            })),
-            {
-                title: 'Select Runtime',
-                placeholder: 'Choose a runtime for your project',
-                buttons: [vscode.QuickInputButtons.Back],
-            }
-        )
+    const runtimes = metadataManager.getRuntimes(pattern)
+    if (runtimes.length === 0) {
+        throw new Error('No runtimes found for the selected pattern')
     }
 
-    private async promptIac(pattern: string | undefined) {
-        if (!pattern || typeof pattern !== 'string') {
-            throw new Error('Pattern not selected')
-        }
-
-        const iacOptions = this.metadataManager.getIacOptions(pattern)
-        if (iacOptions.length === 0) {
-            throw new Error('No IAC options found for the selected pattern')
+    return createQuickPick<string>(
+        runtimes.map((r) => ({
+            label: r.label,
+            data: r.label,
+        })),
+        {
+            title: 'Select Runtime',
+            placeholder: 'Choose a runtime for your project',
+            buttons: [vscode.QuickInputButtons.Back],
         }
+    )
+}
 
-        return createQuickPick<string>(
-            iacOptions.map((i) => ({
-                label: i.label,
-                data: i.label,
-            })),
-            {
-                title: 'Select IaC',
-                placeholder: 'Choose an IaC option for your project',
-                buttons: [vscode.QuickInputButtons.Back],
-            }
-        )
+function promptIac(metadataManager: MetadataManager, pattern: string | undefined) {
+    if (!pattern || typeof pattern !== 'string') {
+        throw new Error('Pattern not selected')
     }
 
-    private async promptLocation() {
-        return createFolderPrompt(vscode.workspace.workspaceFolders ?? [], {
-            title: 'Select Project Location',
-            buttons: [vscode.QuickInputButtons.Back],
-            browseFolderDetail: 'Select a folder for your project',
-        })
+    const iacOptions = metadataManager.getIacOptions(pattern)
+    if (iacOptions.length === 0) {
+        throw new Error('No IAC options found for the selected pattern')
     }
 
-    private async promptName() {
-        return createInputBox({
-            title: 'Enter Project Name',
-            placeholder: 'Enter a name for your new application',
+    return createQuickPick<string>(
+        iacOptions.map((i) => ({
+            label: i.label,
+            data: i.label,
+        })),
+        {
+            title: 'Select IaC',
+            placeholder: 'Choose an IaC option for your project',
             buttons: [vscode.QuickInputButtons.Back],
-            validateInput: (value: string): string | undefined => {
-                if (!value) {
-                    return 'Application name cannot be empty'
-                }
-                if (value.includes(path.sep)) {
-                    return `The path separator (${path.sep}) is not allowed in application names`
-                }
-                return undefined
-            },
-        })
-    }
+        }
+    )
+}
 
-    public override async run(): Promise<CreateServerlessLandWizardForm | undefined> {
-        try {
-            await this.loadMetadata()
-            const form = await super.run()
-            if (!form) {
-                return undefined
-            }
+function promptLocation() {
+    return createFolderPrompt(vscode.workspace.workspaceFolders ?? [], {
+        title: 'Select Project Location',
+        buttons: [vscode.QuickInputButtons.Back],
+        browseFolderDetail: 'Select a folder for your project',
+    })
+}
 
-            return {
-                ...form,
-                assetName: this.metadataManager.getAssetName(form.pattern, form.runtime, form.iac),
+function promptName() {
+    return createInputBox({
+        title: 'Enter Project Name',
+        placeholder: 'Enter a name for your new application',
+        buttons: [vscode.QuickInputButtons.Back],
+        validateInput: (value: string): string | undefined => {
+            if (!value) {
+                return 'Application name cannot be empty'
             }
-        } catch (err) {
-            throw new ToolkitError(`Failed to run wizard: ${err instanceof Error ? err.message : String(err)}`)
-        }
+            if (value.includes(path.sep)) {
+                return `The path separator (${path.sep}) is not allowed in application names`
+            }
+            return undefined
+        },
+    })
+}
+
+/**
+ * Wizard for creating Serverless Land applications
+ * Guides users through the project creation process
+ */
+export class CreateServerlessLandWizard extends Wizard<CreateServerlessLandWizardForm> {
+    private metadataManager: MetadataManager
+
+    public constructor(context: { defaultRegion?: string; credentials?: AWS.Credentials }) {
+        super({
+            exitPrompterProvider: createExitPrompter,
+        })
+        loadMetadata().catch((err: any) => {
+            throw new ToolkitError(`Failed to load metadata: ${err}`)
+        })
+        this.metadataManager = MetadataManager.getInstance()
+        this.form.pattern.bindPrompter(() => promptPattern(this.metadataManager))
+        this.form.runtime.bindPrompter((state) => promptRuntime(this.metadataManager, state.pattern))
+        this.form.iac.bindPrompter((state) => promptIac(this.metadataManager, state.pattern))
+        this.form.location.bindPrompter(() => promptLocation())
+        this.form.name.bindPrompter(() => promptName())
     }
 }