@friggframework/core 2.0.0--canary.657.8f335eb.0 → 2.0.0--canary.657.b14221f.0

package/CLAUDE.md

@@ -570,9 +570,12 @@ 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 }`, and `null` after the message
-  ran. `EXHAUSTED` means a cap ended the deferrals, or a visibility change came
-  on the last delivery.
+  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.
 - 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/Worker.js

@@ -182,60 +182,101 @@ class Worker {
             return { outcome: 'failed' };
         }
 
-        const next = withDeferral(body, deferral);
-
-        if (waitMs <= MAX_DELAY_SECONDS * 1000) {
-            const delaySeconds = Math.ceil(waitMs / 1000);
-            try {
-                const queueUrl = await this._queueUrl(queueName);
-                await this.send({ ...next, QueueUrl: queueUrl }, delaySeconds);
-            } catch (cause) {
-                return { outcome: 'skipped', skipped: 'send_failed', cause };
-            }
-            await this._recordWait(body, error, state('WAITING', 'delay'));
-            log.warn('Record deferred', {
-                eventName: 'frigg.worker.record_deferred',
-                mechanism: 'delay',
-                delaySeconds,
-                ...details,
-                error,
-            });
-            return { outcome: 'acked' };
+        const tier = {
+            record,
+            queueName,
+            body,
+            next: withDeferral(body, deferral),
+            error,
+            delivery,
+            retryAt,
+            waitMs,
+            details,
+            state,
+        };
+        if (waitMs <= MAX_DELAY_SECONDS * 1000)
+            return this._deferWithDelay(tier);
+        const scheduled = await this._deferWithSchedule(tier);
+        if (scheduled?.outcome) return scheduled;
+        return this._deferWithVisibility({
+            ...tier,
+            scheduleError: scheduled?.scheduleError,
+        });
+    }
+
+    async _deferWithDelay({
+        queueName,
+        body,
+        next,
+        error,
+        waitMs,
+        details,
+        state,
+    }) {
+        const delaySeconds = Math.ceil(waitMs / 1000);
+        try {
+            const queueUrl = await this._queueUrl(queueName);
+            await this.send({ ...next, QueueUrl: queueUrl }, delaySeconds);
+        } catch (cause) {
+            return { outcome: 'skipped', skipped: 'send_failed', cause };
         }
+        await this._recordWait(body, error, state('WAITING', 'delay'));
+        log.warn('Record deferred', {
+            eventName: 'frigg.worker.record_deferred',
+            mechanism: 'delay',
+            delaySeconds,
+            ...details,
+            error,
+        });
+        return { outcome: 'acked' };
+    }
 
-        let scheduleError;
+    /** `acked`, `{ scheduleError }` when the schedule failed, null with no scheduler. */
+    async _deferWithSchedule({
+        record,
+        body,
+        next,
+        error,
+        retryAt,
+        details,
+        state,
+    }) {
         const scheduler = this.getSchedulerService();
-        if (scheduler) {
-            const scheduleName = `frigg-defer-${
-                record.messageId || randomUUID()
-            }`;
-            try {
-                await scheduler.scheduleOneTime({
-                    scheduleName,
-                    scheduleAt: retryAt,
-                    queueResourceId: record.eventSourceARN,
-                    payload: next,
-                });
-            } catch (cause) {
-                if (cause?.name !== 'ConflictException') scheduleError = cause;
-            }
-            if (!scheduleError) {
-                await this._recordWait(
-                    body,
-                    error,
-                    state('WAITING', 'schedule')
-                );
-                log.warn('Record deferred', {
-                    eventName: 'frigg.worker.record_deferred',
-                    mechanism: 'schedule',
-                    scheduleName,
-                    ...details,
-                    error,
-                });
-                return { outcome: 'acked' };
-            }
+        if (!scheduler) return null;
+        const scheduleName = `frigg-defer-${record.messageId || randomUUID()}`;
+        try {
+            await scheduler.scheduleOneTime({
+                scheduleName,
+                scheduleAt: retryAt,
+                queueResourceId: record.eventSourceARN,
+                payload: next,
+            });
+        } catch (cause) {
+            if (cause?.name !== 'ConflictException')
+                return { scheduleError: cause };
         }
+        await this._recordWait(body, error, state('WAITING', 'schedule'));
+        log.warn('Record deferred', {
+            eventName: 'frigg.worker.record_deferred',
+            mechanism: 'schedule',
+            scheduleName,
+            ...details,
+            error,
+        });
+        return { outcome: 'acked' };
+    }
 
+    async _deferWithVisibility({
+        record,
+        queueName,
+        body,
+        error,
+        delivery,
+        waitMs,
+        details,
+        state,
+        scheduleError,
+    }) {
         const visibilityTimeout = Math.min(
             Math.ceil(waitMs / 1000),
             MAX_VISIBILITY_TIMEOUT_SECONDS
@@ -301,13 +342,17 @@ class Worker {
      * @param {Error} error The RateLimitError.
      * @param {{status: 'WAITING'|'EXHAUSTED', mechanism: string, deferrals: number, retryAt: Date}} state
      */
-    async recordRateLimitWait() {}
+    async recordRateLimitWait() {
+        // A subclass keeps the run state; nothing to do by default.
+    }
 
     /**
      * Hook: a message that was put back for a rate limit ran without error.
      * @param {Object} body The parsed message body.
      */
-    async clearRateLimitWait() {}
+    async clearRateLimitWait() {
+        // A subclass keeps the run state; nothing to do by default.
+    }
 
     _queueUrl(queueName) {
         this._queueUrls ??= new Map();
@@ -330,8 +375,8 @@ class Worker {
     }
 
     async _clearDeferredState(body, delivery) {
-        if (readDeferral(body).deferrals === 0 && !(delivery.receiveCount > 1))
-            return;
+        const redelivered = delivery.receiveCount > 1;
+        if (readDeferral(body).deferrals === 0 && !redelivered) return;
         await this._runStateHook('clear', () => this.clearRateLimitWait(body));
     }
 

package/handlers/backend-utils.js

@@ -22,6 +22,15 @@ const {
 } = require('../integrations/utils/map-integration-dto');
 const { processNotFound } = require('../integrations/use-cases/process-errors');
 
+const CLEAR_RATE_LIMIT_TOLERANCE_MS = 5_000;
+
+const keepsCurrentRateLimit = (current, next) => {
+    if (!current) return false;
+    if (next.status === 'EXHAUSTED') return false;
+    if (current.status === 'EXHAUSTED') return true;
+    return Date.parse(current.retryAt) > next.retryAt.getTime();
+};
+
 const loadRouterFromObject = (IntegrationClass, routerObject) => {
     const router = Router();
     const { path, method, event } = routerObject;
@@ -168,7 +177,11 @@ const createQueueWorker = (integrationClass) => {
         async recordRateLimitWait(body, error, state) {
             const processId = body.data?.processId;
             if (!processId) return;
-            await createProcessRepository().applyProcessUpdate(processId, {
+            const processRepository = createProcessRepository();
+            const process = await processRepository.findById(processId);
+            if (keepsCurrentRateLimit(process?.context?.rateLimit, state))
+                return;
+            await processRepository.applyProcessUpdate(processId, {
                 set: {
                     'context.rateLimit': {
                         status: state.status,
@@ -186,7 +199,13 @@ const createQueueWorker = (integrationClass) => {
         async clearRateLimitWait(body) {
             const processId = body?.data?.processId;
             if (!processId) return;
-            await createProcessRepository().applyProcessUpdate(processId, {
+            const processRepository = createProcessRepository();
+            const process = await 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;
+            await processRepository.applyProcessUpdate(processId, {
                 set: { 'context.rateLimit': null },
             });
         }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.657.8f335eb.0",
+    "version": "2.0.0--canary.657.b14221f.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.8f335eb.0",
-        "@friggframework/prettier-config": "2.0.0--canary.657.8f335eb.0",
-        "@friggframework/test": "2.0.0--canary.657.8f335eb.0",
+        "@friggframework/eslint-config": "2.0.0--canary.657.b14221f.0",
+        "@friggframework/prettier-config": "2.0.0--canary.657.b14221f.0",
+        "@friggframework/test": "2.0.0--canary.657.b14221f.0",
         "@prisma/client": "^6.19.3",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -90,5 +90,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "8f335eb16f678038ad9448d9603c734ad663b3dc"
+    "gitHead": "b14221fca51737284a61407b42e003637930465e"
 }