Repository and unit of work

interface Ride { rideId: string; rider: string; minutes: number; }
interface Payment { rideId: string; pence: number; cardOk: boolean; }

class Declined extends Error {}

// Stands in for SQL tables. Inserts happen one at a time; a transaction is all-or-nothing.
class Database {
  rides = new Map<string, Ride>();
  payments = new Map<string, Payment>();
  insertRide(r: Ride): void { this.rides.set(r.rideId, r); }
  insertPayment(p: Payment): void {
    if (!p.cardOk) throw new Declined("card declined");
    this.payments.set(p.rideId, p);
  }
  counts(): string { return `rides: ${this.rides.size}, payments: ${this.payments.size}`; }
}

type Change = { kind: "ride"; obj: Ride } | { kind: "payment"; obj: Payment };

// ---- Repositories: collections of domain objects. Callers never write SQL or see tables. ----
class RideRepository {
  constructor(private readonly uow: UnitOfWork) {}
  add(ride: Ride): void { this.uow.pending.push({ kind: "ride", obj: ride }); }
  forRider(rider: string): Ride[] { return [...this.uow.db.rides.values()].filter((r) => r.rider === rider); }
}

class PaymentRepository {
  constructor(private readonly uow: UnitOfWork) {}
  add(payment: Payment): void { this.uow.pending.push({ kind: "payment", obj: payment }); }
}

// ---- Unit of work: collects the changes of one business operation and saves them together. ----
class UnitOfWork {
  readonly pending: Change[] = [];
  readonly rides = new RideRepository(this);
  readonly payments = new PaymentRepository(this);
  constructor(readonly db: Database) {}

  commit(): void {
    const savedRides = new Map(this.db.rides), savedPayments = new Map(this.db.payments);   // begin transaction
    try {
      for (const c of this.pending) {
        if (c.kind === "ride") this.db.insertRide(c.obj);
        else this.db.insertPayment(c.obj);
      }
    } catch (e) {
      this.db.rides = savedRides; this.db.payments = savedPayments;                       // roll back everything
      throw e;
    } finally {
      this.pending.length = 0;
    }
  }
}

function endRide(db: Database, ride: Ride, payment: Payment): string {
  const uow = new UnitOfWork(db);
  uow.rides.add(ride);
  uow.payments.add(payment);
  try {
    uow.commit();
    return `end ${ride.rideId}: committed (${db.counts()})`;
  } catch (e) {
    if (!(e instanceof Declined)) throw e;
    return `end ${ride.rideId}: ${e.message}, rolled back (${db.counts()})`;
  }
}

const db = new Database();
console.log(endRide(db, { rideId: "R-1", rider: "mia", minutes: 42 }, { rideId: "R-1", pence: 120, cardOk: true }));
console.log(endRide(db, { rideId: "R-2", rider: "mia", minutes: 18 }, { rideId: "R-2", pence: 280, cardOk: false }));
console.log("mia's rides: " + new UnitOfWork(db).rides.forRider("mia").map((r) => `${r.rideId} (${r.minutes} min)`).join(", "));
db.insertRide({ rideId: "R-3", rider: "leo", minutes: 10 });   // without a unit of work: two separate saves
try {
  db.insertPayment({ rideId: "R-3", pence: 200, cardOk: false });
} catch (e) {
  console.log(`without a unit of work: R-3 saved, payment failed (${(e as Error).message}) -> ${db.counts()}, out of step`);
}

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class Main {
    record Ride(String rideId, String rider, int minutes) {}
    record Payment(String rideId, int pence, boolean cardOk) {}

    static class Declined extends Exception {
        private static final long serialVersionUID = 1L;
        Declined(String message) { super(message); }
    }

    // Stands in for SQL tables. Inserts happen one at a time; a transaction is all-or-nothing.
    static class Database {
        Map<String, Ride> rides = new LinkedHashMap<>();
        Map<String, Payment> payments = new LinkedHashMap<>();
        void insertRide(Ride r) { rides.put(r.rideId(), r); }
        void insertPayment(Payment p) throws Declined {
            if (!p.cardOk()) throw new Declined("card declined");
            payments.put(p.rideId(), p);
        }
        String counts() { return "rides: " + rides.size() + ", payments: " + payments.size(); }
    }

    // ---- Repositories: collections of domain objects. Callers never write SQL or see tables. ----
    static class RideRepository {
        private final UnitOfWork uow;
        RideRepository(UnitOfWork uow) { this.uow = uow; }
        void add(Ride ride) { uow.pending.add(ride); }
        List<Ride> forRider(String rider) { return uow.db.rides.values().stream().filter(r -> r.rider().equals(rider)).toList(); }
    }

    static class PaymentRepository {
        private final UnitOfWork uow;
        PaymentRepository(UnitOfWork uow) { this.uow = uow; }
        void add(Payment payment) { uow.pending.add(payment); }
    }

    // ---- Unit of work: collects the changes of one business operation and saves them together. ----
    static class UnitOfWork {
        final Database db;
        final List<Record> pending = new ArrayList<>();
        final RideRepository rides = new RideRepository(this);
        final PaymentRepository payments = new PaymentRepository(this);
        UnitOfWork(Database db) { this.db = db; }

        void commit() throws Declined {
            Map<String, Ride> savedRides = new LinkedHashMap<>(db.rides);   // begin transaction
            Map<String, Payment> savedPayments = new LinkedHashMap<>(db.payments);
            try {
                for (Record r : pending) {
                    if (r instanceof Ride ride) db.insertRide(ride);
                    else if (r instanceof Payment p) db.insertPayment(p);
                }
            } catch (Declined e) {
                db.rides = savedRides; db.payments = savedPayments;            // roll back everything
                throw e;
            } finally {
                pending.clear();
            }
        }
    }

    static String endRide(Database db, Ride ride, Payment payment) {
        UnitOfWork uow = new UnitOfWork(db);
        uow.rides.add(ride);
        uow.payments.add(payment);
        try {
            uow.commit();
            return "end " + ride.rideId() + ": committed (" + db.counts() + ")";
        } catch (Declined e) {
            return "end " + ride.rideId() + ": " + e.getMessage() + ", rolled back (" + db.counts() + ")";
        }
    }

    public static void main(String[] args) {
        Database db = new Database();
        System.out.println(endRide(db, new Ride("R-1", "mia", 42), new Payment("R-1", 120, true)));
        System.out.println(endRide(db, new Ride("R-2", "mia", 18), new Payment("R-2", 280, false)));
        List<String> mine = new ArrayList<>();
        for (Ride r : new UnitOfWork(db).rides.forRider("mia")) mine.add(r.rideId() + " (" + r.minutes() + " min)");
        System.out.println("mia's rides: " + String.join(", ", mine));
        db.insertRide(new Ride("R-3", "leo", 10));   // without a unit of work: two separate saves
        try {
            db.insertPayment(new Payment("R-3", 200, false));
        } catch (Declined e) {
            System.out.println("without a unit of work: R-3 saved, payment failed (" + e.getMessage() + ") -> " + db.counts() + ", out of step");
        }
    }
}