best practice for updating state in AsyncNotifier class

[mafreud]

Hi!
Different from Notifier, AsyncNotifier class holds AsyncValue state.
In this situation, what is the best practice for updating AsyncNotifier's state?

1. state.when()

  Future<void> updateState(
    dynamic value,
  ) async {
    state.when(
      data: (previousState) {
        return state = AsyncValue.data(
          previousState.copyWith(sampleField: value),
        );
      },
      error: (error, stackTrace) => AsyncValue.error(error, stackTrace),
      loading: () => const AsyncValue.loading(),
    );
  }

2. AsyncGuard

  Future<void> updateState(
    dynamic value,
  ) async {
    // I do not like this null check.
    final previousState = state.asData!.value;
    final newState = previousState.copyWith(sampleFiled: value);
    state = const AsyncValue.loading();
    state = await AsyncValue.guard(() async {
      return newModel;
    });
  }

3. update
   // this does not handle error.

  Future<void> updateState(dynamic value) async {
    await update(
      (previousState) {
        final newState = previousState.copyWith(sampleField: value);
        return newState;
      },
    );
  }

Thank you.

[AhmedLSayed9]

• state.when: can be used to update state only if current state is something (i.e you can ignore updating if current state is loading/error). Btw, In your sample loading/error flags do nothing beside just returning current error/loading.

• update: close to state.when but if current state is loading, the update will be awaited and called if data is emitted later. If current state is error, the callback will not be invoked (onError can be used to handle if current state is error).

Note: Both state.when & update don't try/catch errors and typically used when your update is sync. If your update is async and does throw errors, that's when AsyncGuard is preferred.

[mafreud]

All right.
but how do you handle null check of asData when using AsyncGuard?

  Future<void> updateState(
    dynamic value,
  ) async {
    // I do not like this null check.
    final previousState = state.asData!.value;
    final newState = previousState.copyWith(sampleFiled: value);
    state = const AsyncValue.loading();
    state = await AsyncValue.guard(() async {
      return newModel;
    });
  }

[AhmedLSayed9]

If you want to perform update only if you've value, you can do:

final previousValue = state.valueOrNull;
if(previousValue != null){
   ...
}

[mafreud]

Cool. Thank you. 😸

[yknevenky]

• state.when: can be used to update state only if current state is something (i.e you can ignore updating if current state is loading/error). Btw, In your sample loading/error flags do nothing beside just returning current error/loading.
• update: close to state.when but if current state is loading, the update will be awaited and called if data is emitted later. If current state is error, the callback will not be invoked (onError can be used to handle if current state is error).

Note: Both state.when & update don't try/catch errors and typically used when your update is sync. If your update is async and does throw errors, that's when AsyncGuard is preferred.

How to update the partially using AsyncGuard?

I am trying to update the state of a FamilyAsyncNotifier partially, I just want to know whether I am doing it right, if not how I can do it using AsyncGuard. Also in this case of updating a asyncvalue partially, I want to know what's differences in using whenData, AsyncGuard.value and update method . It would be a immense help, if you provide some clarity on this.

Example

The state here is a freezed class and looks something like this

College(
name: "",
students: [],
faculties: [],
departments: []
)

All the above properties are not updated in a one go, for example the below code tries to update the students property while retaining the other values to its previous value.

update((state) async {
      List<Student> students =
          await getStudentsByCollegeId(id: this.arg);
      return state.copyWith(students: students);
});

Am I doing it right or it needs correction.

[SiddiquiMonis401]

May be a little late here .. But I just want to know how I can have different states for different API calls inside a single AsyncNotifier provider ?

[fenrirx22]

I assume that you meant a situation when you actually have multiple different objects that are updated by different api calls in one AsyncNotifier right? Are they related to each other somehow? Maybe they can be separated into different AsyncNotifiers?
Also you can keep AsyncValue<YourState> as a type in your whole view State object for each object that is fetched separately and expose them by using simple Notifier. This way UI should be able to do something like ref.read(viewNotifierProvider.notifier).viewState.data1State.when... and ref.read(viewNotifierProvider.notifier).viewState.data2State.when...
but this also introduce the complexity of managing those two data sources when you want to somehow synchronise them.

[SiddiquiMonis401]

No the data source for multiple objects is same. Actually, I have a user's profile API that returns multiple sections of the user profile in a single call. Now, those sections can be updated individually. For say, I can update user language, user education and etc. Those update calls return me the updated object against a specific ID now we just want to make sure after every update/add instead of making 2 calls one for mutation and one for reflecting new data changes on user profile screen. We should fetch the data on initial render and subsequent mutations call data should be appended, deleted or updated in the initially load data.
I also have come with your approach which is like so,
Make a Get call to get the user data as user visits the profile screen for the first time during his current session in app.
Create another Notifier provider which holds the state of type ProfileData.
Inside the futureProvider, if the call is made successful set the state in the Notifier provider.
From the AsyncNotifier functions call the update functions in Notifier to update individual sections of profile.
This includes complexity of managing the state efficiently and making sure the local data is in sync with server. But making API call on every update is something client does not want.
Let me know, if there are gaps in my above proposed solution.
Thanks