Typorithm · hard

Clean Architecture

clean-architecturearchitectureuse-casesdependency-ruledependency-inversion

Saved on this device

Full lesson · 8 learning steps Open any exercise for focused practice

Step 1 of 8 · intro card

Learn Clean Architecture

Layered & Clean

Clean architecture nests rings — entities, use cases, interface adapters, frameworks — and enforces the dependency rule: source dependencies point only inward. Use cases form the application core and depend on interfaces (dependency inversion), never on the database or framework.

Clean architecture draws concentric rings: enterprise entities at the center, application use cases around them, interface adapters next, and frameworks on the outer edge.

The dependency rule is the heart of it: source code dependencies may point only inward, so an inner ring never names anything in an outer ring.

Use cases like PlaceOrder are the application core; they depend on interfaces such as OrderRepo (dependency inversion), and the outer rings provide the concrete implementations.

Rings: entities -> use cases -> adapters -> frameworks.

The dependency rule: source dependencies point inward only.

Use cases depend on interfaces, not concrete databases.

// use case — the application core
class PlaceOrder {
  constructor(private orders: OrderRepo) {}
  exec(cmd) {
    const order = new Order(cmd.items);
    return this.orders.save(order);
  }
}

// the boundary the use case depends on (inward)
interface OrderRepo {
  save(order: Order): Order;
}

Read the implementation

Connect each part of the code to the concept before you type.

1. A use case

PlaceOrder is a use case — an application-specific operation that orchestrates the entities.

class PlaceOrder {

2. Depends on an interface

The use case depends on the OrderRepo interface, not a concrete database — dependency inversion.

constructor(private orders: OrderRepo) {}

3. Uses an entity

The use case builds an Order entity; entities sit at the innermost ring.

new Order(cmd.items)

4. The boundary interface

OrderRepo is a boundary the use case owns; outer rings implement it so dependencies point inward.

interface OrderRepo {

A complete learning loop

Understand

Read the concept map and follow the code breakdown.

Reconstruct

Type the implementation, repair mistakes and work through every recall exercise.

Verify

Use the final check without hints; revisit weak concepts in short practice sessions.