fix: resolve bugs found by testing suite

Co-authored-by: MasterMarcoHD <MasterMarcoHD@users.noreply.github.com>

Author: mcquenji

lib/src/cache/infra/services/default_cache_pipeline_service.dart

@@ -31,48 +31,74 @@ class DefaultCachePipelineService extends CachePipelineService {
     required CachePolicy<Serialized> policy,
     SerializationCodec<T, Serialized>? codec,
   }) async {
-    CacheEntry<T>? fileEntry;
+    final layers =
+        <
+          ({
+            CacheSource source,
+            int priority,
+            Future<CacheEntry<T>?> Function() read,
+            Future<void> Function(CacheEntry<T> entry) write,
+          })
+        >[];
 
     if (policy.useMemory && _memoryLayer != null) {
-      try {
-        final memoryEntry = await _memoryLayer.read<T, Serialized>(
-          key,
-          codec: codec,
-        );
-        if (memoryEntry != null) {
-          return CacheResult<T>(
-            value: memoryEntry.value,
-            source: CacheSource.memory,
-            isStale: false,
-          );
-        }
-      } catch (e) {
-        if (policy.strictLayerErrors) rethrow;
-        log('Memory layer read failed for ${key.asStorageKey()}', e);
-      }
+      layers.add((
+        source: CacheSource.memory,
+        priority: _memoryLayer.priority,
+        read: () => _memoryLayer.read<T, Serialized>(key, codec: codec),
+        write: (entry) =>
+            _memoryLayer.write<T, Serialized>(key, entry, codec: codec),
+      ));
     }
 
     if (policy.useFile && _fileLayer != null) {
+      layers.add((
+        source: CacheSource.file,
+        priority: _fileLayer.priority,
+        read: () => _fileLayer.read<T, Serialized>(key, codec: codec),
+        write: (entry) =>
+            _fileLayer.write<T, Serialized>(key, entry, codec: codec),
+      ));
+    }
+
+    layers.sort((a, b) => a.priority.compareTo(b.priority));
+
+    for (final layer in layers) {
+      CacheEntry<T>? entry;
       try {
-        fileEntry = await _fileLayer.read<T, Serialized>(key, codec: codec);
+        entry = await layer.read();
       } catch (e) {
         if (policy.strictLayerErrors) rethrow;
-        log('File layer read failed for ${key.asStorageKey()}', e);
+        log(
+          '${layer.source == CacheSource.memory ? 'Memory' : 'File'} layer read failed for ${key.asStorageKey()}',
+          e,
+        );
+        continue;
       }
 
-      if (fileEntry != null) {
-        if (policy.backfillHigherLayers &&
-            policy.useMemory &&
-            _memoryLayer != null) {
-          await _memoryLayer.write<T, Serialized>(key, fileEntry, codec: codec);
+      if (entry == null) continue;
+
+      if (policy.backfillHigherLayers) {
+        for (final higherLayer in layers) {
+          if (higherLayer.priority >= layer.priority) continue;
+
+          try {
+            await higherLayer.write(entry);
+          } catch (e) {
+            if (policy.strictLayerErrors) rethrow;
+            log(
+              '${higherLayer.source == CacheSource.memory ? 'Memory' : 'File'} layer backfill failed for ${key.asStorageKey()}',
+              e,
+            );
+          }
         }
-
-        return CacheResult<T>(
-          value: fileEntry.value,
-          source: CacheSource.file,
-          isStale: fileEntry.isExpired,
-        );
       }
+
+      return CacheResult<T>(
+        value: entry.value,
+        source: layer.source,
+        isStale: layer.source == CacheSource.file ? entry.isExpired : false,
+      );
     }
 
     return null;

lib/src/module/module.dart

@@ -50,6 +50,21 @@ abstract class Module<RouteType, Config extends Object>
   final Set<LifecycleMixin> _activeInjectableSet = {};
   final Set<LifecycleMixin> _initializedInjectables = {};
 
+  /// `true` if the module is active and ready to serve its functionality.
+  bool get isActive => _isActive;
+
+  /// `true` if the module is in the process of initializing.
+  bool get isInitializing => _isInitializing;
+
+  /// `true` if the module is in the process of activating.
+  bool get isActivating => _isActivating;
+
+  /// `true` if the module has been disposed and should no longer be used.
+  bool get isDisposed => _disposed;
+
+  /// `true` if the module is active and not in the process of initializing or activating.
+  bool get isReady => isActive && !isInitializing && !isActivating;
+
   /// Override this getter to declare module dependencies.
   ///
   /// Dependency mounting and activation are orchestrated by
@@ -135,11 +150,47 @@ abstract class Module<RouteType, Config extends Object>
           _activeRepos.add(repo);
         }
       }
+      _isActive = true;
+    } catch (e, s) {
+      await _rollbackFailedActivation(e, s);
+      rethrow;
     } finally {
       _isActivating = false;
     }
+  }
+
+  Future<void> _rollbackFailedActivation(Object error, StackTrace stack) async {
+    log(
+      'Activation failed. Rolling back activated dependencies.',
+      error,
+      stack,
+    );
+
+    for (final repo in _activeRepos.reversed) {
+      try {
+        await repo.deactivate();
+      } catch (e, s) {
+        log('Rollback deactivate failed for repo ${repo.runtimeType}', e, s);
+      }
+    }
+    _activeRepos.clear();
+    _activeRepoSet.clear();
+
+    for (final injectable in _activeInjectables.reversed) {
+      try {
+        await injectable.deactivate();
+      } catch (e, s) {
+        log(
+          'Rollback deactivate failed for injectable ${injectable.runtimeType}',
+          e,
+          s,
+        );
+      }
+    }
+    _activeInjectables.clear();
+    _activeInjectableSet.clear();
 
-    _isActive = true;
+    _isActive = false;
   }
 
   @mustCallSuper

lib/src/persistence/mixins/persistent_repo_state_mixin.dart

@@ -71,6 +71,9 @@ mixin PersistentRepoStateMixin<T, Serialized extends Object>
       if (!persistencePolicy.enabled || !persistencePolicy.persistOnData) {
         return;
       }
+      if (!persistencePolicy.saveNullData && value == null) {
+        return;
+      }
 
       _persistDebounce?.cancel();
       _persistDebounce = Timer(persistencePolicy.persistDebounce, () async {
@@ -107,6 +110,10 @@ mixin PersistentRepoStateMixin<T, Serialized extends Object>
   }
 
   Future<void> _saveSnapshot(T value) async {
+    if (!persistencePolicy.saveNullData && value == null) {
+      return;
+    }
+
     final now = DateTime.now();
     await RepoStatePersistenceService().save<T, Serialized>(
       snapshotKey,

lib/src/repo/mixins/use_repo_mixin.dart

@@ -9,9 +9,10 @@ import 'package:grumpy/grumpy.dart';
 mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
   final _subs = <StreamSubscription>[];
   final _watchedRepos = <Type, Repo>{};
+  final _pendingRepoResolutions = <Type, Future<Repo<dynamic>>>{};
 
   bool _installed = false;
-  bool _handlingStateChange = false;
+  int _stateChangeVersion = 0;
 
   D? _lastData;
   E? _lastError;
@@ -21,22 +22,27 @@ mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
     log(
       'Detected state change in dependencies (${changedRepo.runtimeType}). Re-evaluating...',
     );
+    final version = ++_stateChangeVersion;
+    await _rebuildDependencyState(version);
+  }
 
-    if (_handlingStateChange) return;
-    _handlingStateChange = true;
-    bool anyLoading = false;
+  Future<void> _rebuildDependencyState(int version) async {
+    var anyLoading = false;
     RepoErrorState? firstError;
 
+    D? nextData = _lastData;
+    E? nextError = _lastError;
+    L? nextLoading = _lastLoading;
+
     for (final repo in _watchedRepos.values) {
       if (repo.state.hasError) {
         log(
           'Dependency of type ${repo.runtimeType} has error. Rebuilding error state...',
         );
-        final errorState = repo.state.asError;
-
-        firstError = errorState;
+        firstError = repo.state.asError;
         break;
-      } else if (repo.state.isLoading) {
+      }
+      if (repo.state.isLoading) {
         log(
           'Dependency of type ${repo.runtimeType} is loading. Rebuilding loading state...',
         );
@@ -46,32 +52,49 @@ mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
 
     final allDataReady = !anyLoading && firstError == null;
 
-    _lastError = firstError != null
-        ? await onDependencyError(firstError.error, firstError.stackTrace)
-        : null;
-    _lastLoading = anyLoading ? onDependenciesLoading() : null;
-
     try {
-      if (allDataReady) log('All dependencies are ready. Rebuilding data...');
-      _lastData = allDataReady ? await onDependenciesReady() : null;
-      if (allDataReady) log('Dependencies ready, obtained new data.');
+      if (firstError != null) {
+        nextError = await onDependencyError(
+          firstError.error,
+          firstError.stackTrace,
+        );
+        nextLoading = null;
+        nextData = null;
+      } else if (anyLoading) {
+        nextError = null;
+        nextLoading = onDependenciesLoading();
+        nextData = null;
+      } else if (allDataReady) {
+        log('All dependencies are ready. Rebuilding data...');
+        nextError = null;
+        nextLoading = null;
+        nextData = await onDependenciesReady();
+        log('Dependencies ready, obtained new data.');
+      }
     } on NoRepoDataError catch (e, st) {
       if (e.state.isLoading) {
-        _lastLoading = onDependenciesLoading();
-        _lastData = null;
+        nextError = null;
+        nextLoading = onDependenciesLoading();
+        nextData = null;
       } else {
-        _lastError = await onDependencyError(e, st);
-        _lastData = null;
+        nextError = await onDependencyError(e, st);
+        nextLoading = null;
+        nextData = null;
       }
     } catch (e, st) {
-      _lastError = await onDependencyError(e, st);
-      _lastData = null;
+      nextError = await onDependencyError(e, st);
+      nextLoading = null;
+      nextData = null;
     }
 
+    if (version != _stateChangeVersion) return;
+
+    _lastData = nextData;
+    _lastError = nextError;
+    _lastLoading = nextLoading;
+
     log('State rebuilt, notifying listeners...');
     await dependenciesChanged();
-
-    _handlingStateChange = false;
   }
 
   Future<void> _discover() async {
@@ -142,17 +165,41 @@ mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
       return (repo.state.requireData, repo);
     }
 
-    final repo = await GetIt.I.getAsync<R>();
+    final pending = _pendingRepoResolutions[R];
+    if (pending != null) {
+      final repo = await pending as R;
+      return (repo.state.requireData, repo);
+    }
 
-    log('Discovered new dependency. Now watching repo of type $R');
+    final resolveAndWatch = (() async {
+      final repo = await GetIt.I.getAsync<R>();
+      if (_watchedRepos.containsKey(R)) {
+        return _watchedRepos[R] as R;
+      }
 
-    _watchedRepos[R] = repo;
+      log('Discovered new dependency. Now watching repo of type $R');
+      _watchedRepos[R] = repo;
 
-    final sub = repo.stream.listen((_) async {
-      await _onWatchedRepoStateChange(repo);
-    });
+      var ignoredInitialReplay = false;
+      final sub = repo.stream.listen((_) async {
+        if (!ignoredInitialReplay) {
+          ignoredInitialReplay = true;
+          return;
+        }
+        await _onWatchedRepoStateChange(repo);
+      });
+
+      _subs.add(sub);
+      return repo;
+    })();
 
-    _subs.add(sub);
+    _pendingRepoResolutions[R] = resolveAndWatch;
+    late final R repo;
+    try {
+      repo = await resolveAndWatch;
+    } finally {
+      await _pendingRepoResolutions.remove(R);
+    }
 
     return (repo.state.requireData, repo);
   }

lib/src/routing/infra/services/routing_kit_routing_service.dart

@@ -43,9 +43,13 @@ class RoutingKitRoutingService<T, Config extends Object>
   RouteContext? get currentContext => _context;
 
   @override
-  FutureOr<void> free() {
-    super.free();
+  FutureOr<void> free() async {
+    await super.free();
     _listeners.clear();
+    _pendingNavigations.clear();
+    if (!_viewChangeController.isClosed) {
+      await _viewChangeController.close();
+    }
   }
 
   @override
@@ -81,8 +85,8 @@ class RoutingKitRoutingService<T, Config extends Object>
     _context = null;
     _listeners.clear();
     _moduleCache.clear();
+    _pendingNavigations.clear();
     await moduleRegistry.sync(<Module<T, Config>>[]);
-    await _viewChangeController.close();
   }
 
   @override
@@ -359,7 +363,7 @@ class RoutingKitRoutingService<T, Config extends Object>
 
   @override
   Stream<ViewChangedEvent<T, Config>> get viewStream =>
-      _viewChangeController.stream.asBroadcastStream();
+      _viewChangeController.stream;
 
   @override
   Future<void> get currentNavigation => _currentNavigation;