The correct way to update combined providers

[saccho]

Overview

There are four FutureProviders or AsyncNotifierProviders that serve as sources (typically caching the results of API calls).

// source providers

@riverpod
Future<String> id(Ref ref) async {
  print('called id');
  await Future.delayed(const Duration(seconds: 1));
  return 'id';
}

@riverpod
Future<String> future1(Ref ref, String id) async {
  print('called future1');
  await Future.delayed(const Duration(seconds: 1));
  final i = Random().nextInt(10);
  return 'future$i';
}

@riverpod
Future<String> future2(Ref ref, String id) async {
  print('called future2');
  await Future.delayed(const Duration(seconds: 2));
  final i = Random().nextInt(10);
  return 'future$i';
}

@riverpod
class Future3State extends _$Future3State {
  @override
  Future<String> build(String id) async {
    print('called future3');
    await Future.delayed(const Duration(seconds: 3));
    final i = Random().nextInt(10);
    return 'future$i';
  }

  Future<void> someUpdate() async {
    await Future.delayed(const Duration(seconds: 3));
    ref.invalidateSelf();
  }
}

When there is a FutureProvider that combines sources, please tell me the correct way to update this combined FutureProvider.

// combined providers

@riverpod
Future<(String, String)> combined1(Ref ref) async {
  print('called combined1');
  final id = await ref.watch(idProvider.future);
  final f1 = await ref.watch(future1Provider(id).future);
  final f2 = await ref.watch(future2Provider(id).future);
  return (f1, f2);
}

@riverpod
Future<(String, String)> combined2(Ref ref) async {
  print('called combined2');
  final id = await ref.watch(idProvider.future);
  final f2 = await ref.watch(future2Provider(id).future);
  final f3 = await ref.watch(future3StateProvider(id).future);
  return (f2, f3);
}

What I Tried

I simply attempted to invalidate or invalidateSelf the sources, but it seems that each source is built twice.

// refresher

@riverpod
RefreshCombined refreshCombined(Ref ref) => RefreshCombined(ref);

class RefreshCombined {
  const RefreshCombined(this._ref);

  final Ref _ref;

  Future<void> call() async {
    final id = await _ref.read(idProvider.future);
    await _ref.read(future3StateProvider(id).notifier).someUpdate();
    _ref.invalidate(future1Provider(id));
    _ref.invalidate(future2Provider(id));
  }
}

...
I/flutter (14969): called future3
I/flutter (14969): called future1
I/flutter (14969): called combined2
I/flutter (14969): called combined1
I/flutter (14969): called future2
I/flutter (14969): called future1
I/flutter (14969): called future3
...

Expected

When updating, each source should be built only once (preventing the same API call from being made twice), and the combined FutureProvider should also be updated.

---

Full source code is here: https://github.com/saccho/refresh_combined_demo