@upstash/workflow 0.2.22 → 0.2.23

package/{chunk-BON2RKOR.mjs → chunk-GZRDB6Z5.mjs}

@@ -113,7 +113,9 @@ var StepTypes = [
   "Call",
   "Wait",
   "Notify",
-  "Invoke"
+  "Invoke",
+  "CreateWebhook",
+  "WaitForWebhook"
 ];
 
 // src/agents/adapters.ts
@@ -394,8 +396,8 @@ var NANOID_LENGTH = 21;
 function getRandomInt() {
   return Math.floor(Math.random() * NANOID_CHARS.length);
 }
-function nanoid() {
-  return Array.from({ length: NANOID_LENGTH }).map(() => NANOID_CHARS[getRandomInt()]).join("");
+function nanoid(length = NANOID_LENGTH) {
+  return Array.from({ length }).map(() => NANOID_CHARS[getRandomInt()]).join("");
 }
 function getWorkflowRunId(id) {
   return `wfr_${id ?? nanoid()}`;
@@ -412,6 +414,37 @@ function decodeBase64(base64) {
     return binString;
   }
 }
+function getUserIdFromToken(qstashClient) {
+  try {
+    const token = qstashClient.token;
+    const decodedToken = decodeBase64(token);
+    const tokenPayload = JSON.parse(decodedToken);
+    const userId = tokenPayload.UserID;
+    if (!userId) {
+      throw new WorkflowError("QStash token payload does not contain userId");
+    }
+    return userId;
+  } catch (error) {
+    throw new WorkflowError(
+      `Failed to decode QStash token while running create webhook step: ${error.message}`
+    );
+  }
+}
+function getQStashUrl(qstashClient) {
+  try {
+    const requester = qstashClient.http;
+    const baseUrl = requester.baseUrl;
+    if (!baseUrl) {
+      throw new WorkflowError("QStash client does not have a baseUrl");
+    }
+    return baseUrl;
+  } catch (error) {
+    throw new WorkflowError(`Failed to get QStash URL from client: ${error.message}`);
+  }
+}
+function getEventId() {
+  return `evt_${nanoid(15)}`;
+}
 
 // node_modules/neverthrow/dist/index.es.js
 var defaultErrorConfig = {
@@ -1137,7 +1170,9 @@ If you want to disable QStash Verification, you should clear env variables QSTAS
 // src/context/steps.ts
 var BaseLazyStep = class _BaseLazyStep {
   stepName;
-  constructor(stepName) {
+  context;
+  constructor(context, stepName) {
+    this.context = context;
     if (!stepName) {
       throw new WorkflowError(
         "A workflow step name cannot be undefined or an empty string. Please provide a name for your workflow step."
@@ -1155,13 +1190,14 @@ var BaseLazyStep = class _BaseLazyStep {
    *
    * will be called when returning the steps to the context from auto executor
    *
-   * @param out field of the step
+   * @param step step
    * @returns parsed out field
    */
-  parseOut(out) {
+  parseOut(step) {
+    const out = step.out;
     if (out === void 0) {
       if (this.allowUndefinedOut) {
-        return void 0;
+        return this.handleUndefinedOut(step);
       } else {
         throw new WorkflowError(
           `Error while parsing output of ${this.stepType} step. Expected a string, but got: undefined`
@@ -1169,27 +1205,26 @@ var BaseLazyStep = class _BaseLazyStep {
       }
     }
     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)
-      };
+      console.warn(
+        `Error while parsing ${this.stepType} step output. Expected a string, but got object. Please reach out to Upstash Support.`
+      );
+      return out;
     }
     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);
+    return this.safeParseOut(out, step);
   }
-  safeParseOut(out) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  safeParseOut(out, step) {
     return _BaseLazyStep.tryParsing(out);
   }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  handleUndefinedOut(step) {
+    return void 0;
+  }
   static tryParsing(stepOut) {
     try {
       return JSON.parse(stepOut);
@@ -1240,8 +1275,8 @@ var LazyFunctionStep = class extends BaseLazyStep {
   stepFunction;
   stepType = "Run";
   allowUndefinedOut = true;
-  constructor(stepName, stepFunction) {
-    super(stepName);
+  constructor(context, stepName, stepFunction) {
+    super(context, stepName);
     this.stepFunction = stepFunction;
   }
   getPlanStep(concurrent, targetStep) {
@@ -1271,8 +1306,8 @@ var LazySleepStep = class extends BaseLazyStep {
   sleep;
   stepType = "SleepFor";
   allowUndefinedOut = true;
-  constructor(stepName, sleep) {
-    super(stepName);
+  constructor(context, stepName, sleep) {
+    super(context, stepName);
     this.sleep = sleep;
   }
   getPlanStep(concurrent, targetStep) {
@@ -1313,8 +1348,8 @@ var LazySleepUntilStep = class extends BaseLazyStep {
   sleepUntil;
   stepType = "SleepUntil";
   allowUndefinedOut = true;
-  constructor(stepName, sleepUntil) {
-    super(stepName);
+  constructor(context, stepName, sleepUntil) {
+    super(context, stepName);
     this.sleepUntil = sleepUntil;
   }
   getPlanStep(concurrent, targetStep) {
@@ -1366,8 +1401,8 @@ var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
   stringifyBody;
   stepType = "Call";
   allowUndefinedOut = false;
-  constructor(stepName, url, method, body, headers, retries, retryDelay, timeout, flowControl, stringifyBody) {
-    super(stepName);
+  constructor(context, stepName, url, method, body, headers, retries, retryDelay, timeout, flowControl, stringifyBody) {
+    super(context, stepName);
     this.url = url;
     this.method = method;
     this.body = body;
@@ -1511,13 +1546,12 @@ var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
     ]);
   }
 };
-var LazyWaitForEventStep = class extends BaseLazyStep {
+var LazyWaitEventStep = class extends BaseLazyStep {
   eventId;
   timeout;
-  stepType = "Wait";
   allowUndefinedOut = false;
-  constructor(stepName, eventId, timeout) {
-    super(stepName);
+  constructor(context, stepName, eventId, timeout) {
+    super(context, stepName);
     this.eventId = eventId;
     this.timeout = timeout;
   }
@@ -1542,13 +1576,6 @@ var LazyWaitForEventStep = class extends BaseLazyStep {
       concurrent
     });
   }
-  safeParseOut(out) {
-    const result = JSON.parse(out);
-    return {
-      ...result,
-      eventData: BaseLazyStep.tryParsing(result.eventData)
-    };
-  }
   getHeaders({ context, telemetry, invokeCount, step }) {
     const headers = super.getHeaders({ context, telemetry, invokeCount, step });
     headers.headers["Upstash-Workflow-CallType"] = "step";
@@ -1582,7 +1609,7 @@ var LazyWaitForEventStep = class extends BaseLazyStep {
       timeoutHeaders,
       step: {
         stepId: step.stepId,
-        stepType: "Wait",
+        stepType: this.stepType,
         stepName: step.stepName,
         concurrent: step.concurrent,
         targetStep: step.targetStep
@@ -1603,8 +1630,8 @@ var LazyWaitForEventStep = class extends BaseLazyStep {
 };
 var LazyNotifyStep = class extends LazyFunctionStep {
   stepType = "Notify";
-  constructor(stepName, eventId, eventData, requester) {
-    super(stepName, async () => {
+  constructor(context, stepName, eventId, eventData, requester) {
+    super(context, stepName, async () => {
       const notifyResponse = await makeNotifyRequest(requester, eventId, eventData);
       return {
         eventId,
@@ -1629,7 +1656,7 @@ var LazyInvokeStep = class extends BaseLazyStep {
    * workflow id of the invoked workflow
    */
   workflowId;
-  constructor(stepName, {
+  constructor(context, stepName, {
     workflow,
     body,
     headers = {},
@@ -1639,7 +1666,7 @@ var LazyInvokeStep = class extends BaseLazyStep {
     flowControl,
     stringifyBody = true
   }) {
-    super(stepName);
+    super(context, stepName);
     this.params = {
       workflow,
       body,
@@ -1700,6 +1727,9 @@ var LazyInvokeStep = class extends BaseLazyStep {
       userHeaders: context.headers,
       invokeCount
     });
+    context.qstashClient.http.headers?.forEach((value, key) => {
+      invokerHeaders[key] = value;
+    });
     invokerHeaders["Upstash-Workflow-Runid"] = context.workflowRunId;
     let invokeBody;
     if (this.params.stringifyBody) {
@@ -1771,6 +1801,88 @@ var LazyInvokeStep = class extends BaseLazyStep {
     return [result];
   }
 };
+var LazyCreateWebhookStep = class extends BaseLazyStep {
+  stepType = "CreateWebhook";
+  allowUndefinedOut = false;
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return {
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      out: void 0,
+      concurrent
+    };
+  }
+  getBody({ step, context }) {
+    const userId = getUserIdFromToken(context.qstashClient);
+    const workflowRunId = context.workflowRunId;
+    const eventId = getEventId();
+    const qstashUrl = getQStashUrl(this.context.qstashClient);
+    return JSON.stringify({
+      ...step,
+      out: JSON.stringify({
+        webhookUrl: `${qstashUrl}/v2/workflows/hooks/${userId}/${workflowRunId}/${eventId}`,
+        eventId
+      })
+    });
+  }
+};
+var LazyWaitForWebhookStep = class extends LazyWaitEventStep {
+  stepType = "WaitForWebhook";
+  allowUndefinedOut = true;
+  constructor(context, stepName, webhook, timeout) {
+    super(context, stepName, webhook.eventId, timeout);
+  }
+  safeParseOut(out) {
+    const eventData = decodeBase64(out);
+    const parsedEventData = BaseLazyStep.tryParsing(eventData);
+    const body = parsedEventData.body;
+    const parsedBody = typeof body === "string" ? decodeBase64(body) : void 0;
+    const request = new Request(
+      `${parsedEventData.proto}://${parsedEventData.host}${parsedEventData.url}`,
+      {
+        method: parsedEventData.method,
+        headers: parsedEventData.header,
+        body: parsedBody
+      }
+    );
+    return {
+      request,
+      timeout: false
+    };
+  }
+  handleUndefinedOut() {
+    return {
+      timeout: true,
+      request: void 0
+    };
+  }
+};
+var LazyWaitForEventStep = class extends LazyWaitEventStep {
+  stepType = "Wait";
+  allowUndefinedOut = true;
+  parseWaitForEventOut(out, waitTimeout) {
+    return {
+      eventData: out ? BaseLazyStep.tryParsing(decodeBase64(out)) : void 0,
+      timeout: waitTimeout ?? false
+    };
+  }
+  safeParseOut(out, step) {
+    return this.parseWaitForEventOut(out, step.waitTimeout);
+  }
+  handleUndefinedOut(step) {
+    return this.parseWaitForEventOut(void 0, step.waitTimeout);
+  }
+};
 
 // src/qstash/headers.ts
 var WorkflowHeaders = class {
@@ -2161,7 +2273,7 @@ var AutoExecutor = class _AutoExecutor {
         step,
         stepCount: this.stepCount
       });
-      return lazyStep.parseOut(step.out);
+      return lazyStep.parseOut(step);
     }
     const resultStep = await submitSingleStep({
       context: this.context,
@@ -2248,7 +2360,7 @@ var AutoExecutor = class _AutoExecutor {
         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)
+          (step, index) => parallelSteps[index].parseOut(step)
         );
       }
     }
@@ -2304,7 +2416,6 @@ var AutoExecutor = class _AutoExecutor {
    * @param index index of the current step
    * @returns result[index] if lazyStepList > 1, otherwise result
    */
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
   static getResult(lazyStepList, result, index) {
     if (lazyStepList.length === 1) {
       return result;
@@ -2937,7 +3048,7 @@ var WorkflowContext = class {
    */
   async run(stepName, stepFunction) {
     const wrappedStepFunction = () => this.executor.wrapStep(stepName, stepFunction);
-    return await this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
+    return await this.addStep(new LazyFunctionStep(this, stepName, wrappedStepFunction));
   }
   /**
    * Stops the execution for the duration provided.
@@ -2951,7 +3062,7 @@ var WorkflowContext = class {
    * @returns undefined
    */
   async sleep(stepName, duration) {
-    await this.addStep(new LazySleepStep(stepName, duration));
+    await this.addStep(new LazySleepStep(this, stepName, duration));
   }
   /**
    * Stops the execution until the date time provided.
@@ -2973,13 +3084,14 @@ var WorkflowContext = class {
       datetime = typeof datetime === "string" ? new Date(datetime) : datetime;
       time = Math.round(datetime.getTime() / 1e3);
     }
-    await this.addStep(new LazySleepUntilStep(stepName, time));
+    await this.addStep(new LazySleepUntilStep(this, stepName, time));
   }
   async call(stepName, settings) {
     let callStep;
     if ("workflow" in settings) {
       const url = getNewUrlFromWorkflowId(this.url, settings.workflow.workflowId);
       callStep = new LazyCallStep(
+        this,
         stepName,
         url,
         "POST",
@@ -3004,6 +3116,7 @@ var WorkflowContext = class {
         stringifyBody = true
       } = settings;
       callStep = new LazyCallStep(
+        this,
         stepName,
         url,
         method,
@@ -3055,7 +3168,9 @@ 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));
+    return await this.addStep(
+      new LazyWaitForEventStep(this, stepName, eventId, timeoutStr)
+    );
   }
   /**
    * Notify workflow runs waiting for an event
@@ -3080,11 +3195,19 @@ var WorkflowContext = class {
    */
   async notify(stepName, eventId, eventData) {
     return await this.addStep(
-      new LazyNotifyStep(stepName, eventId, eventData, this.qstashClient.http)
+      new LazyNotifyStep(this, stepName, eventId, eventData, this.qstashClient.http)
     );
   }
   async invoke(stepName, settings) {
-    return await this.addStep(new LazyInvokeStep(stepName, settings));
+    return await this.addStep(
+      new LazyInvokeStep(this, stepName, settings)
+    );
+  }
+  async createWebhook(stepName) {
+    return await this.addStep(new LazyCreateWebhookStep(this, stepName));
+  }
+  async waitForWebhook(stepName, webhook, timeout) {
+    return await this.addStep(new LazyWaitForWebhookStep(this, stepName, webhook, timeout));
   }
   /**
    * Cancel the current workflow run
@@ -3248,13 +3371,6 @@ var processRawSteps = (rawSteps) => {
   const stepsToDecode = encodedSteps.filter((step) => step.callType === "step");
   const otherSteps = stepsToDecode.map((rawStep) => {
     const step = JSON.parse(decodeBase64(rawStep.body));
-    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];

package/cloudflare.d.mts

@@ -1,5 +1,5 @@
-import { R as RouteFunction, o as PublicServeOptions, z as InvokableWorkflow } from './types-9nCq6bRP.mjs';
-import { s as serveManyBase } from './serve-many-CctdYIfB.mjs';
+import { R as RouteFunction, o as PublicServeOptions, z as InvokableWorkflow } from './types-BD06btU6.mjs';
+import { s as serveManyBase } from './serve-many-B5Vbacm6.mjs';
 import '@upstash/qstash';
 import 'zod';
 import 'ai';

package/cloudflare.d.ts

@@ -1,5 +1,5 @@
-import { R as RouteFunction, o as PublicServeOptions, z as InvokableWorkflow } from './types-9nCq6bRP.js';
-import { s as serveManyBase } from './serve-many-BXDr30rl.js';
+import { R as RouteFunction, o as PublicServeOptions, z as InvokableWorkflow } from './types-BD06btU6.js';
+import { s as serveManyBase } from './serve-many-BCV7INWe.js';
 import '@upstash/qstash';
 import 'zod';
 import 'ai';