Add strict mode

Author: Sytten

README.md

@@ -51,6 +51,16 @@ fn main() {
 }
 ```
 
+## Strict mode
+
+The implementation tries to make smart guesses when it can, for example the deserializer will fallback to converting `BigInt` to `String`. This is likely not what you want if you implement a serialization that is JSON compliant.
+
+This is s why we offer the `strict` mode, that will stick to what the behaviour that the Javascript specification defines for `JSON`. Just switch the method to use it.
+
+```rust
+let u: User = rquickjs_serde::from_value_strict(val).unwrap();
+```
+
 ## Acknowledgements
 
 This project includes code derived from the [Javy](https://github.com/bytecodealliance/javy) project. See [`NOTICE`](./NOTICE) for more details.

src/de.rs

@@ -48,17 +48,33 @@ enum ClassId {
 /// });
 /// ```
 pub struct Deserializer<'js> {
-    pub value: Value<'js>,
+    value: Value<'js>,
+    /// In strict mode, only JSON-able values are allowed.
+    strict: bool,
     map_key: bool,
     current_kv: Option<(Value<'js>, Value<'js>)>,
     /// Stack to track circular dependencies.
     stack: Vec<Value<'js>>,
 }
 
+impl<'js> Deserializer<'js> {
+    pub fn new(value: Value<'js>) -> Self {
+        Self::from(value)
+    }
+
+    pub fn with_strict(self) -> Self {
+        Self {
+            strict: true,
+            ..self
+        }
+    }
+}
+
 impl<'de> From<Value<'de>> for Deserializer<'de> {
     fn from(value: Value<'de>) -> Self {
         Self {
             value,
+            strict: false,
             map_key: false,
             current_kv: None,
             // We are probaby over allocating here. But it's probably fine to
@@ -220,7 +236,9 @@ impl<'de> de::Deserializer<'de> for &mut Deserializer<'de> {
                 return self.deserialize_any(visitor);
             }
 
-            if let Some(f) = get_to_string(&self.value) {
+            if let Some(f) = get_to_string(&self.value)
+                && !self.strict
+            {
                 let v: Value = f.call((This(self.value.clone()),)).map_err(Error::new)?;
                 self.value = v;
                 return self.deserialize_any(visitor);

src/err.rs

@@ -82,7 +82,9 @@ impl fmt::Display for ErrorImpl {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             ErrorImpl::Message(msg) => write!(f, "{msg}"),
-            ErrorImpl::Rquickjs(e) => write!(f, "{e}"),
+            // JSError prefix is used by Javy because the serde_transcode.
+            // Keep it as-is for compatibility.
+            ErrorImpl::Rquickjs(e) => write!(f, "JSError: {e}"),
         }
     }
 }

src/lib.rs

@@ -127,6 +127,19 @@ where
     T::deserialize(&mut deserializer)
 }
 
+/// Interpret a `rquickjs::Value` as an instance of type `T` in strict mode.
+///
+/// Strict mode will stick to the behaviour of JSON.stringify.
+///
+/// See [from_value] for more information about the deserialization.
+pub fn from_value_strict<T>(value: Value) -> Result<T>
+where
+    T: DeserializeOwned,
+{
+    let mut deserializer = Deserializer::from(value).with_strict();
+    T::deserialize(&mut deserializer)
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::BTreeMap;