refactor(mobile): split store into repo and service

mobile/integration_test/test_utils/general_helper.dart

@@ -4,12 +4,13 @@ import 'package:easy_localization/easy_localization.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/main.dart' as app;
 import 'package:immich_mobile/providers/db.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
 import 'package:integration_test/integration_test.dart';
 import 'package:isar/isar.dart';
 // ignore: depend_on_referenced_packages
 import 'package:meta/meta.dart';
-import 'package:immich_mobile/main.dart' as app;
 
 import 'login_helper.dart';
 
@@ -44,7 +45,10 @@ class ImmichTestHelper {
     // Load main Widget
     await tester.pumpWidget(
       ProviderScope(
-        overrides: [dbProvider.overrideWithValue(db)],
+        overrides: [
+          dbProvider.overrideWithValue(db),
+          isarProvider.overrideWithValue(db),
+        ],
         child: const app.MainWidget(),
       ),
     );

mobile/lib/domain/README.md

@@ -0,0 +1,34 @@
+# Domain Layer
+
+This directory contains the domain layer of Immich. The domain layer is responsible for the business logic of the app. It includes interfaces for repositories, models, services and utilities. This layer should never depend on anything from the presentation layer or from the infrastructure layer.
+
+## Structure
+
+- **[Interfaces](./interfaces/)**: These are the interfaces that define the contract for data operations.
+- **[Models](./models/)**: These are the core data classes that represent the business models.
+- **[Services](./services/)**: These are the classes that contain the business logic and interact with the repositories.
+- **[Utils](./utils/)**: These are utility classes and functions that provide common functionalities used across the domain layer.
+
+```
+domain/
+├── interfaces/
+│   └── user.interface.dart
+├── models/
+│   └── user.model.dart
+├── services/
+│   └── user.service.dart
+└── utils/
+    └── date_utils.dart
+```
+
+## Usage
+
+The domain layer provides services that implement the business logic by consuming repositories through dependency injection. Services are exposed through Riverpod providers in the root `providers` directory.
+
+```dart
+// In presentation layer
+final userService = ref.watch(userServiceProvider);
+final user = await userService.getUser(userId);
+```
+
+The presentation layer should never directly use repositories, but instead interact with the domain layer through services.

mobile/lib/domain/interfaces/db.interface.dart

@@ -0,0 +1,5 @@
+abstract interface class IDatabaseRepository {
+  Future<T> nestTxn<T>(Future<T> Function() callback);
+
+  Future<T> txn<T>(Future<T> Function() callback);
+}

mobile/lib/domain/interfaces/store.interface.dart

@@ -0,0 +1,17 @@
+import 'package:immich_mobile/entities/store.entity.dart';
+
+abstract interface class IStoreRepository {
+  Future<bool> insert<T>(StoreKey<T> key, T value);
+
+  Future<T?> tryGet<T>(StoreKey<T> key);
+
+  Stream<T?> watch<T>(StoreKey<T> key);
+
+  Stream<StoreUpdateEvent> watchAll();
+
+  Future<bool> update<T>(StoreKey<T> key, T value);
+
+  Future<void> delete<T>(StoreKey<T> key);
+
+  Future<void> deleteAll();
+}

mobile/lib/domain/services/store.service.dart

@@ -0,0 +1,106 @@
+import 'dart:async';
+
+import 'package:immich_mobile/domain/interfaces/store.interface.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+
+class StoreService {
+  final IStoreRepository _storeRepo;
+
+  final Map<int, dynamic> _cache = {};
+  late final StreamSubscription<StoreUpdateEvent> _subscription;
+
+  StoreService._({
+    required IStoreRepository storeRepo,
+  }) : _storeRepo = storeRepo;
+
+  // TODO: Temporary typedef to make minimal changes. Remove this and make the presentation layer access store through a provider
+  static StoreService? _instance;
+  static StoreService get I {
+    if (_instance == null) {
+      throw UnsupportedError("StoreService not initialized. Call init() first");
+    }
+    return _instance!;
+  }
+
+  // TODO: Replace the implementation with the one from create after removing the typedef
+  /// Initializes the store with the given [storeRepository]
+  static Future<StoreService> init({
+    required IStoreRepository storeRepo,
+  }) async {
+    _instance ??= await create(storeRepo: storeRepo);
+    return _instance!;
+  }
+
+  /// Initializes the store with the given [storeRepository]
+  static Future<StoreService> create({
+    required IStoreRepository storeRepo,
+  }) async {
+    final instance = StoreService._(storeRepo: storeRepo);
+    await instance._populateCache();
+    instance._subscription = instance._listenForChange();
+    return instance;
+  }
+
+  /// Fills the cache with the values from the DB
+  Future<void> _populateCache() async {
+    for (StoreKey key in StoreKey.values) {
+      final storeValue = await _storeRepo.tryGet(key);
+      _cache[key.id] = storeValue;
+    }
+  }
+
+  /// Listens for changes in the DB and updates the cache
+  StreamSubscription<StoreUpdateEvent> _listenForChange() =>
+      _storeRepo.watchAll().listen((event) {
+        _cache[event.key.id] = event.value;
+      });
+
+  /// Disposes the store and cancels the subscription. To reuse the store call init() again
+  void dispose() async {
+    await _subscription.cancel();
+    _cache.clear();
+  }
+
+  /// Returns the stored value for the given key (possibly null)
+  T? tryGet<T>(StoreKey<T> key) => _cache[key.id];
+
+  /// Returns the stored value for the given key or if null the [defaultValue]
+  /// Throws a [StoreKeyNotFoundException] if both are null
+  T get<T>(StoreKey<T> key, [T? defaultValue]) {
+    final value = tryGet(key) ?? defaultValue;
+    if (value == null) {
+      throw StoreKeyNotFoundException(key);
+    }
+    return value;
+  }
+
+  /// Asynchronously stores the value in the DB and synchronously in the cache
+  Future<void> put<T>(StoreKey<T> key, T value) async {
+    if (_cache[key.id] == value) return;
+    await _storeRepo.insert(key, value);
+    _cache[key.id] = value;
+  }
+
+  /// Watches a specific key for changes
+  Stream<T?> watch<T>(StoreKey<T> key) => _storeRepo.watch(key);
+
+  /// Removes the value asynchronously from the DB and synchronously from the cache
+  Future<void> delete<T>(StoreKey<T> key) async {
+    await _storeRepo.delete(key);
+    _cache.remove(key.id);
+  }
+
+  /// Clears all values from this store (cache and DB)
+  Future<void> clear() async {
+    await _storeRepo.deleteAll();
+    _cache.clear();
+  }
+}
+
+class StoreKeyNotFoundException implements Exception {
+  final StoreKey key;
+  const StoreKeyNotFoundException(this.key);
+
+  @override
+  String toString() => "Key - <${key.name}> not available in Store";
+}