Serialize sqlite exceptions

Author: simolus3

sqlite3_web/lib/src/channel.dart

@@ -126,7 +126,10 @@ abstract class ProtocolChannel {
           console.error('Original trace: $s'.toJS);
 
           response = ErrorResponse(
-              message: e.toString(), requestId: message.requestId);
+            message: e.toString(),
+            requestId: message.requestId,
+            serializedException: e,
+          );
         }
 
         _channel.sink.add(response);

sqlite3_web/lib/src/protocol.dart

@@ -1,4 +1,3 @@
-import 'dart:async';
 import 'dart:js_interop';
 import 'dart:js_interop_unsafe';
 import 'dart:typed_data';
@@ -64,13 +63,15 @@ class _UniqueFieldNames {
   static const onlyOpenVfs = 'o';
   static const parameters = 'p';
   static const storageMode = 's';
+  static const serializedExceptionType = 's';
   static const sql = 's'; // not used in same message
   static const type = 't';
   static const wasmUri = 'u';
   static const updateTableName = 'u';
   static const responseData = 'r';
   static const returnRows = 'r';
   static const updateRowId = 'r';
+  static const serializedException = 'r';
   static const rows = 'r'; // no clash, used on different message types
   static const typeVector = 'v';
 }
@@ -162,14 +163,6 @@ sealed class Request extends Message {
       object[_UniqueFieldNames.databaseId] = id.toJS;
     }
   }
-
-  Future<Response> tryRespond(FutureOr<Response> Function() function) async {
-    try {
-      return await function();
-    } catch (e) {
-      return ErrorResponse(message: e.toString(), requestId: requestId);
-    }
-  }
 }
 
 sealed class Response extends Message {
@@ -767,12 +760,33 @@ final class RowsResponse extends Response {
 final class ErrorResponse extends Response {
   final String message;
 
-  ErrorResponse({required this.message, required super.requestId});
+  /// We can't send Dart objects over web channels, but we're serializing the
+  /// most common exception types so that we can reconstruct them on the other
+  /// end.
+  final Object? serializedException;
+
+  ErrorResponse({
+    required this.message,
+    required super.requestId,
+    this.serializedException,
+  });
 
   factory ErrorResponse.deserialize(JSObject object) {
+    Object? serializedException;
+    if (object.has(_UniqueFieldNames.serializedExceptionType)) {
+      serializedException = switch (
+          (object[_UniqueFieldNames.serializedExceptionType] as JSNumber)
+              .toDartInt) {
+        _typeSqliteException => deserializeSqliteException(
+            object[_UniqueFieldNames.serializedException] as JSArray),
+        _ => null,
+      };
+    }
+
     return ErrorResponse(
       message: (object[_UniqueFieldNames.errorMessage] as JSString).toDart,
       requestId: object.requestId,
+      serializedException: serializedException,
     );
   }
 
@@ -783,12 +797,70 @@ final class ErrorResponse extends Response {
   void serialize(JSObject object, List<JSObject> transferred) {
     super.serialize(object, transferred);
     object[_UniqueFieldNames.errorMessage] = message.toJS;
+
+    if (serializedException case final SqliteException e?) {
+      object[_UniqueFieldNames.serializedExceptionType] =
+          _typeSqliteException.toJS;
+      object[_UniqueFieldNames.serializedException] =
+          serializeSqliteException(e);
+    }
   }
 
   @override
   RemoteException interpretAsError() {
-    return RemoteException(message: message);
+    return RemoteException(message: message, exception: serializedException);
+  }
+
+  static SqliteException deserializeSqliteException(JSArray data) {
+    final [
+      message,
+      explanation,
+      extendedResultCode,
+      operation,
+      causingStatement,
+      paramData,
+      paramTypes,
+      ..._,
+    ] = data.toDart;
+
+    String? decodeNullableString(JSAny? jsValue) {
+      if (jsValue.isDefinedAndNotNull) {
+        return (jsValue as JSString).toDart;
+      }
+      return null;
+    }
+
+    return SqliteException(
+      (extendedResultCode as JSNumber).toDartInt,
+      (message as JSString).toDart,
+      decodeNullableString(explanation),
+      decodeNullableString(causingStatement),
+      paramData.isDefinedAndNotNull && paramTypes.isDefinedAndNotNull
+          ? TypeCode.decodeValues(
+              paramData as JSArray, paramTypes as JSArrayBuffer)
+          : null,
+      decodeNullableString(operation),
+    );
+  }
+
+  static JSArray serializeSqliteException(SqliteException e) {
+    final params = switch (e.parametersToStatement) {
+      null => null,
+      final parameters => TypeCode.encodeValues(parameters),
+    };
+
+    return [
+      e.message.toJS,
+      e.explanation?.toJS,
+      e.extendedResultCode.toJS,
+      e.operation?.toJS,
+      e.causingStatement?.toJS,
+      params?.$1,
+      params?.$2,
+    ].toJS;
   }
+
+  static const _typeSqliteException = 0;
 }
 
 final class StreamRequest extends Request {

sqlite3_web/lib/src/types.dart

@@ -1,4 +1,5 @@
 import 'dart:typed_data';
+import 'package:sqlite3/common.dart';
 
 /// A [StorageMode], name pair representing an existing database already stored
 /// by the current browsing context.
@@ -66,8 +67,16 @@ final class RemoteException implements Exception {
   /// The [Object.toString] representation of the original exception.
   final String message;
 
+  /// The exception that happened in the context running the operation.
+  ///
+  /// Since that context may be a web worker which can't send arbitrary Dart
+  /// objects to us, only a few common exception types are recognized and
+  /// serialized.
+  /// At the moment, this only includes [SqliteException].
+  final Object? exception;
+
   /// Creates a remote exception from the [message] thrown.
-  RemoteException({required this.message});
+  RemoteException({required this.message, this.exception});
 
   @override
   String toString() {

sqlite3_web/test/protocol_test.dart

@@ -6,6 +6,7 @@ import 'dart:js_interop';
 import 'dart:typed_data';
 
 import 'package:sqlite3/common.dart';
+import 'package:sqlite3_web/sqlite3_web.dart';
 import 'package:sqlite3_web/src/channel.dart';
 import 'package:sqlite3_web/src/protocol.dart';
 import 'package:test/test.dart';
@@ -128,6 +129,47 @@ void main() {
       [1, Uint8List(10), null, 'string value'],
     );
   });
+
+  test('can serialize SqliteExceptions', () async {
+    server.handleRequestFunction = expectAsync1((req) {
+      throw SqliteException(
+        42,
+        'test exception',
+        'explanation',
+        'causingStatement',
+        [1, null, 'a'],
+        'operation',
+      );
+    });
+
+    await expectLater(
+      () => client.sendRequest(
+        RunQuery(
+          requestId: 0,
+          databaseId: 0,
+          sql: 'sql',
+          parameters: [],
+          returnRows: true,
+        ),
+        MessageType.rowsResponse,
+      ),
+      throwsA(
+        isA<RemoteException>().having(
+          (e) => e.exception,
+          'exception',
+          isA<SqliteException>()
+              .having((e) => e.extendedResultCode, 'extendedResultCode', 42)
+              .having((e) => e.message, 'message', 'test exception')
+              .having((e) => e.explanation, 'explanation', 'explanation')
+              .having((e) => e.operation, 'operation', 'operation')
+              .having((e) => e.causingStatement, 'causingStatement',
+                  'causingStatement')
+              .having((e) => e.parametersToStatement, 'parametersToStatement',
+                  [1, null, 'a']),
+        ),
+      ),
+    );
+  });
 }
 
 const isDart2Wasm = bool.fromEnvironment('dart.tool.dart2wasm');