Async executor of queue with methods that changing providers state using result of http requests

[pol9kov]

I have many Riverpod providers that need async HTTP requests. Providers make local changes and apply them to the state, then do remote request and apply result to the state. I want to put these requests in order and if one request fails, the next request should not execute before the failed request succeeds. In other words, I need an async queue of methods with requests and changing providers' states. So I created an AsyncNotifierProvider FutureExecutor with Queue<Future Function(AsyncNotifierProviderRef ref)> that will execute methods. I use the ref of the provider that adds the first element in the queue. But I am wondering about circular dependency. Because of implicit dependencies, I tested this solution and have not had any errors yet, but I suppose there will be a case when the provider that adds the first element and executes other methods in the queue will call the notifier of the other provider that is dependent on the first one.

@riverpod
FutureExecutor futureExecutor(FutureExecutorRef ref) {
  return FutureExecutor(Queue<Future<void> Function(AsyncNotifierProviderRef ref)>.from([]));
}

class FutureExecutor {
  final Queue<Future<void> Function(AsyncNotifierProviderRef ref)> queue;

  FutureExecutor(this.queue);

  add(AsyncNotifierProviderRef ref, Future<void> Function(AsyncNotifierProviderRef ref) function) {
    queue.addLast(function);

    if (queue.length == 1) {
      asyncExecute(ref);
    }
  }

  asyncExecute(AsyncNotifierProviderRef ref) async {
    while (queue.isNotEmpty) {
      try {
        await queue.first(ref);

        queue.removeFirst();
      } catch (e, stacktrace) {
        ref.read(errorProvider.notifier).setError("FutureExecutor.asyncExecute", e, stacktrace);
        return;
      }
    }
  }
}

[pol9kov]

import 'dart:async';
import 'dart:collection';

import 'package:dreamteam/src/app/datasource/error.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'future_functions.g.dart';

@Riverpod(keepAlive: true)
FutureFunctions futureFunctions(FutureFunctionsRef ref) {
  return FutureFunctions(ref);
}

class FutureFunctions {
  final Queue<Future Function()> queue = Queue<Future Function()>.from([]);

  final FutureFunctionsRef ref;

  FutureFunctions(this.ref);

  void add(Future Function() futureFunction) {
    if (queue.isNotEmpty) {
      queue.addLast(futureFunction);
      return;
    }

    queue.addLast(futureFunction);
    asyncExecute();
  }

  Future asyncExecute() async {
    while (queue.isNotEmpty) {
      final handler = queue.first;
      try {
        await handler();
        queue.removeFirst();
      } catch (error, stackTrace) {
        await ref.read(errorProvider.notifier).setError("FutureFunctions.asyncExecute", error: error, stackTrace: stackTrace);
        break;
      }
    }
  }

  Future repeatFailedExecution() async {
    final handler = queue.first;
    try {
      await handler();
      queue.removeFirst();

      ref.invalidate(errorProvider);
    } catch (error, stackTrace) {
      await ref.read(errorProvider.notifier).setError("FutureFunctions.repeatFailedExecution", error: error, stackTrace: stackTrace);
      return;
    }

    asyncExecute();
  }
}