Use CommonDatabase type

Author: mugikhan

lib/src/common/isolate_connection_factory.dart

@@ -1,13 +1,12 @@
 import 'dart:async';
-import 'package:sqlite_async/sqlite3.dart';
-import 'package:sqlite_async/sqlite3_common.dart' as sqlite;
+import 'package:sqlite_async/sqlite3_common.dart';
 import 'package:sqlite_async/src/common/mutex.dart';
 import 'package:sqlite_async/src/common/abstract_open_factory.dart';
 import 'package:sqlite_async/src/impl/isolate_connection_factory_impl.dart';
 import 'package:sqlite_async/src/sqlite_connection.dart';
 import 'port_channel.dart';
 
-mixin IsolateOpenFactoryMixin<Database extends sqlite.CommonDatabase> {
+mixin IsolateOpenFactoryMixin<Database extends CommonDatabase> {
   AbstractDefaultSqliteOpenFactory<Database> get openFactory;
 
   /// Opens a synchronous sqlite.Database directly in the current isolate.
@@ -24,8 +23,8 @@ mixin IsolateOpenFactoryMixin<Database extends sqlite.CommonDatabase> {
 }
 
 /// A connection factory that can be passed to different isolates.
-abstract class IsolateConnectionFactory<Database extends sqlite.CommonDatabase>
-    with IsolateOpenFactoryMixin<Database> {
+abstract class IsolateConnectionFactory<Database extends CommonDatabase>
+    with IsolateOpenFactoryMixin {
   Mutex get mutex;
 
   SerializedPortClient get upstreamPort;

lib/src/impl/stub_isolate_connection_factory.dart

@@ -1,14 +1,15 @@
 import 'dart:async';
 
-import 'package:sqlite3/sqlite3.dart' as sqlite;
+import 'package:sqlite_async/sqlite3_common.dart';
 import 'package:sqlite_async/src/common/isolate_connection_factory.dart';
 import 'package:sqlite_async/src/common/mutex.dart';
 import 'package:sqlite_async/src/common/abstract_open_factory.dart';
 import 'package:sqlite_async/src/common/port_channel.dart';
 import 'package:sqlite_async/src/sqlite_connection.dart';
 
 /// A connection factory that can be passed to different isolates.
-class IsolateConnectionFactoryImpl implements IsolateConnectionFactory {
+class IsolateConnectionFactoryImpl<Database extends CommonDatabase>
+    implements IsolateConnectionFactory<Database> {
   @override
   AbstractDefaultSqliteOpenFactory openFactory;
 
@@ -34,7 +35,7 @@ class IsolateConnectionFactoryImpl implements IsolateConnectionFactory {
   ///  2. Other connections are not notified of any updates to tables made within
   ///     this connection.
   @override
-  Future<sqlite.Database> openRawDatabase({bool readOnly = false}) async {
+  Future<Database> openRawDatabase({bool readOnly = false}) async {
     throw UnimplementedError();
   }
 

lib/src/native/native_sqlite_open_factory.dart

@@ -1,4 +1,5 @@
 import 'package:sqlite_async/sqlite3.dart' as sqlite;
+import 'package:sqlite_async/sqlite3_common.dart';
 
 import 'package:sqlite_async/src/common/abstract_open_factory.dart';
 import 'package:sqlite_async/src/native/database/native_sqlite_connection_impl.dart';
@@ -12,7 +13,7 @@ class DefaultSqliteOpenFactory extends AbstractDefaultSqliteOpenFactory {
       super.sqliteOptions = const SqliteOptions.defaults()});
 
   @override
-  sqlite.Database openDB(SqliteOpenOptions options) {
+  CommonDatabase openDB(SqliteOpenOptions options) {
     final mode = options.openMode;
     var db = sqlite.sqlite3.open(path, mode: mode, mutex: false);
     return db;

lib/src/sqlite_connection.dart

@@ -1,10 +1,11 @@
 import 'dart:async';
 
 import 'package:sqlite3/common.dart' as sqlite;
+import 'package:sqlite_async/sqlite3_common.dart';
 import 'package:sqlite_async/src/update_notification.dart';
 
 /// Abstract class representing calls available in a read-only or read-write context.
-abstract class SqliteReadContext<Database extends sqlite.CommonDatabase> {
+abstract class SqliteReadContext {
   /// Execute a read-only (SELECT) query and return the results.
   Future<sqlite.ResultSet> getAll(String sql,
       [List<Object?> parameters = const []]);
@@ -57,7 +58,8 @@ abstract class SqliteReadContext<Database extends sqlite.CommonDatabase> {
   ///   });
   /// }
   /// ```
-  Future<T> computeWithDatabase<T>(Future<T> Function(Database db) compute);
+  Future<T> computeWithDatabase<T>(
+      Future<T> Function(CommonDatabase db) compute);
 }
 
 /// Abstract class representing calls available in a read-write context.