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

package/infrastructure/domains/shared/base-resolver.test.js

@@ -1,305 +0,0 @@
-const BaseResourceResolver = require('./base-resolver');
-const { ResourceOwnership } = require('./types');
-
-describe('BaseResourceResolver', () => {
-    let resolver;
-
-    beforeEach(() => {
-        resolver = new BaseResourceResolver();
-    });
-
-    describe('helper methods', () => {
-        const mockDiscovery = {
-            stackManaged: [
-                { logicalId: 'FriggVPC', physicalId: 'vpc-123', resourceType: 'AWS::EC2::VPC' },
-                { logicalId: 'FriggLambdaSecurityGroup', physicalId: 'sg-456', resourceType: 'AWS::EC2::SecurityGroup' }
-            ],
-            external: [
-                { physicalId: 'vpc-external', resourceType: 'AWS::EC2::VPC', source: 'tag-search' }
-            ],
-            fromCloudFormation: true
-        };
-
-        describe('findInStack', () => {
-            it('should find resource in stack', () => {
-                const resource = resolver.findInStack('FriggVPC', mockDiscovery);
-
-                expect(resource).toEqual({
-                    logicalId: 'FriggVPC',
-                    physicalId: 'vpc-123',
-                    resourceType: 'AWS::EC2::VPC'
-                });
-            });
-
-            it('should return null if not found', () => {
-                const resource = resolver.findInStack('NonExistent', mockDiscovery);
-                expect(resource).toBeNull();
-            });
-        });
-
-        describe('findExternal', () => {
-            it('should find external resource by type', () => {
-                const resource = resolver.findExternal('AWS::EC2::VPC', mockDiscovery);
-
-                expect(resource).toEqual({
-                    physicalId: 'vpc-external',
-                    resourceType: 'AWS::EC2::VPC',
-                    source: 'tag-search'
-                });
-            });
-
-            it('should return null if not found', () => {
-                const resource = resolver.findExternal('AWS::RDS::DBCluster', mockDiscovery);
-                expect(resource).toBeNull();
-            });
-        });
-
-        describe('isInStack', () => {
-            it('should return true if resource is in stack', () => {
-                expect(resolver.isInStack('FriggVPC', mockDiscovery)).toBe(true);
-                expect(resolver.isInStack('FriggLambdaSecurityGroup', mockDiscovery)).toBe(true);
-            });
-
-            it('should return false if resource is not in stack', () => {
-                expect(resolver.isInStack('NonExistent', mockDiscovery)).toBe(false);
-            });
-        });
-
-        describe('requireExternalIds', () => {
-            it('should not throw if IDs are provided', () => {
-                expect(() => resolver.requireExternalIds('vpc-123', 'vpcId')).not.toThrow();
-                expect(() => resolver.requireExternalIds(['sg-1', 'sg-2'], 'securityGroupIds')).not.toThrow();
-            });
-
-            it('should throw if IDs are missing', () => {
-                expect(() => resolver.requireExternalIds(undefined, 'vpcId')).toThrow(
-                    "ownership='external' for vpcId requires external.vpcId"
-                );
-                expect(() => resolver.requireExternalIds(null, 'vpcId')).toThrow();
-                expect(() => resolver.requireExternalIds([], 'securityGroupIds')).toThrow();
-            });
-        });
-    });
-
-    describe('resolveResourceOwnership', () => {
-        describe('with explicit stack intent', () => {
-            it('should return STACK ownership', () => {
-                const discovery = {
-                    stackManaged: [],
-                    external: [{ physicalId: 'vpc-ext', resourceType: 'AWS::EC2::VPC', source: 'tag-search' }],
-                    fromCloudFormation: false
-                };
-
-                const decision = resolver.resolveResourceOwnership(
-                    'stack',
-                    'FriggVPC',
-                    'AWS::EC2::VPC',
-                    discovery
-                );
-
-                expect(decision.ownership).toBe(ResourceOwnership.STACK);
-                expect(decision.reason).toContain('User explicitly specified ownership=stack');
-            });
-        });
-
-        describe('with explicit external intent', () => {
-            it('should return EXTERNAL ownership', () => {
-                const discovery = {
-                    stackManaged: [
-                        { logicalId: 'FriggVPC', physicalId: 'vpc-123', resourceType: 'AWS::EC2::VPC' }
-                    ],
-                    external: [],
-                    fromCloudFormation: true
-                };
-
-                const decision = resolver.resolveResourceOwnership(
-                    'external',
-                    'FriggVPC',
-                    'AWS::EC2::VPC',
-                    discovery
-                );
-
-                expect(decision.ownership).toBe(ResourceOwnership.EXTERNAL);
-                expect(decision.reason).toContain('User explicitly specified ownership=external');
-            });
-        });
-
-        describe('with auto intent', () => {
-            it('should return STACK if resource is in stack (CRITICAL)', () => {
-                const discovery = {
-                    stackManaged: [
-                        { logicalId: 'FriggLambdaSecurityGroup', physicalId: 'sg-069629001ade41c9a', resourceType: 'AWS::EC2::SecurityGroup' }
-                    ],
-                    external: [],
-                    fromCloudFormation: true
-                };
-
-                const decision = resolver.resolveResourceOwnership(
-                    'auto',
-                    'FriggLambdaSecurityGroup',
-                    'AWS::EC2::SecurityGroup',
-                    discovery
-                );
-
-                expect(decision.ownership).toBe(ResourceOwnership.STACK);
-                expect(decision.physicalId).toBe('sg-069629001ade41c9a');
-                expect(decision.reason).toContain('Found in CloudFormation stack');
-                expect(decision.reason).toContain('must keep in template to avoid deletion');
-            });
-
-            it('should return EXTERNAL if found externally but not in stack', () => {
-                const discovery = {
-                    stackManaged: [],
-                    external: [
-                        { physicalId: 'vpc-external', resourceType: 'AWS::EC2::VPC', source: 'tag-search' }
-                    ],
-                    fromCloudFormation: false
-                };
-
-                const decision = resolver.resolveResourceOwnership(
-                    'auto',
-                    'FriggVPC',
-                    'AWS::EC2::VPC',
-                    discovery
-                );
-
-                expect(decision.ownership).toBe(ResourceOwnership.EXTERNAL);
-                expect(decision.physicalId).toBe('vpc-external');
-                expect(decision.reason).toContain('Found external resource via discovery');
-            });
-
-            it('should return STACK if not found anywhere (create new)', () => {
-                const discovery = {
-                    stackManaged: [],
-                    external: [],
-                    fromCloudFormation: false
-                };
-
-                const decision = resolver.resolveResourceOwnership(
-                    'auto',
-                    'FriggVPC',
-                    'AWS::EC2::VPC',
-                    discovery
-                );
-
-                expect(decision.ownership).toBe(ResourceOwnership.STACK);
-                expect(decision.physicalId).toBeUndefined();
-                expect(decision.reason).toContain('No existing resource found - will create in stack');
-            });
-        });
-
-        describe('metadata', () => {
-            it('should include complete metadata', () => {
-                const discovery = {
-                    stackManaged: [
-                        { logicalId: 'FriggVPC', physicalId: 'vpc-123', resourceType: 'AWS::EC2::VPC' }
-                    ],
-                    external: [],
-                    fromCloudFormation: true
-                };
-
-                const decision = resolver.resolveResourceOwnership(
-                    'auto',
-                    'FriggVPC',
-                    'AWS::EC2::VPC',
-                    discovery
-                );
-
-                expect(decision.metadata).toEqual({
-                    logicalId: 'FriggVPC',
-                    resourceType: 'AWS::EC2::VPC',
-                    userIntent: 'auto',
-                    inStack: true,
-                    foundExternal: false
-                });
-            });
-        });
-    });
-
-    describe('createExternalDecision', () => {
-        it('should create external decision with single ID', () => {
-            const decision = resolver.createExternalDecision('vpc-external');
-
-            expect(decision).toEqual({
-                ownership: ResourceOwnership.EXTERNAL,
-                physicalId: 'vpc-external',
-                physicalIds: ['vpc-external'],
-                reason: 'Using external resource reference',
-                metadata: {
-                    source: 'user-provided'
-                }
-            });
-        });
-
-        it('should create external decision with multiple IDs', () => {
-            const decision = resolver.createExternalDecision(['sg-1', 'sg-2'], 'Custom reason');
-
-            expect(decision).toEqual({
-                ownership: ResourceOwnership.EXTERNAL,
-                physicalId: 'sg-1',
-                physicalIds: ['sg-1', 'sg-2'],
-                reason: 'Custom reason',
-                metadata: {
-                    source: 'user-provided'
-                }
-            });
-        });
-    });
-
-    describe('createStackDecision', () => {
-        it('should create stack decision for new resource', () => {
-            const decision = resolver.createStackDecision();
-
-            expect(decision).toEqual({
-                ownership: ResourceOwnership.STACK,
-                physicalId: null,
-                reason: 'Managed by CloudFormation stack',
-                metadata: {
-                    source: 'new'
-                }
-            });
-        });
-
-        it('should create stack decision for existing resource', () => {
-            const decision = resolver.createStackDecision('vpc-123', 'Found in stack');
-
-            expect(decision).toEqual({
-                ownership: ResourceOwnership.STACK,
-                physicalId: 'vpc-123',
-                reason: 'Found in stack',
-                metadata: {
-                    source: 'discovered'
-                }
-            });
-        });
-    });
-
-    describe('backwards compatibility with flat discovery', () => {
-        it('should work with old flat discovery structure', () => {
-            const flatDiscovery = {
-                fromCloudFormationStack: true,
-                existingLogicalIds: ['FriggVPC', 'FriggLambdaSecurityGroup'],
-                defaultVpcId: 'vpc-123',
-                securityGroupId: 'sg-456',
-                _structured: {
-                    stackManaged: [
-                        { logicalId: 'FriggVPC', physicalId: 'vpc-123', resourceType: 'AWS::EC2::VPC' },
-                        { logicalId: 'FriggLambdaSecurityGroup', physicalId: 'sg-456', resourceType: 'AWS::EC2::SecurityGroup' }
-                    ],
-                    external: [],
-                    fromCloudFormation: true
-                }
-            };
-
-            const decision = resolver.resolveResourceOwnership(
-                'auto',
-                'FriggLambdaSecurityGroup',
-                'AWS::EC2::SecurityGroup',
-                flatDiscovery
-            );
-
-            expect(decision.ownership).toBe(ResourceOwnership.STACK);
-            expect(decision.physicalId).toBe('sg-456');
-        });
-    });
-});

package/infrastructure/domains/shared/builder-orchestrator.js

@@ -1,212 +0,0 @@
-/**
- * Infrastructure Builder Orchestrator
- * 
- * Application Layer - Hexagonal Architecture
- * 
- * Orchestrates the execution of all infrastructure builders with:
- * - Dependency resolution
- * - Parallel execution where possible
- * - Error handling and validation
- * - Progress reporting
- */
-
-const { gatherDiscoveredResources } = require('./resource-discovery');
-const { getAppEnvironmentVars, buildEnvironment } = require('./environment-builder');
-
-class BuilderOrchestrator {
-    constructor(builders = []) {
-        this.builders = new Map();
-        builders.forEach(builder => this.registerBuilder(builder));
-    }
-
-    /**
-     * Register a builder
-     */
-    registerBuilder(builder) {
-        this.builders.set(builder.getName(), builder);
-    }
-
-    /**
-     * Validate all applicable builders
-     */
-    async validateAll(appDefinition) {
-        console.log('\n🔍 Validating infrastructure configuration...');
-
-        const validationResults = [];
-        let hasErrors = false;
-
-        for (const [name, builder] of this.builders) {
-            if (builder.shouldExecute(appDefinition)) {
-                const result = builder.validate(appDefinition);
-                validationResults.push({ builder: name, result });
-
-                if (result.hasErrors()) {
-                    hasErrors = true;
-                    console.log(`❌ ${name} validation failed:`);
-                    result.errors.forEach(error => console.log(`   - ${error}`));
-                }
-
-                if (result.hasWarnings()) {
-                    console.log(`⚠️  ${name} warnings:`);
-                    result.warnings.forEach(warning => console.log(`   - ${warning}`));
-                }
-            }
-        }
-
-        if (hasErrors) {
-            throw new Error('Infrastructure validation failed. See errors above.');
-        }
-
-        console.log('✅ All infrastructure validation passed\n');
-        return validationResults;
-    }
-
-    /**
-     * Resolve builder execution order based on dependencies
-     */
-    resolveBuildOrder(appDefinition) {
-        const executionOrder = [];
-        const visited = new Set();
-        const visiting = new Set();
-
-        const visit = (builderName) => {
-            if (visited.has(builderName)) return;
-            if (visiting.has(builderName)) {
-                throw new Error(`Circular dependency detected: ${builderName}`);
-            }
-
-            const builder = this.builders.get(builderName);
-            if (!builder || !builder.shouldExecute(appDefinition)) {
-                return;
-            }
-
-            visiting.add(builderName);
-
-            // Visit dependencies first
-            const dependencies = builder.getDependencies() || [];
-            dependencies.forEach(dep => visit(dep));
-
-            visiting.delete(builderName);
-            visited.add(builderName);
-            executionOrder.push(builderName);
-        };
-
-        // Visit all builders
-        for (const [builderName] of this.builders) {
-            visit(builderName);
-        }
-
-        return executionOrder;
-    }
-
-    /**
-     * Build all infrastructure
-     */
-    async buildAll(appDefinition) {
-        console.log('\n🏗️  Building infrastructure...');
-
-        // Step 1: Validate configuration
-        await this.validateAll(appDefinition);
-
-        // Step 2: Discover AWS resources
-        const discoveredResources = await gatherDiscoveredResources(appDefinition);
-
-        // Step 3: Resolve build order
-        const buildOrder = this.resolveBuildOrder(appDefinition);
-        console.log(`📋 Build order: ${buildOrder.join(' → ')}\n`);
-
-        // Step 4: Execute builders in order
-        const buildResults = {};
-
-        for (const builderName of buildOrder) {
-            const builder = this.builders.get(builderName);
-            try {
-                const result = await builder.build(appDefinition, discoveredResources);
-                buildResults[builderName] = result;
-            } catch (error) {
-                console.error(`❌ ${builderName} build failed:`, error.message);
-                throw error;
-            }
-        }
-
-        // Step 5: Merge results
-        return this.mergeResults(buildResults, appDefinition, discoveredResources);
-    }
-
-    /**
-     * Merge builder results into cohesive definition
-     */
-    mergeResults(buildResults, appDefinition, discoveredResources) {
-        console.log('\n🔗 Merging infrastructure results...');
-
-        const merged = {
-            resources: {},
-            iamStatements: [],
-            environment: {},
-            functions: {},
-            layers: {},
-            plugins: [],
-            custom: {},
-            vpcConfig: null,
-        };
-
-        // Merge results from each builder
-        for (const [builderName, result] of Object.entries(buildResults)) {
-            // Merge resources
-            if (result.resources) {
-                Object.assign(merged.resources, result.resources);
-            }
-
-            // Merge IAM statements
-            if (result.iamStatements) {
-                merged.iamStatements.push(...result.iamStatements);
-            }
-
-            // Merge environment variables
-            if (result.environment) {
-                Object.assign(merged.environment, result.environment);
-            }
-
-            // Merge functions
-            if (result.functions) {
-                Object.assign(merged.functions, result.functions);
-            }
-
-            // Merge layers
-            if (result.layers) {
-                Object.assign(merged.layers, result.layers);
-            }
-
-            // Merge plugins
-            if (result.plugins) {
-                merged.plugins.push(...result.plugins);
-            }
-
-            // Merge custom configuration
-            if (result.pluginConfig) {
-                Object.assign(merged.custom, result.pluginConfig);
-            }
-            if (result.custom) {
-                Object.assign(merged.custom, result.custom);
-            }
-
-            // Capture VPC config (from VpcBuilder)
-            if (result.vpcConfig) {
-                merged.vpcConfig = result.vpcConfig;
-            }
-
-            console.log(`  ✓ Merged ${builderName} results`);
-        }
-
-        console.log('✅ Infrastructure build completed successfully\n');
-
-        return {
-            merged,
-            discoveredResources,
-            appEnvironmentVars: getAppEnvironmentVars(appDefinition),
-        };
-    }
-}
-
-module.exports = { BuilderOrchestrator };
-