Workflow engines and orchestrators

class Crash extends Error {
  constructor(readonly log: string[]) { super("crash"); }
}

class Payments {
  charges = 0;
  charge(): string { return `ch_${++this.charges}`; }
}

const STEPS = ["reserve_stock", "charge_card", "ship_order"];

function run(step: string, payments: Payments): string {
  if (step === "charge_card") return payments.charge();
  return step === "ship_order" ? "trk_81" : "ok";
}

// A plain script: on failure, the whole thing is run again from the top.
function naive(payments: Payments, crashAfter?: string): string[] {
  const log: string[] = [];
  for (const step of STEPS) {
    run(step, payments);
    log.push(step);
    if (step === crashAfter) throw new Crash(log);
  }
  return log;
}

// Durable execution (Temporal, Step Functions, Durable Functions): each step's result is recorded,
// and a re-run replays recorded results instead of doing the step again.
function durable(payments: Payments, stepHistory: Map<string, string>, crashAfter?: string): string[] {
  const log: string[] = [];
  for (const step of STEPS) {
    if (stepHistory.has(step)) log.push(`${step} (from history)`);
    else { stepHistory.set(step, run(step, payments)); log.push(`${step} (ran)`); }
    if (step === crashAfter) throw new Crash(log);
  }
  return log;
}

let p = new Payments();
try { naive(p, "charge_card"); } catch (c) { if (c instanceof Crash) console.log(`naive run 1:   ${c.log.join(", ")} -> worker crashes`); }
console.log(`naive run 2:   ${naive(p).join(", ")} -> card charged ${p.charges} times`);

p = new Payments();
const stepHistory = new Map<string, string>();
try { durable(p, stepHistory, "charge_card"); } catch (c) { if (c instanceof Crash) console.log(`durable run 1: ${c.log.join(", ")} -> worker crashes`); }
console.log(`durable run 2: ${durable(p, stepHistory).join(", ")} -> card charged ${p.charges} time`);
console.log("history: " + [...stepHistory].map(([k, v]) => `${k}=${v}`).join(", "));

import java.util.*;

public class Main {
    static class Crash extends RuntimeException {
        final List<String> log;
        Crash(List<String> log) { this.log = log; }
    }

    static class Payments {
        int charges = 0;
        String charge() { return "ch_" + (++charges); }
    }

    static final List<String> STEPS = List.of("reserve_stock", "charge_card", "ship_order");

    static String run(String step, Payments payments) {
        if (step.equals("charge_card")) return payments.charge();
        return step.equals("ship_order") ? "trk_81" : "ok";
    }

    // A plain script: on failure, the whole thing is run again from the top.
    static List<String> naive(Payments payments, String crashAfter) {
        List<String> log = new ArrayList<>();
        for (String step : STEPS) {
            run(step, payments);
            log.add(step);
            if (step.equals(crashAfter)) throw new Crash(log);
        }
        return log;
    }

    // Durable execution (Temporal, Step Functions, Durable Functions): each step's result is recorded,
    // and a re-run replays recorded results instead of doing the step again.
    static List<String> durable(Payments payments, Map<String, String> stepHistory, String crashAfter) {
        List<String> log = new ArrayList<>();
        for (String step : STEPS) {
            if (stepHistory.containsKey(step)) log.add(step + " (from history)");
            else { stepHistory.put(step, run(step, payments)); log.add(step + " (ran)"); }
            if (step.equals(crashAfter)) throw new Crash(log);
        }
        return log;
    }

    public static void main(String[] args) {
        Payments p = new Payments();
        try { naive(p, "charge_card"); } catch (Crash c) { System.out.println("naive run 1:   " + String.join(", ", c.log) + " -> worker crashes"); }
        System.out.println("naive run 2:   " + String.join(", ", naive(p, null)) + " -> card charged " + p.charges + " times");

        p = new Payments();
        Map<String, String> stepHistory = new LinkedHashMap<>();
        try { durable(p, stepHistory, "charge_card"); } catch (Crash c) { System.out.println("durable run 1: " + String.join(", ", c.log) + " -> worker crashes"); }
        System.out.println("durable run 2: " + String.join(", ", durable(p, stepHistory, null)) + " -> card charged " + p.charges + " time");
        StringJoiner j = new StringJoiner(", ");
        stepHistory.forEach((k, v) -> j.add(k + "=" + v));
        System.out.println("history: " + j);
    }
}