Modelling reusable CRUD with Riverpod

[Moussenger]

Let's say we have the next requisites:

• A list of data loaded from the network
• You can update each item
• You can create new items
• Each time you create/update an item, you need to refresh the whole list.
• Each time you create/update/retrieve items, you need to show a fullscreen loader
• The list of data can be read from other screens or used by other providers in other places of the app.

How would you model that with Riverpod? The approach I found:

State Notifier provider approach:

final dataProvider = StateNotiferProvider<DataStateNotifier, AsyncValue<List<Item>>((ref) => DataStateNotifier());

class DataStateNotifier extends StateNotifier<AsyncValue<List<Item>>> {
  DataStateNotifier() : super(AsyncValue.loading()) {
    retrieveItems();
  }

  void retrieveItems() {
    _doAsyncAndRefresh()
  }

  void updateItem(Item item) {
   _doAsyncAndRefresh(() async => await updateItemFromNetwork(item));
  }

  void createItem(Item item) {
    _doAsyncAndRefresh(() async => await createItemFromNetwork(item));
  }

  Future<void> _doAsyncAndRefresh([Future Function()? action]) async {
    state = const AsyncValue.loading();
    await action?.();
    state = await AsyncValue.guard(() async => await _retrieveDataFromNetwork());
}

Problems I found in this approach: How to read this provider in another one that wants to await until AsyncValue is AsyncData to continue processing? I.e.

final filteredItemsProvider = FutureProvider<List<Item>>((ref) async {
  final items = await ref.watch(dataProvider); //HOW to await for this value??
  
  //filter items...
});

Am I in the right direction? Is there another better approach to model this?

EDIT:

Playing a little more with this, I realize that probably the problem I found regarding using it in a FutureProvider could be solved like this:

final filteredItemsProvider =Provider<AsyncValue<List<Item>>>((ref) async {
  return await ref.watch(dataProvider).whenData((items) {
    return filtterItems(items);
  }); 
});

I think that is the right approach in this case. Still interested to know if the original question about how to face the whole problem is valid and good practice.