@friggframework/devtools 2.0.0-next.5 → 2.0.0-next.50

package/infrastructure/scripts/build-time-discovery.js

@@ -0,0 +1,238 @@
+const fs = require('fs');
+let AWSDiscovery;
+
+function loadAWSDiscovery() {
+    if (!AWSDiscovery) {
+        ({ AWSDiscovery } = require('./aws-discovery'));
+    }
+}
+
+/**
+ * Build-time AWS resource discovery and configuration injection
+ * This utility runs during the build process to discover AWS resources
+ * and inject them into the serverless configuration
+ */
+class BuildTimeDiscovery {
+    /**
+     * Creates an instance of BuildTimeDiscovery
+     * @param {string} [region=process.env.AWS_REGION || 'us-east-1'] - AWS region for discovery
+     */
+    constructor(region = process.env.AWS_REGION || 'us-east-1') {
+        loadAWSDiscovery();
+        this.region = region;
+        this.discovery = new AWSDiscovery(region);
+    }
+
+    /**
+     * Discover AWS resources and create a configuration file
+     * @param {string} [outputPath='./aws-discovery-config.json'] - Path to write the configuration file
+     * @returns {Promise<Object>} Configuration object containing discovered resources
+     * @throws {Error} If AWS resource discovery fails
+     */
+    async discoverAndCreateConfig(outputPath = './aws-discovery-config.json') {
+        try {
+            console.log('Starting AWS resource discovery for build...');
+
+            const resources = await this.discovery.discoverResources();
+
+            // Create configuration object
+            const config = {
+                awsDiscovery: resources,
+                generatedAt: new Date().toISOString(),
+                region: this.region,
+            };
+
+            // Write configuration to file
+            fs.writeFileSync(outputPath, JSON.stringify(config, null, 2));
+            console.log(
+                `AWS discovery configuration written to: ${outputPath}`,
+            );
+
+            return config;
+        } catch (error) {
+            console.error(
+                'Error during AWS resource discovery:',
+                error.message,
+            );
+            throw error;
+        }
+    }
+
+    /**
+     * Replace placeholders in serverless template with discovered values
+     * @param {string} templateContent - The template content with placeholders
+     * @param {Object} discoveredResources - Object containing discovered AWS resource IDs
+     * @returns {string} Updated template content with placeholders replaced
+     */
+    replaceTemplateVariables(templateContent, discoveredResources) {
+        let updatedContent = templateContent;
+
+        // Replace AWS discovery placeholders
+        const replacements = {
+            '${self:custom.awsDiscovery.defaultVpcId}':
+                discoveredResources.defaultVpcId,
+            '${self:custom.awsDiscovery.defaultSecurityGroupId}':
+                discoveredResources.defaultSecurityGroupId,
+            '${self:custom.awsDiscovery.privateSubnetId1}':
+                discoveredResources.privateSubnetId1,
+            '${self:custom.awsDiscovery.privateSubnetId2}':
+                discoveredResources.privateSubnetId2,
+            '${self:custom.awsDiscovery.privateRouteTableId}':
+                discoveredResources.privateRouteTableId,
+            '${self:custom.awsDiscovery.defaultKmsKeyId}':
+                discoveredResources.defaultKmsKeyId,
+        };
+
+        for (const [placeholder, value] of Object.entries(replacements)) {
+            // Use a more targeted replacement to avoid replacing similar strings
+            updatedContent = updatedContent.replace(
+                new RegExp(
+                    placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
+                    'g',
+                ),
+                value,
+            );
+        }
+
+        return updatedContent;
+    }
+
+    /**
+     * Process serverless configuration and inject discovered resources
+     * @param {string} configPath - Path to the serverless configuration file
+     * @param {string} [outputPath=null] - Output path for updated config (defaults to overwriting original)
+     * @returns {Promise<Object>} Object containing discovered AWS resources
+     * @throws {Error} If processing the serverless configuration fails
+     */
+    async processServerlessConfig(configPath, outputPath = null) {
+        try {
+            console.log(`Processing serverless configuration: ${configPath}`);
+
+            // Read the current serverless configuration
+            const configContent = fs.readFileSync(configPath, 'utf8');
+
+            // Discover AWS resources
+            const resources = await this.discovery.discoverResources();
+
+            // Replace placeholders with discovered values
+            const updatedContent = this.replaceTemplateVariables(
+                configContent,
+                resources,
+            );
+
+            // Write to output file or overwrite original
+            const finalPath = outputPath || configPath;
+            fs.writeFileSync(finalPath, updatedContent);
+
+            console.log(
+                `Updated serverless configuration written to: ${finalPath}`,
+            );
+
+            return resources;
+        } catch (error) {
+            console.error(
+                'Error processing serverless configuration:',
+                error.message,
+            );
+            throw error;
+        }
+    }
+
+    /**
+     * Generate a custom serverless configuration section for discovered resources
+     * @param {Object} discoveredResources - Object containing discovered AWS resource IDs
+     * @returns {Object} Custom section object for serverless configuration
+     */
+    generateCustomSection(discoveredResources) {
+        return {
+            awsDiscovery: discoveredResources,
+        };
+    }
+
+    /**
+     * Pre-build hook to discover resources and prepare configuration
+     * @param {Object} appDefinition - Application definition object
+     * @param {string} region - AWS region for discovery
+     * @returns {Promise<Object|null>} Discovered resources or null if discovery not needed
+     * @throws {Error} If pre-build AWS discovery fails
+     */
+    async preBuildHook(appDefinition, region) {
+        try {
+            console.log('Running pre-build AWS discovery hook...');
+
+            // Only run discovery if VPC, KMS, or SSM features are enabled
+            const needsDiscovery =
+                appDefinition.vpc?.enable ||
+                appDefinition.encryption?.fieldLevelEncryptionMethod ===
+                    'kms' ||
+                appDefinition.ssm?.enable;
+
+            if (!needsDiscovery) {
+                console.log('No AWS discovery needed based on app definition');
+                return null;
+            }
+
+            // Create discovery instance with specified region
+            loadAWSDiscovery();
+            const discovery = new AWSDiscovery(region);
+            const resources = await discovery.discoverResources();
+
+            // Create environment variables for serverless
+            const envVars = {
+                AWS_DISCOVERY_VPC_ID: resources.defaultVpcId,
+                AWS_DISCOVERY_SECURITY_GROUP_ID:
+                    resources.defaultSecurityGroupId,
+                AWS_DISCOVERY_SUBNET_ID_1: resources.privateSubnetId1,
+                AWS_DISCOVERY_SUBNET_ID_2: resources.privateSubnetId2,
+                AWS_DISCOVERY_PUBLIC_SUBNET_ID: resources.publicSubnetId,
+                AWS_DISCOVERY_ROUTE_TABLE_ID: resources.privateRouteTableId,
+                AWS_DISCOVERY_KMS_KEY_ID: resources.defaultKmsKeyId, // Keep consistent naming convention (even though it's an ARN)
+            };
+
+            // Set environment variables for serverless to use
+            Object.assign(process.env, envVars);
+
+            console.log(
+                'AWS discovery completed and environment variables set',
+            );
+            return resources;
+        } catch (error) {
+            console.error(
+                'Error in pre-build AWS discovery hook:',
+                error.message,
+            );
+            throw error;
+        }
+    }
+}
+
+/**
+ * CLI utility function for build-time discovery
+ * @param {Object} [options={}] - Options for build-time discovery
+ * @param {string} [options.region=process.env.AWS_REGION || 'us-east-1'] - AWS region
+ * @param {string} [options.outputPath='./aws-discovery-config.json'] - Output path for config file
+ * @param {string} [options.configPath=null] - Path to existing serverless config to process
+ * @returns {Promise<Object>} Discovered AWS resources
+ */
+async function runBuildTimeDiscovery(options = {}) {
+    const {
+        region = process.env.AWS_REGION || 'us-east-1',
+        outputPath = './aws-discovery-config.json',
+        configPath = null,
+    } = options;
+
+    const discovery = new BuildTimeDiscovery(region);
+
+    if (configPath) {
+        // Process existing serverless configuration
+        return await discovery.processServerlessConfig(configPath);
+    } else {
+        // Just discover and create config file
+        return await discovery.discoverAndCreateConfig(outputPath);
+    }
+}
+
+module.exports = {
+    BuildTimeDiscovery,
+    runBuildTimeDiscovery,
+};

package/infrastructure/scripts/build-time-discovery.test.js

@@ -0,0 +1,379 @@
+const fs = require('fs');
+const path = require('path');
+const { BuildTimeDiscovery, runBuildTimeDiscovery } = require('./build-time-discovery');
+const { AWSDiscovery } = require('./aws-discovery');
+
+// Mock dependencies
+jest.mock('fs');
+// Mock will be updated when tests are rewritten for new provider architecture
+// jest.mock('./aws-discovery');
+
+describe('BuildTimeDiscovery', () => {
+    let buildTimeDiscovery;
+    let mockAWSDiscovery;
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+        buildTimeDiscovery = new BuildTimeDiscovery('us-east-1');
+
+        // Mock AWSDiscovery
+        mockAWSDiscovery = {
+            discoverResources: jest.fn(),
+        };
+        AWSDiscovery.mockImplementation(() => mockAWSDiscovery);
+
+        // Mock fs methods
+        fs.writeFileSync = jest.fn();
+        fs.readFileSync = jest.fn();
+
+        // Reset environment
+        process.env = { ...originalEnv };
+
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+
+    describe('constructor', () => {
+        it('should initialize with default region', () => {
+            const discovery = new BuildTimeDiscovery();
+            expect(discovery.region).toBe('us-east-1');
+        });
+
+        it('should initialize with custom region', () => {
+            const discovery = new BuildTimeDiscovery('us-west-2');
+            expect(discovery.region).toBe('us-west-2');
+        });
+
+        it('should use AWS_REGION environment variable', () => {
+            process.env.AWS_REGION = 'eu-west-1';
+            const discovery = new BuildTimeDiscovery();
+            expect(discovery.region).toBe('eu-west-1');
+        });
+    });
+
+    describe('discoverAndCreateConfig', () => {
+        const mockResources = {
+            defaultVpcId: 'vpc-12345678',
+            vpcCidr: '172.31.0.0/16',
+            defaultSecurityGroupId: 'sg-12345678',
+            privateSubnetId1: 'subnet-1',
+            privateSubnetId2: 'subnet-2',
+            privateRouteTableId: 'rtb-12345678',
+            defaultKmsKeyId: 'arn:aws:kms:us-east-1:123456789012:key/12345678'
+        };
+
+        it('should discover resources and create config file', async () => {
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            const result = await buildTimeDiscovery.discoverAndCreateConfig('./test-config.json');
+
+            expect(mockAWSDiscovery.discoverResources).toHaveBeenCalled();
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                './test-config.json',
+                expect.stringContaining('"awsDiscovery"')
+            );
+            expect(result.awsDiscovery).toEqual(mockResources);
+            expect(result.region).toBe('us-east-1');
+            expect(result.generatedAt).toBeDefined();
+        });
+
+        it('should use default output path', async () => {
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            await buildTimeDiscovery.discoverAndCreateConfig();
+
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                './aws-discovery-config.json',
+                expect.any(String)
+            );
+        });
+
+        it('should throw error when discovery fails', async () => {
+            const error = new Error('Discovery failed');
+            mockAWSDiscovery.discoverResources.mockRejectedValue(error);
+
+            await expect(buildTimeDiscovery.discoverAndCreateConfig()).rejects.toThrow('Discovery failed');
+        });
+    });
+
+    describe('replaceTemplateVariables', () => {
+        const mockResources = {
+            defaultVpcId: 'vpc-12345678',
+            vpcCidr: '172.31.0.0/16',
+            defaultSecurityGroupId: 'sg-12345678',
+            privateSubnetId1: 'subnet-1',
+            privateSubnetId2: 'subnet-2',
+            privateRouteTableId: 'rtb-12345678',
+            defaultKmsKeyId: 'arn:aws:kms:us-east-1:123456789012:key/12345678'
+        };
+
+        it('should replace all AWS discovery placeholders', () => {
+            const templateContent = `
+                vpc:
+                    id: \${self:custom.awsDiscovery.defaultVpcId}
+                    securityGroups:
+                        - \${self:custom.awsDiscovery.defaultSecurityGroupId}
+                    subnets:
+                        - \${self:custom.awsDiscovery.privateSubnetId1}
+                        - \${self:custom.awsDiscovery.privateSubnetId2}
+                    routeTable: \${self:custom.awsDiscovery.privateRouteTableId}
+                kms:
+                    keyId: \${self:custom.awsDiscovery.defaultKmsKeyId}
+            `;
+
+            const result = buildTimeDiscovery.replaceTemplateVariables(templateContent, mockResources);
+
+            expect(result).toContain('vpc-12345678');
+            expect(result).toContain('sg-12345678');
+            expect(result).toContain('subnet-1');
+            expect(result).toContain('subnet-2');
+            expect(result).toContain('rtb-12345678');
+            expect(result).toContain('arn:aws:kms:us-east-1:123456789012:key/12345678');
+            expect(result).not.toContain('${self:custom.awsDiscovery');
+        });
+
+        it('should handle content without placeholders', () => {
+            const templateContent = `
+                service: my-service
+                provider:
+                    name: aws
+                    runtime: nodejs18.x
+            `;
+
+            const result = buildTimeDiscovery.replaceTemplateVariables(templateContent, mockResources);
+
+            expect(result).toBe(templateContent);
+        });
+
+        it('should handle multiple occurrences of same placeholder', () => {
+            const templateContent = `
+                vpc1: \${self:custom.awsDiscovery.defaultVpcId}
+                vpc2: \${self:custom.awsDiscovery.defaultVpcId}
+            `;
+
+            const result = buildTimeDiscovery.replaceTemplateVariables(templateContent, mockResources);
+
+            expect(result).toBe(`
+                vpc1: vpc-12345678
+                vpc2: vpc-12345678
+            `);
+        });
+    });
+
+    describe('processServerlessConfig', () => {
+        const mockConfigContent = `
+            provider:
+                vpc: \${self:custom.awsDiscovery.defaultVpcId}
+                kms: \${self:custom.awsDiscovery.defaultKmsKeyId}
+        `;
+
+        const mockResources = {
+            defaultVpcId: 'vpc-12345678',
+            defaultKmsKeyId: 'arn:aws:kms:us-east-1:123456789012:key/12345678'
+        };
+
+        it('should process serverless config and update file', async () => {
+            fs.readFileSync.mockReturnValue(mockConfigContent);
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            const result = await buildTimeDiscovery.processServerlessConfig('./serverless.yml');
+
+            expect(fs.readFileSync).toHaveBeenCalledWith('./serverless.yml', 'utf8');
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                './serverless.yml',
+                expect.stringContaining('vpc-12345678')
+            );
+            expect(result).toEqual(mockResources);
+        });
+
+        it('should write to different output file when specified', async () => {
+            fs.readFileSync.mockReturnValue(mockConfigContent);
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            await buildTimeDiscovery.processServerlessConfig('./serverless.yml', './serverless-processed.yml');
+
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                './serverless-processed.yml',
+                expect.any(String)
+            );
+        });
+
+        it('should throw error when file read fails', async () => {
+            fs.readFileSync.mockImplementation(() => {
+                throw new Error('File not found');
+            });
+
+            await expect(buildTimeDiscovery.processServerlessConfig('./nonexistent.yml')).rejects.toThrow('File not found');
+        });
+    });
+
+    describe('generateCustomSection', () => {
+        it('should generate custom section with discovered resources', () => {
+            const mockResources = {
+                defaultVpcId: 'vpc-12345678',
+                defaultKmsKeyId: 'arn:aws:kms:us-east-1:123456789012:key/12345678'
+            };
+
+            const result = buildTimeDiscovery.generateCustomSection(mockResources);
+
+            expect(result).toEqual({
+                awsDiscovery: mockResources
+            });
+        });
+    });
+
+    describe('preBuildHook', () => {
+        const mockResources = {
+            defaultVpcId: 'vpc-12345678',
+            vpcCidr: '172.31.0.0/16',
+            defaultSecurityGroupId: 'sg-12345678',
+            privateSubnetId1: 'subnet-1',
+            privateSubnetId2: 'subnet-2',
+            privateRouteTableId: 'rtb-12345678',
+            defaultKmsKeyId: 'arn:aws:kms:us-east-1:123456789012:key/12345678'
+        };
+
+        it('should run discovery when VPC is enabled', async () => {
+            const appDefinition = {
+                vpc: { enable: true },
+                integrations: []
+            };
+
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            const result = await buildTimeDiscovery.preBuildHook(appDefinition, 'us-east-1');
+
+            expect(mockAWSDiscovery.discoverResources).toHaveBeenCalled();
+            expect(result).toEqual(mockResources);
+            expect(process.env.AWS_DISCOVERY_VPC_ID).toBe('vpc-12345678');
+            expect(process.env.AWS_DISCOVERY_KMS_KEY_ID).toBe('arn:aws:kms:us-east-1:123456789012:key/12345678');
+        });
+
+        it('should run discovery when KMS is enabled', async () => {
+            const appDefinition = {
+                encryption: { fieldLevelEncryptionMethod: 'kms' },
+                integrations: []
+            };
+
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            const result = await buildTimeDiscovery.preBuildHook(appDefinition, 'us-east-1');
+
+            expect(mockAWSDiscovery.discoverResources).toHaveBeenCalled();
+            expect(result).toEqual(mockResources);
+        });
+
+        it('should run discovery when SSM is enabled', async () => {
+            const appDefinition = {
+                ssm: { enable: true },
+                integrations: []
+            };
+
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            const result = await buildTimeDiscovery.preBuildHook(appDefinition, 'us-east-1');
+
+            expect(mockAWSDiscovery.discoverResources).toHaveBeenCalled();
+            expect(result).toEqual(mockResources);
+        });
+
+        it('should skip discovery when no features are enabled', async () => {
+            const appDefinition = {
+                integrations: []
+            };
+
+            const result = await buildTimeDiscovery.preBuildHook(appDefinition, 'us-east-1');
+
+            expect(mockAWSDiscovery.discoverResources).not.toHaveBeenCalled();
+            expect(result).toBeNull();
+        });
+
+        it('should throw error when discovery fails', async () => {
+            const appDefinition = {
+                vpc: { enable: true },
+                integrations: []
+            };
+
+            const error = new Error('Discovery failed');
+            mockAWSDiscovery.discoverResources.mockRejectedValue(error);
+
+            await expect(buildTimeDiscovery.preBuildHook(appDefinition, 'us-east-1')).rejects.toThrow('Discovery failed');
+        });
+
+        it('should set all environment variables', async () => {
+            const appDefinition = {
+                vpc: { enable: true },
+                integrations: []
+            };
+
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            await buildTimeDiscovery.preBuildHook(appDefinition, 'us-east-1');
+
+            expect(process.env.AWS_DISCOVERY_VPC_ID).toBe('vpc-12345678');
+            expect(process.env.AWS_DISCOVERY_SECURITY_GROUP_ID).toBe('sg-12345678');
+            expect(process.env.AWS_DISCOVERY_SUBNET_ID_1).toBe('subnet-1');
+            expect(process.env.AWS_DISCOVERY_SUBNET_ID_2).toBe('subnet-2');
+            expect(process.env.AWS_DISCOVERY_ROUTE_TABLE_ID).toBe('rtb-12345678');
+            expect(process.env.AWS_DISCOVERY_KMS_KEY_ID).toBe('arn:aws:kms:us-east-1:123456789012:key/12345678');
+        });
+    });
+
+    describe('runBuildTimeDiscovery', () => {
+        it('should run discovery with default options', async () => {
+            const mockResources = { defaultVpcId: 'vpc-12345678' };
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            const result = await runBuildTimeDiscovery();
+
+            expect(result.awsDiscovery).toEqual(mockResources);
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                './aws-discovery-config.json',
+                expect.any(String)
+            );
+        });
+
+        it('should process config file when configPath provided', async () => {
+            const mockConfigContent = 'provider: aws';
+            const mockResources = { defaultVpcId: 'vpc-12345678' };
+
+            fs.readFileSync.mockReturnValue(mockConfigContent);
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            const result = await runBuildTimeDiscovery({
+                configPath: './serverless.yml'
+            });
+
+            expect(result).toEqual(mockResources);
+            expect(fs.readFileSync).toHaveBeenCalledWith('./serverless.yml', 'utf8');
+        });
+
+        it('should use custom region and output path', async () => {
+            const mockResources = { defaultVpcId: 'vpc-12345678' };
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            await runBuildTimeDiscovery({
+                region: 'eu-west-1',
+                outputPath: './custom-config.json'
+            });
+
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                './custom-config.json',
+                expect.any(String)
+            );
+        });
+
+        it('should use AWS_REGION environment variable when region not specified', async () => {
+            process.env.AWS_REGION = 'ap-southeast-1';
+            const mockResources = { defaultVpcId: 'vpc-12345678' };
+            mockAWSDiscovery.discoverResources.mockResolvedValue(mockResources);
+
+            const result = await runBuildTimeDiscovery();
+
+            expect(result.region).toBe('ap-southeast-1');
+        });
+    });
+});