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

package/infrastructure/serverless-template.js

@@ -1,26 +1,7 @@
 const path = require('path');
 const fs = require('fs');
-const { AWSDiscovery } = require('./aws-discovery');
 
-/**
- * Check if AWS discovery should run based on AppDefinition
- * @param {Object} AppDefinition - Application definition
- * @returns {boolean} True if discovery should run
- */
-const shouldRunDiscovery = (AppDefinition) => {
-    return AppDefinition.vpc?.enable === true ||
-           AppDefinition.encryption?.useDefaultKMSForFieldLevelEncryption === true ||
-           AppDefinition.ssm?.enable === true;
-};
-
-/**
- * Find the actual path to node_modules directory
- * Tries multiple methods to locate node_modules:
- * 1. Traversing up from current directory
- * 2. Using npm root command
- * 3. Looking for package.json and adjacent node_modules
- * @returns {string} Path to node_modules directory
- */
+// Function to find the actual path to node_modules
 const findNodeModulesPath = () => {
     try {
         // Method 1: Try to find node_modules by traversing up from current directory
@@ -94,12 +75,7 @@ const findNodeModulesPath = () => {
     }
 };
 
-/**
- * Modify handler paths to point to the correct node_modules location
- * Only modifies paths when running in offline mode
- * @param {Object} functions - Serverless functions configuration object
- * @returns {Object} Modified functions object with updated handler paths
- */
+// Function to modify handler paths to point to the correct node_modules
 const modifyHandlerPaths = (functions) => {
     // Check if we're running in offline mode
     const isOffline = process.argv.includes('offline');
@@ -118,8 +94,7 @@ const modifyHandlerPaths = (functions) => {
         const functionDef = modifiedFunctions[functionName];
         if (functionDef?.handler?.includes('node_modules/')) {
             // Replace node_modules/ with the actual path to node_modules/
-            const relativePath = path.relative(process.cwd(), nodeModulesPath);
-            functionDef.handler = functionDef.handler.replace('node_modules/', `${relativePath}/`);
+            functionDef.handler = functionDef.handler.replace('node_modules/', '../node_modules/');
             console.log(`Updated handler for ${functionName}: ${functionDef.handler}`);
         }
     }
@@ -127,14 +102,7 @@ const modifyHandlerPaths = (functions) => {
     return modifiedFunctions;
 };
 
-/**
- * Create VPC infrastructure resources for CloudFormation
- * Creates VPC, subnets, NAT gateway, route tables, and security groups
- * @param {Object} AppDefinition - Application definition object
- * @param {Object} AppDefinition.vpc - VPC configuration
- * @param {string} [AppDefinition.vpc.cidrBlock='10.0.0.0/16'] - CIDR block for VPC
- * @returns {Object} CloudFormation resources for VPC infrastructure
- */
+// Helper function to create VPC infrastructure resources
 const createVPCInfrastructure = (AppDefinition) => {
     const vpcResources = {
         // VPC
@@ -437,72 +405,7 @@ const createVPCInfrastructure = (AppDefinition) => {
     return vpcResources;
 };
 
-/**
- * Compose a complete serverless framework configuration from app definition
- * @param {Object} AppDefinition - Application definition object
- * @param {string} [AppDefinition.name] - Application name
- * @param {string} [AppDefinition.provider='aws'] - Cloud provider
- * @param {Array} AppDefinition.integrations - Array of integration definitions
- * @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 = async (AppDefinition) => {
-    // Store discovered resources
-    let discoveredResources = {};
-<<<<<<< HEAD
-=======
-    
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-    // Run AWS discovery if needed
-    if (shouldRunDiscovery(AppDefinition)) {
-        console.log('🔍 Running AWS resource discovery for serverless template...');
-        try {
-            const region = process.env.AWS_REGION || 'us-east-1';
-            const discovery = new AWSDiscovery(region);
-<<<<<<< HEAD
-=======
-            
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-            const config = {
-                vpc: AppDefinition.vpc || {},
-                encryption: AppDefinition.encryption || {},
-                ssm: AppDefinition.ssm || {}
-            };
-<<<<<<< HEAD
-
-            discoveredResources = await discovery.discoverResources(config);
-
-=======
-            
-            discoveredResources = await discovery.discoverResources(config);
-            
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-            console.log('✅ AWS discovery completed successfully!');
-            if (discoveredResources.defaultVpcId) {
-                console.log(`   VPC: ${discoveredResources.defaultVpcId}`);
-            }
-            if (discoveredResources.privateSubnetId1 && discoveredResources.privateSubnetId2) {
-                console.log(`   Subnets: ${discoveredResources.privateSubnetId1}, ${discoveredResources.privateSubnetId2}`);
-            }
-            if (discoveredResources.defaultSecurityGroupId) {
-                console.log(`   Security Group: ${discoveredResources.defaultSecurityGroupId}`);
-            }
-            if (discoveredResources.defaultKmsKeyId) {
-                console.log(`   KMS Key: ${discoveredResources.defaultKmsKeyId}`);
-            }
-        } catch (error) {
-            console.error('❌ AWS discovery failed:', error.message);
-            throw new Error(`AWS discovery failed: ${error.message}`);
-        }
-    }
-<<<<<<< HEAD
-=======
-    
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
+const composeServerlessDefinition = (AppDefinition) => {
     const definition = {
         frameworkVersion: '>=3.17.0',
         service: AppDefinition.name || 'create-frigg-app',
@@ -515,19 +418,11 @@ const composeServerlessDefinition = async (AppDefinition) => {
             name: AppDefinition.provider || 'aws',
             runtime: 'nodejs20.x',
             timeout: 30,
-            region: process.env.AWS_REGION || 'us-east-1',
+            region: 'us-east-1',
             stage: '${opt:stage}',
             environment: {
                 STAGE: '${opt:stage}',
                 AWS_NODEJS_CONNECTION_REUSE_ENABLED: 1,
-                // Add discovered resources to environment if available
-                ...(discoveredResources.defaultVpcId && { AWS_DISCOVERY_VPC_ID: discoveredResources.defaultVpcId }),
-                ...(discoveredResources.defaultSecurityGroupId && { AWS_DISCOVERY_SECURITY_GROUP_ID: discoveredResources.defaultSecurityGroupId }),
-                ...(discoveredResources.privateSubnetId1 && { AWS_DISCOVERY_SUBNET_ID_1: discoveredResources.privateSubnetId1 }),
-                ...(discoveredResources.privateSubnetId2 && { AWS_DISCOVERY_SUBNET_ID_2: discoveredResources.privateSubnetId2 }),
-                ...(discoveredResources.publicSubnetId && { AWS_DISCOVERY_PUBLIC_SUBNET_ID: discoveredResources.publicSubnetId }),
-                ...(discoveredResources.defaultRouteTableId && { AWS_DISCOVERY_ROUTE_TABLE_ID: discoveredResources.defaultRouteTableId }),
-                ...(discoveredResources.defaultKmsKeyId && { AWS_DISCOVERY_KMS_KEY_ID: discoveredResources.defaultKmsKeyId }),
             },
             iamRoleStatements: [
                 {
@@ -578,7 +473,7 @@ const composeServerlessDefinition = async (AppDefinition) => {
                 autoCreate: false,
                 apiVersion: '2012-11-05',
                 endpoint: 'http://localhost:4566',
-                region: process.env.AWS_REGION || 'us-east-1',
+                region: 'us-east-1',
                 accessKeyId: 'root',
                 secretAccessKey: 'root',
                 skipCacheInvalidation: false,
@@ -588,6 +483,26 @@ const composeServerlessDefinition = async (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: [
@@ -652,7 +567,7 @@ const composeServerlessDefinition = async (AppDefinition) => {
                     Type: 'AWS::SQS::Queue',
                     Properties: {
                         QueueName:
-                            '${self:service}-internal-error-queue-${self:provider.stage}',
+                            'internal-error-queue-${self:provider.stage}',
                         MessageRetentionPeriod: 300,
                     },
                 },
@@ -736,7 +651,6 @@ const composeServerlessDefinition = async (AppDefinition) => {
         },
     };
 
-
     // KMS Configuration based on App Definition
     if (AppDefinition.encryption?.useDefaultKMSForFieldLevelEncryption === true) {
         // Add KMS IAM permissions
@@ -755,14 +669,39 @@ const composeServerlessDefinition = async (AppDefinition) => {
         // Add serverless-kms-grants plugin
         definition.plugins.push('serverless-kms-grants');
 
-        // Configure KMS grants with discovered default key
+        // Configure KMS grants with default key
         definition.custom.kmsGrants = {
-            kmsKeyId: discoveredResources.defaultKmsKeyId || '${env:AWS_DISCOVERY_KMS_KEY_ID}'
+            kmsKeyId: '*'
         };
     }
 
     // VPC Configuration based on App Definition
     if (AppDefinition.vpc?.enable === true) {
+        // Create VPC config from App Definition or use auto-created resources
+        const vpcConfig = {};
+
+        if (AppDefinition.vpc.securityGroupIds) {
+            // User provided custom security groups
+            vpcConfig.securityGroupIds = AppDefinition.vpc.securityGroupIds;
+        } else {
+            // Use auto-created security group
+            vpcConfig.securityGroupIds = [{ Ref: 'FriggLambdaSecurityGroup' }];
+        }
+
+        if (AppDefinition.vpc.subnetIds) {
+            // User provided custom subnets
+            vpcConfig.subnetIds = AppDefinition.vpc.subnetIds;
+        } else {
+            // Use auto-created private subnets
+            vpcConfig.subnetIds = [
+                { Ref: 'FriggPrivateSubnet1' },
+                { Ref: 'FriggPrivateSubnet2' }
+            ];
+        }
+
+        // Set VPC config for Lambda functions
+        definition.provider.vpc = vpcConfig;
+
         // Add VPC-related IAM permissions
         definition.provider.iamRoleStatements.push({
             Effect: 'Allow',
@@ -776,247 +715,17 @@ const composeServerlessDefinition = async (AppDefinition) => {
             Resource: '*'
         });
 
-        // Default approach: Use AWS Discovery to find existing VPC resources
-        if (AppDefinition.vpc.createNew === true) {
-            // Option 1: Create new VPC infrastructure (explicit opt-in)
-            const vpcConfig = {};
-
-            if (AppDefinition.vpc.securityGroupIds) {
-                // User provided custom security groups
-                vpcConfig.securityGroupIds = AppDefinition.vpc.securityGroupIds;
-            } else {
-                // Use auto-created security group
-                vpcConfig.securityGroupIds = [{ Ref: 'FriggLambdaSecurityGroup' }];
-            }
-
-            if (AppDefinition.vpc.subnetIds) {
-                // User provided custom subnets
-                vpcConfig.subnetIds = AppDefinition.vpc.subnetIds;
-            } else {
-                // Use auto-created private subnets
-                vpcConfig.subnetIds = [
-                    { Ref: 'FriggPrivateSubnet1' },
-                    { Ref: 'FriggPrivateSubnet2' }
-                ];
-            }
-
-            // Set VPC config for Lambda functions
-            definition.provider.vpc = vpcConfig;
-
-            // Add VPC infrastructure resources to CloudFormation
-            const vpcResources = createVPCInfrastructure(AppDefinition);
-            Object.assign(definition.resources.Resources, vpcResources);
-        } else {
-            // Option 2: Use AWS Discovery (default behavior)
-            // VPC configuration using discovered or explicitly provided resources
-            const vpcConfig = {
-<<<<<<< HEAD
-                securityGroupIds: AppDefinition.vpc.securityGroupIds ||
-                    (discoveredResources.defaultSecurityGroupId ? [discoveredResources.defaultSecurityGroupId] : []),
-                subnetIds: AppDefinition.vpc.subnetIds ||
-                    (discoveredResources.privateSubnetId1 && discoveredResources.privateSubnetId2 ?
-                        [discoveredResources.privateSubnetId1, discoveredResources.privateSubnetId2] :
-                        [])
-=======
-                securityGroupIds: AppDefinition.vpc.securityGroupIds || 
-                                  (discoveredResources.defaultSecurityGroupId ? [discoveredResources.defaultSecurityGroupId] : []),
-                subnetIds: AppDefinition.vpc.subnetIds || 
-                          (discoveredResources.privateSubnetId1 && discoveredResources.privateSubnetId2 ? 
-                           [discoveredResources.privateSubnetId1, discoveredResources.privateSubnetId2] :
-                           [])
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-            };
-
-            // Set VPC config for Lambda functions only if we have valid subnet IDs
-            if (vpcConfig.subnetIds.length >= 2 && vpcConfig.securityGroupIds.length > 0) {
-                definition.provider.vpc = vpcConfig;
-<<<<<<< HEAD
-
-                // Check if we have an existing NAT Gateway to use
-                if (!discoveredResources.existingNatGatewayId) {
-                    // No existing NAT Gateway, create new resources
-
-=======
-                
-                // Check if we have an existing NAT Gateway to use
-                if (!discoveredResources.existingNatGatewayId) {
-                    // No existing NAT Gateway, create new resources
-                    
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-                    // Only create EIP if we don't have an existing one available
-                    if (!discoveredResources.existingElasticIpAllocationId) {
-                        definition.resources.Resources.FriggNATGatewayEIP = {
-                            Type: 'AWS::EC2::EIP',
-                            Properties: {
-                                Domain: 'vpc',
-                                Tags: [
-                                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-nat-eip' }
-                                ]
-                            }
-                        };
-                    }
-
-                    definition.resources.Resources.FriggNATGateway = {
-                        Type: 'AWS::EC2::NatGateway',
-                        Properties: {
-<<<<<<< HEAD
-                            AllocationId: discoveredResources.existingElasticIpAllocationId ||
-                                { 'Fn::GetAtt': ['FriggNATGatewayEIP', 'AllocationId'] },
-=======
-                            AllocationId: discoveredResources.existingElasticIpAllocationId || 
-                                         { 'Fn::GetAtt': ['FriggNATGatewayEIP', 'AllocationId'] },
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-                            SubnetId: discoveredResources.publicSubnetId || discoveredResources.privateSubnetId1, // Use first discovered subnet if no public subnet found
-                            Tags: [
-                                { Key: 'Name', Value: '${self:service}-${self:provider.stage}-nat-gateway' }
-                            ]
-                        }
-                    };
-                }
-
-                // Create route table for Lambda subnets to use NAT Gateway
-                definition.resources.Resources.FriggLambdaRouteTable = {
-                    Type: 'AWS::EC2::RouteTable',
-                    Properties: {
-                        VpcId: discoveredResources.defaultVpcId || { Ref: 'FriggVPC' },
-                        Tags: [
-                            { Key: 'Name', Value: '${self:service}-${self:provider.stage}-lambda-rt' }
-                        ]
-                    }
-                };
-
-                definition.resources.Resources.FriggNATRoute = {
-                    Type: 'AWS::EC2::Route',
-                    Properties: {
-                        RouteTableId: { Ref: 'FriggLambdaRouteTable' },
-                        DestinationCidrBlock: '0.0.0.0/0',
-                        NatGatewayId: discoveredResources.existingNatGatewayId || { Ref: 'FriggNATGateway' }
-                    }
-                };
-
-                // Associate Lambda subnets with NAT Gateway route table
-                definition.resources.Resources.FriggSubnet1RouteAssociation = {
-                    Type: 'AWS::EC2::SubnetRouteTableAssociation',
-<<<<<<< HEAD
-                    Properties: {
-                        SubnetId: vpcConfig.subnetIds[0],
-                        RouteTableId: { Ref: 'FriggLambdaRouteTable' }
-                    }
-                };
-
-                definition.resources.Resources.FriggSubnet2RouteAssociation = {
-                    Type: 'AWS::EC2::SubnetRouteTableAssociation',
-                    Properties: {
-                        SubnetId: vpcConfig.subnetIds[1],
-                        RouteTableId: { Ref: 'FriggLambdaRouteTable' }
-                    }
-                };
-=======
-                Properties: {
-                    SubnetId: vpcConfig.subnetIds[0],
-                    RouteTableId: { Ref: 'FriggLambdaRouteTable' }
-                }
-            };
-
-                definition.resources.Resources.FriggSubnet2RouteAssociation = {
-                    Type: 'AWS::EC2::SubnetRouteTableAssociation',
-                Properties: {
-                    SubnetId: vpcConfig.subnetIds[1],
-                    RouteTableId: { Ref: 'FriggLambdaRouteTable' }
-                }
-            };
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-
-                // Add VPC endpoints for AWS service optimization (optional but recommended)
-                if (AppDefinition.vpc.enableVPCEndpoints !== false) {
-                    definition.resources.Resources.VPCEndpointS3 = {
-<<<<<<< HEAD
-                        Type: 'AWS::EC2::VPCEndpoint',
-                        Properties: {
-                            VpcId: discoveredResources.defaultVpcId,
-                            ServiceName: 'com.amazonaws.${self:provider.region}.s3',
-                            VpcEndpointType: 'Gateway',
-                            RouteTableIds: [{ Ref: 'FriggLambdaRouteTable' }]
-                        }
-                    };
-
-                    definition.resources.Resources.VPCEndpointDynamoDB = {
-                        Type: 'AWS::EC2::VPCEndpoint',
-                        Properties: {
-                            VpcId: discoveredResources.defaultVpcId,
-                            ServiceName: 'com.amazonaws.${self:provider.region}.dynamodb',
-                            VpcEndpointType: 'Gateway',
-                            RouteTableIds: [{ Ref: 'FriggLambdaRouteTable' }]
-                        }
-                    };
-=======
-                    Type: 'AWS::EC2::VPCEndpoint',
-                    Properties: {
-                        VpcId: discoveredResources.defaultVpcId,
-                        ServiceName: 'com.amazonaws.${self:provider.region}.s3',
-                        VpcEndpointType: 'Gateway',
-                        RouteTableIds: [{ Ref: 'FriggLambdaRouteTable' }]
-                    }
-                };
-
-                    definition.resources.Resources.VPCEndpointDynamoDB = {
-                    Type: 'AWS::EC2::VPCEndpoint',
-                    Properties: {
-                        VpcId: discoveredResources.defaultVpcId,
-                        ServiceName: 'com.amazonaws.${self:provider.region}.dynamodb',
-                        VpcEndpointType: 'Gateway',
-                        RouteTableIds: [{ Ref: 'FriggLambdaRouteTable' }]
-                    }
-                };
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-                }
-            }
-        }
-    }
-
-    // SSM Parameter Store Configuration based on App Definition  
-    if (AppDefinition.ssm?.enable === true) {
-        // Add AWS Parameters and Secrets Lambda Extension layer
-        definition.provider.layers = [
-            'arn:aws:lambda:${self:provider.region}:177933569100:layer:AWS-Parameters-and-Secrets-Lambda-Extension:11'
-        ];
-
-        // Add SSM IAM permissions
-        definition.provider.iamRoleStatements.push({
-            Effect: 'Allow',
-            Action: [
-                'ssm:GetParameter',
-                'ssm:GetParameters',
-                'ssm:GetParametersByPath'
-            ],
-            Resource: [
-                'arn:aws:ssm:${self:provider.region}:*:parameter/${self:service}/${self:provider.stage}/*'
-            ]
-        });
-
-        // Add environment variable for SSM parameter prefix
-        definition.provider.environment.SSM_PARAMETER_PREFIX = '/${self:service}/${self:provider.stage}';
+        // Add VPC infrastructure resources to CloudFormation
+        const vpcResources = createVPCInfrastructure(AppDefinition);
+        Object.assign(definition.resources.Resources, vpcResources);
     }
 
     // Add integration-specific functions and resources
-    if (AppDefinition.integrations && Array.isArray(AppDefinition.integrations)) {
-        for (const integration of AppDefinition.integrations) {
-            if (!integration || !integration.Definition || !integration.Definition.name) {
-                throw new Error('Invalid integration: missing Definition or name');
-            }
-            const integrationName = integration.Definition.name;
+    for (const integration of AppDefinition.integrations) {
+        const integrationName = integration.Definition.name;
 
-            // Add function for the integration
-            definition.functions[integrationName] = {
-<<<<<<< HEAD
-                handler: `node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.${integrationName}.handler`,
-                events: [
-                    {
-                        http: {
-                            path: `/api/${integrationName}-integration/{proxy+}`,
-                            method: 'ANY',
-                            cors: true,
-=======
+        // Add function for the integration
+        definition.functions[integrationName] = {
             handler: `node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.${integrationName}.handler`,
             events: [
                 {
@@ -1029,11 +738,11 @@ const composeServerlessDefinition = async (AppDefinition) => {
             ],
         };
 
-            // Add SQS Queue for the integration
-            const queueReference = `${integrationName.charAt(0).toUpperCase() + integrationName.slice(1)
-                }Queue`;
-            const queueName = `\${self:service}--\${self:provider.stage}-${queueReference}`;
-            definition.resources.Resources[queueReference] = {
+        // Add SQS Queue for the integration
+        const queueReference = `${integrationName.charAt(0).toUpperCase() + integrationName.slice(1)
+            }Queue`;
+        const queueName = `\${self:service}--\${self:provider.stage}-${queueReference}`;
+        definition.resources.Resources[queueReference] = {
             Type: 'AWS::SQS::Queue',
             Properties: {
                 QueueName: `\${self:custom.${queueReference}}`,
@@ -1048,9 +757,9 @@ const composeServerlessDefinition = async (AppDefinition) => {
             },
         };
 
-            // Add Queue Worker for the integration
-            const queueWorkerName = `${integrationName}QueueWorker`;
-            definition.functions[queueWorkerName] = {
+        // Add Queue Worker for the integration
+        const queueWorkerName = `${integrationName}QueueWorker`;
+        definition.functions[queueWorkerName] = {
             handler: `node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.${integrationName}.queueWorker`,
             reservedConcurrency: 5,
             events: [
@@ -1058,182 +767,23 @@ const composeServerlessDefinition = async (AppDefinition) => {
                     sqs: {
                         arn: {
                             'Fn::GetAtt': [queueReference, 'Arn'],
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-                        },
-                    },
-                ],
-            };
-
-            // Add SQS Queue for the integration
-            const queueReference = `${integrationName.charAt(0).toUpperCase() + integrationName.slice(1)
-                }Queue`;
-            const queueName = `\${self:service}--\${self:provider.stage}-${queueReference}`;
-            definition.resources.Resources[queueReference] = {
-                Type: 'AWS::SQS::Queue',
-                Properties: {
-                    QueueName: `\${self:custom.${queueReference}}`,
-                    MessageRetentionPeriod: 60,
-                    VisibilityTimeout: 1800,  // 30 minutes
-                    RedrivePolicy: {
-                        maxReceiveCount: 1,
-                        deadLetterTargetArn: {
-                            'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
                         },
-                    },
-                },
-            };
-
-            // Add Queue Worker for the integration
-            const queueWorkerName = `${integrationName}QueueWorker`;
-            definition.functions[queueWorkerName] = {
-                handler: `node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.${integrationName}.queueWorker`,
-                reservedConcurrency: 5,
-                events: [
-                    {
-                        sqs: {
-                            arn: {
-                                'Fn::GetAtt': [queueReference, 'Arn'],
-                            },
-                            batchSize: 1,
-                        },
-                    },
-                ],
-                timeout: 600,
-            };
-
-            // Add Queue URL for the integration to the ENVironment variables
-            definition.provider.environment = {
-                ...definition.provider.environment,
-                [`${integrationName.toUpperCase()}_QUEUE_URL`]: {
-                    Ref: queueReference,
-                },
-            };
-
-            definition.custom[queueReference] = queueName;
-        }
-    }
-
-    // Discovery has already run successfully at this point if needed
-    // The discoveredResources object contains all the necessary AWS resources
-
-    // 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',
+                        batchSize: 1,
                     },
                 },
             ],
+            timeout: 600,
         };
-    }
-
-<<<<<<< HEAD
-    // Discovery has already run successfully at this point if needed
-    // The discoveredResources object contains all the necessary AWS resources
 
-    // 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',
-                    },
-                },
-            ],
-        };
-    }
-
-=======
-            // Add Queue URL for the integration to the ENVironment variables
-            definition.provider.environment = {
-                ...definition.provider.environment,
-                [`${integrationName.toUpperCase()}_QUEUE_URL`]: {
-                    Ref: queueReference,
-                },
-            };
-
-            definition.custom[queueReference] = queueName;
-        }
-    }
-
-    // Discovery has already run successfully at this point if needed
-    // The discoveredResources object contains all the necessary AWS resources
-
-    // 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',
-                    },
-                },
-            ],
+        // Add Queue URL for the integration to the ENVironment variables
+        definition.provider.environment = {
+            ...definition.provider.environment,
+            [`${integrationName.toUpperCase()}_QUEUE_URL`]: {
+                Ref: queueReference,
+            },
         };
-    }
 
->>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
-    // Discovery has already run successfully at this point if needed
-    // The discoveredResources object contains all the necessary AWS resources
-
-    // 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',
-                    },
-                },
-            ],
-        };
+        definition.custom[queueReference] = queueName;
     }
 
     // Modify handler paths to point to the correct node_modules location