@friggframework/devtools 2.0.0--canary.474.27d9425.0 → 2.0.0--canary.474.97bfcf0.0

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;

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

@@ -0,0 +1,196 @@
+/**
+ * Tests for ResourceState Value Object
+ */
+
+const ResourceState = require('./resource-state');
+
+describe('ResourceState', () => {
+    describe('valid states', () => {
+        it('should accept IN_STACK state', () => {
+            const state = new ResourceState('IN_STACK');
+
+            expect(state.value).toBe('IN_STACK');
+        });
+
+        it('should accept ORPHANED state', () => {
+            const state = new ResourceState('ORPHANED');
+
+            expect(state.value).toBe('ORPHANED');
+        });
+
+        it('should accept MISSING state', () => {
+            const state = new ResourceState('MISSING');
+
+            expect(state.value).toBe('MISSING');
+        });
+
+        it('should accept DRIFTED state', () => {
+            const state = new ResourceState('DRIFTED');
+
+            expect(state.value).toBe('DRIFTED');
+        });
+
+        it('should accept EXTERNAL state', () => {
+            const state = new ResourceState('EXTERNAL');
+
+            expect(state.value).toBe('EXTERNAL');
+        });
+    });
+
+    describe('invalid states', () => {
+        it('should reject invalid state', () => {
+            expect(() => {
+                new ResourceState('INVALID');
+            }).toThrow('Invalid resource state: INVALID');
+        });
+
+        it('should reject lowercase state', () => {
+            expect(() => {
+                new ResourceState('in_stack');
+            }).toThrow('Invalid resource state: in_stack');
+        });
+
+        it('should reject null', () => {
+            expect(() => {
+                new ResourceState(null);
+            }).toThrow('Resource state is required');
+        });
+
+        it('should reject undefined', () => {
+            expect(() => {
+                new ResourceState(undefined);
+            }).toThrow('Resource state is required');
+        });
+    });
+
+    describe('state checks', () => {
+        it('should check if resource is in stack', () => {
+            const state = new ResourceState('IN_STACK');
+
+            expect(state.isInStack()).toBe(true);
+            expect(state.isOrphaned()).toBe(false);
+            expect(state.isMissing()).toBe(false);
+            expect(state.isDrifted()).toBe(false);
+            expect(state.isExternal()).toBe(false);
+        });
+
+        it('should check if resource is orphaned', () => {
+            const state = new ResourceState('ORPHANED');
+
+            expect(state.isInStack()).toBe(false);
+            expect(state.isOrphaned()).toBe(true);
+            expect(state.isMissing()).toBe(false);
+            expect(state.isDrifted()).toBe(false);
+            expect(state.isExternal()).toBe(false);
+        });
+
+        it('should check if resource is missing', () => {
+            const state = new ResourceState('MISSING');
+
+            expect(state.isInStack()).toBe(false);
+            expect(state.isOrphaned()).toBe(false);
+            expect(state.isMissing()).toBe(true);
+            expect(state.isDrifted()).toBe(false);
+            expect(state.isExternal()).toBe(false);
+        });
+
+        it('should check if resource is drifted', () => {
+            const state = new ResourceState('DRIFTED');
+
+            expect(state.isInStack()).toBe(false);
+            expect(state.isOrphaned()).toBe(false);
+            expect(state.isMissing()).toBe(false);
+            expect(state.isDrifted()).toBe(true);
+            expect(state.isExternal()).toBe(false);
+        });
+
+        it('should check if resource is external', () => {
+            const state = new ResourceState('EXTERNAL');
+
+            expect(state.isInStack()).toBe(false);
+            expect(state.isOrphaned()).toBe(false);
+            expect(state.isMissing()).toBe(false);
+            expect(state.isDrifted()).toBe(false);
+            expect(state.isExternal()).toBe(true);
+        });
+    });
+
+    describe('equality', () => {
+        it('should be equal to same state', () => {
+            const state1 = new ResourceState('IN_STACK');
+            const state2 = new ResourceState('IN_STACK');
+
+            expect(state1.equals(state2)).toBe(true);
+        });
+
+        it('should not be equal to different state', () => {
+            const state1 = new ResourceState('IN_STACK');
+            const state2 = new ResourceState('ORPHANED');
+
+            expect(state1.equals(state2)).toBe(false);
+        });
+
+        it('should not be equal to non-ResourceState', () => {
+            const state = new ResourceState('IN_STACK');
+
+            expect(state.equals('IN_STACK')).toBe(false);
+            expect(state.equals(null)).toBe(false);
+        });
+    });
+
+    describe('toString', () => {
+        it('should return string representation', () => {
+            const state = new ResourceState('IN_STACK');
+
+            expect(state.toString()).toBe('IN_STACK');
+        });
+    });
+
+    describe('static constants', () => {
+        it('should provide IN_STACK constant', () => {
+            expect(ResourceState.IN_STACK.value).toBe('IN_STACK');
+        });
+
+        it('should provide ORPHANED constant', () => {
+            expect(ResourceState.ORPHANED.value).toBe('ORPHANED');
+        });
+
+        it('should provide MISSING constant', () => {
+            expect(ResourceState.MISSING.value).toBe('MISSING');
+        });
+
+        it('should provide DRIFTED constant', () => {
+            expect(ResourceState.DRIFTED.value).toBe('DRIFTED');
+        });
+
+        it('should provide EXTERNAL constant', () => {
+            expect(ResourceState.EXTERNAL.value).toBe('EXTERNAL');
+        });
+
+        it('should provide VALID_STATES array', () => {
+            expect(ResourceState.VALID_STATES).toEqual([
+                'IN_STACK',
+                'ORPHANED',
+                'MISSING',
+                'DRIFTED',
+                'EXTERNAL',
+            ]);
+        });
+    });
+
+    describe('immutability', () => {
+        it('should not allow modification of value', () => {
+            const state = new ResourceState('IN_STACK');
+
+            expect(() => {
+                state.value = 'ORPHANED';
+            }).toThrow();
+        });
+
+        it('should be frozen', () => {
+            const state = new ResourceState('IN_STACK');
+
+            expect(Object.isFrozen(state)).toBe(true);
+        });
+    });
+});

package/infrastructure/domains/health/domain/value-objects/stack-identifier.js

@@ -0,0 +1,179 @@
+/**
+ * StackIdentifier Value Object
+ *
+ * Immutable identifier for a CloudFormation stack
+ * Combines stack name, region, and optional account ID
+ */
+
+class StackIdentifier {
+    /**
+     * Valid AWS regions
+     * @private
+     */
+    static VALID_REGIONS = [
+        'us-east-1',
+        'us-east-2',
+        'us-west-1',
+        'us-west-2',
+        'af-south-1',
+        'ap-east-1',
+        'ap-south-1',
+        'ap-northeast-1',
+        'ap-northeast-2',
+        'ap-northeast-3',
+        'ap-southeast-1',
+        'ap-southeast-2',
+        'ca-central-1',
+        'eu-central-1',
+        'eu-west-1',
+        'eu-west-2',
+        'eu-west-3',
+        'eu-north-1',
+        'eu-south-1',
+        'me-south-1',
+        'sa-east-1',
+    ];
+
+    /**
+     * Create a new StackIdentifier
+     *
+     * @param {Object} params
+     * @param {string} params.stackName - CloudFormation stack name
+     * @param {string} params.region - AWS region
+     * @param {string} [params.accountId] - AWS account ID (12 digits)
+     */
+    constructor({ stackName, region, accountId = null }) {
+        // Validate required fields
+        if (stackName === undefined || stackName === null) {
+            throw new Error('stackName is required');
+        }
+
+        if (region === undefined || region === null) {
+            throw new Error('region is required');
+        }
+
+        // Validate formats
+        if (typeof stackName === 'string' && stackName.trim() === '') {
+            throw new Error('stackName cannot be empty');
+        }
+
+        if (!StackIdentifier.VALID_REGIONS.includes(region)) {
+            throw new Error('region must be a valid AWS region');
+        }
+
+        if (accountId !== null && !/^\d{12}$/.test(accountId)) {
+            throw new Error('accountId must be a 12-digit number');
+        }
+
+        // Assign properties
+        this._stackName = stackName;
+        this._region = region;
+        this._accountId = accountId;
+
+        // Make immutable
+        Object.freeze(this);
+    }
+
+    /**
+     * Get stack name
+     * @returns {string}
+     */
+    get stackName() {
+        return this._stackName;
+    }
+
+    /**
+     * Prevent modification of stackName
+     * @throws {TypeError}
+     */
+    set stackName(value) {
+        throw new TypeError('Cannot modify immutable property stackName');
+    }
+
+    /**
+     * Get region
+     * @returns {string}
+     */
+    get region() {
+        return this._region;
+    }
+
+    /**
+     * Prevent modification of region
+     * @throws {TypeError}
+     */
+    set region(value) {
+        throw new TypeError('Cannot modify immutable property region');
+    }
+
+    /**
+     * Get account ID
+     * @returns {string|null}
+     */
+    get accountId() {
+        return this._accountId;
+    }
+
+    /**
+     * Prevent modification of accountId
+     * @throws {TypeError}
+     */
+    set accountId(value) {
+        throw new TypeError('Cannot modify immutable property accountId');
+    }
+
+    /**
+     * Check equality with another StackIdentifier
+     *
+     * @param {StackIdentifier} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (!(other instanceof StackIdentifier)) {
+            return false;
+        }
+
+        return (
+            this.stackName === other.stackName &&
+            this.region === other.region &&
+            this.accountId === other.accountId
+        );
+    }
+
+    /**
+     * Get string representation
+     *
+     * @returns {string}
+     */
+    toString() {
+        if (this.accountId) {
+            return `${this.stackName} (${this.region}, ${this.accountId})`;
+        }
+        return `${this.stackName} (${this.region})`;
+    }
+
+    /**
+     * Create StackIdentifier from ARN
+     *
+     * @param {string} arn - CloudFormation stack ARN
+     * @returns {StackIdentifier}
+     */
+    static fromArn(arn) {
+        // arn:aws:cloudformation:region:account-id:stack/stack-name/guid
+        const match = arn.match(/^arn:aws:cloudformation:([^:]+):(\d{12}):stack\/([^\/]+)/);
+
+        if (!match) {
+            throw new Error('Invalid CloudFormation stack ARN');
+        }
+
+        const [, region, accountId, stackName] = match;
+
+        return new StackIdentifier({
+            stackName,
+            region,
+            accountId,
+        });
+    }
+}
+
+module.exports = StackIdentifier;