bunqueue 2.8.53 → 2.8.56

package/dist/client/worker/jobParser.js

@@ -2,16 +2,18 @@
  * Job Parser
  * Parses job data from TCP responses
  */
-import { jobId } from '../../domain/types/job';
+import { jobId, normalizeLegacyJobPayload } from '../../domain/types/job';
 /**
  * Parse job from TCP response data
  */
 // eslint-disable-next-line complexity
 export function parseJobFromResponse(jobData, queueName) {
+    const payload = normalizeLegacyJobPayload({ name: jobData.name, data: jobData.data });
     return {
         id: jobId(jobData.id),
         queue: queueName,
-        data: jobData.data,
+        name: payload.name,
+        data: payload.data,
         priority: jobData.priority ?? 0,
         createdAt: jobData.createdAt ?? Date.now(),
         runAt: jobData.runAt ?? Date.now(),

package/dist/client/worker/processor.d.ts

@@ -2,22 +2,9 @@
  * Job Processor
  * Handles job execution and result reporting
  */
-import type { EventEmitter } from 'events';
-import type { TcpConnection } from './types';
-import type { Processor } from '../types';
 import type { Job as InternalJob } from '../../domain/types/job';
-import type { AckBatcher } from './ackBatcher';
-/** Processor configuration */
-export interface ProcessorConfig<T, R> {
-    name: string;
-    processor: Processor<T, R>;
-    embedded: boolean;
-    tcp: TcpConnection | null;
-    ackBatcher: AckBatcher;
-    emitter: EventEmitter;
-    token?: string | null;
-    onOutcome?: (succeeded: boolean) => void;
-}
+import type { ProcessorConfig } from './types';
+export type { ProcessorConfig } from './types';
 /**
  * Process a single job
  */

package/dist/client/worker/processor.js

@@ -4,26 +4,47 @@
  */
 import { createPublicJob } from '../types';
 import { getSharedManager } from '../manager';
-import { UnrecoverableError } from '../errors';
-import { DelayedError } from '../errors';
-import { createProgressHandler, createLogHandler, createGetStateHandler, createGetChildrenValuesHandler, createGetFailedChildrenValuesHandler, createGetIgnoredChildrenFailuresHandler, createRemoveChildDependencyHandler, createRemoveUnprocessedChildrenHandler, createMoveToFailedHandler, createMoveToCompletedHandler, createRemoveHandler, createRetryHandler, createUpdateDataHandler, createPromoteHandler, createChangeDelayHandler, createChangePriorityHandler, createExtendLockHandler, createClearLogsHandler, createMoveToWaitHandler, createMoveToDelayedHandler, createMoveToWaitingChildrenHandler, createWaitUntilFinishedHandler, createDiscardHandler, createGetDependenciesHandler, createGetDependenciesCountHandler, createRemoveDeduplicationKeyHandler, computeStackLines, } from './processorHandlers';
+import { createProgressHandler, createLogHandler, createGetStateHandler, createGetChildrenValuesHandler, createGetFailedChildrenValuesHandler, createGetIgnoredChildrenFailuresHandler, createRemoveChildDependencyHandler, createRemoveUnprocessedChildrenHandler, createMoveToFailedHandler, createMoveToCompletedHandler, createRemoveHandler, createRetryHandler, createUpdateDataHandler, createPromoteHandler, createChangeDelayHandler, createChangePriorityHandler, createExtendLockHandler, createClearLogsHandler, createMoveToWaitHandler, createMoveToDelayedHandler, createMoveToWaitingChildrenHandler, createWaitUntilFinishedHandler, createDiscardHandler, createGetDependenciesHandler, createGetDependenciesCountHandler, createRemoveDeduplicationKeyHandler, } from './processorHandlers';
+import { handleJobFailure, handleManualMove, isJobNotFoundError } from './processorOutcome';
 /**
  * Process a single job
  */
 export async function processJob(internalJob, config) {
     const { processor, embedded, tcp, ackBatcher, emitter, token } = config;
-    const jobData = internalJob.data;
-    const jobName = jobData?.name ?? 'default';
+    const jobName = internalJob.name;
     const jobIdStr = String(internalJob.id);
     const jobHolder = { current: null };
-    // Track whether moveToFailed/moveToCompleted was explicitly called (Issue #82)
-    // Use a mutable holder so TS doesn't narrow to `never` after closure mutation
+    // Track whether the processor explicitly consumed this delivery generation.
+    // Use a mutable holder so TS does not narrow through callback mutation.
     const manualMove = { result: null };
-    const moveToFailedHandler = createMoveToFailedHandler(embedded, tcp, internalJob, token, (error) => {
-        manualMove.result = { type: 'failed', error };
+    const onTransitionApplied = () => {
+        manualMove.result = { type: 'transitioned' };
+    };
+    const moveToFailedHandler = createMoveToFailedHandler({
+        embedded,
+        tcp,
+        internalJob,
+        token,
+        removeOnFail: config.removeOnFail,
+        onCalled: (error) => {
+            manualMove.result = { type: 'failed', error };
+        },
+        onIgnored: () => {
+            manualMove.result = { type: 'ignored' };
+        },
     });
-    const moveToCompletedHandler = createMoveToCompletedHandler(embedded, ackBatcher, internalJob, token, (value) => {
-        manualMove.result = { type: 'completed', value };
+    const moveToCompletedHandler = createMoveToCompletedHandler({
+        embedded,
+        ackBatcher,
+        internalJob,
+        token,
+        removeOnComplete: config.removeOnComplete,
+        onCalled: (value) => {
+            manualMove.result = { type: 'completed', value };
+        },
+        onIgnored: () => {
+            manualMove.result = { type: 'ignored' };
+        },
     });
     const job = createPublicJob({
         job: internalJob,
@@ -41,43 +62,64 @@ export async function processJob(internalJob, config) {
         // Issue #82 follow-up: wire all remaining mutation/query methods so they
         // no longer silently no-op inside the Worker processor.
         remove: createRemoveHandler(embedded, tcp),
-        retry: createRetryHandler(embedded, tcp, internalJob),
+        retry: createRetryHandler(embedded, tcp, {
+            internalJob,
+            token: token ?? undefined,
+            onTransitionApplied,
+        }),
         updateData: createUpdateDataHandler(embedded, tcp),
         promote: createPromoteHandler(embedded, tcp),
-        changeDelay: createChangeDelayHandler(embedded, tcp),
+        changeDelay: createChangeDelayHandler(embedded, tcp, token ?? undefined, onTransitionApplied),
         changePriority: createChangePriorityHandler(embedded, tcp),
         extendLock: createExtendLockHandler(embedded, tcp),
         clearLogs: createClearLogsHandler(embedded, tcp),
-        moveToWait: createMoveToWaitHandler(embedded, tcp),
-        moveToDelayed: createMoveToDelayedHandler(embedded, tcp),
-        moveToWaitingChildren: createMoveToWaitingChildrenHandler(embedded, tcp),
+        moveToWait: createMoveToWaitHandler(embedded, tcp, onTransitionApplied),
+        moveToDelayed: createMoveToDelayedHandler(embedded, tcp, onTransitionApplied),
+        moveToWaitingChildren: createMoveToWaitingChildrenHandler(embedded, tcp, onTransitionApplied),
         waitUntilFinished: createWaitUntilFinishedHandler(embedded, tcp),
-        discard: createDiscardHandler(embedded, tcp),
+        discard: createDiscardHandler(embedded, tcp, {
+            token: token ?? undefined,
+            onPending: (pending) => {
+                if (manualMove.result !== null)
+                    return;
+                manualMove.result = { type: 'pending-transition', context: 'discard', pending };
+            },
+        }),
         getDependencies: createGetDependenciesHandler(embedded, tcp, internalJob),
         getDependenciesCount: createGetDependenciesCountHandler(embedded, tcp, internalJob),
-        removeDeduplicationKey: createRemoveDeduplicationKeyHandler(),
+        removeDeduplicationKey: createRemoveDeduplicationKeyHandler(embedded, tcp),
         token: token ?? undefined,
     });
     jobHolder.current = job;
     emitter.emit('active', job);
     try {
         const result = await processor(job);
-        // Issue #82: If moveToFailed/moveToCompleted was called, skip auto-ACK
-        if (handleManualMove(manualMove, job, config, internalJob))
+        if (config.shouldAbandonOutcome?.())
+            return;
+        // An explicit broker disposition owns the generation, so skip auto-ACK.
+        if (await handleManualMove(manualMove, job, config, internalJob))
             return;
         // Normal path: auto-ACK
         try {
+            let applied = true;
             if (embedded) {
                 const manager = getSharedManager();
                 // Pass token for lock verification
-                await manager.ack(internalJob.id, result, token ?? undefined);
+                const outcome = await manager.ack(internalJob.id, result, token ?? undefined, {
+                    removeOnComplete: config.removeOnComplete,
+                });
+                applied = outcome?.applied !== false;
             }
             else {
                 // Queue with token for batch ACK
-                await ackBatcher.queue(jobIdStr, result, token ?? undefined);
+                applied = await ackBatcher.queue(jobIdStr, result, token ?? undefined, config.removeOnComplete);
             }
+            if (!applied)
+                return;
         }
         catch (ackErr) {
+            if (config.shouldAbandonOutcome?.())
+                return;
             // If stall detection already removed the job from processing,
             // the ACK will fail with "Job not found". This is expected
             // behavior (Issue #33) - emit error event but don't re-throw.
@@ -93,110 +135,11 @@ export async function processJob(internalJob, config) {
         emitter.emit('completed', job, result);
     }
     catch (error) {
-        // Issue #82: If moveToFailed was already called, skip normal failure handling
-        if (handleManualMove(manualMove, job, config, internalJob))
+        if (config.shouldAbandonOutcome?.())
             return;
-        await handleJobFailure(internalJob, error, config, { job, jobIdStr, token });
-    }
-}
-/** Issue #82: Handle explicit moveToFailed/moveToCompleted called inside processor */
-function handleManualMove(manualMove, job, config, internalJob) {
-    if (manualMove.result?.type === 'failed') {
-        const err = manualMove.result.error ?? new Error('Job manually moved to failed');
-        job.failedReason = err.message;
-        // Bug #74 follow-up: populate stacktrace on the local `failed` event for the
-        // explicit moveToFailed() path too, mirroring handleJobFailure. The stack is
-        // persisted server-side by createMoveToFailedHandler's FAIL/manager.fail call.
-        if (err.stack) {
-            const { stackLines } = computeStackLines(err);
-            job.stacktrace = stackLines.slice(0, internalJob.stackTraceLimit);
-        }
-        config.onOutcome?.(false);
-        config.emitter.emit('failed', job, err);
-        return true;
-    }
-    if (manualMove.result?.type === 'completed') {
-        job.returnvalue = manualMove.result.value;
-        config.onOutcome?.(true);
-        config.emitter.emit('completed', job, manualMove.result.value);
-        return true;
-    }
-    return false;
-}
-/** Check if error is a "job not found" error from stale ACK/FAIL (Issue #33) */
-function isJobNotFoundError(err) {
-    return err.message.includes('not found') || err.message.includes('not in processing');
-}
-/** Handle DelayedError: move job back to delayed state without counting as failure */
-async function handleDelayedError(internalJob, config, context) {
-    const { embedded, tcp, emitter } = config;
-    try {
-        if (embedded) {
-            const manager = getSharedManager();
-            await manager.moveToDelayed(internalJob.id, internalJob.backoff || 1000);
-        }
-        else if (tcp) {
-            await tcp.send({
-                cmd: 'MoveToDelayed',
-                id: internalJob.id,
-                delay: internalJob.backoff || 1000,
-                ...(context.token ? { token: context.token } : {}),
-            });
-        }
-    }
-    catch (delayError) {
-        const wrappedError = delayError instanceof Error ? delayError : new Error(String(delayError));
-        if (!isJobNotFoundError(wrappedError)) {
-            emitter.emit('error', Object.assign(wrappedError, { context: 'delay', jobId: context.jobIdStr }));
-        }
-    }
-}
-async function handleJobFailure(internalJob, error, config, context) {
-    const { embedded, tcp, emitter } = config;
-    const { job, jobIdStr, token } = context;
-    const err = error instanceof Error ? error : new Error(String(error));
-    if (err instanceof DelayedError) {
-        await handleDelayedError(internalJob, config, { jobIdStr, token });
-        return;
-    }
-    // UnrecoverableError: force skip all retries
-    if (err instanceof UnrecoverableError) {
-        internalJob.maxAttempts = 1;
-        internalJob.attempts = 0;
-    }
-    // Bug #74: stack lines computed BEFORE the send so the server can persist
-    // them. The wire copy is capped at 50 lines as a bandwidth guard; the
-    // authoritative cap (job.stackTraceLimit) is applied server-side in failJob.
-    const { stackLines, wireStack } = computeStackLines(err);
-    try {
-        if (embedded) {
-            const manager = getSharedManager();
-            await manager.fail(internalJob.id, err.message, token ?? undefined, undefined, wireStack);
-        }
-        else if (tcp) {
-            await tcp.send({
-                cmd: 'FAIL',
-                id: internalJob.id,
-                error: err.message,
-                ...(wireStack ? { stack: wireStack } : {}),
-                ...(token ? { token } : {}),
-                ...(err instanceof UnrecoverableError ? { unrecoverable: true } : {}),
-            });
-        }
-    }
-    catch (failError) {
-        const wrappedError = failError instanceof Error ? failError : new Error(String(failError));
-        if (isJobNotFoundError(wrappedError)) {
+        // An explicit broker disposition also suppresses catch-path auto-FAIL.
+        if (await handleManualMove(manualMove, job, config, internalJob))
             return;
-        }
-        emitter.emit('error', Object.assign(wrappedError, { context: 'fail', jobId: jobIdStr }));
-    }
-    job.failedReason = err.message;
-    // Bug #74: populate stacktrace on the local `failed` event object
-    if (err.stack) {
-        const limit = internalJob.stackTraceLimit;
-        job.stacktrace = stackLines.slice(0, limit);
+        await handleJobFailure(internalJob, error, config, { job, jobIdStr, token });
     }
-    config.onOutcome?.(false);
-    emitter.emit('failed', job, err);
 }

package/dist/client/worker/processorHandlers.d.ts

@@ -1,65 +1,4 @@
-/**
- * Processor Handler Factories
- * Creates callback handlers for job operations during processing
- */
-import type { EventEmitter } from 'events';
-import type { TcpConnection } from './types';
-import type { Job, FlowJobData, JobStateType, ChangePriorityOpts, JobDependencies, JobDependenciesCount } from '../types';
-import type { Job as InternalJob } from '../../domain/types/job';
-import type { AckBatcher } from './ackBatcher';
-export declare function createProgressHandler<T extends FlowJobData>(embedded: boolean, tcp: TcpConnection | null, emitter: EventEmitter, jobHolder: {
-    current: Job<T> | null;
-}): (id: string, progress: number, message?: string) => Promise<void>;
-export declare function createLogHandler<T extends FlowJobData>(embedded: boolean, tcp: TcpConnection | null, emitter: EventEmitter, jobHolder: {
-    current: Job<T> | null;
-}): (id: string, message: string) => Promise<void>;
-export declare function createGetStateHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<JobStateType>;
-export declare function createGetChildrenValuesHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<Record<string, unknown>>;
-export declare function createGetFailedChildrenValuesHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<Record<string, string>>;
-export declare function createGetIgnoredChildrenFailuresHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<Record<string, string>>;
-export declare function createRemoveChildDependencyHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<boolean>;
-export declare function createRemoveUnprocessedChildrenHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<void>;
-/**
- * Bug #74: split an Error's stack into trimmed, non-empty lines.
- * `wireStack` is the bandwidth-capped copy sent to the server (50 lines); the
- * authoritative cap (job.stackTraceLimit) is applied server-side in failJob.
- * Shared by the natural-throw path (handleJobFailure) and the explicit
- * moveToFailed() path so both persist the stack identically.
- */
-export declare function computeStackLines(err: Error): {
-    stackLines: string[];
-    wireStack: string[] | undefined;
-};
-/** Issue #82: Create moveToFailed handler for use inside processor */
-export declare function createMoveToFailedHandler(embedded: boolean, tcp: TcpConnection | null, internalJob: InternalJob, token: string | null | undefined, onCalled: (error: Error) => void): (id: string, error: Error, _lockToken?: string) => Promise<void>;
-/** Issue #82: Create moveToCompleted handler for use inside processor */
-export declare function createMoveToCompletedHandler(embedded: boolean, ackBatcher: AckBatcher, internalJob: InternalJob, token: string | null | undefined, onCalled: (value: unknown) => void): (id: string, returnValue: unknown, _lockToken?: string) => Promise<unknown>;
-export declare function createRemoveHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<void>;
-export declare function createRetryHandler(embedded: boolean, tcp: TcpConnection | null, internalJob: InternalJob): (id: string) => Promise<void>;
-export declare function createUpdateDataHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, data: unknown) => Promise<void>;
-export declare function createPromoteHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<void>;
-export declare function createChangeDelayHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, delay: number) => Promise<void>;
-export declare function createChangePriorityHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, opts: ChangePriorityOpts) => Promise<void>;
-export declare function createExtendLockHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, token: string, duration: number) => Promise<number>;
-export declare function createClearLogsHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, keepLogs?: number) => Promise<void>;
-export declare function createMoveToWaitHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, _token?: string) => Promise<boolean>;
-export declare function createMoveToDelayedHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, timestamp: number, _token?: string) => Promise<void>;
-export declare function createMoveToWaitingChildrenHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, _token?: string, _opts?: {
-    child?: {
-        id: string;
-        queue: string;
-    };
-}) => Promise<boolean>;
-export declare function createWaitUntilFinishedHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, _queueEvents: unknown, ttl?: number) => Promise<unknown>;
-export declare function createDiscardHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => void;
-/**
- * getDependencies — compute from internalJob.childrenIds by querying each child's state.
- * No dedicated server API; derive from existing job state queries.
- */
-export declare function createGetDependenciesHandler(embedded: boolean, tcp: TcpConnection | null, internalJob: InternalJob): (_id: string) => Promise<JobDependencies>;
-export declare function createGetDependenciesCountHandler(embedded: boolean, tcp: TcpConnection | null, internalJob: InternalJob): (_id: string) => Promise<JobDependenciesCount>;
-/**
- * removeDeduplicationKey — no server primitive; throw explicit error so callers
- * learn this isn't supported rather than silently getting `false`.
- */
-export declare function createRemoveDeduplicationKeyHandler(): (_id: string) => Promise<boolean>;
+export * from './handlers/completion';
+export * from './handlers/dependencies';
+export * from './handlers/mutations';
+export * from './handlers/queries';