bunqueue 2.8.0 → 2.8.2

package/dist/client/tcpPool.js

@@ -200,4 +200,3 @@ export function closeAllSharedPools() {
     }
     sharedPools.clear();
 }
-//# sourceMappingURL=tcpPool.js.map

package/dist/client/types.d.ts

@@ -313,10 +313,14 @@ export interface JobOptions {
     timeout?: number;
     /** Custom job ID (for idempotent/deduplication) */
     jobId?: string;
-    /** Remove job on completion (can be boolean, max age in ms, or KeepJobs config) */
-    removeOnComplete?: boolean | number | KeepJobs;
-    /** Remove job on failure (can be boolean, max age in ms, or KeepJobs config) */
-    removeOnFail?: boolean | number | KeepJobs;
+    /**
+     * Remove job on completion. Boolean only — age/count retention
+     * (number | KeepJobs) is not implemented and was silently ignored, so the
+     * type is narrowed to prevent the misuse. See issue #90.
+     */
+    removeOnComplete?: boolean;
+    /** Remove job on failure. Boolean only — see removeOnComplete. */
+    removeOnFail?: boolean;
     /** Stall timeout in ms - job is stalled if no heartbeat after this time */
     stallTimeout?: number;
     /** Repeat configuration for recurring jobs */
@@ -563,4 +567,3 @@ export type Processor<T = unknown, R = unknown> = (job: Job<T & FlowJobData>) =>
 export type QueueEventType = 'waiting' | 'active' | 'completed' | 'failed' | 'progress' | 'removed' | 'drained';
 export { createPublicJob, toPublicJob, toDlqEntry } from './jobConversion';
 export type { CreatePublicJobOptions, ToPublicJobOptions } from './jobConversion';
-//# sourceMappingURL=types.d.ts.map

package/dist/client/types.js

@@ -4,4 +4,3 @@
  */
 // Re-export conversion functions for backwards compatibility
 export { createPublicJob, toPublicJob, toDlqEntry } from './jobConversion';
-//# sourceMappingURL=types.js.map

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

@@ -38,4 +38,3 @@ export declare class AckBatcher {
     /** Wait for all in-flight flush operations to complete */
     waitForInFlight(): Promise<void>;
 }
-//# sourceMappingURL=ackBatcher.d.ts.map

package/dist/client/worker/ackBatcher.js

@@ -26,16 +26,26 @@ export class AckBatcher {
         this.tcp = tcp;
     }
     /** Queue ACK for batch processing (with optional lock token) */
-    queue(id, result, token) {
-        return new Promise((resolve, reject) => {
-            // Prevent unbounded memory growth during server outages
+    async queue(id, result, token) {
+        // Backpressure: never silently drop accepted ACKs. When the buffer is at/over
+        // capacity, force a flush of the pending ACKs (sending them to the server)
+        // before accepting more. If a flush is already in-flight, await it first to
+        // avoid reentrancy/double-send, then re-check and flush any remainder.
+        while (this.pendingAcks.length >= this.MAX_PENDING_ACKS && !this.stopped) {
+            // Wait for any in-flight flush to drain the buffer it owns.
+            await this.waitForInFlight();
+            // If still over capacity (buffer refilled or nothing was in-flight),
+            // flush the current pending ACKs ourselves to make room. The enclosing
+            // while-loop already re-checks `stopped`, so at most one extra flush runs
+            // if stop() lands during the await above (flushing on shutdown is fine).
             if (this.pendingAcks.length >= this.MAX_PENDING_ACKS) {
-                // Drop oldest entries (10%) and reject their promises
-                const dropped = this.pendingAcks.splice(0, Math.floor(this.MAX_PENDING_ACKS * 0.1));
-                for (const ack of dropped) {
-                    ack.reject(new Error('Ack buffer overflow - oldest entries dropped'));
-                }
+                const flushPromise = this.flush();
+                this.inFlightFlushes.add(flushPromise);
+                void flushPromise.finally(() => this.inFlightFlushes.delete(flushPromise));
+                await flushPromise;
             }
+        }
+        return new Promise((resolve, reject) => {
             this.pendingAcks.push({
                 id,
                 result,
@@ -145,4 +155,3 @@ export class AckBatcher {
         await Promise.all(this.inFlightFlushes);
     }
 }
-//# sourceMappingURL=ackBatcher.js.map

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

@@ -45,4 +45,3 @@ export declare class GroupConcurrencyLimiter {
     /** Clear all tracking state. */
     clear(): void;
 }
-//# sourceMappingURL=groupConcurrency.d.ts.map

package/dist/client/worker/groupConcurrency.js

@@ -89,4 +89,3 @@ export class GroupConcurrencyLimiter {
         this.activeByGroup.clear();
     }
 }
-//# sourceMappingURL=groupConcurrency.js.map

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

@@ -8,4 +8,3 @@ export { AckBatcher, type AckBatcherConfig } from './ackBatcher';
 export { parseJobFromResponse } from './jobParser';
 export { processJob, type ProcessorConfig } from './processor';
 export { Worker } from './worker';
-//# sourceMappingURL=index.d.ts.map

package/dist/client/worker/index.js

@@ -7,4 +7,3 @@ export { AckBatcher } from './ackBatcher';
 export { parseJobFromResponse } from './jobParser';
 export { processJob } from './processor';
 export { Worker } from './worker';
-//# sourceMappingURL=index.js.map

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

@@ -7,4 +7,3 @@ import type { Job as InternalJob } from '../../domain/types/job';
  * Parse job from TCP response data
  */
 export declare function parseJobFromResponse(jobData: Record<string, unknown>, queueName: string): InternalJob;
-//# sourceMappingURL=jobParser.d.ts.map

package/dist/client/worker/jobParser.js

@@ -41,4 +41,3 @@ export function parseJobFromResponse(jobData, queueName) {
         repeat: null,
     };
 }
-//# sourceMappingURL=jobParser.js.map

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

@@ -22,4 +22,3 @@ export interface ProcessorConfig<T, R> {
  * Process a single job
  */
 export declare function processJob<T, R>(internalJob: InternalJob, config: ProcessorConfig<T, R>): Promise<void>;
-//# sourceMappingURL=processor.d.ts.map

package/dist/client/worker/processor.js

@@ -3,10 +3,10 @@
  * Handles job execution and result reporting
  */
 import { createPublicJob } from '../types';
-import { jobId } from '../../domain/types/job';
 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, } from './processorHandlers';
 /**
  * Process a single job
  */
@@ -16,6 +16,15 @@ export async function processJob(internalJob, config) {
     const jobName = jobData?.name ?? 'default';
     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
+    const manualMove = { result: null };
+    const moveToFailedHandler = createMoveToFailedHandler(embedded, tcp, internalJob, token, (error) => {
+        manualMove.result = { type: 'failed', error };
+    });
+    const moveToCompletedHandler = createMoveToCompletedHandler(embedded, ackBatcher, internalJob, token, (value) => {
+        manualMove.result = { type: 'completed', value };
+    });
     const job = createPublicJob({
         job: internalJob,
         name: jobName,
@@ -27,11 +36,36 @@ export async function processJob(internalJob, config) {
         getIgnoredChildrenFailures: createGetIgnoredChildrenFailuresHandler(embedded, tcp),
         removeChildDependency: createRemoveChildDependencyHandler(embedded, tcp),
         removeUnprocessedChildren: createRemoveUnprocessedChildrenHandler(embedded, tcp),
+        moveToFailed: moveToFailedHandler,
+        moveToCompleted: moveToCompletedHandler,
+        // 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),
+        updateData: createUpdateDataHandler(embedded, tcp),
+        promote: createPromoteHandler(embedded, tcp),
+        changeDelay: createChangeDelayHandler(embedded, tcp),
+        changePriority: createChangePriorityHandler(embedded, tcp),
+        extendLock: createExtendLockHandler(embedded, tcp),
+        clearLogs: createClearLogsHandler(embedded, tcp),
+        moveToWait: createMoveToWaitHandler(embedded, tcp),
+        moveToDelayed: createMoveToDelayedHandler(embedded, tcp),
+        moveToWaitingChildren: createMoveToWaitingChildrenHandler(embedded, tcp),
+        waitUntilFinished: createWaitUntilFinishedHandler(embedded, tcp),
+        discard: createDiscardHandler(embedded, tcp),
+        getDependencies: createGetDependenciesHandler(embedded, tcp, internalJob),
+        getDependenciesCount: createGetDependenciesCountHandler(embedded, tcp, internalJob),
+        removeDeduplicationKey: createRemoveDeduplicationKeyHandler(),
+        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))
+            return;
+        // Normal path: auto-ACK
         try {
             if (embedded) {
                 const manager = getSharedManager();
@@ -59,107 +93,28 @@ 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))
+            return;
         await handleJobFailure(internalJob, error, config, { job, jobIdStr, token });
     }
 }
-function createProgressHandler(embedded, tcp, emitter, jobHolder) {
-    return async (id, progress, message) => {
-        if (embedded) {
-            const manager = getSharedManager();
-            await manager.updateProgress(jobId(id), progress, message);
-        }
-        else if (tcp) {
-            await tcp.send({ cmd: 'Progress', id, progress, message });
-        }
-        emitter.emit('progress', jobHolder.current, progress);
-    };
-}
-function createLogHandler(embedded, tcp, emitter, jobHolder) {
-    return async (id, message) => {
-        if (embedded) {
-            const manager = getSharedManager();
-            // addLog is synchronous (in-memory Map update)
-            manager.addLog(jobId(id), message);
-        }
-        else if (tcp) {
-            await tcp.send({ cmd: 'AddLog', id, message });
-        }
-        emitter.emit('log', jobHolder.current, message);
-    };
-}
-function createGetStateHandler(embedded, tcp) {
-    return async (id) => {
-        if (embedded) {
-            const manager = getSharedManager();
-            return (await manager.getJobState(jobId(id)));
-        }
-        else if (tcp) {
-            const response = await tcp.send({ cmd: 'GetState', id });
-            return (response.state ?? 'unknown');
-        }
-        return 'unknown';
-    };
-}
-function createGetChildrenValuesHandler(embedded, tcp) {
-    return async (id) => {
-        if (embedded) {
-            const manager = getSharedManager();
-            return manager.getChildrenValues(jobId(id));
-        }
-        else if (tcp) {
-            const response = await tcp.send({ cmd: 'GetChildrenValues', id });
-            const data = response.data;
-            return data?.values ?? {};
-        }
-        return {};
-    };
-}
-function createGetFailedChildrenValuesHandler(embedded, tcp) {
-    return async (id) => {
-        if (embedded) {
-            const manager = getSharedManager();
-            return manager.getFailedChildrenValues(jobId(id));
-        }
-        if (!tcp)
-            return {};
-        const res = await tcp.send({ cmd: 'GetFailedChildrenValues', id });
-        return res.values ?? {};
-    };
-}
-function createGetIgnoredChildrenFailuresHandler(embedded, tcp) {
-    return async (id) => {
-        if (embedded) {
-            const manager = getSharedManager();
-            return manager.getIgnoredChildrenFailures(jobId(id));
-        }
-        if (!tcp)
-            return {};
-        const res = await tcp.send({ cmd: 'GetIgnoredChildrenFailures', id });
-        return res.values ?? {};
-    };
-}
-function createRemoveChildDependencyHandler(embedded, tcp) {
-    return async (id) => {
-        if (embedded) {
-            const manager = getSharedManager();
-            return manager.removeChildDependency(jobId(id));
-        }
-        if (!tcp)
-            return false;
-        const res = await tcp.send({ cmd: 'RemoveChildDependency', id });
-        return res.ok === true;
-    };
-}
-function createRemoveUnprocessedChildrenHandler(embedded, tcp) {
-    return async (id) => {
-        if (embedded) {
-            const manager = getSharedManager();
-            return manager.removeUnprocessedChildren(jobId(id));
-        }
-        if (!tcp)
-            return;
-        await tcp.send({ cmd: 'RemoveUnprocessedChildren', id });
-    };
+/** Issue #82: Handle explicit moveToFailed/moveToCompleted called inside processor */
+function handleManualMove(manualMove, job, config) {
+    if (manualMove.result?.type === 'failed') {
+        const err = manualMove.result.error ?? new Error('Job manually moved to failed');
+        job.failedReason = err.message;
+        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) {
@@ -237,4 +192,3 @@ async function handleJobFailure(internalJob, error, config, context) {
     config.onOutcome?.(false);
     emitter.emit('failed', job, err);
 }
-//# sourceMappingURL=processor.js.map

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

@@ -0,0 +1,54 @@
+/**
+ * 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>;
+/** 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>;