bunqueue 2.8.53 → 2.8.56

package/dist/client/queue/job-proxy/simple.js

@@ -0,0 +1,316 @@
+import { removeJobDeduplicationKey } from '../../jobDeduplication';
+import { getSharedManager } from '../../manager';
+import { jobId } from '../../../domain/types/job';
+import { buildFailCommand, failEmbeddedArgs } from '../failWire';
+import { computeSimpleDependencies } from './dependencies';
+import { reflectFields } from './reflection';
+import { serializeReturnvalue } from '../jobMetadata';
+import { assertFlowTcpOk } from '../../flowJobTypes';
+export function createSimpleJob(id, name, data, timestamp, ctx) {
+    const { queueName, embedded, tcp, meta } = ctx;
+    const reflected = reflectFields(id, queueName, meta);
+    const attemptsMade = meta?.attemptsMade ?? 0;
+    const attemptsStarted = meta?.attemptsStarted ?? attemptsMade;
+    const progress = meta?.progress ?? 0;
+    const stalledCounter = meta?.stalledCounter ?? 0;
+    return {
+        id,
+        name,
+        data,
+        queueName,
+        attemptsMade,
+        timestamp,
+        progress,
+        delay: reflected.delay,
+        processedOn: meta?.processedOn,
+        finishedOn: meta?.finishedOn,
+        stacktrace: reflected.stacktrace,
+        returnvalue: reflected.returnvalue,
+        failedReason: reflected.failedReason,
+        stalledCounter,
+        priority: reflected.priority,
+        parent: reflected.parent,
+        parentKey: reflected.parentKey,
+        opts: reflected.opts,
+        token: undefined,
+        processedBy: undefined,
+        deduplicationId: reflected.deduplicationId,
+        repeatJobKey: reflected.repeatJobKey,
+        attemptsStarted,
+        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),
+        getChildrenValues: () => ctx.getChildrenValues(id),
+        isWaiting: async () => (await ctx.getJobState(id)) === 'waiting',
+        isActive: async () => (await ctx.getJobState(id)) === 'active',
+        isDelayed: async () => (await ctx.getJobState(id)) === 'delayed',
+        isCompleted: async () => (await ctx.getJobState(id)) === 'completed',
+        isFailed: async () => (await ctx.getJobState(id)) === 'failed',
+        isWaitingChildren: async () => (await ctx.getJobState(id)) === 'waiting-children',
+        updateData: async (newData) => {
+            if (embedded) {
+                await getSharedManager().updateJobData(jobId(id), newData);
+                return;
+            }
+            if (tcp)
+                assertFlowTcpOk(await tcp.send({ cmd: 'Update', id, data: newData }), 'Update');
+        },
+        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 response = await tcp.send({ cmd: 'ExtendLock', id, token, duration });
+            return response.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: () => computeSimpleDependencies(id, queueName, embedded, tcp),
+        getDependenciesCount: async () => {
+            const dependencies = await computeSimpleDependencies(id, queueName, embedded, tcp);
+            return {
+                processed: Object.keys(dependencies.processed).length,
+                unprocessed: dependencies.unprocessed.length,
+            };
+        },
+        toJSON: () => ({
+            id,
+            name,
+            data,
+            opts: reflected.opts,
+            progress,
+            delay: reflected.delay,
+            timestamp,
+            attemptsMade,
+            stacktrace: reflected.stacktrace,
+            returnvalue: reflected.returnvalue,
+            failedReason: reflected.failedReason,
+            processedOn: meta?.processedOn,
+            finishedOn: meta?.finishedOn,
+            queueQualifiedName: `bull:${queueName}`,
+            parentKey: reflected.parentKey,
+        }),
+        asJSON: () => ({
+            id,
+            name,
+            data: JSON.stringify(data),
+            opts: JSON.stringify(reflected.opts),
+            progress: String(progress),
+            delay: String(reflected.delay),
+            timestamp: String(timestamp),
+            attemptsMade: String(attemptsMade),
+            stacktrace: reflected.stacktrace ? JSON.stringify(reflected.stacktrace) : null,
+            returnvalue: serializeReturnvalue(reflected.returnvalue),
+            failedReason: reflected.failedReason,
+            processedOn: meta?.processedOn === undefined ? undefined : String(meta.processedOn),
+            finishedOn: meta?.finishedOn === undefined ? undefined : String(meta.finishedOn),
+            parentKey: reflected.parentKey,
+        }),
+        moveToCompleted: async (returnValue, token) => {
+            if (embedded) {
+                await getSharedManager().ack(jobId(id), returnValue, token);
+                return null;
+            }
+            if (tcp) {
+                const response = await tcp.send({
+                    cmd: 'ACK',
+                    id,
+                    result: returnValue,
+                    ...(token === undefined ? {} : { token }),
+                });
+                if (response.ok !== true) {
+                    throw new Error(typeof response.error === 'string' ? response.error : 'ACK failed');
+                }
+            }
+            return null;
+        },
+        moveToFailed: async (error, token) => {
+            if (embedded) {
+                await getSharedManager().fail(jobId(id), ...failEmbeddedArgs(error, token));
+                return;
+            }
+            if (tcp) {
+                const response = await tcp.send(buildFailCommand(id, error, token));
+                if (response.ok !== true) {
+                    throw new Error(typeof response.error === 'string' ? response.error : 'FAIL failed');
+                }
+            }
+        },
+        moveToWait: async (token) => {
+            if (embedded) {
+                const manager = getSharedManager();
+                const state = await manager.getJobState(jobId(id));
+                if (state === 'active')
+                    return await manager.moveActiveToWait(jobId(id), token);
+                if (state === 'delayed')
+                    return await manager.promote(jobId(id));
+                if (state === 'failed') {
+                    const job = await manager.getJob(jobId(id));
+                    if (!job)
+                        return false;
+                    return manager.retryDlq(job.queue, jobId(id)) > 0;
+                }
+                if (state === 'waiting' || state === 'prioritized')
+                    return true;
+                return false;
+            }
+            if (!tcp)
+                return false;
+            const response = await tcp.send({
+                cmd: 'MoveToWait',
+                id,
+                ...(token === undefined ? {} : { token }),
+            });
+            if (response.ok === false && /token/i.test(String(response.error))) {
+                throw new Error(typeof response.error === 'string' ? response.error : 'Invalid lock token');
+            }
+            return response.ok === true;
+        },
+        moveToDelayed: async (targetTimestamp, token) => {
+            const delay = Math.max(0, targetTimestamp - Date.now());
+            if (embedded) {
+                await getSharedManager().moveToDelayed(jobId(id), delay, token);
+                return;
+            }
+            if (tcp) {
+                const response = await tcp.send({
+                    cmd: 'MoveToDelayed',
+                    id,
+                    delay,
+                    ...(token === undefined ? {} : { token }),
+                });
+                if (response.ok !== true) {
+                    throw new Error(typeof response.error === 'string' ? response.error : 'MoveToDelayed failed');
+                }
+            }
+        },
+        moveToWaitingChildren: async (token) => {
+            if (embedded) {
+                return await getSharedManager().moveToWaitingChildren(jobId(id), token);
+            }
+            if (!tcp)
+                return false;
+            const response = await tcp.send({
+                cmd: 'MoveToWaitingChildren',
+                id,
+                ...(token === undefined ? {} : { token }),
+            });
+            if (response.ok === false && /token/i.test(String(response.error))) {
+                throw new Error(typeof response.error === 'string' ? response.error : 'Invalid lock token');
+            }
+            return response.ok === true;
+        },
+        waitUntilFinished: async (_queueEvents, ttl) => {
+            const timeout = ttl ?? 30000;
+            if (embedded) {
+                const manager = getSharedManager();
+                const job = await manager.getJob(jobId(id));
+                if (!job)
+                    throw new Error(`Job ${id} not found`);
+                if (job.completedAt)
+                    return manager.getResult(jobId(id));
+                const ok = await manager.waitForJobCompletion(jobId(id), timeout);
+                if (!ok)
+                    throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
+                return manager.getResult(jobId(id));
+            }
+            if (!tcp)
+                throw new Error('waitUntilFinished: no connection');
+            const response = await tcp.send({ cmd: 'WaitJob', id, timeout });
+            const typed = response;
+            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 response = await tcp.send({ cmd: 'GetFailedChildrenValues', id });
+            return response.values ?? {};
+        },
+        getIgnoredChildrenFailures: async () => {
+            if (embedded)
+                return await getSharedManager().getIgnoredChildrenFailures(jobId(id));
+            if (!tcp)
+                return {};
+            const response = await tcp.send({ cmd: 'GetIgnoredChildrenFailures', id });
+            return response.values ?? {};
+        },
+        removeChildDependency: async () => {
+            if (embedded)
+                return await getSharedManager().removeChildDependency(jobId(id));
+            if (!tcp)
+                return false;
+            const response = await tcp.send({ cmd: 'RemoveChildDependency', id });
+            return response.removed ?? false;
+        },
+        removeDeduplicationKey: () => removeJobDeduplicationKey(id, embedded ?? false, tcp),
+        removeUnprocessedChildren: async () => {
+            if (embedded) {
+                await getSharedManager().removeUnprocessedChildren(jobId(id));
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'RemoveUnprocessedChildren', id });
+        },
+    };
+}

package/dist/client/queue/job-proxy/tcp.d.ts

@@ -0,0 +1,4 @@
+import type { Job } from '../../types';
+import type { JobProxyContext, JobReflectionMeta } from '../types/job';
+/** Create a full Job proxy whose methods use the TCP transport. */
+export declare function createJobProxy<T>(id: string, name: string, data: T, ctx: JobProxyContext, meta?: JobReflectionMeta): Job<T>;

package/dist/client/queue/job-proxy/tcp.js

@@ -0,0 +1,191 @@
+import { removeJobDeduplicationKey } from '../../jobDeduplication';
+import { buildFailCommand } from '../failWire';
+import { computeDependencies } from './dependencies';
+import { reflectFields } from './reflection';
+import { serializeReturnvalue } from '../jobMetadata';
+function assertMoveResponse(response, operation) {
+    if (response.ok === true)
+        return;
+    throw new Error(typeof response.error === 'string' ? response.error : `${operation} failed`);
+}
+/** Create a full Job proxy whose methods use the TCP transport. */
+export function createJobProxy(id, name, data, ctx, meta) {
+    const { tcp, queueName } = ctx;
+    const timestamp = meta?.timestamp ?? Date.now();
+    const reflected = reflectFields(id, queueName, meta);
+    const attemptsMade = meta?.attemptsMade ?? 0;
+    const attemptsStarted = meta?.attemptsStarted ?? attemptsMade;
+    const progress = meta?.progress ?? 0;
+    const stalledCounter = meta?.stalledCounter ?? 0;
+    return {
+        id,
+        name,
+        data,
+        queueName,
+        attemptsMade,
+        timestamp,
+        progress,
+        delay: reflected.delay,
+        processedOn: meta?.processedOn,
+        finishedOn: meta?.finishedOn,
+        stacktrace: reflected.stacktrace,
+        returnvalue: reflected.returnvalue,
+        failedReason: reflected.failedReason,
+        stalledCounter,
+        priority: reflected.priority,
+        parent: reflected.parent,
+        parentKey: reflected.parentKey,
+        opts: reflected.opts,
+        token: undefined,
+        processedBy: undefined,
+        deduplicationId: reflected.deduplicationId,
+        repeatJobKey: reflected.repeatJobKey,
+        attemptsStarted,
+        updateProgress: async (progress, message) => {
+            await tcp.send({ cmd: 'Progress', id, progress, message });
+        },
+        log: async (message) => {
+            await tcp.send({ cmd: 'AddLog', id, message });
+        },
+        getState: () => ctx.getJobState(id),
+        remove: () => ctx.removeAsync(id),
+        retry: () => ctx.retryJob(id),
+        getChildrenValues: () => ctx.getChildrenValues(id),
+        isWaiting: async () => (await ctx.getJobState(id)) === 'waiting',
+        isActive: async () => (await ctx.getJobState(id)) === 'active',
+        isDelayed: async () => (await ctx.getJobState(id)) === 'delayed',
+        isCompleted: async () => (await ctx.getJobState(id)) === 'completed',
+        isFailed: async () => (await ctx.getJobState(id)) === 'failed',
+        isWaitingChildren: async () => (await ctx.getJobState(id)) === 'waiting-children',
+        updateData: async (newData) => {
+            assertMoveResponse(await tcp.send({ cmd: 'Update', id, data: newData }), 'Update');
+        },
+        promote: async () => {
+            await tcp.send({ cmd: 'Promote', id });
+        },
+        changeDelay: async (delay) => {
+            await tcp.send({ cmd: 'ChangeDelay', id, delay });
+        },
+        changePriority: async (opts) => {
+            await tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority, lifo: opts.lifo });
+        },
+        extendLock: async (token, duration) => {
+            const response = await tcp.send({ cmd: 'ExtendLock', id, token, duration });
+            return response.ok === true ? duration : 0;
+        },
+        clearLogs: async () => {
+            await tcp.send({ cmd: 'ClearLogs', id });
+        },
+        getDependencies: () => computeDependencies(id, queueName, tcp),
+        getDependenciesCount: async () => {
+            const dependencies = await computeDependencies(id, queueName, tcp);
+            return {
+                processed: Object.keys(dependencies.processed).length,
+                unprocessed: dependencies.unprocessed.length,
+            };
+        },
+        toJSON: () => ({
+            id,
+            name,
+            data,
+            opts: reflected.opts,
+            progress,
+            delay: reflected.delay,
+            timestamp,
+            attemptsMade,
+            stacktrace: reflected.stacktrace,
+            returnvalue: reflected.returnvalue,
+            failedReason: reflected.failedReason,
+            processedOn: meta?.processedOn,
+            finishedOn: meta?.finishedOn,
+            queueQualifiedName: `bull:${queueName}`,
+            parentKey: reflected.parentKey,
+        }),
+        asJSON: () => ({
+            id,
+            name,
+            data: JSON.stringify(data),
+            opts: JSON.stringify(reflected.opts),
+            progress: String(progress),
+            delay: String(reflected.delay),
+            timestamp: String(timestamp),
+            attemptsMade: String(attemptsMade),
+            stacktrace: reflected.stacktrace ? JSON.stringify(reflected.stacktrace) : null,
+            returnvalue: serializeReturnvalue(reflected.returnvalue),
+            failedReason: reflected.failedReason,
+            processedOn: meta?.processedOn === undefined ? undefined : String(meta.processedOn),
+            finishedOn: meta?.finishedOn === undefined ? undefined : String(meta.finishedOn),
+            parentKey: reflected.parentKey,
+        }),
+        moveToCompleted: async (returnValue, token) => {
+            assertMoveResponse(await tcp.send({
+                cmd: 'ACK',
+                id,
+                result: returnValue,
+                ...(token === undefined ? {} : { token }),
+            }), 'ACK');
+            return null;
+        },
+        moveToFailed: async (error, token) => {
+            assertMoveResponse(await tcp.send(buildFailCommand(id, error, token)), 'FAIL');
+        },
+        moveToWait: async (token) => {
+            const response = await tcp.send({
+                cmd: 'MoveToWait',
+                id,
+                ...(token === undefined ? {} : { token }),
+            });
+            if (response.ok === false && /token/i.test(String(response.error))) {
+                assertMoveResponse(response, 'MoveToWait');
+            }
+            return response.ok === true;
+        },
+        moveToDelayed: async (targetTimestamp, token) => {
+            const delay = Math.max(0, targetTimestamp - Date.now());
+            assertMoveResponse(await tcp.send({
+                cmd: 'MoveToDelayed',
+                id,
+                delay,
+                ...(token === undefined ? {} : { token }),
+            }), 'MoveToDelayed');
+        },
+        moveToWaitingChildren: async (token) => {
+            const response = await tcp.send({
+                cmd: 'MoveToWaitingChildren',
+                id,
+                ...(token === undefined ? {} : { token }),
+            });
+            if (response.ok === false && /token/i.test(String(response.error))) {
+                assertMoveResponse(response, 'MoveToWaitingChildren');
+            }
+            return response.ok === true;
+        },
+        waitUntilFinished: async (_queueEvents, ttl) => {
+            const timeout = ttl ?? 30000;
+            const response = await tcp.send({ cmd: 'WaitJob', id, timeout });
+            const typed = response;
+            if (!typed.completed)
+                throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
+            return typed.result;
+        },
+        discard: () => {
+            void tcp.send({ cmd: 'Discard', id });
+        },
+        getFailedChildrenValues: async () => {
+            const response = await tcp.send({ cmd: 'GetFailedChildrenValues', id });
+            return response.values ?? {};
+        },
+        getIgnoredChildrenFailures: async () => {
+            const response = await tcp.send({ cmd: 'GetIgnoredChildrenFailures', id });
+            return response.values ?? {};
+        },
+        removeChildDependency: async () => {
+            const response = await tcp.send({ cmd: 'RemoveChildDependency', id });
+            return response.removed ?? false;
+        },
+        removeDeduplicationKey: () => removeJobDeduplicationKey(id, false, tcp),
+        removeUnprocessedChildren: async () => {
+            await tcp.send({ cmd: 'RemoveUnprocessedChildren', id });
+        },
+    };
+}

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

@@ -0,0 +1,10 @@
+import type { Job as InternalJob } from '../../domain/types/job';
+import type { JobReflectionMeta } from './types/job';
+export interface TerminalJobView extends InternalJob {
+    returnvalue?: unknown;
+    failedReason?: string;
+}
+/** Build one public metadata shape for embedded and TCP queue reads. */
+export declare function metadataFromJob(job: TerminalJobView, embeddedResult?: unknown): JobReflectionMeta;
+/** Encode terminal values for BullMQ-compatible raw JSON output. */
+export declare function serializeReturnvalue(value: unknown): string | undefined;

package/dist/client/queue/jobMetadata.js

@@ -0,0 +1,24 @@
+import { lastFailedReason } from '../../domain/job/terminal';
+import { buildJobOpts } from '../jobHelpers';
+/** Build one public metadata shape for embedded and TCP queue reads. */
+export function metadataFromJob(job, embeddedResult) {
+    const opts = buildJobOpts(job);
+    return {
+        attemptsMade: job.attempts,
+        attemptsStarted: job.attempts,
+        progress: job.progress,
+        stalledCounter: job.stallCount,
+        priority: job.priority ?? 0,
+        delay: opts.delay ?? 0,
+        processedOn: job.startedAt ?? undefined,
+        finishedOn: job.completedAt ?? undefined,
+        opts,
+        stacktrace: job.stacktrace ?? null,
+        returnvalue: Object.hasOwn(job, 'returnvalue') ? job.returnvalue : embeddedResult,
+        failedReason: job.failedReason ?? lastFailedReason(job),
+    };
+}
+/** Encode terminal values for BullMQ-compatible raw JSON output. */
+export function serializeReturnvalue(value) {
+    return value === undefined ? undefined : JSON.stringify(value);
+}

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

@@ -13,15 +13,15 @@ interface JobMoveContext {
     }>;
 }
 /** Move job to completed state */
-export declare function moveJobToCompleted(ctx: JobMoveContext, id: string, returnValue: unknown, _token?: string): Promise<unknown>;
+export declare function moveJobToCompleted(ctx: JobMoveContext, id: string, returnValue: unknown, token?: string): Promise<unknown>;
 /** Move job to failed state */
 export declare function moveJobToFailed(ctx: JobMoveContext, id: string, error: Error, token?: string): Promise<void>;
 /** Move job back to waiting state */
-export declare function moveJobToWait(ctx: JobMoveContext, id: string, _token?: string): Promise<boolean>;
+export declare function moveJobToWait(ctx: JobMoveContext, id: string, token?: string): Promise<boolean>;
 /** Move job to delayed state */
-export declare function moveJobToDelayed(ctx: JobMoveContext, id: string, timestamp: number, _token?: string): Promise<void>;
+export declare function moveJobToDelayed(ctx: JobMoveContext, id: string, timestamp: number, token?: string): Promise<void>;
 /** Move job to waiting-children state */
-export declare function moveJobToWaitingChildren(ctx: JobMoveContext, id: string, _token?: string, _opts?: {
+export declare function moveJobToWaitingChildren(ctx: JobMoveContext, id: string, token?: string, _opts?: {
     child?: {
         id: string;
         queue: string;