Support for external $ref plain name fragment (#161)

* Added resolve for fragment id in externalSchema

* Added test and fixed undefined resolve

* Changed the test to have a slash inside the schema

* Fixed test and changed dereferencing logic

* Removed ajv compiling when resolving refs

* Updated tests

* Added a test for duplicate schemas

* Don't resolve to other schemas on explicit ref

* Changed the $id in the last test

* Better $id in the last test again

Author: yndc

index.js

@@ -483,10 +483,18 @@ function refFinder (ref, schema, externalSchema) {
   // 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
+    // or plain name fragment id without suffix # - ex: customId
     var walk = ref[1].split('/')
     if (walk.length === 1) {
-      return idFinder(schema, `#${ref[1]}`)
+      var targetId = `#${ref[1]}`
+      var dereferenced = idFinder(schema, targetId)
+      if (dereferenced === undefined && !ref[0]) {
+        for (var key of Object.keys(externalSchema)) {
+          dereferenced = idFinder(externalSchema[key], targetId)
+          if (dereferenced !== undefined) break
+        }
+      }
+      return dereferenced
     } else {
       for (var i = 1; i < walk.length; i++) {
         code += `['${walk[i]}']`

test/ref.test.js

@@ -434,6 +434,206 @@ test('ref internal - plain name fragment', (t) => {
   t.equal(output, '{"obj":{"str":"test"}}')
 })
 
+test('ref external - plain name fragment', (t) => {
+  t.plan(2)
+
+  const externalSchema = {
+    first: {
+      $id: '#first-schema',
+      type: 'object',
+      properties: {
+        str: {
+          type: 'string'
+        }
+      }
+    },
+    second: {
+      definitions: {
+        second: {
+          $id: '#second-schema',
+          type: 'object',
+          properties: {
+            int: {
+              type: 'integer'
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const schema = {
+    title: 'object with $ref to external plain name fragment',
+    type: 'object',
+    properties: {
+      first: {
+        $ref: '#first-schema'
+      },
+      second: {
+        $ref: '#second-schema'
+      }
+    }
+  }
+
+  const object = {
+    first: {
+      str: 'test'
+    },
+    second: {
+      int: 42
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchema })
+  const output = stringify(object)
+
+  try {
+    JSON.parse(output)
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+
+  t.equal(output, '{"first":{"str":"test"},"second":{"int":42}}')
+})
+
+test('ref external - duplicate plain name fragment', (t) => {
+  t.plan(2)
+
+  const externalSchema = {
+    external: {
+      $id: '#duplicateSchema',
+      type: 'object',
+      properties: {
+        prop: {
+          type: 'boolean'
+        }
+      }
+    },
+    other: {
+      $id: '#otherSchema',
+      type: 'object',
+      properties: {
+        prop: {
+          type: 'integer'
+        }
+      }
+    }
+  }
+
+  const schema = {
+    title: 'object with $ref to plain name fragment',
+    type: 'object',
+    definitions: {
+      duplicate: {
+        $id: '#duplicateSchema',
+        type: 'object',
+        properties: {
+          prop: {
+            type: 'string'
+          }
+        }
+      }
+    },
+    properties: {
+      local: {
+        $ref: '#duplicateSchema'
+      },
+      external: {
+        $ref: 'external#duplicateSchema'
+      },
+      other: {
+        $ref: '#otherSchema'
+      }
+    }
+  }
+
+  const object = {
+    local: {
+      prop: 'test'
+    },
+    external: {
+      prop: true
+    },
+    other: {
+      prop: 42
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchema })
+  const output = stringify(object)
+
+  try {
+    JSON.parse(output)
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+
+  t.equal(output, '{"local":{"prop":"test"},"external":{"prop":true},"other":{"prop":42}}')
+})
+
+test('ref external - explicit external plain name fragment must not fallback to other external schemas', (t) => {
+  t.plan(1)
+
+  const externalSchema = {
+    first: {
+      $id: '#target',
+      type: 'object',
+      properties: {
+        prop: {
+          type: 'string'
+        }
+      }
+    },
+    second: {
+      $id: '#wrong',
+      type: 'object',
+      properties: {
+        prop: {
+          type: 'integer'
+        }
+      }
+    }
+  }
+
+  const schema = {
+    title: 'object with $ref to plain name fragment',
+    type: 'object',
+    definitions: {
+      third: {
+        $id: '#wrong',
+        type: 'object',
+        properties: {
+          prop: {
+            type: 'boolean'
+          }
+        }
+      }
+    },
+    properties: {
+      target: {
+        $ref: 'first#wrong'
+      }
+    }
+  }
+
+  const object = {
+    target: {
+      prop: 'test'
+    }
+  }
+
+  try {
+    const stringify = build(schema, { schema: externalSchema })
+    const output = stringify(object)
+    JSON.parse(output)
+    t.fail()
+  } catch (e) {
+    t.pass()
+  }
+})
+
 test('ref internal - multiple $ref format', (t) => {
   t.plan(2)