Improve code

Author: JhonaCodes

lib/src/database/database_manager.dart

@@ -0,0 +1,78 @@
+import 'package:flutter/foundation.dart' show kIsWeb;
+
+import '../core/log.dart';
+import '../model/local_db_error_model.dart';
+import '../utils/system_utils.dart';
+import 'package:result_controller/result_controller.dart';
+import 'database_interface.dart';
+import 'database_mock.dart';
+import 'database_native.dart';
+import 'database_web_import.dart';
+
+/// Elegant database manager that handles connections on-demand
+/// without singleton pattern complexity
+class DatabaseManager {
+  static String? _currentDatabaseName;
+  
+  /// Connect to or create database with given name (safe Result-based version)
+  static Future<Result<DatabaseInterface, ErrorLocalDb>> _safeGetConnection(String databaseName) async {
+    _currentDatabaseName = databaseName;
+    
+    final DatabaseInterface database = _createDatabaseInstance();
+    
+    // Use Result-based initialization if available
+    await database.initialize(databaseName);
+    
+    Log.i('✅ Connected to database: $databaseName on ${database.platformName}');
+    return Ok(database);
+  }
+  
+  /// Factory method to create appropriate database instance
+  static DatabaseInterface _createDatabaseInstance() {
+    if (SystemUtils.isTest) {
+      return DatabaseMock();
+    }
+    
+    if (kIsWeb) {
+      return DatabaseWeb.instance;
+    }
+    
+    return DatabaseNative();
+  }
+  
+  /// Execute a database operation with automatic connection management
+  static Future<Result<T, ErrorLocalDb>> execute<T>(
+    String databaseName,
+    Future<Result<T, ErrorLocalDb>> Function(DatabaseInterface db) operation,
+  ) async {
+    final connectionResult = await _safeGetConnection(databaseName);
+    
+    return connectionResult.when(
+      ok: (db) async {
+        final operationResult = await operation(db);
+        await db.closeDatabase();
+        return operationResult;
+      },
+      err: (error) => Err(error),
+    );
+  }
+  
+  /// Get current database name (useful for debugging)
+  static String? get currentDatabaseName => _currentDatabaseName;
+  
+  /// Check if database exists on disk
+  static Future<bool> databaseExists(String databaseName) async {
+    if (kIsWeb) {
+      // For web, we can't check file existence, assume it exists if we have a name stored
+      return _currentDatabaseName == databaseName;
+    }
+    
+    try {
+      // For native platforms, check if database file exists
+      final db = DatabaseNative();
+      return await db.ensureConnectionValid();
+    } catch (e) {
+      return false;
+    }
+  }
+}

lib/src/database/database_mock.dart

@@ -21,9 +21,6 @@ import 'database_interface.dart';
 /// - Data validation and sanitization
 /// - Thread-safe operations
 class DatabaseMock implements DatabaseInterface {
-  DatabaseMock._();
-
-  static final DatabaseMock instance = DatabaseMock._();
 
   // In-memory storage
   final Map<String, LocalDbModel> _storage = {};

lib/src/database/database_native.dart

@@ -43,6 +43,8 @@ class DatabaseConnection {
 class ConnectionPool {
   static final Map<String, DatabaseConnection> _connections = {};
   static int _currentGeneration = 1;
+  // Persist the last used database name across hot restarts
+  static String? _lastUsedDatabaseName;
 
   static DatabaseConnection? getConnection(String dbName) {
     final connection = _connections[dbName];
@@ -55,6 +57,7 @@ class ConnectionPool {
 
   static void storeConnection(String dbName, DatabaseConnection connection) {
     _connections[dbName] = connection;
+    _lastUsedDatabaseName = dbName; // Remember the last used database name
   }
 
   static void invalidateConnection(String dbName) {
@@ -78,6 +81,9 @@ class ConnectionPool {
   static void incrementGeneration() => _currentGeneration++;
 
   static int get connectionCount => _connections.length;
+  
+  // Getter for last used database name (survives hot restart)
+  static String? get lastUsedDatabaseName => _lastUsedDatabaseName;
 }
 
 /// Typedef for the rust functions
@@ -93,9 +99,6 @@ typedef PointerListFFICallBack = Pointer<Utf8> Function(Pointer<AppDbState>);
 /// Native database implementation using FFI and Rust backend
 /// This implementation is used for mobile and desktop platforms
 class DatabaseNative implements DatabaseInterface {
-  DatabaseNative._();
-
-  static final DatabaseNative instance = DatabaseNative._();
 
   Result<DynamicLibrary, String>? _lib;
   Pointer<AppDbState>? _dbInstance;
@@ -411,13 +414,25 @@ class DatabaseNative implements DatabaseInterface {
       }
     }
 
-    if (_dbInstance == null || _dbInstance == nullptr) {
-      Log.w(
-        'Database connection invalid (null pointer), attempting to reinitialize...',
-      );
+    // Check if we have a database name stored (indicates previous initialization)
+    final dbNameToRestore = _lastDatabaseName ?? ConnectionPool.lastUsedDatabaseName;
+    if (dbNameToRestore != null && (_dbInstance == null || _dbInstance == nullptr)) {
+      Log.i('🔄 Hot restart detected - attempting to reconnect to existing database: $dbNameToRestore');
+      
+      // Restore the database name for the instance
+      if (_lastDatabaseName == null) {
+        _lastDatabaseName = dbNameToRestore;
+        Log.i('🔄 Restored database name from connection pool: $dbNameToRestore');
+      }
+      
       return await _attemptReinitialization();
     }
 
+    if (_dbInstance == null || _dbInstance == nullptr) {
+      Log.w('Database connection invalid (null pointer), no previous database name stored');
+      return false;
+    }
+
     // Check connection pool first
     if (_lastDatabaseName != null) {
       final poolConnection = ConnectionPool.getConnection(_lastDatabaseName!);