bunqueue 2.9.0 → 2.9.2

package/dist/infrastructure/persistence/sqliteSerializer.js

@@ -6,6 +6,7 @@
 import { jobId } from '../../domain/types/job';
 import { setDlqRetryState } from '../../domain/types/dlq';
 import { normalizeLegacyJobPayload } from '../../domain/job/payload';
+import { restoreGroupFifoOrder } from '../../domain/job/groupFifoOrder';
 import { decodeJobOptions } from './jobOptionsBlob';
 import { storageLog } from '../../shared/logger';
 import { decodeMessagePack as msgpackDecode, encodeMessagePack as msgpackEncode, } from '../../shared/msgpack';
@@ -166,6 +167,7 @@ export function rowToJob(row) {
             ? unpack(row.stacktrace, null, `${jobContext}:stacktrace`)
             : null,
     };
+    restoreGroupFifoOrder(job, extended.groupFifoOrder);
     const dlqRetryState = row.dlq_retry_state
         ? unpack(row.dlq_retry_state, null, `${jobContext}:dlqRetryState`)
         : null;

package/dist/infrastructure/server/handler-routes/control.js

@@ -2,6 +2,7 @@ import { handleClean, handleClearConcurrency, handleGetDlqConfig, handleGetStall
 import { handleCron, handleCronDelete, handleCronGet, handleCronList } from '../handlers/cron';
 import { handleDlq, handleGetDlqStats, handlePurgeDlq, handleRemoveDlqJob, handleRetryCompleted, handleRetryDlq, } from '../handlers/dlq';
 import { handleDrain, handlePause, handleResume } from '../handlers/management';
+import { handleGroupCommand, handleGroupsJobsCount } from '../handlers/groups';
 export function routeQueueControlCommand(command, context, requestId) {
     switch (command.cmd) {
         case 'Pause':
@@ -42,6 +43,18 @@ export function routeDlqCommand(command, context, requestId) {
 }
 export function routeRateLimitCommand(command, context, requestId) {
     switch (command.cmd) {
+        case 'GetGroupsJobsCount':
+            return handleGroupsJobsCount(command, context, requestId);
+        case 'GetGroupJobsCount':
+        case 'GetGroupActiveCount':
+        case 'SetGroupRateLimit':
+        case 'GetGroupRateLimit':
+        case 'RemoveGroupRateLimit':
+        case 'GetGroupRateLimitTtl':
+        case 'SetGroupConcurrency':
+        case 'GetGroupConcurrency':
+        case 'RemoveGroupConcurrency':
+            return handleGroupCommand(command, context, requestId);
         case 'RateLimit':
             return handleRateLimit(command, context, requestId);
         case 'RateLimitClear':

package/dist/infrastructure/server/handlers/core.d.ts

@@ -1,20 +1,15 @@
-/** Core command handlers for push, pull, acknowledgement, and failure. */
 import type { Command } from '../../../domain/types/command';
 import type { Response } from '../../../domain/types/response';
 import type { HandlerContext } from '../types';
-/** Handle PUSH command */
 export declare function handlePush(cmd: Extract<Command, {
     cmd: 'PUSH';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle PUSHB (batch push) command */
 export declare function handlePushBatch(cmd: Extract<Command, {
     cmd: 'PUSHB';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle PULL command */
 export declare function handlePull(cmd: Extract<Command, {
     cmd: 'PULL';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle PULLB (batch pull) command - uses optimized single-lock batch pull */
 export declare function handlePullBatch(cmd: Extract<Command, {
     cmd: 'PULLB';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;

package/dist/infrastructure/server/handlers/core.js

@@ -1,11 +1,10 @@
-/** Core command handlers for push, pull, acknowledgement, and failure. */
 import * as resp from '../../../domain/types/response';
+import { validateGroupPullOptions } from '../../../domain/types/group';
 import { jobId, normalizeLegacyJobPayload } from '../../../domain/types/job';
 import { tcpLog } from '../../../shared/logger';
 import { sanitizeServerError, serverErrorDiagnostics } from '../errors';
-import { validateQueueName, validateJobData, validateJobOptions, validateNumericField, } from '../protocol';
+import { validateQueueName, validateGroupId, validateJobData, validateJobOptions, validateNumericField, } from '../protocol';
 import { validatePushBatchJobs, validatePushDependencies } from './pushBatchValidation';
-/** Handle PUSH command */
 export async function handlePush(cmd, ctx, reqId) {
     const queueError = validateQueueName(cmd.queue);
     if (queueError)
@@ -13,7 +12,9 @@ export async function handlePush(cmd, ctx, reqId) {
     const dataError = validateJobData(cmd.data);
     if (dataError)
         return resp.error(dataError, reqId);
-    // Validate numeric fields
+    const groupError = validateGroupId(cmd.groupId);
+    if (groupError)
+        return resp.error(groupError, reqId);
     const optionsError = validateJobOptions({
         priority: cmd.priority,
         delay: cmd.delay,
@@ -69,7 +70,6 @@ export async function handlePush(cmd, ctx, reqId) {
         return resp.error(sanitizeServerError(err), reqId);
     }
 }
-/** Handle PUSHB (batch push) command */
 export async function handlePushBatch(cmd, ctx, reqId) {
     const queueError = validateQueueName(cmd.queue);
     if (queueError)
@@ -91,48 +91,45 @@ export async function handlePushBatch(cmd, ctx, reqId) {
         return resp.error(sanitizeServerError(error), reqId);
     }
 }
-/** Handle PULL command */
 export async function handlePull(cmd, ctx, reqId) {
     const queueError = validateQueueName(cmd.queue);
     if (queueError)
         return resp.error(queueError, reqId);
-    // Validate timeout
     const timeoutError = validateNumericField(cmd.timeout, 'timeout', { min: 0, max: 60000 });
     if (timeoutError)
         return resp.error(timeoutError, reqId);
-    // If owner is provided, use lock-based pull
+    const groupError = validateGroupPullOptions(cmd.group);
+    if (groupError)
+        return resp.error(groupError, reqId);
     if (cmd.owner) {
-        const { job, token } = await ctx.queueManager.pullWithLock(cmd.queue, cmd.owner, cmd.timeout, cmd.lockTtl, ctx.signal);
-        // Register job with client for connection-based release
+        const { job, token } = await ctx.queueManager.pullWithLock(cmd.queue, cmd.owner, cmd.timeout, cmd.lockTtl, ctx.signal, cmd.group);
         if (job && ctx.clientId) {
             ctx.queueManager.registerClientJob(ctx.clientId, job.id);
         }
         return resp.pulledJob(job, token, reqId);
     }
     // Standard pull (no lock, but still track for client release unless detached)
-    const job = await ctx.queueManager.pull(cmd.queue, cmd.timeout, ctx.signal);
+    const job = await ctx.queueManager.pull(cmd.queue, cmd.timeout, ctx.signal, cmd.group);
     if (job && ctx.clientId && !cmd.detach) {
         ctx.queueManager.registerClientJob(ctx.clientId, job.id);
     }
     return resp.nullableJob(job, reqId);
 }
-/** Handle PULLB (batch pull) command - uses optimized single-lock batch pull */
 export async function handlePullBatch(cmd, ctx, reqId) {
     const queueError = validateQueueName(cmd.queue);
     if (queueError)
         return resp.error(queueError, reqId);
-    // Validate count
     const countError = validateNumericField(cmd.count, 'count', { min: 1, max: 1000 });
     if (countError)
         return resp.error(countError, reqId);
-    // Validate timeout (same bound as PULL)
     const timeoutError = validateNumericField(cmd.timeout, 'timeout', { min: 0, max: 60000 });
     if (timeoutError)
         return resp.error(timeoutError, reqId);
-    // If owner is provided, use lock-based pull
+    const groupError = validateGroupPullOptions(cmd.group);
+    if (groupError)
+        return resp.error(groupError, reqId);
     if (cmd.owner) {
-        const { jobs, tokens } = await ctx.queueManager.pullBatchWithLock(cmd.queue, cmd.count, cmd.owner, cmd.timeout ?? 0, cmd.lockTtl, ctx.signal);
-        // Register all jobs with client for connection-based release
+        const { jobs, tokens } = await ctx.queueManager.pullBatchWithLock(cmd.queue, cmd.count, cmd.owner, cmd.timeout ?? 0, cmd.lockTtl, ctx.signal, cmd.group);
         if (ctx.clientId) {
             for (const job of jobs) {
                 ctx.queueManager.registerClientJob(ctx.clientId, job.id);
@@ -142,7 +139,7 @@ export async function handlePullBatch(cmd, ctx, reqId) {
     }
     // Standard pull (no locks, but still track for client release) — the
     // non-owner branch honors cmd.timeout exactly like the owner branch and PULL.
-    const jobs = await ctx.queueManager.pullBatch(cmd.queue, cmd.count, cmd.timeout ?? 0, ctx.signal);
+    const jobs = await ctx.queueManager.pullBatch(cmd.queue, cmd.count, cmd.timeout ?? 0, ctx.signal, cmd.group);
     if (ctx.clientId) {
         for (const job of jobs) {
             ctx.queueManager.registerClientJob(ctx.clientId, job.id);

package/dist/infrastructure/server/handlers/groups.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../../domain/types/command';
+import type { Response } from '../../../domain/types/response';
+import type { HandlerContext } from '../types';
+type GroupCommand = Extract<Command, {
+    groupId: string;
+}>;
+export declare function handleGroupCommand(command: GroupCommand, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleGroupsJobsCount(command: Extract<Command, {
+    cmd: 'GetGroupsJobsCount';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export {};

package/dist/infrastructure/server/handlers/groups.js

@@ -0,0 +1,55 @@
+import { validatePositiveSafeInteger } from '../../../domain/types/group';
+import * as resp from '../../../domain/types/response';
+import { validateGroupId, validateQueueName } from '../protocol';
+function validate(command) {
+    const queueError = validateQueueName(command.queue);
+    if (queueError)
+        return queueError;
+    return validateGroupId(command.groupId, true);
+}
+export async function handleGroupCommand(command, context, requestId) {
+    const error = validate(command);
+    if (error)
+        return resp.error(error, requestId);
+    const manager = context.queueManager;
+    switch (command.cmd) {
+        case 'GetGroupJobsCount':
+            return resp.data({ count: await manager.getGroupJobsCount(command.queue, command.groupId) }, requestId);
+        case 'GetGroupActiveCount':
+            return resp.data({ count: await manager.getGroupActiveCount(command.queue, command.groupId) }, requestId);
+        case 'SetGroupRateLimit': {
+            const maxError = validatePositiveSafeInteger(command.max, 'max');
+            const durationError = validatePositiveSafeInteger(command.duration, 'duration');
+            const numericError = maxError ?? durationError;
+            if (numericError)
+                return resp.error(numericError, requestId);
+            await manager.setGroupRateLimit(command.queue, command.groupId, command.max, command.duration);
+            return resp.ok(undefined, requestId);
+        }
+        case 'GetGroupRateLimit':
+            return resp.data({ limit: await manager.getGroupRateLimit(command.queue, command.groupId) }, requestId);
+        case 'RemoveGroupRateLimit':
+            return resp.data({ removed: await manager.removeGroupRateLimit(command.queue, command.groupId) }, requestId);
+        case 'GetGroupRateLimitTtl':
+            return resp.data({
+                ttl: await manager.getGroupRateLimitTtl(command.queue, command.groupId, command.maxJobs),
+            }, requestId);
+        case 'SetGroupConcurrency': {
+            const concurrencyError = validatePositiveSafeInteger(command.concurrency, 'concurrency');
+            if (concurrencyError)
+                return resp.error(concurrencyError, requestId);
+            await manager.setGroupConcurrency(command.queue, command.groupId, command.concurrency);
+            return resp.ok(undefined, requestId);
+        }
+        case 'GetGroupConcurrency':
+            return resp.data({ concurrency: await manager.getGroupConcurrency(command.queue, command.groupId) }, requestId);
+        case 'RemoveGroupConcurrency':
+            return resp.data({ removed: await manager.removeGroupConcurrency(command.queue, command.groupId) }, requestId);
+    }
+}
+export async function handleGroupsJobsCount(command, context, requestId) {
+    const queueError = validateQueueName(command.queue);
+    if (queueError)
+        return resp.error(queueError, requestId);
+    return resp.data({ count: await context.queueManager.getGroupsJobsCount(command.queue) }, requestId);
+}

package/dist/infrastructure/server/handlers/pushBatchValidation.js

@@ -5,7 +5,7 @@
  * existence gate handlePush enforces (core.ts).
  */
 import { jobId, normalizeLegacyJobPayload, } from '../../../domain/types/job';
-import { validateJobData, validateJobOptions } from '../protocol';
+import { validateGroupId, validateJobData, validateJobOptions } from '../protocol';
 function dependencyExistsLocally(id, ctx) {
     return (ctx.queueManager.getJobIndex().has(id) ||
         ctx.queueManager.getCompletedJobs().has(id) ||
@@ -88,6 +88,9 @@ function validateJobs(jobs, state) {
         const dataError = validateJobData(job.data);
         if (dataError)
             return `jobs[${i}]: ${dataError}`;
+        const groupError = validateGroupId(job.groupId);
+        if (groupError)
+            return `jobs[${i}]: ${groupError}`;
         const optionsError = validateJobOptions({
             priority: job.priority,
             delay: job.delay,

package/dist/infrastructure/server/protocol/validation.d.ts

@@ -1,4 +1,5 @@
 export declare function validateQueueName(name: string): string | null;
+export { validateGroupId } from '../../../domain/types/group';
 export declare function validateJobData(data: unknown): string | null;
 export declare function validateNumericField(value: unknown, name: string, options?: {
     min?: number;

package/dist/infrastructure/server/protocol/validation.js

@@ -7,6 +7,7 @@ export function validateQueueName(name) {
         return 'Queue name contains invalid characters';
     return null;
 }
+export { validateGroupId } from '../../../domain/types/group';
 export function validateJobData(data) {
     let json;
     try {

package/dist/infrastructure/server/protocol.d.ts

@@ -1,6 +1,6 @@
 export { createConnectionState, errorResponse, parseCommand, parseCommands, serializeResponse, } from './protocol/commands';
 export { FrameParser, FrameSizeError, MAX_FRAME_SIZE } from './protocol/frameParser';
 export { LineBuffer } from './protocol/lineBuffer';
-export { validateBackoffField, validateJobData, validateJobOptions, validateNumericField, validateQueueName, } from './protocol/validation';
+export { validateBackoffField, validateGroupId, validateJobData, validateJobOptions, validateNumericField, validateQueueName, } from './protocol/validation';
 export type { ConnectionState } from './types/protocol';
 export { validateWebhookUrl } from '../../shared/webhookValidation';

package/dist/infrastructure/server/protocol.js

@@ -1,5 +1,5 @@
 export { createConnectionState, errorResponse, parseCommand, parseCommands, serializeResponse, } from './protocol/commands';
 export { FrameParser, FrameSizeError, MAX_FRAME_SIZE } from './protocol/frameParser';
 export { LineBuffer } from './protocol/lineBuffer';
-export { validateBackoffField, validateJobData, validateJobOptions, validateNumericField, validateQueueName, } from './protocol/validation';
+export { validateBackoffField, validateGroupId, validateJobData, validateJobOptions, validateNumericField, validateQueueName, } from './protocol/validation';
 export { validateWebhookUrl } from '../../shared/webhookValidation';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunqueue",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "High-performance job queue for Bun and AI agents. Memory or one-file SQLite, optional PostgreSQL 15–18 multi-broker persistence, cron, retries, DLQ, and MCP.",
   "keywords": [
     "agentic",
@@ -127,6 +127,7 @@
     "bench:autobatch": "bun run bench/local-autobatch.ts",
     "bench:postgres:versions": "bun run bench/postgres-versions.ts",
     "bench:pushbulk": "bun run bench/pushbulk-delta.ts",
+    "bench:sqlite-lifecycle": "bun run bench/sqlite-lifecycle-batching.ts",
     "bench:workflow": "bun run bench/workflow-engine.ts",
     "bench:workflow:scale": "bun run bench/workflow-engine/scale.ts",
     "bench:joblist": "bun run bench/job-list-perf.ts",