Flutter Bloc/Cubit Error Handling - what is the best architectural approach?-CodePudding

I'm a beginner developer and I have problem with implementation of BloC framework. Let's assume that I have this code (Model, NetworkService, Repository, Cubit, State, Widget):

class NetworkService {

  Future getData(Uri uri) async {
    try {
      http.Response httpsResponse = await http.get(
        uri,
        headers: {
          // some headers //
        },
      );
      if (httpsResponse.statusCode == 200) {
        return httpsResponse.body;
      } else {
        throw 'Request failed with status: ${httpsResponse.statusCode}';
      }
    } catch (e) {
      // What I shloud return here?
      return e.toString();
    }
  }

  Future<List<dynamic>> fetchData() async {
    final uri = Uri.parse('some url');
    var data = await getData(uri);
    return = jsonDecode(data) as List;
  }
}

class Repository {
  final NetworkService networkService = NetworkService();

  Future<List<SomeObject>> fetchDataList() async {
    final dataRaw =
        await networkService.fetchDataList();

    return dataRaw.map((e) => SomeObject.fromJson(e)).toList();
  }
}

class SomeCubit extends Cubit<CubitState> {
  final Repository repository;

  SomeCubit(this.repository) : super(LoadingState()) {
    fetchDataList();
  }

  void fetchDataList() {
    try {
      repository
          .fetchDataList()
          .then((dataList) => emit(LoadedState(dataList)));
    } catch (e) {
      // What I shloud return here?
      emit(ErrorState(e.toString()));
    }
  }
}

How to make this code "bullet proof" because I don't know how to "pass" error from NetworkService to Cubit? It works fine till I have dynamic responses in functions but in Repository class I want to return List of specific objects and when function fail I will return null. If I write try/catch I have to provide return statement in catch block - and I can't return List. I want to return some kind of Error...

CodePudding user response：

I suggest that you use the excellent class named Either from the dartz package. It will allow you to return X if things went bad, and return Y if all is well, as such: Future<Either<X, Y>>

Then you can check on your variable (e.g. result) as follows: result.isLeft() for error, or do result.fold( ... ) to easily handle the return type (error or success).

In your particular case you could do as follows when returning from the repository to the cubit:

Future<Either<RepositoryError, List<SomeObject>>> fetchDataList() async { ... }

Where RepositoryError could be a class containing information about the type of error.

So in the cubit you do:

final result = await repository.fetchDataList();
emit(
  result.fold(
    (error) => ErrorState(error),
    (dataList) => LoadedState(dataList)
  )
);

Then you continue with this pattern all the way to NetworkService getData(). Either with the same common "error class" in the Repository and the NetworkService, or separate ones in the different layers and you "translate" between different "error classes". Perhaps it makes sense to have a NetworkServiceError that is returned there..

In your NetworkService you could do as follows:

Future<Either<NetworkServiceError, String>> getData(Uri uri) async { ... }

Future<Either<NetworkServiceError, List<dynamic>>> fetchData() async { ... }

This will give you great flexibility and passing of information from the service, to the repository and to the cubit.

CodePudding user response：

You can let exceptions propagate through Futures from NetworkService up to the cubit, by removing the try/catch from getData.