@upstash/qstash 2.9.1 → 2.10.1

package/cloudflare.js

@@ -238,6 +238,14 @@ var QstashDailyRatelimitError = class extends QstashError {
     this.reset = args.reset;
   }
 };
+var QstashEmptyArrayError = class extends QstashError {
+  constructor(parameterName) {
+    super(
+      `Empty array provided for query parameter "${parameterName}". This would result in no filter being applied, which could affect all resources.`
+    );
+    this.name = "QstashEmptyArrayError";
+  }
+};
 var QStashWorkflowError = class extends QstashError {
   constructor(message) {
     super(message);
@@ -267,6 +275,7 @@ var formatWorkflowError = (error) => {
 };
 
 // src/client/utils.ts
+var DEFAULT_BULK_COUNT = 100;
 var isIgnoredHeader = (header) => {
   const lowerCaseHeader = header.toLowerCase();
   return lowerCaseHeader.startsWith("content-type") || lowerCaseHeader.startsWith("upstash-");
@@ -353,6 +362,24 @@ function processHeaders(request) {
   if (request.label !== void 0) {
     headers.set("Upstash-Label", request.label);
   }
+  if (request.redact !== void 0) {
+    const redactParts = [];
+    if (request.redact.body) {
+      redactParts.push("body");
+    }
+    if (request.redact.header !== void 0) {
+      if (request.redact.header === true) {
+        redactParts.push("header");
+      } else if (Array.isArray(request.redact.header) && request.redact.header.length > 0) {
+        for (const headerName of request.redact.header) {
+          redactParts.push(`header[${headerName}]`);
+        }
+      }
+    }
+    if (redactParts.length > 0) {
+      headers.set("Upstash-Redact-Fields", redactParts.join(","));
+    }
+  }
   return headers;
 }
 function getRequestPath(request) {
@@ -392,6 +419,44 @@ function decodeBase64(base64) {
     }
   }
 }
+function buildBulkActionFilterPayload(request) {
+  const cursor = "cursor" in request ? request.cursor : void 0;
+  if ("all" in request) {
+    const count2 = "count" in request ? request.count ?? DEFAULT_BULK_COUNT : DEFAULT_BULK_COUNT;
+    return { count: count2, cursor };
+  }
+  if ("dlqIds" in request) {
+    const ids = request.dlqIds;
+    if (Array.isArray(ids) && ids.length === 0) {
+      throw new QstashError(
+        "Empty dlqIds array provided. If you intend to target all DLQ messages, use { all: true } explicitly."
+      );
+    }
+    return { dlqIds: ids, cursor };
+  }
+  if ("messageIds" in request && request.messageIds) {
+    if (request.messageIds.length === 0) {
+      throw new QstashError(
+        "Empty messageIds array provided. If you intend to target all messages, use { all: true } explicitly."
+      );
+    }
+    return { messageIds: request.messageIds, cursor };
+  }
+  const count = "count" in request ? request.count ?? DEFAULT_BULK_COUNT : DEFAULT_BULK_COUNT;
+  return {
+    ...renameUrlGroup(request.filter),
+    count,
+    cursor
+  };
+}
+function renameUrlGroup(filter) {
+  const { urlGroup, api, ...rest } = filter;
+  return { ...rest, ...urlGroup === void 0 ? {} : { topicName: urlGroup } };
+}
+function normalizeCursor(response) {
+  const cursor = response.cursor;
+  return { ...response, cursor: cursor || void 0 };
+}
 function getRuntime() {
   if (typeof process === "object" && typeof process.versions == "object" && process.versions.bun)
     return `bun@${process.versions.bun}`;
@@ -620,20 +685,21 @@ var DLQ = class {
   }
   /**
    * List messages in the dlq
+   *
+   * Can be called with:
+   * - Filters: `listMessages({ filter: { url: "https://example.com" } })`
+   * - DLQ IDs: `listMessages({ dlqIds: ["id1", "id2"] })`
+   * - No filter (list all): `listMessages()`
    */
-  async listMessages(options) {
-    const filterPayload = {
-      ...options?.filter,
-      topicName: options?.filter?.urlGroup
+  async listMessages(options = {}) {
+    const query = {
+      count: options.count,
+      ..."dlqIds" in options ? { dlqIds: options.dlqIds } : { ...renameUrlGroup(options.filter ?? {}), cursor: options.cursor }
     };
     const messagesPayload = await this.http.request({
       method: "GET",
       path: ["v2", "dlq"],
-      query: {
-        cursor: options?.cursor,
-        count: options?.count,
-        ...filterPayload
-      }
+      query
     });
     return {
       messages: messagesPayload.messages.map((message) => {
@@ -647,26 +713,86 @@ var DLQ = class {
     };
   }
   /**
-   * Remove a message from the dlq using it's `dlqId`
+   * Remove messages from the dlq.
+   *
+   * Can be called with:
+   * - A single dlqId: `delete("id")`
+   * - An array of dlqIds: `delete(["id1", "id2"])`
+   * - An object with dlqIds: `delete({ dlqIds: ["id1", "id2"] })`
+   * - A filter object: `delete({ filter: { url: "https://example.com", label: "label" } })`
+   * - All messages: `delete({ all: true })`
+   *
+   * Pass `count` to limit the number of messages processed per call (defaults to 100).
+   * Call in a loop until cursor is undefined:
+   *
+   * ```ts
+   * let cursor: string | undefined;
+   * do {
+   *   const result = await dlq.delete({ all: true, count: 100, cursor });
+   *   cursor = result.cursor;
+   * } while (cursor);
+   * ```
    */
-  async delete(dlqMessageId) {
+  async delete(request) {
+    if (typeof request === "string") {
+      await this.http.request({
+        method: "DELETE",
+        path: ["v2", "dlq", request],
+        parseResponseAsJson: false
+      });
+      return { deleted: 1 };
+    }
+    if (Array.isArray(request) && request.length === 0)
+      return { deleted: 0 };
+    const filters = Array.isArray(request) ? { dlqIds: request } : request;
     return await this.http.request({
       method: "DELETE",
-      path: ["v2", "dlq", dlqMessageId],
-      parseResponseAsJson: false
-      // there is no response
+      path: ["v2", "dlq"],
+      query: buildBulkActionFilterPayload(filters)
     });
   }
   /**
    * Remove multiple messages from the dlq using their `dlqId`s
+   *
+   * @deprecated Use `delete` instead
    */
   async deleteMany(request) {
-    return await this.http.request({
-      method: "DELETE",
-      path: ["v2", "dlq"],
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ dlqIds: request.dlqIds })
-    });
+    return await this.delete(request);
+  }
+  /**
+   * Retry messages from the dlq.
+   *
+   * Can be called with:
+   * - A single dlqId: `retry("id")`
+   * - An array of dlqIds: `retry(["id1", "id2"])`
+   * - An object with dlqIds: `retry({ dlqIds: ["id1", "id2"] })`
+   * - A filter object: `retry({ filter: { url: "https://example.com", label: "label" } })`
+   * - All messages: `retry({ all: true })`
+   *
+   * Pass `count` to limit the number of messages processed per call (defaults to 100).
+   * Call in a loop until cursor is undefined:
+   *
+   * ```ts
+   * let cursor: string | undefined;
+   * do {
+   *   const result = await dlq.retry({ all: true, count: 100, cursor });
+   *   cursor = result.cursor;
+   * } while (cursor);
+   * ```
+   */
+  async retry(request) {
+    if (typeof request === "string")
+      request = [request];
+    if (Array.isArray(request) && request.length === 0)
+      return { responses: [] };
+    const filters = Array.isArray(request) ? { dlqIds: request } : request;
+    return normalizeCursor(
+      await this.http.request({
+        method: "POST",
+        path: ["v2", "dlq", "retry"],
+        query: buildBulkActionFilterPayload(filters)
+      })
+    );
   }
 };
 
@@ -868,7 +994,18 @@ var HttpClient = class {
     const url = new URL([request.baseUrl ?? this.baseUrl, ...request.path].join("/"));
     if (request.query) {
       for (const [key, value] of Object.entries(request.query)) {
-        if (value !== void 0) {
+        if (value === void 0)
+          continue;
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
+            throw new QstashEmptyArrayError(key);
+          }
+          for (const item of value) {
+            url.searchParams.append(key, item);
+          }
+        } else if (value instanceof Date) {
+          url.searchParams.set(key, value.getTime().toString());
+        } else {
           url.searchParams.set(key, value.toString());
         }
       }
@@ -1099,29 +1236,68 @@ var Messages = class {
     return message;
   }
   /**
-   * Cancel a message
+   * Cancel messages.
+   *
+   * Can be called with:
+   * - A single messageId: `cancel("id")`
+   * - An array of messageIds: `cancel(["id1", "id2"])`
+   * - A filter object: `cancel({ filter: { flowControlKey: "key", label: "label" } })`
+   * - All messages: `cancel({ all: true })`
+   *
+   * Pass `count` to limit the number of messages processed per call (defaults to 100).
+   * Call in a loop until `cancelled` is 0:
+   *
+   * ```ts
+   * let cancelled: number;
+   * do {
+   *   const result = await messages.cancel({ all: true, count: 100 });
+   *   cancelled = result.cancelled;
+   * } while (cancelled > 0);
+   * ```
    */
-  async delete(messageId) {
+  async cancel(request) {
+    if (typeof request === "string") {
+      return await this.http.request({
+        method: "DELETE",
+        path: ["v2", "messages", request]
+      });
+    }
+    if (Array.isArray(request) && request.length === 0)
+      return { cancelled: 0 };
+    const filters = Array.isArray(request) ? { messageIds: request } : request;
     return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages"],
+      query: buildBulkActionFilterPayload(filters)
+    });
+  }
+  /**
+   * Delete a message.
+   *
+   * @deprecated Use `cancel(messageId: string)` instead
+   */
+  async delete(messageId) {
+    await this.http.request({
       method: "DELETE",
       path: ["v2", "messages", messageId],
       parseResponseAsJson: false
     });
   }
+  /**
+   * Cancel multiple messages by their messageIds.
+   *
+   * @deprecated Use `cancel(messageIds: string[])` instead
+   */
   async deleteMany(messageIds) {
-    const result = await this.http.request({
-      method: "DELETE",
-      path: ["v2", "messages"],
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ messageIds })
-    });
+    const result = await this.cancel(messageIds);
     return result.cancelled;
   }
+  /**
+   * Cancel all messages
+   * @deprecated Use `cancel({all: true})` to cancel all
+   */
   async deleteAll() {
-    const result = await this.http.request({
-      method: "DELETE",
-      path: ["v2", "messages"]
-    });
+    const result = await this.cancel({ all: true });
     return result.cancelled;
   }
 };
@@ -1326,6 +1502,24 @@ var Schedules = class {
     if (request.label !== void 0) {
       headers.set("Upstash-Label", request.label);
     }
+    if (request.redact !== void 0) {
+      const redactParts = [];
+      if (request.redact.body) {
+        redactParts.push("body");
+      }
+      if (request.redact.header !== void 0) {
+        if (request.redact.header === true) {
+          redactParts.push("header");
+        } else if (Array.isArray(request.redact.header) && request.redact.header.length > 0) {
+          for (const headerName of request.redact.header) {
+            redactParts.push(`header[${headerName}]`);
+          }
+        }
+      }
+      if (redactParts.length > 0) {
+        headers.set("Upstash-Redact-Fields", redactParts.join(","));
+      }
+    }
     return await this.http.request({
       method: "POST",
       headers: wrapWithGlobalHeaders(headers, this.http.headers, this.http.telemetryHeaders),
@@ -1455,7 +1649,7 @@ var UrlGroups = class {
 };
 
 // version.ts
-var VERSION = "v2.9.1";
+var VERSION = "2.10.1";
 
 // src/client/client.ts
 var Client = class {
@@ -1658,39 +1852,18 @@ var Client = class {
    * }
    * ```
    */
-  async logs(request) {
-    const query = {};
-    if (typeof request?.cursor === "number" && request.cursor > 0) {
-      query.cursor = request.cursor.toString();
-    } else if (typeof request?.cursor === "string" && request.cursor !== "") {
-      query.cursor = request.cursor;
-    }
-    for (const [key, value] of Object.entries(request?.filter ?? {})) {
-      if (typeof value === "number" && value < 0) {
-        continue;
-      }
-      if (key === "urlGroup") {
-        query.topicName = value.toString();
-      } else if (typeof value !== "undefined") {
-        query[key] = value.toString();
-      }
-    }
+  async logs(request = {}) {
+    const query = {
+      count: request.count,
+      ..."messageIds" in request ? { messageIds: request.messageIds } : { ...renameUrlGroup(request.filter ?? {}), cursor: request.cursor }
+    };
     const responsePayload = await this.http.request({
       path: ["v2", "events"],
       method: "GET",
       query
     });
-    const logs = responsePayload.events.map((event) => {
-      return {
-        ...event,
-        urlGroup: event.topicName
-      };
-    });
-    return {
-      cursor: responsePayload.cursor,
-      logs,
-      events: logs
-    };
+    const logs = responsePayload.events.map((event) => ({ ...event, urlGroup: event.topicName }));
+    return { cursor: responsePayload.cursor, logs, events: logs };
   }
   /**
    * @deprecated Will be removed in the next major release. Use the `logs` method instead.

package/cloudflare.mjs

@@ -1,6 +1,6 @@
 import {
   serve
-} from "./chunk-DT2X63FB.mjs";
+} from "./chunk-35B33QW3.mjs";
 
 // platforms/cloudflare.ts
 var getArgs = (args) => {

package/h3.d.mts

@@ -1,6 +1,6 @@
 import * as h3 from 'h3';
 import { H3Event } from 'h3';
-import { ae as RouteFunction, af as WorkflowServeOptions } from './client-jh_SomWB.mjs';
+import { ae as RouteFunction, af as WorkflowServeOptions } from './client-CsM1dTnz.mjs';
 import 'neverthrow';
 
 type VerifySignatureConfig = {

package/h3.d.ts

@@ -1,6 +1,6 @@
 import * as h3 from 'h3';
 import { H3Event } from 'h3';
-import { ae as RouteFunction, af as WorkflowServeOptions } from './client-jh_SomWB.js';
+import { ae as RouteFunction, af as WorkflowServeOptions } from './client-CsM1dTnz.js';
 import 'neverthrow';
 
 type VerifySignatureConfig = {