Updated to pass in nextToken and maxItem for ListStackResources

Author: rongyamazon

src/handlers/StackHandler.ts

@@ -9,6 +9,7 @@ import { analyzeCapabilities } from '../stacks/actions/CapabilityAnalyzer';
 import {
     parseCreateDeploymentParams,
     parseDeleteChangeSetParams,
+    parseListStackResourcesParams,
     parseStackActionParams,
     parseTemplateUriParams,
 } from '../stacks/actions/StackActionParser';
@@ -335,9 +336,14 @@ export function listChangeSetsHandler(
 export function listStackResourcesHandler(
     components: ServerComponents,
 ): RequestHandler<ListStackResourcesParams, ListStackResourcesResult, void> {
-    return async (params: ListStackResourcesParams): Promise<ListStackResourcesResult> => {
+    return async (rawParams): Promise<ListStackResourcesResult> => {
         try {
-            const response = await components.cfnService.listStackResources({ StackName: params.stackName });
+            const params = parseWithPrettyError(parseListStackResourcesParams, rawParams);
+            const response = await components.cfnService.listStackResources({
+                StackName: params.stackName,
+                NextToken: params.nextToken,
+                MaxItems: params.maxItems,
+            });
             return { resources: response.StackResourceSummaries ?? [] };
         } catch (error) {
             log.error({ error: extractErrorMessage(error) }, 'Error listing stack resources');

src/server/CfnServer.ts

@@ -28,11 +28,8 @@ import {
 } from '../handlers/ResourceHandler';
 import {
     listStacksHandler,
-<<<<<<< HEAD
     listChangeSetsHandler,
-=======
     listStackResourcesHandler,
->>>>>>> 29939f4 (Added new command for listStackResources)
     createValidationHandler,
     createDeploymentHandler,
     getValidationStatusHandler,

src/services/CfnService.ts

@@ -42,7 +42,6 @@ import {
     TypeSummary,
     DescribeTypeOutput,
     StackSummary,
-    StackResourceSummary,
     StackStatus,
     waitUntilChangeSetCreateComplete,
     waitUntilStackUpdateComplete,
@@ -197,33 +196,12 @@ export class CfnService {
         return await this.withClient((client) => client.send(new DescribeStackResourceCommand(params)));
     }
 
-    public async listStackResources(params: { StackName: string }): Promise<ListStackResourcesCommandOutput> {
-        return await this.withClient(async (client) => {
-            const allResources: StackResourceSummary[] = [];
-            let nextToken: string | undefined;
-            let lastResponse: ListStackResourcesCommandOutput;
-
-            do {
-                lastResponse = await client.send(
-                    new ListStackResourcesCommand({
-                        StackName: params.StackName,
-                        NextToken: nextToken,
-                    }),
-                );
-
-                if (lastResponse.StackResourceSummaries) {
-                    allResources.push(...lastResponse.StackResourceSummaries);
-                }
-
-                nextToken = lastResponse.NextToken;
-            } while (nextToken);
-
-            return {
-                ...lastResponse,
-                StackResourceSummaries: allResources,
-                NextToken: undefined,
-            };
-        });
+    public async listStackResources(params: {
+        StackName: string;
+        NextToken?: string;
+        MaxItems?: number;
+    }): Promise<ListStackResourcesCommandOutput> {
+        return await this.withClient((client) => client.send(new ListStackResourcesCommand(params)));
     }
 
     public async describeStackResourceDrifts(params: {

src/stacks/StackRequestType.ts

@@ -49,6 +49,8 @@ export const ListChangeSetRequest = new RequestType<ListChangeSetParams, ListCha
 
 export type ListStackResourcesParams = {
     stackName: string;
+    nextToken?: string;
+    maxItems?: number;
 };
 
 export type ListStackResourcesResult = {

src/stacks/actions/StackActionParser.ts

@@ -1,5 +1,6 @@
 import { Capability } from '@aws-sdk/client-cloudformation';
 import { z } from 'zod';
+import { ListStackResourcesParams } from '../StackRequestType';
 import {
     CreateDeploymentParams,
     CreateValidationParams,
@@ -50,6 +51,12 @@ const DeleteChangeSetParamsSchema = z.object({
 
 const TemplateUriSchema = z.string().min(1);
 
+const ListStackResourcesParamsSchema = z.object({
+    stackName: z.string().min(1),
+    nextToken: z.string().optional(),
+    maxItems: z.number().optional(),
+});
+
 export function parseStackActionParams(input: unknown): CreateValidationParams {
     return StackActionParamsSchema.parse(input);
 }
@@ -65,3 +72,7 @@ export function parseDeleteChangeSetParams(input: unknown): DeleteChangeSetParam
 export function parseTemplateUriParams(input: unknown): TemplateUri {
     return TemplateUriSchema.parse(input);
 }
+
+export function parseListStackResourcesParams(input: unknown): ListStackResourcesParams {
+    return ListStackResourcesParamsSchema.parse(input);
+}

tst/unit/handlers/StackHandler.test.ts

@@ -32,12 +32,7 @@ import {
     StackActionPhase,
     StackActionState,
 } from '../../../src/stacks/actions/StackActionRequestType';
-import {
-    ListStacksParams,
-    ListStacksResult,
-    ListStackResourcesParams,
-    ListStackResourcesResult,
-} from '../../../src/stacks/StackRequestType';
+import { ListStacksParams, ListStacksResult, ListStackResourcesResult } from '../../../src/stacks/StackRequestType';
 import {
     createMockComponents,
     createMockSyntaxTreeManager,
@@ -59,6 +54,7 @@ vi.mock('../../../src/stacks/actions/StackActionParser', () => ({
     parseTemplateUriParams: vi.fn((input) => input),
     parseCreateDeploymentParams: vi.fn((input) => input),
     parseDeleteChangeSetParams: vi.fn((input) => input),
+    parseListStackResourcesParams: vi.fn((input) => input),
 }));
 
 vi.mock('../../../src/utils/ZodErrorWrapper', () => ({
@@ -475,18 +471,24 @@ describe('StackActionHandler', () => {
             });
 
             const handler = listStackResourcesHandler(mockComponents);
-            const params: ListStackResourcesParams = { stackName: 'test-stack' };
+            const params = { stackName: 'test-stack', nextToken: 'token123', maxItems: 10 };
             const result = (await handler(params, {} as any)) as ListStackResourcesResult;
 
             expect(result.resources).toEqual(mockResources);
-            expect(mockComponents.cfnService.listStackResources.calledWith({ StackName: 'test-stack' })).toBe(true);
+            expect(
+                mockComponents.cfnService.listStackResources.calledWith({
+                    StackName: 'test-stack',
+                    NextToken: 'token123',
+                    MaxItems: 10,
+                }),
+            ).toBe(true);
         });
 
         it('should return empty array on error', async () => {
             mockComponents.cfnService.listStackResources.rejects(new Error('API Error'));
 
             const handler = listStackResourcesHandler(mockComponents);
-            const params: ListStackResourcesParams = { stackName: 'test-stack' };
+            const params = { stackName: 'test-stack' };
             const result = (await handler(params, {} as any)) as ListStackResourcesResult;
 
             expect(result.resources).toEqual([]);
@@ -496,7 +498,7 @@ describe('StackActionHandler', () => {
             mockComponents.cfnService.listStackResources.resolves({ StackResourceSummaries: undefined, $metadata: {} });
 
             const handler = listStackResourcesHandler(mockComponents);
-            const params: ListStackResourcesParams = { stackName: 'test-stack' };
+            const params = { stackName: 'test-stack' };
             const result = (await handler(params, {} as any)) as ListStackResourcesResult;
 
             expect(result.resources).toEqual([]);

tst/unit/services/CfnService.test.ts

@@ -493,73 +493,13 @@ describe('CfnService', () => {
 
             const result = await service.listStackResources({
                 StackName: TEST_CONSTANTS.STACK_NAME,
+                NextToken: 'token123',
+                MaxItems: 10,
             });
 
             expect(result).toEqual(MOCK_RESPONSES.LIST_STACK_RESOURCES);
         });
 
-        it('should handle pagination and collect all resources', async () => {
-            const page1 = {
-                ...MOCK_RESPONSES.LIST_STACK_RESOURCES,
-                StackResourceSummaries: [
-                    {
-                        LogicalResourceId: 'Resource1',
-                        ResourceType: 'AWS::S3::Bucket',
-                        LastUpdatedTimestamp: new Date(),
-                        ResourceStatus: 'CREATE_COMPLETE' as const,
-                    },
-                    {
-                        LogicalResourceId: 'Resource2',
-                        ResourceType: 'AWS::S3::Bucket',
-                        LastUpdatedTimestamp: new Date(),
-                        ResourceStatus: 'CREATE_COMPLETE' as const,
-                    },
-                ],
-                NextToken: 'token1',
-            };
-            const page2 = {
-                ...MOCK_RESPONSES.LIST_STACK_RESOURCES,
-                StackResourceSummaries: [
-                    {
-                        LogicalResourceId: 'Resource3',
-                        ResourceType: 'AWS::S3::Bucket',
-                        LastUpdatedTimestamp: new Date(),
-                        ResourceStatus: 'CREATE_COMPLETE' as const,
-                    },
-                ],
-                NextToken: undefined,
-            };
-
-            cloudFormationMock.on(ListStackResourcesCommand).resolvesOnce(page1).resolvesOnce(page2);
-
-            const result = await service.listStackResources({
-                StackName: TEST_CONSTANTS.STACK_NAME,
-            });
-
-            expect(result.StackResourceSummaries).toHaveLength(3);
-            expect(result.StackResourceSummaries).toEqual([
-                {
-                    LogicalResourceId: 'Resource1',
-                    ResourceType: 'AWS::S3::Bucket',
-                    LastUpdatedTimestamp: expect.any(Date),
-                    ResourceStatus: 'CREATE_COMPLETE' as const,
-                },
-                {
-                    LogicalResourceId: 'Resource2',
-                    ResourceType: 'AWS::S3::Bucket',
-                    LastUpdatedTimestamp: expect.any(Date),
-                    ResourceStatus: 'CREATE_COMPLETE' as const,
-                },
-                {
-                    LogicalResourceId: 'Resource3',
-                    ResourceType: 'AWS::S3::Bucket',
-                    LastUpdatedTimestamp: expect.any(Date),
-                    ResourceStatus: 'CREATE_COMPLETE' as const,
-                },
-            ]);
-            expect(result.NextToken).toBeUndefined();
-        });
-
         it('should throw StackNotFoundException when API call fails', async () => {
             const error = createStackNotFoundError();
             cloudFormationMock.on(ListStackResourcesCommand).rejects(error);