bunqueue 2.9.0 → 2.9.2

package/dist/application/queue-manager/limits.js

@@ -4,7 +4,68 @@ import { shardIndex, SHARD_COUNT } from '../../shared/hash';
 import * as dlqOps from '../dlqManager';
 import * as queryOps from '../operations/queryOperations';
 import { QueueManagerControl } from './control';
+import { assertGroupId, assertPositiveSafeInteger, } from '../../domain/types/group';
 export class QueueManagerLimits extends QueueManagerControl {
+    getGroupJobsCount(queue, groupId) {
+        assertGroupId(groupId);
+        return this.shards[shardIndex(queue)].getGroupJobsCount(queue, groupId);
+    }
+    getGroupsJobsCount(queue) {
+        return this.shards[shardIndex(queue)].getGroupsJobsCount(queue);
+    }
+    getGroupActiveCount(queue, groupId) {
+        assertGroupId(groupId);
+        return this.shards[shardIndex(queue)].getGroupActiveCount(queue, groupId);
+    }
+    setGroupRateLimit(queue, groupId, max, duration) {
+        assertGroupId(groupId);
+        assertPositiveSafeInteger(max, 'max');
+        assertPositiveSafeInteger(duration, 'duration');
+        const shard = this.shards[shardIndex(queue)];
+        this.storage?.saveGroupRateLimit(queue, groupId, max, duration);
+        shard.setGroupRateLimit(queue, groupId, max, duration);
+        shard.notifyBatch(queue, Math.max(1, shard.getGroupJobsCount(queue, groupId)));
+    }
+    getGroupRateLimit(queue, groupId) {
+        assertGroupId(groupId);
+        return this.shards[shardIndex(queue)].getGroupRateLimit(queue, groupId);
+    }
+    removeGroupRateLimit(queue, groupId) {
+        assertGroupId(groupId);
+        const shard = this.shards[shardIndex(queue)];
+        if (!shard.getGroupRateLimit(queue, groupId))
+            return 0;
+        this.storage?.removeGroupRateLimit(queue, groupId);
+        const removed = shard.removeGroupRateLimit(queue, groupId);
+        shard.notifyBatch(queue, Math.max(1, shard.getGroupJobsCount(queue, groupId)));
+        return removed;
+    }
+    getGroupRateLimitTtl(queue, groupId, maxJobs) {
+        assertGroupId(groupId);
+        return this.shards[shardIndex(queue)].getGroupRateLimitTtl(queue, groupId, maxJobs);
+    }
+    setGroupConcurrency(queue, groupId, concurrency) {
+        assertGroupId(groupId);
+        assertPositiveSafeInteger(concurrency, 'concurrency');
+        const shard = this.shards[shardIndex(queue)];
+        this.storage?.saveGroupConcurrency(queue, groupId, concurrency);
+        shard.setGroupConcurrency(queue, groupId, concurrency);
+        shard.notifyBatch(queue, Math.max(1, shard.getGroupJobsCount(queue, groupId)));
+    }
+    getGroupConcurrency(queue, groupId) {
+        assertGroupId(groupId);
+        return this.shards[shardIndex(queue)].getGroupConcurrency(queue, groupId);
+    }
+    removeGroupConcurrency(queue, groupId) {
+        assertGroupId(groupId);
+        const shard = this.shards[shardIndex(queue)];
+        if (shard.getGroupConcurrency(queue, groupId) === null)
+            return 0;
+        this.storage?.removeGroupConcurrency(queue, groupId);
+        const removed = shard.removeGroupConcurrency(queue, groupId);
+        shard.notifyBatch(queue, Math.max(1, shard.getGroupJobsCount(queue, groupId)));
+        return removed;
+    }
     getCountsPerPriority(queue) {
         const counts = this.shards[shardIndex(queue)].getCountsPerPriority(queue);
         return Object.fromEntries(counts);

package/dist/application/queue-manager/state.js

@@ -135,7 +135,7 @@ export class QueueManagerState {
         this.workerManager = new WorkerManager();
         this.cronScheduler.setWorkerCheckCallback((queue) => this.workerManager.getForQueue(queue).length > 0);
         this.eventsManager = new EventsManager(this.webhookManager);
-        this.eventsManager.subscribe((event) => this.telemetryJournal.record(event));
+        this.eventsManager.subscribe((event) => this.telemetryJournal.record(event), (events) => this.telemetryJournal.recordBatch(events));
         this.contextFactory = new ContextFactory(createContextDependencies(managerRuntime(this)), createContextCallbacks(runtime));
         bgTasks.recover(this.contextFactory.getBackgroundContext());
         if (this.storage) {

package/dist/application/queueTelemetryJournal.d.ts

@@ -10,6 +10,8 @@ export declare class QueueTelemetryJournal {
     private readonly maxMetricDataPoints;
     constructor(storage: SqliteStorage | null, maxEvents: number, maxMetricDataPoints: number);
     record(event: JobEvent): void;
+    /** Persist a lifecycle batch atomically, with scalar fallback on write failure. */
+    recordBatch(events: readonly JobEvent[]): void;
     getMetrics(queue: string, type: QueueMetricType, start?: number, end?: number): QueueMetrics;
     trimEvents(queue: string, maxLength: number): number;
     clearQueue(queue: string): void;

package/dist/application/queueTelemetryJournal.js

@@ -55,6 +55,29 @@ export class QueueTelemetryJournal {
         queueMetrics.set(type, state);
         this.metrics.set(event.queue, queueMetrics);
     }
+    /** Persist a lifecycle batch atomically, with scalar fallback on write failure. */
+    recordBatch(events) {
+        if (events.length === 0)
+            return;
+        if (this.storage) {
+            try {
+                this.storage.recordQueueEventsBatch(events, this.maxEvents, this.maxMetricDataPoints);
+            }
+            catch {
+                for (const event of events) {
+                    try {
+                        this.storage.recordQueueEvent(event, this.maxEvents, this.maxMetricDataPoints);
+                    }
+                    catch {
+                        // Match scalar subscriber isolation and continue with later events.
+                    }
+                }
+            }
+            return;
+        }
+        for (const event of events)
+            this.record(event);
+    }
     getMetrics(queue, type, start = 0, end = -1) {
         assertNonNegativeInteger(start, 'start');
         if (end !== -1)

package/dist/application/types/ack.d.ts

@@ -2,7 +2,7 @@ import type { Shard } from '../../domain/queue/shard';
 import type { FlowFailureRecord } from '../../domain/types/flow';
 import type { FailureReason } from '../../domain/types/dlq';
 import type { Job, JobId } from '../../domain/types/job';
-import type { EventType, JobLocation } from '../../domain/types/queue';
+import type { EventType, JobEvent, JobLocation } from '../../domain/types/queue';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { RWLock } from '../../shared/lock';
 import type { MapLike, SetLike } from '../../shared/lru';
@@ -43,6 +43,7 @@ export interface AckContext {
         prev?: string;
         terminal?: boolean;
     }) => void;
+    broadcastBatch?: (events: readonly JobEvent[]) => void;
     onJobCompleted: (jobId: JobId) => void;
     onJobFailed?: (jobId: JobId) => void;
     onJobsCompleted?: (jobIds: JobId[]) => void;
@@ -107,6 +108,7 @@ export interface FinalizeContext {
         timestamp: number;
         data?: unknown;
     }) => void;
+    broadcastBatch?: (events: readonly JobEvent[]) => void;
     onJobCompleted: (jobId: JobId) => void;
     onJobsCompleted?: (jobIds: JobId[]) => void;
     needsBroadcast?: () => boolean;

package/dist/cli/commandRouter.d.ts

@@ -1,3 +1,3 @@
-export declare const CLI_NETWORK_COMMANDS: readonly ("push" | "queue" | "cron" | "dlq" | "job" | "fail" | "worker" | "concurrency" | "stats" | "ping" | "metrics" | "pull" | "ack" | "rate-limit" | "health" | "webhook")[];
+export declare const CLI_NETWORK_COMMANDS: readonly ("push" | "queue" | "cron" | "concurrency" | "job" | "dlq" | "fail" | "worker" | "stats" | "ping" | "metrics" | "pull" | "ack" | "rate-limit" | "health" | "webhook")[];
 /** Build the protocol command for a routed network CLI command. */
 export declare function buildCommand(command: string, args: string[]): Promise<Record<string, unknown> | null>;

package/dist/client/flowPush.js

@@ -4,6 +4,10 @@
  */
 import { getSharedManager } from './manager';
 import { jobId } from '../domain/types/job';
+import { normalizeGroupId } from './groupId';
+function groupId(opts) {
+    return opts.group ? normalizeGroupId(opts.group.id) : undefined;
+}
 /** Parse removeOnComplete/removeOnFail options */
 function parseRemoveOptions(opts) {
     return {
@@ -67,6 +71,7 @@ function managerOptions(opts) {
         removeDependencyOnFailure: opts.removeDependencyOnFailure,
         ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
         continueParentOnFailure: opts.continueParentOnFailure,
+        groupId: groupId(opts),
     };
 }
 /** Full option set for the TCP PUSH command, mirroring buildPushPayload in add.ts (#90). */
@@ -94,6 +99,7 @@ function tcpOptions(opts) {
         removeDependencyOnFailure: opts.removeDependencyOnFailure,
         ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
         continueParentOnFailure: opts.continueParentOnFailure,
+        groupId: groupId(opts),
     };
 }
 /** Push a job via embedded manager or TCP */

package/dist/client/groupId.d.ts

@@ -0,0 +1 @@
+export { normalizeGroupId } from '../domain/types/group';

package/dist/client/groupId.js

@@ -0,0 +1 @@
+export { normalizeGroupId } from '../domain/types/group';

package/dist/client/index.d.ts

@@ -38,7 +38,7 @@ export { shutdownManager } from './manager';
 export { closeSharedTcpClient } from './tcpClient';
 export type { ConnectionHealth } from './tcpClient';
 export { TcpConnectionPool, getSharedPool, closeAllSharedPools } from './tcpPool';
-export type { Job, JobOptions, JobJson, JobJsonRaw, QueueOptions, WorkerOptions, Processor, FlowJobData, StallConfig, DlqConfig, DlqEntry, DlqStats, DlqFilter, FailureReason, ConnectionOptions, ParentOpts, RateLimiterOptions, ChangePriorityOpts, GetDependenciesOpts, JobDependencies, JobDependenciesCount, QueueMetrics, QueueMetricsMeta, QueueMetricType, } from './types';
+export type { Job, JobOptions, GroupJobOptions, GroupWorkerOptions, JobJson, JobJsonRaw, QueueOptions, WorkerOptions, Processor, FlowJobData, StallConfig, DlqConfig, DlqEntry, DlqStats, DlqFilter, FailureReason, ConnectionOptions, ParentOpts, RateLimiterOptions, ChangePriorityOpts, GetDependenciesOpts, JobDependencies, JobDependenciesCount, QueueMetrics, QueueMetricsMeta, QueueMetricType, } from './types';
 export type { FlowStep, FlowResult, FlowJob, JobNode, FlowProducerOptions, FlowOpts } from './flow';
 export type { RepeatOpts, JobTemplate, SchedulerInfo } from './queue/scheduler';
 export type { SandboxedWorkerOptions } from './sandboxedWorker';

package/dist/client/jobHelpers.js

@@ -97,6 +97,7 @@ export function buildJobOpts(job) {
         debounce: job.debounceId && job.debounceTtl !== null
             ? { id: job.debounceId, ttl: job.debounceTtl }
             : undefined,
+        group: job.groupId ? { id: job.groupId } : undefined,
     };
 }
 /** Build parent key from job */

package/dist/client/queue/operations/add/bulk.js

@@ -1,7 +1,7 @@
 import { getSharedManager } from '../../../manager';
 import { jobId } from '../../../../domain/types/job';
 import { createJobProxy, createSimpleJob } from '../../jobProxy';
-import { buildJobData, buildRepeatOptions, compact, reflectionMeta } from './payload';
+import { buildJobData, buildRepeatOptions, compact, reflectionMeta, resolveGroupId, } from './payload';
 export async function addBulk(context, jobs) {
     if (jobs.length === 0)
         return [];
@@ -11,7 +11,7 @@ export async function addBulk(context, jobs) {
         ...opts,
     }));
     if (context.embedded) {
-        const manager = getSharedManager();
+        const manager = getSharedManager(context.opts.dataPath);
         const inputs = jobs.map(({ name, data }, index) => {
             const options = merged[index];
             const removeOnComplete = typeof options.removeOnComplete === 'boolean' ? options.removeOnComplete : false;
@@ -30,7 +30,7 @@ export async function addBulk(context, jobs) {
                 dependsOn: options.dependsOn?.map((id) => jobId(id)),
                 parentId: options.parent ? jobId(options.parent.id) : undefined,
                 tags: options.tags,
-                groupId: options.groupId,
+                groupId: resolveGroupId(options),
                 stallTimeout: options.stallTimeout,
                 timestamp: options.timestamp,
                 removeOnComplete,
@@ -84,7 +84,7 @@ export async function addBulk(context, jobs) {
             ttl: options.ttl,
             customId: options.jobId,
             tags: options.tags,
-            groupId: options.groupId,
+            groupId: resolveGroupId(options),
             dependsOn: options.dependsOn?.map((id) => jobId(id)),
             parentId: options.parent ? jobId(options.parent.id) : undefined,
             uniqueKey: options.deduplication?.id,

package/dist/client/queue/operations/add/payload.d.ts

@@ -16,6 +16,7 @@ export declare function buildRepeatOptions(repeat: NonNullable<JobOptions['repea
     jobId: string | undefined;
 };
 export declare function buildPushPayload(queue: string, name: string, data: unknown, options: ExtendedJobOptions): Record<string, unknown>;
+export declare function resolveGroupId(options: ExtendedJobOptions): string | undefined;
 export declare function buildJobData(data: unknown, options: ExtendedJobOptions): unknown;
 export declare function reflectionMeta(options: ExtendedJobOptions): {
     priority?: number;

package/dist/client/queue/operations/add/payload.js

@@ -1,3 +1,4 @@
+import { normalizeGroupId } from '../../../groupId';
 export function compact(object) {
     const output = {};
     for (const key in object) {
@@ -51,7 +52,7 @@ export function buildPushPayload(queue, name, data, options) {
             : undefined,
         dependsOn: options.dependsOn,
         tags: options.tags,
-        groupId: options.groupId,
+        groupId: resolveGroupId(options),
         lifo: options.lifo,
         removeOnComplete: typeof options.removeOnComplete === 'boolean' ? options.removeOnComplete : undefined,
         removeOnFail: typeof options.removeOnFail === 'boolean' ? options.removeOnFail : undefined,
@@ -71,6 +72,11 @@ export function buildPushPayload(queue, name, data, options) {
         parentId: options.parent?.id,
     });
 }
+export function resolveGroupId(options) {
+    if (options.group)
+        return normalizeGroupId(options.group.id);
+    return options.groupId === undefined ? undefined : normalizeGroupId(options.groupId);
+}
 export function buildJobData(data, options) {
     if (!options.parent)
         return data;

package/dist/client/queue/operations/add/single.js

@@ -3,12 +3,12 @@ import { removeJobDeduplicationKey } from '../../../jobDeduplication';
 import { toPublicJob } from '../../../types';
 import { jobId } from '../../../../domain/types/job';
 import { createJobProxy } from '../../jobProxy';
-import { buildJobData, buildPushPayload, buildRepeatOptions } from './payload';
+import { buildJobData, buildPushPayload, buildRepeatOptions, resolveGroupId } from './payload';
 export async function add(context, jobName, data, options = {}) {
     const merged = { ...context.opts.defaultJobOptions, ...options };
     const jobData = buildJobData(data, merged);
     if (context.embedded) {
-        const manager = getSharedManager();
+        const manager = getSharedManager(context.opts.dataPath);
         const removeOnComplete = typeof merged.removeOnComplete === 'boolean' ? merged.removeOnComplete : false;
         const removeOnFail = typeof merged.removeOnFail === 'boolean' ? merged.removeOnFail : false;
         const repeat = merged.repeat ? buildRepeatOptions(merged.repeat) : undefined;
@@ -25,7 +25,7 @@ export async function add(context, jobName, data, options = {}) {
             customId: merged.jobId,
             dependsOn: merged.dependsOn?.map((id) => jobId(id)),
             tags: merged.tags,
-            groupId: merged.groupId,
+            groupId: resolveGroupId(merged),
             dedup: merged.deduplication
                 ? {
                     ttl: merged.deduplication.ttl,

package/dist/client/queue/operations/groups.d.ts

@@ -0,0 +1,21 @@
+import type { TcpConnectionPool } from '../../tcpPool';
+interface GroupContext {
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+    dataPath: string | undefined;
+}
+export declare function getGroupJobsCount(ctx: GroupContext, groupId: string): Promise<number>;
+export declare function getGroupsJobsCount(ctx: GroupContext, maxCount?: number): Promise<number>;
+export declare function getGroupActiveCount(ctx: GroupContext, groupId: string): Promise<number>;
+export declare function setGroupRateLimit(ctx: GroupContext, groupId: string, max: number, duration: number): Promise<void>;
+export declare function getGroupRateLimit(ctx: GroupContext, groupId: string): Promise<{
+    max: number;
+    duration: number;
+} | null>;
+export declare function removeGroupRateLimit(ctx: GroupContext, groupId: string): Promise<number>;
+export declare function getGroupRateLimitTtl(ctx: GroupContext, groupId: string, maxJobs?: number): Promise<number>;
+export declare function setGroupConcurrency(ctx: GroupContext, groupId: string, concurrency: number): Promise<void>;
+export declare function getGroupConcurrency(ctx: GroupContext, groupId: string): Promise<number | null>;
+export declare function removeGroupConcurrency(ctx: GroupContext, groupId: string): Promise<number>;
+export {};

package/dist/client/queue/operations/groups.js

@@ -0,0 +1,88 @@
+import { getSharedManager } from '../../manager';
+import { normalizeGroupId } from '../../groupId';
+function manager(ctx) {
+    return getSharedManager(ctx.dataPath);
+}
+async function send(ctx, command) {
+    if (!ctx.tcp)
+        throw new Error('TCP connection is unavailable for group operation');
+    const response = await ctx.tcp.send({ ...command, queue: ctx.name });
+    if (!response.ok)
+        throw new Error(String(response.error ?? 'Group operation failed'));
+    const data = typeof response.data === 'object' && response.data !== null
+        ? response.data
+        : {};
+    return { ...response, ...data };
+}
+export async function getGroupJobsCount(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).getGroupJobsCount(ctx.name, id);
+    const response = await send(ctx, { cmd: 'GetGroupJobsCount', groupId: id });
+    return Number(response.count ?? 0);
+}
+export async function getGroupsJobsCount(ctx, maxCount = 100) {
+    if (ctx.embedded)
+        return await manager(ctx).getGroupsJobsCount(ctx.name);
+    const response = await send(ctx, { cmd: 'GetGroupsJobsCount', maxCount });
+    return Number(response.count ?? 0);
+}
+export async function getGroupActiveCount(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).getGroupActiveCount(ctx.name, id);
+    const response = await send(ctx, { cmd: 'GetGroupActiveCount', groupId: id });
+    return Number(response.count ?? 0);
+}
+export async function setGroupRateLimit(ctx, groupId, max, duration) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded) {
+        await manager(ctx).setGroupRateLimit(ctx.name, id, max, duration);
+        return;
+    }
+    await send(ctx, { cmd: 'SetGroupRateLimit', groupId: id, max, duration });
+}
+export async function getGroupRateLimit(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).getGroupRateLimit(ctx.name, id);
+    const response = await send(ctx, { cmd: 'GetGroupRateLimit', groupId: id });
+    return response.limit ?? null;
+}
+export async function removeGroupRateLimit(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).removeGroupRateLimit(ctx.name, id);
+    const response = await send(ctx, { cmd: 'RemoveGroupRateLimit', groupId: id });
+    return Number(response.removed ?? 0);
+}
+export async function getGroupRateLimitTtl(ctx, groupId, maxJobs) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded) {
+        return await manager(ctx).getGroupRateLimitTtl(ctx.name, id, maxJobs);
+    }
+    const response = await send(ctx, { cmd: 'GetGroupRateLimitTtl', groupId: id, maxJobs });
+    return Number(response.ttl ?? -2);
+}
+export async function setGroupConcurrency(ctx, groupId, concurrency) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded) {
+        await manager(ctx).setGroupConcurrency(ctx.name, id, concurrency);
+        return;
+    }
+    await send(ctx, { cmd: 'SetGroupConcurrency', groupId: id, concurrency });
+}
+export async function getGroupConcurrency(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).getGroupConcurrency(ctx.name, id);
+    const response = await send(ctx, { cmd: 'GetGroupConcurrency', groupId: id });
+    return typeof response.concurrency === 'number' ? response.concurrency : null;
+}
+export async function removeGroupConcurrency(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).removeGroupConcurrency(ctx.name, id);
+    const response = await send(ctx, { cmd: 'RemoveGroupConcurrency', groupId: id });
+    return Number(response.removed ?? 0);
+}

package/dist/client/queue/runtime/queries.d.ts

@@ -3,6 +3,19 @@ import * as countsOps from '../operations/counts';
 import { QueueState } from './state';
 /** Job creation, lookup, state-listing, and count operations. */
 export declare class QueueQueries<T> extends QueueState<T> {
+    getGroupJobsCount(groupId: string): Promise<number>;
+    getGroupsJobsCount(maxCount?: number): Promise<number>;
+    getGroupActiveCount(groupId: string): Promise<number>;
+    setGroupRateLimit(groupId: string, max: number, duration: number): Promise<void>;
+    getGroupRateLimit(groupId: string): Promise<{
+        max: number;
+        duration: number;
+    } | null>;
+    removeGroupRateLimit(groupId: string): Promise<number>;
+    getGroupRateLimitTtl(groupId: string, maxJobs?: number): Promise<number>;
+    setGroupConcurrency(groupId: string, concurrency: number): Promise<void>;
+    getGroupConcurrency(groupId: string): Promise<number | null>;
+    removeGroupConcurrency(groupId: string): Promise<number>;
     add(name: string, data: T, opts?: JobOptions): Promise<Job<T>>;
     addBulk(jobs: Array<{
         name: string;

package/dist/client/queue/runtime/queries.js

@@ -2,9 +2,40 @@ import * as countsOps from '../operations/counts';
 import * as addOps from '../operations/add';
 import * as queryOps from '../operations/query';
 import * as queryStateOps from '../operations/queryStates';
+import * as groupOps from '../operations/groups';
 import { QueueState } from './state';
 /** Job creation, lookup, state-listing, and count operations. */
 export class QueueQueries extends QueueState {
+    getGroupJobsCount(groupId) {
+        return groupOps.getGroupJobsCount(this.ctx, groupId);
+    }
+    getGroupsJobsCount(maxCount) {
+        return groupOps.getGroupsJobsCount(this.ctx, maxCount);
+    }
+    getGroupActiveCount(groupId) {
+        return groupOps.getGroupActiveCount(this.ctx, groupId);
+    }
+    setGroupRateLimit(groupId, max, duration) {
+        return groupOps.setGroupRateLimit(this.ctx, groupId, max, duration);
+    }
+    getGroupRateLimit(groupId) {
+        return groupOps.getGroupRateLimit(this.ctx, groupId);
+    }
+    removeGroupRateLimit(groupId) {
+        return groupOps.removeGroupRateLimit(this.ctx, groupId);
+    }
+    getGroupRateLimitTtl(groupId, maxJobs) {
+        return groupOps.getGroupRateLimitTtl(this.ctx, groupId, maxJobs);
+    }
+    setGroupConcurrency(groupId, concurrency) {
+        return groupOps.setGroupConcurrency(this.ctx, groupId, concurrency);
+    }
+    getGroupConcurrency(groupId) {
+        return groupOps.getGroupConcurrency(this.ctx, groupId);
+    }
+    removeGroupConcurrency(groupId) {
+        return groupOps.removeGroupConcurrency(this.ctx, groupId);
+    }
     add(name, data, opts) {
         if (this.addBatcher && !opts?.durable) {
             return this.addBatcher.enqueue(name, data, opts);

package/dist/client/queue/runtime/state.d.ts

@@ -18,6 +18,7 @@ export declare class QueueState<T> {
         embedded: boolean;
         tcp: TcpConnectionPool | null;
         prefixKey: string;
+        dataPath: string | undefined;
     };
     protected get addCtx(): {
         opts: QueueOptions;
@@ -55,6 +56,7 @@ export declare class QueueState<T> {
         embedded: boolean;
         tcp: TcpConnectionPool | null;
         prefixKey: string;
+        dataPath: string | undefined;
     };
     protected get queryCtx(): {
         getJobState: (id: string) => Promise<import("../../types").JobStateType>;
@@ -84,6 +86,7 @@ export declare class QueueState<T> {
         embedded: boolean;
         tcp: TcpConnectionPool | null;
         prefixKey: string;
+        dataPath: string | undefined;
     };
     protected get moveCtx(): {
         getJobState: (id: string) => Promise<import("../../types").JobStateType>;
@@ -92,6 +95,7 @@ export declare class QueueState<T> {
         embedded: boolean;
         tcp: TcpConnectionPool | null;
         prefixKey: string;
+        dataPath: string | undefined;
     };
     protected releaseConnection(): void;
 }

package/dist/client/queue/runtime/state.js

@@ -78,6 +78,7 @@ export class QueueState {
             embedded: this.embedded,
             tcp: this.tcpPool,
             prefixKey: this.prefixKey,
+            dataPath: this.opts.dataPath,
         };
     }
     get addCtx() {

package/dist/client/types/index.d.ts

@@ -4,7 +4,7 @@ export type { ActiveEvent, CompletedEvent, DelayedEvent, DrainedEvent, Duplicate
 export type { FlowJobData, Processor, QueueEventType } from './flow';
 export type { ChangePriorityOpts, GetDependenciesOpts, Job, JobDependencies, JobDependenciesCount, JobJson, JobJsonRaw, JobStateType, } from './job';
 export type { QueueMetrics, QueueMetricsMeta, QueueMetricType } from './metrics';
-export type { BackoffOptions, DebounceOptions, DeduplicationOptions, JobOptions, KeepJobs, ParentOpts, RepeatOptions, } from './options';
-export type { RateLimiterOptions, StallConfig, WorkerOptions } from './worker';
+export type { BackoffOptions, DebounceOptions, DeduplicationOptions, GroupJobOptions, JobOptions, KeepJobs, ParentOpts, RepeatOptions, } from './options';
+export type { GroupWorkerOptions, RateLimiterOptions, StallConfig, WorkerOptions } from './worker';
 export { createPublicJob, toDlqEntry, toPublicJob } from '../jobConversion';
 export type { CreatePublicJobOptions, ToPublicJobOptions } from '../jobConversion';

package/dist/client/types/options.d.ts

@@ -33,6 +33,9 @@ export interface RepeatOptions {
     offset?: number;
     jobId?: string;
 }
+export interface GroupJobOptions {
+    id: string | number;
+}
 /** Options accepted when adding a job. */
 export interface JobOptions {
     priority?: number;
@@ -59,4 +62,5 @@ export interface JobOptions {
     timestamp?: number;
     deduplication?: DeduplicationOptions;
     debounce?: DebounceOptions;
+    group?: GroupJobOptions;
 }

package/dist/client/types/worker.d.ts

@@ -4,6 +4,13 @@ export interface RateLimiterOptions {
     duration: number;
     groupKey?: string;
 }
+export interface GroupWorkerOptions {
+    concurrency?: number;
+    limit?: {
+        max: number;
+        duration: number;
+    };
+}
 export interface WorkerOptions {
     concurrency?: number;
     autorun?: boolean;
@@ -16,6 +23,7 @@ export interface WorkerOptions {
     pollTimeout?: number;
     useLocks?: boolean;
     limiter?: RateLimiterOptions;
+    group?: GroupWorkerOptions;
     lockDuration?: number;
     maxStalledCount?: number;
     skipStalledCheck?: boolean;

package/dist/client/worker/runtime/execution.js

@@ -113,6 +113,7 @@ export class WorkerExecution extends WorkerPolling {
             useLocks: this.opts.useLocks,
             pollTimeout: this.opts.pollTimeout,
             lockDuration: this.opts.lockDuration,
+            group: this.opts.group,
         };
     }
 }

package/dist/client/worker/runtime/options.js

@@ -1,7 +1,9 @@
+import { assertGroupPullOptions } from '../../../domain/types/group';
 import { resolveToken } from '../../resolveToken';
 import { TcpConnectionPool } from '../../tcpPool';
 import { WORKER_CONSTANTS } from '../constants';
 export function resolveWorkerOptions(options, embedded) {
+    assertGroupPullOptions(options.group);
     return {
         concurrency: options.concurrency ?? 1,
         autorun: options.autorun ?? true,
@@ -18,6 +20,7 @@ export function resolveWorkerOptions(options, embedded) {
         removeOnComplete: options.removeOnComplete,
         removeOnFail: options.removeOnFail,
         connection: options.connection,
+        group: options.group,
     };
 }
 export function createTcpPool(options, concurrency) {

package/dist/client/worker/types/options.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionOptions } from '../../types';
+import type { ConnectionOptions, GroupWorkerOptions } from '../../types';
 export interface ExtendedWorkerOptions {
     concurrency: number;
     autorun: boolean;
@@ -21,4 +21,5 @@ export interface ExtendedWorkerOptions {
         count?: number;
     };
     connection?: ConnectionOptions;
+    group?: GroupWorkerOptions;
 }

package/dist/client/worker/workerPull.d.ts

@@ -4,6 +4,7 @@
  */
 import type { Job as InternalJob } from '../../domain/types/job';
 import type { TcpConnection } from './types';
+import type { GroupWorkerOptions } from '../types';
 export interface PullConfig {
     readonly name: string;
     readonly workerId: string;
@@ -11,6 +12,7 @@ export interface PullConfig {
     readonly pollTimeout: number;
     /** Lock TTL in ms to request from the server on a lock-based pull. */
     readonly lockDuration?: number;
+    readonly group?: GroupWorkerOptions;
 }
 export declare function pullEmbedded(config: PullConfig, count: number): Promise<Array<{
     job: InternalJob;