bunqueue 2.8.53 → 2.8.56

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

@@ -0,0 +1,149 @@
+import { getSharedManager } from '../../manager';
+import { resolveToken } from '../../resolveToken';
+import { TcpConnectionPool, getSharedPool, releaseSharedPool } from '../../tcpPool';
+import { AddBatcher } from '../addBatcher';
+import { FORCE_EMBEDDED } from '../helpers';
+import * as addOps from '../operations/add';
+/** Owns Queue connection state and builds the shared operation contexts. */
+export class QueueState {
+    name;
+    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) {
+            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;
+            }
+            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));
+            }
+        }
+    }
+    get ctx() {
+        return {
+            name: this.queueKey,
+            embedded: this.embedded,
+            tcp: this.tcpPool,
+            prefixKey: this.prefixKey,
+        };
+    }
+    get addCtx() {
+        const queue = this;
+        return {
+            ...this.ctx,
+            opts: this.opts,
+            getJobState: (id) => queue.getJobState(id),
+            removeAsync: (id) => queue.removeAsync(id),
+            retryJob: (id) => queue.retryJob(id),
+            getChildrenValues: (id) => queue.getChildrenValues(id),
+            updateJobData: (id, data) => queue.updateJobData(id, data),
+            promoteJob: (id) => queue.promoteJob(id),
+            changeJobDelay: (id, delay) => queue.changeJobDelay(id, delay),
+            changeJobPriority: (id, options) => queue.changeJobPriority(id, options),
+            extendJobLock: (id, token, duration) => queue.extendJobLock(id, token, duration),
+            clearJobLogs: (id, keep) => queue.clearJobLogs(id, keep),
+            getJobDependencies: (id, options) => queue.getJobDependencies(id, options),
+            getJobDependenciesCount: (id, options) => queue.getJobDependenciesCount(id, options),
+            getJobCountsAsync: () => queue.getJobCountsAsync(),
+            getJobsAsync: (options) => queue.getJobsAsync(options),
+            moveJobToCompleted: (id, result, token) => queue.moveJobToCompleted(id, result, token),
+            moveJobToFailed: (id, error, token) => queue.moveJobToFailed(id, error, token),
+            moveJobToWait: (id, token) => queue.moveJobToWait(id, token),
+            moveJobToDelayed: (id, timestamp, token) => queue.moveJobToDelayed(id, timestamp, token),
+            moveJobToWaitingChildren: (id, token, options) => queue.moveJobToWaitingChildren(id, token, options),
+            waitJobUntilFinished: (id, queueEvents, ttl) => queue.waitJobUntilFinished(id, queueEvents, ttl),
+        };
+    }
+    get queryCtx() {
+        const queue = this;
+        return {
+            ...this.ctx,
+            getJobState: (id) => queue.getJobState(id),
+            removeAsync: (id) => queue.removeAsync(id),
+            retryJob: (id) => queue.retryJob(id),
+            getChildrenValues: (id) => queue.getChildrenValues(id),
+            updateJobData: (id, data) => queue.updateJobData(id, data),
+            promoteJob: (id) => queue.promoteJob(id),
+            changeJobDelay: (id, delay) => queue.changeJobDelay(id, delay),
+            changeJobPriority: (id, options) => queue.changeJobPriority(id, options),
+            extendJobLock: (id, token, duration) => queue.extendJobLock(id, token, duration),
+            clearJobLogs: (id, keep) => queue.clearJobLogs(id, keep),
+            getJobDependencies: (id, options) => queue.getJobDependencies(id, options),
+            getJobDependenciesCount: (id, options) => queue.getJobDependenciesCount(id, options),
+            moveJobToCompleted: (id, result, token) => queue.moveJobToCompleted(id, result, token),
+            moveJobToFailed: (id, error, token) => queue.moveJobToFailed(id, error, token),
+            moveJobToWait: (id, token) => queue.moveJobToWait(id, token),
+            moveJobToDelayed: (id, timestamp, token) => queue.moveJobToDelayed(id, timestamp, token),
+            moveJobToWaitingChildren: (id, token, options) => queue.moveJobToWaitingChildren(id, token, options),
+            waitJobUntilFinished: (id, queueEvents, ttl) => queue.waitJobUntilFinished(id, queueEvents, ttl),
+        };
+    }
+    get moveCtx() {
+        const queue = this;
+        return {
+            ...this.ctx,
+            getJobState: (id) => queue.getJobState(id),
+            getJobDependencies: (id) => queue.getJobDependencies(id),
+        };
+    }
+    releaseConnection() {
+        if (!this.tcpPool)
+            return;
+        if (this.useSharedPool)
+            releaseSharedPool(this.tcpPool);
+        else
+            this.tcpPool.close();
+    }
+}

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

@@ -27,7 +27,7 @@ export interface RepeatOpts {
     offset?: number;
     jobId?: string;
     timezone?: string;
-    /** Skip missed runs on restart instead of executing them (default: false) */
+    /** Skip missed runs on restart instead of executing them (default: true) */
     skipMissedOnRestart?: boolean;
     /** Skip job push if no worker is registered for the queue (default: false) */
     skipIfNoWorker?: boolean;
@@ -50,12 +50,9 @@ export interface SchedulerInfo {
 }
 /** Create or update a job scheduler */
 export declare function upsertJobScheduler(ctx: SchedulerContext, schedulerId: string, repeatOpts: RepeatOpts, jobTemplate?: JobTemplate): Promise<SchedulerInfo | null>;
-/** Remove a job scheduler */
 export declare function removeJobScheduler(ctx: SchedulerContext, schedulerId: string): Promise<boolean>;
 /** Get a job scheduler by ID */
 export declare function getJobScheduler(ctx: SchedulerContext, schedulerId: string): Promise<SchedulerInfo | null>;
-/** Get all job schedulers for this queue */
-export declare function getJobSchedulers(ctx: SchedulerContext, _start?: number, _end?: number, _asc?: boolean): Promise<SchedulerInfo[]>;
-/** Get count of job schedulers */
+export declare function getJobSchedulers(ctx: SchedulerContext, start?: number, end?: number, asc?: boolean): Promise<SchedulerInfo[]>;
 export declare function getJobSchedulersCount(ctx: SchedulerContext): Promise<number>;
 export {};

package/dist/client/queue/scheduler.js

@@ -3,6 +3,7 @@
  * Job Scheduler Operations (BullMQ v5 repeatable jobs)
  */
 import { getSharedManager } from '../manager';
+import { paginateSchedulers } from './schedulerPagination';
 /** Apply the namespace prefix to a user-facing scheduler ID. */
 function toCronName(ctx, schedulerId) {
     return ctx.prefixKey ? `${ctx.prefixKey}${schedulerId}` : schedulerId;
@@ -16,11 +17,7 @@ function fromCronName(ctx, cronName) {
 }
 /** Build cron job data from template */
 function buildCronData(jobTemplate) {
-    if (!jobTemplate)
-        return {};
-    return jobTemplate.name
-        ? { name: jobTemplate.name, ...(jobTemplate.data ?? {}) }
-        : (jobTemplate.data ?? {});
+    return jobTemplate?.data ?? {};
 }
 /**
  * Build the job options carried by every cron-spawned job (issue #86).
@@ -70,8 +67,9 @@ export async function upsertJobScheduler(ctx, schedulerId, repeatOpts, jobTempla
     const priority = jobTemplate?.opts?.priority ?? ctx.defaultJobOptions?.priority;
     if (ctx.embedded) {
         const manager = getSharedManager();
-        manager.addCron({
+        const cron = manager.addCron({
             name: cronName,
+            jobName: jobTemplate?.name ?? 'default',
             queue: ctx.name,
             data,
             schedule: cronPattern,
@@ -89,14 +87,17 @@ export async function upsertJobScheduler(ctx, schedulerId, repeatOpts, jobTempla
         });
         return {
             id: schedulerId,
-            name: jobTemplate?.name ?? 'default',
-            next: Date.now() + (repeatEvery ?? 60000),
-            limit: repeatOpts.limit && repeatOpts.limit > 0 ? repeatOpts.limit : undefined,
+            name: cron.jobName,
+            next: cron.nextRun,
+            pattern: cron.schedule ?? undefined,
+            every: cron.repeatEvery ?? undefined,
+            limit: cron.maxLimit ?? undefined,
         };
     }
     const response = await ctx.tcp.send({
         cmd: 'Cron',
         name: cronName,
+        jobName: jobTemplate?.name ?? 'default',
         queue: ctx.name,
         data,
         schedule: cronPattern,
@@ -114,14 +115,16 @@ export async function upsertJobScheduler(ctx, schedulerId, repeatOpts, jobTempla
     });
     if (!response.ok)
         return null;
+    const returnedCron = response.cron;
     return {
         id: schedulerId,
-        name: jobTemplate?.name ?? 'default',
-        next: (response.nextRun ?? Date.now()),
+        name: returnedCron?.jobName ?? jobTemplate?.name ?? 'default',
+        next: returnedCron?.nextRun ?? Date.now(),
+        pattern: cronPattern,
+        every: repeatEvery,
         limit: repeatOpts.limit && repeatOpts.limit > 0 ? repeatOpts.limit : undefined,
     };
 }
-/** Remove a job scheduler */
 export async function removeJobScheduler(ctx, schedulerId) {
     const cronName = toCronName(ctx, schedulerId);
     if (ctx.embedded) {
@@ -141,7 +144,7 @@ export async function getJobScheduler(ctx, schedulerId) {
             return null;
         return {
             id: fromCronName(ctx, cron.name),
-            name: fromCronName(ctx, cron.name),
+            name: cron.jobName,
             next: cron.nextRun,
             pattern: cron.schedule ?? undefined,
             every: cron.repeatEvery ?? undefined,
@@ -157,45 +160,44 @@ export async function getJobScheduler(ctx, schedulerId) {
         return null;
     return {
         id: fromCronName(ctx, cron.name),
-        name: fromCronName(ctx, cron.name),
+        name: cron.jobName ?? fromCronName(ctx, cron.name),
         next: cron.nextRun,
         pattern: cron.schedule ?? undefined,
         every: cron.repeatEvery ?? undefined,
         limit: cron.maxLimit ?? undefined,
     };
 }
-/** Get all job schedulers for this queue */
-export async function getJobSchedulers(ctx, _start = 0, _end = -1, _asc = true) {
+export async function getJobSchedulers(ctx, start = 0, end = -1, asc = false) {
     if (ctx.embedded) {
-        return getSharedManager()
+        const schedulers = getSharedManager()
             .listCrons()
             .filter((c) => c.queue === ctx.name)
             .map((c) => ({
             id: fromCronName(ctx, c.name),
-            name: fromCronName(ctx, c.name),
+            name: c.jobName,
             next: c.nextRun,
             pattern: c.schedule ?? undefined,
             every: c.repeatEvery ?? undefined,
             limit: c.maxLimit ?? undefined,
         }));
+        return paginateSchedulers(schedulers, start, end, asc);
     }
     const response = await ctx.tcp.send({ cmd: 'CronList' });
     if (!response.ok)
         return [];
     const crons = response.crons ?? [];
-    return crons
+    const schedulers = crons
         .filter((c) => c.queue === ctx.name)
         .map((c) => ({
         id: fromCronName(ctx, c.name),
-        name: fromCronName(ctx, c.name),
+        name: c.jobName ?? fromCronName(ctx, c.name),
         next: c.nextRun,
         pattern: c.schedule ?? undefined,
         every: c.repeatEvery ?? undefined,
         limit: c.maxLimit ?? undefined,
     }));
+    return paginateSchedulers(schedulers, start, end, asc);
 }
-/** Get count of job schedulers */
 export async function getJobSchedulersCount(ctx) {
-    const schedulers = await getJobSchedulers(ctx);
-    return schedulers.length;
+    return (await getJobSchedulers(ctx)).length;
 }

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

@@ -0,0 +1,7 @@
+interface ScheduledEntry {
+    id: string;
+    next: number;
+}
+/** Sort schedulers like BullMQ's scored range and apply its inclusive indexes. */
+export declare function paginateSchedulers<T extends ScheduledEntry>(schedulers: T[], start: number, end: number, asc: boolean): T[];
+export {};

package/dist/client/queue/schedulerPagination.js

@@ -0,0 +1,10 @@
+/** Sort schedulers like BullMQ's scored range and apply its inclusive indexes. */
+export function paginateSchedulers(schedulers, start, end, asc) {
+    const direction = asc ? 1 : -1;
+    schedulers.sort((left, right) => {
+        const byNext = left.next - right.next;
+        const byId = left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+        return (byNext || byId) * direction;
+    });
+    return schedulers.slice(start, end === -1 ? undefined : end + 1);
+}

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

@@ -0,0 +1,40 @@
+import type { TcpConnectionPool } from '../../tcpPool';
+import type { GetDependenciesOpts, JobDependencies, JobDependenciesCount, JobOptions, JobStateType, QueueOptions } from '../../types';
+export interface ExtendedJobOptions extends JobOptions {
+    ttl?: number;
+    dependsOn?: string[];
+    tags?: string[];
+    groupId?: string;
+}
+export interface AddContext {
+    name: string;
+    opts: QueueOptions;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+    getJobState: (id: string) => Promise<JobStateType>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+    updateJobData: (id: string, data: unknown) => Promise<void>;
+    promoteJob: (id: string) => Promise<void>;
+    changeJobDelay: (id: string, delay: number) => Promise<void>;
+    changeJobPriority: (id: string, opts: {
+        priority: number;
+        lifo?: boolean;
+    }) => Promise<void>;
+    extendJobLock: (id: string, token: string, duration: number) => Promise<number>;
+    clearJobLogs: (id: string, keepLogs?: number) => Promise<void>;
+    getJobDependencies: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependencies>;
+    getJobDependenciesCount: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>;
+    moveJobToCompleted: (id: string, result: unknown, token?: string) => Promise<unknown>;
+    moveJobToFailed: (id: string, error: Error, token?: string) => Promise<void>;
+    moveJobToWait: (id: string, token?: string) => Promise<boolean>;
+    moveJobToDelayed: (id: string, timestamp: number, token?: string) => Promise<void>;
+    moveJobToWaitingChildren: (id: string, token?: string, opts?: {
+        child?: {
+            id: string;
+            queue: string;
+        };
+    }) => Promise<boolean>;
+    waitJobUntilFinished: (id: string, queueEvents: unknown, ttl?: number) => Promise<unknown>;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,33 @@
+/**
+ * Queue Internal Types
+ * Shared types for queue module operations
+ */
+import type { TcpConnectionPool } from '../../tcpPool';
+import type { JobStateType, QueueOptions } from '../../types';
+/** Internal queue context for operations */
+export interface QueueContext {
+    name: string;
+    opts: QueueOptions;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+    getJobState: (id: string) => Promise<JobStateType>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+}
+/** Job creation context for proxy */
+export interface JobCreationContext {
+    queueName: string;
+    tcp: TcpConnectionPool | null;
+    getJobState: (id: string) => Promise<string>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+}
+/** TCP response with optional data */
+export interface TcpResponse {
+    ok: boolean;
+    error?: string;
+    data?: unknown;
+    [key: string]: unknown;
+}

package/dist/client/queue/types/contexts.js

@@ -0,0 +1,5 @@
+/**
+ * Queue Internal Types
+ * Shared types for queue module operations
+ */
+export {};

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

@@ -0,0 +1,3 @@
+export type { JobCreationContext, QueueContext, TcpResponse } from './contexts';
+export type { JobReflectionMeta, SimpleJobContext } from './job';
+export type { QueueRuntime } from './runtime';

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,50 @@
+import type { TcpConnectionPool } from '../../tcpPool';
+import type { JobOptions, JobStateType } from '../../types';
+export interface JobProxyContext {
+    queueName: string;
+    tcp: TcpConnectionPool;
+    getJobState: (id: string) => Promise<JobStateType>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+}
+export interface JobReflectionMeta {
+    attemptsMade?: number;
+    attemptsStarted?: number;
+    progress?: number;
+    stalledCounter?: number;
+    priority?: number;
+    delay?: number;
+    processedOn?: number;
+    finishedOn?: number;
+    opts?: JobOptions;
+    timestamp?: number;
+    stacktrace?: string[] | null;
+    returnvalue?: unknown;
+    failedReason?: string;
+}
+export interface ReflectedFields {
+    delay: number;
+    priority: number;
+    opts: JobOptions;
+    deduplicationId: string | undefined;
+    parentKey: string | undefined;
+    parent: {
+        id: string;
+        queueQualifiedName: string;
+    } | undefined;
+    repeatJobKey: string | undefined;
+    stacktrace: string[] | null;
+    returnvalue: unknown;
+    failedReason: string | undefined;
+}
+export interface SimpleJobContext {
+    queueName: string;
+    embedded?: boolean;
+    tcp?: TcpConnectionPool | null;
+    getJobState: (id: string) => Promise<JobStateType>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+    meta?: JobReflectionMeta;
+}

package/dist/client/queue/types/job.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,35 @@
+import type { ChangePriorityOpts, GetDependenciesOpts, Job, JobDependencies, JobDependenciesCount, JobStateType } from '../../types';
+/** Internal contract used by context callbacks across the Queue runtime layers. */
+export interface QueueRuntime<T> {
+    getJobState(id: string): Promise<JobStateType>;
+    removeAsync(id: string): Promise<void>;
+    retryJob(id: string): Promise<void>;
+    getChildrenValues(id: string): Promise<Record<string, unknown>>;
+    updateJobData(id: string, data: unknown): Promise<void>;
+    promoteJob(id: string): Promise<void>;
+    changeJobDelay(id: string, delay: number): Promise<void>;
+    changeJobPriority(id: string, opts: ChangePriorityOpts): Promise<void>;
+    extendJobLock(id: string, token: string, duration: number): Promise<number>;
+    clearJobLogs(id: string, keepLogs?: number): Promise<void>;
+    getJobDependencies(id: string, opts?: GetDependenciesOpts): Promise<JobDependencies>;
+    getJobDependenciesCount(id: string, opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
+    getJobCountsAsync(): Promise<unknown>;
+    getJobsAsync(options: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Promise<Job<T>[]>;
+    moveJobToCompleted(id: string, result: unknown, token?: string): Promise<unknown>;
+    moveJobToFailed(id: string, error: Error, token?: string): Promise<void>;
+    moveJobToWait(id: string, token?: string): Promise<boolean>;
+    moveJobToDelayed(id: string, timestamp: number, token?: string): Promise<void>;
+    moveJobToWaitingChildren(id: string, token?: string, opts?: {
+        child?: {
+            id: string;
+            queue: string;
+        };
+    }): Promise<boolean>;
+    waitJobUntilFinished(id: string, queueEvents: unknown, ttl?: number): Promise<unknown>;
+    getWaitingAsync(start?: number, end?: number): Promise<Job<T>[]>;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -2,6 +2,7 @@
  * Worker Query Operations
  */
 import type { TcpConnectionPool } from '../tcpPool';
+import type { QueueMetrics, QueueMetricType } from '../../domain/types/metrics';
 interface WorkersContext {
     name: string;
     embedded: boolean;
@@ -11,18 +12,25 @@ 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[]>;
 /** Get worker count */
 export declare function getWorkersCount(ctx: WorkersContext): Promise<number>;
 /** Get metrics for this queue */
-export declare function getMetrics(ctx: WorkersContext, type: 'completed' | 'failed', _start?: number, _end?: number): Promise<{
-    meta: {
-        count: number;
-    };
-    data: number[];
-}>;
-/** Trim events (no-op in bunqueue - events are real-time) */
-export declare function trimEvents(_ctx: WorkersContext, _maxLength: number): Promise<number>;
+export declare function getMetrics(ctx: WorkersContext, type: QueueMetricType, start?: number, end?: number): Promise<QueueMetrics>;
+/** Trim old events from this queue's durable lifecycle journal. */
+export declare function trimEvents(ctx: WorkersContext, maxLength: number): Promise<number>;
 export {};

package/dist/client/queue/workers.js

@@ -6,12 +6,32 @@ 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,
+        }));
     }
+    if (!ctx.tcp)
+        return [];
     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) {
@@ -19,22 +39,28 @@ export async function getWorkersCount(ctx) {
     return workers.length;
 }
 /** Get metrics for this queue */
-export async function getMetrics(ctx, type, _start, _end) {
+export async function getMetrics(ctx, type, start = 0, end = -1) {
     if (ctx.embedded) {
-        const stats = getSharedManager().getStats();
-        const count = type === 'completed' ? stats.completed : stats.dlq;
-        return { meta: { count }, data: [] };
+        return getSharedManager().getQueueMetrics(ctx.name, type, start, end);
     }
-    const response = await ctx.tcp.send({ cmd: 'Metrics' });
+    if (!ctx.tcp)
+        throw new Error('TCP connection is not available');
+    const response = await ctx.tcp.send({ cmd: 'Metrics', queue: ctx.name, type, start, end });
     if (!response.ok)
-        return { meta: { count: 0 }, data: [] };
-    // The Metrics handler replies with { ok, metrics: { totalCompleted, totalFailed, ... } }
-    // (resp.metrics). Reading a non-existent `response.stats` always yielded 0.
-    const metrics = response.metrics;
-    const count = type === 'completed' ? (metrics?.totalCompleted ?? 0) : (metrics?.totalFailed ?? 0);
-    return { meta: { count }, data: [] };
+        throw new Error(String(response.error));
+    const metrics = response.data;
+    if (!metrics)
+        throw new Error('Broker returned no queue metrics payload');
+    return metrics;
 }
-/** Trim events (no-op in bunqueue - events are real-time) */
-export function trimEvents(_ctx, _maxLength) {
-    return Promise.resolve(0);
+/** Trim old events from this queue's durable lifecycle journal. */
+export async function trimEvents(ctx, maxLength) {
+    if (ctx.embedded)
+        return getSharedManager().trimQueueEvents(ctx.name, maxLength);
+    if (!ctx.tcp)
+        throw new Error('TCP connection is not available');
+    const response = await ctx.tcp.send({ cmd: 'TrimEvents', queue: ctx.name, maxLength });
+    if (!response.ok)
+        throw new Error(String(response.error));
+    return response.data?.removed ?? 0;
 }

package/dist/client/queue-events/tcpSubscription.d.ts

@@ -0,0 +1,23 @@
+import type { JobEvent } from '../../domain/types/queue';
+import type { ConnectionOptions } from '../types';
+interface TcpEventSubscriptionOptions {
+    connection?: ConnectionOptions;
+    onError: (error: Error) => void;
+    onEvent: (event: JobEvent) => void;
+    queue: string;
+}
+/** One dedicated TCP connection with one broker-side queue subscription. */
+export declare class TcpEventSubscription {
+    private readonly client;
+    private readonly queue;
+    private readonly onError;
+    private closed;
+    private ready;
+    private generation;
+    private subscriptionPromise;
+    constructor(options: TcpEventSubscriptionOptions);
+    waitUntilReady(): Promise<void>;
+    close(): void;
+    private ensureSubscribed;
+}
+export {};