Riverpod + Clean Architecture + Firebase — The Complete Flutter Guide

class UserEntity {
  final String id;
  final String email;
  final String? displayName;

  const UserEntity({
    required this.id,
    required this.email,
    this.displayName,
  });
}

// domain/repositories/auth_repository.dart
abstract class AuthRepository {
  Future<Either<Failure, UserEntity>> signIn({
    required String email,
    required String password,
  });
  Future<Either<Failure, void>> signOut();
  Stream<UserEntity?> get authStateChanges;
}

class AuthRepositoryImpl implements AuthRepository {
  final FirebaseAuth _auth;

  const AuthRepositoryImpl({required FirebaseAuth auth}) : _auth = auth;

  @override
  Future<Either<Failure, UserEntity>> signIn({
    required String email,
    required String password,
  }) async {
    try {
      final credential = await _auth.signInWithEmailAndPassword(
        email: email,
        password: password,
      );
      return Right(UserModel.fromFirebase(credential.user!).toEntity());
    } on FirebaseAuthException catch (e) {
      return Left(AuthFailure(message: e.message ?? 'Authentication failed'));
    }
  }
}

final authRepositoryProvider = Provider<AuthRepository>((ref) {
  return AuthRepositoryImpl(auth: FirebaseAuth.instance);
});

final authNotifierProvider =
    StateNotifierProvider<AuthNotifier, AsyncValue<UserEntity?>>((ref) {
  return AuthNotifier(ref.watch(authRepositoryProvider));
});

class AuthNotifier extends StateNotifier<AsyncValue<UserEntity?>> {
  final AuthRepository _repository;

  AuthNotifier(this._repository) : super(const AsyncValue.loading()) {
    _init();
  }

  void _init() {
    _repository.authStateChanges.listen((user) {
      state = AsyncValue.data(user);
    });
  }

  Future<void> signIn({required String email, required String password}) async {
    state = const AsyncValue.loading();
    final result = await _repository.signIn(email: email, password: password);
    result.fold(
      (failure) => state = AsyncValue.error(failure, StackTrace.current),
      (user) => state = AsyncValue.data(user),
    );
  }
}

final routerProvider = Provider<GoRouter>((ref) {
  final authState = ref.watch(authNotifierProvider);

  return GoRouter(
    initialLocation: '/sign-in',
    redirect: (context, state) {
      final isAuthenticated = authState.valueOrNull != null;
      final isOnAuth = state.uri.path.startsWith('/sign-in') ||
          state.uri.path.startsWith('/sign-up');

      if (isAuthenticated && isOnAuth) return '/home';
      if (!isAuthenticated && !isOnAuth) return '/sign-in';
      return null;
    },
    routes: [
      GoRoute(path: '/sign-in', builder: (_, __) => const SignInPage()),
      GoRoute(path: '/sign-up', builder: (_, __) => const SignUpPage()),
      GoRoute(path: '/home', builder: (_, __) => const HomePage()),
    ],
  );
});

// Test use case with a mock repository
void main() {
  group('SignInUsecase', () {
    late MockAuthRepository mockRepository;
    late SignInUsecase usecase;

    setUp(() {
      mockRepository = MockAuthRepository();
      usecase = SignInUsecase(repository: mockRepository);
    });

    test('returns UserEntity on success', () async {
      when(() => mockRepository.signIn(email: any, password: any))
          .thenAnswer((_) async => Right(testUser));

      final result = await usecase(email: 'test@test.com', password: 'pass');

      expect(result, Right(testUser));
    });
  });
}