JSON.stringify with interop (ObjectWrapper/TypeReference)?

[ajdust]

I am using some C# inside scripts. However, when attempting to use JSON.stringify I run into a JavaScriptException 'Cyclic reference detected'.

Is there a way to have Jint use a JSON serializer for C# objects? Using the latest 3.0.0-beta-2038. Below is an example. Thanks.

Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(TimeSpan.FromSeconds(3))); // "00:00:03"
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(TimeSpan.FromSeconds(3))); // "00:00:03

var engine = new Jint.Engine((Jint.Options options) =>
{
  options.Strict();
  options.LimitRecursion();
});

engine.SetValue("TimeSpan", TypeReference.CreateTypeReference(engine, typeof(TimeSpan)));
var val = engine.Evaluate(@"
return JSON.stringify(TimeSpan.FromSeconds(3));
"); // JavaScriptException 'Cyclic reference detected', but expecting "00:00:03"

Console.WriteLine(val);

[lahma]

Because both NJSON and STJ have implicit knowledge how to serialize specific types it's easier for those libraries. I found a workaround where you can return custom toJSON implementation for interop objects using custom member accessor.

jint/Jint.Tests/Runtime/InteropTests.Json.cs

Lines 81 to 109 in cb4e73d

	[Fact]
	public void CanStringifyTimeSpanUsingCustomToJsonHook()
	{
	var engine = new Engine(options =>
	{
	options.Interop.MemberAccessor = (e, target, member) =>
	{
	// custom serializer hook for known object types
	if (member == "toJSON" && target is TimeSpan)
	{
	return new ClrFunctionInstance(e, "toJSON", (thisObject, _) =>
	{
	// here could check other types too
	var wrappedInstance = ((IObjectWrapper) thisObject).Target;
	return wrappedInstance.ToString();
	});
	}
	return null;
	};
	});
	var expected = Newtonsoft.Json.JsonConvert.SerializeObject(TimeSpan.FromSeconds(3));
	engine.SetValue("TimeSpan", TypeReference.CreateTypeReference<TimeSpan>(engine));
	var value = engine.Evaluate("JSON.stringify(TimeSpan.FromSeconds(3));");
	Assert.Equal(expected, value);
	}

So requires some manual plumbing work, but I think the sample should cover your use case. Ideally I think this would be possible by setting toJSON to TypeReference after its creation, but in your sample you use FromSeconds which evades current type reference from being the prototype, type reference would be the prototype if you'd call new TimeSpan().

One possible enhancement could be to allow such toJson callback in interop configuration if IObjectWrapper is detected as serialization target, that would probably reduce amount of needed code, PR is welcome!

[ajdust]

Thanks @lahma I really appreciate the quick answer. That works in the simple case of TimeSpan, but

Perhaps the example I gave was too simple 😅. Looking at something more realistic, consider using an anonymous type (with Newtonsoft set to snake_case just to help distinguish what it outputs). Following the pattern you provided using toJSON yields a double-quoted JSON string unfortunately, see below. If you know a workaround for that, that'd be cool.

In terms of a PR to add a new feature, I'd argue we shouldn't be mixing toJSON a JavaScript serialization concept with native .NET serializing like Newtonsoft. Would it be kosher to directly check for an interop in JsonSerializer? See https://github.com/sebastienros/jint/pull/1232/files

Func<object, string> serialize = (o) => Newtonsoft.Json.JsonConvert.SerializeObject(o,
    new Newtonsoft.Json.JsonSerializerSettings
    {
        ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver
        { NamingStrategy = new Newtonsoft.Json.Serialization.SnakeCaseNamingStrategy() }
    });

var engine = new Jint.Engine((Jint.Options options) =>
{
    options.Strict();
    options.LimitRecursion();
    options.Interop.MemberAccessor = (e, target, member) =>
    {
        if (member == "toJSON" && target is object)
        {
            return new ClrFunctionInstance(e, "toJSON", (thisObject, _) =>
            {
                var wrappedInstance = ((IObjectWrapper)thisObject).Target;
                return serialize(wrappedInstance);
            });
        }
        
        return null;
    };
});

var test = new { FooBar = "Bar" };
Console.WriteLine(serialize(test)); // {"foo_bar":"Bar"}
engine.SetValue("Test", test);
Console.WriteLine(engine.Evaluate(@"return JSON.stringify(Test);").ToString()); // "{\"foo_bar\":\"Bar\"}"

[lahma]

The PR looks good. I think my workaround could sniff some things to work out the kinks, but the PR gives a proper customization point for this case, thank you for investing to build it!