bunqueue 2.8.53 → 2.8.56

package/dist/client/queue/jobMove.js

@@ -5,13 +5,28 @@
 import { getSharedManager } from '../manager';
 import { jobId } from '../../domain/types/job';
 import { buildFailCommand, failEmbeddedArgs } from './failWire';
+function responseError(response, fallback) {
+    return new Error(typeof response.error === 'string' ? response.error : fallback);
+}
+function throwTokenResponse(response) {
+    if (response.ok === false && /token/i.test(String(response.error))) {
+        throw responseError(response, 'Invalid lock token');
+    }
+}
 /** Move job to completed state */
-export async function moveJobToCompleted(ctx, id, returnValue, _token) {
+export async function moveJobToCompleted(ctx, id, returnValue, token) {
     if (ctx.embedded) {
-        await getSharedManager().ack(jobId(id), returnValue);
+        await getSharedManager().ack(jobId(id), returnValue, token);
         return null;
     }
-    await ctx.tcp.send({ cmd: 'ACK', id, result: returnValue });
+    const response = await ctx.tcp.send({
+        cmd: 'ACK',
+        id,
+        result: returnValue,
+        ...(token === undefined ? {} : { token }),
+    });
+    if (response.ok !== true)
+        throw responseError(response, 'Failed to complete job');
     return null;
 }
 /** Move job to failed state */
@@ -24,11 +39,13 @@ export async function moveJobToFailed(ctx, id, error, token) {
         await getSharedManager().fail(jobId(id), ...failEmbeddedArgs(error, token));
     }
     else {
-        await ctx.tcp.send(buildFailCommand(id, error, token));
+        const response = await ctx.tcp.send(buildFailCommand(id, error, token));
+        if (response.ok !== true)
+            throw responseError(response, 'Failed to fail job');
     }
 }
 /** Move job back to waiting state */
-export async function moveJobToWait(ctx, id, _token) {
+export async function moveJobToWait(ctx, id, token) {
     if (ctx.embedded) {
         const manager = getSharedManager();
         const state = await ctx.getJobState(id);
@@ -42,7 +59,7 @@ export async function moveJobToWait(ctx, id, _token) {
         }
         if (state === 'active') {
             // Job is being processed - move back to queue
-            return manager.moveActiveToWait(jobId(id));
+            return manager.moveActiveToWait(jobId(id), token);
         }
         if (state === 'delayed') {
             // Delayed job - promote to waiting
@@ -54,11 +71,16 @@ export async function moveJobToWait(ctx, id, _token) {
         }
         return false;
     }
-    const response = await ctx.tcp.send({ cmd: 'MoveToWait', id });
+    const response = await ctx.tcp.send({
+        cmd: 'MoveToWait',
+        id,
+        ...(token === undefined ? {} : { token }),
+    });
+    throwTokenResponse(response);
     return response.ok === true;
 }
 /** Move job to delayed state */
-export async function moveJobToDelayed(ctx, id, timestamp, _token) {
+export async function moveJobToDelayed(ctx, id, timestamp, token) {
     if (ctx.embedded) {
         const delay = Math.max(0, timestamp - Date.now());
         const manager = getSharedManager();
@@ -70,16 +92,16 @@ export async function moveJobToDelayed(ctx, id, timestamp, _token) {
                 return;
             const count = manager.retryDlq(job.queue, jobId(id));
             if (count > 0 && delay > 0) {
-                await manager.changeWaitingDelay(jobId(id), delay);
+                await manager.changeDelay(jobId(id), delay, token);
             }
         }
         else if (state === 'waiting' || state === 'prioritized' || state === 'delayed') {
             // Job is in queue - update its runAt directly
-            await manager.changeWaitingDelay(jobId(id), delay);
+            await manager.changeDelay(jobId(id), delay, token);
         }
         else {
             // Active or other state - use existing changeDelay (handles processing)
-            await manager.changeDelay(jobId(id), delay);
+            await manager.changeDelay(jobId(id), delay, token);
         }
     }
     else {
@@ -90,40 +112,61 @@ export async function moveJobToDelayed(ctx, id, timestamp, _token) {
         // was re-queued as `waiting` with the delay dropped) or a silent no-op (a
         // waiting job). Convert to relative delay here so the wire field matches.
         const delay = Math.max(0, timestamp - Date.now());
-        const response = await ctx.tcp.send({ cmd: 'MoveToDelayed', id, delay });
+        const response = await ctx.tcp.send({
+            cmd: 'MoveToDelayed',
+            id,
+            delay,
+            ...(token === undefined ? {} : { token }),
+        });
         // Surface server-side failures instead of silently ignoring the response
         // (e.g. the job was completed/removed before the command arrived).
         if (response.ok === false) {
-            throw new Error(typeof response.error === 'string' ? response.error : 'Failed to move job to delayed');
+            throw responseError(response, 'Failed to move job to delayed');
         }
     }
 }
 /** Move job to waiting-children state */
-export async function moveJobToWaitingChildren(ctx, id, _token, _opts) {
+export async function moveJobToWaitingChildren(ctx, id, token, _opts) {
     if (ctx.embedded) {
         const manager = getSharedManager();
-        return manager.moveToWaitingChildren(jobId(id));
+        return manager.moveToWaitingChildren(jobId(id), token);
     }
-    return false;
+    if (!ctx.tcp)
+        return false;
+    const response = await ctx.tcp.send({
+        cmd: 'MoveToWaitingChildren',
+        id,
+        ...(token === undefined ? {} : { token }),
+    });
+    throwTokenResponse(response);
+    if (!response.ok)
+        return false;
+    return response.data?.moved ?? true;
 }
 /** Wait until job has finished */
 export async function waitJobUntilFinished(ctx, id, queueEvents, ttl) {
     return new Promise((resolve, reject) => {
+        let settled = false;
         const timeout = ttl
             ? setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
                 cleanup();
                 reject(new Error(`Job ${id} timed out after ${ttl}ms`));
             }, ttl)
             : null;
         const events = queueEvents;
         const completedHandler = (data) => {
-            if (data.jobId === id) {
+            if (data.jobId === id && !settled) {
+                settled = true;
                 cleanup();
                 resolve(data.returnvalue);
             }
         };
         const failedHandler = (data) => {
-            if (data.jobId === id) {
+            if (data.jobId === id && !settled) {
+                settled = true;
                 cleanup();
                 reject(new Error(data.failedReason ?? 'Job failed'));
             }
@@ -136,22 +179,42 @@ export async function waitJobUntilFinished(ctx, id, queueEvents, ttl) {
         };
         events.on('completed', completedHandler);
         events.on('failed', failedHandler);
-        // Check if job is already finished
-        void ctx.getJobState(id).then((state) => {
+        const checkFinishedState = async () => {
+            const state = await ctx.getJobState(id);
+            if (settled)
+                return;
             if (state === 'completed') {
-                cleanup();
+                let result;
                 if (ctx.embedded) {
-                    const result = getSharedManager().getResult(jobId(id));
-                    resolve(result);
+                    result = getSharedManager().getResult(jobId(id));
                 }
                 else {
-                    resolve(undefined);
+                    if (!ctx.tcp)
+                        throw new Error('Queue TCP connection is unavailable');
+                    const response = await ctx.tcp.send({ cmd: 'GetResult', id });
+                    if (response.ok !== true) {
+                        throw new Error(typeof response.error === 'string' ? response.error : 'Failed to read job result');
+                    }
+                    result = response.result;
                 }
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(result);
             }
             else if (state === 'failed') {
+                settled = true;
                 cleanup();
                 reject(new Error('Job already failed'));
             }
+        };
+        void checkFinishedState().catch((error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error instanceof Error ? error : new Error(String(error)));
         });
     });
 }

package/dist/client/queue/jobProxy.d.ts

@@ -1,50 +1,4 @@
-/**
- * Job Proxy
- * Creates Job objects with methods for TCP and embedded modes
- */
-import type { Job, JobOptions } from '../types';
-import type { TcpConnectionPool } from '../tcpPool';
-import type { JobStateType } from '../types';
-interface JobProxyContext {
-    queueName: string;
-    tcp: TcpConnectionPool;
-    getJobState: (id: string) => Promise<JobStateType>;
-    removeAsync: (id: string) => Promise<void>;
-    retryJob: (id: string) => Promise<void>;
-    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
-}
-/**
- * Options actually requested for the job, so the returned Job object reflects
- * them (priority, delay, opts) instead of hardcoded defaults. See issue #88.
- */
-export interface JobReflectionMeta {
-    priority?: number;
-    delay?: number;
-    opts?: JobOptions;
-    timestamp?: number;
-    /** Persisted stacktrace of the last failure, from the server/manager job (#74) */
-    stacktrace?: string[] | null;
-    /** Last failure's error message, derived from the job timeline (#74) */
-    failedReason?: string;
-}
-/** Create a full Job proxy with TCP methods */
-export declare function createJobProxy<T>(id: string, name: string, data: T, ctx: JobProxyContext, meta?: JobReflectionMeta): Job<T>;
-export interface SimpleJobContext {
-    queueName: string;
-    /** Execution mode — determines whether to use embedded manager or TCP */
-    embedded?: boolean;
-    /** TCP connection pool, required when !embedded */
-    tcp?: TcpConnectionPool | null;
-    getJobState: (id: string) => Promise<JobStateType>;
-    removeAsync: (id: string) => Promise<void>;
-    retryJob: (id: string) => Promise<void>;
-    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
-    /** Requested options to reflect on the returned job (priority/delay/opts) — #88 */
-    meta?: JobReflectionMeta;
-}
-/**
- * Create a simple Job with all BullMQ v5 methods wired.
- * Used by Queue.getJob / getJobs in both embedded and TCP modes.
- */
-export declare function createSimpleJob<T>(id: string, name: string, data: T, timestamp: number, ctx: SimpleJobContext): Job<T>;
-export {};
+/** Stable Job proxy import surface. */
+export { createSimpleJob } from './job-proxy/simple';
+export { createJobProxy } from './job-proxy/tcp';
+export type { JobReflectionMeta, SimpleJobContext } from './types/job';