Expose lock name as well

Author: simolus3

packages/sqlite_async/lib/src/web/database.dart

@@ -7,6 +7,7 @@ import 'package:sqlite_async/sqlite_async.dart';
 import 'package:sqlite_async/src/utils/shared_utils.dart';
 import 'package:sqlite_async/web.dart';
 import 'protocol.dart';
+import 'web_mutex.dart';
 
 class WebDatabase
     with SqliteQueries, SqliteDatabaseMixin
@@ -58,8 +59,17 @@ class WebDatabase
   Never get openFactory => throw UnimplementedError();
 
   @override
-  Future<SqliteWebEndpoint> exposeEndpoint() async {
-    return await _database.additionalConnection();
+  Future<WebDatabaseEndpoint> exposeEndpoint() async {
+    final endpoint = await _database.additionalConnection();
+
+    return (
+      connectPort: endpoint.$1,
+      connectName: endpoint.$2,
+      lockName: switch (_mutex) {
+        MutexImpl(:final resolvedIdentifier) => resolvedIdentifier,
+        _ => null,
+      },
+    );
   }
 
   @override

packages/sqlite_async/lib/src/web/web_mutex.dart

@@ -18,7 +18,7 @@ external Navigator get _navigator;
 class MutexImpl implements Mutex {
   late final mutex.Mutex fallback;
   String? identifier;
-  final String _resolvedIdentifier;
+  final String resolvedIdentifier;
 
   MutexImpl({this.identifier})
 
@@ -29,7 +29,7 @@ class MutexImpl implements Mutex {
       ///    - The uuid package could be added for better uniqueness if required.
       ///      This would add another package dependency to `sqlite_async` which is potentially unnecessary at this point.
       /// An identifier should be supplied for better exclusion.
-      : _resolvedIdentifier = identifier ??
+      : resolvedIdentifier = identifier ??
             "${DateTime.now().microsecondsSinceEpoch}-${Random().nextDouble()}" {
     fallback = mutex.Mutex();
   }
@@ -125,7 +125,7 @@ class MutexImpl implements Mutex {
     final lockOptions = JSObject();
     lockOptions['signal'] = controller.signal;
     final promise = _navigator.locks
-        .request(_resolvedIdentifier, lockOptions, jsCallback.toJS);
+        .request(resolvedIdentifier, lockOptions, jsCallback.toJS);
     // A timeout abort will throw an exception which needs to be handled.
     // There should not be any other unhandled lock errors.
     js_util.promiseToFuture(promise).catchError((error) {});

packages/sqlite_async/lib/web.dart

@@ -2,9 +2,25 @@
 library sqlite_async.web;
 
 import 'package:sqlite3_web/sqlite3_web.dart';
+import 'package:web/web.dart';
 import 'sqlite_async.dart';
 import 'src/web/database.dart';
 
+/// An endpoint that can be used, by any running JavaScript context in the same
+/// website, to connect to an existing [WebSqliteConnection].
+///
+/// These endpoints are created by calling [WebSqliteConnection.exposeEndpoint]
+/// and consist of a [MessagePort] and two [String]s internally identifying the
+/// connection. Both objects can be transferred over send ports towards another
+/// worker or context. That context can then use
+/// [WebSqliteConnection.connectToEndpoint] to connect to the port already
+/// opened.
+typedef WebDatabaseEndpoint = ({
+  MessagePort connectPort,
+  String connectName,
+  String? lockName,
+});
+
 /// A [SqliteConnection] interface implemented by opened connections when
 /// running on the web.
 ///
@@ -13,23 +29,30 @@ import 'src/web/database.dart';
 /// opened database across different JavaScript contexts
 /// (e.g. document windows and workers).
 abstract class WebSqliteConnection implements SqliteConnection {
-  /// Returns a [SqliteWebEndpoint] from `package:sqlite3/web.dart` - a
-  /// structure that consists only of types that can be transferred across a
-  /// `MessagePort` in JavaScript.
+  /// Returns a [WebDatabaseEndpoint] - a structure that consists only of types
+  /// that can be transferred across a [MessagePort] in JavaScript.
   ///
   /// After transferring this endpoint to another JavaScript context (e.g. a
   /// worker), the worker can call [connectToEndpoint] to obtain a connection to
   /// the same sqlite database.
-  Future<SqliteWebEndpoint> exposeEndpoint();
+  Future<WebDatabaseEndpoint> exposeEndpoint();
 
   /// Connect to an endpoint obtained through [exposeEndpoint].
   ///
   /// The endpoint is transferrable in JavaScript, allowing multiple JavaScript
   /// contexts to exchange opened database connections.
   static Future<WebSqliteConnection> connectToEndpoint(
-      SqliteWebEndpoint endpoint) async {
-    final rawSqlite = await WebSqlite.connectToPort(endpoint);
-    final database = WebDatabase(rawSqlite, null);
+      WebDatabaseEndpoint endpoint) async {
+    final rawSqlite = await WebSqlite.connectToPort(
+        (endpoint.connectPort, endpoint.connectName));
+
+    final database = WebDatabase(
+      rawSqlite,
+      switch (endpoint.lockName) {
+        var lock? => Mutex(identifier: lock),
+        null => null,
+      },
+    );
     return database;
   }
 }