bunqueue 2.8.53 → 2.8.54

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

@@ -7,6 +7,7 @@ import { getSharedManager } from '../../manager';
 import { toPublicJob } from '../../types';
 import { jobId } from '../../../domain/types/job';
 import { createJobProxy, createSimpleJob } from '../jobProxy';
+import { removeJobDeduplicationKey } from '../../jobDeduplication';
 /** Add a single job */
 export async function add(ctx, jobName, data, opts = {}) {
     const merged = { ...ctx.opts.defaultJobOptions, ...opts };
@@ -82,6 +83,12 @@ export async function add(ctx, jobName, data, opts = {}) {
         return toPublicJob({
             job,
             name: jobName,
+            updateProgress: async (jid, progress, message) => {
+                await manager.updateProgress(jobId(jid), progress, message);
+            },
+            log: async (jid, message) => {
+                manager.addLog(jobId(jid), message);
+            },
             getState: (jid) => ctx.getJobState(jid),
             remove: (jid) => ctx.removeAsync(jid),
             retry: (jid) => ctx.retryJob(jid),
@@ -100,6 +107,16 @@ export async function add(ctx, jobName, data, opts = {}) {
             moveToDelayed: (jid, timestamp, token) => ctx.moveJobToDelayed(jid, timestamp, token),
             moveToWaitingChildren: (jid, token, o) => ctx.moveJobToWaitingChildren(jid, token, o),
             waitUntilFinished: (jid, queueEvents, ttl) => ctx.waitJobUntilFinished(jid, queueEvents, ttl),
+            removeDeduplicationKey: (jid) => removeJobDeduplicationKey(jid, true, null),
+            discard: (jid) => {
+                void manager.discard(jobId(jid));
+            },
+            getFailedChildrenValues: (jid) => manager.getFailedChildrenValues(jobId(jid)),
+            getIgnoredChildrenFailures: (jid) => manager.getIgnoredChildrenFailures(jobId(jid)),
+            removeChildDependency: (jid) => manager.removeChildDependency(jobId(jid)),
+            removeUnprocessedChildren: async (jid) => {
+                await manager.removeUnprocessedChildren(jobId(jid));
+            },
         });
     }
     // TCP mode — forward the full option set so nothing is silently dropped (#88)

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

@@ -4,6 +4,7 @@
  */
 export * from './add';
 export * from './query';
+export * from './queryStates';
 export * from './counts';
 export * from './control';
 export * from './management';

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

@@ -4,6 +4,7 @@
  */
 export * from './add';
 export * from './query';
+export * from './queryStates';
 export * from './counts';
 export * from './control';
 export * from './management';

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

@@ -1,7 +1,3 @@
-/**
- * Queue Management Operations
- * remove, retry, clean, promote, updateProgress, logs
- */
 import type { TcpConnectionPool } from '../../tcpPool';
 interface ManagementContext {
     name: string;

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

@@ -54,15 +54,43 @@ export async function retryJob(ctx, id) {
 }
 /** Retry jobs matching criteria */
 export async function retryJobs(ctx, opts) {
+    const state = opts?.state ?? 'failed';
     if (ctx.embedded) {
-        if (opts?.state === 'failed') {
-            // #111-class: forward the count cap (was ignored → retried the whole DLQ).
-            getSharedManager().retryDlq(ctx.name, undefined, opts?.count);
+        const manager = getSharedManager();
+        if (state === 'completed') {
+            manager.retryCompleted(ctx.name, undefined, {
+                limit: opts?.count,
+                timestamp: opts?.timestamp,
+            });
+        }
+        else if (opts?.timestamp !== undefined) {
+            manager.retryDlqByFilter(ctx.name, {
+                olderThan: opts.timestamp,
+                limit: opts.count,
+            });
+        }
+        else {
+            manager.retryDlq(ctx.name, undefined, opts?.count);
         }
         return;
     }
-    if (opts?.state === 'failed') {
-        await ctx.tcp.send({ cmd: 'RetryDlq', queue: ctx.name, count: opts?.count });
+    if (state === 'completed') {
+        await ctx.tcp.send({
+            cmd: 'RetryCompleted',
+            queue: ctx.name,
+            count: opts?.count,
+            timestamp: opts?.timestamp,
+        });
+    }
+    else {
+        await ctx.tcp.send({
+            cmd: 'RetryDlq',
+            queue: ctx.name,
+            count: opts?.count,
+            filter: opts?.timestamp === undefined
+                ? undefined
+                : { olderThan: opts.timestamp, limit: opts.count },
+        });
     }
 }
 // ============ Clean Operations ============

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

@@ -1,10 +1,6 @@
-/**
- * Queue Query Operations
- * getJob, getJobs, getJobState, getJobsAsync
- */
 import type { TcpConnectionPool } from '../../tcpPool';
 import type { Job, JobStateType, GetDependenciesOpts, JobDependencies, JobDependenciesCount } from '../../types';
-interface QueryContext {
+export interface QueryContext {
     name: string;
     embedded: boolean;
     tcp: TcpConnectionPool | null;
@@ -51,19 +47,4 @@ interface GetJobsOptions {
 export declare function getJobs<T>(ctx: QueryContext, options?: GetJobsOptions): Job<T>[];
 /** Get jobs with filtering (async, works with TCP) */
 export declare function getJobsAsync<T>(ctx: QueryContext, options?: GetJobsOptions): Promise<Job<T>[]>;
-/** Get waiting jobs */
-export declare function getWaiting<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
-export declare function getWaitingAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
-/** Get delayed jobs */
-export declare function getDelayed<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
-export declare function getDelayedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
-/** Get active jobs */
-export declare function getActive<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
-export declare function getActiveAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
-/** Get completed jobs */
-export declare function getCompleted<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
-export declare function getCompletedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
-/** Get failed jobs */
-export declare function getFailed<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
-export declare function getFailedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
 export {};

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

@@ -1,13 +1,11 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-unnecessary-condition, @typescript-eslint/switch-exhaustiveness-check */
-/**
- * Queue Query Operations
- * getJob, getJobs, getJobState, getJobsAsync
- */
 import { getSharedManager } from '../../manager';
 import { toPublicJob } from '../../types';
 import { jobId } from '../../../domain/types/job';
 import { createSimpleJob } from '../jobProxy';
 import { buildJobOpts } from '../../jobHelpers';
+import { removeJobDeduplicationKey } from '../../jobDeduplication';
+import { fetchTcpJobRows } from './queryTcpPages';
 /** Last failure's error message from the job timeline (#74) */
 function lastFailedError(timeline) {
     if (!timeline)
@@ -44,6 +42,10 @@ export async function getJob(ctx, id) {
             return toPublicJob({
                 job,
                 name,
+                updateProgress: async (jid, progress, message) => {
+                    await mgr.updateProgress(jobId(jid), progress, message);
+                },
+                log: (jid, message) => Promise.resolve(void mgr.addLog(jobId(jid), message)),
                 getState: (jid) => ctx.getJobState(jid),
                 remove: (jid) => ctx.removeAsync(jid),
                 retry: (jid) => ctx.retryJob(jid),
@@ -72,6 +74,7 @@ export async function getJob(ctx, id) {
                 getFailedChildrenValues: (jid) => mgr.getFailedChildrenValues(jobId(jid)),
                 getIgnoredChildrenFailures: (jid) => mgr.getIgnoredChildrenFailures(jobId(jid)),
                 removeChildDependency: (jid) => mgr.removeChildDependency(jobId(jid)),
+                removeDeduplicationKey: (jid) => removeJobDeduplicationKey(jid, true, null),
                 removeUnprocessedChildren: async (jid) => {
                     await mgr.removeUnprocessedChildren(jobId(jid));
                 },
@@ -161,7 +164,12 @@ export function getJobs(ctx, options = {}) {
     const jobs = manager.getJobs(ctx.name, {
         state: options.state,
         start: options.start ?? 0,
-        end: options.end !== undefined && options.end >= 0 ? options.end : 100,
+        asc: options.asc,
+        end: options.end === -1
+            ? Number.MAX_SAFE_INTEGER
+            : options.end !== undefined && options.end >= 0
+                ? options.end
+                : 100,
     });
     return jobs.map((j) => {
         const name = j.data?.name ?? 'unknown';
@@ -186,22 +194,14 @@ export function getJobs(ctx, options = {}) {
 export async function getJobsAsync(ctx, options = {}) {
     if (ctx.embedded)
         return getJobs(ctx, options);
-    // Handle end=-1 as "get all"
-    const end = options.end !== undefined && options.end >= 0 ? options.end : 1000;
-    const start = options.start ?? 0;
-    const response = await ctx.tcp.send({
-        cmd: 'GetJobs',
-        queue: ctx.name,
-        state: options.state,
-        offset: start,
-        limit: end - start,
-    });
-    if (!response.ok || !Array.isArray(response.jobs)) {
+    if (!ctx.tcp)
+        return [];
+    const rows = await fetchTcpJobRows({ name: ctx.name, tcp: ctx.tcp }, options);
+    if (!rows)
         return [];
-    }
     // handleGetJobs returns the full internal job per element ({ ...job, state }),
     // so reflect the complete opts via metaFromJob instead of a slim subset (#90).
-    const jobs = response.jobs;
+    const jobs = rows;
     const now = Date.now();
     return jobs.map((j) => {
         const name = j.data?.name ?? 'unknown';
@@ -230,38 +230,3 @@ export async function getJobsAsync(ctx, options = {}) {
         return result;
     });
 }
-/** Get waiting jobs */
-export function getWaiting(ctx, start = 0, end = 100) {
-    return getJobs(ctx, { state: 'waiting', start, end });
-}
-export async function getWaitingAsync(ctx, start = 0, end = 100) {
-    return getJobsAsync(ctx, { state: 'waiting', start, end });
-}
-/** Get delayed jobs */
-export function getDelayed(ctx, start = 0, end = 100) {
-    return getJobs(ctx, { state: 'delayed', start, end });
-}
-export async function getDelayedAsync(ctx, start = 0, end = 100) {
-    return getJobsAsync(ctx, { state: 'delayed', start, end });
-}
-/** Get active jobs */
-export function getActive(ctx, start = 0, end = 100) {
-    return getJobs(ctx, { state: 'active', start, end });
-}
-export async function getActiveAsync(ctx, start = 0, end = 100) {
-    return getJobsAsync(ctx, { state: 'active', start, end });
-}
-/** Get completed jobs */
-export function getCompleted(ctx, start = 0, end = 100) {
-    return getJobs(ctx, { state: 'completed', start, end });
-}
-export async function getCompletedAsync(ctx, start = 0, end = 100) {
-    return getJobsAsync(ctx, { state: 'completed', start, end });
-}
-/** Get failed jobs */
-export function getFailed(ctx, start = 0, end = 100) {
-    return getJobs(ctx, { state: 'failed', start, end });
-}
-export async function getFailedAsync(ctx, start = 0, end = 100) {
-    return getJobsAsync(ctx, { state: 'failed', start, end });
-}

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

@@ -0,0 +1,13 @@
+/** State-specific aliases over the generic queue query operations. */
+import type { Job } from '../../types';
+import { type QueryContext } from './query';
+export declare function getWaiting<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
+export declare function getWaitingAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getDelayed<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
+export declare function getDelayedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getActive<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
+export declare function getActiveAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getCompleted<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
+export declare function getCompletedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getFailed<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
+export declare function getFailedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;

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

@@ -0,0 +1,32 @@
+/** State-specific aliases over the generic queue query operations. */
+import { getJobs, getJobsAsync } from './query';
+export function getWaiting(ctx, start = 0, end = 100) {
+    return getJobs(ctx, { state: 'waiting', start, end });
+}
+export function getWaitingAsync(ctx, start = 0, end = 100) {
+    return getJobsAsync(ctx, { state: 'waiting', start, end });
+}
+export function getDelayed(ctx, start = 0, end = 100) {
+    return getJobs(ctx, { state: 'delayed', start, end });
+}
+export function getDelayedAsync(ctx, start = 0, end = 100) {
+    return getJobsAsync(ctx, { state: 'delayed', start, end });
+}
+export function getActive(ctx, start = 0, end = 100) {
+    return getJobs(ctx, { state: 'active', start, end });
+}
+export function getActiveAsync(ctx, start = 0, end = 100) {
+    return getJobsAsync(ctx, { state: 'active', start, end });
+}
+export function getCompleted(ctx, start = 0, end = 100) {
+    return getJobs(ctx, { state: 'completed', start, end });
+}
+export function getCompletedAsync(ctx, start = 0, end = 100) {
+    return getJobsAsync(ctx, { state: 'completed', start, end });
+}
+export function getFailed(ctx, start = 0, end = 100) {
+    return getJobs(ctx, { state: 'failed', start, end });
+}
+export function getFailedAsync(ctx, start = 0, end = 100) {
+    return getJobsAsync(ctx, { state: 'failed', start, end });
+}

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

@@ -0,0 +1,14 @@
+import type { TcpConnectionPool } from '../../tcpPool';
+interface TcpQueryContext {
+    name: string;
+    tcp: TcpConnectionPool;
+}
+export interface TcpJobQueryOptions {
+    state?: string | string[];
+    start?: number;
+    end?: number;
+    asc?: boolean;
+}
+/** Read a finite range once, or page until exhaustion when `end` is -1. */
+export declare function fetchTcpJobRows(ctx: TcpQueryContext, options: TcpJobQueryOptions): Promise<Record<string, unknown>[] | null>;
+export {};

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

@@ -0,0 +1,40 @@
+const QUERY_PAGE_SIZE = 1000;
+async function fetchPage(ctx, options, offset, limit) {
+    const response = await ctx.tcp.send({
+        cmd: 'GetJobs',
+        queue: ctx.name,
+        state: options.state,
+        offset,
+        limit,
+        asc: options.asc,
+    });
+    if (!response.ok || !Array.isArray(response.jobs))
+        return null;
+    return response.jobs;
+}
+/** Read a finite range once, or page until exhaustion when `end` is -1. */
+export async function fetchTcpJobRows(ctx, options) {
+    const start = options.start ?? 0;
+    if (options.end !== -1) {
+        const end = options.end !== undefined && options.end >= 0 ? options.end : 1000;
+        return fetchPage(ctx, options, start, end - start);
+    }
+    const rows = [];
+    const seen = new Set();
+    let offset = start;
+    while (true) {
+        const page = await fetchPage(ctx, options, offset, QUERY_PAGE_SIZE);
+        if (!page)
+            return null;
+        for (const row of page) {
+            const id = String(row.id);
+            if (!seen.has(id)) {
+                seen.add(id);
+                rows.push(row);
+            }
+        }
+        if (page.length < QUERY_PAGE_SIZE)
+            return rows;
+        offset += page.length;
+    }
+}

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

@@ -118,11 +118,14 @@ export declare class Queue<T = unknown> {
     getDlqConfig(): DlqConfig;
     getDlqConfigAsync(): Promise<DlqConfig>;
     getDlq(filter?: DlqFilter): DlqEntry<T>[];
+    getDlqAsync(filter?: DlqFilter): Promise<DlqEntry<T>[]>;
     getDlqJobsAsync(count?: number): Promise<Job<T>[]>;
     getDlqStats(): DlqStats;
+    getDlqStatsAsync(): Promise<DlqStats>;
     retryDlq(id?: string): number;
     retryDlqAsync(id?: string): Promise<number>;
     retryDlqByFilter(filter: DlqFilter): number;
+    retryDlqByFilterAsync(filter: DlqFilter): Promise<number>;
     purgeDlq(): number;
     purgeDlqAsync(): Promise<number>;
     retryCompleted(id?: string): number;

package/dist/client/queue/queue.js

@@ -11,6 +11,7 @@ import { getSharedManager } from '../manager';
 // Import operation modules
 import * as addOps from './operations/add';
 import * as queryOps from './operations/query';
+import * as queryStateOps from './operations/queryStates';
 import * as countsOps from './operations/counts';
 import * as controlOps from './operations/control';
 import * as managementOps from './operations/management';
@@ -127,6 +128,8 @@ export class Queue {
             clearJobLogs: (id, keep) => this.clearJobLogs(id, keep),
             getJobDependencies: (id, o) => this.getJobDependencies(id, o),
             getJobDependenciesCount: (id, o) => this.getJobDependenciesCount(id, o),
+            getJobCountsAsync: () => this.getJobCountsAsync(),
+            getJobsAsync: (options) => this.getJobsAsync(options),
             moveJobToCompleted: (id, r, t) => this.moveJobToCompleted(id, r, t),
             moveJobToFailed: (id, e, t) => this.moveJobToFailed(id, e, t),
             moveJobToWait: (id, t) => this.moveJobToWait(id, t),
@@ -195,34 +198,34 @@ export class Queue {
         return queryOps.getJobsAsync(this.queryCtx, opts);
     }
     getWaiting(start, end) {
-        return queryOps.getWaiting(this.queryCtx, start, end);
+        return queryStateOps.getWaiting(this.queryCtx, start, end);
     }
     getWaitingAsync(start, end) {
-        return queryOps.getWaitingAsync(this.queryCtx, start, end);
+        return queryStateOps.getWaitingAsync(this.queryCtx, start, end);
     }
     getDelayed(start, end) {
-        return queryOps.getDelayed(this.queryCtx, start, end);
+        return queryStateOps.getDelayed(this.queryCtx, start, end);
     }
     getDelayedAsync(start, end) {
-        return queryOps.getDelayedAsync(this.queryCtx, start, end);
+        return queryStateOps.getDelayedAsync(this.queryCtx, start, end);
     }
     getActive(start, end) {
-        return queryOps.getActive(this.queryCtx, start, end);
+        return queryStateOps.getActive(this.queryCtx, start, end);
     }
     getActiveAsync(start, end) {
-        return queryOps.getActiveAsync(this.queryCtx, start, end);
+        return queryStateOps.getActiveAsync(this.queryCtx, start, end);
     }
     getCompleted(start, end) {
-        return queryOps.getCompleted(this.queryCtx, start, end);
+        return queryStateOps.getCompleted(this.queryCtx, start, end);
     }
     getCompletedAsync(start, end) {
-        return queryOps.getCompletedAsync(this.queryCtx, start, end);
+        return queryStateOps.getCompletedAsync(this.queryCtx, start, end);
     }
     getFailed(start, end) {
-        return queryOps.getFailed(this.queryCtx, start, end);
+        return queryStateOps.getFailed(this.queryCtx, start, end);
     }
     getFailedAsync(start, end) {
-        return queryOps.getFailedAsync(this.queryCtx, start, end);
+        return queryStateOps.getFailedAsync(this.queryCtx, start, end);
     }
     // ============ Count Operations ============
     getJobCounts() {
@@ -368,7 +371,10 @@ export class Queue {
         return dlqOps.getDlqConfigAsync(this.ctx);
     }
     getDlq(filter) {
-        return dlqOps.getDlq(this.ctx, filter);
+        return dlqOps.getDlq(this.queryCtx, filter);
+    }
+    getDlqAsync(filter) {
+        return dlqOps.getDlqAsync(this.queryCtx, filter);
     }
     getDlqJobsAsync(count) {
         return dlqOps.getDlqJobsAsync(this.queryCtx, count);
@@ -376,6 +382,9 @@ export class Queue {
     getDlqStats() {
         return dlqOps.getDlqStats(this.ctx);
     }
+    getDlqStatsAsync() {
+        return dlqOps.getDlqStatsAsync(this.ctx);
+    }
     retryDlq(id) {
         return dlqOps.retryDlq(this.ctx, id);
     }
@@ -385,6 +394,9 @@ export class Queue {
     retryDlqByFilter(filter) {
         return dlqOps.retryDlqByFilter(this.ctx, filter);
     }
+    retryDlqByFilterAsync(filter) {
+        return dlqOps.retryDlqByFilterAsync(this.ctx, filter);
+    }
     purgeDlq() {
         return dlqOps.purgeDlq(this.ctx);
     }

package/dist/client/queue/rateLimit.d.ts

@@ -16,7 +16,7 @@ export declare function removeGlobalConcurrency(ctx: RateLimitContext): void;
 /** Remove global concurrency limit and resolve once the server has applied it. */
 export declare function removeGlobalConcurrencyAsync(ctx: RateLimitContext): Promise<void>;
 /** Get global concurrency limit */
-export declare function getGlobalConcurrency(_ctx: RateLimitContext): Promise<number | null>;
+export declare function getGlobalConcurrency(ctx: RateLimitContext): Promise<number | null>;
 /**
  * Set global rate limit: `max` jobs per `duration` ms (default 1000ms).
  * The window is honored in both embedded and TCP modes.
@@ -29,7 +29,7 @@ export declare function removeGlobalRateLimit(ctx: RateLimitContext): void;
 /** Remove global rate limit and resolve once the server has applied it. */
 export declare function removeGlobalRateLimitAsync(ctx: RateLimitContext): Promise<void>;
 /** Get global rate limit */
-export declare function getGlobalRateLimit(_ctx: RateLimitContext): Promise<{
+export declare function getGlobalRateLimit(ctx: RateLimitContext): Promise<{
     max: number;
     duration: number;
 } | null>;
@@ -40,7 +40,7 @@ export declare function getGlobalRateLimit(_ctx: RateLimitContext): Promise<{
  */
 export declare function rateLimit(ctx: RateLimitContext, expireTimeMs: number): Promise<void>;
 /** Get rate limit TTL */
-export declare function getRateLimitTtl(_ctx: RateLimitContext, _maxJobs?: number): Promise<number>;
+export declare function getRateLimitTtl(ctx: RateLimitContext, maxJobs?: number): Promise<number>;
 /** Check if queue is at max capacity */
-export declare function isMaxed(_ctx: RateLimitContext): Promise<boolean>;
+export declare function isMaxed(ctx: RateLimitContext): Promise<boolean>;
 export {};

package/dist/client/queue/rateLimit.js

@@ -2,6 +2,15 @@
  * Rate Limit and Concurrency Operations
  */
 import { getSharedManager } from '../manager';
+async function getQueueLimits(ctx, maxJobs) {
+    if (ctx.embedded)
+        return getSharedManager().getQueueLimitStatus(ctx.name, maxJobs);
+    if (!ctx.tcp) {
+        return { rateLimit: null, rateLimitTtl: -2, concurrencyLimit: null, maxed: false };
+    }
+    const response = await ctx.tcp.send({ cmd: 'GetQueueLimits', queue: ctx.name, maxJobs });
+    return response.data.limits;
+}
 /** Set global concurrency limit */
 export function setGlobalConcurrency(ctx, concurrency) {
     if (ctx.embedded) {
@@ -35,8 +44,8 @@ export async function removeGlobalConcurrencyAsync(ctx) {
         await ctx.tcp.send({ cmd: 'ClearConcurrency', queue: ctx.name });
 }
 /** Get global concurrency limit */
-export function getGlobalConcurrency(_ctx) {
-    return Promise.resolve(null);
+export async function getGlobalConcurrency(ctx) {
+    return (await getQueueLimits(ctx)).concurrencyLimit;
 }
 /**
  * Set global rate limit: `max` jobs per `duration` ms (default 1000ms).
@@ -74,8 +83,8 @@ export async function removeGlobalRateLimitAsync(ctx) {
         await ctx.tcp.send({ cmd: 'RateLimitClear', queue: ctx.name });
 }
 /** Get global rate limit */
-export function getGlobalRateLimit(_ctx) {
-    return Promise.resolve(null);
+export function getGlobalRateLimit(ctx) {
+    return getQueueLimits(ctx).then((limits) => limits.rateLimit);
 }
 /**
  * Set temporary rate limit with expiration. The expiry lives broker-side
@@ -94,10 +103,10 @@ export async function rateLimit(ctx, expireTimeMs) {
     }
 }
 /** Get rate limit TTL */
-export function getRateLimitTtl(_ctx, _maxJobs) {
-    return Promise.resolve(0);
+export async function getRateLimitTtl(ctx, maxJobs) {
+    return (await getQueueLimits(ctx, maxJobs)).rateLimitTtl;
 }
 /** Check if queue is at max capacity */
-export function isMaxed(_ctx) {
-    return Promise.resolve(false);
+export async function isMaxed(ctx) {
+    return (await getQueueLimits(ctx)).maxed;
 }

package/dist/client/queue/workers.d.ts

@@ -11,6 +11,18 @@ export interface WorkerInfo {
     id: string;
     name: string;
     addr?: string;
+    queues?: string[];
+    concurrency?: number;
+    hostname?: string;
+    pid?: number;
+    status?: 'active' | 'stale';
+    registeredAt?: number;
+    lastSeen?: number;
+    activeJobs?: number;
+    processedJobs?: number;
+    failedJobs?: number;
+    currentJob?: string | null;
+    uptime?: number;
 }
 /** Get workers processing this queue */
 export declare function getWorkers(ctx: WorkersContext): Promise<WorkerInfo[]>;

package/dist/client/queue/workers.js

@@ -6,12 +6,30 @@ import { getSharedManager } from '../manager';
 /** Get workers processing this queue */
 export async function getWorkers(ctx) {
     if (ctx.embedded) {
-        return [];
+        return getSharedManager()
+            .workerManager.getForQueue(ctx.name)
+            .map((worker) => ({
+            id: worker.id,
+            name: worker.name,
+            queues: worker.queues,
+            concurrency: worker.concurrency,
+            hostname: worker.hostname,
+            pid: worker.pid,
+            status: 'active',
+            registeredAt: worker.registeredAt,
+            lastSeen: worker.lastSeen,
+            activeJobs: worker.activeJobs,
+            processedJobs: worker.processedJobs,
+            failedJobs: worker.failedJobs,
+            currentJob: worker.currentJob,
+            uptime: Date.now() - worker.registeredAt,
+        }));
     }
     const response = await ctx.tcp.send({ cmd: 'ListWorkers' });
     if (!response.ok)
         return [];
-    return response.workers ?? [];
+    const workers = response.data?.workers ?? [];
+    return workers.filter((worker) => worker.queues?.includes(ctx.name));
 }
 /** Get worker count */
 export async function getWorkersCount(ctx) {

package/dist/client/queueGroup.d.ts

@@ -22,6 +22,7 @@ import type { QueueOptions, WorkerOptions, Processor } from './types';
  */
 export declare class QueueGroup {
     readonly prefix: string;
+    private readonly queues;
     constructor(namespace: string);
     /** Get a queue within this group */
     getQueue<T = unknown>(name: string, opts?: QueueOptions): Queue<T>;
@@ -37,4 +38,14 @@ export declare class QueueGroup {
     drainAll(): void;
     /** Obliterate all queues in this group (remove all data) */
     obliterateAll(): void;
+    /** List queues created through this group, including remote queues. */
+    listQueuesAsync(): Promise<string[]>;
+    /** Pause every queue created through this group. */
+    pauseAllAsync(): Promise<void>;
+    /** Resume every queue created through this group. */
+    resumeAllAsync(): Promise<void>;
+    /** Drain waiting jobs from every queue and return the aggregate count. */
+    drainAllAsync(): Promise<number>;
+    /** Remove all data from every queue created through this group. */
+    obliterateAllAsync(): Promise<void>;
 }