chore: merge master (#41)

* chore: merge master

* chore: fix lint issue

* chore: add version update

* fix: changelog

---------

Co-authored-by: DominicGBauer <[email protected]>

Author: DominicGBauer

Diff for: .github/workflows/test.yaml

@@ -32,19 +32,19 @@ jobs:
         include:
           - sqlite_version: "3440200"
             sqlite_url: "https://www.sqlite.org/2023/sqlite-autoconf-3440200.tar.gz"
-            dart_sdk: 3.2.4
+            dart_sdk: 3.3.3
           - sqlite_version: "3430200"
             sqlite_url: "https://www.sqlite.org/2023/sqlite-autoconf-3430200.tar.gz"
-            dart_sdk: 3.2.4
+            dart_sdk: 3.3.3
           - sqlite_version: "3420000"
             sqlite_url: "https://www.sqlite.org/2023/sqlite-autoconf-3420000.tar.gz"
-            dart_sdk: 3.2.4
+            dart_sdk: 3.3.3
           - sqlite_version: "3410100"
             sqlite_url: "https://www.sqlite.org/2023/sqlite-autoconf-3410100.tar.gz"
-            dart_sdk: 3.2.4
+            dart_sdk: 3.3.3
           - sqlite_version: "3380000"
             sqlite_url: "https://www.sqlite.org/2022/sqlite-autoconf-3380000.tar.gz"
-            dart_sdk: 3.2.0
+            dart_sdk: 3.3.3
     steps:
       - uses: actions/checkout@v3
       - uses: dart-lang/setup-dart@v1

Diff for: .gitignore

@@ -17,3 +17,5 @@ assets
 test-db
 sqlite-autoconf-*
 doc
+
+build

Diff for: CHANGELOG.md

@@ -1,11 +1,25 @@
+## 0.7.0-alpha.3
+
+- Add latest changes from master
+
 ## 0.7.0-alpha.2
 
-- Fix re-using a shared Mutex from https://github.com/powersync-ja/sqlite_async.dart/pull/31
+- Fix re-using a shared Mutex from <https://github.com/powersync-ja/sqlite_async.dart/pull/31>
 
 ## 0.7.0-alpha.1
 
 - Added initial support for web platform.
 
+## 0.6.1
+
+- Fix errors when closing a `SqliteDatabase`.
+- Configure SQLite `busy_timeout` (30s default). This fixes "database is locked (code 5)" error when using multiple `SqliteDatabase` instances for the same database.
+- Fix errors when opening multiple connections at the same time, e.g. when running multiple read queries concurrently
+  right after opening the dtaabase.
+- Improved error handling when an Isolate crashes with an uncaught error.
+- Rewrite connection pool logic to fix performance issues when multiple read connections are open.
+- Fix using `SqliteDatabase.isolateConnectionFactory()` in multiple isolates.
+
 ## 0.6.0
 
 - Allow catching errors and continuing the transaction. This is technically a breaking change, although it should not be an issue in most cases.

Diff for: lib/src/common/abstract_open_factory.dart

@@ -86,8 +86,21 @@ abstract class AbstractDefaultSqliteOpenFactory<
   FutureOr<Database> open(SqliteOpenOptions options) async {
     var db = await openDB(options);
 
+    // Pragma statements don't have the same BUSY_TIMEOUT behavior as normal statements.
+    // We add a manual retry loop for those.
     for (var statement in pragmaStatements(options)) {
-      db.execute(statement);
+      for (var tries = 0; tries < 30; tries++) {
+        try {
+          db.execute(statement);
+          break;
+        } on sqlite.SqliteException catch (e) {
+          if (e.resultCode == sqlite.SqlError.SQLITE_BUSY && tries < 29) {
+            continue;
+          } else {
+            rethrow;
+          }
+        }
+      }
     }
     return db;
   }

Diff for: lib/src/common/port_channel.dart

@@ -18,8 +18,11 @@ abstract class PortClient {
 class ParentPortClient implements PortClient {
   late Future<SendPort> sendPortFuture;
   SendPort? sendPort;
-  ReceivePort receivePort = ReceivePort();
+  final ReceivePort _receivePort = ReceivePort();
+  final ReceivePort _errorPort = ReceivePort();
   bool closed = false;
+  Object? _closeError;
+  String? _isolateDebugName;
   int _nextId = 1;
 
   Map<int, Completer<Object?>> handlers = HashMap();
@@ -30,7 +33,7 @@ class ParentPortClient implements PortClient {
     sendPortFuture.then((value) {
       sendPort = value;
     });
-    receivePort.listen((message) {
+    _receivePort.listen((message) {
       if (message is _InitMessage) {
         assert(!initCompleter.isCompleted);
         initCompleter.complete(message.port);
@@ -57,24 +60,35 @@ class ParentPortClient implements PortClient {
       }
       close();
     });
+    _errorPort.listen((message) {
+      final [error, stackTraceString] = message;
+      final stackTrace = stackTraceString == null
+          ? null
+          : StackTrace.fromString(stackTraceString);
+      if (!initCompleter.isCompleted) {
+        initCompleter.completeError(error, stackTrace);
+      }
+      _close(IsolateError(cause: error, isolateDebugName: _isolateDebugName),
+          stackTrace);
+    });
   }
 
   Future<void> get ready async {
     await sendPortFuture;
   }
 
-  void _cancelAll(Object error) {
+  void _cancelAll(Object error, [StackTrace? stackTrace]) {
     var handlers = this.handlers;
     this.handlers = {};
     for (var message in handlers.values) {
-      message.completeError(error);
+      message.completeError(error, stackTrace);
     }
   }
 
   @override
   Future<T> post<T>(Object message) async {
     if (closed) {
-      throw ClosedException();
+      throw _closeError ?? const ClosedException();
     }
     var completer = Completer<T>.sync();
     var id = _nextId++;
@@ -87,27 +101,39 @@ class ParentPortClient implements PortClient {
   @override
   void fire(Object message) async {
     if (closed) {
-      throw ClosedException();
+      throw _closeError ?? ClosedException();
     }
     final port = sendPort ?? await sendPortFuture;
     port.send(_FireMessage(message));
   }
 
   RequestPortServer server() {
-    return RequestPortServer(receivePort.sendPort);
+    return RequestPortServer(_receivePort.sendPort);
   }
 
-  void close() async {
+  void _close([Object? error, StackTrace? stackTrace]) {
     if (!closed) {
       closed = true;
 
-      receivePort.close();
-      _cancelAll(const ClosedException());
+      _receivePort.close();
+      _errorPort.close();
+      if (error == null) {
+        _cancelAll(const ClosedException());
+      } else {
+        _closeError = error;
+        _cancelAll(error, stackTrace);
+      }
     }
   }
 
+  void close() {
+    _close();
+  }
+
   tieToIsolate(Isolate isolate) {
-    isolate.addOnExitListener(receivePort.sendPort, response: _closeMessage);
+    _isolateDebugName = isolate.debugName;
+    isolate.addErrorListener(_errorPort.sendPort);
+    isolate.addOnExitListener(_receivePort.sendPort, response: _closeMessage);
   }
 }
 
@@ -261,6 +287,27 @@ class _RequestMessage {
 
 class ClosedException implements Exception {
   const ClosedException();
+
+  @override
+  String toString() {
+    return 'ClosedException';
+  }
+}
+
+class IsolateError extends Error {
+  final Object cause;
+  final String? isolateDebugName;
+
+  IsolateError({required this.cause, this.isolateDebugName});
+
+  @override
+  String toString() {
+    if (isolateDebugName != null) {
+      return 'IsolateError in $isolateDebugName: $cause';
+    } else {
+      return 'IsolateError: $cause';
+    }
+  }
 }
 
 class _PortChannelResult<T> {