bunqueue 2.8.0 → 2.8.2

package/dist/client/queue/jobProxy.js

@@ -2,10 +2,28 @@
  * Job Proxy
  * Creates Job objects with methods for TCP and embedded modes
  */
+import { getSharedManager } from '../manager';
+import { jobId } from '../../domain/types/job';
+function reflectFields(id, queueName, meta) {
+    const opts = meta?.opts ?? {};
+    const p = opts.parent;
+    const repeat = opts.repeat;
+    const pattern = repeat?.pattern ?? (repeat?.every ? `every:${repeat.every}` : '');
+    return {
+        delay: meta?.delay ?? 0,
+        priority: meta?.priority ?? 0,
+        opts,
+        deduplicationId: opts.jobId ?? opts.deduplication?.id,
+        parentKey: p ? `${p.queue}:${p.id}` : undefined,
+        parent: p ? { id: p.id, queueQualifiedName: p.queue } : undefined,
+        repeatJobKey: repeat ? `${queueName}:${id}:${pattern}` : undefined,
+    };
+}
 /** Create a full Job proxy with TCP methods */
-export function createJobProxy(id, name, data, ctx) {
+export function createJobProxy(id, name, data, ctx, meta) {
     const { tcp, queueName } = ctx;
-    const ts = Date.now();
+    const ts = meta?.timestamp ?? Date.now();
+    const r = reflectFields(id, queueName, meta);
     return {
         id,
         name,
@@ -14,18 +32,19 @@ export function createJobProxy(id, name, data, ctx) {
         attemptsMade: 0,
         timestamp: ts,
         progress: 0,
-        delay: 0,
+        delay: r.delay,
         processedOn: undefined,
         finishedOn: undefined,
         stacktrace: null,
         stalledCounter: 0,
-        priority: 0,
-        parentKey: undefined,
-        opts: {},
+        priority: r.priority,
+        parent: r.parent,
+        parentKey: r.parentKey,
+        opts: r.opts,
         token: undefined,
         processedBy: undefined,
-        deduplicationId: undefined,
-        repeatJobKey: undefined,
+        deduplicationId: r.deduplicationId,
+        repeatJobKey: r.repeatJobKey,
         attemptsStarted: 0,
         // Methods
         updateProgress: async (progress, message) => {
@@ -44,7 +63,7 @@ export function createJobProxy(id, name, data, ctx) {
         isDelayed: async () => (await ctx.getJobState(id)) === 'delayed',
         isCompleted: async () => (await ctx.getJobState(id)) === 'completed',
         isFailed: async () => (await ctx.getJobState(id)) === 'failed',
-        isWaitingChildren: () => Promise.resolve(false),
+        isWaitingChildren: async () => (await ctx.getJobState(id)) === 'waiting-children',
         // Mutation methods
         updateData: async (newData) => {
             await tcp.send({ cmd: 'Update', id, data: newData });
@@ -56,41 +75,49 @@ export function createJobProxy(id, name, data, ctx) {
             await tcp.send({ cmd: 'ChangeDelay', id, delay });
         },
         changePriority: async (opts) => {
-            await tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority });
+            await tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority, lifo: opts.lifo });
         },
-        extendLock: async (_token, duration) => {
-            const res = await tcp.send({ cmd: 'ExtendLock', id, duration });
-            return res.ok ? duration : 0;
+        extendLock: async (token, duration) => {
+            const res = await tcp.send({ cmd: 'ExtendLock', id, token, duration });
+            return res.ok === true ? duration : 0;
         },
         clearLogs: async () => {
             await tcp.send({ cmd: 'ClearLogs', id });
         },
-        // Dependency methods
-        getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
-        getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
+        // Dependency methods — derive from child state queries since no dedicated API
+        getDependencies: () => computeDependencies(id, queueName, tcp),
+        getDependenciesCount: async () => {
+            const deps = await computeDependencies(id, queueName, tcp);
+            return {
+                processed: Object.keys(deps.processed).length,
+                unprocessed: deps.unprocessed.length,
+            };
+        },
         // Serialization methods
         toJSON: () => ({
             id,
             name,
             data,
-            opts: {},
+            opts: r.opts,
             progress: 0,
-            delay: 0,
+            delay: r.delay,
             timestamp: ts,
             attemptsMade: 0,
             stacktrace: null,
             queueQualifiedName: `bull:${queueName}`,
+            parentKey: r.parentKey,
         }),
         asJSON: () => ({
             id,
             name,
             data: JSON.stringify(data),
-            opts: '{}',
+            opts: JSON.stringify(r.opts),
             progress: '0',
-            delay: '0',
+            delay: String(r.delay),
             timestamp: String(ts),
             attemptsMade: '0',
             stacktrace: null,
+            parentKey: r.parentKey,
         }),
         // Move methods
         moveToCompleted: async (returnValue) => {
@@ -105,12 +132,24 @@ export function createJobProxy(id, name, data, ctx) {
             return res.ok === true;
         },
         moveToDelayed: async (timestamp) => {
-            await tcp.send({ cmd: 'MoveToDelayed', id, timestamp });
+            const delay = Math.max(0, timestamp - Date.now());
+            await tcp.send({ cmd: 'MoveToDelayed', id, delay });
+        },
+        moveToWaitingChildren: () => {
+            return Promise.reject(new Error('moveToWaitingChildren is not supported in TCP mode — no server command available'));
+        },
+        waitUntilFinished: async (_queueEvents, ttl) => {
+            const timeout = ttl ?? 30000;
+            const res = await tcp.send({ cmd: 'WaitJob', id, timeout });
+            const typed = res;
+            if (!typed.completed)
+                throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
+            return typed.result;
         },
-        moveToWaitingChildren: () => Promise.resolve(false),
-        waitUntilFinished: () => Promise.resolve(undefined),
         // Additional methods
-        discard: () => { },
+        discard: () => {
+            void tcp.send({ cmd: 'Discard', id });
+        },
         getFailedChildrenValues: async () => {
             const res = await tcp.send({ cmd: 'GetFailedChildrenValues', id });
             return res.values ?? {};
@@ -123,15 +162,45 @@ export function createJobProxy(id, name, data, ctx) {
             const res = await tcp.send({ cmd: 'RemoveChildDependency', id });
             return res.removed ?? false;
         },
-        removeDeduplicationKey: () => Promise.resolve(false),
+        removeDeduplicationKey: () => Promise.reject(new Error('removeDeduplicationKey is not implemented — no server primitive available')),
         removeUnprocessedChildren: async () => {
             await tcp.send({ cmd: 'RemoveUnprocessedChildren', id });
         },
     };
 }
-/** Create a simple Job without TCP methods (for embedded or read-only) */
+/** Fetch child ids for a job via GetJob, then derive dependency state per child */
+async function computeDependencies(id, queueName, tcp) {
+    const jobRes = await tcp.send({ cmd: 'GetJob', id });
+    const parent = jobRes.job;
+    const childIds = parent?.childrenIds ?? [];
+    const processed = {};
+    const unprocessed = [];
+    for (const cid of childIds) {
+        const stateRes = await tcp.send({ cmd: 'GetState', id: cid });
+        const state = stateRes.state ?? 'unknown';
+        const key = `${queueName}:${cid}`;
+        if (state === 'completed' || state === 'failed') {
+            if (state === 'completed') {
+                const resR = await tcp.send({ cmd: 'GetResult', id: cid });
+                processed[key] = resR.result ?? null;
+            }
+            else {
+                processed[key] = null;
+            }
+        }
+        else {
+            unprocessed.push(key);
+        }
+    }
+    return { processed, unprocessed };
+}
+/**
+ * Create a simple Job with all BullMQ v5 methods wired.
+ * Used by Queue.getJob / getJobs in both embedded and TCP modes.
+ */
 export function createSimpleJob(id, name, data, timestamp, ctx) {
-    const { queueName } = ctx;
+    const { queueName, embedded, tcp, meta } = ctx;
+    const r = reflectFields(id, queueName, meta);
     return {
         id,
         name,
@@ -140,22 +209,36 @@ export function createSimpleJob(id, name, data, timestamp, ctx) {
         attemptsMade: 0,
         timestamp,
         progress: 0,
-        delay: 0,
+        delay: r.delay,
         processedOn: undefined,
         finishedOn: undefined,
         stacktrace: null,
         stalledCounter: 0,
-        priority: 0,
-        parentKey: undefined,
-        opts: {},
+        priority: r.priority,
+        parent: r.parent,
+        parentKey: r.parentKey,
+        opts: r.opts,
         token: undefined,
         processedBy: undefined,
-        deduplicationId: undefined,
-        repeatJobKey: undefined,
+        deduplicationId: r.deduplicationId,
+        repeatJobKey: r.repeatJobKey,
         attemptsStarted: 0,
-        // Methods (no-op for simple jobs)
-        updateProgress: async () => { },
-        log: async () => { },
+        updateProgress: async (progress, message) => {
+            if (embedded) {
+                await getSharedManager().updateProgress(jobId(id), progress, message);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'Progress', id, progress, message });
+        },
+        log: async (message) => {
+            if (embedded) {
+                getSharedManager().addLog(jobId(id), message);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'AddLog', id, message });
+        },
         getState: () => ctx.getJobState(id),
         remove: () => ctx.removeAsync(id),
         retry: () => ctx.retryJob(id),
@@ -166,55 +249,252 @@ export function createSimpleJob(id, name, data, timestamp, ctx) {
         isDelayed: async () => (await ctx.getJobState(id)) === 'delayed',
         isCompleted: async () => (await ctx.getJobState(id)) === 'completed',
         isFailed: async () => (await ctx.getJobState(id)) === 'failed',
-        isWaitingChildren: () => Promise.resolve(false),
-        // No-op mutation methods
-        updateData: async () => { },
-        promote: async () => { },
-        changeDelay: async () => { },
-        changePriority: async () => { },
-        extendLock: () => Promise.resolve(0),
-        clearLogs: async () => { },
-        // Dependency methods
-        getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
-        getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
-        // Serialization methods
+        isWaitingChildren: async () => (await ctx.getJobState(id)) === 'waiting-children',
+        updateData: async (newData) => {
+            if (embedded) {
+                await getSharedManager().updateJobData(jobId(id), newData);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'Update', id, data: newData });
+        },
+        promote: async () => {
+            if (embedded) {
+                await getSharedManager().promote(jobId(id));
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'Promote', id });
+        },
+        changeDelay: async (delay) => {
+            if (embedded) {
+                await getSharedManager().changeDelay(jobId(id), delay);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'ChangeDelay', id, delay });
+        },
+        changePriority: async (opts) => {
+            if (embedded) {
+                await getSharedManager().changePriority(jobId(id), opts.priority, opts.lifo);
+                return;
+            }
+            if (tcp) {
+                await tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority, lifo: opts.lifo });
+            }
+        },
+        extendLock: async (token, duration) => {
+            if (embedded) {
+                const ok = await getSharedManager().extendLock(jobId(id), token, duration);
+                return ok ? duration : 0;
+            }
+            if (!tcp)
+                return 0;
+            const res = await tcp.send({ cmd: 'ExtendLock', id, token, duration });
+            return res.ok === true ? duration : 0;
+        },
+        clearLogs: async (keepLogs) => {
+            if (embedded) {
+                getSharedManager().clearLogs(jobId(id), keepLogs);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'ClearLogs', id, keepLogs });
+        },
+        getDependencies: () => computeDepsSimple(id, queueName, embedded, tcp),
+        getDependenciesCount: async () => {
+            const deps = await computeDepsSimple(id, queueName, embedded, tcp);
+            return {
+                processed: Object.keys(deps.processed).length,
+                unprocessed: deps.unprocessed.length,
+            };
+        },
         toJSON: () => ({
             id,
             name,
             data,
-            opts: {},
+            opts: r.opts,
             progress: 0,
-            delay: 0,
+            delay: r.delay,
             timestamp,
             attemptsMade: 0,
             stacktrace: null,
             queueQualifiedName: `bull:${queueName}`,
+            parentKey: r.parentKey,
         }),
         asJSON: () => ({
             id,
             name,
             data: JSON.stringify(data),
-            opts: '{}',
+            opts: JSON.stringify(r.opts),
             progress: '0',
-            delay: '0',
+            delay: String(r.delay),
             timestamp: String(timestamp),
             attemptsMade: '0',
             stacktrace: null,
+            parentKey: r.parentKey,
         }),
-        // Move methods (no-op)
-        moveToCompleted: () => Promise.resolve(null),
-        moveToFailed: () => Promise.resolve(),
-        moveToWait: () => Promise.resolve(false),
-        moveToDelayed: () => Promise.resolve(),
-        moveToWaitingChildren: () => Promise.resolve(false),
-        waitUntilFinished: () => Promise.resolve(undefined),
-        // Additional methods
-        discard: () => { },
-        getFailedChildrenValues: () => Promise.resolve({}),
-        getIgnoredChildrenFailures: () => Promise.resolve({}),
-        removeChildDependency: () => Promise.resolve(false),
-        removeDeduplicationKey: () => Promise.resolve(false),
-        removeUnprocessedChildren: () => Promise.resolve(),
+        moveToCompleted: async (returnValue) => {
+            if (embedded) {
+                await getSharedManager().ack(jobId(id), returnValue);
+                return null;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'ACK', id, result: returnValue });
+            return null;
+        },
+        moveToFailed: async (error) => {
+            if (embedded) {
+                await getSharedManager().fail(jobId(id), error.message);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'FAIL', id, error: error.message });
+        },
+        moveToWait: async () => {
+            if (embedded) {
+                const mgr = getSharedManager();
+                const state = await mgr.getJobState(jobId(id));
+                if (state === 'active')
+                    return await mgr.moveActiveToWait(jobId(id));
+                if (state === 'delayed')
+                    return await mgr.promote(jobId(id));
+                if (state === 'failed') {
+                    const job = await mgr.getJob(jobId(id));
+                    if (!job)
+                        return false;
+                    return mgr.retryDlq(job.queue, jobId(id)) > 0;
+                }
+                if (state === 'waiting' || state === 'prioritized')
+                    return true;
+                return false;
+            }
+            if (!tcp)
+                return false;
+            const res = await tcp.send({ cmd: 'MoveToWait', id });
+            return res.ok === true;
+        },
+        moveToDelayed: async (ts) => {
+            const delay = Math.max(0, ts - Date.now());
+            if (embedded) {
+                await getSharedManager().moveToDelayed(jobId(id), delay);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'MoveToDelayed', id, delay });
+        },
+        moveToWaitingChildren: async () => {
+            if (embedded) {
+                return await getSharedManager().moveToWaitingChildren(jobId(id));
+            }
+            throw new Error('moveToWaitingChildren is not supported in TCP mode — no server command available');
+        },
+        waitUntilFinished: async (_qe, ttl) => {
+            const timeout = ttl ?? 30000;
+            if (embedded) {
+                const mgr = getSharedManager();
+                const job = await mgr.getJob(jobId(id));
+                if (!job)
+                    throw new Error(`Job ${id} not found`);
+                if (job.completedAt)
+                    return mgr.getResult(jobId(id));
+                const ok = await mgr.waitForJobCompletion(jobId(id), timeout);
+                if (!ok)
+                    throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
+                return mgr.getResult(jobId(id));
+            }
+            if (!tcp)
+                throw new Error('waitUntilFinished: no connection');
+            const res = await tcp.send({ cmd: 'WaitJob', id, timeout });
+            const typed = res;
+            if (!typed.completed)
+                throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
+            return typed.result;
+        },
+        discard: () => {
+            if (embedded) {
+                void getSharedManager().discard(jobId(id));
+                return;
+            }
+            if (tcp)
+                void tcp.send({ cmd: 'Discard', id });
+        },
+        getFailedChildrenValues: async () => {
+            if (embedded) {
+                return await getSharedManager().getFailedChildrenValues(jobId(id));
+            }
+            if (!tcp)
+                return {};
+            const res = await tcp.send({ cmd: 'GetFailedChildrenValues', id });
+            return res.values ?? {};
+        },
+        getIgnoredChildrenFailures: async () => {
+            if (embedded) {
+                return await getSharedManager().getIgnoredChildrenFailures(jobId(id));
+            }
+            if (!tcp)
+                return {};
+            const res = await tcp.send({ cmd: 'GetIgnoredChildrenFailures', id });
+            return res.values ?? {};
+        },
+        removeChildDependency: async () => {
+            if (embedded) {
+                return await getSharedManager().removeChildDependency(jobId(id));
+            }
+            if (!tcp)
+                return false;
+            const res = await tcp.send({ cmd: 'RemoveChildDependency', id });
+            return res.removed ?? false;
+        },
+        removeDeduplicationKey: () => Promise.reject(new Error('removeDeduplicationKey is not implemented — no server primitive available')),
+        removeUnprocessedChildren: async () => {
+            if (embedded) {
+                await getSharedManager().removeUnprocessedChildren(jobId(id));
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'RemoveUnprocessedChildren', id });
+        },
     };
 }
-//# sourceMappingURL=jobProxy.js.map
+/** Shared dependency computation for both embedded and TCP modes */
+async function computeDepsSimple(id, queueName, embedded, tcp) {
+    const processed = {};
+    const unprocessed = [];
+    let childIds = [];
+    if (embedded) {
+        const job = await getSharedManager().getJob(jobId(id));
+        childIds = (job?.childrenIds ?? []).map(String);
+    }
+    else if (tcp) {
+        const jobRes = await tcp.send({ cmd: 'GetJob', id });
+        const parent = jobRes.job;
+        childIds = (parent?.childrenIds ?? []).map(String);
+    }
+    for (const cid of childIds) {
+        let state = 'unknown';
+        let result;
+        if (embedded) {
+            const mgr = getSharedManager();
+            state = await mgr.getJobState(jobId(cid));
+            if (state === 'completed')
+                result = mgr.getResult(jobId(cid));
+        }
+        else if (tcp) {
+            const r = await tcp.send({ cmd: 'GetState', id: cid });
+            state = r.state ?? 'unknown';
+            if (state === 'completed') {
+                const rr = await tcp.send({ cmd: 'GetResult', id: cid });
+                result = rr.result;
+            }
+        }
+        const key = `${queueName}:${cid}`;
+        if (state === 'completed' || state === 'failed') {
+            processed[key] = result ?? null;
+        }
+        else {
+            unprocessed.push(key);
+        }
+    }
+    return { processed, unprocessed };
+}

package/dist/client/queue/operations/add.d.ts

@@ -18,6 +18,7 @@ interface AddContext {
     changeJobDelay: (id: string, delay: number) => Promise<void>;
     changeJobPriority: (id: string, opts: {
         priority: number;
+        lifo?: boolean;
     }) => Promise<void>;
     extendJobLock: (id: string, token: string, duration: number) => Promise<number>;
     clearJobLogs: (id: string, keepLogs?: number) => Promise<void>;
@@ -44,4 +45,3 @@ export declare function addBulk<T>(ctx: AddContext, jobs: Array<{
     opts?: JobOptions;
 }>): Promise<Job<T>[]>;
 export {};
-//# sourceMappingURL=add.d.ts.map