Add support for Proxy objects in JSON serialization and logging (#1401)

Author: richarddavison

libs/llrt_json/src/stringify.rs

@@ -133,7 +133,11 @@ fn run_to_json<'js>(
 
     //only preserve indentation if we're returning nested data
     let indentation = context.indentation.and_then(|indentation| {
-        matches!(val.type_of(), Type::Object | Type::Array | Type::Exception).then_some(indentation)
+        matches!(
+            val.type_of(),
+            Type::Object | Type::Array | Type::Exception | Type::Proxy
+        )
+        .then_some(indentation)
     });
 
     append_value(
@@ -438,7 +442,7 @@ fn iterate<'js>(
     let ctx = context.ctx;
     let indentation = context.indentation;
     match elem.type_of() {
-        Type::Object | Type::Exception => {
+        Type::Object | Type::Exception | Type::Proxy => {
             let js_object = unsafe { elem.as_object().unwrap_unchecked() };
             if js_object.contains_key(PredefinedAtom::ToJSON)? {
                 return run_to_json(context, js_object);
@@ -461,8 +465,25 @@ fn iterate<'js>(
 
             value_written = false;
 
-            for key in js_object.keys::<String>() {
-                let key = key?;
+            // Collect keys: js_object.keys() uses JS_GetOwnPropertyNames which can fail for
+            // Proxy objects. Fall back to Object.keys() in that case.
+            let keys: Vec<String> = {
+                let collected: Vec<String> = js_object.keys::<String>().flatten().collect();
+                if collected.is_empty() {
+                    // Clear any pending exception and try Object.keys() for Proxy support
+                    ctx.catch();
+                    ctx.globals()
+                        .get::<_, Object>("Object")
+                        .ok()
+                        .and_then(|o| o.get::<_, Function>("keys").ok())
+                        .and_then(|f| f.call::<_, Vec<String>>((js_object.clone(),)).ok())
+                        .unwrap_or_default()
+                } else {
+                    collected
+                }
+            };
+
+            for key in keys {
                 let val = js_object.get(&key)?;
 
                 add_comma = append_value(

libs/llrt_logging/src/lib.rs

@@ -455,7 +455,7 @@ fn format_raw_inner<'js>(
             result.push('}');
             return Ok(());
         },
-        Type::Array | Type::Object | Type::Exception => {
+        Type::Array | Type::Object | Type::Exception | Type::Proxy => {
             let hash = hash::default_hash(&value);
             if visited.contains(&hash) {
                 if color_enabled {
@@ -661,10 +661,71 @@ fn write_object<'js>(
     let mut keys = obj.keys();
     let mut filter_functions = false;
     if !is_array && keys.len() == 0 {
+        // Clear any pending exception from JS_GetOwnPropertyNames (e.g. on Proxy objects)
+        let ctx = obj.ctx();
+        ctx.catch();
+        // Try Object.keys() which correctly handles Proxy objects
+        let proxy_keys: Option<Vec<String>> = ctx
+            .globals()
+            .get::<_, Object>("Object")
+            .ok()
+            .and_then(|o| o.get::<_, Function>("keys").ok())
+            .and_then(|f| f.call::<_, Vec<String>>((obj.clone(),)).ok());
+        if let Some(pk) = proxy_keys {
+            if !pk.is_empty() {
+                let apply_indentation = depth < 2;
+                let mut first = false;
+                let length = pk.len();
+                for (i, key) in pk.iter().enumerate() {
+                    let value: Value = obj.get::<&str, _>(key.as_str())?;
+                    let numeric_key = key.parse::<f64>().is_ok();
+                    write_sep(result, first, apply_indentation, options.newline);
+                    if apply_indentation {
+                        push_indentation(result, depth + 1);
+                    }
+                    if depth > MAX_INDENTATION_LEVEL - 1 {
+                        result.push(SPACING);
+                    }
+                    format_raw_string_inner(
+                        result,
+                        key.clone(),
+                        numeric_key,
+                        numeric_key & color_enabled,
+                    );
+                    if numeric_key && color_enabled {
+                        Color::reset(result);
+                    }
+                    result.push(':');
+                    result.push(SPACING);
+                    format_raw_inner(result, value, options, visited, depth + 1)?;
+                    first = true;
+                    if i > 99 {
+                        result.push_str("... ");
+                        let mut buffer = itoa::Buffer::new();
+                        result.push_str(buffer.format(length - i));
+                        result.push_str(" more items");
+                        break;
+                    }
+                }
+                if first {
+                    if apply_indentation {
+                        result.push(if options.newline {
+                            NEWLINE
+                        } else {
+                            CARRIAGE_RETURN
+                        });
+                        push_indentation(result, depth);
+                    } else {
+                        result.push(SPACING);
+                    }
+                }
+                result.push('}');
+                return Ok(());
+            }
+        }
         if let Some(proto) = obj.get_prototype() {
             if proto != options.object_prototype {
                 keys = proto.own_keys(options.object_filter);
-
                 filter_functions = true;
             }
         }

libs/llrt_utils/src/clone.rs

@@ -5,7 +5,7 @@ use std::collections::HashSet;
 use rquickjs::{
     atom::PredefinedAtom,
     function::{Constructor, Opt, This},
-    Array, ArrayBuffer, Ctx, Function, IntoJs, Null, Object, Result, Type, Value,
+    Array, ArrayBuffer, Ctx, Exception, Function, IntoJs, Null, Object, Result, Type, Value,
 };
 
 use super::{
@@ -79,6 +79,12 @@ pub fn structured_clone<'js>(
                     }
                 }
                 match value.type_of() {
+                    Type::Proxy => {
+                        return Err(Exception::throw_type(
+                            ctx,
+                            "A Proxy value could not be cloned",
+                        ));
+                    },
                     Type::Object => {
                         if check_circular(
                             &mut tape,

modules/llrt_assert/src/lib.rs

@@ -29,6 +29,7 @@ fn ok(ctx: Ctx, value: Value, message: Opt<Value>) -> Result<()> {
         | Type::Constructor
         | Type::Exception
         | Type::Function
+        | Type::Proxy
         | Type::Symbol
         | Type::Object => {
             return Ok(());

tests/unit/console.test.ts

@@ -166,6 +166,17 @@ it("should log complex object", () => {
   );
 });
 
+it("should log Proxy object", () => {
+  const target = { a: 1, b: "foo" };
+  const proxy = new Proxy(target, {
+    set(t, p, v) {
+      t[p] = v;
+      return true;
+    },
+  });
+  expect(util.format(proxy)).toEqual(`{\n  a: 1,\n  b: 'foo'\n}`);
+});
+
 it("should log Headers", () => {
   const headers = new Headers();
   headers.append("foo", "bar");