feat: move UseRepoMixin hooks to detecated record

Author: mcquenji

lib/src/cache/mixins/query_mixins.dart

@@ -5,7 +5,6 @@ import 'dart:typed_data';
 import 'package:fuzzy_bolt/fuzzy_bolt.dart';
 import 'package:get_it/get_it.dart';
 import 'package:grumpy_annotations/grumpy_annotations.dart';
-import 'package:memory_cache/memory_cache.dart';
 import 'package:meta/meta.dart';
 import 'package:grumpy/grumpy.dart';
 
@@ -42,8 +41,6 @@ mixin QueryMixin<T> on Repo<T>, RepoLifecycleHooksMixin<T>, TelemetryMixin {
 
   int _dataVersion = 0;
 
-  /// Legacy in-memory cache used when pipeline is unavailable.
-  final cache = MemoryCache();
   final Map<StorageKey, Future<Object?>> _inflight =
       <StorageKey, Future<Object?>>{};
 
@@ -106,29 +103,6 @@ mixin QueryMixin<T> on Repo<T>, RepoLifecycleHooksMixin<T>, TelemetryMixin {
 
     onData((_) {
       _dataVersion++;
-      if (invalidateCacheOnNewData) {
-        cache.invalidate();
-        log('Cache cleared due to new data. (v=$_dataVersion)');
-      }
-    });
-
-    onLoading(() {
-      if (invalidateCacheOnLoading) {
-        cache.invalidate();
-        log('Cache cleared due to loading state.');
-      }
-    });
-
-    onError((error, stackTrace) {
-      if (invalidateCacheOnError) {
-        cache.invalidate();
-        log('Cache cleared due to error: $error');
-      }
-    });
-
-    onDisposed(() {
-      cache.invalidate();
-      log('Cache cleared on dispose.');
     });
 
     _installed = true;

lib/src/repo/mixins/use_repo_mixin.dart

@@ -5,14 +5,23 @@ import 'package:grumpy_annotations/grumpy_annotations.dart';
 import 'package:meta/meta.dart';
 import 'package:grumpy/grumpy.dart';
 
+/// Provides use hooks for watching and accessing data within [UseRepoMixin._onDependenciesReady].
+typedef UseHooks = ({
+  /// A function that allows you to watch a [Repo] of type [R] managing data of type [S] and
+  /// returns a tuple containing the data from the repo and the repo itself.
+  ///
+  /// Throws a [NoRepoDataError] if the repo's state does not contain data.
+  Future<(S, R)> Function<S, R extends Repo<S>>() repo,
+});
+
 /// A mixin that provides functionality to watch and use multiple [Repo] instances.
 ///
 /// {@category repo}
-
 mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
   final _subs = <StreamSubscription>[];
   final _watchedRepos = <Type, Repo>{};
   final _pendingRepoResolutions = <Type, Future<Repo<dynamic>>>{};
+  final _watchedStreams = <Stream, StreamSubscription>{};
 
   bool _installed = false;
   int _stateChangeVersion = 0;
@@ -71,7 +80,7 @@ mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
         log('All dependencies are ready. Rebuilding data...');
         nextError = null;
         nextLoading = null;
-        nextData = await onDependenciesReady();
+        nextData = await _onDependenciesReady();
         log('Dependencies ready, obtained new data.');
       }
     } on NoRepoDataError catch (e, st) {
@@ -103,7 +112,7 @@ mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
   Future<void> _discover() async {
     log('Discovering dependencies...');
     try {
-      final result = await onDependenciesReady();
+      final result = await _onDependenciesReady();
 
       // if we already get data in the discovery phase, store it.
       _lastData = result;
@@ -116,6 +125,11 @@ mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
       _lastError = await onDependencyError(e, st);
       // Ignore errors during the initial discovery phase.
       // we are just trying to discover repos here.
+    } finally {
+      log(
+        'Dependency discovery complete. Currently watching ${_watchedRepos.length} repos.',
+      );
+      await dependenciesChanged();
     }
   }
 
@@ -150,13 +164,17 @@ mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
       _subs.clear();
     });
     onDisposed(_watchedRepos.clear);
+    onDisposed(_watchedStreams.clear);
   }
 
   /// Watches a [Repo] of type [R] managing data of type [S] and
   /// returns a tuple containing the data from the repo and the repo itself.
   ///
   /// Throws a [NoRepoDataError] if the repo's state does not contain data.
-  Future<(S, R)> useRepo<S, R extends Repo<S>>() async {
+  @Deprecated('Use the provided use arg in onDependenciesReady instead')
+  Future<(S, R)> useRepo<S, R extends Repo<S>>() => _useRepo<S, R>();
+
+  Future<(S, R)> _useRepo<S, R extends Repo<S>>() async {
     if (!_installed) {
       throw StateError(
         'UseRepoMixin not installed. Call installUseRepoHooks in the constructor.',
@@ -180,7 +198,7 @@ mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
         return _watchedRepos[R] as R;
       }
 
-      log('Discovered new dependency. Now watching repo of type $R');
+      log('Discovered new dependency. Now watching ${repo.logTag}');
       _watchedRepos[R] = repo;
 
       var ignoredInitialReplay = false;
@@ -207,17 +225,19 @@ mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
     return (repo.state.requireData, repo);
   }
 
+  FutureOr<D> _onDependenciesReady() => onDependenciesReady((repo: _useRepo));
+
   /// A callback function that is called when all watched repositories are ready.
-  /// Call [useRepo] within this function to access repositories required to build the value.
+  /// Call [use.useRepo] within this function to access repositories required to build the value.
   ///
-  /// [onDependenciesReady] is called whenever any of the watched repositories emit a new state and *all* watched
+  /// [_onDependenciesReady] is called whenever any of the watched repositories emit a new state and *all* watched
   /// repositories have a state of [RepoDataState].
   ///
   /// If this function throws an exception, the error will be handled by [onDependencyError].
-  FutureOr<D> onDependenciesReady();
+  FutureOr<D> onDependenciesReady(UseHooks use);
 
   /// A callback function that is called when any of the watched repositories emit an error state
-  /// or when an exception is thrown during the execution of [onDependenciesReady].
+  /// or when an exception is thrown during the execution of [_onDependenciesReady].
   ///
   /// Takes precedence over [onDependenciesLoading].
   FutureOr<E> onDependencyError(Object error, StackTrace? stackTrace);
@@ -262,17 +282,6 @@ mixin UseRepoMixin<D, E, L> on LifecycleMixin, LifecycleHooksMixin {
   }
 }
 
-/// A typedef for [UseRepoMixin.useRepo].
-///
-/// **Example:**
-/// ```dart
-/// final (user, userRepo) = await useRepo<User, UserRepo>();
-/// ```
-///
-/// {@category repo}
-
-typedef UseRepo = Future<(T, R)> Function<T, R extends Repo<T>>();
-
 /// A mixin that provides a deferred repository implementation using [UseRepoMixin].
 ///
 /// The [DeferredRepoMixin] allows you to create a repository that builds its state
@@ -298,15 +307,15 @@ mixin DeferredRepoMixin<T> on Repo<T>, UseRepoMixin<void, void, void> {
 
   @mustCallSuper
   @override
-  FutureOr<void> onDependenciesReady() async {
-    final data = await build();
+  FutureOr<void> onDependenciesReady(UseHooks use) async {
+    final data = await build(use);
 
     this.data(data);
   }
 
   /// A builder function that constructs the state of this repo of type [T].
   ///
-  /// When implementing this method, you can call [useRepo] to access other repositories
+  /// When implementing this method, you can call [UseHooks.repo] to access other repositories
   /// that this repository depends on.
-  FutureOr<T> build();
+  FutureOr<T> build(UseHooks use);
 }

lib/src/telemetry/infra/services/noop_analytics_service.dart

@@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'package:grumpy/grumpy.dart';
 
 /// A no-operation implementation of [AnalyticsService].
@@ -9,10 +11,46 @@ class NoopAnalyticsService extends AnalyticsService {
   NoopAnalyticsService() : super.internal();
 
   @override
-  noSuchMethod(Invocation invocation) {
-    log('NoopAnalyticsService: ${invocation.memberName} called.');
+  String get logTag => 'NoopAnalyticsService';
+
+  @override
+  FutureOr<void> destroy() {}
+
+  @override
+  Future<void> groupUser(String groupId, {Map<String, dynamic>? traits}) async {
+    log('groupUser called.');
   }
 
   @override
-  String get logTag => 'NoopAnalyticsService';
+  Future<void> identifyUser(
+    String userId, {
+    Map<String, dynamic>? traits,
+  }) async {
+    log('identifyUser called.');
+  }
+
+  @override
+  Future<void> recordNavigation(
+    String from,
+    String to, {
+    Map<String, dynamic>? properties,
+  }) async {
+    log('recordNavigation called.');
+  }
+
+  @override
+  Future<void> recordPageView(
+    String pageName, {
+    Map<String, dynamic>? properties,
+  }) async {
+    log('recordPageView called.');
+  }
+
+  @override
+  Future<void> trackEvent(
+    String name, {
+    Map<String, dynamic>? properties,
+  }) async {
+    log('trackEvent called.');
+  }
 }

lib/src/telemetry/infra/services/noop_telemetry_service.dart

@@ -10,24 +10,44 @@ class NoopTelemetryService extends TelemetryService {
   /// A no-operation implementation of [TelemetryService].
   NoopTelemetryService() : super.internal();
 
-  @override
-  noSuchMethod(Invocation invocation) {
-    log('NoopTelemetryService: ${invocation.memberName} called.');
-  }
-
   @override
   Future<T> runSpan<T>(
     String name,
     FutureOr<T> Function() callback, {
     Map<String, dynamic>? attributes,
   }) async {
-    log(
-      'NoopTelemetryService: runSpan $name called with attributes: $attributes',
-    );
+    log('runSpan $name called with attributes: $attributes');
 
     return callback();
   }
 
   @override
   String get logTag => 'NoopTelemetryService';
+
+  @override
+  void addSpanAttribute(String key, String value) {
+    log('addSpanAttribute called with key: $key, value: $value');
+  }
+
+  @override
+  FutureOr<void> destroy() {}
+
+  @override
+  Future<void> recordEvent(
+    String name, {
+    Map<String, dynamic>? attributes,
+  }) async {
+    log('recordEvent called with name: $name, attributes: $attributes');
+  }
+
+  @override
+  Future<void> recordException(
+    Object error, [
+    StackTrace? stackTrace,
+    Map<String, dynamic>? attributes,
+  ]) async {
+    log(
+      'recordException called with error: $error, stackTrace: $stackTrace, attributes: $attributes',
+    );
+  }
 }

pubspec.yaml

@@ -15,7 +15,6 @@ dependencies:
       url: https://github.com/necodeIT/grumpy_annotations.git
   json_annotation: ^4.8.0
   logging: ^1.3.0
-  memory_cache: ^1.2.0
   meta: ^1.17.0
   routingkit: ^5.1.2
   rxdart: ^0.28.0
@@ -27,5 +26,3 @@ dev_dependencies:
 
   lints: ^6.0.0
   test: ^1.25.6
-
-

test/repo/harness/use_repo_mixin_test_harness.dart

@@ -19,9 +19,9 @@ class UseRepoConsumer
   Object? lastError;
 
   @override
-  FutureOr<String> onDependenciesReady() async {
-    final (count, _) = await useRepo<int, IntRepo>();
-    final (label, _) = await useRepo<String, StringRepo>();
+  FutureOr<String> onDependenciesReady(UseHooks use) async {
+    final (count, _) = await use.repo<int, IntRepo>();
+    final (label, _) = await use.repo<String, StringRepo>();
     return '$count-$label';
   }
 
@@ -59,10 +59,10 @@ class SlowSnapshotUseRepoConsumer
   final Completer<void> firstSnapshotCaptured = Completer<void>();
 
   @override
-  FutureOr<String> onDependenciesReady() async {
+  FutureOr<String> onDependenciesReady(UseHooks use) async {
     readyCalls++;
-    final (count, _) = await useRepo<int, IntRepo>();
-    final (label, _) = await useRepo<String, StringRepo>();
+    final (count, _) = await use.repo<int, IntRepo>();
+    final (label, _) = await use.repo<String, StringRepo>();
     final snapshot = '$count-$label';
     lastSnapshot = snapshot;
     if (!firstSnapshotCaptured.isCompleted) {
@@ -93,7 +93,7 @@ class UninitializedConsumer
         LifecycleHooksMixin,
         UseRepoMixin<void, void, void> {
   @override
-  FutureOr<void> onDependenciesReady() {}
+  FutureOr<void> onDependenciesReady(UseHooks use) {}
 
   @override
   FutureOr<void> onDependencyError(Object _, StackTrace? _) {}
@@ -117,9 +117,9 @@ class DeferredCombinedRepo extends Repo<String>
   }
 
   @override
-  FutureOr<String> build() async {
-    final (count, _) = await useRepo<int, IntRepo>();
-    final (label, _) = await useRepo<String, StringRepo>();
+  FutureOr<String> build(UseHooks use) async {
+    final (count, _) = await use.repo<int, IntRepo>();
+    final (label, _) = await use.repo<String, StringRepo>();
     return '$count-$label';
   }