@friggframework/core 2.0.0-next.74 → 2.0.0-next.76

package/core/Worker.js

@@ -18,12 +18,25 @@ class Worker {
 
     async run(params, context = {}) {
         const records = get(params, 'Records');
+        const batchItemFailures = [];
 
         for (const record of records) {
-            const runParams = JSON.parse(record.body);
-            this._validateParams(runParams);
-            await this._run(runParams, context);
+            try {
+                const runParams = JSON.parse(record.body);
+                this._validateParams(runParams);
+                await this._run(runParams, context);
+            } catch (error) {
+                if (error.isHaltError) {
+                    // HaltError means "discard this message, don't retry".
+                    // Treat as success so SQS deletes it from the queue.
+                    continue;
+                }
+                console.error(`[Worker] Failed to process record ${record.messageId}:`, error);
+                batchItemFailures.push({ itemIdentifier: record.messageId });
+            }
         }
+
+        return { batchItemFailures };
     }
 
     async _run(params, context = {}) {

package/handlers/backend-utils.js

@@ -88,9 +88,16 @@ const loadIntegrationForWebhook = async (integrationId) => {
         moduleFactory,
     });
 
-    const integrationRecord = await integrationRepository.findIntegrationById(
-        integrationId
-    );
+    let integrationRecord;
+    try {
+        integrationRecord =
+            await integrationRepository.findIntegrationById(integrationId);
+    } catch (error) {
+        if (error.message?.includes('not found')) {
+            return null;
+        }
+        throw error;
+    }
 
     const instance = await getIntegrationInstance.execute(
         integrationId,
@@ -151,6 +158,12 @@ const createQueueWorker = (integrationClass) => {
                     integrationInstance = await loadIntegrationForWebhook(
                         params.data.integrationId
                     );
+                    if (!integrationInstance) {
+                        console.warn(
+                            `[${integrationClass.Definition.name}] Integration ${params.data.integrationId} no longer exists. Discarding ${params.event} message.`
+                        );
+                        return;
+                    }
                 } else {
                     // Instantiates a DRY integration class without database records.
                     // There will be cases where we need to use helpers that the api modules can export.

package/handlers/workers/dlq-processor.js

@@ -0,0 +1,63 @@
+/**
+ * DLQ Processor — logs failed messages from the InternalErrorQueue
+ * with structured context for monitoring and debugging.
+ *
+ * This handler MUST NOT throw. If it throws, the message goes back to
+ * the DLQ and creates an infinite loop. All errors are caught and logged.
+ */
+
+function extractQueueName(eventSourceARN) {
+    if (!eventSourceARN) return 'UNKNOWN';
+    const parts = eventSourceARN.split(':');
+    return parts[parts.length - 1] || 'UNKNOWN';
+}
+
+function parseMessageBody(body) {
+    try {
+        const parsed = JSON.parse(body);
+        return {
+            event: parsed.event || 'UNKNOWN',
+            integrationId: parsed.data?.integrationId || null,
+            processId: parsed.data?.processId || null,
+            data: parsed.data,
+        };
+    } catch (error) {
+        console.warn('[DLQ] Failed to parse message body', { error: error.message, body });
+        return {
+            event: 'UNKNOWN',
+            integrationId: null,
+            processId: null,
+            rawBody: body,
+        };
+    }
+}
+
+async function dlqProcessor(event) {
+    if (!event?.Records?.length) return { batchItemFailures: [] };
+
+    for (const record of event.Records) {
+        try {
+            const parsed = parseMessageBody(record.body);
+
+            console.error('[DLQ] Failed message', {
+                messageId: record.messageId,
+                event: parsed.event,
+                integrationId: parsed.integrationId,
+                processId: parsed.processId,
+                receiveCount: record.attributes?.ApproximateReceiveCount,
+                sentTimestamp: record.attributes?.SentTimestamp,
+                sourceQueue: extractQueueName(record.eventSourceARN),
+                ...(parsed.rawBody !== undefined && { rawBody: parsed.rawBody }),
+            });
+        } catch (error) {
+            console.error('[DLQ] Error processing DLQ record', {
+                messageId: record.messageId,
+                error: error.message,
+            });
+        }
+    }
+
+    return { batchItemFailures: [] };
+}
+
+module.exports = { dlqProcessor };

package/handlers/workers/integration-defined-workers.js

@@ -14,11 +14,7 @@ integrationClasses.forEach((IntegrationClass) => {
             isUserFacingResponse: false,
             method: async (event, context) => {
                 const worker = new defaultQueueWorker();
-                await worker.run(event, context);
-                return {
-                    message: 'Successfully processed the Generic Queue Worker',
-                    input: event,
-                };
+                return await worker.run(event, context);
             },
         }),
     };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0-next.74",
+    "version": "2.0.0-next.76",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -38,9 +38,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0-next.74",
-        "@friggframework/prettier-config": "2.0.0-next.74",
-        "@friggframework/test": "2.0.0-next.74",
+        "@friggframework/eslint-config": "2.0.0-next.76",
+        "@friggframework/prettier-config": "2.0.0-next.76",
+        "@friggframework/test": "2.0.0-next.76",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -80,5 +80,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "8f935e0715e46299f5bc720d2ce8551da5d5705a"
+    "gitHead": "5f03113234df57301443502f2751f1864dd44e73"
 }

package/types/core/index.d.ts

@@ -26,10 +26,18 @@ declare module "@friggframework/core" {
     ): Promise<any>;
   }
 
+  export interface BatchItemFailure {
+    itemIdentifier: string;
+  }
+
+  export interface BatchItemFailuresResponse {
+    batchItemFailures: BatchItemFailure[];
+  }
+
   export class Worker implements IWorker {
     getQueueURL(params: GetQueueURLParams): Promise<string | undefined>;
 
-    run(params: { Records: any }): Promise<void>;
+    run(params: { Records: any }, context?: object): Promise<BatchItemFailuresResponse>;
 
     send(params: object & { QueueUrl: any }, delay?: number): Promise<string>;
 
@@ -38,7 +46,7 @@ declare module "@friggframework/core" {
 
   interface IWorker {
     getQueueURL(params: GetQueueURLParams): Promise<string | undefined>;
-    run(params: { Records: any }): Promise<void>;
+    run(params: { Records: any }, context?: object): Promise<BatchItemFailuresResponse>;
     send(params: object & { QueueUrl: any }, delay?: number): Promise<string>;
     sendAsyncSQSMessage(params: SendSQSMessageParams): Promise<string>;
   }