queasy 0.2.0 → 0.3.0

package/src/client.js

@@ -1,8 +1,10 @@
 import EventEmitter from 'node:events';
 import { readFileSync } from 'node:fs';
+import os from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getEnvironmentData } from 'node:worker_threads';
+import { createClient, createCluster } from 'redis';
 import { HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT, LUA_FUNCTIONS_VERSION } from './constants.js';
 import { Manager } from './manager.js';
 import { Pool } from './pool.js';
@@ -18,7 +20,7 @@ const luaScript = readFileSync(join(__dirname, 'queasy.lua'), 'utf8').replace(
 /**
  * Check the installed version and load our Lua functions if needed.
  * Returns true if this client should be disconnected (newer major on server).
- * @param {RedisClient} redis
+ * @param {{ fCall: Function, sendCommand: Function }} redis
  * @returns {Promise<boolean>} Whether to disconnect.
  */
 async function installLuaFunctions(redis) {
@@ -38,9 +40,19 @@ async function installLuaFunctions(redis) {
     return installedVersion[0] > availableVersion[0];
 }
 
-/** @typedef {import('redis').RedisClientType} RedisClient */
+/** @typedef {import('./types').RedisOptions} RedisOptions */
 /** @typedef {import('./types').Job} Job */
 
+/**
+ * @param {RedisOptions} options
+ */
+function buildRedisConnection(options) {
+    if ('rootNodes' in options) {
+        return createCluster(options);
+    }
+    return createClient(options);
+}
+
 /** @typedef {{ queue: Queue, bumpTimer?: NodeJS.Timeout }} QueueEntry */
 
 /**
@@ -70,13 +82,13 @@ export function parseJob(jobArray) {
 
 export class Client extends EventEmitter {
     /**
-     * @param {RedisClient} redis - Redis client
-     * @param {number?} workerCount - Allow this client to dequeue jobs.
+     * @param {RedisOptions} options - Redis connection options
+     * @param {number} [workerCount] - Allow this client to dequeue jobs.
      * @param {((client: Client) => any)} [callback] - Callback when client is ready
      */
-    constructor(redis, workerCount, callback) {
+    constructor(options = {}, workerCount = os.cpus().length, callback) {
         super();
-        this.redis = redis;
+        this.redis = buildRedisConnection(options);
         this.clientId = generateId();
 
         /** @type {Record<string, QueueEntry>} */
@@ -90,11 +102,21 @@ export class Client extends EventEmitter {
         // Not awaited — the Lua script is read synchronously at module load,
         // so Redis' single-threaded ordering ensures the FUNCTION LOAD completes
         // before any subsequent fCalls from user code.
-        installLuaFunctions(this.redis).then((disconnect) => {
-            this.disconnected = disconnect;
-            if (disconnect) this.emit('disconnected', 'Redis has incompatible queasy version.');
-            else if (callback) callback(this);
-        });
+        this.redis
+            .connect()
+            .then(() => installLuaFunctions(this.redis))
+            .then((disconnect) => {
+                this.disconnected = disconnect;
+                if (disconnect) this.emit('disconnected', 'Redis has incompatible queasy version.');
+                else {
+                    this.emit('connected');
+                    if (callback) callback(this);
+                }
+            })
+            .catch((err) => {
+                this.disconnected = true;
+                this.emit('disconnected', err.message);
+            });
     }
 
     /**
@@ -155,6 +177,7 @@ export class Client extends EventEmitter {
         this.queues = {};
         this.pool = undefined;
         this.disconnected = true;
+        await this.redis.quit().catch(() => {});
     }
 
     /**
@@ -211,7 +234,11 @@ export class Client extends EventEmitter {
         // Heartbeats should start with the first dequeue.
         this.scheduleBump(key);
 
-        return /** @type Job[] */ (result.map((jobArray) => parseJob(jobArray)).filter(Boolean));
+        const jobs = /** @type Job[] */ (
+            result.map((jobArray) => parseJob(jobArray)).filter(Boolean)
+        );
+        for (const job of jobs) this.emit('dequeue', key, job);
+        return jobs;
     }
 
     /**
@@ -223,6 +250,7 @@ export class Client extends EventEmitter {
             keys: [key],
             arguments: [jobId, this.clientId, String(Date.now())],
         });
+        this.emit('finish', key, jobId);
     }
 
     /**
@@ -242,6 +270,7 @@ export class Client extends EventEmitter {
                 String(Date.now()),
             ],
         });
+        this.emit('fail', key, jobId);
     }
 
     /**
@@ -254,5 +283,6 @@ export class Client extends EventEmitter {
             keys: [key],
             arguments: [jobId, this.clientId, String(retryAt), String(Date.now())],
         });
+        this.emit('retry', key, jobId);
     }
 }

package/src/constants.js

@@ -30,7 +30,7 @@ export const FAILJOB_RETRY_OPTIONS = {
     priority: 100,
 };
 
-export const LUA_FUNCTIONS_VERSION = '1.0';
+export const LUA_FUNCTIONS_VERSION = '1.0.1';
 export const HEARTBEAT_INTERVAL = 5000; // 5 seconds
 export const HEARTBEAT_TIMEOUT = 10000; // 10 seconds
 export const WORKER_CAPACITY = 10;

package/src/queasy.lua

@@ -226,9 +226,8 @@ local function dequeue(queue_key, client_id, now, expiry, limit)
         table.insert(result, job)
     end
 
-    if #result > 0 then
-        redis.call('ZADD', expiry_key, expiry, client_id)
-    end
+    -- Add this client to queue and bump its expiry
+    redis.call('ZADD', expiry_key, expiry, client_id)
 
     -- Sweep stalled clients
     sweep(queue_key, now)

package/src/types.ts

@@ -1,3 +1,18 @@
+import type { RedisClientOptions, RedisClusterOptions } from 'redis';
+
+type SingleNodeOptions = Pick<
+    RedisClientOptions,
+    'url' | 'socket' | 'username' | 'password' | 'database'
+>;
+
+export type RedisOptions =
+    | SingleNodeOptions
+    | {
+          rootNodes: SingleNodeOptions[];
+          defaults?: Partial<SingleNodeOptions>;
+          nodeAddressMap?: RedisClusterOptions['nodeAddressMap'];
+      };
+
 /**
  * Core job identification and data
  */

package/test/client.test.js

@@ -14,7 +14,7 @@ describe.skip('Client heartbeat', () => {
     beforeEach(async () => {
         redis = createClient();
         await redis.connect();
-        client = new Client(redis, 1);
+        client = new Client({}, 1);
         client.scheduleBump = mock.fn();
         if (client.manager) client.manager.addQueue = mock.fn();
     });

package/test/guards.test.js

@@ -4,22 +4,17 @@ import { createClient } from 'redis';
 import { Client } from '../src/index.js';
 
 describe('Client disconnect guard', () => {
-    /** @type {import('redis').RedisClientType} */
-    let redis;
     /** @type {import('../src/client.js').Client} */
     let client;
 
-    beforeEach(async () => {
-        redis = createClient();
-        await redis.connect();
+    beforeEach(() => {
         return new Promise((res) => {
-            client = new Client(redis, 0, res);
+            client = new Client({}, 0, res);
         });
     });
 
     afterEach(async () => {
         await client.close();
-        await redis.quit();
     });
 
     it('should throw from queue() when disconnected', () => {
@@ -29,23 +24,18 @@ describe('Client disconnect guard', () => {
 });
 
 describe('Queue disconnect guards', () => {
-    /** @type {import('redis').RedisClientType} */
-    let redis;
     /** @type {import('../src/client.js').Client} */
     let client;
 
-    beforeEach(async () => {
-        redis = createClient();
-        await redis.connect();
-        client = new Client(redis, 1);
-        if (client.manager) client.manager.addQueue = mock.fn();
-        // Wait for installLuaFunctions to settle
-        await new Promise((r) => setTimeout(r, 50));
+    beforeEach(() => {
+        return new Promise((res) => {
+            client = new Client({}, 1, res);
+            if (client.manager) client.manager.addQueue = mock.fn();
+        });
     });
 
     afterEach(async () => {
         await client.close();
-        await redis.quit();
     });
 
     it('should throw from dispatch() when disconnected', async () => {
@@ -67,12 +57,10 @@ describe('Queue disconnect guards', () => {
     });
 
     it('should throw from listen() on non-processing client', async () => {
-        const nonProcessingClient = new Client(redis, 0);
-        // Wait for installLuaFunctions to settle
-        await new Promise((r) => setTimeout(r, 50));
+        const nonProcessingClient = await new Promise((res) => new Client({}, 0, res));
         const q = nonProcessingClient.queue('guard-test');
         await assert.rejects(() => q.listen('/some/handler.js'), /non-processing/);
-        await client.close();
+        await nonProcessingClient.close();
     });
 });
 
@@ -90,8 +78,10 @@ describe('Client bump lost lock', () => {
         const keys = await redis.keys(`{${QUEUE_NAME}}*`);
         if (keys.length > 0) await redis.del(keys);
 
-        client = new Client(redis, 1);
-        if (client.manager) client.manager.addQueue = mock.fn();
+        await new Promise((res) => {
+            client = new Client({}, 1, res);
+            if (client.manager) client.manager.addQueue = mock.fn();
+        });
     });
 
     afterEach(async () => {

package/test/manager.test.js

@@ -163,7 +163,9 @@ describe('Manager scheduling', () => {
         if (keys.length > 0) await redis.del(keys);
 
         // Do NOT mock manager.addQueue — let the manager drive dequeuing
-        client = new Client(redis, 1);
+        await new Promise((res) => {
+            client = new Client({}, 1, res);
+        });
     });
 
     afterEach(async () => {

package/test/pool.test.js

@@ -111,8 +111,10 @@ describe('Pool stall and timeout', () => {
         const keys = await redis.keys(`{${QUEUE_NAME}}*`);
         if (keys.length > 0) await redis.del(keys);
 
-        client = new Client(redis, 1);
-        if (client.manager) client.manager.addQueue = mock.fn();
+        await new Promise((res) => {
+            client = new Client({}, 1, res);
+            if (client.manager) client.manager.addQueue = mock.fn();
+        });
     });
 
     afterEach(async () => {

package/test/queue.test.js

@@ -19,10 +19,11 @@ describe('Queue E2E', () => {
             await redis.del(keys);
         }
 
-        client = new Client(redis, 1);
-
-        // Mock this so that no actual work is dequeued by the manager.
-        if (client.manager) client.manager.addQueue = mock.fn();
+        await new Promise((res) => {
+            client = new Client({}, 1, res);
+            // Mock this so that no actual work is dequeued by the manager.
+            if (client.manager) client.manager.addQueue = mock.fn();
+        });
     });
 
     afterEach(async () => {