Bubble up errors with .future but still continue running rest of provider initializer

[triallax]

This problem has been driving me insane for weeks, so I'd appreciate any help on it.

Use case: to simplify things a bit, I have a FutureProvider.family<Weather>, and another provider that uses that provider but changes the weather's unit system (metric/imperial) based on user preference. Something like:

final weatherProvider = FutureProvider((ref) => ...);

final weatherWithUnitSystemProvider = FutureProvider((ref) async {
  return (await ref.watch(weatherProvider.future)).changeUnitSystem(ref.watch(unitSystemProvider));
});

However, the problem here is that if weatherProvider is refreshed with ref.refresh(weatherProvider) and produces an error, and the unit system is changed, then weatherWithUnitSystemProvider will not correctly update the weather with the new unit system.

In a nutshell, what I'm wondering is if there's a sane way to make .future set the error field in weatherWithUnitSystemProvider's AsyncData state, but if weatherProvider has a previous value, then complete the future with that value instead of throwing the error. That way, the error is propagated to weatherWithUnitSystemProvider, but the unit system still gets updated correctly.

[rrousselGit]

To begin with, you shouldn't modify other states inside providers when a provider is initializing.
So you shouldn't call changeUnitSystem in weatherWithUnitSystemProvider as you're modifying weatherProvider while weatherWithUnitSystemProvider is initializing.

You probably want to move that logic to weatherProvider:

final weatherProvider = FutureProvider((ref) async {
  ...

  weather.changeUnitSystem(ref.watch(unitSystemProvider));

  return weather;
});

[snapsl]

The method name is somewhat misleading, the weather object is immutable and cannot be modified. changeUnitSystem returns a new weather object with the updated unit system (hence why its result is returned from weatherWithUnitSystemProvider's initializer).

There seems to be some confusion between the state and its notifier. The notifier is used to modify the state. The state should not have a method to modify its state.

[triallax]

Again, the state object is immutable and cannot be modified, and also I haven't mentioned anything about any notifiers in my post. Or am I misunderstanding you?

[snapsl]

I am referring to the concept of NotifierProvider. The immutable class used as state does not have a function to modify itself. Instead the notifier is used to modify the state.

e.g.

final state = ref.watch(provider); // get state
ref.read(provider.notifier).modfun(); // function to modify the state

[triallax]

I already understand that, but why is it relevant? I'm very confused here.

[snapsl]

Try to implement the weatherProvider as AsyncNotifierProvider. Create a method changeUnitSystem() to update its state.

[snapsl]

I am not sure if I get your question correctly.

Maybe you could listen to state changes in unitSystemProvider, like

final weatherProvider = FutureProvider((ref) => null);

final weatherWithUnitSystemProvider = FutureProvider<??>((ref) async {
  final weather = await ref.watch(weatherProvider.future);
  ref.listen(
    unitSystemProvider,
    (_, newState) {
      ref.state = weather.changeUnitSystem(newState);
    },
    fireImmediately: true,
  );
  return ??;
});

[snapsl]

Furthermore, could you clarify on the following:

to simplify things a bit, I have a FutureProvider.family, and another provider that uses that provider but changes the weather's unit system (metric/imperial) based on user preference.

Your example does not show any family.

In a nutshell, what I'm wondering is if there's a sane way to make .future set the error field in weatherWithUnitSystemProvider's AsyncData state, but if weatherProvider has a previous value, then complete the future with that value instead of throwing the error. That way, the error is propagated to weatherWithUnitSystemProvider, but the unit system still gets updated correctly.

When would this happen and why would you want that?