Clean Architecture Rules

Clean Architecture-এর মূল নিয়মাবলী এবং নীতিমালা যা প্রতিটি ডেভেলপারের মেনে চলা উচিত।

🎯 মূল নীতিমালা

1. Dependency Rule (নির্ভরতার নিয়ম)

সবচেয়ে গুরুত্বপূর্ণ নিয়ম: উচ্চতর লেয়ার নিম্নতর লেয়ারের উপর নির্ভর করতে পারে, কিন্তু উল্টোটা নয়।

Domain ← Data ← Presentation

✅ সঠিক:

// Data layer এ Domain layer ব্যবহার করা
class AuthRepositoryImpl implements AuthRepository {
  final AuthEntity user = AuthEntity(name: 'John');
}

❌ ভুল:

// Domain layer এ Data layer ব্যবহার করা (নিষিদ্ধ)
class AuthEntity {
  final AuthModel model; // ❌ এটি করবেন না
}

2. Single Responsibility Principle

প্রতিটি ক্লাস/ফাইলের একটিই দায়িত্ব থাকবে।

✅ সঠিক:

// শুধু API থেকে ডেটা নিয়ে আসার জন্য
class AuthRemoteDataSource {
  Future<AuthModel> login(String email, String password);
}

// শুধু local storage থেকে ডেটা নিয়ে আসার জন্য  
class AuthLocalDataSource {
  Future<AuthModel> getCachedUser();
}

❌ ভুল:

// একাধিক দায়িত্ব (API + Local + Validation)
class AuthDataSource {
  Future<AuthModel> login(String email, String password);
  Future<AuthModel> getCachedUser();
  bool validateEmail(String email); // ❌ এই validation এখানে থাকবে না
}

3. Interface Segregation

বড় interface ভেঙে ছোট ছোট specific interface বানান।

✅ সঠিক:

abstract class AuthRepository {
  Future<AuthEntity> login(String email, String password);
  Future<void> logout();
}

abstract class UserRepository {
  Future<UserEntity> getProfile();
  Future<void> updateProfile(UserEntity user);
}

❌ ভুল:

// একটি বড় interface যেখানে সব কিছু আছে
abstract class Repository {
  Future<AuthEntity> login(String email, String password);
  Future<void> logout();
  Future<UserEntity> getProfile();
  Future<void> updateProfile(UserEntity user);
  Future<List<Product>> getProducts(); // ❌ এটি আলাদা repository-তে থাকবে
}

🏗️ Layer-wise নিয়মাবলী

Domain Layer

✅ করবেন:

• শুধু business logic রাখুন
• Pure Dart code ব্যবহার করুন
• Abstract repositories তৈরি করুন
• Entities এবং Use cases রাখুন

❌ করবেন না:

• Flutter/UI dependencies ব্যবহার করবেন না
• HTTP calls করবেন না
• Database operations করবেন না
• File I/O operations করবেন না

// ✅ সঠিক Domain Entity
class UserEntity {
  final String id;
  final String name;
  final String email;
  
  const UserEntity({
    required this.id,
    required this.name,
    required this.email,
  });
}

// ❌ ভুল - UI dependencies আছে
class UserEntity {
  final String id;
  final String name;
  final Color profileColor; // ❌ Flutter dependency
}

Data Layer

✅ করবেন:

• External services এর সাথে communication করুন
• Data transformation করুন (Model ↔ Entity)
• Caching implement করুন
• Repository interfaces implement করুন

❌ করবেন না:

• Business logic রাখবেন না
• UI logic রাখবেন না
• Direct widget building করবেন না

// ✅ সঠিক Data Model
class UserModel extends UserEntity {
  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,
    };
  }
}

Presentation Layer

✅ করবেন:

• UI logic রাখুন
• State management করুন
• User interactions handle করুন
• Navigation logic রাখুন

❌ করবেন না:

• Direct API calls করবেন না
• Business logic রাখবেন না
• Database operations করবেন না

// ✅ সঠিক Controller/Bloc
class AuthController extends GetxController {
  final AuthUseCase _authUseCase;
  
  AuthController(this._authUseCase);
  
  Future<void> login(String email, String password) async {
    try {
      final user = await _authUseCase.login(email, password);
      // UI state update
    } catch (e) {
      // Error handling for UI
    }
  }
}

// ❌ ভুল - Direct API call
class AuthController extends GetxController {
  Future<void> login(String email, String password) async {
    final response = await http.post(...); // ❌ Direct API call
  }
}

🔄 Dependency Injection নিয়ম

1. Constructor Injection ব্যবহার করুন

// ✅ সঠিক
class AuthUseCase {
  final AuthRepository _repository;
  
  AuthUseCase(this._repository);
}

// ❌ ভুল - Service Locator pattern
class AuthUseCase {
  late final AuthRepository _repository;
  
  AuthUseCase() {
    _repository = GetIt.instance<AuthRepository>(); // ❌
  }
}

2. Abstractions এর উপর নির্ভর করুন

// ✅ সঠিক - Abstract repository
class AuthUseCase {
  final AuthRepository _repository; // Interface
  
  AuthUseCase(this._repository);
}

// ❌ ভুল - Concrete implementation
class AuthUseCase {
  final AuthRepositoryImpl _repository; // ❌ Concrete class
  
  AuthUseCase(this._repository);
}

📁 File Organization নিয়ম

1. Feature-based Structure

lib/
└── features/
    └── auth/
        ├── data/
        │   ├── datasources/
        │   ├── models/
        │   └── repositories/
        ├── domain/
        │   ├── entities/
        │   ├── repositories/
        │   └── usecases/
        └── presentation/
            ├── bloc/ (or controllers/)
            ├── pages/
            └── widgets/

2. Naming Conventions

Files:

• Entity: user_entity.dart
• Model: user_model.dart
• Repository Interface: user_repository.dart
• Repository Implementation: user_repository_impl.dart
• Use Case: login_usecase.dart
• Data Source: user_remote_data_source.dart

Classes:

• Entity: UserEntity
• Model: UserModel
• Repository Interface: UserRepository
• Repository Implementation: UserRepositoryImpl
• Use Case: LoginUseCase
• Data Source: UserRemoteDataSource

⚠️ Common Mistakes (সাধারণ ভুল)

1. Layer Mixing

// ❌ Domain layer এ Flutter dependency
import 'package:flutter/material.dart'; // Domain layer এ এটি থাকবে না

class UserEntity {
  final Color themeColor; // ❌
}

2. Circular Dependencies

// ❌ ভুল - Circular dependency
class AuthUseCase {
  final AuthController controller; // ❌ UseCase Controller কে জানবে না
}

class AuthController {
  final AuthUseCase useCase; // এটি ঠিক আছে
}

3. God Classes

// ❌ ভুল - একটি class-এ অনেক responsibility
class AuthManager {
  Future<void> login() {}
  Future<void> logout() {}
  Future<void> validateEmail() {}
  Future<void> sendOTP() {}
  Future<void> uploadProfilePicture() {} // ❌ এটি আলাদা class এ থাকবে
  Future<void> updateUserPreferences() {} // ❌ এটি আলাদা class এ থাকবে
}

✅ Best Practices Checklist

Domain Layer Checklist:

• কোন Flutter dependencies নেই
• Pure business logic আছে
• Abstract repositories আছে
• Entities immutable
• Use cases single responsibility follow করে

Data Layer Checklist:

• Repository interfaces implement করেছে
• Model to Entity conversion আছে
• Error handling আছে
• Data sources আলাদা আলাদা
• Caching strategy আছে

Presentation Layer Checklist:

• UI logic শুধু এখানে
• Use cases ব্যবহার করেছে
• State management proper
• Error handling for UI
• Navigation logic আছে

🎯 Benefits of Following Rules

1. Maintainability: কোড সহজে maintain করা যায়
2. Testability: Unit testing সহজ হয়
3. Scalability: প্রজেক্ট বড় হলেও manage করা যায়
4. Team Collaboration: টিমের সবাই same pattern follow করে
5. Code Reusability: Business logic reuse করা যায়

---

মনে রাখবেন: এই নিয়মগুলো follow করলে আপনার কোড হবে Clean, Maintainable এবং Scalable! 🚀