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

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

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

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

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