@prsm/queue 3.0.0 → 3.0.1

package/README.md

@@ -147,7 +147,7 @@ queue.on('drain', () => {})
   uuid: string,
   payload: any,
   createdAt: number,
-  groupKey?: string,  // present when pushed with { group }
+  group?: string,     // present when pushed with { group }
   attempts: number
 }
 ```
@@ -178,15 +178,15 @@ Each tenant gets up to 2 concurrent LLM calls with a 50ms pause between them. To
 
 ## WebSocket Integration with [mesh](https://github.com/nvms/mesh)
 
-Queue events are local-only - only the server that processes a task emits `complete`/`failed`. Use [mesh](https://github.com/nvms/mesh) to push results to connected clients in real time.
+Queue events are local-only - only the server that processes a task emits `complete`/`failed`. Use [@prsm/realtime](https://github.com/nvms/realtime) to push results to connected clients in real time.
 
 Send results to a specific client:
 
 ```js
 import Queue from '@prsm/queue'
-import { MeshServer } from '@mesh-kit/server'
+import { RealtimeServer } from '@prsm/realtime'
 
-const mesh = new MeshServer({ redis: { host: 'localhost', port: 6379 } })
+const realtime = new RealtimeServer({ redis: { host: 'localhost', port: 6379 } })
 const queue = new Queue({ concurrency: 5, groups: { concurrency: 1 } })
 
 queue.process(async (payload) => {
@@ -194,14 +194,14 @@ queue.process(async (payload) => {
 })
 
 queue.on('complete', ({ task, result }) => {
-  mesh.sendTo(task.payload.connectionId, 'job:complete', result)
+  realtime.sendTo(task.payload.connectionId, 'job:complete', result)
 })
 
 queue.on('failed', ({ task, error }) => {
-  mesh.sendTo(task.payload.connectionId, 'job:failed', { error: error.message })
+  realtime.sendTo(task.payload.connectionId, 'job:failed', { error: error.message })
 })
 
-mesh.exposeCommand('generate-report', async (ctx) => {
+realtime.exposeCommand('generate-report', async (ctx) => {
   const taskId = await queue.push({
     connectionId: ctx.connection.id,
     ...ctx.payload,
@@ -210,10 +210,10 @@ mesh.exposeCommand('generate-report', async (ctx) => {
 })
 
 await queue.ready()
-await mesh.listen(8080)
+await realtime.listen(8080)
 ```
 
-Both queue and mesh use the same Redis instance. No key conflicts (`queue:*` vs `mesh:*`).
+Both queue and realtime use the same Redis instance. No key conflicts (`queue:*` vs `mesh:*`).
 
 ## Horizontal Scaling
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prsm/queue",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Redis-backed distributed task queue with grouped concurrency, retries, and rate limiting",
   "type": "module",
   "exports": {

package/src/queue.js

@@ -20,7 +20,7 @@ import ms from "@prsm/ms"
  * @property {string} uuid
  * @property {any} payload
  * @property {number} createdAt
- * @property {string} [groupKey]
+ * @property {string} [group]
  * @property {number} attempts
  */
 
@@ -157,7 +157,7 @@ export default class Queue extends EventEmitter {
   async push(payload, { group } = {}) {
     if (this._closed) throw new Error("Queue is closed")
     const task = group
-      ? { uuid: randomUUID(), payload, createdAt: Date.now(), groupKey: group, attempts: 0 }
+      ? { uuid: randomUUID(), payload, createdAt: Date.now(), group, attempts: 0 }
       : { uuid: randomUUID(), payload, createdAt: Date.now(), attempts: 0 }
     this._pushed++
     try {
@@ -178,7 +178,7 @@ export default class Queue extends EventEmitter {
   pushAndWait(payload, { group, timeout = 0 } = {}) {
     if (this._closed) return Promise.reject(new Error("Queue is closed"))
     const task = group
-      ? { uuid: randomUUID(), payload, createdAt: Date.now(), groupKey: group, attempts: 0 }
+      ? { uuid: randomUUID(), payload, createdAt: Date.now(), group, attempts: 0 }
       : { uuid: randomUUID(), payload, createdAt: Date.now(), attempts: 0 }
     this._pushed++
     const result = this._awaitTask(task.uuid, timeout)
@@ -338,13 +338,13 @@ export default class Queue extends EventEmitter {
       timeout: this._options.groups.timeout,
       maxRetries: this._options.groups.maxRetries,
       retryKey: `queue:groups:${groupKey}`,
-      groupKey,
+      group: groupKey,
     }
     this._runWorkerLoop(workerId, client, `queue:groups:${groupKey}`, groupWorkers, opts)
   }
 
   async _runWorkerLoop(workerId, client, key, activeMap, opts) {
-    const delay = opts.groupKey ? this._options.groups.delay : this._options.delay
+    const delay = opts.group ? this._options.groups.delay : this._options.delay
 
     while (activeMap.get(workerId)) {
       try {
@@ -371,17 +371,17 @@ export default class Queue extends EventEmitter {
           }
 
           this._inFlight++
-          if (opts.groupKey) {
-            this._groupInFlight.set(opts.groupKey, (this._groupInFlight.get(opts.groupKey) || 0) + 1)
+          if (opts.group) {
+            this._groupInFlight.set(opts.group, (this._groupInFlight.get(opts.group) || 0) + 1)
           }
 
           try {
             await this._processTask(task, opts)
           } finally {
-            if (opts.groupKey) {
-              const count = (this._groupInFlight.get(opts.groupKey) || 1) - 1
-              if (count <= 0) this._groupInFlight.delete(opts.groupKey)
-              else this._groupInFlight.set(opts.groupKey, count)
+            if (opts.group) {
+              const count = (this._groupInFlight.get(opts.group) || 1) - 1
+              if (count <= 0) this._groupInFlight.delete(opts.group)
+              else this._groupInFlight.set(opts.group, count)
             }
             if (leaseId) await this._releaseGlobal(leaseId).catch(() => {})
           }

package/types/queue.d.ts

@@ -4752,7 +4752,7 @@ export type Task = {
     uuid: string;
     payload: any;
     createdAt: number;
-    groupKey?: string;
+    group?: string;
     attempts: number;
 };
 export type TaskHandler = (payload: any, task: Task) => Promise<any> | any;