@upstash/workflow 0.2.10 → 0.2.11

package/express.js

@@ -23823,22 +23823,21 @@ function getWorkflowRunId(id) {
   return `wfr_${id ?? nanoid()}`;
 }
 function decodeBase64(base64) {
+  const binString = atob(base64);
   try {
-    const binString = atob(base64);
     const intArray = Uint8Array.from(binString, (m) => m.codePointAt(0));
     return new TextDecoder().decode(intArray);
   } catch (error) {
     console.warn(
       `Upstash Qstash: Failed while decoding base64 "${base64}". Decoding with atob and returning it instead. ${error}`
     );
-    return atob(base64);
+    return binString;
   }
 }
 
 // src/context/steps.ts
-var BaseLazyStep = class {
+var BaseLazyStep = class _BaseLazyStep {
   stepName;
-  // will be set in the subclasses
   constructor(stepName) {
     if (!stepName) {
       throw new WorkflowError(
@@ -23847,10 +23846,58 @@ var BaseLazyStep = class {
     }
     this.stepName = stepName;
   }
+  /**
+   * parse the out field of a step result.
+   *
+   * will be called when returning the steps to the context from auto executor
+   *
+   * @param out field of the step
+   * @returns parsed out field
+   */
+  parseOut(out) {
+    if (out === void 0) {
+      if (this.allowUndefinedOut) {
+        return void 0;
+      } else {
+        throw new WorkflowError(
+          `Error while parsing output of ${this.stepType} step. Expected a string, but got: undefined`
+        );
+      }
+    }
+    if (typeof out === "object") {
+      if (this.stepType !== "Wait") {
+        console.warn(
+          `Error while parsing ${this.stepType} step output. Expected a string, but got object. Please reach out to Upstash Support.`
+        );
+        return out;
+      }
+      return {
+        ...out,
+        eventData: _BaseLazyStep.tryParsing(out.eventData)
+      };
+    }
+    if (typeof out !== "string") {
+      throw new WorkflowError(
+        `Error while parsing output of ${this.stepType} step. Expected a string or undefined, but got: ${typeof out}`
+      );
+    }
+    return this.safeParseOut(out);
+  }
+  safeParseOut(out) {
+    return _BaseLazyStep.tryParsing(out);
+  }
+  static tryParsing(stepOut) {
+    try {
+      return JSON.parse(stepOut);
+    } catch {
+      return stepOut;
+    }
+  }
 };
 var LazyFunctionStep = class extends BaseLazyStep {
   stepFunction;
   stepType = "Run";
+  allowUndefinedOut = true;
   constructor(stepName, stepFunction) {
     super(stepName);
     this.stepFunction = stepFunction;
@@ -23881,6 +23928,7 @@ var LazyFunctionStep = class extends BaseLazyStep {
 var LazySleepStep = class extends BaseLazyStep {
   sleep;
   stepType = "SleepFor";
+  allowUndefinedOut = true;
   constructor(stepName, sleep) {
     super(stepName);
     this.sleep = sleep;
@@ -23908,6 +23956,7 @@ var LazySleepStep = class extends BaseLazyStep {
 var LazySleepUntilStep = class extends BaseLazyStep {
   sleepUntil;
   stepType = "SleepUntil";
+  allowUndefinedOut = true;
   constructor(stepName, sleepUntil) {
     super(stepName);
     this.sleepUntil = sleepUntil;
@@ -23931,8 +23980,11 @@ var LazySleepUntilStep = class extends BaseLazyStep {
       concurrent
     });
   }
+  safeParseOut() {
+    return void 0;
+  }
 };
-var LazyCallStep = class extends BaseLazyStep {
+var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
   url;
   method;
   body;
@@ -23941,6 +23993,7 @@ var LazyCallStep = class extends BaseLazyStep {
   timeout;
   flowControl;
   stepType = "Call";
+  allowUndefinedOut = false;
   constructor(stepName, url, method, body, headers, retries, timeout, flowControl) {
     super(stepName);
     this.url = url;
@@ -23972,11 +24025,53 @@ var LazyCallStep = class extends BaseLazyStep {
       callHeaders: this.headers
     });
   }
+  safeParseOut(out) {
+    const { header, status, body } = JSON.parse(out);
+    const responseHeaders = new Headers(header);
+    if (_LazyCallStep.isText(responseHeaders.get("content-type"))) {
+      const bytes = new Uint8Array(out.length);
+      for (let i = 0; i < out.length; i++) {
+        bytes[i] = out.charCodeAt(i);
+      }
+      const processedResult = new TextDecoder().decode(bytes);
+      const newBody = JSON.parse(processedResult).body;
+      return {
+        status,
+        header,
+        body: BaseLazyStep.tryParsing(newBody)
+      };
+    } else {
+      return { header, status, body };
+    }
+  }
+  static applicationHeaders = /* @__PURE__ */ new Set([
+    "application/json",
+    "application/xml",
+    "application/javascript",
+    "application/x-www-form-urlencoded",
+    "application/xhtml+xml",
+    "application/ld+json",
+    "application/rss+xml",
+    "application/atom+xml"
+  ]);
+  static isText = (contentTypeHeader) => {
+    if (!contentTypeHeader) {
+      return false;
+    }
+    if (_LazyCallStep.applicationHeaders.has(contentTypeHeader)) {
+      return true;
+    }
+    if (contentTypeHeader.startsWith("text/")) {
+      return true;
+    }
+    return false;
+  };
 };
 var LazyWaitForEventStep = class extends BaseLazyStep {
   eventId;
   timeout;
   stepType = "Wait";
+  allowUndefinedOut = false;
   constructor(stepName, eventId, timeout) {
     super(stepName);
     this.eventId = eventId;
@@ -24003,6 +24098,13 @@ var LazyWaitForEventStep = class extends BaseLazyStep {
       concurrent
     });
   }
+  safeParseOut(out) {
+    const result = JSON.parse(out);
+    return {
+      ...result,
+      eventData: BaseLazyStep.tryParsing(result.eventData)
+    };
+  }
 };
 var LazyNotifyStep = class extends LazyFunctionStep {
   stepType = "Notify";
@@ -24016,10 +24118,18 @@ var LazyNotifyStep = class extends LazyFunctionStep {
       };
     });
   }
+  safeParseOut(out) {
+    const result = JSON.parse(out);
+    return {
+      ...result,
+      eventData: BaseLazyStep.tryParsing(result.eventData)
+    };
+  }
 };
 var LazyInvokeStep = class extends BaseLazyStep {
   stepType = "Invoke";
   params;
+  allowUndefinedOut = false;
   constructor(stepName, {
     workflow,
     body,
@@ -24059,6 +24169,13 @@ var LazyInvokeStep = class extends BaseLazyStep {
       concurrent
     });
   }
+  safeParseOut(out) {
+    const result = JSON.parse(out);
+    return {
+      ...result,
+      body: BaseLazyStep.tryParsing(result.body)
+    };
+  }
 };
 
 // node_modules/neverthrow/dist/index.es.js
@@ -24744,7 +24861,8 @@ var getHeaders = ({
   flowControl,
   callFlowControl
 }) => {
-  const contentType = (userHeaders ? userHeaders.get("Content-Type") : void 0) ?? DEFAULT_CONTENT_TYPE;
+  const callHeaders = new Headers(step?.callHeaders);
+  const contentType = (callHeaders.get("content-type") ? callHeaders.get("content-type") : userHeaders?.get("Content-Type") ? userHeaders.get("Content-Type") : void 0) ?? DEFAULT_CONTENT_TYPE;
   const baseHeaders = {
     [WORKFLOW_INIT_HEADER]: initHeaderValue,
     [WORKFLOW_ID_HEADER]: workflowRunId,
@@ -25155,7 +25273,7 @@ var AutoExecutor = class _AutoExecutor {
         step,
         stepCount: this.stepCount
       });
-      return step.out;
+      return lazyStep.parseOut(step.out);
     }
     const resultStep = await lazyStep.getResultStep(NO_CONCURRENCY, this.stepCount);
     await this.debug?.log("INFO", "RUN_SINGLE", {
@@ -25230,7 +25348,9 @@ var AutoExecutor = class _AutoExecutor {
       case "last": {
         const parallelResultSteps = sortedSteps.filter((step) => step.stepId >= initialStepCount).slice(0, parallelSteps.length);
         validateParallelSteps(parallelSteps, parallelResultSteps);
-        return parallelResultSteps.map((step) => step.out);
+        return parallelResultSteps.map(
+          (step, index) => parallelSteps[index].parseOut(step.out)
+        );
       }
     }
     const fillValue = void 0;
@@ -25333,7 +25453,7 @@ var AutoExecutor = class _AutoExecutor {
       });
       throw new WorkflowAbort(invokeStep.stepName, invokeStep);
     }
-    const result = await this.context.qstashClient.batchJSON(
+    const result = await this.context.qstashClient.batch(
       steps.map((singleStep, index) => {
         const lazyStep = lazySteps[index];
         const { headers } = getHeaders({
@@ -25363,7 +25483,7 @@ var AutoExecutor = class _AutoExecutor {
           {
             headers,
             method: singleStep.callMethod,
-            body: singleStep.callBody,
+            body: JSON.stringify(singleStep.callBody),
             url: singleStep.callUrl
           }
         ) : (
@@ -25373,7 +25493,7 @@ var AutoExecutor = class _AutoExecutor {
           {
             headers,
             method: "POST",
-            body: singleStep,
+            body: JSON.stringify(singleStep),
             url: this.context.url,
             notBefore: willWait ? singleStep.sleepUntil : void 0,
             delay: willWait ? singleStep.sleepFor : void 0
@@ -25381,8 +25501,9 @@ var AutoExecutor = class _AutoExecutor {
         );
       })
     );
+    const _result = result;
     await this.debug?.log("INFO", "SUBMIT_STEP", {
-      messageIds: result.map((message) => {
+      messageIds: _result.map((message) => {
         return {
           message: message.messageId
         };
@@ -26071,7 +26192,7 @@ var WorkflowContext = class {
    */
   async run(stepName, stepFunction) {
     const wrappedStepFunction = () => this.executor.wrapStep(stepName, stepFunction);
-    return this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
+    return await this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
   }
   /**
    * Stops the execution for the duration provided.
@@ -26142,43 +26263,27 @@ var WorkflowContext = class {
    *   }
    */
   async call(stepName, settings) {
-    const { url, method = "GET", body, headers = {}, retries = 0, timeout, flowControl } = settings;
-    const result = await this.addStep(
+    const {
+      url,
+      method = "GET",
+      body: requestBody,
+      headers = {},
+      retries = 0,
+      timeout,
+      flowControl
+    } = settings;
+    return await this.addStep(
       new LazyCallStep(
         stepName,
         url,
         method,
-        body,
+        requestBody,
         headers,
         retries,
         timeout,
         flowControl
       )
     );
-    if (typeof result === "string") {
-      try {
-        const body2 = JSON.parse(result);
-        return {
-          status: 200,
-          header: {},
-          body: body2
-        };
-      } catch {
-        return {
-          status: 200,
-          header: {},
-          body: result
-        };
-      }
-    }
-    try {
-      return {
-        ...result,
-        body: JSON.parse(result.body)
-      };
-    } catch {
-      return result;
-    }
   }
   /**
    * Pauses workflow execution until a specific event occurs or a timeout is reached.
@@ -26217,15 +26322,7 @@ var WorkflowContext = class {
   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,
-        eventData: JSON.parse(result.eventData)
-      };
-    } catch {
-      return result;
-    }
+    return await this.addStep(new LazyWaitForEventStep(stepName, eventId, timeoutStr));
   }
   /**
    * Notify workflow runs waiting for an event
@@ -26249,24 +26346,12 @@ var WorkflowContext = class {
    * @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(
+    return await this.addStep(
       new LazyNotifyStep(stepName, eventId, eventData, this.qstashClient.http)
     );
-    try {
-      return {
-        ...result,
-        eventData: JSON.parse(result.eventData)
-      };
-    } catch {
-      return result;
-    }
   }
   async invoke(stepName, settings) {
-    const result = await this.addStep(new LazyInvokeStep(stepName, settings));
-    return {
-      ...result,
-      body: result.body ? JSON.parse(result.body) : void 0
-    };
+    return await this.addStep(new LazyInvokeStep(stepName, settings));
   }
   /**
    * Cancel the current workflow run
@@ -26425,10 +26510,6 @@ var processRawSteps = (rawSteps) => {
   const stepsToDecode = encodedSteps.filter((step) => step.callType === "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,

package/express.mjs

@@ -5,7 +5,7 @@ import {
   __toESM,
   serveBase,
   serveManyBase
-} from "./chunk-GFNR743S.mjs";
+} from "./chunk-WQAJ2RSZ.mjs";
 
 // node_modules/depd/index.js
 var require_depd = __commonJS({

package/h3.d.mts

@@ -1,6 +1,6 @@
 import * as h3 from 'h3';
-import { R as RouteFunction, k as PublicServeOptions, t as InvokableWorkflow } from './types-CYhDXnf8.mjs';
-import { s as serveManyBase } from './serve-many-BVDpPsF-.mjs';
+import { R as RouteFunction, k as PublicServeOptions, t as InvokableWorkflow } from './types-DS9q8FyV.mjs';
+import { s as serveManyBase } from './serve-many-Fuovl7gl.mjs';
 import '@upstash/qstash';
 import 'zod';
 import 'ai';

package/h3.d.ts

@@ -1,6 +1,6 @@
 import * as h3 from 'h3';
-import { R as RouteFunction, k as PublicServeOptions, t as InvokableWorkflow } from './types-CYhDXnf8.js';
-import { s as serveManyBase } from './serve-many-e4zufyXN.js';
+import { R as RouteFunction, k as PublicServeOptions, t as InvokableWorkflow } from './types-DS9q8FyV.js';
+import { s as serveManyBase } from './serve-many-DNnLsDIp.js';
 import '@upstash/qstash';
 import 'zod';
 import 'ai';