@friggframework/devtools 2.0.0--canary.606.7d3473f.0 → 2.0.0--canary.608.ba60ba6.0

package/frigg-cli/package.json

@@ -16,14 +16,14 @@
     "@friggframework/core": "^2.0.0-next.0",
     "@friggframework/schemas": "^2.0.0-next.0",
     "@inquirer/prompts": "^5.3.8",
-    "axios": "^1.7.2",
+    "axios": "^1.18.0",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
     "cross-spawn": "^7.0.3",
     "dotenv": "^16.4.5",
     "fs-extra": "^11.2.0",
     "js-yaml": "^4.1.0",
-    "lodash": "4.17.21",
+    "lodash": "4.18.1",
     "node-cache": "^5.1.2",
     "open": "^8.4.2",
     "osls": "^3.40.1",

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

@@ -196,6 +196,14 @@ class IntegrationBuilder extends InfrastructureBuilder {
             );
         }
 
+        // App-level FIFO queue for dispatch:'queue' events — one per app,
+        // independent of per-integration queue ownership.
+        this.createUserActionQueue(
+            result,
+            functionPackageConfig,
+            usePrismaLayer
+        );
+
         for (const integration of appDefinition.integrations) {
             const integrationName = integration.Definition.name;
             const queueDecision = decisions.integrations[integrationName].queue;
@@ -472,6 +480,113 @@ class IntegrationBuilder extends InfrastructureBuilder {
         console.log('  ✓ Created InternalErrorQueue resource');
     }
 
+    /**
+     * Create the app-level FIFO queue + FIFO DLQ + worker used by integration
+     * events declared with `dispatch: 'queue'`.
+     *
+     * A single queue serves every integration: `MessageGroupId = integrationId`
+     * (set by the producer) serializes events per integration while letting
+     * distinct integrations process in parallel. Always created, like the
+     * InternalErrorQueue — idle cost is ~$0.
+     */
+    createUserActionQueue(
+        result,
+        functionPackageConfig,
+        usePrismaLayer = true
+    ) {
+        const queueName =
+            '${self:service}-${self:provider.stage}-FriggUserActionQueue.fifo';
+        const dlqName =
+            '${self:service}-${self:provider.stage}-FriggUserActionDLQ.fifo';
+
+        result.custom.FriggUserActionQueue = queueName;
+        result.custom.FriggUserActionDLQ = dlqName;
+
+        // A FIFO source queue can only redrive to a FIFO DLQ.
+        result.resources.FriggUserActionDLQ = {
+            Type: 'AWS::SQS::Queue',
+            Properties: {
+                QueueName: '${self:custom.FriggUserActionDLQ}',
+                FifoQueue: true,
+                MessageRetentionPeriod: 1209600, // 14 days
+            },
+        };
+
+        // ContentBasedDeduplication is intentionally OMITTED. The producer
+        // supplies a unique MessageDeduplicationId per send, so two distinct
+        // requests with identical bodies both run — content-based dedup would
+        // hash the body and silently drop the second within the 5-min window.
+        result.resources.FriggUserActionQueue = {
+            Type: 'AWS::SQS::Queue',
+            Properties: {
+                QueueName: '${self:custom.FriggUserActionQueue}',
+                FifoQueue: true,
+                MessageRetentionPeriod: 345600, // 4 days
+                VisibilityTimeout: 1800, // >= worker timeout (900s)
+                RedrivePolicy: {
+                    maxReceiveCount: 2,
+                    deadLetterTargetArn: {
+                        'Fn::GetAtt': ['FriggUserActionDLQ', 'Arn'],
+                    },
+                },
+            },
+        };
+
+        // Expose the queue URL to ALL Lambdas — both the HTTP handlers that
+        // produce events and the worker that consumes them.
+        result.environment.USER_ACTION_QUEUE_URL = {
+            Ref: 'FriggUserActionQueue',
+        };
+
+        // Any message in the FIFO DLQ is a failed eventual event.
+        result.resources.FriggUserActionDLQAlarm = {
+            Type: 'AWS::CloudWatch::Alarm',
+            Properties: {
+                AlarmDescription:
+                    'Messages in FriggUserActionDLQ — eventual (queued) integration event failures',
+                Namespace: 'AWS/SQS',
+                MetricName: 'ApproximateNumberOfMessagesVisible',
+                Statistic: 'Maximum',
+                Threshold: 0,
+                ComparisonOperator: 'GreaterThanThreshold',
+                EvaluationPeriods: 1,
+                Period: 300,
+                AlarmActions: [{ Ref: 'InternalErrorBridgeTopic' }],
+                Dimensions: [
+                    {
+                        Name: 'QueueName',
+                        Value: {
+                            'Fn::GetAtt': ['FriggUserActionDLQ', 'QueueName'],
+                        },
+                    },
+                ],
+            },
+        };
+
+        // Single app-level worker. NO reservedConcurrency: FIFO already
+        // serializes per MessageGroupId; capping at 1 would serialize across
+        // ALL integrations and kill cross-integration parallelism.
+        result.functions.userActionQueueWorker = {
+            handler:
+                'node_modules/@friggframework/core/handlers/workers/user-action-worker.userActionQueueWorker',
+            skipEsbuild: true,
+            package: functionPackageConfig,
+            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
+            timeout: 900,
+            events: [
+                {
+                    sqs: {
+                        arn: { 'Fn::GetAtt': ['FriggUserActionQueue', 'Arn'] },
+                        batchSize: 1,
+                        functionResponseType: 'ReportBatchItemFailures',
+                    },
+                },
+            ],
+        };
+
+        console.log('  ✓ Created FriggUserActionQueue (.fifo) + DLQ + worker');
+    }
+
     /**
      * Use external InternalErrorQueue
      */