@friggframework/devtools 2.0.0--canary.400.bed3308.0 → 2.0.0--canary.404.e9d4980.0

package/infrastructure/run-discovery.js

@@ -1,110 +0,0 @@
-#!/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?.useDefaultKMSForFieldLevelEncryption ||
-                              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?.useDefaultKMSForFieldLevelEncryption) 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?.useDefaultKMSForFieldLevelEncryption) console.error('   ❌ KMS encryption (encryption.useDefaultKMSForFieldLevelEncryption: true)');
-            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: { useDefaultKMSForFieldLevelEncryption: false }');
-        console.error('   ssm: { enable: false }');
-        
-        process.exit(1);
-    }
-}
-
-// Run if called directly
-if (require.main === module) {
-    runDiscovery();
-}
-
-module.exports = { runDiscovery };

package/infrastructure/serverless-template.test.js

@@ -1,553 +0,0 @@
-const { composeServerlessDefinition } = require('./serverless-template');
-
-// Mock AWS Discovery to prevent actual AWS calls
-jest.mock('./aws-discovery', () => {
-    return {
-        AWSDiscovery: jest.fn().mockImplementation(() => {
-            return {
-                discoverResources: jest.fn().mockResolvedValue({
-                    defaultVpcId: 'vpc-123456',
-                    defaultSecurityGroupId: 'sg-123456',
-                    privateSubnetId1: 'subnet-123456',
-                    privateSubnetId2: 'subnet-789012',
-                    publicSubnetId: 'subnet-public',
-                    defaultRouteTableId: 'rtb-123456',
-                    defaultKmsKeyId: 'arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012'
-                })
-            };
-        })
-    };
-});
-
-describe('composeServerlessDefinition', () => {
-    let mockIntegration;
-
-    beforeEach(() => {
-        mockIntegration = {
-            Definition: {
-                name: 'testIntegration'
-            }
-        };
-
-        // Mock process.argv to avoid offline mode during tests
-        process.argv = ['node', 'test'];
-<<<<<<< HEAD
-=======
-
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-        // Clear AWS_REGION for tests
-        delete process.env.AWS_REGION;
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-        // Restore env
-        delete process.env.AWS_REGION;
-    });
-
-    describe('Basic Configuration', () => {
-        it('should create basic serverless definition with minimal app definition', async () => {
-            const appDefinition = {
-                name: 'test-app',
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.service).toBe('test-app');
-            expect(result.provider.name).toBe('aws');
-            expect(result.provider.runtime).toBe('nodejs20.x');
-            expect(result.provider.region).toBe('us-east-1');
-            expect(result.provider.stage).toBe('${opt:stage}');
-            expect(result.frameworkVersion).toBe('>=3.17.0');
-        });
-
-        it('should use default service name when name not provided', async () => {
-            const appDefinition = {
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.service).toBe('create-frigg-app');
-        });
-
-        it('should use custom provider when specified', async () => {
-            const appDefinition = {
-                provider: 'custom-provider',
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.provider.name).toBe('custom-provider');
-        });
-
-        it('should use AWS_REGION environment variable when set', async () => {
-            process.env.AWS_REGION = 'eu-west-1';
-<<<<<<< HEAD
-=======
-
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-            const appDefinition = {
-                name: 'test-app',
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.provider.region).toBe('eu-west-1');
-            expect(result.custom['serverless-offline-sqs'].region).toBe('eu-west-1');
-        });
-
-        it('should default to us-east-1 when AWS_REGION is not set', async () => {
-            delete process.env.AWS_REGION;
-<<<<<<< HEAD
-=======
-
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-            const appDefinition = {
-                name: 'test-app',
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.provider.region).toBe('us-east-1');
-            expect(result.custom['serverless-offline-sqs'].region).toBe('us-east-1');
-        });
-    });
-
-    describe('VPC Configuration', () => {
-        it('should add VPC configuration when vpc.enable is true', async () => {
-            const appDefinition = {
-                vpc: { enable: true },
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.provider.vpc).toBe('${self:custom.vpc.${self:provider.stage}}');
-            expect(result.custom.vpc).toEqual({
-                '${self:provider.stage}': {
-                    securityGroupIds: ['${env:AWS_DISCOVERY_SECURITY_GROUP_ID}'],
-                    subnetIds: [
-                        '${env:AWS_DISCOVERY_SUBNET_ID_1}',
-                        '${env:AWS_DISCOVERY_SUBNET_ID_2}'
-                    ]
-                }
-            });
-        });
-
-        it('should add VPC endpoint for S3 when VPC is enabled', async () => {
-            const appDefinition = {
-                vpc: { enable: true },
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.resources.Resources.VPCEndpointS3).toEqual({
-                Type: 'AWS::EC2::VPCEndpoint',
-                Properties: {
-                    VpcId: '${env:AWS_DISCOVERY_VPC_ID}',
-                    ServiceName: 'com.amazonaws.${self:provider.region}.s3',
-                    VpcEndpointType: 'Gateway',
-                    RouteTableIds: ['${env:AWS_DISCOVERY_ROUTE_TABLE_ID}']
-                }
-            });
-        });
-
-        it('should not add VPC configuration when vpc.enable is false', async () => {
-            const appDefinition = {
-                vpc: { enable: false },
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.provider.vpc).toBeUndefined();
-            expect(result.custom.vpc).toBeUndefined();
-            expect(result.resources.Resources.VPCEndpointS3).toBeUndefined();
-        });
-
-        it('should not add VPC configuration when vpc is not defined', async () => {
-            const appDefinition = {
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.provider.vpc).toBeUndefined();
-            expect(result.custom.vpc).toBeUndefined();
-        });
-    });
-
-    describe('KMS Configuration', () => {
-        it('should add KMS configuration when encryption is enabled', async () => {
-            const appDefinition = {
-                encryption: { useDefaultKMSForFieldLevelEncryption: true },
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            // Check IAM permissions
-            const kmsPermission = result.provider.iamRoleStatements.find(
-                statement => statement.Action.includes('kms:GenerateDataKey')
-            );
-            expect(kmsPermission).toEqual({
-                Effect: 'Allow',
-                Action: [
-                    'kms:GenerateDataKey',
-                    'kms:Decrypt'
-                ],
-                Resource: ['${self:custom.kmsGrants.kmsKeyId}']
-            });
-
-            // Check environment variable
-            expect(result.provider.environment.KMS_KEY_ARN).toBe('${self:custom.kmsGrants.kmsKeyId}');
-
-            // Check plugin
-            expect(result.plugins).toContain('serverless-kms-grants');
-
-            // Check custom configuration
-            expect(result.custom.kmsGrants).toEqual({
-                kmsKeyId: '${env:AWS_DISCOVERY_KMS_KEY_ID}'
-            });
-        });
-
-        it('should not add KMS configuration when encryption is disabled', async () => {
-            const appDefinition = {
-                encryption: { useDefaultKMSForFieldLevelEncryption: false },
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            const kmsPermission = result.provider.iamRoleStatements.find(
-                statement => statement.Action && statement.Action.includes('kms:GenerateDataKey')
-            );
-            expect(kmsPermission).toBeUndefined();
-            expect(result.provider.environment.KMS_KEY_ARN).toBeUndefined();
-            expect(result.plugins).not.toContain('serverless-kms-grants');
-            expect(result.custom.kmsGrants).toBeUndefined();
-        });
-
-        it('should not add KMS configuration when encryption is not defined', async () => {
-            const appDefinition = {
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            const kmsPermission = result.provider.iamRoleStatements.find(
-                statement => statement.Action && statement.Action.includes('kms:GenerateDataKey')
-            );
-            expect(kmsPermission).toBeUndefined();
-            expect(result.custom.kmsGrants).toBeUndefined();
-        });
-    });
-
-    describe('SSM Configuration', () => {
-        it('should add SSM configuration when ssm.enable is true', async () => {
-            const appDefinition = {
-                ssm: { enable: true },
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            // Check lambda layers
-            expect(result.provider.layers).toEqual([
-                'arn:aws:lambda:${self:provider.region}:177933569100:layer:AWS-Parameters-and-Secrets-Lambda-Extension:11'
-            ]);
-
-            // Check IAM permissions
-            const ssmPermission = result.provider.iamRoleStatements.find(
-                statement => statement.Action.includes('ssm:GetParameter')
-            );
-            expect(ssmPermission).toEqual({
-                Effect: 'Allow',
-                Action: [
-                    'ssm:GetParameter',
-                    'ssm:GetParameters',
-                    'ssm:GetParametersByPath'
-                ],
-                Resource: [
-                    'arn:aws:ssm:${self:provider.region}:*:parameter/${self:service}/${self:provider.stage}/*'
-                ]
-            });
-
-            // Check environment variable
-            expect(result.provider.environment.SSM_PARAMETER_PREFIX).toBe('/${self:service}/${self:provider.stage}');
-        });
-
-        it('should not add SSM configuration when ssm.enable is false', async () => {
-            const appDefinition = {
-                ssm: { enable: false },
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.provider.layers).toBeUndefined();
-<<<<<<< HEAD
-=======
-
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-            const ssmPermission = result.provider.iamRoleStatements.find(
-                statement => statement.Action && statement.Action.includes('ssm:GetParameter')
-            );
-            expect(ssmPermission).toBeUndefined();
-            expect(result.provider.environment.SSM_PARAMETER_PREFIX).toBeUndefined();
-        });
-
-        it('should not add SSM configuration when ssm is not defined', async () => {
-            const appDefinition = {
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.provider.layers).toBeUndefined();
-            expect(result.provider.environment.SSM_PARAMETER_PREFIX).toBeUndefined();
-        });
-    });
-
-    describe('Integration Configuration', () => {
-        it('should add integration-specific resources and functions', async () => {
-            const appDefinition = {
-                integrations: [mockIntegration]
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            // Check integration function
-            expect(result.functions.testIntegration).toEqual({
-                handler: 'node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.testIntegration.handler',
-                events: [{
-                    http: {
-                        path: '/api/testIntegration-integration/{proxy+}',
-                        method: 'ANY',
-                        cors: true
-                    }
-                }]
-            });
-
-            // Check SQS Queue
-            expect(result.resources.Resources.TestIntegrationQueue).toEqual({
-                Type: 'AWS::SQS::Queue',
-                Properties: {
-                    QueueName: '${self:custom.TestIntegrationQueue}',
-                    MessageRetentionPeriod: 60,
-                    VisibilityTimeout: 1800,
-                    RedrivePolicy: {
-                        maxReceiveCount: 1,
-                        deadLetterTargetArn: {
-                            'Fn::GetAtt': ['InternalErrorQueue', 'Arn']
-                        }
-                    }
-                }
-            });
-
-            // Check Queue Worker
-            expect(result.functions.testIntegrationQueueWorker).toEqual({
-                handler: 'node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.testIntegration.queueWorker',
-                reservedConcurrency: 5,
-                events: [{
-                    sqs: {
-                        arn: {
-                            'Fn::GetAtt': ['TestIntegrationQueue', 'Arn']
-                        },
-                        batchSize: 1
-                    }
-                }],
-                timeout: 600
-            });
-
-            // Check environment variable
-            expect(result.provider.environment.TESTINTEGRATION_QUEUE_URL).toEqual({
-                Ref: 'TestIntegrationQueue'
-            });
-
-            // Check custom queue name
-            expect(result.custom.TestIntegrationQueue).toBe('${self:service}--${self:provider.stage}-TestIntegrationQueue');
-        });
-
-        it('should handle multiple integrations', async () => {
-            const secondIntegration = {
-                Definition: {
-                    name: 'secondIntegration'
-                }
-            };
-
-            const appDefinition = {
-                integrations: [mockIntegration, secondIntegration]
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.functions.testIntegration).toBeDefined();
-            expect(result.functions.secondIntegration).toBeDefined();
-            expect(result.functions.testIntegrationQueueWorker).toBeDefined();
-            expect(result.functions.secondIntegrationQueueWorker).toBeDefined();
-            expect(result.resources.Resources.TestIntegrationQueue).toBeDefined();
-            expect(result.resources.Resources.SecondIntegrationQueue).toBeDefined();
-        });
-    });
-
-    describe('Combined Configurations', () => {
-        it('should combine VPC, KMS, and SSM configurations', async () => {
-            const appDefinition = {
-                vpc: { enable: true },
-                encryption: { useDefaultKMSForFieldLevelEncryption: true },
-                ssm: { enable: true },
-                integrations: [mockIntegration]
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            // VPC
-            expect(result.provider.vpc).toBeDefined();
-            expect(result.custom.vpc).toBeDefined();
-            expect(result.resources.Resources.VPCEndpointS3).toBeDefined();
-
-            // KMS
-            expect(result.plugins).toContain('serverless-kms-grants');
-            expect(result.provider.environment.KMS_KEY_ARN).toBeDefined();
-            expect(result.custom.kmsGrants).toBeDefined();
-
-            // SSM
-            expect(result.provider.layers).toBeDefined();
-            expect(result.provider.environment.SSM_PARAMETER_PREFIX).toBeDefined();
-
-            // Integration
-            expect(result.functions.testIntegration).toBeDefined();
-            expect(result.resources.Resources.TestIntegrationQueue).toBeDefined();
-
-            // All plugins should be present
-            expect(result.plugins).toEqual([
-                'serverless-jetpack',
-                'serverless-dotenv-plugin',
-                'serverless-offline-sqs',
-                'serverless-offline',
-                '@friggframework/serverless-plugin',
-                'serverless-kms-grants'
-            ]);
-        });
-
-        it('should handle partial configuration combinations', async () => {
-            const appDefinition = {
-                vpc: { enable: true },
-                encryption: { useDefaultKMSForFieldLevelEncryption: true },
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            // VPC and KMS should be present
-            expect(result.provider.vpc).toBeDefined();
-            expect(result.custom.kmsGrants).toBeDefined();
-
-            // SSM should not be present
-            expect(result.provider.layers).toBeUndefined();
-            expect(result.provider.environment.SSM_PARAMETER_PREFIX).toBeUndefined();
-        });
-    });
-
-    describe('Default Resources', () => {
-        it('should always include default resources', async () => {
-            const appDefinition = {
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            // Check default resources are always present
-            expect(result.resources.Resources.InternalErrorQueue).toBeDefined();
-            expect(result.resources.Resources.InternalErrorBridgeTopic).toBeDefined();
-            expect(result.resources.Resources.InternalErrorBridgePolicy).toBeDefined();
-            expect(result.resources.Resources.ApiGatewayAlarm5xx).toBeDefined();
-
-            // Check default functions
-            expect(result.functions.defaultWebsocket).toBeDefined();
-            expect(result.functions.auth).toBeDefined();
-            expect(result.functions.user).toBeDefined();
-
-            // Check default plugins
-            expect(result.plugins).toContain('serverless-jetpack');
-            expect(result.plugins).toContain('serverless-dotenv-plugin');
-            expect(result.plugins).toContain('@friggframework/serverless-plugin');
-        });
-
-        it('should always include default IAM permissions', async () => {
-            const appDefinition = {
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            // Check SNS publish permission
-            const snsPermission = result.provider.iamRoleStatements.find(
-                statement => statement.Action.includes('sns:Publish')
-            );
-            expect(snsPermission).toBeDefined();
-
-            // Check SQS permissions
-            const sqsPermission = result.provider.iamRoleStatements.find(
-                statement => statement.Action.includes('sqs:SendMessage')
-            );
-            expect(sqsPermission).toBeDefined();
-        });
-
-        it('should include default environment variables', async () => {
-            const appDefinition = {
-                integrations: []
-            };
-
-            const result = await composeServerlessDefinition(appDefinition);
-
-            expect(result.provider.environment.STAGE).toBe('${opt:stage}');
-            expect(result.provider.environment.AWS_NODEJS_CONNECTION_REUSE_ENABLED).toBe(1);
-        });
-    });
-
-    describe('Edge Cases', () => {
-        it('should handle empty app definition', async () => {
-            const appDefinition = {};
-
-            await expect(composeServerlessDefinition(appDefinition)).resolves.not.toThrow();
-            const result = await composeServerlessDefinition(appDefinition);
-            expect(result.service).toBe('create-frigg-app');
-        });
-
-        it('should handle null/undefined integrations', async () => {
-            const appDefinition = {
-                integrations: null
-            };
-
-            await expect(composeServerlessDefinition(appDefinition)).rejects.toThrow();
-        });
-
-        it('should handle integration with missing Definition', async () => {
-            const invalidIntegration = {};
-            const appDefinition = {
-                integrations: [invalidIntegration]
-            };
-
-            await expect(composeServerlessDefinition(appDefinition)).rejects.toThrow();
-        });
-
-        it('should handle integration with missing name', async () => {
-            const invalidIntegration = {
-                Definition: {}
-            };
-            const appDefinition = {
-                integrations: [invalidIntegration]
-            };
-
-            await expect(composeServerlessDefinition(appDefinition)).rejects.toThrow();
-        });
-    });
-});

package/management-ui/.eslintrc.js

@@ -1,22 +0,0 @@
-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 },
-    ],
-  },
-}