Clean architecture

Learn clean architecture principles.

Clean architecture

Clean architecture is an approach where dependencies flow inward. At the center sit the domain (entities and use cases); on the outside, frameworks and UI. The outer ring depends on the inner; never the reverse.

This way the domain logic is independent of React Native or the database. Even if the framework changes, the domain stays the same; tests are easy to write. Dependencies are inverted (dependency inversion).

Dependency inversion

The core principle of clean architecture is dependency inversion. The outer layer depends on the inner; the inner does not know the outer. This is achieved through interfaces.

Example: a UserRepository interface is defined in the domain; the real implementation (API call) is written in the outer layer. The domain does not know the concrete class; it only calls the interface.

Exercise UserRepository interface

Define a UserRepository interface. It should have a method getUser(id: string): Promise<User>. Also define User as a simple interface.

Show example solution

// Define User and UserRepository types here
interface User {
  id: string;
  name: string;
}

interface UserRepository {
  getUser(id: string): Promise<User>;
}

export { User, UserRepository };

Test yourself

Match the Clean rings

Entities

Domain entities
Use cases

Business logic
Controllers

UI adapters
Frameworks

React Native, database
What does the domain know in clean architecture?
- Only its own entities and use cases
- React Native components
- The database schema
- HTTP requests
Show answer

The database schema — The domain only knows its own entities.

Write the repository interface name

interface ____ {
  getUser(id: string): Promise<User>;
}

Show answer

interface UserRepository {
  getUser(id: string): Promise<User>;
}

Next lesson: Repository pattern

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies