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

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

@@ -0,0 +1,305 @@
+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

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