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

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

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

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