prevent infinite recursion when validating schemas

src/utils.ts

@@ -1,4 +1,4 @@
-import {deburr, isPlainObject, mapValues, trim, upperFirst} from 'lodash'
+import {deburr, isPlainObject, trim, upperFirst} from 'lodash'
 import {basename, dirname, extname, join, normalize, sep} from 'path'
 import {JSONSchema, LinkedJSONSchema} from './types/JSONSchema'
 
@@ -12,23 +12,30 @@ export function Try<T>(fn: () => T, err: (e: Error) => any): T {
   }
 }
 
-export function mapDeep(object: object, fn: (value: object, key?: string) => object, key?: string): object {
-  return fn(
-    mapValues(object, (_: unknown, key) => {
-      if (isPlainObject(_)) {
-        return mapDeep(_ as object, fn, key)
-      } else if (Array.isArray(_)) {
-        return _.map(item => {
-          if (isPlainObject(item)) {
-            return mapDeep(item as object, fn, key)
-          }
-          return item
-        })
+/**
+ * Recursively crawls the given obj, and invokes fn for every plain object,
+ * starting with the deep values. Circular references are skipped.
+ */
+export function crawl(
+  obj: any,
+  fn: (value: object, key?: string) => void,
+  key?: string, // internal
+  seen = new Set<object>() // internal
+): void {
+  if (!seen.has(obj)) {
+    if (isPlainObject(obj)) {
+      seen.add(obj)
+      for (const key of Object.keys(obj)) {
+        crawl(obj[key], fn, key, seen)
       }
-      return _
-    }),
-    key
-  )
+      fn(obj, key)
+    } else if (Array.isArray(obj)) {
+      seen.add(obj)
+      for (const el of obj) {
+        crawl(el, fn, key, seen)
+      }
+    }
+  }
 }
 
 // keys that shouldn't be traversed by the catchall step

src/validator.ts

@@ -1,5 +1,5 @@
 import {JSONSchema} from './types/JSONSchema'
-import {mapDeep} from './utils'
+import {crawl} from './utils'
 
 type Rule = (schema: JSONSchema) => boolean | void
 const rules = new Map<string, Rule>()
@@ -40,11 +40,10 @@ rules.set('When minItems exists, minItems >= 0', schema => {
 export function validate(schema: JSONSchema, filename: string): string[] {
   const errors: string[] = []
   rules.forEach((rule, ruleName) => {
-    mapDeep(schema, (schema, key) => {
+    crawl(schema, (schema, key) => {
       if (rule(schema) === false) {
         errors.push(`Error at key "${key}" in file "${filename}": ${ruleName}`)
       }
-      return schema
     })
   })
   return errors

test/testUtils.ts

@@ -1,5 +1,5 @@
 import {serial as test} from 'ava'
-import {pathTransform, generateName} from '../src/utils'
+import {crawl, pathTransform, generateName} from '../src/utils'
 
 export function run() {
   test('pathTransform', t => {
@@ -20,4 +20,40 @@ export function run() {
     t.is(generateName('a', usedNames), 'A2')
     t.is(generateName('a', usedNames), 'A3')
   })
+  test('crawl', t => {
+    const schema1 = {
+      type: 'object',
+      properties: {
+        prop1: {enum: [1, 2, 3]},
+        prop2: {
+          oneOf: [{type: 'string'}, {type: 'number'}]
+        },
+        prop3: null as unknown
+      }
+    }
+    // circular reference will trigger "Maximum call stack size exceeded" if cycle is not detected
+    schema1.properties.prop3 = schema1
+    const fn1 = spy()
+    crawl(schema1, fn1)
+    t.is(fn1.calls.length, 6)
+    // only invokes fn on objects, not scalars, not arrays
+    t.is(fn1.calls[0][0], schema1.properties.prop1)
+    // crawls arrays
+    t.is(fn1.calls[1][0], schema1.properties.prop2.oneOf[0])
+    t.is(fn1.calls[2][0], schema1.properties.prop2.oneOf[1])
+    t.is(fn1.calls[3][0], schema1.properties.prop2)
+    // skips prop3 as cycle is detected
+    // crawl back up the stack
+    t.is(fn1.calls[4][0], schema1.properties)
+    t.is(fn1.calls[5][0], schema1)
+  })
+}
+
+function spy() {
+  const calls: unknown[][] = []
+  const fn = (...args: unknown[]) => {
+    calls.push(args)
+  }
+  fn.calls = calls
+  return fn
 }