@friggframework/devtools 2.0.0-next.29 → 2.0.0-next.30

package/infrastructure/serverless-template.js

@@ -94,12 +94,6 @@ 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
- */
 /**
  * Modify handler paths to point to the correct node_modules location
  * Only modifies paths when running in offline mode
@@ -126,8 +120,6 @@ const modifyHandlerPaths = (functions) => {
             // 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}/`);
-            const relativePath = path.relative(process.cwd(), nodeModulesPath);
-            functionDef.handler = functionDef.handler.replace('node_modules/', `${relativePath}/`);
             console.log(`Updated handler for ${functionName}: ${functionDef.handler}`);
         }
     }
@@ -135,14 +127,6 @@ 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
- */
 /**
  * Create VPC infrastructure resources for CloudFormation
  * Creates VPC, subnets, NAT gateway, route tables, and security groups
@@ -517,7 +501,6 @@ const composeServerlessDefinition = async (AppDefinition) => {
             runtime: 'nodejs20.x',
             timeout: 30,
             region: process.env.AWS_REGION || 'us-east-1',
-            region: process.env.AWS_REGION || 'us-east-1',
             stage: '${opt:stage}',
             environment: {
                 STAGE: '${opt:stage, "dev"}',
@@ -530,14 +513,6 @@ const composeServerlessDefinition = async (AppDefinition) => {
                 ...(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 }),
-                // 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: [
                 {
@@ -600,7 +575,6 @@ const composeServerlessDefinition = async (AppDefinition) => {
                 apiVersion: '2012-11-05',
                 endpoint: 'http://localhost:4566',
                 region: process.env.AWS_REGION || 'us-east-1',
-                region: process.env.AWS_REGION || 'us-east-1',
                 accessKeyId: 'root',
                 secretAccessKey: 'root',
                 skipCacheInvalidation: false,
@@ -669,7 +643,6 @@ const composeServerlessDefinition = async (AppDefinition) => {
                     Properties: {
                         QueueName:
                             '${self:service}-internal-error-queue-${self:provider.stage}',
-                        '${self:service}-internal-error-queue-${self:provider.stage}',
                         MessageRetentionPeriod: 300,
                     },
                 },
@@ -749,8 +722,6 @@ const composeServerlessDefinition = async (AppDefinition) => {
         },
     };
 
-
-
     // KMS Configuration based on App Definition
     if (AppDefinition.encryption?.useDefaultKMSForFieldLevelEncryption === true) {
         // Provision a dedicated KMS key and wire it automatically
@@ -783,11 +754,9 @@ const composeServerlessDefinition = async (AppDefinition) => {
 
         definition.plugins.push('serverless-kms-grants');
 
-        // Configure KMS grants with discovered default key
         // Configure KMS grants with discovered default key
         definition.custom.kmsGrants = {
             kmsKeyId: discoveredResources.defaultKmsKeyId || '${env:AWS_DISCOVERY_KMS_KEY_ID}'
-            kmsKeyId: discoveredResources.defaultKmsKeyId || '${env:AWS_DISCOVERY_KMS_KEY_ID}'
         };
     }
 
@@ -810,290 +779,231 @@ const composeServerlessDefinition = async (AppDefinition) => {
         if (AppDefinition.vpc.createNew === true) {
             // Option 1: Create new VPC infrastructure (explicit opt-in)
             const vpcConfig = {};
-            // Add VPC-related IAM permissions
-            definition.provider.iamRoleStatements.push({
-                Effect: 'Allow',
-                Action: [
-                    'ec2:CreateNetworkInterface',
-                    'ec2:DescribeNetworkInterfaces',
-                    'ec2:DeleteNetworkInterface',
-                    'ec2:AttachNetworkInterface',
-                    'ec2:DetachNetworkInterface'
-                ],
-                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.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' }
-                    ];
-                }
-                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;
-                // Set VPC config for Lambda functions
-                definition.provider.vpc = 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' }];
+            }
 
-                // Add VPC infrastructure resources to CloudFormation
-                const vpcResources = createVPCInfrastructure(AppDefinition);
-                Object.assign(definition.resources.Resources, vpcResources);
+            if (AppDefinition.vpc.subnetIds) {
+                // User provided custom subnets
+                vpcConfig.subnetIds = AppDefinition.vpc.subnetIds;
             } else {
-                // Option 2: Use AWS Discovery (default behavior)
-                // VPC configuration using discovered or explicitly provided resources
-                const vpcConfig = {
-                    securityGroupIds: AppDefinition.vpc.securityGroupIds ||
-                        (discoveredResources.defaultSecurityGroupId ? [discoveredResources.defaultSecurityGroupId] : []),
-                    subnetIds: AppDefinition.vpc.subnetIds ||
-                        (discoveredResources.privateSubnetId1 && discoveredResources.privateSubnetId2 ?
-                            [discoveredResources.privateSubnetId1, discoveredResources.privateSubnetId2] :
-                            [])
-                };
+                // Use auto-created private subnets
+                vpcConfig.subnetIds = [
+                    { Ref: 'FriggPrivateSubnet1' },
+                    { Ref: 'FriggPrivateSubnet2' }
+                ];
+            }
 
-                // 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;
-
-                    // Check if we have an existing NAT Gateway to use
-                    if (!discoveredResources.existingNatGatewayId) {
-                        // No existing NAT Gateway, create new resources
-
-                        // 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' }
-                                    ]
-                                }
-                            };
-                        }
+            // 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 = {
+                securityGroupIds: AppDefinition.vpc.securityGroupIds ||
+                    (discoveredResources.defaultSecurityGroupId ? [discoveredResources.defaultSecurityGroupId] : []),
+                subnetIds: AppDefinition.vpc.subnetIds ||
+                    (discoveredResources.privateSubnetId1 && discoveredResources.privateSubnetId2 ?
+                        [discoveredResources.privateSubnetId1, discoveredResources.privateSubnetId2] :
+                        [])
+            };
+
+            // 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;
+
+                // Check if we have an existing NAT Gateway to use
+                if (!discoveredResources.existingNatGatewayId) {
+                    // No existing NAT Gateway, create new resources
 
-                        definition.resources.Resources.FriggNATGateway = {
-                            Type: 'AWS::EC2::NatGateway',
+                    // Only create EIP if we don't have an existing one available
+                    if (!discoveredResources.existingElasticIpAllocationId) {
+                        definition.resources.Resources.FriggNATGatewayEIP = {
+                            Type: 'AWS::EC2::EIP',
                             Properties: {
-                                AllocationId: discoveredResources.existingElasticIpAllocationId ||
-                                    { 'Fn::GetAtt': ['FriggNATGatewayEIP', 'AllocationId'] },
-                                SubnetId: discoveredResources.publicSubnetId || discoveredResources.privateSubnetId1, // Use first discovered subnet if no public subnet found
+                                Domain: 'vpc',
                                 Tags: [
-                                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-nat-gateway' }
+                                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-nat-eip' }
                                 ]
                             }
                         };
                     }
 
-                    // Create route table for Lambda subnets to use NAT Gateway
-                    definition.resources.Resources.FriggLambdaRouteTable = {
-                        Type: 'AWS::EC2::RouteTable',
+                    definition.resources.Resources.FriggNATGateway = {
+                        Type: 'AWS::EC2::NatGateway',
                         Properties: {
-                            VpcId: discoveredResources.defaultVpcId || { Ref: 'FriggVPC' },
+                            AllocationId: discoveredResources.existingElasticIpAllocationId ||
+                                { 'Fn::GetAtt': ['FriggNATGatewayEIP', 'AllocationId'] },
+                            SubnetId: discoveredResources.publicSubnetId || discoveredResources.privateSubnetId1, // Use first discovered subnet if no public subnet found
                             Tags: [
-                                { Key: 'Name', Value: '${self:service}-${self:provider.stage}-lambda-rt' }
+                                { Key: 'Name', Value: '${self:service}-${self:provider.stage}-nat-gateway' }
                             ]
                         }
                     };
+                }
 
-                    definition.resources.Resources.FriggNATRoute = {
-                        Type: 'AWS::EC2::Route',
-                        Properties: {
-                            RouteTableId: { Ref: 'FriggLambdaRouteTable' },
-                            DestinationCidrBlock: '0.0.0.0/0',
-                            NatGatewayId: discoveredResources.existingNatGatewayId || { Ref: 'FriggNATGateway' }
-                        }
-                    };
+                // 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',
+                    Properties: {
+                        SubnetId: vpcConfig.subnetIds[0],
+                        RouteTableId: { Ref: 'FriggLambdaRouteTable' }
+                    }
+                };
 
-                    // Associate Lambda subnets with NAT Gateway route table
-                    definition.resources.Resources.FriggSubnet1RouteAssociation = {
-                        Type: 'AWS::EC2::SubnetRouteTableAssociation',
+                definition.resources.Resources.FriggSubnet2RouteAssociation = {
+                    Type: 'AWS::EC2::SubnetRouteTableAssociation',
+                    Properties: {
+                        SubnetId: vpcConfig.subnetIds[1],
+                        RouteTableId: { Ref: 'FriggLambdaRouteTable' }
+                    }
+                };
+
+                // Add VPC endpoints for AWS service optimization (optional but recommended)
+                if (AppDefinition.vpc.enableVPCEndpoints !== false) {
+                    definition.resources.Resources.VPCEndpointS3 = {
+                        Type: 'AWS::EC2::VPCEndpoint',
                         Properties: {
-                            SubnetId: vpcConfig.subnetIds[0],
-                            RouteTableId: { Ref: 'FriggLambdaRouteTable' }
+                            VpcId: discoveredResources.defaultVpcId,
+                            ServiceName: 'com.amazonaws.${self:provider.region}.s3',
+                            VpcEndpointType: 'Gateway',
+                            RouteTableIds: [{ Ref: 'FriggLambdaRouteTable' }]
                         }
                     };
 
-                    definition.resources.Resources.FriggSubnet2RouteAssociation = {
-                        Type: 'AWS::EC2::SubnetRouteTableAssociation',
+                    definition.resources.Resources.VPCEndpointDynamoDB = {
+                        Type: 'AWS::EC2::VPCEndpoint',
                         Properties: {
-                            SubnetId: vpcConfig.subnetIds[1],
-                            RouteTableId: { Ref: 'FriggLambdaRouteTable' }
+                            VpcId: discoveredResources.defaultVpcId,
+                            ServiceName: 'com.amazonaws.${self:provider.region}.dynamodb',
+                            VpcEndpointType: 'Gateway',
+                            RouteTableIds: [{ Ref: 'FriggLambdaRouteTable' }]
                         }
                     };
-
-                    // Add VPC endpoints for AWS service optimization (optional but recommended)
-                    if (AppDefinition.vpc.enableVPCEndpoints !== false) {
-                        definition.resources.Resources.VPCEndpointS3 = {
-                            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' }]
-                            }
-                        };
-                    }
                 }
             }
         }
 
-        // 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}/*'
-                ]
+    // 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}/*'
-]
+            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 environment variable for SSM parameter prefix
-definition.provider.environment.SSM_PARAMETER_PREFIX = '/${self:service}/${self:provider.stage}';
+        // Add environment variable for SSM parameter prefix
+        definition.provider.environment.SSM_PARAMETER_PREFIX = '/${self:service}/${self:provider.stage}';
     }
 
-// 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;
-        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;
+    // 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;
 
-                // Add function for the integration
-                definition.functions[integrationName] = {
-                    handler: `node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.${integrationName}.handler`,
-                    events: [
-                        {
-                            httpApi: {
-                                path: `/api/${integrationName}-integration/{proxy+}`,
-                                method: 'ANY',
-                            },
+            // Add function for the integration
+            definition.functions[integrationName] = {
+                handler: `node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.${integrationName}.handler`,
+                events: [
+                    {
+                        httpApi: {
+                            path: `/api/${integrationName}-integration/{proxy+}`,
+                            method: 'ANY',
                         },
-                    ],
-                };
+                    },
+                ],
+            };
 
-                // 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 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,
+            // 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,
-                    },
-                };
-                // Add Queue URL for the integration to the ENVironment variables
-                definition.provider.environment = {
-                    ...definition.provider.environment,
-                    [`${integrationName.toUpperCase()}_QUEUE_URL`]: {
-                        Ref: queueReference,
                     },
-                };
+                ],
+                timeout: 600,
+            };
 
-                definition.custom[queueReference] = queueName;
+            // 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;
             }
         }
 
@@ -1149,7 +1059,6 @@ if (AppDefinition.integrations && Array.isArray(AppDefinition.integrations)) {
                     },
                 ],
             };
-            definition.custom[queueReference] = queueName;
         }
     }
 
@@ -1183,30 +1092,6 @@ if (AppDefinition.integrations && Array.isArray(AppDefinition.integrations)) {
     // 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',
-                    },
-                },
-            ],
-        };
-    }
-
     // Modify handler paths to point to the correct node_modules location
     definition.functions = modifyHandlerPaths(definition.functions);
 

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 },
+    ],
+  },
+}