@upstash/workflow 0.2.10-hono-generics → 0.2.10-unicode-rc

package/index.js

@@ -163,22 +163,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(
@@ -187,10 +186,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;
@@ -221,6 +268,7 @@ var LazyFunctionStep = class extends BaseLazyStep {
 var LazySleepStep = class extends BaseLazyStep {
   sleep;
   stepType = "SleepFor";
+  allowUndefinedOut = true;
   constructor(stepName, sleep) {
     super(stepName);
     this.sleep = sleep;
@@ -248,6 +296,7 @@ var LazySleepStep = class extends BaseLazyStep {
 var LazySleepUntilStep = class extends BaseLazyStep {
   sleepUntil;
   stepType = "SleepUntil";
+  allowUndefinedOut = true;
   constructor(stepName, sleepUntil) {
     super(stepName);
     this.sleepUntil = sleepUntil;
@@ -271,8 +320,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;
@@ -281,6 +333,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;
@@ -312,11 +365,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;
@@ -343,6 +438,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";
@@ -356,10 +458,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,
@@ -399,6 +509,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
@@ -1434,7 +1551,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", {
@@ -1509,7 +1626,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;
@@ -2381,7 +2500,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.
@@ -2452,43 +2571,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.
@@ -2527,15 +2630,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
@@ -2559,24 +2654,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
@@ -2735,10 +2818,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/index.mjs

@@ -10,7 +10,7 @@ import {
   makeNotifyRequest,
   serve,
   triggerFirstInvocation
-} from "./chunk-IPXJZU3K.mjs";
+} from "./chunk-N2WV5VCD.mjs";
 
 // src/client/index.ts
 import { Client as QStashClient } from "@upstash/qstash";

package/nextjs.d.mts

@@ -1,6 +1,6 @@
 import { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
-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-Dg_9L83G.mjs';
+import { s as serveManyBase } from './serve-many-wMUWrSIP.mjs';
 import '@upstash/qstash';
 import 'zod';
 import 'ai';

package/nextjs.d.ts

@@ -1,6 +1,6 @@
 import { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
-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-Dg_9L83G.js';
+import { s as serveManyBase } from './serve-many-jCRazho9.js';
 import '@upstash/qstash';
 import 'zod';
 import 'ai';