Merge pull request #7 from Vinzent03/feat/isolates

feat: isolates for json en-/decoding

Author: dshukertjr

CHANGELOG.md

@@ -1,3 +1,7 @@
+## [1.0.0-dev.2]
+
+- feat: use isolates for json encoding/decoding
+
 ## [1.0.0-dev.1]
 
 - chore: Update lints to v2.0.0

lib/src/_isolates_io.dart

@@ -0,0 +1,129 @@
+//Modified from package:flutter/foundation/_isolates_io.dart
+
+import 'dart:async';
+import 'dart:isolate';
+
+import 'isolates.dart' as isolates;
+
+/// The dart:io implementation of [isolate.compute].
+Future<R> compute<Q, R>(
+    isolates.ComputeCallback<Q, R> callback, Q message) async {
+  final RawReceivePort port = RawReceivePort();
+
+  void cleanup() {
+    port.close();
+  }
+
+  final Completer<dynamic> completer = Completer<dynamic>();
+  port.handler = (dynamic msg) {
+    cleanup();
+    completer.complete(msg);
+  };
+
+  try {
+    await Isolate.spawn<_IsolateConfiguration<Q, R>>(
+      _spawn,
+      _IsolateConfiguration<Q, R>(
+        callback,
+        message,
+        port.sendPort,
+      ),
+      errorsAreFatal: true,
+      onExit: port.sendPort,
+      onError: port.sendPort,
+    );
+  } on Object {
+    cleanup();
+    rethrow;
+  }
+
+  final dynamic response = await completer.future;
+  if (response == null) {
+    throw RemoteError('Isolate exited without result or error.', '');
+  }
+
+  assert(response is List<dynamic>);
+  response as List<dynamic>;
+
+  final int type = response.length;
+  assert(1 <= type && type <= 3);
+
+  switch (type) {
+    // success; see _buildSuccessResponse
+    case 1:
+      return response[0] as R;
+
+    // native error; see Isolate.addErrorListener
+    case 2:
+      await Future<Never>.error(RemoteError(
+        response[0] as String,
+        response[1] as String,
+      ));
+
+    // caught error; see _buildErrorResponse
+    case 3:
+    default:
+      assert(type == 3 && response[2] == null);
+
+      await Future<Never>.error(
+        response[0] as Object,
+        response[1] as StackTrace,
+      );
+  }
+}
+
+class _IsolateConfiguration<Q, R> {
+  const _IsolateConfiguration(
+    this.callback,
+    this.message,
+    this.resultPort,
+  );
+  final isolates.ComputeCallback<Q, R> callback;
+  final Q message;
+  final SendPort resultPort;
+
+  FutureOr<R> apply() {
+    return callback(message);
+  }
+}
+
+/// The spawn point MUST guarantee only one result event is sent through the
+/// [SendPort.send] be it directly or indirectly i.e. [Isolate.exit].
+///
+/// In case an [Error] or [Exception] are thrown AFTER the data
+/// is sent, they will NOT be handled or reported by the main [Isolate] because
+/// it stops listening after the first event is received.
+///
+/// Also use the helpers [_buildSuccessResponse] and [_buildErrorResponse] to
+/// build the response
+Future<void> _spawn<Q, R>(_IsolateConfiguration<Q, R> configuration) async {
+  late final List<dynamic> computationResult;
+
+  try {
+    computationResult = _buildSuccessResponse(await configuration.apply());
+  } catch (e, s) {
+    computationResult = _buildErrorResponse(e, s);
+  }
+
+  Isolate.exit(configuration.resultPort, computationResult);
+}
+
+/// Wrap in [List] to ensure our expectations in the main [Isolate] are met.
+///
+/// We need to wrap a success result in a [List] because the user provided type
+/// [R] could also be a [List]. Meaning, a check `result is R` could return true
+/// for what was an error event.
+List<R> _buildSuccessResponse<R>(R result) {
+  return List<R>.filled(1, result);
+}
+
+/// Wrap in [List] to ensure our expectations in the main isolate are met.
+///
+/// We wrap a caught error in a 3 element [List]. Where the last element is
+/// always null. We do this so we have a way to know if an error was one we
+/// caught or one thrown by the library code.
+List<dynamic> _buildErrorResponse(Object error, StackTrace stack) {
+  return List<dynamic>.filled(3, null)
+    ..[0] = error
+    ..[1] = stack;
+}

lib/src/_isolates_web.dart

@@ -0,0 +1,13 @@
+//Copied from package:flutter/foundation/_isolates_web.dart
+
+import 'isolates.dart' as isolates;
+
+/// The dart:html implementation of [isolates.compute].
+Future<R> compute<Q, R>(isolates.ComputeCallback<Q, R> callback, Q message,
+    {String? debugLabel}) async {
+  // To avoid blocking the UI immediately for an expensive function call, we
+  // pump a single frame to allow the framework to complete the current set
+  // of work.
+  await null;
+  return callback(message);
+}

lib/src/functions_client.dart

@@ -4,6 +4,8 @@ import 'package:functions_client/src/constants.dart';
 import 'package:functions_client/src/types.dart';
 import 'package:http/http.dart' as http;
 
+import 'isolates.dart';
+
 class FunctionsClient {
   final String _url;
   final Map<String, String> _headers;
@@ -40,15 +42,17 @@ class FunctionsClient {
     ResponseType responseType = ResponseType.json,
   }) async {
     try {
+      final bodyStr = await compute(json.encode, body);
+
       final response = await (_httpClient?.post ?? http.post)(
         Uri.parse('$_url/$functionName'),
         headers: <String, String>{..._headers, if (headers != null) ...headers},
-        body: jsonEncode(body),
+        body: bodyStr,
       );
 
       final dynamic data;
       if (responseType == ResponseType.json) {
-        data = json.decode(response.body);
+        data = await compute(json.decode, response.body);
       } else if (responseType == ResponseType.blob) {
         data = response.bodyBytes;
       } else if (responseType == ResponseType.arraybuffer) {

lib/src/isolates.dart

@@ -0,0 +1,14 @@
+//Modified from package:flutter/foundation/isolates.dart
+
+import 'dart:async';
+
+import '_isolates_io.dart' if (dart.library.html) '_isolates_web.dart'
+    as isolates;
+
+typedef ComputeCallback<Q, R> = FutureOr<R> Function(Q message);
+typedef ComputeImpl = Future<R> Function<Q, R>(
+  ComputeCallback<Q, R> callback,
+  Q message,
+);
+
+const ComputeImpl compute = isolates.compute;

lib/src/version.dart

@@ -1 +1 @@
-const version = '1.0.0-dev.1';
+const version = '1.0.0-dev.2';

pubspec.yaml

@@ -1,6 +1,6 @@
 name: functions_client
 description: A dart client library for the Supabase functions.
-version: 1.0.0-dev.1
+version: 1.0.0-dev.2
 homepage: 'https://supabase.io'
 repository: 'https://github.com/supabase-community/functions-dart'