@upstash/workflow 1.2.0 → 1.2.1

package/index.js

@@ -196,6 +196,66 @@ var getSteps = async (requester, workflowRunId, messageId, dispatchDebug) => {
     }
   }
 };
+function normalizeCursor(response) {
+  const cursor = response.cursor;
+  return { ...response, cursor: cursor || void 0 };
+}
+var DEFAULT_BULK_COUNT = 100;
+function buildBulkActionQueryParameters(request, options) {
+  const cursor = "cursor" in request ? request.cursor : void 0;
+  if ("all" in request) {
+    return { count: request.count ?? DEFAULT_BULK_COUNT, cursor };
+  }
+  if ("dlqIds" in request) {
+    const ids = request.dlqIds;
+    if (Array.isArray(ids) && ids.length === 0) {
+      throw new import_qstash2.QstashError(
+        "Empty dlqIds array provided. If you intend to target all DLQ messages, use { all: true } explicitly."
+      );
+    }
+    return { dlqIds: ids, cursor };
+  }
+  if ("workflowRunIds" in request && request.workflowRunIds) {
+    if (request.workflowRunIds.length === 0) {
+      throw new import_qstash2.QstashError(
+        "Empty workflowRunIds array provided. If you intend to target all workflow runs, use { all: true } explicitly."
+      );
+    }
+    return { workflowRunIds: request.workflowRunIds };
+  }
+  const filter = request.filter;
+  if (!filter) {
+    throw new import_qstash2.QstashError(
+      "No filter provided. Use { filter: { ... } } with at least one filter field, or { all: true }."
+    );
+  }
+  if (options?.translateWorkflowUrl) {
+    const { workflowUrlStartingWith, workflowUrl, ...rest } = filter;
+    if (workflowUrlStartingWith && workflowUrl) {
+      throw new import_qstash2.QstashError(
+        "workflowUrl and workflowUrlStartingWith are mutually exclusive. Use workflowUrl for exact match or workflowUrlStartingWith for prefix match."
+      );
+    }
+    const urlParams = {};
+    if (workflowUrlStartingWith) {
+      urlParams.workflowUrl = workflowUrlStartingWith;
+    } else if (workflowUrl) {
+      urlParams.workflowUrl = workflowUrl;
+      urlParams.workflowUrlExactMatch = true;
+    }
+    return {
+      ...rest,
+      ...urlParams,
+      count: request.count ?? DEFAULT_BULK_COUNT,
+      cursor
+    };
+  }
+  return {
+    ...filter,
+    count: request.count ?? DEFAULT_BULK_COUNT,
+    cursor
+  };
+}
 
 // src/constants.ts
 var WORKFLOW_ID_HEADER = "Upstash-Workflow-RunId";
@@ -3800,7 +3860,19 @@ var serve = (routeFunction, options) => {
 var import_qstash12 = require("@upstash/qstash");
 
 // src/client/dlq.ts
-var DLQ = class _DLQ {
+function buildResumeRestartHeaders(options) {
+  const headers = {};
+  if (options?.flowControl) {
+    const { flowControlKey, flowControlValue } = prepareFlowControl(options.flowControl);
+    headers["Upstash-Flow-Control-Key"] = flowControlKey;
+    headers["Upstash-Flow-Control-Value"] = flowControlValue;
+  }
+  if (options?.retries !== void 0) {
+    headers["Upstash-Retries"] = options.retries.toString();
+  }
+  return headers;
+}
+var DLQ = class {
   constructor(client) {
     this.client = client;
   }
@@ -3823,40 +3895,66 @@ var DLQ = class _DLQ {
    */
   async list(parameters) {
     const { cursor, count, filter } = parameters || {};
-    return await this.client.http.request({
-      path: ["v2", "dlq"],
-      method: "GET",
-      query: {
-        cursor,
-        count,
-        ...filter,
-        source: "workflow"
-      }
-    });
+    return normalizeCursor(
+      await this.client.http.request({
+        path: ["v2", "dlq"],
+        method: "GET",
+        query: {
+          cursor,
+          count,
+          ...filter,
+          source: "workflow"
+        }
+      })
+    );
   }
-  async resume(parameters) {
-    const { headers, queryParams } = _DLQ.handleDLQOptions(parameters);
-    const { workflowRuns } = await this.client.http.request({
-      path: ["v2", "workflows", "dlq", `resume?${queryParams}`],
-      headers,
-      method: "POST"
-    });
-    if (Array.isArray(parameters.dlqId)) {
-      return workflowRuns;
+  async resume(request, options) {
+    if (typeof request === "object" && !Array.isArray(request) && "dlqId" in request) {
+      const { dlqId, flowControl, retries } = request;
+      const dlqIds = Array.isArray(dlqId) ? dlqId : [dlqId];
+      const { workflowRuns } = await this.client.http.request({
+        path: ["v2", "workflows", "dlq", "resume"],
+        query: { dlqIds },
+        method: "POST",
+        headers: buildResumeRestartHeaders({ flowControl, retries })
+      });
+      return Array.isArray(dlqId) ? workflowRuns : workflowRuns[0];
     }
-    return workflowRuns[0];
+    if (typeof request === "string") request = [request];
+    if (Array.isArray(request) && request.length === 0) return { workflowRuns: [] };
+    const filters = Array.isArray(request) ? { dlqIds: request } : request;
+    return normalizeCursor(
+      await this.client.http.request({
+        path: ["v2", "workflows", "dlq", "resume"],
+        query: buildBulkActionQueryParameters(filters),
+        method: "POST",
+        headers: buildResumeRestartHeaders(options)
+      })
+    );
   }
-  async restart(parameters) {
-    const { headers, queryParams } = _DLQ.handleDLQOptions(parameters);
-    const { workflowRuns } = await this.client.http.request({
-      path: ["v2", "workflows", "dlq", `restart?${queryParams}`],
-      headers,
-      method: "POST"
-    });
-    if (Array.isArray(parameters.dlqId)) {
-      return workflowRuns;
+  async restart(request, options) {
+    if (typeof request === "object" && !Array.isArray(request) && "dlqId" in request) {
+      const { dlqId, flowControl, retries } = request;
+      const dlqIds = Array.isArray(dlqId) ? dlqId : [dlqId];
+      const { workflowRuns } = await this.client.http.request({
+        path: ["v2", "workflows", "dlq", "restart"],
+        query: { dlqIds },
+        method: "POST",
+        headers: buildResumeRestartHeaders({ flowControl, retries })
+      });
+      return Array.isArray(dlqId) ? workflowRuns : workflowRuns[0];
     }
-    return workflowRuns[0];
+    if (typeof request === "string") request = [request];
+    if (Array.isArray(request) && request.length === 0) return { workflowRuns: [] };
+    const filters = Array.isArray(request) ? { dlqIds: request } : request;
+    return normalizeCursor(
+      await this.client.http.request({
+        path: ["v2", "workflows", "dlq", "restart"],
+        query: buildBulkActionQueryParameters(filters),
+        method: "POST",
+        headers: buildResumeRestartHeaders(options)
+      })
+    );
   }
   /**
    * Retry the failure callback of a workflow run whose failureUrl/failureFunction
@@ -3873,35 +3971,36 @@ var DLQ = class _DLQ {
     return response;
   }
   /**
-   * Handles DLQ options and prepares headers and query parameters.
+   * Delete DLQ messages.
    *
-   * @param options - DLQ resume/restart options
-   */
-  static handleDLQOptions(options) {
-    const { dlqId, flowControl, retries } = options;
-    const headers = {};
-    if (flowControl) {
-      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
-      headers["Upstash-Flow-Control-Key"] = flowControlKey;
-      headers["Upstash-Flow-Control-Value"] = flowControlValue;
-    }
-    if (retries !== void 0) {
-      headers["Upstash-Retries"] = retries.toString();
-    }
-    return {
-      queryParams: _DLQ.getDlqIdQueryParameter(dlqId),
-      headers
-    };
-  }
-  /**
-   * Converts DLQ ID(s) to query parameter string.
+   * Can be called with:
+   * - A single dlqId: `delete("id")`
+   * - An array of dlqIds: `delete(["id1", "id2"])`
+   * - A filter object: `delete({ filter: { label: "my-label", fromDate: 1640995200000 } })`
+   * - To target all entries: `delete({ all: true })`
+   *
+   * Processes up to `count` messages per call (defaults to 100).
+   * Call in a loop until cursor is undefined to process all:
    *
-   * @param dlqId - Single DLQ ID or array of DLQ IDs
+   * ```ts
+   * let cursor: string | undefined;
+   * do {
+   *   const result = await client.dlq.delete({ all: true, count: 100, cursor });
+   *   cursor = result.cursor;
+   * } while (cursor);
+   * ```
    */
-  static getDlqIdQueryParameter(dlqId) {
-    const dlqIds = Array.isArray(dlqId) ? dlqId : [dlqId];
-    const paramsArray = dlqIds.map((id) => ["dlqIds", id]);
-    return new URLSearchParams(paramsArray).toString();
+  async delete(request) {
+    if (typeof request === "string") request = [request];
+    if (Array.isArray(request) && request.length === 0) return { deleted: 0 };
+    const filters = Array.isArray(request) ? { dlqIds: request } : request;
+    return normalizeCursor(
+      await this.client.http.request({
+        path: ["v2", "workflows", "dlq"],
+        method: "DELETE",
+        query: buildBulkActionQueryParameters(filters)
+      })
+    );
   }
 };
 
@@ -3911,82 +4010,25 @@ var Client4 = class {
   constructor(clientConfig) {
     this.client = new import_qstash12.Client(clientConfig);
   }
-  /**
-   * Cancel an ongoing workflow
-   *
-   * Returns true if workflow is canceled succesfully. Otherwise, throws error.
-   *
-   * There are multiple ways you can cancel workflows:
-   * - pass one or more workflow run ids to cancel them
-   * - pass a workflow url to cancel all runs starting with this url
-   * - cancel all pending or active workflow runs
-   *
-   * ### Cancel a set of workflow runs
-   *
-   * ```ts
-   * // cancel a single workflow
-   * await client.cancel({ ids: "<WORKFLOW_RUN_ID>" })
-   *
-   * // cancel a set of workflow runs
-   * await client.cancel({ ids: [
-   *   "<WORKFLOW_RUN_ID_1>",
-   *   "<WORKFLOW_RUN_ID_2>",
-   * ]})
-   * ```
-   *
-   * ### Cancel workflows starting with a url
-   *
-   * If you have an endpoint called `https://your-endpoint.com` and you
-   * want to cancel all workflow runs on it, you can use `urlStartingWith`.
-   *
-   * Note that this will cancel workflows in all endpoints under
-   * `https://your-endpoint.com`.
-   *
-   * ```ts
-   * await client.cancel({ urlStartingWith: "https://your-endpoint.com" })
-   * ```
-   *
-   * ### Cancel *all* workflows
-   *
-   * To cancel all pending and currently running workflows, you can
-   * do it like this:
-   *
-   * ```ts
-   * await client.cancel({ all: true })
-   * ```
-   *
-   * @param ids run id of the workflow to delete
-   * @param urlStartingWith cancel workflows starting with this url. Will be ignored
-   *   if `ids` parameter is set.
-   * @param all set to true in order to cancel all workflows. Will be ignored
-   *   if `ids` or `urlStartingWith` parameters are set.
-   * @returns true if workflow is succesfully deleted. Otherwise throws QStashError
-   */
-  async cancel({
-    ids,
-    urlStartingWith,
-    all
-  }) {
-    let body;
-    if (ids) {
-      const runIdArray = typeof ids === "string" ? [ids] : ids;
-      body = JSON.stringify({ workflowRunIds: runIdArray });
-    } else if (urlStartingWith) {
-      body = JSON.stringify({ workflowUrl: urlStartingWith });
-    } else if (all) {
-      body = "{}";
-    } else {
-      throw new TypeError("The `cancel` method cannot be called without any options.");
+  async cancel(request) {
+    if (typeof request === "object" && !Array.isArray(request) && ("ids" in request || "urlStartingWith" in request)) {
+      const legacy = request;
+      if (legacy.ids) {
+        const ids = typeof legacy.ids === "string" ? [legacy.ids] : legacy.ids;
+        return this.cancel(ids);
+      }
+      if (legacy.urlStartingWith) {
+        return this.cancel({ filter: { workflowUrlStartingWith: legacy.urlStartingWith } });
+      }
     }
-    const result = await this.client.http.request({
+    if (typeof request === "string") request = [request];
+    if (Array.isArray(request) && request.length === 0) return { cancelled: 0 };
+    const filters = Array.isArray(request) ? { workflowRunIds: request } : request;
+    return await this.client.http.request({
       path: ["v2", "workflows", "runs"],
       method: "DELETE",
-      body,
-      headers: {
-        "Content-Type": "application/json"
-      }
+      query: buildBulkActionQueryParameters(filters, { translateWorkflowUrl: true })
     });
-    return result;
   }
   /**
    * Notify a workflow run waiting for an event
@@ -4110,33 +4152,17 @@ var Client4 = class {
    * ```
    */
   async logs(params) {
-    const { workflowRunId, cursor, count, state, workflowUrl, workflowCreatedAt } = params ?? {};
-    const urlParams = new URLSearchParams({ groupBy: "workflowRunId" });
-    if (workflowRunId) {
-      urlParams.append("workflowRunId", workflowRunId);
-    }
-    if (cursor) {
-      urlParams.append("cursor", cursor);
-    }
-    if (count) {
-      urlParams.append("count", count.toString());
-    }
-    if (state) {
-      urlParams.append("state", state);
-    }
-    if (workflowUrl) {
-      urlParams.append("workflowUrl", workflowUrl);
-    }
-    if (workflowCreatedAt) {
-      urlParams.append("workflowCreatedAt", workflowCreatedAt.toString());
-    }
-    if (params?.label) {
-      urlParams.append("label", params.label);
-    }
-    const result = await this.client.http.request({
-      path: ["v2", "workflows", `events?${urlParams.toString()}`]
+    const { cursor, count, filter, ...legacyFilter } = params ?? {};
+    return await this.client.http.request({
+      path: ["v2", "workflows", "events"],
+      query: {
+        groupBy: "workflowRunId",
+        ...legacyFilter,
+        cursor,
+        count,
+        ...filter
+      }
     });
-    return result;
   }
   get dlq() {
     return new DLQ(this.client);