bunqueue 2.8.54 → 2.8.57

package/dist/client/queue/operations/query.js

@@ -3,45 +3,27 @@ import { getSharedManager } from '../../manager';
 import { toPublicJob } from '../../types';
 import { jobId } from '../../../domain/types/job';
 import { createSimpleJob } from '../jobProxy';
-import { buildJobOpts } from '../../jobHelpers';
+import { resolvePublicJobPayload } from '../../jobHelpers';
 import { removeJobDeduplicationKey } from '../../jobDeduplication';
 import { fetchTcpJobRows } from './queryTcpPages';
-/** Last failure's error message from the job timeline (#74) */
-function lastFailedError(timeline) {
-    if (!timeline)
-        return undefined;
-    for (let i = timeline.length - 1; i >= 0; i--) {
-        const entry = timeline[i];
-        if (entry.state === 'failed' && entry.error)
-            return entry.error;
-    }
-    return undefined;
-}
-/** Build reflection meta (priority/delay/opts/stacktrace) from an internal job shape */
-function metaFromJob(job) {
-    const opts = buildJobOpts(job);
-    return {
-        priority: job.priority ?? 0,
-        delay: opts.delay ?? 0,
-        opts,
-        // Persisted server-side on FAIL (#74); absent on pre-#74 servers
-        stacktrace: job.stacktrace ?? null,
-        failedReason: lastFailedError(job.timeline),
-    };
-}
+import { metadataFromJob } from '../jobMetadata';
 /** Get a single job by ID */
 export async function getJob(ctx, id) {
     if (ctx.embedded) {
-        const job = await getSharedManager().getJob(jobId(id));
+        const manager = getSharedManager();
+        const job = await manager.getJob(jobId(id));
         if (!job)
             return null;
-        const name = job.data?.name ?? 'unknown';
+        const { name, data } = resolvePublicJobPayload(job);
+        const meta = metadataFromJob(job, manager.getResult(job.id));
         // Use toPublicJob with full wiring (all callbacks route to the shared manager)
         if (ctx.updateJobData) {
-            const mgr = getSharedManager();
+            const mgr = manager;
             return toPublicJob({
                 job,
                 name,
+                returnvalue: meta.returnvalue,
+                failedReason: meta.failedReason,
                 updateProgress: async (jid, progress, message) => {
                     await mgr.updateProgress(jobId(jid), progress, message);
                 },
@@ -81,7 +63,7 @@ export async function getJob(ctx, id) {
             });
         }
         // Fallback to simple job — reflect priority/delay/opts from the real job (#88)
-        return createSimpleJob(String(job.id), name, job.data, job.createdAt, {
+        return createSimpleJob(String(job.id), name, data, job.createdAt, {
             queueName: ctx.name,
             embedded: ctx.embedded,
             tcp: ctx.tcp,
@@ -89,15 +71,15 @@ export async function getJob(ctx, id) {
             removeAsync: ctx.removeAsync,
             retryJob: ctx.retryJob,
             getChildrenValues: ctx.getChildrenValues,
-            meta: metaFromJob(job),
+            meta,
         });
     }
     const response = await ctx.tcp.send({ cmd: 'GetJob', id });
     if (!response.ok || !response.job)
         return null;
     const j = response.job;
-    const name = j.data?.name ?? 'unknown';
-    const result = createSimpleJob(String(j.id), name, j.data, j.createdAt ?? Date.now(), {
+    const { name, data } = resolvePublicJobPayload(j);
+    return createSimpleJob(String(j.id), name, data, j.createdAt ?? Date.now(), {
         queueName: ctx.name,
         embedded: ctx.embedded,
         tcp: ctx.tcp,
@@ -105,16 +87,8 @@ export async function getJob(ctx, id) {
         removeAsync: ctx.removeAsync,
         retryJob: ctx.retryJob,
         getChildrenValues: ctx.getChildrenValues,
-        meta: metaFromJob(j),
+        meta: metadataFromJob(j),
     });
-    if (j.progress !== undefined)
-        result.progress = j.progress;
-    // Mirror getJob/buildJobProperties: a number maps through, null → undefined (#104)
-    if (typeof j.startedAt === 'number')
-        result.processedOn = j.startedAt;
-    if (typeof j.completedAt === 'number')
-        result.finishedOn = j.completedAt;
-    return result;
 }
 /** Get job state by ID */
 export async function getJobState(ctx, id) {
@@ -172,8 +146,8 @@ export function getJobs(ctx, options = {}) {
                 : 100,
     });
     return jobs.map((j) => {
-        const name = j.data?.name ?? 'unknown';
-        const result = createSimpleJob(String(j.id), name, j.data, j.createdAt, {
+        const { name, data } = resolvePublicJobPayload(j);
+        return createSimpleJob(String(j.id), name, data, j.createdAt, {
             queueName: ctx.name,
             embedded: ctx.embedded,
             tcp: ctx.tcp,
@@ -181,13 +155,8 @@ export function getJobs(ctx, options = {}) {
             removeAsync: ctx.removeAsync,
             retryJob: ctx.retryJob,
             getChildrenValues: ctx.getChildrenValues,
+            meta: metadataFromJob(j, manager.getResult(j.id)),
         });
-        // Mirror getJob/buildJobProperties: a number maps through, null → undefined (#104)
-        if (typeof j.startedAt === 'number')
-            result.processedOn = j.startedAt;
-        if (typeof j.completedAt === 'number')
-            result.finishedOn = j.completedAt;
-        return result;
     });
 }
 /** Get jobs with filtering (async, works with TCP) */
@@ -204,9 +173,9 @@ export async function getJobsAsync(ctx, options = {}) {
     const jobs = rows;
     const now = Date.now();
     return jobs.map((j) => {
-        const name = j.data?.name ?? 'unknown';
+        const { name, data } = resolvePublicJobPayload(j);
         const createdAt = j.createdAt ?? now;
-        const result = createSimpleJob(String(j.id), name, j.data, createdAt, {
+        return createSimpleJob(String(j.id), name, data, createdAt, {
             queueName: ctx.name,
             embedded: ctx.embedded,
             tcp: ctx.tcp,
@@ -214,19 +183,7 @@ export async function getJobsAsync(ctx, options = {}) {
             removeAsync: ctx.removeAsync,
             retryJob: ctx.retryJob,
             getChildrenValues: ctx.getChildrenValues,
-            meta: metaFromJob(j),
+            meta: metadataFromJob(j),
         });
-        if (j.progress !== undefined)
-            result.progress = j.progress;
-        if (j.priority !== undefined)
-            result.priority = j.priority;
-        if (j.attempts !== undefined)
-            result.attemptsMade = j.attempts;
-        // Mirror getJob/buildJobProperties: a number maps through, null → undefined (#104)
-        if (typeof j.startedAt === 'number')
-            result.processedOn = j.startedAt;
-        if (typeof j.completedAt === 'number')
-            result.finishedOn = j.completedAt;
-        return result;
     });
 }

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

@@ -1,198 +1,12 @@
-/**
- * Queue
- * BullMQ-style queue for job management
- */
-import type { Job, JobOptions, QueueOptions, StallConfig, DlqConfig, DlqEntry, DlqStats, DlqFilter, ChangePriorityOpts, GetDependenciesOpts, JobDependencies, JobDependenciesCount, JobStateType } from '../types';
+/** BullMQ-style queue for job management. */
 import { Forwarder, type ForwardOptions } from '../forwarder';
-import * as countsOps from './operations/counts';
-import * as schedulerOps from './scheduler';
-import type { RepeatOpts, JobTemplate, SchedulerInfo } from './scheduler';
-import * as workersOps from './workers';
-/**
- * Queue class for adding and managing jobs
- */
-export declare class Queue<T = unknown> {
-    readonly name: string;
-    /**
-     * Server-side queue key. Equals `name` unless `prefixKey` is set, in which
-     * case it is `prefixKey + name`. All TCP/embedded operations route through
-     * this key so that two queues with the same logical name but different
-     * `prefixKey` values are fully isolated on the broker.
-     */
-    private readonly queueKey;
-    private readonly prefixKey;
-    private readonly opts;
-    private readonly embedded;
-    private readonly tcpPool;
-    private readonly useSharedPool;
-    private readonly addBatcher;
-    constructor(name: string, opts?: QueueOptions);
-    private get ctx();
-    private get addCtx();
-    private get queryCtx();
-    private get moveCtx();
-    add(name: string, data: T, opts?: JobOptions): Promise<Job<T>>;
-    addBulk(jobs: Array<{
-        name: string;
-        data: T;
-        opts?: JobOptions;
-    }>): Promise<Job<T>[]>;
-    getJob(id: string): Promise<Job<T> | null>;
-    getJobState(id: string): Promise<JobStateType>;
-    getChildrenValues(id: string): Promise<Record<string, unknown>>;
-    getJobs(opts?: {
-        state?: string | string[];
-        start?: number;
-        end?: number;
-        asc?: boolean;
-    }): Job<T>[];
-    getJobsAsync(opts?: {
-        state?: string | string[];
-        start?: number;
-        end?: number;
-        asc?: boolean;
-    }): Promise<Job<unknown>[]>;
-    getWaiting(start?: number, end?: number): Job<T>[];
-    getWaitingAsync(start?: number, end?: number): Promise<Job<T>[]>;
-    getDelayed(start?: number, end?: number): Job<T>[];
-    getDelayedAsync(start?: number, end?: number): Promise<Job<T>[]>;
-    getActive(start?: number, end?: number): Job<T>[];
-    getActiveAsync(start?: number, end?: number): Promise<Job<T>[]>;
-    getCompleted(start?: number, end?: number): Job<T>[];
-    getCompletedAsync(start?: number, end?: number): Promise<Job<T>[]>;
-    getFailed(start?: number, end?: number): Job<T>[];
-    getFailedAsync(start?: number, end?: number): Promise<Job<T>[]>;
-    getJobCounts(): countsOps.JobCounts | Promise<countsOps.JobCounts>;
-    getJobCountsAsync(): Promise<countsOps.JobCounts>;
-    getWaitingCount(): Promise<number>;
-    getActiveCount(): Promise<number>;
-    getCompletedCount(): Promise<number>;
-    getFailedCount(): Promise<number>;
-    getDelayedCount(): Promise<number>;
-    count(): number;
-    countAsync(): Promise<number>;
-    getCountsPerPriority(): Record<number, number>;
-    getCountsPerPriorityAsync(): Promise<Record<number, number>>;
-    pause(): void;
-    pauseAsync(): Promise<void>;
-    resume(): void;
-    resumeAsync(): Promise<void>;
-    drain(): void;
-    drainAsync(): Promise<number>;
-    obliterate(): void;
-    obliterateAsync(): Promise<void>;
-    isPaused(): boolean;
-    isPausedAsync(): Promise<boolean>;
-    waitUntilReady(): Promise<void>;
-    remove(id: string): void;
-    removeAsync(id: string): Promise<void>;
-    retryJob(id: string): Promise<void>;
-    retryJobs(opts?: {
-        state?: 'failed' | 'completed';
-        count?: number;
-        timestamp?: number;
-    }): Promise<void>;
-    clean(grace: number, limit: number, type?: string): string[];
-    cleanAsync(grace: number, limit: number, type?: string): Promise<string[]>;
-    promoteJobs(opts?: {
-        count?: number;
-    }): Promise<number>;
-    promoteJob(id: string): Promise<void>;
-    updateJobProgress(id: string, progress: number | object): Promise<void>;
-    getJobLogs(id: string, start?: number, end?: number, _asc?: boolean): Promise<{
-        logs: string[];
-        count: number;
-    }>;
-    addJobLog(id: string, logRow: string, _keepLogs?: number): Promise<number>;
-    clearJobLogs(id: string, keepLogs?: number): Promise<void>;
-    updateJobData(id: string, data: unknown): Promise<void>;
-    changeJobDelay(id: string, delay: number): Promise<void>;
-    changeJobPriority(id: string, opts: ChangePriorityOpts): Promise<void>;
-    extendJobLock(id: string, token: string, duration: number): Promise<number>;
-    setStallConfig(config: Partial<StallConfig>): void;
-    setStallConfigAsync(config: Partial<StallConfig>): Promise<void>;
-    getStallConfig(): StallConfig;
-    getStallConfigAsync(): Promise<StallConfig>;
-    setDlqConfig(config: Partial<DlqConfig>): void;
-    setDlqConfigAsync(config: Partial<DlqConfig>): Promise<void>;
-    getDlqConfig(): DlqConfig;
-    getDlqConfigAsync(): Promise<DlqConfig>;
-    getDlq(filter?: DlqFilter): DlqEntry<T>[];
-    getDlqAsync(filter?: DlqFilter): Promise<DlqEntry<T>[]>;
-    getDlqJobsAsync(count?: number): Promise<Job<T>[]>;
-    getDlqStats(): DlqStats;
-    getDlqStatsAsync(): Promise<DlqStats>;
-    retryDlq(id?: string): number;
-    retryDlqAsync(id?: string): Promise<number>;
-    retryDlqByFilter(filter: DlqFilter): number;
-    retryDlqByFilterAsync(filter: DlqFilter): Promise<number>;
-    purgeDlq(): number;
-    purgeDlqAsync(): Promise<number>;
-    retryCompleted(id?: string): number;
-    retryCompletedAsync(id?: string): Promise<number>;
-    setGlobalConcurrency(concurrency: number): void;
-    setGlobalConcurrencyAsync(concurrency: number): Promise<void>;
-    removeGlobalConcurrency(): void;
-    removeGlobalConcurrencyAsync(): Promise<void>;
-    getGlobalConcurrency(): Promise<number | null>;
-    setGlobalRateLimit(max: number, duration?: number): void;
-    setGlobalRateLimitAsync(max: number, duration?: number): Promise<void>;
-    removeGlobalRateLimit(): void;
-    removeGlobalRateLimitAsync(): Promise<void>;
-    getGlobalRateLimit(): Promise<{
-        max: number;
-        duration: number;
-    } | null>;
-    rateLimit(expireTimeMs: number): Promise<void>;
-    getRateLimitTtl(maxJobs?: number): Promise<number>;
-    isMaxed(): Promise<boolean>;
-    upsertJobScheduler(schedulerId: string, repeatOpts: RepeatOpts, jobTemplate?: JobTemplate<T>): Promise<SchedulerInfo | null>;
-    removeJobScheduler(schedulerId: string): Promise<boolean>;
-    getJobScheduler(schedulerId: string): Promise<schedulerOps.SchedulerInfo | null>;
-    getJobSchedulers(start?: number, end?: number, asc?: boolean): Promise<schedulerOps.SchedulerInfo[]>;
-    getJobSchedulersCount(): Promise<number>;
-    getDeduplicationJobId(deduplicationId: string): Promise<string | null>;
-    removeDeduplicationKey(deduplicationId: string): Promise<number>;
-    moveJobToCompleted(id: string, returnValue: unknown, token?: string): Promise<unknown>;
-    moveJobToFailed(id: string, error: Error, token?: string): Promise<void>;
-    moveJobToWait(id: string, token?: string): Promise<boolean>;
-    moveJobToDelayed(id: string, timestamp: number, token?: string): Promise<void>;
-    moveJobToWaitingChildren(id: string, token?: string, opts?: {
-        child?: {
-            id: string;
-            queue: string;
-        };
-    }): Promise<boolean>;
-    waitJobUntilFinished(id: string, queueEvents: unknown, ttl?: number): Promise<unknown>;
-    getJobDependencies(id: string, opts?: GetDependenciesOpts): Promise<JobDependencies>;
-    getJobDependenciesCount(id: string, opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
-    getDependencies(parentId: string, type?: 'processed' | 'unprocessed', start?: number, end?: number): Promise<{
-        processed?: Record<string, unknown>;
-        unprocessed?: string[];
-        nextProcessedCursor?: number;
-        nextUnprocessedCursor?: number;
-    }>;
-    getPrioritized(start?: number, end?: number): Promise<Job<T>[]>;
-    getPrioritizedCount(): Promise<number>;
-    getWaitingChildren(start?: number, end?: number): Promise<Job<T>[]>;
-    getWaitingChildrenCount(): Promise<number>;
-    trimEvents(maxLength: number): Promise<number>;
-    getWorkers(): Promise<workersOps.WorkerInfo[]>;
-    getWorkersCount(): Promise<number>;
-    getMetrics(type: 'completed' | 'failed', start?: number, end?: number): Promise<{
-        meta: {
-            count: number;
-        };
-        data: number[];
-    }>;
+import { QueueConnection } from './runtime/connection';
+/** Public Queue façade; behavior is implemented by focused runtime layers. */
+export declare class Queue<T = unknown> extends QueueConnection<T> {
     /**
      * Drain this queue's jobs to a remote bunqueue server (store-and-forward).
-     * Typical edge pattern: embedded local queue as offline buffer, forwarded
-     * to a central server over TCP/TLS. Remote failures leave jobs local
-     * (retry → DLQ) — nothing is lost while the uplink is down. Forwarded jobs
-     * carry a deterministic remote jobId so re-forwards never duplicate.
+     * Remote failures leave jobs local and deterministic remote IDs prevent
+     * duplicate delivery when a forward is retried.
      */
     forward(options: ForwardOptions): Forwarder;
-    disconnect(): Promise<void>;
-    close(): void;
 }