@pingpolls/redisq 1.0.2 → 1.0.4

package/dist/app.d.ts

@@ -1,57 +1,149 @@
 import { RedisClient as BunRedisClient } from "bun";
+/**
+ * Options for initializing the RedisQ client.
+ * You can either provide a Redis client instance or connection details.
+ */
 export type QueueOptions = {
+    /** A Bun Redis client instance. */
     redis: BunRedisClient;
 } | {
+    /** Redis server host. */
     host: string;
+    /** Redis server port. */
     port: string;
+    /** Redis server user. */
     user?: string;
+    /** Redis server password. */
     password?: string;
+    /** Namespace for all Redis keys. */
     namespace?: string;
+    /** Whether to use TLS for the connection. */
     tls?: boolean;
 };
+/**
+ * Options for creating a new queue.
+ * The options are different for regular and batch queues.
+ */
 export type CreateQueueOptions<QueueName extends string = string> = QueueName extends `${string}:batch` ? {
+    /**
+     * The name of the queue. Must end with `:batch` for batch queues.
+     * @example "my-queue:batch"
+     */
     qname: QueueName;
+    /** Maximum message size in bytes.
+     * @default 65536
+     */
     maxsize?: number;
+    /**
+     * Maximum number of retries for a message.
+     * `0` = no retry, `-1` = unlimited, `n` = max retries.
+     * @default 0
+     */
     maxRetries?: number;
+    /**
+     * Maximum backoff time in seconds for exponential backoff.
+     * @default 30
+     */
     maxBackoffSeconds?: number;
+    /**
+     * Batch processing interval in seconds.
+     * @default 60
+     */
     every?: number;
 } : {
+    /**
+     * The name of the queue.
+     * @example "my-queue"
+     */
     qname: QueueName;
+    /** Maximum message size in bytes.
+     * @default 65536
+     */
     maxsize?: number;
+    /**
+     * Maximum number of retries for a message.
+     * `0` = no retry, `-1` = unlimited, `n` = max retries.
+     * @default 0
+     */
     maxRetries?: number;
+    /**
+     * Maximum backoff time in seconds for exponential backoff.
+     * @default 30
+     */
     maxBackoffSeconds?: number;
 };
+/**
+ * Attributes of a queue.
+ */
 export interface QueueAttributes {
+    /** Maximum message size in bytes. */
     maxsize: number;
+    /** Timestamp when the queue was created. */
     created: number;
+    /** Number of pending messages in the queue. */
     msgs: number;
+    /** Whether the queue is a batch queue. */
     isBatch: boolean;
+    /** Maximum number of retries for a message. */
     maxRetries: number;
+    /** Maximum backoff time in seconds for exponential backoff. */
     maxBackoffSeconds: number;
+    /** Batch processing interval in seconds (for batch queues only). */
     every?: number;
 }
+/**
+ * Options for sending a message to a regular queue.
+ */
 export interface SendMessageOptions {
+    /** The name of the queue. */
     qname: string;
+    /** The message content. */
     message: string;
+    /** Optional delay in milliseconds before the message is processed. */
     delay?: number;
 }
+/**
+ * Options for sending a message to a batch queue.
+ */
 export interface SendBatchMessageOptions {
+    /** The name of the batch queue. */
     qname: string;
+    /**
+     * The ID of the batch. Messages with the same `batchId` are processed together.
+     */
     batchId: string;
+    /** The message content. */
     message: string;
 }
+/**
+ * A message received from a regular queue.
+ */
 export interface Message {
+    /** The unique ID of the message. */
     id: string;
+    /** The message content. */
     message: string;
+    /** Timestamp when the message was sent. */
     sent: number;
+    /** The current attempt number (1-based). */
     attempt: number;
 }
+/**
+ * A batch of messages received from a batch queue.
+ */
 export interface BatchMessage {
+    /** The ID of the batch. */
     batchId: string;
+    /** Array of messages in the batch. */
     messages: Omit<Message, "attempt">[];
+    /** Timestamp when the batch was created. */
     sent: number;
+    /** The current attempt number for the batch (1-based). */
     attempt: number;
 }
+/**
+ * A lightweight, type-safe Redis-based message queue for Bun.
+ */
 export declare class RedisQ {
     private redis;
     private redisUrl;
@@ -59,14 +151,47 @@ export declare class RedisQ {
     private workers;
     private batchJobs;
     private isClosing;
+    /**
+     * Initializes the RedisQ client.
+     * @param options - Options for initializing the client.
+     */
     constructor(options: QueueOptions);
     private getKey;
     private isBatchQueue;
+    /**
+     * Creates a new queue with the specified options.
+     * @param options - Options for creating the queue.
+     * @returns `true` if the queue was created, `false` if it already exists.
+     */
     createQueue<QueueName extends string>(options: CreateQueueOptions<QueueName>): Promise<boolean>;
+    /**
+     * Lists all queue names.
+     * @returns An array of queue names.
+     */
     listQueues(): Promise<string[]>;
+    /**
+     * Gets the attributes of a queue.
+     * @param qname - The name of the queue.
+     * @returns The queue attributes, or `null` if the queue does not exist.
+     */
     getQueue(qname: string): Promise<QueueAttributes | null>;
+    /**
+     * Deletes a queue and all its data.
+     * @param qname - The name of the queue to delete.
+     * @returns `true` if the queue was deleted, `false` if it did not exist.
+     */
     deleteQueue(qname: string): Promise<boolean>;
+    /**
+     * Sends a message to a regular queue.
+     * @param options - Options for sending the message.
+     * @returns The unique ID of the message.
+     */
     sendMessage(options: SendMessageOptions): Promise<string>;
+    /**
+     * Sends a message to a batch queue.
+     * @param options - Options for sending the batch message.
+     * @returns The unique ID of the message.
+     */
     sendBatchMessage(options: SendBatchMessageOptions): Promise<string>;
     private encodeMessage;
     private decodeMessage;
@@ -74,12 +199,24 @@ export declare class RedisQ {
     private decodeBatchMeta;
     private fetchMessages;
     private fetchBatchMessage;
+    /**
+     * Manually deletes a message from the queue.
+     * @param qname - The name of the queue.
+     * @param id - The ID of the message to delete.
+     * @returns `true` if the message was deleted, `false` otherwise.
+     */
     deleteMessage(qname: string, id: string): Promise<boolean>;
     private deleteBatch;
     private retryMessage;
     private retryBatch;
     private processDelayedMessages;
     private processBatches;
+    /**
+     * Starts a worker to process messages from a queue.
+     * @param qname - The name of the queue.
+     * @param handler - The function to process messages.
+     * @param options - Options for the worker.
+     */
     startWorker<QueueName extends `${string}:batch` | (string & {})>(qname: QueueName, handler: (received: QueueName extends `${string}:batch` ? BatchMessage : Message) => Promise<{
         success: boolean;
     }>, options?: {
@@ -87,6 +224,13 @@ export declare class RedisQ {
         silent?: boolean;
     }): Promise<void>;
     private runWorker;
+    /**
+     * Stops a specific worker.
+     * @param qname - The name of the queue for which to stop the worker.
+     */
     stopWorker(qname: string): void;
+    /**
+     * Closes all workers and the Redis connection gracefully.
+     */
     close(): Promise<void>;
 }

package/dist/app.js

@@ -1,5 +1,8 @@
 import { RedisClient as BunRedisClient } from "bun";
 import { Cron } from "croner";
+/**
+ * A lightweight, type-safe Redis-based message queue for Bun.
+ */
 export class RedisQ {
     redis;
     redisUrl;
@@ -7,6 +10,10 @@ export class RedisQ {
     workers = new Map();
     batchJobs = new Map();
     isClosing = false;
+    /**
+     * Initializes the RedisQ client.
+     * @param options - Options for initializing the client.
+     */
     constructor(options) {
         if ("redis" in options) {
             this.redis = options.redis;
@@ -34,6 +41,11 @@ export class RedisQ {
     isBatchQueue(qname) {
         return qname.endsWith(":batch");
     }
+    /**
+     * Creates a new queue with the specified options.
+     * @param options - Options for creating the queue.
+     * @returns `true` if the queue was created, `false` if it already exists.
+     */
     async createQueue(options) {
         const { qname, maxsize = 65536, maxRetries = 0, maxBackoffSeconds = 30, } = options;
         if (!/^[a-zA-Z0-9_:-]{1,160}$/.test(qname)) {
@@ -58,6 +70,10 @@ export class RedisQ {
         await this.redis.hset(key, attrs);
         return true;
     }
+    /**
+     * Lists all queue names.
+     * @returns An array of queue names.
+     */
     async listQueues() {
         const pattern = `${this.ns}:*`;
         const keys = await this.redis.keys(pattern);
@@ -65,6 +81,11 @@ export class RedisQ {
             .map((k) => k.replace(`${this.ns}:`, ""))
             .filter((k) => !k.includes(":") || k.endsWith(":batch"));
     }
+    /**
+     * Gets the attributes of a queue.
+     * @param qname - The name of the queue.
+     * @returns The queue attributes, or `null` if the queue does not exist.
+     */
     async getQueue(qname) {
         const key = this.getKey(qname);
         const attrs = await this.redis.hgetall(key);
@@ -91,6 +112,11 @@ export class RedisQ {
         }
         return result;
     }
+    /**
+     * Deletes a queue and all its data.
+     * @param qname - The name of the queue to delete.
+     * @returns `true` if the queue was deleted, `false` if it did not exist.
+     */
     async deleteQueue(qname) {
         const pattern = `${this.ns}:${qname}*`;
         let cursor = "0";
@@ -105,6 +131,11 @@ export class RedisQ {
         } while (cursor !== "0");
         return keysFound;
     }
+    /**
+     * Sends a message to a regular queue.
+     * @param options - Options for sending the message.
+     * @returns The unique ID of the message.
+     */
     async sendMessage(options) {
         const { qname, message, delay } = options;
         if (this.isBatchQueue(qname)) {
@@ -147,6 +178,11 @@ export class RedisQ {
         }
         return id;
     }
+    /**
+     * Sends a message to a batch queue.
+     * @param options - Options for sending the batch message.
+     * @returns The unique ID of the message.
+     */
     async sendBatchMessage(options) {
         const { qname, batchId, message } = options;
         if (!this.isBatchQueue(qname)) {
@@ -256,6 +292,12 @@ export class RedisQ {
             sent: meta.sent,
         };
     }
+    /**
+     * Manually deletes a message from the queue.
+     * @param qname - The name of the queue.
+     * @param id - The ID of the message to delete.
+     * @returns `true` if the message was deleted, `false` otherwise.
+     */
     async deleteMessage(qname, id) {
         const messagesKey = this.getKey(qname, "messages");
         const deleted = await this.redis.hdel(messagesKey, id);
@@ -388,6 +430,12 @@ export class RedisQ {
         });
         await Promise.all(batchPromises);
     }
+    /**
+     * Starts a worker to process messages from a queue.
+     * @param qname - The name of the queue.
+     * @param handler - The function to process messages.
+     * @param options - Options for the worker.
+     */
     async startWorker(qname, handler, options = {}) {
         const { concurrency = 1, silent = false } = options;
         if (this.workers.has(qname)) {
@@ -462,6 +510,10 @@ export class RedisQ {
             }
         }
     }
+    /**
+     * Stops a specific worker.
+     * @param qname - The name of the queue for which to stop the worker.
+     */
     stopWorker(qname) {
         const controller = this.workers.get(qname);
         if (controller) {
@@ -474,6 +526,9 @@ export class RedisQ {
             this.batchJobs.delete(qname);
         }
     }
+    /**
+     * Closes all workers and the Redis connection gracefully.
+     */
     async close() {
         this.isClosing = true;
         for (const qname of this.workers.keys()) {

package/package.json

@@ -43,5 +43,5 @@
     },
     "type": "module",
     "types": "./dist/app.d.ts",
-    "version": "1.0.2"
+    "version": "1.0.4"
 }

package/dist/app.test.d.ts

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

package/dist/app.test.js

@@ -1,427 +0,0 @@
-import { afterAll, describe, expect, test } from "bun:test";
-import { RedisQ } from "./app";
-const redisConfig = {
-    host: process.env.REDIS_HOST || "127.0.0.1",
-    namespace: "redisq-testing",
-    port: process.env.REDIS_PORT || "6379",
-};
-const workerConfig = {
-    silent: true,
-};
-/**
- * Helper to wait for a specific duration
- */
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-describe("RedisQ Tests", () => {
-    test("1. Can send and receive single message", async () => {
-        const queue = new RedisQ(redisConfig);
-        await queue.createQueue({ qname: "test-basic" });
-        const message = JSON.stringify({ id: 1, name: "John Doe" });
-        let receivedCount = 0;
-        const id = await queue.sendMessage({
-            message,
-            qname: "test-basic",
-        });
-        await new Promise((resolve) => {
-            queue.startWorker("test-basic", async (received) => {
-                expect(received.message).toEqual(message);
-                expect(received.attempt).toBe(1);
-                expect(received.id).toEqual(id);
-                receivedCount++;
-                resolve();
-                return { success: true };
-            }, workerConfig);
-        });
-        expect(receivedCount).toBe(1);
-        await queue.close();
-    });
-    test("2. Can send and receive delayed message", async () => {
-        const queue = new RedisQ(redisConfig);
-        await queue.createQueue({ qname: "test-delayed" });
-        const message = "Delayed message";
-        const delayMs = 2000;
-        let receivedCount = 0;
-        const sentAt = Date.now();
-        const id = await queue.sendMessage({
-            delay: delayMs,
-            message,
-            qname: "test-delayed",
-        });
-        await new Promise((resolve) => {
-            queue.startWorker("test-delayed", async (received) => {
-                const receivedAt = Date.now();
-                const actualDelay = receivedAt - sentAt;
-                expect(received.message).toEqual(message);
-                expect(received.id).toEqual(id);
-                expect(received.attempt).toBe(1);
-                /**
-                 * Check that message was delayed by at least the specified delay
-                 * Allow 100ms margin for processing time
-                 */
-                expect(actualDelay).toBeGreaterThanOrEqual(delayMs - 100);
-                receivedCount++;
-                resolve();
-                return { success: true };
-            }, workerConfig);
-        });
-        expect(receivedCount).toBe(1);
-        await queue.close();
-    });
-    test("3. Can retry send and receive single message", async () => {
-        const queue = new RedisQ(redisConfig);
-        await queue.createQueue({
-            maxBackoffSeconds: 1,
-            maxRetries: 3,
-            qname: "test-retry",
-        });
-        const message = "Retry me!";
-        let attemptCount = 0;
-        await queue.sendMessage({
-            message,
-            qname: "test-retry",
-        });
-        await new Promise((resolve) => {
-            queue.startWorker("test-retry", async (received) => {
-                attemptCount++;
-                expect(received.attempt).toBe(attemptCount);
-                expect(received.message).toBe(message);
-                /**
-                 * Fail first 2 attempts, succeed on 3rd
-                 */
-                if (received.attempt < 3) {
-                    return { success: false };
-                }
-                resolve();
-                return { success: true };
-            }, workerConfig);
-        });
-        expect(attemptCount).toBe(3);
-        await queue.close();
-    });
-    test("4. Can retry send and receive delayed message", async () => {
-        const queue = new RedisQ(redisConfig);
-        await queue.createQueue({
-            maxBackoffSeconds: 1,
-            maxRetries: 2,
-            qname: "test-delayed-retry",
-        });
-        const message = "Delayed retry message";
-        const delayMs = 1000;
-        let attemptCount = 0;
-        const sentAt = Date.now();
-        await queue.sendMessage({
-            delay: delayMs,
-            message,
-            qname: "test-delayed-retry",
-        });
-        await new Promise((resolve) => {
-            queue.startWorker("test-delayed-retry", async (received) => {
-                attemptCount++;
-                expect(received.attempt).toBe(attemptCount);
-                expect(received.message).toBe(message);
-                /**
-                 * First attempt should be delayed by initial delay
-                 */
-                if (attemptCount === 1) {
-                    const actualDelay = Date.now() - sentAt;
-                    expect(actualDelay).toBeGreaterThanOrEqual(delayMs - 100);
-                }
-                /**
-                 * Fail first attempt, succeed on 2nd
-                 */
-                if (received.attempt < 2) {
-                    return { success: false };
-                }
-                resolve();
-                return { success: true };
-            }, workerConfig);
-        });
-        expect(attemptCount).toBe(2);
-        await queue.close();
-    });
-    test("5. Can send and receive batched messages (multiple batches in same period)", async () => {
-        const queue = new RedisQ(redisConfig);
-        /**
-         * Create batch queue with 3-second interval
-         * This simulates a spreadsheet-queue:batch with shorter period for testing
-         */
-        await queue.createQueue({
-            every: 3,
-            maxRetries: 0,
-            qname: "spreadsheet-queue:batch",
-        });
-        /**
-         * Simulate the scenario:
-         * - 10 messages sent at different timestamps
-         * - 6 messages with batchId "batch-001"
-         * - 4 messages with batchId "batch-002"
-         * - All should be processed in the SAME 3-second period
-         */
-        const batch001Messages = [];
-        const batch002Messages = [];
-        const processedBatches = new Set();
-        let batch001Processed = false;
-        let batch002Processed = false;
-        /**
-         * Send messages FIRST, then start worker
-         * This allows all messages to be ready before the first cron cycle
-         */
-        /**
-         * Send 6 messages to batch-001
-         */
-        for (let i = 1; i <= 6; i++) {
-            const message = `Spreadsheet row ${i} for batch-001`;
-            await queue.sendBatchMessage({
-                batchId: "batch-001",
-                message,
-                qname: "spreadsheet-queue:batch",
-            });
-            batch001Messages.push(message);
-        }
-        /**
-         * Send 4 messages to batch-002
-         */
-        for (let i = 1; i <= 4; i++) {
-            const message = `Spreadsheet row ${i} for batch-002`;
-            await queue.sendBatchMessage({
-                batchId: "batch-002",
-                message,
-                qname: "spreadsheet-queue:batch",
-            });
-            batch002Messages.push(message);
-        }
-        /**
-         * Start worker AFTER sending messages
-         * This ensures all messages are already pending when the cron starts
-         */
-        const workerPromise = new Promise((resolve) => {
-            queue.startWorker("spreadsheet-queue:batch", async (received) => {
-                processedBatches.add(received.batchId);
-                if (received.batchId === "batch-001") {
-                    expect(received.messages.length).toBe(6);
-                    expect(received.attempt).toBe(1);
-                    /**
-                     * Verify all messages are present
-                     */
-                    received.messages.forEach((msg, idx) => {
-                        expect(msg.message).toBe(batch001Messages.at(idx) ?? "");
-                    });
-                    batch001Processed = true;
-                }
-                else if (received.batchId === "batch-002") {
-                    expect(received.messages.length).toBe(4);
-                    expect(received.attempt).toBe(1);
-                    received.messages.forEach((msg, idx) => {
-                        expect(msg.message).toBe(batch002Messages.at(idx) ?? "");
-                    });
-                    batch002Processed = true;
-                }
-                /**
-                 * Resolve when both batches are processed
-                 */
-                if (batch001Processed && batch002Processed) {
-                    resolve();
-                }
-                return { success: true };
-            }, workerConfig);
-        });
-        /**
-         * Wait for batches to be processed
-         * The cron job will run every 3 seconds and process all pending batches
-         * Allow up to 6 seconds for processing (2 cron cycles to be safe)
-         */
-        await Promise.race([
-            workerPromise,
-            sleep(6000).then(() => {
-                throw new Error("Test timeout: batches not processed in time");
-            }),
-        ]);
-        /**
-         * Assert both batches were processed
-         */
-        expect(processedBatches.size).toBe(2);
-        expect(batch001Processed).toBe(true);
-        expect(batch002Processed).toBe(true);
-        await queue.close();
-    });
-    test("6. Can send and receive batched messages with selective retry", async () => {
-        const queue = new RedisQ(redisConfig);
-        /**
-         * Create batch queue with 2-second interval and retry enabled
-         */
-        await queue.createQueue({
-            every: 2,
-            maxBackoffSeconds: 1,
-            maxRetries: 3,
-            qname: "retry-test:batch",
-        });
-        const processedBatches = [];
-        /**
-         * Create 3 different batches
-         */
-        for (let i = 1; i <= 3; i++) {
-            await queue.sendBatchMessage({
-                batchId: `batch-00${i}`,
-                message: `Message ${i}`,
-                qname: "retry-test:batch",
-            });
-        }
-        /**
-         * Start worker AFTER sending messages
-         */
-        const workerPromise = new Promise((resolve) => {
-            queue.startWorker("retry-test:batch", async (received) => {
-                processedBatches.push({
-                    attempt: received.attempt,
-                    batchId: received.batchId,
-                    success: false,
-                });
-                /**
-                 * Simulate batch-001 failing on first 2 attempts
-                 * batch-002 and batch-003 always succeed
-                 */
-                if (received.batchId === "batch-001") {
-                    if (received.attempt < 3) {
-                        /**
-                         * Mark as failed, will retry
-                         */
-                        const lastBatch = processedBatches.at(-1);
-                        if (lastBatch) {
-                            lastBatch.success = false;
-                        }
-                        return { success: false };
-                    }
-                    /**
-                     * 3rd attempt succeeds
-                     */
-                    expect(received.attempt).toBe(3);
-                    const lastBatch = processedBatches.at(-1);
-                    if (lastBatch) {
-                        lastBatch.success = true;
-                    }
-                }
-                else {
-                    /**
-                     * batch-002 and batch-003 succeed immediately
-                     */
-                    expect(received.attempt).toBe(1);
-                    const lastBatch = processedBatches.at(-1);
-                    if (lastBatch) {
-                        lastBatch.success = true;
-                    }
-                }
-                /**
-                 * Check if all batches are done:
-                 * - batch-001: should appear 3 times (attempt 1, 2, 3)
-                 * - batch-002: should appear 1 time (attempt 1)
-                 * - batch-003: should appear 1 time (attempt 1)
-                 * Total: 5 invocations
-                 */
-                const batch001Count = processedBatches.filter((b) => b.batchId === "batch-001").length;
-                const batch002Count = processedBatches.filter((b) => b.batchId === "batch-002").length;
-                const batch003Count = processedBatches.filter((b) => b.batchId === "batch-003").length;
-                if (batch001Count === 3 &&
-                    batch002Count === 1 &&
-                    batch003Count === 1) {
-                    resolve();
-                }
-                return { success: true };
-            }, workerConfig);
-        });
-        /**
-         * Wait for all batches to be processed (including retries)
-         * Allow up to 10 seconds (batch-001 will take multiple cycles)
-         */
-        await Promise.race([
-            workerPromise,
-            sleep(10000).then(() => {
-                throw new Error("Test timeout: batches not processed in time");
-            }),
-        ]);
-        /**
-         * Verify total handler invocations
-         */
-        expect(processedBatches.length).toBe(5);
-        /**
-         * Verify batch-001 retry behavior
-         */
-        const batch001Attempts = processedBatches.filter((b) => b.batchId === "batch-001");
-        expect(batch001Attempts.length).toBe(3);
-        const batch001Attempt1 = batch001Attempts.at(0);
-        expect(batch001Attempt1?.attempt).toBe(1);
-        expect(batch001Attempt1?.success).toBe(false);
-        const batch001Attempt2 = batch001Attempts.at(1);
-        expect(batch001Attempt2?.attempt).toBe(2);
-        expect(batch001Attempt2?.success).toBe(false);
-        const batch001Attempt3 = batch001Attempts.at(2);
-        expect(batch001Attempt3?.attempt).toBe(3);
-        expect(batch001Attempt3?.success).toBe(true);
-        /**
-         * Verify batch-002 succeeded on first attempt
-         */
-        const batch002Attempts = processedBatches.filter((b) => b.batchId === "batch-002");
-        expect(batch002Attempts.length).toBe(1);
-        const batch002Attempt1 = batch002Attempts.at(0);
-        expect(batch002Attempt1?.attempt).toBe(1);
-        expect(batch002Attempt1?.success).toBe(true);
-        /**
-         * Verify batch-003 succeeded on first attempt
-         */
-        const batch003Attempts = processedBatches.filter((b) => b.batchId === "batch-003");
-        expect(batch003Attempts.length).toBe(1);
-        const batch003Attempt1 = batch003Attempts.at(0);
-        expect(batch003Attempt1?.attempt).toBe(1);
-        expect(batch003Attempt1?.success).toBe(true);
-        /**
-         * Verify independence: batch-002 and batch-003 were not affected by batch-001 failures
-         */
-        const successfulBatches = processedBatches.filter((b) => b.success && b.attempt === 1);
-        expect(successfulBatches.length).toBe(2); // batch-002 and batch-003
-        await queue.close();
-    });
-    test("7. Can handle high volume and concurrency", async () => {
-        const totalMessages = 10_000;
-        const queue = new RedisQ(redisConfig);
-        await queue.createQueue({ qname: "test-concurrency" });
-        const processedIds = [];
-        Array.from({ length: totalMessages }, async (_, i) => {
-            await queue.sendMessage({
-                message: JSON.stringify({
-                    id: `${i}`,
-                    name: `John Doe ${i}`,
-                }),
-                qname: "test-concurrency",
-            });
-        });
-        let receivedCount = 0;
-        await new Promise((resolve) => {
-            queue.startWorker("test-concurrency", async (received) => {
-                receivedCount++;
-                processedIds.push(JSON.parse(received.message).id);
-                if (receivedCount === totalMessages) {
-                    resolve();
-                }
-                return { success: true };
-            }, workerConfig);
-        });
-        for (let i = 0; i < totalMessages; i++) {
-            expect(processedIds[i]).toBe(`${i}`);
-        }
-        expect(receivedCount).toBe(totalMessages);
-        await queue.close();
-    });
-});
-afterAll(async () => {
-    const redis = new Bun.RedisClient(`redis://${redisConfig.host}:${redisConfig.port}`);
-    let cursor = "0";
-    const pattern = `${redisConfig.namespace}:*`;
-    do {
-        const result = await redis.scan(cursor, "MATCH", pattern);
-        const [nextCursor, keys] = result;
-        cursor = nextCursor;
-        if (keys.length > 0) {
-            await redis.del(...keys);
-        }
-    } while (cursor !== "0");
-    redis.close();
-});

package/dist/benchmark/stress-worker.d.ts

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

package/dist/benchmark/stress-worker.js

@@ -1,39 +0,0 @@
-import { RedisQ } from "../app";
-self.addEventListener("message", async (event) => {
-    if (event.data.type === "start") {
-        const { messagesPerWorker, testMessage, qname, redisConfig } = event.data.data;
-        try {
-            const queue = new RedisQ(redisConfig);
-            const latencies = [];
-            const CHUNK_SIZE = 1000;
-            for (let i = 0; i < messagesPerWorker; i += CHUNK_SIZE) {
-                const promises = [];
-                const chunkEnd = Math.min(i + CHUNK_SIZE, messagesPerWorker);
-                for (let j = i; j < chunkEnd; j++) {
-                    const start = performance.now();
-                    promises.push(queue
-                        .sendMessage({
-                        message: testMessage,
-                        qname,
-                    })
-                        .then(() => {
-                        const latency = performance.now() - start;
-                        latencies.push(latency);
-                    }));
-                }
-                await Promise.all(promises);
-            }
-            await queue.close();
-            self.postMessage({
-                data: { latencies },
-                type: "result",
-            });
-        }
-        catch (error) {
-            self.postMessage({
-                data: { error: error.message },
-                type: "error",
-            });
-        }
-    }
-});

package/dist/benchmark/stress.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};

package/dist/benchmark/stress.js

@@ -1,219 +0,0 @@
-#!/usr/bin/env bun
-import { RedisQ } from "../app";
-import mediumMsg from "./medium.txt";
-import smallMsg from "./small.txt";
-import tinyMsg from "./tiny.txt";
-const COLORS = {
-    blue: "\x1b[34m",
-    bright: "\x1b[1m",
-    cyan: "\x1b[36m",
-    green: "\x1b[32m",
-    magenta: "\x1b[35m",
-    red: "\x1b[31m",
-    reset: "\x1b[0m",
-    yellow: "\x1b[33m",
-};
-const WORKER_COUNT = 8;
-const CONCURRENCY = 2;
-const MSG_COUNT = 100_000;
-function log(color, message) {
-    console.log(`${COLORS[color]}${message}${COLORS.reset}`);
-}
-function calculatePercentile(sorted, percentile) {
-    const index = Math.ceil((percentile / 100) * sorted.length) - 1;
-    return sorted[Math.max(0, index)] ?? 0;
-}
-function calculateStats(latencies) {
-    const sorted = [...latencies].sort((a, b) => a - b);
-    const sum = latencies.reduce((acc, val) => acc + val, 0);
-    return {
-        avg: sum / latencies.length,
-        latencies,
-        max: sorted[sorted.length - 1] ?? 0,
-        min: sorted[0] ?? 0,
-        p50: calculatePercentile(sorted, 50),
-        p95: calculatePercentile(sorted, 95),
-        p99: calculatePercentile(sorted, 99),
-    };
-}
-function printResults(testName, results) {
-    log("bright", `\n${"=".repeat(60)}`);
-    log("cyan", `  ${testName}`);
-    log("bright", "=".repeat(60));
-    log("green", "\n📊 Overall Performance:");
-    console.log(`  Total Messages:     ${results.totalMessages.toLocaleString()}`);
-    console.log(`  Duration:           ${results.duration.toFixed(2)}s`);
-    console.log(`  Throughput:         ${results.throughput.toFixed(2)} msg/s`);
-    log("yellow", "\n⚡ Latency Statistics (ms):");
-    console.log(`  Min:                ${results.min.toFixed(2)} ms`);
-    console.log(`  Average:            ${results.avg.toFixed(2)} ms`);
-    console.log(`  Median (p50):       ${results.p50.toFixed(2)} ms`);
-    console.log(`  p95:                ${results.p95.toFixed(2)} ms`);
-    console.log(`  p99:                ${results.p99.toFixed(2)} ms`);
-    console.log(`  Max:                ${results.max.toFixed(2)} ms`);
-}
-async function testRegularQueueParallel(config) {
-    const queue = new RedisQ({
-        host: process.env.REDIS_HOST || "127.0.0.1",
-        namespace: "stress-test",
-        port: process.env.REDIS_PORT || "6379",
-    });
-    const qname = "stress-regular";
-    await queue.createQueue({ maxRetries: 0, maxsize: 150_000, qname });
-    const allLatencies = [];
-    let receivedCount = 0;
-    const messagesPerWorker = Math.floor(config.messageCount / config.workerCount);
-    const actualMessageCount = messagesPerWorker * config.workerCount;
-    const workerPromise = new Promise((resolve) => {
-        queue.startWorker(qname, async () => {
-            receivedCount++;
-            if (receivedCount === actualMessageCount) {
-                resolve();
-            }
-            return { success: true };
-        }, { concurrency: config.concurrency, silent: true });
-    });
-    log("blue", `\n🚀 Spawning ${config.workerCount} workers to send ${actualMessageCount.toLocaleString()} messages...`);
-    const startTime = performance.now();
-    const workers = [];
-    const workerPromises = [];
-    for (let i = 0; i < config.workerCount; i++) {
-        const worker = new Worker(new URL("./stress-worker.ts", import.meta.url).href);
-        workers.push(worker);
-        const workerPromise = new Promise((resolve, reject) => {
-            worker.addEventListener("message", (event) => {
-                if (event.data.type === "result") {
-                    resolve(event.data.data?.latencies || []);
-                    worker.terminate();
-                }
-                else if (event.data.type === "error") {
-                    reject(new Error(event.data.data?.error || "Worker error"));
-                    worker.terminate();
-                }
-            });
-            worker.addEventListener("error", (error) => {
-                reject(error);
-                worker.terminate();
-            });
-            worker.postMessage({
-                data: {
-                    messagesPerWorker,
-                    qname,
-                    redisConfig: {
-                        host: process.env.REDIS_HOST || "127.0.0.1",
-                        namespace: "stress-test",
-                        port: process.env.REDIS_PORT || "6379",
-                    },
-                    testMessage: config.testMessage,
-                    workerIndex: i,
-                },
-                type: "start",
-            });
-        });
-        workerPromises.push(workerPromise);
-    }
-    const workerResults = await Promise.all(workerPromises);
-    for (const latencies of workerResults) {
-        allLatencies.push(...latencies);
-    }
-    const sendDuration = performance.now() - startTime;
-    log("green", `✓ All messages sent in ${sendDuration.toFixed(2)}ms`);
-    log("blue", "\n⏳ Waiting for all messages to be processed...");
-    await workerPromise;
-    const duration = (performance.now() - startTime) / 1000;
-    const throughput = actualMessageCount / duration;
-    await queue.close();
-    const stats = calculateStats(allLatencies);
-    return {
-        duration,
-        throughput,
-        totalMessages: actualMessageCount,
-        ...stats,
-    };
-}
-async function cleanup() {
-    log("blue", "\n🧹 Cleaning up test data...");
-    const redis = new Bun.RedisClient(`redis://${process.env.REDIS_HOST || "127.0.0.1"}:${process.env.REDIS_PORT || "6379"}`);
-    let cursor = "0";
-    const pattern = "stress-test:*";
-    let deletedCount = 0;
-    do {
-        const result = await redis.scan(cursor, "MATCH", pattern);
-        const [nextCursor, keys] = result;
-        cursor = nextCursor;
-        if (keys.length > 0) {
-            await redis.del(...keys);
-            deletedCount += keys.length;
-        }
-    } while (cursor !== "0");
-    redis.close();
-    log("green", `✓ Cleaned up ${deletedCount} keys`);
-}
-async function main() {
-    log("bright", "\n╔═══════════════════════════════════════════════════════════╗");
-    log("bright", "║           RedisQ Stress Test & Benchmark Tool             ║");
-    log("bright", "╚═══════════════════════════════════════════════════════════╝");
-    await cleanup();
-    const availableCPUs = navigator.hardwareConcurrency;
-    log("yellow", `\n💻 Detected ${availableCPUs} CPU cores`);
-    log("blue", `\n🔧 Using ${WORKER_COUNT} workers for tests`);
-    try {
-        log("cyan", "\n📋 Test 1: Tiny messages (100 bytes)");
-        const test1Results = await testRegularQueueParallel({
-            concurrency: CONCURRENCY,
-            messageCount: MSG_COUNT,
-            testMessage: tinyMsg,
-            workerCount: WORKER_COUNT,
-        });
-        printResults("Test 1: Tiny Messages (100K msgs, 100 bytes)", test1Results);
-        await cleanup();
-        log("cyan", "\n📋 Test 2: Small messages (1KB)");
-        const test2Results = await testRegularQueueParallel({
-            concurrency: CONCURRENCY,
-            messageCount: MSG_COUNT,
-            testMessage: smallMsg,
-            workerCount: WORKER_COUNT,
-        });
-        printResults("Test 2: Small Messages (100K msgs, 1KB)", test2Results);
-        await cleanup();
-        log("cyan", "\n📋 Test 3: Medium messages (10KB)");
-        const test3Results = await testRegularQueueParallel({
-            concurrency: CONCURRENCY,
-            messageCount: MSG_COUNT,
-            testMessage: mediumMsg,
-            workerCount: WORKER_COUNT,
-        });
-        printResults("Test 3: Medium Messages (100K msgs, 10KB)", test3Results);
-        await cleanup();
-        // Calculate combined averages
-        const avgThroughput = (test1Results.throughput +
-            test2Results.throughput +
-            test3Results.throughput) /
-            3;
-        const avgP50 = (test1Results.p50 + test2Results.p50 + test3Results.p50) / 3;
-        const avgP95 = (test1Results.p95 + test2Results.p95 + test3Results.p95) / 3;
-        const avgP99 = (test1Results.p99 + test2Results.p99 + test3Results.p99) / 3;
-        // Summary
-        log("bright", `\n${"=".repeat(60)}`);
-        log("magenta", "  📈 BENCHMARK SUMMARY");
-        log("bright", "=".repeat(60));
-        console.log("\n  Individual Queue Performance:");
-        console.log(`    - Tiny messages (100B):   ${test1Results.throughput.toFixed(0)} msg/s (p50: ${test1Results.p50.toFixed(2)}ms)`);
-        console.log(`    - Small messages (1KB):   ${test2Results.throughput.toFixed(0)} msg/s (p50: ${test2Results.p50.toFixed(2)}ms)`);
-        console.log(`    - Medium messages (10KB):  ${test3Results.throughput.toFixed(0)} msg/s (p50: ${test3Results.p50.toFixed(2)}ms)`);
-        log("bright", `\n${"=".repeat(60)}`);
-        log("green", "\n✅ All stress tests completed successfully!");
-        log("yellow", "\n💡 To update README.md Performance section, use these values (averaged across all tests):");
-        console.log("\n  Overall:");
-        log("cyan", `   - **Throughput**: ~${Math.round(avgThroughput).toLocaleString()} messages/second`);
-        log("cyan", `   - **Latency (p50)**: ${avgP50.toFixed(2)} ms`);
-        log("cyan", `   - **Latency (p95)**: ${avgP95.toFixed(2)} ms`);
-        log("cyan", `   - **Latency (p99)**: ${avgP99.toFixed(2)} ms`);
-    }
-    catch (error) {
-        log("red", `\n❌ Error during stress test: ${error.message}`);
-        log("red", error.stack || "");
-        process.exit(1);
-    }
-}
-main();