@upstash/workflow 0.1.5 → 0.2.0

package/astro.js

@@ -26,22 +26,33 @@ module.exports = __toCommonJS(astro_exports);
 
 // src/error.ts
 var import_qstash = require("@upstash/qstash");
-var QStashWorkflowError = class extends import_qstash.QstashError {
+var WorkflowError = class extends import_qstash.QstashError {
   constructor(message) {
     super(message);
-    this.name = "QStashWorkflowError";
+    this.name = "WorkflowError";
   }
 };
-var QStashWorkflowAbort = class extends Error {
+var WorkflowAbort = class extends Error {
   stepInfo;
   stepName;
-  constructor(stepName, stepInfo) {
+  /**
+   * whether workflow is to be canceled on abort
+   */
+  cancelWorkflow;
+  /**
+   *
+   * @param stepName name of the aborting step
+   * @param stepInfo step information
+   * @param cancelWorkflow
+   */
+  constructor(stepName, stepInfo, cancelWorkflow = false) {
     super(
       `This is an Upstash Workflow error thrown after a step executes. It is expected to be raised. Make sure that you await for each step. Also, if you are using try/catch blocks, you should not wrap context.run/sleep/sleepUntil/call methods with try/catch. Aborting workflow after executing step '${stepName}'.`
     );
-    this.name = "QStashWorkflowAbort";
+    this.name = "WorkflowAbort";
     this.stepName = stepName;
     this.stepInfo = stepInfo;
+    this.cancelWorkflow = cancelWorkflow;
   }
 };
 var formatWorkflowError = (error) => {
@@ -63,6 +74,44 @@ var makeNotifyRequest = async (requester, eventId, eventData) => {
   });
   return result;
 };
+var makeCancelRequest = async (requester, workflowRunId) => {
+  await requester.request({
+    path: ["v2", "workflows", "runs", `${workflowRunId}?cancel=true`],
+    method: "DELETE",
+    parseResponseAsJson: false
+  });
+  return true;
+};
+var getSteps = async (requester, workflowRunId, messageId, debug) => {
+  try {
+    const steps = await requester.request({
+      path: ["v2", "workflows", "runs", workflowRunId],
+      parseResponseAsJson: true
+    });
+    if (!messageId) {
+      await debug?.log("INFO", "ENDPOINT_START", {
+        message: `Pulled ${steps.length} steps from QStashand returned them without filtering with messageId.`
+      });
+      return steps;
+    } else {
+      const index = steps.findIndex((item) => item.messageId === messageId);
+      if (index === -1) {
+        return [];
+      }
+      const filteredSteps = steps.slice(0, index + 1);
+      await debug?.log("INFO", "ENDPOINT_START", {
+        message: `Pulled ${steps.length} steps from QStash and filtered them to ${filteredSteps.length} using messageId.`
+      });
+      return filteredSteps;
+    }
+  } catch (error) {
+    await debug?.log("ERROR", "ERROR", {
+      message: "failed while fetching steps.",
+      error
+    });
+    throw new WorkflowError(`Failed while pulling steps. ${error}`);
+  }
+};
 
 // src/context/steps.ts
 var BaseLazyStep = class {
@@ -677,6 +726,7 @@ var StepTypes = [
 ];
 
 // src/workflow-requests.ts
+var import_qstash2 = require("@upstash/qstash");
 var triggerFirstInvocation = async (workflowContext, retries, debug) => {
   const { headers } = getHeaders(
     "true",
@@ -687,20 +737,32 @@ var triggerFirstInvocation = async (workflowContext, retries, debug) => {
     workflowContext.failureUrl,
     retries
   );
-  await debug?.log("SUBMIT", "SUBMIT_FIRST_INVOCATION", {
-    headers,
-    requestPayload: workflowContext.requestPayload,
-    url: workflowContext.url
-  });
   try {
     const body = typeof workflowContext.requestPayload === "string" ? workflowContext.requestPayload : JSON.stringify(workflowContext.requestPayload);
-    await workflowContext.qstashClient.publish({
+    const result = await workflowContext.qstashClient.publish({
       headers,
       method: "POST",
       body,
       url: workflowContext.url
     });
-    return ok("success");
+    if (result.deduplicated) {
+      await debug?.log("WARN", "SUBMIT_FIRST_INVOCATION", {
+        message: `Workflow run ${workflowContext.workflowRunId} already exists. A new one isn't created.`,
+        headers,
+        requestPayload: workflowContext.requestPayload,
+        url: workflowContext.url,
+        messageId: result.messageId
+      });
+      return ok("workflow-run-already-exists");
+    } else {
+      await debug?.log("SUBMIT", "SUBMIT_FIRST_INVOCATION", {
+        headers,
+        requestPayload: workflowContext.requestPayload,
+        url: workflowContext.url,
+        messageId: result.messageId
+      });
+      return ok("success");
+    }
   } catch (error) {
     const error_ = error;
     return err(error_);
@@ -708,7 +770,9 @@ var triggerFirstInvocation = async (workflowContext, retries, debug) => {
 };
 var triggerRouteFunction = async ({
   onCleanup,
-  onStep
+  onStep,
+  onCancel,
+  debug
 }) => {
   try {
     await onStep();
@@ -716,19 +780,50 @@ var triggerRouteFunction = async ({
     return ok("workflow-finished");
   } catch (error) {
     const error_ = error;
-    return error_ instanceof QStashWorkflowAbort ? ok("step-finished") : err(error_);
+    if (error instanceof import_qstash2.QstashError && error.status === 400) {
+      await debug?.log("WARN", "RESPONSE_WORKFLOW", {
+        message: `tried to append to a cancelled workflow. exiting without publishing.`,
+        name: error.name,
+        errorMessage: error.message
+      });
+      return ok("workflow-was-finished");
+    } else if (!(error_ instanceof WorkflowAbort)) {
+      return err(error_);
+    } else if (error_.cancelWorkflow) {
+      await onCancel();
+      return ok("workflow-finished");
+    } else {
+      return ok("step-finished");
+    }
   }
 };
 var triggerWorkflowDelete = async (workflowContext, debug, cancel = false) => {
   await debug?.log("SUBMIT", "SUBMIT_CLEANUP", {
     deletedWorkflowRunId: workflowContext.workflowRunId
   });
-  const result = await workflowContext.qstashClient.http.request({
-    path: ["v2", "workflows", "runs", `${workflowContext.workflowRunId}?cancel=${cancel}`],
-    method: "DELETE",
-    parseResponseAsJson: false
-  });
-  await debug?.log("SUBMIT", "SUBMIT_CLEANUP", result);
+  try {
+    await workflowContext.qstashClient.http.request({
+      path: ["v2", "workflows", "runs", `${workflowContext.workflowRunId}?cancel=${cancel}`],
+      method: "DELETE",
+      parseResponseAsJson: false
+    });
+    await debug?.log(
+      "SUBMIT",
+      "SUBMIT_CLEANUP",
+      `workflow run ${workflowContext.workflowRunId} deleted.`
+    );
+    return { deleted: true };
+  } catch (error) {
+    if (error instanceof import_qstash2.QstashError && error.status === 404) {
+      await debug?.log("WARN", "SUBMIT_CLEANUP", {
+        message: `Failed to remove workflow run ${workflowContext.workflowRunId} as it doesn't exist.`,
+        name: error.name,
+        errorMessage: error.message
+      });
+      return { deleted: false };
+    }
+    throw error;
+  }
 };
 var recreateUserHeaders = (headers) => {
   const filteredHeaders = new Headers();
@@ -744,15 +839,32 @@ var recreateUserHeaders = (headers) => {
 var handleThirdPartyCallResult = async (request, requestPayload, client, workflowUrl, failureUrl, retries, debug) => {
   try {
     if (request.headers.get("Upstash-Workflow-Callback")) {
-      const callbackMessage = JSON.parse(requestPayload);
+      let callbackPayload;
+      if (requestPayload) {
+        callbackPayload = requestPayload;
+      } else {
+        const workflowRunId2 = request.headers.get("upstash-workflow-runid");
+        const messageId = request.headers.get("upstash-message-id");
+        if (!workflowRunId2)
+          throw new WorkflowError("workflow run id missing in context.call lazy fetch.");
+        if (!messageId) throw new WorkflowError("message id missing in context.call lazy fetch.");
+        const steps = await getSteps(client.http, workflowRunId2, messageId, debug);
+        const failingStep = steps.find((step) => step.messageId === messageId);
+        if (!failingStep)
+          throw new WorkflowError(
+            "Failed to submit the context.call." + (steps.length === 0 ? "No steps found." : `No step was found with matching messageId ${messageId} out of ${steps.length} steps.`)
+          );
+        callbackPayload = atob(failingStep.body);
+      }
+      const callbackMessage = JSON.parse(callbackPayload);
       if (!(callbackMessage.status >= 200 && callbackMessage.status < 300) && callbackMessage.maxRetries && callbackMessage.retried !== callbackMessage.maxRetries) {
         await debug?.log("WARN", "SUBMIT_THIRD_PARTY_RESULT", {
           status: callbackMessage.status,
-          body: atob(callbackMessage.body)
+          body: atob(callbackMessage.body ?? "")
         });
         console.warn(
           `Workflow Warning: "context.call" failed with status ${callbackMessage.status} and will retry (retried ${callbackMessage.retried ?? 0} out of ${callbackMessage.maxRetries} times). Error Message:
-${atob(callbackMessage.body)}`
+${atob(callbackMessage.body ?? "")}`
         );
         return ok("call-will-retry");
       }
@@ -786,7 +898,7 @@ ${atob(callbackMessage.body)}`
       );
       const callResponse = {
         status: callbackMessage.status,
-        body: atob(callbackMessage.body),
+        body: atob(callbackMessage.body ?? ""),
         header: callbackMessage.header
       };
       const callResultStep = {
@@ -817,9 +929,7 @@ ${atob(callbackMessage.body)}`
   } catch (error) {
     const isCallReturn = request.headers.get("Upstash-Workflow-Callback");
     return err(
-      new QStashWorkflowError(
-        `Error when handling call return (isCallReturn=${isCallReturn}): ${error}`
-      )
+      new WorkflowError(`Error when handling call return (isCallReturn=${isCallReturn}): ${error}`)
     );
   }
 };
@@ -827,7 +937,8 @@ var getHeaders = (initHeaderValue, workflowRunId, workflowUrl, userHeaders, step
   const baseHeaders = {
     [WORKFLOW_INIT_HEADER]: initHeaderValue,
     [WORKFLOW_ID_HEADER]: workflowRunId,
-    [WORKFLOW_URL_HEADER]: workflowUrl
+    [WORKFLOW_URL_HEADER]: workflowUrl,
+    [WORKFLOW_FEATURE_HEADER]: "LazyFetch,InitialBody"
   };
   if (!step?.callUrl) {
     baseHeaders[`Upstash-Forward-${WORKFLOW_PROTOCOL_VERSION_HEADER}`] = WORKFLOW_PROTOCOL_VERSION;
@@ -840,8 +951,8 @@ var getHeaders = (initHeaderValue, workflowRunId, workflowUrl, userHeaders, step
   }
   if (step?.callUrl) {
     baseHeaders["Upstash-Retries"] = callRetries?.toString() ?? "0";
-    baseHeaders[WORKFLOW_FEATURE_HEADER] = "WF_NoDelete";
-    if (retries) {
+    baseHeaders[WORKFLOW_FEATURE_HEADER] = "WF_NoDelete,InitialBody";
+    if (retries !== void 0) {
       baseHeaders["Upstash-Callback-Retries"] = retries.toString();
       baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
     }
@@ -876,6 +987,7 @@ var getHeaders = (initHeaderValue, workflowRunId, workflowUrl, userHeaders, step
         "Upstash-Callback-Workflow-CallType": "fromCallback",
         "Upstash-Callback-Workflow-Init": "false",
         "Upstash-Callback-Workflow-Url": workflowUrl,
+        "Upstash-Callback-Feature-Set": "LazyFetch,InitialBody",
         "Upstash-Callback-Forward-Upstash-Workflow-Callback": "true",
         "Upstash-Callback-Forward-Upstash-Workflow-StepId": step.stepId.toString(),
         "Upstash-Callback-Forward-Upstash-Workflow-StepName": step.stepName,
@@ -924,7 +1036,7 @@ var verifyRequest = async (body, signature, verifier) => {
       throw new Error("Signature in `Upstash-Signature` header is not valid");
     }
   } catch (error) {
-    throw new QStashWorkflowError(
+    throw new WorkflowError(
       `Failed to verify that the Workflow request comes from QStash: ${error}
 
 If signature is missing, trigger the workflow endpoint by publishing your request to QStash instead of calling it directly.
@@ -964,14 +1076,14 @@ var AutoExecutor = class _AutoExecutor {
    *
    * If a function is already executing (this.executingStep), this
    * means that there is a nested step which is not allowed. In this
-   * case, addStep throws QStashWorkflowError.
+   * case, addStep throws WorkflowError.
    *
    * @param stepInfo step plan to add
    * @returns result of the step function
    */
   async addStep(stepInfo) {
     if (this.executingStep) {
-      throw new QStashWorkflowError(
+      throw new WorkflowError(
         `A step can not be run inside another step. Tried to run '${stepInfo.stepName}' inside '${this.executingStep}'`
       );
     }
@@ -1056,7 +1168,7 @@ var AutoExecutor = class _AutoExecutor {
     const sortedSteps = sortSteps(this.steps);
     const plannedParallelStepCount = sortedSteps[initialStepCount + this.planStepCount]?.concurrent;
     if (parallelCallState !== "first" && plannedParallelStepCount !== parallelSteps.length) {
-      throw new QStashWorkflowError(
+      throw new WorkflowError(
         `Incompatible number of parallel steps when call state was '${parallelCallState}'. Expected ${parallelSteps.length}, got ${plannedParallelStepCount} from the request.`
       );
     }
@@ -1078,7 +1190,7 @@ var AutoExecutor = class _AutoExecutor {
       case "partial": {
         const planStep = this.steps.at(-1);
         if (!planStep || planStep.targetStep === void 0) {
-          throw new QStashWorkflowError(
+          throw new WorkflowError(
             `There must be a last step and it should have targetStep larger than 0.Received: ${JSON.stringify(planStep)}`
           );
         }
@@ -1092,17 +1204,17 @@ var AutoExecutor = class _AutoExecutor {
           );
           await this.submitStepsToQStash([resultStep], [parallelStep]);
         } catch (error) {
-          if (error instanceof QStashWorkflowAbort) {
+          if (error instanceof WorkflowAbort) {
             throw error;
           }
-          throw new QStashWorkflowError(
+          throw new WorkflowError(
             `Error submitting steps to QStash in partial parallel step execution: ${error}`
           );
         }
         break;
       }
       case "discard": {
-        throw new QStashWorkflowAbort("discarded parallel");
+        throw new WorkflowAbort("discarded parallel");
       }
       case "last": {
         const parallelResultSteps = sortedSteps.filter((step) => step.stepId >= initialStepCount).slice(0, parallelSteps.length);
@@ -1153,7 +1265,7 @@ var AutoExecutor = class _AutoExecutor {
    */
   async submitStepsToQStash(steps, lazySteps) {
     if (steps.length === 0) {
-      throw new QStashWorkflowError(
+      throw new WorkflowError(
         `Unable to submit steps to QStash. Provided list is empty. Current step: ${this.stepCount}`
       );
     }
@@ -1193,7 +1305,7 @@ var AutoExecutor = class _AutoExecutor {
         method: "POST",
         parseResponseAsJson: false
       });
-      throw new QStashWorkflowAbort(steps[0].stepName, steps[0]);
+      throw new WorkflowAbort(steps[0].stepName, steps[0]);
     }
     const result = await this.context.qstashClient.batchJSON(
       steps.map((singleStep, index) => {
@@ -1245,7 +1357,7 @@ var AutoExecutor = class _AutoExecutor {
         };
       })
     });
-    throw new QStashWorkflowAbort(steps[0].stepName, steps[0]);
+    throw new WorkflowAbort(steps[0].stepName, steps[0]);
   }
   /**
    * Get the promise by executing the lazt steps list. If there is a single
@@ -1270,7 +1382,7 @@ var AutoExecutor = class _AutoExecutor {
     } else if (Array.isArray(result) && lazyStepList.length === result.length && index < lazyStepList.length) {
       return result[index];
     } else {
-      throw new QStashWorkflowError(
+      throw new WorkflowError(
         `Unexpected parallel call result while executing step ${index}: '${result}'. Expected ${lazyStepList.length} many items`
       );
     }
@@ -1282,12 +1394,12 @@ var AutoExecutor = class _AutoExecutor {
 };
 var validateStep = (lazyStep, stepFromRequest) => {
   if (lazyStep.stepName !== stepFromRequest.stepName) {
-    throw new QStashWorkflowError(
+    throw new WorkflowError(
       `Incompatible step name. Expected '${lazyStep.stepName}', got '${stepFromRequest.stepName}' from the request`
     );
   }
   if (lazyStep.stepType !== stepFromRequest.stepType) {
-    throw new QStashWorkflowError(
+    throw new WorkflowError(
       `Incompatible step type. Expected '${lazyStep.stepType}', got '${stepFromRequest.stepType}' from the request`
     );
   }
@@ -1298,12 +1410,12 @@ var validateParallelSteps = (lazySteps, stepsFromRequest) => {
       validateStep(lazySteps[index], stepFromRequest);
     }
   } catch (error) {
-    if (error instanceof QStashWorkflowError) {
+    if (error instanceof WorkflowError) {
       const lazyStepNames = lazySteps.map((lazyStep) => lazyStep.stepName);
       const lazyStepTypes = lazySteps.map((lazyStep) => lazyStep.stepType);
       const requestStepNames = stepsFromRequest.map((step) => step.stepName);
       const requestStepTypes = stepsFromRequest.map((step) => step.stepType);
-      throw new QStashWorkflowError(
+      throw new WorkflowError(
         `Incompatible steps detected in parallel execution: ${error.message}
   > Step Names from the request: ${JSON.stringify(requestStepNames)}
     Step Types from the request: ${JSON.stringify(requestStepTypes)}
@@ -1416,10 +1528,6 @@ var WorkflowContext = class {
    * headers of the initial request
    */
   headers;
-  /**
-   * initial payload as a raw string
-   */
-  rawInitialPayload;
   /**
    * Map of environment variables and their values.
    *
@@ -1454,7 +1562,6 @@ var WorkflowContext = class {
     failureUrl,
     debug,
     initialPayload,
-    rawInitialPayload,
     env,
     retries
   }) {
@@ -1465,7 +1572,6 @@ var WorkflowContext = class {
     this.failureUrl = failureUrl;
     this.headers = headers;
     this.requestPayload = initialPayload;
-    this.rawInitialPayload = rawInitialPayload ?? JSON.stringify(this.requestPayload);
     this.env = env ?? {};
     this.retries = retries ?? DEFAULT_RETRIES;
     this.executor = new AutoExecutor(this, this.steps, debug);
@@ -1486,7 +1592,7 @@ var WorkflowContext = class {
    * const [result1, result2] = await Promise.all([
    *   context.run("step 1", () => {
    *     return "result1"
-   *   })
+   *   }),
    *   context.run("step 2", async () => {
    *     return await fetchResults()
    *   })
@@ -1504,6 +1610,10 @@ var WorkflowContext = class {
   /**
    * Stops the execution for the duration provided.
    *
+   * ```typescript
+   * await context.sleep('sleep1', 3) // wait for three seconds
+   * ```
+   *
    * @param stepName
    * @param duration sleep duration in seconds
    * @returns undefined
@@ -1514,6 +1624,10 @@ var WorkflowContext = class {
   /**
    * Stops the execution until the date time provided.
    *
+   * ```typescript
+   * await context.sleepUntil('sleep1', Date.now() / 1000 + 3) // wait for three seconds
+   * ```
+   *
    * @param stepName
    * @param datetime time to sleep until. Can be provided as a number (in unix seconds),
    *   as a Date object or a string (passed to `new Date(datetimeString)`)
@@ -1537,7 +1651,7 @@ var WorkflowContext = class {
    * const { status, body } = await context.call<string>(
    *   "post call step",
    *   {
-   *     url: `https://www.some-endpoint.com/api`,
+   *     url: "https://www.some-endpoint.com/api",
    *     method: "POST",
    *     body: "my-payload"
    *   }
@@ -1591,45 +1705,43 @@ var WorkflowContext = class {
     }
   }
   /**
-   * Makes the workflow run wait until a notify request is sent or until the
-   * timeout ends
+   * Pauses workflow execution until a specific event occurs or a timeout is reached.
    *
-   * ```ts
-   * const { eventData, timeout } = await context.waitForEvent(
-   *   "wait for event step",
-   *   "my-event-id",
-   *   100 // timeout after 100 seconds
-   * );
-   * ```
+   *```ts
+   * const result = await workflow.waitForEvent("payment-confirmed", {
+   *   timeout: "5m"
+   * });
+   *```
    *
-   * To notify a waiting workflow run, you can use the notify method:
+   * To notify a waiting workflow:
    *
    * ```ts
    * import { Client } from "@upstash/workflow";
    *
-   * const client = new Client({ token: });
+   * const client = new Client({ token: "<QSTASH_TOKEN>" });
    *
    * await client.notify({
-   *   eventId: "my-event-id",
-   *   eventData: "eventData"
+   *   eventId: "payment.confirmed",
+   *   data: {
+   *     amount: 99.99,
+   *     currency: "USD"
+   *   }
    * })
    * ```
    *
+   * Alternatively, you can use the `context.notify` method.
+   *
    * @param stepName
-   * @param eventId event id to wake up the waiting workflow run
-   * @param timeout timeout duration in seconds
-   * @returns wait response as `{ timeout: boolean, eventData: unknown }`.
-   *   timeout is true if the wait times out, if notified it is false. eventData
-   *   is the value passed to `client.notify`.
+   * @param eventId - Unique identifier for the event to wait for
+   * @param options - Configuration options.
+   * @returns `{ timeout: boolean, eventData: unknown }`.
+   *   The `timeout` property specifies if the workflow has timed out. The `eventData`
+   *   is the data passed when notifying this workflow of an event.
    */
-  async waitForEvent(stepName, eventId, timeout) {
-    const result = await this.addStep(
-      new LazyWaitForEventStep(
-        stepName,
-        eventId,
-        typeof timeout === "string" ? timeout : `${timeout}s`
-      )
-    );
+  async waitForEvent(stepName, eventId, options = {}) {
+    const { timeout = "7d" } = options;
+    const timeoutStr = typeof timeout === "string" ? timeout : `${timeout}s`;
+    const result = await this.addStep(new LazyWaitForEventStep(stepName, eventId, timeoutStr));
     try {
       return {
         ...result,
@@ -1639,6 +1751,27 @@ var WorkflowContext = class {
       return result;
     }
   }
+  /**
+   * Notify workflow runs waiting for an event
+   *
+   * ```ts
+   * const { eventId, eventData, notifyResponse } = await context.notify(
+   *   "notify step", "event-id", "event-data"
+   * );
+   * ```
+   *
+   * Upon `context.notify`, the workflow runs waiting for the given eventId (context.waitForEvent)
+   * will receive the given event data and resume execution.
+   *
+   * The response includes the same eventId and eventData. Additionally, there is
+   * a notifyResponse field which contains a list of `Waiter` objects, each corresponding
+   * to a notified workflow run.
+   *
+   * @param stepName
+   * @param eventId event id to notify
+   * @param eventData event data to notify with
+   * @returns notify response which has event id, event data and list of waiters which were notified
+   */
   async notify(stepName, eventId, eventData) {
     const result = await this.addStep(
       new LazyNotifyStep(stepName, eventId, eventData, this.qstashClient.http)
@@ -1652,6 +1785,15 @@ var WorkflowContext = class {
       return result;
     }
   }
+  /**
+   * Cancel the current workflow run
+   *
+   * Will throw WorkflowAbort to stop workflow execution.
+   * Shouldn't be inside try/catch.
+   */
+  async cancel() {
+    throw new WorkflowAbort("cancel", void 0, true);
+  }
   /**
    * Adds steps to the executor. Needed so that it can be overwritten in
    * DisabledWorkflowContext.
@@ -1692,7 +1834,8 @@ var WorkflowLogger = class _WorkflowLogger {
   }
   writeToConsole(logEntry) {
     const JSON_SPACING = 2;
-    console.log(JSON.stringify(logEntry, void 0, JSON_SPACING));
+    const logMethod = logEntry.logLevel === "ERROR" ? console.error : logEntry.logLevel === "WARN" ? console.warn : console.log;
+    logMethod(JSON.stringify(logEntry, void 0, JSON_SPACING));
   }
   shouldLog(level) {
     return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(this.options.logLevel);
@@ -1734,6 +1877,63 @@ function decodeBase64(base64) {
   }
 }
 
+// src/serve/authorization.ts
+var import_qstash3 = require("@upstash/qstash");
+var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowContext {
+  static disabledMessage = "disabled-qstash-worklfow-run";
+  /**
+   * overwrite the WorkflowContext.addStep method to always raise WorkflowAbort
+   * error in order to stop the execution whenever we encounter a step.
+   *
+   * @param _step
+   */
+  async addStep(_step) {
+    throw new WorkflowAbort(_DisabledWorkflowContext.disabledMessage);
+  }
+  /**
+   * overwrite cancel method to do nothing
+   */
+  async cancel() {
+    return;
+  }
+  /**
+   * copies the passed context to create a DisabledWorkflowContext. Then, runs the
+   * route function with the new context.
+   *
+   * - returns "run-ended" if there are no steps found or
+   *      if the auth failed and user called `return`
+   * - returns "step-found" if DisabledWorkflowContext.addStep is called.
+   * - if there is another error, returns the error.
+   *
+   * @param routeFunction
+   */
+  static async tryAuthentication(routeFunction, context) {
+    const disabledContext = new _DisabledWorkflowContext({
+      qstashClient: new import_qstash3.Client({
+        baseUrl: "disabled-client",
+        token: "disabled-client"
+      }),
+      workflowRunId: context.workflowRunId,
+      headers: context.headers,
+      steps: [],
+      url: context.url,
+      failureUrl: context.failureUrl,
+      initialPayload: context.requestPayload,
+      env: context.env,
+      retries: context.retries
+    });
+    try {
+      await routeFunction(disabledContext);
+    } catch (error) {
+      if (error instanceof WorkflowAbort && error.stepName === this.disabledMessage) {
+        return ok("step-found");
+      }
+      return err(error);
+    }
+    return ok("run-ended");
+  }
+};
+
 // src/workflow-parser.ts
 var getPayload = async (request) => {
   try {
@@ -1742,8 +1942,8 @@ var getPayload = async (request) => {
     return;
   }
 };
-var parsePayload = async (rawPayload, debug) => {
-  const [encodedInitialPayload, ...encodedSteps] = JSON.parse(rawPayload);
+var processRawSteps = (rawSteps) => {
+  const [encodedInitialPayload, ...encodedSteps] = rawSteps;
   const rawInitialPayload = decodeBase64(encodedInitialPayload.body);
   const initialStep = {
     stepId: 0,
@@ -1753,27 +1953,21 @@ var parsePayload = async (rawPayload, debug) => {
     concurrent: NO_CONCURRENCY
   };
   const stepsToDecode = encodedSteps.filter((step) => step.callType === "step");
-  const otherSteps = await Promise.all(
-    stepsToDecode.map(async (rawStep) => {
-      const step = JSON.parse(decodeBase64(rawStep.body));
-      try {
-        step.out = JSON.parse(step.out);
-      } catch {
-        await debug?.log("WARN", "ENDPOINT_START", {
-          message: "failed while parsing out field of step",
-          step
-        });
-      }
-      if (step.waitEventId) {
-        const newOut = {
-          eventData: step.out ? decodeBase64(step.out) : void 0,
-          timeout: step.waitTimeout ?? false
-        };
-        step.out = newOut;
-      }
-      return step;
-    })
-  );
+  const otherSteps = stepsToDecode.map((rawStep) => {
+    const step = JSON.parse(decodeBase64(rawStep.body));
+    try {
+      step.out = JSON.parse(step.out);
+    } catch {
+    }
+    if (step.waitEventId) {
+      const newOut = {
+        eventData: step.out ? decodeBase64(step.out) : void 0,
+        timeout: step.waitTimeout ?? false
+      };
+      step.out = newOut;
+    }
+    return step;
+  });
   const steps = [initialStep, ...otherSteps];
   return {
     rawInitialPayload,
@@ -1821,20 +2015,20 @@ var validateRequest = (request) => {
   const versionHeader = request.headers.get(WORKFLOW_PROTOCOL_VERSION_HEADER);
   const isFirstInvocation = !versionHeader;
   if (!isFirstInvocation && versionHeader !== WORKFLOW_PROTOCOL_VERSION) {
-    throw new QStashWorkflowError(
+    throw new WorkflowError(
       `Incompatible workflow sdk protocol version. Expected ${WORKFLOW_PROTOCOL_VERSION}, got ${versionHeader} from the request.`
     );
   }
   const workflowRunId = isFirstInvocation ? getWorkflowRunId() : request.headers.get(WORKFLOW_ID_HEADER) ?? "";
   if (workflowRunId.length === 0) {
-    throw new QStashWorkflowError("Couldn't get workflow id from header");
+    throw new WorkflowError("Couldn't get workflow id from header");
   }
   return {
     isFirstInvocation,
     workflowRunId
   };
 };
-var parseRequest = async (requestPayload, isFirstInvocation, debug) => {
+var parseRequest = async (requestPayload, isFirstInvocation, workflowRunId, requester, messageId, debug) => {
   if (isFirstInvocation) {
     return {
       rawInitialPayload: requestPayload ?? "",
@@ -1842,10 +2036,18 @@ var parseRequest = async (requestPayload, isFirstInvocation, debug) => {
       isLastDuplicate: false
     };
   } else {
+    let rawSteps;
     if (!requestPayload) {
-      throw new QStashWorkflowError("Only first call can have an empty body");
+      await debug?.log(
+        "INFO",
+        "ENDPOINT_START",
+        "request payload is empty, steps will be fetched from QStash."
+      );
+      rawSteps = await getSteps(requester, workflowRunId, messageId, debug);
+    } else {
+      rawSteps = JSON.parse(requestPayload);
     }
-    const { rawInitialPayload, steps } = await parsePayload(requestPayload, debug);
+    const { rawInitialPayload, steps } = processRawSteps(rawSteps);
     const isLastDuplicate = await checkIfLastOneIsDuplicate(steps, debug);
     const deduplicatedSteps = deduplicateSteps(steps);
     return {
@@ -1855,13 +2057,13 @@ var parseRequest = async (requestPayload, isFirstInvocation, debug) => {
     };
   }
 };
-var handleFailure = async (request, requestPayload, qstashClient, initialPayloadParser, failureFunction, debug) => {
+var handleFailure = async (request, requestPayload, qstashClient, initialPayloadParser, routeFunction, failureFunction, debug) => {
   if (request.headers.get(WORKFLOW_FAILURE_HEADER) !== "true") {
     return ok("not-failure-callback");
   }
   if (!failureFunction) {
     return err(
-      new QStashWorkflowError(
+      new WorkflowError(
         "Workflow endpoint is called to handle a failure, but a failureFunction is not provided in serve options. Either provide a failureUrl or a failureFunction."
       )
     );
@@ -1872,92 +2074,48 @@ var handleFailure = async (request, requestPayload, qstashClient, initialPayload
     );
     const decodedBody = body ? decodeBase64(body) : "{}";
     const errorPayload = JSON.parse(decodedBody);
-    const {
-      rawInitialPayload,
-      steps,
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      isLastDuplicate: _isLastDuplicate
-    } = await parseRequest(decodeBase64(sourceBody), false, debug);
     const workflowContext = new WorkflowContext({
       qstashClient,
       workflowRunId,
-      initialPayload: initialPayloadParser(rawInitialPayload),
-      rawInitialPayload,
+      initialPayload: initialPayloadParser(decodeBase64(sourceBody)),
       headers: recreateUserHeaders(new Headers(sourceHeader)),
-      steps,
+      steps: [],
       url,
       failureUrl: url,
       debug
     });
-    await failureFunction(workflowContext, status, errorPayload.message, header);
+    const authCheck = await DisabledWorkflowContext.tryAuthentication(
+      routeFunction,
+      workflowContext
+    );
+    if (authCheck.isErr()) {
+      await debug?.log("ERROR", "ERROR", { error: authCheck.error.message });
+      throw authCheck.error;
+    } else if (authCheck.value === "run-ended") {
+      return err(new WorkflowError("Not authorized to run the failure function."));
+    }
+    await failureFunction({
+      context: workflowContext,
+      failStatus: status,
+      failResponse: errorPayload.message,
+      failHeaders: header
+    });
   } catch (error) {
     return err(error);
   }
   return ok("is-failure-callback");
 };
 
-// src/serve/authorization.ts
-var import_qstash2 = require("@upstash/qstash");
-var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowContext {
-  static disabledMessage = "disabled-qstash-worklfow-run";
-  /**
-   * overwrite the WorkflowContext.addStep method to always raise QStashWorkflowAbort
-   * error in order to stop the execution whenever we encounter a step.
-   *
-   * @param _step
-   */
-  async addStep(_step) {
-    throw new QStashWorkflowAbort(_DisabledWorkflowContext.disabledMessage);
-  }
-  /**
-   * copies the passed context to create a DisabledWorkflowContext. Then, runs the
-   * route function with the new context.
-   *
-   * - returns "run-ended" if there are no steps found or
-   *      if the auth failed and user called `return`
-   * - returns "step-found" if DisabledWorkflowContext.addStep is called.
-   * - if there is another error, returns the error.
-   *
-   * @param routeFunction
-   */
-  static async tryAuthentication(routeFunction, context) {
-    const disabledContext = new _DisabledWorkflowContext({
-      qstashClient: new import_qstash2.Client({
-        baseUrl: "disabled-client",
-        token: "disabled-client"
-      }),
-      workflowRunId: context.workflowRunId,
-      headers: context.headers,
-      steps: [],
-      url: context.url,
-      failureUrl: context.failureUrl,
-      initialPayload: context.requestPayload,
-      rawInitialPayload: context.rawInitialPayload,
-      env: context.env,
-      retries: context.retries
-    });
-    try {
-      await routeFunction(disabledContext);
-    } catch (error) {
-      if (error instanceof QStashWorkflowAbort && error.stepName === this.disabledMessage) {
-        return ok("step-found");
-      }
-      return err(error);
-    }
-    return ok("run-ended");
-  }
-};
-
 // src/serve/options.ts
-var import_qstash3 = require("@upstash/qstash");
 var import_qstash4 = require("@upstash/qstash");
+var import_qstash5 = require("@upstash/qstash");
 var processOptions = (options) => {
   const environment = options?.env ?? (typeof process === "undefined" ? {} : process.env);
   const receiverEnvironmentVariablesSet = Boolean(
     environment.QSTASH_CURRENT_SIGNING_KEY && environment.QSTASH_NEXT_SIGNING_KEY
   );
   return {
-    qstashClient: new import_qstash4.Client({
+    qstashClient: new import_qstash5.Client({
       baseUrl: environment.QSTASH_URL,
       token: environment.QSTASH_TOKEN
     }),
@@ -1978,7 +2136,7 @@ var processOptions = (options) => {
         throw error;
       }
     },
-    receiver: receiverEnvironmentVariablesSet ? new import_qstash3.Receiver({
+    receiver: receiverEnvironmentVariablesSet ? new import_qstash4.Receiver({
       currentSigningKey: environment.QSTASH_CURRENT_SIGNING_KEY,
       nextSigningKey: environment.QSTASH_NEXT_SIGNING_KEY
     }) : void 0,
@@ -2040,6 +2198,9 @@ var serve = (routeFunction, options) => {
     const { rawInitialPayload, steps, isLastDuplicate } = await parseRequest(
       requestPayload,
       isFirstInvocation,
+      workflowRunId,
+      qstashClient.http,
+      request.headers.get("upstash-message-id"),
       debug
     );
     if (isLastDuplicate) {
@@ -2050,6 +2211,7 @@ var serve = (routeFunction, options) => {
       requestPayload,
       qstashClient,
       initialPayloadParser,
+      routeFunction,
       failureFunction
     );
     if (failureCheck.isErr()) {
@@ -2062,7 +2224,6 @@ var serve = (routeFunction, options) => {
       qstashClient,
       workflowRunId,
       initialPayload: initialPayloadParser(rawInitialPayload),
-      rawInitialPayload,
       headers: recreateUserHeaders(request.headers),
       steps,
       url: workflowUrl,
@@ -2100,7 +2261,11 @@ var serve = (routeFunction, options) => {
         onStep: async () => routeFunction(workflowContext),
         onCleanup: async () => {
           await triggerWorkflowDelete(workflowContext, debug);
-        }
+        },
+        onCancel: async () => {
+          await makeCancelRequest(workflowContext.qstashClient.http, workflowRunId);
+        },
+        debug
       });
       if (result.isErr()) {
         await debug?.log("ERROR", "ERROR", { error: result.error.message });
@@ -2126,7 +2291,7 @@ var serve = (routeFunction, options) => {
 };
 
 // src/client/index.ts
-var import_qstash5 = require("@upstash/qstash");
+var import_qstash6 = require("@upstash/qstash");
 
 // platforms/astro.ts
 function serve2(routeFunction, options) {