Add support for recursive references in object types (#366)

Author: simonsinclair

index.js

@@ -47,10 +47,12 @@ function mergeLocation (source, dest) {
   }
 }
 
-const referenceSerializersMap = new Map()
+const arrayItemsReferenceSerializersMap = new Map()
+const objectReferenceSerializersMap = new Map()
 
 function build (schema, options) {
-  referenceSerializersMap.clear()
+  arrayItemsReferenceSerializersMap.clear()
+  objectReferenceSerializersMap.clear()
   options = options || {}
   isValidSchema(schema)
   if (options.schema) {
@@ -147,7 +149,8 @@ function build (schema, options) {
     return dependenciesName
   }
 
-  referenceSerializersMap.clear()
+  arrayItemsReferenceSerializersMap.clear()
+  objectReferenceSerializersMap.clear()
 
   return (Function.apply(null, dependenciesName).apply(null, dependencies))
 }
@@ -399,51 +402,60 @@ function addPatternProperties (location) {
     } catch (err) {
       throw new Error(`${err.message}. Found at ${regex} matching ${JSON.stringify(pp[regex])}`)
     }
-    code += `
-        if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {
-    `
+
+    const ifPpKeyExists = `if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {`
+
     if (type === 'object') {
       code += `${buildObject(ppLocation, '', 'buildObjectPP' + index)}
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + buildObjectPP${index}(obj[keys[i]])
       `
     } else if (type === 'array') {
       code += `${buildArray(ppLocation, '', 'buildArrayPP' + index)}
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + buildArrayPP${index}(obj[keys[i]])
       `
     } else if (type === 'null') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) +':null'
       `
     } else if (type === 'string') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + ${stringSerializer}(obj[keys[i]])
       `
     } else if (type === 'integer') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asInteger(obj[keys[i]])
       `
     } else if (type === 'number') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asNumber(obj[keys[i]])
       `
     } else if (type === 'boolean') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asBoolean(obj[keys[i]])
       `
     } else if (type === undefined) {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asAny(obj[keys[i]])
       `
     } else {
       code += `
+        ${ifPpKeyExists}
         throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
       `
     }
@@ -922,6 +934,16 @@ function buildObject (location, code, name) {
       }
   `
   }
+
+  if (objectReferenceSerializersMap.has(schema)) {
+    code += `
+      return ${objectReferenceSerializersMap.get(schema)}(input)
+    }
+    `
+    return code
+  }
+  objectReferenceSerializersMap.set(schema, name)
+
   code += `
       var obj = ${toJSON('input')}
       var json = '{'
@@ -978,14 +1000,14 @@ function buildArray (location, code, name, key = null) {
     location = refFinder(schema.items.$ref, location)
     schema.items = location.schema
 
-    if (referenceSerializersMap.has(schema.items)) {
+    if (arrayItemsReferenceSerializersMap.has(schema.items)) {
       code += `
-      return ${referenceSerializersMap.get(schema.items)}(obj)
+      return ${arrayItemsReferenceSerializersMap.get(schema.items)}(obj)
       }
       `
       return code
     }
-    referenceSerializersMap.set(schema.items, name)
+    arrayItemsReferenceSerializersMap.set(schema.items, name)
   }
 
   let result = { code: '', laterCode: '' }

test/recursion.test.js

@@ -135,3 +135,46 @@ test('use proper serialize function', t => {
   })
   t.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles","children":[{"name":"William","children":[{"name":"George"},{"name":"Charlotte"}]},{"name":"Harry"}]}]},"directory":{"name":"directory 1","subDirectories":[{"name":"directory 1.1","subDirectories":[]},{"name":"directory 1.2","subDirectories":[{"name":"directory 1.2.1","subDirectories":[]},{"name":"directory 1.2.2","subDirectories":[]}]}]}}')
 })
+
+test('can stringify recursive references in object types (issue #365)', t => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    definitions: {
+      parentCategory: {
+        type: 'object',
+        properties: {
+          parent: {
+            $ref: '#/definitions/parentCategory'
+          }
+        }
+      }
+    },
+    properties: {
+      category: {
+        type: 'object',
+        properties: {
+          parent: {
+            $ref: '#/definitions/parentCategory'
+          }
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const data = {
+    category: {
+      parent: {
+        parent: {
+          parent: {
+            parent: {}
+          }
+        }
+      }
+    }
+  }
+  const value = stringify(data)
+  t.equal(value, '{"category":{"parent":{"parent":{"parent":{"parent":{}}}}}}')
+})