@upstash/qstash 2.7.11-canary-3 → 2.7.11

package/workflow.js

@@ -211,7 +211,7 @@ var QStashWorkflowAbort = class extends Error {
   stepName;
   constructor(stepName, stepInfo) {
     super(
-      `This is an QStash 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 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.stepName = stepName;
@@ -467,7 +467,7 @@ var Chat = class _Chat {
    */
   // eslint-disable-next-line @typescript-eslint/require-await
   createThirdParty = async (request) => {
-    const { baseUrl, token, owner } = request.provider;
+    const { baseUrl, token, owner, organization } = request.provider;
     if (owner === "upstash")
       throw new Error("Upstash is not 3rd party provider!");
     delete request.provider;
@@ -481,6 +481,9 @@ var Chat = class _Chat {
     const headers = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${token}`,
+      ...organization ? {
+        "OpenAI-Organization": organization
+      } : {},
       ...isStream ? {
         Connection: "keep-alive",
         Accept: "text/event-stream",
@@ -696,7 +699,7 @@ function decodeBase64(base64) {
     return new TextDecoder().decode(intArray);
   } catch (error) {
     console.warn(
-      `Upstash Qstash: Failed while decoding base64 "${base64}". Decoding with atob and returning it instead. Error: ${error}`
+      `Upstash Qstash: Failed while decoding base64 "${base64}". Decoding with atob and returning it instead. ${error}`
     );
     return atob(base64);
   }
@@ -1203,377 +1206,11 @@ var DEFAULT_CONTENT_TYPE = "application/json";
 var NO_CONCURRENCY = 1;
 var DEFAULT_RETRIES = 3;
 
-// node_modules/neverthrow/dist/index.es.js
-var defaultErrorConfig = {
-  withStackTrace: false
-};
-var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
-  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
-  const maybeStack = config.withStackTrace ? new Error().stack : void 0;
-  return {
-    data,
-    message,
-    stack: maybeStack
-  };
-};
-function __awaiter(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
-    });
-  }
-  return new (P || (P = Promise))(function(resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, [])).next());
-  });
-}
-function __values(o) {
-  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-  if (m)
-    return m.call(o);
-  if (o && typeof o.length === "number")
-    return {
-      next: function() {
-        if (o && i >= o.length)
-          o = void 0;
-        return { value: o && o[i++], done: !o };
-      }
-    };
-  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-function __await(v) {
-  return this instanceof __await ? (this.v = v, this) : new __await(v);
-}
-function __asyncGenerator(thisArg, _arguments, generator) {
-  if (!Symbol.asyncIterator)
-    throw new TypeError("Symbol.asyncIterator is not defined.");
-  var g = generator.apply(thisArg, _arguments || []), i, q = [];
-  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-    return this;
-  }, i;
-  function verb(n) {
-    if (g[n])
-      i[n] = function(v) {
-        return new Promise(function(a, b) {
-          q.push([n, v, a, b]) > 1 || resume(n, v);
-        });
-      };
-  }
-  function resume(n, v) {
-    try {
-      step(g[n](v));
-    } catch (e) {
-      settle(q[0][3], e);
-    }
-  }
-  function step(r) {
-    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
-  }
-  function fulfill(value) {
-    resume("next", value);
-  }
-  function reject(value) {
-    resume("throw", value);
-  }
-  function settle(f, v) {
-    if (f(v), q.shift(), q.length)
-      resume(q[0][0], q[0][1]);
-  }
-}
-function __asyncDelegator(o) {
-  var i, p;
-  return i = {}, verb("next"), verb("throw", function(e) {
-    throw e;
-  }), verb("return"), i[Symbol.iterator] = function() {
-    return this;
-  }, i;
-  function verb(n, f) {
-    i[n] = o[n] ? function(v) {
-      return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
-    } : f;
-  }
-}
-function __asyncValues(o) {
-  if (!Symbol.asyncIterator)
-    throw new TypeError("Symbol.asyncIterator is not defined.");
-  var m = o[Symbol.asyncIterator], i;
-  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-    return this;
-  }, i);
-  function verb(n) {
-    i[n] = o[n] && function(v) {
-      return new Promise(function(resolve, reject) {
-        v = o[n](v), settle(resolve, reject, v.done, v.value);
-      });
-    };
-  }
-  function settle(resolve, reject, d, v) {
-    Promise.resolve(v).then(function(v2) {
-      resolve({ value: v2, done: d });
-    }, reject);
-  }
-}
-var ResultAsync = class _ResultAsync {
-  constructor(res) {
-    this._promise = res;
-  }
-  static fromSafePromise(promise) {
-    const newPromise = promise.then((value) => new Ok(value));
-    return new _ResultAsync(newPromise);
-  }
-  static fromPromise(promise, errorFn) {
-    const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
-    return new _ResultAsync(newPromise);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static fromThrowable(fn, errorFn) {
-    return (...args) => {
-      return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
-        try {
-          return new Ok(yield fn(...args));
-        } catch (error) {
-          return new Err(errorFn ? errorFn(error) : error);
-        }
-      }))());
-    };
-  }
-  static combine(asyncResultList) {
-    return combineResultAsyncList(asyncResultList);
-  }
-  static combineWithAllErrors(asyncResultList) {
-    return combineResultAsyncListWithAllErrors(asyncResultList);
-  }
-  map(f) {
-    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-      if (res.isErr()) {
-        return new Err(res.error);
-      }
-      return new Ok(yield f(res.value));
-    })));
-  }
-  mapErr(f) {
-    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-      if (res.isOk()) {
-        return new Ok(res.value);
-      }
-      return new Err(yield f(res.error));
-    })));
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-  andThen(f) {
-    return new _ResultAsync(this._promise.then((res) => {
-      if (res.isErr()) {
-        return new Err(res.error);
-      }
-      const newValue = f(res.value);
-      return newValue instanceof _ResultAsync ? newValue._promise : newValue;
-    }));
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-  orElse(f) {
-    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-      if (res.isErr()) {
-        return f(res.error);
-      }
-      return new Ok(res.value);
-    })));
-  }
-  match(ok2, _err) {
-    return this._promise.then((res) => res.match(ok2, _err));
-  }
-  unwrapOr(t) {
-    return this._promise.then((res) => res.unwrapOr(t));
-  }
-  /**
-   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-   */
-  safeUnwrap() {
-    return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
-      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
-    });
-  }
-  // Makes ResultAsync implement PromiseLike<Result>
-  then(successCallback, failureCallback) {
-    return this._promise.then(successCallback, failureCallback);
-  }
-};
-var errAsync = (err2) => new ResultAsync(Promise.resolve(new Err(err2)));
-var fromPromise = ResultAsync.fromPromise;
-var fromSafePromise = ResultAsync.fromSafePromise;
-var fromAsyncThrowable = ResultAsync.fromThrowable;
-var combineResultList = (resultList) => {
-  let acc = ok([]);
-  for (const result of resultList) {
-    if (result.isErr()) {
-      acc = err(result.error);
-      break;
-    } else {
-      acc.map((list) => list.push(result.value));
-    }
-  }
-  return acc;
-};
-var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
-var combineResultListWithAllErrors = (resultList) => {
-  let acc = ok([]);
-  for (const result of resultList) {
-    if (result.isErr() && acc.isErr()) {
-      acc.error.push(result.error);
-    } else if (result.isErr() && acc.isOk()) {
-      acc = err([result.error]);
-    } else if (result.isOk() && acc.isOk()) {
-      acc.value.push(result.value);
-    }
-  }
-  return acc;
-};
-var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
-var Result;
-(function(Result2) {
-  function fromThrowable2(fn, errorFn) {
-    return (...args) => {
-      try {
-        const result = fn(...args);
-        return ok(result);
-      } catch (e) {
-        return err(errorFn ? errorFn(e) : e);
-      }
-    };
-  }
-  Result2.fromThrowable = fromThrowable2;
-  function combine(resultList) {
-    return combineResultList(resultList);
-  }
-  Result2.combine = combine;
-  function combineWithAllErrors(resultList) {
-    return combineResultListWithAllErrors(resultList);
-  }
-  Result2.combineWithAllErrors = combineWithAllErrors;
-})(Result || (Result = {}));
-var ok = (value) => new Ok(value);
-var err = (err2) => new Err(err2);
-var Ok = class {
-  constructor(value) {
-    this.value = value;
-  }
-  isOk() {
-    return true;
-  }
-  isErr() {
-    return !this.isOk();
-  }
-  map(f) {
-    return ok(f(this.value));
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  mapErr(_f) {
-    return ok(this.value);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-  andThen(f) {
-    return f(this.value);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-  orElse(_f) {
-    return ok(this.value);
-  }
-  asyncAndThen(f) {
-    return f(this.value);
-  }
-  asyncMap(f) {
-    return ResultAsync.fromSafePromise(f(this.value));
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  unwrapOr(_v) {
-    return this.value;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  match(ok2, _err) {
-    return ok2(this.value);
-  }
-  safeUnwrap() {
-    const value = this.value;
-    return function* () {
-      return value;
-    }();
-  }
-  _unsafeUnwrap(_) {
-    return this.value;
-  }
-  _unsafeUnwrapErr(config) {
-    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
-  }
-};
-var Err = class {
-  constructor(error) {
-    this.error = error;
-  }
-  isOk() {
-    return false;
-  }
-  isErr() {
-    return !this.isOk();
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  map(_f) {
-    return err(this.error);
-  }
-  mapErr(f) {
-    return err(f(this.error));
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-  andThen(_f) {
-    return err(this.error);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-  orElse(f) {
-    return f(this.error);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  asyncAndThen(_f) {
-    return errAsync(this.error);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  asyncMap(_f) {
-    return errAsync(this.error);
-  }
-  unwrapOr(v) {
-    return v;
-  }
-  match(_ok, err2) {
-    return err2(this.error);
-  }
-  safeUnwrap() {
-    const error = this.error;
-    return function* () {
-      yield err(error);
-      throw new Error("Do not use this generator out of `safeTry`");
-    }();
-  }
-  _unsafeUnwrap(config) {
-    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
-  }
-  _unsafeUnwrapErr(_) {
-    return this.error;
-  }
-};
-var fromThrowable = Result.fromThrowable;
+// src/client/workflow/context.ts
+var import_neverthrow2 = require("neverthrow");
+
+// src/client/workflow/workflow-requests.ts
+var import_neverthrow = require("neverthrow");
 
 // src/client/workflow/types.ts
 var StepTypes = ["Initial", "Run", "SleepFor", "SleepUntil", "Call"];
@@ -1601,10 +1238,10 @@ var triggerFirstInvocation = async (workflowContext, retries, debug) => {
       body: workflowContext.requestPayload,
       url: workflowContext.url
     });
-    return ok("success");
+    return (0, import_neverthrow.ok)("success");
   } catch (error) {
     const error_ = error;
-    return err(error_);
+    return (0, import_neverthrow.err)(error_);
   }
 };
 var triggerRouteFunction = async ({
@@ -1614,10 +1251,10 @@ var triggerRouteFunction = async ({
   try {
     await onStep();
     await onCleanup();
-    return ok("workflow-finished");
+    return (0, import_neverthrow.ok)("workflow-finished");
   } catch (error) {
     const error_ = error;
-    return error_ instanceof QStashWorkflowAbort ? ok("step-finished") : err(error_);
+    return error_ instanceof QStashWorkflowAbort ? (0, import_neverthrow.ok)("step-finished") : (0, import_neverthrow.err)(error_);
   }
 };
 var triggerWorkflowDelete = async (workflowContext, debug, cancel = false) => {
@@ -1649,13 +1286,13 @@ var handleThirdPartyCallResult = async (request, requestPayload, client, workflo
       if (!(callbackMessage.status >= 200 && callbackMessage.status < 300)) {
         await debug?.log("WARN", "SUBMIT_THIRD_PARTY_RESULT", {
           status: callbackMessage.status,
-          body: decodeBase64(callbackMessage.body)
+          body: atob(callbackMessage.body)
         });
         console.warn(
           `Workflow Warning: "context.call" failed with status ${callbackMessage.status} and will retry (if there are retries remaining). Error Message:
-${decodeBase64(callbackMessage.body)}`
+${atob(callbackMessage.body)}`
         );
-        return ok("call-will-retry");
+        return (0, import_neverthrow.ok)("call-will-retry");
       }
       const workflowRunId = request.headers.get(WORKFLOW_ID_HEADER);
       const stepIdString = request.headers.get("Upstash-Workflow-StepId");
@@ -1689,7 +1326,7 @@ ${decodeBase64(callbackMessage.body)}`
         stepId: Number(stepIdString),
         stepName,
         stepType,
-        out: decodeBase64(callbackMessage.body),
+        out: atob(callbackMessage.body),
         concurrent: Number(concurrentString)
       };
       await debug?.log("SUBMIT", "SUBMIT_THIRD_PARTY_RESULT", {
@@ -1706,13 +1343,13 @@ ${decodeBase64(callbackMessage.body)}`
       await debug?.log("SUBMIT", "SUBMIT_THIRD_PARTY_RESULT", {
         messageId: result.messageId
       });
-      return ok("is-call-return");
+      return (0, import_neverthrow.ok)("is-call-return");
     } else {
-      return ok("continue-workflow");
+      return (0, import_neverthrow.ok)("continue-workflow");
     }
   } catch (error) {
     const isCallReturn = request.headers.get("Upstash-Workflow-Callback");
-    return err(
+    return (0, import_neverthrow.err)(
       new QStashWorkflowError(
         `Error when handling call return (isCallReturn=${isCallReturn}): ${error}`
       )
@@ -2568,11 +2205,11 @@ var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowCon
       await routeFunction(disabledContext);
     } catch (error) {
       if (error instanceof QStashWorkflowAbort && error.stepName === this.disabledMessage) {
-        return ok("step-found");
+        return (0, import_neverthrow2.ok)("step-found");
       }
-      return err(error);
+      return (0, import_neverthrow2.err)(error);
     }
-    return ok("run-ended");
+    return (0, import_neverthrow2.ok)("run-ended");
   }
 };
 
@@ -2625,6 +2262,7 @@ var WorkflowLogger = class _WorkflowLogger {
 };
 
 // src/client/workflow/workflow-parser.ts
+var import_neverthrow3 = require("neverthrow");
 var getPayload = async (request) => {
   try {
     return await request.text();
@@ -2681,7 +2319,7 @@ var checkIfLastOneIsDuplicate = async (steps, debug) => {
   for (let index = 0; index < steps.length - 1; index++) {
     const step = steps[index];
     if (step.stepId === lastStepId && step.targetStep === lastTargetStepId) {
-      const message = `QStash Workflow: The step '${step.stepName}' with id '${step.stepId}'  has run twice during workflow execution. Rest of the workflow will continue running as usual.`;
+      const message = `Upstash Workflow: The step '${step.stepName}' with id '${step.stepId}'  has run twice during workflow execution. Rest of the workflow will continue running as usual.`;
       await debug?.log("WARN", "RESPONSE_DEFAULT", message);
       console.warn(message);
       return true;
@@ -2729,10 +2367,10 @@ var parseRequest = async (requestPayload, isFirstInvocation, debug) => {
 };
 var handleFailure = async (request, requestPayload, qstashClient, initialPayloadParser, failureFunction, debug) => {
   if (request.headers.get(WORKFLOW_FAILURE_HEADER) !== "true") {
-    return ok("not-failure-callback");
+    return (0, import_neverthrow3.ok)("not-failure-callback");
   }
   if (!failureFunction) {
-    return err(
+    return (0, import_neverthrow3.err)(
       new QStashWorkflowError(
         "Workflow endpoint is called to handle a failure, but a failureFunction is not provided in serve options. Either provide a failureUrl or a failureFunction."
       )
@@ -2762,9 +2400,9 @@ var handleFailure = async (request, requestPayload, qstashClient, initialPayload
     });
     await failureFunction(workflowContext, status, errorPayload.message, header);
   } catch (error) {
-    return err(error);
+    return (0, import_neverthrow3.err)(error);
   }
-  return ok("is-failure-callback");
+  return (0, import_neverthrow3.ok)("is-failure-callback");
 };
 
 // src/client/workflow/serve.ts
@@ -2826,7 +2464,7 @@ var serve = (routeFunction, options) => {
     }) : initialWorkflowUrl;
     if (workflowUrl !== initialWorkflowUrl) {
       await debug?.log("WARN", "ENDPOINT_START", {
-        warning: `QStash Workflow: replacing the base of the url with "${baseUrl}" and using it as workflow endpoint.`,
+        warning: `Upstash Workflow: replacing the base of the url with "${baseUrl}" and using it as workflow endpoint.`,
         originalURL: initialWorkflowUrl,
         updatedURL: workflowUrl
       });

package/workflow.mjs

@@ -6,7 +6,7 @@ import {
   WorkflowLogger,
   processOptions,
   serve
-} from "./chunk-KGI26PDH.mjs";
+} from "./chunk-Q6E5NF42.mjs";
 export {
   DisabledWorkflowContext,
   StepTypes,