@zudojs/queue 1.0.0 → 1.1.0

package/dist/worker/worker.core.js

@@ -17,6 +17,7 @@ export function createWorker(id, queue, options) {
     const drainTimeout = options?.drainTimeout ?? DEFAULT_DRAIN_TIMEOUT_MS;
     let pollTimer = null;
     let activeJobs = 0;
+    let polling = false;
     let abortController = null;
     const onError = options?.onError ??
         ((error) => {
@@ -24,10 +25,20 @@ export function createWorker(id, queue, options) {
                 console.error(`[@zudojs/queue] Worker "${id}" poll failed.`, error);
             });
         });
+    /**
+     * Arms the next poll. At most one timer is ever armed: a delayed poll
+     * already pending is left alone, while an immediate poll (capacity just
+     * freed up, or a job was just dispatched) supersedes it.
+     */
     const scheduleNextPoll = (delay) => {
         if (state !== WorkerState.RUNNING) {
             return;
         }
+        if (pollTimer !== null) {
+            if (delay > 0)
+                return;
+            clearTimeout(pollTimer);
+        }
         pollTimer = setTimeout(runPoll, delay);
         pollTimer.unref?.();
     };
@@ -37,34 +48,20 @@ export function createWorker(id, queue, options) {
      * fatal, would take down the whole application.
      */
     const runPoll = () => {
+        pollTimer = null;
         void poll().catch((error) => {
             onError(error);
             scheduleNextPoll(pollInterval);
         });
     };
-    const poll = async () => {
-        if (state !== WorkerState.RUNNING || abortController?.signal.aborted) {
-            return;
-        }
-        if (activeJobs >= concurrency) {
-            scheduleNextPoll(pollInterval);
-            return;
-        }
-        const job = await queue.claimNextJob();
-        if (!job) {
-            scheduleNextPoll(pollInterval);
-            return;
-        }
-        const proc = queue.getProcessor(job.name);
-        if (!proc) {
-            // Claimed but unrunnable: release it rather than stranding it in
-            // `active` where nothing would ever pick it up again.
-            await queue.releaseJob(job.id);
-            scheduleNextPoll(pollInterval);
-            return;
-        }
-        activeJobs++;
-        stats.processed++;
+    /**
+     * Runs one claimed job to completion and frees its concurrency slot.
+     *
+     * Deliberately not awaited by `poll`: awaiting it there serialised the
+     * worker, so `concurrency` was reported by `getStats()` and honoured by
+     * nothing.
+     */
+    const runClaimedJob = async (job) => {
         try {
             // Dispatch through the queue rather than invoking the processor
             // directly. The queue owns job state, retry, dead-lettering and
@@ -91,11 +88,47 @@ export function createWorker(id, queue, options) {
         }
         finally {
             activeJobs--;
-            // Poll again immediately while there is capacity, but yield to the
-            // event loop first so a saturated queue cannot starve timers.
+            // A slot just opened: poll again immediately, yielding to the event
+            // loop first so a saturated queue cannot starve timers.
             scheduleNextPoll(0);
         }
     };
+    const poll = async () => {
+        if (polling ||
+            state !== WorkerState.RUNNING ||
+            abortController?.signal.aborted) {
+            return;
+        }
+        polling = true;
+        try {
+            if (activeJobs >= concurrency) {
+                scheduleNextPoll(pollInterval);
+                return;
+            }
+            const job = await queue.claimNextJob();
+            if (!job) {
+                scheduleNextPoll(pollInterval);
+                return;
+            }
+            const proc = queue.getProcessor(job.name);
+            if (!proc) {
+                // Claimed but unrunnable: release it rather than stranding it in
+                // `active` where nothing would ever pick it up again.
+                await queue.releaseJob(job.id);
+                scheduleNextPoll(pollInterval);
+                return;
+            }
+            activeJobs++;
+            stats.processed++;
+            void runClaimedJob(job);
+            // Capacity may remain: look for more work now, not after this job
+            // settles.
+            scheduleNextPoll(0);
+        }
+        finally {
+            polling = false;
+        }
+    };
     const clearPollTimer = () => {
         if (pollTimer) {
             clearTimeout(pollTimer);
@@ -138,13 +171,18 @@ export function createWorker(id, queue, options) {
             }
             state = WorkerState.DRAINING;
             clearPollTimer();
-            abortController?.abort();
+            // Graceful means graceful: in-flight jobs get `drainTimeout` to
+            // finish on their own. Aborting them up front — as this once did —
+            // made `stop()` indistinguishable from `forceStop()` for any
+            // processor that honours its signal, and turned every routine
+            // shutdown into a batch of failed jobs.
             const deadline = Date.now() + Math.max(0, drainTimeout);
             while (activeJobs > 0 && Date.now() < deadline) {
                 await new Promise((resolve) => setTimeout(resolve, 25));
             }
             if (activeJobs > 0) {
                 onError(new WorkerLifecycleError(`Worker "${id}" still had ${activeJobs} job(s) in flight after ${drainTimeout}ms; forcing stop.`, { workerId: id }));
+                abortController?.abort();
             }
             clearPollTimer();
             state = WorkerState.STOPPED;

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@zudojs/queue",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Background job and asynchronous task infrastructure with in-memory and adapter-based queue implementations.",
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -21,9 +25,9 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/errors": "1.0.0",
-    "@zudojs/constants": "1.0.0",
-    "@zudojs/serialization": "1.0.0"
+    "@zudojs/errors": "1.0.1",
+    "@zudojs/constants": "1.0.1",
+    "@zudojs/serialization": "1.0.1"
   },
   "devDependencies": {
     "typescript": "7.0.2",