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

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

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

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

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