@friggframework/core 2.0.0-next.75 → 2.0.0-next.77

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

@@ -154,6 +154,12 @@ const createQueueWorker = (integrationClass) => {
                         params.data.processId,
                         integrationClass
                     );
+                    if (integrationInstance?.status === 'DISABLED') {
+                        console.warn(
+                            `[${integrationClass.Definition.name}] Integration for process ${params.data.processId} is DISABLED. Discarding ${params.event} message.`
+                        );
+                        return;
+                    }
                 } else if (params.data?.integrationId) {
                     integrationInstance = await loadIntegrationForWebhook(
                         params.data.integrationId
@@ -164,6 +170,12 @@ const createQueueWorker = (integrationClass) => {
                         );
                         return;
                     }
+                    if (integrationInstance.status === 'DISABLED') {
+                        console.warn(
+                            `[${integrationClass.Definition.name}] Integration ${params.data.integrationId} is DISABLED. 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.
@@ -186,6 +198,19 @@ const createQueueWorker = (integrationClass) => {
                     `Error in ${params.event} for ${integrationClass.Definition.name}:`,
                     error
                 );
+
+                // 4xx HTTP errors are permanent — the requester already
+                // attempted token refresh (401) and backoff (429/5xx).
+                // By the time a 4xx reaches here, retrying won't help.
+                // 408 (timeout) and 429 (rate limit) are excluded — both are transient.
+                const status = error.statusCode;
+                if (status && status >= 400 && status < 500 && status !== 408 && status !== 429) {
+                    error.isHaltError = true;
+                    console.warn(
+                        `[${integrationClass.Definition.name}] Permanent ${status} error for ${params.event} — message will be discarded (no retry)`
+                    );
+                }
+
                 throw error;
             }
         }

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.75",
+    "version": "2.0.0-next.77",
     "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.75",
-        "@friggframework/prettier-config": "2.0.0-next.75",
-        "@friggframework/test": "2.0.0-next.75",
+        "@friggframework/eslint-config": "2.0.0-next.77",
+        "@friggframework/prettier-config": "2.0.0-next.77",
+        "@friggframework/test": "2.0.0-next.77",
         "@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": "d8b091ab80329d8d8ed22c019d120f3122419bb9"
+    "gitHead": "0f451bd5c8493b4ec6f82964a976cf2533aa94d8"
 }

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>;
   }