bunqueue 2.8.54 → 2.8.57

package/dist/client/queue/operations/add/payload.js

@@ -0,0 +1,85 @@
+export function compact(object) {
+    const output = {};
+    for (const key in object) {
+        if (object[key] !== undefined)
+            output[key] = object[key];
+    }
+    return output;
+}
+export function parseDate(date) {
+    if (date instanceof Date)
+        return date.getTime();
+    if (typeof date === 'string')
+        return new Date(date).getTime();
+    return date;
+}
+export function buildRepeatOptions(repeat) {
+    return {
+        every: repeat.every,
+        limit: repeat.limit,
+        pattern: repeat.pattern,
+        count: repeat.count,
+        startDate: parseDate(repeat.startDate),
+        endDate: parseDate(repeat.endDate),
+        tz: repeat.tz,
+        immediately: repeat.immediately,
+        prevMillis: repeat.prevMillis,
+        offset: repeat.offset,
+        jobId: repeat.jobId,
+    };
+}
+export function buildPushPayload(queue, name, data, options) {
+    return compact({
+        cmd: 'PUSH',
+        queue,
+        name,
+        data,
+        priority: options.priority,
+        delay: options.delay,
+        maxAttempts: options.attempts,
+        backoff: options.backoff,
+        ttl: options.ttl,
+        timeout: options.timeout,
+        jobId: options.jobId,
+        uniqueKey: options.deduplication?.id,
+        dedup: options.deduplication
+            ? {
+                ttl: options.deduplication.ttl,
+                extend: options.deduplication.extend,
+                replace: options.deduplication.replace,
+            }
+            : undefined,
+        dependsOn: options.dependsOn,
+        tags: options.tags,
+        groupId: options.groupId,
+        lifo: options.lifo,
+        removeOnComplete: typeof options.removeOnComplete === 'boolean' ? options.removeOnComplete : undefined,
+        removeOnFail: typeof options.removeOnFail === 'boolean' ? options.removeOnFail : undefined,
+        stallTimeout: options.stallTimeout,
+        stackTraceLimit: options.stackTraceLimit,
+        keepLogs: options.keepLogs,
+        sizeLimit: options.sizeLimit,
+        failParentOnFailure: options.failParentOnFailure,
+        removeDependencyOnFailure: options.removeDependencyOnFailure,
+        continueParentOnFailure: options.continueParentOnFailure,
+        ignoreDependencyOnFailure: options.ignoreDependencyOnFailure,
+        debounceId: options.debounce?.id,
+        debounceTtl: options.debounce?.ttl,
+        timestamp: options.timestamp,
+        durable: options.durable,
+        repeat: options.repeat,
+        parentId: options.parent?.id,
+    });
+}
+export function buildJobData(data, options) {
+    if (!options.parent)
+        return data;
+    return {
+        ...data,
+        __parentId: options.parent.id,
+        __parentQueue: options.parent.queue,
+    };
+}
+export function reflectionMeta(options) {
+    return { priority: options.priority, delay: options.delay, opts: options };
+}

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

@@ -0,0 +1,3 @@
+import type { Job, JobOptions } from '../../../types';
+import type { AddContext } from '../../types/add';
+export declare function add<T>(context: AddContext, jobName: string, data: T, options?: JobOptions): Promise<Job<T>>;

package/dist/client/queue/operations/add/single.js

@@ -0,0 +1,107 @@
+import { getSharedManager } from '../../../manager';
+import { removeJobDeduplicationKey } from '../../../jobDeduplication';
+import { toPublicJob } from '../../../types';
+import { jobId } from '../../../../domain/types/job';
+import { createJobProxy } from '../../jobProxy';
+import { buildJobData, buildPushPayload, buildRepeatOptions } from './payload';
+export async function add(context, jobName, data, options = {}) {
+    const merged = { ...context.opts.defaultJobOptions, ...options };
+    const jobData = buildJobData(data, merged);
+    if (context.embedded) {
+        const manager = getSharedManager();
+        const removeOnComplete = typeof merged.removeOnComplete === 'boolean' ? merged.removeOnComplete : false;
+        const removeOnFail = typeof merged.removeOnFail === 'boolean' ? merged.removeOnFail : false;
+        const repeat = merged.repeat ? buildRepeatOptions(merged.repeat) : undefined;
+        const job = await manager.push(context.name, {
+            name: jobName,
+            data: jobData,
+            priority: merged.priority,
+            delay: merged.delay,
+            maxAttempts: merged.attempts,
+            backoff: merged.backoff,
+            ttl: merged.ttl,
+            timeout: merged.timeout,
+            uniqueKey: merged.deduplication?.id,
+            customId: merged.jobId,
+            dependsOn: merged.dependsOn?.map((id) => jobId(id)),
+            tags: merged.tags,
+            groupId: merged.groupId,
+            dedup: merged.deduplication
+                ? {
+                    ttl: merged.deduplication.ttl,
+                    extend: merged.deduplication.extend,
+                    replace: merged.deduplication.replace,
+                }
+                : undefined,
+            lifo: merged.lifo,
+            removeOnComplete,
+            removeOnFail,
+            stallTimeout: merged.stallTimeout,
+            durable: merged.durable,
+            repeat,
+            parentId: merged.parent ? jobId(merged.parent.id) : undefined,
+            stackTraceLimit: merged.stackTraceLimit,
+            keepLogs: merged.keepLogs,
+            sizeLimit: merged.sizeLimit,
+            failParentOnFailure: merged.failParentOnFailure,
+            removeDependencyOnFailure: merged.removeDependencyOnFailure,
+            continueParentOnFailure: merged.continueParentOnFailure,
+            ignoreDependencyOnFailure: merged.ignoreDependencyOnFailure,
+            timestamp: merged.timestamp,
+            debounceId: merged.debounce?.id,
+            debounceTtl: merged.debounce?.ttl,
+        });
+        return toPublicJob({
+            job,
+            name: jobName,
+            updateProgress: async (id, progress, message) => {
+                await manager.updateProgress(jobId(id), progress, message);
+            },
+            // biome-ignore lint/suspicious/useAwait: public callback contract is asynchronous.
+            log: async (id, message) => {
+                manager.addLog(jobId(id), message);
+            },
+            getState: (id) => context.getJobState(id),
+            remove: (id) => context.removeAsync(id),
+            retry: (id) => context.retryJob(id),
+            getChildrenValues: (id) => context.getChildrenValues(id),
+            updateData: (id, value) => context.updateJobData(id, value),
+            promote: (id) => context.promoteJob(id),
+            changeDelay: (id, delay) => context.changeJobDelay(id, delay),
+            changePriority: (id, value) => context.changeJobPriority(id, value),
+            extendLock: (id, token, duration) => context.extendJobLock(id, token, duration),
+            clearLogs: (id, keepLogs) => context.clearJobLogs(id, keepLogs),
+            getDependencies: (id, opts) => context.getJobDependencies(id, opts),
+            getDependenciesCount: (id, opts) => context.getJobDependenciesCount(id, opts),
+            moveToCompleted: (id, result, token) => context.moveJobToCompleted(id, result, token),
+            moveToFailed: (id, error, token) => context.moveJobToFailed(id, error, token),
+            moveToWait: (id, token) => context.moveJobToWait(id, token),
+            moveToDelayed: (id, timestamp, token) => context.moveJobToDelayed(id, timestamp, token),
+            moveToWaitingChildren: (id, token, opts) => context.moveJobToWaitingChildren(id, token, opts),
+            waitUntilFinished: (id, queueEvents, ttl) => context.waitJobUntilFinished(id, queueEvents, ttl),
+            removeDeduplicationKey: (id) => removeJobDeduplicationKey(id, true, null),
+            discard: (id) => {
+                void manager.discard(jobId(id));
+            },
+            getFailedChildrenValues: (id) => manager.getFailedChildrenValues(jobId(id)),
+            getIgnoredChildrenFailures: (id) => manager.getIgnoredChildrenFailures(jobId(id)),
+            removeChildDependency: (id) => manager.removeChildDependency(jobId(id)),
+            removeUnprocessedChildren: async (id) => {
+                await manager.removeUnprocessedChildren(jobId(id));
+            },
+        });
+    }
+    const tcp = context.tcp;
+    const response = await tcp.send(buildPushPayload(context.name, jobName, jobData, merged));
+    if (!response.ok) {
+        throw new Error(response.error ?? 'Failed to add job');
+    }
+    return createJobProxy(response.id, jobName, data, {
+        queueName: context.name,
+        tcp,
+        getJobState: context.getJobState,
+        removeAsync: context.removeAsync,
+        retryJob: context.retryJob,
+        getChildrenValues: context.getChildrenValues,
+    }, { priority: merged.priority, delay: merged.delay, opts: merged });
+}

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

@@ -1,47 +1,2 @@
-/**
- * Queue Add Operations
- * add, addBulk methods
- */
-import type { TcpConnectionPool } from '../../tcpPool';
-import type { Job, JobOptions, QueueOptions, JobStateType, GetDependenciesOpts, JobDependencies, JobDependenciesCount } from '../../types';
-interface AddContext {
-    name: string;
-    opts: QueueOptions;
-    embedded: boolean;
-    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>>;
-    updateJobData: (id: string, data: unknown) => Promise<void>;
-    promoteJob: (id: string) => Promise<void>;
-    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>;
-    getJobDependencies: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependencies>;
-    getJobDependenciesCount: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>;
-    moveJobToCompleted: (id: string, result: unknown, token?: string) => Promise<unknown>;
-    moveJobToFailed: (id: string, error: Error, token?: string) => Promise<void>;
-    moveJobToWait: (id: string, token?: string) => Promise<boolean>;
-    moveJobToDelayed: (id: string, timestamp: number, token?: string) => Promise<void>;
-    moveJobToWaitingChildren: (id: string, token?: string, opts?: {
-        child?: {
-            id: string;
-            queue: string;
-        };
-    }) => Promise<boolean>;
-    waitJobUntilFinished: (id: string, queueEvents: unknown, ttl?: number) => Promise<unknown>;
-}
-/** Add a single job */
-export declare function add<T>(ctx: AddContext, jobName: string, data: T, opts?: JobOptions): Promise<Job<T>>;
-/** Add multiple jobs in bulk */
-export declare function addBulk<T>(ctx: AddContext, jobs: Array<{
-    name: string;
-    data: T;
-    opts?: JobOptions;
-}>): Promise<Job<T>[]>;
-export {};
+export { addBulk } from './add/bulk';
+export { add } from './add/single';

package/dist/client/queue/operations/add.js

@@ -1,364 +1,2 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/**
- * Queue Add Operations
- * add, addBulk methods
- */
-import { getSharedManager } from '../../manager';
-import { toPublicJob } from '../../types';
-import { jobId } from '../../../domain/types/job';
-import { createJobProxy, createSimpleJob } from '../jobProxy';
-import { removeJobDeduplicationKey } from '../../jobDeduplication';
-/** Add a single job */
-export async function add(ctx, jobName, data, opts = {}) {
-    const merged = { ...ctx.opts.defaultJobOptions, ...opts };
-    // Add parent info to data if specified
-    const jobData = { name: jobName, ...data };
-    if (merged.parent) {
-        jobData.__parentId = merged.parent.id;
-        jobData.__parentQueue = merged.parent.queue;
-    }
-    if (ctx.embedded) {
-        const manager = getSharedManager();
-        const removeOnComplete = typeof merged.removeOnComplete === 'boolean' ? merged.removeOnComplete : false;
-        const removeOnFail = typeof merged.removeOnFail === 'boolean' ? merged.removeOnFail : false;
-        const repeat = merged.repeat
-            ? {
-                every: merged.repeat.every,
-                limit: merged.repeat.limit,
-                pattern: merged.repeat.pattern,
-                count: merged.repeat.count,
-                startDate: parseDate(merged.repeat.startDate),
-                endDate: parseDate(merged.repeat.endDate),
-                tz: merged.repeat.tz,
-                immediately: merged.repeat.immediately,
-                prevMillis: merged.repeat.prevMillis,
-                offset: merged.repeat.offset,
-                jobId: merged.repeat.jobId,
-            }
-            : undefined;
-        const job = await manager.push(ctx.name, {
-            data: jobData,
-            priority: merged.priority,
-            delay: merged.delay,
-            maxAttempts: merged.attempts,
-            backoff: merged.backoff,
-            ttl: merged.ttl,
-            timeout: merged.timeout,
-            uniqueKey: merged.deduplication?.id,
-            // Only an explicit jobId becomes the customId. The dedup id is carried by
-            // `uniqueKey` above into handleDeduplication (suppress/replace/extend). If we
-            // also mirrored it into customId, handleCustomId would short-circuit the re-add
-            // as an idempotent no-op BEFORE replace/extend run — silently dropping them in
-            // embedded mode. TCP/bulk already use `customId: jobId` only; this matches them.
-            customId: merged.jobId,
-            dependsOn: merged.dependsOn?.map((id) => jobId(id)),
-            tags: merged.tags,
-            groupId: merged.groupId,
-            dedup: merged.deduplication
-                ? {
-                    ttl: merged.deduplication.ttl,
-                    extend: merged.deduplication.extend,
-                    replace: merged.deduplication.replace,
-                }
-                : undefined,
-            lifo: merged.lifo,
-            removeOnComplete,
-            removeOnFail,
-            stallTimeout: merged.stallTimeout,
-            durable: merged.durable,
-            repeat,
-            parentId: merged.parent ? jobId(merged.parent.id) : undefined,
-            // BullMQ v5 options
-            stackTraceLimit: merged.stackTraceLimit,
-            keepLogs: merged.keepLogs,
-            sizeLimit: merged.sizeLimit,
-            failParentOnFailure: merged.failParentOnFailure,
-            removeDependencyOnFailure: merged.removeDependencyOnFailure,
-            continueParentOnFailure: merged.continueParentOnFailure,
-            ignoreDependencyOnFailure: merged.ignoreDependencyOnFailure,
-            timestamp: merged.timestamp,
-            debounceId: merged.debounce?.id,
-            debounceTtl: merged.debounce?.ttl,
-        });
-        return toPublicJob({
-            job,
-            name: jobName,
-            updateProgress: async (jid, progress, message) => {
-                await manager.updateProgress(jobId(jid), progress, message);
-            },
-            log: async (jid, message) => {
-                manager.addLog(jobId(jid), message);
-            },
-            getState: (jid) => ctx.getJobState(jid),
-            remove: (jid) => ctx.removeAsync(jid),
-            retry: (jid) => ctx.retryJob(jid),
-            getChildrenValues: (jid) => ctx.getChildrenValues(jid),
-            updateData: (jid, d) => ctx.updateJobData(jid, d),
-            promote: (jid) => ctx.promoteJob(jid),
-            changeDelay: (jid, delay) => ctx.changeJobDelay(jid, delay),
-            changePriority: (jid, o) => ctx.changeJobPriority(jid, o),
-            extendLock: (jid, token, duration) => ctx.extendJobLock(jid, token, duration),
-            clearLogs: (jid, keepLogs) => ctx.clearJobLogs(jid, keepLogs),
-            getDependencies: (jid, o) => ctx.getJobDependencies(jid, o),
-            getDependenciesCount: (jid, o) => ctx.getJobDependenciesCount(jid, o),
-            moveToCompleted: (jid, result, token) => ctx.moveJobToCompleted(jid, result, token),
-            moveToFailed: (jid, error, token) => ctx.moveJobToFailed(jid, error, token),
-            moveToWait: (jid, token) => ctx.moveJobToWait(jid, token),
-            moveToDelayed: (jid, timestamp, token) => ctx.moveJobToDelayed(jid, timestamp, token),
-            moveToWaitingChildren: (jid, token, o) => ctx.moveJobToWaitingChildren(jid, token, o),
-            waitUntilFinished: (jid, queueEvents, ttl) => ctx.waitJobUntilFinished(jid, queueEvents, ttl),
-            removeDeduplicationKey: (jid) => removeJobDeduplicationKey(jid, true, null),
-            discard: (jid) => {
-                void manager.discard(jobId(jid));
-            },
-            getFailedChildrenValues: (jid) => manager.getFailedChildrenValues(jobId(jid)),
-            getIgnoredChildrenFailures: (jid) => manager.getIgnoredChildrenFailures(jobId(jid)),
-            removeChildDependency: (jid) => manager.removeChildDependency(jobId(jid)),
-            removeUnprocessedChildren: async (jid) => {
-                await manager.removeUnprocessedChildren(jobId(jid));
-            },
-        });
-    }
-    // TCP mode — forward the full option set so nothing is silently dropped (#88)
-    const tcp = ctx.tcp;
-    const response = await tcp.send(buildPushPayload(ctx.name, jobData, merged));
-    if (!response.ok) {
-        throw new Error(response.error ?? 'Failed to add job');
-    }
-    const jobIdStr = response.id;
-    return createJobProxy(jobIdStr, jobName, data, {
-        queueName: ctx.name,
-        tcp,
-        getJobState: ctx.getJobState,
-        removeAsync: ctx.removeAsync,
-        retryJob: ctx.retryJob,
-        getChildrenValues: ctx.getChildrenValues,
-    }, { priority: merged.priority, delay: merged.delay, opts: merged });
-}
-/**
- * Strip undefined-valued keys so the msgpack frame stays compact. Sending a
- * field as `undefined` still serializes a nil entry; for large batches this
- * bloats the frame (and intermittently trips large-frame delivery). Omitting
- * undefined keeps option-less jobs minimal while still forwarding real options.
- */
-function compact(obj) {
-    const out = {};
-    for (const k in obj) {
-        if (obj[k] !== undefined)
-            out[k] = obj[k];
-    }
-    return out;
-}
-/** Build the compacted PUSH command payload, forwarding the full option set (#88) */
-function buildPushPayload(queue, jobData, m) {
-    return compact({
-        cmd: 'PUSH',
-        queue,
-        data: jobData,
-        priority: m.priority,
-        delay: m.delay,
-        maxAttempts: m.attempts,
-        backoff: m.backoff,
-        ttl: m.ttl,
-        timeout: m.timeout,
-        jobId: m.jobId,
-        uniqueKey: m.deduplication?.id,
-        dedup: m.deduplication
-            ? {
-                ttl: m.deduplication.ttl,
-                extend: m.deduplication.extend,
-                replace: m.deduplication.replace,
-            }
-            : undefined,
-        dependsOn: m.dependsOn,
-        tags: m.tags,
-        groupId: m.groupId,
-        lifo: m.lifo,
-        // Coerce to boolean for parity with embedded (which ignores non-boolean). #90
-        removeOnComplete: typeof m.removeOnComplete === 'boolean' ? m.removeOnComplete : undefined,
-        removeOnFail: typeof m.removeOnFail === 'boolean' ? m.removeOnFail : undefined,
-        stallTimeout: m.stallTimeout,
-        stackTraceLimit: m.stackTraceLimit,
-        keepLogs: m.keepLogs,
-        sizeLimit: m.sizeLimit,
-        failParentOnFailure: m.failParentOnFailure,
-        removeDependencyOnFailure: m.removeDependencyOnFailure,
-        continueParentOnFailure: m.continueParentOnFailure,
-        ignoreDependencyOnFailure: m.ignoreDependencyOnFailure,
-        debounceId: m.debounce?.id,
-        debounceTtl: m.debounce?.ttl,
-        timestamp: m.timestamp,
-        durable: m.durable,
-        repeat: m.repeat,
-        parentId: m.parent?.id,
-    });
-}
-/** Build the data payload for a bulk job, injecting parent refs when present */
-function buildBulkData(name, data, m) {
-    const jobData = { name, ...data };
-    if (m.parent) {
-        jobData.__parentId = m.parent.id;
-        jobData.__parentQueue = m.parent.queue;
-    }
-    return jobData;
-}
-/** Reflection meta so the returned bulk Job reflects the requested options (#88) */
-function reflectionMeta(m) {
-    return { priority: m.priority, delay: m.delay, opts: m };
-}
-/** Add multiple jobs in bulk */
-export async function addBulk(ctx, jobs) {
-    if (jobs.length === 0)
-        return [];
-    const now = Date.now();
-    // Merge defaults once per job so input building and reflection stay in sync
-    const merged = jobs.map(({ opts }) => ({
-        ...ctx.opts.defaultJobOptions,
-        ...opts,
-    }));
-    if (ctx.embedded) {
-        const manager = getSharedManager();
-        const inputs = jobs.map(({ name, data }, i) => {
-            const m = merged[i];
-            const removeOnComplete = typeof m.removeOnComplete === 'boolean' ? m.removeOnComplete : false;
-            const removeOnFail = typeof m.removeOnFail === 'boolean' ? m.removeOnFail : false;
-            return {
-                data: buildBulkData(name, data, m),
-                priority: m.priority,
-                delay: m.delay,
-                maxAttempts: m.attempts,
-                backoff: m.backoff,
-                timeout: m.timeout,
-                ttl: m.ttl,
-                customId: m.jobId,
-                uniqueKey: m.deduplication?.id,
-                dependsOn: m.dependsOn?.map((id) => jobId(id)),
-                parentId: m.parent ? jobId(m.parent.id) : undefined,
-                tags: m.tags,
-                groupId: m.groupId,
-                stallTimeout: m.stallTimeout,
-                timestamp: m.timestamp,
-                removeOnComplete,
-                removeOnFail,
-                repeat: m.repeat
-                    ? {
-                        every: m.repeat.every,
-                        limit: m.repeat.limit,
-                        pattern: m.repeat.pattern,
-                        count: m.repeat.count,
-                        startDate: parseDate(m.repeat.startDate),
-                        endDate: parseDate(m.repeat.endDate),
-                        tz: m.repeat.tz,
-                        immediately: m.repeat.immediately,
-                        prevMillis: m.repeat.prevMillis,
-                        offset: m.repeat.offset,
-                        jobId: m.repeat.jobId,
-                    }
-                    : undefined,
-                durable: m.durable,
-                // BullMQ v5 options
-                lifo: m.lifo,
-                stackTraceLimit: m.stackTraceLimit,
-                keepLogs: m.keepLogs,
-                sizeLimit: m.sizeLimit,
-                failParentOnFailure: m.failParentOnFailure,
-                removeDependencyOnFailure: m.removeDependencyOnFailure,
-                continueParentOnFailure: m.continueParentOnFailure,
-                ignoreDependencyOnFailure: m.ignoreDependencyOnFailure,
-                dedup: m.deduplication
-                    ? {
-                        ttl: m.deduplication.ttl,
-                        extend: m.deduplication.extend,
-                        replace: m.deduplication.replace,
-                    }
-                    : undefined,
-                debounceId: m.debounce?.id,
-                debounceTtl: m.debounce?.ttl,
-            };
-        });
-        const ids = await manager.pushBatch(ctx.name, inputs);
-        return ids.map((id, i) => createSimpleJob(String(id), jobs[i].name, jobs[i].data, now, {
-            queueName: ctx.name,
-            embedded: ctx.embedded,
-            tcp: ctx.tcp,
-            getJobState: ctx.getJobState,
-            removeAsync: ctx.removeAsync,
-            retryJob: ctx.retryJob,
-            getChildrenValues: ctx.getChildrenValues,
-            meta: reflectionMeta(merged[i]),
-        }));
-    }
-    // TCP mode
-    const tcp = ctx.tcp;
-    const batchJobs = jobs.map(({ name, data }, i) => {
-        const m = merged[i];
-        const removeOnComplete = typeof m.removeOnComplete === 'boolean' ? m.removeOnComplete : false;
-        const removeOnFail = typeof m.removeOnFail === 'boolean' ? m.removeOnFail : false;
-        return compact({
-            data: buildBulkData(name, data, m),
-            priority: m.priority,
-            delay: m.delay,
-            maxAttempts: m.attempts,
-            backoff: m.backoff,
-            timeout: m.timeout,
-            ttl: m.ttl,
-            customId: m.jobId,
-            tags: m.tags,
-            groupId: m.groupId,
-            dependsOn: m.dependsOn?.map((id) => jobId(id)),
-            parentId: m.parent ? jobId(m.parent.id) : undefined,
-            uniqueKey: m.deduplication?.id,
-            dedup: m.deduplication
-                ? {
-                    ttl: m.deduplication.ttl,
-                    extend: m.deduplication.extend,
-                    replace: m.deduplication.replace,
-                }
-                : undefined,
-            lifo: m.lifo,
-            stallTimeout: m.stallTimeout,
-            timestamp: m.timestamp,
-            removeOnComplete,
-            removeOnFail,
-            repeat: m.repeat,
-            durable: m.durable,
-            stackTraceLimit: m.stackTraceLimit,
-            keepLogs: m.keepLogs,
-            sizeLimit: m.sizeLimit,
-            failParentOnFailure: m.failParentOnFailure,
-            removeDependencyOnFailure: m.removeDependencyOnFailure,
-            continueParentOnFailure: m.continueParentOnFailure,
-            ignoreDependencyOnFailure: m.ignoreDependencyOnFailure,
-            debounceId: m.debounce?.id,
-            debounceTtl: m.debounce?.ttl,
-        });
-    });
-    const response = await tcp.send({
-        cmd: 'PUSHB',
-        queue: ctx.name,
-        jobs: batchJobs,
-    });
-    // Mirror the single-PUSH path (~line 168): a rejected response (e.g. auth
-    // failure) must propagate as a thrown error so the AddBatcher rejects the
-    // queued callers, instead of resolving them with undefined jobs. An OK
-    // response with zero jobs is a legitimate empty result and is NOT an error.
-    if (!response.ok) {
-        throw new Error(response.error ?? 'Failed to add jobs');
-    }
-    const ids = (response.ids ?? []);
-    return ids.map((id, i) => createJobProxy(id, jobs[i].name, jobs[i].data, {
-        queueName: ctx.name,
-        tcp,
-        getJobState: ctx.getJobState,
-        removeAsync: ctx.removeAsync,
-        retryJob: ctx.retryJob,
-        getChildrenValues: ctx.getChildrenValues,
-    }, reflectionMeta(merged[i])));
-}
-function parseDate(date) {
-    if (date instanceof Date)
-        return date.getTime();
-    if (typeof date === 'string')
-        return new Date(date).getTime();
-    return date;
-}
+export { addBulk } from './add/bulk';
+export { add } from './add/single';

package/dist/client/queue/operations/management.js

@@ -4,6 +4,7 @@
  */
 import { getSharedManager } from '../../manager';
 import { jobId } from '../../../domain/types/job';
+import { assertFlowTcpOk } from '../../flowJobTypes';
 // ============ Remove Operations ============
 /** Remove a job (sync, fire-and-forget; use removeAsync to await the removal) */
 export function remove(ctx, id) {
@@ -193,7 +194,7 @@ export async function updateJobData(ctx, id, data) {
         await getSharedManager().updateJobData(jobId(id), data);
         return;
     }
-    await ctx.tcp.send({ cmd: 'Update', id, data });
+    assertFlowTcpOk(await ctx.tcp.send({ cmd: 'Update', id, data }), 'Update');
 }
 /** Change job delay */
 export async function changeJobDelay(ctx, id, delay) {