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

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

@@ -0,0 +1,213 @@
+/**
+ * Tests for BuilderOrchestrator
+ * 
+ * Tests orchestration, dependency resolution, and parallel execution
+ */
+
+const { BuilderOrchestrator } = require('./builder-orchestrator');
+const { InfrastructureBuilder, ValidationResult } = require('./base-builder');
+
+// Mock builders for testing
+class MockBuilderA extends InfrastructureBuilder {
+    getName() { return 'MockBuilderA'; }
+    shouldExecute(appDef) { return appDef.featureA === true; }
+    validate(appDef) { return new ValidationResult(); }
+    async build(appDef, discovered) {
+        return {
+            resources: { ResourceA: { Type: 'Test' } },
+            iamStatements: [{ Effect: 'Allow', Action: 'test:A' }],
+        };
+    }
+}
+
+class MockBuilderB extends InfrastructureBuilder {
+    getName() { return 'MockBuilderB'; }
+    shouldExecute(appDef) { return appDef.featureB === true; }
+    validate(appDef) { return new ValidationResult(); }
+    getDependencies() { return ['MockBuilderA']; }  // Depends on A
+    async build(appDef, discovered) {
+        return {
+            resources: { ResourceB: { Type: 'Test' } },
+            environment: { VAR_B: 'value-b' },
+        };
+    }
+}
+
+class MockBuilderC extends InfrastructureBuilder {
+    getName() { return 'MockBuilderC'; }
+    shouldExecute() { return false; }  // Never executes
+    validate() { return new ValidationResult(); }
+    async build() {
+        throw new Error('Should not be called');
+    }
+}
+
+jest.mock('./resource-discovery', () => ({
+    gatherDiscoveredResources: jest.fn().mockResolvedValue({ discovered: true }),
+}));
+
+jest.mock('./environment-builder', () => ({
+    getAppEnvironmentVars: jest.fn().mockReturnValue({ ENV_VAR: 'value' }),
+    buildEnvironment: jest.fn().mockReturnValue({ ENV_VAR: 'value' }),
+}));
+
+describe('BuilderOrchestrator', () => {
+    let orchestrator;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('registerBuilder()', () => {
+        it('should register builders', () => {
+            orchestrator = new BuilderOrchestrator();
+            const builder = new MockBuilderA();
+
+            orchestrator.registerBuilder(builder);
+
+            expect(orchestrator.builders.has('MockBuilderA')).toBe(true);
+        });
+
+        it('should register multiple builders via constructor', () => {
+            orchestrator = new BuilderOrchestrator([
+                new MockBuilderA(),
+                new MockBuilderB(),
+            ]);
+
+            expect(orchestrator.builders.size).toBe(2);
+        });
+    });
+
+    describe('validateAll()', () => {
+        it('should validate all applicable builders', async () => {
+            orchestrator = new BuilderOrchestrator([
+                new MockBuilderA(),
+                new MockBuilderB(),
+            ]);
+
+            const appDef = { featureA: true, featureB: true };
+
+            await expect(orchestrator.validateAll(appDef)).resolves.toBeDefined();
+        });
+
+        it('should skip builders that shouldNotExecute', async () => {
+            orchestrator = new BuilderOrchestrator([
+                new MockBuilderA(),
+                new MockBuilderC(),  // Should not execute
+            ]);
+
+            const appDef = { featureA: true };
+
+            const results = await orchestrator.validateAll(appDef);
+
+            // Should only validate MockBuilderA
+            expect(results).toHaveLength(1);
+            expect(results[0].builder).toBe('MockBuilderA');
+        });
+
+        it('should throw error if validation fails', async () => {
+            class FailingBuilder extends InfrastructureBuilder {
+                getName() { return 'FailingBuilder'; }
+                shouldExecute() { return true; }
+                validate() {
+                    const result = new ValidationResult();
+                    result.addError('Test error');
+                    return result;
+                }
+            }
+
+            orchestrator = new BuilderOrchestrator([new FailingBuilder()]);
+
+            await expect(orchestrator.validateAll({})).rejects.toThrow('Infrastructure validation failed');
+        });
+    });
+
+    describe('resolveBuildOrder()', () => {
+        it('should resolve dependencies correctly', () => {
+            orchestrator = new BuilderOrchestrator([
+                new MockBuilderB(),  // Depends on A
+                new MockBuilderA(),  // No dependencies
+            ]);
+
+            const appDef = { featureA: true, featureB: true };
+            const order = orchestrator.resolveBuildOrder(appDef);
+
+            // A should come before B
+            expect(order).toEqual(['MockBuilderA', 'MockBuilderB']);
+        });
+
+        it('should handle builders with no dependencies', () => {
+            orchestrator = new BuilderOrchestrator([
+                new MockBuilderA(),
+            ]);
+
+            const appDef = { featureA: true };
+            const order = orchestrator.resolveBuildOrder(appDef);
+
+            expect(order).toEqual(['MockBuilderA']);
+        });
+
+        it('should skip builders that should not execute', () => {
+            orchestrator = new BuilderOrchestrator([
+                new MockBuilderA(),
+                new MockBuilderC(),  // Should not execute
+            ]);
+
+            const appDef = { featureA: true };
+            const order = orchestrator.resolveBuildOrder(appDef);
+
+            expect(order).toEqual(['MockBuilderA']);
+        });
+    });
+
+    describe('buildAll()', () => {
+        it('should build all infrastructure and merge results', async () => {
+            orchestrator = new BuilderOrchestrator([
+                new MockBuilderA(),
+                new MockBuilderB(),
+            ]);
+
+            const appDef = { featureA: true, featureB: true };
+
+            const result = await orchestrator.buildAll(appDef);
+
+            expect(result.merged).toBeDefined();
+            expect(result.merged.resources).toMatchObject({
+                ResourceA: { Type: 'Test' },
+                ResourceB: { Type: 'Test' },
+            });
+            expect(result.merged.iamStatements).toHaveLength(1);
+            expect(result.merged.environment).toMatchObject({ VAR_B: 'value-b' });
+        });
+
+        it('should skip builders that should not execute', async () => {
+            orchestrator = new BuilderOrchestrator([
+                new MockBuilderA(),
+                new MockBuilderC(),  // Should not execute
+            ]);
+
+            const appDef = { featureA: true };
+
+            const result = await orchestrator.buildAll(appDef);
+
+            // Should only have results from A
+            expect(Object.keys(result.merged.resources)).toEqual(['ResourceA']);
+        });
+
+        it('should throw error if builder fails', async () => {
+            class FailingBuilder extends InfrastructureBuilder {
+                getName() { return 'FailingBuilder'; }
+                shouldExecute() { return true; }
+                validate() { return new ValidationResult(); }
+                async build() {
+                    throw new Error('Build failed');
+                }
+            }
+
+            orchestrator = new BuilderOrchestrator([new FailingBuilder()]);
+
+            await expect(orchestrator.buildAll({})).rejects.toThrow('Build failed');
+        });
+    });
+});
+

package/infrastructure/domains/shared/cloudformation-discovery-v2.js

@@ -0,0 +1,334 @@
+/**
+ * CloudFormation-based Resource Discovery v2
+ *
+ * Refactored to return structured DiscoveryResult instead of flat object.
+ * Part of the clean resource ownership architecture.
+ *
+ * Domain Service - Hexagonal Architecture
+ */
+
+const { createEmptyDiscoveryResult } = require('./types');
+
+class CloudFormationDiscoveryV2 {
+    constructor(provider, config = {}) {
+        this.provider = provider;
+        this.serviceName = config.serviceName;
+        this.stage = config.stage;
+    }
+
+    /**
+     * Discover resources from an existing CloudFormation stack
+     *
+     * @param {string} stackName - Name of the CloudFormation stack
+     * @returns {Promise<Object>} DiscoveryResult or empty result if stack doesn't exist
+     */
+    async discoverFromStack(stackName) {
+        try {
+            // Try to get the stack
+            const stack = await this.provider.describeStack(stackName);
+
+            // Get stack resources
+            const resources = await this.provider.listStackResources(stackName);
+
+            // Create structured discovery result
+            const discovery = createEmptyDiscoveryResult();
+            discovery.fromCloudFormation = true;
+            discovery.stackName = stackName;
+            discovery.region = this.provider.region;
+
+            // Extract stack-managed resources
+            await this._extractStackManagedResources(resources || [], discovery);
+
+            // Also keep flat structure for backwards compatibility (temporarily)
+            const flatDiscovered = {
+                fromCloudFormationStack: true,
+                stackName: stackName,
+                existingLogicalIds: discovery.stackManaged.map(r => r.logicalId)
+            };
+
+            // Extract from outputs (legacy)
+            if (stack.Outputs && stack.Outputs.length > 0) {
+                this._extractFromOutputs(stack.Outputs, flatDiscovered);
+            }
+
+            // Extract flat properties from stackManaged resources
+            this._createFlatPropertiesFromStackManaged(discovery, flatDiscovered);
+
+            // Return both structures (flat for backwards compat, structured for new code)
+            return {
+                ...flatDiscovered,
+                _structured: discovery  // New structured format
+            };
+        } catch (error) {
+            // Stack doesn't exist - return empty discovery
+            if (error.message && error.message.includes('does not exist')) {
+                const empty = createEmptyDiscoveryResult();
+                return {
+                    fromCloudFormationStack: false,
+                    _structured: empty
+                };
+            }
+
+            // Other errors - log and return empty
+            console.warn(`⚠️  CloudFormation discovery failed: ${error.message}`);
+            const empty = createEmptyDiscoveryResult();
+            return {
+                fromCloudFormationStack: false,
+                _structured: empty
+            };
+        }
+    }
+
+    /**
+     * Extract stack-managed resources into structured format
+     * @private
+     */
+    async _extractStackManagedResources(resources, discovery) {
+        console.log(`  DEBUG: Processing ${resources.length} CloudFormation resources...`);
+
+        for (const resource of resources) {
+            const { LogicalResourceId, PhysicalResourceId, ResourceType } = resource;
+
+            // Only track Frigg-managed resources
+            if (!LogicalResourceId.startsWith('Frigg') && !LogicalResourceId.includes('Migration')) {
+                continue;
+            }
+
+            // Add to stack-managed list
+            const stackResource = {
+                logicalId: LogicalResourceId,
+                physicalId: PhysicalResourceId,
+                resourceType: ResourceType,
+                properties: {}  // Will be populated as needed
+            };
+
+            discovery.stackManaged.push(stackResource);
+
+            // Query AWS for detailed properties for certain resources
+            await this._enrichResourceProperties(stackResource, discovery);
+        }
+
+        console.log(`  ✓ Discovered ${discovery.stackManaged.length} stack-managed resources`);
+    }
+
+    /**
+     * Enrich resource properties by querying AWS APIs
+     * @private
+     */
+    async _enrichResourceProperties(stackResource, discovery) {
+        const { logicalId, physicalId, resourceType } = stackResource;
+
+        // Security Group - query to get VPC ID
+        if (logicalId === 'FriggLambdaSecurityGroup' && resourceType === 'AWS::EC2::SecurityGroup') {
+            console.log(`  ✓ Found security group in stack: ${physicalId}`);
+
+            if (this.provider && this.provider.getEC2Client) {
+                try {
+                    console.log(`  Querying EC2 to get VPC ID from security group...`);
+                    const { DescribeSecurityGroupsCommand } = require('@aws-sdk/client-ec2');
+                    const ec2Client = this.provider.getEC2Client();
+                    const sgDetails = await ec2Client.send(
+                        new DescribeSecurityGroupsCommand({
+                            GroupIds: [physicalId]
+                        })
+                    );
+
+                    if (sgDetails.SecurityGroups && sgDetails.SecurityGroups.length > 0) {
+                        const sg = sgDetails.SecurityGroups[0];
+                        stackResource.properties.VpcId = sg.VpcId;
+                        console.log(`  ✓ Extracted VPC ID from security group: ${sg.VpcId}`);
+
+                        // Also add VPC to stack-managed if not already there
+                        const vpcExists = discovery.stackManaged.some(r => r.logicalId === 'FriggVPC');
+                        if (!vpcExists && sg.VpcId) {
+                            // Note: VPC was created by stack, just not listed in resources yet
+                            // We'll add it when we encounter it, or infer it here
+                        }
+                    }
+                } catch (error) {
+                    console.warn(`  ⚠️  Could not get VPC from security group: ${error.message}`);
+                }
+            }
+        }
+
+        // Aurora Cluster - query to get endpoint
+        if (logicalId === 'FriggAuroraCluster' && resourceType === 'AWS::RDS::DBCluster') {
+            console.log(`  ✓ Found Aurora cluster in stack: ${physicalId}`);
+
+            if (this.provider) {
+                try {
+                    console.log(`  Querying RDS to get Aurora endpoint...`);
+                    const { DescribeDBClustersCommand, RDSClient } = require('@aws-sdk/client-rds');
+
+                    const rdsClient = new RDSClient({ region: this.provider.region });
+                    const clusterDetails = await rdsClient.send(
+                        new DescribeDBClustersCommand({
+                            DBClusterIdentifier: physicalId
+                        })
+                    );
+
+                    if (clusterDetails.DBClusters && clusterDetails.DBClusters.length > 0) {
+                        const cluster = clusterDetails.DBClusters[0];
+                        stackResource.properties.Endpoint = cluster.Endpoint;
+                        stackResource.properties.Port = cluster.Port;
+                        stackResource.properties.DBClusterIdentifier = cluster.DBClusterIdentifier;
+                        console.log(`  ✓ Extracted Aurora endpoint: ${cluster.Endpoint}:${cluster.Port}`);
+                    }
+                } catch (error) {
+                    console.warn(`  ⚠️  Could not get endpoint from Aurora cluster: ${error.message}`);
+                }
+            }
+        }
+
+        // KMS Key Alias - query to get ARN
+        if (logicalId === 'FriggKMSKeyAlias' && resourceType === 'AWS::KMS::Alias') {
+            console.log(`  ✓ Found KMS key alias in stack: ${physicalId}`);
+
+            if (this.provider && this.provider.describeKmsKey) {
+                try {
+                    console.log(`  Querying KMS for alias: ${physicalId}...`);
+                    const keyMetadata = await this.provider.describeKmsKey(physicalId);
+
+                    if (keyMetadata) {
+                        stackResource.properties.KeyArn = keyMetadata.Arn;
+                        console.log(`  ✓ Found KMS key via alias query: ${keyMetadata.Arn}`);
+                    }
+                } catch (error) {
+                    console.warn(`  ⚠️  Could not get key ARN from alias: ${error.message}`);
+                }
+            }
+        }
+
+        // VPC - just log
+        if (logicalId === 'FriggVPC' && resourceType === 'AWS::EC2::VPC') {
+            console.log(`  ✓ Found VPC in stack: ${physicalId}`);
+        }
+    }
+
+    /**
+     * Create flat properties from stack-managed resources (backwards compatibility)
+     * @private
+     */
+    _createFlatPropertiesFromStackManaged(discovery, flatDiscovered) {
+        for (const resource of discovery.stackManaged) {
+            const { logicalId, physicalId, properties } = resource;
+
+            // Map to flat property names
+            switch (logicalId) {
+                case 'FriggVPC':
+                    flatDiscovered.defaultVpcId = physicalId;
+                    break;
+                case 'FriggLambdaSecurityGroup':
+                    flatDiscovered.securityGroupId = physicalId;
+                    if (properties.VpcId) {
+                        flatDiscovered.defaultVpcId = properties.VpcId;
+                    }
+                    break;
+                case 'FriggPrivateSubnet1':
+                    flatDiscovered.privateSubnetId1 = physicalId;
+                    break;
+                case 'FriggPrivateSubnet2':
+                    flatDiscovered.privateSubnetId2 = physicalId;
+                    break;
+                case 'FriggPublicSubnet':
+                    flatDiscovered.publicSubnetId1 = physicalId;
+                    break;
+                case 'FriggPublicSubnet2':
+                    flatDiscovered.publicSubnetId2 = physicalId;
+                    break;
+                case 'FriggNatGateway':
+                    flatDiscovered.natGatewayId = physicalId;
+                    break;
+                case 'FriggLambdaRouteTable':
+                    flatDiscovered.routeTableId = physicalId;
+                    break;
+                case 'FriggVPCEndpointSecurityGroup':
+                    flatDiscovered.vpcEndpointSecurityGroupId = physicalId;
+                    break;
+                case 'FriggS3VPCEndpoint':
+                    flatDiscovered.s3VpcEndpointId = physicalId;
+                    break;
+                case 'FriggDynamoDBVPCEndpoint':
+                    flatDiscovered.dynamoDbVpcEndpointId = physicalId;
+                    break;
+                case 'FriggKMSVPCEndpoint':
+                    flatDiscovered.kmsVpcEndpointId = physicalId;
+                    break;
+                case 'FriggSecretsManagerVPCEndpoint':
+                    flatDiscovered.secretsManagerVpcEndpointId = physicalId;
+                    break;
+                case 'FriggSQSVPCEndpoint':
+                    flatDiscovered.sqsVpcEndpointId = physicalId;
+                    break;
+                case 'FriggAuroraCluster':
+                    flatDiscovered.auroraClusterId = physicalId;
+                    if (properties.Endpoint) {
+                        flatDiscovered.auroraClusterEndpoint = properties.Endpoint;
+                    }
+                    if (properties.Port) {
+                        flatDiscovered.auroraClusterPort = properties.Port;
+                        flatDiscovered.auroraPort = properties.Port;
+                    }
+                    if (properties.DBClusterIdentifier) {
+                        flatDiscovered.auroraClusterIdentifier = properties.DBClusterIdentifier;
+                    }
+                    break;
+                case 'FriggKMSKey':
+                    flatDiscovered.defaultKmsKeyId = physicalId;
+                    break;
+                case 'FriggKMSKeyAlias':
+                    flatDiscovered.kmsKeyAlias = physicalId;
+                    if (properties.KeyArn) {
+                        flatDiscovered.defaultKmsKeyId = properties.KeyArn;
+                    }
+                    break;
+                case 'FriggMigrationStatusBucket':
+                    flatDiscovered.migrationStatusBucket = physicalId;
+                    break;
+                case 'DbMigrationQueue':
+                    flatDiscovered.migrationQueueUrl = physicalId;
+                    break;
+            }
+        }
+    }
+
+    /**
+     * Extract discovered resources from CloudFormation stack outputs (legacy)
+     * @private
+     */
+    _extractFromOutputs(outputs, discovered) {
+        const outputMap = outputs.reduce((acc, output) => {
+            acc[output.OutputKey] = output.OutputValue;
+            return acc;
+        }, {});
+
+        // VPC outputs
+        if (outputMap.VpcId) {
+            discovered.defaultVpcId = outputMap.VpcId;
+        }
+
+        if (outputMap.PrivateSubnetIds) {
+            discovered.privateSubnetIds = outputMap.PrivateSubnetIds.split(',').map(id => id.trim());
+        }
+
+        if (outputMap.PublicSubnetId) {
+            discovered.publicSubnetId = outputMap.PublicSubnetId;
+        }
+
+        if (outputMap.SecurityGroupId) {
+            discovered.securityGroupId = outputMap.SecurityGroupId;
+        }
+
+        // KMS outputs
+        if (outputMap.KMS_KEY_ARN) {
+            discovered.defaultKmsKeyId = outputMap.KMS_KEY_ARN;
+        }
+
+        // Database outputs
+        if (outputMap.DatabaseEndpoint) {
+            discovered.databaseEndpoint = outputMap.DatabaseEndpoint;
+        }
+    }
+}
+
+module.exports = CloudFormationDiscoveryV2;