Fix/ref to (#137)

* add: quick and dirty solution for $ref with plan name fragment $id

* add: test with multiple $ref formats

* fix: search for ids in plain format when needed

* fix: finder for JSON schema id as top level function

Author: Eomm

index.js

@@ -424,19 +424,42 @@ function addAdditionalProperties (schema, externalSchema, fullSchema) {
   `
 }
 
+function idFinder (schema, searchedId) {
+  let objSchema
+  const explore = (schema, searchedId) => {
+    Object.keys(schema || {}).forEach((key, i, a) => {
+      if (key === '$id' && schema[key] === searchedId) {
+        objSchema = schema
+      } else if (objSchema === undefined && typeof schema[key] === 'object') {
+        explore(schema[key], searchedId)
+      }
+    })
+  }
+  explore(schema, searchedId)
+  return objSchema
+}
+
 function refFinder (ref, schema, externalSchema) {
   // Split file from walk
   ref = ref.split('#')
+
   // If external file
   if (ref[0]) {
     schema = externalSchema[ref[0]]
   }
+
   var code = 'return schema'
   // If it has a path
   if (ref[1]) {
+    // ref[1] could contain a JSON pointer - ex: /definitions/num
+    // or plan name fragment id without suffix # - ex: customId
     var walk = ref[1].split('/')
-    for (var i = 1; i < walk.length; i++) {
-      code += `['${walk[i]}']`
+    if (walk.length === 1) {
+      return idFinder(schema, `#${ref[1]}`)
+    } else {
+      for (var i = 1; i < walk.length; i++) {
+        code += `['${walk[i]}']`
+      }
     }
   }
   return (new Function('schema', code))(schema)

test/ref.test.js

@@ -389,3 +389,98 @@ test('ref internal - deepObject schema', (t) => {
 
   t.equal(output, '{"winter":{"is":{"coming":{"where":"to town"}}}}')
 })
+
+test('ref internal - plain name fragment', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with $ref',
+    definitions: {
+      def: {
+        $id: '#uri',
+        type: 'object',
+        properties: {
+          str: {
+            type: 'string'
+          }
+        },
+        required: ['str']
+      }
+    },
+    type: 'object',
+    properties: {
+      obj: {
+        $ref: '#uri'
+      }
+    }
+  }
+
+  const object = {
+    obj: {
+      str: 'test'
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify(object)
+
+  try {
+    JSON.parse(output)
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+
+  t.equal(output, '{"obj":{"str":"test"}}')
+})
+
+test('ref internal - multiple $ref format', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    definitions: {
+      one: {
+        type: 'string',
+        definitions: {
+          two: {
+            $id: '#twos',
+            type: 'string'
+          }
+        }
+      }
+    },
+    properties: {
+      zero: {
+        $id: '#three',
+        type: 'string'
+      },
+      a: { $ref: '#/definitions/one' },
+      b: { $ref: '#three' },
+      c: { $ref: '#/properties/zero' },
+      d: { $ref: '#twos' },
+      e: { $ref: '#/definitions/one/definitions/two' }
+    }
+  }
+
+  const object = {
+    zero: 'test',
+    a: 'test',
+    b: 'test',
+    c: 'test',
+    d: 'test',
+    e: 'test'
+  }
+
+  const stringify = build(schema)
+  const output = stringify(object)
+
+  try {
+    JSON.parse(output)
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+
+  t.equal(output, '{"zero":"test","a":"test","b":"test","c":"test","d":"test","e":"test"}')
+})