fast-json-stringify 4.2.0 → 5.0.2

package/index.js

@@ -12,7 +12,6 @@ const Serializer = require('./serializer')
 const buildAjv = require('./ajv')
 
 let largeArraySize = 2e4
-let stringSimilarity = null
 let largeArrayMechanism = 'default'
 const validLargeArrayMechanisms = [
   'default',
@@ -41,36 +40,83 @@ function isValidSchema (schema, name) {
   }
 }
 
-function mergeLocation (source, dest) {
+function mergeLocation (location, key) {
   return {
-    schema: dest.schema || source.schema,
-    root: dest.root || source.root,
-    externalSchema: dest.externalSchema || source.externalSchema
+    schema: location.schema[key],
+    schemaId: location.schemaId,
+    jsonPointer: location.jsonPointer + '/' + key
   }
 }
 
+function resolveRef (location, ref) {
+  let hashIndex = ref.indexOf('#')
+  if (hashIndex === -1) {
+    hashIndex = ref.length
+  }
+
+  const schemaId = ref.slice(0, hashIndex) || location.schemaId
+  const jsonPointer = ref.slice(hashIndex)
+
+  const schemaRef = schemaId + jsonPointer
+
+  let ajvSchema
+  try {
+    ajvSchema = ajvInstance.getSchema(schemaRef)
+  } catch (error) {
+    throw new Error(`Cannot find reference "${ref}"`)
+  }
+
+  if (ajvSchema === undefined) {
+    throw new Error(`Cannot find reference "${ref}"`)
+  }
+
+  const schema = ajvSchema.schema
+  if (schema.$ref !== undefined) {
+    return resolveRef({ schema, schemaId, jsonPointer }, schema.$ref)
+  }
+
+  return { schema, schemaId, jsonPointer }
+}
+
 const arrayItemsReferenceSerializersMap = new Map()
 const objectReferenceSerializersMap = new Map()
-const schemaReferenceMap = new Map()
 
+let rootSchemaId = null
 let ajvInstance = null
 let contextFunctions = null
 
 function build (schema, options) {
+  schema = clone(schema)
+
   arrayItemsReferenceSerializersMap.clear()
   objectReferenceSerializersMap.clear()
-  schemaReferenceMap.clear()
 
   contextFunctions = []
   options = options || {}
 
   ajvInstance = buildAjv(options.ajv)
+  rootSchemaId = schema.$id || randomUUID()
 
   isValidSchema(schema)
+  extendDateTimeType(schema)
+  ajvInstance.addSchema(schema, rootSchemaId)
+
   if (options.schema) {
-    // eslint-disable-next-line
-    for (var key of Object.keys(options.schema)) {
-      isValidSchema(options.schema[key], key)
+    const externalSchemas = clone(options.schema)
+
+    for (const key of Object.keys(externalSchemas)) {
+      const externalSchema = externalSchemas[key]
+      isValidSchema(externalSchema, key)
+      extendDateTimeType(externalSchema)
+
+      let schemaKey = externalSchema.$id || key
+      if (externalSchema.$id !== undefined && externalSchema.$id[0] === '#') {
+        schemaKey = key + externalSchema.$id // relative URI
+      }
+
+      if (ajvInstance.getSchema(schemaKey) === undefined) {
+        ajvInstance.addSchema(externalSchema, schemaKey)
+      }
     }
   }
 
@@ -98,22 +144,8 @@ function build (schema, options) {
 
   const serializer = new Serializer(options)
 
-  let location = {
-    schema,
-    root: schema,
-    externalSchema: options.schema
-  }
-
-  if (schema.$ref) {
-    location = refFinder(schema.$ref, location)
-    schema = location.schema
-  }
-
-  if (schema.type === undefined) {
-    schema.type = inferTypeByKeyword(schema)
-  }
-
-  const code = buildValue('main', 'input', location)
+  const location = { schema, schemaId: rootSchemaId, jsonPointer: '#' }
+  const code = buildValue(location, 'input')
 
   const contextFunctionCode = `
     function main (input) {
@@ -146,10 +178,10 @@ function build (schema, options) {
   const stringifyFunc = contextFunc(ajvInstance, serializer)
 
   ajvInstance = null
+  rootSchemaId = null
   contextFunctions = null
   arrayItemsReferenceSerializersMap.clear()
   objectReferenceSerializersMap.clear()
-  schemaReferenceMap.clear()
 
   return stringifyFunc
 }
@@ -230,10 +262,11 @@ function addPatternProperties (location) {
         if (properties[keys[i]]) continue
   `
 
-  Object.keys(pp).forEach((regex, index) => {
-    let ppLocation = mergeLocation(location, { schema: pp[regex] })
+  const patternPropertiesLocation = mergeLocation(location, 'patternProperties')
+  Object.keys(pp).forEach((regex) => {
+    let ppLocation = mergeLocation(patternPropertiesLocation, regex)
     if (pp[regex].$ref) {
-      ppLocation = refFinder(pp[regex].$ref, location)
+      ppLocation = resolveRef(ppLocation, pp[regex].$ref)
       pp[regex] = ppLocation.schema
     }
 
@@ -243,7 +276,7 @@ function addPatternProperties (location) {
       throw new Error(`${err.message}. Found at ${regex} matching ${JSON.stringify(pp[regex])}`)
     }
 
-    const valueCode = buildValue('', 'obj[keys[i]]', ppLocation)
+    const valueCode = buildValue(ppLocation, 'obj[keys[i]]')
     code += `
       if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {
         ${addComma}
@@ -264,7 +297,7 @@ function addPatternProperties (location) {
 }
 
 function additionalProperty (location) {
-  let ap = location.schema.additionalProperties
+  const ap = location.schema.additionalProperties
   let code = ''
   if (ap === true) {
     code += `
@@ -276,13 +309,13 @@ function additionalProperty (location) {
 
     return code
   }
-  let apLocation = mergeLocation(location, { schema: ap })
-  if (ap.$ref) {
-    apLocation = refFinder(ap.$ref, location)
-    ap = apLocation.schema
+
+  let apLocation = mergeLocation(location, 'additionalProperties')
+  if (apLocation.schema.$ref) {
+    apLocation = resolveRef(apLocation, apLocation.schema.$ref)
   }
 
-  const valueCode = buildValue('', 'obj[keys[i]]', apLocation)
+  const valueCode = buildValue(apLocation, 'obj[keys[i]]')
 
   code += `
     ${addComma}
@@ -304,140 +337,9 @@ function addAdditionalProperties (location) {
   `
 }
 
-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, location) {
-  const externalSchema = location.externalSchema
-  let root = location.root
-  let schema = location.schema
-
-  if (externalSchema && externalSchema[ref]) {
-    return {
-      schema: externalSchema[ref],
-      root: externalSchema[ref],
-      externalSchema
-    }
-  }
-
-  // Split file from walk
-  ref = ref.split('#')
-
-  // Check schemaReferenceMap for $id entry
-  if (ref[0] && schemaReferenceMap.has(ref[0])) {
-    schema = schemaReferenceMap.get(ref[0])
-    root = schemaReferenceMap.get(ref[0])
-    if (schema.$ref) {
-      return refFinder(schema.$ref, {
-        schema,
-        root,
-        externalSchema
-      })
-    }
-  } else if (ref[0]) { // If external file
-    schema = externalSchema[ref[0]]
-    root = externalSchema[ref[0]]
-
-    if (schema === undefined) {
-      findBadKey(externalSchema, [ref[0]])
-    }
-
-    if (schema.$ref) {
-      return refFinder(schema.$ref, {
-        schema,
-        root,
-        externalSchema
-      })
-    }
-  }
-
-  let code = 'return schema'
-  // If it has a path
-  if (ref[1]) {
-    // ref[1] could contain a JSON pointer - ex: /definitions/num
-    // or plain name fragment id without suffix # - ex: customId
-    const walk = ref[1].split('/')
-    if (walk.length === 1) {
-      const targetId = `#${ref[1]}`
-      let dereferenced = idFinder(schema, targetId)
-      if (dereferenced === undefined && !ref[0]) {
-        // eslint-disable-next-line
-        for (var key of Object.keys(externalSchema)) {
-          dereferenced = idFinder(externalSchema[key], targetId)
-          if (dereferenced !== undefined) {
-            root = externalSchema[key]
-            break
-          }
-        }
-      }
-
-      return {
-        schema: dereferenced,
-        root,
-        externalSchema
-      }
-    } else {
-      // eslint-disable-next-line
-      for (var i = 1; i < walk.length; i++) {
-        code += `[${JSON.stringify(walk[i])}]`
-      }
-    }
-  }
-  let result
-  try {
-    result = (new Function('schema', code))(root)
-  } catch (err) {}
-
-  if (result === undefined && ref[1]) {
-    const walk = ref[1].split('/')
-    findBadKey(schema, walk.slice(1))
-  }
-
-  if (result.$ref) {
-    return refFinder(result.$ref, {
-      schema,
-      root,
-      externalSchema
-    })
-  }
-
-  return {
-    schema: result,
-    root,
-    externalSchema
-  }
-
-  function findBadKey (obj, keys) {
-    if (keys.length === 0) return null
-    const key = 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 ${JSON.stringify(key)}, did you mean ${JSON.stringify(bestMatch.target)}?`)
-      } else {
-        throw new Error(`Cannot find reference ${JSON.stringify(key)}`)
-      }
-    }
-    return findBadKey(obj[key], keys)
-  }
-}
-
-function buildCode (location, locationPath) {
+function buildCode (location) {
   if (location.schema.$ref) {
-    location = refFinder(location.schema.$ref, location)
+    location = resolveRef(location, location.schema.$ref)
   }
 
   const schema = location.schema
@@ -445,10 +347,11 @@ function buildCode (location, locationPath) {
 
   let code = ''
 
+  const propertiesLocation = mergeLocation(location, 'properties')
   Object.keys(schema.properties || {}).forEach((key) => {
-    let propertyLocation = mergeLocation(location, { schema: schema.properties[key] })
+    let propertyLocation = mergeLocation(propertiesLocation, key)
     if (schema.properties[key].$ref) {
-      propertyLocation = refFinder(schema.properties[key].$ref, location)
+      propertyLocation = resolveRef(location, schema.properties[key].$ref)
       schema.properties[key] = propertyLocation.schema
     }
 
@@ -464,7 +367,7 @@ function buildCode (location, locationPath) {
         json += ${asString} + ':'
       `
 
-    code += buildValue(locationPath + key, `obj[${JSON.stringify(key)}]`, mergeLocation(propertyLocation, { schema: schema.properties[key] }))
+    code += buildValue(propertyLocation, `obj[${JSON.stringify(key)}]`)
 
     const defaultValue = schema.properties[key].default
     if (defaultValue !== undefined) {
@@ -494,9 +397,14 @@ function buildCode (location, locationPath) {
 }
 
 function mergeAllOfSchema (location, schema, mergedSchema) {
-  for (let allOfSchema of schema.allOf) {
+  const allOfLocation = mergeLocation(location, 'allOf')
+
+  for (let i = 0; i < schema.allOf.length; i++) {
+    let allOfSchema = schema.allOf[i]
+
     if (allOfSchema.$ref) {
-      allOfSchema = refFinder(allOfSchema.$ref, mergeLocation(location, { schema: allOfSchema })).schema
+      const allOfSchemaLocation = mergeLocation(allOfLocation, i)
+      allOfSchema = resolveRef(allOfSchemaLocation, allOfSchema.$ref).schema
     }
 
     let allOfSchemaType = allOfSchema.type
@@ -583,9 +491,9 @@ function mergeAllOfSchema (location, schema, mergedSchema) {
   delete mergedSchema.allOf
 }
 
-function buildInnerObject (location, locationPath) {
+function buildInnerObject (location) {
   const schema = location.schema
-  let code = buildCode(location, locationPath)
+  let code = buildCode(location)
   if (schema.patternProperties) {
     code += addPatternProperties(location)
   } else if (schema.additionalProperties && !schema.patternProperties) {
@@ -594,49 +502,46 @@ function buildInnerObject (location, locationPath) {
   return code
 }
 
-function addIfThenElse (location, locationPath) {
-  let code = ''
+function addIfThenElse (location) {
+  const schema = merge({}, location.schema)
+  const thenSchema = schema.then
+  const elseSchema = schema.else || { additionalProperties: true }
 
-  const schema = location.schema
-  const copy = merge({}, schema)
-  const i = copy.if
-  const then = copy.then
-  const e = copy.else ? copy.else : { additionalProperties: true }
-  delete copy.if
-  delete copy.then
-  delete copy.else
-  let merged = merge(copy, then)
-  let mergedLocation = mergeLocation(location, { schema: merged })
-
-  const schemaKey = i.$id || randomUUID()
-  ajvInstance.addSchema(i, schemaKey)
+  delete schema.if
+  delete schema.then
+  delete schema.else
 
-  code += `
-    valid = ajv.validate("${schemaKey}", obj)
-    if (valid) {
+  const ifLocation = mergeLocation(location, 'if')
+  const ifSchemaRef = ifLocation.schemaId + ifLocation.jsonPointer
+
+  let code = `
+    if (ajv.validate("${ifSchemaRef}", obj)) {
   `
-  if (merged.if && merged.then) {
-    code += addIfThenElse(mergedLocation, locationPath + 'Then')
-  }
 
-  code += buildInnerObject(mergedLocation, locationPath + 'Then')
+  const thenLocation = mergeLocation(location, 'then')
+  thenLocation.schema = merge(schema, thenSchema)
 
+  if (thenSchema.if && thenSchema.then) {
+    code += addIfThenElse(thenLocation)
+  } else {
+    code += buildInnerObject(thenLocation)
+  }
   code += `
     }
   `
-  merged = merge(copy, e)
-  mergedLocation = mergeLocation(mergedLocation, { schema: merged })
+
+  const elseLocation = mergeLocation(location, 'else')
+  elseLocation.schema = merge(schema, elseSchema)
 
   code += `
       else {
     `
 
-  if (merged.if && merged.then) {
-    code += addIfThenElse(mergedLocation, locationPath + 'Else')
+  if (elseSchema.if && elseSchema.then) {
+    code += addIfThenElse(elseLocation)
+  } else {
+    code += buildInnerObject(elseLocation)
   }
-
-  code += buildInnerObject(mergedLocation, locationPath + 'Else')
-
   code += `
       }
     `
@@ -650,11 +555,8 @@ function toJSON (variableName) {
   `
 }
 
-function buildObject (location, locationPath) {
+function buildObject (location) {
   const schema = location.schema
-  if (schema.$id !== undefined) {
-    schemaReferenceMap.set(schema.$id, schema)
-  }
 
   if (objectReferenceSerializersMap.has(schema)) {
     return objectReferenceSerializersMap.get(schema)
@@ -663,9 +565,10 @@ function buildObject (location, locationPath) {
   const functionName = generateFuncName()
   objectReferenceSerializersMap.set(schema, functionName)
 
+  const schemaId = location.schemaId === rootSchemaId ? '' : location.schemaId
   let functionCode = `
     function ${functionName} (input) {
-      // ${locationPath}
+      // ${schemaId + location.jsonPointer}
   `
   if (schema.nullable) {
     functionCode += `
@@ -681,18 +584,13 @@ function buildObject (location, locationPath) {
       var addComma = false
   `
 
-  let rCode
   if (schema.if && schema.then) {
-    functionCode += `
-      var valid
-    `
-    rCode = addIfThenElse(location, locationPath)
+    functionCode += addIfThenElse(location)
   } else {
-    rCode = buildInnerObject(location, locationPath)
+    functionCode += buildInnerObject(location)
   }
 
-  // Removes the comma if is the last element of the string (in case there are not properties)
-  functionCode += `${rCode}
+  functionCode += `
       json += '}'
       return json
     }
@@ -702,17 +600,16 @@ function buildObject (location, locationPath) {
   return functionName
 }
 
-function buildArray (location, locationPath) {
+function buildArray (location) {
   let schema = location.schema
-  if (schema.$id !== undefined) {
-    schemaReferenceMap.set(schema.$id, schema)
-  }
 
   // default to any items type
   if (!schema.items) {
     schema.items = {}
   }
 
+  let itemsLocation = mergeLocation(location, 'items')
+
   if (schema.items.$ref) {
     if (!schema[fjsCloned]) {
       location.schema = clone(location.schema)
@@ -720,7 +617,8 @@ function buildArray (location, locationPath) {
       schema[fjsCloned] = true
     }
 
-    location = refFinder(schema.items.$ref, location)
+    location = resolveRef(location, schema.items.$ref)
+    itemsLocation = location
     schema.items = location.schema
   }
 
@@ -731,9 +629,10 @@ function buildArray (location, locationPath) {
   const functionName = generateFuncName()
   arrayItemsReferenceSerializersMap.set(schema.items, functionName)
 
+  const schemaId = location.schemaId === rootSchemaId ? '' : location.schemaId
   let functionCode = `
     function ${functionName} (obj) {
-      // ${locationPath}
+      // ${schemaId + location.jsonPointer}
   `
 
   if (schema.nullable) {
@@ -771,11 +670,10 @@ function buildArray (location, locationPath) {
     let jsonOutput = ''
   `
 
-  const accessor = '[i]'
   if (Array.isArray(schema.items)) {
     for (let i = 0; i < schema.items.length; i++) {
       const item = schema.items[i]
-      const tmpRes = buildValue(locationPath + accessor + i, `obj[${i}]`, mergeLocation(location, { schema: item }))
+      const tmpRes = buildValue(mergeLocation(itemsLocation, i), `obj[${i}]`)
       functionCode += `
         if (${i} < arrayLength) {
           if (${buildArrayTypeCondition(item.type, `[${i}]`)}) {
@@ -803,7 +701,7 @@ function buildArray (location, locationPath) {
         }`
     }
   } else {
-    const code = buildValue(locationPath + accessor, 'obj[i]', mergeLocation(location, { schema: schema.items }))
+    const code = buildValue(itemsLocation, 'obj[i]')
     functionCode += `
       for (let i = 0; i < arrayLength; i++) {
         let json = ''
@@ -860,40 +758,17 @@ function buildArrayTypeCondition (type, accessor) {
   return condition
 }
 
-function dereferenceOfRefs (location, type) {
-  if (!location.schema[fjsCloned]) {
-    const schemaClone = clone(location.schema)
-    schemaClone[fjsCloned] = true
-    location.schema = schemaClone
-  }
-
-  const schema = location.schema
-  const locations = []
-
-  schema[type].forEach((s, index) => {
-    // follow the refs
-    let sLocation = mergeLocation(location, { schema: s })
-    while (s.$ref) {
-      sLocation = refFinder(s.$ref, sLocation)
-      schema[type][index] = sLocation.schema
-      s = schema[type][index]
-    }
-    locations[index] = sLocation
-  })
-
-  return locations
-}
-
 let genFuncNameCounter = 0
 function generateFuncName () {
   return 'anonymous' + genFuncNameCounter++
 }
 
-function buildValue (locationPath, input, location) {
+function buildValue (location, input) {
   let schema = location.schema
 
   if (schema.$ref) {
-    schema = refFinder(schema.$ref, location)
+    location = resolveRef(location, schema.$ref)
+    schema = location.schema
   }
 
   if (schema.type === undefined) {
@@ -940,41 +815,32 @@ function buildValue (locationPath, input, location) {
       code += `json += ${funcName}(${input})`
       break
     case 'object':
-      funcName = buildObject(location, locationPath)
+      funcName = buildObject(location)
       code += `json += ${funcName}(${input})`
       break
     case 'array':
-      funcName = buildArray(location, locationPath)
+      funcName = buildArray(location)
       code += `json += ${funcName}(${input})`
       break
     case undefined:
-      if (schema.anyOf || schema.oneOf) {
+      if (schema.fjs_date_type) {
+        funcName = getStringSerializer(schema.fjs_date_type, nullable)
+        code += `json += ${funcName}(${input})`
+        break
+      } else if (schema.anyOf || schema.oneOf) {
         // beware: dereferenceOfRefs has side effects and changes schema.anyOf
-        const locations = dereferenceOfRefs(location, schema.anyOf ? 'anyOf' : 'oneOf')
-        locations.forEach((location, index) => {
-          const nestedResult = buildValue(locationPath + 'i' + index, input, location)
-          // Since we are only passing the relevant schema to ajv.validate, it needs to be full dereferenced
-          // otherwise any $ref pointing to an external schema would result in an error.
-          // Full dereference of the schema happens as side effect of two functions:
-          // 1. `dereferenceOfRefs` loops through the `schema.anyOf`` array and replaces any top level reference
-          // with the actual schema
-          // 2. `buildValue`, through `buildCode`, replaces any reference in object properties with the actual schema
-          // (see https://github.com/fastify/fast-json-stringify/blob/6da3b3e8ac24b1ca5578223adedb4083b7adf8db/index.js#L631)
-
-          // Ajv does not support js date format. In order to properly validate objects containing a date,
-          // it needs to replace all occurrences of the string date format with a custom keyword fjs_date_type.
-          // (see https://github.com/fastify/fast-json-stringify/pull/441)
-          const extendedSchema = clone(location.schema)
-          extendDateTimeType(extendedSchema)
-
-          const schemaKey = location.schema.$id || randomUUID()
-          ajvInstance.addSchema(extendedSchema, schemaKey)
+        const type = schema.anyOf ? 'anyOf' : 'oneOf'
+        const anyOfLocation = mergeLocation(location, type)
 
+        for (let index = 0; index < location.schema[type].length; index++) {
+          const optionLocation = mergeLocation(anyOfLocation, index)
+          const schemaRef = optionLocation.schemaId + optionLocation.jsonPointer
+          const nestedResult = buildValue(optionLocation, input)
           code += `
-            ${index === 0 ? 'if' : 'else if'}(ajv.validate("${schemaKey}", ${input}))
+            ${index === 0 ? 'if' : 'else if'}(ajv.validate("${schemaRef}", ${input}))
               ${nestedResult}
           `
-        })
+        }
 
         code += `
           else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
@@ -1011,10 +877,11 @@ function buildValue (locationPath, input, location) {
             } else {`
         }
 
+        const locationClone = clone(location)
         sortedTypes.forEach((type, index) => {
           const statement = index === 0 ? 'if' : 'else if'
-          const tempSchema = Object.assign({}, schema, { type })
-          const nestedResult = buildValue(locationPath, input, mergeLocation(location, { schema: tempSchema }))
+          locationClone.schema.type = type
+          const nestedResult = buildValue(locationClone, input)
           switch (type) {
             case 'string': {
               code += `
@@ -1063,7 +930,12 @@ function buildValue (locationPath, input, location) {
   return code
 }
 
+// Ajv does not support js date format. In order to properly validate objects containing a date,
+// it needs to replace all occurrences of the string date format with a custom keyword fjs_date_type.
+// (see https://github.com/fastify/fast-json-stringify/pull/441)
 function extendDateTimeType (schema) {
+  if (schema === null) return
+
   if (schema.type === 'string' && ['date-time', 'date', 'time'].includes(schema.format)) {
     schema.fjs_date_type = schema.format
     delete schema.type