bunqueue 2.8.53 → 2.8.56

package/dist/client/flow.js

@@ -13,6 +13,7 @@ import { assertFlowTcpOk } from './flowJobTypes';
 import { planFlows } from './flowPlan';
 import { planBulkThen, planChain, planTree } from './flowLegacyPlan';
 import { readFlow } from './flowReader';
+import { getParentResult as readParentResult, getParentResults as readParentResults, } from './flowResults';
 const FORCE_EMBEDDED = Bun.env.BUNQUEUE_EMBEDDED === '1';
 /**
  * FlowProducer creates job flows with automatic dependencies.
@@ -39,11 +40,10 @@ const FORCE_EMBEDDED = Bun.env.BUNQUEUE_EMBEDDED === '1';
  * ```
  */
 export class FlowProducer extends EventEmitter {
-    closing = Promise.resolve();
+    closing = null;
     embedded;
     tcp;
     useSharedPool;
-    closed = false;
     constructor(opts = {}) {
         super();
         this.embedded = opts.embedded ?? FORCE_EMBEDDED;
@@ -91,16 +91,14 @@ export class FlowProducer extends EventEmitter {
     }
     /** Close the connection pool (only if using dedicated pool) */
     close() {
-        if (this.closed)
+        if (this.closing)
             return this.closing;
-        this.closed = true;
-        if (this.tcp && !this.useSharedPool) {
-            this.tcp.close();
-        }
-        else if (this.tcp && this.useSharedPool) {
-            releaseSharedPool(this.tcp);
-        }
-        this.closing = Promise.resolve();
+        this.closing = Promise.resolve().then(() => {
+            if (this.tcp && !this.useSharedPool)
+                this.tcp.close();
+            else if (this.tcp)
+                releaseSharedPool(this.tcp);
+        });
         return this.closing;
     }
     /** Disconnect from the server (BullMQ v5 compatible). Alias for close(). */
@@ -131,6 +129,7 @@ export class FlowProducer extends EventEmitter {
         return plan.roots.map((root) => this.buildPlannedNode(root, snapshotsById));
     }
     /** Get a flow tree starting from a job (BullMQ v5 compatible). */
+    // biome-ignore lint/suspicious/useAwait: preserves the public Promise return contract.
     async getFlow(opts) {
         return readFlow({
             embedded: this.embedded,
@@ -164,31 +163,14 @@ export class FlowProducer extends EventEmitter {
         await commitFlow(this.pushCtx, plan.batch);
         return { jobIds: plan.ids.map(String) };
     }
-    /**
-     * Get the result of a completed parent job (embedded only).
-     * @template R - Type of the job result
-     */
+    /** Get the result of a completed parent job in embedded or TCP mode. */
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
     getParentResult(parentId) {
-        if (!this.embedded)
-            throw new Error('getParentResult is only available in embedded mode');
-        return getSharedManager().getResult(jobId(parentId));
-    }
-    /**
-     * Get results from multiple parent jobs (embedded only).
-     * @template R - Type of the job results
-     */
+        return readParentResult({ embedded: this.embedded, tcp: this.tcp }, parentId);
+    }
+    /** Get results from multiple parent jobs in input order in either runtime. */
     getParentResults(parentIds) {
-        if (!this.embedded)
-            throw new Error('getParentResults is only available in embedded mode');
-        const manager = getSharedManager();
-        const results = new Map();
-        for (const id of parentIds) {
-            const result = manager.getResult(jobId(id));
-            if (result !== undefined)
-                results.set(id, result);
-        }
-        return results;
+        return readParentResults({ embedded: this.embedded, tcp: this.tcp }, parentIds);
     }
     // ============================================================================
     // Private Methods
@@ -216,7 +198,7 @@ export class FlowProducer extends EventEmitter {
             embedded: true,
             updateData: (id, data) => managementOps.updateJobData(ctx, id, data),
             updateProgress: (id, progress) => managementOps.updateJobProgress(ctx, id, progress),
-            log: (id, msg) => managementOps.addJobLog(ctx, id, msg).then(() => { }),
+            log: (id, msg) => managementOps.addJobLog(ctx, id, msg).then(() => undefined),
             promote: (id) => managementOps.promoteJob(ctx, id),
             remove: (id) => managementOps.removeAsync(ctx, id),
             changePriority: (id, opts) => managementOps.changeJobPriority(ctx, id, opts),

package/dist/client/flowJobDependencies.js

@@ -5,12 +5,14 @@ async function fetchChildIds(id, embedded, tcp) {
     if (embedded) {
         const job = await getSharedManager().getJob(jobId(id));
         if (!job)
-            throw new Error(`Flow job ${id} not found`);
+            return [];
         return job.childrenIds.map(String);
     }
     if (!tcp)
         return [];
     const response = await tcp.send({ cmd: 'GetJob', id });
+    if (response.ok !== true && response.error === 'Job not found')
+        return [];
     assertFlowTcpOk(response, 'GetJob');
     const parent = response.job;
     return (parent?.childrenIds ?? []).map(String);

package/dist/client/flowJobFactory.d.ts

@@ -6,8 +6,16 @@ import type { Job as DomainJob } from '../domain/types/job';
 import type { FlowJobCallbacks } from './flowJobTypes';
 import type { Job } from './types';
 export type { FlowJobCallbacks } from './flowJobTypes';
-/** Extract user data while removing internal flow metadata and the stored job name. */
+/** Decode historical flow envelopes for callers that only have the data field. */
 export declare function extractUserDataFromInternal(data: Record<string, unknown>): unknown;
+/** Resolve a stored flow node while preserving a modern user `data.name` field. */
+export declare function extractFlowJobPayload(job: {
+    readonly name?: unknown;
+    readonly data?: unknown;
+}): {
+    name: string;
+    data: unknown;
+};
 interface FlowJobObjectOptions {
     callbacks?: FlowJobCallbacks;
     snapshot?: DomainJob;

package/dist/client/flowJobFactory.js

@@ -2,7 +2,7 @@
  * Flow Job Factory
  * Creates BullMQ-compatible Job objects backed by FlowProducer transports.
  */
-import { jobId } from '../domain/types/job';
+import { jobId, normalizeLegacyJobPayload } from '../domain/types/job';
 import { buildJobProperties, buildSerializationMethods } from './jobConversionHelpers';
 import { buildJobOpts } from './jobHelpers';
 import { buildFlowJobCoreMethods } from './flowJobCoreMethods';
@@ -22,14 +22,16 @@ function stateAsType(state) {
     return JOB_STATES.has(state) ? state : 'unknown';
 }
 function buildStateResolver(id, callbacks) {
-    if (callbacks?.getState) {
-        return () => callbacks.getState(id).then(stateAsType);
+    const getState = callbacks?.getState;
+    if (getState) {
+        return () => getState(id).then(stateAsType);
     }
     if (callbacks?.embedded) {
         return () => getSharedManager().getJobState(jobId(id)).then(stateAsType);
     }
-    if (callbacks?.tcp) {
-        return () => callbacks.tcp.send({ cmd: 'GetState', id }).then((response) => {
+    const tcp = callbacks?.tcp;
+    if (tcp) {
+        return () => tcp.send({ cmd: 'GetState', id }).then((response) => {
             if (response.ok !== true) {
                 throw new Error(typeof response.error === 'string' ? response.error : 'GetState failed');
             }
@@ -65,15 +67,25 @@ function defaultSerialization(id, name, data, queueName, timestamp) {
         }),
     };
 }
-/** Extract user data while removing internal flow metadata and the stored job name. */
-export function extractUserDataFromInternal(data) {
+function stripFlowMetadata(data) {
+    if (typeof data !== 'object' || data === null || Array.isArray(data))
+        return data;
     const result = {};
     for (const [key, value] of Object.entries(data)) {
-        if (!key.startsWith('__') && key !== 'name')
+        if (!key.startsWith('__'))
             result[key] = value;
     }
     return result;
 }
+/** Decode historical flow envelopes for callers that only have the data field. */
+export function extractUserDataFromInternal(data) {
+    return stripFlowMetadata(normalizeLegacyJobPayload({ data }).data);
+}
+/** Resolve a stored flow node while preserving a modern user `data.name` field. */
+export function extractFlowJobPayload(job) {
+    const payload = normalizeLegacyJobPayload({ name: job.name, data: job.data });
+    return { name: payload.name, data: stripFlowMetadata(payload.data) };
+}
 /** Create a Job object for a newly committed or fetched flow node. */
 export function createFlowJobObject(id, name, data, queueName, factoryOptions = {}) {
     const { callbacks, snapshot } = factoryOptions;
@@ -115,7 +127,11 @@ export function createFlowJobObject(id, name, data, queueName, factoryOptions =
         return result;
     const options = buildJobOpts(snapshot);
     Object.assign(result, buildJobProperties(snapshot, name), { data, opts: options });
-    const serialization = buildSerializationMethods(snapshot, id, name, options);
+    const serialization = buildSerializationMethods(snapshot, {
+        id,
+        name,
+        jobOpts: options,
+    });
     Object.assign(result, {
         toJSON: () => ({ ...serialization.toJSON(), data }),
         asJSON: () => ({ ...serialization.asJSON(), data: JSON.stringify(data) }),

package/dist/client/flowJobMoveMethods.d.ts

@@ -1,11 +1,11 @@
 import { type FlowJobRuntime } from './flowJobTypes';
 /** Lifecycle and failure-inspection methods exposed by a FlowProducer Job. */
 export declare function buildFlowJobMoveMethods(runtime: FlowJobRuntime): {
-    moveToCompleted: (returnValue: unknown) => Promise<null>;
-    moveToFailed: (error: Error) => Promise<void>;
-    moveToWait: () => Promise<boolean>;
-    moveToDelayed: (timestamp: number) => Promise<undefined>;
-    moveToWaitingChildren: () => Promise<boolean>;
+    moveToCompleted: (returnValue: unknown, token?: string) => Promise<null>;
+    moveToFailed: (error: Error, token?: string) => Promise<void>;
+    moveToWait: (token?: string) => Promise<boolean>;
+    moveToDelayed: (timestamp: number, token?: string) => Promise<undefined>;
+    moveToWaitingChildren: (token?: string) => Promise<boolean>;
     waitUntilFinished: (_queueEvents: unknown, ttl?: number) => Promise<unknown>;
     discard: () => void;
     getFailedChildrenValues: () => Promise<Record<string, string>>;

package/dist/client/flowJobMoveMethods.js

@@ -2,47 +2,67 @@ import { jobId } from '../domain/types/job';
 import { getSharedManager } from './manager';
 import { buildFailCommand, failEmbeddedArgs } from './queue/failWire';
 import { assertFlowTcpOk } from './flowJobTypes';
+import { removeJobDeduplicationKey } from './jobDeduplication';
 /** Lifecycle and failure-inspection methods exposed by a FlowProducer Job. */
 export function buildFlowJobMoveMethods(runtime) {
     const { id, embedded, tcp } = runtime;
     return {
-        moveToCompleted: async (returnValue) => {
+        moveToCompleted: async (returnValue, token) => {
             if (embedded) {
-                await getSharedManager().ack(jobId(id), returnValue);
+                await getSharedManager().ack(jobId(id), returnValue, token);
                 return null;
             }
-            if (tcp)
-                assertFlowTcpOk(await tcp.send({ cmd: 'ACK', id, result: returnValue }), 'ACK');
+            if (tcp) {
+                assertFlowTcpOk(await tcp.send({
+                    cmd: 'ACK',
+                    id,
+                    result: returnValue,
+                    ...(token === undefined ? {} : { token }),
+                }), 'ACK');
+            }
             return null;
         },
-        moveToFailed: async (error) => {
+        moveToFailed: async (error, token) => {
             if (embedded) {
-                await getSharedManager().fail(jobId(id), ...failEmbeddedArgs(error));
+                await getSharedManager().fail(jobId(id), ...failEmbeddedArgs(error, token));
                 return;
             }
             if (tcp)
-                assertFlowTcpOk(await tcp.send(buildFailCommand(id, error)), 'FAIL');
+                assertFlowTcpOk(await tcp.send(buildFailCommand(id, error, token)), 'FAIL');
         },
-        moveToWait: async () => {
+        moveToWait: async (token) => {
             if (embedded)
-                return getSharedManager().moveActiveToWait(jobId(id));
+                return getSharedManager().moveActiveToWait(jobId(id), token);
             if (!tcp)
                 return false;
-            assertFlowTcpOk(await tcp.send({ cmd: 'MoveToWait', id }), 'MoveToWait');
+            assertFlowTcpOk(await tcp.send({ cmd: 'MoveToWait', id, ...(token === undefined ? {} : { token }) }), 'MoveToWait');
             return true;
         },
-        moveToDelayed: async (timestamp) => {
+        moveToDelayed: async (timestamp, token) => {
             const delay = Math.max(0, timestamp - Date.now());
             if (embedded)
-                return void (await getSharedManager().moveToDelayed(jobId(id), delay));
+                return void (await getSharedManager().moveToDelayed(jobId(id), delay, token));
             if (!tcp)
                 return;
-            assertFlowTcpOk(await tcp.send({ cmd: 'MoveToDelayed', id, delay }), 'MoveToDelayed');
+            assertFlowTcpOk(await tcp.send({
+                cmd: 'MoveToDelayed',
+                id,
+                delay,
+                ...(token === undefined ? {} : { token }),
+            }), 'MoveToDelayed');
         },
-        moveToWaitingChildren: async () => {
+        moveToWaitingChildren: async (token) => {
             if (embedded)
-                return getSharedManager().moveToWaitingChildren(jobId(id));
-            throw new Error('moveToWaitingChildren is not supported in TCP mode — no server command available');
+                return getSharedManager().moveToWaitingChildren(jobId(id), token);
+            if (!tcp)
+                return false;
+            const response = await tcp.send({
+                cmd: 'MoveToWaitingChildren',
+                id,
+                ...(token === undefined ? {} : { token }),
+            });
+            assertFlowTcpOk(response, 'MoveToWaitingChildren');
+            return true;
         },
         waitUntilFinished: async (_queueEvents, ttl) => {
             const timeout = ttl ?? 30_000;
@@ -100,7 +120,7 @@ export function buildFlowJobMoveMethods(runtime) {
             assertFlowTcpOk(response, 'RemoveChildDependency');
             return response.removed ?? false;
         },
-        removeDeduplicationKey: () => Promise.reject(new Error('removeDeduplicationKey is not implemented — no server primitive available')),
+        removeDeduplicationKey: () => removeJobDeduplicationKey(id, embedded, tcp),
         removeUnprocessedChildren: async () => {
             if (embedded)
                 return void (await getSharedManager().removeUnprocessedChildren(jobId(id)));

package/dist/client/flowLegacyPlan.js

@@ -21,7 +21,7 @@ function validateStep(step, depth = 0) {
         throw new Error('flow job data must be an object');
     }
     for (const key of Object.keys(step.data)) {
-        if (key === 'name' || key.startsWith('__')) {
+        if (key.startsWith('__')) {
             throw new Error(`flow job data key is reserved: ${key}`);
         }
     }
@@ -48,7 +48,7 @@ function allocate(step, ids) {
     return id;
 }
 function dataFor(step, internal) {
-    return { ...step.data, name: step.name, ...internal };
+    return { ...step.data, ...internal };
 }
 export function planChain(steps) {
     validateFlatSteps(steps);
@@ -56,10 +56,17 @@ export function planChain(steps) {
     const ids = steps.map((step) => allocate(step, seen));
     const jobs = steps.map((step, index) => {
         const dependency = index > 0 ? ids[index - 1] : undefined;
+        const dependencyQueue = index > 0 ? steps[index - 1].queueName : undefined;
         return {
             id: ids[index],
             queue: step.queueName,
-            input: flowJobInput(dataFor(step, { __flowParentId: dependency ? String(dependency) : null }), step.opts ?? {}, { dependsOn: dependency ? [dependency] : undefined }),
+            input: flowJobInput(step.name, dataFor(step, dependency && dependencyQueue
+                ? {
+                    __flowParentId: String(dependency),
+                    __parentId: String(dependency),
+                    __parentQueue: dependencyQueue,
+                }
+                : { __flowParentId: null }), step.opts ?? {}, { dependsOn: dependency ? [dependency] : undefined }),
         };
     });
     return { batch: { jobs }, ids };
@@ -72,7 +79,7 @@ export function planBulkThen(parallel, final) {
     const parallelJobs = parallel.map((step, index) => ({
         id: parallelIds[index],
         queue: step.queueName,
-        input: flowJobInput(dataFor(step, {
+        input: flowJobInput(step.name, dataFor(step, {
             __parentId: String(finalId),
             __parentQueue: final.queueName,
         }), step.opts ?? {}, { parentId: finalId }),
@@ -80,7 +87,7 @@ export function planBulkThen(parallel, final) {
     const finalJob = {
         id: finalId,
         queue: final.queueName,
-        input: flowJobInput(dataFor(final, {
+        input: flowJobInput(final.name, dataFor(final, {
             __flowParentIds: parallelIds.map(String),
             __childrenIds: parallelIds.map(String),
         }), final.opts ?? {}, {
@@ -108,10 +115,17 @@ export function planTree(root) {
         jobs.push({
             id,
             queue: step.queueName,
-            input: flowJobInput(dataFor(step, { __flowParentId: dependency ? String(dependency) : null }), step.opts ?? {}, { dependsOn: dependency ? [dependency] : undefined }),
+            input: flowJobInput(step.name, dataFor(step, dependency
+                ? {
+                    __flowParentId: String(dependency.id),
+                    __parentId: String(dependency.id),
+                    __parentQueue: dependency.queue,
+                }
+                : { __flowParentId: null }), step.opts ?? {}, { dependsOn: dependency ? [dependency.id] : undefined }),
         });
-        for (const child of step.children ?? [])
-            visit(child, id, depth + 1);
+        for (const child of step.children ?? []) {
+            visit(child, { id, queue: step.queueName }, depth + 1);
+        }
     };
     visit(root);
     return { batch: { jobs }, ids };

package/dist/client/flowOptions.d.ts

@@ -3,7 +3,7 @@ import type { JobOptions } from './types';
 /** Options intentionally unsupported by BullMQ-compatible atomic flows. */
 export declare function assertAtomicFlowOptions(opts: JobOptions): void;
 /** Convert public JobOptions into the domain input used by the atomic broker command. */
-export declare function flowJobInput(data: unknown, opts: JobOptions, links?: {
+export declare function flowJobInput(name: string, data: unknown, opts: JobOptions, links?: {
     parentId?: JobId;
     dependsOn?: JobId[];
     childrenIds?: JobId[];

package/dist/client/flowOptions.js

@@ -14,9 +14,10 @@ export function assertAtomicFlowOptions(opts) {
         throw new Error('FlowProducer owns parent links; opts.parent is not allowed');
 }
 /** Convert public JobOptions into the domain input used by the atomic broker command. */
-export function flowJobInput(data, opts, links = {}) {
+export function flowJobInput(name, data, opts, links = {}) {
     assertAtomicFlowOptions(opts);
     return {
+        name,
         data,
         priority: opts.priority,
         delay: opts.delay,

package/dist/client/flowPlan.js

@@ -21,7 +21,7 @@ function validateNodeShape(node, depth) {
             throw new Error('flow job data must be an object');
         }
         for (const key of Object.keys(node.data)) {
-            if (key === 'name' || key.startsWith('__')) {
+            if (key.startsWith('__')) {
                 throw new Error(`flow job data key is reserved: ${key}`);
             }
         }
@@ -69,7 +69,6 @@ export function planFlows(flows, options) {
         const opts = defaults ? { ...defaults, ...node.opts } : (node.opts ?? {});
         const internalData = {
             ...node.data,
-            name: node.name,
         };
         if (parent) {
             internalData.__parentId = String(parent.id);
@@ -80,7 +79,7 @@ export function planFlows(flows, options) {
         jobs.push({
             id,
             queue: node.queueName,
-            input: flowJobInput(internalData, opts, {
+            input: flowJobInput(node.name, internalData, opts, {
                 parentId: parent?.id,
                 dependsOn: childIds.length > 0 ? childIds : undefined,
                 childrenIds: childIds.length > 0 ? childIds : undefined,

package/dist/client/flowPush.d.ts

@@ -12,6 +12,7 @@ export interface PushContext {
 export declare function pushJob(ctx: PushContext, queueName: string, data: unknown, opts?: JobOptions, dependsOn?: string[]): Promise<string>;
 export interface PushWithParentOpts {
     queueName: string;
+    name?: string;
     data: unknown;
     opts: JobOptions;
     parentRef: {

package/dist/client/flowPush.js

@@ -102,6 +102,7 @@ export async function pushJob(ctx, queueName, data, opts = {}, dependsOn) {
     if (ctx.embedded) {
         const manager = getSharedManager();
         const job = await manager.push(queueName, {
+            name: 'default',
             data,
             ...managerOptions(opts),
             removeOnComplete,
@@ -115,6 +116,7 @@ export async function pushJob(ctx, queueName, data, opts = {}, dependsOn) {
     const response = await ctx.tcp.send({
         cmd: 'PUSH',
         queue: queueName,
+        name: 'default',
         data,
         ...tcpOptions(opts),
         removeOnComplete,
@@ -128,12 +130,13 @@ 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 { queueName, data, opts, parentRef, childIds, name = 'default' } = params;
     const { removeOnComplete, removeOnFail } = parseRemoveOptions(opts);
     if (ctx.embedded) {
         const manager = getSharedManager();
         const childJobIds = childIds.map((id) => jobId(id));
         const job = await manager.push(queueName, {
+            name,
             data,
             ...managerOptions(opts),
             removeOnComplete,
@@ -154,6 +157,7 @@ export async function pushJobWithParent(ctx, params) {
     const response = await ctx.tcp.send({
         cmd: 'PUSH',
         queue: queueName,
+        name,
         data,
         ...tcpOptions(opts),
         removeOnComplete,

package/dist/client/flowReader.js

@@ -1,5 +1,5 @@
 import { jobId } from '../domain/types/job';
-import { createFlowJobObject, extractUserDataFromInternal } from './flowJobFactory';
+import { createFlowJobObject, extractFlowJobPayload } from './flowJobFactory';
 import { getSharedManager } from './manager';
 function traversalLimit(value, name) {
     if (value === undefined)
@@ -43,9 +43,9 @@ async function buildEmbeddedNode(context, job, traversal) {
     const nextAncestors = assertNoCycle(id, ancestors);
     const data = job.data;
     assertParentLink(id, job.parentId, data, expectedParent);
-    const name = typeof data.name === 'string' ? data.name : 'default';
+    const payload = extractFlowJobPayload(job);
     const node = {
-        job: createFlowJobObject(id, name, extractUserDataFromInternal(data), job.queue, {
+        job: createFlowJobObject(id, payload.name, payload.data, job.queue, {
             callbacks: context.buildCallbacks(job.queue),
             snapshot: job,
         }),
@@ -91,9 +91,9 @@ async function buildTcpNode(context, job, traversal) {
     const nextAncestors = assertNoCycle(id, ancestors);
     const data = typeof job.data === 'object' && job.data !== null ? job.data : {};
     assertParentLink(id, job.parentId, data, expectedParent);
-    const name = typeof data.name === 'string' ? data.name : 'default';
+    const payload = extractFlowJobPayload(job);
     const node = {
-        job: createFlowJobObject(id, name, extractUserDataFromInternal(data), queueName, {
+        job: createFlowJobObject(id, payload.name, payload.data, queueName, {
             callbacks: context.buildCallbacks(queueName),
             snapshot: job,
         }),

package/dist/client/flowResults.d.ts

@@ -0,0 +1,11 @@
+import type { TcpConnectionPool } from './tcpPool';
+interface FlowResultContext {
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+}
+export type RuntimeResult<T> = T | Promise<T>;
+/** Keep the embedded call synchronous while providing the same result over TCP. */
+export declare function getParentResult<R>(ctx: FlowResultContext, parentId: string): RuntimeResult<R | undefined>;
+/** Resolve parent results in input order and preserve falsy completed values. */
+export declare function getParentResults<R>(ctx: FlowResultContext, parentIds: string[]): RuntimeResult<Map<string, R>>;
+export {};

package/dist/client/flowResults.js

@@ -0,0 +1,42 @@
+import { jobId } from '../domain/types/job';
+import { getSharedManager } from './manager';
+import { assertFlowTcpOk } from './flowJobTypes';
+/** Keep the embedded call synchronous while providing the same result over TCP. */
+export function getParentResult(ctx, parentId) {
+    if (ctx.embedded)
+        return getSharedManager().getResult(jobId(parentId));
+    if (!ctx.tcp)
+        return Promise.reject(new Error('FlowProducer TCP connection is unavailable'));
+    return ctx.tcp.send({ cmd: 'GetResult', id: parentId }).then((response) => {
+        assertFlowTcpOk(response, 'GetResult');
+        return response.result;
+    });
+}
+/** Resolve parent results in input order and preserve falsy completed values. */
+export function getParentResults(ctx, parentIds) {
+    if (ctx.embedded) {
+        const manager = getSharedManager();
+        const results = new Map();
+        for (const id of parentIds) {
+            const result = manager.getResult(jobId(id));
+            if (result !== undefined)
+                results.set(id, result);
+        }
+        return results;
+    }
+    const tcp = ctx.tcp;
+    if (!tcp)
+        return Promise.reject(new Error('FlowProducer TCP connection is unavailable'));
+    return Promise.all(parentIds.map(async (id) => {
+        const response = await tcp.send({ cmd: 'GetResult', id });
+        assertFlowTcpOk(response, 'GetResult');
+        return [id, response.result];
+    })).then((entries) => {
+        const results = new Map();
+        for (const [id, result] of entries) {
+            if (result !== undefined)
+                results.set(id, result);
+        }
+        return results;
+    });
+}

package/dist/client/index.d.ts

@@ -23,12 +23,14 @@ export { defineConfig } from '../config';
 export type { BunqueueConfig } from '../config';
 export { Queue } from './queue';
 export { Worker } from './worker';
+export type { ManualJob } from './worker/types';
 export { Bunqueue } from './bunqueue';
 export type { BunqueueOptions, BunqueueMiddleware, RetryStrategy, RetryConfig, CircuitBreakerConfig, TriggerRule, PriorityAgingConfig, BatchProcessor, BatchConfig, JobTtlConfig, BunqueueDeduplicationConfig, BunqueueDebounceConfig, BunqueueDlqConfig, } from './bunqueue';
 export { SandboxedWorker } from './sandboxedWorker';
 export { Forwarder } from './forwarder';
 export type { ForwardOptions, ForwardedInfo } from './forwarder';
 export { QueueEvents } from './events';
+export type { ActiveEvent, CompletedEvent, DelayedEvent, DrainedEvent, DuplicatedEvent, FailedEvent, ProgressEvent, QueueEventsOptions, RemovedEvent, RetriedEvent, StalledEvent, WaitingChildrenEvent, WaitingEvent, } from './types/events';
 export { QueueGroup } from './queueGroup';
 export { FlowProducer } from './flow';
 export { UnrecoverableError, DelayedError } from './errors';
@@ -36,7 +38,7 @@ export { shutdownManager } from './manager';
 export { closeSharedTcpClient } from './tcpClient';
 export type { ConnectionHealth } from './tcpClient';
 export { TcpConnectionPool, getSharedPool, closeAllSharedPools } from './tcpPool';
-export type { Job, JobOptions, JobJson, JobJsonRaw, QueueOptions, WorkerOptions, Processor, FlowJobData, StallConfig, DlqConfig, DlqEntry, DlqStats, DlqFilter, FailureReason, ConnectionOptions, ParentOpts, RateLimiterOptions, ChangePriorityOpts, GetDependenciesOpts, JobDependencies, JobDependenciesCount, } from './types';
+export type { Job, JobOptions, JobJson, JobJsonRaw, QueueOptions, WorkerOptions, Processor, FlowJobData, StallConfig, DlqConfig, DlqEntry, DlqStats, DlqFilter, FailureReason, ConnectionOptions, ParentOpts, RateLimiterOptions, ChangePriorityOpts, GetDependenciesOpts, JobDependencies, JobDependenciesCount, QueueMetrics, QueueMetricsMeta, QueueMetricType, } from './types';
 export type { FlowStep, FlowResult, FlowJob, JobNode, FlowProducerOptions, FlowOpts } from './flow';
 export type { RepeatOpts, JobTemplate, SchedulerInfo } from './queue/scheduler';
 export type { SandboxedWorkerOptions } from './sandboxedWorker';

package/dist/client/jobConversion.d.ts

@@ -1,14 +1,10 @@
-/**
- * Job Conversion Functions
- * Convert internal job types to public API types
- */
 import type { DlqEntry as InternalDlqEntry } from '../domain/types/dlq';
 import type { Job, DlqEntry } from './types';
-import type { CreatePublicJobOptions, ToPublicJobOptions } from './jobConversionTypes';
-export type { CreatePublicJobOptions, ToPublicJobOptions } from './jobConversionTypes';
+import type { CreatePublicJobOptions, PublicJobMethodContext, ToPublicJobOptions } from './jobConversionTypes';
+export type { CreatePublicJobOptions, PublicJobMethodContext, ToPublicJobOptions, } from './jobConversionTypes';
 /** Convert internal job to public job (with methods) */
 export declare function createPublicJob<T>(opts: CreatePublicJobOptions): Job<T>;
 /** Simple public job without methods (for Queue.getJob) */
 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>;
+export declare function toDlqEntry<T>(entry: InternalDlqEntry, methods: PublicJobMethodContext): DlqEntry<T>;