bunqueue 2.8.53 → 2.8.56

package/dist/client/queue-events/tcpSubscription.js

@@ -0,0 +1,99 @@
+import { resolveToken } from '../resolveToken';
+import { TcpClient } from '../tcpClient';
+/** One dedicated TCP connection with one broker-side queue subscription. */
+export class TcpEventSubscription {
+    client;
+    queue;
+    onError;
+    closed = false;
+    ready = false;
+    generation = 0;
+    subscriptionPromise = null;
+    constructor(options) {
+        this.queue = options.queue;
+        this.onError = options.onError;
+        const connection = options.connection ?? {};
+        this.client = new TcpClient({
+            host: connection.host ?? 'localhost',
+            port: connection.port ?? 6789,
+            token: resolveToken(connection.token) ?? '',
+            tls: connection.tls ?? false,
+            pingInterval: connection.pingInterval ?? 30_000,
+            commandTimeout: connection.commandTimeout ?? 30_000,
+            maxCommandTimeouts: connection.maxCommandTimeouts ?? 3,
+            pipelining: connection.pipelining ?? true,
+            maxInFlight: connection.maxInFlight ?? 100,
+        });
+        this.client.on('queueEvent', (event) => {
+            if (!this.closed && event.queue === this.queue)
+                options.onEvent(event);
+        });
+        this.client.on('error', (error) => {
+            if (!this.closed)
+                this.onError(error);
+        });
+        this.client.on('disconnected', () => {
+            if (this.closed)
+                return;
+            this.generation++;
+            this.ready = false;
+            this.subscriptionPromise = null;
+        });
+        this.client.on('connected', () => {
+            if (!this.closed)
+                void this.ensureSubscribed().catch(() => undefined);
+        });
+        void this.ensureSubscribed().catch(() => undefined);
+    }
+    waitUntilReady() {
+        if (this.closed)
+            return Promise.reject(new Error('Event subscription is closed'));
+        if (this.ready && this.client.isConnected()) {
+            return this.client.send({ cmd: 'Ping' }).then((reply) => {
+                if (reply.ok !== true)
+                    throw new Error('Queue event connection is not ready');
+            });
+        }
+        return this.ensureSubscribed();
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.generation++;
+        this.ready = false;
+        this.subscriptionPromise = null;
+        this.client.close();
+    }
+    ensureSubscribed() {
+        if (this.closed)
+            return Promise.reject(new Error('Event subscription is closed'));
+        if (this.ready)
+            return Promise.resolve();
+        if (this.subscriptionPromise)
+            return this.subscriptionPromise;
+        const generation = this.generation;
+        const operation = (this.client.isConnected() ? Promise.resolve() : this.client.connect())
+            .then(() => this.client.send({ cmd: 'SubscribeEvents', queue: this.queue }))
+            .then((reply) => {
+            if (reply.ok !== true) {
+                throw new Error(typeof reply.error === 'string' ? reply.error : 'Queue event subscription failed');
+            }
+            if (this.closed || generation !== this.generation) {
+                throw new Error('Event subscription changed while connecting');
+            }
+            this.ready = true;
+        });
+        this.subscriptionPromise = operation;
+        void operation.then(() => {
+            if (this.subscriptionPromise === operation)
+                this.subscriptionPromise = null;
+        }, (error) => {
+            if (this.subscriptionPromise === operation)
+                this.subscriptionPromise = null;
+            if (!this.closed)
+                this.onError(error instanceof Error ? error : new Error(String(error)));
+        });
+        return operation;
+    }
+}

package/dist/client/queueGroup.d.ts

@@ -22,6 +22,7 @@ import type { QueueOptions, WorkerOptions, Processor } from './types';
  */
 export declare class QueueGroup {
     readonly prefix: string;
+    private readonly queues;
     constructor(namespace: string);
     /** Get a queue within this group */
     getQueue<T = unknown>(name: string, opts?: QueueOptions): Queue<T>;
@@ -37,4 +38,14 @@ export declare class QueueGroup {
     drainAll(): void;
     /** Obliterate all queues in this group (remove all data) */
     obliterateAll(): void;
+    /** List queues created through this group, including remote queues. */
+    listQueuesAsync(): Promise<string[]>;
+    /** Pause every queue created through this group. */
+    pauseAllAsync(): Promise<void>;
+    /** Resume every queue created through this group. */
+    resumeAllAsync(): Promise<void>;
+    /** Drain waiting jobs from every queue and return the aggregate count. */
+    drainAllAsync(): Promise<number>;
+    /** Remove all data from every queue created through this group. */
+    obliterateAllAsync(): Promise<void>;
 }

package/dist/client/queueGroup.js

@@ -22,12 +22,15 @@ import { getSharedManager } from './manager';
  */
 export class QueueGroup {
     prefix;
+    queues = new Map();
     constructor(namespace) {
         this.prefix = namespace.endsWith(':') ? namespace : `${namespace}:`;
     }
     /** Get a queue within this group */
     getQueue(name, opts) {
-        return new Queue(this.prefix + name, opts);
+        const queue = new Queue(this.prefix + name, opts);
+        this.queues.set(name, queue);
+        return queue;
     }
     /** Create a worker for a queue in this group */
     getWorker(name, processor, opts) {
@@ -77,4 +80,28 @@ export class QueueGroup {
             }
         }
     }
+    /** List queues created through this group, including remote queues. */
+    async listQueuesAsync() {
+        const names = new Set(this.queues.keys());
+        for (const name of this.listQueues())
+            names.add(name);
+        return [...names].sort();
+    }
+    /** Pause every queue created through this group. */
+    async pauseAllAsync() {
+        await Promise.all([...this.queues.values()].map((queue) => queue.pauseAsync()));
+    }
+    /** Resume every queue created through this group. */
+    async resumeAllAsync() {
+        await Promise.all([...this.queues.values()].map((queue) => queue.resumeAsync()));
+    }
+    /** Drain waiting jobs from every queue and return the aggregate count. */
+    async drainAllAsync() {
+        const counts = await Promise.all([...this.queues.values()].map((queue) => queue.drainAsync()));
+        return counts.reduce((total, count) => total + count, 0);
+    }
+    /** Remove all data from every queue created through this group. */
+    async obliterateAllAsync() {
+        await Promise.all([...this.queues.values()].map((queue) => queue.obliterateAsync()));
+    }
 }

package/dist/client/sandboxed/queueOps.d.ts

@@ -11,8 +11,8 @@ export interface QueueOps {
         job: DomainJob | null;
         token: string | null;
     }>;
-    ack(id: JobId, result: unknown, token?: string): Promise<void>;
-    fail(id: JobId, error: string, token?: string): Promise<void>;
+    ack(id: JobId, result: unknown, token?: string): Promise<boolean>;
+    fail(id: JobId, error: string, token?: string): Promise<boolean>;
     updateProgress(id: JobId, progress: number): Promise<void>;
     addLog(id: JobId, message: string): void;
     sendHeartbeat(ids: string[], tokens: string[]): Promise<void>;

package/dist/client/sandboxed/queueOps.js

@@ -4,12 +4,19 @@
  */
 import { jobId } from '../../domain/types/job';
 import { parseJobFromResponse } from '../worker/jobParser';
+import { outcomeWasApplied } from '../worker/ackOutcome';
 /** Create embedded mode operations using shared QueueManager */
 export function createEmbeddedOps(manager) {
     return {
         pull: (queue, workerId, timeout) => manager.pullWithLock(queue, workerId, timeout),
-        ack: (id, result, token) => manager.ack(id, result, token),
-        fail: (id, error, token) => manager.fail(id, error, token),
+        ack: async (id, result, token) => {
+            const outcome = await manager.ack(id, result, token);
+            return outcome?.applied !== false;
+        },
+        fail: async (id, error, token) => {
+            const outcome = await manager.fail(id, error, token);
+            return outcome?.applied !== false;
+        },
         updateProgress: async (id, progress) => {
             await manager.updateProgress(id, progress);
         },
@@ -41,16 +48,36 @@ export function createTcpOps(tcp) {
             };
         },
         async ack(id, result, token) {
-            await tcp.send({ cmd: 'ACK', id: String(id), result, token: token ?? undefined });
+            const response = await tcp.send({
+                cmd: 'ACK',
+                id: String(id),
+                result,
+                token: token ?? undefined,
+            });
+            if (response.ok !== true) {
+                throw new Error(typeof response.error === 'string' ? response.error : 'ACK failed');
+            }
+            return outcomeWasApplied(response.data);
         },
         async fail(id, error, token) {
-            await tcp.send({ cmd: 'FAIL', id: String(id), error, token: token ?? undefined });
+            const response = await tcp.send({
+                cmd: 'FAIL',
+                id: String(id),
+                error,
+                token: token ?? undefined,
+            });
+            if (response.ok !== true) {
+                throw new Error(typeof response.error === 'string' ? response.error : 'FAIL failed');
+            }
+            return outcomeWasApplied(response.data);
         },
         async updateProgress(id, progress) {
             await tcp.send({ cmd: 'Progress', id: String(id), progress });
         },
         addLog(id, message) {
-            tcp.send({ cmd: 'AddLog', id: String(id), message }).catch(() => { });
+            tcp.send({ cmd: 'AddLog', id: String(id), message }).catch(() => {
+                // Logging is intentionally best-effort and must not fail job processing.
+            });
         },
         async sendHeartbeat(ids, tokens) {
             if (ids.length === 0)

package/dist/client/sandboxed/runtime/dispatch.d.ts

@@ -0,0 +1,13 @@
+import type { Job as DomainJob } from '../../../domain/types/job';
+import type { Job } from '../../types';
+import type { IPCResponse, WorkerProcess } from '../types';
+import { SandboxedPool } from './pool';
+export declare abstract class SandboxedDispatch<T = unknown> extends SandboxedPool<T> {
+    protected dispatch(worker: WorkerProcess, job: DomainJob, token: string | null): void;
+    protected handleMessage(worker: WorkerProcess, message: IPCResponse): void;
+    protected complete(worker: WorkerProcess, result: unknown): Promise<void>;
+    protected fail(worker: WorkerProcess, error: string): Promise<void>;
+    protected handleTimeout(worker: WorkerProcess, job: DomainJob): Promise<void>;
+    protected abstract safeEmitError(error: Error): void;
+    protected abstract createEventJob(domainJob: DomainJob): Job;
+}

package/dist/client/sandboxed/runtime/dispatch.js

@@ -0,0 +1,186 @@
+import { log } from './log';
+import { SandboxedPool } from './pool';
+export class SandboxedDispatch extends SandboxedPool {
+    dispatch(worker, job, token) {
+        this.lastActivityTime = Date.now();
+        worker.busy = true;
+        worker.currentJob = job;
+        worker.currentToken = token;
+        if (this.options.timeout > 0) {
+            worker.timeoutId = setTimeout(() => {
+                void this.handleTimeout(worker, job);
+            }, this.options.timeout);
+        }
+        this.emit('active', this.createEventJob(job));
+        const jobData = job.data;
+        const parentId = jobData?.__flowParentId;
+        const request = {
+            type: 'job',
+            job: {
+                id: String(job.id),
+                name: job.name,
+                data: job.data,
+                queue: job.queue,
+                attempts: job.attempts,
+                ...(parentId ? { parentId } : {}),
+            },
+        };
+        try {
+            worker.worker.postMessage(request);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log('error', 'Failed to dispatch job', {
+                jobId: String(job.id),
+                error: errorMessage,
+            });
+            this.safeEmitError(Object.assign(new Error(`Dispatch failed: ${errorMessage}`), {
+                jobId: String(job.id),
+                context: 'dispatch',
+            }));
+            this.resetWorkerState(worker);
+            this.ops
+                .fail(job.id, 'Dispatch failed: worker terminated', token ?? undefined)
+                .catch((failure) => {
+                log('error', 'Failed to mark dispatched job as failed', {
+                    jobId: String(job.id),
+                    error: failure instanceof Error ? failure.message : String(failure),
+                });
+            });
+        }
+    }
+    handleMessage(worker, message) {
+        if (message.type === 'ready')
+            return;
+        if (!worker.currentJob || message.jobId !== String(worker.currentJob.id))
+            return;
+        switch (message.type) {
+            case 'result':
+                void this.complete(worker, message.result);
+                break;
+            case 'error':
+                void this.fail(worker, message.error ?? 'Unknown error');
+                break;
+            case 'fail':
+                void this.fail(worker, message.error ?? 'Job explicitly failed');
+                break;
+            case 'progress':
+                if (message.progress !== undefined) {
+                    this.ops
+                        .updateProgress(worker.currentJob.id, message.progress)
+                        .catch((error) => {
+                        log('error', 'Failed to update job progress', {
+                            jobId: String(worker.currentJob?.id),
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                    this.emit('progress', this.createEventJob(worker.currentJob), message.progress);
+                }
+                break;
+            case 'log':
+                if (message.message) {
+                    this.ops.addLog(worker.currentJob.id, message.message);
+                    this.emit('log', this.createEventJob(worker.currentJob), message.message);
+                }
+                break;
+        }
+    }
+    async complete(worker, result) {
+        this.lastActivityTime = Date.now();
+        const job = worker.currentJob;
+        if (!job)
+            return;
+        const token = worker.currentToken ?? undefined;
+        // Claim this result message locally before awaiting the broker so duplicate
+        // thread messages cannot send a second outcome for the same generation.
+        worker.currentJob = null;
+        if (worker.timeoutId) {
+            clearTimeout(worker.timeoutId);
+            worker.timeoutId = null;
+        }
+        try {
+            const applied = await this.ops.ack(job.id, result, token);
+            if (applied) {
+                const eventJob = this.createEventJob(job);
+                eventJob.returnvalue = result;
+                this.emit('completed', eventJob, result);
+            }
+        }
+        catch (error) {
+            const ackError = error instanceof Error ? error : new Error(String(error));
+            log('error', 'Failed to ack job', {
+                jobId: String(job.id),
+                error: ackError.message,
+            });
+            this.safeEmitError(Object.assign(ackError, { context: 'ack', jobId: String(job.id) }));
+        }
+        finally {
+            this.resetWorkerState(worker);
+        }
+    }
+    async fail(worker, error) {
+        const job = worker.currentJob;
+        if (!job)
+            return;
+        const token = worker.currentToken ?? undefined;
+        worker.currentJob = null;
+        if (worker.timeoutId) {
+            clearTimeout(worker.timeoutId);
+            worker.timeoutId = null;
+        }
+        try {
+            const applied = await this.ops.fail(job.id, error, token);
+            if (applied) {
+                const eventJob = this.createEventJob(job);
+                eventJob.failedReason = error;
+                this.emit('failed', eventJob, new Error(error));
+            }
+        }
+        catch (failure) {
+            const failError = failure instanceof Error ? failure : new Error(String(failure));
+            log('error', 'Failed to mark job as failed', {
+                jobId: String(job.id),
+                error: failError.message,
+            });
+            this.safeEmitError(Object.assign(failError, { context: 'fail', jobId: String(job.id) }));
+        }
+        finally {
+            this.resetWorkerState(worker);
+        }
+    }
+    async handleTimeout(worker, job) {
+        if (worker.currentJob !== job)
+            return;
+        const token = worker.currentToken ?? undefined;
+        worker.currentJob = null;
+        if (worker.timeoutId) {
+            clearTimeout(worker.timeoutId);
+            worker.timeoutId = null;
+        }
+        worker.worker.terminate();
+        const errorMessage = `Job timed out after ${this.options.timeout}ms`;
+        let applied = false;
+        try {
+            applied = await this.ops.fail(job.id, errorMessage, token);
+            if (applied) {
+                const eventJob = this.createEventJob(job);
+                eventJob.failedReason = errorMessage;
+                this.emit('failed', eventJob, new Error(errorMessage));
+            }
+        }
+        catch (error) {
+            const failError = error instanceof Error ? error : new Error(String(error));
+            log('error', 'Failed to mark timed-out job as failed', {
+                jobId: String(job.id),
+                error: failError.message,
+            });
+            this.safeEmitError(Object.assign(failError, { context: 'timeout-fail', jobId: String(job.id) }));
+        }
+        finally {
+            this.resetWorkerState(worker);
+            const index = this.workers.indexOf(worker);
+            if (index !== -1)
+                this.handleCrash(worker, index, applied);
+        }
+    }
+}

package/dist/client/sandboxed/runtime/lifecycle.d.ts

@@ -0,0 +1,20 @@
+import type { WorkerProcess } from '../types';
+import { SandboxedState } from './state';
+export declare abstract class SandboxedLifecycle<T = unknown> extends SandboxedState<T> {
+    start(): Promise<void>;
+    stop(force?: boolean): Promise<void>;
+    protected stopAndWatch(): Promise<void>;
+    protected checkAndRestart(): Promise<void>;
+    isRunning(): boolean;
+    getStats(): {
+        total: number;
+        busy: number;
+        idle: number;
+        recycled: number;
+        restarts: number;
+    };
+    protected resetWorkerState(worker: WorkerProcess): void;
+    protected abstract spawnWorker(index: number): Promise<void>;
+    protected abstract pullLoop(): Promise<void>;
+    protected abstract startHeartbeat(): void;
+}

package/dist/client/sandboxed/runtime/lifecycle.js

@@ -0,0 +1,95 @@
+import { releaseSharedPool } from '../../tcpPool';
+import { cleanupWrapperScript, createWrapperScript } from '../wrapper';
+import { SandboxedState } from './state';
+export class SandboxedLifecycle extends SandboxedState {
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.lastActivityTime = Date.now();
+        if (this.tcp)
+            await this.tcp.connect();
+        this.wrapperPath = await createWrapperScript(this.queueName, this.options.processor);
+        await this.spawnWorker(0);
+        if (this.options.concurrency > 1) {
+            const spawnPromises = [];
+            for (let index = 1; index < this.options.concurrency; index++) {
+                spawnPromises.push(this.spawnWorker(index));
+            }
+            await Promise.all(spawnPromises);
+        }
+        this.startHeartbeat();
+        this.emit('ready');
+        this.pullPromise = this.pullLoop();
+    }
+    async stop(force = false) {
+        this.running = false;
+        if (this.autoStartTimer) {
+            clearInterval(this.autoStartTimer);
+            this.autoStartTimer = null;
+        }
+        if (this.pullPromise)
+            await this.pullPromise;
+        if (!force) {
+            while (this.workers.some((worker) => worker.busy && !worker.terminated)) {
+                await Bun.sleep(50);
+            }
+        }
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        for (const worker of this.workers) {
+            if (worker.timeoutId)
+                clearTimeout(worker.timeoutId);
+            if (!worker.terminated)
+                worker.worker.terminate();
+        }
+        this.workers.length = 0;
+        await cleanupWrapperScript(this.wrapperPath);
+        if (this.tcp)
+            releaseSharedPool(this.tcp);
+        this.emit('closed');
+    }
+    async stopAndWatch() {
+        await this.stop();
+        this.autoStartTimer = setInterval(() => {
+            void this.checkAndRestart();
+        }, this.autoStartPollMs);
+    }
+    async checkAndRestart() {
+        try {
+            const count = await this.ops.countWaiting(this.queueName);
+            if (count > 0) {
+                if (this.autoStartTimer) {
+                    clearInterval(this.autoStartTimer);
+                    this.autoStartTimer = null;
+                }
+                await this.start();
+            }
+        }
+        catch {
+            // Ignore poll errors during watch.
+        }
+    }
+    isRunning() {
+        return this.running;
+    }
+    getStats() {
+        const busy = this.workers.filter((worker) => worker.busy && !worker.terminated).length;
+        const recycled = this.workers.filter((worker) => worker.terminated).length;
+        const alive = this.workers.length - recycled;
+        const restarts = this.workers.reduce((sum, worker) => sum + worker.restarts, 0);
+        return { total: this.workers.length, busy, idle: alive - busy, recycled, restarts };
+    }
+    resetWorkerState(worker) {
+        if (worker.timeoutId) {
+            clearTimeout(worker.timeoutId);
+            worker.timeoutId = null;
+        }
+        worker.busy = false;
+        worker.currentJob = null;
+        worker.currentToken = null;
+        worker.lastIdleAt = Date.now();
+    }
+}

package/dist/client/sandboxed/runtime/log.d.ts

@@ -0,0 +1 @@
+export declare function log(level: 'info' | 'warn' | 'error', message: string, data?: Record<string, unknown>): void;

package/dist/client/sandboxed/runtime/log.js

@@ -0,0 +1,15 @@
+const LOG_PREFIX = '[SandboxedWorker]';
+export function log(level, message, data) {
+    const entry = data ? { message, ...data } : message;
+    switch (level) {
+        case 'info':
+            console.log(LOG_PREFIX, entry);
+            break;
+        case 'warn':
+            console.warn(LOG_PREFIX, entry);
+            break;
+        case 'error':
+            console.error(LOG_PREFIX, entry);
+            break;
+    }
+}

package/dist/client/sandboxed/runtime/pool.d.ts

@@ -0,0 +1,11 @@
+import type { Job as DomainJob } from '../../../domain/types/job';
+import type { IPCResponse, WorkerProcess } from '../types';
+import { SandboxedLifecycle } from './lifecycle';
+export declare abstract class SandboxedPool<T = unknown> extends SandboxedLifecycle<T> {
+    protected spawnWorker(index: number): Promise<void>;
+    protected pullLoop(): Promise<void>;
+    protected recycleIdleWorkers(): void;
+    protected abstract dispatch(worker: WorkerProcess, job: DomainJob, token: string | null): void;
+    protected abstract handleMessage(worker: WorkerProcess, message: IPCResponse): void;
+    protected abstract handleCrash(worker: WorkerProcess, index: number, reportError?: boolean): void;
+}