Building Quick Pick structure

Author: Vandita Patidar

aws-toolkit-vscode.code-workspace

@@ -1,19 +1,50 @@
 {
-	"folders": [
-		{
-			"path": "."
-		},
-		{
-			"path": "packages/toolkit"
-		},
-		{
-			"path": "packages/core"
-		},
-		{
-			"path": "packages/amazonq"
-		}
-	],
-	"settings": {
-		"typescript.tsdk": "node_modules/typescript/lib"
-	}
-}
+    "folders": [
+        {
+            "path": ".",
+        },
+        {
+            "path": "packages/toolkit",
+        },
+        {
+            "path": "packages/core",
+        },
+        {
+            "path": "packages/amazonq",
+        },
+    ],
+    "settings": {
+        "typescript.tsdk": "node_modules/typescript/lib",
+    },
+    "launch": {
+        "configurations": [
+            {
+                "type": "aws-sam",
+                "request": "direct-invoke",
+                "name": "core:src/awsService/appBuilder/serverlessLand.getProjectUri (nodejs14.x)",
+                "invokeTarget": {
+                    "target": "code",
+                    "projectRoot": "/Users/vanditap/src/github.com/aws-toolkit-vscode/packages/core",
+                    "lambdaHandler": "src/awsService/appBuilder/serverlessLand.getProjectUri",
+                },
+                "lambda": {
+                    "runtime": "nodejs14.x",
+                    "payload": {},
+                    "environmentVariables": {},
+                },
+            },
+            {
+                "name": "Test Lint",
+                "type": "node",
+                "request": "launch",
+                "program": "${workspaceFolder}/scripts/lint/testLint.ts",
+                "outFiles": ["${workspaceFolder}/dist/**/*.js"],
+                "preLaunchTask": "build",
+                "presentation": {
+                    "group": "7_TestLint",
+                    "order": 1,
+                },
+            },
+        ],
+    },
+}

packages/core/scripts/build/copyFiles.ts

@@ -44,6 +44,10 @@ const tasks: CopyTask[] = [
         target: path.join('../../node_modules', 'aws-ssm-document-language-service', 'dist', 'server.js.map'),
         destination: path.join('src', 'ssmDocument', 'ssm', 'server.js.map'),
     },
+    {
+        target: path.join('../core', 'src', 'awsService', 'appBuilder', 'serverlessLand', 'metadata.json'),
+        destination: path.join('src', 'awsService', 'appBuilder', 'serverlessLand', 'metadata.json'),
+    },
 ]
 
 function copy(task: CopyTask): void {

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

@@ -6,16 +6,22 @@
 import * as nls from 'vscode-nls'
 const localize = nls.loadMessageBundle()
 import * as path from 'path'
+import * as vscode from 'vscode'
 import { getTelemetryReason, getTelemetryResult } from '../../../shared/errors'
 import { getLogger } from '../../../shared/logger/logger'
 import globals from '../../../shared/extensionGlobals'
 import { checklogs } from '../../../shared/localizedText'
 import { Result, telemetry } from '../../../shared/telemetry/telemetry'
-import { CreateServerlessLandWizard } from './wizard'
+import { CreateServerlessLandWizardForm, CreateServerlessLandWizard } from './wizard'
 import { ExtContext } from '../../../shared/extensions'
 import { addFolderToWorkspace } from '../../../shared/utilities/workspaceUtils'
+import { ToolkitError } from '../../../shared/errors'
+import { fileExists } from '../../../shared/filesystemUtilities'
+import { getPattern } from '../../../shared/utilities/downloadPatterns'
 
 export const readmeFile: string = 'README.md'
+const serverlessLandOwner = 'aws-samples'
+const serverlessLandRepo = 'serverless-patterns'
 
 /**
  * Creates a new Serverless Land project using the provided extension context
@@ -31,30 +37,24 @@ export const readmeFile: string = 'README.md'
  * 6. Handles errors and emits telemetry
  */
 export async function createNewServerlessLandProject(extContext: ExtContext): Promise<void> {
-    const awsContext = extContext.awsContext
     let createResult: Result = 'Succeeded'
     let reason: string | undefined
 
     try {
-        const credentials = await awsContext.getCredentials()
-        const defaultRegion = awsContext.getCredentialDefaultRegion()
-
         // Launch the project creation wizard
-        const config = await new CreateServerlessLandWizard({
-            credentials,
-            defaultRegion,
-        }).run()
+        const config = await launchProjectCreationWizard(extContext)
         if (!config) {
             createResult = 'Cancelled'
             reason = 'userCancelled'
             return
         }
 
-        // Add the project folder to the workspace
+        await downloadPatternCode(config)
+        await openReadmeFile(config)
         await addFolderToWorkspace(
             {
-                uri: config.location,
-                name: path.basename(config.location.fsPath),
+                uri: vscode.Uri.joinPath(config.location, config.name),
+                name: path.basename(config.name),
             },
             true
         )
@@ -80,3 +80,79 @@ export async function createNewServerlessLandProject(extContext: ExtContext): Pr
         })
     }
 }
+
+async function launchProjectCreationWizard(
+    extContext: ExtContext
+): Promise<CreateServerlessLandWizardForm | undefined> {
+    const awsContext = extContext.awsContext
+    const credentials = await awsContext.getCredentials()
+    const defaultRegion = awsContext.getCredentialDefaultRegion()
+
+    return new CreateServerlessLandWizard({
+        credentials,
+        defaultRegion,
+    }).run()
+}
+
+async function downloadPatternCode(config: CreateServerlessLandWizardForm): Promise<void> {
+    const assetName = config.assetName + '.zip'
+    const location = vscode.Uri.joinPath(config.location, config.name)
+    try {
+        await getPattern(serverlessLandOwner, serverlessLandRepo, assetName, location, true)
+    } catch (error) {
+        if (error instanceof ToolkitError) {
+            throw error
+        }
+        throw new ToolkitError(`Failed to download pattern: ${error}`)
+    }
+}
+
+async function openReadmeFile(config: CreateServerlessLandWizardForm): Promise<void> {
+    try {
+        const projectUri = await getProjectUri(config, readmeFile)
+        if (!projectUri) {
+            getLogger().warn('Project URI not found when trying to open README')
+            return
+        }
+
+        const readmeUri = vscode.Uri.file(path.join(path.dirname(projectUri.fsPath), readmeFile))
+        if (!(await fileExists(readmeUri.fsPath))) {
+            getLogger().warn(
+                localize('AWS.serverlessLand.readme.notFound', 'README.md file not found in the project directory')
+            )
+            return
+        }
+
+        try {
+            const document = await vscode.workspace.openTextDocument(readmeUri)
+            await vscode.window.showTextDocument(document, { preview: true })
+        } catch (err) {
+            getLogger().error(`Failed to open README file: ${err}`)
+            throw new ToolkitError('Failed to open README file')
+        }
+    } catch (err) {
+        getLogger().error(`Error in openReadmeFile: ${err}`)
+        throw new ToolkitError('Error processing README file')
+    }
+}
+
+async function getProjectUri(
+    config: Pick<CreateServerlessLandWizardForm, 'location' | 'name'>,
+    file: string
+): Promise<vscode.Uri | undefined> {
+    if (!file) {
+        throw Error('expected "file" parameter to have at least one item')
+    }
+    const cfnTemplatePath = path.resolve(config.location.fsPath, config.name, file)
+    if (await fileExists(cfnTemplatePath)) {
+        return vscode.Uri.file(cfnTemplatePath)
+    }
+    void vscode.window.showWarningMessage(
+        localize(
+            'AWS.serverlessLand.initWizard.source.error.notFound',
+            'Project created successfully, but {0} file not found: {1}',
+            file!,
+            cfnTemplatePath!
+        )
+    )
+}

packages/core/src/awsService/appBuilder/serverlessLand/metadata.json

@@ -3,56 +3,52 @@
         "s3-lambda-resizing-sam": {
             "name": "Resizing image",
             "description": "Lambda, S3 • Python, Javascript, Java, .NET • SAM",
-            "runtimes": [
+            "implementation": [
                 {
-                    "id": "python",
-                    "name": "Python"
+                    "iac": "sam",
+                    "runtime": "python",
+                    "assetName": "s3-lambda-resizing-python"
                 },
                 {
-                    "id": "javascript",
-                    "name": "Javascript"
+                    "iac": "sam",
+                    "runtime": "javascript",
+                    "assetName": "s3-lambda"
                 },
                 {
-                    "id": "dotnet",
-                    "name": "Dotnet"
+                    "iac": "sam",
+                    "runtime": "java",
+                    "assetName": "s3-lambda-resizing-java"
                 },
                 {
-                    "id": "java",
-                    "name": "Java"
-                }
-            ],
-            "iac": [
-                {
-                    "id": "sam",
-                    "name": "SAM"
+                    "iac": "sam",
+                    "runtime": "dotnet",
+                    "assetName": "s3-lambda-dotnet"
                 }
             ]
         },
         "apigw-rest-api-lambda-sam": {
             "name": "Rest API",
             "description": "Lambda, API Gateway • Python, Javascript, Java, .NET • SAM",
-            "runtimes": [
+            "implementation": [
                 {
-                    "id": "python",
-                    "name": "Python"
+                    "iac": "sam",
+                    "runtime": "python",
+                    "assetName": "apigw-rest-api-lambda-python"
                 },
                 {
-                    "id": "javascript",
-                    "name": "Javascript"
+                    "iac": "sam",
+                    "runtime": "javascript",
+                    "assetName": "apigw-rest-api-lambda-node"
                 },
                 {
-                    "id": "dotnet",
-                    "name": "Dotnet"
+                    "iac": "sam",
+                    "runtime": "java",
+                    "assetName": "apigw-rest-api-lambda-java"
                 },
                 {
-                    "id": "java",
-                    "name": "Java"
-                }
-            ],
-            "iac": [
-                {
-                    "id": "sam",
-                    "name": "AWS SAM"
+                    "iac": "sam",
+                    "runtime": "dotnet",
+                    "assetName": "apigw-rest-api-lambda-dotnet"
                 }
             ]
         }

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

@@ -5,20 +5,15 @@
 import * as nodefs from 'fs' // eslint-disable-line no-restricted-imports
 import { ToolkitError } from '../../../shared/errors'
 
-interface IaC {
-    id: string
-    name: string
-}
-interface Runtime {
-    id: string
-    name: string
-    version: string
+interface Implementation {
+    iac: string
+    runtime: string
+    assetName: string
 }
 interface PatternData {
     name: string
     description: string
-    runtimes: Runtime[]
-    iac: IaC[]
+    implementation: Implementation[]
 }
 
 export interface ProjectMetadata {
@@ -97,11 +92,12 @@ export class MetadataManager {
      */
     public getRuntimes(pattern: string): { label: string }[] {
         const patternData = this.metadata?.patterns?.[pattern]
-        if (!patternData || !patternData.runtimes) {
+        if (!patternData || !patternData.implementation) {
             return []
         }
-        return patternData.runtimes.map((runtime) => ({
-            label: runtime.name,
+        const uniqueRuntimes = new Set(patternData.implementation.map((item) => item.runtime))
+        return Array.from(uniqueRuntimes).map((runtime) => ({
+            label: runtime,
         }))
     }
 
@@ -112,11 +108,22 @@ export class MetadataManager {
      */
     public getIacOptions(pattern: string): { label: string }[] {
         const patternData = this.metadata?.patterns?.[pattern]
-        if (!patternData || !patternData.iac) {
+        if (!patternData || !patternData.implementation) {
             return []
         }
-        return patternData.iac.map((iac) => ({
-            label: iac.name,
+        const uniqueIaCs = new Set(patternData.implementation.map((item) => item.iac))
+        return Array.from(uniqueIaCs).map((iac) => ({
+            label: iac,
         }))
     }
+    public getAssetName(selectedPattern: string, selectedRuntime: string, selectedIaC: string): string {
+        const patternData = this.metadata?.patterns?.[selectedPattern]
+        if (!patternData || !patternData.implementation) {
+            return ''
+        }
+        const matchingImplementation = patternData.implementation.find(
+            (impl) => impl.runtime === selectedRuntime && impl.iac === selectedIaC
+        )
+        return matchingImplementation?.assetName ?? ''
+    }
 }

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

@@ -20,6 +20,7 @@ export interface CreateServerlessLandWizardForm {
     pattern: string
     runtime: string
     iac: string
+    assetName: string
 }
 
 /**
@@ -133,6 +134,9 @@ export class CreateServerlessLandWizard extends Wizard<CreateServerlessLandWizar
             }
             const selectedIac = iacResult
 
+            // Get Asset Name based on selected Pattern, Runtime and IaC
+            const assetName = this.metadataManager.getAssetName(selectedPattern, selectedRuntime, selectedIac)
+
             // Create and show location picker
             const locationPicker = createFolderPrompt(vscode.workspace.workspaceFolders ?? [], {
                 title: 'Select Project Location',
@@ -173,6 +177,7 @@ export class CreateServerlessLandWizard extends Wizard<CreateServerlessLandWizar
                 pattern: selectedPattern,
                 runtime: selectedRuntime,
                 iac: selectedIac,
+                assetName: assetName,
             }
         } catch (err) {
             throw new ToolkitError(`Failed to run wizard: ${err instanceof Error ? err.message : String(err)}`)