enqiu 0.1.0

package/dist/redis.d.ts

@@ -0,0 +1,202 @@
+import type { AddOptions, BackoffOptions, JobInput, JobLogEntry, JobMap, JobName, JobOutput, JobSnapshot, JobStatus, QueueEventMap, QueueOptions, QueueStats, SerializedError } from "./memory.js";
+export interface RedisCommandClient {
+    /** Bun's native RedisClient shape. */
+    send?(command: string, arguments_: string[]): Promise<unknown>;
+    /** node-redis and compatible clients. */
+    sendCommand?(arguments_: string[]): Promise<unknown>;
+}
+export interface RedisDriverOptions {
+    /** Redis key namespace. @default "enqiu" */
+    prefix?: string;
+    /** Worker polling interval in milliseconds. @default 100 */
+    pollInterval?: number;
+    /** Time before work owned by a dead worker is reclaimed. @default 30000 */
+    visibilityTimeout?: number;
+    /** Terminal job metadata retention in milliseconds. @default 604800000 */
+    retention?: number;
+}
+export interface RedisDriver {
+    readonly kind: "redis";
+    readonly client: RedisCommandClient;
+    readonly prefix: string;
+    readonly pollInterval: number;
+    readonly visibilityTimeout: number;
+    readonly retention: number;
+}
+export interface RedisRetryOptions {
+    retries: number;
+    backoff?: number | BackoffOptions;
+}
+export interface RedisAddOptions extends Omit<AddOptions, "retry"> {
+    retry?: number | RedisRetryOptions;
+}
+export interface RedisQueueOptions extends Omit<QueueOptions, "retry"> {
+    driver: RedisDriver;
+    /**
+     * Start a local worker for these handlers. Set `false` in producer-only
+     * processes. @default true
+     */
+    worker?: boolean;
+    retry?: number | RedisRetryOptions;
+}
+export interface RedisJob<Output = unknown, Input = unknown, Name extends string = string> {
+    readonly id: string;
+    readonly name: Name;
+    readonly input: Input;
+    readonly status: JobStatus;
+    readonly deduplicated: boolean;
+    /** Resolves after Redis atomically accepts the job. */
+    readonly accepted: Promise<void>;
+    readonly result: Promise<Output>;
+    cancel(reason?: string): Promise<boolean>;
+    refresh(): Promise<JobSnapshot<Input, Output, Name>>;
+}
+export interface RedisQueueEventMap extends QueueEventMap {
+    error: Error;
+    recovered: JobSnapshot;
+}
+export interface RedisListOptions {
+    status?: JobStatus;
+    name?: string;
+    before?: number;
+    after?: number;
+    limit?: number;
+    cursor?: string;
+}
+export interface RedisListPage {
+    jobs: JobSnapshot[];
+    cursor?: string;
+}
+export interface RedisScheduleRegistration {
+    id?: string;
+    jobName: string;
+    cron: string;
+    timezone?: string;
+    input: unknown;
+    catchUp?: boolean;
+    submit: RedisAddOptions;
+}
+export interface RedisScheduleSnapshot {
+    id: string;
+    jobName: string;
+    cron: string;
+    timezone: string;
+    status: "active" | "paused";
+    nextRunAt: number;
+    input: unknown;
+    catchUp: boolean;
+}
+export interface RedisScheduleHandle {
+    readonly id: string;
+    readonly nextRunAt: number;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    remove(): Promise<void>;
+    refresh(): Promise<RedisScheduleSnapshot>;
+}
+interface RedisJobRecord {
+    id: string;
+    name: string;
+    input: unknown;
+    status: JobStatus;
+    priority: number;
+    attempt: number;
+    retry: NormalizedRedisRetry;
+    timeout: number | undefined;
+    expiresAt: number | undefined;
+    keyRetention: number;
+    concurrency: RedisAddOptions["concurrency"];
+    throttle: RedisAddOptions["throttle"];
+    debounce: RedisAddOptions["debounce"];
+    createdAt: number;
+    runAt: number;
+    startedAt: number | undefined;
+    finishedAt: number | undefined;
+    progress: unknown;
+    output: unknown;
+    error: SerializedError | undefined;
+    logs: JobLogEntry[];
+    deduplicated: boolean;
+    submission: Promise<void>;
+    submissionError: Error | undefined;
+}
+interface NormalizedRedisRetry {
+    retries: number;
+    backoff: number | BackoffOptions | undefined;
+}
+export declare function redis(client: RedisCommandClient, options?: RedisDriverOptions): RedisDriver;
+export declare class RedisQueue<Jobs extends JobMap> {
+    readonly name: string;
+    private readonly handlers;
+    private readonly driver;
+    private readonly workerEnabled;
+    private concurrency;
+    private readonly retry;
+    private readonly timeout;
+    private readonly rateLimit;
+    private readonly historyLimit;
+    private readonly logLimit;
+    private readonly keys;
+    private readonly local;
+    private readonly listeners;
+    private readonly running;
+    private started;
+    private closed;
+    private workerLoop;
+    private eventLoop;
+    private eventCursor;
+    private sequence;
+    constructor(handlers: Jobs, options: RedisQueueOptions);
+    add<Name extends JobName<Jobs>>(name: Name, input: JobInput<Jobs, Name>, options?: RedisAddOptions): RedisJob<JobOutput<Jobs, Name>, JobInput<Jobs, Name>, Name>;
+    addMany<Name extends JobName<Jobs>>(name: Name, inputs: readonly JobInput<Jobs, Name>[], options?: RedisAddOptions): Array<RedisJob<JobOutput<Jobs, Name>, JobInput<Jobs, Name>, Name>>;
+    get(id: string): Promise<JobSnapshot | undefined>;
+    list(options?: RedisListOptions): Promise<RedisListPage>;
+    cleanup(options?: {
+        status?: JobStatus | readonly JobStatus[];
+        olderThan?: number;
+        limit?: number;
+    }): Promise<string[]>;
+    redrive(id: string): Promise<RedisJob<unknown>>;
+    pauseQueue(): Promise<void>;
+    resumeQueue(): Promise<void>;
+    setGlobalConcurrency(limit: number): Promise<void>;
+    upsertSchedule(registration: RedisScheduleRegistration): Promise<RedisScheduleHandle>;
+    getSchedule(id: string): Promise<RedisScheduleSnapshot | undefined>;
+    pauseSchedule(id: string): Promise<void>;
+    resumeSchedule(id: string): Promise<number>;
+    removeSchedule(id: string): Promise<void>;
+    cancel(id: string, reason?: string): Promise<boolean>;
+    stats(): Promise<QueueStats>;
+    pause(): this;
+    start(): this;
+    setWorkerConcurrency(limit: number): void;
+    onIdle(): Promise<void>;
+    close(options?: {
+        drain?: boolean;
+    }): Promise<void>;
+    on<Event extends keyof RedisQueueEventMap>(event: Event, listener: (payload: RedisQueueEventMap[Event]) => void): () => void;
+    /** @internal */
+    resultFor(record: RedisJobRecord): Promise<unknown>;
+    private handle;
+    private enqueue;
+    private ensureWorker;
+    private work;
+    private claim;
+    private processSchedules;
+    private execute;
+    private heartbeat;
+    private complete;
+    private fail;
+    private localRecordFromClaim;
+    private recordFromSnapshot;
+    private ensureEventLoop;
+    private readEvents;
+    private hasEventListeners;
+    private dispatchRemoteEvent;
+    private publishEvent;
+    private command;
+    private eval;
+    private emit;
+    private assertOpen;
+}
+export {};