@friggframework/devtools 2.0.0--canary.398.e2147f7.0 → 2.0.0--canary.398.c9e5d61.0

package/infrastructure/iam-generator.test.js

@@ -0,0 +1,169 @@
+const { generateIAMCloudFormation, getFeatureSummary } = require('./iam-generator');
+
+describe('IAM Generator', () => {
+    describe('getFeatureSummary', () => {
+        it('should detect all features when enabled', () => {
+            const appDefinition = {
+                name: 'test-app',
+                integrations: ['Integration1', 'Integration2'],
+                vpc: { enable: true },
+                encryption: { useDefaultKMSForFieldLevelEncryption: true },
+                ssm: { enable: true },
+                websockets: { enable: true }
+            };
+
+            const summary = getFeatureSummary(appDefinition);
+
+            expect(summary.appName).toBe('test-app');
+            expect(summary.integrationCount).toBe(2);
+            expect(summary.features.core).toBe(true);
+            expect(summary.features.vpc).toBe(true);
+            expect(summary.features.kms).toBe(true);
+            expect(summary.features.ssm).toBe(true);
+            expect(summary.features.websockets).toBe(true);
+        });
+
+        it('should detect minimal features when disabled', () => {
+            const appDefinition = {
+                integrations: []
+            };
+
+            const summary = getFeatureSummary(appDefinition);
+
+            expect(summary.appName).toBe('Unnamed Frigg App');
+            expect(summary.integrationCount).toBe(0);
+            expect(summary.features.core).toBe(true);
+            expect(summary.features.vpc).toBe(false);
+            expect(summary.features.kms).toBe(false);
+            expect(summary.features.ssm).toBe(false);
+            expect(summary.features.websockets).toBe(false);
+        });
+    });
+
+    describe('generateIAMCloudFormation', () => {
+        it('should generate valid CloudFormation YAML', () => {
+            const appDefinition = {
+                name: 'test-app',
+                integrations: [],
+                vpc: { enable: false },
+                encryption: { useDefaultKMSForFieldLevelEncryption: false },
+                ssm: { enable: false },
+                websockets: { enable: false }
+            };
+
+            const yaml = generateIAMCloudFormation(appDefinition);
+
+            expect(yaml).toContain('AWSTemplateFormatVersion');
+            expect(yaml).toContain('FriggDeploymentUser');
+            expect(yaml).toContain('FriggCoreDeploymentPolicy');
+            expect(yaml).toContain('FriggDiscoveryPolicy');
+        });
+
+        it('should include VPC policy when VPC is enabled', () => {
+            const appDefinition = {
+                name: 'test-app',
+                integrations: [],
+                vpc: { enable: true }
+            };
+
+            const yaml = generateIAMCloudFormation(appDefinition);
+
+            expect(yaml).toContain('FriggVPCPolicy');
+            expect(yaml).toContain('CreateVPCPermissions');
+            expect(yaml).toContain('EnableVPCSupport');
+        });
+
+        it('should include KMS policy when encryption is enabled', () => {
+            const appDefinition = {
+                name: 'test-app',
+                integrations: [],
+                encryption: { useDefaultKMSForFieldLevelEncryption: true }
+            };
+
+            const yaml = generateIAMCloudFormation(appDefinition);
+
+            expect(yaml).toContain('FriggKMSPolicy');
+            expect(yaml).toContain('CreateKMSPermissions');
+            expect(yaml).toContain('EnableKMSSupport');
+        });
+
+        it('should include SSM policy when SSM is enabled', () => {
+            const appDefinition = {
+                name: 'test-app',
+                integrations: [],
+                ssm: { enable: true }
+            };
+
+            const yaml = generateIAMCloudFormation(appDefinition);
+
+            expect(yaml).toContain('FriggSSMPolicy');
+            expect(yaml).toContain('CreateSSMPermissions');
+            expect(yaml).toContain('EnableSSMSupport');
+        });
+
+        it('should set correct default parameter values based on features', () => {
+            const appDefinition = {
+                name: 'test-app',
+                integrations: [],
+                vpc: { enable: true },
+                encryption: { useDefaultKMSForFieldLevelEncryption: false },
+                ssm: { enable: true }
+            };
+
+            const yaml = generateIAMCloudFormation(appDefinition);
+
+            // Check parameter defaults match the enabled features
+            expect(yaml).toContain('Default: true'); // VPC enabled
+            expect(yaml).toContain('Default: false'); // KMS disabled  
+            // SSM should be true
+        });
+
+        it('should include all core permissions', () => {
+            const appDefinition = {
+                name: 'test-app',
+                integrations: []
+            };
+
+            const yaml = generateIAMCloudFormation(appDefinition);
+
+            // Check for core permissions
+            expect(yaml).toContain('cloudformation:CreateStack');
+            expect(yaml).toContain('cloudformation:ListStackResources');
+            expect(yaml).toContain('lambda:CreateFunction');
+            expect(yaml).toContain('iam:CreateRole');
+            expect(yaml).toContain('s3:CreateBucket');
+            expect(yaml).toContain('sqs:CreateQueue');
+            expect(yaml).toContain('sns:CreateTopic');
+            expect(yaml).toContain('logs:CreateLogGroup');
+            expect(yaml).toContain('apigateway:POST');
+            expect(yaml).toContain('lambda:ListVersionsByFunction');
+            expect(yaml).toContain('iam:ListPolicyVersions');
+        });
+
+        it('should include internal-error-queue pattern in SQS resources', () => {
+            const appDefinition = {
+                name: 'test-app',
+                integrations: []
+            };
+
+            const yaml = generateIAMCloudFormation(appDefinition);
+
+            expect(yaml).toContain('internal-error-queue-*');
+        });
+
+        it('should generate outputs section', () => {
+            const appDefinition = {
+                name: 'test-app',
+                integrations: []
+            };
+
+            const yaml = generateIAMCloudFormation(appDefinition);
+
+            expect(yaml).toContain('Outputs:');
+            expect(yaml).toContain('DeploymentUserArn:');
+            expect(yaml).toContain('AccessKeyId:');
+            expect(yaml).toContain('SecretAccessKeyCommand:');
+            expect(yaml).toContain('CredentialsSecretArn:');
+        });
+    });
+});

package/infrastructure/run-discovery.js

@@ -0,0 +1,108 @@
+#!/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() {
+    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);
+        const 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.js

@@ -434,6 +434,8 @@ const createVPCInfrastructure = (AppDefinition) => {
  * @param {Object} [AppDefinition.vpc] - VPC configuration
  * @param {Object} [AppDefinition.encryption] - KMS encryption configuration
  * @param {Object} [AppDefinition.ssm] - SSM parameter store configuration
+ * @param {Object} [AppDefinition.websockets] - WebSocket configuration
+ * @param {boolean} [AppDefinition.websockets.enable=false] - Enable WebSocket support for live update streaming
  * @returns {Object} Complete serverless framework configuration
  */
 const composeServerlessDefinition = (AppDefinition) => {
@@ -514,26 +516,6 @@ const composeServerlessDefinition = (AppDefinition) => {
             },
         },
         functions: {
-            defaultWebsocket: {
-                handler: 'node_modules/@friggframework/core/handlers/routers/websocket.handler',
-                events: [
-                    {
-                        websocket: {
-                            route: '$connect',
-                        },
-                    },
-                    {
-                        websocket: {
-                            route: '$default',
-                        },
-                    },
-                    {
-                        websocket: {
-                            route: '$disconnect',
-                        },
-                    },
-                ],
-            },
             auth: {
                 handler: 'node_modules/@friggframework/core/handlers/routers/auth.handler',
                 events: [
@@ -923,6 +905,51 @@ const composeServerlessDefinition = (AppDefinition) => {
         definition.custom[queueReference] = queueName;
     }
 
+    // Check if AWS discovery environment variables are missing and error
+    const needsDiscovery = AppDefinition.vpc?.enable || 
+                          AppDefinition.encryption?.useDefaultKMSForFieldLevelEncryption ||
+                          AppDefinition.ssm?.enable;
+    
+    if (needsDiscovery && !process.env.AWS_DISCOVERY_VPC_ID) {
+        console.error('❌ AWS discovery environment variables not found');
+        console.error('');
+        console.error('🚨 Your AppDefinition requires AWS discovery but variables are missing:');
+        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('💡 Run AWS discovery before building:');
+        console.error('   node node_modules/@friggframework/devtools/infrastructure/run-discovery.js');
+        console.error('');
+        console.error('🔧 Or use the build command which runs discovery automatically:');
+        console.error('   npx frigg build');
+        throw new Error('AWS discovery required but environment variables not found');
+    }
+
+    // Add websocket function if enabled
+    if (AppDefinition.websockets?.enable === true) {
+        definition.functions.defaultWebsocket = {
+            handler: 'node_modules/@friggframework/core/handlers/routers/websocket.handler',
+            events: [
+                {
+                    websocket: {
+                        route: '$connect',
+                    },
+                },
+                {
+                    websocket: {
+                        route: '$default',
+                    },
+                },
+                {
+                    websocket: {
+                        route: '$disconnect',
+                    },
+                },
+            ],
+        };
+    }
+
     // Modify handler paths to point to the correct node_modules location
     definition.functions = modifyHandlerPaths(definition.functions);
 

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.398.e2147f7.0",
+  "version": "2.0.0--canary.398.c9e5d61.0",
   "dependencies": {
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/test": "2.0.0--canary.398.e2147f7.0",
+    "@friggframework/test": "2.0.0--canary.398.c9e5d61.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -23,12 +23,13 @@
     "express": "^4.19.2",
     "express-async-handler": "^1.2.0",
     "fs-extra": "^11.2.0",
+    "js-yaml": "^4.1.0",
     "lodash": "4.17.21",
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.398.e2147f7.0",
-    "@friggframework/prettier-config": "2.0.0--canary.398.e2147f7.0",
+    "@friggframework/eslint-config": "2.0.0--canary.398.c9e5d61.0",
+    "@friggframework/prettier-config": "2.0.0--canary.398.c9e5d61.0",
     "prettier": "^2.7.1",
     "serverless": "3.39.0",
     "serverless-dotenv-plugin": "^6.0.0",
@@ -60,5 +61,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e2147f7f03122a5daa917429ba610c1a7c6ef819"
+  "gitHead": "c9e5d614b0abcc3a1066ffa87da17ada71dc8f9d"
 }