@friggframework/devtools 2.0.0--canary.474.6ec870b.0 → 2.0.0--canary.474.d64c550.0

package/infrastructure/domains/health/domain/services/mismatch-analyzer.js

@@ -0,0 +1,234 @@
+/**
+ * MismatchAnalyzer Domain Service
+ *
+ * Analyzes differences between expected (CloudFormation template) and actual
+ * (cloud resource) property values to detect drift.
+ *
+ * Features:
+ * - Deep object comparison
+ * - Array comparison (order-sensitive)
+ * - Primitive value comparison
+ * - Type mismatch detection
+ * - Property mutability tracking
+ * - Ignore specific properties
+ * - Nested property path tracking
+ */
+
+const PropertyMismatch = require('../entities/property-mismatch');
+const PropertyMutability = require('../value-objects/property-mutability');
+
+class MismatchAnalyzer {
+    /**
+     * Analyze differences between expected and actual property values
+     *
+     * @param {Object} params
+     * @param {Object} params.expected - Expected properties from CloudFormation template
+     * @param {Object} params.actual - Actual properties from cloud resource
+     * @param {Object} params.propertyMutability - Map of property paths to PropertyMutability instances
+     * @param {string[]} [params.ignoreProperties=[]] - Property paths to ignore
+     * @returns {PropertyMismatch[]} Array of detected mismatches
+     */
+    analyze({ expected, actual, propertyMutability, ignoreProperties = [] }) {
+        const mismatches = [];
+
+        // Recursively compare objects
+        this._compareObjects({
+            expected,
+            actual,
+            propertyMutability,
+            ignoreProperties,
+            currentPath: '',
+            mismatches,
+        });
+
+        return mismatches;
+    }
+
+    /**
+     * Recursively compare two objects
+     *
+     * @private
+     */
+    _compareObjects({
+        expected,
+        actual,
+        propertyMutability,
+        ignoreProperties,
+        currentPath,
+        mismatches,
+    }) {
+        // Get all unique property keys from both objects
+        const allKeys = new Set([
+            ...Object.keys(expected || {}),
+            ...Object.keys(actual || {}),
+        ]);
+
+        for (const key of allKeys) {
+            const propertyPath = currentPath ? `${currentPath}.${key}` : key;
+
+            // Skip ignored properties
+            if (ignoreProperties.includes(propertyPath)) {
+                continue;
+            }
+
+            const expectedValue = expected?.[key];
+            const actualValue = actual?.[key];
+
+            // Check if values are different
+            if (!this._areValuesEqual(expectedValue, actualValue)) {
+                // Check if both are objects (and not arrays or null)
+                if (
+                    this._isPlainObject(expectedValue) &&
+                    this._isPlainObject(actualValue)
+                ) {
+                    // Recursively compare nested objects
+                    this._compareObjects({
+                        expected: expectedValue,
+                        actual: actualValue,
+                        propertyMutability,
+                        ignoreProperties,
+                        currentPath: propertyPath,
+                        mismatches,
+                    });
+                } else {
+                    // Create a mismatch for this property
+                    const mutability =
+                        propertyMutability[propertyPath] || PropertyMutability.MUTABLE;
+
+                    const mismatch = new PropertyMismatch({
+                        propertyPath,
+                        expectedValue,
+                        actualValue,
+                        mutability,
+                    });
+
+                    mismatches.push(mismatch);
+                }
+            }
+        }
+    }
+
+    /**
+     * Check if two values are equal
+     *
+     * @private
+     * @param {*} value1
+     * @param {*} value2
+     * @returns {boolean}
+     */
+    _areValuesEqual(value1, value2) {
+        // Handle null/undefined equivalence
+        if (this._isNullish(value1) && this._isNullish(value2)) {
+            return true;
+        }
+
+        // Handle different types
+        if (typeof value1 !== typeof value2) {
+            return false;
+        }
+
+        // Handle primitives
+        if (
+            typeof value1 === 'string' ||
+            typeof value1 === 'number' ||
+            typeof value1 === 'boolean'
+        ) {
+            return value1 === value2;
+        }
+
+        // Handle arrays
+        if (Array.isArray(value1) && Array.isArray(value2)) {
+            return this._areArraysEqual(value1, value2);
+        }
+
+        // Handle plain objects
+        if (this._isPlainObject(value1) && this._isPlainObject(value2)) {
+            return this._areObjectsEqual(value1, value2);
+        }
+
+        // Handle dates
+        if (value1 instanceof Date && value2 instanceof Date) {
+            return value1.getTime() === value2.getTime();
+        }
+
+        // Fallback: strict equality
+        return value1 === value2;
+    }
+
+    /**
+     * Check if value is null or undefined
+     *
+     * @private
+     * @param {*} value
+     * @returns {boolean}
+     */
+    _isNullish(value) {
+        return value === null || value === undefined;
+    }
+
+    /**
+     * Check if value is a plain object (not array, not null, not Date, etc.)
+     *
+     * @private
+     * @param {*} value
+     * @returns {boolean}
+     */
+    _isPlainObject(value) {
+        return (
+            typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            !(value instanceof Date) &&
+            Object.getPrototypeOf(value) === Object.prototype
+        );
+    }
+
+    /**
+     * Deep equality check for arrays (order-sensitive)
+     *
+     * @private
+     * @param {Array} arr1
+     * @param {Array} arr2
+     * @returns {boolean}
+     */
+    _areArraysEqual(arr1, arr2) {
+        if (arr1.length !== arr2.length) {
+            return false;
+        }
+
+        for (let i = 0; i < arr1.length; i++) {
+            if (!this._areValuesEqual(arr1[i], arr2[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Deep equality check for plain objects
+     *
+     * @private
+     * @param {Object} obj1
+     * @param {Object} obj2
+     * @returns {boolean}
+     */
+    _areObjectsEqual(obj1, obj2) {
+        const keys1 = Object.keys(obj1);
+        const keys2 = Object.keys(obj2);
+
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+
+        for (const key of keys1) {
+            if (!this._areValuesEqual(obj1[key], obj2[key])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+
+module.exports = MismatchAnalyzer;

package/infrastructure/domains/health/domain/services/mismatch-analyzer.test.js

@@ -0,0 +1,431 @@
+/**
+ * Tests for MismatchAnalyzer Domain Service
+ */
+
+const MismatchAnalyzer = require('./mismatch-analyzer');
+const PropertyMutability = require('../value-objects/property-mutability');
+
+describe('MismatchAnalyzer', () => {
+    let analyzer;
+
+    beforeEach(() => {
+        analyzer = new MismatchAnalyzer();
+    });
+
+    describe('primitive value comparison', () => {
+        it('should detect no mismatch for identical strings', () => {
+            const mismatches = analyzer.analyze({
+                expected: { name: 'my-vpc' },
+                actual: { name: 'my-vpc' },
+                propertyMutability: { name: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(0);
+        });
+
+        it('should detect mismatch for different strings', () => {
+            const mismatches = analyzer.analyze({
+                expected: { name: 'my-vpc-v1' },
+                actual: { name: 'my-vpc-v2' },
+                propertyMutability: { name: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('name');
+            expect(mismatches[0].expectedValue).toBe('my-vpc-v1');
+            expect(mismatches[0].actualValue).toBe('my-vpc-v2');
+            expect(mismatches[0].mutability.value).toBe('MUTABLE');
+        });
+
+        it('should detect mismatch for different numbers', () => {
+            const mismatches = analyzer.analyze({
+                expected: { maxSize: 10 },
+                actual: { maxSize: 20 },
+                propertyMutability: { maxSize: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('maxSize');
+            expect(mismatches[0].expectedValue).toBe(10);
+            expect(mismatches[0].actualValue).toBe(20);
+        });
+
+        it('should detect mismatch for different booleans', () => {
+            const mismatches = analyzer.analyze({
+                expected: { enableDnsSupport: true },
+                actual: { enableDnsSupport: false },
+                propertyMutability: { enableDnsSupport: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('enableDnsSupport');
+            expect(mismatches[0].expectedValue).toBe(true);
+            expect(mismatches[0].actualValue).toBe(false);
+        });
+    });
+
+    describe('null and undefined handling', () => {
+        it('should detect no mismatch for both null', () => {
+            const mismatches = analyzer.analyze({
+                expected: { description: null },
+                actual: { description: null },
+                propertyMutability: { description: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(0);
+        });
+
+        it('should detect mismatch for null vs value', () => {
+            const mismatches = analyzer.analyze({
+                expected: { description: null },
+                actual: { description: 'Production VPC' },
+                propertyMutability: { description: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('description');
+            expect(mismatches[0].expectedValue).toBeNull();
+            expect(mismatches[0].actualValue).toBe('Production VPC');
+        });
+
+        it('should handle undefined as equivalent to null', () => {
+            const mismatches = analyzer.analyze({
+                expected: { description: undefined },
+                actual: { description: null },
+                propertyMutability: { description: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(0);
+        });
+    });
+
+    describe('nested object comparison', () => {
+        it('should detect no mismatch for identical nested objects', () => {
+            const mismatches = analyzer.analyze({
+                expected: {
+                    tags: {
+                        Environment: 'production',
+                        Team: 'platform',
+                    },
+                },
+                actual: {
+                    tags: {
+                        Environment: 'production',
+                        Team: 'platform',
+                    },
+                },
+                propertyMutability: { tags: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(0);
+        });
+
+        it('should detect mismatch in nested object property', () => {
+            const mismatches = analyzer.analyze({
+                expected: {
+                    tags: {
+                        Environment: 'production',
+                        Team: 'platform',
+                    },
+                },
+                actual: {
+                    tags: {
+                        Environment: 'staging',
+                        Team: 'platform',
+                    },
+                },
+                propertyMutability: { 'tags.Environment': PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('tags.Environment');
+            expect(mismatches[0].expectedValue).toBe('production');
+            expect(mismatches[0].actualValue).toBe('staging');
+        });
+
+        it('should detect mismatch when nested property is missing', () => {
+            const mismatches = analyzer.analyze({
+                expected: {
+                    tags: {
+                        Environment: 'production',
+                        Team: 'platform',
+                    },
+                },
+                actual: {
+                    tags: {
+                        Environment: 'production',
+                    },
+                },
+                propertyMutability: { 'tags.Team': PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('tags.Team');
+            expect(mismatches[0].expectedValue).toBe('platform');
+            expect(mismatches[0].actualValue).toBeUndefined();
+        });
+
+        it('should detect mismatch when nested property is added', () => {
+            const mismatches = analyzer.analyze({
+                expected: {
+                    tags: {
+                        Environment: 'production',
+                    },
+                },
+                actual: {
+                    tags: {
+                        Environment: 'production',
+                        Team: 'platform',
+                    },
+                },
+                propertyMutability: { 'tags.Team': PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('tags.Team');
+            expect(mismatches[0].expectedValue).toBeUndefined();
+            expect(mismatches[0].actualValue).toBe('platform');
+        });
+    });
+
+    describe('array comparison', () => {
+        it('should detect no mismatch for identical arrays', () => {
+            const mismatches = analyzer.analyze({
+                expected: { subnets: ['subnet-1', 'subnet-2'] },
+                actual: { subnets: ['subnet-1', 'subnet-2'] },
+                propertyMutability: { subnets: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(0);
+        });
+
+        it('should detect mismatch for different array values', () => {
+            const mismatches = analyzer.analyze({
+                expected: { subnets: ['subnet-1', 'subnet-2'] },
+                actual: { subnets: ['subnet-1', 'subnet-3'] },
+                propertyMutability: { subnets: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('subnets');
+            expect(mismatches[0].expectedValue).toEqual(['subnet-1', 'subnet-2']);
+            expect(mismatches[0].actualValue).toEqual(['subnet-1', 'subnet-3']);
+        });
+
+        it('should detect mismatch for different array lengths', () => {
+            const mismatches = analyzer.analyze({
+                expected: { subnets: ['subnet-1', 'subnet-2'] },
+                actual: { subnets: ['subnet-1'] },
+                propertyMutability: { subnets: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('subnets');
+            expect(mismatches[0].expectedValue).toEqual(['subnet-1', 'subnet-2']);
+            expect(mismatches[0].actualValue).toEqual(['subnet-1']);
+        });
+
+        it('should detect mismatch for different array order (order-sensitive)', () => {
+            const mismatches = analyzer.analyze({
+                expected: { subnets: ['subnet-1', 'subnet-2'] },
+                actual: { subnets: ['subnet-2', 'subnet-1'] },
+                propertyMutability: { subnets: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('subnets');
+        });
+
+        it('should handle arrays of objects', () => {
+            const mismatches = analyzer.analyze({
+                expected: {
+                    tags: [
+                        { Key: 'Environment', Value: 'production' },
+                        { Key: 'Team', Value: 'platform' },
+                    ],
+                },
+                actual: {
+                    tags: [
+                        { Key: 'Environment', Value: 'staging' },
+                        { Key: 'Team', Value: 'platform' },
+                    ],
+                },
+                propertyMutability: { tags: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('tags');
+        });
+    });
+
+    describe('type mismatch', () => {
+        it('should detect type mismatch (string vs number)', () => {
+            const mismatches = analyzer.analyze({
+                expected: { port: '8080' },
+                actual: { port: 8080 },
+                propertyMutability: { port: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('port');
+            expect(mismatches[0].expectedValue).toBe('8080');
+            expect(mismatches[0].actualValue).toBe(8080);
+        });
+
+        it('should detect type mismatch (object vs array)', () => {
+            const mismatches = analyzer.analyze({
+                expected: { data: {} },
+                actual: { data: [] },
+                propertyMutability: { data: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('data');
+        });
+    });
+
+    describe('property mutability', () => {
+        it('should use MUTABLE mutability by default', () => {
+            const mismatches = analyzer.analyze({
+                expected: { name: 'vpc-v1' },
+                actual: { name: 'vpc-v2' },
+                propertyMutability: {}, // No mutability specified
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].mutability.value).toBe('MUTABLE');
+        });
+
+        it('should apply IMMUTABLE mutability', () => {
+            const mismatches = analyzer.analyze({
+                expected: { bucketName: 'bucket-v1' },
+                actual: { bucketName: 'bucket-v2' },
+                propertyMutability: { bucketName: PropertyMutability.IMMUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].mutability.value).toBe('IMMUTABLE');
+        });
+
+        it('should apply CONDITIONAL mutability', () => {
+            const mismatches = analyzer.analyze({
+                expected: { engineVersion: '13.7' },
+                actual: { engineVersion: '13.8' },
+                propertyMutability: { engineVersion: PropertyMutability.CONDITIONAL },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].mutability.value).toBe('CONDITIONAL');
+        });
+    });
+
+    describe('multiple mismatches', () => {
+        it('should detect multiple mismatches in same object', () => {
+            const mismatches = analyzer.analyze({
+                expected: {
+                    name: 'vpc-v1',
+                    cidr: '10.0.0.0/16',
+                    enableDnsSupport: true,
+                },
+                actual: {
+                    name: 'vpc-v2',
+                    cidr: '10.1.0.0/16',
+                    enableDnsSupport: true,
+                },
+                propertyMutability: {
+                    name: PropertyMutability.MUTABLE,
+                    cidr: PropertyMutability.IMMUTABLE,
+                    enableDnsSupport: PropertyMutability.MUTABLE,
+                },
+            });
+
+            expect(mismatches).toHaveLength(2);
+
+            const nameMismatch = mismatches.find((m) => m.propertyPath === 'name');
+            expect(nameMismatch).toBeDefined();
+            expect(nameMismatch.mutability.value).toBe('MUTABLE');
+
+            const cidrMismatch = mismatches.find((m) => m.propertyPath === 'cidr');
+            expect(cidrMismatch).toBeDefined();
+            expect(cidrMismatch.mutability.value).toBe('IMMUTABLE');
+        });
+    });
+
+    describe('ignore properties', () => {
+        it('should ignore specified properties', () => {
+            const mismatches = analyzer.analyze({
+                expected: {
+                    name: 'my-vpc',
+                    lastModified: '2024-01-01',
+                },
+                actual: {
+                    name: 'my-vpc',
+                    lastModified: '2024-01-15',
+                },
+                propertyMutability: { name: PropertyMutability.MUTABLE },
+                ignoreProperties: ['lastModified'],
+            });
+
+            expect(mismatches).toHaveLength(0);
+        });
+
+        it('should ignore nested properties', () => {
+            const mismatches = analyzer.analyze({
+                expected: {
+                    config: {
+                        name: 'production',
+                        timestamp: '2024-01-01',
+                    },
+                },
+                actual: {
+                    config: {
+                        name: 'production',
+                        timestamp: '2024-01-15',
+                    },
+                },
+                propertyMutability: { 'config.name': PropertyMutability.MUTABLE },
+                ignoreProperties: ['config.timestamp'],
+            });
+
+            expect(mismatches).toHaveLength(0);
+        });
+    });
+
+    describe('empty objects', () => {
+        it('should detect no mismatch for both empty objects', () => {
+            const mismatches = analyzer.analyze({
+                expected: {},
+                actual: {},
+                propertyMutability: {},
+            });
+
+            expect(mismatches).toHaveLength(0);
+        });
+
+        it('should detect mismatch when expected is empty but actual has properties', () => {
+            const mismatches = analyzer.analyze({
+                expected: {},
+                actual: { name: 'my-vpc' },
+                propertyMutability: { name: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('name');
+            expect(mismatches[0].expectedValue).toBeUndefined();
+            expect(mismatches[0].actualValue).toBe('my-vpc');
+        });
+
+        it('should detect mismatch when actual is empty but expected has properties', () => {
+            const mismatches = analyzer.analyze({
+                expected: { name: 'my-vpc' },
+                actual: {},
+                propertyMutability: { name: PropertyMutability.MUTABLE },
+            });
+
+            expect(mismatches).toHaveLength(1);
+            expect(mismatches[0].propertyPath).toBe('name');
+            expect(mismatches[0].expectedValue).toBe('my-vpc');
+            expect(mismatches[0].actualValue).toBeUndefined();
+        });
+    });
+});

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

@@ -152,6 +152,19 @@ class StackIdentifier {
         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
      *