Skip to main content

​
Introduction

In this guide, we’ll look at best practices and caveats for using Upstash Workflow.

​
Core Principles

​
Execute business logic in context.run

Your workflow endpoint will be called multiple times during a workflow run. Therefore:
  • Place your business logic code inside the context.run function for each step
  • Code outside context.run only serves to connect steps
Example: 
export const { POST } = serve<string>(async (context) => {
  const input = context.requestPayload

  const result = await context.run("step-1", () => {
    return { success: true }
  })

  console.log("This log will appear multiple times")

  await context.run("step-2", () => {
    console.log("This log will appear just once")
    console.log("Step 1 status is:", result.success)
  })
})

​
Return Results from context.run for Later Use

Always return step results if needed in subsequent steps. 
export const { POST } = serve<string>(async (context) => {
  const input = context.requestPayload

  let result

  await context.run("step-1", async () => {
    result = await someWork(input)
  })
  await context.run("step-2", async () => {
    await someOtherWork(result)
  })
})
Because your workflow endpoint is called multiple times, result will be unitialized when the endpoint is called again to run step-2. If you are curious about why an endpoint is called multiple times, see how Workflow works.

​
Avoiding Common Pitfalls

​
Avoid Non-deterministic Code Outside context.run

A workflow endpoint should always produce the same results, even if it’s called multiple times. Avoid:
  • Non-idempotent functions
  • Time-dependent code
  • Randomness
Example of what to avoid: 
export const { POST } = serve<{ entryId: string }>(async (context) => {
  const { entryId } = context.requestPayload;

  // 👇 Problem: Non-idempotent function outside context.run:
  const result = await getResultFromDb(entryId);
  if (result.return) {
    return;
  }

  // ...
})
If you implement a non-idempotent code like the one shown above, you might encounter Failed to authenticate Workflow request. errors. This can happen if you return based on the result of the non-idempotent code before any workflow step. To prevent this, ensure that the non-idempotent code (such as getResultFromDb in the example) runs within context.run. 
const result = await context.run(async () => {
  await getResultFromDb(entryId)
});
if (result.return) {
  return;
}

​
Ensure Idempotency in context.run

Business logic should be idempotent due to potential retries in distributed systems. In other words, when a workflow runs twice with the same input, the end result should be the same as if the workflow only ran once. In the example below, the someWork function must be idempotent: 
export const { POST } = serve<string>(async (context) => {
  const input = context.requestPayload

  await context.run("step-1", async () => {
    return someWork(input)
  })
})
Imagine that someWork executes once and makes a change to a database. However, before the database had a chance to respond with the successful change, the connection is lost. Your Workflow cannot know if the database change was successful or not. The caller has no choice but to retry, which will cause someWork to run twice. If someWork is not idempotent, this could lead to unintended consequences. For example duplicated records or corrupted data. Idempotency is crucial to maintaining the integrity and reliability of your workflow.

​
Don’t Nest Context Methods

Avoid calling context.call, context.sleep, context.sleepFor, or context.run within another context.run. 
import { serve } from "@upstash/workflow/nextjs"

export const { POST } = serve<string>(async (context) => {
  const input = context.requestPayload

  await context.run("step-1", async () => {
    await context.sleep(...) // ❌ INCORRECT
    await context.run(...) // ❌ INCORRECT
    await context.call(...) // ❌ INCORRECT
  })
})

​
Include At Least One Step in Workflow

Every workflow must include at least one step execution with context.run. If no steps are defined, the workflow will throw a Failed to authenticate Workflow request. error. 
export const { POST } = serve<string>(async (context) => {
  const input = context.requestPayload
  
  // 👇 Problem: No context.run call
  console.log("Processing input:", input)
  
  // This workflow will fail with "Failed to authenticate Workflow request."
})
Even for the placeholder implementations, you must include one dummy step for the Workflow authentication mechanism to function properly.

​
Avoid Promise.any

In workflow-js, you can use Promise.all to run steps in parallel. However, a similar method, Promise.any, is not supported for workflow steps. While Promise.all works seamlessly, Promise.any does not currently function with workflow steps. We are exploring the possibility of adding support for Promise.any in the future. If you have a specific use case that requires Promise.any, don’t hesitate to reach out to Upstash support.
⌘I