bunqueue 2.8.53 → 2.8.56

package/dist/client/jobConversion.js

@@ -1,17 +1,27 @@
-/**
- * Job Conversion Functions
- * Convert internal job types to public API types
- */
 import { buildJobOpts } from './jobHelpers';
+import { convertDlqEntry } from './dlqConversion';
 import { buildJobProperties, buildStateCheckMethods, buildSerializationMethods, } from './jobConversionHelpers';
 /** Convert internal job to public job (with methods) */
 export function createPublicJob(opts) {
-    const { job, name, updateProgress, log, getState, remove, retry, getChildrenValues, updateData, promote, changeDelay, changePriority, extendLock, clearLogs, getDependencies, getDependenciesCount, moveToCompleted, moveToFailed, moveToWait, moveToDelayed, moveToWaitingChildren, waitUntilFinished, discard, getFailedChildrenValues, getIgnoredChildrenFailures, removeChildDependency, removeDeduplicationKey, removeUnprocessedChildren, token, processedBy, stacktrace, } = opts;
+    const { job, name, updateProgress, log, getState, remove, retry, getChildrenValues, updateData, promote, changeDelay, changePriority, extendLock, clearLogs, getDependencies, getDependenciesCount, moveToCompleted, moveToFailed, moveToWait, moveToDelayed, moveToWaitingChildren, waitUntilFinished, discard, getFailedChildrenValues, getIgnoredChildrenFailures, removeChildDependency, removeDeduplicationKey, removeUnprocessedChildren, token, processedBy, stacktrace, returnvalue, failedReason, } = opts;
     const id = String(job.id);
     const jobOpts = buildJobOpts(job);
-    const props = buildJobProperties(job, name, stacktrace, token, processedBy);
+    const props = buildJobProperties(job, name, {
+        stacktrace,
+        token,
+        processedBy,
+        returnvalue,
+        failedReason,
+    });
     const stateChecks = buildStateCheckMethods(id, getState, getDependenciesCount);
-    const serialization = buildSerializationMethods(job, id, name, jobOpts, stacktrace);
+    const serialization = buildSerializationMethods(job, {
+        id,
+        name,
+        jobOpts,
+        stacktrace,
+        returnvalue,
+        failedReason,
+    });
     return {
         ...props,
         ...stateChecks,
@@ -64,19 +74,30 @@ export function createPublicJob(opts) {
 }
 /** Simple public job without methods (for Queue.getJob) */
 export function toPublicJob(opts) {
-    const { job, name, getState, remove, retry, getChildrenValues, updateData, promote, changeDelay, changePriority, extendLock, clearLogs, getDependencies, getDependenciesCount, moveToCompleted, moveToFailed, moveToWait, moveToDelayed, moveToWaitingChildren, waitUntilFinished, discard, getFailedChildrenValues, getIgnoredChildrenFailures, removeChildDependency, removeDeduplicationKey, removeUnprocessedChildren, stacktrace, } = opts;
+    const { job, name, updateProgress, log, getState, remove, retry, getChildrenValues, updateData, promote, changeDelay, changePriority, extendLock, clearLogs, getDependencies, getDependenciesCount, moveToCompleted, moveToFailed, moveToWait, moveToDelayed, moveToWaitingChildren, waitUntilFinished, discard, getFailedChildrenValues, getIgnoredChildrenFailures, removeChildDependency, removeDeduplicationKey, removeUnprocessedChildren, stacktrace, returnvalue, failedReason, } = opts;
     const id = String(job.id);
     const jobOpts = buildJobOpts(job);
-    const props = buildJobProperties(job, name, stacktrace, undefined, undefined);
+    const props = buildJobProperties(job, name, {
+        stacktrace,
+        returnvalue,
+        failedReason,
+    });
     const stateChecks = buildStateCheckMethods(id, getState, getDependenciesCount);
-    const serialization = buildSerializationMethods(job, id, name, jobOpts, stacktrace);
+    const serialization = buildSerializationMethods(job, {
+        id,
+        name,
+        jobOpts,
+        stacktrace,
+        returnvalue,
+        failedReason,
+    });
     return {
         ...props,
         ...stateChecks,
         ...serialization,
-        // Core methods (no-op for simple jobs)
-        updateProgress: async () => { },
-        log: async () => { },
+        // Core methods
+        updateProgress: (progress, message) => updateProgress ? updateProgress(id, progress, message) : Promise.resolve(),
+        log: (message) => (log ? log(id, message) : Promise.resolve()),
         getState: () => (getState ? getState(id) : Promise.resolve('unknown')),
         remove: () => (remove ? remove(id) : Promise.resolve()),
         retry: () => (retry ? retry(id) : Promise.resolve()),
@@ -121,24 +142,6 @@ export function toPublicJob(opts) {
     };
 }
 /** Convert internal DLQ entry to public DLQ entry */
-export function toDlqEntry(entry) {
-    const jobData = entry.job.data;
-    return {
-        job: toPublicJob({ job: entry.job, name: jobData?.name ?? 'default' }),
-        enteredAt: entry.enteredAt,
-        reason: entry.reason,
-        error: entry.error,
-        attempts: entry.attempts.map((a) => ({
-            attempt: a.attempt,
-            startedAt: a.startedAt,
-            failedAt: a.failedAt,
-            reason: a.reason,
-            error: a.error,
-            duration: a.duration,
-        })),
-        retryCount: entry.retryCount,
-        lastRetryAt: entry.lastRetryAt,
-        nextRetryAt: entry.nextRetryAt,
-        expiresAt: entry.expiresAt,
-    };
+export function toDlqEntry(entry, methods) {
+    return convertDlqEntry(entry, methods, (options) => createPublicJob(options));
 }

package/dist/client/jobConversionHelpers.d.ts

@@ -4,9 +4,25 @@
  */
 import type { Job as InternalJob } from '../domain/types/job';
 import type { Job, JobStateType, JobOptions, GetDependenciesOpts, JobDependenciesCount } from './types';
+interface JobPropertyOptions {
+    stacktrace?: string[] | null;
+    token?: string;
+    processedBy?: string;
+    returnvalue?: unknown;
+    failedReason?: string;
+}
 /** Build common job properties from internal job */
-export declare function buildJobProperties<T>(job: InternalJob, name: string, stacktrace?: string[] | null, token?: string, processedBy?: string): Pick<Job<T>, 'id' | 'name' | 'data' | 'queueName' | 'attemptsMade' | 'timestamp' | 'progress' | 'parent' | 'delay' | 'processedOn' | 'finishedOn' | 'stacktrace' | 'stalledCounter' | 'priority' | 'parentKey' | 'opts' | 'token' | 'processedBy' | 'deduplicationId' | 'repeatJobKey' | 'attemptsStarted'>;
+export declare function buildJobProperties<T>(job: InternalJob, name: string, options?: JobPropertyOptions): Pick<Job<T>, 'id' | 'name' | 'data' | 'queueName' | 'attemptsMade' | 'timestamp' | 'progress' | 'parent' | 'delay' | 'processedOn' | 'finishedOn' | 'stacktrace' | 'returnvalue' | 'failedReason' | 'stalledCounter' | 'priority' | 'parentKey' | 'opts' | 'token' | 'processedBy' | 'deduplicationId' | 'repeatJobKey' | 'attemptsStarted'>;
 /** Build state check methods */
-export declare function buildStateCheckMethods(id: string, getState?: (id: string) => Promise<JobStateType>, getDependenciesCount?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>): Pick<Job, 'isWaiting' | 'isActive' | 'isDelayed' | 'isCompleted' | 'isFailed' | 'isWaitingChildren'>;
+export declare function buildStateCheckMethods(id: string, getState?: (id: string) => Promise<JobStateType>, _getDependenciesCount?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>): Pick<Job, 'isWaiting' | 'isActive' | 'isDelayed' | 'isCompleted' | 'isFailed' | 'isWaitingChildren'>;
+interface JobSerializationOptions {
+    id: string;
+    name: string;
+    jobOpts: JobOptions;
+    stacktrace?: string[] | null;
+    returnvalue?: unknown;
+    failedReason?: string;
+}
 /** Build serialization methods */
-export declare function buildSerializationMethods<T>(job: InternalJob, id: string, name: string, jobOpts: JobOptions, stacktrace?: string[] | null): Pick<Job<T>, 'toJSON' | 'asJSON'>;
+export declare function buildSerializationMethods<T>(job: InternalJob, options: JobSerializationOptions): Pick<Job<T>, 'toJSON' | 'asJSON'>;
+export {};

package/dist/client/jobConversionHelpers.js

@@ -2,16 +2,19 @@
  * Job Conversion Helpers
  * Builder functions for constructing public job properties
  */
-import { extractUserData, extractParent, buildJobOpts, buildParentKey, buildRepeatJobKey, } from './jobHelpers';
+import { extractParent, buildJobOpts, buildParentKey, buildRepeatJobKey, resolvePublicJobPayload, } from './jobHelpers';
+import { serializeReturnvalue } from './queue/jobMetadata';
 /** Build common job properties from internal job */
-export function buildJobProperties(job, name, stacktrace, token, processedBy) {
+export function buildJobProperties(job, name, options = {}) {
+    const { stacktrace, token, processedBy, returnvalue, failedReason } = options;
     const id = String(job.id);
     const parent = extractParent(job.data);
     const jobOpts = buildJobOpts(job);
+    const payload = resolvePublicJobPayload(job);
     return {
         id,
         name,
-        data: extractUserData(job.data),
+        data: payload.data,
         queueName: job.queue,
         attemptsMade: job.attempts,
         timestamp: job.createdAt,
@@ -22,6 +25,8 @@ export function buildJobProperties(job, name, stacktrace, token, processedBy) {
         finishedOn: job.completedAt ?? undefined,
         // Fall back to the stack persisted on the internal job at FAIL time (#74)
         stacktrace: stacktrace ?? job.stacktrace ?? null,
+        returnvalue,
+        failedReason,
         stalledCounter: job.stallCount,
         priority: job.priority,
         parentKey: buildParentKey(job),
@@ -38,7 +43,7 @@ export function buildJobProperties(job, name, stacktrace, token, processedBy) {
     };
 }
 /** Build state check methods */
-export function buildStateCheckMethods(id, getState, getDependenciesCount) {
+export function buildStateCheckMethods(id, getState, _getDependenciesCount) {
     return {
         isWaiting: async () => {
             const state = await (getState ? getState(id) : Promise.resolve('unknown'));
@@ -61,31 +66,30 @@ export function buildStateCheckMethods(id, getState, getDependenciesCount) {
             return state === 'failed';
         },
         isWaitingChildren: async () => {
-            if (getDependenciesCount) {
-                const counts = await getDependenciesCount(id);
-                return counts.unprocessed > 0;
-            }
-            return false;
+            const state = await (getState ? getState(id) : Promise.resolve('unknown'));
+            return state === 'waiting-children';
         },
     };
 }
 /** Build serialization methods */
-export function buildSerializationMethods(job, id, name, jobOpts, stacktrace) {
+export function buildSerializationMethods(job, options) {
+    const { id, name, jobOpts, stacktrace, returnvalue, failedReason } = options;
     // Fall back to the stack persisted on the internal job at FAIL time (#74)
     const stack = stacktrace ?? job.stacktrace ?? null;
+    const payload = resolvePublicJobPayload(job);
     return {
         toJSON: () => ({
             id,
             name,
-            data: extractUserData(job.data),
+            data: payload.data,
             opts: jobOpts,
             progress: job.progress,
             delay: job.runAt > job.createdAt ? job.runAt - job.createdAt : 0,
             timestamp: job.createdAt,
             attemptsMade: job.attempts,
             stacktrace: stack,
-            returnvalue: undefined,
-            failedReason: undefined,
+            returnvalue,
+            failedReason,
             finishedOn: job.completedAt ?? undefined,
             processedOn: job.startedAt ?? undefined,
             queueQualifiedName: `bull:${job.queue}`,
@@ -94,15 +98,15 @@ export function buildSerializationMethods(job, id, name, jobOpts, stacktrace) {
         asJSON: () => ({
             id,
             name,
-            data: JSON.stringify(extractUserData(job.data)),
+            data: JSON.stringify(payload.data),
             opts: JSON.stringify(jobOpts),
             progress: JSON.stringify(job.progress),
             delay: String(job.runAt > job.createdAt ? job.runAt - job.createdAt : 0),
             timestamp: String(job.createdAt),
             attemptsMade: String(job.attempts),
             stacktrace: stack ? JSON.stringify(stack) : null,
-            returnvalue: undefined,
-            failedReason: undefined,
+            returnvalue: serializeReturnvalue(returnvalue),
+            failedReason,
             finishedOn: job.completedAt ? String(job.completedAt) : undefined,
             processedOn: job.startedAt ? String(job.startedAt) : undefined,
             parentKey: buildParentKey(job),

package/dist/client/jobConversionTypes.d.ts

@@ -42,11 +42,17 @@ export interface CreatePublicJobOptions {
     token?: string;
     processedBy?: string;
     stacktrace?: string[] | null;
+    returnvalue?: unknown;
+    failedReason?: string;
 }
+/** Complete operation set required when exposing a live job from another view. */
+export type PublicJobMethodContext = Required<Omit<CreatePublicJobOptions, 'job' | 'name' | 'token' | 'processedBy' | 'stacktrace' | 'returnvalue' | 'failedReason'>>;
 /** Options for creating a simple public job */
 export interface ToPublicJobOptions {
     job: InternalJob;
     name: string;
+    updateProgress?: (id: string, progress: number, message?: string) => Promise<void>;
+    log?: (id: string, message: string) => Promise<void>;
     getState?: (id: string) => Promise<JobStateType>;
     remove?: (id: string) => Promise<void>;
     retry?: (id: string) => Promise<void>;
@@ -77,4 +83,6 @@ export interface ToPublicJobOptions {
     removeDeduplicationKey?: (id: string) => Promise<boolean>;
     removeUnprocessedChildren?: (id: string) => Promise<void>;
     stacktrace?: string[] | null;
+    returnvalue?: unknown;
+    failedReason?: string;
 }

package/dist/client/jobDeduplication.d.ts

@@ -0,0 +1,6 @@
+interface CommandTransport {
+    send(command: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+/** Remove only the deduplication key currently owned by the given job. */
+export declare function removeJobDeduplicationKey(id: string, embedded: boolean, transport: CommandTransport | null | undefined): Promise<boolean>;
+export {};

package/dist/client/jobDeduplication.js

@@ -0,0 +1,14 @@
+import { jobId } from '../domain/types/job';
+import { getSharedManager } from './manager';
+/** Remove only the deduplication key currently owned by the given job. */
+export async function removeJobDeduplicationKey(id, embedded, transport) {
+    if (embedded)
+        return getSharedManager().removeJobDeduplicationKey(jobId(id));
+    if (!transport)
+        return false;
+    const response = await transport.send({ cmd: 'RemoveJobDeduplicationKey', id });
+    if (!response.ok) {
+        throw new Error(response.error ?? 'Failed to remove deduplication key');
+    }
+    return response.data.removed;
+}

package/dist/client/jobHelpers.d.ts

@@ -2,10 +2,15 @@
  * Job Helper Functions
  * Internal utilities for extracting and building job data
  */
-import type { Job as InternalJob } from '../domain/types/job';
+import { type Job as InternalJob } from '../domain/types/job';
 import type { RepeatOptions, JobOptions } from './types';
-/** Extract user data from stored job data (removes internal 'name' field) */
+/** Decode a bare pre-name-field payload. Modern conversions use normalizeJobPayload(job). */
 export declare function extractUserData(jobData: unknown): unknown;
+/** Resolve legacy names while preserving documented engine-owned flow metadata. */
+export declare function resolvePublicJobPayload(job: InternalJob): {
+    name: string;
+    data: unknown;
+};
 /** Extract parent info from job data if present */
 export declare function extractParent(jobData: unknown): {
     id: string;

package/dist/client/jobHelpers.js

@@ -2,13 +2,15 @@
  * Job Helper Functions
  * Internal utilities for extracting and building job data
  */
-/** Extract user data from stored job data (removes internal 'name' field) */
+import { normalizeLegacyJobPayload } from '../domain/types/job';
+/** Decode a bare pre-name-field payload. Modern conversions use normalizeJobPayload(job). */
 export function extractUserData(jobData) {
-    if (typeof jobData === 'object' && jobData !== null) {
-        const { name: _name, ...userData } = jobData;
-        return userData;
-    }
-    return jobData;
+    return normalizeLegacyJobPayload({ data: jobData }).data;
+}
+/** Resolve legacy names while preserving documented engine-owned flow metadata. */
+export function resolvePublicJobPayload(job) {
+    const payload = normalizeLegacyJobPayload(job);
+    return { name: payload.name, data: payload.data };
 }
 /** Extract parent info from job data if present */
 export function extractParent(jobData) {
@@ -83,8 +85,14 @@ export function buildJobOpts(job) {
         removeDependencyOnFailure: job.removeDependencyOnFailure,
         continueParentOnFailure: job.continueParentOnFailure,
         ignoreDependencyOnFailure: job.ignoreDependencyOnFailure,
-        deduplication: job.deduplicationTtl !== null
-            ? { id: job.customId ?? '', ttl: job.deduplicationTtl }
+        durable: job.durable ?? false,
+        deduplication: job.uniqueKey !== null
+            ? {
+                id: job.uniqueKey,
+                ttl: job.deduplicationTtl ?? undefined,
+                extend: job.deduplicationExtend,
+                replace: job.deduplicationReplace,
+            }
             : undefined,
         debounce: job.debounceId && job.debounceTtl !== null
             ? { id: job.debounceId, ttl: job.debounceTtl }

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

@@ -3,7 +3,7 @@
  */
 import type { TcpConnectionPool } from '../tcpPool';
 import type { Job, JobDependencies, JobDependenciesCount, GetDependenciesOpts } from '../types';
-interface BullMQContext<T = unknown> {
+interface CompatibilityContext<T = unknown> {
     name: string;
     embedded: boolean;
     tcp: TcpConnectionPool | null;
@@ -22,26 +22,36 @@ interface BullMQContext<T = unknown> {
     clearJobLogs: (id: string, keepLogs?: number) => Promise<void>;
     getJobDependencies: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependencies>;
     getJobDependenciesCount: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>;
+    getJobCountsAsync: () => Promise<{
+        prioritized: number;
+        'waiting-children': number;
+    }>;
     getWaitingAsync: (start?: number, end?: number) => Promise<Job<T>[]>;
     getPrioritizedAsync: (start?: number, end?: number) => Promise<Job<T>[]>;
+    getJobsAsync: (options: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }) => Promise<Job<T>[]>;
 }
 /** Get jobs in the "prioritized" state (priority > 0, BullMQ v5) */
-export declare function getPrioritized<T>(ctx: BullMQContext<T>, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getPrioritized<T>(ctx: CompatibilityContext<T>, start?: number, end?: number): Promise<Job<T>[]>;
 /** Get count of prioritized jobs (priority > 0) */
-export declare function getPrioritizedCount<T>(ctx: BullMQContext<T>): Promise<number>;
+export declare function getPrioritizedCount<T>(ctx: CompatibilityContext<T>): Promise<number>;
 /** Get jobs waiting for parent to complete */
-export declare function getWaitingChildren<T>(ctx: BullMQContext<T>, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getWaitingChildren<T>(ctx: CompatibilityContext<T>, start?: number, end?: number): Promise<Job<T>[]>;
 /** Get count of jobs waiting for parent */
-export declare function getWaitingChildrenCount<T>(ctx: BullMQContext<T>): Promise<number>;
+export declare function getWaitingChildrenCount<T>(ctx: CompatibilityContext<T>): Promise<number>;
 /** Get dependencies of a parent job */
-export declare function getDependencies(_ctx: BullMQContext, _parentId: string, _type?: 'processed' | 'unprocessed', _start?: number, _end?: number): Promise<{
+export declare function getDependencies(ctx: CompatibilityContext, parentId: string, type?: 'processed' | 'unprocessed', start?: number, end?: number): Promise<{
     processed?: Record<string, unknown>;
     unprocessed?: string[];
     nextProcessedCursor?: number;
     nextUnprocessedCursor?: number;
 }>;
 /** Get job dependencies (for Job instance method) */
-export declare function getJobDependencies(ctx: BullMQContext, id: string, _opts?: GetDependenciesOpts): Promise<JobDependencies>;
+export declare function getJobDependencies(ctx: CompatibilityContext, id: string, _opts?: GetDependenciesOpts): Promise<JobDependencies>;
 /** Get job dependencies count */
-export declare function getJobDependenciesCount(ctx: BullMQContext, id: string, _opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
+export declare function getJobDependenciesCount(ctx: CompatibilityContext, id: string, _opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
 export {};

package/dist/client/queue/bullmqCompat.js

@@ -2,95 +2,63 @@
 /**
  * BullMQ v5 Compatibility Operations
  */
-import { getSharedManager } from '../manager';
-import { toPublicJob } from '../types';
-import { jobId } from '../../domain/types/job';
+import { getFlowDependencies } from '../flowJobDependencies';
 /** Get jobs in the "prioritized" state (priority > 0, BullMQ v5) */
 export function getPrioritized(ctx, start = 0, end = -1) {
     return ctx.getPrioritizedAsync(start, end);
 }
 /** Get count of prioritized jobs (priority > 0) */
 export async function getPrioritizedCount(ctx) {
-    const jobs = await ctx.getPrioritizedAsync(0, 1000);
-    return jobs.length;
+    return (await ctx.getJobCountsAsync()).prioritized;
 }
 /** Get jobs waiting for parent to complete */
 export async function getWaitingChildren(ctx, start = 0, end = -1) {
-    if (ctx.embedded) {
-        const jobs = getSharedManager().getJobs(ctx.name, {
-            state: 'delayed',
-            start,
-            end: end === -1 ? 1000 : end,
-        });
-        return jobs
-            .filter((j) => {
-            const data = j.data;
-            return data?._waitingParent === true;
-        })
-            .map((job) => {
-            const jobData = job.data;
-            return toPublicJob({
-                job,
-                name: jobData?.name ?? 'default',
-                getState: ctx.getJobState,
-                remove: ctx.removeAsync,
-                retry: ctx.retryJob,
-                getChildrenValues: ctx.getChildrenValues,
-                updateData: ctx.updateJobData,
-                promote: ctx.promoteJob,
-                changeDelay: ctx.changeJobDelay,
-                changePriority: ctx.changeJobPriority,
-                extendLock: ctx.extendJobLock,
-                clearLogs: ctx.clearJobLogs,
-                getDependencies: ctx.getJobDependencies,
-                getDependenciesCount: ctx.getJobDependenciesCount,
-            });
-        });
-    }
-    return [];
+    return ctx.getJobsAsync({
+        state: 'waiting-children',
+        start,
+        end: end === -1 ? -1 : end + 1,
+        asc: true,
+    });
 }
 /** Get count of jobs waiting for parent */
 export async function getWaitingChildrenCount(ctx) {
-    const children = await getWaitingChildren(ctx);
-    return children.length;
+    return (await ctx.getJobCountsAsync())['waiting-children'];
 }
 /** Get dependencies of a parent job */
-export function getDependencies(_ctx, _parentId, _type, _start, _end) {
-    return Promise.resolve({ processed: {}, unprocessed: [] });
+export function getDependencies(ctx, parentId, type, start = 0, end = -1) {
+    return getFlowDependencies(parentId, ctx.name, ctx.embedded, ctx.tcp).then((dependencies) => {
+        const unprocessed = [...dependencies.unprocessed].sort();
+        const processedEntries = Object.entries(dependencies.processed).sort(([a], [b]) => a.localeCompare(b));
+        const stop = end < 0 ? undefined : end + 1;
+        return {
+            processed: type === 'unprocessed' ? {} : Object.fromEntries(processedEntries.slice(start, stop)),
+            unprocessed: type === 'processed' ? [] : unprocessed.slice(start, stop),
+        };
+    });
 }
 /** Get job dependencies (for Job instance method) */
 export async function getJobDependencies(ctx, id, _opts) {
-    if (ctx.embedded) {
-        const manager = getSharedManager();
-        const job = await manager.getJob(jobId(id));
-        if (!job)
-            return { processed: {}, unprocessed: [] };
-        const childIds = job.childrenIds;
-        const processed = {};
-        const unprocessed = [];
-        for (const childId of childIds) {
-            const result = manager.getResult(childId);
-            if (result !== undefined) {
-                const childJob = await manager.getJob(childId);
-                const key = childJob ? `${childJob.queue}:${childId}` : String(childId);
-                processed[key] = result;
-            }
-            else {
-                unprocessed.push(String(childId));
-            }
-        }
-        return { processed, unprocessed };
-    }
-    return { processed: {}, unprocessed: [] };
+    const dependencies = await getFlowDependencies(id, ctx.name, ctx.embedded, ctx.tcp);
+    const processedEntries = Object.entries(dependencies.processed).sort(([a], [b]) => a.localeCompare(b));
+    const unprocessed = [...dependencies.unprocessed].sort();
+    const processedCursor = _opts?.processed?.cursor ?? 0;
+    const processedCount = _opts?.processed?.count ?? processedEntries.length;
+    const unprocessedCursor = _opts?.unprocessed?.cursor ?? 0;
+    const unprocessedCount = _opts?.unprocessed?.count ?? unprocessed.length;
+    const processedEnd = Math.min(processedEntries.length, processedCursor + processedCount);
+    const unprocessedEnd = Math.min(unprocessed.length, unprocessedCursor + unprocessedCount);
+    return {
+        processed: Object.fromEntries(processedEntries.slice(processedCursor, processedEnd)),
+        unprocessed: unprocessed.slice(unprocessedCursor, unprocessedEnd),
+        nextProcessedCursor: processedEnd < processedEntries.length ? processedEnd : 0,
+        nextUnprocessedCursor: unprocessedEnd < unprocessed.length ? unprocessedEnd : 0,
+    };
 }
 /** Get job dependencies count */
 export async function getJobDependenciesCount(ctx, id, _opts) {
-    if (ctx.embedded) {
-        const deps = await getJobDependencies(ctx, id);
-        return {
-            processed: Object.keys(deps.processed).length,
-            unprocessed: deps.unprocessed.length,
-        };
-    }
-    return { processed: 0, unprocessed: 0 };
+    const deps = await getFlowDependencies(id, ctx.name, ctx.embedded, ctx.tcp);
+    return {
+        processed: Object.keys(deps.processed).length,
+        unprocessed: deps.unprocessed.length,
+    };
 }

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

@@ -1,9 +1,11 @@
 /**
  * Deduplication Operations
  */
+import type { TcpConnectionPool } from '../tcpPool';
 interface DeduplicationContext {
     name: string;
     embedded: boolean;
+    tcp: TcpConnectionPool | null;
 }
 /** Get the job ID associated with a deduplication key */
 export declare function getDeduplicationJobId(ctx: DeduplicationContext, deduplicationId: string): Promise<string | null>;

package/dist/client/queue/deduplication.js

@@ -3,21 +3,30 @@
  */
 import { getSharedManager } from '../manager';
 /** Get the job ID associated with a deduplication key */
-export function getDeduplicationJobId(ctx, deduplicationId) {
+export async function getDeduplicationJobId(ctx, deduplicationId) {
     if (ctx.embedded) {
-        const job = getSharedManager().getJobByCustomId(deduplicationId);
-        return Promise.resolve(job ? String(job.id) : null);
+        return getSharedManager().getDeduplicationJobId(ctx.name, deduplicationId);
     }
-    return Promise.resolve(null);
+    if (!ctx.tcp)
+        return null;
+    const response = await ctx.tcp.send({
+        cmd: 'GetDeduplicationJobId',
+        queue: ctx.name,
+        deduplicationId,
+    });
+    return response.data.jobId;
 }
 /** Remove a deduplication key */
-export function removeDeduplicationKey(ctx, deduplicationId) {
+export async function removeDeduplicationKey(ctx, deduplicationId) {
     if (ctx.embedded) {
-        const job = getSharedManager().getJobByCustomId(deduplicationId);
-        if (job) {
-            return Promise.resolve(1);
-        }
-        return Promise.resolve(0);
+        return getSharedManager().removeDeduplicationKey(ctx.name, deduplicationId);
     }
-    return Promise.resolve(0);
+    if (!ctx.tcp)
+        return 0;
+    const response = await ctx.tcp.send({
+        cmd: 'RemoveDeduplicationKey',
+        queue: ctx.name,
+        deduplicationId,
+    });
+    return response.data.count;
 }

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

@@ -4,7 +4,7 @@
  */
 import type { TcpConnectionPool } from '../tcpPool';
 import type { Job, DlqConfig, DlqEntry, DlqStats, DlqFilter } from '../types';
-import { type SimpleJobContext } from './jobProxy';
+import { type DlqJobContext } from './dlqJobMethods';
 interface DlqContext {
     name: string;
     embedded: boolean;
@@ -19,16 +19,19 @@ export declare function getDlqConfig(ctx: DlqContext): DlqConfig;
 /** Get DLQ configuration (async, works in TCP mode) */
 export declare function getDlqConfigAsync(ctx: DlqContext): Promise<DlqConfig>;
 /** Get DLQ entries */
-export declare function getDlq<T>(ctx: DlqContext, filter?: DlqFilter): DlqEntry<T>[];
-type DlqQueryContext = DlqContext & Pick<SimpleJobContext, 'getJobState' | 'removeAsync' | 'retryJob' | 'getChildrenValues'>;
+export declare function getDlq<T>(ctx: DlqQueryContext, filter?: DlqFilter): DlqEntry<T>[];
+type DlqQueryContext = DlqJobContext;
+/** Read full DLQ metadata from the selected broker runtime. */
+export declare function getDlqAsync<T>(ctx: DlqQueryContext, filter?: DlqFilter): Promise<DlqEntry<T>[]>;
 /**
- * Get the dead jobs in the DLQ, working over TCP too (wire command `Dlq`).
- * Returns public Job objects; the wire does not carry DlqEntry metadata
- * (reason, enteredAt, attempts) — that stays embedded-only via getDlq().
+ * Get only the public jobs from the DLQ. Use getDlqAsync() when the full entry
+ * metadata is needed; both views work over TCP through the same command.
  */
 export declare function getDlqJobsAsync<T>(ctx: DlqQueryContext, count?: number): Promise<Job<T>[]>;
 /** Get DLQ stats */
 export declare function getDlqStats(ctx: DlqContext): DlqStats;
+/** Read authoritative DLQ statistics from the selected broker runtime. */
+export declare function getDlqStatsAsync(ctx: DlqContext): Promise<DlqStats>;
 /** Retry DLQ entries */
 export declare function retryDlq(ctx: DlqContext, id?: string): number;
 /**
@@ -39,6 +42,8 @@ export declare function retryDlq(ctx: DlqContext, id?: string): number;
 export declare function retryDlqAsync(ctx: DlqContext, id?: string): Promise<number>;
 /** Retry DLQ entries by filter */
 export declare function retryDlqByFilter(ctx: DlqContext, filter: DlqFilter): number;
+/** Retry matching DLQ entries and return the applied count. */
+export declare function retryDlqByFilterAsync(ctx: DlqContext, filter: DlqFilter): Promise<number>;
 /** Purge DLQ */
 export declare function purgeDlq(ctx: DlqContext): number;
 /**