@friggframework/devtools 2.0.0--canary.474.6a0bba7.0 → 2.0.0--canary.474.a794ea3.0

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/import-progress-monitor.js

@@ -0,0 +1,195 @@
+/**
+ * ImportProgressMonitor - Monitor CloudFormation Import Operation Progress
+ *
+ * Domain Layer - Service
+ *
+ * Monitors CloudFormation import operations by polling stack events and tracking
+ * resource import progress. Provides real-time progress callbacks and detects
+ * failures, rollbacks, and timeouts.
+ *
+ * Responsibilities:
+ * - Poll CloudFormation stack events during import
+ * - Track progress per resource (IN_PROGRESS, COMPLETE, FAILED)
+ * - Detect stack rollback states
+ * - Timeout after 5 minutes
+ * - Provide progress callbacks for UI updates
+ */
+
+class ImportProgressMonitor {
+  /**
+   * Create progress monitor with CloudFormation repository dependency
+   *
+   * @param {Object} params
+   * @param {Object} params.cloudFormationRepository - CloudFormation operations
+   */
+  constructor({ cloudFormationRepository }) {
+    if (!cloudFormationRepository) {
+      throw new Error('cloudFormationRepository is required');
+    }
+    this.cfRepo = cloudFormationRepository;
+  }
+
+  /**
+   * Monitor import operation progress
+   *
+   * Polls CloudFormation stack events every 2 seconds to track resource import progress.
+   * Calls onProgress callback with status updates for each resource.
+   * Detects failures, rollbacks, and timeouts.
+   *
+   * @param {Object} params
+   * @param {Object} params.stackIdentifier - Stack identifier { stackName, region }
+   * @param {Array<string>} params.resourceLogicalIds - Logical IDs to track
+   * @param {Function} params.onProgress - Progress callback function
+   * @returns {Promise<Object>} Import result
+   */
+  async monitorImport({ stackIdentifier, resourceLogicalIds, onProgress }) {
+    const importedResources = new Set();
+    const failedResources = [];
+    const processedEvents = new Set(); // Track processed events by timestamp + logicalId
+    let elapsedTime = 0; // Track elapsed time manually for fake timers compatibility
+    const TIMEOUT_MS = 300000; // 5 minutes
+    const POLL_INTERVAL_MS = 2000; // 2 seconds
+
+    // Continue polling until all resources are complete or failed
+    while (
+      importedResources.size + failedResources.length <
+      resourceLogicalIds.length
+    ) {
+      // Wait 2 seconds before polling
+      await this._delay(POLL_INTERVAL_MS);
+      elapsedTime += POLL_INTERVAL_MS;
+
+      // Check for timeout
+      if (elapsedTime > TIMEOUT_MS) {
+        throw new Error('Import operation timed out');
+      }
+
+      // Get stack events
+      const events = await this.cfRepo.getStackEvents({
+        stackIdentifier,
+      });
+
+      // Sort events by timestamp (oldest first) for consistent processing
+      const sortedEvents = [...events].sort(
+        (a, b) => new Date(a.Timestamp) - new Date(b.Timestamp)
+      );
+
+      // Track if we processed any new events in this iteration
+      let processedNewEvents = false;
+
+      // Process events for tracked resources
+      for (const event of sortedEvents) {
+        const logicalId = event.LogicalResourceId;
+
+        // Skip if not a tracked resource
+        if (!resourceLogicalIds.includes(logicalId)) {
+          continue;
+        }
+
+        // Create unique event key to avoid duplicate processing
+        const eventKey = `${event.Timestamp.toISOString()}_${logicalId}_${event.ResourceStatus}`;
+
+        // Skip if already processed
+        if (processedEvents.has(eventKey)) {
+          continue;
+        }
+
+        processedEvents.add(eventKey);
+        processedNewEvents = true;
+
+        // Handle different resource statuses
+        if (event.ResourceStatus === 'IMPORT_IN_PROGRESS') {
+          // Call progress callback with IN_PROGRESS status
+          if (onProgress) {
+            onProgress({
+              logicalId,
+              status: 'IN_PROGRESS',
+            });
+          }
+        } else if (event.ResourceStatus === 'IMPORT_COMPLETE' || event.ResourceStatus === 'UPDATE_COMPLETE') {
+          // Mark resource as imported
+          // Note: CloudFormation sends IMPORT_COMPLETE then UPDATE_COMPLETE (for tagging)
+          // We count either as successfully imported
+          importedResources.add(logicalId);
+
+          // Call progress callback with COMPLETE status
+          if (onProgress) {
+            onProgress({
+              logicalId,
+              status: 'COMPLETE',
+              progress: importedResources.size,
+              total: resourceLogicalIds.length,
+            });
+          }
+        } else if (event.ResourceStatus === 'IMPORT_FAILED') {
+          // Add to failed resources
+          const reason = event.ResourceStatusReason || 'Unknown error';
+          failedResources.push({
+            logicalId,
+            reason,
+          });
+
+          // Call progress callback with FAILED status
+          if (onProgress) {
+            onProgress({
+              logicalId,
+              status: 'FAILED',
+              reason,
+            });
+          }
+        }
+      }
+
+      // Check if all resources are now accounted for
+      const allResourcesProcessed =
+        importedResources.size + failedResources.length >=
+        resourceLogicalIds.length;
+
+      // If all resources processed, exit loop to return result
+      if (allResourcesProcessed) {
+        break;
+      }
+
+      // Check stack status AFTER processing events - if rollback in progress, throw
+      const stackStatus = await this.cfRepo.getStackStatus(stackIdentifier);
+      if (stackStatus.includes('ROLLBACK') && stackStatus !== 'IMPORT_ROLLBACK_COMPLETE') {
+        throw new Error('Import operation failed and rolled back');
+      }
+    }
+
+    // Check final stack status before returning
+    const finalStackStatus = await this.cfRepo.getStackStatus(stackIdentifier);
+
+    // If stack rolled back completely and monitoring just finished,
+    // check if we should throw or return
+    if (finalStackStatus.includes('ROLLBACK')) {
+      // If we have any imported resources, return result (partial success)
+      // Otherwise, throw error (complete failure)
+      if (importedResources.size === 0 && failedResources.length > 0) {
+        throw new Error('Import operation failed and rolled back');
+      }
+    }
+
+    // Return result
+    const success = failedResources.length === 0;
+    return {
+      success,
+      importedCount: importedResources.size,
+      failedCount: failedResources.length,
+      failedResources,
+    };
+  }
+
+  /**
+   * Delay helper for polling intervals
+   *
+   * @param {number} ms - Milliseconds to delay
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+module.exports = { ImportProgressMonitor };