Fix/async memoizer storing exception

CHANGELOG.md

@@ -1,6 +1,6 @@
 ## 2.12.0-wip
-
-- Require Dart 3.4
+* Can decide `runOnce` method of `AsyncMemoizer` will store exception or not.
+* Require Dart 3.4
 
 ## 2.11.0
 

lib/src/async_memoizer.dart

@@ -5,7 +5,9 @@
 import 'dart:async';
 
 /// A class for running an asynchronous function exactly once and caching its
-/// result.
+/// result. If you doesn't want to cache Exception then you can set
+/// [_canCacheException] to false.
+///
 ///
 /// An `AsyncMemoizer` is used when some function may be run multiple times in
 /// order to get its result, but it only actually needs to be run once for its
@@ -27,6 +29,9 @@ import 'dart:async';
 /// }
 /// ```
 class AsyncMemoizer<T> {
+ AsyncMemoizer({bool canCacheException = true}):
+ _canCacheException = canCacheException;
+
  /// The future containing the method's result.
  ///
  /// This can be accessed at any time, and will fire once [runOnce] is called.
@@ -36,11 +41,28 @@ class AsyncMemoizer<T> {
  /// Whether [runOnce] has been called yet.
  bool get hasRun => _completer.isCompleted;
 
+ ///Default is set to true.
+ ///If we set this variable to false.
+ ///On the initial run, if callback returned the [Exception].
+ ///Next time, we can reRun the callback for the successful attempt.
+ final bool _canCacheException;
+
  /// Runs the function, [computation], if it hasn't been run before.
  ///
  /// If [runOnce] has already been called, this returns the original result.
- Future<T> runOnce(FutureOr<T> Function() computation) {
- if (!hasRun) _completer.complete(Future.sync(computation));
+ Future<T> runOnce(FutureOr<T> Function() computation) async {
+ if (!hasRun) {
+ if (_canCacheException) {
+ _completer.complete(Future.sync(computation));
+ } else {
+ try {
+ var value = await computation();
+ _completer.complete(value);
+ } catch (error) {
+ rethrow;
+ }
+ }
+ }
  return future;
  }
 }

test/async_memoizer_test.dart

@@ -9,6 +9,14 @@ void main() {
  late AsyncMemoizer cache;
  setUp(() => cache = AsyncMemoizer());
 
+ test('should not store exception when callback throws exception', () async {
+ Future<String> asyncFunctionThatThrows() {
+ throw Exception();
+ }
+ var cacheFuture = cache.runOnce(asyncFunctionThatThrows);
+ await expectLater(cacheFuture,throwsA(isException));
+ });
+
  test('runs the function only the first time runOnce() is called', () async {
  var count = 0;
  expect(await cache.runOnce(() => count++), equals(0));