@zerotal/queue 1.7.0 → 1.7.3

package/CHANGELOG.md

@@ -8,6 +8,23 @@ follows the Zerotal monorepo's unified versioning.
 
 ## [Unreleased]
 
+### Fixed
+
+- **`queue:work` listened on one hardcoded queue, so queued notifications were never sent.**
+  The `--queue` flag defaulted to the literal string `"default"` and the command never read
+  `queue.queues` — the key `QueueProvider`'s in-process pool has always used. A job may pin its
+  own queue, and `SendNotificationJob` sets `"notifications"`, so following both documented
+  steps — `Notify.queue(user, notification)`, then `bun zt queue:work` — put the mail on a queue
+  nobody was reading. Nothing errored. The job sat as pending forever and the worker reported
+  "Queue is empty."
+
+  With no `--queue`, the worker now drains every queue in `queue.queues`, falling back to
+  `["default"]`. The flag still overrides it and now accepts a comma-separated list
+  (`--queue=emails,reports`) in priority order, so one worker can take a subset without a second
+  process. `--once` stops at the first queue with a claimable job rather than taking one job per
+  queue, and the idle sleep is only taken when _no_ queue had anything — sleeping after the first
+  empty one would leave a busy second queue waiting out the poll interval.
+
 ## [1.5.0] — 2026-08-15
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zerotal/queue",
-  "version": "1.7.0",
+  "version": "1.7.3",
   "license": "MIT",
   "maturity": "stable",
   "private": false,
@@ -31,8 +31,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@zerotal/core": "1.7.0",
-    "@zerotal/orm": "1.7.0"
+    "@zerotal/core": "1.7.3",
+    "@zerotal/orm": "1.7.3"
   },
   "devDependencies": {
     "typescript": "^5.8.0"

package/src/commands/QueueWorkCommand.ts

@@ -1,5 +1,6 @@
 import type { Application } from "@zerotal/core";
 import { Command } from "@zerotal/core";
+import type { ConfigManager } from "@zerotal/core/config";
 import type { QueueManager } from "../QueueManager.ts";
 
 export class QueueWorkCommand extends Command {
@@ -12,8 +13,8 @@ export class QueueWorkCommand extends Command {
       name: "queue",
       short: "q",
       type: "string" as const,
-      description: "Queue name to process",
-      default: "default",
+      description: "Queue name(s) to process, comma-separated. Defaults to config queue.queues",
+      default: "",
     },
     {
       name: "once",
@@ -23,8 +24,35 @@ export class QueueWorkCommand extends Command {
     },
   ];
 
+  /**
+   * The queues to drain: the flag if given, else the app's own `queue.queues`.
+   *
+   * Defaulting to the literal string `"default"` was a silent delivery failure.
+   * A job may pin its own queue — `SendNotificationJob` sets `"notifications"` —
+   * and `config/queue.ts` lists exactly that queue so the in-process pool drains
+   * it (`QueueProvider` reads this same key and loops over every entry). But this
+   * command ignored the config and listened on `"default"` alone, so following
+   * both documented steps — `Notify.queue(...)`, then `zt queue:work` — queued
+   * the mail and then never sent it. Nothing errors: the job sits in a queue
+   * nobody is reading, forever.
+   *
+   * Comma-separated, so one worker can take a subset without a second process.
+   * Order is priority order, matching the provider's loop.
+   */
+  private targetQueues(app: Application): string[] {
+    const flag = ((this.flags["queue"] as string) ?? "").trim();
+    if (flag) {
+      const named = flag
+        .split(",")
+        .map((q) => q.trim())
+        .filter(Boolean);
+      if (named.length) return named;
+    }
+    const config = app.container.makeSync("config") as ConfigManager;
+    return config.get<string[]>("queue.queues", ["default"]);
+  }
+
   async run(): Promise<void> {
-    const queueName = this.flags["queue"] as string;
     const once = this.flags["once"] as boolean;
     const app = this.app as Application | undefined;
     if (!app) {
@@ -33,22 +61,36 @@ export class QueueWorkCommand extends Command {
     }
 
     const manager = app.container.makeSync("queue") as QueueManager;
+    const queues = this.targetQueues(app);
 
     if (once) {
-      const processed = await manager.processNext(queueName);
-      this.info(processed ? "Processed 1 job." : "Queue is empty.");
+      // The first queue with anything claimable wins, so `--once` drains one job
+      // rather than one job *per queue*.
+      for (const q of queues) {
+        if (await manager.processNext(q)) {
+          this.info("Processed 1 job.");
+          return;
+        }
+      }
+      this.info("Queue is empty.");
       return;
     }
 
-    this.info(`Processing queue "${queueName}" — Ctrl+C to stop.`);
+    this.info(`Processing queue(s) [${queues.join(", ")}] — Ctrl+C to stop.`);
     while (!manager.isShuttingDown) {
       // Sleep whenever nothing was *claimable* this tick — not merely when the
       // queue is empty. size() counts not-yet-due delayed jobs and jobs reserved
       // by other workers, so keying the sleep off size() busy-spins at 100% CPU
       // whenever a delayed/reserved job exists but nothing is ready.
-      const processed = await manager
-        .processNext(queueName)
-        .catch((err) => (console.error(err), false));
+      //
+      // "Nothing claimable" means across every queue: sleeping after the first
+      // empty one would leave a busy second queue waiting out the poll interval.
+      let processed = false;
+      for (const q of queues) {
+        if (manager.isShuttingDown) break;
+        const did = await manager.processNext(q).catch((err) => (console.error(err), false));
+        processed = processed || did;
+      }
       if (!processed) {
         await new Promise<void>((r) => setTimeout(r, 500));
       }