What is the CAP theorem?

// CAP in one run: a 3-seat inventory replicated on A, B, C, then a partition {A} | {B, C}.
// CP: an operation needs a majority (2 of 3 replicas) reachable, or it fails.
// AP: any replica answers from what it knows and syncs with the others later.
const NODES = ["A", "B", "C"], SEATS = 3;
const script = [["buy", "B"], ["partition"], ["buy", "A"], ["buy", "B"], ["buy", "A"], ["buy", "C"],
  ["read", "A"], ["read", "B"], ["heal"], ["read", "A"]];

function simulate(mode) {
  const sales = { A: new Set(), B: new Set(), C: new Set() }; // sale ids each replica knows about
  let side = { A: 0, B: 0, C: 0 }, ok = 0, errors = 0, n = 0;
  const reachable = (x) => NODES.filter((y) => side[y] === side[x]);
  const left = (x) => SEATS - sales[x].size;
  console.log("-- " + mode + " --");
  for (const [op, at] of script) {
    if (op === "partition") { side = { A: 1, B: 0, C: 0 }; console.log("   partition: A | B C"); continue; }
    if (op === "heal") {
      const all = new Set([...sales.A, ...sales.B, ...sales.C]);
      for (const x of NODES) sales[x] = new Set(all);
      side = { A: 0, B: 0, C: 0 };
      console.log("   heal: replicas merge, " + all.size + " sales recorded for " + SEATS + " seats" + (all.size > SEATS ? " -> OVERSOLD by " + (all.size - SEATS) : ""));
      continue;
    }
    const peers = reachable(at);
    let res;
    if (mode === "CP" && peers.length * 2 <= NODES.length) { res = "ERROR no quorum (" + peers.length + " of 3 reachable)"; errors++; }
    else if (op === "read") { res = left(at) < 0 ? "oversold: " + -left(at) + " tickets have no seat" : left(at) + " seats left"; ok++; }
    else if (left(at) === 0) { res = "sold out"; ok++; }
    else {
      const id = "sale" + ++n;
      for (const p of peers) sales[p].add(id); // replicate to every replica this side can reach
      res = "sold, " + left(at) + " left on " + peers.join("");
      ok++;
    }
    console.log("   " + op + " at " + at + ": " + res);
  }
  console.log("   answered " + ok + " of " + (ok + errors) + " requests, " + errors + " errors");
}
simulate("CP");
simulate("AP");

console.log("-- AP with data that merges: a like counter, partition A | B C --");
// 10 likes before the split; then 9 likes arrive, each at one replica, and spread only within its side.
const likes = ["A", "B", "A", "C", "A", "B", "A", "C", "B"], side2 = { A: 1, B: 0, C: 0 };
const lww = {}, gc = {}; // lww: [value, timestamp]; gc: one count per replica (G-counter)
for (const x of NODES) { lww[x] = [10, 0]; gc[x] = { A: 10, B: 0, C: 0 }; }
likes.forEach((x, i) => {
  const ts = i + 1, val = lww[x][0] + 1, mine = gc[x][x] + 1;
  for (const y of NODES) if (side2[y] === side2[x]) { lww[y] = [val, ts]; gc[y][x] = mine; }
});
let newest = lww.A; // heal: last-writer-wins keeps the value with the newest timestamp
for (const x of NODES) if (lww[x][1] > newest[1]) newest = lww[x];
const merged = {}; // heal: G-counter takes the max of each replica slot, then sums
for (const k of NODES) merged[k] = Math.max(gc.A[k], gc.B[k], gc.C[k]);
const truth = 10 + likes.length, gTotal = merged.A + merged.B + merged.C;
console.log("   side A alone saw " + lww.A[0] + ", side B C saw " + lww.B[0]);
console.log("   true total " + truth + ", last-writer-wins keeps " + newest[0] + " (lost " + (truth - newest[0]) + "), G-counter merge gives " + gTotal);

console.log("-- No partition: the else-branch of PACELC (client next to A) --");
const rtt = { A: 1, B: 12, C: 80 }; // ms round trip from the client region to each replica
const sorted = NODES.map((x) => rtt[x]).sort((a, b) => a - b);
console.log("   ack from 1 replica (EL, may read stale): " + sorted[0] + " ms");
console.log("   ack from a majority, 2 of 3 (EC):        " + sorted[1] + " ms");
console.log("   ack from all 3 replicas:                 " + sorted[2] + " ms");