add support for changeset pagination

Author: kddejong

src/handlers/StackHandler.ts

@@ -266,14 +266,15 @@ export function listChangeSetsHandler(
 ): RequestHandler<ListChangeSetParams, ListChangeSetResult, void> {
     return async (params: ListChangeSetParams): Promise<ListChangeSetResult> => {
         try {
-            const changeSets = await components.cfnService.listChangeSets(params.stackName);
+            const result = await components.cfnService.listChangeSets(params.stackName, params.nextToken);
             return {
-                changeSets: changeSets.map((cs) => ({
+                changeSets: result.changeSets.map((cs) => ({
                     changeSetName: cs.ChangeSetName ?? '',
                     status: cs.Status ?? '',
                     creationTime: cs.CreationTime?.toISOString(),
                     description: cs.Description,
                 })),
+                nextToken: result.nextToken,
             };
         } catch {
             return { changeSets: [] };

src/services/CfnService.ts

@@ -334,14 +334,25 @@ export class CfnService {
         return await this.withClient((client) => client.send(new ValidateTemplateCommand(params)));
     }
 
-    public async listChangeSets(stackName: string): Promise<ChangeSetSummary[]> {
+    public async listChangeSets(
+        stackName: string,
+        nextToken?: string,
+    ): Promise<{ changeSets: ChangeSetSummary[]; nextToken?: string }> {
         try {
             return await this.withClient(async (client) => {
-                const response = await client.send(new ListChangeSetsCommand({ StackName: stackName }));
-                return response.Summaries ?? [];
+                const response = await client.send(
+                    new ListChangeSetsCommand({
+                        StackName: stackName,
+                        NextToken: nextToken,
+                    }),
+                );
+                return {
+                    changeSets: response.Summaries ?? [],
+                    nextToken: response.NextToken,
+                };
             });
         } catch {
-            return [];
+            return { changeSets: [] };
         }
     }
 }

src/stacks/StackRequestType.ts

@@ -30,6 +30,7 @@ export const GetStackTemplateRequest = new RequestType<GetStackTemplateParams, G
 
 export type ListChangeSetParams = {
     stackName: string;
+    nextToken?: string;
 };
 
 export type ListChangeSetResult = {
@@ -39,6 +40,7 @@ export type ListChangeSetResult = {
         creationTime?: string;
         description?: string;
     }>;
+    nextToken?: string;
 };
 
 export const ListChangeSetRequest = new RequestType<ListChangeSetParams, ListChangeSetResult, void>(

tst/unit/handlers/ListChangeSetsHandler.test.ts

@@ -21,27 +21,31 @@ describe('listChangeSetsHandler', () => {
         expect(result).toEqual({ changeSets: [] });
     });
 
-    it('should transform change sets correctly', async () => {
-        const mockChangeSets = [
-            {
-                ChangeSetName: 'changeset-1',
-                Status: 'CREATE_COMPLETE',
-                CreationTime: new Date('2023-01-01T00:00:00Z'),
-                Description: 'Test changeset',
-            },
-        ];
+    it('should transform change sets correctly with pagination', async () => {
+        const mockResult = {
+            changeSets: [
+                {
+                    ChangeSetName: 'changeset-1',
+                    Status: 'CREATE_COMPLETE',
+                    CreationTime: new Date('2023-01-01T00:00:00Z'),
+                    Description: 'Test changeset',
+                },
+            ],
+            nextToken: 'next-page-token',
+        };
 
         const mockCfnService = {
-            listChangeSets: vi.fn().mockResolvedValue(mockChangeSets),
+            listChangeSets: vi.fn().mockResolvedValue(mockResult),
         };
 
         const mockComponents = {
             cfnService: mockCfnService,
         } as unknown as ServerComponents;
 
         const handler = listChangeSetsHandler(mockComponents);
-        const result = await handler({ stackName: 'test-stack' }, mockToken);
+        const result = await handler({ stackName: 'test-stack', nextToken: 'some-token' }, mockToken);
 
+        expect(mockCfnService.listChangeSets).toHaveBeenCalledWith('test-stack', 'some-token');
         expect(result).toEqual({
             changeSets: [
                 {
@@ -51,6 +55,7 @@ describe('listChangeSetsHandler', () => {
                     description: 'Test changeset',
                 },
             ],
+            nextToken: 'next-page-token',
         });
     });
 });