Fixing Node.js nested object serialization issue (#3)

Author: mathewc

sample/QueueTrigger/index.js

@@ -1,7 +1,7 @@
 var util = require('util');
 
 module.exports = function (context) {
-    context.log('Node.js queue trigger function processed work item ' + util.inspect(context.workItem.id));
+    context.log('Node.js queue trigger function processed work item ' + context.workItem.id);
 
     context.output({
         receipt: JSON.stringify(context.workItem)

src/WebJobs.Script/Description/NodeFunctionInvoker.cs

@@ -118,9 +118,10 @@ private Dictionary<string, object> CreateContext(object input, TraceWriter trace
             Type triggerParameterType = input.GetType();
             if (triggerParameterType == typeof(string))
             {
-                // convert string into Dictionary which Edge will convert into an object
+                // convert string into Dictionary (recursively) which Edge will convert into an object
                 // before invoking the function
-                input = JsonConvert.DeserializeObject<Dictionary<string, object>>((string)input);
+                input = JsonConvert.DeserializeObject<Dictionary<string, object>>(
+                    (string)input, new DictionaryJsonConverter());
             }
 
             // create a TraceWriter wrapper that can be exposed to Node.js

src/WebJobs.Script/DictionaryJsonConverter.cs

@@ -0,0 +1,155 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Microsoft.Azure.WebJobs.Script
+{
+
+    public class DictionaryJsonConverter : JsonConverter
+    {
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            WriteValue(writer, value);
+        }
+
+        private void WriteValue(JsonWriter writer, object value)
+        {
+            var token = JToken.FromObject(value);
+            switch (token.Type)
+            {
+                case JTokenType.Object:
+                    WriteObject(writer, value);
+                    break;
+                case JTokenType.Array:
+                    WriteArray(writer, value);
+                    break;
+                default:
+                    writer.WriteValue(value);
+                    break;
+            }
+        }
+
+        private void WriteObject(JsonWriter writer, object value)
+        {
+            writer.WriteStartObject();
+
+            var obj = value as IDictionary<string, object>;
+            foreach (var kvp in obj)
+            {
+                writer.WritePropertyName(kvp.Key);
+                WriteValue(writer, kvp.Value);
+            }
+
+            writer.WriteEndObject();
+        }
+
+        private void WriteArray(JsonWriter writer, object value)
+        {
+            writer.WriteStartArray();
+
+            var array = value as IEnumerable<object>;
+            foreach (var o in array)
+            {
+                WriteValue(writer, o);
+            }
+
+            writer.WriteEndArray();
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            return ReadValue(reader);
+        }
+
+        private object ReadValue(JsonReader reader)
+        {
+            while (reader.TokenType == JsonToken.Comment)
+            {
+                if (!reader.Read())
+                {
+                    throw new JsonSerializationException("Unexpected Token when converting IDictionary<string, object>");
+                }
+            }
+
+            switch (reader.TokenType)
+            {
+                case JsonToken.StartObject:
+                    return ReadObject(reader);
+                case JsonToken.StartArray:
+                    return ReadArray(reader);
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                case JsonToken.String:
+                case JsonToken.Boolean:
+                case JsonToken.Undefined:
+                case JsonToken.Null:
+                case JsonToken.Date:
+                case JsonToken.Bytes:
+                    return reader.Value;
+                default:
+                    string msg = string.Format("Unexpected token when converting IDictionary<string, object>: {0}", reader.TokenType);
+                    throw new JsonSerializationException(msg);
+            }
+        }
+
+        private object ReadArray(JsonReader reader)
+        {
+            IList<object> list = new List<object>();
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.Comment:
+                        break;
+                    default:
+                        var value = ReadValue(reader);
+                        list.Add(value);
+                        break;
+                    case JsonToken.EndArray:
+                        return list;
+                }
+            }
+
+            throw new JsonSerializationException("Unexpected end when reading IDictionary<string, object>");
+        }
+
+        private object ReadObject(JsonReader reader)
+        {
+            var obj = new Dictionary<string, object>();
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        var propertyName = reader.Value.ToString();
+
+                        if (!reader.Read())
+                        {
+                            throw new JsonSerializationException("Unexpected end when reading IDictionary<string, object>");
+                        }
+
+                        var value = ReadValue(reader);
+                        obj[propertyName] = value;
+                        break;
+                    case JsonToken.Comment:
+                        break;
+                    case JsonToken.EndObject:
+                        return obj;
+                }
+            }
+
+            throw new JsonSerializationException("Unexpected end when reading IDictionary<string, object>");
+        }
+
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(IDictionary<string, object>).IsAssignableFrom(objectType);
+        }
+    }
+}

src/WebJobs.Script/WebJobs.Script.csproj

@@ -179,6 +179,7 @@
     <Compile Include="Description\ScriptFunctionInvoker.cs" />
     <Compile Include="Description\NodeFunctionDescriptorProvider.cs" />
     <Compile Include="Description\NodeFunctionInvoker.cs" />
+    <Compile Include="DictionaryJsonConverter.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Config\ScriptHostConfiguration.cs" />
     <Compile Include="Config\TypeLocator.cs" />