feat(appbuilder): add CapacityProvider node and property node (#8395)

## Problem
LMI function contains new property and we have new CapacityProvider
property

## Solution

- Add support for `AWS::Serverless::CapacityProvider` resource type in
explorer
- Display capacity provider properties in resource nodes
- Stringify CloudFormation intrinsic functions in property nodes for
better readability
- Add type-safe resource entity interfaces (FunctionResourceEntity,
CapacityProviderResourceEntity)
- Add type guards (isFunctionResource, isCapacityProviderResource) for
safer resource handling
- Hide property node if not defined
- Fix optional chaining for Architectures array access to prevent
undefined errors
- Add test coverage for capacity provider resources with intrinsic
functions

---

- Treat all work as PUBLIC. Private `feature/x` branches will not be
squash-merged at release time.
- Your code changes must meet the guidelines in
[CONTRIBUTING.md](https://github.com/aws/aws-toolkit-vscode/blob/master/CONTRIBUTING.md#guidelines).
- License: I confirm that my contribution is made under the terms of the
Apache 2.0 license.

---------

Co-authored-by: chungjac <chungjac@amazon.com>

Author: vicheey

packages/core/src/awsService/appBuilder/explorer/nodes/deployedNode.ts

@@ -26,9 +26,11 @@ import {
     SERVERLESS_FUNCTION_TYPE,
     SERVERLESS_API_TYPE,
     s3BucketType,
+    SERVERLESS_CAPACITY_PROVIDER_TYPE,
 } from '../../../../shared/cloudformation/cloudformation'
 import { ToolkitError } from '../../../../shared/errors'
-import { ResourceTreeEntity } from '../samProject'
+import { ResourceTreeEntity, isFunctionResource } from '../samProject'
+import { LambdaCapacityProviderNode } from '../../../../lambda/explorer/lambdaCapacityProviderNode'
 
 const localize = nls.loadMessageBundle()
 export interface DeployedResource {
@@ -43,6 +45,7 @@ export const DeployedResourceContextValues: Record<string, string> = {
     [SERVERLESS_FUNCTION_TYPE]: 'awsRegionFunctionNodeDownloadable',
     [SERVERLESS_API_TYPE]: 'awsApiGatewayNode',
     [s3BucketType]: 'awsS3BucketNode',
+    [SERVERLESS_CAPACITY_PROVIDER_TYPE]: 'awsCapacityProviderNode',
 }
 
 export class DeployedResourceNode implements TreeNode<DeployedResource> {
@@ -93,12 +96,13 @@ export async function generateDeployedNode(
                 try {
                     configuration = (await defaultClient.getFunction(deployedResource.PhysicalResourceId))
                         .Configuration as FunctionConfiguration
+                    const codeUri = isFunctionResource(resourceTreeEntity) ? resourceTreeEntity.CodeUri : undefined
                     newDeployedResource = new LambdaFunctionNode(
                         lambdaNode,
                         regionCode,
                         configuration,
                         undefined,
-                        location ? vscode.Uri.joinPath(location, resourceTreeEntity.CodeUri ?? '').fsPath : undefined,
+                        location ? vscode.Uri.joinPath(location, codeUri ?? '').fsPath : undefined,
                         location,
                         deployedResource.LogicalResourceId
                     )
@@ -124,6 +128,10 @@ export async function generateDeployedNode(
                 newDeployedResource = new RestApiNode(apiParentNode, partitionId, regionCode, apiNode as RestApi)
                 break
             }
+            case SERVERLESS_CAPACITY_PROVIDER_TYPE: {
+                newDeployedResource = new LambdaCapacityProviderNode(regionCode, deployedResource)
+                break
+            }
             default:
                 newDeployedResource = new DeployedResourceNode(deployedResource)
                 getLogger().info('Details are missing or are incomplete for: %O', deployedResource)

packages/core/src/awsService/appBuilder/explorer/nodes/propertyNode.ts

@@ -7,6 +7,16 @@ import * as vscode from 'vscode'
 import { getIcon } from '../../../../shared/icons'
 import { TreeNode } from '../../../../shared/treeview/resourceTreeDataProvider'
 
+/**
+ * Formats CloudFormation intrinsic functions into readable strings
+ */
+function formatIntrinsicFunction(value: any): string | undefined {
+    if (typeof value !== 'object' || value === null || Object.keys(value).length !== 1) {
+        return undefined
+    }
+    return JSON.stringify(value)
+}
+
 export class PropertyNode implements TreeNode {
     public readonly id = this.key
     public readonly resource = this.value
@@ -25,12 +35,15 @@ export class PropertyNode implements TreeNode {
     }
 
     public getTreeItem() {
-        const item = new vscode.TreeItem(`${this.key}: ${this.value}`)
+        const intrinsicFormat = formatIntrinsicFunction(this.value)
+        const displayValue = intrinsicFormat ?? this.value
+
+        const item = new vscode.TreeItem(`${this.key}: ${displayValue}`)
 
         item.contextValue = 'awsAppBuilderPropertyNode'
         item.iconPath = getIcon('vscode-gear')
 
-        if (this.value instanceof Array || this.value instanceof Object) {
+        if (!intrinsicFormat && (this.value instanceof Array || this.value instanceof Object)) {
             item.label = this.key
             item.collapsibleState = vscode.TreeItemCollapsibleState.Collapsed
         }
@@ -41,6 +54,6 @@ export class PropertyNode implements TreeNode {
 
 export function generatePropertyNodes(properties: { [key: string]: any }): TreeNode[] {
     return Object.entries(properties)
-        .filter(([key, _]) => key !== 'Id' && key !== 'Type' && key !== 'Events')
+        .filter(([key, value]) => key !== 'Id' && key !== 'Type' && key !== 'Events' && value !== undefined)
         .map(([key, value]) => new PropertyNode(key, value))
 }

packages/core/src/awsService/appBuilder/explorer/nodes/resourceNode.ts

@@ -12,6 +12,7 @@ import {
     s3BucketType,
     appRunnerType,
     ecrRepositoryType,
+    SERVERLESS_CAPACITY_PROVIDER_TYPE,
 } from '../../../../shared/cloudformation/cloudformation'
 import { generatePropertyNodes } from './propertyNode'
 import { generateDeployedNode } from './deployedNode'
@@ -24,6 +25,7 @@ enum ResourceTypeId {
     Function = 'function',
     DeployedFunction = 'deployed-function',
     Api = 'api',
+    CapacityProvider = 'capacityprovider',
     Other = '',
 }
 
@@ -88,7 +90,10 @@ export class ResourceNode implements TreeNode {
                 this.location.projectRoot
             )) as DeployedResourceNode[]
         }
-        if (this.resourceTreeEntity.Type === SERVERLESS_FUNCTION_TYPE) {
+        if (
+            this.resourceTreeEntity.Type === SERVERLESS_FUNCTION_TYPE ||
+            this.resourceTreeEntity.Type === SERVERLESS_CAPACITY_PROVIDER_TYPE
+        ) {
             propertyNodes = generatePropertyNodes(this.resourceTreeEntity)
         }
 
@@ -132,6 +137,8 @@ export class ResourceNode implements TreeNode {
                 return getIcon('aws-apprunner-service')
             case ecrRepositoryType:
                 return getIcon('aws-ecr-registry')
+            case SERVERLESS_CAPACITY_PROVIDER_TYPE:
+                return getIcon('vscode-gear')
             default:
                 return getIcon('vscode-info')
         }
@@ -146,6 +153,8 @@ export class ResourceNode implements TreeNode {
                 return ResourceTypeId.Function
             case 'Api':
                 return ResourceTypeId.Api
+            case SERVERLESS_CAPACITY_PROVIDER_TYPE:
+                return ResourceTypeId.CapacityProvider
             default:
                 return ResourceTypeId.Other
         }

packages/core/src/awsService/appBuilder/explorer/samProject.ts

@@ -9,7 +9,6 @@ import { SamConfig, SamConfigErrorCode } from '../../../shared/sam/config'
 import { getLogger } from '../../../shared/logger/logger'
 import { ToolkitError } from '../../../shared/errors'
 import { showViewLogsMessage } from '../../../shared/utilities/messages'
-import { Runtime } from '@aws-sdk/client-lambda'
 
 export interface SamApp {
     location: SamAppLocation
@@ -22,18 +21,40 @@ export interface SamAppLocation {
     projectRoot: vscode.Uri
 }
 
-export interface ResourceTreeEntity {
+export interface BaseResourceEntity {
     Id: string
     Type: string
-    Runtime?: Runtime
-    CodeUri?: string
-    Handler?: string
-    Events?: ResourceTreeEntity[]
+}
+
+export interface EventEntity extends BaseResourceEntity {
     Path?: string
     Method?: string
+}
+
+export interface FunctionResourceEntity extends BaseResourceEntity {
+    Runtime?: string
+    CodeUri?: string
+    Handler?: string
+    Events?: EventEntity[]
     Environment?: {
         Variables: Record<string, any>
     }
+    CapacityProviderConfig?: string
+    Architectures?: string
+}
+
+export interface CapacityProviderResourceEntity extends BaseResourceEntity {
+    Architectures?: string
+}
+
+export type ResourceTreeEntity = FunctionResourceEntity | CapacityProviderResourceEntity | BaseResourceEntity
+
+export function isFunctionResource(resource: ResourceTreeEntity): resource is FunctionResourceEntity {
+    return resource.Type === CloudFormation.SERVERLESS_FUNCTION_TYPE
+}
+
+export function isCapacityProviderResource(resource: ResourceTreeEntity): resource is CapacityProviderResourceEntity {
+    return resource.Type === CloudFormation.SERVERLESS_CAPACITY_PROVIDER_TYPE
 }
 
 export async function getStackName(projectRoot: vscode.Uri): Promise<any> {
@@ -78,30 +99,58 @@ function getResourceEntity(template: any): ResourceTreeEntity[] {
     const resourceTree: ResourceTreeEntity[] = []
 
     for (const [logicalId, resource] of Object.entries(template?.Resources ?? []) as [string, any][]) {
-        const resourceEntity: ResourceTreeEntity = {
-            Id: logicalId,
-            Type: resource.Type,
+        const resourceEntity = createResourceEntity(logicalId, resource, template)
+        resourceTree.push(resourceEntity)
+    }
+    return resourceTree
+}
+
+function createResourceEntity(logicalId: string, resource: any, template: any): ResourceTreeEntity {
+    const baseEntity: BaseResourceEntity = {
+        Id: logicalId,
+        Type: resource.Type,
+    }
+
+    // Create type-specific entities
+    if (resource.Type === CloudFormation.SERVERLESS_FUNCTION_TYPE) {
+        const functionEntity: FunctionResourceEntity = {
+            ...baseEntity,
             Runtime: resource.Properties?.Runtime ?? template?.Globals?.Function?.Runtime,
             Handler: resource.Properties?.Handler ?? template?.Globals?.Function?.Handler,
             Events: resource.Properties?.Events ? getEvents(resource.Properties.Events) : undefined,
             CodeUri: resource.Properties?.CodeUri ?? template?.Globals?.Function?.CodeUri,
             Environment: resource.Properties?.Environment ?? template?.Globals?.Function?.Environment,
+            CapacityProviderConfig:
+                resource.Properties?.CapacityProviderConfig ?? template?.Globals?.Function?.CapacityProviderConfig,
+            Architectures: resource.Properties?.Architectures?.[0] ?? template?.Globals?.Function?.Architectures?.[0],
         }
-        resourceTree.push(resourceEntity)
+        return functionEntity
     }
-    return resourceTree
+
+    if (resource.Type === CloudFormation.SERVERLESS_CAPACITY_PROVIDER_TYPE) {
+        const capacityProviderEntity: CapacityProviderResourceEntity = {
+            ...baseEntity,
+            Architectures:
+                resource.Properties?.InstanceRequirements?.Architectures?.[0] ??
+                template?.Globals?.CapacityProvider?.InstanceRequirements?.Architectures?.[0],
+        }
+        return capacityProviderEntity
+    }
+
+    // Generic resource for unsupported types
+    return baseEntity
 }
 
-function getEvents(events: Record<string, any>): ResourceTreeEntity[] {
-    const eventResources: ResourceTreeEntity[] = []
+function getEvents(events: Record<string, any>): EventEntity[] {
+    const eventResources: EventEntity[] = []
 
     for (const [eventsLogicalId, event] of Object.entries(events)) {
         const eventProperties = event.Properties
-        const eventResource: ResourceTreeEntity = {
+        const eventResource: EventEntity = {
             Id: eventsLogicalId,
             Type: event.Type,
-            Path: eventProperties.Path,
-            Method: eventProperties.Method,
+            Path: eventProperties?.Path,
+            Method: eventProperties?.Method,
         }
         eventResources.push(eventResource)
     }

packages/core/src/awsService/appBuilder/utils.ts

@@ -8,6 +8,7 @@ import { TreeNode } from '../../shared/treeview/resourceTreeDataProvider'
 import * as nls from 'vscode-nls'
 import { ResourceNode } from './explorer/nodes/resourceNode'
 import type { SamAppLocation } from './explorer/samProject'
+import { isFunctionResource } from './explorer/samProject'
 import { ToolkitError } from '../../shared/errors'
 import globals from '../../shared/extensionGlobals'
 import { OpenTemplateParams, OpenTemplateWizard } from './explorer/openTemplate'
@@ -552,27 +553,33 @@ export async function runOpenTemplate(arg?: TreeNode) {
  */
 export async function runOpenHandler(arg: ResourceNode): Promise<void> {
     const folderUri = path.dirname(arg.resource.location.fsPath)
-    if (!arg.resource.resource.CodeUri) {
+    const resource = arg.resource.resource
+
+    if (!isFunctionResource(resource)) {
+        throw new ToolkitError('Resource is not a Lambda function', { code: 'NotAFunction' })
+    }
+
+    if (!resource.CodeUri) {
         throw new ToolkitError('No CodeUri provided in template, cannot open handler', { code: 'NoCodeUriProvided' })
     }
 
-    if (!arg.resource.resource.Handler) {
+    if (!resource.Handler) {
         throw new ToolkitError('No Handler provided in template, cannot open handler', { code: 'NoHandlerProvided' })
     }
 
-    if (!arg.resource.resource.Runtime) {
+    if (!resource.Runtime) {
         throw new ToolkitError('No Runtime provided in template, cannot open handler', { code: 'NoRuntimeProvided' })
     }
 
     const handlerFile = await getLambdaHandlerFile(
         vscode.Uri.file(folderUri),
-        arg.resource.resource.CodeUri,
-        arg.resource.resource.Handler,
-        arg.resource.resource.Runtime
+        resource.CodeUri,
+        resource.Handler,
+        resource.Runtime as Runtime
     )
     if (!handlerFile) {
         throw new ToolkitError(
-            `No handler file found with name "${arg.resource.resource.Handler}". Ensure the file exists in the expected location."`,
+            `No handler file found with name "${resource.Handler}". Ensure the file exists in the expected location."`,
             {
                 code: 'NoHandlerFound',
             }

packages/core/src/lambda/activation.ts

@@ -233,7 +233,6 @@ export async function activate(context: ExtContext): Promise<void> {
         Commands.register('aws.launchDebugConfigForm', async (node: ResourceNode) =>
             registerSamDebugInvokeVueCommand(context.extensionContext, { resource: node })
         ),
-
         Commands.register('aws.appBuilder.tailLogs', async (node: LambdaFunctionNode | TreeNode) => {
             let functionConfiguration: FunctionConfiguration
             try {

packages/core/src/lambda/explorer/lambdaCapacityProviderNode.ts

@@ -0,0 +1,46 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode'
+import { getIcon } from '../../shared/icons'
+
+import { AWSResourceNode } from '../../shared/treeview/nodes/awsResourceNode'
+import { AWSTreeNodeBase } from '../../shared/treeview/nodes/awsTreeNodeBase'
+import globals from '../../shared/extensionGlobals'
+import { ToolkitError } from '../../shared/errors'
+
+export const contextValueLambdaCapacityProvider = 'awsCapacityProviderNode'
+
+export class LambdaCapacityProviderNode extends AWSTreeNodeBase implements AWSResourceNode {
+    public constructor(
+        public override readonly regionCode: string,
+        public readonly deployedResource: any,
+        public override readonly contextValue?: string
+    ) {
+        super(
+            deployedResource.LogicalResourceId,
+            contextValue === contextValueLambdaCapacityProvider
+                ? vscode.TreeItemCollapsibleState.Collapsed
+                : vscode.TreeItemCollapsibleState.None
+        )
+        this.iconPath = getIcon('vscode-gear')
+        this.contextValue = contextValueLambdaCapacityProvider
+    }
+
+    public get name() {
+        return this.deployedResource.LogicalResourceId
+    }
+    private get accountId(): string {
+        const accountId = globals.awsContext.getCredentialAccountId()
+        if (!accountId) {
+            throw new ToolkitError('Aws account ID not found')
+        }
+        return accountId
+    }
+
+    public get arn() {
+        return `arn:aws:lambda:${this.regionCode}:${this.accountId}:capacity-provider:${this.deployedResource.PhysicalResourceId}`
+    }
+}

packages/core/src/lambda/vue/configEditor/samInvokeBackend.ts

@@ -28,6 +28,7 @@ import * as CloudFormation from '../../../shared/cloudformation/cloudformation'
 import { openLaunchJsonFile } from '../../../shared/sam/debugger/commands/addSamDebugConfiguration'
 import { getSampleLambdaPayloads } from '../../utils'
 import { samLambdaCreatableRuntimes } from '../../models/samLambdaRuntime'
+import { isFunctionResource } from '../../../awsService/appBuilder/explorer/samProject'
 import globals from '../../../shared/extensionGlobals'
 import { VueWebview } from '../../../webviews/main'
 import { Commands } from '../../../shared/vscode/commands2'
@@ -441,6 +442,10 @@ export async function registerSamDebugInvokeVueCommand(
         (config) => (config.invokeTarget as TemplateTargetProperties).logicalId === resource.resource.Id
     )
 
+    if (!isFunctionResource(resource.resource)) {
+        throw new ToolkitError('Resource is not a Lambda function')
+    }
+
     const webview = new WebviewPanel(context, launchConfig, {
         logicalId: resource.resource.Id ?? '',
         region: resource.region ?? '',

packages/core/src/shared/cloudformation/cloudformation.ts

@@ -19,6 +19,8 @@ export const LAMBDA_FUNCTION_TYPE = 'AWS::Lambda::Function' // eslint-disable-li
 export const LAMBDA_LAYER_TYPE = 'AWS::Lambda::LayerVersion' // eslint-disable-line @typescript-eslint/naming-convention
 export const LAMBDA_URL_TYPE = 'AWS::Lambda::Url' // eslint-disable-line @typescript-eslint/naming-convention
 export const SERVERLESS_LAYER_TYPE = 'AWS::Serverless::LayerVersion' // eslint-disable-line @typescript-eslint/naming-convention
+export const SERVERLESS_CAPACITY_PROVIDER_TYPE = 'AWS::Serverless::CapacityProvider' // eslint-disable-line @typescript-eslint/naming-convention
+export const LAMBDA_CAPACITY_PROVIDER_TYPE = 'AWS::Lambda::CapacityProvider' // eslint-disable-line @typescript-eslint/naming-convention
 
 export const serverlessTableType = 'AWS::Serverless::SimpleTable'
 export const s3BucketType = 'AWS::S3::Bucket'