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

package/infrastructure/domains/health/domain/value-objects/property-mutability.js

@@ -0,0 +1,161 @@
+/**
+ * PropertyMutability Value Object
+ *
+ * Enum-like immutable mutability classification for CloudFormation resource properties
+ *
+ * Types:
+ * - MUTABLE: Property can be changed without replacing the resource (Update requires: No interruption)
+ * - IMMUTABLE: Property cannot be changed - requires resource replacement (Update requires: Replacement)
+ * - CONDITIONAL: Property mutability depends on other properties or conditions (Update requires: Some interruptions)
+ */
+
+class PropertyMutability {
+    /**
+     * Valid mutability types
+     * @type {string[]}
+     */
+    static VALID_TYPES = [
+        'MUTABLE',
+        'IMMUTABLE',
+        'CONDITIONAL',
+    ];
+
+    /**
+     * Create a new PropertyMutability
+     *
+     * @param {string} value - Mutability type
+     */
+    constructor(value) {
+        if (value === undefined || value === null) {
+            throw new Error('Property mutability is required');
+        }
+
+        if (!PropertyMutability.VALID_TYPES.includes(value)) {
+            throw new Error(`Invalid property mutability: ${value}`);
+        }
+
+        this._value = value;
+
+        // Make immutable
+        Object.freeze(this);
+    }
+
+    /**
+     * Get mutability value
+     * @returns {string}
+     */
+    get value() {
+        return this._value;
+    }
+
+    /**
+     * Prevent modification of value
+     * @throws {TypeError}
+     */
+    set value(newValue) {
+        throw new TypeError('Cannot modify immutable property value');
+    }
+
+    /**
+     * Check if property is mutable
+     * @returns {boolean}
+     */
+    isMutable() {
+        return this._value === 'MUTABLE';
+    }
+
+    /**
+     * Check if property is immutable
+     * @returns {boolean}
+     */
+    isImmutable() {
+        return this._value === 'IMMUTABLE';
+    }
+
+    /**
+     * Check if property mutability is conditional
+     * @returns {boolean}
+     */
+    isConditional() {
+        return this._value === 'CONDITIONAL';
+    }
+
+    /**
+     * Check if property can be changed
+     * @returns {boolean}
+     */
+    canChange() {
+        return this._value === 'MUTABLE';
+    }
+
+    /**
+     * Check if changing property requires resource replacement
+     * @returns {boolean}
+     */
+    requiresReplacement() {
+        return this._value === 'IMMUTABLE';
+    }
+
+    /**
+     * Get description of mutability type
+     * @returns {string}
+     */
+    getDescription() {
+        const descriptions = {
+            MUTABLE: 'Property can be changed without replacing the resource',
+            IMMUTABLE: 'Property cannot be changed - requires resource replacement',
+            CONDITIONAL: 'Property mutability depends on other property values or conditions',
+        };
+
+        return descriptions[this._value];
+    }
+
+    /**
+     * Check equality with another PropertyMutability
+     *
+     * @param {PropertyMutability} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (!(other instanceof PropertyMutability)) {
+            return false;
+        }
+
+        return this._value === other._value;
+    }
+
+    /**
+     * Get string representation
+     *
+     * @returns {string}
+     */
+    toString() {
+        return this._value;
+    }
+
+    /**
+     * Predefined mutability: MUTABLE
+     * @type {PropertyMutability}
+     */
+    static get MUTABLE() {
+        return new PropertyMutability('MUTABLE');
+    }
+
+    /**
+     * Predefined mutability: IMMUTABLE
+     * @type {PropertyMutability}
+     */
+    static get IMMUTABLE() {
+        return new PropertyMutability('IMMUTABLE');
+    }
+
+    /**
+     * Predefined mutability: CONDITIONAL
+     * @type {PropertyMutability}
+     */
+    static get CONDITIONAL() {
+        return new PropertyMutability('CONDITIONAL');
+    }
+}
+
+module.exports = PropertyMutability;

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

@@ -0,0 +1,198 @@
+/**
+ * Tests for PropertyMutability Value Object
+ */
+
+const PropertyMutability = require('./property-mutability');
+
+describe('PropertyMutability', () => {
+    describe('valid mutability types', () => {
+        it('should accept MUTABLE', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.value).toBe('MUTABLE');
+        });
+
+        it('should accept IMMUTABLE', () => {
+            const mutability = new PropertyMutability('IMMUTABLE');
+
+            expect(mutability.value).toBe('IMMUTABLE');
+        });
+
+        it('should accept CONDITIONAL', () => {
+            const mutability = new PropertyMutability('CONDITIONAL');
+
+            expect(mutability.value).toBe('CONDITIONAL');
+        });
+    });
+
+    describe('invalid mutability types', () => {
+        it('should reject invalid mutability', () => {
+            expect(() => {
+                new PropertyMutability('INVALID');
+            }).toThrow('Invalid property mutability: INVALID');
+        });
+
+        it('should reject lowercase mutability', () => {
+            expect(() => {
+                new PropertyMutability('mutable');
+            }).toThrow('Invalid property mutability: mutable');
+        });
+
+        it('should reject null', () => {
+            expect(() => {
+                new PropertyMutability(null);
+            }).toThrow('Property mutability is required');
+        });
+
+        it('should reject undefined', () => {
+            expect(() => {
+                new PropertyMutability(undefined);
+            }).toThrow('Property mutability is required');
+        });
+    });
+
+    describe('mutability checks', () => {
+        it('should check if property is mutable', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.isMutable()).toBe(true);
+            expect(mutability.isImmutable()).toBe(false);
+            expect(mutability.isConditional()).toBe(false);
+        });
+
+        it('should check if property is immutable', () => {
+            const mutability = new PropertyMutability('IMMUTABLE');
+
+            expect(mutability.isMutable()).toBe(false);
+            expect(mutability.isImmutable()).toBe(true);
+            expect(mutability.isConditional()).toBe(false);
+        });
+
+        it('should check if property is conditionally mutable', () => {
+            const mutability = new PropertyMutability('CONDITIONAL');
+
+            expect(mutability.isMutable()).toBe(false);
+            expect(mutability.isImmutable()).toBe(false);
+            expect(mutability.isConditional()).toBe(true);
+        });
+    });
+
+    describe('changeability checks', () => {
+        it('should allow changes for mutable properties', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.canChange()).toBe(true);
+            expect(mutability.requiresReplacement()).toBe(false);
+        });
+
+        it('should not allow changes for immutable properties', () => {
+            const mutability = new PropertyMutability('IMMUTABLE');
+
+            expect(mutability.canChange()).toBe(false);
+            expect(mutability.requiresReplacement()).toBe(true);
+        });
+
+        it('should conditionally allow changes', () => {
+            const mutability = new PropertyMutability('CONDITIONAL');
+
+            // Conditional means it depends on other factors
+            expect(mutability.canChange()).toBe(false); // Can't change without conditions met
+            expect(mutability.requiresReplacement()).toBe(false); // Doesn't always require replacement
+        });
+    });
+
+    describe('equality', () => {
+        it('should be equal to same mutability', () => {
+            const m1 = new PropertyMutability('MUTABLE');
+            const m2 = new PropertyMutability('MUTABLE');
+
+            expect(m1.equals(m2)).toBe(true);
+        });
+
+        it('should not be equal to different mutability', () => {
+            const m1 = new PropertyMutability('MUTABLE');
+            const m2 = new PropertyMutability('IMMUTABLE');
+
+            expect(m1.equals(m2)).toBe(false);
+        });
+
+        it('should not be equal to non-PropertyMutability', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.equals('MUTABLE')).toBe(false);
+            expect(mutability.equals(null)).toBe(false);
+        });
+    });
+
+    describe('toString', () => {
+        it('should return string representation', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.toString()).toBe('MUTABLE');
+        });
+    });
+
+    describe('static constants', () => {
+        it('should provide MUTABLE constant', () => {
+            expect(PropertyMutability.MUTABLE.value).toBe('MUTABLE');
+        });
+
+        it('should provide IMMUTABLE constant', () => {
+            expect(PropertyMutability.IMMUTABLE.value).toBe('IMMUTABLE');
+        });
+
+        it('should provide CONDITIONAL constant', () => {
+            expect(PropertyMutability.CONDITIONAL.value).toBe('CONDITIONAL');
+        });
+
+        it('should provide VALID_TYPES array', () => {
+            expect(PropertyMutability.VALID_TYPES).toEqual([
+                'MUTABLE',
+                'IMMUTABLE',
+                'CONDITIONAL',
+            ]);
+        });
+    });
+
+    describe('immutability', () => {
+        it('should not allow modification of value', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(() => {
+                mutability.value = 'IMMUTABLE';
+            }).toThrow();
+        });
+
+        it('should be frozen', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(Object.isFrozen(mutability)).toBe(true);
+        });
+    });
+
+    describe('description', () => {
+        it('should provide description for MUTABLE', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.getDescription()).toBe(
+                'Property can be changed without replacing the resource'
+            );
+        });
+
+        it('should provide description for IMMUTABLE', () => {
+            const mutability = new PropertyMutability('IMMUTABLE');
+
+            expect(mutability.getDescription()).toBe(
+                'Property cannot be changed - requires resource replacement'
+            );
+        });
+
+        it('should provide description for CONDITIONAL', () => {
+            const mutability = new PropertyMutability('CONDITIONAL');
+
+            expect(mutability.getDescription()).toBe(
+                'Property mutability depends on other property values or conditions'
+            );
+        });
+    });
+});

package/infrastructure/domains/health/domain/value-objects/resource-state.js

@@ -0,0 +1,167 @@
+/**
+ * ResourceState Value Object
+ *
+ * Enum-like immutable state for CloudFormation resources
+ *
+ * States:
+ * - IN_STACK: Resource exists in CloudFormation stack and matches expected definition
+ * - ORPHANED: Resource exists in AWS but not in CloudFormation stack
+ * - MISSING: Resource is in CloudFormation stack but not in AWS
+ * - DRIFTED: Resource exists in both but properties differ
+ * - EXTERNAL: Resource is intentionally external to stack
+ */
+
+class ResourceState {
+    /**
+     * Valid resource states
+     * @type {string[]}
+     */
+    static VALID_STATES = [
+        'IN_STACK',
+        'ORPHANED',
+        'MISSING',
+        'DRIFTED',
+        'EXTERNAL',
+    ];
+
+    /**
+     * Create a new ResourceState
+     *
+     * @param {string} value - State value
+     */
+    constructor(value) {
+        if (value === undefined || value === null) {
+            throw new Error('Resource state is required');
+        }
+
+        if (!ResourceState.VALID_STATES.includes(value)) {
+            throw new Error(`Invalid resource state: ${value}`);
+        }
+
+        this._value = value;
+
+        // Make immutable
+        Object.freeze(this);
+    }
+
+    /**
+     * Get state value
+     * @returns {string}
+     */
+    get value() {
+        return this._value;
+    }
+
+    /**
+     * Prevent modification of value
+     * @throws {TypeError}
+     */
+    set value(newValue) {
+        throw new TypeError('Cannot modify immutable property value');
+    }
+
+    /**
+     * Check if resource is in stack
+     * @returns {boolean}
+     */
+    isInStack() {
+        return this._value === 'IN_STACK';
+    }
+
+    /**
+     * Check if resource is orphaned
+     * @returns {boolean}
+     */
+    isOrphaned() {
+        return this._value === 'ORPHANED';
+    }
+
+    /**
+     * Check if resource is missing
+     * @returns {boolean}
+     */
+    isMissing() {
+        return this._value === 'MISSING';
+    }
+
+    /**
+     * Check if resource has drifted
+     * @returns {boolean}
+     */
+    isDrifted() {
+        return this._value === 'DRIFTED';
+    }
+
+    /**
+     * Check if resource is external
+     * @returns {boolean}
+     */
+    isExternal() {
+        return this._value === 'EXTERNAL';
+    }
+
+    /**
+     * Check equality with another ResourceState
+     *
+     * @param {ResourceState} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (!(other instanceof ResourceState)) {
+            return false;
+        }
+
+        return this._value === other._value;
+    }
+
+    /**
+     * Get string representation
+     *
+     * @returns {string}
+     */
+    toString() {
+        return this._value;
+    }
+
+    /**
+     * Predefined state: IN_STACK
+     * @type {ResourceState}
+     */
+    static get IN_STACK() {
+        return new ResourceState('IN_STACK');
+    }
+
+    /**
+     * Predefined state: ORPHANED
+     * @type {ResourceState}
+     */
+    static get ORPHANED() {
+        return new ResourceState('ORPHANED');
+    }
+
+    /**
+     * Predefined state: MISSING
+     * @type {ResourceState}
+     */
+    static get MISSING() {
+        return new ResourceState('MISSING');
+    }
+
+    /**
+     * Predefined state: DRIFTED
+     * @type {ResourceState}
+     */
+    static get DRIFTED() {
+        return new ResourceState('DRIFTED');
+    }
+
+    /**
+     * Predefined state: EXTERNAL
+     * @type {ResourceState}
+     */
+    static get EXTERNAL() {
+        return new ResourceState('EXTERNAL');
+    }
+}
+
+module.exports = ResourceState;