Dependency Inversion Principle

// ❌ High-level OrderService directly depends on low-level PostgresDB
class PostgresDB {
  save(order: Order): void { /* SQL INSERT */ }
}

class OrderService {
  private db = new PostgresDB(); // ❌ concrete dependency — impossible to test or swap

  placeOrder(order: Order): void {
    this.db.save(order);
  }
}

// ✓ Both depend on an abstraction — the interface belongs to the high-level layer
interface OrderRepository {
  save(order: Order): Promise<void>;
  findById(id: string): Promise<Order | null>;
}

class OrderService {
  constructor(private repo: OrderRepository) {} // depends on abstraction ✓

  async placeOrder(order: Order): Promise<void> {
    await this.repo.save(order);
  }
}

// Low-level module implements the high-level abstraction
class PostgresOrderRepository implements OrderRepository {
  async save(order: Order)              { /* SQL INSERT */ }
  async findById(id: string)            { /* SQL SELECT */ return null; }
}

// Test double — zero infrastructure required
class InMemoryOrderRepository implements OrderRepository {
  private orders = new Map<string, Order>();
  async save(o: Order)       { this.orders.set(o.id, o); }
  async findById(id: string) { return this.orders.get(id) ?? null; }
}