@trigger.dev/redis-worker 0.0.0-re2-20250321122245

package/dist/index.d.cts

@@ -0,0 +1,165 @@
+import { Callback, Result, RedisOptions } from '@internal/redis';
+import { Logger } from '@trigger.dev/core/logger';
+import { z } from 'zod';
+import { Tracer } from '@internal/tracing';
+import { RetryOptions } from '@trigger.dev/core/v3/schemas';
+import { Registry } from 'prom-client';
+
+interface MessageCatalogSchema {
+    [key: string]: z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>;
+}
+type MessageCatalogKey<TMessageCatalog extends MessageCatalogSchema> = keyof TMessageCatalog;
+type MessageCatalogValue<TMessageCatalog extends MessageCatalogSchema, TKey extends MessageCatalogKey<TMessageCatalog>> = z.infer<TMessageCatalog[TKey]>;
+type AnyMessageCatalog = MessageCatalogSchema;
+type QueueItem<TMessageCatalog extends MessageCatalogSchema> = {
+    id: string;
+    job: MessageCatalogKey<TMessageCatalog>;
+    item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
+    visibilityTimeoutMs: number;
+    attempt: number;
+    timestamp: Date;
+};
+type AnyQueueItem = {
+    id: string;
+    job: string;
+    item: any;
+    visibilityTimeoutMs: number;
+    attempt: number;
+    timestamp: Date;
+};
+declare class SimpleQueue<TMessageCatalog extends MessageCatalogSchema> {
+    #private;
+    name: string;
+    private redis;
+    private schema;
+    private logger;
+    constructor({ name, schema, redisOptions, logger, }: {
+        name: string;
+        schema: TMessageCatalog;
+        redisOptions: RedisOptions;
+        logger?: Logger;
+    });
+    enqueue({ id, job, item, attempt, availableAt, visibilityTimeoutMs, }: {
+        id?: string;
+        job: MessageCatalogKey<TMessageCatalog>;
+        item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
+        attempt?: number;
+        availableAt?: Date;
+        visibilityTimeoutMs: number;
+    }): Promise<void>;
+    dequeue(count?: number): Promise<Array<QueueItem<TMessageCatalog>>>;
+    ack(id: string): Promise<void>;
+    reschedule(id: string, availableAt: Date): Promise<void>;
+    size({ includeFuture }?: {
+        includeFuture?: boolean;
+    }): Promise<number>;
+    moveToDeadLetterQueue(id: string, errorMessage: string): Promise<void>;
+    sizeOfDeadLetterQueue(): Promise<number>;
+    redriveFromDeadLetterQueue(id: string): Promise<void>;
+    close(): Promise<void>;
+}
+declare module "@internal/redis" {
+    interface RedisCommander<Context> {
+        enqueueItem(queue: string, items: string, id: string, score: number, serializedItem: string, callback?: Callback<number>): Result<number, Context>;
+        dequeueItems(queue: string, items: string, now: number, count: number, callback?: Callback<Array<[string, string, string]>>): Result<Array<[string, string, string]>, Context>;
+        ackItem(queue: string, items: string, id: string, callback?: Callback<number>): Result<number, Context>;
+        redriveFromDeadLetterQueue(queue: string, items: string, dlq: string, dlqItems: string, id: string, callback?: Callback<number>): Result<number, Context>;
+        moveToDeadLetterQueue(queue: string, items: string, dlq: string, dlqItems: string, id: string, errorMessage: string, callback?: Callback<number>): Result<number, Context>;
+    }
+}
+
+type WorkerCatalog = {
+    [key: string]: {
+        schema: z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>;
+        visibilityTimeoutMs: number;
+        retry?: RetryOptions;
+    };
+};
+type QueueCatalogFromWorkerCatalog<Catalog extends WorkerCatalog> = {
+    [K in keyof Catalog]: Catalog[K]["schema"];
+};
+type JobHandler<Catalog extends WorkerCatalog, K extends keyof Catalog> = (params: {
+    id: string;
+    payload: z.infer<Catalog[K]["schema"]>;
+    visibilityTimeoutMs: number;
+    attempt: number;
+}) => Promise<void>;
+type WorkerConcurrencyOptions = {
+    workers?: number;
+    tasksPerWorker?: number;
+    limit?: number;
+};
+type WorkerOptions<TCatalog extends WorkerCatalog> = {
+    name: string;
+    redisOptions: RedisOptions;
+    catalog: TCatalog;
+    jobs: {
+        [K in keyof TCatalog]: JobHandler<TCatalog, K>;
+    };
+    concurrency?: WorkerConcurrencyOptions;
+    pollIntervalMs?: number;
+    immediatePollIntervalMs?: number;
+    shutdownTimeoutMs?: number;
+    logger?: Logger;
+    tracer?: Tracer;
+    metrics?: {
+        register: Registry;
+    };
+};
+declare class Worker<TCatalog extends WorkerCatalog> {
+    private options;
+    private subscriber;
+    private tracer;
+    private metrics;
+    queue: SimpleQueue<QueueCatalogFromWorkerCatalog<TCatalog>>;
+    private jobs;
+    private logger;
+    private workerLoops;
+    private isShuttingDown;
+    private concurrency;
+    private shutdownTimeoutMs;
+    private limiter;
+    constructor(options: WorkerOptions<TCatalog>);
+    start(): this;
+    /**
+     * Enqueues a job for processing.
+     * @param options - The enqueue options.
+     * @param options.id - Optional unique identifier for the job. If not provided, one will be generated. It prevents duplication.
+     * @param options.job - The job type from the worker catalog.
+     * @param options.payload - The job payload that matches the schema defined in the catalog.
+     * @param options.visibilityTimeoutMs - Optional visibility timeout in milliseconds. Defaults to value from catalog.
+     * @param options.availableAt - Optional date when the job should become available for processing. Defaults to now.
+     * @returns A promise that resolves when the job is enqueued.
+     */
+    enqueue<K extends keyof TCatalog>({ id, job, payload, visibilityTimeoutMs, availableAt, }: {
+        id?: string;
+        job: K;
+        payload: z.infer<TCatalog[K]["schema"]>;
+        visibilityTimeoutMs?: number;
+        availableAt?: Date;
+    }): Promise<void>;
+    /**
+     * Reschedules an existing job to a new available date.
+     * If the job isn't in the queue, it will be ignored.
+     */
+    reschedule(id: string, availableAt: Date): Promise<void>;
+    ack(id: string): Promise<void>;
+    /**
+     * The main loop that each worker runs. It repeatedly polls for items,
+     * processes them, and then waits before the next iteration.
+     */
+    private runWorkerLoop;
+    /**
+     * Processes a single item.
+     */
+    private processItem;
+    private withHistogram;
+    private static delay;
+    private setupSubscriber;
+    private handleRedriveMessage;
+    private setupShutdownHandlers;
+    private shutdown;
+    stop(): Promise<void>;
+}
+
+export { type AnyMessageCatalog, type AnyQueueItem, type MessageCatalogKey, type MessageCatalogSchema, type MessageCatalogValue, type QueueItem, SimpleQueue, Worker, type WorkerCatalog, type WorkerConcurrencyOptions };

package/dist/index.d.ts

@@ -0,0 +1,165 @@
+import { Callback, Result, RedisOptions } from '@internal/redis';
+import { Logger } from '@trigger.dev/core/logger';
+import { z } from 'zod';
+import { Tracer } from '@internal/tracing';
+import { RetryOptions } from '@trigger.dev/core/v3/schemas';
+import { Registry } from 'prom-client';
+
+interface MessageCatalogSchema {
+    [key: string]: z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>;
+}
+type MessageCatalogKey<TMessageCatalog extends MessageCatalogSchema> = keyof TMessageCatalog;
+type MessageCatalogValue<TMessageCatalog extends MessageCatalogSchema, TKey extends MessageCatalogKey<TMessageCatalog>> = z.infer<TMessageCatalog[TKey]>;
+type AnyMessageCatalog = MessageCatalogSchema;
+type QueueItem<TMessageCatalog extends MessageCatalogSchema> = {
+    id: string;
+    job: MessageCatalogKey<TMessageCatalog>;
+    item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
+    visibilityTimeoutMs: number;
+    attempt: number;
+    timestamp: Date;
+};
+type AnyQueueItem = {
+    id: string;
+    job: string;
+    item: any;
+    visibilityTimeoutMs: number;
+    attempt: number;
+    timestamp: Date;
+};
+declare class SimpleQueue<TMessageCatalog extends MessageCatalogSchema> {
+    #private;
+    name: string;
+    private redis;
+    private schema;
+    private logger;
+    constructor({ name, schema, redisOptions, logger, }: {
+        name: string;
+        schema: TMessageCatalog;
+        redisOptions: RedisOptions;
+        logger?: Logger;
+    });
+    enqueue({ id, job, item, attempt, availableAt, visibilityTimeoutMs, }: {
+        id?: string;
+        job: MessageCatalogKey<TMessageCatalog>;
+        item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
+        attempt?: number;
+        availableAt?: Date;
+        visibilityTimeoutMs: number;
+    }): Promise<void>;
+    dequeue(count?: number): Promise<Array<QueueItem<TMessageCatalog>>>;
+    ack(id: string): Promise<void>;
+    reschedule(id: string, availableAt: Date): Promise<void>;
+    size({ includeFuture }?: {
+        includeFuture?: boolean;
+    }): Promise<number>;
+    moveToDeadLetterQueue(id: string, errorMessage: string): Promise<void>;
+    sizeOfDeadLetterQueue(): Promise<number>;
+    redriveFromDeadLetterQueue(id: string): Promise<void>;
+    close(): Promise<void>;
+}
+declare module "@internal/redis" {
+    interface RedisCommander<Context> {
+        enqueueItem(queue: string, items: string, id: string, score: number, serializedItem: string, callback?: Callback<number>): Result<number, Context>;
+        dequeueItems(queue: string, items: string, now: number, count: number, callback?: Callback<Array<[string, string, string]>>): Result<Array<[string, string, string]>, Context>;
+        ackItem(queue: string, items: string, id: string, callback?: Callback<number>): Result<number, Context>;
+        redriveFromDeadLetterQueue(queue: string, items: string, dlq: string, dlqItems: string, id: string, callback?: Callback<number>): Result<number, Context>;
+        moveToDeadLetterQueue(queue: string, items: string, dlq: string, dlqItems: string, id: string, errorMessage: string, callback?: Callback<number>): Result<number, Context>;
+    }
+}
+
+type WorkerCatalog = {
+    [key: string]: {
+        schema: z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>;
+        visibilityTimeoutMs: number;
+        retry?: RetryOptions;
+    };
+};
+type QueueCatalogFromWorkerCatalog<Catalog extends WorkerCatalog> = {
+    [K in keyof Catalog]: Catalog[K]["schema"];
+};
+type JobHandler<Catalog extends WorkerCatalog, K extends keyof Catalog> = (params: {
+    id: string;
+    payload: z.infer<Catalog[K]["schema"]>;
+    visibilityTimeoutMs: number;
+    attempt: number;
+}) => Promise<void>;
+type WorkerConcurrencyOptions = {
+    workers?: number;
+    tasksPerWorker?: number;
+    limit?: number;
+};
+type WorkerOptions<TCatalog extends WorkerCatalog> = {
+    name: string;
+    redisOptions: RedisOptions;
+    catalog: TCatalog;
+    jobs: {
+        [K in keyof TCatalog]: JobHandler<TCatalog, K>;
+    };
+    concurrency?: WorkerConcurrencyOptions;
+    pollIntervalMs?: number;
+    immediatePollIntervalMs?: number;
+    shutdownTimeoutMs?: number;
+    logger?: Logger;
+    tracer?: Tracer;
+    metrics?: {
+        register: Registry;
+    };
+};
+declare class Worker<TCatalog extends WorkerCatalog> {
+    private options;
+    private subscriber;
+    private tracer;
+    private metrics;
+    queue: SimpleQueue<QueueCatalogFromWorkerCatalog<TCatalog>>;
+    private jobs;
+    private logger;
+    private workerLoops;
+    private isShuttingDown;
+    private concurrency;
+    private shutdownTimeoutMs;
+    private limiter;
+    constructor(options: WorkerOptions<TCatalog>);
+    start(): this;
+    /**
+     * Enqueues a job for processing.
+     * @param options - The enqueue options.
+     * @param options.id - Optional unique identifier for the job. If not provided, one will be generated. It prevents duplication.
+     * @param options.job - The job type from the worker catalog.
+     * @param options.payload - The job payload that matches the schema defined in the catalog.
+     * @param options.visibilityTimeoutMs - Optional visibility timeout in milliseconds. Defaults to value from catalog.
+     * @param options.availableAt - Optional date when the job should become available for processing. Defaults to now.
+     * @returns A promise that resolves when the job is enqueued.
+     */
+    enqueue<K extends keyof TCatalog>({ id, job, payload, visibilityTimeoutMs, availableAt, }: {
+        id?: string;
+        job: K;
+        payload: z.infer<TCatalog[K]["schema"]>;
+        visibilityTimeoutMs?: number;
+        availableAt?: Date;
+    }): Promise<void>;
+    /**
+     * Reschedules an existing job to a new available date.
+     * If the job isn't in the queue, it will be ignored.
+     */
+    reschedule(id: string, availableAt: Date): Promise<void>;
+    ack(id: string): Promise<void>;
+    /**
+     * The main loop that each worker runs. It repeatedly polls for items,
+     * processes them, and then waits before the next iteration.
+     */
+    private runWorkerLoop;
+    /**
+     * Processes a single item.
+     */
+    private processItem;
+    private withHistogram;
+    private static delay;
+    private setupSubscriber;
+    private handleRedriveMessage;
+    private setupShutdownHandlers;
+    private shutdown;
+    stop(): Promise<void>;
+}
+
+export { type AnyMessageCatalog, type AnyQueueItem, type MessageCatalogKey, type MessageCatalogSchema, type MessageCatalogValue, type QueueItem, SimpleQueue, Worker, type WorkerCatalog, type WorkerConcurrencyOptions };