@upstash/workflow 0.2.10-unicode-rc → 0.2.10

package/{chunk-N2WV5VCD.mjs → chunk-GFNR743S.mjs}

@@ -114,15 +114,15 @@ 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 binString;
+    return atob(base64);
   }
 }
 
@@ -1153,7 +1153,7 @@ var invokeWorkflow = async ({
     headers: Object.fromEntries(
       Object.entries(invokerHeaders).map((pairs) => [pairs[0], [pairs[1]]])
     ),
-    workflowRunId,
+    workflowRunId: context.workflowRunId,
     workflowUrl: context.url,
     step: invokeStep
   };
@@ -1290,8 +1290,9 @@ var WorkflowTool = class {
 };
 
 // src/context/steps.ts
-var BaseLazyStep = class _BaseLazyStep {
+var BaseLazyStep = class {
   stepName;
+  // will be set in the subclasses
   constructor(stepName) {
     if (!stepName) {
       throw new WorkflowError(
@@ -1300,58 +1301,10 @@ var BaseLazyStep = class _BaseLazyStep {
     }
     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;
@@ -1382,7 +1335,6 @@ var LazyFunctionStep = class extends BaseLazyStep {
 var LazySleepStep = class extends BaseLazyStep {
   sleep;
   stepType = "SleepFor";
-  allowUndefinedOut = true;
   constructor(stepName, sleep) {
     super(stepName);
     this.sleep = sleep;
@@ -1410,7 +1362,6 @@ var LazySleepStep = class extends BaseLazyStep {
 var LazySleepUntilStep = class extends BaseLazyStep {
   sleepUntil;
   stepType = "SleepUntil";
-  allowUndefinedOut = true;
   constructor(stepName, sleepUntil) {
     super(stepName);
     this.sleepUntil = sleepUntil;
@@ -1434,11 +1385,8 @@ var LazySleepUntilStep = class extends BaseLazyStep {
       concurrent
     });
   }
-  safeParseOut() {
-    return void 0;
-  }
 };
-var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
+var LazyCallStep = class extends BaseLazyStep {
   url;
   method;
   body;
@@ -1447,7 +1395,6 @@ var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
   timeout;
   flowControl;
   stepType = "Call";
-  allowUndefinedOut = false;
   constructor(stepName, url, method, body, headers, retries, timeout, flowControl) {
     super(stepName);
     this.url = url;
@@ -1479,53 +1426,11 @@ var LazyCallStep = class _LazyCallStep 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;
@@ -1552,13 +1457,6 @@ 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";
@@ -1572,18 +1470,10 @@ 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,
@@ -1623,13 +1513,6 @@ var LazyInvokeStep = class extends BaseLazyStep {
       concurrent
     });
   }
-  safeParseOut(out) {
-    const result = JSON.parse(out);
-    return {
-      ...result,
-      body: BaseLazyStep.tryParsing(result.body)
-    };
-  }
 };
 
 // src/context/auto-executor.ts
@@ -1735,7 +1618,7 @@ var AutoExecutor = class _AutoExecutor {
         step,
         stepCount: this.stepCount
       });
-      return lazyStep.parseOut(step.out);
+      return step.out;
     }
     const resultStep = await lazyStep.getResultStep(NO_CONCURRENCY, this.stepCount);
     await this.debug?.log("INFO", "RUN_SINGLE", {
@@ -1810,9 +1693,7 @@ 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, index) => parallelSteps[index].parseOut(step.out)
-        );
+        return parallelResultSteps.map((step) => step.out);
       }
     }
     const fillValue = void 0;
@@ -2560,7 +2441,7 @@ var WorkflowContext = class {
    */
   async run(stepName, stepFunction) {
     const wrappedStepFunction = () => this.executor.wrapStep(stepName, stepFunction);
-    return await this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
+    return this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
   }
   /**
    * Stops the execution for the duration provided.
@@ -2631,27 +2512,43 @@ var WorkflowContext = class {
    *   }
    */
   async call(stepName, settings) {
-    const {
-      url,
-      method = "GET",
-      body: requestBody,
-      headers = {},
-      retries = 0,
-      timeout,
-      flowControl
-    } = settings;
-    return await this.addStep(
+    const { url, method = "GET", body, headers = {}, retries = 0, timeout, flowControl } = settings;
+    const result = await this.addStep(
       new LazyCallStep(
         stepName,
         url,
         method,
-        requestBody,
+        body,
         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.
@@ -2690,7 +2587,15 @@ var WorkflowContext = class {
   async waitForEvent(stepName, eventId, options = {}) {
     const { timeout = "7d" } = options;
     const timeoutStr = typeof timeout === "string" ? timeout : `${timeout}s`;
-    return await this.addStep(new LazyWaitForEventStep(stepName, eventId, timeoutStr));
+    const result = await this.addStep(new LazyWaitForEventStep(stepName, eventId, timeoutStr));
+    try {
+      return {
+        ...result,
+        eventData: JSON.parse(result.eventData)
+      };
+    } catch {
+      return result;
+    }
   }
   /**
    * Notify workflow runs waiting for an event
@@ -2714,12 +2619,24 @@ var WorkflowContext = class {
    * @returns notify response which has event id, event data and list of waiters which were notified
    */
   async notify(stepName, eventId, eventData) {
-    return await this.addStep(
+    const result = 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) {
-    return await this.addStep(new LazyInvokeStep(stepName, settings));
+    const result = await this.addStep(new LazyInvokeStep(stepName, settings));
+    return {
+      ...result,
+      body: result.body ? JSON.parse(result.body) : void 0
+    };
   }
   /**
    * Cancel the current workflow run
@@ -2878,6 +2795,10 @@ 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/cloudflare.d.mts

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

package/cloudflare.d.ts

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