Service-based and SOA

// One shared database, as service-based architecture usually has. Each service is deployed separately.
type Row = Record<string, string | number | null>;
const DB: Record<string, Row[]> = { bikes: [{ bike: "B7", dock: "D12" }, { bike: "B9", dock: "D12" }], rides: [], charges: [] };

class FleetService { // bikes and docks
  release(dock: string): string {
    const bike = DB.bikes.find((b) => b.dock === dock) as Row;
    bike.dock = null;
    return bike.bike as string;
  }
}

class BillingService { // prices and charges
  charge(rider: string, plan: string, minutes: number): number {
    const pence = plan === "member" ? Math.max(0, minutes - 30) * 10 : 100 + minutes * 10;
    DB.charges.push({ rider, pence });
    return pence;
  }
}

class RideService { // the rider-facing flows; calls the others over their APIs
  constructor(private fleet: FleetService, private billing: BillingService) {}
  unlock(rider: string, plan: string, dock: string): string {
    const bike = this.fleet.release(dock);
    DB.rides.push({ id: `R${DB.rides.length + 1}`, rider, plan, bike, minutes: null });
    return `${DB.rides[DB.rides.length - 1].id} on ${bike}`;
  }
  giveBack(id: string, minutes: number): number {
    const ride = DB.rides.find((r) => r.id === id) as Row;
    ride.minutes = minutes;
    return this.billing.charge(ride.rider as string, ride.plan as string, minutes);
  }
}

class ReportService { // monthly city reports, read straight from the shared tables
  monthly(source = "rides"): string {
    const rows = DB[source];
    if (rows.length && !("minutes" in rows[0])) return "Report service broken: column minutes missing";
    return `${rows.length} ride(s), ${rows.reduce((s, r) => s + (r.minutes as number), 0)} minutes`;
  }
}

const rides = new RideService(new FleetService(), new BillingService());
console.log("unlock: " + rides.unlock("Mia", "member", "D12"));
console.log("return: charged " + rides.giveBack("R1", 42) + " pence");
const reports = new ReportService();
console.log("report: " + reports.monthly());
// The Ride team renames a column in "its" table. Reports shared that table.
for (const r of DB.rides) { r.duration_min = r.minutes; delete r.minutes; }
console.log("after the rename: " + reports.monthly());
// The fix: the Ride team publishes a stable read view; Reports reads only that.
DB.ride_report_view = DB.rides.map((r) => ({ id: r.id, minutes: r.duration_min }));
console.log("reading the view: " + reports.monthly("ride_report_view"));

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

public class Main {
    // One shared database, as service-based architecture usually has. Each service is deployed separately.
    static final Map<String, List<Map<String, Object>>> DB = new HashMap<>();

    static Map<String, Object> row(Object... kv) { Map<String, Object> m = new HashMap<>(); for (int i = 0; i < kv.length; i += 2) m.put((String) kv[i], kv[i + 1]); return m; }

    static class FleetService { // bikes and docks
        String release(String dock) {
            Map<String, Object> bike = DB.get("bikes").stream().filter(b -> dock.equals(b.get("dock"))).findFirst().orElseThrow();
            bike.put("dock", null);
            return (String) bike.get("bike");
        }
    }

    static class BillingService { // prices and charges
        int charge(String rider, String plan, int minutes) {
            int pence = plan.equals("member") ? Math.max(0, minutes - 30) * 10 : 100 + minutes * 10;
            DB.get("charges").add(row("rider", rider, "pence", pence));
            return pence;
        }
    }

    static class RideService { // the rider-facing flows; calls the others over their APIs
        private final FleetService fleet; private final BillingService billing;
        RideService(FleetService fleet, BillingService billing) { this.fleet = fleet; this.billing = billing; }
        String unlock(String rider, String plan, String dock) {
            String bike = fleet.release(dock);
            List<Map<String, Object>> rides = DB.get("rides");
            rides.add(row("id", "R" + (rides.size() + 1), "rider", rider, "plan", plan, "bike", bike, "minutes", null));
            return rides.get(rides.size() - 1).get("id") + " on " + bike;
        }
        int giveBack(String id, int minutes) {
            Map<String, Object> ride = DB.get("rides").stream().filter(r -> id.equals(r.get("id"))).findFirst().orElseThrow();
            ride.put("minutes", minutes);
            return billing.charge((String) ride.get("rider"), (String) ride.get("plan"), minutes);
        }
    }

    static class ReportService { // monthly city reports, read straight from the shared tables
        String monthly(String source) {
            List<Map<String, Object>> rows = DB.get(source);
            if (!rows.isEmpty() && !rows.get(0).containsKey("minutes")) return "Report service broken: column minutes missing";
            return rows.size() + " ride(s), " + rows.stream().mapToInt(r -> (Integer) r.get("minutes")).sum() + " minutes";
        }
    }

    public static void main(String[] args) {
        DB.put("bikes", new ArrayList<>(List.of(row("bike", "B7", "dock", "D12"), row("bike", "B9", "dock", "D12"))));
        DB.put("rides", new ArrayList<>());
        DB.put("charges", new ArrayList<>());
        RideService rides = new RideService(new FleetService(), new BillingService());
        System.out.println("unlock: " + rides.unlock("Mia", "member", "D12"));
        System.out.println("return: charged " + rides.giveBack("R1", 42) + " pence");
        ReportService reports = new ReportService();
        System.out.println("report: " + reports.monthly("rides"));
        // The Ride team renames a column in "its" table. Reports shared that table.
        for (Map<String, Object> r : DB.get("rides")) r.put("duration_min", r.remove("minutes"));
        System.out.println("after the rename: " + reports.monthly("rides"));
        // The fix: the Ride team publishes a stable read view; Reports reads only that.
        List<Map<String, Object>> view = new ArrayList<>();
        for (Map<String, Object> r : DB.get("rides")) view.add(row("id", r.get("id"), "minutes", r.get("duration_min")));
        DB.put("ride_report_view", view);
        System.out.println("reading the view: " + reports.monthly("ride_report_view"));
    }
}