make DescribeEvents passthrough API and remove caching

Zee2413 · Zee2413 · commit 1df3bdf4d6d3 · 2025-12-12T11:44:05.000-05:00
diff --git a/src/handlers/StackHandler.ts b/src/handlers/StackHandler.ts
@@ -1,3 +1,4 @@
+import { OperationEvent } from '@aws-sdk/client-cloudformation';
 import { ErrorCodes, RequestHandler, ResponseError } from 'vscode-languageserver';
 import { ArtifactExporter } from '../artifactexporter/ArtifactExporter';
 import { TopLevelSection } from '../context/ContextType';
@@ -455,16 +456,32 @@ export function describeEventsHandler(
         try {
             const params = parseWithPrettyError(parseDescribeEventsParams, rawParams);
 
-            if (!params.stackName) {
-                throw new Error('stackName is required for describeEventsHandler');
-            }
+            const response = await components.cfnService.describeEvents({
+                StackName: params.stackName,
+                ChangeSetName: params.changeSetName,
+                OperationId: params.operationId,
+                FailedEventsOnly: params.failedEventsOnly,
+                NextToken: params.nextToken,
+            });
 
-            if (params.refresh) {
-                const result = await components.stackOperationEventManager.refresh(params.stackName);
-                return { operations: result.operations, nextToken: undefined, gapDetected: result.gapDetected };
+            const operations = new Map<string, OperationEvent[]>();
+            for (const event of response.OperationEvents ?? []) {
+                const opId = event.OperationId ?? 'unknown';
+                const existing = operations.get(opId);
+                if (existing) {
+                    existing.push(event);
+                } else {
+                    operations.set(opId, [event]);
+                }
             }
 
-            return await components.stackOperationEventManager.fetchEvents(params.stackName, params.nextToken);
+            return {
+                operations: [...operations.entries()].map(([operationId, events]) => ({
+                    operationId,
+                    events: events.sort((a, b) => (b.Timestamp?.getTime() ?? 0) - (a.Timestamp?.getTime() ?? 0)),
+                })),
+                nextToken: response.NextToken,
+            };
         } catch (error) {
             handleLspError(error, 'Failed to describe events');
         }
diff --git a/src/server/CfnLspProviders.ts b/src/server/CfnLspProviders.ts
@@ -25,7 +25,6 @@ import { StackActionWorkflow } from '../stacks/actions/StackActionWorkflowType';
 import { ValidationWorkflow } from '../stacks/actions/ValidationWorkflow';
 import { StackEventManager } from '../stacks/StackEventManager';
 import { StackManager } from '../stacks/StackManager';
-import { StackOperationEventManager } from '../stacks/StackOperationEventManager';
 import { Closeable, closeSafely } from '../utils/Closeable';
 import { Configurable, Configurables } from '../utils/Configurable';
 import { CfnExternal } from './CfnExternal';
@@ -39,7 +38,6 @@ export class CfnLspProviders implements Configurables, Closeable {
     readonly changeSetDeletionWorkflowService: StackActionWorkflow<DeleteChangeSetParams, DescribeDeletionStatusResult>;
     readonly stackManager: StackManager;
     readonly stackEventManager: StackEventManager;
-    readonly stackOperationEventManager: StackOperationEventManager;
     readonly resourceStateManager: ResourceStateManager;
     readonly resourceStateImporter: ResourceStateImporter;
     readonly relationshipSchemaService: RelationshipSchemaService;
@@ -62,8 +60,6 @@ export class CfnLspProviders implements Configurables, Closeable {
             overrides.stackManagementInfoProvider ?? new StackManagementInfoProvider(external.cfnService);
         this.stackManager = overrides.stackManager ?? new StackManager(external.cfnService);
         this.stackEventManager = overrides.stackEventManager ?? new StackEventManager(external.cfnService);
-        this.stackOperationEventManager =
-            overrides.stackOperationEventManager ?? new StackOperationEventManager(external.cfnService);
         this.validationWorkflowService =
             overrides.validationWorkflowService ?? ValidationWorkflow.create(core, external, core.validationManager);
         this.deploymentWorkflowService =
diff --git a/src/stacks/StackOperationEventManager.ts b/src/stacks/StackOperationEventManager.ts
diff --git a/src/stacks/StackRequestType.ts b/src/stacks/StackRequestType.ts
@@ -125,7 +125,6 @@ export type DescribeEventsParams = {
     operationId?: string;
     failedEventsOnly?: boolean;
     nextToken?: string;
-    refresh?: boolean;
 };
 
 export type StackOperationGroup = {
@@ -136,7 +135,6 @@ export type StackOperationGroup = {
 export type DescribeEventsResult = {
     operations: StackOperationGroup[];
     nextToken?: string;
-    gapDetected?: boolean;
 };
 
 export const DescribeEventsRequest = new RequestType<DescribeEventsParams, DescribeEventsResult, void>(
diff --git a/src/stacks/actions/StackActionParser.ts b/src/stacks/actions/StackActionParser.ts
@@ -108,7 +108,6 @@ const DescribeEventsParamsSchema = z
         operationId: z.string().optional(),
         failedEventsOnly: z.boolean().optional(),
         nextToken: z.string().optional(),
-        refresh: z.boolean().optional(),
     })
     .refine((data) => data.stackName ?? data.changeSetName ?? data.operationId, {
         message: 'At least one of stackName, changeSetName, or operationId must be provided',
diff --git a/tst/unit/handlers/StackHandler.test.ts b/tst/unit/handlers/StackHandler.test.ts
@@ -52,7 +52,6 @@ import {
     DescribeStackResult,
     DescribeChangeSetParams,
     DescribeChangeSetResult,
-    DescribeEventsParams,
     DescribeEventsResult,
 } from '../../../src/stacks/StackRequestType';
 import {
@@ -928,83 +927,53 @@ describe('StackActionHandler', () => {
     });
 
     describe('describeEventsHandler', () => {
-        it('should fetch events for stack', async () => {
-            mockComponents.stackOperationEventManager.fetchEvents.resolves({
-                operations: [{ operationId: 'op1', events: [] }],
-                nextToken: undefined,
+        it('should fetch and group events by operation ID', async () => {
+            mockComponents.cfnService.describeEvents.resolves({
+                OperationEvents: [
+                    { EventId: '1', OperationId: 'op1', Timestamp: new Date('2024-01-01') },
+                    { EventId: '2', OperationId: 'op1', Timestamp: new Date('2024-01-02') },
+                    { EventId: '3', OperationId: 'op2', Timestamp: new Date('2024-01-03') },
+                ],
+                $metadata: {},
             });
 
             const handler = describeEventsHandler(mockComponents);
             const result = (await handler({ stackName: 'test-stack' }, CancellationToken.None)) as DescribeEventsResult;
 
-            expect(result.operations).toHaveLength(1);
-            expect(result.nextToken).toBeUndefined();
-            expect(mockComponents.stackOperationEventManager.fetchEvents.calledWith('test-stack', undefined)).toBe(
-                true,
-            );
+            expect(result.operations).toHaveLength(2);
+            expect(result.operations[0].operationId).toBe('op1');
+            expect(result.operations[0].events).toHaveLength(2);
         });
 
-        it('should refresh events when refresh flag is true', async () => {
-            mockComponents.stackOperationEventManager.refresh.resolves({
-                operations: [{ operationId: 'op1', events: [] }],
-                gapDetected: false,
-            });
+        it('should pass all parameters to API', async () => {
+            mockComponents.cfnService.describeEvents.resolves({ OperationEvents: [], $metadata: {} });
 
             const handler = describeEventsHandler(mockComponents);
-            const result = (await handler(
-                { stackName: 'test-stack', refresh: true },
-                CancellationToken.None,
-            )) as DescribeEventsResult;
-
-            expect(result.operations).toHaveLength(1);
-            expect(result.gapDetected).toBe(false);
-            expect(mockComponents.stackOperationEventManager.refresh.calledWith('test-stack')).toBe(true);
-        });
-
-        it('should pass nextToken for pagination', async () => {
-            mockComponents.stackOperationEventManager.fetchEvents.resolves({
-                operations: [],
-                nextToken: 'token123',
-            });
-
-            const handler = describeEventsHandler(mockComponents);
-            const result = (await handler(
-                { stackName: 'test-stack', nextToken: 'token123' },
+            await handler(
+                {
+                    stackName: 'test-stack',
+                    changeSetName: 'cs',
+                    operationId: 'op',
+                    failedEventsOnly: true,
+                    nextToken: 'token',
+                },
                 CancellationToken.None,
-            )) as DescribeEventsResult;
-
-            expect(result.nextToken).toBe('token123');
-            expect(mockComponents.stackOperationEventManager.fetchEvents.calledWith('test-stack', 'token123')).toBe(
-                true,
             );
-        });
-
-        it('should return gapDetected from refresh', async () => {
-            mockComponents.stackOperationEventManager.refresh.resolves({
-                operations: [],
-                gapDetected: true,
-            });
-
-            const handler = describeEventsHandler(mockComponents);
-            const result = (await handler(
-                { stackName: 'test-stack', refresh: true },
-                CancellationToken.None,
-            )) as DescribeEventsResult;
-
-            expect(result.gapDetected).toBe(true);
-        });
-
-        it('should throw error when stackName is missing with refresh', async () => {
-            const handler = describeEventsHandler(mockComponents);
 
-            await expect(
-                handler({ operationId: 'op-123', refresh: true } as DescribeEventsParams, CancellationToken.None),
-            ).rejects.toThrow();
+            expect(
+                mockComponents.cfnService.describeEvents.calledWith({
+                    StackName: 'test-stack',
+                    ChangeSetName: 'cs',
+                    OperationId: 'op',
+                    FailedEventsOnly: true,
+                    NextToken: 'token',
+                }),
+            ).toBe(true);
         });
 
         it('should handle service errors', async () => {
             const serviceError = new Error('Service error');
-            mockComponents.stackOperationEventManager.fetchEvents.rejects(serviceError);
+            mockComponents.cfnService.describeEvents.rejects(serviceError);
 
             const handler = describeEventsHandler(mockComponents);
 
diff --git a/tst/unit/stackActions/StackActionParser.test.ts b/tst/unit/stackActions/StackActionParser.test.ts
@@ -284,15 +284,13 @@ describe('StackActionParser', () => {
                 operationId: 'op-123',
                 failedEventsOnly: true,
                 nextToken: 'token123',
-                refresh: true,
             });
 
             expect(result.stackName).toBe('test-stack');
             expect(result.changeSetName).toBe('test-changeset');
             expect(result.operationId).toBe('op-123');
             expect(result.failedEventsOnly).toBe(true);
             expect(result.nextToken).toBe('token123');
-            expect(result.refresh).toBe(true);
         });
 
         it('should throw error when no identifier provided', () => {
@@ -310,21 +308,18 @@ describe('StackActionParser', () => {
 
         it('should throw error for invalid types', () => {
             expect(() => parseDescribeEventsParams({ stackName: 'test', failedEventsOnly: 'true' as any })).toThrow();
-            expect(() => parseDescribeEventsParams({ stackName: 'test', refresh: 'yes' as any })).toThrow();
         });
 
         it('should accept undefined optional parameters', () => {
             const result = parseDescribeEventsParams({
                 stackName: 'test-stack',
                 failedEventsOnly: undefined,
                 nextToken: undefined,
-                refresh: undefined,
             });
 
             expect(result.stackName).toBe('test-stack');
             expect(result.failedEventsOnly).toBeUndefined();
             expect(result.nextToken).toBeUndefined();
-            expect(result.refresh).toBeUndefined();
         });
     });
 });
diff --git a/tst/unit/stacks/StackOperationEventManager.test.ts b/tst/unit/stacks/StackOperationEventManager.test.ts
diff --git a/tst/utils/MockServerComponents.ts b/tst/utils/MockServerComponents.ts
