Clean Architecture Repository: Part 04

Clean Architecture Repository: Bridging Logic and Data

In our previous article, we learned about Use Cases—the conductors of our application. But here is the big question: Where does the data actually come from? While the Use Case knows what to do with the data, it shouldn’t care how that data is fetched. This is where the Clean Architecture Repository comes into play.

What is a Repository?

A Repository is a “contract” or an interface that sits between your Domain layer (Logic) and your Data layer (External World). It acts as a gateway, allowing your business logic to request data without knowing anything about APIs, Databases, or Firebase.

The Connection: Why the Interface belongs in the Domain?

One of the most common mistakes is putting the Repository Interface in the Data layer. In Clean Architecture, we use the Dependency Inversion Principle (DIP).

By placing the Interface in the Domain Layer, the Domain remains the boss. It says, “I need a method called getUser. I don’t care if you get it from a SQL database or a carrier pigeon; just give me the data.”

Why is this needed?

1. Independence: Your “Heart” (Domain) doesn’t depend on the “Body” (Data). If you change your database, you don’t touch your business logic.
2. Testability: You can easily inject a “Fake” or “Mock” repository during testing to simulate data without needing a real server.
3. Flexibility: You can swap your http package for dio or move from REST to GraphQL by only changing the implementation in the Data layer.

Practical Code Example

Let’s look at how we split the contract from the actual work.

Step 1: The Contract (Domain Layer)

This is pure Dart. No libraries, no API links. Just a promise.

// Domain Layer: repositories/user_repository.dart
abstract class UserRepository {
  Future<UserEntity> getUser(String id);
}

Step 2: The Implementation (Data Layer)

This is where the actual “dirty” work happens. This layer “signs” the contract.

// Data Layer: repositories/user_repository_impl.dart
class UserRepositoryImpl implements UserRepository {
  final RemoteDataSource remoteDataSource;

  UserRepositoryImpl(this.remoteDataSource);

  @override
  Future<UserEntity> getUser(String id) async {
    // Fetch from API and convert to Entity
    return await remoteDataSource.fetchUserFromApi(id);
  }
}

Conclusion

The Clean Architecture Repository is the secret to a decoupled and professional codebase. By keeping the interface in the Domain layer, you ensure that your business rules remain protected from external changes.

In the next part, we will explore Data Sources—the final destination where we actually write our API calls and Database queries.