@friggframework/devtools 2.0.0-next.44 → 2.0.0-next.46

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,192 @@
+/**
+ * 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})`;
+    }
+
+    /**
+     * Serialize to JSON
+     *
+     * @returns {Object}
+     */
+    toJSON() {
+        return {
+            stackName: this.stackName,
+            region: this.region,
+            accountId: this.accountId,
+        };
+    }
+
+    /**
+     * 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;

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

@@ -0,0 +1,262 @@
+/**
+ * Tests for StackIdentifier Value Object
+ */
+
+const StackIdentifier = require('./stack-identifier');
+
+describe('StackIdentifier', () => {
+    describe('constructor', () => {
+        it('should create a valid stack identifier', () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '123456789012',
+            });
+
+            expect(identifier.stackName).toBe('my-app-prod');
+            expect(identifier.region).toBe('us-east-1');
+            expect(identifier.accountId).toBe('123456789012');
+        });
+
+        it('should require stackName', () => {
+            expect(() => {
+                new StackIdentifier({
+                    region: 'us-east-1',
+                    accountId: '123456789012',
+                });
+            }).toThrow('stackName is required');
+        });
+
+        it('should require region', () => {
+            expect(() => {
+                new StackIdentifier({
+                    stackName: 'my-app-prod',
+                    accountId: '123456789012',
+                });
+            }).toThrow('region is required');
+        });
+
+        it('should allow accountId to be optional', () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            expect(identifier.stackName).toBe('my-app-prod');
+            expect(identifier.region).toBe('us-east-1');
+            expect(identifier.accountId).toBeNull();
+        });
+
+        it('should validate stackName format', () => {
+            expect(() => {
+                new StackIdentifier({
+                    stackName: '',
+                    region: 'us-east-1',
+                });
+            }).toThrow('stackName cannot be empty');
+        });
+
+        it('should validate region format', () => {
+            expect(() => {
+                new StackIdentifier({
+                    stackName: 'my-app-prod',
+                    region: 'invalid-region',
+                });
+            }).toThrow('region must be a valid AWS region');
+        });
+
+        it('should validate accountId format when provided', () => {
+            expect(() => {
+                new StackIdentifier({
+                    stackName: 'my-app-prod',
+                    region: 'us-east-1',
+                    accountId: '123',
+                });
+            }).toThrow('accountId must be a 12-digit number');
+        });
+
+        it('should accept valid AWS regions', () => {
+            const validRegions = [
+                'us-east-1',
+                'us-east-2',
+                'us-west-1',
+                'us-west-2',
+                'eu-west-1',
+                'eu-central-1',
+                'ap-southeast-1',
+                'ap-northeast-1',
+            ];
+
+            validRegions.forEach(region => {
+                expect(() => {
+                    new StackIdentifier({
+                        stackName: 'my-app-prod',
+                        region,
+                    });
+                }).not.toThrow();
+            });
+        });
+    });
+
+    describe('equals', () => {
+        it('should return true for identical identifiers', () => {
+            const id1 = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '123456789012',
+            });
+
+            const id2 = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '123456789012',
+            });
+
+            expect(id1.equals(id2)).toBe(true);
+        });
+
+        it('should return false for different stack names', () => {
+            const id1 = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const id2 = new StackIdentifier({
+                stackName: 'my-app-dev',
+                region: 'us-east-1',
+            });
+
+            expect(id1.equals(id2)).toBe(false);
+        });
+
+        it('should return false for different regions', () => {
+            const id1 = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const id2 = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-west-2',
+            });
+
+            expect(id1.equals(id2)).toBe(false);
+        });
+
+        it('should return false for different account IDs', () => {
+            const id1 = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '123456789012',
+            });
+
+            const id2 = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '987654321098',
+            });
+
+            expect(id1.equals(id2)).toBe(false);
+        });
+
+        it('should handle null accountId comparison', () => {
+            const id1 = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const id2 = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            expect(id1.equals(id2)).toBe(true);
+        });
+    });
+
+    describe('toString', () => {
+        it('should return string representation with account ID', () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '123456789012',
+            });
+
+            expect(identifier.toString()).toBe('my-app-prod (us-east-1, 123456789012)');
+        });
+
+        it('should return string representation without account ID', () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            expect(identifier.toString()).toBe('my-app-prod (us-east-1)');
+        });
+    });
+
+    describe('toJSON', () => {
+        it('should serialize to JSON with account ID', () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '123456789012',
+            });
+
+            expect(identifier.toJSON()).toEqual({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '123456789012',
+            });
+        });
+
+        it('should serialize to JSON without account ID', () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            expect(identifier.toJSON()).toEqual({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: null,
+            });
+        });
+    });
+
+    describe('immutability', () => {
+        it('should not allow modification of stackName', () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            expect(() => {
+                identifier.stackName = 'modified';
+            }).toThrow();
+        });
+
+        it('should not allow modification of region', () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            expect(() => {
+                identifier.region = 'us-west-2';
+            }).toThrow();
+        });
+
+        it('should not allow modification of accountId', () => {
+            const identifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+                accountId: '123456789012',
+            });
+
+            expect(() => {
+                identifier.accountId = '987654321098';
+            }).toThrow();
+        });
+    });
+});