Dependency Injection: Receive Dependencies, Don't Create Them

A class that instantiates its own dependencies with new is tightly coupled to those implementations. It is untestable without running the real infrastructure and closed to substitution.

Accept dependencies as constructor parameters typed against interfaces. The caller (or a DI container) supplies the concrete implementation. The class never calls new on its dependencies.

// Bad: tightly coupled
class OrderService {
  private repo = new PostgresOrderRepository(); // hardcoded
  async getOrder(id: string) { return this.repo.findById(id); }
}

// Good: dependency injected
class OrderService {
  constructor(private repo: OrderRepository) {} // interface type
  async getOrder(id: string) { return this.repo.findById(id); }
}

// In production
const service = new OrderService(new PostgresOrderRepository(prisma));
// In tests
const service = new OrderService(new InMemoryOrderRepository());

DI inverts control: the class declares what it needs; external code decides what to provide. This makes classes independently testable and makes swapping implementations trivially safe.