@friggframework/devtools 2.0.0--canary.474.d64c550.0 → 2.0.0--canary.474.efd7936.0

package/infrastructure/domains/health/infrastructure/adapters/aws-stack-repository.js

@@ -0,0 +1,386 @@
+/**
+ * AWSStackRepository - AWS CloudFormation Stack Adapter
+ *
+ * Infrastructure Adapter - Hexagonal Architecture
+ *
+ * Implements IStackRepository port for AWS CloudFormation.
+ * Handles CloudFormation API operations using AWS SDK v3.
+ *
+ * Lazy-loads AWS SDK to minimize cold start time and memory usage.
+ */
+
+const IStackRepository = require('../../application/ports/IStackRepository');
+const yaml = require('js-yaml');
+
+// Lazy-loaded AWS SDK CloudFormation client
+let CloudFormationClient,
+    DescribeStacksCommand,
+    ListStackResourcesCommand,
+    DescribeStackResourcesCommand,
+    DescribeStackResourceCommand,
+    GetTemplateCommand,
+    DetectStackDriftCommand,
+    DescribeStackDriftDetectionStatusCommand,
+    DescribeStackResourceDriftsCommand;
+
+/**
+ * Lazy load CloudFormation SDK
+ */
+function loadCloudFormation() {
+    if (!CloudFormationClient) {
+        const cfModule = require('@aws-sdk/client-cloudformation');
+        CloudFormationClient = cfModule.CloudFormationClient;
+        DescribeStacksCommand = cfModule.DescribeStacksCommand;
+        ListStackResourcesCommand = cfModule.ListStackResourcesCommand;
+        DescribeStackResourcesCommand = cfModule.DescribeStackResourcesCommand;
+        DescribeStackResourceCommand = cfModule.DescribeStackResourceCommand;
+        GetTemplateCommand = cfModule.GetTemplateCommand;
+        DetectStackDriftCommand = cfModule.DetectStackDriftCommand;
+        DescribeStackDriftDetectionStatusCommand =
+            cfModule.DescribeStackDriftDetectionStatusCommand;
+        DescribeStackResourceDriftsCommand = cfModule.DescribeStackResourceDriftsCommand;
+    }
+}
+
+class AWSStackRepository extends IStackRepository {
+    /**
+     * Create AWS Stack Repository
+     *
+     * @param {Object} [config={}]
+     * @param {string} [config.region] - AWS region (defaults to AWS_REGION env var)
+     */
+    constructor(config = {}) {
+        super();
+        this.region = config.region || process.env.AWS_REGION || 'us-east-1';
+        this.client = null;
+    }
+
+    /**
+     * Get or create CloudFormation client
+     * @private
+     */
+    _getClient() {
+        if (!this.client) {
+            loadCloudFormation();
+            this.client = new CloudFormationClient({ region: this.region });
+        }
+        return this.client;
+    }
+
+    /**
+     * Get stack information by identifier
+     */
+    async getStack(identifier) {
+        const client = this._getClient();
+
+        try {
+            const command = new DescribeStacksCommand({
+                StackName: identifier.stackName,
+            });
+
+            const response = await client.send(command);
+
+            if (!response.Stacks || response.Stacks.length === 0) {
+                throw new Error(
+                    `Stack ${identifier.stackName} does not exist in region ${this.region}`
+                );
+            }
+
+            const stack = response.Stacks[0];
+
+            // Parse ARN to get account ID
+            const arnMatch = stack.StackId.match(/:(\d{12}):/);
+            const accountId = arnMatch ? arnMatch[1] : identifier.accountId;
+
+            return {
+                stackName: stack.StackName,
+                region: this.region,
+                accountId,
+                stackId: stack.StackId,
+                status: stack.StackStatus,
+                creationTime: stack.CreationTime,
+                lastUpdatedTime: stack.LastUpdatedTime,
+                parameters: this._parseParameters(stack.Parameters),
+                outputs: this._parseOutputs(stack.Outputs),
+                tags: this._parseTags(stack.Tags),
+            };
+        } catch (error) {
+            if (error.name === 'ValidationError' || error.message?.includes('does not exist')) {
+                throw new Error(
+                    `Stack ${identifier.stackName} does not exist in region ${this.region}`
+                );
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * List all resources in a stack
+     */
+    async listResources(identifier) {
+        const client = this._getClient();
+        const resources = [];
+        let nextToken = null;
+
+        do {
+            const command = new ListStackResourcesCommand({
+                StackName: identifier.stackName,
+                NextToken: nextToken,
+            });
+
+            const response = await client.send(command);
+
+            if (response.StackResourceSummaries) {
+                for (const resource of response.StackResourceSummaries) {
+                    resources.push({
+                        logicalId: resource.LogicalResourceId,
+                        physicalId: resource.PhysicalResourceId,
+                        resourceType: resource.ResourceType,
+                        status: resource.ResourceStatus,
+                        lastUpdatedTime: resource.LastUpdatedTimestamp,
+                        driftStatus: resource.DriftInformation?.StackResourceDriftStatus || 'NOT_CHECKED',
+                    });
+                }
+            }
+
+            nextToken = response.NextToken;
+        } while (nextToken);
+
+        return resources;
+    }
+
+    /**
+     * Get resource details from stack
+     */
+    async getResource(identifier, logicalId) {
+        const client = this._getClient();
+
+        const command = new DescribeStackResourceCommand({
+            StackName: identifier.stackName,
+            LogicalResourceId: logicalId,
+        });
+
+        const response = await client.send(command);
+        const resource = response.StackResourceDetail;
+
+        return {
+            logicalId: resource.LogicalResourceId,
+            physicalId: resource.PhysicalResourceId,
+            resourceType: resource.ResourceType,
+            status: resource.ResourceStatus,
+            properties: {}, // CloudFormation doesn't return properties directly
+            metadata: this._parseMetadata(resource.Metadata),
+        };
+    }
+
+    /**
+     * Get the CloudFormation template for a stack
+     */
+    async getTemplate(identifier) {
+        const client = this._getClient();
+
+        const command = new GetTemplateCommand({
+            StackName: identifier.stackName,
+            TemplateStage: 'Original',
+        });
+
+        const response = await client.send(command);
+        const templateBody = response.TemplateBody;
+
+        // Try to parse as JSON first
+        try {
+            return JSON.parse(templateBody);
+        } catch {
+            // If not JSON, try YAML
+            try {
+                return yaml.load(templateBody);
+            } catch {
+                throw new Error('Failed to parse template body as JSON or YAML');
+            }
+        }
+    }
+
+    /**
+     * Check if a stack exists
+     */
+    async exists(identifier) {
+        try {
+            const stack = await this.getStack(identifier);
+
+            // Check if stack is in a deleted state
+            const deletedStates = ['DELETE_COMPLETE', 'DELETE_IN_PROGRESS'];
+            return !deletedStates.includes(stack.status);
+        } catch (error) {
+            if (error.message?.includes('does not exist')) {
+                return false;
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Detect drift for the entire stack
+     */
+    async detectStackDrift(identifier) {
+        const client = this._getClient();
+
+        // Initiate drift detection
+        const detectCommand = new DetectStackDriftCommand({
+            StackName: identifier.stackName,
+        });
+
+        const detectResponse = await client.send(detectCommand);
+        const driftDetectionId = detectResponse.StackDriftDetectionId;
+
+        // Poll for detection completion
+        let detectionStatus = 'DETECTION_IN_PROGRESS';
+        let statusResponse;
+
+        while (detectionStatus === 'DETECTION_IN_PROGRESS') {
+            await this._sleep(1000); // Wait 1 second between polls
+
+            const statusCommand = new DescribeStackDriftDetectionStatusCommand({
+                StackDriftDetectionId: driftDetectionId,
+            });
+
+            statusResponse = await client.send(statusCommand);
+            detectionStatus = statusResponse.DetectionStatus;
+        }
+
+        if (detectionStatus !== 'DETECTION_COMPLETE') {
+            throw new Error(`Drift detection failed with status: ${detectionStatus}`);
+        }
+
+        return {
+            stackDriftStatus: statusResponse.StackDriftStatus,
+            driftedResourceCount: statusResponse.DriftedStackResourceCount || 0,
+            detectionTime: statusResponse.Timestamp,
+        };
+    }
+
+    /**
+     * Get drift details for a specific resource
+     */
+    async getResourceDrift(identifier, logicalId) {
+        const client = this._getClient();
+
+        const command = new DescribeStackResourceDriftsCommand({
+            StackName: identifier.stackName,
+            StackResourceDriftStatusFilters: ['MODIFIED', 'DELETED', 'IN_SYNC'],
+        });
+
+        const response = await client.send(command);
+
+        // Find the specific resource
+        const resourceDrift = response.StackResourceDrifts?.find(
+            (drift) => drift.LogicalResourceId === logicalId
+        );
+
+        if (!resourceDrift) {
+            throw new Error(
+                `No drift information found for resource ${logicalId} in stack ${identifier.stackName}`
+            );
+        }
+
+        return {
+            driftStatus: resourceDrift.StackResourceDriftStatus,
+            expectedProperties: this._parseProperties(resourceDrift.ExpectedProperties),
+            actualProperties: this._parseProperties(resourceDrift.ActualProperties),
+            propertyDifferences: resourceDrift.PropertyDifferences || [],
+        };
+    }
+
+    // ========================================
+    // Private Helper Methods
+    // ========================================
+
+    /**
+     * Parse CloudFormation parameters to key-value object
+     * @private
+     */
+    _parseParameters(parameters) {
+        if (!parameters || parameters.length === 0) {
+            return {};
+        }
+
+        const result = {};
+        for (const param of parameters) {
+            result[param.ParameterKey] = param.ParameterValue;
+        }
+        return result;
+    }
+
+    /**
+     * Parse CloudFormation outputs to key-value object
+     * @private
+     */
+    _parseOutputs(outputs) {
+        if (!outputs || outputs.length === 0) {
+            return {};
+        }
+
+        const result = {};
+        for (const output of outputs) {
+            result[output.OutputKey] = output.OutputValue;
+        }
+        return result;
+    }
+
+    /**
+     * Parse CloudFormation tags to key-value object
+     * @private
+     */
+    _parseTags(tags) {
+        if (!tags || tags.length === 0) {
+            return {};
+        }
+
+        const result = {};
+        for (const tag of tags) {
+            result[tag.Key] = tag.Value;
+        }
+        return result;
+    }
+
+    /**
+     * Parse resource metadata
+     * @private
+     */
+    _parseMetadata(metadata) {
+        if (!metadata) {
+            return {};
+        }
+
+        try {
+            return JSON.parse(metadata);
+        } catch {
+            return {};
+        }
+    }
+
+    /**
+     * Parse property JSON string
+     * @private
+     */
+    _parseProperties(propertiesString) {
+        if (!propertiesString) {
+            return {};
+        }
+
+        try {
+            return JSON.parse(propertiesString);
+        } catch {
+            return {};
+        }
+    }
+
+    /**
+     * Sleep for specified milliseconds
+     * @private
+     */
+    _sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+
+module.exports = AWSStackRepository;

package/infrastructure/domains/health/infrastructure/adapters/aws-stack-repository.test.js

@@ -0,0 +1,580 @@
+/**
+ * Tests for AWSStackRepository Adapter
+ *
+ * Tests CloudFormation API integration using mocked AWS SDK clients
+ */
+
+const AWSStackRepository = require('./aws-stack-repository');
+const StackIdentifier = require('../../domain/value-objects/stack-identifier');
+
+// Mock AWS SDK
+jest.mock('@aws-sdk/client-cloudformation', () => {
+    return {
+        CloudFormationClient: jest.fn(),
+        DescribeStacksCommand: jest.fn(),
+        ListStackResourcesCommand: jest.fn(),
+        DescribeStackResourcesCommand: jest.fn(),
+        DescribeStackResourceCommand: jest.fn(),
+        GetTemplateCommand: jest.fn(),
+        DetectStackDriftCommand: jest.fn(),
+        DescribeStackDriftDetectionStatusCommand: jest.fn(),
+        DescribeStackResourceDriftsCommand: jest.fn(),
+    };
+});
+
+describe('AWSStackRepository', () => {
+    let repository;
+    let mockSend;
+    let mockClient;
+
+    beforeEach(() => {
+        // Reset mocks
+        jest.clearAllMocks();
+
+        // Create mock client with send method
+        mockSend = jest.fn();
+        mockClient = {
+            send: mockSend,
+        };
+
+        // Mock CloudFormationClient constructor
+        const { CloudFormationClient } = require('@aws-sdk/client-cloudformation');
+        CloudFormationClient.mockImplementation(() => mockClient);
+
+        repository = new AWSStackRepository();
+    });
+
+    describe('getStack', () => {
+        it('should get stack information', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '123456789012',
+            });
+
+            const mockStack = {
+                StackId: 'arn:aws:cloudformation:us-east-1:123456789012:stack/my-app-prod/guid',
+                StackName: 'my-app-prod',
+                StackStatus: 'UPDATE_COMPLETE',
+                CreationTime: new Date('2024-01-01T00:00:00Z'),
+                LastUpdatedTime: new Date('2024-01-15T00:00:00Z'),
+                Parameters: [
+                    { ParameterKey: 'Environment', ParameterValue: 'production' },
+                ],
+                Outputs: [
+                    { OutputKey: 'VpcId', OutputValue: 'vpc-123' },
+                ],
+                Tags: [
+                    { Key: 'Team', Value: 'platform' },
+                ],
+            };
+
+            mockSend.mockResolvedValue({
+                Stacks: [mockStack],
+            });
+
+            const stack = await repository.getStack(identifier);
+
+            expect(stack).toEqual({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '123456789012',
+                stackId: 'arn:aws:cloudformation:us-east-1:123456789012:stack/my-app-prod/guid',
+                status: 'UPDATE_COMPLETE',
+                creationTime: new Date('2024-01-01T00:00:00Z'),
+                lastUpdatedTime: new Date('2024-01-15T00:00:00Z'),
+                parameters: { Environment: 'production' },
+                outputs: { VpcId: 'vpc-123' },
+                tags: { Team: 'platform' },
+            });
+
+            expect(mockSend).toHaveBeenCalledTimes(1);
+        });
+
+        it('should throw error if stack does not exist', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'non-existent',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockRejectedValue({
+                name: 'ValidationError',
+                message: 'Stack does not exist',
+            });
+
+            await expect(repository.getStack(identifier)).rejects.toThrow(
+                'Stack non-existent does not exist in region us-east-1'
+            );
+        });
+
+        it('should handle stacks without parameters', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'simple-stack',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockResolvedValue({
+                Stacks: [
+                    {
+                        StackId: 'arn:aws:cloudformation:us-east-1:123456789012:stack/simple-stack/guid',
+                        StackName: 'simple-stack',
+                        StackStatus: 'CREATE_COMPLETE',
+                        CreationTime: new Date('2024-01-01T00:00:00Z'),
+                    },
+                ],
+            });
+
+            const stack = await repository.getStack(identifier);
+
+            expect(stack.parameters).toEqual({});
+            expect(stack.outputs).toEqual({});
+            expect(stack.tags).toEqual({});
+        });
+    });
+
+    describe('listResources', () => {
+        it('should list all stack resources', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockResolvedValue({
+                StackResourceSummaries: [
+                    {
+                        LogicalResourceId: 'MyVPC',
+                        PhysicalResourceId: 'vpc-123',
+                        ResourceType: 'AWS::EC2::VPC',
+                        ResourceStatus: 'CREATE_COMPLETE',
+                        LastUpdatedTimestamp: new Date('2024-01-15T00:00:00Z'),
+                        DriftInformation: { StackResourceDriftStatus: 'IN_SYNC' },
+                    },
+                    {
+                        LogicalResourceId: 'MySubnet',
+                        PhysicalResourceId: 'subnet-456',
+                        ResourceType: 'AWS::EC2::Subnet',
+                        ResourceStatus: 'CREATE_COMPLETE',
+                        LastUpdatedTimestamp: new Date('2024-01-15T00:00:00Z'),
+                        DriftInformation: { StackResourceDriftStatus: 'NOT_CHECKED' },
+                    },
+                ],
+            });
+
+            const resources = await repository.listResources(identifier);
+
+            expect(resources).toHaveLength(2);
+            expect(resources[0]).toEqual({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                status: 'CREATE_COMPLETE',
+                lastUpdatedTime: new Date('2024-01-15T00:00:00Z'),
+                driftStatus: 'IN_SYNC',
+            });
+
+            expect(resources[1].driftStatus).toBe('NOT_CHECKED');
+        });
+
+        it('should handle pagination for large stacks', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'large-stack',
+                region: 'us-east-1',
+            });
+
+            // First page
+            mockSend.mockResolvedValueOnce({
+                StackResourceSummaries: [
+                    {
+                        LogicalResourceId: 'Resource1',
+                        PhysicalResourceId: 'res-1',
+                        ResourceType: 'AWS::EC2::VPC',
+                        ResourceStatus: 'CREATE_COMPLETE',
+                        LastUpdatedTimestamp: new Date('2024-01-15T00:00:00Z'),
+                        DriftInformation: { StackResourceDriftStatus: 'IN_SYNC' },
+                    },
+                ],
+                NextToken: 'token-123',
+            });
+
+            // Second page
+            mockSend.mockResolvedValueOnce({
+                StackResourceSummaries: [
+                    {
+                        LogicalResourceId: 'Resource2',
+                        PhysicalResourceId: 'res-2',
+                        ResourceType: 'AWS::EC2::Subnet',
+                        ResourceStatus: 'CREATE_COMPLETE',
+                        LastUpdatedTimestamp: new Date('2024-01-15T00:00:00Z'),
+                        DriftInformation: { StackResourceDriftStatus: 'IN_SYNC' },
+                    },
+                ],
+            });
+
+            const resources = await repository.listResources(identifier);
+
+            expect(resources).toHaveLength(2);
+            expect(mockSend).toHaveBeenCalledTimes(2);
+        });
+
+        it('should throw error if stack does not exist', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'non-existent',
+                region: 'us-east-1',
+            });
+
+            const error = new Error('Stack does not exist');
+            error.name = 'ValidationError';
+            mockSend.mockRejectedValue(error);
+
+            await expect(repository.listResources(identifier)).rejects.toThrow('Stack does not exist');
+        });
+    });
+
+    describe('getResource', () => {
+        it('should get resource details', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockResolvedValue({
+                StackResourceDetail: {
+                    LogicalResourceId: 'MyVPC',
+                    PhysicalResourceId: 'vpc-123',
+                    ResourceType: 'AWS::EC2::VPC',
+                    ResourceStatus: 'CREATE_COMPLETE',
+                    Metadata: '{"Description": "Main VPC"}',
+                },
+            });
+
+            const resource = await repository.getResource(identifier, 'MyVPC');
+
+            expect(resource).toEqual({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                status: 'CREATE_COMPLETE',
+                properties: {},
+                metadata: { Description: 'Main VPC' },
+            });
+        });
+
+        it('should handle resource without metadata', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockResolvedValue({
+                StackResourceDetail: {
+                    LogicalResourceId: 'MyVPC',
+                    PhysicalResourceId: 'vpc-123',
+                    ResourceType: 'AWS::EC2::VPC',
+                    ResourceStatus: 'CREATE_COMPLETE',
+                },
+            });
+
+            const resource = await repository.getResource(identifier, 'MyVPC');
+
+            expect(resource.metadata).toEqual({});
+        });
+
+        it('should throw error if resource does not exist', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const error = new Error('Resource does not exist');
+            error.name = 'ValidationError';
+            mockSend.mockRejectedValue(error);
+
+            await expect(repository.getResource(identifier, 'NonExistent')).rejects.toThrow('Resource does not exist');
+        });
+    });
+
+    describe('getTemplate', () => {
+        it('should get CloudFormation template', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const mockTemplate = {
+                Resources: {
+                    MyVPC: {
+                        Type: 'AWS::EC2::VPC',
+                        Properties: {
+                            CidrBlock: '10.0.0.0/16',
+                        },
+                    },
+                },
+            };
+
+            mockSend.mockResolvedValue({
+                TemplateBody: JSON.stringify(mockTemplate),
+            });
+
+            const template = await repository.getTemplate(identifier);
+
+            expect(template).toEqual(mockTemplate);
+        });
+
+        it('should handle YAML templates', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const yamlTemplate = `
+Resources:
+  MyVPC:
+    Type: AWS::EC2::VPC
+    Properties:
+      CidrBlock: 10.0.0.0/16
+`;
+
+            mockSend.mockResolvedValue({
+                TemplateBody: yamlTemplate,
+            });
+
+            const template = await repository.getTemplate(identifier);
+
+            expect(template).toHaveProperty('Resources');
+            expect(template.Resources).toHaveProperty('MyVPC');
+        });
+    });
+
+    describe('exists', () => {
+        it('should return true if stack exists', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockResolvedValue({
+                Stacks: [{
+                    StackName: 'my-app-prod',
+                    StackId: 'arn:aws:cloudformation:us-east-1:123456789012:stack/my-app-prod/guid',
+                    StackStatus: 'UPDATE_COMPLETE',
+                    CreationTime: new Date('2024-01-01T00:00:00Z'),
+                }],
+            });
+
+            const exists = await repository.exists(identifier);
+
+            expect(exists).toBe(true);
+        });
+
+        it('should return false if stack does not exist', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'non-existent',
+                region: 'us-east-1',
+            });
+
+            const error = new Error('Stack does not exist');
+            error.name = 'ValidationError';
+            mockSend.mockRejectedValue(error);
+
+            const exists = await repository.exists(identifier);
+
+            expect(exists).toBe(false);
+        });
+
+        it('should return false if stack is deleted', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'deleted-stack',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockResolvedValue({
+                Stacks: [{
+                    StackName: 'deleted-stack',
+                    StackId: 'arn:aws:cloudformation:us-east-1:123456789012:stack/deleted-stack/guid',
+                    StackStatus: 'DELETE_COMPLETE',
+                    CreationTime: new Date('2024-01-01T00:00:00Z'),
+                }],
+            });
+
+            const exists = await repository.exists(identifier);
+
+            expect(exists).toBe(false);
+        });
+    });
+
+    describe('detectStackDrift', () => {
+        it('should detect stack drift', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            // Mock drift detection initiation
+            mockSend.mockResolvedValueOnce({
+                StackDriftDetectionId: 'drift-detection-123',
+            });
+
+            // Mock drift detection status polling
+            mockSend.mockResolvedValueOnce({
+                DetectionStatus: 'DETECTION_COMPLETE',
+                StackDriftStatus: 'DRIFTED',
+                DriftedStackResourceCount: 2,
+                Timestamp: new Date('2024-01-15T10:00:00Z'),
+            });
+
+            const result = await repository.detectStackDrift(identifier);
+
+            expect(result).toEqual({
+                stackDriftStatus: 'DRIFTED',
+                driftedResourceCount: 2,
+                detectionTime: new Date('2024-01-15T10:00:00Z'),
+            });
+
+            expect(mockSend).toHaveBeenCalledTimes(2);
+        });
+
+        it('should handle in-sync stacks', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockResolvedValueOnce({
+                StackDriftDetectionId: 'drift-detection-123',
+            });
+
+            mockSend.mockResolvedValueOnce({
+                DetectionStatus: 'DETECTION_COMPLETE',
+                StackDriftStatus: 'IN_SYNC',
+                DriftedStackResourceCount: 0,
+                Timestamp: new Date('2024-01-15T10:00:00Z'),
+            });
+
+            const result = await repository.detectStackDrift(identifier);
+
+            expect(result.stackDriftStatus).toBe('IN_SYNC');
+            expect(result.driftedResourceCount).toBe(0);
+        });
+
+        it('should poll until detection completes', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockResolvedValueOnce({
+                StackDriftDetectionId: 'drift-detection-123',
+            });
+
+            // First poll: in progress
+            mockSend.mockResolvedValueOnce({
+                DetectionStatus: 'DETECTION_IN_PROGRESS',
+            });
+
+            // Second poll: complete
+            mockSend.mockResolvedValueOnce({
+                DetectionStatus: 'DETECTION_COMPLETE',
+                StackDriftStatus: 'IN_SYNC',
+                DriftedStackResourceCount: 0,
+                Timestamp: new Date('2024-01-15T10:00:00Z'),
+            });
+
+            const result = await repository.detectStackDrift(identifier);
+
+            expect(result.stackDriftStatus).toBe('IN_SYNC');
+            expect(mockSend).toHaveBeenCalledTimes(3);
+        });
+    });
+
+    describe('getResourceDrift', () => {
+        it('should get resource drift details', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockResolvedValue({
+                StackResourceDrifts: [
+                    {
+                        LogicalResourceId: 'MyVPC',
+                        StackResourceDriftStatus: 'MODIFIED',
+                        ExpectedProperties: JSON.stringify({
+                            CidrBlock: '10.0.0.0/16',
+                            EnableDnsSupport: true,
+                        }),
+                        ActualProperties: JSON.stringify({
+                            CidrBlock: '10.0.0.0/16',
+                            EnableDnsSupport: false,
+                        }),
+                        PropertyDifferences: [
+                            {
+                                PropertyPath: '/Properties/EnableDnsSupport',
+                                ExpectedValue: 'true',
+                                ActualValue: 'false',
+                                DifferenceType: 'NOT_EQUAL',
+                            },
+                        ],
+                    },
+                ],
+            });
+
+            const drift = await repository.getResourceDrift(identifier, 'MyVPC');
+
+            expect(drift).toEqual({
+                driftStatus: 'MODIFIED',
+                expectedProperties: {
+                    CidrBlock: '10.0.0.0/16',
+                    EnableDnsSupport: true,
+                },
+                actualProperties: {
+                    CidrBlock: '10.0.0.0/16',
+                    EnableDnsSupport: false,
+                },
+                propertyDifferences: [
+                    {
+                        PropertyPath: '/Properties/EnableDnsSupport',
+                        ExpectedValue: 'true',
+                        ActualValue: 'false',
+                        DifferenceType: 'NOT_EQUAL',
+                    },
+                ],
+            });
+        });
+
+        it('should handle resources in sync', async () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            mockSend.mockResolvedValue({
+                StackResourceDrifts: [
+                    {
+                        LogicalResourceId: 'MyVPC',
+                        StackResourceDriftStatus: 'IN_SYNC',
+                        ExpectedProperties: JSON.stringify({ CidrBlock: '10.0.0.0/16' }),
+                        ActualProperties: JSON.stringify({ CidrBlock: '10.0.0.0/16' }),
+                        PropertyDifferences: [],
+                    },
+                ],
+            });
+
+            const drift = await repository.getResourceDrift(identifier, 'MyVPC');
+
+            expect(drift.driftStatus).toBe('IN_SYNC');
+            expect(drift.propertyDifferences).toEqual([]);
+        });
+    });
+
+    describe('constructor', () => {
+        it('should create instance with default region', () => {
+            const repo = new AWSStackRepository();
+            expect(repo).toBeInstanceOf(AWSStackRepository);
+        });
+
+        it('should create instance with custom region', () => {
+            const repo = new AWSStackRepository({ region: 'eu-west-1' });
+            expect(repo).toBeInstanceOf(AWSStackRepository);
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.474.d64c550.0",
+  "version": "2.0.0--canary.474.efd7936.0",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -11,8 +11,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0--canary.474.d64c550.0",
-    "@friggframework/test": "2.0.0--canary.474.d64c550.0",
+    "@friggframework/schemas": "2.0.0--canary.474.efd7936.0",
+    "@friggframework/test": "2.0.0--canary.474.efd7936.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -34,8 +34,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.474.d64c550.0",
-    "@friggframework/prettier-config": "2.0.0--canary.474.d64c550.0",
+    "@friggframework/eslint-config": "2.0.0--canary.474.efd7936.0",
+    "@friggframework/prettier-config": "2.0.0--canary.474.efd7936.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -70,5 +70,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d64c55085840ccaf0cf6666ba699eb20873d9a81"
+  "gitHead": "efd79365aef7bb559b15d072ae85000069c61837"
 }