bunqueue 2.8.53 → 2.8.56

package/dist/client/queue/dlq.js

@@ -6,6 +6,10 @@ import { getSharedManager } from '../manager';
 import { jobId } from '../../domain/types/job';
 import { createSimpleJob } from './jobProxy';
 import * as dlqOps from './dlqOps';
+import { toDlqEntry } from '../jobConversion';
+import { createDlqJobMethods } from './dlqJobMethods';
+import { resolvePublicJobPayload } from '../jobHelpers';
+import { toPublicDlqStats } from './dlqStats';
 /** Client-side cache for TCP mode */
 const tcpDlqConfigCache = new Map();
 /** Set DLQ configuration */
@@ -56,12 +60,31 @@ export async function getDlqConfigAsync(ctx) {
 export function getDlq(ctx, filter) {
     if (!ctx.embedded)
         return [];
-    return dlqOps.getDlqEntries(ctx.name, filter);
+    const entries = getSharedManager().getDlqEntries(ctx.name, filter);
+    const methods = createDlqJobMethods(ctx);
+    return entries.map((entry) => toDlqEntry(entry, methods));
+}
+/** Read full DLQ metadata from the selected broker runtime. */
+export async function getDlqAsync(ctx, filter) {
+    let entries;
+    if (ctx.embedded) {
+        entries = getSharedManager().getDlqEntries(ctx.name, filter);
+    }
+    else if (ctx.tcp) {
+        const response = await ctx.tcp.send({ cmd: 'Dlq', queue: ctx.name, filter });
+        if (!response.ok)
+            return [];
+        entries = (response.entries ?? []);
+    }
+    else {
+        return [];
+    }
+    const methods = createDlqJobMethods(ctx);
+    return entries.map((entry) => toDlqEntry(entry, methods));
 }
 /**
- * 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 async function getDlqJobsAsync(ctx, count) {
     let raw;
@@ -78,8 +101,8 @@ export async function getDlqJobsAsync(ctx, count) {
         return [];
     }
     return raw.map((job) => {
-        const name = job.data?.name ?? 'unknown';
-        return createSimpleJob(String(job.id), name, job.data, job.createdAt ?? Date.now(), {
+        const { name, data } = resolvePublicJobPayload(job);
+        return createSimpleJob(String(job.id), name, data, job.createdAt ?? Date.now(), {
             queueName: ctx.name,
             embedded: ctx.embedded,
             tcp: ctx.tcp,
@@ -93,17 +116,21 @@ export async function getDlqJobsAsync(ctx, count) {
 /** Get DLQ stats */
 export function getDlqStats(ctx) {
     if (!ctx.embedded) {
-        return {
-            total: 0,
-            byReason: {},
-            pendingRetry: 0,
-            expired: 0,
-            oldestEntry: null,
-            newestEntry: null,
-        };
+        return toPublicDlqStats(undefined);
     }
     return dlqOps.getDlqStatsEmbedded(ctx.name);
 }
+/** Read authoritative DLQ statistics from the selected broker runtime. */
+export async function getDlqStatsAsync(ctx) {
+    if (ctx.embedded)
+        return dlqOps.getDlqStatsEmbedded(ctx.name);
+    if (!ctx.tcp)
+        return getDlqStats(ctx);
+    const response = await ctx.tcp.send({ cmd: 'GetDlqStats', queue: ctx.name });
+    if (!response.ok)
+        return getDlqStats(ctx);
+    return toPublicDlqStats(response.data.stats);
+}
 /** Retry DLQ entries */
 export function retryDlq(ctx, id) {
     if (ctx.embedded)
@@ -129,9 +156,23 @@ export async function retryDlqAsync(ctx, id) {
 }
 /** Retry DLQ entries by filter */
 export function retryDlqByFilter(ctx, filter) {
-    if (!ctx.embedded)
+    if (ctx.embedded)
+        return dlqOps.retryDlqByFilterEmbedded(ctx.name, filter);
+    if (ctx.tcp) {
+        void ctx.tcp.send({ cmd: 'RetryDlq', queue: ctx.name, filter }).catch(() => undefined);
+    }
+    return 0;
+}
+/** Retry matching DLQ entries and return the applied count. */
+export async function retryDlqByFilterAsync(ctx, filter) {
+    if (ctx.embedded)
+        return dlqOps.retryDlqByFilterEmbedded(ctx.name, filter);
+    if (!ctx.tcp)
         return 0;
-    return dlqOps.retryDlqByFilterEmbedded(ctx.name, filter);
+    const response = await ctx.tcp.send({ cmd: 'RetryDlq', queue: ctx.name, filter });
+    if (!response.ok)
+        return 0;
+    return (response.count ?? 0);
 }
 /** Purge DLQ */
 export function purgeDlq(ctx) {

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

@@ -0,0 +1,9 @@
+import type { PublicJobMethodContext } from '../jobConversionTypes';
+import type { TcpConnectionPool } from '../tcpPool';
+import type { SimpleJobContext } from './jobProxy';
+export interface DlqJobContext extends Pick<SimpleJobContext, 'getJobState' | 'removeAsync' | 'retryJob' | 'getChildrenValues'> {
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+}
+export declare function createDlqJobMethods(ctx: DlqJobContext): PublicJobMethodContext;

package/dist/client/queue/dlqJobMethods.js

@@ -0,0 +1,177 @@
+import { jobId } from '../../domain/types/job';
+import { getFlowDependencies } from '../flowJobDependencies';
+import { getSharedManager } from '../manager';
+import { removeJobDeduplicationKey } from '../jobDeduplication';
+import { buildFailCommand, failEmbeddedArgs } from './failWire';
+function assertCommand(response, operation) {
+    if (response.ok === true)
+        return;
+    throw new Error(typeof response.error === 'string' ? response.error : `${operation} failed`);
+}
+export function createDlqJobMethods(ctx) {
+    const manager = getSharedManager();
+    const send = async (command, operation) => {
+        if (!ctx.tcp)
+            throw new Error(`${operation}: no connection`);
+        const response = await ctx.tcp.send(command);
+        assertCommand(response, operation);
+        return response;
+    };
+    const dependencies = (id) => getFlowDependencies(id, ctx.name, ctx.embedded, ctx.tcp);
+    return {
+        updateProgress: async (id, progress, message) => {
+            if (ctx.embedded) {
+                if (!(await manager.updateProgress(jobId(id), progress, message))) {
+                    throw new Error(`Job ${id} is not active`);
+                }
+            }
+            else
+                await send({ cmd: 'Progress', id, progress, message }, 'Progress');
+        },
+        log: async (id, message) => {
+            if (ctx.embedded)
+                manager.addLog(jobId(id), message);
+            else
+                await send({ cmd: 'AddLog', id, message }, 'AddLog');
+        },
+        getState: ctx.getJobState,
+        remove: ctx.removeAsync,
+        retry: ctx.retryJob,
+        getChildrenValues: ctx.getChildrenValues,
+        updateData: async (id, data) => {
+            if (ctx.embedded)
+                await manager.updateJobData(jobId(id), data);
+            else
+                await send({ cmd: 'Update', id, data }, 'Update');
+        },
+        promote: async (id) => {
+            if (ctx.embedded)
+                await manager.promote(jobId(id));
+            else
+                await send({ cmd: 'Promote', id }, 'Promote');
+        },
+        changeDelay: async (id, delay) => {
+            if (ctx.embedded)
+                await manager.changeDelay(jobId(id), delay);
+            else
+                await send({ cmd: 'ChangeDelay', id, delay }, 'ChangeDelay');
+        },
+        changePriority: async (id, options) => {
+            if (ctx.embedded)
+                await manager.changePriority(jobId(id), options.priority, options.lifo);
+            else {
+                await send({ cmd: 'ChangePriority', id, priority: options.priority, lifo: options.lifo }, 'ChangePriority');
+            }
+        },
+        extendLock: async (id, token, duration) => {
+            if (ctx.embedded)
+                return (await manager.extendLock(jobId(id), token, duration)) ? duration : 0;
+            const response = await send({ cmd: 'ExtendLock', id, token, duration }, 'ExtendLock');
+            return response.ok === true ? duration : 0;
+        },
+        clearLogs: async (id, keepLogs) => {
+            if (ctx.embedded)
+                manager.clearLogs(jobId(id), keepLogs);
+            else
+                await send({ cmd: 'ClearLogs', id, keepLogs }, 'ClearLogs');
+        },
+        getDependencies: async (id) => dependencies(id),
+        getDependenciesCount: async (id) => {
+            const value = await dependencies(id);
+            return {
+                processed: Object.keys(value.processed).length,
+                unprocessed: value.unprocessed.length,
+            };
+        },
+        moveToCompleted: async (id, result, token) => {
+            if (ctx.embedded)
+                await manager.ack(jobId(id), result, token);
+            else
+                await send({ cmd: 'ACK', id, result, token }, 'ACK');
+            return null;
+        },
+        moveToFailed: async (id, error, token) => {
+            if (ctx.embedded)
+                await manager.fail(jobId(id), ...failEmbeddedArgs(error, token));
+            else
+                await send(buildFailCommand(id, error, token), 'FAIL');
+        },
+        moveToWait: async (id, token) => {
+            if (ctx.embedded) {
+                const state = await manager.getJobState(jobId(id));
+                if (state === 'failed')
+                    return manager.retryDlq(ctx.name, jobId(id)) > 0;
+                if (state === 'active')
+                    return manager.moveActiveToWait(jobId(id), token);
+                if (state === 'delayed')
+                    return manager.promote(jobId(id));
+                return state === 'waiting' || state === 'prioritized';
+            }
+            const response = await send({ cmd: 'MoveToWait', id, ...(token === undefined ? {} : { token }) }, 'MoveToWait');
+            return response.ok === true;
+        },
+        moveToDelayed: async (id, timestamp, token) => {
+            const delay = Math.max(0, timestamp - Date.now());
+            if (ctx.embedded)
+                await manager.moveToDelayed(jobId(id), delay, token);
+            else {
+                await send({ cmd: 'MoveToDelayed', id, delay, ...(token === undefined ? {} : { token }) }, 'MoveToDelayed');
+            }
+        },
+        moveToWaitingChildren: async (id, token) => {
+            if (ctx.embedded)
+                return manager.moveToWaitingChildren(jobId(id), token);
+            await send({ cmd: 'MoveToWaitingChildren', id, ...(token === undefined ? {} : { token }) }, 'MoveToWaitingChildren');
+            return true;
+        },
+        waitUntilFinished: async (id, _events, ttl) => {
+            const timeout = ttl ?? 30_000;
+            if (ctx.embedded) {
+                const current = await manager.getJob(jobId(id));
+                if (!current)
+                    throw new Error(`Job ${id} not found`);
+                if (current.completedAt)
+                    return manager.getResult(jobId(id));
+                if (!(await manager.waitForJobCompletion(jobId(id), timeout))) {
+                    throw new Error(`Job ${id} timed out after ${timeout}ms`);
+                }
+                return manager.getResult(jobId(id));
+            }
+            const response = await send({ cmd: 'WaitJob', id, timeout }, 'WaitJob');
+            if (!response.completed)
+                throw new Error(`Job ${id} timed out after ${timeout}ms`);
+            return response.result;
+        },
+        discard: (id) => {
+            if (ctx.embedded)
+                void manager.discard(jobId(id));
+            else if (ctx.tcp)
+                void ctx.tcp.send({ cmd: 'Discard', id });
+        },
+        getFailedChildrenValues: async (id) => {
+            if (ctx.embedded)
+                return manager.getFailedChildrenValues(jobId(id));
+            const response = await send({ cmd: 'GetFailedChildrenValues', id }, 'GetFailedChildrenValues');
+            return response.values ?? {};
+        },
+        getIgnoredChildrenFailures: async (id) => {
+            if (ctx.embedded)
+                return manager.getIgnoredChildrenFailures(jobId(id));
+            const response = await send({ cmd: 'GetIgnoredChildrenFailures', id }, 'GetIgnoredChildrenFailures');
+            return response.values ?? {};
+        },
+        removeChildDependency: async (id) => {
+            if (ctx.embedded)
+                return manager.removeChildDependency(jobId(id));
+            const response = await send({ cmd: 'RemoveChildDependency', id }, 'RemoveChildDependency');
+            return response.removed ?? false;
+        },
+        removeDeduplicationKey: (id) => removeJobDeduplicationKey(id, ctx.embedded, ctx.tcp),
+        removeUnprocessedChildren: async (id) => {
+            if (ctx.embedded)
+                await manager.removeUnprocessedChildren(jobId(id));
+            else
+                await send({ cmd: 'RemoveUnprocessedChildren', id }, 'RemoveUnprocessedChildren');
+        },
+    };
+}

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

@@ -3,12 +3,13 @@
  * Dead Letter Queue management for embedded mode
  */
 import type { DlqConfig, DlqEntry, DlqStats, DlqFilter, StallConfig } from '../types';
+import type { PublicJobMethodContext } from '../jobConversionTypes';
 /** Set DLQ configuration (embedded only) */
 export declare function setDlqConfig(queue: string, config: Partial<DlqConfig>): void;
 /** Get DLQ configuration (embedded only) */
 export declare function getDlqConfigEmbedded(queue: string): DlqConfig;
 /** Get DLQ entries (embedded only) */
-export declare function getDlqEntries<T>(queue: string, filter?: DlqFilter): DlqEntry<T>[];
+export declare function getDlqEntries<T>(queue: string, methods: PublicJobMethodContext, filter?: DlqFilter): DlqEntry<T>[];
 /** Get DLQ statistics (embedded only) */
 export declare function getDlqStatsEmbedded(queue: string): DlqStats;
 /** Retry DLQ jobs by filter (embedded only) */

package/dist/client/queue/dlqOps.js

@@ -7,6 +7,7 @@ import { jobId } from '../../domain/types/job';
 import { toDlqEntry } from '../types';
 import { getShard, getDlqContext, toDomainFilter, toDomainDlqConfig } from './helpers';
 import * as dlqOps from '../../application/dlqManager';
+import { toPublicDlqStats } from './dlqStats';
 /** Set DLQ configuration (embedded only) */
 export function setDlqConfig(queue, config) {
     getSharedManager().setDlqConfig(queue, toDomainDlqConfig(config));
@@ -18,25 +19,18 @@ export function getDlqConfigEmbedded(queue) {
     return dlqOps.getDlqConfig(queue, ctx);
 }
 /** Get DLQ entries (embedded only) */
-export function getDlqEntries(queue, filter) {
+export function getDlqEntries(queue, methods, filter) {
     const manager = getSharedManager();
     const ctx = getDlqContext(manager);
     const entries = dlqOps.getDlqEntries(queue, ctx, toDomainFilter(filter));
-    return entries.map((entry) => toDlqEntry(entry));
+    return entries.map((entry) => toDlqEntry(entry, methods));
 }
 /** Get DLQ statistics (embedded only) */
 export function getDlqStatsEmbedded(queue) {
     const manager = getSharedManager();
     const ctx = getDlqContext(manager);
     const stats = dlqOps.getDlqStats(queue, ctx);
-    return {
-        total: stats.total,
-        byReason: stats.byReason,
-        pendingRetry: stats.pendingRetry,
-        expired: stats.expired,
-        oldestEntry: stats.oldestEntry,
-        newestEntry: stats.newestEntry,
-    };
+    return toPublicDlqStats(stats);
 }
 /** Retry DLQ jobs by filter (embedded only) */
 export function retryDlqByFilterEmbedded(queue, filter) {

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

@@ -0,0 +1,3 @@
+import type { DlqStats } from '../types';
+/** Normalize one authoritative DLQ stats shape for both transports. */
+export declare function toPublicDlqStats(stats: Partial<DlqStats> | undefined): DlqStats;

package/dist/client/queue/dlqStats.js

@@ -0,0 +1,21 @@
+const EMPTY_REASONS = {
+    ["explicit_fail" /* FailureReason.ExplicitFail */]: 0,
+    ["max_attempts_exceeded" /* FailureReason.MaxAttemptsExceeded */]: 0,
+    ["timeout" /* FailureReason.Timeout */]: 0,
+    ["stalled" /* FailureReason.Stalled */]: 0,
+    ["ttl_expired" /* FailureReason.TtlExpired */]: 0,
+    ["worker_lost" /* FailureReason.WorkerLost */]: 0,
+    ["unknown" /* FailureReason.Unknown */]: 0,
+};
+/** Normalize one authoritative DLQ stats shape for both transports. */
+export function toPublicDlqStats(stats) {
+    return {
+        total: stats?.total ?? 0,
+        byReason: { ...EMPTY_REASONS, ...stats?.byReason },
+        byQueue: { ...stats?.byQueue },
+        pendingRetry: stats?.pendingRetry ?? 0,
+        expired: stats?.expired ?? 0,
+        oldestEntry: stats?.oldestEntry ?? null,
+        newestEntry: stats?.newestEntry ?? null,
+    };
+}

package/dist/client/queue/job-proxy/dependencies.d.ts

@@ -0,0 +1,9 @@
+import type { TcpConnectionPool } from '../../tcpPool';
+export declare function computeDependencies(id: string, queueName: string, tcp: TcpConnectionPool): Promise<{
+    processed: Record<string, unknown>;
+    unprocessed: string[];
+}>;
+export declare function computeSimpleDependencies(id: string, queueName: string, embedded: boolean | undefined, tcp: TcpConnectionPool | null | undefined): Promise<{
+    processed: Record<string, unknown>;
+    unprocessed: string[];
+}>;

package/dist/client/queue/job-proxy/dependencies.js

@@ -0,0 +1,67 @@
+import { getSharedManager } from '../../manager';
+import { jobId } from '../../../domain/types/job';
+export async function computeDependencies(id, queueName, tcp) {
+    const jobRes = await tcp.send({ cmd: 'GetJob', id });
+    const parent = jobRes.job;
+    const childIds = parent?.childrenIds ?? [];
+    const processed = {};
+    const unprocessed = [];
+    for (const childId of childIds) {
+        const stateRes = await tcp.send({ cmd: 'GetState', id: childId });
+        const state = stateRes.state ?? 'unknown';
+        const key = `${queueName}:${childId}`;
+        if (state === 'completed' || state === 'failed') {
+            if (state === 'completed') {
+                const resultResponse = await tcp.send({ cmd: 'GetResult', id: childId });
+                processed[key] = resultResponse.result ?? null;
+            }
+            else {
+                processed[key] = null;
+            }
+        }
+        else {
+            unprocessed.push(key);
+        }
+    }
+    return { processed, unprocessed };
+}
+export async function computeSimpleDependencies(id, queueName, embedded, tcp) {
+    const processed = {};
+    const unprocessed = [];
+    let childIds = [];
+    if (embedded) {
+        const job = await getSharedManager().getJob(jobId(id));
+        childIds = (job?.childrenIds ?? []).map(String);
+    }
+    else if (tcp) {
+        const jobRes = await tcp.send({ cmd: 'GetJob', id });
+        const parent = jobRes.job;
+        childIds = (parent?.childrenIds ?? []).map(String);
+    }
+    for (const childId of childIds) {
+        let state = 'unknown';
+        let result;
+        if (embedded) {
+            const manager = getSharedManager();
+            state = await manager.getJobState(jobId(childId));
+            if (state === 'completed')
+                result = manager.getResult(jobId(childId));
+        }
+        else if (tcp) {
+            const response = await tcp.send({ cmd: 'GetState', id: childId });
+            state = response.state ?? 'unknown';
+            if (state === 'completed') {
+                const resultResponse = await tcp.send({ cmd: 'GetResult', id: childId });
+                result = resultResponse.result;
+            }
+        }
+        const key = `${queueName}:${childId}`;
+        if (state === 'completed' || state === 'failed') {
+            processed[key] = result ?? null;
+        }
+        else {
+            unprocessed.push(key);
+        }
+    }
+    return { processed, unprocessed };
+}

package/dist/client/queue/job-proxy/reflection.d.ts

@@ -0,0 +1,2 @@
+import type { JobReflectionMeta, ReflectedFields } from '../types/job';
+export declare function reflectFields(id: string, queueName: string, meta?: JobReflectionMeta): ReflectedFields;

package/dist/client/queue/job-proxy/reflection.js

@@ -0,0 +1,18 @@
+export function reflectFields(id, queueName, meta) {
+    const opts = meta?.opts ?? {};
+    const parent = opts.parent;
+    const repeat = opts.repeat;
+    const pattern = repeat?.pattern ?? (repeat?.every ? `every:${repeat.every}` : '');
+    return {
+        delay: meta?.delay ?? 0,
+        priority: meta?.priority ?? 0,
+        opts,
+        deduplicationId: opts.jobId ?? opts.deduplication?.id,
+        parentKey: parent ? `${parent.queue}:${parent.id}` : undefined,
+        parent: parent ? { id: parent.id, queueQualifiedName: parent.queue } : undefined,
+        repeatJobKey: repeat ? `${queueName}:${id}:${pattern}` : undefined,
+        stacktrace: meta?.stacktrace ?? null,
+        returnvalue: meta?.returnvalue,
+        failedReason: meta?.failedReason,
+    };
+}

package/dist/client/queue/job-proxy/simple.d.ts

@@ -0,0 +1,3 @@
+import type { Job } from '../../types';
+import type { SimpleJobContext } from '../types/job';
+export declare function createSimpleJob<T>(id: string, name: string, data: T, timestamp: number, ctx: SimpleJobContext): Job<T>;