Need advice: Is this a correct way to invalidate all providers using listen?

[thanhdatvo]

I invented a way to invalidate all providers.
Firstly, I create a _resetProvider

class GlobalProviderManager {
  static void subscribeToReset(StateProviderRef ref) {
    ref.listen(_resetProvider, (_, __) {
      ref.invalidateSelf();
    });
  }

  static void resetSubscribedProviders(ReadProvider read){
    read(_resetProvider.notifier).state = DateTime.now();
  }

  static final _resetProvider = StateProvider<DateTime?>((state) => null);
}

Then I make responseProvider subscribe to this provider

final StateProvider<Response> responseProvider = StateProvider<Response>((ref) {
    GlobalProviderManager.subscribeToReset(ref);
    return ref.watch(defaultResponse);
});

And when user logs out, I could reset responseProvider with this

GlobalProviderManager.resetSubscribedProviders(ref)

I want to hear your opinions on this approach.

Thanks,

[thanhdatvo]

@rrousselGit Could you please take some time to review my example and provide your feedback? It will help my team a lot.
Thank you!

[Trung15010802]

Why don't you just create a function and put all ref.invalidate(provider) you need into that funtion?

In my opinion, we usually depend on a token. So I will create a userProvider and watch it in every provider where I need it. This way, if my userProvider changes, all providers that depend on it will change as well

[thanhdatvo]

@Trung15010802
Thank you for your suggestion!
Your approach would certainly work if we knew the number of StateProviders at compile time.
However, in our case, we have multiple StateProviders created at runtime in various ways, so your suggestion isn’t dynamic enough for our needs.

[Ae-Mc]

Maybe it's possible to create a root provider that all providers will depend on? Like so:

import 'dart:math';
import 'package:riverpod_annotation/riverpod_annotation.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
part 'force_reload.g.dart';

@riverpod
class ForceReload extends _$ForceReload {
  bool _previous = true;

  @override
  bool build() => _previous = !_previous;
}

@riverpod
double providerA(Ref ref) {
  ref.watch(forceReloadProvider);
  return Random().nextDouble();
}

@riverpod
double providerB(Ref ref) {
  ref.watch(forceReloadProvider);
  return 1;
}

So, using ref.invalidate(forceReloadProvider) must invalidate all providerA and all providerB. If I'm wrong, please, correct me.