Error Handling in BLoC: Flutter Best Practices

abstract class UserState {
  const UserState();
}

class UserLoadInProgress extends UserState {}
class UserLoadSuccess extends UserState {}
class UserLoadFailure extends UserState {
  final String message;
  final ErrorType type;

  UserLoadFailure({required this.message, required this.type});
}

sealed class ErrorType {
  const ErrorType();
}

class NetworkError extends ErrorType {}
class ValidationError extends ErrorType {}
class ServerError extends ErrorType {}

class UserBloc extends Bloc<UserEvent, UserState> {
  UserBloc() : super(UserInitial()) {
    on<FetchUserData>((event, emit) async {
      try {
        emit(UserLoadInProgress());
        final userData = await userRepository.fetchUser(event.userId);
        emit(UserLoadSuccess(user: userData));
      } catch (e) {
        emit(UserLoadFailure(
          message: _getErrorMessage(e),
          type: _getErrorType(e),
        ));
      }
    });
  }
}

EventTransformer<E> errorTransformer<E>() {
  return (events, mapper) {
    return events.asyncExpand((event) async* {
      try {
        yield* mapper(event);
      } catch (e, stackTrace) {
        log('Error occurred', error: e, stackTrace: stackTrace);
        yield* Stream.error(e, stackTrace);
      }
    });
  };
}

class ErrorView extends StatelessWidget {
  final ErrorType type;
  final String message;
  final VoidCallback onRetry;

  const ErrorView({
    required this.type,
    required this.message,
    required this.onRetry,
  });

  @override
  Widget build(BuildContext context) {
    return Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          Text(message),
          ElevatedButton(
            onPressed: onRetry,
            child: Text('Retry'),
          ),
        ],
      ),
    );
  }
}

void main() {
  runZonedGuarded(
    () {
      BlocOverrides.runZoned(
        () => runApp(MyApp()),
        blocObserver: CustomBlocObserver(),
      );
    },
    (error, stackTrace) {
      // Log error to crash reporting service
      crashlytics.recordError(error, stackTrace);
    },
  );
}

blocTest<UserBloc, UserState>(
  'emits [UserLoadInProgress, UserLoadFailure] when loading fails',
  build: () => UserBloc(),
  act: (bloc) => bloc.add(FetchUserData()),
  expect: () => [
    UserLoadInProgress(),
    UserLoadFailure(
      message: 'Failed to load user data',
      type: NetworkError(),
    ),
  ],
);