@upstash/qstash 2.9.1-rc.1 → 2.9.1

package/workflow.js

@@ -398,43 +398,6 @@ function decodeBase64(base64) {
     }
   }
 }
-function buildBulkActionFilterPayload(request, options) {
-  const hasDlqIds = "dlqIds" in request && request.dlqIds !== void 0;
-  const hasAll = "all" in request && Boolean(request.all);
-  const filterKeys = Object.keys(request).filter((k) => k !== "dlqIds" && k !== "all");
-  const hasFilters = filterKeys.length > 0;
-  if (hasDlqIds && hasAll) {
-    throw new QstashError("dlqIds and all: true are mutually exclusive.");
-  }
-  if (hasDlqIds && hasFilters) {
-    throw new QstashError(
-      `dlqIds cannot be combined with filter fields: ${filterKeys.join(", ")}.`
-    );
-  }
-  if (hasAll && hasFilters) {
-    throw new QstashError(
-      `all: true cannot be combined with filter fields: ${filterKeys.join(", ")}.`
-    );
-  }
-  if (hasAll)
-    return {};
-  const { urlGroup, callerIp, ...rest } = request;
-  const payload = {
-    ...rest,
-    ...urlGroup === void 0 || typeof urlGroup !== "string" ? {} : { topicName: urlGroup },
-    ...callerIp === void 0 || typeof callerIp !== "string" ? {} : options?.callerIpCasing ? { callerIP: callerIp } : { callerIp }
-  };
-  if (Object.keys(payload).length === 0) {
-    throw new QstashError(
-      "No filters provided. Pass { all: true } to explicitly target all messages."
-    );
-  }
-  return payload;
-}
-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}`;
@@ -664,20 +627,17 @@ var DLQ = class {
   /**
    * List messages in the dlq
    */
-  async listMessages(options = {}) {
-    const { urlGroup, ...restFilter } = options.filter ?? {};
+  async listMessages(options) {
     const filterPayload = {
-      ...restFilter,
-      ...urlGroup === void 0 ? {} : { topicName: urlGroup }
+      ...options?.filter,
+      topicName: options?.filter?.urlGroup
     };
     const messagesPayload = await this.http.request({
       method: "GET",
       path: ["v2", "dlq"],
       query: {
-        cursor: options.cursor,
-        count: options.count,
-        order: options.order,
-        trimBody: options.trimBody,
+        cursor: options?.cursor,
+        count: options?.count,
         ...filterPayload
       }
     });
@@ -693,70 +653,127 @@ var DLQ = class {
     };
   }
   /**
-   * 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({ url: "https://example.com", label: "label" })`
-   * - All messages: `delete({ all: true })`
-   *
-   * Note: passing an empty array returns `{ deleted: 0 }` without making a request.
+   * Remove a message from the dlq using it's `dlqId`
    */
-  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 normalizeCursor(
-      await this.http.request({
-        method: "DELETE",
-        path: ["v2", "dlq"],
-        query: buildBulkActionFilterPayload(filters)
-      })
-    );
+  async delete(dlqMessageId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "dlq", dlqMessageId],
+      parseResponseAsJson: false
+      // there is no response
+    });
   }
   /**
    * Remove multiple messages from the dlq using their `dlqId`s
-   *
-   * @deprecated Use `delete` instead
    */
   async deleteMany(request) {
-    return await this.delete(request);
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "dlq"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ dlqIds: request.dlqIds })
+    });
+  }
+};
+
+// src/client/flow-control.ts
+var FlowControlApi = class {
+  http;
+  constructor(http) {
+    this.http = http;
   }
   /**
-   * Retry messages from the dlq.
+   * Get a single flow control by key.
+   */
+  async get(flowControlKey) {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "flowControl", flowControlKey]
+    });
+  }
+  /**
+   * Get the global parallelism info.
+   */
+  async getGlobalParallelism() {
+    const response = await this.http.request({
+      method: "GET",
+      path: ["v2", "globalParallelism"]
+    });
+    return {
+      parallelismMax: response.parallelismMax ?? 0,
+      parallelismCount: response.parallelismCount ?? 0
+    };
+  }
+  /**
+   * Pause message delivery for a flow-control key.
    *
-   * 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({ url: "https://example.com", label: "label" })`
-   * - All messages: `retry({ all: true })`
+   * Messages already in the waitlist will remain there.
+   * New incoming messages will be added directly to the waitlist.
+   */
+  async pause(flowControlKey) {
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "flowControl", flowControlKey, "pause"],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Resume message delivery for a flow-control key.
+   */
+  async resume(flowControlKey) {
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "flowControl", flowControlKey, "resume"],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Pin a processing configuration for a flow-control key.
    *
-   * Note: passing an empty array returns `{ responses: [] }` without making a request.
+   * While pinned, the system ignores configurations provided by incoming
+   * messages and uses the pinned configuration instead.
    */
-  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)
-      })
-    );
+  async pin(flowControlKey, options) {
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "flowControl", flowControlKey, "pin"],
+      query: {
+        parallelism: options.parallelism,
+        rate: options.rate,
+        period: options.period
+      },
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Remove the pinned configuration for a flow-control key.
+   *
+   * After unpinning, the system resumes updating the configuration
+   * based on incoming messages.
+   */
+  async unpin(flowControlKey, options) {
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "flowControl", flowControlKey, "unpin"],
+      query: {
+        parallelism: options.parallelism,
+        rate: options.rate
+      },
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Reset the rate configuration state for a flow-control key.
+   *
+   * Clears the current rate count and immediately ends the current period.
+   * The current timestamp becomes the start of the new rate period.
+   */
+  async resetRate(flowControlKey) {
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "flowControl", flowControlKey, "resetRate"],
+      parseResponseAsJson: false
+    });
   }
 };
 
@@ -857,15 +874,7 @@ 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)
-          continue;
-        if (Array.isArray(value)) {
-          for (const item of value) {
-            url.searchParams.append(key, item);
-          }
-        } else if (value instanceof Date) {
-          url.searchParams.set(key, value.getTime().toString());
-        } else {
+        if (value !== void 0) {
           url.searchParams.set(key, value.toString());
         }
       }
@@ -1096,57 +1105,29 @@ var Messages = class {
     return message;
   }
   /**
-   * Cancel messages.
-   *
-   * Can be called with:
-   * - A single messageId: `cancel("id")`
-   * - An array of messageIds: `cancel(["id1", "id2"])`
-   * - A filter object: `cancel({ flowControlKey: "key", label: "label" })`
-   * - All messages: `cancel({ all: true })`
-   */
-  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, { callerIpCasing: true })
-    });
-  }
-  /**
-   * Delete a message.
-   *
-   * @deprecated Use `cancel(messageId: string)` instead
+   * Cancel a message
    */
   async delete(messageId) {
-    await this.http.request({
+    return 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.cancel(messageIds);
+    const result = await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ messageIds })
+    });
     return result.cancelled;
   }
-  /**
-   * Cancel all messages
-   * @deprecated Use `cancel({all: true})` to cancel all
-   */
   async deleteAll() {
-    const result = await this.cancel({ all: true });
+    const result = await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages"]
+    });
     return result.cancelled;
   }
 };
@@ -1480,7 +1461,7 @@ var UrlGroups = class {
 };
 
 // version.ts
-var VERSION = "v2.9.1-rc.1";
+var VERSION = "v2.9.1";
 
 // src/client/client.ts
 var Client = class {
@@ -1551,6 +1532,14 @@ var Client = class {
   get schedules() {
     return new Schedules(this.http);
   }
+  /**
+   * Access the flow control API.
+   *
+   * List, get, or reset flow controls.
+   */
+  get flowControl() {
+    return new FlowControlApi(this.http);
+  }
   /**
    * Access the workflow API.
    *
@@ -1675,47 +1664,39 @@ var Client = class {
    * }
    * ```
    */
-  async logs(request = {}) {
-    const {
-      urlGroup,
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
-      topicName,
-      fromDate,
-      toDate,
-      callerIp,
-      messageIds,
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
-      count: filterCount,
-      ...restFilter
-    } = request.filter ?? {};
-    const filterPayload = {
-      ...restFilter,
-      topicName: urlGroup ?? topicName,
-      fromDate,
-      toDate,
-      callerIp
-    };
-    let cursorString;
-    if (typeof request.cursor === "number" && request.cursor > 0) {
-      cursorString = request.cursor.toString();
-    } else if (typeof request.cursor === "string" && request.cursor !== "") {
-      cursorString = request.cursor;
-    }
-    const query = {
-      cursor: cursorString,
-      count: request.count ?? filterCount,
-      order: request.order,
-      trimBody: request.trimBody,
-      messageIds,
-      ...filterPayload
-    };
+  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();
+      }
+    }
     const responsePayload = await this.http.request({
       path: ["v2", "events"],
       method: "GET",
       query
     });
-    const logs = responsePayload.events.map((event) => ({ ...event, urlGroup: event.topicName }));
-    return { cursor: responsePayload.cursor, logs, events: logs };
+    const logs = responsePayload.events.map((event) => {
+      return {
+        ...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/workflow.mjs

@@ -6,7 +6,7 @@ import {
   WorkflowLogger,
   processOptions,
   serve
-} from "./chunk-RUCOF5QZ.mjs";
+} from "./chunk-DT2X63FB.mjs";
 export {
   DisabledWorkflowContext,
   StepTypes,