Use rquickjs-serde implementation

crates/javy/Cargo.toml

@@ -16,6 +16,7 @@ rquickjs = { version = "0.10.0", features = [
     "bindgen",
     "disable-assertions",
 ] }
+rquickjs-serde = { version = "0.3.0", optional = true }
 serde = { workspace = true, default-features = true, features = ["derive"] }
 serde_json = { workspace = true, optional = true }
 serde-transcode = { version = "1.1", optional = true }
@@ -34,12 +35,12 @@ simd-json = { version = "0.17.0", optional = true, default-features = false, fea
 javy-test-macros = { path = "../test-macros/" }
 
 [features]
-messagepack = ["rmp-serde", "serde-transcode"]
+messagepack = ["rmp-serde", "serde-transcode", "rquickjs-serde"]
 # According to our benchmarks and experiments, the fastest and most efficient
 # JSON implementation comes from:
 # * Using SIMD JSON for parsing
 # * Using serde_json for stringifying
 # This implementation is behind a feature flag, because of the code size
 # implications of enabling by default (due to the extra dependencies) and also
 # because the native implementation is probably fine for most use-cases.
-json = ["serde_json", "serde-transcode", "simd-json"]
+json = ["serde_json", "serde-transcode", "simd-json", "rquickjs-serde"]

crates/javy/src/apis/json.rs

@@ -21,14 +21,14 @@ use crate::{
     Args, hold, json,
     quickjs::{
         Ctx, Exception, Function, Object, String as JSString, Value,
+        atom::PredefinedAtom,
         function::This,
         prelude::{MutFn, Rest},
+        qjs::JS_GetProperty,
     },
     to_js_error, val_to_string,
 };
 
-use crate::serde::de::get_to_json;
-
 use simd_json::Error as SError;
 
 use anyhow::{Result, anyhow, bail};
@@ -169,3 +169,21 @@ fn call_json_stringify(args: Args<'_>) -> Result<Value<'_>> {
             )),
     }
 }
+
+fn get_to_json<'a>(value: &Value<'a>) -> Option<Function<'a>> {
+    let f = unsafe {
+        JS_GetProperty(
+            value.ctx().as_raw().as_ptr(),
+            value.as_raw(),
+            PredefinedAtom::ToJSON as u32,
+        )
+    };
+    let f = unsafe { Value::from_raw(value.ctx().clone(), f) };
+    if f.is_function()
+        && let Some(f) = f.into_function()
+    {
+        Some(f)
+    } else {
+        None
+    }
+}

crates/javy/src/json.rs

@@ -1,6 +1,6 @@
 use crate::quickjs::{Ctx, Value};
-use crate::serde::{de::Deserializer, ser::Serializer};
 use anyhow::Result;
+use rquickjs_serde::{de::Deserializer, ser::Serializer};
 
 /// Transcodes a byte slice containing a JSON encoded payload into a [Value].
 pub fn parse<'js>(context: Ctx<'js>, bytes: &mut [u8]) -> Result<Value<'js>> {
@@ -14,7 +14,7 @@ pub fn parse<'js>(context: Ctx<'js>, bytes: &mut [u8]) -> Result<Value<'js>> {
 /// Transcodes a [Value] into a slice of JSON bytes.
 pub fn stringify(val: Value<'_>) -> Result<Vec<u8>> {
     let mut output: Vec<u8> = Vec::new();
-    let mut deserializer = Deserializer::from(val);
+    let mut deserializer = Deserializer::from(val).with_strict();
     let mut serializer = serde_json::Serializer::new(&mut output);
     serde_transcode::transcode(&mut deserializer, &mut serializer)?;
     Ok(output)

crates/javy/src/lib.rs

@@ -53,7 +53,6 @@ use std::str;
 
 mod config;
 mod runtime;
-mod serde;
 
 use anyhow::{Error, Result, anyhow};
 use rquickjs::{
@@ -129,7 +128,7 @@ pub fn to_js_error(cx: Ctx, e: Error) -> JSError {
         Ok(e) => e,
         Err(e) => {
             // In some cases the original error context is lost i.e. we can't
-            // retain the orginal JSError when invoking serde_transcode,
+            // retain the original JSError when invoking serde_transcode,
             // particularly for json::stringify. The process of transcoding will
             // report the Serializer error, which is totally implementation
             // dependent, in this case particular to serde_json::Error. To

crates/javy/src/messagepack.rs

@@ -1,6 +1,6 @@
 use crate::quickjs::{Ctx, Value};
-use crate::serde::{de::Deserializer, ser::Serializer};
 use anyhow::Result;
+use rquickjs_serde::{de::Deserializer, ser::Serializer};
 
 /// Transcodes a byte slice containing a MessagePack encoded payload into a [`JSValueRef`].
 ///
@@ -18,7 +18,7 @@ pub fn transcode_input<'js>(context: Ctx<'js>, bytes: &[u8]) -> Result<Value<'js
 /// Transcodes a [`JSValueRef`] into a MessagePack encoded byte vector.
 pub fn transcode_output(val: Value<'_>) -> Result<Vec<u8>> {
     let mut output = Vec::new();
-    let mut deserializer = Deserializer::from(val);
+    let mut deserializer = Deserializer::from(val).with_strict();
     let mut serializer = rmp_serde::Serializer::new(&mut output);
     serde_transcode::transcode(&mut deserializer, &mut serializer)?;
     Ok(output)