@trigger.dev/redis-worker 4.0.0-v4-beta.24 → 4.0.0-v4-beta.25

package/dist/index.d.cts

@@ -40,13 +40,15 @@ declare class SimpleQueue<TMessageCatalog extends MessageCatalogSchema> {
         redisOptions: RedisOptions;
         logger?: Logger;
     });
-    enqueue({ id, job, item, attempt, availableAt, visibilityTimeoutMs, }: {
+    cancel(cancellationKey: string): Promise<void>;
+    enqueue({ id, job, item, attempt, availableAt, visibilityTimeoutMs, cancellationKey, }: {
         id?: string;
         job: MessageCatalogKey<TMessageCatalog>;
         item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
         attempt?: number;
         availableAt?: Date;
         visibilityTimeoutMs: number;
+        cancellationKey?: string;
     }): Promise<void>;
     enqueueOnce({ id, job, item, attempt, availableAt, visibilityTimeoutMs, }: {
         id: string;
@@ -71,6 +73,7 @@ declare class SimpleQueue<TMessageCatalog extends MessageCatalogSchema> {
 declare module "@internal/redis" {
     interface RedisCommander<Context> {
         enqueueItem(queue: string, items: string, id: string, score: number, serializedItem: string, callback?: Callback<number>): Result<number, Context>;
+        enqueueItemWithCancellationKey(queue: string, items: string, cancellationKey: 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, deduplicationKey: string, callback?: Callback<number>): Result<number, Context>;
         redriveFromDeadLetterQueue(queue: string, items: string, dlq: string, dlqItems: string, id: string, callback?: Callback<number>): Result<number, Context>;
@@ -161,12 +164,13 @@ declare class Worker<TCatalog extends WorkerCatalog> {
      * @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, }: {
+    enqueue<K extends keyof TCatalog>({ id, job, payload, visibilityTimeoutMs, availableAt, cancellationKey, }: {
         id?: string;
         job: K;
         payload: z.infer<TCatalog[K]["schema"]>;
         visibilityTimeoutMs?: number;
         availableAt?: Date;
+        cancellationKey?: string;
     }): Promise<void>;
     /**
      * Enqueues a job for processing once. If the job is already in the queue, it will be ignored.
@@ -190,6 +194,14 @@ declare class Worker<TCatalog extends WorkerCatalog> {
      * If the job isn't in the queue, it will be ignored.
      */
     reschedule(id: string, availableAt: Date): Promise<void>;
+    /**
+     * Cancels a job before it's enqueued.
+     * @param cancellationKey - The cancellation key to cancel.
+     * @returns A promise that resolves when the job is cancelled.
+     *
+     * Any jobs enqueued with the same cancellation key will be not be enqueued.
+     */
+    cancel(cancellationKey: string): Promise<void>;
     ack(id: string): Promise<void>;
     getJob(id: string): Promise<QueueItem<QueueCatalogFromWorkerCatalog<TCatalog>> | null>;
     /**

package/dist/index.d.ts

@@ -40,13 +40,15 @@ declare class SimpleQueue<TMessageCatalog extends MessageCatalogSchema> {
         redisOptions: RedisOptions;
         logger?: Logger;
     });
-    enqueue({ id, job, item, attempt, availableAt, visibilityTimeoutMs, }: {
+    cancel(cancellationKey: string): Promise<void>;
+    enqueue({ id, job, item, attempt, availableAt, visibilityTimeoutMs, cancellationKey, }: {
         id?: string;
         job: MessageCatalogKey<TMessageCatalog>;
         item: MessageCatalogValue<TMessageCatalog, MessageCatalogKey<TMessageCatalog>>;
         attempt?: number;
         availableAt?: Date;
         visibilityTimeoutMs: number;
+        cancellationKey?: string;
     }): Promise<void>;
     enqueueOnce({ id, job, item, attempt, availableAt, visibilityTimeoutMs, }: {
         id: string;
@@ -71,6 +73,7 @@ declare class SimpleQueue<TMessageCatalog extends MessageCatalogSchema> {
 declare module "@internal/redis" {
     interface RedisCommander<Context> {
         enqueueItem(queue: string, items: string, id: string, score: number, serializedItem: string, callback?: Callback<number>): Result<number, Context>;
+        enqueueItemWithCancellationKey(queue: string, items: string, cancellationKey: 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, deduplicationKey: string, callback?: Callback<number>): Result<number, Context>;
         redriveFromDeadLetterQueue(queue: string, items: string, dlq: string, dlqItems: string, id: string, callback?: Callback<number>): Result<number, Context>;
@@ -161,12 +164,13 @@ declare class Worker<TCatalog extends WorkerCatalog> {
      * @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, }: {
+    enqueue<K extends keyof TCatalog>({ id, job, payload, visibilityTimeoutMs, availableAt, cancellationKey, }: {
         id?: string;
         job: K;
         payload: z.infer<TCatalog[K]["schema"]>;
         visibilityTimeoutMs?: number;
         availableAt?: Date;
+        cancellationKey?: string;
     }): Promise<void>;
     /**
      * Enqueues a job for processing once. If the job is already in the queue, it will be ignored.
@@ -190,6 +194,14 @@ declare class Worker<TCatalog extends WorkerCatalog> {
      * If the job isn't in the queue, it will be ignored.
      */
     reschedule(id: string, availableAt: Date): Promise<void>;
+    /**
+     * Cancels a job before it's enqueued.
+     * @param cancellationKey - The cancellation key to cancel.
+     * @returns A promise that resolves when the job is cancelled.
+     *
+     * Any jobs enqueued with the same cancellation key will be not be enqueued.
+     */
+    cancel(cancellationKey: string): Promise<void>;
     ack(id: string): Promise<void>;
     getJob(id: string): Promise<QueueItem<QueueCatalogFromWorkerCatalog<TCatalog>> | null>;
     /**

package/dist/index.js

@@ -9466,13 +9466,17 @@ var SimpleQueue = class {
     this.#registerCommands();
     this.schema = schema;
   }
+  async cancel(cancellationKey) {
+    await this.redis.set(`cancellationKey:${cancellationKey}`, "1", "EX", 60 * 60 * 24);
+  }
   async enqueue({
     id,
     job,
     item,
     attempt,
     availableAt,
-    visibilityTimeoutMs
+    visibilityTimeoutMs,
+    cancellationKey
   }) {
     try {
       const score = availableAt ? availableAt.getTime() : Date.now();
@@ -9484,13 +9488,14 @@ var SimpleQueue = class {
         attempt,
         deduplicationKey
       });
-      const result = await this.redis.enqueueItem(
+      const result = cancellationKey ? await this.redis.enqueueItemWithCancellationKey(
         `queue`,
         `items`,
+        `cancellationKey:${cancellationKey}`,
         id ?? nanoid(),
         score,
         serializedItem
-      );
+      ) : await this.redis.enqueueItem(`queue`, `items`, id ?? nanoid(), score, serializedItem);
       if (result !== 1) {
         throw new Error("Enqueue operation failed");
       }
@@ -9743,6 +9748,28 @@ var SimpleQueue = class {
         return 1
       `
     });
+    this.redis.defineCommand("enqueueItemWithCancellationKey", {
+      numberOfKeys: 3,
+      lua: `
+        local queue = KEYS[1]
+        local items = KEYS[2]
+        local cancellationKey = KEYS[3]
+
+        local id = ARGV[1]
+        local score = ARGV[2]
+        local serializedItem = ARGV[3]
+
+        -- if the cancellation key exists, return 1
+        if redis.call('EXISTS', cancellationKey) == 1 then
+          return 1
+        end
+
+        redis.call('ZADD', queue, score, id)
+        redis.call('HSET', items, id, serializedItem)
+
+        return 1
+      `
+    });
     this.redis.defineCommand("dequeueItems", {
       numberOfKeys: 2,
       lua: `
@@ -11195,7 +11222,8 @@ var Worker = class _Worker {
     job,
     payload,
     visibilityTimeoutMs,
-    availableAt
+    availableAt,
+    cancellationKey
   }) {
     return startSpan(
       this.tracer,
@@ -11213,7 +11241,8 @@ var Worker = class _Worker {
             job,
             item: payload,
             visibilityTimeoutMs: timeout,
-            availableAt
+            availableAt,
+            cancellationKey
           }),
           {
             job_type: String(job),
@@ -11302,6 +11331,16 @@ var Worker = class _Worker {
       }
     );
   }
+  /**
+   * Cancels a job before it's enqueued.
+   * @param cancellationKey - The cancellation key to cancel.
+   * @returns A promise that resolves when the job is cancelled.
+   *
+   * Any jobs enqueued with the same cancellation key will be not be enqueued.
+   */
+  cancel(cancellationKey) {
+    return startSpan(this.tracer, "cancel", () => this.queue.cancel(cancellationKey));
+  }
   ack(id) {
     return startSpan(
       this.tracer,