Add describe change set lsp request (#160)

chrisqm-dev · web-flow · commit 148bf7e8cfbc · 2025-10-30T13:41:50.000-04:00
diff --git a/src/handlers/StackHandler.ts b/src/handlers/StackHandler.ts
@@ -6,11 +6,13 @@ import { parseIdentifiable } from '../protocol/LspParser';
 import { Identifiable } from '../protocol/LspTypes';
 import { ServerComponents } from '../server/ServerComponents';
 import { analyzeCapabilities } from '../stacks/actions/CapabilityAnalyzer';
+import { mapChangesToStackChanges } from '../stacks/actions/StackActionOperations';
 import {
     parseCreateDeploymentParams,
     parseDeleteChangeSetParams,
     parseListStackResourcesParams,
     parseCreateValidationParams,
+    parseDescribeChangeSetParams,
     parseTemplateUriParams,
     parseGetStackEventsParams,
     parseClearStackEventsParams,
@@ -42,6 +44,8 @@ import {
     ClearStackEventsParams,
     GetStackOutputsParams,
     GetStackOutputsResult,
+    DescribeChangeSetParams,
+    DescribeChangeSetResult,
 } from '../stacks/StackRequestType';
 import { LoggerFactory } from '../telemetry/LoggerFactory';
 import { extractErrorMessage } from '../utils/Errors';
@@ -338,6 +342,29 @@ export function listStackResourcesHandler(
     };
 }
 
+export function describeChangeSetHandler(
+    components: ServerComponents,
+): RequestHandler<DescribeChangeSetParams, DescribeChangeSetResult, void> {
+    return async (rawParams: DescribeChangeSetParams): Promise<DescribeChangeSetResult> => {
+        const params = parseWithPrettyError(parseDescribeChangeSetParams, rawParams);
+
+        const result = await components.cfnService.describeChangeSet({
+            ChangeSetName: params.changeSetName,
+            IncludePropertyValues: true,
+            StackName: params.stackName,
+        });
+
+        return {
+            changeSetName: params.changeSetName,
+            stackName: params.stackName,
+            status: result.Status ?? '',
+            creationTime: result.CreationTime?.toISOString(),
+            description: result.Description,
+            changes: mapChangesToStackChanges(result.Changes),
+        };
+    };
+}
+
 export function getStackEventsHandler(
     components: ServerComponents,
 ): RequestHandler<GetStackEventsParams, GetStackEventsResult, void> {
diff --git a/src/protocol/LspStackHandlers.ts b/src/protocol/LspStackHandlers.ts
@@ -48,6 +48,9 @@ import {
     GetStackOutputsParams,
     GetStackOutputsResult,
     GetStackOutputsRequest,
+    DescribeChangeSetParams,
+    DescribeChangeSetResult,
+    DescribeChangeSetRequest,
 } from '../stacks/StackRequestType';
 import { Identifiable } from './LspTypes';
 
@@ -106,6 +109,10 @@ export class LspStackHandlers {
         this.connection.onRequest(ListChangeSetRequest.method, handler);
     }
 
+    onDescribeChangeSet(handler: RequestHandler<DescribeChangeSetParams, DescribeChangeSetResult, void>) {
+        this.connection.onRequest(DescribeChangeSetRequest.method, handler);
+    }
+
     onDeleteChangeSet(handler: RequestHandler<DeleteChangeSetParams, CreateStackActionResult, void>) {
         this.connection.onRequest(DeleteChangeSetRequest.method, handler);
     }
diff --git a/src/server/CfnServer.ts b/src/server/CfnServer.ts
@@ -39,6 +39,7 @@ import {
     getStackEventsHandler,
     clearStackEventsHandler,
     getStackOutputsHandler,
+    describeChangeSetHandler,
 } from '../handlers/StackHandler';
 import { LspComponents } from '../protocol/LspComponents';
 import { closeSafely } from '../utils/Closeable';
@@ -115,6 +116,7 @@ export class CfnServer {
         this.lsp.stackHandlers.onListStacks(listStacksHandler(this.components));
         this.lsp.stackHandlers.onListChangeSets(listChangeSetsHandler(this.components));
         this.lsp.stackHandlers.onListStackResources(listStackResourcesHandler(this.components));
+        this.lsp.stackHandlers.onDescribeChangeSet(describeChangeSetHandler(this.components));
         this.lsp.stackHandlers.onGetStackTemplate(getManagedResourceStackTemplateHandler(this.components));
         this.lsp.stackHandlers.onGetStackEvents(getStackEventsHandler(this.components));
         this.lsp.stackHandlers.onClearStackEvents(clearStackEventsHandler(this.components));
diff --git a/src/services/CfnService.ts b/src/services/CfnService.ts
@@ -135,6 +135,7 @@ export class CfnService {
         return await this.withClient((client) => client.send(new CreateChangeSetCommand(params)));
     }
 
+    @Measure({ name: 'describeChangeSet' })
     public async describeChangeSet(params: {
         ChangeSetName: string;
         IncludePropertyValues: boolean;
diff --git a/src/stacks/StackRequestType.ts b/src/stacks/StackRequestType.ts
@@ -1,5 +1,6 @@
 import { StackSummary, StackStatus, StackResourceSummary, StackEvent, Output } from '@aws-sdk/client-cloudformation';
 import { RequestType } from 'vscode-languageserver-protocol';
+import { ChangeSetReference, StackChange } from './actions/StackActionRequestType';
 
 export type ListStacksParams = {
     statusToInclude?: StackStatus[];
@@ -33,16 +34,25 @@ export type ListChangeSetParams = {
     nextToken?: string;
 };
 
+export type DescribeChangeSetParams = ChangeSetReference;
+
+export type ChangeSetSummary = {
+    changeSetName: string;
+    status: string;
+    creationTime?: string;
+    description?: string;
+};
+
 export type ListChangeSetResult = {
-    changeSets: Array<{
-        changeSetName: string;
-        status: string;
-        creationTime?: string;
-        description?: string;
-    }>;
+    changeSets: Array<ChangeSetSummary>;
     nextToken?: string;
 };
 
+export type DescribeChangeSetResult = ChangeSetSummary & {
+    stackName: string;
+    changes?: StackChange[];
+};
+
 export const ListChangeSetRequest = new RequestType<ListChangeSetParams, ListChangeSetResult, void>(
     'aws/cfn/stack/changeSet/list',
 );
@@ -96,3 +106,7 @@ export type GetStackOutputsResult = {
 export const GetStackOutputsRequest = new RequestType<GetStackOutputsParams, GetStackOutputsResult, void>(
     'aws/cfn/stack/outputs',
 );
+
+export const DescribeChangeSetRequest = new RequestType<DescribeChangeSetParams, DescribeChangeSetResult, void>(
+    'aws/cfn/stack/changeSet/describe',
+);
diff --git a/src/stacks/actions/StackActionParser.ts b/src/stacks/actions/StackActionParser.ts
@@ -5,6 +5,7 @@ import {
     GetStackEventsParams,
     ClearStackEventsParams,
     GetStackOutputsParams,
+    DescribeChangeSetParams,
 } from '../StackRequestType';
 import {
     CreateDeploymentParams,
@@ -65,6 +66,11 @@ const DeleteChangeSetParamsSchema = z.object({
     changeSetName: z.string().min(1).max(128),
 });
 
+const DescribeChangeSetParamsSchema = z.object({
+    stackName: z.string().min(1).max(128),
+    changeSetName: z.string().min(1).max(128),
+});
+
 const TemplateUriSchema = z.string().min(1);
 
 const ListStackResourcesParamsSchema = z.object({
@@ -118,3 +124,7 @@ export function parseClearStackEventsParams(input: unknown): ClearStackEventsPar
 export function parseGetStackOutputsParams(input: unknown): GetStackOutputsParams {
     return GetStackOutputsParamsSchema.parse(input);
 }
+
+export function parseDescribeChangeSetParams(input: unknown): DescribeChangeSetParams {
+    return DescribeChangeSetParamsSchema.parse(input);
+}
diff --git a/tst/unit/handlers/StackHandler.test.ts b/tst/unit/handlers/StackHandler.test.ts
@@ -1,4 +1,10 @@
-import { Capability, StackSummary, StackStatus, StackResourceSummary } from '@aws-sdk/client-cloudformation';
+import {
+    Capability,
+    StackSummary,
+    StackStatus,
+    StackResourceSummary,
+    ChangeSetStatus,
+} from '@aws-sdk/client-cloudformation';
 import { StubbedInstance } from 'ts-sinon';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { CancellationToken, ResponseError, ErrorCodes } from 'vscode-languageserver';
@@ -23,8 +29,10 @@ import {
     describeChangeSetDeletionStatusHandler,
     getChangeSetDeletionStatusHandler,
     getStackOutputsHandler,
+    describeChangeSetHandler,
 } from '../../../src/handlers/StackHandler';
 import { analyzeCapabilities } from '../../../src/stacks/actions/CapabilityAnalyzer';
+import { mapChangesToStackChanges } from '../../../src/stacks/actions/StackActionOperations';
 import {
     TemplateUri,
     GetCapabilitiesResult,
@@ -38,6 +46,8 @@ import {
     ListStacksResult,
     ListStackResourcesResult,
     GetStackOutputsResult,
+    DescribeChangeSetParams,
+    DescribeChangeSetResult,
 } from '../../../src/stacks/StackRequestType';
 import {
     createMockComponents,
@@ -73,6 +83,10 @@ vi.mock('../../../src/stacks/actions/CapabilityAnalyzer', () => ({
     analyzeCapabilities: vi.fn(),
 }));
 
+vi.mock('../../../src/stacks/actions/StackActionOperations', () => ({
+    mapChangesToStackChanges: vi.fn(),
+}));
+
 describe('StackActionHandler', () => {
     let mockComponents: MockedServerComponents;
     let syntaxTreeManager: StubbedInstance<SyntaxTreeManager>;
@@ -763,4 +777,107 @@ describe('StackActionHandler', () => {
             await expect(handler(params, {} as any)).rejects.toThrow(ResponseError);
         });
     });
+
+    describe('describeChangeSetHandler', () => {
+        it('should return changeset details on success', async () => {
+            const mockChangeSetResponse = {
+                Status: ChangeSetStatus.CREATE_COMPLETE,
+                CreationTime: new Date('2023-01-01T00:00:00Z'),
+                Description: 'Test changeset',
+                Changes: [
+                    {
+                        Action: 'Add',
+                        ResourceChange: {
+                            LogicalResourceId: 'MyBucket',
+                            ResourceType: 'AWS::S3::Bucket',
+                        },
+                    },
+                ],
+                $metadata: {},
+            };
+
+            const mockMappedChanges = [
+                {
+                    type: 'Resource',
+                    resourceChange: {
+                        action: 'Add',
+                        logicalResourceId: 'MyBucket',
+                        resourceType: 'AWS::S3::Bucket',
+                    },
+                },
+            ];
+
+            mockComponents.cfnService.describeChangeSet.resolves(mockChangeSetResponse);
+            vi.mocked(mapChangesToStackChanges).mockReturnValue(mockMappedChanges);
+
+            const handler = describeChangeSetHandler(mockComponents);
+            const params: DescribeChangeSetParams = {
+                changeSetName: 'test-changeset',
+                stackName: 'test-stack',
+            };
+
+            const result = (await handler(params, {} as any)) as DescribeChangeSetResult;
+
+            expect(result).toEqual({
+                changeSetName: 'test-changeset',
+                stackName: 'test-stack',
+                status: ChangeSetStatus.CREATE_COMPLETE,
+                creationTime: '2023-01-01T00:00:00.000Z',
+                description: 'Test changeset',
+                changes: mockMappedChanges,
+            });
+
+            expect(
+                mockComponents.cfnService.describeChangeSet.calledWith({
+                    ChangeSetName: 'test-changeset',
+                    IncludePropertyValues: true,
+                    StackName: 'test-stack',
+                }),
+            ).toBe(true);
+            expect(mapChangesToStackChanges).toHaveBeenCalledWith(mockChangeSetResponse.Changes);
+        });
+
+        it('should handle undefined optional fields', async () => {
+            const mockChangeSetResponse = {
+                Status: undefined,
+                CreationTime: undefined,
+                Description: undefined,
+                Changes: undefined,
+                $metadata: {},
+            };
+
+            mockComponents.cfnService.describeChangeSet.resolves(mockChangeSetResponse);
+            vi.mocked(mapChangesToStackChanges).mockReturnValue([]);
+
+            const handler = describeChangeSetHandler(mockComponents);
+            const params: DescribeChangeSetParams = {
+                changeSetName: 'test-changeset',
+                stackName: 'test-stack',
+            };
+
+            const result = (await handler(params, {} as any)) as DescribeChangeSetResult;
+
+            expect(result).toEqual({
+                changeSetName: 'test-changeset',
+                stackName: 'test-stack',
+                status: '',
+                creationTime: undefined,
+                description: undefined,
+                changes: [],
+            });
+        });
+
+        it('should propagate errors from cfnService', async () => {
+            const error = new Error('ChangeSet not found');
+            mockComponents.cfnService.describeChangeSet.rejects(error);
+
+            const handler = describeChangeSetHandler(mockComponents);
+            const params: DescribeChangeSetParams = {
+                changeSetName: 'non-existent-changeset',
+                stackName: 'test-stack',
+            };
+
+            await expect(handler(params, {} as any)).rejects.toThrow('ChangeSet not found');
+        });
+    });
 });
diff --git a/tst/unit/protocol/LspStackHandlers.test.ts b/tst/unit/protocol/LspStackHandlers.test.ts
@@ -36,6 +36,9 @@ import {
     ListStackResourcesRequest,
     ListStackResourcesParams,
     ListStackResourcesResult,
+    DescribeChangeSetParams,
+    DescribeChangeSetResult,
+    DescribeChangeSetRequest,
 } from '../../../src/stacks/StackRequestType';
 
 describe('LspTemplateHandlers', () => {
@@ -150,4 +153,12 @@ describe('LspTemplateHandlers', () => {
 
         expect(connection.onRequest.calledWith(ListStackResourcesRequest.method)).toBe(true);
     });
+
+    it('should register onDescribeChangeSet handler', () => {
+        const mockHandler: RequestHandler<DescribeChangeSetParams, DescribeChangeSetResult, void> = vi.fn();
+
+        stackActionHandlers.onDescribeChangeSet(mockHandler);
+
+        expect(connection.onRequest.calledWith(DescribeChangeSetRequest.method)).toBe(true);
+    });
 });
diff --git a/tst/unit/stackActions/StackActionParser.test.ts b/tst/unit/stackActions/StackActionParser.test.ts

Original file line number	Diff line number	Diff line change
`@@ -135,6 +135,7 @@ export class CfnService {`
`135`	`135`	`return await this.withClient((client) => client.send(new CreateChangeSetCommand(params)));`
`136`	`136`	`}`
`137`	`137`
	`138`	`+ @Measure({ name: 'describeChangeSet' })`
`138`	`139`	`public async describeChangeSet(params: {`
`139`	`140`	`ChangeSetName: string;`
`140`	`141`	`IncludePropertyValues: boolean;`