bunqueue 2.8.53 → 2.8.56

package/dist/client/queue/queue.js

@@ -1,535 +1,12 @@
-/**
- * Queue
- * BullMQ-style queue for job management
- */
-import { TcpConnectionPool, getSharedPool, releaseSharedPool } from '../tcpPool';
-import { FORCE_EMBEDDED } from './helpers';
-import { AddBatcher } from './addBatcher';
+/** BullMQ-style queue for job management. */
 import { Forwarder } from '../forwarder';
-import { resolveToken } from '../resolveToken';
-import { getSharedManager } from '../manager';
-// Import operation modules
-import * as addOps from './operations/add';
-import * as queryOps from './operations/query';
-import * as countsOps from './operations/counts';
-import * as controlOps from './operations/control';
-import * as managementOps from './operations/management';
-import * as stallOps from './stall';
-import * as dlqOps from './dlq';
-import * as rateLimitOps from './rateLimit';
-import * as schedulerOps from './scheduler';
-import * as deduplicationOps from './deduplication';
-import * as jobMoveOps from './jobMove';
-import * as workersOps from './workers';
-import * as bullmqCompatOps from './bullmqCompat';
-/**
- * Queue class for adding and managing jobs
- */
-export class Queue {
-    name;
-    /**
-     * Server-side queue key. Equals `name` unless `prefixKey` is set, in which
-     * case it is `prefixKey + name`. All TCP/embedded operations route through
-     * this key so that two queues with the same logical name but different
-     * `prefixKey` values are fully isolated on the broker.
-     */
-    queueKey;
-    prefixKey;
-    opts;
-    embedded;
-    tcpPool;
-    useSharedPool;
-    addBatcher;
-    constructor(name, opts = {}) {
-        this.name = name;
-        this.prefixKey = opts.prefixKey ?? '';
-        this.queueKey = this.prefixKey + name;
-        this.opts = opts;
-        this.embedded = opts.embedded ?? FORCE_EMBEDDED;
-        if (this.embedded) {
-            // Initialize shared manager with programmatic dataPath (if provided)
-            getSharedManager(opts.dataPath);
-            this.tcpPool = null;
-            this.useSharedPool = false;
-            this.addBatcher = null;
-        }
-        else {
-            const connOpts = opts.connection ?? {};
-            const poolSize = connOpts.poolSize ?? 4;
-            const token = resolveToken(connOpts.token);
-            if (poolSize === 4 && !token) {
-                this.tcpPool = getSharedPool({
-                    host: connOpts.host,
-                    port: connOpts.port,
-                    tls: connOpts.tls,
-                    poolSize,
-                    pingInterval: connOpts.pingInterval,
-                    commandTimeout: connOpts.commandTimeout,
-                    maxCommandTimeouts: connOpts.maxCommandTimeouts,
-                    pipelining: connOpts.pipelining,
-                    maxInFlight: connOpts.maxInFlight,
-                });
-                this.useSharedPool = true;
-            }
-            else {
-                this.tcpPool = new TcpConnectionPool({
-                    host: connOpts.host ?? 'localhost',
-                    port: connOpts.port ?? 6789,
-                    token,
-                    tls: connOpts.tls,
-                    poolSize,
-                    pingInterval: connOpts.pingInterval,
-                    commandTimeout: connOpts.commandTimeout,
-                    maxCommandTimeouts: connOpts.maxCommandTimeouts,
-                    pipelining: connOpts.pipelining,
-                    maxInFlight: connOpts.maxInFlight,
-                });
-                this.useSharedPool = false;
-            }
-            // Initialize auto-batcher for TCP mode
-            const autoBatch = opts.autoBatch;
-            if (autoBatch?.enabled === false) {
-                this.addBatcher = null;
-            }
-            else {
-                this.addBatcher = new AddBatcher({
-                    maxSize: autoBatch?.maxSize ?? 50,
-                    maxDelayMs: autoBatch?.maxDelayMs ?? 5,
-                }, (jobs) => addOps.addBulk(this.addCtx, jobs));
-            }
-        }
-    }
-    // Context builders for modules.
-    // `name` here is the **server-side** queue key (already includes prefixKey),
-    // so every operation that forwards `ctx.name` to the broker is automatically
-    // namespaced. The user-facing logical name lives on `this.name`.
-    get ctx() {
-        return {
-            name: this.queueKey,
-            embedded: this.embedded,
-            tcp: this.tcpPool,
-            prefixKey: this.prefixKey,
-        };
-    }
-    get addCtx() {
-        return {
-            ...this.ctx,
-            opts: this.opts,
-            getJobState: (id) => this.getJobState(id),
-            removeAsync: (id) => this.removeAsync(id),
-            retryJob: (id) => this.retryJob(id),
-            getChildrenValues: (id) => this.getChildrenValues(id),
-            updateJobData: (id, data) => this.updateJobData(id, data),
-            promoteJob: (id) => this.promoteJob(id),
-            changeJobDelay: (id, delay) => this.changeJobDelay(id, delay),
-            changeJobPriority: (id, opts) => this.changeJobPriority(id, opts),
-            extendJobLock: (id, token, dur) => this.extendJobLock(id, token, dur),
-            clearJobLogs: (id, keep) => this.clearJobLogs(id, keep),
-            getJobDependencies: (id, o) => this.getJobDependencies(id, o),
-            getJobDependenciesCount: (id, o) => this.getJobDependenciesCount(id, o),
-            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),
-            moveJobToDelayed: (id, ts, t) => this.moveJobToDelayed(id, ts, t),
-            moveJobToWaitingChildren: (id, t, o) => this.moveJobToWaitingChildren(id, t, o),
-            waitJobUntilFinished: (id, qe, ttl) => this.waitJobUntilFinished(id, qe, ttl),
-        };
-    }
-    get queryCtx() {
-        return {
-            ...this.ctx,
-            getJobState: (id) => this.getJobState(id),
-            removeAsync: (id) => this.removeAsync(id),
-            retryJob: (id) => this.retryJob(id),
-            getChildrenValues: (id) => this.getChildrenValues(id),
-            // Extended context for toPublicJob (full opts support)
-            updateJobData: (id, data) => this.updateJobData(id, data),
-            promoteJob: (id) => this.promoteJob(id),
-            changeJobDelay: (id, delay) => this.changeJobDelay(id, delay),
-            changeJobPriority: (id, opts) => this.changeJobPriority(id, opts),
-            extendJobLock: (id, token, dur) => this.extendJobLock(id, token, dur),
-            clearJobLogs: (id, keep) => this.clearJobLogs(id, keep),
-            getJobDependencies: (id, o) => this.getJobDependencies(id, o),
-            getJobDependenciesCount: (id, o) => this.getJobDependenciesCount(id, o),
-            // Move / wait callbacks
-            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),
-            moveJobToDelayed: (id, ts, t) => this.moveJobToDelayed(id, ts, t),
-            moveJobToWaitingChildren: (id, t, o) => this.moveJobToWaitingChildren(id, t, o),
-            waitJobUntilFinished: (id, qe, ttl) => this.waitJobUntilFinished(id, qe, ttl),
-        };
-    }
-    get moveCtx() {
-        return {
-            ...this.ctx,
-            getJobState: (id) => this.getJobState(id),
-            getJobDependencies: (id) => this.getJobDependencies(id),
-        };
-    }
-    // ============ Add Operations ============
-    add(name, data, opts) {
-        // Bypass batcher for durable jobs or when batcher is not active
-        if (this.addBatcher && !opts?.durable) {
-            return this.addBatcher.enqueue(name, data, opts);
-        }
-        return addOps.add(this.addCtx, name, data, opts);
-    }
-    addBulk(jobs) {
-        return addOps.addBulk(this.addCtx, jobs);
-    }
-    // ============ Query Operations ============
-    getJob(id) {
-        return queryOps.getJob(this.queryCtx, id);
-    }
-    getJobState(id) {
-        return queryOps.getJobState(this.queryCtx, id);
-    }
-    getChildrenValues(id) {
-        return queryOps.getChildrenValues(this.queryCtx, id);
-    }
-    getJobs(opts) {
-        return queryOps.getJobs(this.queryCtx, opts);
-    }
-    getJobsAsync(opts) {
-        return queryOps.getJobsAsync(this.queryCtx, opts);
-    }
-    getWaiting(start, end) {
-        return queryOps.getWaiting(this.queryCtx, start, end);
-    }
-    getWaitingAsync(start, end) {
-        return queryOps.getWaitingAsync(this.queryCtx, start, end);
-    }
-    getDelayed(start, end) {
-        return queryOps.getDelayed(this.queryCtx, start, end);
-    }
-    getDelayedAsync(start, end) {
-        return queryOps.getDelayedAsync(this.queryCtx, start, end);
-    }
-    getActive(start, end) {
-        return queryOps.getActive(this.queryCtx, start, end);
-    }
-    getActiveAsync(start, end) {
-        return queryOps.getActiveAsync(this.queryCtx, start, end);
-    }
-    getCompleted(start, end) {
-        return queryOps.getCompleted(this.queryCtx, start, end);
-    }
-    getCompletedAsync(start, end) {
-        return queryOps.getCompletedAsync(this.queryCtx, start, end);
-    }
-    getFailed(start, end) {
-        return queryOps.getFailed(this.queryCtx, start, end);
-    }
-    getFailedAsync(start, end) {
-        return queryOps.getFailedAsync(this.queryCtx, start, end);
-    }
-    // ============ Count Operations ============
-    getJobCounts() {
-        return countsOps.getJobCounts(this.ctx);
-    }
-    getJobCountsAsync() {
-        return countsOps.getJobCountsAsync(this.ctx);
-    }
-    getWaitingCount() {
-        return countsOps.getWaitingCount(this.ctx);
-    }
-    getActiveCount() {
-        return countsOps.getActiveCount(this.ctx);
-    }
-    getCompletedCount() {
-        return countsOps.getCompletedCount(this.ctx);
-    }
-    getFailedCount() {
-        return countsOps.getFailedCount(this.ctx);
-    }
-    getDelayedCount() {
-        return countsOps.getDelayedCount(this.ctx);
-    }
-    count() {
-        return countsOps.count(this.ctx);
-    }
-    countAsync() {
-        return countsOps.countAsync(this.ctx);
-    }
-    getCountsPerPriority() {
-        return countsOps.getCountsPerPriority(this.ctx);
-    }
-    getCountsPerPriorityAsync() {
-        return countsOps.getCountsPerPriorityAsync(this.ctx);
-    }
-    // ============ Control Operations ============
-    pause() {
-        controlOps.pause(this.ctx);
-    }
-    pauseAsync() {
-        return controlOps.pauseAsync(this.ctx);
-    }
-    resume() {
-        controlOps.resume(this.ctx);
-    }
-    resumeAsync() {
-        return controlOps.resumeAsync(this.ctx);
-    }
-    drain() {
-        controlOps.drain(this.ctx);
-    }
-    drainAsync() {
-        return controlOps.drainAsync(this.ctx);
-    }
-    obliterate() {
-        controlOps.obliterate(this.ctx);
-    }
-    obliterateAsync() {
-        return controlOps.obliterateAsync(this.ctx);
-    }
-    isPaused() {
-        return controlOps.isPaused(this.ctx);
-    }
-    isPausedAsync() {
-        return controlOps.isPausedAsync(this.ctx);
-    }
-    waitUntilReady() {
-        return controlOps.waitUntilReady(this.ctx);
-    }
-    // ============ Management Operations ============
-    remove(id) {
-        managementOps.remove(this.ctx, id);
-    }
-    removeAsync(id) {
-        return managementOps.removeAsync(this.ctx, id);
-    }
-    retryJob(id) {
-        return managementOps.retryJob(this.ctx, id);
-    }
-    retryJobs(opts) {
-        return managementOps.retryJobs(this.ctx, opts);
-    }
-    clean(grace, limit, type) {
-        return managementOps.clean(this.ctx, grace, limit, type);
-    }
-    cleanAsync(grace, limit, type) {
-        return managementOps.cleanAsync(this.ctx, grace, limit, type);
-    }
-    promoteJobs(opts) {
-        return managementOps.promoteJobs(this.ctx, opts);
-    }
-    promoteJob(id) {
-        return managementOps.promoteJob(this.ctx, id);
-    }
-    updateJobProgress(id, progress) {
-        return managementOps.updateJobProgress(this.ctx, id, progress);
-    }
-    getJobLogs(id, start, end, _asc) {
-        return managementOps.getJobLogs(this.ctx, id, start, end);
-    }
-    addJobLog(id, logRow, _keepLogs) {
-        return managementOps.addJobLog(this.ctx, id, logRow);
-    }
-    clearJobLogs(id, keepLogs) {
-        return managementOps.clearJobLogs(this.ctx, id, keepLogs);
-    }
-    updateJobData(id, data) {
-        return managementOps.updateJobData(this.ctx, id, data);
-    }
-    changeJobDelay(id, delay) {
-        return managementOps.changeJobDelay(this.ctx, id, delay);
-    }
-    changeJobPriority(id, opts) {
-        return managementOps.changeJobPriority(this.ctx, id, opts);
-    }
-    extendJobLock(id, token, duration) {
-        return managementOps.extendJobLock(this.ctx, id, token, duration);
-    }
-    // ============ Stall Detection ============
-    setStallConfig(config) {
-        stallOps.setStallConfig(this.ctx, config);
-    }
-    setStallConfigAsync(config) {
-        return stallOps.setStallConfigAsync(this.ctx, config);
-    }
-    getStallConfig() {
-        return stallOps.getStallConfig(this.ctx);
-    }
-    getStallConfigAsync() {
-        return stallOps.getStallConfigAsync(this.ctx);
-    }
-    // ============ DLQ Operations ============
-    setDlqConfig(config) {
-        dlqOps.setDlqConfig(this.ctx, config);
-    }
-    setDlqConfigAsync(config) {
-        return dlqOps.setDlqConfigAsync(this.ctx, config);
-    }
-    getDlqConfig() {
-        return dlqOps.getDlqConfig(this.ctx);
-    }
-    getDlqConfigAsync() {
-        return dlqOps.getDlqConfigAsync(this.ctx);
-    }
-    getDlq(filter) {
-        return dlqOps.getDlq(this.ctx, filter);
-    }
-    getDlqJobsAsync(count) {
-        return dlqOps.getDlqJobsAsync(this.queryCtx, count);
-    }
-    getDlqStats() {
-        return dlqOps.getDlqStats(this.ctx);
-    }
-    retryDlq(id) {
-        return dlqOps.retryDlq(this.ctx, id);
-    }
-    retryDlqAsync(id) {
-        return dlqOps.retryDlqAsync(this.ctx, id);
-    }
-    retryDlqByFilter(filter) {
-        return dlqOps.retryDlqByFilter(this.ctx, filter);
-    }
-    purgeDlq() {
-        return dlqOps.purgeDlq(this.ctx);
-    }
-    purgeDlqAsync() {
-        return dlqOps.purgeDlqAsync(this.ctx);
-    }
-    retryCompleted(id) {
-        return dlqOps.retryCompleted(this.ctx, id);
-    }
-    retryCompletedAsync(id) {
-        return dlqOps.retryCompletedAsync(this.ctx, id);
-    }
-    // ============ Rate Limit Operations ============
-    setGlobalConcurrency(concurrency) {
-        rateLimitOps.setGlobalConcurrency(this.ctx, concurrency);
-    }
-    setGlobalConcurrencyAsync(concurrency) {
-        return rateLimitOps.setGlobalConcurrencyAsync(this.ctx, concurrency);
-    }
-    removeGlobalConcurrency() {
-        rateLimitOps.removeGlobalConcurrency(this.ctx);
-    }
-    removeGlobalConcurrencyAsync() {
-        return rateLimitOps.removeGlobalConcurrencyAsync(this.ctx);
-    }
-    getGlobalConcurrency() {
-        return rateLimitOps.getGlobalConcurrency(this.ctx);
-    }
-    setGlobalRateLimit(max, duration) {
-        rateLimitOps.setGlobalRateLimit(this.ctx, max, duration);
-    }
-    setGlobalRateLimitAsync(max, duration) {
-        return rateLimitOps.setGlobalRateLimitAsync(this.ctx, max, duration);
-    }
-    removeGlobalRateLimit() {
-        rateLimitOps.removeGlobalRateLimit(this.ctx);
-    }
-    removeGlobalRateLimitAsync() {
-        return rateLimitOps.removeGlobalRateLimitAsync(this.ctx);
-    }
-    getGlobalRateLimit() {
-        return rateLimitOps.getGlobalRateLimit(this.ctx);
-    }
-    rateLimit(expireTimeMs) {
-        return rateLimitOps.rateLimit(this.ctx, expireTimeMs);
-    }
-    getRateLimitTtl(maxJobs) {
-        return rateLimitOps.getRateLimitTtl(this.ctx, maxJobs);
-    }
-    isMaxed() {
-        return rateLimitOps.isMaxed(this.ctx);
-    }
-    // ============ Scheduler Operations ============
-    upsertJobScheduler(schedulerId, repeatOpts, jobTemplate) {
-        return schedulerOps.upsertJobScheduler({ ...this.ctx, defaultJobOptions: this.opts.defaultJobOptions }, schedulerId, repeatOpts, jobTemplate);
-    }
-    removeJobScheduler(schedulerId) {
-        return schedulerOps.removeJobScheduler(this.ctx, schedulerId);
-    }
-    getJobScheduler(schedulerId) {
-        return schedulerOps.getJobScheduler(this.ctx, schedulerId);
-    }
-    getJobSchedulers(start, end, asc) {
-        return schedulerOps.getJobSchedulers(this.ctx, start, end, asc);
-    }
-    getJobSchedulersCount() {
-        return schedulerOps.getJobSchedulersCount(this.ctx);
-    }
-    // ============ Deduplication Operations ============
-    getDeduplicationJobId(deduplicationId) {
-        return deduplicationOps.getDeduplicationJobId(this.ctx, deduplicationId);
-    }
-    removeDeduplicationKey(deduplicationId) {
-        return deduplicationOps.removeDeduplicationKey(this.ctx, deduplicationId);
-    }
-    // ============ Job Move Operations ============
-    moveJobToCompleted(id, returnValue, token) {
-        return jobMoveOps.moveJobToCompleted(this.moveCtx, id, returnValue, token);
-    }
-    moveJobToFailed(id, error, token) {
-        return jobMoveOps.moveJobToFailed(this.moveCtx, id, error, token);
-    }
-    moveJobToWait(id, token) {
-        return jobMoveOps.moveJobToWait(this.moveCtx, id, token);
-    }
-    moveJobToDelayed(id, timestamp, token) {
-        return jobMoveOps.moveJobToDelayed(this.moveCtx, id, timestamp, token);
-    }
-    moveJobToWaitingChildren(id, token, opts) {
-        return jobMoveOps.moveJobToWaitingChildren(this.moveCtx, id, token, opts);
-    }
-    waitJobUntilFinished(id, queueEvents, ttl) {
-        return jobMoveOps.waitJobUntilFinished(this.moveCtx, id, queueEvents, ttl);
-    }
-    // ============ Dependency Operations ============
-    getJobDependencies(id, opts) {
-        return bullmqCompatOps.getJobDependencies(this.addCtx, id, opts);
-    }
-    getJobDependenciesCount(id, opts) {
-        return bullmqCompatOps.getJobDependenciesCount(this.addCtx, id, opts);
-    }
-    getDependencies(parentId, type, start, end) {
-        return bullmqCompatOps.getDependencies(this.addCtx, parentId, type, start, end);
-    }
-    // ============ BullMQ Compatibility ============
-    getPrioritized(start, end) {
-        return bullmqCompatOps.getPrioritized({
-            ...this.addCtx,
-            getWaitingAsync: (s, e) => this.getWaitingAsync(s, e),
-            getPrioritizedAsync: (s, e) => this.getJobsAsync({ state: 'prioritized', start: s, end: e }),
-        }, start, end);
-    }
-    getPrioritizedCount() {
-        return bullmqCompatOps.getPrioritizedCount({
-            ...this.addCtx,
-            getWaitingAsync: (s, e) => this.getWaitingAsync(s, e),
-            getPrioritizedAsync: (s, e) => this.getJobsAsync({ state: 'prioritized', start: s, end: e }),
-        });
-    }
-    getWaitingChildren(start, end) {
-        return bullmqCompatOps.getWaitingChildren(this.addCtx, start, end);
-    }
-    getWaitingChildrenCount() {
-        return bullmqCompatOps.getWaitingChildrenCount(this.addCtx);
-    }
-    trimEvents(maxLength) {
-        return workersOps.trimEvents(this.ctx, maxLength);
-    }
-    // ============ Worker/Metrics Operations ============
-    getWorkers() {
-        return workersOps.getWorkers(this.ctx);
-    }
-    getWorkersCount() {
-        return workersOps.getWorkersCount(this.ctx);
-    }
-    getMetrics(type, start, end) {
-        return workersOps.getMetrics(this.ctx, type, start, end);
-    }
-    // ============ Forwarding ============
+import { QueueConnection } from './runtime/connection';
+/** Public Queue façade; behavior is implemented by focused runtime layers. */
+export class Queue extends QueueConnection {
     /**
      * Drain this queue's jobs to a remote bunqueue server (store-and-forward).
-     * Typical edge pattern: embedded local queue as offline buffer, forwarded
-     * to a central server over TCP/TLS. Remote failures leave jobs local
-     * (retry → DLQ) — nothing is lost while the uplink is down. Forwarded jobs
-     * carry a deterministic remote jobId so re-forwards never duplicate.
+     * Remote failures leave jobs local and deterministic remote IDs prevent
+     * duplicate delivery when a forward is retried.
      */
     forward(options) {
         return new Forwarder({
@@ -541,22 +18,4 @@ export class Queue {
             connection: this.opts.connection,
         }, options, Queue);
     }
-    // ============ Connection ============
-    async disconnect() {
-        if (this.addBatcher) {
-            await this.addBatcher.flush();
-            await this.addBatcher.waitForInFlight();
-            this.addBatcher.stop();
-        }
-        this.close();
-    }
-    close() {
-        this.addBatcher?.stop();
-        if (this.tcpPool) {
-            if (this.useSharedPool)
-                releaseSharedPool(this.tcpPool);
-            else
-                this.tcpPool.close();
-        }
-    }
 }

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/runtime/compatibility.d.ts

@@ -0,0 +1,13 @@
+import * as workersOps from '../workers';
+import { QueueScheduling } from './scheduling';
+/** BullMQ compatibility helpers plus worker and metrics inspection. */
+export declare class QueueCompatibility<T> extends QueueScheduling<T> {
+    getPrioritized(start?: number, end?: number): Promise<import("../..").Job<T>[]>;
+    getPrioritizedCount(): Promise<number>;
+    getWaitingChildren(start?: number, end?: number): Promise<import("../..").Job<T>[]>;
+    getWaitingChildrenCount(): Promise<number>;
+    trimEvents(maxLength: number): Promise<number>;
+    getWorkers(): Promise<workersOps.WorkerInfo[]>;
+    getWorkersCount(): Promise<number>;
+    getMetrics(type: 'completed' | 'failed', start?: number, end?: number): Promise<import("../..").QueueMetrics>;
+}

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

@@ -0,0 +1,38 @@
+import * as bullmqCompatOps from '../bullmqCompat';
+import * as workersOps from '../workers';
+import { QueueScheduling } from './scheduling';
+/** BullMQ compatibility helpers plus worker and metrics inspection. */
+export class QueueCompatibility extends QueueScheduling {
+    getPrioritized(start, end) {
+        return bullmqCompatOps.getPrioritized({
+            ...this.addCtx,
+            getWaitingAsync: (from, to) => this.getWaitingAsync(from, to),
+            getPrioritizedAsync: (from, to) => this.getJobsAsync({ state: 'prioritized', start: from, end: to }),
+        }, start, end);
+    }
+    getPrioritizedCount() {
+        return bullmqCompatOps.getPrioritizedCount({
+            ...this.addCtx,
+            getWaitingAsync: (from, to) => this.getWaitingAsync(from, to),
+            getPrioritizedAsync: (from, to) => this.getJobsAsync({ state: 'prioritized', start: from, end: to }),
+        });
+    }
+    getWaitingChildren(start, end) {
+        return bullmqCompatOps.getWaitingChildren(this.addCtx, start, end);
+    }
+    getWaitingChildrenCount() {
+        return bullmqCompatOps.getWaitingChildrenCount(this.addCtx);
+    }
+    trimEvents(maxLength) {
+        return workersOps.trimEvents(this.ctx, maxLength);
+    }
+    getWorkers() {
+        return workersOps.getWorkers(this.ctx);
+    }
+    getWorkersCount() {
+        return workersOps.getWorkersCount(this.ctx);
+    }
+    getMetrics(type, start, end) {
+        return workersOps.getMetrics(this.ctx, type, start, end);
+    }
+}