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

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');
+        });
+    });
+});

package/infrastructure/scripts/run-discovery.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-build script to run AWS discovery and set environment variables
+ * This should be run before serverless commands that need AWS resource discovery
+ */
+
+const { BuildTimeDiscovery } = require('./build-time-discovery');
+const { findNearestBackendPackageJson } = require('@friggframework/core');
+const path = require('path');
+
+async function runDiscovery() {
+    let appDefinition;
+    
+    try {
+        console.log('🔍 Starting AWS resource discovery...');
+        
+        // Find the backend package.json to get AppDefinition
+        const backendPath = findNearestBackendPackageJson();
+        if (!backendPath) {
+            console.log('⚠️  No backend package.json found, skipping discovery');
+            return;
+        }
+
+        const backendDir = path.dirname(backendPath);
+        const backendFilePath = path.join(backendDir, 'index.js');
+        
+        if (!require('fs').existsSync(backendFilePath)) {
+            console.log('⚠️  No backend/index.js found, skipping discovery');
+            return;
+        }
+
+        // Load the app definition
+        const backend = require(backendFilePath);
+        appDefinition = backend.Definition;
+
+        if (!appDefinition) {
+            console.log('⚠️  No Definition found in backend/index.js, skipping discovery');
+            return;
+        }
+
+        // Check if discovery is needed
+        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;
+        }
+
+        console.log('📋 App requires AWS discovery for:');
+        if (appDefinition.vpc?.enable) console.log('   ✅ VPC support');
+        if (appDefinition.encryption?.fieldLevelEncryptionMethod === 'kms') console.log('   ✅ KMS encryption');
+        if (appDefinition.ssm?.enable) console.log('   ✅ SSM parameters');
+
+        // Run discovery
+        const discovery = new BuildTimeDiscovery();
+        const resources = await discovery.preBuildHook(appDefinition, process.env.AWS_REGION || 'us-east-1');
+        
+        if (resources) {
+            console.log('✅ AWS discovery completed successfully!');
+            console.log(`   VPC: ${resources.defaultVpcId}`);
+            console.log(`   Subnets: ${resources.privateSubnetId1}, ${resources.privateSubnetId2}`);
+            console.log(`   Public Subnet: ${resources.publicSubnetId}`);
+            console.log(`   Security Group: ${resources.defaultSecurityGroupId}`);
+            console.log(`   Route Table: ${resources.privateRouteTableId}`);
+            console.log(`   KMS Key: ${resources.defaultKmsKeyId}`);
+        }
+        
+    } catch (error) {
+        console.error('❌ AWS discovery failed:', error.message);
+        console.error('');
+        
+        // Check if this is an AWS SDK missing error
+        if (error.message.includes('Cannot find module') && error.message.includes('@aws-sdk')) {
+            console.error('🚨 AWS SDK not installed!');
+            console.error('');
+            console.error('💡 Install AWS SDK dependencies:');
+            console.error('   npm install @aws-sdk/client-ec2 @aws-sdk/client-kms @aws-sdk/client-sts');
+            console.error('');
+        } else {
+            console.error('🚨 Discovery is required because your AppDefinition has these features enabled:');
+            if (appDefinition.vpc?.enable) console.error('   ❌ VPC support (vpc.enable: true)');
+            if (appDefinition.encryption?.fieldLevelEncryptionMethod === 'kms') console.error('   ❌ KMS encryption (encryption.fieldLevelEncryptionMethod: \'kms\')');
+            if (appDefinition.ssm?.enable) console.error('   ❌ SSM parameters (ssm.enable: true)');
+            console.error('');
+            console.error('💡 To fix this issue:');
+            console.error('   1. Check AWS credentials: aws sts get-caller-identity');
+            console.error('   2. Verify IAM permissions (see AWS-IAM-CREDENTIAL-NEEDS.md)');
+            console.error('   3. Ensure default VPC exists: aws ec2 describe-vpcs');
+            console.error('   4. Check AWS region: aws configure get region');
+            console.error('');
+        }
+        
+        console.error('🔧 Or disable features in backend/index.js:');
+        console.error('   vpc: { enable: false }');
+        console.error('   encryption: { fieldLevelEncryptionMethod: \'aes\' }');
+        console.error('   ssm: { enable: false }');
+        
+        process.exit(1);
+    }
+}
+
+// Run if called directly
+if (require.main === module) {
+    runDiscovery();
+}
+
+module.exports = { runDiscovery };

package/infrastructure/scripts/verify-prisma-layer.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const PROJECT_ROOT = process.cwd();
+const LAYER_PATH = path.join(PROJECT_ROOT, 'layers/prisma/nodejs/node_modules');
+
+async function verifyLayerStructure() {
+    console.log('Verifying Prisma layer structure...\n');
+
+    const checks = [
+        {
+            name: 'PostgreSQL schema',
+            path: 'generated/prisma-postgresql/schema.prisma'
+        },
+        {
+            name: 'PostgreSQL migrations directory',
+            path: 'generated/prisma-postgresql/migrations'
+        },
+        {
+            name: 'PostgreSQL migration_lock.toml',
+            path: 'generated/prisma-postgresql/migrations/migration_lock.toml'
+        },
+        {
+            name: '@prisma/client runtime',
+            path: '@prisma/client/runtime'
+        }
+    ];
+
+    let allPassed = true;
+
+    for (const check of checks) {
+        const fullPath = path.join(LAYER_PATH, check.path);
+        const exists = await fs.pathExists(fullPath);
+        
+        if (exists) {
+            console.log(`✓ ${check.name}`);
+        } else {
+            console.log(`✗ ${check.name} (missing)`);
+            allPassed = false;
+        }
+    }
+
+    console.log('\n');
+
+    if (allPassed) {
+        console.log('✓ All checks passed!');
+        const migrationsPath = path.join(LAYER_PATH, 'generated/prisma-postgresql/migrations');
+        const migrationFiles = await fs.readdir(migrationsPath);
+        console.log(`\nFound ${migrationFiles.length} items in migrations directory:`);
+        migrationFiles.forEach(file => {
+            console.log(`  - ${file}`);
+        });
+        return 0;
+    } else {
+        console.log('✗ Some checks failed!');
+        return 1;
+    }
+}
+
+if (require.main === module) {
+    verifyLayerStructure()
+        .then(code => process.exit(code))
+        .catch(err => {
+            console.error('Error:', err.message);
+            process.exit(1);
+        });
+}
+
+module.exports = { verifyLayerStructure };
+

package/layers/prisma/.build-complete

@@ -0,0 +1,3 @@
+Build completed: 2025-11-17T22:06:29.204Z
+Node: v20.12.1
+Platform: darwin

package/layers/prisma/nodejs/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "prisma-lambda-layer",
+  "version": "1.0.0",
+  "private": true,
+  "dependencies": {
+    "@prisma/client": "^6.16.3"
+  }
+}

package/management-ui/.eslintrc.js

@@ -0,0 +1,22 @@
+module.exports = {
+  root: true,
+  env: { browser: true, es2020: true },
+  extends: [
+    'eslint:recommended',
+    '@eslint/js/recommended',
+    'plugin:react/recommended',
+    'plugin:react/jsx-runtime',
+    'plugin:react-hooks/recommended',
+  ],
+  ignorePatterns: ['dist', '.eslintrc.js'],
+  parserOptions: { ecmaVersion: 'latest', sourceType: 'module' },
+  settings: { react: { version: '18.3' } },
+  plugins: ['react-refresh'],
+  rules: {
+    'react/jsx-no-target-blank': 'off',
+    'react-refresh/only-export-components': [
+      'warn',
+      { allowConstantExport: true },
+    ],
+  },
+}