flutter-enterprise

What this skill does

# Flutter Enterprise - Feature-Based Clean Architecture

Lightweight Flutter development skill for building enterprise applications using feature-based clean architecture patterns.

## Core Philosophy

**"Feature-first, testable, maintainable enterprise code"** - Focus on:

| Priority | Area | Purpose |
|----------|------|---------|
| 1 | Feature-Based Structure | Modular, scalable code organization |
| 2 | Clean Architecture | Separation of concerns and testability |
| 3 | Dependency Injection | Loose coupling and maintainability |
| 4 | Enterprise Patterns | Proven enterprise development practices |
| 5 | Code Generation | Boilerplate reduction and consistency |

## Development Workflow

Execute phases sequentially. Complete each before proceeding.

### Phase 1: Analyze Requirements

1. **Feature identification** - Identify distinct business features
2. **Data flow analysis** - Map data dependencies between features
3. **Integration points** - Define external service integrations
4. **Scalability requirements** - Plan for future feature additions

Output: Feature breakdown with dependency mapping.

### Phase 2: Design Feature Architecture

1. **Feature boundary definition** - Define clear feature boundaries
2. **Data layer planning** - Design repositories and data sources
3. **Domain modeling** - Create entities and use cases
4. **Presentation layer design** - Plan UI components and state management

Output: Feature architecture diagram and data contracts.

### Phase 3: Implement Core Structure

1. **Project setup** - Create feature-based directory structure
2. **Dependency injection** - Set up service locator or DI container
3. **Core utilities** - Create shared utilities and constants
4. **Navigation setup** - Implement routing structure

**Feature Structure Pattern:**
```
lib/
├── core/
│   ├── constants/
│   ├── errors/
│   ├── network/
│   ├── utils/
│   └── widgets/
├── features/
│   ├── feature_name/
│   │   ├── data/
│   │   │   ├── datasources/
│   │   │   ├── models/
│   │   │   └── repositories/
│   │   ├── domain/
│   │   │   ├── entities/
│   │   │   ├── repositories/
│   │   │   └── usecases/
│   │   └── presentation/
│   │       ├── pages/
│   │       ├── widgets/
│   │       └── providers/
│   └── ...
└── main.dart
```

### Phase 4: Implement Feature Modules

1. **Data layer** - Implement repositories and data sources
2. **Domain layer** - Create business logic and use cases
3. **Presentation layer** - Build UI components and state management
4. **Feature integration** - Connect feature to main app

**Clean Architecture Implementation:**
```dart
// Domain Layer - Entity
class User {
  final String id;
  final String name;
  final String email;

  User({required this.id, required this.name, required this.email});
}

// Domain Layer - Repository (Abstract)
abstract class UserRepository {
  Future<List<User>> getUsers();
  Future<User> getUserById(String id);
}

// Domain Layer - Use Case
class GetUsersUseCase {
  final UserRepository repository;

  GetUsersUseCase(this.repository);

  Future<List<User>> call() async {
    return await repository.getUsers();
  }
}

// Data Layer - Repository Implementation
class UserRepositoryImpl implements UserRepository {
  final RemoteDataSource remoteDataSource;

  UserRepositoryImpl(this.remoteDataSource);

  @override
  Future<List<User>> getUsers() async {
    final userModels = await remoteDataSource.getUsers();
    return userModels.map((model) => model.toEntity()).toList();
  }
}
```

### Phase 5: Setup Testing Structure

1. **Unit tests** - Test domain layer and use cases
2. **Integration tests** - Test data layer and repositories
3. **Widget tests** - Test presentation layer components
4. **Test utilities** - Create mock objects and test helpers

## Quick Reference

### Feature-Based Architecture Patterns

| Layer | Responsibility | Key Components |
|-------|----------------|----------------|
| **Presentation** | UI and State Management | Pages, Widgets, Providers/Bloc |
| **Domain** | Business Logic | Entities, Use Cases, Repository Interfaces |
| **Data** | Data Implementation | Models, Data Sources, Repository Implementations |

### Dependency Injection Setup

```dart
// main.dart
void main() {
  // Initialize dependencies
  final serviceLocator = GetIt.instance;

  // Data sources
  serviceLocator.registerLazySingleton<RemoteDataSource>(
    () => RemoteDataSourceImpl(httpClient: serviceLocator()));

  // Repositories
  serviceLocator.registerLazySingleton<UserRepository>(
    () => UserRepositoryImpl(serviceLocator()));

  // Use cases
  serviceLocator.registerFactory<GetUsersUseCase>(
    () => GetUsersUseCase(serviceLocator()));

  runApp(MyApp());
}
```

### State Management Patterns

This skill now supports **state management neutrality** with equivalent implementations for all four major approaches:

#### Provider Pattern
```dart
// Presentation Layer - Provider
class UserProvider extends ChangeNotifier {
  final GetUsersUseCase getUsersUseCase;

  List<User> _users = [];
  bool _isLoading = false;

  UserProvider({required this.getUsersUseCase});

  List<User> get users => _users;
  bool get isLoading => _isLoading;

  Future<void> loadUsers() async {
    _isLoading = true;
    notifyListeners();

    try {
      _users = await getUsersUseCase();
    } catch (e) {
      // Handle error
    } finally {
      _isLoading = false;
      notifyListeners();
    }
  }
}
```

#### Bloc Pattern
```dart
// Presentation Layer - Bloc
abstract class UserEvent extends Equatable {}
class LoadUsers extends UserEvent {}

abstract class UserState extends Equatable {}
class UserLoading extends UserState {}
class UserLoaded extends UserState {
  final List<User> users;
  UserLoaded(this.users);
  @override
  List<Object> get props => [users];
}

class UserBloc extends Bloc<UserEvent, UserState> {
  final GetUsersUseCase getUsersUseCase;

  UserBloc({required this.getUsersUseCase}) : super(UserInitial()) {
    on<LoadUsers>(_onLoadUsers);
  }

  Future<void> _onLoadUsers(LoadUsers event, Emitter<UserState> emit) async {
    emit(UserLoading());
    try {
      final users = await getUsersUseCase();
      emit(UserLoaded(users));
    } catch (e) {
      // Handle error
    }
  }
}
```

#### Riverpod Pattern
```dart
// Presentation Layer - Riverpod
class UserNotifier extends StateNotifier<AsyncValue<List<User>>> {
  final GetUsersUseCase getUsersUseCase;

  UserNotifier({required this.getUsersUseCase}) : super(const AsyncValue.loading());

  Future<void> loadUsers() async {
    state = const AsyncValue.loading();
    try {
      final users = await getUsersUseCase();
      state = AsyncValue.data(users);
    } catch (e, stackTrace) {
      state = AsyncValue.error(e, stackTrace);
    }
  }
}

final userProvider = StateNotifierProvider<UserNotifier, AsyncValue<List<User>>>((ref) {
  return UserNotifier(getUsersUseCase: ref.watch(getUsersUseCaseProvider));
});
```

#### GetX Pattern
```dart
// Presentation Layer - GetX
class UserController extends GetxController {
  final GetUsersUseCase getUsersUseCase;

  UserController({required this.getUsersUseCase});

  final RxList<User> _users = <User>[].obs;
  final RxBool _isLoading = false.obs;

  List<User> get users => _users;
  bool get isLoading => _isLoading.value;

  Future<void> loadUsers() async {
    _isLoading.value = true;
    try {
      final userList = await getUsersUseCase();
      _users.assignAll(userList);
    } catch (e) {
      // Handle error
    } finally {
      _isLoading.value = false;
    }
  }
}

// Page Example with GetX
class UserListPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return GetBuilder<UserController>(
      init: UserController(getUsersUseCase: Get.find()),
      builder: (controller) {
        return Scaffold(
          appBar: AppBar(title: Text('Users')),
          body: Obx(() {
            if (controller.isLoading.value) {
              return Center(child: CircularProgres