CAP Theorem

1// ============================================
2// CAP Theorem — Practical Demonstration
3// ============================================
4
5// ---------- CP System (Consistency over Availability) ----------
6class CPDatabase {
7  constructor(nodes) {
8    this.nodes = nodes;
9    this.quorum = Math.floor(nodes.length / 2) + 1;
10  }
11
12  async write(key, value) {
13    let acks = 0;
14    for (const node of this.nodes) {
15      try {
16        await node.write(key, value);
17        acks++;
18      } catch (e) {
19        console.log(`Node \${node.id} unreachable`);
20      }
21    }
22
23    if (acks >= this.quorum) {
24      return { success: true, acks };
25    }
26    // CP: Reject write if quorum not met
27    throw new Error(`Write failed: only \${acks}/\${this.quorum} acks (UNAVAILABLE)`);
28  }
29
30  async read(key) {
31    let responses = [];
32    for (const node of this.nodes) {
33      try {
34        const value = await node.read(key);
35        responses.push(value);
36      } catch (e) { /* Node unreachable */ }
37    }
38
39    if (responses.length >= this.quorum) {
40      // Return the most recent value
41      return responses.sort((a, b) => b.version - a.version)[0];
42    }
43    throw new Error('Read failed: quorum not met (UNAVAILABLE)');
44  }
45}
46
47// ---------- AP System (Availability over Consistency) ----------
48class APDatabase {
49  constructor(nodes) {
50    this.nodes = nodes;
51  }
52
53  async write(key, value) {
54    // AP: Write to ANY available node, even during partition
55    for (const node of this.nodes) {
56      try {
57        await node.write(key, value);
58        // Background: async replicate to other nodes
59        this.asyncReplicate(node, key, value);
60        return { success: true, node: node.id };
61      } catch (e) { continue; }
62    }
63    throw new Error('All nodes down');
64  }
65
66  async read(key) {
67    // AP: Read from ANY available node (might be stale!)
68    for (const node of this.nodes) {
69      try {
70        return await node.read(key);
71      } catch (e) { continue; }
72    }
73    throw new Error('All nodes down');
74  }
75
76  async asyncReplicate(sourceNode, key, value) {
77    for (const node of this.nodes) {
78      if (node.id !== sourceNode.id) {
79        try { await node.write(key, value); } catch (e) { /* Retry later */ }
80      }
81    }
82  }
83}
84
85// ---------- Per-Component Consistency Decisions ----------
86const systemDesignDecisions = {
87  'User Authentication': {
88    consistency: 'CP (Strong)',
89    reason: 'Cannot serve stale auth data — security risk',
90    database: 'PostgreSQL with synchronous replication',
91  },
92  'Social Feed': {
93    consistency: 'AP (Eventual)',
94    reason: 'Stale feed for a few seconds is acceptable',
95    database: 'Cassandra with async replication',
96  },
97  'Shopping Cart': {
98    consistency: 'AP with conflict resolution',
99    reason: 'Must be available during sales events, merge conflicts later',
100    database: 'DynamoDB with last-writer-wins',
101  },
102  'Inventory Count': {
103    consistency: 'CP for checkout, AP for display',
104    reason: 'Display can be stale, but checkout must prevent overselling',
105    database: 'PostgreSQL for checkout, Redis cache for display',
106  },
107  'Chat Messages': {
108    consistency: 'AP with causal ordering',
109    reason: 'Messages must be available even during partial outages',
110    database: 'Cassandra with client-side ordering',
111  },
112};
113
114console.log('System design consistency decisions:');
115Object.entries(systemDesignDecisions).forEach(([component, config]) => {
116  console.log(`\n\${component}: \${config.consistency}`);
117  console.log(`  Reason: \${config.reason}`);
118});