bunqueue 2.8.49 → 2.8.50

package/dist/client/flow.js

@@ -6,9 +6,13 @@ import { EventEmitter } from 'events';
 import { getSharedManager } from './manager';
 import { TcpConnectionPool, getSharedPool, releaseSharedPool } from './tcpPool';
 import { jobId } from '../domain/types/job';
-import { createFlowJobObject, extractUserDataFromInternal, } from './flowJobFactory';
-import { pushJob, pushJobWithParent, cleanupJobs } from './flowPush';
+import { createFlowJobObject } from './flowJobFactory';
 import * as managementOps from './queue/operations/management';
+import { commitFlow } from './flowAtomic';
+import { assertFlowTcpOk } from './flowJobTypes';
+import { planFlows } from './flowPlan';
+import { planBulkThen, planChain, planTree } from './flowLegacyPlan';
+import { readFlow } from './flowReader';
 const FORCE_EMBEDDED = Bun.env.BUNQUEUE_EMBEDDED === '1';
 /**
  * FlowProducer creates job flows with automatic dependencies.
@@ -39,6 +43,7 @@ export class FlowProducer extends EventEmitter {
     embedded;
     tcp;
     useSharedPool;
+    closed = false;
     constructor(opts = {}) {
         super();
         this.embedded = opts.embedded ?? FORCE_EMBEDDED;
@@ -56,6 +61,8 @@ export class FlowProducer extends EventEmitter {
                     poolSize,
                     pingInterval: connOpts.pingInterval,
                     commandTimeout: connOpts.commandTimeout,
+                    maxCommandTimeouts: connOpts.maxCommandTimeouts,
+                    tls: connOpts.tls,
                     pipelining: connOpts.pipelining,
                     maxInFlight: connOpts.maxInFlight,
                 });
@@ -69,6 +76,8 @@ export class FlowProducer extends EventEmitter {
                     poolSize,
                     pingInterval: connOpts.pingInterval,
                     commandTimeout: connOpts.commandTimeout,
+                    maxCommandTimeouts: connOpts.maxCommandTimeouts,
+                    tls: connOpts.tls,
                     pipelining: connOpts.pipelining,
                     maxInFlight: connOpts.maxInFlight,
                 });
@@ -82,6 +91,9 @@ export class FlowProducer extends EventEmitter {
     }
     /** Close the connection pool (only if using dedicated pool) */
     close() {
+        if (this.closed)
+            return this.closing;
+        this.closed = true;
         if (this.tcp && !this.useSharedPool) {
             this.tcp.close();
         }
@@ -100,49 +112,31 @@ export class FlowProducer extends EventEmitter {
         if (this.embedded)
             return;
         if (this.tcp)
-            await this.tcp.send({ cmd: 'Ping' });
+            assertFlowTcpOk(await this.tcp.send({ cmd: 'Ping' }), 'Ping');
     }
     // ============================================================================
     // BullMQ v5 Compatible Methods
     // ============================================================================
     /** Add a flow (BullMQ v5 compatible). Children are processed BEFORE their parent. */
     async add(flow, opts) {
-        const createdJobIds = [];
-        try {
-            return await this.addFlowNode(flow, null, createdJobIds, opts);
-        }
-        catch (error) {
-            // Atomic rollback: clean up all created jobs
-            await cleanupJobs(this.pushCtx, createdJobIds);
-            throw error;
-        }
+        const plan = planFlows([flow], opts);
+        const snapshots = await commitFlow(this.pushCtx, plan.batch);
+        return this.buildPlannedNode(plan.roots[0], this.indexSnapshots(snapshots));
     }
     /** Add multiple flows (BullMQ v5 compatible). */
     async addBulk(flows) {
-        const results = [];
-        const allCreatedJobIds = [];
-        try {
-            for (const flow of flows) {
-                const createdJobIds = [];
-                const result = await this.addFlowNode(flow, null, createdJobIds);
-                allCreatedJobIds.push(...createdJobIds);
-                results.push(result);
-            }
-            return results;
-        }
-        catch (error) {
-            // Atomic rollback: clean up all created jobs from all flows
-            await cleanupJobs(this.pushCtx, allCreatedJobIds);
-            throw error;
-        }
+        const plan = planFlows(flows);
+        const snapshots = await commitFlow(this.pushCtx, plan.batch);
+        const snapshotsById = this.indexSnapshots(snapshots);
+        return plan.roots.map((root) => this.buildPlannedNode(root, snapshotsById));
     }
     /** Get a flow tree starting from a job (BullMQ v5 compatible). */
     async getFlow(opts) {
-        const { id, queueName, depth, maxChildren } = opts;
-        if (this.embedded) {
-            return this.getFlowEmbedded(id, queueName, depth ?? Infinity, maxChildren);
-        }
-        return this.getFlowTcp(id, queueName, depth ?? Infinity, maxChildren);
+        return readFlow({
+            embedded: this.embedded,
+            tcp: this.tcp,
+            buildCallbacks: (queueName) => this.buildCallbacks(queueName),
+        }, opts);
     }
     // ============================================================================
     // Legacy bunqueue API Methods
@@ -151,80 +145,24 @@ export class FlowProducer extends EventEmitter {
     async addChain(steps) {
         if (steps.length === 0)
             return { jobIds: [] };
-        const jobIds = [];
-        let prevId = null;
-        try {
-            for (const step of steps) {
-                const data = { name: step.name, __flowParentId: prevId, ...step.data };
-                const id = await pushJob(this.pushCtx, step.queueName, data, step.opts ?? {}, prevId ? [prevId] : undefined);
-                jobIds.push(id);
-                prevId = id;
-            }
-        }
-        catch (error) {
-            await cleanupJobs(this.pushCtx, jobIds);
-            throw error;
-        }
-        return { jobIds };
+        const plan = planChain(steps);
+        await commitFlow(this.pushCtx, plan.batch);
+        return { jobIds: plan.ids.map(String) };
     }
     /** Add parallel jobs that converge to a final job. */
     async addBulkThen(parallel, final) {
-        const parallelIds = [];
-        try {
-            // Push parallel jobs concurrently — they are independent by design
-            const results = await Promise.allSettled(parallel.map(async (step) => {
-                const data = { name: step.name, ...step.data };
-                return pushJob(this.pushCtx, step.queueName, data, step.opts ?? {});
-            }));
-            // Collect successful IDs and check for failures
-            const errors = [];
-            for (const r of results) {
-                if (r.status === 'fulfilled') {
-                    parallelIds.push(r.value);
-                }
-                else {
-                    errors.push(r.reason);
-                }
-            }
-            if (errors.length > 0) {
-                // Clean up successfully created jobs before throwing
-                await cleanupJobs(this.pushCtx, parallelIds);
-                throw errors[0] instanceof Error ? errors[0] : new Error(String(errors[0]));
-            }
-            const finalData = {
-                name: final.name,
-                __flowParentIds: parallelIds,
-                ...final.data,
-            };
-            // pushJobWithParent (not pushJob) so the final job records childrenIds =
-            // parallelIds: this keeps the same dependsOn ordering (waits for all
-            // parallel jobs) AND lets the merge step read their results via
-            // getChildrenValues()/getDependencies(), like a BullMQ fan-in parent.
-            const finalId = await pushJobWithParent(this.pushCtx, {
-                queueName: final.queueName,
-                data: finalData,
-                opts: final.opts ?? {},
-                parentRef: null,
-                childIds: parallelIds,
-            });
-            return { parallelIds, finalId };
-        }
-        catch (error) {
-            await cleanupJobs(this.pushCtx, parallelIds);
-            throw error;
-        }
+        const plan = planBulkThen(parallel, final);
+        await commitFlow(this.pushCtx, plan.batch);
+        return {
+            parallelIds: plan.parallelIds.map(String),
+            finalId: String(plan.finalId),
+        };
     }
     /** Add a tree of jobs where children depend on parent. */
     async addTree(root) {
-        const jobIds = [];
-        try {
-            await this.addTreeNode(root, null, jobIds);
-        }
-        catch (error) {
-            await cleanupJobs(this.pushCtx, jobIds);
-            throw error;
-        }
-        return { jobIds };
+        const plan = planTree(root);
+        await commitFlow(this.pushCtx, plan.batch);
+        return { jobIds: plan.ids.map(String) };
     }
     /**
      * Get the result of a completed parent job (embedded only).
@@ -258,9 +196,24 @@ export class FlowProducer extends EventEmitter {
     /** Build callbacks that wire flow job methods to actual management operations */
     buildCallbacks(queueName) {
         const ctx = { name: queueName, embedded: this.embedded, tcp: this.tcp };
+        if (!this.embedded) {
+            return {
+                embedded: false,
+                tcp: this.tcp,
+                getState: (id) => {
+                    if (!this.tcp)
+                        return Promise.resolve('unknown');
+                    return this.tcp.send({ cmd: 'GetState', id }).then((response) => {
+                        if (response.ok !== true) {
+                            throw new Error(typeof response.error === 'string' ? response.error : 'GetState failed');
+                        }
+                        return typeof response.state === 'string' ? response.state : 'unknown';
+                    });
+                },
+            };
+        }
         return {
-            embedded: this.embedded,
-            tcp: this.tcp,
+            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(() => { }),
@@ -268,117 +221,25 @@ export class FlowProducer extends EventEmitter {
             remove: (id) => managementOps.removeAsync(ctx, id),
             changePriority: (id, opts) => managementOps.changeJobPriority(ctx, id, opts),
             changeDelay: (id, d) => managementOps.changeJobDelay(ctx, id, d),
-            clearLogs: (id) => managementOps.clearJobLogs(ctx, id),
+            clearLogs: (id, keepLogs) => managementOps.clearJobLogs(ctx, id, keepLogs),
             retry: (id) => managementOps.retryJob(ctx, id),
-            getState: (id) => {
-                if (this.embedded) {
-                    return getSharedManager().getJobState(jobId(id));
-                }
-                if (!this.tcp)
-                    return Promise.resolve('unknown');
-                return this.tcp
-                    .send({ cmd: 'GetState', id })
-                    .then((r) => (typeof r.state === 'string' ? r.state : 'unknown'));
-            },
+            getState: (id) => getSharedManager().getJobState(jobId(id)),
         };
     }
-    async getFlowEmbedded(id, queueName, depth, maxChildren) {
-        const job = await getSharedManager().getJob(jobId(id));
-        if (job?.queue !== queueName)
-            return null;
-        return this.buildJobNode(job, depth, maxChildren);
-    }
-    async getFlowTcp(id, queueName, depth, maxChildren) {
-        if (!this.tcp)
-            throw new Error('TCP connection not initialized');
-        const response = await this.tcp.send({ cmd: 'GetJob', id });
-        if (!response.ok || !response.job)
-            return null;
-        const jobData = response.job;
-        if (jobData.queue !== queueName)
-            return null;
-        return this.buildJobNodeFromTcp(jobData, depth, maxChildren);
-    }
-    async buildJobNode(job, depth, maxChildren) {
-        const data = job.data;
-        const name = typeof data.name === 'string' ? data.name : 'default';
-        const userData = extractUserDataFromInternal(data);
-        const jobObj = createFlowJobObject(String(job.id), name, userData, job.queue, this.buildCallbacks(job.queue));
-        if (depth <= 0 || job.childrenIds.length === 0)
-            return { job: jobObj };
-        const childNodes = [];
-        const childrenToFetch = maxChildren ? job.childrenIds.slice(0, maxChildren) : job.childrenIds;
-        for (const childId of childrenToFetch) {
-            const childJob = await getSharedManager().getJob(childId);
-            if (childJob)
-                childNodes.push(await this.buildJobNode(childJob, depth - 1, maxChildren));
-        }
-        return { job: jobObj, children: childNodes.length > 0 ? childNodes : undefined };
-    }
-    async buildJobNodeFromTcp(jobData, depth, maxChildren) {
-        const id = String(jobData.id);
-        const queueName = String(jobData.queue);
-        const data = jobData.data;
-        const name = typeof data?.name === 'string' ? data.name : 'default';
-        const userData = extractUserDataFromInternal(data ?? {});
-        const rawChildrenIds = data?.__childrenIds;
-        const childrenIds = Array.isArray(rawChildrenIds) ? rawChildrenIds : [];
-        const jobObj = createFlowJobObject(id, name, userData, queueName, this.buildCallbacks(queueName));
-        if (depth <= 0 || childrenIds.length === 0 || !this.tcp)
-            return { job: jobObj };
-        const childNodes = [];
-        const childrenToFetch = maxChildren ? childrenIds.slice(0, maxChildren) : childrenIds;
-        for (const childId of childrenToFetch) {
-            const response = await this.tcp.send({ cmd: 'GetJob', id: childId });
-            if (response.ok && response.job) {
-                childNodes.push(await this.buildJobNodeFromTcp(response.job, depth - 1, maxChildren));
-            }
-        }
-        return { job: jobObj, children: childNodes.length > 0 ? childNodes : undefined };
-    }
-    async addFlowNode(node, parentRef, createdJobIds, flowOpts) {
-        const childNodes = [];
-        const childIds = [];
-        if (node.children && node.children.length > 0) {
-            const tempParentRef = { id: 'pending', queue: node.queueName };
-            // Siblings are independent — create them concurrently
-            const results = await Promise.all(node.children.map((child) => this.addFlowNode(child, tempParentRef, createdJobIds, flowOpts)));
-            for (const childNode of results) {
-                childNodes.push(childNode);
-                childIds.push(childNode.job.id);
-            }
-        }
-        // Merge node opts with per-queue defaults from FlowOpts
-        const queueDefaults = flowOpts?.queuesOptions?.[node.queueName];
-        const mergedOpts = queueDefaults ? { ...queueDefaults, ...node.opts } : (node.opts ?? {});
-        const jobData = {
-            name: node.name,
-            ...node.data,
+    buildPlannedNode(node, snapshots) {
+        const snapshot = snapshots.get(String(node.id));
+        if (!snapshot)
+            throw new Error(`Committed flow snapshot missing for ${String(node.id)}`);
+        const children = node.children?.map((child) => this.buildPlannedNode(child, snapshots));
+        return {
+            job: createFlowJobObject(String(node.id), node.name, node.data, node.queueName, {
+                callbacks: this.buildCallbacks(node.queueName),
+                snapshot,
+            }),
+            children: children && children.length > 0 ? children : undefined,
         };
-        if (parentRef) {
-            jobData.__parentId = parentRef.id;
-            jobData.__parentQueue = parentRef.queue;
-        }
-        if (childIds.length > 0)
-            jobData.__childrenIds = childIds;
-        const jobIdStr = await pushJobWithParent(this.pushCtx, {
-            queueName: node.queueName,
-            data: jobData,
-            opts: mergedOpts,
-            parentRef,
-            childIds,
-        });
-        createdJobIds.push(jobIdStr);
-        const job = createFlowJobObject(jobIdStr, node.name, node.data, node.queueName, this.buildCallbacks(node.queueName));
-        return { job, children: childNodes.length > 0 ? childNodes : undefined };
     }
-    async addTreeNode(step, parentId, jobIds) {
-        const data = { name: step.name, __flowParentId: parentId, ...step.data };
-        const id = await pushJob(this.pushCtx, step.queueName, data, step.opts ?? {}, parentId ? [parentId] : undefined);
-        jobIds.push(id);
-        if (step.children) {
-            await Promise.all(step.children.map((child) => this.addTreeNode(child, id, jobIds)));
-        }
-        return id;
+    indexSnapshots(snapshots) {
+        return new Map(snapshots.map((snapshot) => [String(snapshot.id), snapshot]));
     }
 }

package/dist/client/flowAtomic.d.ts

@@ -0,0 +1,9 @@
+import type { Job as DomainJob } from '../domain/types/job';
+import type { AtomicFlowBatchInput } from '../domain/types/flow';
+import type { TcpConnectionPool } from './tcpPool';
+export interface AtomicFlowContext {
+    readonly embedded: boolean;
+    readonly tcp: TcpConnectionPool | null;
+}
+/** Execute the same one-command atomic primitive in embedded and TCP modes. */
+export declare function commitFlow(ctx: AtomicFlowContext, batch: AtomicFlowBatchInput): Promise<DomainJob[]>;

package/dist/client/flowAtomic.js

@@ -0,0 +1,24 @@
+import { getSharedManager } from './manager';
+/** Execute the same one-command atomic primitive in embedded and TCP modes. */
+export async function commitFlow(ctx, batch) {
+    if (batch.jobs.length === 0)
+        return [];
+    if (ctx.embedded) {
+        return (await getSharedManager().pushFlow(batch)).jobs;
+    }
+    if (!ctx.tcp)
+        throw new Error('TCP connection not initialized');
+    const response = await ctx.tcp.send({ cmd: 'PUSHF', jobs: batch.jobs });
+    if (response.ok !== true) {
+        throw new Error(typeof response.error === 'string' ? response.error : 'Failed to add flow');
+    }
+    const result = response.data;
+    if (!result || !Array.isArray(result.jobs) || result.jobs.length !== batch.jobs.length) {
+        throw new Error('Invalid PUSHF response: committed job snapshots are missing');
+    }
+    const expected = new Set(batch.jobs.map((job) => String(job.id)));
+    if (result.jobs.some((job) => !expected.delete(String(job.id))) || expected.size > 0) {
+        throw new Error('Invalid PUSHF response: committed job IDs do not match the request');
+    }
+    return result.jobs;
+}

package/dist/client/flowJobCoreMethods.d.ts

@@ -0,0 +1,28 @@
+import type { ChangePriorityOpts } from './types';
+import { type FlowJobRuntime } from './flowJobTypes';
+/** Core state, mutation, and dependency methods exposed by a FlowProducer Job. */
+export declare function buildFlowJobCoreMethods(runtime: FlowJobRuntime): {
+    updateProgress: (progress: number | object) => Promise<void>;
+    log: (message: string) => Promise<void>;
+    getState: () => Promise<import("./types").JobStateType>;
+    remove: () => Promise<void>;
+    retry: () => Promise<void>;
+    getChildrenValues: <R = unknown>() => Promise<Record<string, R>>;
+    isWaiting: () => Promise<boolean>;
+    isActive: () => Promise<boolean>;
+    isDelayed: () => Promise<boolean>;
+    isCompleted: () => Promise<boolean>;
+    isFailed: () => Promise<boolean>;
+    isWaitingChildren: () => Promise<boolean>;
+    updateData: (data: unknown) => Promise<void>;
+    promote: () => Promise<void>;
+    changeDelay: (delay: number) => Promise<void>;
+    changePriority: (opts: ChangePriorityOpts) => Promise<void>;
+    extendLock: (token: string, duration: number) => Promise<number>;
+    clearLogs: (keepLogs?: number) => Promise<void>;
+    getDependencies: () => Promise<import("./flowJobDependencies").FlowDependencies>;
+    getDependenciesCount: () => Promise<{
+        processed: number;
+        unprocessed: number;
+    }>;
+};

package/dist/client/flowJobCoreMethods.js

@@ -0,0 +1,151 @@
+import { jobId } from '../domain/types/job';
+import { getSharedManager } from './manager';
+import { getFlowDependencies } from './flowJobDependencies';
+import { assertFlowTcpOk } from './flowJobTypes';
+/** Core state, mutation, and dependency methods exposed by a FlowProducer Job. */
+export function buildFlowJobCoreMethods(runtime) {
+    const { id, queueName, callbacks, embedded, tcp, getState } = runtime;
+    return {
+        updateProgress: async (progress) => {
+            if (callbacks?.updateProgress)
+                return callbacks.updateProgress(id, progress);
+            if (embedded) {
+                const value = typeof progress === 'number' ? progress : 0;
+                const message = typeof progress === 'object' ? JSON.stringify(progress) : undefined;
+                return void (await getSharedManager().updateProgress(jobId(id), value, message));
+            }
+            if (!tcp)
+                return;
+            const value = typeof progress === 'number' ? progress : 0;
+            const message = typeof progress === 'object' ? JSON.stringify(progress) : undefined;
+            assertFlowTcpOk(await tcp.send({ cmd: 'Progress', id, progress: value, message }), 'Progress');
+        },
+        log: async (message) => {
+            if (callbacks?.log)
+                return callbacks.log(id, message);
+            if (embedded)
+                return void getSharedManager().addLog(jobId(id), message);
+            if (!tcp)
+                return;
+            assertFlowTcpOk(await tcp.send({ cmd: 'AddLog', id, message }), 'AddLog');
+        },
+        getState,
+        remove: async () => {
+            if (callbacks?.remove)
+                return callbacks.remove(id);
+            if (embedded)
+                return void (await getSharedManager().cancel(jobId(id)));
+            if (!tcp)
+                return;
+            assertFlowTcpOk(await tcp.send({ cmd: 'Cancel', id }), 'Cancel');
+        },
+        retry: async () => {
+            if (callbacks?.retry)
+                return callbacks.retry(id);
+            if (embedded) {
+                const manager = getSharedManager();
+                const state = await manager.getJobState(jobId(id));
+                if (state === 'failed') {
+                    if (manager.retryDlq(queueName, jobId(id)) === 0) {
+                        throw new Error(`Job ${id} is failed but not present in DLQ`);
+                    }
+                    return;
+                }
+                if (state === 'active') {
+                    if (!(await manager.moveActiveToWait(jobId(id)))) {
+                        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;
+            assertFlowTcpOk(await tcp.send({ cmd: 'MoveToWait', id }), 'MoveToWait');
+        },
+        getChildrenValues: async () => {
+            if (embedded) {
+                return (await getSharedManager().getChildrenValues(jobId(id)));
+            }
+            if (!tcp)
+                return {};
+            const response = await tcp.send({ cmd: 'GetChildrenValues', id });
+            assertFlowTcpOk(response, 'GetChildrenValues');
+            const values = response.data?.values ?? {};
+            return values;
+        },
+        isWaiting: async () => (await getState()) === 'waiting',
+        isActive: async () => (await getState()) === 'active',
+        isDelayed: async () => (await getState()) === 'delayed',
+        isCompleted: async () => (await getState()) === 'completed',
+        isFailed: async () => (await getState()) === 'failed',
+        isWaitingChildren: async () => (await getState()) === 'waiting-children',
+        updateData: async (data) => {
+            if (callbacks?.updateData)
+                return callbacks.updateData(id, data);
+            if (embedded)
+                return void (await getSharedManager().updateJobData(jobId(id), data));
+            if (!tcp)
+                return;
+            assertFlowTcpOk(await tcp.send({ cmd: 'Update', id, data }), 'Update');
+        },
+        promote: async () => {
+            if (callbacks?.promote)
+                return callbacks.promote(id);
+            if (embedded)
+                return void (await getSharedManager().promote(jobId(id)));
+            if (!tcp)
+                return;
+            assertFlowTcpOk(await tcp.send({ cmd: 'Promote', id }), 'Promote');
+        },
+        changeDelay: async (delay) => {
+            if (callbacks?.changeDelay)
+                return callbacks.changeDelay(id, delay);
+            if (embedded)
+                return void (await getSharedManager().changeDelay(jobId(id), delay));
+            if (!tcp)
+                return;
+            assertFlowTcpOk(await tcp.send({ cmd: 'ChangeDelay', id, delay }), 'ChangeDelay');
+        },
+        changePriority: async (opts) => {
+            if (callbacks?.changePriority) {
+                return callbacks.changePriority(id, { priority: opts.priority, lifo: opts.lifo });
+            }
+            if (embedded) {
+                return void (await getSharedManager().changePriority(jobId(id), opts.priority, opts.lifo));
+            }
+            if (!tcp)
+                return;
+            assertFlowTcpOk(await tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority, lifo: opts.lifo }), 'ChangePriority');
+        },
+        extendLock: async (token, duration) => {
+            if (embedded) {
+                return (await getSharedManager().extendLock(jobId(id), token, duration)) ? duration : 0;
+            }
+            if (!tcp)
+                return 0;
+            const response = await tcp.send({ cmd: 'ExtendLock', id, token, duration });
+            assertFlowTcpOk(response, 'ExtendLock');
+            return duration;
+        },
+        clearLogs: async (keepLogs) => {
+            if (callbacks?.clearLogs)
+                return callbacks.clearLogs(id, keepLogs);
+            if (embedded)
+                return void getSharedManager().clearLogs(jobId(id), keepLogs);
+            if (!tcp)
+                return;
+            assertFlowTcpOk(await tcp.send({ cmd: 'ClearLogs', id, keepLogs }), 'ClearLogs');
+        },
+        getDependencies: () => getFlowDependencies(id, queueName, embedded, tcp),
+        getDependenciesCount: async () => {
+            const dependencies = await getFlowDependencies(id, queueName, embedded, tcp);
+            return {
+                processed: Object.keys(dependencies.processed).length,
+                unprocessed: dependencies.unprocessed.length,
+            };
+        },
+    };
+}

package/dist/client/flowJobDependencies.d.ts

@@ -0,0 +1,7 @@
+import type { TcpConnectionPool } from './tcpPool';
+export interface FlowDependencies {
+    processed: Record<string, unknown>;
+    unprocessed: string[];
+}
+/** Resolve dependency keys using the actual queue of every child. */
+export declare function getFlowDependencies(id: string, queueName: string, embedded: boolean, tcp: TcpConnectionPool | null): Promise<FlowDependencies>;

package/dist/client/flowJobDependencies.js

@@ -0,0 +1,64 @@
+import { jobId } from '../domain/types/job';
+import { getSharedManager } from './manager';
+import { assertFlowTcpOk } from './flowJobTypes';
+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 job.childrenIds.map(String);
+    }
+    if (!tcp)
+        return [];
+    const response = await tcp.send({ cmd: 'GetJob', id });
+    assertFlowTcpOk(response, 'GetJob');
+    const parent = response.job;
+    return (parent?.childrenIds ?? []).map(String);
+}
+async function embeddedDependency(fallbackQueue, childId) {
+    const manager = getSharedManager();
+    const child = await manager.getJob(jobId(childId));
+    if (!child)
+        throw new Error(`Flow child job ${childId} not found`);
+    const state = await manager.getJobState(jobId(childId));
+    return {
+        key: `${child.queue || fallbackQueue}:${childId}`,
+        state,
+        result: state === 'completed' ? manager.getResult(jobId(childId)) : undefined,
+    };
+}
+async function tcpDependency(fallbackQueue, childId, tcp) {
+    const response = await tcp.send({ cmd: 'GetJob', id: childId });
+    assertFlowTcpOk(response, 'GetJob');
+    const child = response.job;
+    if (!child)
+        throw new Error(`Flow child job ${childId} not found`);
+    const state = child.state ?? 'unknown';
+    let result;
+    if (state === 'completed') {
+        const resultResponse = await tcp.send({ cmd: 'GetResult', id: childId });
+        assertFlowTcpOk(resultResponse, 'GetResult');
+        result = resultResponse.result;
+    }
+    return { key: `${child.queue ?? fallbackQueue}:${childId}`, state, result };
+}
+/** Resolve dependency keys using the actual queue of every child. */
+export async function getFlowDependencies(id, queueName, embedded, tcp) {
+    const childIds = await fetchChildIds(id, embedded, tcp);
+    const processed = {};
+    const unprocessed = [];
+    for (const childId of childIds) {
+        const dependency = embedded
+            ? await embeddedDependency(queueName, childId)
+            : tcp
+                ? await tcpDependency(queueName, childId, tcp)
+                : { key: `${queueName}:${childId}`, state: 'unknown', result: undefined };
+        if (dependency.state === 'completed' || dependency.state === 'failed') {
+            processed[dependency.key] = dependency.result ?? null;
+        }
+        else {
+            unprocessed.push(dependency.key);
+        }
+    }
+    return { processed, unprocessed };
+}