@prsm/queue 1.0.0

package/README.md

@@ -0,0 +1,101 @@
+# Queues
+
+You must place your queue definitions in `/queues`. For example:
+
+```bash
+src
+└── app
+    └── queues
+        ├── mailer.ts
+        └── llm-processor.ts
+```
+
+Each queue module is expected to have a default export that is an asynchronous function, which serves as the handler for each queued job. Additionally, a `queue` object must be exported that generates and configures the queue.
+
+Here's an example queue definition.
+
+```typescript
+// /src/app/queues/mail.ts
+import Queue from "@prsm/queues";
+
+interface MailPayload {
+  recipient: string;
+  subject: string;
+  body: string;
+}
+
+// The task to be executed for each queued job when a worker becomes available.
+export default async function ({ recipient, subject, body }: MailPayload) {
+  // send an email
+}
+
+export const queue = new Queue<MailPayload>({
+  // Number of concurrent queue workers.
+  concurrency: 1,
+
+  // Once a worker becomes available, it will wait delay ms before processing the next job.
+  delay: 0,
+
+  // After it is initiated, a task will fail if it does not resolve within timeout ms.
+  timeout: 0,
+
+  // Groups enable scoped queues based on a key, such as a recipient's address.
+  // This can be useful, for instance, if we want to restrict the number of emails we send to a particular
+  // recipient during a specific time period.
+  //
+  // By default, a group will inherit the queue's config above, but you can
+  // override that config here.
+  groups: {
+    concurrency: 3,
+    delay: "5s",
+    timeout: "1m"
+  },
+});
+```
+
+## Adding jobs to a queue
+
+To add a job to the queue, import the queue and call `queue.push`.
+
+```typescript
+import { queue as mailQueue } from "../queues/mail";
+mailQueue.push({ recipient, subject, body });
+```
+
+To track task status, listen for events emitted by the queue. The queue will emit events when:
+
+1. A job is added to the queue
+2. A job is completed
+3. A job fails
+
+```typescript
+// /src/app/http/mail/index.ts
+import { queue as mailQueue } from "../queues/mail";
+
+const onNew = ({ task }) => console.log("Task created:", task.uuid);
+const onFailed = ({ task }) => console.log("Task failed:", task.uuid);
+const onComplete = ({ task }) => console.log("Task complete:", task.uuid);
+
+mailQueue.on("new", onNew);
+mailQueue.on("failed", onFailed);
+mailQueue.on("complete", onComplete);
+
+// POST /mail
+export async function post(c: Context, { body: { recipient, subject, body } }) {
+  const uuid = mailQueue.push({ recipient, subject, body });
+  return Respond.OK(c, { uuid });
+}
+
+// /src/app/queues/mail.ts
+export default async function({ recipient, subject, body }) {
+  // send a very important email
+}
+```
+
+You can add a grouped queue like:
+
+```typescript
+mailQueue.group(recipient).push({ recipient, subject, body });
+```
+
+As mentioned above, this is a scoped queue. The scoped queue has its own concurrency, delay, and timeout.

package/dist/index.cjs

@@ -0,0 +1,255 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => Queue
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/queue.ts
+var import_redis = require("redis");
+var import_events = require("events");
+var import_crypto = require("crypto");
+var import_ms = __toESM(require("@prsm/ms"), 1);
+var Queue = class extends import_events.EventEmitter {
+  redis;
+  options;
+  handler;
+  workers = /* @__PURE__ */ new Map();
+  groupWorkers = /* @__PURE__ */ new Map();
+  cleanupTimer;
+  constructor(options = {}) {
+    super();
+    this.options = {
+      concurrency: options.concurrency ?? 1,
+      delay: (0, import_ms.default)(options.delay ?? 0),
+      timeout: (0, import_ms.default)(options.timeout ?? 0),
+      maxRetries: options.maxRetries ?? 3,
+      groups: {
+        concurrency: options.groups?.concurrency ?? options.concurrency ?? 1,
+        delay: (0, import_ms.default)(options.groups?.delay ?? options.delay ?? 0),
+        timeout: (0, import_ms.default)(options.groups?.timeout ?? options.timeout ?? 0),
+        maxRetries: options.groups?.maxRetries ?? options.maxRetries ?? 3
+      },
+      redisOptions: options.redisOptions ?? {},
+      cleanupInterval: options.cleanupInterval ?? 3e4
+    };
+    this.redis = (0, import_redis.createClient)(this.options.redisOptions);
+    this.redis.on("error", () => {
+    });
+    this.initializeRedis();
+  }
+  process(handler) {
+    this.handler = handler;
+  }
+  async push(payload) {
+    const task = {
+      uuid: (0, import_crypto.randomUUID)(),
+      payload,
+      createdAt: Date.now(),
+      attempts: 0
+    };
+    await this.redis.lPush("queue:tasks", JSON.stringify(task));
+    this.emit("new", { task });
+    return task.uuid;
+  }
+  group(key) {
+    return {
+      push: async (payload) => {
+        const task = {
+          uuid: (0, import_crypto.randomUUID)(),
+          payload,
+          createdAt: Date.now(),
+          groupKey: key,
+          attempts: 0
+        };
+        await this.redis.lPush(`queue:groups:${key}`, JSON.stringify(task));
+        this.emit("new", { task });
+        if (!this.groupWorkers.has(key)) {
+          this.groupWorkers.set(key, /* @__PURE__ */ new Map());
+          await this.startGroupWorkers(key);
+          await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        return task.uuid;
+      }
+    };
+  }
+  async startWorkers() {
+    for (let i = 0; i < this.options.concurrency; i++) {
+      this.startWorker(`worker-${i}`);
+    }
+  }
+  async startGroupWorkers(groupKey) {
+    const groupWorkers = this.groupWorkers.get(groupKey);
+    for (let i = 0; i < this.options.groups.concurrency; i++) {
+      const workerId = `group-${groupKey}-worker-${i}`;
+      groupWorkers.set(workerId, true);
+      this.startGroupWorker(workerId, groupKey);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  async startWorker(workerId) {
+    this.workers.set(workerId, true);
+    while (this.workers.get(workerId)) {
+      try {
+        if (!this.redis.isOpen) {
+          break;
+        }
+        const taskData = await this.redis.brPop("queue:tasks", 1);
+        if (taskData) {
+          const task = JSON.parse(taskData.element);
+          await this.processTask(task);
+        }
+        if (this.options.delay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, this.options.delay));
+        }
+      } catch (err) {
+        const error = err;
+        if (error.message?.includes("closed") || error.message?.includes("ClientClosedError")) {
+          break;
+        }
+      }
+    }
+  }
+  async startGroupWorker(workerId, groupKey) {
+    const groupWorkers = this.groupWorkers.get(groupKey);
+    while (groupWorkers.get(workerId)) {
+      try {
+        if (!this.redis.isOpen) {
+          break;
+        }
+        const taskData = await this.redis.brPop(`queue:groups:${groupKey}`, 1);
+        if (taskData) {
+          const task = JSON.parse(taskData.element);
+          await this.processGroupTask(task);
+        }
+        if (this.options.groups.delay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, this.options.groups.delay));
+        }
+      } catch (err) {
+        const error = err;
+        if (error.message?.includes("closed") || error.message?.includes("ClientClosedError")) {
+          break;
+        }
+      }
+    }
+  }
+  async processTask(task) {
+    task.attempts++;
+    try {
+      if (!this.handler) {
+        this.emit("complete", { task, result: void 0 });
+        return;
+      }
+      const timeoutPromise = this.options.timeout > 0 ? new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Task timeout")), this.options.timeout)
+      ) : null;
+      const workPromise = Promise.resolve(this.handler(task.payload, task));
+      const result = timeoutPromise ? await Promise.race([workPromise, timeoutPromise]) : await workPromise;
+      this.emit("complete", { task, result });
+    } catch (error) {
+      if (task.attempts < this.options.maxRetries) {
+        this.emit("retry", { task, error, attempt: task.attempts });
+        await this.redis.lPush("queue:tasks", JSON.stringify(task));
+      } else {
+        this.emit("failed", { task, error });
+      }
+    }
+  }
+  async processGroupTask(task) {
+    task.attempts++;
+    try {
+      if (!this.handler) {
+        this.emit("complete", { task, result: void 0 });
+        return;
+      }
+      const timeoutPromise = this.options.groups.timeout > 0 ? new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Task timeout")), this.options.groups.timeout)
+      ) : null;
+      const workPromise = Promise.resolve(this.handler(task.payload, task));
+      const result = timeoutPromise ? await Promise.race([workPromise, timeoutPromise]) : await workPromise;
+      this.emit("complete", { task, result });
+    } catch (error) {
+      if (task.attempts < this.options.groups.maxRetries) {
+        this.emit("retry", { task, error, attempt: task.attempts });
+        await this.redis.lPush(`queue:groups:${task.groupKey}`, JSON.stringify(task));
+      } else {
+        this.emit("failed", { task, error });
+      }
+    }
+  }
+  async initializeRedis() {
+    await this.redis.connect();
+    this.startWorkers();
+    if (this.options.cleanupInterval > 0) {
+      this.cleanupTimer = setInterval(() => {
+        this.performPeriodicCleanup();
+      }, this.options.cleanupInterval);
+    }
+  }
+  async performPeriodicCleanup() {
+    try {
+      if (!this.redis.isOpen) {
+        return;
+      }
+      const groupKeys = Array.from(this.groupWorkers.keys());
+      for (const groupKey of groupKeys) {
+        const length = await this.redis.lLen(`queue:groups:${groupKey}`);
+        if (length === 0) {
+          const keyExists = await this.redis.exists(`queue:groups:${groupKey}`);
+          if (keyExists) {
+            await this.redis.del(`queue:groups:${groupKey}`);
+          }
+          const groupWorkers = this.groupWorkers.get(groupKey);
+          if (groupWorkers) {
+            groupWorkers.clear();
+            this.groupWorkers.delete(groupKey);
+          }
+        }
+      }
+    } catch (error) {
+    }
+  }
+  async close() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+    }
+    this.workers.clear();
+    for (const groupWorkers of this.groupWorkers.values()) {
+      groupWorkers.clear();
+    }
+    this.groupWorkers.clear();
+    if (this.redis.isOpen) {
+      await this.redis.quit();
+    }
+  }
+};
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/queue.ts"],"sourcesContent":["export { default } from './queue.js'\nexport type { QueueOptions, Task, TaskHandler } from './queue.js'\n","import { createClient, RedisClientType } from 'redis'\nimport { EventEmitter } from 'events'\nimport { randomUUID } from 'crypto'\nimport ms from '@prsm/ms'\n\nexport interface QueueOptions<T = any> {\n  concurrency?: number\n  delay?: number | string\n  timeout?: number | string\n  maxRetries?: number\n  groups?: {\n    concurrency?: number\n    delay?: number | string\n    timeout?: number | string\n    maxRetries?: number\n  }\n  redisOptions?: {\n    url?: string\n    host?: string\n    port?: number\n    password?: string\n  }\n  cleanupInterval?: number\n}\n\nexport type TaskHandler<T, R = any> = (payload: T, task: Task<T>) => Promise<R> | R\n\nexport interface Task<T = any> {\n  uuid: string\n  payload: T\n  createdAt: number\n  groupKey?: string\n  attempts: number\n}\n\n\nexport default class Queue<T = any, R = any> extends EventEmitter {\n  private redis: RedisClientType\n  private options: {\n    concurrency: number\n    delay: number\n    timeout: number\n    maxRetries: number\n    groups: {\n      concurrency: number\n      delay: number\n      timeout: number\n      maxRetries: number\n    }\n    redisOptions: object\n    cleanupInterval: number\n  }\n  private handler?: TaskHandler<T, R>\n  private workers = new Map<string, boolean>()\n  private groupWorkers = new Map<string, Map<string, boolean>>()\n  private cleanupTimer?: NodeJS.Timeout\n\n  constructor(options: QueueOptions<T> = {}) {\n    super()\n\n    this.options = {\n      concurrency: options.concurrency ?? 1,\n      delay: ms(options.delay ?? 0),\n      timeout: ms(options.timeout ?? 0),\n      maxRetries: options.maxRetries ?? 3,\n      groups: {\n        concurrency: options.groups?.concurrency ?? options.concurrency ?? 1,\n        delay: ms(options.groups?.delay ?? options.delay ?? 0),\n        timeout: ms(options.groups?.timeout ?? options.timeout ?? 0),\n        maxRetries: options.groups?.maxRetries ?? options.maxRetries ?? 3\n      },\n      redisOptions: options.redisOptions ?? {},\n      cleanupInterval: options.cleanupInterval ?? 30000\n    }\n\n    this.redis = createClient(this.options.redisOptions)\n    this.redis.on('error', () => {})\n    this.initializeRedis()\n  }\n\n  process(handler: TaskHandler<T, R>) {\n    this.handler = handler\n  }\n\n  async push(payload: T): Promise<string> {\n    const task: Task<T> = {\n      uuid: randomUUID(),\n      payload,\n      createdAt: Date.now(),\n      attempts: 0\n    }\n\n    await this.redis.lPush('queue:tasks', JSON.stringify(task))\n    this.emit('new', { task })\n\n    return task.uuid\n  }\n\n  group(key: string) {\n    return {\n      push: async (payload: T): Promise<string> => {\n        const task: Task<T> = {\n          uuid: randomUUID(),\n          payload,\n          createdAt: Date.now(),\n          groupKey: key,\n          attempts: 0\n        }\n\n        await this.redis.lPush(`queue:groups:${key}`, JSON.stringify(task))\n        this.emit('new', { task })\n\n        if (!this.groupWorkers.has(key)) {\n          this.groupWorkers.set(key, new Map())\n          await this.startGroupWorkers(key)\n          await new Promise(resolve => setTimeout(resolve, 50))\n        }\n\n        return task.uuid\n      }\n    }\n  }\n\n  private async startWorkers() {\n    for (let i = 0; i < this.options.concurrency; i++) {\n      this.startWorker(`worker-${i}`)\n    }\n  }\n\n  private async startGroupWorkers(groupKey: string) {\n    const groupWorkers = this.groupWorkers.get(groupKey)!\n    for (let i = 0; i < this.options.groups.concurrency; i++) {\n      const workerId = `group-${groupKey}-worker-${i}`\n      groupWorkers.set(workerId, true)\n      this.startGroupWorker(workerId, groupKey)\n    }\n    // give workers more time to start and be ready\n    await new Promise(resolve => setTimeout(resolve, 100))\n  }\n\n  private async startWorker(workerId: string) {\n    this.workers.set(workerId, true)\n\n    while (this.workers.get(workerId)) {\n      try {\n        if (!this.redis.isOpen) {\n          break\n        }\n\n        const taskData = await this.redis.brPop('queue:tasks', 1)\n\n        if (taskData) {\n          const task: Task<T> = JSON.parse(taskData.element)\n          await this.processTask(task)\n        }\n\n        if (this.options.delay > 0) {\n          await new Promise(resolve => setTimeout(resolve, this.options.delay))\n        }\n      } catch (err) {\n        const error = err as Error\n        if (error.message?.includes('closed') || error.message?.includes('ClientClosedError')) {\n          break\n        }\n      }\n    }\n  }\n\n  private async startGroupWorker(workerId: string, groupKey: string) {\n    const groupWorkers = this.groupWorkers.get(groupKey)!\n\n    while (groupWorkers.get(workerId)) {\n      try {\n        if (!this.redis.isOpen) {\n          break\n        }\n\n        const taskData = await this.redis.brPop(`queue:groups:${groupKey}`, 1)\n\n        if (taskData) {\n          const task: Task<T> = JSON.parse(taskData.element)\n          await this.processGroupTask(task)\n        }\n\n        if (this.options.groups.delay > 0) {\n          await new Promise(resolve => setTimeout(resolve, this.options.groups.delay))\n        }\n      } catch (err) {\n        const error = err as Error\n        if (error.message?.includes('closed') || error.message?.includes('ClientClosedError')) {\n          break\n        }\n      }\n    }\n  }\n\n  private async processTask(task: Task<T>) {\n    task.attempts++\n\n    try {\n      if (!this.handler) {\n        this.emit('complete', { task, result: undefined })\n        return\n      }\n\n      const timeoutPromise = this.options.timeout > 0\n        ? new Promise<never>((_, reject) =>\n            setTimeout(() => reject(new Error('Task timeout')), this.options.timeout)\n          )\n        : null\n\n      const workPromise = Promise.resolve(this.handler(task.payload, task))\n\n      const result = timeoutPromise\n        ? await Promise.race([workPromise, timeoutPromise])\n        : await workPromise\n\n      this.emit('complete', { task, result })\n    } catch (error) {\n      if (task.attempts < this.options.maxRetries) {\n        this.emit('retry', { task, error, attempt: task.attempts })\n        await this.redis.lPush('queue:tasks', JSON.stringify(task))\n      } else {\n        this.emit('failed', { task, error })\n      }\n    }\n  }\n\n  private async processGroupTask(task: Task<T>) {\n    task.attempts++\n\n    try {\n      if (!this.handler) {\n        this.emit('complete', { task, result: undefined })\n        return\n      }\n\n      const timeoutPromise = this.options.groups.timeout > 0\n        ? new Promise<never>((_, reject) =>\n            setTimeout(() => reject(new Error('Task timeout')), this.options.groups.timeout)\n          )\n        : null\n\n      const workPromise = Promise.resolve(this.handler(task.payload, task))\n\n      const result = timeoutPromise\n        ? await Promise.race([workPromise, timeoutPromise])\n        : await workPromise\n\n      this.emit('complete', { task, result })\n    } catch (error) {\n      if (task.attempts < this.options.groups.maxRetries) {\n        this.emit('retry', { task, error, attempt: task.attempts })\n        await this.redis.lPush(`queue:groups:${task.groupKey}`, JSON.stringify(task))\n      } else {\n        this.emit('failed', { task, error })\n      }\n    }\n  }\n\n  private async initializeRedis() {\n    await this.redis.connect()\n    this.startWorkers()\n\n    // start periodic cleanup after redis is connected\n    if (this.options.cleanupInterval > 0) {\n      this.cleanupTimer = setInterval(() => {\n        this.performPeriodicCleanup()\n      }, this.options.cleanupInterval)\n    }\n  }\n\n  private async performPeriodicCleanup() {\n    try {\n      if (!this.redis.isOpen) {\n        return\n      }\n\n      const groupKeys = Array.from(this.groupWorkers.keys())\n\n      for (const groupKey of groupKeys) {\n        const length = await this.redis.lLen(`queue:groups:${groupKey}`)\n\n        if (length === 0) {\n          const keyExists = await this.redis.exists(`queue:groups:${groupKey}`)\n          if (keyExists) {\n            await this.redis.del(`queue:groups:${groupKey}`)\n          }\n\n          const groupWorkers = this.groupWorkers.get(groupKey)\n          if (groupWorkers) {\n            groupWorkers.clear()\n            this.groupWorkers.delete(groupKey)\n          }\n        }\n      }\n    } catch (error) {\n      // cleanup error handled silently\n    }\n  }\n\n  async close() {\n    if (this.cleanupTimer) {\n      clearInterval(this.cleanupTimer)\n    }\n    this.workers.clear()\n    for (const groupWorkers of this.groupWorkers.values()) {\n      groupWorkers.clear()\n    }\n    this.groupWorkers.clear()\n\n    if (this.redis.isOpen) {\n      await this.redis.quit()\n    }\n  }\n}\n"],"mappings":"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","names":["ms"]}

package/dist/index.d.cts

@@ -0,0 +1,54 @@
+import { EventEmitter } from 'events';
+
+interface QueueOptions<T = any> {
+    concurrency?: number;
+    delay?: number | string;
+    timeout?: number | string;
+    maxRetries?: number;
+    groups?: {
+        concurrency?: number;
+        delay?: number | string;
+        timeout?: number | string;
+        maxRetries?: number;
+    };
+    redisOptions?: {
+        url?: string;
+        host?: string;
+        port?: number;
+        password?: string;
+    };
+    cleanupInterval?: number;
+}
+type TaskHandler<T, R = any> = (payload: T, task: Task<T>) => Promise<R> | R;
+interface Task<T = any> {
+    uuid: string;
+    payload: T;
+    createdAt: number;
+    groupKey?: string;
+    attempts: number;
+}
+declare class Queue<T = any, R = any> extends EventEmitter {
+    private redis;
+    private options;
+    private handler?;
+    private workers;
+    private groupWorkers;
+    private cleanupTimer?;
+    constructor(options?: QueueOptions<T>);
+    process(handler: TaskHandler<T, R>): void;
+    push(payload: T): Promise<string>;
+    group(key: string): {
+        push: (payload: T) => Promise<string>;
+    };
+    private startWorkers;
+    private startGroupWorkers;
+    private startWorker;
+    private startGroupWorker;
+    private processTask;
+    private processGroupTask;
+    private initializeRedis;
+    private performPeriodicCleanup;
+    close(): Promise<void>;
+}
+
+export { type QueueOptions, type Task, type TaskHandler, Queue as default };

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { EventEmitter } from 'events';
+
+interface QueueOptions<T = any> {
+    concurrency?: number;
+    delay?: number | string;
+    timeout?: number | string;
+    maxRetries?: number;
+    groups?: {
+        concurrency?: number;
+        delay?: number | string;
+        timeout?: number | string;
+        maxRetries?: number;
+    };
+    redisOptions?: {
+        url?: string;
+        host?: string;
+        port?: number;
+        password?: string;
+    };
+    cleanupInterval?: number;
+}
+type TaskHandler<T, R = any> = (payload: T, task: Task<T>) => Promise<R> | R;
+interface Task<T = any> {
+    uuid: string;
+    payload: T;
+    createdAt: number;
+    groupKey?: string;
+    attempts: number;
+}
+declare class Queue<T = any, R = any> extends EventEmitter {
+    private redis;
+    private options;
+    private handler?;
+    private workers;
+    private groupWorkers;
+    private cleanupTimer?;
+    constructor(options?: QueueOptions<T>);
+    process(handler: TaskHandler<T, R>): void;
+    push(payload: T): Promise<string>;
+    group(key: string): {
+        push: (payload: T) => Promise<string>;
+    };
+    private startWorkers;
+    private startGroupWorkers;
+    private startWorker;
+    private startGroupWorker;
+    private processTask;
+    private processGroupTask;
+    private initializeRedis;
+    private performPeriodicCleanup;
+    close(): Promise<void>;
+}
+
+export { type QueueOptions, type Task, type TaskHandler, Queue as default };

package/dist/index.js

@@ -0,0 +1,222 @@
+// src/queue.ts
+import { createClient } from "redis";
+import { EventEmitter } from "events";
+import { randomUUID } from "crypto";
+import ms from "@prsm/ms";
+var Queue = class extends EventEmitter {
+  redis;
+  options;
+  handler;
+  workers = /* @__PURE__ */ new Map();
+  groupWorkers = /* @__PURE__ */ new Map();
+  cleanupTimer;
+  constructor(options = {}) {
+    super();
+    this.options = {
+      concurrency: options.concurrency ?? 1,
+      delay: ms(options.delay ?? 0),
+      timeout: ms(options.timeout ?? 0),
+      maxRetries: options.maxRetries ?? 3,
+      groups: {
+        concurrency: options.groups?.concurrency ?? options.concurrency ?? 1,
+        delay: ms(options.groups?.delay ?? options.delay ?? 0),
+        timeout: ms(options.groups?.timeout ?? options.timeout ?? 0),
+        maxRetries: options.groups?.maxRetries ?? options.maxRetries ?? 3
+      },
+      redisOptions: options.redisOptions ?? {},
+      cleanupInterval: options.cleanupInterval ?? 3e4
+    };
+    this.redis = createClient(this.options.redisOptions);
+    this.redis.on("error", () => {
+    });
+    this.initializeRedis();
+  }
+  process(handler) {
+    this.handler = handler;
+  }
+  async push(payload) {
+    const task = {
+      uuid: randomUUID(),
+      payload,
+      createdAt: Date.now(),
+      attempts: 0
+    };
+    await this.redis.lPush("queue:tasks", JSON.stringify(task));
+    this.emit("new", { task });
+    return task.uuid;
+  }
+  group(key) {
+    return {
+      push: async (payload) => {
+        const task = {
+          uuid: randomUUID(),
+          payload,
+          createdAt: Date.now(),
+          groupKey: key,
+          attempts: 0
+        };
+        await this.redis.lPush(`queue:groups:${key}`, JSON.stringify(task));
+        this.emit("new", { task });
+        if (!this.groupWorkers.has(key)) {
+          this.groupWorkers.set(key, /* @__PURE__ */ new Map());
+          await this.startGroupWorkers(key);
+          await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        return task.uuid;
+      }
+    };
+  }
+  async startWorkers() {
+    for (let i = 0; i < this.options.concurrency; i++) {
+      this.startWorker(`worker-${i}`);
+    }
+  }
+  async startGroupWorkers(groupKey) {
+    const groupWorkers = this.groupWorkers.get(groupKey);
+    for (let i = 0; i < this.options.groups.concurrency; i++) {
+      const workerId = `group-${groupKey}-worker-${i}`;
+      groupWorkers.set(workerId, true);
+      this.startGroupWorker(workerId, groupKey);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  async startWorker(workerId) {
+    this.workers.set(workerId, true);
+    while (this.workers.get(workerId)) {
+      try {
+        if (!this.redis.isOpen) {
+          break;
+        }
+        const taskData = await this.redis.brPop("queue:tasks", 1);
+        if (taskData) {
+          const task = JSON.parse(taskData.element);
+          await this.processTask(task);
+        }
+        if (this.options.delay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, this.options.delay));
+        }
+      } catch (err) {
+        const error = err;
+        if (error.message?.includes("closed") || error.message?.includes("ClientClosedError")) {
+          break;
+        }
+      }
+    }
+  }
+  async startGroupWorker(workerId, groupKey) {
+    const groupWorkers = this.groupWorkers.get(groupKey);
+    while (groupWorkers.get(workerId)) {
+      try {
+        if (!this.redis.isOpen) {
+          break;
+        }
+        const taskData = await this.redis.brPop(`queue:groups:${groupKey}`, 1);
+        if (taskData) {
+          const task = JSON.parse(taskData.element);
+          await this.processGroupTask(task);
+        }
+        if (this.options.groups.delay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, this.options.groups.delay));
+        }
+      } catch (err) {
+        const error = err;
+        if (error.message?.includes("closed") || error.message?.includes("ClientClosedError")) {
+          break;
+        }
+      }
+    }
+  }
+  async processTask(task) {
+    task.attempts++;
+    try {
+      if (!this.handler) {
+        this.emit("complete", { task, result: void 0 });
+        return;
+      }
+      const timeoutPromise = this.options.timeout > 0 ? new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Task timeout")), this.options.timeout)
+      ) : null;
+      const workPromise = Promise.resolve(this.handler(task.payload, task));
+      const result = timeoutPromise ? await Promise.race([workPromise, timeoutPromise]) : await workPromise;
+      this.emit("complete", { task, result });
+    } catch (error) {
+      if (task.attempts < this.options.maxRetries) {
+        this.emit("retry", { task, error, attempt: task.attempts });
+        await this.redis.lPush("queue:tasks", JSON.stringify(task));
+      } else {
+        this.emit("failed", { task, error });
+      }
+    }
+  }
+  async processGroupTask(task) {
+    task.attempts++;
+    try {
+      if (!this.handler) {
+        this.emit("complete", { task, result: void 0 });
+        return;
+      }
+      const timeoutPromise = this.options.groups.timeout > 0 ? new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Task timeout")), this.options.groups.timeout)
+      ) : null;
+      const workPromise = Promise.resolve(this.handler(task.payload, task));
+      const result = timeoutPromise ? await Promise.race([workPromise, timeoutPromise]) : await workPromise;
+      this.emit("complete", { task, result });
+    } catch (error) {
+      if (task.attempts < this.options.groups.maxRetries) {
+        this.emit("retry", { task, error, attempt: task.attempts });
+        await this.redis.lPush(`queue:groups:${task.groupKey}`, JSON.stringify(task));
+      } else {
+        this.emit("failed", { task, error });
+      }
+    }
+  }
+  async initializeRedis() {
+    await this.redis.connect();
+    this.startWorkers();
+    if (this.options.cleanupInterval > 0) {
+      this.cleanupTimer = setInterval(() => {
+        this.performPeriodicCleanup();
+      }, this.options.cleanupInterval);
+    }
+  }
+  async performPeriodicCleanup() {
+    try {
+      if (!this.redis.isOpen) {
+        return;
+      }
+      const groupKeys = Array.from(this.groupWorkers.keys());
+      for (const groupKey of groupKeys) {
+        const length = await this.redis.lLen(`queue:groups:${groupKey}`);
+        if (length === 0) {
+          const keyExists = await this.redis.exists(`queue:groups:${groupKey}`);
+          if (keyExists) {
+            await this.redis.del(`queue:groups:${groupKey}`);
+          }
+          const groupWorkers = this.groupWorkers.get(groupKey);
+          if (groupWorkers) {
+            groupWorkers.clear();
+            this.groupWorkers.delete(groupKey);
+          }
+        }
+      }
+    } catch (error) {
+    }
+  }
+  async close() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+    }
+    this.workers.clear();
+    for (const groupWorkers of this.groupWorkers.values()) {
+      groupWorkers.clear();
+    }
+    this.groupWorkers.clear();
+    if (this.redis.isOpen) {
+      await this.redis.quit();
+    }
+  }
+};
+export {
+  Queue as default
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/queue.ts"],"sourcesContent":["import { createClient, RedisClientType } from 'redis'\nimport { EventEmitter } from 'events'\nimport { randomUUID } from 'crypto'\nimport ms from '@prsm/ms'\n\nexport interface QueueOptions<T = any> {\n  concurrency?: number\n  delay?: number | string\n  timeout?: number | string\n  maxRetries?: number\n  groups?: {\n    concurrency?: number\n    delay?: number | string\n    timeout?: number | string\n    maxRetries?: number\n  }\n  redisOptions?: {\n    url?: string\n    host?: string\n    port?: number\n    password?: string\n  }\n  cleanupInterval?: number\n}\n\nexport type TaskHandler<T, R = any> = (payload: T, task: Task<T>) => Promise<R> | R\n\nexport interface Task<T = any> {\n  uuid: string\n  payload: T\n  createdAt: number\n  groupKey?: string\n  attempts: number\n}\n\n\nexport default class Queue<T = any, R = any> extends EventEmitter {\n  private redis: RedisClientType\n  private options: {\n    concurrency: number\n    delay: number\n    timeout: number\n    maxRetries: number\n    groups: {\n      concurrency: number\n      delay: number\n      timeout: number\n      maxRetries: number\n    }\n    redisOptions: object\n    cleanupInterval: number\n  }\n  private handler?: TaskHandler<T, R>\n  private workers = new Map<string, boolean>()\n  private groupWorkers = new Map<string, Map<string, boolean>>()\n  private cleanupTimer?: NodeJS.Timeout\n\n  constructor(options: QueueOptions<T> = {}) {\n    super()\n\n    this.options = {\n      concurrency: options.concurrency ?? 1,\n      delay: ms(options.delay ?? 0),\n      timeout: ms(options.timeout ?? 0),\n      maxRetries: options.maxRetries ?? 3,\n      groups: {\n        concurrency: options.groups?.concurrency ?? options.concurrency ?? 1,\n        delay: ms(options.groups?.delay ?? options.delay ?? 0),\n        timeout: ms(options.groups?.timeout ?? options.timeout ?? 0),\n        maxRetries: options.groups?.maxRetries ?? options.maxRetries ?? 3\n      },\n      redisOptions: options.redisOptions ?? {},\n      cleanupInterval: options.cleanupInterval ?? 30000\n    }\n\n    this.redis = createClient(this.options.redisOptions)\n    this.redis.on('error', () => {})\n    this.initializeRedis()\n  }\n\n  process(handler: TaskHandler<T, R>) {\n    this.handler = handler\n  }\n\n  async push(payload: T): Promise<string> {\n    const task: Task<T> = {\n      uuid: randomUUID(),\n      payload,\n      createdAt: Date.now(),\n      attempts: 0\n    }\n\n    await this.redis.lPush('queue:tasks', JSON.stringify(task))\n    this.emit('new', { task })\n\n    return task.uuid\n  }\n\n  group(key: string) {\n    return {\n      push: async (payload: T): Promise<string> => {\n        const task: Task<T> = {\n          uuid: randomUUID(),\n          payload,\n          createdAt: Date.now(),\n          groupKey: key,\n          attempts: 0\n        }\n\n        await this.redis.lPush(`queue:groups:${key}`, JSON.stringify(task))\n        this.emit('new', { task })\n\n        if (!this.groupWorkers.has(key)) {\n          this.groupWorkers.set(key, new Map())\n          await this.startGroupWorkers(key)\n          await new Promise(resolve => setTimeout(resolve, 50))\n        }\n\n        return task.uuid\n      }\n    }\n  }\n\n  private async startWorkers() {\n    for (let i = 0; i < this.options.concurrency; i++) {\n      this.startWorker(`worker-${i}`)\n    }\n  }\n\n  private async startGroupWorkers(groupKey: string) {\n    const groupWorkers = this.groupWorkers.get(groupKey)!\n    for (let i = 0; i < this.options.groups.concurrency; i++) {\n      const workerId = `group-${groupKey}-worker-${i}`\n      groupWorkers.set(workerId, true)\n      this.startGroupWorker(workerId, groupKey)\n    }\n    // give workers more time to start and be ready\n    await new Promise(resolve => setTimeout(resolve, 100))\n  }\n\n  private async startWorker(workerId: string) {\n    this.workers.set(workerId, true)\n\n    while (this.workers.get(workerId)) {\n      try {\n        if (!this.redis.isOpen) {\n          break\n        }\n\n        const taskData = await this.redis.brPop('queue:tasks', 1)\n\n        if (taskData) {\n          const task: Task<T> = JSON.parse(taskData.element)\n          await this.processTask(task)\n        }\n\n        if (this.options.delay > 0) {\n          await new Promise(resolve => setTimeout(resolve, this.options.delay))\n        }\n      } catch (err) {\n        const error = err as Error\n        if (error.message?.includes('closed') || error.message?.includes('ClientClosedError')) {\n          break\n        }\n      }\n    }\n  }\n\n  private async startGroupWorker(workerId: string, groupKey: string) {\n    const groupWorkers = this.groupWorkers.get(groupKey)!\n\n    while (groupWorkers.get(workerId)) {\n      try {\n        if (!this.redis.isOpen) {\n          break\n        }\n\n        const taskData = await this.redis.brPop(`queue:groups:${groupKey}`, 1)\n\n        if (taskData) {\n          const task: Task<T> = JSON.parse(taskData.element)\n          await this.processGroupTask(task)\n        }\n\n        if (this.options.groups.delay > 0) {\n          await new Promise(resolve => setTimeout(resolve, this.options.groups.delay))\n        }\n      } catch (err) {\n        const error = err as Error\n        if (error.message?.includes('closed') || error.message?.includes('ClientClosedError')) {\n          break\n        }\n      }\n    }\n  }\n\n  private async processTask(task: Task<T>) {\n    task.attempts++\n\n    try {\n      if (!this.handler) {\n        this.emit('complete', { task, result: undefined })\n        return\n      }\n\n      const timeoutPromise = this.options.timeout > 0\n        ? new Promise<never>((_, reject) =>\n            setTimeout(() => reject(new Error('Task timeout')), this.options.timeout)\n          )\n        : null\n\n      const workPromise = Promise.resolve(this.handler(task.payload, task))\n\n      const result = timeoutPromise\n        ? await Promise.race([workPromise, timeoutPromise])\n        : await workPromise\n\n      this.emit('complete', { task, result })\n    } catch (error) {\n      if (task.attempts < this.options.maxRetries) {\n        this.emit('retry', { task, error, attempt: task.attempts })\n        await this.redis.lPush('queue:tasks', JSON.stringify(task))\n      } else {\n        this.emit('failed', { task, error })\n      }\n    }\n  }\n\n  private async processGroupTask(task: Task<T>) {\n    task.attempts++\n\n    try {\n      if (!this.handler) {\n        this.emit('complete', { task, result: undefined })\n        return\n      }\n\n      const timeoutPromise = this.options.groups.timeout > 0\n        ? new Promise<never>((_, reject) =>\n            setTimeout(() => reject(new Error('Task timeout')), this.options.groups.timeout)\n          )\n        : null\n\n      const workPromise = Promise.resolve(this.handler(task.payload, task))\n\n      const result = timeoutPromise\n        ? await Promise.race([workPromise, timeoutPromise])\n        : await workPromise\n\n      this.emit('complete', { task, result })\n    } catch (error) {\n      if (task.attempts < this.options.groups.maxRetries) {\n        this.emit('retry', { task, error, attempt: task.attempts })\n        await this.redis.lPush(`queue:groups:${task.groupKey}`, JSON.stringify(task))\n      } else {\n        this.emit('failed', { task, error })\n      }\n    }\n  }\n\n  private async initializeRedis() {\n    await this.redis.connect()\n    this.startWorkers()\n\n    // start periodic cleanup after redis is connected\n    if (this.options.cleanupInterval > 0) {\n      this.cleanupTimer = setInterval(() => {\n        this.performPeriodicCleanup()\n      }, this.options.cleanupInterval)\n    }\n  }\n\n  private async performPeriodicCleanup() {\n    try {\n      if (!this.redis.isOpen) {\n        return\n      }\n\n      const groupKeys = Array.from(this.groupWorkers.keys())\n\n      for (const groupKey of groupKeys) {\n        const length = await this.redis.lLen(`queue:groups:${groupKey}`)\n\n        if (length === 0) {\n          const keyExists = await this.redis.exists(`queue:groups:${groupKey}`)\n          if (keyExists) {\n            await this.redis.del(`queue:groups:${groupKey}`)\n          }\n\n          const groupWorkers = this.groupWorkers.get(groupKey)\n          if (groupWorkers) {\n            groupWorkers.clear()\n            this.groupWorkers.delete(groupKey)\n          }\n        }\n      }\n    } catch (error) {\n      // cleanup error handled silently\n    }\n  }\n\n  async close() {\n    if (this.cleanupTimer) {\n      clearInterval(this.cleanupTimer)\n    }\n    this.workers.clear()\n    for (const groupWorkers of this.groupWorkers.values()) {\n      groupWorkers.clear()\n    }\n    this.groupWorkers.clear()\n\n    if (this.redis.isOpen) {\n      await this.redis.quit()\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@prsm/queue",
+  "version": "1.0.0",
+  "description": "Redis-backed distributed task queue with grouped concurrency, retries, and rate limiting",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "queue",
+    "redis",
+    "distributed",
+    "task",
+    "job",
+    "worker",
+    "rate-limit",
+    "concurrency",
+    "retry"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@prsm/ms": "^1.0.1",
+    "redis": "^5.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.29",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.4"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}