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

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

@@ -0,0 +1,192 @@
+/**
+ * UpdateProgressMonitor - Monitor CloudFormation Update Operation Progress
+ *
+ * Domain Layer - Service
+ *
+ * Monitors CloudFormation UPDATE operations by polling stack events and tracking
+ * resource update progress. Provides real-time progress callbacks and detects
+ * failures, rollbacks, and timeouts.
+ *
+ * Responsibilities:
+ * - Poll CloudFormation stack events during update
+ * - Track progress per resource (IN_PROGRESS, COMPLETE, FAILED)
+ * - Detect stack rollback states
+ * - Timeout after 5 minutes
+ * - Provide progress callbacks for UI updates
+ */
+
+class UpdateProgressMonitor {
+  /**
+   * 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 update operation progress
+   *
+   * Polls CloudFormation stack events every 2 seconds to track resource update 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>} Update result
+   */
+  async monitorUpdate({ stackIdentifier, resourceLogicalIds, onProgress }) {
+    // If no resources to track, return immediately
+    if (!resourceLogicalIds || resourceLogicalIds.length === 0) {
+      return {
+        success: true,
+        updatedCount: 0,
+        failedCount: 0,
+        failedResources: [],
+      };
+    }
+
+    const updatedResources = 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 (
+      updatedResources.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('Update 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)
+      );
+
+      // 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);
+
+        // Handle different resource statuses
+        if (event.ResourceStatus === 'UPDATE_IN_PROGRESS') {
+          // Call progress callback with IN_PROGRESS status
+          if (onProgress) {
+            onProgress({
+              logicalId,
+              status: 'IN_PROGRESS',
+            });
+          }
+        } else if (event.ResourceStatus === 'UPDATE_COMPLETE') {
+          // Mark resource as updated
+          updatedResources.add(logicalId);
+
+          // Call progress callback with COMPLETE status
+          if (onProgress) {
+            onProgress({
+              logicalId,
+              status: 'COMPLETE',
+              progress: updatedResources.size,
+              total: resourceLogicalIds.length,
+            });
+          }
+        } else if (event.ResourceStatus === 'UPDATE_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 =
+        updatedResources.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 !== 'UPDATE_ROLLBACK_COMPLETE'
+      ) {
+        throw new Error('Update operation failed and rolled back');
+      }
+    }
+
+    // Check final stack status before returning
+    const finalStackStatus = await this.cfRepo.getStackStatus(stackIdentifier);
+
+    // Return result (success = no failures)
+    const success = failedResources.length === 0;
+    return {
+      success,
+      updatedCount: updatedResources.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 = { UpdateProgressMonitor };

package/infrastructure/domains/health/domain/value-objects/health-score.js

@@ -0,0 +1,138 @@
+/**
+ * HealthScore Value Object
+ *
+ * Immutable health score from 0-100 with qualitative assessment
+ * - 80-100: healthy
+ * - 40-79: degraded
+ * - 0-39: unhealthy
+ */
+
+class HealthScore {
+    /**
+     * Create a new HealthScore
+     *
+     * @param {number} value - Score from 0 to 100
+     */
+    constructor(value) {
+        // Validate type
+        if (typeof value !== 'number' || isNaN(value) || !isFinite(value)) {
+            throw new Error('Health score must be a number');
+        }
+
+        // Validate range
+        if (value < 0 || value > 100) {
+            throw new Error('Health score must be between 0 and 100');
+        }
+
+        // Assign property
+        this._value = value;
+
+        // Make immutable
+        Object.freeze(this);
+    }
+
+    /**
+     * Get score value
+     * @returns {number}
+     */
+    get value() {
+        return this._value;
+    }
+
+    /**
+     * Prevent modification of value
+     * @throws {TypeError}
+     */
+    set value(newValue) {
+        throw new TypeError('Cannot modify immutable property value');
+    }
+
+    /**
+     * Get qualitative assessment
+     *
+     * @returns {'healthy' | 'degraded' | 'unhealthy'}
+     */
+    qualitativeAssessment() {
+        if (this._value >= 80) {
+            return 'healthy';
+        } else if (this._value >= 40) {
+            return 'degraded';
+        } else {
+            return 'unhealthy';
+        }
+    }
+
+    /**
+     * Check if score is healthy (>= 80)
+     *
+     * @returns {boolean}
+     */
+    isHealthy() {
+        return this._value >= 80;
+    }
+
+    /**
+     * Check if score is degraded (40-79)
+     *
+     * @returns {boolean}
+     */
+    isDegraded() {
+        return this._value >= 40 && this._value < 80;
+    }
+
+    /**
+     * Check if score is unhealthy (< 40)
+     *
+     * @returns {boolean}
+     */
+    isUnhealthy() {
+        return this._value < 40;
+    }
+
+    /**
+     * Get string representation
+     *
+     * @returns {string}
+     */
+    toString() {
+        return `${this._value} (${this.qualitativeAssessment()})`;
+    }
+
+    /**
+     * Create perfect health score (100)
+     *
+     * @returns {HealthScore}
+     */
+    static perfect() {
+        return new HealthScore(100);
+    }
+
+    /**
+     * Create failed health score (0)
+     *
+     * @returns {HealthScore}
+     */
+    static failed() {
+        return new HealthScore(0);
+    }
+
+    /**
+     * Create HealthScore from percentage (0.0 to 1.0)
+     *
+     * @param {number} percentage - Percentage as decimal (0.75 = 75%)
+     * @returns {HealthScore}
+     */
+    static fromPercentage(percentage) {
+        if (typeof percentage !== 'number' || isNaN(percentage) || !isFinite(percentage)) {
+            throw new Error('Percentage must be a number');
+        }
+
+        if (percentage < 0 || percentage > 1) {
+            throw new Error('Percentage must be between 0 and 1');
+        }
+
+        return new HealthScore(Math.round(percentage * 100));
+    }
+}
+
+module.exports = HealthScore;

package/infrastructure/domains/health/domain/value-objects/health-score.test.js

@@ -0,0 +1,267 @@
+/**
+ * Tests for HealthScore Value Object
+ */
+
+const HealthScore = require('./health-score');
+
+describe('HealthScore', () => {
+    describe('constructor', () => {
+        it('should create health score with valid value', () => {
+            const score = new HealthScore(75);
+
+            expect(score.value).toBe(75);
+        });
+
+        it('should accept 0 as minimum score', () => {
+            const score = new HealthScore(0);
+
+            expect(score.value).toBe(0);
+        });
+
+        it('should accept 100 as maximum score', () => {
+            const score = new HealthScore(100);
+
+            expect(score.value).toBe(100);
+        });
+
+        it('should reject negative scores', () => {
+            expect(() => {
+                new HealthScore(-1);
+            }).toThrow('Health score must be between 0 and 100');
+        });
+
+        it('should reject scores above 100', () => {
+            expect(() => {
+                new HealthScore(101);
+            }).toThrow('Health score must be between 0 and 100');
+        });
+
+        it('should reject non-numeric scores', () => {
+            expect(() => {
+                new HealthScore('75');
+            }).toThrow('Health score must be a number');
+        });
+
+        it('should reject NaN', () => {
+            expect(() => {
+                new HealthScore(NaN);
+            }).toThrow('Health score must be a number');
+        });
+
+        it('should reject Infinity', () => {
+            expect(() => {
+                new HealthScore(Infinity);
+            }).toThrow('Health score must be a number');
+        });
+    });
+
+    describe('qualitativeAssessment', () => {
+        it('should return "healthy" for score 100', () => {
+            const score = new HealthScore(100);
+
+            expect(score.qualitativeAssessment()).toBe('healthy');
+        });
+
+        it('should return "healthy" for score 90', () => {
+            const score = new HealthScore(90);
+
+            expect(score.qualitativeAssessment()).toBe('healthy');
+        });
+
+        it('should return "healthy" for score 80', () => {
+            const score = new HealthScore(80);
+
+            expect(score.qualitativeAssessment()).toBe('healthy');
+        });
+
+        it('should return "degraded" for score 79', () => {
+            const score = new HealthScore(79);
+
+            expect(score.qualitativeAssessment()).toBe('degraded');
+        });
+
+        it('should return "degraded" for score 50', () => {
+            const score = new HealthScore(50);
+
+            expect(score.qualitativeAssessment()).toBe('degraded');
+        });
+
+        it('should return "degraded" for score 40', () => {
+            const score = new HealthScore(40);
+
+            expect(score.qualitativeAssessment()).toBe('degraded');
+        });
+
+        it('should return "unhealthy" for score 39', () => {
+            const score = new HealthScore(39);
+
+            expect(score.qualitativeAssessment()).toBe('unhealthy');
+        });
+
+        it('should return "unhealthy" for score 0', () => {
+            const score = new HealthScore(0);
+
+            expect(score.qualitativeAssessment()).toBe('unhealthy');
+        });
+    });
+
+    describe('isHealthy', () => {
+        it('should return true for score 80', () => {
+            const score = new HealthScore(80);
+
+            expect(score.isHealthy()).toBe(true);
+        });
+
+        it('should return true for score 100', () => {
+            const score = new HealthScore(100);
+
+            expect(score.isHealthy()).toBe(true);
+        });
+
+        it('should return false for score 79', () => {
+            const score = new HealthScore(79);
+
+            expect(score.isHealthy()).toBe(false);
+        });
+
+        it('should return false for score 0', () => {
+            const score = new HealthScore(0);
+
+            expect(score.isHealthy()).toBe(false);
+        });
+    });
+
+    describe('isDegraded', () => {
+        it('should return true for score 79', () => {
+            const score = new HealthScore(79);
+
+            expect(score.isDegraded()).toBe(true);
+        });
+
+        it('should return true for score 40', () => {
+            const score = new HealthScore(40);
+
+            expect(score.isDegraded()).toBe(true);
+        });
+
+        it('should return false for score 80', () => {
+            const score = new HealthScore(80);
+
+            expect(score.isDegraded()).toBe(false);
+        });
+
+        it('should return false for score 39', () => {
+            const score = new HealthScore(39);
+
+            expect(score.isDegraded()).toBe(false);
+        });
+    });
+
+    describe('isUnhealthy', () => {
+        it('should return true for score 39', () => {
+            const score = new HealthScore(39);
+
+            expect(score.isUnhealthy()).toBe(true);
+        });
+
+        it('should return true for score 0', () => {
+            const score = new HealthScore(0);
+
+            expect(score.isUnhealthy()).toBe(true);
+        });
+
+        it('should return false for score 40', () => {
+            const score = new HealthScore(40);
+
+            expect(score.isUnhealthy()).toBe(false);
+        });
+
+        it('should return false for score 80', () => {
+            const score = new HealthScore(80);
+
+            expect(score.isUnhealthy()).toBe(false);
+        });
+    });
+
+    describe('toString', () => {
+        it('should return string representation for healthy score', () => {
+            const score = new HealthScore(100);
+
+            expect(score.toString()).toBe('100 (healthy)');
+        });
+
+        it('should return string representation for degraded score', () => {
+            const score = new HealthScore(50);
+
+            expect(score.toString()).toBe('50 (degraded)');
+        });
+
+        it('should return string representation for unhealthy score', () => {
+            const score = new HealthScore(25);
+
+            expect(score.toString()).toBe('25 (unhealthy)');
+        });
+    });
+
+    describe('static factory methods', () => {
+        it('should create perfect score', () => {
+            const score = HealthScore.perfect();
+
+            expect(score.value).toBe(100);
+            expect(score.isHealthy()).toBe(true);
+        });
+
+        it('should create failed score', () => {
+            const score = HealthScore.failed();
+
+            expect(score.value).toBe(0);
+            expect(score.isUnhealthy()).toBe(true);
+        });
+
+        it('should create from percentage (1.0 = 100)', () => {
+            const score = HealthScore.fromPercentage(0.75);
+
+            expect(score.value).toBe(75);
+        });
+
+        it('should create from percentage (0.0 = 0)', () => {
+            const score = HealthScore.fromPercentage(0);
+
+            expect(score.value).toBe(0);
+        });
+
+        it('should create from percentage (1.0 = 100)', () => {
+            const score = HealthScore.fromPercentage(1.0);
+
+            expect(score.value).toBe(100);
+        });
+
+        it('should reject percentage below 0', () => {
+            expect(() => {
+                HealthScore.fromPercentage(-0.1);
+            }).toThrow('Percentage must be between 0 and 1');
+        });
+
+        it('should reject percentage above 1', () => {
+            expect(() => {
+                HealthScore.fromPercentage(1.1);
+            }).toThrow('Percentage must be between 0 and 1');
+        });
+    });
+
+    describe('immutability', () => {
+        it('should not allow modification of value', () => {
+            const score = new HealthScore(75);
+
+            expect(() => {
+                score.value = 50;
+            }).toThrow();
+        });
+
+        it('should be frozen', () => {
+            const score = new HealthScore(75);
+
+            expect(Object.isFrozen(score)).toBe(true);
+        });
+    });
+});