bunqueue 2.8.54 → 2.8.57

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,12 +74,23 @@ export function createPublicJob(opts) {
 }
 /** Simple public job without methods (for Queue.getJob) */
 export function toPublicJob(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, } = 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,
@@ -122,27 +143,5 @@ export function toPublicJob(opts) {
 }
 /** Convert internal DLQ entry to public DLQ entry */
 export function toDlqEntry(entry, methods) {
-    const jobData = entry.job.data;
-    return {
-        job: createPublicJob({
-            job: entry.job,
-            name: jobData?.name ?? 'default',
-            ...methods,
-        }),
-        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,
-    };
+    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'>;
+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),
@@ -67,22 +72,24 @@ export function buildStateCheckMethods(id, getState, _getDependenciesCount) {
     };
 }
 /** 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}`,
@@ -91,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,9 +42,11 @@ 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'>>;
+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;
@@ -81,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/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/dlq.js

@@ -8,6 +8,8 @@ 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 */
@@ -99,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,
@@ -114,14 +116,7 @@ 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);
 }
@@ -134,7 +129,7 @@ export async function getDlqStatsAsync(ctx) {
     const response = await ctx.tcp.send({ cmd: 'GetDlqStats', queue: ctx.name });
     if (!response.ok)
         return getDlqStats(ctx);
-    return response.data.stats;
+    return toPublicDlqStats(response.data.stats);
 }
 /** Retry DLQ entries */
 export function retryDlq(ctx, id) {
@@ -161,9 +156,12 @@ export async function retryDlqAsync(ctx, id) {
 }
 /** Retry DLQ entries by filter */
 export function retryDlqByFilter(ctx, filter) {
-    if (!ctx.embedded)
-        return 0;
-    return dlqOps.retryDlqByFilterEmbedded(ctx.name, filter);
+    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) {

package/dist/client/queue/dlqJobMethods.js

@@ -96,31 +96,32 @@ export function createDlqJobMethods(ctx) {
             else
                 await send(buildFailCommand(id, error, token), 'FAIL');
         },
-        moveToWait: async (id) => {
+        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));
+                    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 }, 'MoveToWait');
+            const response = await send({ cmd: 'MoveToWait', id, ...(token === undefined ? {} : { token }) }, 'MoveToWait');
             return response.ok === true;
         },
-        moveToDelayed: async (id, timestamp) => {
+        moveToDelayed: async (id, timestamp, token) => {
             const delay = Math.max(0, timestamp - Date.now());
             if (ctx.embedded)
-                await manager.moveToDelayed(jobId(id), delay);
-            else
-                await send({ cmd: 'MoveToDelayed', id, delay }, 'MoveToDelayed');
+                await manager.moveToDelayed(jobId(id), delay, token);
+            else {
+                await send({ cmd: 'MoveToDelayed', id, delay, ...(token === undefined ? {} : { token }) }, 'MoveToDelayed');
+            }
         },
-        moveToWaitingChildren: async (id) => {
+        moveToWaitingChildren: async (id, token) => {
             if (ctx.embedded)
-                return manager.moveToWaitingChildren(jobId(id));
-            await send({ cmd: 'MoveToWaitingChildren', id }, 'MoveToWaitingChildren');
+                return manager.moveToWaitingChildren(jobId(id), token);
+            await send({ cmd: 'MoveToWaitingChildren', id, ...(token === undefined ? {} : { token }) }, 'MoveToWaitingChildren');
             return true;
         },
         waitUntilFinished: async (id, _events, ttl) => {

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));
@@ -29,14 +30,7 @@ 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>;