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

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

@@ -1,275 +0,0 @@
-/**
- * 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 parameter', () => {
-            expect(() => {
-                new PropertyMismatch({
-                    propertyPath: 'Properties.Name',
-                    actualValue: 'value2',
-                    mutability: PropertyMutability.MUTABLE,
-                });
-            }).toThrow('expectedValue must be provided');
-        });
-
-        it('should require actualValue parameter', () => {
-            expect(() => {
-                new PropertyMismatch({
-                    propertyPath: 'Properties.Name',
-                    expectedValue: 'value1',
-                    mutability: PropertyMutability.MUTABLE,
-                });
-            }).toThrow('actualValue must be provided');
-        });
-
-        it('should accept undefined as expectedValue', () => {
-            const mismatch = new PropertyMismatch({
-                propertyPath: 'Properties.NewProperty',
-                expectedValue: undefined,
-                actualValue: 'new-value',
-                mutability: PropertyMutability.MUTABLE,
-            });
-
-            expect(mismatch.expectedValue).toBeUndefined();
-            expect(mismatch.actualValue).toBe('new-value');
-        });
-
-        it('should accept undefined as actualValue', () => {
-            const mismatch = new PropertyMismatch({
-                propertyPath: 'Properties.OldProperty',
-                expectedValue: 'old-value',
-                actualValue: undefined,
-                mutability: PropertyMutability.MUTABLE,
-            });
-
-            expect(mismatch.expectedValue).toBe('old-value');
-            expect(mismatch.actualValue).toBeUndefined();
-        });
-
-        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/entities/resource.js

@@ -1,159 +0,0 @@
-/**
- * Resource Entity
- *
- * Represents a CloudFormation resource with its current state and any detected issues
- */
-
-const ResourceState = require('../value-objects/resource-state');
-
-class Resource {
-    /**
-     * Create a new Resource
-     *
-     * @param {Object} params
-     * @param {string|null} params.logicalId - CloudFormation logical ID (null for orphaned resources)
-     * @param {string} params.physicalId - Physical resource ID in cloud provider
-     * @param {string} params.resourceType - CloudFormation resource type (e.g., AWS::EC2::VPC)
-     * @param {ResourceState} params.state - Resource state
-     * @param {Object} [params.properties={}] - Resource properties
-     * @param {Issue[]} [params.issues=[]] - Detected issues with this resource
-     */
-    constructor({
-        logicalId = null,
-        physicalId,
-        resourceType,
-        state,
-        properties = {},
-        issues = [],
-    }) {
-        // Validate required fields
-        if (physicalId === undefined || physicalId === null) {
-            throw new Error('physicalId is required');
-        }
-
-        if (!resourceType) {
-            throw new Error('resourceType is required');
-        }
-
-        if (!state) {
-            throw new Error('state is required');
-        }
-
-        if (!(state instanceof ResourceState)) {
-            throw new Error('state must be a ResourceState instance');
-        }
-
-        this.logicalId = logicalId;
-        this.physicalId = physicalId;
-        this.resourceType = resourceType;
-        this.state = state;
-        this.properties = properties;
-        this.issues = [...issues]; // Copy array to avoid mutations
-    }
-
-    /**
-     * Check if resource is in CloudFormation stack
-     * @returns {boolean}
-     */
-    isInStack() {
-        return this.state.isInStack();
-    }
-
-    /**
-     * Check if resource is orphaned (exists in cloud but not in stack)
-     * @returns {boolean}
-     */
-    isOrphaned() {
-        return this.state.isOrphaned();
-    }
-
-    /**
-     * Check if resource is missing (exists in stack but not in cloud)
-     * @returns {boolean}
-     */
-    isMissing() {
-        return this.state.isMissing();
-    }
-
-    /**
-     * Check if resource has drifted (properties differ)
-     * @returns {boolean}
-     */
-    isDrifted() {
-        return this.state.isDrifted();
-    }
-
-    /**
-     * Add an issue to this resource
-     * @param {Issue} issue
-     */
-    addIssue(issue) {
-        this.issues.push(issue);
-    }
-
-    /**
-     * Check if resource has any issues
-     * @returns {boolean}
-     */
-    hasIssues() {
-        return this.issues.length > 0;
-    }
-
-    /**
-     * Check if resource has critical issues
-     * @returns {boolean}
-     */
-    hasCriticalIssues() {
-        return this.issues.some(issue => issue.isCritical());
-    }
-
-    /**
-     * Get all critical issues
-     * @returns {Issue[]}
-     */
-    getCriticalIssues() {
-        return this.issues.filter(issue => issue.isCritical());
-    }
-
-    /**
-     * Check if resource is healthy (no issues)
-     * @returns {boolean}
-     */
-    isHealthy() {
-        return !this.hasIssues();
-    }
-
-    /**
-     * Get resource identifier (logical ID or physical ID)
-     * @returns {string}
-     */
-    getIdentifier() {
-        return this.logicalId || this.physicalId;
-    }
-
-    /**
-     * Get string representation
-     * @returns {string}
-     */
-    toString() {
-        return `Resource: ${this.resourceType} [${this.state.toString()}] - LogicalId: ${this.logicalId}, PhysicalId: ${this.physicalId}`;
-    }
-
-    /**
-     * Serialize to JSON
-     * @returns {Object}
-     */
-    toJSON() {
-        return {
-            logicalId: this.logicalId,
-            physicalId: this.physicalId,
-            resourceType: this.resourceType,
-            state: this.state.toString(),
-            properties: this.properties,
-            issues: this.issues.map(issue => issue.toJSON()),
-            isHealthy: this.isHealthy(),
-        };
-    }
-}
-
-module.exports = Resource;