bunqueue-client 0.1.2 → 0.1.3

package/src/socket-factory.ts

@@ -0,0 +1,51 @@
+/** Socket factory: opens a plain or TLS socket with a connect timeout. */
+
+import { readFileSync } from 'node:fs';
+import { connect as netConnect, type Socket } from 'node:net';
+import { type ConnectionOptions as TlsConnectOptions, connect as tlsConnect } from 'node:tls';
+import type { TlsOption } from './connection-types.js';
+import { ConnectionClosedError } from './errors.js';
+
+export function openSocket(
+  host: string,
+  port: number,
+  tls: TlsOption,
+  connectTimeoutMs: number
+): Promise<Socket> {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      reject(new ConnectionClosedError(`connect timeout to ${host}:${port}`));
+    }, connectTimeoutMs);
+
+    const onError = (err: Error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new ConnectionClosedError(`connect failed: ${err.message}`));
+    };
+    const onReady = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.off('error', onError);
+      resolve(socket);
+    };
+
+    let socket: Socket;
+    if (tls) {
+      const tlsOpts: TlsConnectOptions = { host: host, port: port };
+      if (typeof tls === 'object') {
+        if (tls.caFile) tlsOpts.ca = readFileSync(tls.caFile);
+        if (tls.rejectUnauthorized === false) tlsOpts.rejectUnauthorized = false;
+      }
+      socket = tlsConnect(tlsOpts, onReady);
+    } else {
+      socket = netConnect({ host: host, port: port }, onReady);
+    }
+    socket.on('error', onError);
+  });
+}

package/src/worker-base.ts

@@ -31,8 +31,10 @@ export class WorkerBase extends EventEmitter {
   protected failedCount = 0;
   protected readyPromise: Promise<void>;
   protected readyResolve: (() => void) | null = null;
+  protected readyFired = false;
   protected loopPromise: Promise<void> | null = null;
   protected heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  protected registeredGeneration = -1;
 
   constructor(queue: string, opts: WorkerOptions = {}) {
     super();
@@ -80,6 +82,24 @@ export class WorkerBase extends EventEmitter {
     await this.readyPromise;
   }
 
+  /**
+   * 'ready' is replayed to listeners attached after it fired: with autorun the
+   * loop starts inside the constructor, so a plain once-only event could be
+   * missed by `new Worker(...).on('ready', ...)` patterns.
+   */
+  override on(event: string | symbol, listener: (...args: unknown[]) => void): this {
+    if (event === 'ready' && this.readyFired) listener();
+    return super.on(event, listener);
+  }
+
+  override once(event: string | symbol, listener: (...args: unknown[]) => void): this {
+    if (event === 'ready' && this.readyFired) {
+      listener();
+      return this;
+    }
+    return super.once(event, listener);
+  }
+
   /**
    * Cooperative cancel of a locally active job (mirrors the official client):
    * marks the job and emits 'cancelled'; the processor is expected to check
@@ -105,17 +125,23 @@ export class WorkerBase extends EventEmitter {
     return this.cancelledJobs.has(jobId);
   }
 
-  /** Graceful shutdown: stop pulling, wait for in-flight jobs. */
-  async close(): Promise<void> {
+  /** Graceful shutdown: stop pulling, wait for in-flight jobs.
+   * With `force` the wait for in-flight jobs is skipped (parity with the
+   * official client's `close(force)`). */
+  async close(force = false): Promise<void> {
     if (this.closedFlag) return;
     this.stopped = true;
     if (this.loopPromise) await this.loopPromise;
-    while (this.active.size > 0) await sleep(20);
+    while (!force && this.active.size > 0) await sleep(20);
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
     }
-    await this.safeCall({ cmd: 'UnregisterWorker', workerId: this.workerId });
+    // Only unregister when the loop actually registered (autorun: false and
+    // never run() means the server does not know this worker).
+    if (this.registeredGeneration >= 0) {
+      await this.safeCall({ cmd: 'UnregisterWorker', workerId: this.workerId });
+    }
     this.connection.close();
     this.closedFlag = true;
     this.running = false;

package/src/worker.ts

@@ -42,6 +42,7 @@ export class Worker<T = unknown, R = unknown> extends WorkerBase {
   private async loop(): Promise<void> {
     await this.register();
     this.readyResolve?.();
+    this.readyFired = true;
     this.emit('ready');
     this.startHeartbeat();
 
@@ -74,6 +75,13 @@ export class Worker<T = unknown, R = unknown> extends WorkerBase {
       return;
     }
 
+    // The registration is per-connection server state: after a reconnect the
+    // server no longer knows this worker (ListWorkers, skipIfNoWorker crons).
+    // Detect the new connection generation and re-register before pulling.
+    if (this.connection.isConnected && this.connection.generation !== this.registeredGeneration) {
+      await this.register();
+    }
+
     const response = await this.connection.call(
       {
         cmd: 'PULLB',
@@ -170,5 +178,6 @@ export class Worker<T = unknown, R = unknown> extends WorkerBase {
       pid: process.pid,
       startedAt: Date.now(),
     });
+    this.registeredGeneration = this.connection.generation;
   }
 }