Composable Control Flow

type Payment = { id: string; amount: number };

class InvalidDiscountCode extends Error {}
class DiscountServiceDown extends Error {}
class GatewayDown extends Error {}
class EmailDown extends Error {}

function validateDiscountOrThrow(code: string): number {
  if (code === "SAVE10") return 10;
  if (code === "DOWN") throw new DiscountServiceDown("discount service down");
  throw new InvalidDiscountCode("invalid discount");
}

function chargeOrThrow(amount: number): Payment {
  if (amount === 13) throw new GatewayDown("gateway down");
  return { id: "PAY-1", amount };
}

function sendReceiptEmailOrThrow(_paymentId: string): void {
  throw new EmailDown("smtp down");
}

export function checkoutBad(userId: string, amount: number, discountCode?: string): Payment {
  try {
    if (!userId) throw new Error("userId required");
    if (!Number.isFinite(amount) || amount <= 0) throw new Error("amount must be > 0");

    let finalAmount = amount;

    if (discountCode) {
      try {
        finalAmount = Math.max(0, amount - validateDiscountOrThrow(discountCode));
      } catch (e) {
        if (e instanceof InvalidDiscountCode) {
          finalAmount = amount;
        } else {
          throw new Error("Discount unavailable, retry later");
        }
      }
    }

    try {
      const payment = chargeOrThrow(finalAmount);

      try {
        sendReceiptEmailOrThrow(payment.id);
      } catch {
        // ignored (best-effort)
      }

      return payment;
    } catch {
      throw new Error("Payment failed");
    }
  } catch (e) {
    throw e;
  }
}

import { Result } from "@carbonteq/fp";

type Payment = { id: string; amount: number };

type CheckoutError =
  | { type: "Validation"; message: string }
  | { type: "DiscountUnavailable" }
  | { type: "GatewayDown" };

type DiscountError =
  | { type: "InvalidCode" }
  | { type: "Expired" }
  | { type: "ServiceDown" };

type CheckoutInput = { userId: string; amount: number };

function guardInput(userId: string, amount: number): Result<CheckoutInput, CheckoutError> {
  if (!userId)
    return Result.Err({ type: "Validation", message: "userId required" });
  if (!Number.isFinite(amount) || amount <= 0)
    return Result.Err({ type: "Validation", message: "amount must be > 0" });
  return Result.Ok({ userId, amount });
}

function validateDiscount(code: string): Result<number, DiscountError> {
  if (code === "SAVE10") return Result.Ok(10);
  if (code === "EXPIRED") return Result.Err({ type: "Expired" });
  if (code === "DOWN") return Result.Err({ type: "ServiceDown" });
  return Result.Err({ type: "InvalidCode" });
}

function applyDiscountBestEffort(amount: number, discountCode?: string): Result<number, CheckoutError> {
  if (!discountCode) return Result.Ok(amount);

  return validateDiscount(discountCode)
    .map((off) => Math.max(0, amount - off))
    .orElse((e) =>
      e.type === "ServiceDown"
        ? Result.Err({ type: "DiscountUnavailable" })
        : Result.Ok(amount) // InvalidCode/Expired: continue without discount
    );
}

function charge(amount: number): Result<Payment, CheckoutError> {
  if (amount === 13) return Result.Err({ type: "GatewayDown" });
  return Result.Ok({ id: "PAY-1", amount });
}

declare function sendReceiptEmail(paymentId: string): void;

export function checkoutGood(userId: string, amount: number, discountCode?: string): Result<Payment, CheckoutError> {
  return guardInput(userId, amount)
    .flatMap((input) => applyDiscountBestEffort(input.amount, discountCode))
    .flatMap(charge)
    .tap((payment) => sendReceiptEmail(payment.id)); // best-effort side effect
}