bunqueue 2.8.54 → 2.8.57

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

@@ -0,0 +1,122 @@
+import { jobId } from '../../../domain/types/job';
+import { getSharedManager } from '../../manager';
+import { createPublicJob } from '../../jobConversion';
+import { buildFailCommand, failEmbeddedArgs } from '../../queue/failWire';
+import { createChangeDelayHandler, createChangePriorityHandler, createClearLogsHandler, createDiscardHandler, createExtendLockHandler, createGetChildrenValuesHandler, createGetDependenciesCountHandler, createGetDependenciesHandler, createGetFailedChildrenValuesHandler, createGetIgnoredChildrenFailuresHandler, createGetStateHandler, createLogHandler, createMoveToDelayedHandler, createMoveToWaitHandler, createMoveToWaitingChildrenHandler, createProgressHandler, createPromoteHandler, createRemoveChildDependencyHandler, createRemoveDeduplicationKeyHandler, createRemoveHandler, createRemoveUnprocessedChildrenHandler, createRetryHandler, createUpdateDataHandler, createWaitUntilFinishedHandler, } from '../../worker/processorHandlers';
+import { SandboxedDispatch } from './dispatch';
+import { log } from './log';
+export class SandboxedRecovery extends SandboxedDispatch {
+    handleCrash(worker, index, reportError = true) {
+        if (worker.currentJob) {
+            const token = worker.currentToken ?? undefined;
+            this.ops.fail(worker.currentJob.id, 'Worker crashed', token).catch((error) => {
+                log('error', 'Failed to mark crashed job as failed', {
+                    jobId: String(worker.currentJob?.id),
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        }
+        if (reportError) {
+            this.safeEmitError(Object.assign(new Error('Worker crashed'), {
+                workerIndex: index,
+                context: 'crash',
+            }));
+        }
+        this.resetWorkerState(worker);
+        worker.restarts++;
+        if (this.options.autoRestart && worker.restarts < this.options.maxRestarts && this.running) {
+            this.spawnWorker(index).catch((error) => {
+                log('error', 'Failed to restart worker', {
+                    workerIndex: index,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        }
+        else if (worker.restarts >= this.options.maxRestarts) {
+            log('error', 'Worker exceeded max restarts', {
+                workerIndex: index,
+                maxRestarts: this.options.maxRestarts,
+            });
+        }
+    }
+    startHeartbeat() {
+        if (this.heartbeatInterval <= 0)
+            return;
+        this.heartbeatTimer = setInterval(() => void this.sendHeartbeat(), this.heartbeatInterval);
+    }
+    async sendHeartbeat() {
+        const active = this.workers.filter((worker) => worker.busy && worker.currentJob && !worker.terminated);
+        if (active.length === 0)
+            return;
+        try {
+            const ids = active.map((worker) => String(worker.currentJob?.id));
+            const tokens = active.map((worker) => worker.currentToken ?? '');
+            await this.ops.sendHeartbeat(ids, tokens);
+        }
+        catch (error) {
+            this.safeEmitError(Object.assign(error instanceof Error ? error : new Error(String(error)), {
+                context: 'heartbeat',
+            }));
+        }
+    }
+    safeEmitError(error) {
+        if (this.listenerCount('error') > 0)
+            this.emit('error', error);
+    }
+    createEventJob(domainJob) {
+        const embedded = !this.tcp;
+        const tcp = this.tcp;
+        const moveToCompleted = async (id, returnValue, token) => {
+            if (embedded)
+                await getSharedManager().ack(jobId(id), returnValue, token);
+            else if (tcp) {
+                const response = await tcp.send({
+                    cmd: 'ACK',
+                    id,
+                    result: returnValue,
+                    ...(token === undefined ? {} : { token }),
+                });
+                if (response.ok !== true) {
+                    throw new Error(typeof response.error === 'string' ? response.error : 'ACK failed');
+                }
+            }
+            return null;
+        };
+        const moveToFailed = async (id, error, token) => {
+            if (embedded)
+                await getSharedManager().fail(jobId(id), ...failEmbeddedArgs(error, token));
+            else if (tcp)
+                await tcp.send(buildFailCommand(id, error, token));
+        };
+        return createPublicJob({
+            job: domainJob,
+            name: domainJob.name,
+            updateProgress: createProgressHandler(embedded, tcp, this, { current: null }),
+            log: createLogHandler(embedded, tcp, this, { current: null }),
+            getState: createGetStateHandler(embedded, tcp),
+            getChildrenValues: createGetChildrenValuesHandler(embedded, tcp),
+            getFailedChildrenValues: createGetFailedChildrenValuesHandler(embedded, tcp),
+            getIgnoredChildrenFailures: createGetIgnoredChildrenFailuresHandler(embedded, tcp),
+            removeChildDependency: createRemoveChildDependencyHandler(embedded, tcp),
+            removeUnprocessedChildren: createRemoveUnprocessedChildrenHandler(embedded, tcp),
+            remove: createRemoveHandler(embedded, tcp),
+            retry: createRetryHandler(embedded, tcp, { internalJob: domainJob }),
+            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, domainJob),
+            getDependenciesCount: createGetDependenciesCountHandler(embedded, tcp, domainJob),
+            removeDeduplicationKey: createRemoveDeduplicationKeyHandler(embedded, tcp),
+            moveToCompleted,
+            moveToFailed,
+        });
+    }
+}

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

@@ -0,0 +1,39 @@
+import { EventEmitter } from 'events';
+import type { Job } from '../../types';
+import { type TcpConnectionPool } from '../../tcpPool';
+import { type QueueOps } from '../queueOps';
+import type { RequiredSandboxedWorkerOptions, SandboxedWorkerOptions, WorkerProcess } from '../types';
+export declare abstract class SandboxedState<T = unknown> extends EventEmitter {
+    on(event: 'ready' | 'closed', listener: () => void): this;
+    on(event: 'active', listener: (job: Job<T>) => void): this;
+    on(event: 'completed', listener: (job: Job<T>, result: unknown) => void): this;
+    on(event: 'failed', listener: (job: Job<T>, error: Error) => void): this;
+    on(event: 'progress', listener: (job: Job<T>, progress: number) => void): this;
+    on(event: 'log', listener: (job: Job<T>, message: string) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    once(event: 'ready' | 'closed', listener: () => void): this;
+    once(event: 'active', listener: (job: Job<T>) => void): this;
+    once(event: 'completed', listener: (job: Job<T>, result: unknown) => void): this;
+    once(event: 'failed', listener: (job: Job<T>, error: Error) => void): this;
+    once(event: 'progress', listener: (job: Job<T>, progress: number) => void): this;
+    once(event: 'log', listener: (job: Job<T>, message: string) => void): this;
+    once(event: 'error', listener: (error: Error) => void): this;
+    protected readonly queueName: string;
+    protected readonly options: RequiredSandboxedWorkerOptions;
+    protected readonly workers: WorkerProcess[];
+    protected running: boolean;
+    protected pullPromise: Promise<void> | null;
+    protected wrapperPath: string | null;
+    protected readonly ops: QueueOps;
+    protected readonly tcp: TcpConnectionPool | null;
+    protected readonly workerId: string;
+    protected heartbeatTimer: ReturnType<typeof setInterval> | null;
+    protected readonly heartbeatInterval: number;
+    protected readonly idleTimeout: number;
+    protected readonly idleRecycleMs: number;
+    protected readonly autoStart: boolean;
+    protected readonly autoStartPollMs: number;
+    protected lastActivityTime: number;
+    protected autoStartTimer: ReturnType<typeof setInterval> | null;
+    constructor(queueName: string, options: SandboxedWorkerOptions);
+}

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

@@ -0,0 +1,59 @@
+import { EventEmitter } from 'events';
+import { getSharedManager } from '../../manager';
+import { getSharedPool } from '../../tcpPool';
+import { createEmbeddedOps, createTcpOps } from '../queueOps';
+export class SandboxedState extends EventEmitter {
+    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback listener is intentionally untyped
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback listener is intentionally untyped
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    queueName;
+    options;
+    workers = [];
+    running = false;
+    pullPromise = null;
+    wrapperPath = null;
+    ops;
+    tcp;
+    workerId;
+    heartbeatTimer = null;
+    heartbeatInterval;
+    idleTimeout;
+    idleRecycleMs;
+    autoStart;
+    autoStartPollMs;
+    lastActivityTime = 0;
+    autoStartTimer = null;
+    constructor(queueName, options) {
+        super();
+        this.queueName = queueName;
+        this.workerId = `sandboxed-worker-${queueName}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+        if (options.connection) {
+            this.tcp = getSharedPool(options.connection);
+            this.ops = createTcpOps(this.tcp);
+            this.heartbeatInterval = options.heartbeatInterval ?? 10000;
+        }
+        else {
+            this.tcp = null;
+            this.ops = createEmbeddedOps(options.manager ?? getSharedManager());
+            this.heartbeatInterval = options.heartbeatInterval ?? 5000;
+        }
+        this.idleTimeout = options.idleTimeout ?? 0;
+        this.idleRecycleMs = options.idleRecycleMs ?? 30000;
+        this.autoStart = options.autoStart ?? false;
+        this.autoStartPollMs = options.autoStartPollMs ?? 5000;
+        this.options = {
+            processor: options.processor,
+            concurrency: options.concurrency ?? 1,
+            maxMemory: options.maxMemory ?? 256,
+            timeout: options.timeout ?? 30000,
+            autoRestart: options.autoRestart ?? true,
+            maxRestarts: options.maxRestarts ?? 10,
+            pollInterval: options.pollInterval ?? 10,
+        };
+    }
+}

package/dist/client/sandboxed/types/index.d.ts

@@ -0,0 +1,2 @@
+export type { RequiredSandboxedWorkerOptions, SandboxedWorkerOptions } from './options';
+export type { IPCRequest, IPCResponse, WorkerProcess } from './process';

package/dist/client/sandboxed/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/client/sandboxed/types/options.d.ts

@@ -0,0 +1,27 @@
+import type { SharedManager } from '../../manager';
+import type { ConnectionOptions } from '../../types';
+export interface SandboxedWorkerOptions {
+    processor: string;
+    concurrency?: number;
+    maxMemory?: number;
+    timeout?: number;
+    autoRestart?: boolean;
+    maxRestarts?: number;
+    pollInterval?: number;
+    manager?: SharedManager;
+    connection?: ConnectionOptions;
+    heartbeatInterval?: number;
+    idleTimeout?: number;
+    idleRecycleMs?: number;
+    autoStart?: boolean;
+    autoStartPollMs?: number;
+}
+export interface RequiredSandboxedWorkerOptions {
+    processor: string;
+    concurrency: number;
+    maxMemory: number;
+    timeout: number;
+    autoRestart: boolean;
+    maxRestarts: number;
+    pollInterval: number;
+}

package/dist/client/sandboxed/types/options.js

@@ -0,0 +1 @@
+export {};

package/dist/client/sandboxed/types/process.d.ts

@@ -0,0 +1,30 @@
+import type { Job as DomainJob } from '../../../domain/types/job';
+export interface WorkerProcess {
+    worker: Worker;
+    busy: boolean;
+    currentJob: DomainJob | null;
+    currentToken: string | null;
+    restarts: number;
+    timeoutId: Timer | null;
+    lastIdleAt: number;
+    terminated: boolean;
+}
+export interface IPCRequest {
+    type: 'job';
+    job: {
+        id: string;
+        name: string;
+        data: unknown;
+        queue: string;
+        attempts: number;
+        parentId?: string;
+    };
+}
+export interface IPCResponse {
+    type: 'result' | 'error' | 'progress' | 'log' | 'fail' | 'ready';
+    jobId?: string;
+    result?: unknown;
+    error?: string;
+    progress?: number;
+    message?: string;
+}

package/dist/client/sandboxed/types/process.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,86 +1,4 @@
-/**
- * Sandboxed Worker
- * Runs job processors in isolated Bun Worker processes
- */
-import { EventEmitter } from 'events';
-import type { Job } from '../types';
-import type { SandboxedWorkerOptions } from './types';
-/**
- * Sandboxed Worker - runs processors in isolated Bun Worker processes
- * @template T - Job data type for typed events
- */
-export declare class SandboxedWorker<T = unknown> extends EventEmitter {
-    on(event: 'ready' | 'closed', listener: () => void): this;
-    on(event: 'active', listener: (job: Job<T>) => void): this;
-    on(event: 'completed', listener: (job: Job<T>, result: unknown) => void): this;
-    on(event: 'failed', listener: (job: Job<T>, error: Error) => void): this;
-    on(event: 'progress', listener: (job: Job<T>, progress: number) => void): this;
-    on(event: 'log', listener: (job: Job<T>, message: string) => void): this;
-    on(event: 'error', listener: (error: Error) => void): this;
-    once(event: 'ready' | 'closed', listener: () => void): this;
-    once(event: 'active', listener: (job: Job<T>) => void): this;
-    once(event: 'completed', listener: (job: Job<T>, result: unknown) => void): this;
-    once(event: 'failed', listener: (job: Job<T>, error: Error) => void): this;
-    once(event: 'progress', listener: (job: Job<T>, progress: number) => void): this;
-    once(event: 'log', listener: (job: Job<T>, message: string) => void): this;
-    once(event: 'error', listener: (error: Error) => void): this;
-    private readonly queueName;
-    private readonly options;
-    private readonly workers;
-    private running;
-    private pullPromise;
-    private wrapperPath;
-    private readonly ops;
-    private readonly tcp;
-    private readonly workerId;
-    private heartbeatTimer;
-    private readonly heartbeatInterval;
-    private readonly idleTimeout;
-    private readonly idleRecycleMs;
-    private readonly autoStart;
-    private readonly autoStartPollMs;
-    private lastActivityTime;
-    private autoStartTimer;
-    constructor(queueName: string, options: SandboxedWorkerOptions);
-    /** Start the sandboxed worker pool */
-    start(): Promise<void>;
-    /** Stop all workers gracefully */
-    stop(force?: boolean): Promise<void>;
-    /**
-     * Stop workers but keep polling for new jobs.
-     * When a job is found, automatically restart the worker pool.
-     */
-    private stopAndWatch;
-    /** Check for waiting jobs and restart if found */
-    private checkAndRestart;
-    /** Check if the worker is currently running */
-    isRunning(): boolean;
-    /** Get worker pool stats */
-    getStats(): {
-        total: number;
-        busy: number;
-        idle: number;
-        recycled: number;
-        restarts: number;
-    };
-    /** Reset worker state to idle */
-    private resetWorkerState;
-    private spawnWorker;
-    private pullLoop;
-    /** Terminate individual idle workers that exceeded idleRecycleMs, keeping at least 1 alive */
-    private recycleIdleWorkers;
-    private dispatch;
-    private handleMessage;
-    private complete;
-    private fail;
-    private handleTimeout;
-    private handleCrash;
-    /** Start heartbeat timer for TCP lock renewal */
-    private startHeartbeat;
-    /** Send heartbeat for all active jobs */
-    private sendHeartbeat;
-    /** Emit 'error' only if there are listeners (avoids uncaught exception) */
-    private safeEmitError;
-    /** Create a public Job object from a DomainJob for event payloads */
-    private createEventJob;
+/** Public SandboxedWorker façade. Runtime lives in sandboxed/runtime/. */
+import { SandboxedRecovery } from './runtime/recovery';
+export declare class SandboxedWorker<T = unknown> extends SandboxedRecovery<T> {
 }