Improve the debugging experience in case of a bad reference (#202)

* Improve the debugging experience in case of a bad reference

* Updated test

Author: delvedor

index.js

@@ -6,6 +6,7 @@ var Ajv = require('ajv')
 var merge = require('deepmerge')
 var util = require('util')
 var validate = require('./schema-validator')
+var stringSimilarity = null
 
 var uglify = null
 var isLong
@@ -490,6 +491,10 @@ function refFinder (ref, schema, externalSchema) {
   if (ref[0]) {
     schema = externalSchema[ref[0]]
 
+    if (schema === undefined) {
+      findBadKey(externalSchema, [ref[0]])
+    }
+
     if (schema.$ref) {
       return refFinder(schema.$ref, schema, externalSchema)
     }
@@ -517,8 +522,30 @@ function refFinder (ref, schema, externalSchema) {
       }
     }
   }
-  const result = (new Function('schema', code))(schema)
+  var result
+  try {
+    result = (new Function('schema', code))(schema)
+  } catch (err) {}
+
+  if (result === undefined) {
+    findBadKey(schema, walk.slice(1))
+  }
   return result.$ref ? refFinder(result.$ref, schema, externalSchema) : result
+
+  function findBadKey (obj, keys) {
+    if (keys.length === 0) return null
+    const key = sanitizeKey(keys.shift())
+    if (obj[key] === undefined) {
+      stringSimilarity = stringSimilarity || require('string-similarity')
+      const { bestMatch } = stringSimilarity.findBestMatch(key, Object.keys(obj))
+      if (bestMatch.rating >= 0.5) {
+        throw new Error(`Cannot find reference '${key}', did you mean '${bestMatch.target}'?`)
+      } else {
+        throw new Error(`Cannot find reference '${key}'`)
+      }
+    }
+    return findBadKey(obj[key], keys)
+  }
 }
 
 function sanitizeKey (key) {

package.json

@@ -48,7 +48,8 @@
   },
   "dependencies": {
     "ajv": "^6.10.2",
-    "deepmerge": "^4.0.0"
+    "deepmerge": "^4.0.0",
+    "string-similarity": "^4.0.1"
   },
   "standard": {
     "ignore": [

test/ref.test.js

@@ -876,3 +876,202 @@ test('ref in definition with exact match', (t) => {
 
   t.equal(output, '{"foo":"foo"}')
 })
+
+test('Bad key', t => {
+  t.test('Find match', t => {
+    t.plan(1)
+    try {
+      build({
+        definitions: {
+          projectId: {
+            type: 'object',
+            properties: {
+              id: { type: 'integer' }
+            }
+          }
+        },
+        type: 'object',
+        properties: {
+          data: {
+            $ref: '#/definitions/porjectId'
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'porjectId', did you mean 'projectId'?")
+    }
+  })
+
+  t.test('No match', t => {
+    t.plan(1)
+    try {
+      build({
+        definitions: {
+          projectId: {
+            type: 'object',
+            properties: {
+              id: { type: 'integer' }
+            }
+          }
+        },
+        type: 'object',
+        properties: {
+          data: {
+            $ref: '#/definitions/foobar'
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'foobar'")
+    }
+  })
+
+  t.test('Find match (external schema)', t => {
+    t.plan(1)
+    try {
+      build({
+        type: 'object',
+        properties: {
+          data: {
+            $ref: 'external#/definitions/porjectId'
+          }
+        }
+      }, {
+        schema: {
+          external: {
+            definitions: {
+              projectId: {
+                type: 'object',
+                properties: {
+                  id: { type: 'integer' }
+                }
+              }
+            }
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'porjectId', did you mean 'projectId'?")
+    }
+  })
+
+  t.test('No match (external schema)', t => {
+    t.plan(1)
+    try {
+      build({
+        type: 'object',
+        properties: {
+          data: {
+            $ref: 'external#/definitions/foobar'
+          }
+        }
+      }, {
+        schema: {
+          external: {
+            definitions: {
+              projectId: {
+                type: 'object',
+                properties: {
+                  id: { type: 'integer' }
+                }
+              }
+            }
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'foobar'")
+    }
+  })
+
+  t.test('Find match (external definitions typo)', t => {
+    t.plan(1)
+    try {
+      build({
+        type: 'object',
+        properties: {
+          data: {
+            $ref: 'external#/deifnitions/projectId'
+          }
+        }
+      }, {
+        schema: {
+          external: {
+            definitions: {
+              projectId: {
+                type: 'object',
+                properties: {
+                  id: { type: 'integer' }
+                }
+              }
+            }
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'deifnitions', did you mean 'definitions'?")
+    }
+  })
+
+  t.test('Find match (definitions typo)', t => {
+    t.plan(1)
+    try {
+      build({
+        definitions: {
+          projectId: {
+            type: 'object',
+            properties: {
+              id: { type: 'integer' }
+            }
+          }
+        },
+        type: 'object',
+        properties: {
+          data: {
+            $ref: '#/deifnitions/projectId'
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'deifnitions', did you mean 'definitions'?")
+    }
+  })
+
+  t.test('Find match (external schema typo)', t => {
+    t.plan(1)
+    try {
+      build({
+        type: 'object',
+        properties: {
+          data: {
+            $ref: 'extrenal#/definitions/projectId'
+          }
+        }
+      }, {
+        schema: {
+          external: {
+            definitions: {
+              projectId: {
+                type: 'object',
+                properties: {
+                  id: { type: 'integer' }
+                }
+              }
+            }
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'extrenal', did you mean 'external'?")
+    }
+  })
+
+  t.end()
+})