@friggframework/devtools 2.0.0--canary.474.28f4860.0 → 2.0.0--canary.474.97bfcf0.0

package/infrastructure/domains/health/domain/entities/property-mismatch.js

@@ -0,0 +1,105 @@
+/**
+ * PropertyMismatch Entity
+ *
+ * Represents a difference between expected and actual property values
+ * for a CloudFormation resource.
+ */
+
+const PropertyMutability = require('../value-objects/property-mutability');
+
+class PropertyMismatch {
+    /**
+     * Create a new PropertyMismatch
+     *
+     * @param {Object} params
+     * @param {string} params.propertyPath - Path to the property (e.g., 'Properties.BucketName')
+     * @param {*} params.expectedValue - Expected property value
+     * @param {*} params.actualValue - Actual property value
+     * @param {PropertyMutability} params.mutability - Property mutability
+     */
+    constructor({ propertyPath, expectedValue, actualValue, mutability }) {
+        // Validate required fields
+        if (!propertyPath) {
+            throw new Error('propertyPath is required');
+        }
+
+        if (expectedValue === undefined) {
+            throw new Error('expectedValue is required');
+        }
+
+        if (actualValue === undefined) {
+            throw new Error('actualValue is required');
+        }
+
+        if (!mutability) {
+            throw new Error('mutability is required');
+        }
+
+        if (!(mutability instanceof PropertyMutability)) {
+            throw new Error('mutability must be a PropertyMutability instance');
+        }
+
+        this.propertyPath = propertyPath;
+        this.expectedValue = expectedValue;
+        this.actualValue = actualValue;
+        this.mutability = mutability;
+    }
+
+    /**
+     * Check if fixing this mismatch requires resource replacement
+     *
+     * @returns {boolean}
+     */
+    requiresReplacement() {
+        return this.mutability.requiresReplacement();
+    }
+
+    /**
+     * Check if this mismatch can be automatically fixed
+     *
+     * @returns {boolean}
+     */
+    canAutoFix() {
+        return this.mutability.canChange();
+    }
+
+    /**
+     * Get severity level of this mismatch
+     *
+     * @returns {'critical' | 'warning'}
+     */
+    getSeverity() {
+        return this.mutability.isImmutable() ? 'critical' : 'warning';
+    }
+
+    /**
+     * Get string representation
+     *
+     * @returns {string}
+     */
+    toString() {
+        const expectedStr = this.expectedValue === null ? 'null' : this.expectedValue;
+        const actualStr = this.actualValue === null ? 'null' : this.actualValue;
+
+        return `PropertyMismatch: ${this.propertyPath} (expected: ${expectedStr}, actual: ${actualStr}, mutability: ${this.mutability.toString()})`;
+    }
+
+    /**
+     * Serialize to JSON
+     *
+     * @returns {Object}
+     */
+    toJSON() {
+        return {
+            propertyPath: this.propertyPath,
+            expectedValue: this.expectedValue,
+            actualValue: this.actualValue,
+            mutability: this.mutability.toString(),
+            severity: this.getSeverity(),
+            canAutoFix: this.canAutoFix(),
+            requiresReplacement: this.requiresReplacement(),
+        };
+    }
+}
+
+module.exports = PropertyMismatch;

package/infrastructure/domains/health/domain/entities/property-mismatch.test.js

@@ -0,0 +1,251 @@
+/**
+ * Tests for PropertyMismatch Entity
+ */
+
+const PropertyMismatch = require('./property-mismatch');
+const PropertyMutability = require('../value-objects/property-mutability');
+
+describe('PropertyMismatch', () => {
+    describe('constructor', () => {
+        it('should create property mismatch with all fields', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.BucketName',
+                expectedValue: 'my-app-prod-bucket',
+                actualValue: 'my-app-dev-bucket',
+                mutability: PropertyMutability.IMMUTABLE,
+            });
+
+            expect(mismatch.propertyPath).toBe('Properties.BucketName');
+            expect(mismatch.expectedValue).toBe('my-app-prod-bucket');
+            expect(mismatch.actualValue).toBe('my-app-dev-bucket');
+            expect(mismatch.mutability.value).toBe('IMMUTABLE');
+        });
+
+        it('should require propertyPath', () => {
+            expect(() => {
+                new PropertyMismatch({
+                    expectedValue: 'value1',
+                    actualValue: 'value2',
+                    mutability: PropertyMutability.MUTABLE,
+                });
+            }).toThrow('propertyPath is required');
+        });
+
+        it('should require expectedValue', () => {
+            expect(() => {
+                new PropertyMismatch({
+                    propertyPath: 'Properties.Name',
+                    actualValue: 'value2',
+                    mutability: PropertyMutability.MUTABLE,
+                });
+            }).toThrow('expectedValue is required');
+        });
+
+        it('should require actualValue', () => {
+            expect(() => {
+                new PropertyMismatch({
+                    propertyPath: 'Properties.Name',
+                    expectedValue: 'value1',
+                    mutability: PropertyMutability.MUTABLE,
+                });
+            }).toThrow('actualValue is required');
+        });
+
+        it('should require mutability', () => {
+            expect(() => {
+                new PropertyMismatch({
+                    propertyPath: 'Properties.Name',
+                    expectedValue: 'value1',
+                    actualValue: 'value2',
+                });
+            }).toThrow('mutability is required');
+        });
+
+        it('should accept null as expectedValue', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: null,
+                actualValue: ['tag1', 'tag2'],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            expect(mismatch.expectedValue).toBeNull();
+        });
+
+        it('should accept null as actualValue', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: ['tag1', 'tag2'],
+                actualValue: null,
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            expect(mismatch.actualValue).toBeNull();
+        });
+    });
+
+    describe('requiresReplacement', () => {
+        it('should return true for immutable property', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.BucketName',
+                expectedValue: 'bucket1',
+                actualValue: 'bucket2',
+                mutability: PropertyMutability.IMMUTABLE,
+            });
+
+            expect(mismatch.requiresReplacement()).toBe(true);
+        });
+
+        it('should return false for mutable property', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: ['tag1'],
+                actualValue: ['tag2'],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            expect(mismatch.requiresReplacement()).toBe(false);
+        });
+
+        it('should return false for conditional property', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.EngineVersion',
+                expectedValue: '5.7',
+                actualValue: '5.6',
+                mutability: PropertyMutability.CONDITIONAL,
+            });
+
+            expect(mismatch.requiresReplacement()).toBe(false);
+        });
+    });
+
+    describe('canAutoFix', () => {
+        it('should return true for mutable property', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: ['tag1'],
+                actualValue: ['tag2'],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            expect(mismatch.canAutoFix()).toBe(true);
+        });
+
+        it('should return false for immutable property', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.BucketName',
+                expectedValue: 'bucket1',
+                actualValue: 'bucket2',
+                mutability: PropertyMutability.IMMUTABLE,
+            });
+
+            expect(mismatch.canAutoFix()).toBe(false);
+        });
+
+        it('should return false for conditional property', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.EngineVersion',
+                expectedValue: '5.7',
+                actualValue: '5.6',
+                mutability: PropertyMutability.CONDITIONAL,
+            });
+
+            expect(mismatch.canAutoFix()).toBe(false);
+        });
+    });
+
+    describe('getSeverity', () => {
+        it('should return critical for immutable property mismatch', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.BucketName',
+                expectedValue: 'bucket1',
+                actualValue: 'bucket2',
+                mutability: PropertyMutability.IMMUTABLE,
+            });
+
+            expect(mismatch.getSeverity()).toBe('critical');
+        });
+
+        it('should return warning for mutable property mismatch', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: ['tag1'],
+                actualValue: ['tag2'],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            expect(mismatch.getSeverity()).toBe('warning');
+        });
+
+        it('should return warning for conditional property mismatch', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.EngineVersion',
+                expectedValue: '5.7',
+                actualValue: '5.6',
+                mutability: PropertyMutability.CONDITIONAL,
+            });
+
+            expect(mismatch.getSeverity()).toBe('warning');
+        });
+    });
+
+    describe('toString', () => {
+        it('should return string representation', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.BucketName',
+                expectedValue: 'bucket1',
+                actualValue: 'bucket2',
+                mutability: PropertyMutability.IMMUTABLE,
+            });
+
+            expect(mismatch.toString()).toBe(
+                'PropertyMismatch: Properties.BucketName (expected: bucket1, actual: bucket2, mutability: IMMUTABLE)'
+            );
+        });
+
+        it('should handle null expected value', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: null,
+                actualValue: ['tag1'],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            expect(mismatch.toString()).toContain('expected: null');
+        });
+
+        it('should handle null actual value', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: ['tag1'],
+                actualValue: null,
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            expect(mismatch.toString()).toContain('actual: null');
+        });
+    });
+
+    describe('toJSON', () => {
+        it('should serialize to JSON', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.BucketName',
+                expectedValue: 'bucket1',
+                actualValue: 'bucket2',
+                mutability: PropertyMutability.IMMUTABLE,
+            });
+
+            const json = mismatch.toJSON();
+
+            expect(json).toEqual({
+                propertyPath: 'Properties.BucketName',
+                expectedValue: 'bucket1',
+                actualValue: 'bucket2',
+                mutability: 'IMMUTABLE',
+                severity: 'critical',
+                canAutoFix: false,
+                requiresReplacement: true,
+            });
+        });
+    });
+});

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;