@friggframework/devtools 2.0.0-next.45 → 2.0.0-next.47

package/infrastructure/domains/health/domain/services/__tests__/update-progress-monitor.test.js

@@ -0,0 +1,419 @@
+/**
+ * UpdateProgressMonitor Tests
+ *
+ * TDD tests for monitoring CloudFormation UPDATE operations
+ */
+
+const { UpdateProgressMonitor } = require('../update-progress-monitor');
+const StackIdentifier = require('../../../domain/value-objects/stack-identifier');
+
+// Mock timers for testing delays and timeouts
+jest.useFakeTimers();
+
+describe('UpdateProgressMonitor', () => {
+    let monitor;
+    let mockCFRepo;
+    let onProgressCallback;
+
+    beforeEach(() => {
+        // Reset mock CloudFormation repository
+        mockCFRepo = {
+            getStackEvents: jest.fn(),
+            getStackStatus: jest.fn(),
+        };
+
+        // Reset progress callback
+        onProgressCallback = jest.fn();
+
+        // Create monitor instance
+        monitor = new UpdateProgressMonitor({
+            cloudFormationRepository: mockCFRepo,
+        });
+
+        // Clear all timers
+        jest.clearAllTimers();
+    });
+
+    afterEach(() => {
+        jest.clearAllTimers();
+    });
+
+    describe('constructor', () => {
+        it('should require cloudFormationRepository', () => {
+            expect(() => new UpdateProgressMonitor({})).toThrow(
+                'cloudFormationRepository is required'
+            );
+        });
+
+        it('should create instance with valid dependencies', () => {
+            const monitor = new UpdateProgressMonitor({
+                cloudFormationRepository: mockCFRepo,
+            });
+            expect(monitor).toBeInstanceOf(UpdateProgressMonitor);
+        });
+    });
+
+    describe('monitorUpdate - successful update', () => {
+        it('should monitor single resource update to completion', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'test-stack',
+                region: 'us-east-1',
+            });
+
+            const resourceLogicalIds = ['AttioLambdaFunction'];
+
+            // Mock stack events sequence
+            mockCFRepo.getStackEvents
+                // First poll: UPDATE_IN_PROGRESS
+                .mockResolvedValueOnce([
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:01Z'),
+                    },
+                ])
+                // Second poll: UPDATE_COMPLETE
+                .mockResolvedValueOnce([
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:01Z'),
+                    },
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_COMPLETE',
+                        Timestamp: new Date('2025-01-01T00:00:05Z'),
+                    },
+                ]);
+
+            // Mock stack status
+            mockCFRepo.getStackStatus.mockResolvedValue('UPDATE_COMPLETE');
+
+            // Start monitoring in background
+            const monitorPromise = monitor.monitorUpdate({
+                stackIdentifier,
+                resourceLogicalIds,
+                onProgress: onProgressCallback,
+            });
+
+            // Advance timers to trigger first poll (2 seconds)
+            await jest.advanceTimersByTimeAsync(2000);
+
+            // Advance timers to trigger second poll (2 more seconds)
+            await jest.advanceTimersByTimeAsync(2000);
+
+            // Wait for monitoring to complete
+            const result = await monitorPromise;
+
+            // Verify result
+            expect(result.success).toBe(true);
+            expect(result.updatedCount).toBe(1);
+            expect(result.failedCount).toBe(0);
+
+            // Verify progress callbacks
+            expect(onProgressCallback).toHaveBeenCalledWith({
+                logicalId: 'AttioLambdaFunction',
+                status: 'IN_PROGRESS',
+            });
+            expect(onProgressCallback).toHaveBeenCalledWith({
+                logicalId: 'AttioLambdaFunction',
+                status: 'COMPLETE',
+                progress: 1,
+                total: 1,
+            });
+        });
+
+        it('should monitor multiple resources updating simultaneously', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'test-stack',
+                region: 'us-east-1',
+            });
+
+            const resourceLogicalIds = [
+                'AttioLambdaFunction',
+                'PipedriveLambdaFunction',
+                'ZohoCrmLambdaFunction',
+            ];
+
+            // Mock stack events - all resources update together
+            mockCFRepo.getStackEvents
+                // First poll: All IN_PROGRESS
+                .mockResolvedValueOnce([
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:01Z'),
+                    },
+                    {
+                        LogicalResourceId: 'PipedriveLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:02Z'),
+                    },
+                    {
+                        LogicalResourceId: 'ZohoCrmLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:03Z'),
+                    },
+                ])
+                // Second poll: First complete
+                .mockResolvedValueOnce([
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:01Z'),
+                    },
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_COMPLETE',
+                        Timestamp: new Date('2025-01-01T00:00:10Z'),
+                    },
+                    {
+                        LogicalResourceId: 'PipedriveLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:02Z'),
+                    },
+                    {
+                        LogicalResourceId: 'ZohoCrmLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:03Z'),
+                    },
+                ])
+                // Third poll: All complete
+                .mockResolvedValueOnce([
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_COMPLETE',
+                        Timestamp: new Date('2025-01-01T00:00:10Z'),
+                    },
+                    {
+                        LogicalResourceId: 'PipedriveLambdaFunction',
+                        ResourceStatus: 'UPDATE_COMPLETE',
+                        Timestamp: new Date('2025-01-01T00:00:11Z'),
+                    },
+                    {
+                        LogicalResourceId: 'ZohoCrmLambdaFunction',
+                        ResourceStatus: 'UPDATE_COMPLETE',
+                        Timestamp: new Date('2025-01-01T00:00:12Z'),
+                    },
+                ]);
+
+            mockCFRepo.getStackStatus.mockResolvedValue('UPDATE_COMPLETE');
+
+            const monitorPromise = monitor.monitorUpdate({
+                stackIdentifier,
+                resourceLogicalIds,
+                onProgress: onProgressCallback,
+            });
+
+            // Advance through polling intervals
+            await jest.advanceTimersByTimeAsync(2000);
+            await jest.advanceTimersByTimeAsync(2000);
+            await jest.advanceTimersByTimeAsync(2000);
+
+            const result = await monitorPromise;
+
+            expect(result.success).toBe(true);
+            expect(result.updatedCount).toBe(3);
+            expect(result.failedCount).toBe(0);
+        });
+    });
+
+    describe('monitorUpdate - failed updates', () => {
+        it('should detect and report UPDATE_FAILED resources', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'test-stack',
+                region: 'us-east-1',
+            });
+
+            const resourceLogicalIds = ['AttioLambdaFunction'];
+
+            mockCFRepo.getStackEvents
+                .mockResolvedValueOnce([
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:01Z'),
+                    },
+                ])
+                .mockResolvedValueOnce([
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:01Z'),
+                    },
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_FAILED',
+                        ResourceStatusReason: 'Subnet does not exist: subnet-invalid',
+                        Timestamp: new Date('2025-01-01T00:00:05Z'),
+                    },
+                ]);
+
+            mockCFRepo.getStackStatus.mockResolvedValue('UPDATE_ROLLBACK_COMPLETE');
+
+            const monitorPromise = monitor.monitorUpdate({
+                stackIdentifier,
+                resourceLogicalIds,
+                onProgress: onProgressCallback,
+            });
+
+            await jest.advanceTimersByTimeAsync(2000);
+            await jest.advanceTimersByTimeAsync(2000);
+
+            const result = await monitorPromise;
+
+            expect(result.success).toBe(false);
+            expect(result.updatedCount).toBe(0);
+            expect(result.failedCount).toBe(1);
+            expect(result.failedResources).toHaveLength(1);
+            expect(result.failedResources[0].logicalId).toBe('AttioLambdaFunction');
+            expect(result.failedResources[0].reason).toBe('Subnet does not exist: subnet-invalid');
+
+            // Verify FAILED callback was triggered
+            expect(onProgressCallback).toHaveBeenCalledWith({
+                logicalId: 'AttioLambdaFunction',
+                status: 'FAILED',
+                reason: 'Subnet does not exist: subnet-invalid',
+            });
+        });
+
+        it('should detect stack rollback during update', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'test-stack',
+                region: 'us-east-1',
+            });
+
+            const resourceLogicalIds = ['AttioLambdaFunction'];
+
+            mockCFRepo.getStackEvents.mockResolvedValue([
+                {
+                    LogicalResourceId: 'AttioLambdaFunction',
+                    ResourceStatus: 'UPDATE_IN_PROGRESS',
+                    Timestamp: new Date('2025-01-01T00:00:01Z'),
+                },
+            ]);
+
+            // Stack status shows rollback in progress
+            mockCFRepo.getStackStatus.mockResolvedValue('UPDATE_ROLLBACK_IN_PROGRESS');
+
+            const monitorPromise = monitor.monitorUpdate({
+                stackIdentifier,
+                resourceLogicalIds,
+                onProgress: onProgressCallback,
+            });
+
+            await jest.advanceTimersByTimeAsync(2000);
+
+            await expect(monitorPromise).rejects.toThrow('Update operation failed and rolled back');
+        });
+    });
+
+    describe('monitorUpdate - timeout handling', () => {
+        it('should timeout after 5 minutes', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'test-stack',
+                region: 'us-east-1',
+            });
+
+            const resourceLogicalIds = ['AttioLambdaFunction'];
+
+            // Mock events that never complete
+            mockCFRepo.getStackEvents.mockResolvedValue([
+                {
+                    LogicalResourceId: 'AttioLambdaFunction',
+                    ResourceStatus: 'UPDATE_IN_PROGRESS',
+                    Timestamp: new Date('2025-01-01T00:00:01Z'),
+                },
+            ]);
+
+            mockCFRepo.getStackStatus.mockResolvedValue('UPDATE_IN_PROGRESS');
+
+            const monitorPromise = monitor.monitorUpdate({
+                stackIdentifier,
+                resourceLogicalIds,
+                onProgress: onProgressCallback,
+            });
+
+            // Advance past 5 minute timeout (300000ms)
+            await jest.advanceTimersByTimeAsync(300000 + 2000);
+
+            await expect(monitorPromise).rejects.toThrow('Update operation timed out');
+        });
+    });
+
+    describe('monitorUpdate - event deduplication', () => {
+        it('should not process duplicate events', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'test-stack',
+                region: 'us-east-1',
+            });
+
+            const resourceLogicalIds = ['AttioLambdaFunction'];
+
+            // Mock duplicate events (same timestamp + logicalId + status)
+            mockCFRepo.getStackEvents
+                .mockResolvedValueOnce([
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:01Z'),
+                    },
+                ])
+                .mockResolvedValueOnce([
+                    // Duplicate event
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_IN_PROGRESS',
+                        Timestamp: new Date('2025-01-01T00:00:01Z'),
+                    },
+                    // New event
+                    {
+                        LogicalResourceId: 'AttioLambdaFunction',
+                        ResourceStatus: 'UPDATE_COMPLETE',
+                        Timestamp: new Date('2025-01-01T00:00:05Z'),
+                    },
+                ]);
+
+            mockCFRepo.getStackStatus.mockResolvedValue('UPDATE_COMPLETE');
+
+            const monitorPromise = monitor.monitorUpdate({
+                stackIdentifier,
+                resourceLogicalIds,
+                onProgress: onProgressCallback,
+            });
+
+            await jest.advanceTimersByTimeAsync(2000);
+            await jest.advanceTimersByTimeAsync(2000);
+
+            await monitorPromise;
+
+            // IN_PROGRESS callback should only be called once (not twice for duplicate)
+            const inProgressCalls = onProgressCallback.mock.calls.filter(
+                (call) => call[0].status === 'IN_PROGRESS'
+            );
+            expect(inProgressCalls).toHaveLength(1);
+        });
+    });
+
+    describe('monitorUpdate - no resources to track', () => {
+        it('should return immediately if no resources to track', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'test-stack',
+                region: 'us-east-1',
+            });
+
+            const result = await monitor.monitorUpdate({
+                stackIdentifier,
+                resourceLogicalIds: [],
+                onProgress: onProgressCallback,
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.updatedCount).toBe(0);
+            expect(result.failedCount).toBe(0);
+
+            // Should not have polled CloudFormation
+            expect(mockCFRepo.getStackEvents).not.toHaveBeenCalled();
+        });
+    });
+});

package/infrastructure/domains/health/domain/services/health-score-calculator.js

@@ -0,0 +1,248 @@
+/**
+ * HealthScoreCalculator Domain Service
+ *
+ * Calculates health scores (0-100) based on percentage-based penalties
+ * weighted by resource criticality.
+ *
+ * Resource Criticality:
+ * - Critical: Lambda, RDS, DynamoDB (affect application functionality)
+ * - Infrastructure: VPC, Subnet, SecurityGroup, KMS, etc.
+ *
+ * Percentage-Based Penalties (max 100 points):
+ * - Critical issues (orphaned, missing): up to 50 points (% of total resources)
+ * - Functional drift: up to 30 points (% of critical resources drifted)
+ * - Infrastructure drift: up to 20 points (% of infrastructure resources drifted)
+ *
+ * Example: 16/16 Lambdas drifted = 100% functional drift = 30 penalty → 70/100 score
+ */
+
+const HealthScore = require('../value-objects/health-score');
+
+class HealthScoreCalculator {
+    /**
+     * Critical resource types that affect application functionality
+     * @private
+     */
+    static CRITICAL_RESOURCE_TYPES = [
+        'AWS::Lambda::Function',
+        'AWS::RDS::DBCluster',
+        'AWS::RDS::DBInstance',
+        'AWS::DynamoDB::Table',
+    ];
+
+    /**
+     * Maximum penalties for each category (sum = 100)
+     * @private
+     */
+    static MAX_PENALTIES = {
+        criticalIssues: 50, // Orphaned resources, missing resources
+        functionalDrift: 30, // Drift on critical resources (Lambda, RDS, DynamoDB)
+        infrastructureDrift: 20, // Drift on infrastructure resources (VPC, networking, KMS)
+    };
+
+    /**
+     * Create a new HealthScoreCalculator
+     *
+     * @param {Object} [config={}]
+     * @param {Object} [config.maxPenalties] - Custom max penalty configuration
+     * @param {number} [config.maxPenalties.criticalIssues] - Max penalty for critical issues (default: 50)
+     * @param {number} [config.maxPenalties.functionalDrift] - Max penalty for functional drift (default: 30)
+     * @param {number} [config.maxPenalties.infrastructureDrift] - Max penalty for infra drift (default: 20)
+     */
+    constructor(config = {}) {
+        this.maxPenalties = {
+            ...HealthScoreCalculator.MAX_PENALTIES,
+            ...(config.maxPenalties || {}),
+        };
+    }
+
+    /**
+     * Check if resource type is critical (affects functionality)
+     * @private
+     */
+    _isCriticalResourceType(resourceType) {
+        return HealthScoreCalculator.CRITICAL_RESOURCE_TYPES.includes(resourceType);
+    }
+
+    /**
+     * Calculate health score based on percentage-based penalties
+     *
+     * @param {Object} params
+     * @param {Resource[]} params.resources - Resources in the stack
+     * @param {Issue[]} params.issues - Detected issues
+     * @returns {HealthScore}
+     */
+    calculate({ resources, issues }) {
+        const startingScore = 100;
+
+        // Handle empty stack edge case
+        if (resources.length === 0) {
+            return new HealthScore(startingScore);
+        }
+
+        // Categorize resources by criticality
+        const criticalResources = resources.filter((r) =>
+            this._isCriticalResourceType(r.resourceType)
+        );
+        const infraResources = resources.filter(
+            (r) => !this._isCriticalResourceType(r.resourceType)
+        );
+
+        // Count issues by category
+        const criticalIssues = issues.filter(
+            (issue) => issue.type === 'ORPHANED_RESOURCE' || issue.type === 'MISSING_RESOURCE'
+        );
+        const functionalDriftIssues = issues.filter(
+            (issue) =>
+                issue.type === 'PROPERTY_MISMATCH' &&
+                this._isCriticalResourceType(issue.resourceType)
+        );
+        const infraDriftIssues = issues.filter(
+            (issue) =>
+                issue.type === 'PROPERTY_MISMATCH' &&
+                !this._isCriticalResourceType(issue.resourceType)
+        );
+
+        // Calculate percentage-based penalties
+        let totalPenalty = 0;
+
+        // 1. Critical issues penalty (up to 50 points)
+        if (criticalIssues.length > 0) {
+            const criticalImpactPercent = criticalIssues.length / resources.length;
+            totalPenalty += criticalImpactPercent * this.maxPenalties.criticalIssues;
+        }
+
+        // 2. Functional drift penalty (up to 30 points)
+        if (functionalDriftIssues.length > 0 && criticalResources.length > 0) {
+            // Get unique drifted critical resources
+            const driftedCriticalResourceIds = new Set(
+                functionalDriftIssues.map((issue) => issue.resourceId)
+            );
+            const functionalDriftPercent =
+                driftedCriticalResourceIds.size / criticalResources.length;
+            totalPenalty += functionalDriftPercent * this.maxPenalties.functionalDrift;
+        }
+
+        // 3. Infrastructure drift penalty (up to 20 points)
+        if (infraDriftIssues.length > 0 && infraResources.length > 0) {
+            // Get unique drifted infrastructure resources
+            const driftedInfraResourceIds = new Set(
+                infraDriftIssues.map((issue) => issue.resourceId)
+            );
+            const infraDriftPercent = driftedInfraResourceIds.size / infraResources.length;
+            totalPenalty += infraDriftPercent * this.maxPenalties.infrastructureDrift;
+        }
+
+        // Calculate final score (capped at 0)
+        const finalScore = Math.max(0, Math.round(startingScore - totalPenalty));
+
+        return new HealthScore(finalScore);
+    }
+
+    /**
+     * Explain the score calculation with detailed percentage-based breakdown
+     *
+     * @param {Object} params
+     * @param {Resource[]} params.resources - Resources in the stack
+     * @param {Issue[]} params.issues - Detected issues
+     * @returns {Object} Explanation with breakdown
+     */
+    explainScore({ resources, issues }) {
+        const startingScore = 100;
+
+        if (resources.length === 0) {
+            return {
+                finalScore: startingScore,
+                startingScore,
+                totalPenalty: 0,
+                breakdown: {
+                    criticalIssues: { count: 0, impactPercent: 0, penalty: 0 },
+                    functionalDrift: { count: 0, impactPercent: 0, penalty: 0 },
+                    infrastructureDrift: { count: 0, impactPercent: 0, penalty: 0 },
+                },
+            };
+        }
+
+        // Categorize resources
+        const criticalResources = resources.filter((r) =>
+            this._isCriticalResourceType(r.resourceType)
+        );
+        const infraResources = resources.filter(
+            (r) => !this._isCriticalResourceType(r.resourceType)
+        );
+
+        // Count issues by category
+        const criticalIssues = issues.filter(
+            (issue) => issue.type === 'ORPHANED_RESOURCE' || issue.type === 'MISSING_RESOURCE'
+        );
+        const functionalDriftIssues = issues.filter(
+            (issue) =>
+                issue.type === 'PROPERTY_MISMATCH' &&
+                this._isCriticalResourceType(issue.resourceType)
+        );
+        const infraDriftIssues = issues.filter(
+            (issue) =>
+                issue.type === 'PROPERTY_MISMATCH' &&
+                !this._isCriticalResourceType(issue.resourceType)
+        );
+
+        // Calculate penalties
+        const breakdown = {
+            criticalIssues: {
+                count: criticalIssues.length,
+                impactPercent: criticalIssues.length / resources.length,
+                penalty:
+                    (criticalIssues.length / resources.length) * this.maxPenalties.criticalIssues,
+            },
+            functionalDrift: {
+                count: functionalDriftIssues.length,
+                impactPercent:
+                    criticalResources.length > 0
+                        ? new Set(functionalDriftIssues.map((i) => i.resourceId)).size /
+                          criticalResources.length
+                        : 0,
+                penalty:
+                    criticalResources.length > 0
+                        ? (new Set(functionalDriftIssues.map((i) => i.resourceId)).size /
+                              criticalResources.length) *
+                          this.maxPenalties.functionalDrift
+                        : 0,
+            },
+            infrastructureDrift: {
+                count: infraDriftIssues.length,
+                impactPercent:
+                    infraResources.length > 0
+                        ? new Set(infraDriftIssues.map((i) => i.resourceId)).size /
+                          infraResources.length
+                        : 0,
+                penalty:
+                    infraResources.length > 0
+                        ? (new Set(infraDriftIssues.map((i) => i.resourceId)).size /
+                              infraResources.length) *
+                          this.maxPenalties.infrastructureDrift
+                        : 0,
+            },
+        };
+
+        const totalPenalty =
+            breakdown.criticalIssues.penalty +
+            breakdown.functionalDrift.penalty +
+            breakdown.infrastructureDrift.penalty;
+
+        const finalScore = Math.max(0, Math.round(startingScore - totalPenalty));
+
+        return {
+            finalScore,
+            startingScore,
+            totalPenalty: Math.round(totalPenalty * 100) / 100, // Round to 2 decimal places
+            breakdown,
+            resourceCounts: {
+                total: resources.length,
+                critical: criticalResources.length,
+                infrastructure: infraResources.length,
+            },
+        };
+    }
+}
+
+module.exports = HealthScoreCalculator;