bunqueue 2.8.54 → 2.8.57

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

@@ -0,0 +1,29 @@
+import type { ClientTlsOptions } from '../tcp/types';
+import type { JobOptions } from './options';
+export type { ClientTlsOptions } from '../tcp/types';
+export interface ConnectionOptions {
+    host?: string;
+    port?: number;
+    socketPath?: string;
+    tls?: boolean | ClientTlsOptions;
+    token?: string;
+    poolSize?: number;
+    pingInterval?: number;
+    commandTimeout?: number;
+    maxCommandTimeouts?: number;
+    pipelining?: boolean;
+    maxInFlight?: number;
+}
+export interface AutoBatchOptions {
+    enabled?: boolean;
+    maxSize?: number;
+    maxDelayMs?: number;
+}
+export interface QueueOptions {
+    defaultJobOptions?: JobOptions;
+    connection?: ConnectionOptions;
+    embedded?: boolean;
+    dataPath?: string;
+    autoBatch?: AutoBatchOptions;
+    prefixKey?: string;
+}

package/dist/client/types/connection.js

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

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

@@ -0,0 +1,45 @@
+import type { Job } from './job';
+export interface DlqConfig {
+    autoRetry?: boolean;
+    autoRetryInterval?: number;
+    maxAutoRetries?: number;
+    maxAge?: number | null;
+    maxEntries?: number;
+}
+export type FailureReason = 'explicit_fail' | 'max_attempts_exceeded' | 'timeout' | 'stalled' | 'ttl_expired' | 'worker_lost' | 'unknown';
+export interface DlqEntry<T = unknown> {
+    job: Job<T>;
+    enteredAt: number;
+    reason: FailureReason;
+    error: string | null;
+    attempts: Array<{
+        attempt: number;
+        startedAt: number;
+        failedAt: number;
+        reason: FailureReason;
+        error: string | null;
+        duration: number;
+    }>;
+    retryCount: number;
+    lastRetryAt: number | null;
+    nextRetryAt: number | null;
+    expiresAt: number | null;
+}
+export interface DlqStats {
+    total: number;
+    byReason: Record<FailureReason, number>;
+    byQueue: Record<string, number>;
+    pendingRetry: number;
+    expired: number;
+    oldestEntry: number | null;
+    newestEntry: number | null;
+}
+export interface DlqFilter {
+    reason?: FailureReason;
+    olderThan?: number;
+    newerThan?: number;
+    retriable?: boolean;
+    expired?: boolean;
+    limit?: number;
+    offset?: number;
+}

package/dist/client/types/dlq.js

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

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

@@ -0,0 +1,54 @@
+import type { ConnectionOptions } from './connection';
+export interface QueueEventsOptions {
+    /** Select the embedded manager instead of the TCP broker. */
+    embedded?: boolean;
+    /** TCP connection used when embedded is false. */
+    connection?: ConnectionOptions;
+    /** Embedded SQLite path. */
+    dataPath?: string;
+    /** Namespace prefix applied to the queue name. */
+    prefixKey?: string;
+}
+export interface WaitingEvent {
+    jobId: string;
+}
+export interface ActiveEvent {
+    jobId: string;
+}
+export interface CompletedEvent<R = unknown> {
+    jobId: string;
+    returnvalue: R;
+}
+export interface FailedEvent {
+    jobId: string;
+    failedReason: string;
+    data?: unknown;
+}
+export interface ProgressEvent<P = unknown> {
+    jobId: string;
+    data: P;
+}
+export interface StalledEvent {
+    jobId: string;
+}
+export interface RemovedEvent {
+    jobId: string;
+    prev: string;
+}
+export interface DelayedEvent {
+    jobId: string;
+    delay: number;
+}
+export interface DuplicatedEvent {
+    jobId: string;
+}
+export interface RetriedEvent {
+    jobId: string;
+    prev: string;
+}
+export interface WaitingChildrenEvent {
+    jobId: string;
+}
+export interface DrainedEvent {
+    id: string;
+}

package/dist/client/types/events.js

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

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

@@ -0,0 +1,10 @@
+import type { Job } from './job';
+export interface FlowJobData {
+    __flowParentId?: string;
+    __flowParentIds?: string[];
+    __parentId?: string;
+    __parentQueue?: string;
+    __childrenIds?: string[];
+}
+export type Processor<T = unknown, R = unknown> = (job: Job<T & FlowJobData>) => Promise<R> | R;
+export type QueueEventType = 'waiting' | 'active' | 'completed' | 'failed' | 'progress' | 'removed' | 'drained';

package/dist/client/types/flow.js

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

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

@@ -0,0 +1,10 @@
+export type { AutoBatchOptions, ClientTlsOptions, ConnectionOptions, QueueOptions, } from './connection';
+export type { DlqConfig, DlqEntry, DlqFilter, DlqStats, FailureReason } from './dlq';
+export type { ActiveEvent, CompletedEvent, DelayedEvent, DrainedEvent, DuplicatedEvent, FailedEvent, ProgressEvent, QueueEventsOptions, RemovedEvent, RetriedEvent, StalledEvent, WaitingChildrenEvent, WaitingEvent, } from './events';
+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 { createPublicJob, toDlqEntry, toPublicJob } from '../jobConversion';
+export type { CreatePublicJobOptions, ToPublicJobOptions } from '../jobConversion';

package/dist/client/types/index.js

@@ -0,0 +1 @@
+export { createPublicJob, toDlqEntry, toPublicJob } from '../jobConversion';

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

@@ -0,0 +1,127 @@
+import type { JobOptions } from './options';
+export type JobStateType = 'waiting' | 'prioritized' | 'delayed' | 'active' | 'completed' | 'failed' | 'waiting-children' | 'unknown';
+export interface JobJson<T = unknown> {
+    id: string;
+    name: string;
+    data: T;
+    opts: JobOptions;
+    progress: number;
+    delay: number;
+    timestamp: number;
+    attemptsMade: number;
+    stacktrace: string[] | null;
+    returnvalue?: unknown;
+    failedReason?: string;
+    finishedOn?: number;
+    processedOn?: number;
+    queueQualifiedName: string;
+    parentKey?: string;
+}
+export interface JobJsonRaw {
+    id: string;
+    name: string;
+    data: string;
+    opts: string;
+    progress: string;
+    delay: string;
+    timestamp: string;
+    attemptsMade: string;
+    stacktrace: string | null;
+    returnvalue?: string;
+    failedReason?: string;
+    finishedOn?: string;
+    processedOn?: string;
+    parentKey?: string;
+}
+export interface ChangePriorityOpts {
+    priority: number;
+    lifo?: boolean;
+}
+export interface GetDependenciesOpts {
+    processed?: {
+        cursor?: number;
+        count?: number;
+    };
+    unprocessed?: {
+        cursor?: number;
+        count?: number;
+    };
+}
+export interface JobDependencies {
+    processed: Record<string, unknown>;
+    unprocessed: string[];
+    nextProcessedCursor?: number;
+    nextUnprocessedCursor?: number;
+}
+export interface JobDependenciesCount {
+    processed: number;
+    unprocessed: number;
+}
+/** Public BullMQ-compatible job contract. */
+export interface Job<T = unknown> {
+    id: string;
+    name: string;
+    data: T;
+    queueName: string;
+    attemptsMade: number;
+    timestamp: number;
+    progress: number;
+    returnvalue?: unknown;
+    failedReason?: string;
+    parent?: {
+        id: string;
+        queueQualifiedName: string;
+    };
+    delay: number;
+    processedOn?: number;
+    finishedOn?: number;
+    stacktrace: string[] | null;
+    stalledCounter: number;
+    priority: number;
+    parentKey?: string;
+    opts: JobOptions;
+    token?: string;
+    processedBy?: string;
+    deduplicationId?: string;
+    repeatJobKey?: string;
+    attemptsStarted: number;
+    updateProgress(progress: number, message?: string): Promise<void>;
+    log(message: string): Promise<void>;
+    getState(): Promise<JobStateType>;
+    remove(): Promise<void>;
+    retry(): Promise<void>;
+    getChildrenValues<R = unknown>(): Promise<Record<string, R>>;
+    isWaiting(): Promise<boolean>;
+    isActive(): Promise<boolean>;
+    isDelayed(): Promise<boolean>;
+    isCompleted(): Promise<boolean>;
+    isFailed(): Promise<boolean>;
+    isWaitingChildren(): Promise<boolean>;
+    updateData(data: T): Promise<void>;
+    promote(): Promise<void>;
+    changeDelay(delay: number): Promise<void>;
+    changePriority(opts: ChangePriorityOpts): Promise<void>;
+    extendLock(token: string, duration: number): Promise<number>;
+    clearLogs(keepLogs?: number): Promise<void>;
+    getDependencies(opts?: GetDependenciesOpts): Promise<JobDependencies>;
+    getDependenciesCount(opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
+    toJSON(): JobJson<T>;
+    asJSON(): JobJsonRaw;
+    moveToCompleted(returnValue: unknown, token?: string, fetchNext?: boolean): Promise<unknown>;
+    moveToFailed(error: Error, token?: string, fetchNext?: boolean): Promise<void>;
+    moveToWait(token?: string): Promise<boolean>;
+    moveToDelayed(timestamp: number, token?: string): Promise<void>;
+    moveToWaitingChildren(token?: string, opts?: {
+        child?: {
+            id: string;
+            queue: string;
+        };
+    }): Promise<boolean>;
+    waitUntilFinished(queueEvents: unknown, ttl?: number): Promise<unknown>;
+    discard(): void;
+    getFailedChildrenValues(): Promise<Record<string, string>>;
+    getIgnoredChildrenFailures(): Promise<Record<string, string>>;
+    removeChildDependency(): Promise<boolean>;
+    removeDeduplicationKey(): Promise<boolean>;
+    removeUnprocessedChildren(): Promise<void>;
+}

package/dist/client/types/job.js

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

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

@@ -0,0 +1 @@
+export type { QueueMetrics, QueueMetricsMeta, QueueMetricType, } from '../../domain/types/metrics';

package/dist/client/types/metrics.js

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

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

@@ -0,0 +1,62 @@
+export interface ParentOpts {
+    id: string;
+    queue: string;
+}
+export interface BackoffOptions {
+    type: 'fixed' | 'exponential';
+    delay: number;
+}
+export interface KeepJobs {
+    age?: number;
+    count?: number;
+}
+export interface DeduplicationOptions {
+    id: string;
+    ttl?: number;
+    extend?: boolean;
+    replace?: boolean;
+}
+export interface DebounceOptions {
+    id: string;
+    ttl: number;
+}
+export interface RepeatOptions {
+    every?: number;
+    limit?: number;
+    pattern?: string;
+    startDate?: Date | string | number;
+    endDate?: Date | string | number;
+    tz?: string;
+    immediately?: boolean;
+    count?: number;
+    prevMillis?: number;
+    offset?: number;
+    jobId?: string;
+}
+/** Options accepted when adding a job. */
+export interface JobOptions {
+    priority?: number;
+    delay?: number;
+    attempts?: number;
+    backoff?: number | BackoffOptions;
+    timeout?: number;
+    jobId?: string;
+    /** Age/count retention is intentionally unsupported. */
+    removeOnComplete?: boolean;
+    removeOnFail?: boolean;
+    stallTimeout?: number;
+    repeat?: RepeatOptions;
+    durable?: boolean;
+    parent?: ParentOpts;
+    lifo?: boolean;
+    stackTraceLimit?: number;
+    keepLogs?: number;
+    sizeLimit?: number;
+    failParentOnFailure?: boolean;
+    removeDependencyOnFailure?: boolean;
+    continueParentOnFailure?: boolean;
+    ignoreDependencyOnFailure?: boolean;
+    timestamp?: number;
+    deduplication?: DeduplicationOptions;
+    debounce?: DebounceOptions;
+}

package/dist/client/types/options.js

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

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

@@ -0,0 +1,38 @@
+import type { ConnectionOptions } from './connection';
+export interface RateLimiterOptions {
+    max: number;
+    duration: number;
+    groupKey?: string;
+}
+export interface WorkerOptions {
+    concurrency?: number;
+    autorun?: boolean;
+    heartbeatInterval?: number;
+    connection?: ConnectionOptions;
+    embedded?: boolean;
+    dataPath?: string;
+    batchSize?: number;
+    pollTimeout?: number;
+    useLocks?: boolean;
+    limiter?: RateLimiterOptions;
+    lockDuration?: number;
+    maxStalledCount?: number;
+    skipStalledCheck?: boolean;
+    skipLockRenewal?: boolean;
+    drainDelay?: number;
+    removeOnComplete?: boolean | number | {
+        age?: number;
+        count?: number;
+    };
+    removeOnFail?: boolean | number | {
+        age?: number;
+        count?: number;
+    };
+    prefixKey?: string;
+}
+export interface StallConfig {
+    enabled?: boolean;
+    stallInterval?: number;
+    maxStalls?: number;
+    gracePeriod?: number;
+}

package/dist/client/types/worker.js

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