groupmq-plus 1.1.0 → 1.1.1

package/dist/index.cjs

@@ -281,6 +281,13 @@ var Job = class Job {
 	async update(jobData) {
 		await this.updateData(jobData);
 	}
+	/**
+	* Wait until this job is completed or failed.
+	* @param timeoutMs Optional timeout in milliseconds (0 = no timeout)
+	*/
+	async waitUntilFinished(timeoutMs = 0) {
+		return this.queue.waitUntilFinished(this.id, timeoutMs);
+	}
 	static fromReserved(queue, reserved, meta) {
 		return new Job({
 			queue,
@@ -474,6 +481,8 @@ function safeJsonParse(input) {
 var Queue = class {
 	constructor(opts) {
 		this._consecutiveEmptyReserves = 0;
+		this.eventsSubscribed = false;
+		this.waitingJobs = /* @__PURE__ */ new Map();
 		this.promoterRunning = false;
 		this.batchBuffer = [];
 		this.flushing = false;
@@ -1322,6 +1331,91 @@ var Queue = class {
 	async getJob(id) {
 		return Job.fromStore(this, id);
 	}
+	async setupSubscriber() {
+		if (this.eventsSubscribed && this.subscriber) return;
+		if (!this.subscriber) {
+			this.subscriber = this.r.duplicate();
+			this.subscriber.on("message", (channel, message) => {
+				if (channel === `${this.ns}:events`) this.handleJobEvent(message);
+			});
+			this.subscriber.on("error", (err) => {
+				this.logger.error("Redis error (events subscriber):", err);
+			});
+		}
+		await this.subscriber.subscribe(`${this.ns}:events`);
+		this.eventsSubscribed = true;
+	}
+	handleJobEvent(message) {
+		try {
+			const event = safeJsonParse(message);
+			if (!event || typeof event.id !== "string") return;
+			const waiters = this.waitingJobs.get(event.id);
+			if (!waiters || waiters.length === 0) return;
+			if (event.status === "completed") {
+				const parsed = typeof event.result === "string" ? safeJsonParse(event.result) ?? event.result : event.result;
+				waiters.forEach((w) => w.resolve(parsed));
+			} else if (event.status === "failed") {
+				const info = typeof event.result === "string" ? safeJsonParse(event.result) ?? {} : event.result ?? {};
+				const err = new Error(info && info.message || "Job failed");
+				if (info && typeof info === "object") {
+					if (typeof info.name === "string") err.name = info.name;
+					if (typeof info.stack === "string") err.stack = info.stack;
+				}
+				waiters.forEach((w) => w.reject(err));
+			}
+			this.waitingJobs.delete(event.id);
+		} catch (err) {
+			this.logger.error("Failed to process job event:", err);
+		}
+	}
+	/**
+	* Wait for a job to complete or fail, similar to BullMQ's waitUntilFinished.
+	*/
+	async waitUntilFinished(jobId, timeoutMs = 0) {
+		const job = await this.getJob(jobId);
+		const state = await job.getState();
+		if (state === "completed") return job.returnvalue;
+		if (state === "failed") throw new Error(job.failedReason || "Job failed");
+		await this.setupSubscriber();
+		return new Promise((resolve, reject) => {
+			let timer;
+			let waiter;
+			const cleanup = () => {
+				if (timer) clearTimeout(timer);
+				const current = this.waitingJobs.get(jobId);
+				if (!current) return;
+				const remaining = current.filter((w) => w !== waiter);
+				if (remaining.length === 0) this.waitingJobs.delete(jobId);
+				else this.waitingJobs.set(jobId, remaining);
+			};
+			const wrappedResolve = (value) => {
+				cleanup();
+				resolve(value);
+			};
+			const wrappedReject = (err) => {
+				cleanup();
+				reject(err);
+			};
+			waiter = {
+				resolve: wrappedResolve,
+				reject: wrappedReject
+			};
+			const waiters = this.waitingJobs.get(jobId) ?? [];
+			waiters.push(waiter);
+			this.waitingJobs.set(jobId, waiters);
+			if (timeoutMs > 0) timer = setTimeout(() => {
+				wrappedReject(/* @__PURE__ */ new Error(`Timed out waiting for job ${jobId} to finish`));
+			}, timeoutMs);
+			(async () => {
+				try {
+					const latest = await this.getJob(jobId);
+					const latestState = await latest.getState();
+					if (latestState === "completed") wrappedResolve(latest.returnvalue);
+					else if (latestState === "failed") wrappedReject(new Error(latest.failedReason ?? "Job failed"));
+				} catch (_err) {}
+			})();
+		});
+	}
 	/**
 	* Fetch jobs by statuses, emulating BullMQ's Queue.getJobs API used by BullBoard.
 	* Only getter functionality; ordering is best-effort.
@@ -1516,6 +1610,25 @@ var Queue = class {
 			await this.flushBatch();
 		}
 		await this.stopPromoter();
+		if (this.subscriber) {
+			try {
+				await this.subscriber.unsubscribe(`${this.ns}:events`);
+				await this.subscriber.quit();
+			} catch (_err) {
+				try {
+					this.subscriber.disconnect();
+				} catch (_e) {}
+			}
+			this.subscriber = void 0;
+			this.eventsSubscribed = false;
+		}
+		if (this.waitingJobs.size > 0) {
+			const err = /* @__PURE__ */ new Error("Queue closed");
+			this.waitingJobs.forEach((waiters) => {
+				waiters.forEach((w) => w.reject(err));
+			});
+			this.waitingJobs.clear();
+		}
 		try {
 			await this.r.quit();
 		} catch (_e) {
@@ -1943,6 +2056,12 @@ var AsyncFifoQueue = class {
 
 //#endregion
 //#region src/worker.ts
+var UnrecoverableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnrecoverableError";
+	}
+};
 var TypedEventEmitter = class {
 	constructor() {
 		this.listeners = /* @__PURE__ */ new Map();
@@ -1978,7 +2097,7 @@ var TypedEventEmitter = class {
 		return this;
 	}
 };
-const defaultBackoff = (attempt) => {
+const defaultBackoff = (attempt, _error) => {
 	const base = Math.min(3e4, 2 ** (attempt - 1) * 500);
 	const jitter = Math.floor(base * .25 * Math.random());
 	return base + jitter;
@@ -2491,7 +2610,12 @@ var _Worker = class extends TypedEventEmitter {
 			status: "failed"
 		}));
 		const nextAttempt = job.attempts + 1;
-		const backoffMs = this.backoff(nextAttempt);
+		if (err instanceof UnrecoverableError) {
+			this.logger.info(`Unrecoverable error for job ${job.id}: ${err instanceof Error ? err.message : String(err)}. Skipping retries.`);
+			await this.deadLetterJob(err, job, jobStartWallTime, failedAt, nextAttempt);
+			return;
+		}
+		const backoffMs = this.backoff(nextAttempt, err);
 		if (nextAttempt >= this.maxAttempts) {
 			await this.deadLetterJob(err, job, jobStartWallTime, failedAt, nextAttempt);
 			return;
@@ -2561,6 +2685,7 @@ function sleep(ms) {
 exports.BullBoardGroupMQAdapter = BullBoardGroupMQAdapter;
 exports.Job = Job;
 exports.Queue = Queue;
+exports.UnrecoverableError = UnrecoverableError;
 exports.Worker = Worker;
 exports.getWorkersStatus = getWorkersStatus;
 exports.waitForQueueToEmpty = waitForQueueToEmpty;