@holo-js/queue-redis 0.1.4 → 0.1.5

package/dist/index.d.ts

@@ -104,10 +104,14 @@ declare class RedisQueueDriver implements QueueAsyncDriver {
     private readonly managedRedisConnection?;
     private readonly queues;
     private readonly workers;
+    private readonly workerReadyPromises;
     private readonly reservations;
     private queueCursor;
     constructor(connection: NormalizedQueueRedisConnectionConfig, context: QueueDriverFactoryContext);
     private getQueue;
+    private createWorkerKey;
+    private normalizeReserveBlockFor;
+    private resolveWorkerDrainDelay;
     private getWorker;
     private normalizeQueueNames;
     private rotateQueueNames;
@@ -116,8 +120,9 @@ declare class RedisQueueDriver implements QueueAsyncDriver {
     private settleReservation;
     dispatch<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<QueueDriverDispatchResult<TResult>>;
     reserve<TPayload extends QueueJsonValue = QueueJsonValue>(input: {
-        readonly queueNames: readonly string[];
-        readonly workerId: string;
+        readonly queueNames?: readonly string[];
+        readonly workerId?: string;
+        readonly timeout?: number;
     }): Promise<QueueReservedJob<TPayload> | null>;
     acknowledge(job: QueueReservedJob): Promise<void>;
     release(job: QueueReservedJob, options?: QueueReleaseOptions): Promise<void>;

package/dist/index.mjs

@@ -140,6 +140,7 @@ var RedisQueueDriver = class {
   managedRedisConnection;
   queues = /* @__PURE__ */ new Map();
   workers = /* @__PURE__ */ new Map();
+  workerReadyPromises = /* @__PURE__ */ new Map();
   reservations = /* @__PURE__ */ new Map();
   queueCursor = 0;
   getQueue(queueName) {
@@ -157,10 +158,30 @@ var RedisQueueDriver = class {
     this.queues.set(queueName, queue);
     return queue;
   }
-  async getWorker(queueName) {
-    const cached = this.workers.get(queueName);
+  createWorkerKey(queueName, blockFor) {
+    return `${queueName}:${blockFor}`;
+  }
+  normalizeReserveBlockFor(timeout) {
+    if (typeof timeout === "undefined") {
+      return this.connection.blockFor;
+    }
+    if (!Number.isFinite(timeout) || timeout < 0) {
+      throw new Error("[Holo Queue] Redis queue reservation timeout must be a non-negative finite number when provided.");
+    }
+    return timeout;
+  }
+  resolveWorkerDrainDelay(blockFor) {
+    return blockFor > 0 ? blockFor : 1;
+  }
+  async getWorker(queueName, blockFor = this.connection.blockFor) {
+    const workerKey = this.createWorkerKey(queueName, blockFor);
+    const pending = this.workerReadyPromises.get(workerKey);
+    if (pending) {
+      return (await pending).worker;
+    }
+    const cached = this.workers.get(workerKey);
     if (cached) {
-      return cached;
+      return cached.worker;
     }
     const worker = new BullWorker(
       queueName,
@@ -169,22 +190,40 @@ var RedisQueueDriver = class {
         autorun: false,
         concurrency: 1,
         connection: this.bullConnection,
-        drainDelay: this.connection.blockFor,
+        drainDelay: this.resolveWorkerDrainDelay(blockFor),
         lockDuration: this.connection.retryAfter * 1e3,
         removeOnComplete: { count: 0 },
         removeOnFail: { count: 0 }
       }
     );
-    await worker.waitUntilReady();
-    this.workers.set(queueName, worker);
-    return worker;
+    const workerRecord = {
+      queueName,
+      worker
+    };
+    const ready = worker.waitUntilReady().then(() => workerRecord).catch(async (error) => {
+      if (this.workers.get(workerKey) === workerRecord) {
+        this.workers.delete(workerKey);
+      }
+      try {
+        await worker.close(true);
+      } catch {
+      }
+      throw error;
+    }).finally(() => {
+      if (this.workerReadyPromises.get(workerKey) === ready) {
+        this.workerReadyPromises.delete(workerKey);
+      }
+    });
+    this.workers.set(workerKey, workerRecord);
+    this.workerReadyPromises.set(workerKey, ready);
+    return (await ready).worker;
   }
   normalizeQueueNames(queueNames) {
     if (!queueNames || queueNames.length === 0) {
       return [.../* @__PURE__ */ new Set([
         this.connection.queue,
         ...this.queues.keys(),
-        ...this.workers.keys()
+        ...[...this.workers.values()].map((worker) => worker.queueName)
       ])];
     }
     return [...new Set(queueNames)];
@@ -242,9 +281,8 @@ var RedisQueueDriver = class {
       await callback(reservation);
     } catch (error) {
       throw wrapRedisError(this.name, action, error);
-    } finally {
-      this.reservations.delete(reserved.reservationId);
     }
+    this.reservations.delete(reserved.reservationId);
   }
   async dispatch(job) {
     try {
@@ -268,8 +306,10 @@ var RedisQueueDriver = class {
   async reserve(input) {
     try {
       const queueNames = this.rotateQueueNames(this.normalizeQueueNames(input.queueNames));
+      const workerId = input.workerId ?? this.name;
+      const blockFor = this.normalizeReserveBlockFor(input.timeout);
       for (const queueName of queueNames) {
-        const token2 = `${input.workerId}:${randomUUID()}`;
+        const token2 = `${workerId}:${randomUUID()}`;
         const worker2 = await this.getWorker(queueName);
         const job2 = await worker2.getNextJob(token2, { block: false });
         if (job2) {
@@ -277,11 +317,11 @@ var RedisQueueDriver = class {
         }
       }
       const [blockingQueue] = queueNames;
-      if (!blockingQueue || this.connection.blockFor <= 0) {
+      if (!blockingQueue || blockFor <= 0) {
         return null;
       }
-      const token = `${input.workerId}:${randomUUID()}`;
-      const worker = await this.getWorker(blockingQueue);
+      const token = `${workerId}:${randomUUID()}`;
+      const worker = await this.getWorker(blockingQueue, blockFor);
       const job = await worker.getNextJob(token, { block: true });
       if (!job) {
         return null;
@@ -327,10 +367,12 @@ var RedisQueueDriver = class {
   }
   async close() {
     const resources = [
-      ...this.workers.values(),
+      ...[...this.workers.values()].map((worker) => worker.worker),
       ...this.queues.values()
     ];
+    const workerReadyPromises = [...this.workerReadyPromises.values()];
     this.reservations.clear();
+    this.workerReadyPromises.clear();
     this.workers.clear();
     this.queues.clear();
     let closeRejection;
@@ -342,6 +384,7 @@ var RedisQueueDriver = class {
         }
         await resource.close();
       }));
+      await Promise.allSettled(workerReadyPromises);
       closeRejection = results.find((result) => result.status === "rejected");
     } finally {
       if (this.managedRedisConnection) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/queue-redis",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Holo-JS Framework - Redis queue driver",
   "type": "module",
   "license": "MIT",
@@ -23,18 +23,18 @@
     "test": "vitest --run"
   },
   "peerDependencies": {
-    "@holo-js/queue": "^0.1.4"
+    "@holo-js/queue": "^0.1.5"
   },
   "dependencies": {
     "bullmq": "^5.71.0",
-    "ioredis": "catalog:",
+    "ioredis": "^5.4.2",
     "tslib": "^2.8.1"
   },
   "devDependencies": {
-    "@holo-js/queue": "workspace:*",
+    "@holo-js/queue": "^0.1.5",
     "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.5"
   }
 }