@friggframework/core 2.0.0--canary.657.07aea31.0 → 2.0.0--canary.657.e372ef6.0

package/CLAUDE.md

@@ -521,8 +521,9 @@ minute redelivery. It puts the message back so it runs at `retryAt`:
 | Over 900 s, no scheduler | Extends the message's visibility timeout to `retryAt` (12 h less 20 minutes at most). This uses one receive | reported failed |
 
 - The new message starts at receive count 1. A deferred body carries
-  `_frigg: { deferrals, firstDeferredAt }`; `_frigg` is reserved and the handler
-  never sees it.
+  `_frigg: { deferrals, firstDeferredAt, deferralId }`; `_frigg` is reserved and
+  the handler never sees it. `deferralId` is the SQS message id of the first
+  message that was put back, and every later deferral of that work keeps it.
 - The visibility tier sets a timeout of at most 12 h less 20 minutes
   (42,000 s). SQS counts its 12 h maximum from the receive, and an extension
   does not reset it. The margin covers the longest Lambda run (900 s) plus the
@@ -537,12 +538,16 @@ minute redelivery. It puts the message back so it runs at `retryAt`:
   would be lost with the acknowledged message.
 - With a `processId` in the message, the worker writes
   `Process.context.rateLimit = { status: 'WAITING' | 'EXHAUSTED', mechanism,
-  retryAt, reason, module, deferrals, updatedAt }`. `EXHAUSTED` means a cap ended
-  the deferrals, or a visibility change came on the last delivery. The value is
-  one per process, so it holds the latest known wait: a new wait replaces it only
-  when its `retryAt` is later, a `WAITING` value never hides an `EXHAUSTED` one,
-  and after a deferred or redelivered message ran the worker sets it to `null`
-  only when it is `WAITING` and its `retryAt` is past or within 5 s.
+  retryAt, reason, module, deferrals, deferralId, updatedAt }`. `EXHAUSTED` means
+  a cap ended the deferrals, or a visibility change came on the last delivery.
+  The value is one per process, so it holds the latest known wait: a new wait
+  replaces it only when its `retryAt` is later, and a `WAITING` value never hides
+  an `EXHAUSTED` one. After a deferred or redelivered message ran, the worker
+  sets a `WAITING` value to `null` at once when that message set it (same
+  `deferralId`, or the message's own id for a visibility change), and for any
+  other message only when its `retryAt` is past or within 5 s. So a job that
+  resumes before its `retryAt` clears its own wait, and cannot clear the wait of
+  another message.
 - Delivery stays at least once. The new message is sent before the old one is
   acknowledged, so a crash between the two can run the work twice.
 - Handlers check `delivery.isLastAttempt` first, then rethrow. The delay and

package/core/CLAUDE.md

@@ -98,8 +98,10 @@ the last attempt they write one ERROR, `record_lost_rate_limited`, with the
 details, and no WARN.
 
 Subclasses override two no-op hooks to keep run state: `recordRateLimitWait(body,
-error, state)` runs after the message was put back, and `clearRateLimitWait(body)`
-runs after a deferred or redelivered message succeeded. A failing hook logs
+error, state)` runs after the message was put back, and `clearRateLimitWait(body,
+{ deferralId })` runs after a deferred or redelivered message succeeded.
+`state.deferralId` and `deferralId` name the message that was first put back
+(`_frigg.deferralId`, or the message's own id). A failing hook logs
 `frigg.worker.rate_limit_state_failed` and never changes the outcome. The queue
 worker of an integration (`createQueueWorker`) writes `Process.context.rateLimit`
 in them. See `packages/core/CLAUDE.md` section 7.

package/core/Worker.js

@@ -63,7 +63,7 @@ class Worker {
                     runParams = JSON.parse(record.body);
                     this._validateParams(runParams);
                     await this._run(runParams, context, delivery);
-                    await this._clearDeferredState(runParams, delivery);
+                    await this._clearDeferredState(record, runParams, delivery);
                     log.debug('Record succeeded', { eventName: 'frigg.worker.record_succeeded' });
                 } catch (error) {
                     let deferralResult;
@@ -146,7 +146,7 @@ class Worker {
         }
 
         const now = Date.now();
-        const counters = nextDeferral(body, now);
+        const counters = nextDeferral(body, now, record.messageId);
         const deferral = {
             record,
             queueName,
@@ -312,15 +312,21 @@ class Worker {
                 status,
                 mechanism,
                 deferrals: counters.deferrals,
+                deferralId: counters.deferralId,
                 retryAt,
             })
         );
     }
 
-    async _clearDeferredState(body, delivery) {
+    async _clearDeferredState(record, body, delivery) {
         const redelivered = delivery.receiveCount > 1;
-        if (readDeferral(body).deferrals === 0 && !redelivered) return;
-        await this._runStateHook('clear', () => this.clearRateLimitWait(body));
+        const { deferrals, deferralId } = readDeferral(body);
+        if (deferrals === 0 && !redelivered) return;
+        await this._runStateHook('clear', () =>
+            this.clearRateLimitWait(body, {
+                deferralId: deferralId ?? record.messageId,
+            })
+        );
     }
 
     async _runStateHook(operation, hook) {

package/handlers/backend-utils.js

@@ -184,13 +184,13 @@ const createQueueWorker = (integrationClass) => {
             });
         }
 
-        async clearRateLimitWait(body) {
+        async clearRateLimitWait(body, { deferralId } = {}) {
             const processId = body?.data?.processId;
             if (!processId) return;
             const clearRateLimitWait = new ClearRateLimitWait({
                 processRepository: createProcessRepository(),
             });
-            await clearRateLimitWait.execute(processId);
+            await clearRateLimitWait.execute(processId, { deferralId });
         }
 
         async _run(params, context, delivery) {

package/integrations/use-cases/clear-rate-limit-wait.js

@@ -1,5 +1,11 @@
 const CLEAR_RATE_LIMIT_TOLERANCE_MS = 5_000;
 
+const isOwnWait = (current, deferralId) =>
+    Boolean(deferralId) && current.deferralId === deferralId;
+
+const isOver = (current) =>
+    Date.parse(current.retryAt) - Date.now() <= CLEAR_RATE_LIMIT_TOLERANCE_MS;
+
 class ClearRateLimitWait {
     constructor({ processRepository }) {
         if (!processRepository) {
@@ -8,12 +14,11 @@ class ClearRateLimitWait {
         this.processRepository = processRepository;
     }
 
-    async execute(processId) {
+    async execute(processId, { deferralId } = {}) {
         const process = await this.processRepository.findById(processId);
         const current = process?.context?.rateLimit;
         if (current?.status !== 'WAITING') return;
-        const remainingMs = Date.parse(current.retryAt) - Date.now();
-        if (remainingMs > CLEAR_RATE_LIMIT_TOLERANCE_MS) return;
+        if (!isOwnWait(current, deferralId) && !isOver(current)) return;
         await this.processRepository.applyProcessUpdate(processId, {
             set: { 'context.rateLimit': null },
         });

package/integrations/use-cases/record-rate-limit-wait.js

@@ -25,6 +25,7 @@ class RecordRateLimitWait {
                     reason: wait.reason,
                     module: wait.module,
                     deferrals: wait.deferrals,
+                    deferralId: wait.deferralId,
                     updatedAt: new Date().toISOString(),
                 },
             },

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.657.07aea31.0",
+    "version": "2.0.0--canary.657.e372ef6.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -48,9 +48,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.657.07aea31.0",
-        "@friggframework/prettier-config": "2.0.0--canary.657.07aea31.0",
-        "@friggframework/test": "2.0.0--canary.657.07aea31.0",
+        "@friggframework/eslint-config": "2.0.0--canary.657.e372ef6.0",
+        "@friggframework/prettier-config": "2.0.0--canary.657.e372ef6.0",
+        "@friggframework/test": "2.0.0--canary.657.e372ef6.0",
         "@prisma/client": "^6.19.3",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -91,5 +91,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "07aea3197703a6bc5116bdb6c52308c0ac9b50db"
+    "gitHead": "e372ef6b74e5bb76673a99181fed6d54d097dc99"
 }

package/queues/queue-deferral.js

@@ -30,14 +30,19 @@ const readDeferral = (body) => {
         !Number.isNaN(Date.parse(frigg.firstDeferredAt))
             ? frigg.firstDeferredAt
             : undefined;
-    return { deferrals, firstDeferredAt };
+    const deferralId =
+        typeof frigg?.deferralId === 'string' && frigg.deferralId !== ''
+            ? frigg.deferralId
+            : undefined;
+    return { deferrals, firstDeferredAt, deferralId };
 };
 
-const nextDeferral = (body, now = Date.now()) => {
+const nextDeferral = (body, now = Date.now(), messageId) => {
     const current = readDeferral(body);
     return {
         deferrals: current.deferrals + 1,
         firstDeferredAt: current.firstDeferredAt ?? new Date(now).toISOString(),
+        deferralId: current.deferralId ?? messageId,
     };
 };
 

package/types/core/index.d.ts

@@ -54,13 +54,17 @@ declare module "@friggframework/core" {
       state: RateLimitWaitState
     ): Promise<void>;
 
-    clearRateLimitWait(body: object): Promise<void>;
+    clearRateLimitWait(
+      body: object,
+      options?: { deferralId?: string }
+    ): Promise<void>;
   }
 
   export type RateLimitWaitState = {
     status: "WAITING" | "EXHAUSTED";
     mechanism: "delay" | "schedule" | "visibility" | "none";
     deferrals: number;
+    deferralId?: string;
     retryAt: Date;
   };