@friggframework/devtools 2.0.0-next.76 → 2.0.0-next.78

package/infrastructure/domains/integration/integration-builder.js

@@ -15,9 +15,15 @@
  * and externally-provided SQS queues.
  */
 
-const { InfrastructureBuilder, ValidationResult } = require('../shared/base-builder');
+const {
+    InfrastructureBuilder,
+    ValidationResult,
+} = require('../shared/base-builder');
 const IntegrationResourceResolver = require('./integration-resolver');
-const { createEmptyDiscoveryResult, ResourceOwnership } = require('../shared/types');
+const {
+    createEmptyDiscoveryResult,
+    ResourceOwnership,
+} = require('../shared/types');
 
 class IntegrationBuilder extends InfrastructureBuilder {
     constructor() {
@@ -26,7 +32,10 @@ class IntegrationBuilder extends InfrastructureBuilder {
     }
 
     shouldExecute(appDefinition) {
-        return Array.isArray(appDefinition.integrations) && appDefinition.integrations.length > 0;
+        return (
+            Array.isArray(appDefinition.integrations) &&
+            appDefinition.integrations.length > 0
+        );
     }
 
     getDependencies() {
@@ -48,7 +57,9 @@ class IntegrationBuilder extends InfrastructureBuilder {
         // Validate each integration
         appDefinition.integrations.forEach((integration, index) => {
             if (!integration?.Definition?.name) {
-                result.addError(`Integration at index ${index} is missing Definition or name`);
+                result.addError(
+                    `Integration at index ${index} is missing Definition or name`
+                );
             }
         });
 
@@ -60,7 +71,9 @@ class IntegrationBuilder extends InfrastructureBuilder {
      */
     async build(appDefinition, discoveredResources) {
         console.log(`\n[${this.name}] Configuring integrations...`);
-        console.log(`  Processing ${appDefinition.integrations.length} integrations...`);
+        console.log(
+            `  Processing ${appDefinition.integrations.length} integrations...`
+        );
 
         const usePrismaLayer = appDefinition.usePrismaLambdaLayer !== false;
 
@@ -73,23 +86,34 @@ class IntegrationBuilder extends InfrastructureBuilder {
         };
 
         // Get structured discovery result
-        const discovery = discoveredResources._structured || this.convertFlatDiscoveryToStructured(discoveredResources);
+        const discovery =
+            discoveredResources._structured ||
+            this.convertFlatDiscoveryToStructured(discoveredResources);
 
         // Use IntegrationResourceResolver to make ownership decisions
         const resolver = new IntegrationResourceResolver();
         const decisions = resolver.resolveAll(appDefinition, discovery);
 
         console.log('\n  📋 Resource Ownership Decisions:');
-        console.log(`     InternalErrorQueue: ${decisions.internalErrorQueue.ownership} - ${decisions.internalErrorQueue.reason}`);
+        console.log(
+            `     InternalErrorQueue: ${decisions.internalErrorQueue.ownership} - ${decisions.internalErrorQueue.reason}`
+        );
 
         // Log per-integration decisions
-        Object.keys(decisions.integrations).forEach(integrationName => {
+        Object.keys(decisions.integrations).forEach((integrationName) => {
             const queueDecision = decisions.integrations[integrationName].queue;
-            console.log(`     ${integrationName}Queue: ${queueDecision.ownership} - ${queueDecision.reason}`);
+            console.log(
+                `     ${integrationName}Queue: ${queueDecision.ownership} - ${queueDecision.reason}`
+            );
         });
 
         // Build resources based on ownership decisions
-        await this.buildFromDecisions(decisions, appDefinition, result, usePrismaLayer);
+        await this.buildFromDecisions(
+            decisions,
+            appDefinition,
+            result,
+            usePrismaLayer
+        );
 
         console.log(`[${this.name}] ✅ Integration configuration completed`);
         return result;
@@ -113,7 +137,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
 
             // Add stack-managed resources from existingLogicalIds
             const existingLogicalIds = flatDiscovery.existingLogicalIds || [];
-            existingLogicalIds.forEach(logicalId => {
+            existingLogicalIds.forEach((logicalId) => {
                 let resourceType = '';
                 let physicalId = '';
 
@@ -124,7 +148,9 @@ class IntegrationBuilder extends InfrastructureBuilder {
                 } else if (logicalId.endsWith('Queue')) {
                     // Integration-specific queue (e.g., SlackQueue, HubspotQueue)
                     resourceType = 'AWS::SQS::Queue';
-                    const integrationName = logicalId.replace('Queue', '').toLowerCase();
+                    const integrationName = logicalId
+                        .replace('Queue', '')
+                        .toLowerCase();
                     physicalId = flatDiscovery[`${integrationName}QueueUrl`];
                 }
 
@@ -132,7 +158,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
                     discovery.stackManaged.push({
                         logicalId,
                         physicalId,
-                        resourceType
+                        resourceType,
                     });
                 }
             });
@@ -144,19 +170,30 @@ class IntegrationBuilder extends InfrastructureBuilder {
     /**
      * Build integration resources based on ownership decisions
      */
-    async buildFromDecisions(decisions, appDefinition, result, usePrismaLayer = true) {
+    async buildFromDecisions(
+        decisions,
+        appDefinition,
+        result,
+        usePrismaLayer = true
+    ) {
         // Create package config first — needed by all Lambda functions including DLQ processor
-        const functionPackageConfig = this.createFunctionPackageConfig(usePrismaLayer);
+        const functionPackageConfig =
+            this.createFunctionPackageConfig(usePrismaLayer);
 
         // Create InternalErrorQueue if ownership = STACK
-        const shouldCreateInternalErrorQueue = decisions.internalErrorQueue.ownership === ResourceOwnership.STACK;
+        const shouldCreateInternalErrorQueue =
+            decisions.internalErrorQueue.ownership === ResourceOwnership.STACK;
 
         if (shouldCreateInternalErrorQueue) {
             console.log('  → Creating InternalErrorQueue in stack');
             this.createInternalErrorQueue(result, functionPackageConfig);
         } else {
             console.log('  → Using external InternalErrorQueue');
-            this.useExternalInternalErrorQueue(decisions.internalErrorQueue, result, functionPackageConfig);
+            this.useExternalInternalErrorQueue(
+                decisions.internalErrorQueue,
+                result,
+                functionPackageConfig
+            );
         }
 
         for (const integration of appDefinition.integrations) {
@@ -166,17 +203,29 @@ class IntegrationBuilder extends InfrastructureBuilder {
             console.log(`\n    Adding integration: ${integrationName}`);
 
             // Create Lambda function definitions (serverless template code)
-            await this.createFunctionDefinitions(integration, functionPackageConfig, result, usePrismaLayer);
+            await this.createFunctionDefinitions(
+                integration,
+                functionPackageConfig,
+                result,
+                usePrismaLayer
+            );
 
             // Create or reference SQS queue based on ownership decision
-            const shouldCreateQueue = queueDecision.ownership === ResourceOwnership.STACK;
+            const shouldCreateQueue =
+                queueDecision.ownership === ResourceOwnership.STACK;
 
             if (shouldCreateQueue) {
-                console.log(`      ✓ Creating ${integrationName}Queue in stack`);
+                console.log(
+                    `      ✓ Creating ${integrationName}Queue in stack`
+                );
                 this.createIntegrationQueue(integrationName, result);
             } else {
                 console.log(`      ✓ Using external ${integrationName}Queue`);
-                this.useExternalIntegrationQueue(integrationName, queueDecision, result);
+                this.useExternalIntegrationQueue(
+                    integrationName,
+                    queueDecision,
+                    result
+                );
             }
         }
     }
@@ -192,12 +241,14 @@ class IntegrationBuilder extends InfrastructureBuilder {
                 'node_modules/@aws-sdk/**',
 
                 // Exclude Prisma (provided via Lambda Layer)
-                ...(usePrismaLayer ? [
-                    'node_modules/@prisma/**',
-                    'node_modules/.prisma/**',
-                    'node_modules/prisma/**',
-                    'node_modules/@friggframework/core/generated/**',
-                ] : []),
+                ...(usePrismaLayer
+                    ? [
+                          'node_modules/@prisma/**',
+                          'node_modules/.prisma/**',
+                          'node_modules/prisma/**',
+                          'node_modules/@friggframework/core/generated/**',
+                      ]
+                    : []),
 
                 // Exclude ALL nested node_modules
                 'node_modules/**/node_modules/**',
@@ -253,21 +304,31 @@ class IntegrationBuilder extends InfrastructureBuilder {
      * Create Lambda function definitions for an integration
      * These are serverless framework template function definitions
      */
-    async createFunctionDefinitions(integration, functionPackageConfig, result, usePrismaLayer = true) {
+    async createFunctionDefinitions(
+        integration,
+        functionPackageConfig,
+        result,
+        usePrismaLayer = true
+    ) {
         const integrationName = integration.Definition.name;
 
         // Add webhook handler if enabled (BEFORE catch-all proxy route)
         // CRITICAL: Webhook routes must be defined before the catch-all {proxy+} route
         // to ensure proper route matching in AWS API Gateway/HTTP API
         const webhookConfig = integration.Definition.webhooks;
-        if (webhookConfig && (webhookConfig === true || webhookConfig.enabled === true)) {
+        if (
+            webhookConfig &&
+            (webhookConfig === true || webhookConfig.enabled === true)
+        ) {
             const webhookFunctionName = `${integrationName}Webhook`;
 
             result.functions[webhookFunctionName] = {
                 handler: `node_modules/@friggframework/core/handlers/routers/integration-webhook-routers.handlers.${integrationName}Webhook.handler`,
-                skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
+                skipEsbuild: true, // Nested exports in node_modules - skip esbuild bundling
                 package: functionPackageConfig,
-                ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),  // Webhook handlers need Prisma for credential lookups
+                ...(usePrismaLayer && {
+                    layers: [{ Ref: 'PrismaLambdaLayer' }],
+                }), // Webhook handlers need Prisma for credential lookups
                 events: [
                     {
                         httpApi: {
@@ -289,9 +350,9 @@ class IntegrationBuilder extends InfrastructureBuilder {
         // Create HTTP API handler for integration (catch-all route AFTER webhooks)
         result.functions[integrationName] = {
             handler: `node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.${integrationName}.handler`,
-            skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
+            skipEsbuild: true, // Nested exports in node_modules - skip esbuild bundling
             package: functionPackageConfig,
-            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),  // HTTP handlers need Prisma for integration queries
+            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }), // HTTP handlers need Prisma for integration queries
             events: [
                 {
                     httpApi: {
@@ -307,20 +368,25 @@ class IntegrationBuilder extends InfrastructureBuilder {
         const queueWorkerName = `${integrationName}QueueWorker`;
         result.functions[queueWorkerName] = {
             handler: `node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.${integrationName}.queueWorker`,
-            skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
+            skipEsbuild: true, // Nested exports in node_modules - skip esbuild bundling
             package: functionPackageConfig,
-            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),  // Queue workers need Prisma for database operations
-            reservedConcurrency: 5,
+            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }), // Queue workers need Prisma for database operations
+            reservedConcurrency: 20,
             events: [
                 {
                     sqs: {
-                        arn: { 'Fn::GetAtt': [`${this.capitalizeFirst(integrationName)}Queue`, 'Arn'] },
+                        arn: {
+                            'Fn::GetAtt': [
+                                `${this.capitalizeFirst(integrationName)}Queue`,
+                                'Arn',
+                            ],
+                        },
                         batchSize: 1,
                         functionResponseType: 'ReportBatchItemFailures',
                     },
                 },
             ],
-            timeout: 900,  // 15 minutes max for queue workers (Lambda maximum)
+            timeout: 900, // 15 minutes max for queue workers (Lambda maximum)
         };
         console.log(`      ✓ Queue worker function defined`);
     }
@@ -329,20 +395,30 @@ class IntegrationBuilder extends InfrastructureBuilder {
      * Create InternalErrorQueue CloudFormation resource
      */
     createInternalErrorQueue(result, functionPackageConfig) {
+        const queueName =
+            '${self:service}-${self:provider.stage}-InternalErrorQueue';
+
+        result.custom.InternalErrorQueue = queueName;
+
         result.resources.InternalErrorQueue = {
             Type: 'AWS::SQS::Queue',
             Properties: {
-                QueueName: '${self:service}-${self:provider.stage}-InternalErrorQueue',
+                QueueName: '${self:custom.InternalErrorQueue}',
                 MessageRetentionPeriod: 1209600, // 14 days
                 VisibilityTimeout: 300, // 5 minutes — must be >= 6x DLQ processor Lambda timeout (30s × 6 = 180s)
             },
         };
 
-        this.createDLQObservability(result, functionPackageConfig, {
-            'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
-        }, {
-            'Fn::GetAtt': ['InternalErrorQueue', 'QueueName'],
-        });
+        this.createDLQObservability(
+            result,
+            functionPackageConfig,
+            {
+                'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
+            },
+            {
+                'Fn::GetAtt': ['InternalErrorQueue', 'QueueName'],
+            }
+        );
 
         console.log('  ✓ Created InternalErrorQueue resource');
     }
@@ -358,9 +434,16 @@ class IntegrationBuilder extends InfrastructureBuilder {
         const arnParts = decision.physicalId.split(':');
         const queueName = arnParts[arnParts.length - 1];
 
-        this.createDLQObservability(result, functionPackageConfig, decision.physicalId, queueName);
+        this.createDLQObservability(
+            result,
+            functionPackageConfig,
+            decision.physicalId,
+            queueName
+        );
 
-        console.log(`  ✓ Using external InternalErrorQueue: ${decision.physicalId}`);
+        console.log(
+            `  ✓ Using external InternalErrorQueue: ${decision.physicalId}`
+        );
     }
 
     /**
@@ -372,7 +455,8 @@ class IntegrationBuilder extends InfrastructureBuilder {
         result.resources.DLQMessageAlarm = {
             Type: 'AWS::CloudWatch::Alarm',
             Properties: {
-                AlarmDescription: 'Messages in dead-letter queue — integration queue processing failures',
+                AlarmDescription:
+                    'Messages in dead-letter queue — integration queue processing failures',
                 Namespace: 'AWS/SQS',
                 MetricName: 'ApproximateNumberOfMessagesVisible',
                 Statistic: 'Maximum',
@@ -381,15 +465,14 @@ class IntegrationBuilder extends InfrastructureBuilder {
                 EvaluationPeriods: 1,
                 Period: 300,
                 AlarmActions: [{ Ref: 'InternalErrorBridgeTopic' }],
-                Dimensions: [
-                    { Name: 'QueueName', Value: queueName },
-                ],
+                Dimensions: [{ Name: 'QueueName', Value: queueName }],
             },
         };
 
         // DLQ processor Lambda: logs failed messages with structured context
         result.functions.dlqProcessor = {
-            handler: 'node_modules/@friggframework/core/handlers/workers/dlq-processor.dlqProcessor',
+            handler:
+                'node_modules/@friggframework/core/handlers/workers/dlq-processor.dlqProcessor',
             skipEsbuild: true,
             package: functionPackageConfig,
             reservedConcurrency: 1,
@@ -447,7 +530,8 @@ class IntegrationBuilder extends InfrastructureBuilder {
      */
     useExternalIntegrationQueue(integrationName, decision, result) {
         // Add queue URL to environment for Lambda functions
-        result.environment[`${integrationName.toUpperCase()}_QUEUE_URL`] = decision.physicalId;
+        result.environment[`${integrationName.toUpperCase()}_QUEUE_URL`] =
+            decision.physicalId;
 
         console.log(`  ✓ Using external queue: ${decision.physicalId}`);
     }

package/infrastructure/domains/integration/integration-builder.test.js

@@ -260,7 +260,7 @@ describe('IntegrationBuilder', () => {
 
             const result = await integrationBuilder.build(appDefinition, {});
 
-            expect(result.functions.testQueueWorker.reservedConcurrency).toBe(5);
+            expect(result.functions.testQueueWorker.reservedConcurrency).toBe(20);
         });
 
         it('should add queue URL to environment variables', async () => {

package/infrastructure/infrastructure-composer.test.js

@@ -1162,7 +1162,7 @@ describe('composeServerlessDefinition', () => {
             // Check Queue Worker
             expect(result.functions.testIntegrationQueueWorker).toEqual({
                 handler: 'node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.testIntegration.queueWorker',
-                reservedConcurrency: 5,
+                reservedConcurrency: 20,
                 events: [{
                     sqs: {
                         arn: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0-next.76",
+  "version": "2.0.0-next.78",
   "bin": {
     "frigg": "./frigg-cli/index.js"
   },
@@ -25,9 +25,9 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/core": "2.0.0-next.76",
-    "@friggframework/schemas": "2.0.0-next.76",
-    "@friggframework/test": "2.0.0-next.76",
+    "@friggframework/core": "2.0.0-next.78",
+    "@friggframework/schemas": "2.0.0-next.78",
+    "@friggframework/test": "2.0.0-next.78",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -55,8 +55,8 @@
     "validate-npm-package-name": "^5.0.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0-next.76",
-    "@friggframework/prettier-config": "2.0.0-next.76",
+    "@friggframework/eslint-config": "2.0.0-next.78",
+    "@friggframework/prettier-config": "2.0.0-next.78",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -88,5 +88,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5f03113234df57301443502f2751f1864dd44e73"
+  "gitHead": "c8e0c0c725a9e49b76d4e095927a443640bf9ec9"
 }