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

package/infrastructure/domains/health/application/use-cases/reconcile-properties-use-case.test.js

@@ -0,0 +1,343 @@
+/**
+ * Tests for ReconcilePropertiesUseCase
+ *
+ * Use case for reconciling property drift between CloudFormation template
+ * and actual cloud resources (frigg repair --reconcile command)
+ */
+
+const ReconcilePropertiesUseCase = require('./reconcile-properties-use-case');
+const StackIdentifier = require('../../domain/value-objects/stack-identifier');
+const PropertyMismatch = require('../../domain/entities/property-mismatch');
+const PropertyMutability = require('../../domain/value-objects/property-mutability');
+
+describe('ReconcilePropertiesUseCase', () => {
+    let useCase;
+    let mockPropertyReconciler;
+
+    beforeEach(() => {
+        // Mock property reconciler
+        mockPropertyReconciler = {
+            canReconcile: jest.fn(),
+            reconcileProperty: jest.fn(),
+            reconcileMultipleProperties: jest.fn(),
+            previewReconciliation: jest.fn(),
+        };
+
+        useCase = new ReconcilePropertiesUseCase({
+            propertyReconciler: mockPropertyReconciler,
+        });
+    });
+
+    describe('reconcileSingleProperty', () => {
+        it('should reconcile a single mutable property mismatch', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.EnableDnsSupport',
+                expectedValue: true,
+                actualValue: false,
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            // Mock reconciler can handle this mismatch
+            mockPropertyReconciler.canReconcile.mockResolvedValue(true);
+
+            // Mock reconciliation result
+            mockPropertyReconciler.reconcileProperty.mockResolvedValue({
+                success: true,
+                mode: 'template',
+                propertyPath: 'Properties.EnableDnsSupport',
+                oldValue: true,
+                newValue: false,
+                message: 'Template updated to match actual resource state',
+            });
+
+            const result = await useCase.reconcileSingleProperty({
+                stackIdentifier,
+                logicalId: 'MyVPC',
+                mismatch,
+                mode: 'template',
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.mode).toBe('template');
+            expect(result.propertyPath).toBe('Properties.EnableDnsSupport');
+            expect(mockPropertyReconciler.canReconcile).toHaveBeenCalledWith(mismatch);
+            expect(mockPropertyReconciler.reconcileProperty).toHaveBeenCalled();
+        });
+
+        it('should fail if property cannot be reconciled', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.CidrBlock',
+                expectedValue: '10.0.0.0/16',
+                actualValue: '10.1.0.0/16',
+                mutability: PropertyMutability.IMMUTABLE,
+            });
+
+            // Mock reconciler cannot handle immutable property
+            mockPropertyReconciler.canReconcile.mockResolvedValue(false);
+
+            await expect(
+                useCase.reconcileSingleProperty({
+                    stackIdentifier,
+                    logicalId: 'MyVPC',
+                    mismatch,
+                    mode: 'template',
+                })
+            ).rejects.toThrow('Property Properties.CidrBlock cannot be reconciled automatically');
+        });
+
+        it('should use resource mode when specified', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.EnableDnsSupport',
+                expectedValue: true,
+                actualValue: false,
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            mockPropertyReconciler.canReconcile.mockResolvedValue(true);
+
+            mockPropertyReconciler.reconcileProperty.mockResolvedValue({
+                success: true,
+                mode: 'resource',
+                propertyPath: 'Properties.EnableDnsSupport',
+                oldValue: false,
+                newValue: true,
+                message: 'Resource updated to match template definition',
+            });
+
+            const result = await useCase.reconcileSingleProperty({
+                stackIdentifier,
+                logicalId: 'MyVPC',
+                mismatch,
+                mode: 'resource',
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.mode).toBe('resource');
+            expect(mockPropertyReconciler.reconcileProperty).toHaveBeenCalledWith({
+                stackIdentifier,
+                logicalId: 'MyVPC',
+                mismatch,
+                mode: 'resource',
+            });
+        });
+    });
+
+    describe('reconcileMultipleProperties', () => {
+        it('should reconcile multiple property mismatches for a resource', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const mismatches = [
+                new PropertyMismatch({
+                    propertyPath: 'Properties.EnableDnsSupport',
+                    expectedValue: true,
+                    actualValue: false,
+                    mutability: PropertyMutability.MUTABLE,
+                }),
+                new PropertyMismatch({
+                    propertyPath: 'Properties.EnableDnsHostnames',
+                    expectedValue: true,
+                    actualValue: false,
+                    mutability: PropertyMutability.MUTABLE,
+                }),
+            ];
+
+            // Mock all mismatches can be reconciled
+            mockPropertyReconciler.canReconcile.mockResolvedValue(true);
+
+            // Mock batch reconciliation
+            mockPropertyReconciler.reconcileMultipleProperties.mockResolvedValue({
+                reconciledCount: 2,
+                failedCount: 0,
+                results: [
+                    {
+                        success: true,
+                        mode: 'template',
+                        propertyPath: 'Properties.EnableDnsSupport',
+                        oldValue: true,
+                        newValue: false,
+                        message: 'Template updated',
+                    },
+                    {
+                        success: true,
+                        mode: 'template',
+                        propertyPath: 'Properties.EnableDnsHostnames',
+                        oldValue: true,
+                        newValue: false,
+                        message: 'Template updated',
+                    },
+                ],
+                message: 'Reconciled 2 of 2 properties',
+            });
+
+            const result = await useCase.reconcileMultipleProperties({
+                stackIdentifier,
+                logicalId: 'MyVPC',
+                mismatches,
+                mode: 'template',
+            });
+
+            expect(result.reconciledCount).toBe(2);
+            expect(result.failedCount).toBe(0);
+            expect(result.results).toHaveLength(2);
+        });
+
+        it('should skip immutable properties and reconcile mutable ones', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const mismatches = [
+                new PropertyMismatch({
+                    propertyPath: 'Properties.EnableDnsSupport',
+                    expectedValue: true,
+                    actualValue: false,
+                    mutability: PropertyMutability.MUTABLE,
+                }),
+                new PropertyMismatch({
+                    propertyPath: 'Properties.CidrBlock',
+                    expectedValue: '10.0.0.0/16',
+                    actualValue: '10.1.0.0/16',
+                    mutability: PropertyMutability.IMMUTABLE,
+                }),
+            ];
+
+            // Mock first can be reconciled, second cannot
+            mockPropertyReconciler.canReconcile
+                .mockResolvedValueOnce(true)
+                .mockResolvedValueOnce(false);
+
+            // Mock reconciliation of the mutable property
+            mockPropertyReconciler.reconcileMultipleProperties.mockResolvedValue({
+                reconciledCount: 1,
+                failedCount: 0,
+                results: [
+                    {
+                        success: true,
+                        mode: 'template',
+                        propertyPath: 'Properties.EnableDnsSupport',
+                        oldValue: true,
+                        newValue: false,
+                        message: 'Template updated',
+                    },
+                ],
+                message: 'Reconciled 1 of 1 properties',
+            });
+
+            const result = await useCase.reconcileMultipleProperties({
+                stackIdentifier,
+                logicalId: 'MyVPC',
+                mismatches,
+                mode: 'template',
+            });
+
+            expect(result.reconciledCount).toBe(1); // One mutable property reconciled
+            expect(result.skippedCount).toBe(1); // One immutable property skipped
+            expect(result.reconcilableCount).toBe(1);
+            expect(result.results).toHaveLength(1);
+        });
+    });
+
+    describe('previewReconciliation', () => {
+        it('should preview reconciliation changes', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.EnableDnsSupport',
+                expectedValue: true,
+                actualValue: false,
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            // Mock preview
+            mockPropertyReconciler.previewReconciliation.mockResolvedValue({
+                canReconcile: true,
+                mode: 'template',
+                propertyPath: 'Properties.EnableDnsSupport',
+                currentValue: true,
+                proposedValue: false,
+                impact: 'Will update CloudFormation template to match actual resource state',
+                warnings: [],
+            });
+
+            const preview = await useCase.previewReconciliation({
+                stackIdentifier,
+                logicalId: 'MyVPC',
+                mismatch,
+                mode: 'template',
+            });
+
+            expect(preview.canReconcile).toBe(true);
+            expect(preview.mode).toBe('template');
+            expect(preview.impact).toContain('CloudFormation template');
+        });
+
+        it('should include warnings for risky reconciliations', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.EngineVersion',
+                expectedValue: '13.7',
+                actualValue: '13.8',
+                mutability: PropertyMutability.CONDITIONAL,
+            });
+
+            // Mock preview with warnings
+            mockPropertyReconciler.previewReconciliation.mockResolvedValue({
+                canReconcile: true,
+                mode: 'resource',
+                propertyPath: 'Properties.EngineVersion',
+                currentValue: '13.7',
+                proposedValue: '13.8',
+                impact: 'Will update database engine version - may cause downtime',
+                warnings: [
+                    'Engine version downgrade may not be supported',
+                    'Downtime may occur during version change',
+                ],
+            });
+
+            const preview = await useCase.previewReconciliation({
+                stackIdentifier,
+                logicalId: 'MyDBCluster',
+                mismatch,
+                mode: 'resource',
+            });
+
+            expect(preview.canReconcile).toBe(true);
+            expect(preview.warnings).toHaveLength(2);
+            expect(preview.warnings[0]).toContain('Engine version');
+        });
+    });
+
+    describe('constructor', () => {
+        it('should require propertyReconciler', () => {
+            expect(() => {
+                new ReconcilePropertiesUseCase({});
+            }).toThrow('propertyReconciler is required');
+        });
+    });
+});

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

@@ -0,0 +1,229 @@
+/**
+ * RepairViaImportUseCase - Import Orphaned Resources into CloudFormation Stack
+ *
+ * Application Layer - Use Case
+ *
+ * Business logic for the "frigg repair --import" command. Orchestrates resource
+ * import operations to fix orphaned resources by bringing them under CloudFormation management.
+ *
+ * Responsibilities:
+ * - Validate resources can be imported
+ * - Retrieve resource details from cloud
+ * - Generate CloudFormation template snippets
+ * - Execute import operations (single or batch)
+ * - Track import operation status
+ */
+
+class RepairViaImportUseCase {
+    /**
+     * Create use case with required dependencies
+     *
+     * @param {Object} params
+     * @param {IResourceImporter} params.resourceImporter - Resource import operations
+     * @param {IResourceDetector} params.resourceDetector - Resource discovery and details
+     */
+    constructor({ resourceImporter, resourceDetector }) {
+        if (!resourceImporter) {
+            throw new Error('resourceImporter is required');
+        }
+        if (!resourceDetector) {
+            throw new Error('resourceDetector is required');
+        }
+
+        this.resourceImporter = resourceImporter;
+        this.resourceDetector = resourceDetector;
+    }
+
+    /**
+     * Import a single orphaned resource into a CloudFormation stack
+     *
+     * @param {Object} params
+     * @param {StackIdentifier} params.stackIdentifier - Target stack
+     * @param {string} params.logicalId - Desired logical ID for resource in template
+     * @param {string} params.physicalId - Physical ID of resource in cloud
+     * @param {string} params.resourceType - CloudFormation resource type
+     * @returns {Promise<Object>} Import result
+     */
+    async importSingleResource({ stackIdentifier, logicalId, physicalId, resourceType }) {
+        // 1. Validate resource can be imported
+        const validation = await this.resourceImporter.validateImport({
+            resourceType,
+            physicalId,
+            region: stackIdentifier.region,
+        });
+
+        if (!validation.canImport) {
+            throw new Error(validation.reason);
+        }
+
+        // 2. Get detailed resource properties from cloud
+        const resourceDetails = await this.resourceDetector.getResourceDetails({
+            resourceType,
+            physicalId,
+            region: stackIdentifier.region,
+        });
+
+        // 3. Execute import operation
+        const importResult = await this.resourceImporter.importResource({
+            stackIdentifier,
+            logicalId,
+            resourceType,
+            physicalId,
+            properties: resourceDetails.properties,
+        });
+
+        // 4. Return result with warnings if any
+        return {
+            success: true,
+            operationId: importResult.operationId,
+            status: importResult.status,
+            message: importResult.message,
+            warnings: validation.warnings || [],
+            resource: {
+                logicalId,
+                physicalId,
+                resourceType,
+            },
+        };
+    }
+
+    /**
+     * Import multiple orphaned resources into a stack in batch
+     *
+     * @param {Object} params
+     * @param {StackIdentifier} params.stackIdentifier - Target stack
+     * @param {Array<Object>} params.resources - Resources to import
+     * @param {string} params.resources[].logicalId - Logical ID
+     * @param {string} params.resources[].physicalId - Physical ID
+     * @param {string} params.resources[].resourceType - Resource type
+     * @returns {Promise<Object>} Batch import result
+     */
+    async importMultipleResources({ stackIdentifier, resources }) {
+        const validationErrors = [];
+        const validResources = [];
+
+        // 1. Validate all resources first
+        for (const resource of resources) {
+            try {
+                const validation = await this.resourceImporter.validateImport({
+                    resourceType: resource.resourceType,
+                    physicalId: resource.physicalId,
+                    region: stackIdentifier.region,
+                });
+
+                if (!validation.canImport) {
+                    validationErrors.push({
+                        logicalId: resource.logicalId,
+                        physicalId: resource.physicalId,
+                        reason: validation.reason,
+                    });
+                    continue;
+                }
+
+                // Get resource details
+                const resourceDetails = await this.resourceDetector.getResourceDetails({
+                    resourceType: resource.resourceType,
+                    physicalId: resource.physicalId,
+                    region: stackIdentifier.region,
+                });
+
+                validResources.push({
+                    logicalId: resource.logicalId,
+                    resourceType: resource.resourceType,
+                    physicalId: resource.physicalId,
+                    properties: resourceDetails.properties,
+                });
+            } catch (error) {
+                validationErrors.push({
+                    logicalId: resource.logicalId,
+                    physicalId: resource.physicalId,
+                    reason: error.message,
+                });
+            }
+        }
+
+        // 2. If ANY validation failed, fail the entire batch (all-or-nothing approach)
+        if (validationErrors.length > 0) {
+            return {
+                success: false,
+                importedCount: 0,
+                failedCount: validationErrors.length,
+                validationErrors,
+                message: `${validationErrors.length} resource(s) failed validation - batch import aborted`,
+            };
+        }
+
+        // 3. All validations passed - import resources in batch
+        if (validResources.length > 0) {
+            const importResult = await this.resourceImporter.importMultipleResources({
+                stackIdentifier,
+                resources: validResources,
+            });
+
+            return {
+                success: true,
+                importedCount: importResult.importedCount,
+                failedCount: importResult.failedCount,
+                operationId: importResult.operationId,
+                status: importResult.status,
+                message: importResult.message,
+                details: importResult.details,
+            };
+        }
+
+        // 4. No resources provided
+        return {
+            success: false,
+            importedCount: 0,
+            failedCount: 0,
+            message: 'No resources provided for import',
+        };
+    }
+
+    /**
+     * Get status of an ongoing import operation
+     *
+     * @param {Object} params
+     * @param {string} params.operationId - CloudFormation change set ID
+     * @returns {Promise<Object>} Operation status
+     */
+    async getImportStatus({ operationId }) {
+        return await this.resourceImporter.getImportStatus(operationId);
+    }
+
+    /**
+     * Preview what template changes will be made for an import
+     *
+     * @param {Object} params
+     * @param {StackIdentifier} params.stackIdentifier - Target stack
+     * @param {string} params.logicalId - Desired logical ID
+     * @param {string} params.physicalId - Physical resource ID
+     * @param {string} params.resourceType - Resource type
+     * @returns {Promise<Object>} Preview with template snippet
+     */
+    async previewImport({ stackIdentifier, logicalId, physicalId, resourceType }) {
+        // Get resource details from cloud
+        const resourceDetails = await this.resourceDetector.getResourceDetails({
+            resourceType,
+            physicalId,
+            region: stackIdentifier.region,
+        });
+
+        // Generate template snippet
+        const templateSnippet = await this.resourceImporter.generateTemplateSnippet({
+            logicalId,
+            resourceType,
+            properties: resourceDetails.properties,
+        });
+
+        return {
+            logicalId,
+            physicalId,
+            resourceType,
+            templateSnippet,
+            properties: resourceDetails.properties,
+        };
+    }
+}
+
+module.exports = RepairViaImportUseCase;