Serialization

import { createWebhook } from "workflow";

export async function handleWebhookWorkflow() {
  "use workflow";

  const webhook = createWebhook();
  const request = await webhook;

  // The body of the request will only be consumed once
  const body = await request.json(); 

  // …
}

import { fetch } from "workflow"; 

export async function apiWorkflow() {
  "use workflow";

  // fetch can be called directly in workflows
  const response = await fetch("https://api.example.com/data"); 
  const data = await response.json();

  return data;
}

export async function fetch(...args: Parameters<typeof globalThis.fetch>) {
  "use step";
  return globalThis.fetch(...args);
}

import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from "@workflow/serde"; 

class Point {
  constructor(
    public x: number,
    public y: number
  ) {}

  // Define how to serialize an instance to plain data
  static [WORKFLOW_SERIALIZE](instance: Point) { 
    return { x: instance.x, y: instance.y }; 
  } 

  // Define how to reconstruct an instance from plain data
  static [WORKFLOW_DESERIALIZE](data: { x: number; y: number }) { 
    return new Point(data.x, data.y); 
  } 
}

import { Point } from "./custom-class";

export async function geometryWorkflow() {
  "use workflow";

  const point = new Point(10, 20);
  // Point is serialized automatically
  const doubled = await doublePoint(point); 

  console.log(doubled.x, doubled.y); // 20, 40
  return doubled;
}

async function doublePoint(point: Point) {
  "use step";
  // Returns a new Point instance
  return new Point(point.x * 2, point.y * 2); 
}

import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from "@workflow/serde"; 
import { db } from "../lib/db";

class Order {
  constructor(
    public id: string,
    public items: Map<string, number>,
    public createdAt: Date
  ) {}

  // Custom serialization — data must be serializable types
  static [WORKFLOW_SERIALIZE](instance: Order) { 
    return { 
      id: instance.id, 
      items: instance.items, // Map is serializable
      createdAt: instance.createdAt, // Date is serializable
    }; 
  } 

  static [WORKFLOW_DESERIALIZE](data: { 
    id: string; 
    items: Map<string, number>; 
    createdAt: Date; 
  }) { 
    return new Order(data.id, data.items, data.createdAt); 
  } 

  // Methods without "use step" run in the workflow context
  // and must follow the same constraints as workflow functions
  total(): number {
    let sum = 0;
    for (const quantity of this.items.values()) {
      sum += quantity;
    }
    return sum;
  }

  // Instance methods with "use step" run as step functions
  // with full Node.js access — `this` is automatically serialized
  async save(): Promise<void> {
    "use step"; 
    await db.orders.insert({ 
      id: this.id, 
      items: Object.fromEntries(this.items), 
      createdAt: this.createdAt, 
    }); 
  }

  async sendConfirmation(email: string): Promise<string> {
    "use step"; 
    const res = await fetch("https://api.example.com/email", { 
      method: "POST", 
      body: JSON.stringify({ 
        to: email, 
        orderId: this.id, 
        itemCount: this.items.size, 
      }), 
    }); 
    const { messageId } = await res.json();
    return messageId;
  }
}

export async function processOrderWorkflow(
  orderId: string,
  items: Map<string, number>,
  email: string
) {
  "use workflow";

  const order = new Order(orderId, items, new Date()); 

  // Runs in the workflow context — no "use step" needed
  const itemCount = order.total(); 

  // Each "use step" instance method call runs as a separate step
  await order.save(); 
  const messageId = await order.sendConfirmation(email); 

  return { orderId, itemCount, messageId };
}

export class Order {
  // ...

  async addItem(name: string, quantity: number): Promise<Order> {
    "use step";
    this.items.set(name, quantity);
    return this; 
  }
}

export async function processOrderWorkflow() {
  "use workflow";

  let order = new Order(orderId, items, new Date());

  // Re-assign to capture the updated instance
  order = await order.addItem("Widget", 3); 
}

export async function updateUserWorkflow(userId: string) {
  "use workflow";

  let user = { id: userId, name: "John", email: "john@example.com" };
  await updateUserStep(user);

  // user.email is still "john@example.com"
  console.log(user.email); 
}

async function updateUserStep(user: { id: string; name: string; email: string }) {
  "use step";
  user.email = "newemail@example.com"; // Changes are lost
}

export async function updateUserWorkflow(userId: string) {
  "use workflow";

  let user = { id: userId, name: "John", email: "john@example.com" };
  user = await updateUserStep(user); // Reassign the return value

  console.log(user.email); // "newemail@example.com"
}

async function updateUserStep(user: { id: string; name: string; email: string }) {
  "use step";
  user.email = "newemail@example.com";
  return user; 
}