Typed Errors

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

class ValidationError extends Error {}
class InsufficientFundsError extends Error {}

// The signature only describes the happy path.
async function processPayment(userId: string, amount: number): Promise<Payment> {
  if (!userId) throw new ValidationError("userId required");
  if (amount <= 0) throw new ValidationError("amount must be > 0");
  if (amount > 100) throw new InsufficientFundsError("insufficient funds");
  return { id: "PAY-123", amount };
}

processPayment;
     
function processPayment(userId: string, amount: number): Promise<Payment>

async function main() {
  try {
    const payment = await processPayment("USER-1", 150);
    return payment;
  } catch (error) {
    error;
    
function (local var) error: unknown

    if (error instanceof ValidationError) return "Bad request";
    if (error instanceof InsufficientFundsError) return "Payment declined";

    return "Unknown error";
  }
}

main();

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

type Payment = { id: string };
type PaymentError =
  | { type: "ValidationError"; message: string }
  | { type: "InsufficientFunds"; message: string };

function processPayment(userId: string, amount: number): Result<Payment, PaymentError> {
  if (!userId) return Result.Err({ type: "ValidationError", message: "userId required" });
  if (amount <= 0) return Result.Err({ type: "ValidationError", message: "amount must be > 0" });
  if (amount > 100) return Result.Err({ type: "InsufficientFunds", message: "insufficient funds" });
  return Result.Ok({ id: "PAY-123" });
}

const res = processPayment("USER-1", 0);
res;
const res: Result<Payment, PaymentError>

const message = res
  .tapErr((e) => console.error(`[PaymentError] ${e.type}: ${e.message}`))
  .match({
    Ok: (p) => `Paid: ${p.id}`,
    Err: (e) => e.message,
  });

message;
 
const message: string