bunqueue 2.8.0 → 2.8.2

package/dist/client/flowJobFactory.js

@@ -2,6 +2,8 @@
  * Flow Job Factory
  * Creates simple Job objects for FlowProducer results
  */
+import { getSharedManager } from './manager';
+import { jobId } from '../domain/types/job';
 /** Extract user data (remove internal fields like __parentId, __childrenIds, name) */
 export function extractUserDataFromInternal(data) {
     const result = {};
@@ -15,6 +17,37 @@ export function extractUserDataFromInternal(data) {
 /** Create a simple Job object for flow results */
 export function createFlowJobObject(id, name, data, queueName, callbacks) {
     const ts = Date.now();
+    const embedded = !!callbacks?.embedded;
+    const tcp = callbacks?.tcp ?? null;
+    const stateAsType = (s) => {
+        const valid = [
+            'waiting',
+            'active',
+            'completed',
+            'failed',
+            'delayed',
+            'prioritized',
+            'waiting-children',
+            'unknown',
+        ];
+        return (valid.includes(s) ? s : 'unknown');
+    };
+    const getStateInternal = () => {
+        if (callbacks?.getState)
+            return callbacks.getState(id).then(stateAsType);
+        if (embedded) {
+            return getSharedManager()
+                .getJobState(jobId(id))
+                .then((s) => stateAsType(s));
+        }
+        if (tcp) {
+            return tcp.send({ cmd: 'GetState', id }).then((r) => {
+                const s = r.state ?? 'unknown';
+                return stateAsType(s);
+            });
+        }
+        return Promise.resolve('unknown');
+    };
     return {
         id,
         name,
@@ -23,7 +56,6 @@ export function createFlowJobObject(id, name, data, queueName, callbacks) {
         attemptsMade: 0,
         timestamp: ts,
         progress: 0,
-        // BullMQ v5 properties
         delay: 0,
         processedOn: undefined,
         finishedOn: undefined,
@@ -37,47 +69,158 @@ export function createFlowJobObject(id, name, data, queueName, callbacks) {
         deduplicationId: undefined,
         repeatJobKey: undefined,
         attemptsStarted: 0,
-        // Methods - wired to callbacks when available, otherwise no-op
-        updateProgress: (progress) => callbacks?.updateProgress
-            ? callbacks.updateProgress(id, progress)
-            : Promise.resolve(),
-        log: (message) => (callbacks?.log ? callbacks.log(id, message) : Promise.resolve()),
-        getState: () => callbacks?.getState
-            ? callbacks.getState(id)
-            : Promise.resolve('waiting'),
-        remove: () => (callbacks?.remove ? callbacks.remove(id) : Promise.resolve()),
-        retry: () => (callbacks?.retry ? callbacks.retry(id) : Promise.resolve()),
-        getChildrenValues: () => Promise.resolve({}),
-        // BullMQ v5 state check methods
-        isWaiting: () => callbacks?.getState
-            ? callbacks.getState(id).then((s) => s === 'waiting')
-            : Promise.resolve(true),
-        isActive: () => callbacks?.getState
-            ? callbacks.getState(id).then((s) => s === 'active')
-            : Promise.resolve(false),
-        isDelayed: () => callbacks?.getState
-            ? callbacks.getState(id).then((s) => s === 'delayed')
-            : Promise.resolve(false),
-        isCompleted: () => callbacks?.getState
-            ? callbacks.getState(id).then((s) => s === 'completed')
-            : Promise.resolve(false),
-        isFailed: () => callbacks?.getState
-            ? callbacks.getState(id).then((s) => s === 'failed')
-            : Promise.resolve(false),
-        isWaitingChildren: () => Promise.resolve(false),
-        // BullMQ v5 mutation methods
-        updateData: (newData) => callbacks?.updateData ? callbacks.updateData(id, newData) : Promise.resolve(),
-        promote: () => (callbacks?.promote ? callbacks.promote(id) : Promise.resolve()),
-        changeDelay: (delay) => callbacks?.changeDelay ? callbacks.changeDelay(id, delay) : Promise.resolve(),
-        changePriority: (opts) => callbacks?.changePriority
-            ? callbacks.changePriority(id, opts.priority)
-            : Promise.resolve(),
-        extendLock: () => Promise.resolve(0),
-        clearLogs: () => (callbacks?.clearLogs ? callbacks.clearLogs(id) : Promise.resolve()),
-        // BullMQ v5 dependency methods
-        getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
-        getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
-        // BullMQ v5 serialization methods
+        updateProgress: async (progress) => {
+            if (callbacks?.updateProgress) {
+                return callbacks.updateProgress(id, progress);
+            }
+            if (embedded) {
+                await getSharedManager().updateProgress(jobId(id), progress);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'Progress', id, progress: progress });
+        },
+        log: async (message) => {
+            if (callbacks?.log)
+                return callbacks.log(id, message);
+            if (embedded) {
+                getSharedManager().addLog(jobId(id), message);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'AddLog', id, message });
+        },
+        getState: getStateInternal,
+        remove: async () => {
+            if (callbacks?.remove)
+                return callbacks.remove(id);
+            if (embedded) {
+                await getSharedManager().cancel(jobId(id));
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'Cancel', id });
+        },
+        retry: async () => {
+            if (callbacks?.retry)
+                return callbacks.retry(id);
+            if (embedded) {
+                const mgr = getSharedManager();
+                const state = await mgr.getJobState(jobId(id));
+                if (state === 'failed') {
+                    const count = mgr.retryDlq(queueName, jobId(id));
+                    if (count === 0)
+                        throw new Error(`Job ${id} is failed but not present in DLQ`);
+                    return;
+                }
+                if (state === 'active') {
+                    const ok = await mgr.moveActiveToWait(jobId(id));
+                    if (!ok)
+                        throw new Error(`Failed to retry active job ${id}`);
+                    return;
+                }
+                if (state === 'waiting' || state === 'prioritized' || state === 'delayed')
+                    return;
+                throw new Error(`Cannot retry job ${id} from state '${state}'`);
+            }
+            if (!tcp)
+                return;
+            const res = await tcp.send({ cmd: 'MoveToWait', id });
+            if (res.ok !== true) {
+                const err = typeof res.error === 'string' ? res.error : 'retry failed';
+                throw new Error(err);
+            }
+        },
+        getChildrenValues: async () => {
+            if (embedded) {
+                return (await getSharedManager().getChildrenValues(jobId(id)));
+            }
+            if (!tcp)
+                return {};
+            const res = await tcp.send({ cmd: 'GetChildrenValues', id });
+            const vals = res.data?.values ?? {};
+            return vals;
+        },
+        isWaiting: async () => (await getStateInternal()) === 'waiting',
+        isActive: async () => (await getStateInternal()) === 'active',
+        isDelayed: async () => (await getStateInternal()) === 'delayed',
+        isCompleted: async () => (await getStateInternal()) === 'completed',
+        isFailed: async () => (await getStateInternal()) === 'failed',
+        isWaitingChildren: async () => (await getStateInternal()) === 'waiting-children',
+        updateData: async (newData) => {
+            if (callbacks?.updateData)
+                return callbacks.updateData(id, newData);
+            if (embedded) {
+                await getSharedManager().updateJobData(jobId(id), newData);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'Update', id, data: newData });
+        },
+        promote: async () => {
+            if (callbacks?.promote)
+                return callbacks.promote(id);
+            if (embedded) {
+                await getSharedManager().promote(jobId(id));
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'Promote', id });
+        },
+        changeDelay: async (delay) => {
+            if (callbacks?.changeDelay)
+                return callbacks.changeDelay(id, delay);
+            if (embedded) {
+                await getSharedManager().changeDelay(jobId(id), delay);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'ChangeDelay', id, delay });
+        },
+        changePriority: async (opts) => {
+            if (callbacks?.changePriority) {
+                return callbacks.changePriority(id, { priority: opts.priority, lifo: opts.lifo });
+            }
+            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 (callbacks?.clearLogs)
+                return callbacks.clearLogs(id);
+            if (embedded) {
+                getSharedManager().clearLogs(jobId(id), keepLogs);
+                return;
+            }
+            if (tcp)
+                await tcp.send({ cmd: 'ClearLogs', id, keepLogs });
+        },
+        getDependencies: async () => {
+            const childIds = await fetchChildIds(id, embedded, tcp);
+            return computeDepsFlow(queueName, childIds, embedded, tcp);
+        },
+        getDependenciesCount: async () => {
+            const childIds = await fetchChildIds(id, embedded, tcp);
+            const deps = await computeDepsFlow(queueName, childIds, embedded, tcp);
+            return {
+                processed: Object.keys(deps.processed).length,
+                unprocessed: deps.unprocessed.length,
+            };
+        },
         toJSON: () => ({
             id,
             name,
@@ -101,20 +244,148 @@ export function createFlowJobObject(id, name, data, queueName, callbacks) {
             attemptsMade: '0',
             stacktrace: null,
         }),
-        // BullMQ v5 move methods
-        moveToCompleted: () => Promise.resolve(null),
-        moveToFailed: () => Promise.resolve(),
-        moveToWait: () => Promise.resolve(false),
-        moveToDelayed: () => Promise.resolve(),
-        moveToWaitingChildren: () => Promise.resolve(false),
-        waitUntilFinished: () => Promise.resolve(undefined),
-        // BullMQ v5 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)
+                return await getSharedManager().moveActiveToWait(jobId(id));
+            if (!tcp)
+                return false;
+            const res = await tcp.send({ cmd: 'MoveToWait', id });
+            return res.ok === true;
+        },
+        moveToDelayed: async (timestamp) => {
+            const delay = Math.max(0, timestamp - 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=flowJobFactory.js.map
+async function fetchChildIds(id, embedded, tcp) {
+    if (embedded) {
+        const job = await getSharedManager().getJob(jobId(id));
+        return (job?.childrenIds ?? []).map(String);
+    }
+    if (!tcp)
+        return [];
+    const jobRes = await tcp.send({ cmd: 'GetJob', id });
+    const parent = jobRes.job;
+    return (parent?.childrenIds ?? []).map(String);
+}
+async function computeDepsFlow(queueName, childIds, embedded, tcp) {
+    const processed = {};
+    const unprocessed = [];
+    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/flowPush.d.ts

@@ -24,4 +24,3 @@ export interface PushWithParentOpts {
 export declare function pushJobWithParent(ctx: PushContext, params: PushWithParentOpts): Promise<string>;
 /** Cleanup jobs that were created before a failure occurred */
 export declare function cleanupJobs(ctx: PushContext, jobIds: string[]): Promise<void>;
-//# sourceMappingURL=flowPush.d.ts.map

package/dist/client/flowPush.js

@@ -11,25 +11,101 @@ function parseRemoveOptions(opts) {
         removeOnFail: typeof opts.removeOnFail === 'boolean' ? opts.removeOnFail : false,
     };
 }
+/** Normalize repeat startDate/endDate to epoch ms for the embedded manager. */
+function normalizeRepeat(repeat) {
+    if (!repeat)
+        return undefined;
+    const toMs = (d) => d instanceof Date ? d.getTime() : typeof d === 'string' ? new Date(d).getTime() : d;
+    return {
+        every: repeat.every,
+        limit: repeat.limit,
+        pattern: repeat.pattern,
+        count: repeat.count,
+        startDate: toMs(repeat.startDate),
+        endDate: toMs(repeat.endDate),
+        tz: repeat.tz,
+        immediately: repeat.immediately,
+        prevMillis: repeat.prevMillis,
+        offset: repeat.offset,
+        jobId: repeat.jobId,
+    };
+}
+function dedupConfig(opts) {
+    return opts.deduplication
+        ? {
+            ttl: opts.deduplication.ttl,
+            extend: opts.deduplication.extend,
+            replace: opts.deduplication.replace,
+        }
+        : undefined;
+}
+/**
+ * Full option set for the embedded manager.push, mirroring Queue.add (#90).
+ * Flow nodes must forward the same options as a direct add, not a subset.
+ */
+function managerOptions(opts) {
+    return {
+        priority: opts.priority,
+        delay: opts.delay,
+        maxAttempts: opts.attempts,
+        backoff: opts.backoff,
+        timeout: opts.timeout,
+        customId: opts.jobId ?? opts.deduplication?.id,
+        uniqueKey: opts.deduplication?.id,
+        dedup: dedupConfig(opts),
+        lifo: opts.lifo,
+        stallTimeout: opts.stallTimeout,
+        durable: opts.durable,
+        stackTraceLimit: opts.stackTraceLimit,
+        keepLogs: opts.keepLogs,
+        sizeLimit: opts.sizeLimit,
+        timestamp: opts.timestamp,
+        repeat: normalizeRepeat(opts.repeat),
+        debounceId: opts.debounce?.id,
+        debounceTtl: opts.debounce?.ttl,
+        failParentOnFailure: opts.failParentOnFailure,
+        removeDependencyOnFailure: opts.removeDependencyOnFailure,
+        ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
+        continueParentOnFailure: opts.continueParentOnFailure,
+    };
+}
+/** Full option set for the TCP PUSH command, mirroring buildPushPayload in add.ts (#90). */
+function tcpOptions(opts) {
+    return {
+        priority: opts.priority,
+        delay: opts.delay,
+        maxAttempts: opts.attempts,
+        backoff: opts.backoff,
+        timeout: opts.timeout,
+        jobId: opts.jobId,
+        uniqueKey: opts.deduplication?.id,
+        dedup: dedupConfig(opts),
+        lifo: opts.lifo,
+        stallTimeout: opts.stallTimeout,
+        durable: opts.durable,
+        stackTraceLimit: opts.stackTraceLimit,
+        keepLogs: opts.keepLogs,
+        sizeLimit: opts.sizeLimit,
+        timestamp: opts.timestamp,
+        repeat: opts.repeat,
+        debounceId: opts.debounce?.id,
+        debounceTtl: opts.debounce?.ttl,
+        failParentOnFailure: opts.failParentOnFailure,
+        removeDependencyOnFailure: opts.removeDependencyOnFailure,
+        ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
+        continueParentOnFailure: opts.continueParentOnFailure,
+    };
+}
 /** Push a job via embedded manager or TCP */
 export async function pushJob(ctx, queueName, data, opts = {}, dependsOn) {
+    const { removeOnComplete, removeOnFail } = parseRemoveOptions(opts);
     if (ctx.embedded) {
         const manager = getSharedManager();
-        const { removeOnComplete, removeOnFail } = parseRemoveOptions(opts);
         const job = await manager.push(queueName, {
             data,
-            priority: opts.priority,
-            delay: opts.delay,
-            maxAttempts: opts.attempts,
-            backoff: opts.backoff,
-            timeout: opts.timeout,
-            customId: opts.jobId,
+            ...managerOptions(opts),
             removeOnComplete,
             removeOnFail,
-            failParentOnFailure: opts.failParentOnFailure,
-            removeDependencyOnFailure: opts.removeDependencyOnFailure,
-            ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
-            continueParentOnFailure: opts.continueParentOnFailure,
             dependsOn: dependsOn?.map((id) => jobId(id)),
         });
         return String(job.id);
@@ -40,18 +116,9 @@ export async function pushJob(ctx, queueName, data, opts = {}, dependsOn) {
         cmd: 'PUSH',
         queue: queueName,
         data,
-        priority: opts.priority,
-        delay: opts.delay,
-        maxAttempts: opts.attempts,
-        backoff: opts.backoff,
-        timeout: opts.timeout,
-        jobId: opts.jobId,
-        removeOnComplete: opts.removeOnComplete,
-        removeOnFail: opts.removeOnFail,
-        failParentOnFailure: opts.failParentOnFailure,
-        removeDependencyOnFailure: opts.removeDependencyOnFailure,
-        ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
-        continueParentOnFailure: opts.continueParentOnFailure,
+        ...tcpOptions(opts),
+        removeOnComplete,
+        removeOnFail,
         dependsOn,
     });
     if (!response.ok) {
@@ -62,24 +129,15 @@ export async function pushJob(ctx, queueName, data, opts = {}, dependsOn) {
 /** Push a job with parent/children tracking */
 export async function pushJobWithParent(ctx, params) {
     const { queueName, data, opts, parentRef, childIds } = params;
+    const { removeOnComplete, removeOnFail } = parseRemoveOptions(opts);
     if (ctx.embedded) {
         const manager = getSharedManager();
-        const { removeOnComplete, removeOnFail } = parseRemoveOptions(opts);
         const childJobIds = childIds.map((id) => jobId(id));
         const job = await manager.push(queueName, {
             data,
-            priority: opts.priority,
-            delay: opts.delay,
-            maxAttempts: opts.attempts,
-            backoff: opts.backoff,
-            timeout: opts.timeout,
-            customId: opts.jobId,
+            ...managerOptions(opts),
             removeOnComplete,
             removeOnFail,
-            failParentOnFailure: opts.failParentOnFailure,
-            removeDependencyOnFailure: opts.removeDependencyOnFailure,
-            ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
-            continueParentOnFailure: opts.continueParentOnFailure,
             parentId: parentRef ? jobId(parentRef.id) : undefined,
             dependsOn: childJobIds.length > 0 ? childJobIds : undefined,
             childrenIds: childJobIds.length > 0 ? childJobIds : undefined,
@@ -97,18 +155,9 @@ export async function pushJobWithParent(ctx, params) {
         cmd: 'PUSH',
         queue: queueName,
         data,
-        priority: opts.priority,
-        delay: opts.delay,
-        maxAttempts: opts.attempts,
-        backoff: opts.backoff,
-        timeout: opts.timeout,
-        jobId: opts.jobId,
-        removeOnComplete: opts.removeOnComplete,
-        removeOnFail: opts.removeOnFail,
-        failParentOnFailure: opts.failParentOnFailure,
-        removeDependencyOnFailure: opts.removeDependencyOnFailure,
-        ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
-        continueParentOnFailure: opts.continueParentOnFailure,
+        ...tcpOptions(opts),
+        removeOnComplete,
+        removeOnFail,
         parentId: parentRef?.id,
         childrenIds: childIds.length > 0 ? childIds : undefined,
         dependsOn: childIds.length > 0 ? childIds : undefined,
@@ -153,4 +202,3 @@ export async function cleanupJobs(ctx, jobIds) {
         await Promise.all(cleanupPromises);
     }
 }
-//# sourceMappingURL=flowPush.js.map

package/dist/client/flowTypes.d.ts

@@ -75,4 +75,3 @@ export interface FlowOpts {
     /** Default job options per queue name */
     queuesOptions?: Record<string, Partial<JobOptions>>;
 }
-//# sourceMappingURL=flowTypes.d.ts.map

package/dist/client/flowTypes.js

@@ -3,4 +3,3 @@
  * Type definitions for job flows and pipelines
  */
 export {};
-//# sourceMappingURL=flowTypes.js.map

package/dist/client/index.d.ts

@@ -37,4 +37,3 @@ export type { Job, JobOptions, JobJson, JobJsonRaw, QueueOptions, WorkerOptions,
 export type { FlowStep, FlowResult, FlowJob, JobNode, FlowProducerOptions, FlowOpts } from './flow';
 export type { RepeatOpts, JobTemplate, SchedulerInfo } from './queue/scheduler';
 export type { SandboxedWorkerOptions } from './sandboxedWorker';
-//# sourceMappingURL=index.d.ts.map

package/dist/client/index.js

@@ -30,4 +30,3 @@ export { UnrecoverableError, DelayedError } from './errors';
 export { shutdownManager } from './manager';
 export { closeSharedTcpClient } from './tcpClient';
 export { TcpConnectionPool, getSharedPool, closeAllSharedPools } from './tcpPool';
-//# sourceMappingURL=index.js.map

package/dist/client/jobConversion.d.ts

@@ -12,4 +12,3 @@ export declare function createPublicJob<T>(opts: CreatePublicJobOptions): Job<T>
 export declare function toPublicJob<T>(opts: ToPublicJobOptions): Job<T>;
 /** Convert internal DLQ entry to public DLQ entry */
 export declare function toDlqEntry<T>(entry: InternalDlqEntry): DlqEntry<T>;
-//# sourceMappingURL=jobConversion.d.ts.map