feat: implement Injectable interface for service and datasource classes

Author: mcquenji

lib/src/domain/datasources/datasource.dart

@@ -9,7 +9,9 @@ import 'package:grumpy/grumpy.dart';
 /// A datasource is responsible for providing data from a specific source,
 /// such as a database, API, or local storage.
 @BaseClass(allowedLayers: {.domain, .infra})
-abstract class Datasource with LogMixin, Disposable, TelemetryMixin {
+abstract class Datasource
+    with LogMixin, Disposable, TelemetryMixin
+    implements Injectable {
   /// A datasource is responsible for providing data from a specific source,
   /// such as a database, API, or local storage.
   const Datasource();
@@ -28,4 +30,7 @@ abstract class Datasource with LogMixin, Disposable, TelemetryMixin {
 
   /// Retrieves an instance of the specified [Datasource] type from the service locator.
   static D get<D extends Datasource>() => GetIt.instance<D>();
+
+  @override
+  bool get singelton => false;
 }

lib/src/domain/domain.dart

@@ -2,3 +2,23 @@ export 'models/models.dart';
 export 'datasources/datasources.dart';
 export 'services/services.dart';
 export 'errors/errors.dart';
+
+import 'package:get_it/get_it.dart' hide Disposable;
+
+/// Base contract for DI-managed types.
+///
+/// Concrete implementations can control their registration behavior in
+/// [Module.bindServices] and [Module.bindDatasources] through [singelton]:
+/// if `true`, modules register them as lazy singletons; if `false`, modules
+/// register them as factories.
+abstract class Injectable {
+  /// Creates an injectable DI contract.
+  const Injectable();
+
+  /// Whether this type should be resolved as a singleton in module DI binding.
+  ///
+  /// Used by module injectable binding:
+  /// - `true` => [GetIt.registerLazySingleton]
+  /// - `false` => [GetIt.registerFactory]
+  bool get singelton;
+}

lib/src/domain/services/routing_service.dart

@@ -74,6 +74,9 @@ abstract class RoutingService<T, Config extends Object> extends Service {
   factory RoutingService() {
     return Service.get<RoutingService<T, Config>>();
   }
+
+  @override
+  bool get singelton => true;
 }
 
 /// An event representing a change in the view rendered by the [RoutingService].

lib/src/domain/services/service.dart

@@ -9,7 +9,9 @@ import 'package:grumpy/grumpy.dart';
 /// A service is responsible for IO operations, such as making network requests
 /// or reading/writing files.
 @BaseClass(allowedLayers: {.domain, .infra})
-abstract class Service with LogMixin, Disposable, TelemetryMixin {
+abstract class Service
+    with LogMixin, Disposable, TelemetryMixin
+    implements Injectable {
   /// A service is responsible for IO operations, such as making network requests
   /// or reading/writing files.
   const Service();
@@ -27,4 +29,7 @@ abstract class Service with LogMixin, Disposable, TelemetryMixin {
 
   /// Retrieves an instance of the specified [Service] type from the service locator.
   static S get<S extends Service>() => GetIt.instance<S>();
+
+  @override
+  bool get singelton => false;
 }

lib/src/module.dart

@@ -71,6 +71,16 @@ abstract class Module<RouteType, Config extends Object>
     log('${module.runtimeType} mounted successfully.');
   }
 
+  void _bindInjectable<T extends Injectable>(Builder<T, Config> builder) {
+    final instance = builder(_di.get<Config>(), _di.get);
+
+    if (instance.singelton) {
+      _di.registerLazySingleton<T>(() => builder(_di.get<Config>(), _di.get));
+    } else {
+      _di.registerFactory<T>(() => builder(_di.get<Config>(), _di.get));
+    }
+  }
+
   @mustCallSuper
   @override
   FutureOr<void> activate() async {
@@ -107,14 +117,12 @@ abstract class Module<RouteType, Config extends Object>
       _di.registerSingleton<T>(builder(_di.get<Config>(), _di.get));
     });
 
-    bindServices(<T extends Service>(Builder<Service, Config> builder) {
-      _di.registerFactory<T>(() => builder(_di.get<Config>(), _di.get) as T);
+    bindServices(<T extends Service>(Builder<T, Config> builder) {
+      _bindInjectable<T>(builder);
     });
 
-    bindDatasources(<T extends Datasource>(
-      Builder<Datasource, Config> builder,
-    ) {
-      _di.registerFactory<T>(() => builder(_di.get<Config>(), _di.get) as T);
+    bindDatasources(<T extends Datasource>(Builder<T, Config> builder) {
+      _bindInjectable<T>(builder);
     });
 
     bindRepos(<T extends Repo>(Builder<Repo, Config> builder) {

lib/src/presentation/repositories/repo.dart

@@ -12,7 +12,8 @@ import 'package:rxdart/rxdart.dart';
 ///
 /// See [RepoState] for more details on the possible states.
 abstract class Repo<T>
-    with LogMixin, LifecycleMixin, LifecycleHooksMixin, Disposable {
+    with LogMixin, LifecycleMixin, LifecycleHooksMixin, Disposable
+    implements Injectable {
   final _stream = BehaviorSubject.seeded(RepoState<T>.loading());
 
   /// Creates a new instance of [Repo].
@@ -55,4 +56,8 @@ abstract class Repo<T>
 
   /// Retrieves an instance of the specified [Repo] type from the service locator.
   static Future<R> get<R extends Repo>() => GetIt.instance.getAsync<R>();
+
+  /// This will be ignored by the module's DI system, as repositories are always treated as async singletons.
+  @override
+  bool get singelton => true;
 }

test/module_test.dart

@@ -44,9 +44,15 @@ void main() {
     final service = di.get<_FakeService>();
     expect(service.config, same(di.get<_TestConfig>()));
 
+    final singletonService = di.get<_SingletonFakeService>();
+    expect(singletonService.config, same(di.get<_TestConfig>()));
+
     final datasource = di.get<_FakeDatasource>();
     expect(datasource.config, same(di.get<_TestConfig>()));
 
+    final singletonDatasource = di.get<_SingletonFakeDatasource>();
+    expect(singletonDatasource.config, same(di.get<_TestConfig>()));
+
     final repo = await di.getAsync<_FakeRepo>();
     expect(repo.config, same(di.get<_TestConfig>()));
     expect(repo.initializeCallCount, greaterThanOrEqualTo(1));
@@ -56,6 +62,41 @@ void main() {
     await module.free();
   });
 
+  group('Injectables', () {
+    test('marked as factory return a new instance per resolution', () async {
+      final module = _TestModule(_ImportModule());
+      await module.initialize();
+
+      final serviceA = di.get<_FakeService>();
+      final serviceB = di.get<_FakeService>();
+      expect(serviceA, isNot(same(serviceB)));
+
+      final datasourceA = di.get<_FakeDatasource>();
+      final datasourceB = di.get<_FakeDatasource>();
+      expect(datasourceA, isNot(same(datasourceB)));
+
+      await module.free();
+    });
+
+    test(
+      'marked as singelton return the same instance per resolution',
+      () async {
+        final module = _TestModule(_ImportModule());
+        await module.initialize();
+
+        final serviceA = di.get<_SingletonFakeService>();
+        final serviceB = di.get<_SingletonFakeService>();
+        expect(serviceA, same(serviceB));
+
+        final datasourceA = di.get<_SingletonFakeDatasource>();
+        final datasourceB = di.get<_SingletonFakeDatasource>();
+        expect(datasourceA, same(datasourceB));
+
+        await module.free();
+      },
+    );
+  });
+
   test('Classes are not available after disposing module', () async {
     final importModule = _ImportModule();
     final module = _TestModule(importModule);
@@ -68,7 +109,9 @@ void main() {
     expect(repo.disposed, isTrue);
     expect(di.isRegistered<_ExternalDependency>(), isFalse);
     expect(di.isRegistered<_FakeService>(), isFalse);
+    expect(di.isRegistered<_SingletonFakeService>(), isFalse);
     expect(di.isRegistered<_FakeDatasource>(), isFalse);
+    expect(di.isRegistered<_SingletonFakeDatasource>(), isFalse);
     expect(di.isRegistered<_FakeRepo>(), isFalse);
     expect(di.get<_TestConfig>(), isA<_TestConfig>());
   });
@@ -90,11 +133,13 @@ class _TestModule extends Module<int, _TestConfig> {
   @override
   void bindServices(Bind<Service, _TestConfig> bind) {
     bind((config, resolver) => _FakeService(config));
+    bind((config, resolver) => _SingletonFakeService(config));
   }
 
   @override
   void bindDatasources(Bind<Datasource, _TestConfig> bind) {
     bind((config, resolver) => _FakeDatasource(config));
+    bind((config, resolver) => _SingletonFakeDatasource(config));
   }
 
   @override
@@ -173,6 +218,20 @@ class _FakeService extends Service {
   String get logTag => '_FakeService';
 }
 
+class _SingletonFakeService extends Service {
+  _SingletonFakeService(this.config);
+
+  final _TestConfig config;
+
+  @override
+  bool get singelton => true;
+
+  @override
+  Future<void> free() async {}
+  @override
+  String get logTag => '_SingletonFakeService';
+}
+
 class _FakeDatasource extends Datasource {
   _FakeDatasource(this.config);
 
@@ -184,6 +243,20 @@ class _FakeDatasource extends Datasource {
   String get logTag => '_FakeDatasource';
 }
 
+class _SingletonFakeDatasource extends Datasource {
+  _SingletonFakeDatasource(this.config);
+
+  final _TestConfig config;
+
+  @override
+  bool get singelton => true;
+
+  @override
+  Future<void> free() async {}
+  @override
+  String get logTag => '_SingletonFakeDatasource';
+}
+
 class _FakeRepo extends Repo<int> {
   _FakeRepo(this.config) {
     onInitialize(() => initializeHookRan = true);