auto deserialize JsonPayload data over bridge

Author: codekeyz

packages/globe_runtime/lib/src/runtime_data.dart

@@ -17,7 +17,8 @@ enum FFITypeId {
   integer(2),
   double(3),
   bool(4),
-  bytes(5);
+  bytes(5),
+  json_payload(6);
 
   final int value;
   const FFITypeId(this.value);
@@ -30,9 +31,10 @@ extension FFITypeExtension on Object {
         double() => FFIDouble(this as double),
         bool() => FFIBool(this as bool),
         List<int>() => FFIBytes(this as List<int>),
-        JsonPayload() => FFIBytes((this as JsonPayload).data),
-        _ =>
-          throw UnimplementedError('FFIConvertible not found for $runtimeType'),
+        Map() => FFIJsonPayload(this),
+        List() => FFIJsonPayload(this),
+        Set() => FFIJsonPayload(this),
+        _ => FFIJsonPayload(this as Map),
       };
 }
 
@@ -62,6 +64,14 @@ class FFIInt implements FFIConvertible {
   FFITypeId get typeId => FFITypeId.integer;
 }
 
+class FFIJsonPayload<T> extends FFIBytes {
+  final T data;
+  FFIJsonPayload(this.data) : super(msg_parkr.serialize(data));
+
+  @override
+  FFITypeId get typeId => FFITypeId.json_payload;
+}
+
 class FFIDouble implements FFIConvertible {
   final double value;
   FFIDouble(this.value);
@@ -154,8 +164,5 @@ extension MessagePackrExtensionForListInt on List<int> {
 }
 
 extension MessagePackrExtensionForObject<T> on T {
-  FFIBytes pack() {
-    final bytes = msg_parkr.serialize(this);
-    return FFIBytes(bytes);
-  }
+  FFIJsonPayload pack() => FFIJsonPayload(this);
 }

packages/globe_runtime/test/module.js

@@ -18,11 +18,8 @@ const sdk = {
         })
       );
     },
-    json_decode: function (_, encoded, DartCallbackId) {
-      const data = JsonPayload.decode(encoded);
-
-      const mapKeys = Object.keys(data);
-
+    json_decode: function (_, jsonData, DartCallbackId) {
+      const mapKeys = Object.keys(jsonData);
       Dart.send_value(DartCallbackId, JsonPayload.encode(mapKeys));
     },
     say_hello: function (_, name, DartCallbackId) {
@@ -60,6 +57,9 @@ const sdk = {
         Dart.send_error(DartCallbackId, `Fetch failed: ${err.message}`);
       }
     },
+    throw_error: function (_, DartCallbackId) {
+      throw new Error("This is a simulated error");
+    },
   },
 };
 

packages/globe_runtime/test/runtime_test.dart

@@ -88,8 +88,7 @@ void main() {
     });
 
     test('should decode object', () async {
-      final mapDataAsArg = mapData.pack();
-      final result = await callJsFunction('json_decode', args: [mapDataAsArg])
+      final result = await callJsFunction('json_decode', args: [mapData.pack()])
           .then((data) => data.unpack());
 
       expect(
@@ -154,4 +153,16 @@ void main() {
       ]),
     );
   });
+
+  test('should catch errors from Javascript', () async {
+    try {
+      runtime.callFunction(
+        moduleName,
+        function: 'throw_error',
+        onData: (data) => true,
+      );
+    } catch (e) {
+      expect(e, isA<StateError>());
+    }
+  });
 }

src/dart_runtime.ts

@@ -3,7 +3,6 @@ import {
   DartJSService,
   RpcResponse,
   SendValueRequest,
-  JsonPayload,
 } from "./dart_runtime_entry.ts";
 import * as msgPackr from "ext:js_msg_packr/index.js";
 

src/js_runtime.rs

@@ -226,6 +226,7 @@ pub enum FFITypeId {
     Double = 3,
     Bool = 4,
     Bytes = 5,
+    JsonPayload = 6,
 }
 
 impl FFITypeId {
@@ -238,6 +239,7 @@ impl FFITypeId {
             3 => Some(FFITypeId::Double),
             4 => Some(FFITypeId::Bool),
             5 => Some(FFITypeId::Bytes),
+            6 => Some(FFITypeId::JsonPayload),
             _ => None,
         }
     }
@@ -287,15 +289,10 @@ pub fn c_args_to_v8_args_global(
                 v8::Boolean::new(scope, bool_value).into()
             }
             Some(FFITypeId::Bytes) => {
-                let byte_array =
-                    unsafe { std::slice::from_raw_parts(arg_ptr as *const u8, size as usize) };
-
-                let v8_array = v8::ArrayBuffer::new_backing_store_from_boxed_slice(
-                    byte_array.to_vec().into_boxed_slice(),
-                );
-                let v8_shared_array = v8_array.make_shared();
-                let v8_buffer = v8::ArrayBuffer::with_backing_store(scope, &v8_shared_array);
-                v8_buffer.into()
+                parse_byte_data(scope, arg_ptr as *const u8, size as usize).into()
+            }
+            Some(FFITypeId::JsonPayload) => {
+                parse_json_payload_bytes(scope, arg_ptr as *const u8, size as usize).into()
             }
             _ => v8::undefined(scope).into(),
         };
@@ -307,6 +304,50 @@ pub fn c_args_to_v8_args_global(
     v8_args
 }
 
+fn parse_byte_data<'a>(
+    scope: &mut v8::HandleScope<'a>,
+    arg_ptr: *const u8,
+    size: usize,
+) -> v8::Local<'a, v8::ArrayBuffer> {
+    let byte_array = unsafe { std::slice::from_raw_parts(arg_ptr, size) };
+
+    let v8_array =
+        v8::ArrayBuffer::new_backing_store_from_boxed_slice(byte_array.to_vec().into_boxed_slice());
+    let v8_shared_array = v8_array.make_shared();
+    let v8_buffer = v8::ArrayBuffer::with_backing_store(scope, &v8_shared_array);
+    v8_buffer
+}
+
+fn parse_json_payload_bytes<'a>(
+    scope: &mut v8::HandleScope<'a>,
+    arg_ptr: *const u8,
+    size: usize,
+) -> v8::Local<'a, v8::Value> {
+    let v8_buffer = parse_byte_data(scope, arg_ptr, size);
+
+    // call JsonPayload.decode() from the runtime add pass the v8_buffer as an argument
+    let json_payload = v8::String::new(scope, "JsonPayload").unwrap();
+    let json_payload_value = scope
+        .get_current_context()
+        .global(scope)
+        .get(scope, json_payload.into())
+        .unwrap();
+
+    let decode_function = v8::String::new(scope, "decode").unwrap();
+    let decode_function_value = json_payload_value
+        .to_object(scope)
+        .unwrap()
+        .get(scope, decode_function.into())
+        .unwrap();
+    let decode_function = v8::Local::<v8::Function>::try_from(decode_function_value).unwrap();
+    let args = vec![v8_buffer.into()];
+    let result = decode_function
+        .call(scope, json_payload_value.into(), &args)
+        .unwrap();
+    let result = v8::Local::<v8::Value>::try_from(result).unwrap();
+    result
+}
+
 pub fn c_args_to_v8_args_local<'s>(
     scope: &mut v8::HandleScope<'s>,
     args: *const *const c_void,
@@ -350,15 +391,10 @@ pub fn c_args_to_v8_args_local<'s>(
                 v8::Boolean::new(scope, bool_value).into()
             }
             Some(FFITypeId::Bytes) => {
-                let byte_array =
-                    unsafe { std::slice::from_raw_parts(arg_ptr as *const u8, size as usize) };
-
-                let v8_array = v8::ArrayBuffer::new_backing_store_from_boxed_slice(
-                    byte_array.to_vec().into_boxed_slice(),
-                );
-                let v8_shared_array = v8_array.make_shared();
-                let v8_buffer = v8::ArrayBuffer::with_backing_store(scope, &v8_shared_array);
-                v8_buffer.into()
+                parse_byte_data(scope, arg_ptr as *const u8, size as usize).into()
+            }
+            Some(FFITypeId::JsonPayload) => {
+                parse_json_payload_bytes(scope, arg_ptr as *const u8, size as usize).into()
             }
             _ => v8::undefined(scope).into(),
         };

src/lib.rs

@@ -241,11 +241,11 @@ pub unsafe extern "C" fn call_js_function(
 
                 // Wait for module execution
                 if let Err(e) = javascript_runtime.run_event_loop(Default::default()).await {
-                    return Err(format!("Error running event loop: {}", e));
+                    return Err(e.to_string());
                 }
 
                 if let Err(e) = fnc_call.await {
-                    return Err(format!("Error running function: {}", e));
+                    return Err(e.to_string());
                 }
 
                 Ok(())