Refactor DescribeEvents to be paginated and move page exhaustion loop… (#356)

Refactor DescribeEvents to be paginated and move page exhaustion loop to business layer

Author: Zee2413

src/services/CfnService.ts

@@ -201,35 +201,22 @@ export class CfnService {
 
     @Count({ name: 'describeEvents' })
     public async describeEvents(params: {
-        ChangeSetName: string;
-        StackName: string;
+        StackName?: string;
+        ChangeSetName?: string;
+        OperationId?: string;
+        FailedEventsOnly?: boolean;
+        NextToken?: string;
     }): Promise<DescribeEventsCommandOutput> {
         return await this.withClient(async (client) => {
-            let nextToken: string | undefined;
-            let result: DescribeEventsCommandOutput | undefined;
-            const operationEvents: DescribeEventsCommandOutput['OperationEvents'] = [];
-
-            do {
-                const response = (await client.send(
-                    new DescribeEventsCommand({
-                        ...params,
-                        NextToken: nextToken,
-                    }),
-                )) as unknown as DescribeEventsCommandOutput;
-
-                if (result) {
-                    operationEvents.push(...(response.OperationEvents ?? []));
-                } else {
-                    result = response;
-                    operationEvents.push(...(result.OperationEvents ?? []));
-                }
-
-                nextToken = response.NextToken;
-            } while (nextToken);
-
-            result.OperationEvents = operationEvents;
-            result.NextToken = undefined;
-            return result;
+            return (await client.send(
+                new DescribeEventsCommand({
+                    StackName: params.StackName,
+                    ChangeSetName: params.ChangeSetName,
+                    OperationId: params.OperationId,
+                    Filters: params.FailedEventsOnly ? { FailedEvents: true } : undefined,
+                    NextToken: params.NextToken,
+                }),
+            )) as unknown as DescribeEventsCommandOutput;
         });
     }
 

src/stacks/actions/StackActionOperations.ts

@@ -1,11 +1,11 @@
 import {
     Change,
     ChangeSetType,
-    DescribeEventsCommandOutput,
     StackStatus,
     OnStackFailure,
     EventType,
     HookFailureMode,
+    OperationEvent,
 } from '@aws-sdk/client-cloudformation';
 import { WaiterState } from '@smithy/util-waiter';
 import { dump } from 'js-yaml';
@@ -345,21 +345,17 @@ export function processWorkflowUpdates(
     return existingWorkflow;
 }
 
-export function parseValidationEvents(events: DescribeEventsCommandOutput, validationName: string): ValidationDetail[] {
-    const validEvents = events.OperationEvents?.filter((event) => event.EventType === EventType.VALIDATION_ERROR);
-
-    return (
-        validEvents?.map((event) => {
-            return {
-                Timestamp: event.Timestamp ? DateTime.fromISO(event.Timestamp.toISOString()) : undefined,
-                ValidationName: validationName,
-                LogicalId: event.LogicalResourceId,
-                Message: [event.ValidationName, event.ValidationStatusReason].filter(Boolean).join(': '),
-                Severity: event.ValidationFailureMode === HookFailureMode.FAIL ? 'ERROR' : 'INFO',
-                ResourcePropertyPath: event.ValidationPath,
-            };
-        }) ?? []
-    );
+export function parseValidationEvents(events: OperationEvent[], validationName: string): ValidationDetail[] {
+    const validEvents = events.filter((event) => event.EventType === EventType.VALIDATION_ERROR);
+
+    return validEvents.map((event) => ({
+        Timestamp: event.Timestamp ? DateTime.fromISO(event.Timestamp.toISOString()) : undefined,
+        ValidationName: validationName,
+        LogicalId: event.LogicalResourceId,
+        Message: [event.ValidationName, event.ValidationStatusReason].filter(Boolean).join(': '),
+        Severity: event.ValidationFailureMode === HookFailureMode.FAIL ? 'ERROR' : 'INFO',
+        ResourcePropertyPath: event.ValidationPath,
+    }));
 }
 
 export async function publishValidationDiagnostics(

src/stacks/actions/ValidationWorkflow.ts

@@ -1,4 +1,4 @@
-import { ChangeSetType, StackStatus } from '@aws-sdk/client-cloudformation';
+import { ChangeSetType, OperationEvent, StackStatus } from '@aws-sdk/client-cloudformation';
 import { AwsCredentials } from '../../auth/AwsCredentials';
 import { SyntaxTreeManager } from '../../context/syntaxtree/SyntaxTreeManager';
 import { DocumentManager } from '../../document/DocumentManager';
@@ -181,12 +181,8 @@ export class ValidationWorkflow implements StackActionWorkflow<CreateValidationP
             }
 
             if (this.featureFlag.isEnabled(this.awsCredentials.getIAM().region)) {
-                const describeEventsResponse = await this.cfnService.describeEvents({
-                    ChangeSetName: changeSetName,
-                    StackName: stackName,
-                });
-
-                const validationDetails = parseValidationEvents(describeEventsResponse, VALIDATION_NAME);
+                const allEvents = await this.fetchAllFailedEvents(changeSetName, stackName);
+                const validationDetails = parseValidationEvents(allEvents, VALIDATION_NAME);
 
                 existingWorkflow = processWorkflowUpdates(this.workflows, existingWorkflow, {
                     validationDetails: validationDetails,
@@ -232,6 +228,24 @@ export class ValidationWorkflow implements StackActionWorkflow<CreateValidationP
         }
     }
 
+    private async fetchAllFailedEvents(changeSetName: string, stackName: string): Promise<OperationEvent[]> {
+        const allEvents: OperationEvent[] = [];
+        let nextToken: string | undefined = undefined;
+
+        do {
+            const response = await this.cfnService.describeEvents({
+                ChangeSetName: changeSetName,
+                StackName: stackName,
+                FailedEventsOnly: true,
+                NextToken: nextToken,
+            });
+            allEvents.push(...(response.OperationEvents ?? []));
+            nextToken = response.NextToken;
+        } while (nextToken);
+
+        return allEvents;
+    }
+
     static create(core: CfnInfraCore, external: CfnExternal, validationManager: ValidationManager): ValidationWorkflow {
         return new ValidationWorkflow(
             external.cfnService,

tst/unit/services/CfnService.test.ts

@@ -357,7 +357,7 @@ describe('CfnService', () => {
             expect(result).toEqual(MOCK_RESPONSES.DESCRIBE_EVENTS);
         });
 
-        it('should fetch all pages when paginated', async () => {
+        it('should return single page with NextToken for pagination', async () => {
             const page1 = {
                 ...MOCK_RESPONSES.DESCRIBE_EVENTS,
                 OperationEvents: [
@@ -376,30 +376,16 @@ describe('CfnService', () => {
                 ],
                 NextToken: 'token1',
             };
-            const page2 = {
-                ...MOCK_RESPONSES.DESCRIBE_EVENTS,
-                OperationEvents: [
-                    {
-                        EventId: 'event-3',
-                        EventType: EventType.VALIDATION_ERROR,
-                        Timestamp: new Date('2023-01-01T00:02:00Z'),
-                        LogicalResourceId: 'Resource3',
-                    },
-                ],
-                NextToken: undefined,
-            };
 
-            cloudFormationMock.on(DescribeEventsCommand).resolvesOnce(page1).resolvesOnce(page2);
+            cloudFormationMock.on(DescribeEventsCommand).resolvesOnce(page1);
 
             const result = await service.describeEvents({
                 ChangeSetName: TEST_CONSTANTS.CHANGE_SET_NAME,
                 StackName: TEST_CONSTANTS.STACK_NAME,
             });
 
-            expect(result.OperationEvents).toHaveLength(3);
-            expect(result.OperationEvents?.[0].EventId).toBe('event-1');
-            expect(result.OperationEvents?.[2].EventId).toBe('event-3');
-            expect(result.NextToken).toBeUndefined();
+            expect(result.OperationEvents).toHaveLength(2);
+            expect(result.NextToken).toBe('token1');
         });
 
         it('should throw CloudFormationServiceException when API call fails', async () => {

tst/unit/stackActions/StackActionWorkflowOperations.test.ts

@@ -5,6 +5,7 @@ import {
     OnStackFailure,
     EventType,
     HookFailureMode,
+    OperationEvent,
 } from '@aws-sdk/client-cloudformation';
 import { WaiterState } from '@smithy/util-waiter';
 import { DateTime } from 'luxon';
@@ -432,36 +433,33 @@ describe('StackActionWorkflowOperations', () => {
 
     describe('parseValidationEvents', () => {
         it('should parse validation events correctly', () => {
-            const events = {
-                OperationEvents: [
-                    {
-                        EventId: 'event-1',
-                        EventType: EventType.VALIDATION_ERROR,
-                        Timestamp: new Date('2023-01-01T00:00:00Z'),
-                        LogicalResourceId: 'MyS3Bucket',
-                        ValidationPath: '/Resources/MyS3Bucket/Properties/BucketName',
-                        ValidationFailureMode: HookFailureMode.FAIL,
-                        ValidationName: 'S3BucketValidation',
-                        ValidationStatusReason: 'Bucket name must be globally unique',
-                    },
-                    {
-                        EventId: 'event-2',
-                        EventType: EventType.VALIDATION_ERROR,
-                        Timestamp: new Date('2023-01-01T00:01:00Z'),
-                        LogicalResourceId: 'MyLambda',
-                        ValidationFailureMode: HookFailureMode.WARN,
-                        ValidationName: 'LambdaValidation',
-                        ValidationStatusReason: 'Runtime version is deprecated',
-                    },
-                    {
-                        EventId: 'event-3',
-                        EventType: EventType.HOOK_INVOCATION_ERROR,
-                        Timestamp: new Date('2023-01-01T00:02:00Z'),
-                        LogicalResourceId: 'MyResource',
-                    },
-                ],
-                $metadata: {},
-            };
+            const events = [
+                {
+                    EventId: 'event-1',
+                    EventType: EventType.VALIDATION_ERROR,
+                    Timestamp: new Date('2023-01-01T00:00:00Z'),
+                    LogicalResourceId: 'MyS3Bucket',
+                    ValidationPath: '/Resources/MyS3Bucket/Properties/BucketName',
+                    ValidationFailureMode: HookFailureMode.FAIL,
+                    ValidationName: 'S3BucketValidation',
+                    ValidationStatusReason: 'Bucket name must be globally unique',
+                },
+                {
+                    EventId: 'event-2',
+                    EventType: EventType.VALIDATION_ERROR,
+                    Timestamp: new Date('2023-01-01T00:01:00Z'),
+                    LogicalResourceId: 'MyLambda',
+                    ValidationFailureMode: HookFailureMode.WARN,
+                    ValidationName: 'LambdaValidation',
+                    ValidationStatusReason: 'Runtime version is deprecated',
+                },
+                {
+                    EventId: 'event-3',
+                    EventType: EventType.HOOK_INVOCATION_ERROR,
+                    Timestamp: new Date('2023-01-01T00:02:00Z'),
+                    LogicalResourceId: 'MyResource',
+                },
+            ];
 
             const validationName = 'Enhanced Validation';
             const result = parseValidationEvents(events, validationName);
@@ -488,10 +486,7 @@ describe('StackActionWorkflowOperations', () => {
         });
 
         it('should handle empty events', () => {
-            const events = {
-                OperationEvents: [],
-                $metadata: {},
-            };
+            const events: OperationEvent[] = [];
 
             const result = parseValidationEvents(events, 'Test Validation');
 

tst/unit/stackActions/ValidationWorkflow.test.ts

@@ -1,4 +1,4 @@
-import { DescribeEventsCommandOutput, EventType, HookFailureMode } from '@aws-sdk/client-cloudformation';
+import { EventType, HookFailureMode } from '@aws-sdk/client-cloudformation';
 import { DateTime } from 'luxon';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { AwsCredentials } from '../../../src/auth/AwsCredentials';
@@ -458,15 +458,13 @@ describe('ValidationWorkflow', () => {
                 return updated;
             });
 
-            const mockEmptyDescribeEventsResponse: DescribeEventsCommandOutput = {
-                OperationEvents: [],
-                $metadata: {},
-            };
-
             mockFeatureFlag.isEnabled = vi.fn().mockReturnValue(true);
             mockAwsCredentials.getIAM = vi.fn().mockReturnValue({ region: 'us-east-1' });
 
-            mockCfnService.describeEvents = vi.fn().mockResolvedValue(mockEmptyDescribeEventsResponse);
+            mockCfnService.describeEvents = vi.fn().mockResolvedValue({
+                OperationEvents: [],
+                $metadata: {},
+            });
 
             (parseValidationEvents as any).mockReturnValue([
                 {
@@ -696,23 +694,23 @@ describe('ValidationWorkflow', () => {
                 changes: mockChanges,
             });
 
-            const mockDescribeEventsResponse: DescribeEventsCommandOutput = {
-                OperationEvents: [
-                    {
-                        EventId: 'event-1',
-                        EventType: EventType.VALIDATION_ERROR,
-                        Timestamp: new Date('2023-01-01T00:00:00Z'),
-                        LogicalResourceId: 'TestResource',
-                        ValidationPath: '/Resources/TestResource/Properties/BucketName',
-                        ValidationFailureMode: HookFailureMode.FAIL,
-                        ValidationName: 'TestValidation',
-                        ValidationStatusReason: 'Test error',
-                    },
-                ],
-                $metadata: {},
-            };
+            const mockOperationEvents = [
+                {
+                    EventId: 'event-1',
+                    EventType: EventType.VALIDATION_ERROR,
+                    Timestamp: new Date('2023-01-01T00:00:00Z'),
+                    LogicalResourceId: 'TestResource',
+                    ValidationPath: '/Resources/TestResource/Properties/BucketName',
+                    ValidationFailureMode: HookFailureMode.FAIL,
+                    ValidationName: 'TestValidation',
+                    ValidationStatusReason: 'Test error',
+                },
+            ];
 
-            mockCfnService.describeEvents = vi.fn().mockResolvedValueOnce(mockDescribeEventsResponse);
+            mockCfnService.describeEvents = vi.fn().mockResolvedValueOnce({
+                OperationEvents: mockOperationEvents,
+                $metadata: {},
+            });
 
             const mockParseValidationEventsResponse = [
                 {
@@ -736,12 +734,14 @@ describe('ValidationWorkflow', () => {
             expect(mockCfnService.describeEvents).toHaveBeenCalledWith({
                 ChangeSetName: 'changeset-123',
                 StackName: 'test-stack',
+                FailedEventsOnly: true,
+                NextToken: undefined,
             });
 
             const workflow = (validationWorkflow as any).workflows.get('test-id');
             expect(workflow.changes).toEqual(mockChanges);
 
-            expect(parseValidationEvents).toHaveBeenCalledWith(mockDescribeEventsResponse, VALIDATION_NAME);
+            expect(parseValidationEvents).toHaveBeenCalledWith(mockOperationEvents, VALIDATION_NAME);
 
             const mockValidation = mockValidationManager.get('test-stack');
             expect(mockValidation?.setValidationDetails).toHaveBeenCalledWith(mockParseValidationEventsResponse);