1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

// Simulating CP vs AP behavior during network partition
 
interface PartitionScenario {
  partitionedNodes: string[];
  reachableNodes: string[];
}
 
class CPDatabase {
  // Consistency-prioritizing (ACID-style)
  async write(key: string, value: any, scenario: PartitionScenario) {
    const requiredNodes = this.getQuorum(); // Majority needed
    const availableNodes = scenario.reachableNodes;
    
    if (availableNodes.length < requiredNodes) {
      // Cannot guarantee consistency - reject write
      throw new UnavailableError(
        'Cannot write: insufficient nodes for quorum. ' +
        'Rejecting to preserve ACID consistency.'
      );
    }
    
    // Proceed with synchronous replication to quorum
    await this.replicateToQuorum(key, value, availableNodes);
    return { success: true, consistency: 'strong' };
  }
}
 
class APDatabase {
  // Availability-prioritizing (BASE-style)
  async write(key: string, value: any, scenario: PartitionScenario) {
    const availableNodes = scenario.reachableNodes;
    
    if (availableNodes.length === 0) {
      throw new Error('No nodes available at all');
    }
    
    // Accept write on any available node
    const timestamp = Date.now();
    await this.writeToAvailable(key, value, timestamp, availableNodes);
    
    // Queue for async replication when partition heals
    this.queueForReplication(key, value, timestamp, scenario.partitionedNodes);
    
    return { 
      success: true, 
      consistency: 'eventual',
      warning: 'Write accepted but not yet replicated to all nodes'
    };
  }
  
  async handlePartitionHeal(scenario: PartitionScenario) {
    // Resolve conflicts using last-writer-wins or merge
    for (const node of scenario.partitionedNodes) {
      const conflicts = await this.detectConflicts(node);
      for (const conflict of conflicts) {
        await this.resolveConflict(conflict);
      }
    }
  }
}
 
// Example during partition:
// CP: User sees "Service temporarily unavailable, please retry"
// AP: User's write succeeds, might see stale data from other writes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

// CQRS: ACID writes + BASE reads
 
// ===== WRITE SIDE (ACID) =====
class OrderService {
  private acidDatabase: PostgresDB;
  private eventPublisher: EventPublisher;
  
  async createOrder(command: CreateOrderCommand): Promise<Order> {
    // ACID transaction for order creation
    return await this.acidDatabase.transaction(async (tx) => {
      // Validate inventory (ACID read)
      const inventory = await tx.query(
        'SELECT quantity FROM inventory WHERE product_id = $1 FOR UPDATE',
        [command.productId]
      );
      
      if (inventory.quantity < command.quantity) {
        throw new InsufficientInventoryError();
      }
      
      // Create order (ACID write)
      const order = await tx.query(
        'INSERT INTO orders (product_id, quantity, user_id, status) VALUES ($1, $2, $3, $4) RETURNING *',
        [command.productId, command.quantity, command.userId, 'PENDING']
      );
      
      // Reserve inventory (ACID write)
      await tx.query(
        'UPDATE inventory SET quantity = quantity - $1, reserved = reserved + $1 WHERE product_id = $2',
        [command.quantity, command.productId]
      );
      
      // Publish event (will be consumed by read side)
      await this.eventPublisher.publish('OrderCreated', {
        orderId: order.id,
        productId: command.productId,
        quantity: command.quantity,
        userId: command.userId,
        timestamp: new Date()
      });
      
      return order;
    });
  }
}
 
// ===== READ SIDE (BASE) =====
class OrderReadModelUpdater {
  private readDatabase: CassandraDB; // Optimized for reads
  
  // Eventually consistent - processes events async
  async handleOrderCreated(event: OrderCreatedEvent) {
    // Update denormalized read models
    
    // User's order history (eventually consistent)
    await this.readDatabase.execute(
      'INSERT INTO user_orders (user_id, order_id, product_name, quantity, created_at) VALUES (?, ?, ?, ?, ?)',
      [event.userId, event.orderId, await this.getProductName(event.productId), event.quantity, event.timestamp]
    );
    
    // Product order count (eventually consistent)
    await this.readDatabase.execute(
      'UPDATE product_stats SET order_count = order_count + 1 WHERE product_id = ?',
      [event.productId]
    );
    
    // Real-time dashboard (eventually consistent)
    await this.readDatabase.execute(
      'INSERT INTO recent_orders (hour, order_id, total) VALUES (?, ?, ?) USING TTL 86400',
      [this.getHourBucket(), event.orderId, event.quantity]
    );
  }
}
 
class OrderQueryService {
  private readDatabase: CassandraDB;
  
  // Fast reads from eventually consistent store
  async getUserOrderHistory(userId: string): Promise<OrderSummary[]> {
    // Reads from denormalized, eventually consistent read model
    // Super fast, might be slightly behind writes
    return await this.readDatabase.execute(
      'SELECT * FROM user_orders WHERE user_id = ? LIMIT 100',
      [userId]
    );
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

// Example: E-commerce system consistency decisions
 
interface SystemDesignDecisions {
  operation: string;
  category: 'critical-write' | 'critical-read' | 'important-write' | 'important-read' | 'best-effort';
  consistency: 'ACID' | 'BASE' | 'hybrid';
  implementation: string;
}
 
const ecommerceDecisions: SystemDesignDecisions[] = [
  // Critical
  {
    operation: 'Process payment',
    category: 'critical-write',
    consistency: 'ACID',
    implementation: 'PostgreSQL with 2PC to payment processor'
  },
  {
    operation: 'Check inventory before purchase',
    category: 'critical-read',
    consistency: 'ACID',
    implementation: 'Read from PostgreSQL with SELECT FOR UPDATE'
  },
  {
    operation: 'Create order',
    category: 'critical-write',
    consistency: 'ACID',
    implementation: 'PostgreSQL transaction: order + inventory + payment'
  },
  
  // Important
  {
    operation: 'Update user profile',
    category: 'important-write',
    consistency: 'hybrid',
    implementation: 'ACID write to PostgreSQL, async to read replicas'
  },
  {
    operation: 'View order history',
    category: 'important-read',
    consistency: 'BASE',
    implementation: 'Read from eventually consistent read model'
  },
  
  // Best-effort
  {
    operation: 'Product recommendations',
    category: 'best-effort',
    consistency: 'BASE',
    implementation: 'Pre-computed, cached, updated hourly'
  },
  {
    operation: 'Recently viewed products',
    category: 'best-effort',
    consistency: 'BASE',
    implementation: 'Redis with TTL, async updates'
  },
  {
    operation: 'Real-time analytics',
    category: 'best-effort',
    consistency: 'BASE',
    implementation: 'Event streaming to Kafka, processed by ClickHouse'
  }
];
 
// Result: Core commerce in PostgreSQL (ACID)
//         Read scaling via replicas and Redis (BASE)
//         Analytics via streaming and OLAP (BASE)