@friggframework/devtools 2.0.0--canary.474.6ec870b.0 → 2.0.0--canary.474.82ba370.0

package/infrastructure/domains/health/domain/entities/issue.js

@@ -0,0 +1,250 @@
+/**
+ * Issue Entity
+ *
+ * Represents a problem detected in infrastructure health check
+ */
+
+class Issue {
+    /**
+     * Valid issue types
+     */
+    static TYPES = {
+        ORPHANED_RESOURCE: 'ORPHANED_RESOURCE',
+        MISSING_RESOURCE: 'MISSING_RESOURCE',
+        PROPERTY_MISMATCH: 'PROPERTY_MISMATCH',
+        DRIFTED_RESOURCE: 'DRIFTED_RESOURCE',
+        MISSING_TAG: 'MISSING_TAG',
+    };
+
+    /**
+     * Valid severity levels
+     */
+    static SEVERITIES = {
+        CRITICAL: 'critical',
+        WARNING: 'warning',
+        INFO: 'info',
+    };
+
+    /**
+     * Create a new Issue
+     *
+     * @param {Object} params
+     * @param {string} params.type - Issue type (ORPHANED_RESOURCE, MISSING_RESOURCE, etc.)
+     * @param {string} params.severity - Severity level (critical, warning, info)
+     * @param {string} params.resourceType - CloudFormation resource type
+     * @param {string} params.resourceId - Resource identifier (physical or logical ID)
+     * @param {string} params.description - Human-readable description
+     * @param {string} [params.resolution] - Suggested resolution
+     * @param {boolean} [params.canAutoFix=false] - Whether issue can be automatically fixed
+     * @param {PropertyMismatch} [params.propertyMismatch] - Property mismatch details (for PROPERTY_MISMATCH type)
+     */
+    constructor({
+        type,
+        severity,
+        resourceType,
+        resourceId,
+        description,
+        resolution = null,
+        canAutoFix = false,
+        propertyMismatch = null,
+    }) {
+        // Validate required fields
+        if (!type) {
+            throw new Error('type is required');
+        }
+
+        if (!severity) {
+            throw new Error('severity is required');
+        }
+
+        if (!resourceType) {
+            throw new Error('resourceType is required');
+        }
+
+        if (!resourceId) {
+            throw new Error('resourceId is required');
+        }
+
+        if (!description) {
+            throw new Error('description is required');
+        }
+
+        // Validate type
+        if (!Object.values(Issue.TYPES).includes(type)) {
+            throw new Error(`Invalid issue type: ${type}`);
+        }
+
+        // Validate severity
+        if (!Object.values(Issue.SEVERITIES).includes(severity)) {
+            throw new Error(`Invalid severity: ${severity}`);
+        }
+
+        this.type = type;
+        this.severity = severity;
+        this.resourceType = resourceType;
+        this.resourceId = resourceId;
+        this.description = description;
+        this.resolution = resolution;
+        this.canAutoFix = canAutoFix;
+        this.propertyMismatch = propertyMismatch;
+    }
+
+    /**
+     * Check if issue is an orphaned resource
+     * @returns {boolean}
+     */
+    isOrphanedResource() {
+        return this.type === Issue.TYPES.ORPHANED_RESOURCE;
+    }
+
+    /**
+     * Check if issue is a missing resource
+     * @returns {boolean}
+     */
+    isMissingResource() {
+        return this.type === Issue.TYPES.MISSING_RESOURCE;
+    }
+
+    /**
+     * Check if issue is a property mismatch
+     * @returns {boolean}
+     */
+    isPropertyMismatch() {
+        return this.type === Issue.TYPES.PROPERTY_MISMATCH;
+    }
+
+    /**
+     * Check if issue is a drifted resource
+     * @returns {boolean}
+     */
+    isDrifted() {
+        return this.type === Issue.TYPES.DRIFTED_RESOURCE;
+    }
+
+    /**
+     * Check if issue is critical severity
+     * @returns {boolean}
+     */
+    isCritical() {
+        return this.severity === Issue.SEVERITIES.CRITICAL;
+    }
+
+    /**
+     * Check if issue is warning severity
+     * @returns {boolean}
+     */
+    isWarning() {
+        return this.severity === Issue.SEVERITIES.WARNING;
+    }
+
+    /**
+     * Check if issue is info severity
+     * @returns {boolean}
+     */
+    isInfo() {
+        return this.severity === Issue.SEVERITIES.INFO;
+    }
+
+    /**
+     * Get string representation
+     * @returns {string}
+     */
+    toString() {
+        return `Issue: ${this.type} [${this.severity}] - ${this.resourceType} (${this.resourceId}): ${this.description}`;
+    }
+
+    /**
+     * Serialize to JSON
+     * @returns {Object}
+     */
+    toJSON() {
+        return {
+            type: this.type,
+            severity: this.severity,
+            resourceType: this.resourceType,
+            resourceId: this.resourceId,
+            description: this.description,
+            resolution: this.resolution,
+            canAutoFix: this.canAutoFix,
+            propertyMismatch: this.propertyMismatch ? this.propertyMismatch.toJSON() : null,
+        };
+    }
+
+    /**
+     * Create an orphaned resource issue
+     *
+     * @param {Object} params
+     * @param {string} params.resourceType - CloudFormation resource type
+     * @param {string} params.resourceId - Resource physical ID
+     * @param {string} params.description - Issue description
+     * @returns {Issue}
+     */
+    static orphanedResource({ resourceType, resourceId, description }) {
+        return new Issue({
+            type: Issue.TYPES.ORPHANED_RESOURCE,
+            severity: Issue.SEVERITIES.CRITICAL,
+            resourceType,
+            resourceId,
+            description,
+            resolution: 'Import resource into CloudFormation stack using frigg repair --import',
+            canAutoFix: true,
+        });
+    }
+
+    /**
+     * Create a missing resource issue
+     *
+     * @param {Object} params
+     * @param {string} params.resourceType - CloudFormation resource type
+     * @param {string} params.resourceId - Resource logical ID
+     * @param {string} params.description - Issue description
+     * @returns {Issue}
+     */
+    static missingResource({ resourceType, resourceId, description }) {
+        return new Issue({
+            type: Issue.TYPES.MISSING_RESOURCE,
+            severity: Issue.SEVERITIES.CRITICAL,
+            resourceType,
+            resourceId,
+            description,
+            resolution: 'Verify resource was not manually deleted. May need to recreate or remove from stack definition.',
+            canAutoFix: false,
+        });
+    }
+
+    /**
+     * Create a property mismatch issue
+     *
+     * @param {Object} params
+     * @param {string} params.resourceType - CloudFormation resource type
+     * @param {string} params.resourceId - Resource identifier
+     * @param {PropertyMismatch} params.mismatch - Property mismatch details
+     * @returns {Issue}
+     */
+    static propertyMismatch({ resourceType, resourceId, mismatch }) {
+        const severity = mismatch.requiresReplacement()
+            ? Issue.SEVERITIES.CRITICAL
+            : Issue.SEVERITIES.WARNING;
+
+        const canAutoFix = mismatch.canAutoFix();
+
+        const description = `Property mismatch: ${mismatch.propertyPath} (expected: ${mismatch.expectedValue}, actual: ${mismatch.actualValue})`;
+
+        const resolution = canAutoFix
+            ? 'Can be auto-fixed using frigg repair --reconcile'
+            : 'Requires resource replacement - manual intervention needed';
+
+        return new Issue({
+            type: Issue.TYPES.PROPERTY_MISMATCH,
+            severity,
+            resourceType,
+            resourceId,
+            description,
+            resolution,
+            canAutoFix,
+            propertyMismatch: mismatch,
+        });
+    }
+}
+
+module.exports = Issue;

package/infrastructure/domains/health/domain/entities/issue.test.js

@@ -0,0 +1,417 @@
+/**
+ * Tests for Issue Entity
+ */
+
+const Issue = require('./issue');
+const ResourceState = require('../value-objects/resource-state');
+const PropertyMismatch = require('./property-mismatch');
+const PropertyMutability = require('../value-objects/property-mutability');
+
+describe('Issue', () => {
+    describe('constructor', () => {
+        it('should create an orphaned resource issue', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-app-prod-aurora',
+                description: 'Aurora cluster exists in AWS but not managed by CloudFormation',
+                resolution: 'Import resource into CloudFormation stack',
+                canAutoFix: true,
+            });
+
+            expect(issue.type).toBe('ORPHANED_RESOURCE');
+            expect(issue.severity).toBe('critical');
+            expect(issue.resourceType).toBe('AWS::RDS::DBCluster');
+            expect(issue.resourceId).toBe('my-app-prod-aurora');
+            expect(issue.description).toBe('Aurora cluster exists in AWS but not managed by CloudFormation');
+            expect(issue.resolution).toBe('Import resource into CloudFormation stack');
+            expect(issue.canAutoFix).toBe(true);
+        });
+
+        it('should create a missing resource issue', () => {
+            const issue = new Issue({
+                type: 'MISSING_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::KMS::Key',
+                resourceId: 'FriggKMSKey',
+                description: 'KMS key defined in stack but does not exist in AWS',
+                resolution: 'Verify resource was not manually deleted',
+                canAutoFix: false,
+            });
+
+            expect(issue.type).toBe('MISSING_RESOURCE');
+            expect(issue.severity).toBe('critical');
+        });
+
+        it('should create a property mismatch issue', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: [{ Key: 'Environment', Value: 'production' }],
+                actualValue: [{ Key: 'Env', Value: 'prod' }],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            const issue = new Issue({
+                type: 'PROPERTY_MISMATCH',
+                severity: 'warning',
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-0abc123',
+                description: 'VPC tags differ from expected configuration',
+                resolution: 'Update VPC tags to match desired state',
+                canAutoFix: true,
+                propertyMismatch: mismatch,
+            });
+
+            expect(issue.type).toBe('PROPERTY_MISMATCH');
+            expect(issue.propertyMismatch).toBe(mismatch);
+            expect(issue.canAutoFix).toBe(true);
+        });
+
+        it('should require type', () => {
+            expect(() => {
+                new Issue({
+                    severity: 'critical',
+                    resourceType: 'AWS::S3::Bucket',
+                    resourceId: 'my-bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('type is required');
+        });
+
+        it('should require severity', () => {
+            expect(() => {
+                new Issue({
+                    type: 'ORPHANED_RESOURCE',
+                    resourceType: 'AWS::S3::Bucket',
+                    resourceId: 'my-bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('severity is required');
+        });
+
+        it('should require resourceType', () => {
+            expect(() => {
+                new Issue({
+                    type: 'ORPHANED_RESOURCE',
+                    severity: 'critical',
+                    resourceId: 'my-bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('resourceType is required');
+        });
+
+        it('should require resourceId', () => {
+            expect(() => {
+                new Issue({
+                    type: 'ORPHANED_RESOURCE',
+                    severity: 'critical',
+                    resourceType: 'AWS::S3::Bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('resourceId is required');
+        });
+
+        it('should require description', () => {
+            expect(() => {
+                new Issue({
+                    type: 'ORPHANED_RESOURCE',
+                    severity: 'critical',
+                    resourceType: 'AWS::S3::Bucket',
+                    resourceId: 'my-bucket',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('description is required');
+        });
+
+        it('should validate issue type', () => {
+            expect(() => {
+                new Issue({
+                    type: 'INVALID_TYPE',
+                    severity: 'critical',
+                    resourceType: 'AWS::S3::Bucket',
+                    resourceId: 'my-bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('Invalid issue type: INVALID_TYPE');
+        });
+
+        it('should validate severity', () => {
+            expect(() => {
+                new Issue({
+                    type: 'ORPHANED_RESOURCE',
+                    severity: 'invalid',
+                    resourceType: 'AWS::S3::Bucket',
+                    resourceId: 'my-bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('Invalid severity: invalid');
+        });
+
+        it('should default canAutoFix to false', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::S3::Bucket',
+                resourceId: 'my-bucket',
+                description: 'Test',
+                resolution: 'Fix it',
+            });
+
+            expect(issue.canAutoFix).toBe(false);
+        });
+    });
+
+    describe('type checks', () => {
+        it('should check if issue is orphaned resource', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-cluster',
+                description: 'Test',
+                resolution: 'Import',
+            });
+
+            expect(issue.isOrphanedResource()).toBe(true);
+            expect(issue.isMissingResource()).toBe(false);
+            expect(issue.isPropertyMismatch()).toBe(false);
+            expect(issue.isDrifted()).toBe(false);
+        });
+
+        it('should check if issue is missing resource', () => {
+            const issue = new Issue({
+                type: 'MISSING_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::KMS::Key',
+                resourceId: 'FriggKMSKey',
+                description: 'Test',
+                resolution: 'Verify deletion',
+            });
+
+            expect(issue.isOrphanedResource()).toBe(false);
+            expect(issue.isMissingResource()).toBe(true);
+            expect(issue.isPropertyMismatch()).toBe(false);
+            expect(issue.isDrifted()).toBe(false);
+        });
+
+        it('should check if issue is property mismatch', () => {
+            const issue = new Issue({
+                type: 'PROPERTY_MISMATCH',
+                severity: 'warning',
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Test',
+                resolution: 'Update',
+            });
+
+            expect(issue.isOrphanedResource()).toBe(false);
+            expect(issue.isMissingResource()).toBe(false);
+            expect(issue.isPropertyMismatch()).toBe(true);
+            expect(issue.isDrifted()).toBe(false);
+        });
+
+        it('should check if issue is drifted', () => {
+            const issue = new Issue({
+                type: 'DRIFTED_RESOURCE',
+                severity: 'warning',
+                resourceType: 'AWS::S3::Bucket',
+                resourceId: 'my-bucket',
+                description: 'Test',
+                resolution: 'Reconcile',
+            });
+
+            expect(issue.isOrphanedResource()).toBe(false);
+            expect(issue.isMissingResource()).toBe(false);
+            expect(issue.isPropertyMismatch()).toBe(false);
+            expect(issue.isDrifted()).toBe(true);
+        });
+    });
+
+    describe('severity checks', () => {
+        it('should check if issue is critical', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-cluster',
+                description: 'Test',
+                resolution: 'Import',
+            });
+
+            expect(issue.isCritical()).toBe(true);
+            expect(issue.isWarning()).toBe(false);
+            expect(issue.isInfo()).toBe(false);
+        });
+
+        it('should check if issue is warning', () => {
+            const issue = new Issue({
+                type: 'PROPERTY_MISMATCH',
+                severity: 'warning',
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Test',
+                resolution: 'Update',
+            });
+
+            expect(issue.isCritical()).toBe(false);
+            expect(issue.isWarning()).toBe(true);
+            expect(issue.isInfo()).toBe(false);
+        });
+
+        it('should check if issue is info', () => {
+            const issue = new Issue({
+                type: 'MISSING_TAG',
+                severity: 'info',
+                resourceType: 'AWS::Lambda::Function',
+                resourceId: 'my-function',
+                description: 'Test',
+                resolution: 'Add tag',
+            });
+
+            expect(issue.isCritical()).toBe(false);
+            expect(issue.isWarning()).toBe(false);
+            expect(issue.isInfo()).toBe(true);
+        });
+    });
+
+    describe('toString', () => {
+        it('should return string representation', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-app-prod-aurora',
+                description: 'Aurora cluster exists in AWS but not managed by CloudFormation',
+                resolution: 'Import resource into CloudFormation stack',
+            });
+
+            const str = issue.toString();
+            expect(str).toContain('ORPHANED_RESOURCE');
+            expect(str).toContain('critical');
+            expect(str).toContain('AWS::RDS::DBCluster');
+            expect(str).toContain('my-app-prod-aurora');
+        });
+    });
+
+    describe('toJSON', () => {
+        it('should serialize to JSON', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-app-prod-aurora',
+                description: 'Aurora cluster exists in AWS but not managed by CloudFormation',
+                resolution: 'Import resource into CloudFormation stack',
+                canAutoFix: true,
+            });
+
+            const json = issue.toJSON();
+
+            expect(json).toEqual({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-app-prod-aurora',
+                description: 'Aurora cluster exists in AWS but not managed by CloudFormation',
+                resolution: 'Import resource into CloudFormation stack',
+                canAutoFix: true,
+                propertyMismatch: null,
+            });
+        });
+
+        it('should include property mismatch in JSON', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: [{ Key: 'Env', Value: 'prod' }],
+                actualValue: [{ Key: 'Env', Value: 'dev' }],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            const issue = new Issue({
+                type: 'PROPERTY_MISMATCH',
+                severity: 'warning',
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'VPC tags differ',
+                resolution: 'Update tags',
+                canAutoFix: true,
+                propertyMismatch: mismatch,
+            });
+
+            const json = issue.toJSON();
+
+            expect(json.propertyMismatch).toBeDefined();
+            expect(json.propertyMismatch.propertyPath).toBe('Properties.Tags');
+        });
+    });
+
+    describe('static factory methods', () => {
+        it('should create orphaned resource issue', () => {
+            const issue = Issue.orphanedResource({
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-cluster',
+                description: 'Cluster not in stack',
+            });
+
+            expect(issue.type).toBe('ORPHANED_RESOURCE');
+            expect(issue.severity).toBe('critical');
+            expect(issue.canAutoFix).toBe(true);
+        });
+
+        it('should create missing resource issue', () => {
+            const issue = Issue.missingResource({
+                resourceType: 'AWS::KMS::Key',
+                resourceId: 'FriggKMSKey',
+                description: 'Key not in AWS',
+            });
+
+            expect(issue.type).toBe('MISSING_RESOURCE');
+            expect(issue.severity).toBe('critical');
+            expect(issue.canAutoFix).toBe(false);
+        });
+
+        it('should create property mismatch issue', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: ['tag1'],
+                actualValue: ['tag2'],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            const issue = Issue.propertyMismatch({
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                mismatch,
+            });
+
+            expect(issue.type).toBe('PROPERTY_MISMATCH');
+            expect(issue.severity).toBe('warning'); // Default for mutable
+            expect(issue.propertyMismatch).toBe(mismatch);
+        });
+
+        it('should create property mismatch with critical severity for immutable', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.BucketName',
+                expectedValue: 'bucket-v2',
+                actualValue: 'bucket-v1',
+                mutability: PropertyMutability.IMMUTABLE,
+            });
+
+            const issue = Issue.propertyMismatch({
+                resourceType: 'AWS::S3::Bucket',
+                resourceId: 'my-bucket',
+                mismatch,
+            });
+
+            expect(issue.severity).toBe('critical'); // Critical for immutable
+            expect(issue.canAutoFix).toBe(false); // Can't auto-fix immutable
+        });
+    });
+});

package/infrastructure/domains/health/domain/entities/resource.js

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

package/infrastructure/domains/health/domain/entities/resource.test.js

@@ -0,0 +1,432 @@
+/**
+ * Tests for Resource Entity
+ */
+
+const Resource = require('./resource');
+const ResourceState = require('../value-objects/resource-state');
+const Issue = require('./issue');
+const PropertyMismatch = require('./property-mismatch');
+const PropertyMutability = require('../value-objects/property-mutability');
+
+describe('Resource', () => {
+    describe('constructor', () => {
+        it('should create a resource in stack', () => {
+            const resource = new Resource({
+                logicalId: 'ProductionVPC',
+                physicalId: 'vpc-0abc123def456',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+                properties: {
+                    CidrBlock: '10.0.0.0/16',
+                    Tags: [{ Key: 'Environment', Value: 'production' }],
+                },
+            });
+
+            expect(resource.logicalId).toBe('ProductionVPC');
+            expect(resource.physicalId).toBe('vpc-0abc123def456');
+            expect(resource.resourceType).toBe('AWS::EC2::VPC');
+            expect(resource.state.value).toBe('IN_STACK');
+            expect(resource.properties.CidrBlock).toBe('10.0.0.0/16');
+        });
+
+        it('should create an orphaned resource', () => {
+            const resource = new Resource({
+                logicalId: null,
+                physicalId: 'my-app-prod-aurora',
+                resourceType: 'AWS::RDS::DBCluster',
+                state: ResourceState.ORPHANED,
+                properties: {
+                    Engine: 'aurora-postgresql',
+                    EngineVersion: '13.7',
+                },
+            });
+
+            expect(resource.logicalId).toBeNull();
+            expect(resource.physicalId).toBe('my-app-prod-aurora');
+            expect(resource.state.value).toBe('ORPHANED');
+        });
+
+        it('should require physicalId', () => {
+            expect(() => {
+                new Resource({
+                    logicalId: 'MyResource',
+                    resourceType: 'AWS::S3::Bucket',
+                    state: ResourceState.IN_STACK,
+                });
+            }).toThrow('physicalId is required');
+        });
+
+        it('should require resourceType', () => {
+            expect(() => {
+                new Resource({
+                    logicalId: 'MyResource',
+                    physicalId: 'my-bucket',
+                    state: ResourceState.IN_STACK,
+                });
+            }).toThrow('resourceType is required');
+        });
+
+        it('should require state', () => {
+            expect(() => {
+                new Resource({
+                    logicalId: 'MyResource',
+                    physicalId: 'my-bucket',
+                    resourceType: 'AWS::S3::Bucket',
+                });
+            }).toThrow('state is required');
+        });
+
+        it('should validate state is ResourceState instance', () => {
+            expect(() => {
+                new Resource({
+                    logicalId: 'MyResource',
+                    physicalId: 'my-bucket',
+                    resourceType: 'AWS::S3::Bucket',
+                    state: 'IN_STACK', // String instead of ResourceState
+                });
+            }).toThrow('state must be a ResourceState instance');
+        });
+
+        it('should initialize empty issues array', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            expect(resource.issues).toEqual([]);
+        });
+
+        it('should initialize with provided issues', () => {
+            const issue = Issue.orphanedResource({
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-cluster',
+                description: 'Test',
+            });
+
+            const resource = new Resource({
+                logicalId: null,
+                physicalId: 'my-cluster',
+                resourceType: 'AWS::RDS::DBCluster',
+                state: ResourceState.ORPHANED,
+                issues: [issue],
+            });
+
+            expect(resource.issues).toHaveLength(1);
+            expect(resource.issues[0]).toBe(issue);
+        });
+
+        it('should default properties to empty object', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            expect(resource.properties).toEqual({});
+        });
+    });
+
+    describe('state checks', () => {
+        it('should check if resource is in stack', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            expect(resource.isInStack()).toBe(true);
+            expect(resource.isOrphaned()).toBe(false);
+            expect(resource.isMissing()).toBe(false);
+            expect(resource.isDrifted()).toBe(false);
+        });
+
+        it('should check if resource is orphaned', () => {
+            const resource = new Resource({
+                logicalId: null,
+                physicalId: 'my-cluster',
+                resourceType: 'AWS::RDS::DBCluster',
+                state: ResourceState.ORPHANED,
+            });
+
+            expect(resource.isInStack()).toBe(false);
+            expect(resource.isOrphaned()).toBe(true);
+            expect(resource.isMissing()).toBe(false);
+            expect(resource.isDrifted()).toBe(false);
+        });
+
+        it('should check if resource is missing', () => {
+            const resource = new Resource({
+                logicalId: 'FriggKMSKey',
+                physicalId: 'key-id-that-does-not-exist',
+                resourceType: 'AWS::KMS::Key',
+                state: ResourceState.MISSING,
+            });
+
+            expect(resource.isInStack()).toBe(false);
+            expect(resource.isOrphaned()).toBe(false);
+            expect(resource.isMissing()).toBe(true);
+            expect(resource.isDrifted()).toBe(false);
+        });
+
+        it('should check if resource is drifted', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.DRIFTED,
+            });
+
+            expect(resource.isInStack()).toBe(false);
+            expect(resource.isOrphaned()).toBe(false);
+            expect(resource.isMissing()).toBe(false);
+            expect(resource.isDrifted()).toBe(true);
+        });
+    });
+
+    describe('issue management', () => {
+        it('should add an issue', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            const issue = Issue.propertyMismatch({
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                mismatch: new PropertyMismatch({
+                    propertyPath: 'Properties.Tags',
+                    expectedValue: ['tag1'],
+                    actualValue: ['tag2'],
+                    mutability: PropertyMutability.MUTABLE,
+                }),
+            });
+
+            resource.addIssue(issue);
+
+            expect(resource.issues).toHaveLength(1);
+            expect(resource.issues[0]).toBe(issue);
+        });
+
+        it('should check if resource has issues', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            expect(resource.hasIssues()).toBe(false);
+
+            const issue = Issue.orphanedResource({
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Test',
+            });
+            resource.addIssue(issue);
+
+            expect(resource.hasIssues()).toBe(true);
+        });
+
+        it('should check if resource has critical issues', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            expect(resource.hasCriticalIssues()).toBe(false);
+
+            // Add warning issue
+            const warningIssue = new Issue({
+                type: 'PROPERTY_MISMATCH',
+                severity: 'warning',
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Test warning',
+            });
+            resource.addIssue(warningIssue);
+            expect(resource.hasCriticalIssues()).toBe(false);
+
+            // Add critical issue
+            const criticalIssue = Issue.orphanedResource({
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Test critical',
+            });
+            resource.addIssue(criticalIssue);
+            expect(resource.hasCriticalIssues()).toBe(true);
+        });
+
+        it('should get critical issues', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            const warningIssue = new Issue({
+                type: 'PROPERTY_MISMATCH',
+                severity: 'warning',
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Warning',
+            });
+
+            const criticalIssue1 = Issue.orphanedResource({
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Critical 1',
+            });
+
+            const criticalIssue2 = Issue.missingResource({
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Critical 2',
+            });
+
+            resource.addIssue(warningIssue);
+            resource.addIssue(criticalIssue1);
+            resource.addIssue(criticalIssue2);
+
+            const criticalIssues = resource.getCriticalIssues();
+            expect(criticalIssues).toHaveLength(2);
+            expect(criticalIssues).toContain(criticalIssue1);
+            expect(criticalIssues).toContain(criticalIssue2);
+        });
+    });
+
+    describe('isHealthy', () => {
+        it('should be healthy with no issues', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            expect(resource.isHealthy()).toBe(true);
+        });
+
+        it('should not be healthy with issues', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            const issue = Issue.propertyMismatch({
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                mismatch: new PropertyMismatch({
+                    propertyPath: 'Properties.Tags',
+                    expectedValue: ['tag1'],
+                    actualValue: ['tag2'],
+                    mutability: PropertyMutability.MUTABLE,
+                }),
+            });
+
+            resource.addIssue(issue);
+            expect(resource.isHealthy()).toBe(false);
+        });
+    });
+
+    describe('getIdentifier', () => {
+        it('should return logical ID if present', () => {
+            const resource = new Resource({
+                logicalId: 'ProductionVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            expect(resource.getIdentifier()).toBe('ProductionVPC');
+        });
+
+        it('should return physical ID if no logical ID', () => {
+            const resource = new Resource({
+                logicalId: null,
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.ORPHANED,
+            });
+
+            expect(resource.getIdentifier()).toBe('vpc-123');
+        });
+    });
+
+    describe('toString', () => {
+        it('should return string representation', () => {
+            const resource = new Resource({
+                logicalId: 'ProductionVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+            });
+
+            const str = resource.toString();
+            expect(str).toContain('AWS::EC2::VPC');
+            expect(str).toContain('ProductionVPC');
+            expect(str).toContain('vpc-123');
+            expect(str).toContain('IN_STACK');
+        });
+    });
+
+    describe('toJSON', () => {
+        it('should serialize to JSON', () => {
+            const resource = new Resource({
+                logicalId: 'ProductionVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.IN_STACK,
+                properties: {
+                    CidrBlock: '10.0.0.0/16',
+                },
+            });
+
+            const json = resource.toJSON();
+
+            expect(json).toEqual({
+                logicalId: 'ProductionVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: 'IN_STACK',
+                properties: {
+                    CidrBlock: '10.0.0.0/16',
+                },
+                issues: [],
+                isHealthy: true,
+            });
+        });
+
+        it('should include issues in JSON', () => {
+            const resource = new Resource({
+                logicalId: 'MyVPC',
+                physicalId: 'vpc-123',
+                resourceType: 'AWS::EC2::VPC',
+                state: ResourceState.DRIFTED,
+            });
+
+            const issue = Issue.orphanedResource({
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Test',
+            });
+            resource.addIssue(issue);
+
+            const json = resource.toJSON();
+
+            expect(json.issues).toHaveLength(1);
+            expect(json.issues[0].type).toBe('ORPHANED_RESOURCE');
+            expect(json.isHealthy).toBe(false);
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.474.6ec870b.0",
+  "version": "2.0.0--canary.474.82ba370.0",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -11,8 +11,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0--canary.474.6ec870b.0",
-    "@friggframework/test": "2.0.0--canary.474.6ec870b.0",
+    "@friggframework/schemas": "2.0.0--canary.474.82ba370.0",
+    "@friggframework/test": "2.0.0--canary.474.82ba370.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -34,8 +34,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.474.6ec870b.0",
-    "@friggframework/prettier-config": "2.0.0--canary.474.6ec870b.0",
+    "@friggframework/eslint-config": "2.0.0--canary.474.82ba370.0",
+    "@friggframework/prettier-config": "2.0.0--canary.474.82ba370.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -70,5 +70,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "6ec870b531e40de123ba0be2a4ccff3d00d154ae"
+  "gitHead": "82ba370ccfb7248873a75e36760fbd30401e1027"
 }