@friggframework/devtools 2.0.0--canary.474.884529c.0 → 2.0.0--canary.474.988ec0b.0

package/infrastructure/domains/health/application/use-cases/repair-via-import-use-case.test.js

@@ -0,0 +1,376 @@
+/**
+ * Tests for RepairViaImportUseCase
+ *
+ * Use case for importing orphaned resources into CloudFormation stack
+ * (frigg repair --import command)
+ */
+
+const RepairViaImportUseCase = require('./repair-via-import-use-case');
+const StackIdentifier = require('../../domain/value-objects/stack-identifier');
+
+describe('RepairViaImportUseCase', () => {
+    let useCase;
+    let mockResourceImporter;
+    let mockResourceDetector;
+
+    beforeEach(() => {
+        // Mock repositories
+        mockResourceImporter = {
+            validateImport: jest.fn(),
+            importResource: jest.fn(),
+            importMultipleResources: jest.fn(),
+            getImportStatus: jest.fn(),
+            generateTemplateSnippet: jest.fn(),
+        };
+
+        mockResourceDetector = {
+            getResourceDetails: jest.fn(),
+        };
+
+        useCase = new RepairViaImportUseCase({
+            resourceImporter: mockResourceImporter,
+            resourceDetector: mockResourceDetector,
+        });
+    });
+
+    describe('importSingleResource', () => {
+        it('should import a single orphaned resource', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const resourceToImport = {
+                logicalId: 'OrphanedDBCluster',
+                physicalId: 'my-orphan-cluster',
+                resourceType: 'AWS::RDS::DBCluster',
+            };
+
+            // Mock validation
+            mockResourceImporter.validateImport.mockResolvedValue({
+                canImport: true,
+                reason: null,
+                warnings: [],
+            });
+
+            // Mock resource details retrieval
+            mockResourceDetector.getResourceDetails.mockResolvedValue({
+                physicalId: 'my-orphan-cluster',
+                resourceType: 'AWS::RDS::DBCluster',
+                properties: {
+                    Engine: 'aurora-postgresql',
+                    EngineVersion: '13.7',
+                    MasterUsername: 'admin',
+                },
+                tags: [
+                    { Key: 'frigg:stack', Value: 'my-app-prod' },
+                ],
+            });
+
+            // Mock import operation
+            mockResourceImporter.importResource.mockResolvedValue({
+                operationId: 'arn:aws:cloudformation:us-east-1:123456789012:changeSet/import-xyz',
+                status: 'IN_PROGRESS',
+                message: 'Resource import initiated',
+            });
+
+            const result = await useCase.importSingleResource({
+                stackIdentifier,
+                logicalId: resourceToImport.logicalId,
+                physicalId: resourceToImport.physicalId,
+                resourceType: resourceToImport.resourceType,
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.operationId).toBeDefined();
+            expect(result.status).toBe('IN_PROGRESS');
+            expect(mockResourceImporter.validateImport).toHaveBeenCalledWith({
+                resourceType: 'AWS::RDS::DBCluster',
+                physicalId: 'my-orphan-cluster',
+                region: 'us-east-1',
+            });
+            expect(mockResourceImporter.importResource).toHaveBeenCalled();
+        });
+
+        it('should fail if resource cannot be imported', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            // Mock validation failure
+            mockResourceImporter.validateImport.mockResolvedValue({
+                canImport: false,
+                reason: 'Resource type AWS::Lambda::Function does not support import',
+                warnings: [],
+            });
+
+            await expect(
+                useCase.importSingleResource({
+                    stackIdentifier,
+                    logicalId: 'MyFunction',
+                    physicalId: 'my-function',
+                    resourceType: 'AWS::Lambda::Function',
+                })
+            ).rejects.toThrow('Resource type AWS::Lambda::Function does not support import');
+        });
+
+        it('should include warnings in result', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            // Mock validation with warnings
+            mockResourceImporter.validateImport.mockResolvedValue({
+                canImport: true,
+                reason: null,
+                warnings: ['Resource has manual configuration changes that may be lost'],
+            });
+
+            mockResourceDetector.getResourceDetails.mockResolvedValue({
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                properties: {
+                    CidrBlock: '10.0.0.0/16',
+                },
+                tags: [],
+            });
+
+            mockResourceImporter.importResource.mockResolvedValue({
+                operationId: 'arn:aws:cloudformation:us-east-1:123456789012:changeSet/import-xyz',
+                status: 'IN_PROGRESS',
+                message: 'Resource import initiated',
+            });
+
+            const result = await useCase.importSingleResource({
+                stackIdentifier,
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.warnings).toHaveLength(1);
+            expect(result.warnings[0]).toContain('manual configuration changes');
+        });
+    });
+
+    describe('importMultipleResources', () => {
+        it('should import multiple orphaned resources in batch', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const resourcesToImport = [
+                {
+                    logicalId: 'OrphanedVPC',
+                    physicalId: 'vpc-123',
+                    resourceType: 'AWS::EC2::VPC',
+                },
+                {
+                    logicalId: 'OrphanedSubnet',
+                    physicalId: 'subnet-456',
+                    resourceType: 'AWS::EC2::Subnet',
+                },
+            ];
+
+            // Mock validation for both resources
+            mockResourceImporter.validateImport.mockResolvedValue({
+                canImport: true,
+                reason: null,
+                warnings: [],
+            });
+
+            // Mock resource details
+            mockResourceDetector.getResourceDetails
+                .mockResolvedValueOnce({
+                    physicalId: 'vpc-123',
+                    resourceType: 'AWS::EC2::VPC',
+                    properties: { CidrBlock: '10.0.0.0/16' },
+                    tags: [],
+                })
+                .mockResolvedValueOnce({
+                    physicalId: 'subnet-456',
+                    resourceType: 'AWS::EC2::Subnet',
+                    properties: { CidrBlock: '10.0.1.0/24' },
+                    tags: [],
+                });
+
+            // Mock batch import
+            mockResourceImporter.importMultipleResources.mockResolvedValue({
+                operationId: 'arn:aws:cloudformation:us-east-1:123456789012:changeSet/batch-import-xyz',
+                status: 'IN_PROGRESS',
+                importedCount: 2,
+                failedCount: 0,
+                message: 'Batch import initiated',
+                details: [
+                    { logicalId: 'OrphanedVPC', status: 'IN_PROGRESS' },
+                    { logicalId: 'OrphanedSubnet', status: 'IN_PROGRESS' },
+                ],
+            });
+
+            const result = await useCase.importMultipleResources({
+                stackIdentifier,
+                resources: resourcesToImport,
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.importedCount).toBe(2);
+            expect(result.failedCount).toBe(0);
+            expect(mockResourceImporter.importMultipleResources).toHaveBeenCalled();
+        });
+
+        it('should handle partial failures in batch import', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const resourcesToImport = [
+                {
+                    logicalId: 'OrphanedVPC',
+                    physicalId: 'vpc-123',
+                    resourceType: 'AWS::EC2::VPC',
+                },
+                {
+                    logicalId: 'InvalidResource',
+                    physicalId: 'invalid-123',
+                    resourceType: 'AWS::Lambda::Function',
+                },
+            ];
+
+            // Mock validation - first passes, second fails
+            mockResourceImporter.validateImport
+                .mockResolvedValueOnce({
+                    canImport: true,
+                    reason: null,
+                    warnings: [],
+                })
+                .mockResolvedValueOnce({
+                    canImport: false,
+                    reason: 'Resource does not exist',
+                    warnings: [],
+                });
+
+            // Mock resource details for first resource only
+            mockResourceDetector.getResourceDetails.mockResolvedValueOnce({
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                properties: { CidrBlock: '10.0.0.0/16' },
+                tags: [],
+            });
+
+            const result = await useCase.importMultipleResources({
+                stackIdentifier,
+                resources: resourcesToImport,
+            });
+
+            expect(result.success).toBe(false); // Overall failure due to partial failure
+            expect(result.importedCount).toBe(0); // No resources actually imported yet
+            expect(result.failedCount).toBe(1);
+            expect(result.validationErrors).toHaveLength(1);
+            expect(result.validationErrors[0].logicalId).toBe('InvalidResource');
+        });
+    });
+
+    describe('getImportStatus', () => {
+        it('should get status of import operation', async () => {
+            const operationId = 'arn:aws:cloudformation:us-east-1:123456789012:changeSet/import-xyz';
+
+            mockResourceImporter.getImportStatus.mockResolvedValue({
+                operationId,
+                status: 'COMPLETE',
+                progress: 100,
+                message: 'Resource import completed successfully',
+                completedTime: new Date('2024-01-15T12:00:00Z'),
+            });
+
+            const status = await useCase.getImportStatus({ operationId });
+
+            expect(status.status).toBe('COMPLETE');
+            expect(status.progress).toBe(100);
+            expect(mockResourceImporter.getImportStatus).toHaveBeenCalledWith(operationId);
+        });
+
+        it('should return in-progress status for ongoing import', async () => {
+            const operationId = 'arn:aws:cloudformation:us-east-1:123456789012:changeSet/import-xyz';
+
+            mockResourceImporter.getImportStatus.mockResolvedValue({
+                operationId,
+                status: 'IN_PROGRESS',
+                progress: 50,
+                message: 'Importing resources...',
+                completedTime: null,
+            });
+
+            const status = await useCase.getImportStatus({ operationId });
+
+            expect(status.status).toBe('IN_PROGRESS');
+            expect(status.progress).toBe(50);
+            expect(status.completedTime).toBeNull();
+        });
+    });
+
+    describe('previewImport', () => {
+        it('should preview template changes for import', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            // Mock resource details
+            mockResourceDetector.getResourceDetails.mockResolvedValue({
+                physicalId: 'my-orphan-cluster',
+                resourceType: 'AWS::RDS::DBCluster',
+                properties: {
+                    Engine: 'aurora-postgresql',
+                    EngineVersion: '13.7',
+                },
+                tags: [],
+            });
+
+            // Mock template snippet generation
+            mockResourceImporter.generateTemplateSnippet.mockResolvedValue({
+                OrphanedDBCluster: {
+                    Type: 'AWS::RDS::DBCluster',
+                    Properties: {
+                        Engine: 'aurora-postgresql',
+                        EngineVersion: '13.7',
+                    },
+                },
+            });
+
+            const preview = await useCase.previewImport({
+                stackIdentifier,
+                logicalId: 'OrphanedDBCluster',
+                physicalId: 'my-orphan-cluster',
+                resourceType: 'AWS::RDS::DBCluster',
+            });
+
+            expect(preview.logicalId).toBe('OrphanedDBCluster');
+            expect(preview.physicalId).toBe('my-orphan-cluster');
+            expect(preview.templateSnippet).toBeDefined();
+            expect(preview.templateSnippet.OrphanedDBCluster.Type).toBe('AWS::RDS::DBCluster');
+        });
+    });
+
+    describe('constructor', () => {
+        it('should require resourceImporter', () => {
+            expect(() => {
+                new RepairViaImportUseCase({
+                    resourceDetector: mockResourceDetector,
+                });
+            }).toThrow('resourceImporter is required');
+        });
+
+        it('should require resourceDetector', () => {
+            expect(() => {
+                new RepairViaImportUseCase({
+                    resourceImporter: mockResourceImporter,
+                });
+            }).toThrow('resourceDetector is required');
+        });
+    });
+});

package/infrastructure/domains/health/application/use-cases/run-health-check-use-case.js

@@ -0,0 +1,180 @@
+/**
+ * RunHealthCheckUseCase - Orchestrate Complete Stack Health Check
+ *
+ * Application Layer - Use Case
+ *
+ * Business logic for the "frigg doctor" command. Orchestrates multiple
+ * repositories and domain services to produce a comprehensive health report.
+ *
+ * Responsibilities:
+ * - Coordinate stack information retrieval
+ * - Detect drift at stack and resource level
+ * - Find orphaned resources
+ * - Analyze property mismatches
+ * - Calculate health score
+ * - Build comprehensive health report
+ */
+
+const StackHealthReport = require('../../domain/entities/stack-health-report');
+const Resource = require('../../domain/entities/resource');
+const Issue = require('../../domain/entities/issue');
+const ResourceState = require('../../domain/value-objects/resource-state');
+
+class RunHealthCheckUseCase {
+    /**
+     * Create use case with required dependencies
+     *
+     * @param {Object} params
+     * @param {IStackRepository} params.stackRepository - Stack operations
+     * @param {IResourceDetector} params.resourceDetector - Resource discovery
+     * @param {MismatchAnalyzer} params.mismatchAnalyzer - Property drift analysis
+     * @param {HealthScoreCalculator} params.healthScoreCalculator - Health scoring
+     */
+    constructor({ stackRepository, resourceDetector, mismatchAnalyzer, healthScoreCalculator }) {
+        if (!stackRepository) {
+            throw new Error('stackRepository is required');
+        }
+        if (!resourceDetector) {
+            throw new Error('resourceDetector is required');
+        }
+        if (!mismatchAnalyzer) {
+            throw new Error('mismatchAnalyzer is required');
+        }
+        if (!healthScoreCalculator) {
+            throw new Error('healthScoreCalculator is required');
+        }
+
+        this.stackRepository = stackRepository;
+        this.resourceDetector = resourceDetector;
+        this.mismatchAnalyzer = mismatchAnalyzer;
+        this.healthScoreCalculator = healthScoreCalculator;
+    }
+
+    /**
+     * Execute complete health check for a stack
+     *
+     * @param {Object} params
+     * @param {StackIdentifier} params.stackIdentifier - Stack to check
+     * @returns {Promise<StackHealthReport>} Comprehensive health report
+     */
+    async execute({ stackIdentifier }) {
+        // 1. Verify stack exists
+        await this.stackRepository.getStack(stackIdentifier);
+
+        // 2. Detect stack-level drift
+        const driftDetection = await this.stackRepository.detectStackDrift(stackIdentifier);
+
+        // 3. Get all stack resources
+        const stackResources = await this.stackRepository.listResources(stackIdentifier);
+
+        // 4. Build resource entities with drift status
+        const resources = [];
+        const issues = [];
+
+        for (const stackResource of stackResources) {
+            let resourceState;
+
+            // Determine resource state
+            if (!stackResource.physicalId || stackResource.driftStatus === 'DELETED') {
+                // Missing resource (defined in template but doesn't exist in cloud)
+                resourceState = ResourceState.MISSING;
+
+                // Create issue for missing resource using factory method
+                issues.push(
+                    Issue.missingResource({
+                        resourceType: stackResource.resourceType,
+                        resourceId: stackResource.logicalId,
+                        description: `CloudFormation resource ${stackResource.logicalId} (${stackResource.resourceType}) is defined in the template but does not exist in the cloud.`,
+                    })
+                );
+            } else if (stackResource.driftStatus === 'MODIFIED') {
+                // Drifted resource - get detailed drift information
+                resourceState = ResourceState.DRIFTED;
+
+                const resourceDrift = await this.stackRepository.getResourceDrift(
+                    stackIdentifier,
+                    stackResource.logicalId
+                );
+
+                // Analyze property mismatches using domain service
+                if (
+                    resourceDrift.propertyDifferences &&
+                    resourceDrift.propertyDifferences.length > 0
+                ) {
+                    const propertyMismatches = this.mismatchAnalyzer.analyzePropertyMismatches(
+                        resourceDrift.propertyDifferences,
+                        stackResource.resourceType
+                    );
+
+                    // Create issue for each property mismatch using factory method
+                    for (const mismatch of propertyMismatches) {
+                        issues.push(
+                            Issue.propertyMismatch({
+                                resourceType: stackResource.resourceType,
+                                resourceId: stackResource.physicalId,
+                                mismatch,
+                            })
+                        );
+                    }
+                }
+            } else {
+                // Resource is in sync
+                resourceState = ResourceState.IN_STACK;
+            }
+
+            // Create resource entity
+            // For missing resources, use placeholder physicalId since they don't exist in cloud
+            const resource = new Resource({
+                logicalId: stackResource.logicalId,
+                physicalId: stackResource.physicalId || `missing-${stackResource.logicalId}`,
+                resourceType: stackResource.resourceType,
+                state: resourceState,
+            });
+
+            resources.push(resource);
+        }
+
+        // 5. Find orphaned resources (exist in cloud but not in stack)
+        const orphanedResources = await this.resourceDetector.findOrphanedResources({
+            stackIdentifier,
+            stackResources,
+        });
+
+        for (const orphan of orphanedResources) {
+            // Create resource entity for orphan
+            const orphanResource = new Resource({
+                logicalId: null, // No logical ID (not in template)
+                physicalId: orphan.physicalId,
+                resourceType: orphan.resourceType,
+                state: ResourceState.ORPHANED,
+            });
+
+            resources.push(orphanResource);
+
+            // Create issue for orphaned resource using factory method
+            issues.push(
+                Issue.orphanedResource({
+                    resourceType: orphan.resourceType,
+                    resourceId: orphan.physicalId,
+                    description: `Resource ${orphan.physicalId} exists in the cloud but is not managed by CloudFormation stack ${stackIdentifier.stackName}.`,
+                })
+            );
+        }
+
+        // 6. Calculate health score using domain service
+        const healthScore = this.healthScoreCalculator.calculate({ resources, issues });
+
+        // 7. Build comprehensive health report (aggregate root)
+        const report = new StackHealthReport({
+            stackIdentifier,
+            healthScore,
+            resources,
+            issues,
+            timestamp: new Date(),
+        });
+
+        return report;
+    }
+}
+
+module.exports = RunHealthCheckUseCase;