@upstash/workflow 0.1.3-crpyto-canary-2 → 0.1.3

package/index.js

@@ -70,6 +70,197 @@ var formatWorkflowError = (error) => {
   };
 };
 
+// src/client/utils.ts
+var makeNotifyRequest = async (requester, eventId, eventData) => {
+  const result = await requester.request({
+    path: ["v2", "notify", eventId],
+    method: "POST",
+    body: typeof eventData === "string" ? eventData : JSON.stringify(eventData)
+  });
+  return result;
+};
+var makeGetWaitersRequest = async (requester, eventId) => {
+  const result = await requester.request({
+    path: ["v2", "waiters", eventId],
+    method: "GET"
+  });
+  return result;
+};
+
+// src/context/steps.ts
+var BaseLazyStep = class {
+  stepName;
+  // will be set in the subclasses
+  constructor(stepName) {
+    this.stepName = stepName;
+  }
+};
+var LazyFunctionStep = class extends BaseLazyStep {
+  stepFunction;
+  stepType = "Run";
+  constructor(stepName, stepFunction) {
+    super(stepName);
+    this.stepFunction = stepFunction;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    let result = this.stepFunction();
+    if (result instanceof Promise) {
+      result = await result;
+    }
+    return {
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      out: result,
+      concurrent
+    };
+  }
+};
+var LazySleepStep = class extends BaseLazyStep {
+  sleep;
+  stepType = "SleepFor";
+  constructor(stepName, sleep) {
+    super(stepName);
+    this.sleep = sleep;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepFor: this.sleep,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepFor: this.sleep,
+      concurrent
+    });
+  }
+};
+var LazySleepUntilStep = class extends BaseLazyStep {
+  sleepUntil;
+  stepType = "SleepUntil";
+  constructor(stepName, sleepUntil) {
+    super(stepName);
+    this.sleepUntil = sleepUntil;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepUntil: this.sleepUntil,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepUntil: this.sleepUntil,
+      concurrent
+    });
+  }
+};
+var LazyCallStep = class extends BaseLazyStep {
+  url;
+  method;
+  body;
+  headers;
+  stepType = "Call";
+  retries;
+  constructor(stepName, url, method, body, headers, retries) {
+    super(stepName);
+    this.url = url;
+    this.method = method;
+    this.body = body;
+    this.headers = headers;
+    this.retries = retries;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      callUrl: this.url,
+      callMethod: this.method,
+      callBody: this.body,
+      callHeaders: this.headers
+    });
+  }
+};
+var LazyWaitForEventStep = class extends BaseLazyStep {
+  eventId;
+  timeout;
+  stepType = "Wait";
+  constructor(stepName, eventId, timeout) {
+    super(stepName);
+    this.eventId = eventId;
+    this.timeout = timeout;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      waitEventId: this.eventId,
+      timeout: this.timeout,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      waitEventId: this.eventId,
+      timeout: this.timeout,
+      concurrent
+    });
+  }
+};
+var LazyNotifyStep = class extends LazyFunctionStep {
+  stepType = "Notify";
+  constructor(stepName, eventId, eventData, requester) {
+    super(stepName, async () => {
+      const notifyResponse = await makeNotifyRequest(requester, eventId, eventData);
+      return {
+        eventId,
+        eventData,
+        notifyResponse
+      };
+    });
+  }
+};
+
 // node_modules/neverthrow/dist/index.es.js
 var defaultErrorConfig = {
   withStackTrace: false
@@ -525,10 +716,11 @@ var triggerFirstInvocation = async (workflowContext, retries, debug) => {
     url: workflowContext.url
   });
   try {
-    await workflowContext.qstashClient.publishJSON({
+    const body = typeof workflowContext.requestPayload === "string" ? workflowContext.requestPayload : JSON.stringify(workflowContext.requestPayload);
+    await workflowContext.qstashClient.publish({
       headers,
       method: "POST",
-      body: workflowContext.requestPayload,
+      body,
       url: workflowContext.url
     });
     return ok("success");
@@ -654,7 +846,7 @@ ${atob(callbackMessage.body)}`
     );
   }
 };
-var getHeaders = (initHeaderValue, workflowRunId, workflowUrl, userHeaders, step, failureUrl, retries) => {
+var getHeaders = (initHeaderValue, workflowRunId, workflowUrl, userHeaders, step, failureUrl, retries, callRetries) => {
   const baseHeaders = {
     [WORKFLOW_INIT_HEADER]: initHeaderValue,
     [WORKFLOW_ID_HEADER]: workflowRunId,
@@ -670,7 +862,7 @@ var getHeaders = (initHeaderValue, workflowRunId, workflowUrl, userHeaders, step
     baseHeaders["Upstash-Failure-Callback"] = failureUrl;
   }
   if (step?.callUrl) {
-    baseHeaders["Upstash-Retries"] = "0";
+    baseHeaders["Upstash-Retries"] = callRetries?.toString() ?? "0";
     baseHeaders[WORKFLOW_FEATURE_HEADER] = "WF_NoDelete";
     if (retries) {
       baseHeaders["Upstash-Callback-Retries"] = retries.toString();
@@ -678,6 +870,7 @@ var getHeaders = (initHeaderValue, workflowRunId, workflowUrl, userHeaders, step
     }
   } else if (retries !== void 0) {
     baseHeaders["Upstash-Retries"] = retries.toString();
+    baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
   }
   if (userHeaders) {
     for (const header of userHeaders.keys()) {
@@ -686,6 +879,7 @@ var getHeaders = (initHeaderValue, workflowRunId, workflowUrl, userHeaders, step
       } else {
         baseHeaders[`Upstash-Forward-${header}`] = userHeaders.get(header);
       }
+      baseHeaders[`Upstash-Failure-Callback-Forward-${header}`] = userHeaders.get(header);
     }
   }
   const contentType = (userHeaders ? userHeaders.get("Content-Type") : void 0) ?? DEFAULT_CONTENT_TYPE;
@@ -869,7 +1063,7 @@ var AutoExecutor = class _AutoExecutor {
       step: resultStep,
       stepCount: this.stepCount
     });
-    await this.submitStepsToQStash([resultStep]);
+    await this.submitStepsToQStash([resultStep], [lazyStep]);
     return resultStep.out;
   }
   /**
@@ -901,7 +1095,7 @@ var AutoExecutor = class _AutoExecutor {
         const planSteps = parallelSteps.map(
           (parallelStep, index) => parallelStep.getPlanStep(parallelSteps.length, initialStepCount + index)
         );
-        await this.submitStepsToQStash(planSteps);
+        await this.submitStepsToQStash(planSteps, parallelSteps);
         break;
       }
       case "partial": {
@@ -914,11 +1108,12 @@ var AutoExecutor = class _AutoExecutor {
         const stepIndex = planStep.targetStep - initialStepCount;
         validateStep(parallelSteps[stepIndex], planStep);
         try {
-          const resultStep = await parallelSteps[stepIndex].getResultStep(
+          const parallelStep = parallelSteps[stepIndex];
+          const resultStep = await parallelStep.getResultStep(
             parallelSteps.length,
             planStep.targetStep
           );
-          await this.submitStepsToQStash([resultStep]);
+          await this.submitStepsToQStash([resultStep], [parallelStep]);
         } catch (error) {
           if (error instanceof QStashWorkflowAbort) {
             throw error;
@@ -979,7 +1174,7 @@ var AutoExecutor = class _AutoExecutor {
    *
    * @param steps steps to send
    */
-  async submitStepsToQStash(steps) {
+  async submitStepsToQStash(steps, lazySteps) {
     if (steps.length === 0) {
       throw new QStashWorkflowError(
         `Unable to submit steps to QStash. Provided list is empty. Current step: ${this.stepCount}`
@@ -1024,7 +1219,8 @@ var AutoExecutor = class _AutoExecutor {
       throw new QStashWorkflowAbort(steps[0].stepName, steps[0]);
     }
     const result = await this.context.qstashClient.batchJSON(
-      steps.map((singleStep) => {
+      steps.map((singleStep, index) => {
+        const lazyStep = lazySteps[index];
         const { headers } = getHeaders(
           "false",
           this.context.workflowRunId,
@@ -1032,7 +1228,8 @@ var AutoExecutor = class _AutoExecutor {
           this.context.headers,
           singleStep,
           this.context.failureUrl,
-          this.context.retries
+          this.context.retries,
+          lazyStep instanceof LazyCallStep ? lazyStep.retries : void 0
         );
         const willWait = singleStep.concurrent === NO_CONCURRENCY || singleStep.stepId === 0;
         singleStep.out = JSON.stringify(singleStep.out);
@@ -1145,195 +1342,6 @@ var sortSteps = (steps) => {
   return [...steps].sort((step, stepOther) => getStepId(step) - getStepId(stepOther));
 };
 
-// src/client/utils.ts
-var makeNotifyRequest = async (requester, eventId, eventData) => {
-  const result = await requester.request({
-    path: ["v2", "notify", eventId],
-    method: "POST",
-    body: typeof eventData === "string" ? eventData : JSON.stringify(eventData)
-  });
-  return result;
-};
-var makeGetWaitersRequest = async (requester, eventId) => {
-  const result = await requester.request({
-    path: ["v2", "waiters", eventId],
-    method: "GET"
-  });
-  return result;
-};
-
-// src/context/steps.ts
-var BaseLazyStep = class {
-  stepName;
-  // will be set in the subclasses
-  constructor(stepName) {
-    this.stepName = stepName;
-  }
-};
-var LazyFunctionStep = class extends BaseLazyStep {
-  stepFunction;
-  stepType = "Run";
-  constructor(stepName, stepFunction) {
-    super(stepName);
-    this.stepFunction = stepFunction;
-  }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      concurrent,
-      targetStep
-    };
-  }
-  async getResultStep(concurrent, stepId) {
-    let result = this.stepFunction();
-    if (result instanceof Promise) {
-      result = await result;
-    }
-    return {
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      out: result,
-      concurrent
-    };
-  }
-};
-var LazySleepStep = class extends BaseLazyStep {
-  sleep;
-  stepType = "SleepFor";
-  constructor(stepName, sleep) {
-    super(stepName);
-    this.sleep = sleep;
-  }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      sleepFor: this.sleep,
-      concurrent,
-      targetStep
-    };
-  }
-  async getResultStep(concurrent, stepId) {
-    return await Promise.resolve({
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      sleepFor: this.sleep,
-      concurrent
-    });
-  }
-};
-var LazySleepUntilStep = class extends BaseLazyStep {
-  sleepUntil;
-  stepType = "SleepUntil";
-  constructor(stepName, sleepUntil) {
-    super(stepName);
-    this.sleepUntil = sleepUntil;
-  }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      sleepUntil: this.sleepUntil,
-      concurrent,
-      targetStep
-    };
-  }
-  async getResultStep(concurrent, stepId) {
-    return await Promise.resolve({
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      sleepUntil: this.sleepUntil,
-      concurrent
-    });
-  }
-};
-var LazyCallStep = class extends BaseLazyStep {
-  url;
-  method;
-  body;
-  headers;
-  stepType = "Call";
-  constructor(stepName, url, method, body, headers) {
-    super(stepName);
-    this.url = url;
-    this.method = method;
-    this.body = body;
-    this.headers = headers;
-  }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      concurrent,
-      targetStep
-    };
-  }
-  async getResultStep(concurrent, stepId) {
-    return await Promise.resolve({
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      concurrent,
-      callUrl: this.url,
-      callMethod: this.method,
-      callBody: this.body,
-      callHeaders: this.headers
-    });
-  }
-};
-var LazyWaitForEventStep = class extends BaseLazyStep {
-  eventId;
-  timeout;
-  stepType = "Wait";
-  constructor(stepName, eventId, timeout) {
-    super(stepName);
-    this.eventId = eventId;
-    this.timeout = timeout;
-  }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      waitEventId: this.eventId,
-      timeout: this.timeout,
-      concurrent,
-      targetStep
-    };
-  }
-  async getResultStep(concurrent, stepId) {
-    return await Promise.resolve({
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      waitEventId: this.eventId,
-      timeout: this.timeout,
-      concurrent
-    });
-  }
-};
-var LazyNotifyStep = class extends LazyFunctionStep {
-  stepType = "Notify";
-  constructor(stepName, eventId, eventData, requester) {
-    super(stepName, async () => {
-      const notifyResponse = await makeNotifyRequest(requester, eventId, eventData);
-      return {
-        eventId,
-        eventData,
-        notifyResponse
-      };
-    });
-  }
-};
-
 // src/context/context.ts
 var WorkflowContext = class {
   executor;
@@ -1549,11 +1557,13 @@ var WorkflowContext = class {
    * network call without consuming any runtime.
    *
    * ```ts
-   * const postResult = await context.call<string>(
+   * const { status, body } = await context.call<string>(
    *   "post call step",
-   *   `https://www.some-endpoint.com/api`,
-   *   "POST",
-   *   "my-payload"
+   *   {
+   *     url: `https://www.some-endpoint.com/api`,
+   *     method: "POST",
+   *     body: "my-payload"
+   *   }
    * );
    * ```
    *
@@ -1563,9 +1573,10 @@ var WorkflowContext = class {
    *
    * @param stepName
    * @param url url to call
-   * @param method call method
+   * @param method call method. "GET" by default.
    * @param body call body
    * @param headers call headers
+   * @param retries number of call retries. 0 by default
    * @returns call result as {
    *     status: number;
    *     body: unknown;
@@ -1573,9 +1584,9 @@ var WorkflowContext = class {
    *   }
    */
   async call(stepName, settings) {
-    const { url, method = "GET", body, headers = {} } = settings;
+    const { url, method = "GET", body, headers = {}, retries = 0 } = settings;
     const result = await this.addStep(
-      new LazyCallStep(stepName, url, method, body, headers ?? {})
+      new LazyCallStep(stepName, url, method, body, headers, retries)
     );
     if (typeof result === "string") {
       try {
@@ -1722,11 +1733,14 @@ var WorkflowLogger = class _WorkflowLogger {
 };
 
 // src/utils.ts
-var import_crypto = __toESM(require("crypto"));
+var import_node_crypto = __toESM(require("crypto"));
 var NANOID_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
 var NANOID_LENGTH = 21;
 function nanoid() {
-  return [...import_crypto.default.getRandomValues(new Uint8Array(NANOID_LENGTH))].map((x) => NANOID_CHARS[x % NANOID_CHARS.length]).join("");
+  return [...import_node_crypto.default.getRandomValues(new Uint8Array(NANOID_LENGTH))].map((x) => NANOID_CHARS[x % NANOID_CHARS.length]).join("");
+}
+function getWorkflowRunId(id) {
+  return `wfr_${id ?? nanoid()}`;
 }
 function decodeBase64(base64) {
   try {
@@ -1832,7 +1846,7 @@ var validateRequest = (request) => {
       `Incompatible workflow sdk protocol version. Expected ${WORKFLOW_PROTOCOL_VERSION}, got ${versionHeader} from the request.`
     );
   }
-  const workflowRunId = isFirstInvocation ? `wfr_${nanoid()}` : request.headers.get(WORKFLOW_ID_HEADER) ?? "";
+  const workflowRunId = isFirstInvocation ? getWorkflowRunId() : request.headers.get(WORKFLOW_ID_HEADER) ?? "";
   if (workflowRunId.length === 0) {
     throw new QStashWorkflowError("Couldn't get workflow id from header");
   }
@@ -2202,6 +2216,58 @@ var Client3 = class {
   async getWaiters({ eventId }) {
     return await makeGetWaitersRequest(this.client.http, eventId);
   }
+  /**
+   * Trigger new workflow run and returns the workflow run id
+   *
+   * ```ts
+   * const { workflowRunId } await client.trigger({
+   *   url: "https://workflow-endpoint.com",
+   *   body: "hello there!", // optional body
+   *   headers: { ... }, // optional headers
+   *   workflowRunId: "my-workflow", // optional workflow run id
+   *   retries: 3 // optional retries in the initial request
+   * })
+   *
+   * console.log(workflowRunId)
+   * // wfr_my-workflow
+   * ```
+   *
+   * @param url URL of the workflow
+   * @param body body to start the workflow with
+   * @param headers headers to use in the request
+   * @param workflowRunId optional workflow run id to use. mind that
+   *   you should pass different workflow run ids for different runs.
+   *   The final workflowRunId will be `wfr_${workflowRunId}`, in
+   *   other words: the workflow run id you pass will be prefixed
+   *   with `wfr_`.
+   * @param retries retry to use in the initial request. in the rest of
+   *   the workflow, `retries` option of the `serve` will be used.
+   * @returns workflow run id
+   */
+  async trigger({
+    url,
+    body,
+    headers,
+    workflowRunId,
+    retries
+  }) {
+    const finalWorkflowRunId = getWorkflowRunId(workflowRunId);
+    const context = new WorkflowContext({
+      qstashClient: this.client,
+      // @ts-expect-error headers type mismatch
+      headers: new Headers(headers ?? {}),
+      initialPayload: body,
+      steps: [],
+      url,
+      workflowRunId: finalWorkflowRunId
+    });
+    const result = await triggerFirstInvocation(context, retries ?? DEFAULT_RETRIES);
+    if (result.isOk()) {
+      return { workflowRunId: finalWorkflowRunId };
+    } else {
+      throw result.error;
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/index.mjs

@@ -6,7 +6,7 @@ import {
   WorkflowContext,
   WorkflowLogger,
   serve
-} from "./chunk-3FILROVK.mjs";
+} from "./chunk-35GJPVE2.mjs";
 export {
   Client,
   QStashWorkflowAbort,

package/nextjs.d.mts

@@ -1,5 +1,5 @@
 import { NextApiHandler } from 'next';
-import { R as RouteFunction, W as WorkflowServeOptions } from './types-CI-2skYU.mjs';
+import { R as RouteFunction, W as WorkflowServeOptions } from './types-CQuc-j8n.mjs';
 import '@upstash/qstash';
 
 /**

package/nextjs.d.ts

@@ -1,5 +1,5 @@
 import { NextApiHandler } from 'next';
-import { R as RouteFunction, W as WorkflowServeOptions } from './types-CI-2skYU.js';
+import { R as RouteFunction, W as WorkflowServeOptions } from './types-CQuc-j8n.js';
 import '@upstash/qstash';
 
 /**