@upstash/workflow 1.2.0-demo-rc.1 → 1.2.1

package/index.mjs

@@ -1,5 +1,4 @@
 import {
-  DEV_QSTASH_TOKEN,
   SDK_TELEMETRY,
   StepTypes,
   WORKFLOW_LABEL_HEADER,
@@ -9,22 +8,34 @@ import {
   WorkflowMiddleware,
   WorkflowNonRetryableError,
   WorkflowRetryAfterError,
-  ensureDevServer,
-  getDevCredentials,
+  buildBulkActionQueryParameters,
   getWorkflowRunId,
   loggingMiddleware,
   makeGetWaitersRequest,
   makeNotifyRequest,
+  normalizeCursor,
   prepareFlowControl,
   serve,
   triggerFirstInvocation
-} from "./chunk-NZCQPOPR.mjs";
+} from "./chunk-THS5AX2D.mjs";
 
 // src/client/index.ts
 import { Client as QStashClient } from "@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;
   }
@@ -47,40 +58,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
@@ -97,148 +134,64 @@ 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)
+      })
+    );
   }
 };
 
 // src/client/index.ts
 var Client = class {
   client;
-  devMode;
   constructor(clientConfig) {
-    const env = typeof process === "undefined" ? {} : process.env;
-    this.devMode = env.WORKFLOW_DEV === "true";
-    if (this.devMode) {
-      const port = Number(env.WORKFLOW_DEV_PORT) || 8080;
-      const creds = getDevCredentials(port);
-      this.client = new QStashClient({
-        ...clientConfig,
-        token: DEV_QSTASH_TOKEN,
-        baseUrl: creds.QSTASH_URL
-      });
-    } else if (!clientConfig) {
-      throw new Error(
-        "[Upstash Workflow] Client requires a token. Either pass { token: '...' } or set WORKFLOW_DEV=true."
-      );
-    } else {
-      this.client = new QStashClient(clientConfig);
-    }
-  }
-  /**
-   * In dev mode, ensures the dev server is running before making requests.
-   * If a server is already listening on the port (started by another process
-   * or by a platform's serve()), this is a no-op.
-   */
-  async ensureReady() {
-    if (this.devMode) {
-      await ensureDevServer(process.env);
-    }
+    this.client = new QStashClient(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
-  }) {
-    await this.ensureReady();
-    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
@@ -253,15 +206,26 @@ var Client = class {
    * });
    * ```
    *
+   * Optionally, you can pass a workflowRunId to enable lookback functionality:
+   *
+   * ```ts
+   * await client.notify({
+   *   eventId: "my-event-id",
+   *   eventData: "my-data",
+   *   workflowRunId: "wfr_123" // enables lookback
+   * });
+   * ```
+   *
    * @param eventId event id to notify
    * @param eventData data to provide to the workflow
+   * @param workflowRunId optional workflow run id for lookback support
    */
   async notify({
     eventId,
-    eventData
+    eventData,
+    workflowRunId
   }) {
-    await this.ensureReady();
-    return await makeNotifyRequest(this.client.http, eventId, eventData);
+    return await makeNotifyRequest(this.client.http, eventId, eventData, workflowRunId);
   }
   /**
    * Check waiters of an event
@@ -278,11 +242,9 @@ var Client = class {
    * @param eventId event id to check
    */
   async getWaiters({ eventId }) {
-    await this.ensureReady();
     return await makeGetWaitersRequest(this.client.http, eventId);
   }
   async trigger(params) {
-    await this.ensureReady();
     const isBatchInput = Array.isArray(params);
     const options = isBatchInput ? params : [params];
     const invocations = options.map((option) => {
@@ -299,7 +261,9 @@ var Client = class {
         url: option.url,
         workflowRunId: finalWorkflowRunId,
         telemetry: option.disableTelemetry ? void 0 : { sdk: SDK_TELEMETRY },
-        label: option.label
+        label: option.label,
+        workflowRunCreatedAt: Date.now()
+        // pass a timestamp (server will override it)
       });
       return {
         workflowContext: context,
@@ -309,7 +273,8 @@ var Client = class {
         failureUrl,
         retries: option.retries,
         retryDelay: option.retryDelay,
-        flowControl: option.flowControl
+        flowControl: option.flowControl,
+        redact: option.redact
       };
     });
     const result = await triggerFirstInvocation(invocations);
@@ -350,34 +315,17 @@ var Client = class {
    * ```
    */
   async logs(params) {
-    await this.ensureReady();
-    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);

package/nextjs.d.mts

@@ -1,6 +1,6 @@
 import { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
-import { c as RouteFunction, d as WorkflowServeOptions, x as InvokableWorkflow } from './types-CUwgrpCM.mjs';
-import { s as serveManyBase } from './serve-many-CppVPJrh.mjs';
+import { c as RouteFunction, d as WorkflowServeOptions, I as InvokableWorkflow } from './types-B2S08hRU.mjs';
+import { s as serveManyBase } from './serve-many-C6sa_DxN.mjs';
 import '@upstash/qstash';
 import 'zod';
 

package/nextjs.d.ts

@@ -1,6 +1,6 @@
 import { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
-import { c as RouteFunction, d as WorkflowServeOptions, x as InvokableWorkflow } from './types-CUwgrpCM.js';
-import { s as serveManyBase } from './serve-many-Bi8XaOyq.js';
+import { c as RouteFunction, d as WorkflowServeOptions, I as InvokableWorkflow } from './types-B2S08hRU.js';
+import { s as serveManyBase } from './serve-many-B-fe7bh7.js';
 import '@upstash/qstash';
 import 'zod';