@friggframework/devtools 2.0.0-next.61 → 2.0.0-next.62

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

@@ -1,376 +0,0 @@
-/**
- * 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

@@ -1,213 +0,0 @@
-/**
- * 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');
-const { getPropertyMutability } = require('../../domain/services/property-mutability-config');
-
-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
-     * @param {Function} params.onProgress - Optional progress callback (step, message)
-     * @returns {Promise<StackHealthReport>} Comprehensive health report
-     */
-    async execute({ stackIdentifier, onProgress }) {
-        // Helper to call progress callback if provided
-        const progress = (step, message) => {
-            if (onProgress) {
-                onProgress(step, message);
-            }
-        };
-
-        // 1. Verify stack exists
-        progress('📋 Step 1/5:', 'Verifying stack exists...');
-        await this.stackRepository.getStack(stackIdentifier);
-
-        // 2. Detect stack-level drift
-        progress('🔍 Step 2/5:', 'Detecting stack drift...');
-        const driftDetection = await this.stackRepository.detectStackDrift(stackIdentifier);
-
-        // 3. Get all stack resources
-        progress('📊 Step 3/5:', 'Analyzing 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
-                ) {
-                    // Build property mutability map for this resource type
-                    // AWS drift detection returns property paths, we need to provide mutability for each
-                    const propertyMutabilityMap = {};
-                    for (const propDiff of resourceDrift.propertyDifferences) {
-                        const propertyPath = propDiff.PropertyPath.replace(/^\//, ''); // Remove leading slash
-                        propertyMutabilityMap[propertyPath] = getPropertyMutability(
-                            stackResource.resourceType,
-                            propertyPath
-                        );
-                    }
-
-                    const propertyMismatches = this.mismatchAnalyzer.analyze({
-                        expected: resourceDrift.expectedProperties,
-                        actual: resourceDrift.actualProperties,
-                        propertyMutability: propertyMutabilityMap,
-                        ignoreProperties: [],
-                    });
-
-                    // 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)
-        progress('🔎 Step 4/5:', 'Checking for orphaned resources...');
-        const orphanedResources = await this.resourceDetector.findOrphanedResources({
-            stackIdentifier,
-            stackResources,
-        });
-
-        for (const orphan of orphanedResources) {
-            // Create resource entity for orphan
-            // IMPORTANT: Include both properties AND tags for template comparison
-            // Tags are stored in properties.tags for logical ID mapping
-            const orphanResource = new Resource({
-                logicalId: null, // No logical ID (not in template)
-                physicalId: orphan.physicalId,
-                resourceType: orphan.resourceType,
-                state: ResourceState.ORPHANED,
-                properties: {
-                    ...(orphan.properties || {}), // Include AWS properties
-                    tags: orphan.tags || {}, // Include tags for logical ID matching
-                },
-            });
-
-            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
-        progress('🧮 Step 5/5:', 'Calculating health score...');
-        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;