cleanup: kill mapDeep

Author: Boris Cherny

src/index.ts

@@ -122,15 +122,6 @@ export async function compile(schema: JSONSchema4, name: string, options: Partia
     return `(${Date.now() - start}ms)`
   }
 
-  const errors = validate(schema, name)
-  if (errors.length) {
-    errors.forEach(_ => error(_))
-    throw new ValidationError()
-  }
-  if (process.env.VERBOSE) {
-    log('green', 'validator', time(), '✅ No change')
-  }
-
   // normalize options
   if (!endsWith(_options.cwd, '/')) {
     _options.cwd += '/'
@@ -150,6 +141,15 @@ export async function compile(schema: JSONSchema4, name: string, options: Partia
     log('green', 'linker', time(), '✅ No change')
   }
 
+  const errors = validate(linked, name)
+  if (errors.length) {
+    errors.forEach(_ => error(_))
+    throw new ValidationError()
+  }
+  if (process.env.VERBOSE) {
+    log('green', 'validator', time(), '✅ No change')
+  }
+
   const normalized = normalize(linked, name, _options)
   if (process.env.VERBOSE) {
     if (isDeepStrictEqual(linked, normalized)) {

src/utils.ts

@@ -1,9 +1,8 @@
-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'
 
 // TODO: pull out into a separate package
-// eslint-disable-next-line
 export function Try<T>(fn: () => T, err: (e: Error) => any): T {
   try {
     return fn()
@@ -12,25 +11,6 @@ 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
-        })
-      }
-      return _
-    }),
-    key
-  )
-}
-
 // keys that shouldn't be traversed by the catchall step
 const BLACKLISTED_KEYS = new Set([
   'id',
@@ -70,34 +50,39 @@ const BLACKLISTED_KEYS = new Set([
 
 function traverseObjectKeys(
   obj: Record<string, LinkedJSONSchema>,
-  callback: (schema: LinkedJSONSchema) => void,
+  callback: (schema: LinkedJSONSchema, key: string | null) => void,
   processed: Set<LinkedJSONSchema>
 ) {
   Object.keys(obj).forEach(k => {
     if (obj[k] && typeof obj[k] === 'object' && !Array.isArray(obj[k])) {
-      traverse(obj[k], callback, processed)
+      traverse(obj[k], callback, processed, k)
     }
   })
 }
+
 function traverseArray(
   arr: LinkedJSONSchema[],
-  callback: (schema: LinkedJSONSchema) => void,
+  callback: (schema: LinkedJSONSchema, key: string | null) => void,
   processed: Set<LinkedJSONSchema>
 ) {
-  arr.forEach(i => traverse(i, callback, processed))
+  arr.forEach((s, k) => traverse(s, callback, processed, k.toString()))
 }
+
 export function traverse(
   schema: LinkedJSONSchema,
-  callback: (schema: LinkedJSONSchema) => void,
-  processed = new Set<LinkedJSONSchema>()
+  callback: (schema: LinkedJSONSchema, key: string | null) => void,
+  processed = new Set<LinkedJSONSchema>(),
+  key?: string
 ): void {
   // Handle recursive schemas
   if (processed.has(schema)) {
     return
   }
 
+  // console.log('key', key + '\n')
+
   processed.add(schema)
-  callback(schema)
+  callback(schema, key ?? null)
 
   if (schema.anyOf) {
     traverseArray(schema.anyOf, callback, processed)

src/validator.ts

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