Clean Architecture Patterns

Clean Architecture Patterns

Layer Structure

┌─────────────────────────────────────┐
│      PRESENTATION LAYER             │
│  (Controllers, Widgets, Bindings)   │
├─────────────────────────────────────┤
│         DOMAIN LAYER                │
│  (Entities, Use Cases, Interfaces)  │
├─────────────────────────────────────┤
│          DATA LAYER                 │
│  (Models, Repositories, Sources)    │
└─────────────────────────────────────┘

Dependency Rule: Outer layers depend on inner layers, NEVER reverse.

Domain Layer (Pure Business Logic)

Entities

// lib/​domain/​entities/​user.dart
import 'package:equatable/​equatable.dart';

class User extends Equatable {
  final String id;
  final String name;
  final String email;
  
  const User({
    required this.id,
    required this.name,
    required this.email,
  });
  
  @override
  List<Object?> get props => [id, name, email];
}

Repository Interfaces

// lib/​domain/​repositories/​user_repository.dart
import 'package:dartz/​dartz.dart';
import '../​../​core/​errors/​failures.dart';
import '../​entities/​user.dart';

abstract class UserRepository {
  Future<Either<Failure, User>> getUser(String id);
  Future<Either<Failure, List<User>>> getAllUsers();
  Future<Either<Failure, User>> createUser(User user);
}

Use Cases

// lib/​domain/​usecases/​get_user.dart
import 'package:dartz/​dartz.dart';
import '../​../​core/​errors/​failures.dart';
import '../​entities/​user.dart';
import '../​repositories/​user_repository.dart';

class GetUser {
  final UserRepository repository;
  
  GetUser(this.repository);
  
  Future<Either<Failure, User>> call(String id) {
    return repository.getUser(id);
  }
}

Data Layer (Implementation Details)

Models

// lib/​data/​models/​user_model.dart
import '../​../​domain/​entities/​user.dart';

class UserModel extends User {
  const UserModel({
    required super.id,
    required super.name,
    required super.email,
  });
  
  factory UserModel.fromJson(Map<String, dynamic> json) {
    return UserModel(
      id: json['id'],
      name: json['name'],
      email: json['email'],
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'name': name,
      'email': email,
    };
  }
  
  User toEntity() {
    return User(id: id, name: name, email: email);
  }
}

Repository Implementation

// lib/​data/​repositories/​user_repository_impl.dart
import 'package:dartz/​dartz.dart';
import '../​../​core/​errors/​failures.dart';
import '../​../​core/​errors/​exceptions.dart';
import '../​../​domain/​entities/​user.dart';
import '../​../​domain/​repositories/​user_repository.dart';
import '../​providers/​user_provider.dart';

class UserRepositoryImpl implements UserRepository {
  final UserProvider provider;
  
  UserRepositoryImpl(this.provider);
  
  @override
  Future<Either<Failure, User>> getUser(String id) async {
    try {
      final model = await provider.fetchUser(id);
      return Right(model.toEntity());
    } on ServerException catch (e) {
      return Left(ServerFailure(e.message));
    }
  }
}

Presentation Layer (UI & State Management)

Controllers

// lib/​presentation/​controllers/​user_controller.dart
import 'package:get/​get.dart';
import '../​../​domain/​usecases/​get_user.dart';

class UserController extends GetxController {
  final GetUser getUserUseCase;
  
  UserController({required this.getUserUseCase});
  
  final _user = Rx<User?>(null);
  User? get user => _user.value;
  
  Future<void> loadUser(String id) async {
    final result = await getUserUseCase(id);
    result.fold(
      (failure) => Get.snackbar('Error', failure.message),
      (user) => _user.value = user,
    );
  }
}

Dependency Inversion

// ❌ BAD: High-level module depends on low-level module
class UserController {
  final UserApiClient apiClient; // Concrete implementation
  
  void loadUser() {
    apiClient.fetchUser(); // Direct dependency on implementation
  }
}

// ✅ GOOD: Both depend on abstraction
class UserController {
  final UserRepository repository; // Abstract interface
  
  void loadUser() {
    repository.getUser(); // Depends on abstraction
  }
}