fast-json-stringify 5.3.0 → 5.4.1

package/.github/workflows/ci.yml

@@ -15,3 +15,4 @@ jobs:
     uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
     with:
       license-check: true
+      lint: true

package/.taprc

@@ -1,3 +1,9 @@
 ts: false
 jsx: false
-coverage: false
+branches: 65
+functions: 100
+lines: 89
+statements: 89
+nyc-arg:
+  - "--exclude=.cache/*"
+  - "--exclude=lib/schema-validator.js"

package/README.md

@@ -18,31 +18,37 @@ fast-json-stringify requires a [JSON Schema Draft 7](https://json-schema.org/spe
 ##### Benchmarks
 
 - Machine: `EX41S-SSD, Intel Core i7, 4Ghz, 64GB RAM, 4C/8T, SSD`.
-- Node.js `v16.9.1`
+- Node.js `v18.12.1`
 
 ```
-FJS creation x 8,443 ops/sec ±1.01% (90 runs sampled)
-CJS creation x 183,219 ops/sec ±0.13% (96 runs sampled)
-AJV Serialize creation x 83,541,848 ops/sec ±0.24% (98 runs sampled)
-JSON.stringify array x 5,363 ops/sec ±0.11% (100 runs sampled)
-fast-json-stringify array x 6,747 ops/sec ±0.13% (98 runs sampled)
-compile-json-stringify array x 7,121 ops/sec ±0.42% (98 runs sampled)
-AJV Serialize array x 7,533 ops/sec ±0.13% (98 runs sampled)
-JSON.stringify long string x 16,461 ops/sec ±0.12% (98 runs sampled)
-fast-json-stringify long string x 16,443 ops/sec ±0.37% (99 runs sampled)
-compile-json-stringify long string x 16,458 ops/sec ±0.09% (98 runs sampled)
-AJV Serialize long string x 21,433 ops/sec ±0.08% (95 runs sampled)
-JSON.stringify short string x 12,035,664 ops/sec ±0.62% (96 runs sampled)
-fast-json-stringify short string x 38,281,060 ops/sec ±0.24% (98 runs sampled)
-compile-json-stringify short string x 32,388,037 ops/sec ±0.27% (97 runs sampled)
-AJV Serialize short string x 32,288,612 ops/sec ±0.32% (95 runs sampled)
-JSON.stringify obj x 3,068,185 ops/sec ±0.16% (98 runs sampled)
-fast-json-stringify obj x 10,082,694 ops/sec ±0.10% (97 runs sampled)
-compile-json-stringify obj x 17,037,963 ops/sec ±1.17% (97 runs sampled)
-AJV Serialize obj x 9,660,041 ops/sec ±0.11% (97 runs sampled)
-JSON stringify date x 1,084,008 ops/sec ±0.16% (98 runs sampled)
-fast-json-stringify date format x 1,781,044 ops/sec ±0.48% (99 runs sampled)
-compile-json-stringify date format x 1,086,187 ops/sec ±0.16% (99 runs sampled)
+FJS creation x 4,129 ops/sec ±0.82% (92 runs sampled)
+CJS creation x 184,196 ops/sec ±0.12% (97 runs sampled)
+AJV Serialize creation x 61,130,591 ops/sec ±0.40% (92 runs sampled)
+JSON.stringify array x 5,057 ops/sec ±0.10% (100 runs sampled)
+fast-json-stringify array default x 6,243 ops/sec ±0.14% (98 runs sampled)
+fast-json-stringify array json-stringify x 6,261 ops/sec ±0.30% (99 runs sampled)
+compile-json-stringify array x 6,842 ops/sec ±0.18% (96 runs sampled)
+AJV Serialize array x 6,964 ops/sec ±0.11% (95 runs sampled)
+JSON.stringify large array x 248 ops/sec ±0.07% (90 runs sampled)
+fast-json-stringify large array default x 99.96 ops/sec ±0.22% (74 runs sampled)
+fast-json-stringify large array json-stringify x 248 ops/sec ±0.07% (90 runs sampled)
+compile-json-stringify large array x 317 ops/sec ±0.09% (89 runs sampled)
+AJV Serialize large array x 111 ops/sec ±0.07% (33 runs sampled)
+JSON.stringify long string x 16,002 ops/sec ±0.09% (98 runs sampled)
+fast-json-stringify long string x 15,979 ops/sec ±0.09% (96 runs sampled)
+compile-json-stringify long string x 15,952 ops/sec ±0.31% (97 runs sampled)
+AJV Serialize long string x 21,416 ops/sec ±0.08% (98 runs sampled)
+JSON.stringify short string x 12,944,272 ops/sec ±0.09% (96 runs sampled)
+fast-json-stringify short string x 30,585,790 ops/sec ±0.27% (97 runs sampled)
+compile-json-stringify short string x 30,656,406 ops/sec ±0.12% (96 runs sampled)
+AJV Serialize short string x 30,406,785 ops/sec ±0.37% (96 runs sampled)
+JSON.stringify obj x 3,153,043 ops/sec ±0.33% (99 runs sampled)
+fast-json-stringify obj x 6,866,434 ops/sec ±0.11% (100 runs sampled)
+compile-json-stringify obj x 15,886,723 ops/sec ±0.15% (98 runs sampled)
+AJV Serialize obj x 8,969,043 ops/sec ±0.36% (97 runs sampled)
+JSON stringify date x 1,126,547 ops/sec ±0.09% (97 runs sampled)
+fast-json-stringify date format x 1,836,188 ops/sec ±0.12% (99 runs sampled)
+compile-json-stringify date format x 1,125,735 ops/sec ±0.19% (98 runs sampled)
 ```
 
 #### Table of contents:

package/index.js

@@ -10,6 +10,7 @@ const validate = require('./lib/schema-validator')
 const Serializer = require('./lib/serializer')
 const Validator = require('./lib/validator')
 const RefResolver = require('./lib/ref-resolver')
+const Location = require('./lib/location')
 
 let largeArraySize = 2e4
 let largeArrayMechanism = 'default'
@@ -40,21 +41,13 @@ function isValidSchema (schema, name) {
   }
 }
 
-function mergeLocation (location, key) {
-  return {
-    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 schemaId = ref.slice(0, hashIndex) || location.getOriginSchemaId()
   const jsonPointer = ref.slice(hashIndex) || '#'
 
   const schema = refResolver.getSchema(schemaId, jsonPointer)
@@ -63,39 +56,38 @@ function resolveRef (location, ref) {
     throw new Error(`Cannot find reference "${ref}"`)
   }
 
+  const newLocation = new Location(schema, schemaId, jsonPointer)
   if (schema.$ref !== undefined) {
-    return resolveRef({ schema, schemaId, jsonPointer }, schema.$ref)
+    return resolveRef(newLocation, schema.$ref)
   }
 
-  return { schema, schemaId, jsonPointer }
+  return newLocation
 }
 
 const contextFunctionsNamesBySchema = new Map()
 
 let rootSchemaId = null
 let refResolver = null
-let validator = null
 let contextFunctions = null
+let validatorSchemasIds = null
 
 function build (schema, options) {
   contextFunctionsNamesBySchema.clear()
 
   contextFunctions = []
+  validatorSchemasIds = new Set()
   options = options || {}
 
   refResolver = new RefResolver()
-  validator = new Validator(options.ajv)
 
   rootSchemaId = schema.$id || randomUUID()
 
   isValidSchema(schema)
-  validator.addSchema(schema, rootSchemaId)
   refResolver.addSchema(schema, rootSchemaId)
 
   if (options.schema) {
     for (const key of Object.keys(options.schema)) {
       isValidSchema(options.schema[key], key)
-      validator.addSchema(options.schema[key], key)
       refResolver.addSchema(options.schema[key], key)
     }
   }
@@ -110,7 +102,7 @@ function build (schema, options) {
     if (validLargeArrayMechanisms.includes(options.largeArrayMechanism)) {
       largeArrayMechanism = options.largeArrayMechanism
     } else {
-      throw new Error(`Unsupported large array mechanism ${options.rounding}`)
+      throw new Error(`Unsupported large array mechanism ${options.largeArrayMechanism}`)
     }
   }
 
@@ -122,9 +114,7 @@ function build (schema, options) {
     }
   }
 
-  const serializer = new Serializer(options)
-
-  const location = { schema, schemaId: rootSchemaId, jsonPointer: '#' }
+  const location = new Location(schema, rootSchemaId)
   const code = buildValue(location, 'input')
 
   const contextFunctionCode = `
@@ -135,7 +125,20 @@ function build (schema, options) {
     }
     ${contextFunctions.join('\n')}
     return main
-    `
+  `
+
+  const serializer = new Serializer(options)
+  const validator = new Validator(options.ajv)
+
+  for (const schemaId of validatorSchemasIds) {
+    const schema = refResolver.getSchema(schemaId)
+    validator.addSchema(schema, schemaId)
+
+    const dependencies = refResolver.getSchemaDependencies(schemaId)
+    for (const [schemaId, schema] of Object.entries(dependencies)) {
+      validator.addSchema(schema, schemaId)
+    }
+  }
 
   const dependenciesName = ['validator', 'serializer', contextFunctionCode]
 
@@ -154,8 +157,9 @@ function build (schema, options) {
 
   if (options.mode === 'standalone') {
     // lazy load
+    const isValidatorUsed = validatorSchemasIds.size > 0
     const buildStandaloneCode = require('./lib/standalone')
-    return buildStandaloneCode(options, validator, contextFunctionCode)
+    return buildStandaloneCode(options, validator, isValidatorUsed, contextFunctionCode)
   }
 
   /* eslint no-new-func: "off" */
@@ -163,9 +167,9 @@ function build (schema, options) {
   const stringifyFunc = contextFunc(validator, serializer)
 
   refResolver = null
-  validator = null
   rootSchemaId = null
   contextFunctions = null
+  validatorSchemasIds = null
   contextFunctionsNamesBySchema.clear()
 
   return stringifyFunc
@@ -228,106 +232,82 @@ function inferTypeByKeyword (schema) {
   return schema.type
 }
 
-function addPatternProperties (location) {
+function buildExtraObjectPropertiesSerializer (location) {
   const schema = location.schema
-  const pp = schema.patternProperties
+  const propertiesKeys = Object.keys(schema.properties || {})
+
   let code = `
-      var properties = ${JSON.stringify(schema.properties)} || {}
-      var keys = Object.keys(obj)
-      for (var i = 0; i < keys.length; i++) {
-        if (properties[keys[i]]) continue
+    const propertiesKeys = ${JSON.stringify(propertiesKeys)}
+    for (const [key, value] of Object.entries(obj)) {
+      if (
+        propertiesKeys.includes(key) ||
+        value === undefined ||
+        typeof value === 'function' ||
+        typeof value === 'symbol'
+      ) continue
   `
 
-  const patternPropertiesLocation = mergeLocation(location, 'patternProperties')
-  Object.keys(pp).forEach((regex) => {
-    let ppLocation = mergeLocation(patternPropertiesLocation, regex)
-    if (pp[regex].$ref) {
-      ppLocation = resolveRef(ppLocation, pp[regex].$ref)
-      pp[regex] = ppLocation.schema
-    }
-
-    try {
-      RegExp(regex)
-    } catch (err) {
-      throw new Error(`${err.message}. Found at ${regex} matching ${JSON.stringify(pp[regex])}`)
-    }
+  const patternPropertiesLocation = location.getPropertyLocation('patternProperties')
+  const patternPropertiesSchema = patternPropertiesLocation.schema
 
-    const valueCode = buildValue(ppLocation, 'obj[keys[i]]')
-    code += `
-      if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {
-        ${addComma}
-        json += serializer.asString(keys[i]) + ':'
-        ${valueCode}
-        continue
-      }
-    `
-  })
-  if (schema.additionalProperties) {
-    code += additionalProperty(location)
-  }
+  if (patternPropertiesSchema !== undefined) {
+    for (const propertyKey in patternPropertiesSchema) {
+      const propertyLocation = patternPropertiesLocation.getPropertyLocation(propertyKey)
 
-  code += `
+      try {
+        RegExp(propertyKey)
+      } catch (err) {
+        const jsonPointer = propertyLocation.getSchemaRef()
+        throw new Error(`${err.message}. Invalid pattern property regexp key ${propertyKey} at ${jsonPointer}`)
       }
-  `
-  return code
-}
 
-function additionalProperty (location) {
-  const ap = location.schema.additionalProperties
-  let code = ''
-  if (ap === true) {
-    code += `
-        if (obj[keys[i]] !== undefined && typeof obj[keys[i]] !== 'function' && typeof obj[keys[i]] !== 'symbol') {
+      code += `
+        if (/${propertyKey.replace(/\\*\//g, '\\/')}/.test(key)) {
           ${addComma}
-          json += serializer.asString(keys[i]) + ':' + JSON.stringify(obj[keys[i]])
+          json += serializer.asString(key) + ':'
+          ${buildValue(propertyLocation, 'value')}
+          continue
         }
-    `
-
-    return code
+      `
+    }
   }
 
-  let apLocation = mergeLocation(location, 'additionalProperties')
-  if (apLocation.schema.$ref) {
-    apLocation = resolveRef(apLocation, apLocation.schema.$ref)
-  }
+  const additionalPropertiesLocation = location.getPropertyLocation('additionalProperties')
+  const additionalPropertiesSchema = additionalPropertiesLocation.schema
 
-  const valueCode = buildValue(apLocation, 'obj[keys[i]]')
+  if (additionalPropertiesSchema !== undefined) {
+    if (additionalPropertiesSchema === true) {
+      code += `
+        ${addComma}
+        json += serializer.asString(key) + ':' + JSON.stringify(value)
+      `
+    } else {
+      const propertyLocation = location.getPropertyLocation('additionalProperties')
+      code += `
+        ${addComma}
+        json += serializer.asString(key) + ':'
+        ${buildValue(propertyLocation, 'value')}
+      `
+    }
+  }
 
   code += `
-    ${addComma}
-    json += serializer.asString(keys[i]) + ':'
-    ${valueCode}
+    }
   `
-
   return code
 }
 
-function addAdditionalProperties (location) {
-  return `
-      var properties = ${JSON.stringify(location.schema.properties)} || {}
-      var keys = Object.keys(obj)
-      for (var i = 0; i < keys.length; i++) {
-        if (properties[keys[i]]) continue
-        ${additionalProperty(location)}
-      }
-  `
-}
-
-function buildCode (location) {
-  if (location.schema.$ref) {
-    location = resolveRef(location, location.schema.$ref)
-  }
-
+function buildInnerObject (location) {
   const schema = location.schema
   const required = schema.required || []
 
   let code = ''
 
-  const propertiesLocation = mergeLocation(location, 'properties')
+  const propertiesLocation = location.getPropertyLocation('properties')
   Object.keys(schema.properties || {}).forEach((key) => {
-    let propertyLocation = mergeLocation(propertiesLocation, key)
-    if (propertyLocation.$ref) {
-      propertyLocation = resolveRef(location, propertyLocation.$ref)
+    let propertyLocation = propertiesLocation.getPropertyLocation(key)
+    if (propertyLocation.schema.$ref) {
+      propertyLocation = resolveRef(location, propertyLocation.schema.$ref)
     }
 
     const sanitized = JSON.stringify(key)
@@ -368,17 +348,21 @@ function buildCode (location) {
     code += `if (obj['${requiredProperty}'] === undefined) throw new Error('"${requiredProperty}" is required!')\n`
   }
 
+  if (schema.patternProperties || schema.additionalProperties) {
+    code += buildExtraObjectPropertiesSerializer(location)
+  }
+
   return code
 }
 
 function mergeAllOfSchema (location, schema, mergedSchema) {
-  const allOfLocation = mergeLocation(location, 'allOf')
+  const allOfLocation = location.getPropertyLocation('allOf')
 
   for (let i = 0; i < schema.allOf.length; i++) {
     let allOfSchema = schema.allOf[i]
 
     if (allOfSchema.$ref) {
-      const allOfSchemaLocation = mergeLocation(allOfLocation, i)
+      const allOfSchemaLocation = allOfLocation.getPropertyLocation(i)
       allOfSchema = resolveRef(allOfSchemaLocation, allOfSchema.$ref).schema
     }
 
@@ -466,24 +450,13 @@ function mergeAllOfSchema (location, schema, mergedSchema) {
   delete mergedSchema.allOf
 
   mergedSchema.$id = `merged_${randomUUID()}`
-  validator.addSchema(mergedSchema)
   refResolver.addSchema(mergedSchema)
-  location.schemaId = mergedSchema.$id
-  location.jsonPointer = '#'
+  location.addMergedSchema(mergedSchema, mergedSchema.$id)
 }
 
-function buildInnerObject (location) {
-  const schema = location.schema
-  let code = buildCode(location)
-  if (schema.patternProperties) {
-    code += addPatternProperties(location)
-  } else if (schema.additionalProperties && !schema.patternProperties) {
-    code += addAdditionalProperties(location)
-  }
-  return code
-}
+function addIfThenElse (location, input) {
+  validatorSchemasIds.add(location.getSchemaId())
 
-function addIfThenElse (location) {
   const schema = merge({}, location.schema)
   const thenSchema = schema.then
   const elseSchema = schema.else || { additionalProperties: true }
@@ -492,41 +465,22 @@ function addIfThenElse (location) {
   delete schema.then
   delete schema.else
 
-  const ifLocation = mergeLocation(location, 'if')
-  const ifSchemaRef = ifLocation.schemaId + ifLocation.jsonPointer
+  const ifLocation = location.getPropertyLocation('if')
+  const ifSchemaRef = ifLocation.getSchemaRef()
 
-  let code = `
-    if (validator.validate("${ifSchemaRef}", obj)) {
-  `
-
-  const thenLocation = mergeLocation(location, 'then')
+  const thenLocation = location.getPropertyLocation('then')
   thenLocation.schema = merge(schema, thenSchema)
 
-  if (thenSchema.if && thenSchema.then) {
-    code += addIfThenElse(thenLocation)
-  } else {
-    code += buildInnerObject(thenLocation)
-  }
-  code += `
-    }
-  `
-
-  const elseLocation = mergeLocation(location, 'else')
+  const elseLocation = location.getPropertyLocation('else')
   elseLocation.schema = merge(schema, elseSchema)
 
-  code += `
-      else {
-    `
-
-  if (elseSchema.if && elseSchema.then) {
-    code += addIfThenElse(elseLocation)
-  } else {
-    code += buildInnerObject(elseLocation)
-  }
-  code += `
-      }
-    `
-  return code
+  return `
+    if (validator.validate("${ifSchemaRef}", ${input})) {
+      ${buildValue(thenLocation, input)}
+    } else {
+      ${buildValue(elseLocation, input)}
+    }
+  `
 }
 
 function toJSON (variableName) {
@@ -546,10 +500,14 @@ function buildObject (location) {
   const functionName = generateFuncName()
   contextFunctionsNamesBySchema.set(schema, functionName)
 
-  const schemaId = location.schemaId === rootSchemaId ? '' : location.schemaId
+  let schemaRef = location.getSchemaRef()
+  if (schemaRef.startsWith(rootSchemaId)) {
+    schemaRef = schemaRef.replace(rootSchemaId, '')
+  }
+
   let functionCode = `
     function ${functionName} (input) {
-      // ${schemaId + location.jsonPointer}
+      // ${schemaRef}
   `
 
   functionCode += `
@@ -558,12 +516,7 @@ function buildObject (location) {
       var addComma = false
   `
 
-  if (schema.if && schema.then) {
-    functionCode += addIfThenElse(location)
-  } else {
-    functionCode += buildInnerObject(location)
-  }
-
+  functionCode += buildInnerObject(location)
   functionCode += `
       json += '}'
       return json
@@ -577,7 +530,7 @@ function buildObject (location) {
 function buildArray (location) {
   const schema = location.schema
 
-  let itemsLocation = mergeLocation(location, 'items')
+  let itemsLocation = location.getPropertyLocation('items')
   itemsLocation.schema = itemsLocation.schema || {}
 
   if (itemsLocation.schema.$ref) {
@@ -593,10 +546,14 @@ function buildArray (location) {
   const functionName = generateFuncName()
   contextFunctionsNamesBySchema.set(schema, functionName)
 
-  const schemaId = location.schemaId === rootSchemaId ? '' : location.schemaId
+  let schemaRef = location.getSchemaRef()
+  if (schemaRef.startsWith(rootSchemaId)) {
+    schemaRef = schemaRef.replace(rootSchemaId, '')
+  }
+
   let functionCode = `
     function ${functionName} (obj) {
-      // ${schemaId + location.jsonPointer}
+      // ${schemaRef}
   `
 
   functionCode += `
@@ -629,7 +586,7 @@ function buildArray (location) {
   if (Array.isArray(itemsSchema)) {
     for (let i = 0; i < itemsSchema.length; i++) {
       const item = itemsSchema[i]
-      const tmpRes = buildValue(mergeLocation(itemsLocation, i), `obj[${i}]`)
+      const tmpRes = buildValue(itemsLocation.getPropertyLocation(i), `obj[${i}]`)
       functionCode += `
         if (${i} < arrayLength) {
           if (${buildArrayTypeCondition(item.type, `[${i}]`)}) {
@@ -725,11 +682,11 @@ function buildMultiTypeSerializer (location, input) {
 
   let code = ''
 
-  const locationClone = clone(location)
   types.forEach((type, index) => {
+    location.schema = { ...location.schema, type }
+    const nestedResult = buildSingleTypeSerializer(location, input)
+
     const statement = index === 0 ? 'if' : 'else if'
-    locationClone.schema.type = type
-    const nestedResult = buildSingleTypeSerializer(locationClone, input)
     switch (type) {
       case 'null':
         code += `
@@ -869,11 +826,13 @@ function buildValue (location, input) {
     }
   }
 
+  if (schema.if && schema.then) {
+    return addIfThenElse(location, input)
+  }
+
   if (schema.allOf) {
-    const mergedSchema = clone(schema)
-    mergeAllOfSchema(location, schema, mergedSchema)
-    schema = mergedSchema
-    location.schema = mergedSchema
+    mergeAllOfSchema(location, schema, clone(schema))
+    schema = location.schema
   }
 
   const type = schema.type
@@ -881,12 +840,14 @@ function buildValue (location, input) {
   let code = ''
 
   if (type === undefined && (schema.anyOf || schema.oneOf)) {
+    validatorSchemasIds.add(location.getSchemaId())
+
     const type = schema.anyOf ? 'anyOf' : 'oneOf'
-    const anyOfLocation = mergeLocation(location, type)
+    const anyOfLocation = location.getPropertyLocation(type)
 
     for (let index = 0; index < location.schema[type].length; index++) {
-      const optionLocation = mergeLocation(anyOfLocation, index)
-      const schemaRef = optionLocation.schemaId + optionLocation.jsonPointer
+      const optionLocation = anyOfLocation.getPropertyLocation(index)
+      const schemaRef = optionLocation.getSchemaRef()
       const nestedResult = buildValue(optionLocation, input)
       code += `
         ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input}))

package/lib/location.js

@@ -0,0 +1,53 @@
+'use strict'
+
+class Location {
+  constructor (schema, schemaId, jsonPointer = '#') {
+    this.schema = schema
+    this.schemaId = schemaId
+    this.jsonPointer = jsonPointer
+    this.mergedSchemaId = null
+  }
+
+  getPropertyLocation (propertyName) {
+    const propertyLocation = new Location(
+      this.schema[propertyName],
+      this.schemaId,
+      this.jsonPointer + '/' + propertyName
+    )
+
+    if (this.mergedSchemaId !== null) {
+      propertyLocation.addMergedSchema(
+        this.schema[propertyName],
+        this.mergedSchemaId,
+        this.jsonPointer + '/' + propertyName
+      )
+    }
+
+    return propertyLocation
+  }
+
+  // Use this method to get current schema location.
+  // Use it when you need to create reference to the current location.
+  getSchemaId () {
+    return this.mergedSchemaId || this.schemaId
+  }
+
+  // Use this method to get original schema id for resolving user schema $refs
+  // Don't join it with a JSON pointer to get the current location.
+  getOriginSchemaId () {
+    return this.schemaId
+  }
+
+  getSchemaRef () {
+    const schemaId = this.getSchemaId()
+    return schemaId + this.jsonPointer
+  }
+
+  addMergedSchema (mergedSchema, schemaId, jsonPointer = '#') {
+    this.schema = mergedSchema
+    this.mergedSchemaId = schemaId
+    this.jsonPointer = jsonPointer
+  }
+}
+
+module.exports = Location

package/lib/ref-resolver.js

@@ -28,6 +28,18 @@ class RefResolver {
     return getDataByJSONPointer(schema.schema, jsonPointer)
   }
 
+  getSchemaDependencies (schemaId, dependencies = {}) {
+    const schema = this.schemas[schemaId]
+
+    for (const dependencySchemaId of schema.dependencies) {
+      if (dependencies[dependencySchemaId] !== undefined) continue
+      dependencies[dependencySchemaId] = this.getSchema(dependencySchemaId)
+      this.getSchemaDependencies(dependencySchemaId, dependencies)
+    }
+
+    return dependencies
+  }
+
   insertSchemaBySchemaId (schema, schemaId) {
     if (
       this.schemas[schemaId] !== undefined &&
@@ -35,7 +47,7 @@ class RefResolver {
     ) {
       throw new Error(`There is already another schema with id ${schemaId}`)
     }
-    this.schemas[schemaId] = { schema, anchors: {} }
+    this.schemas[schemaId] = { schema, anchors: {}, dependencies: [] }
   }
 
   insertSchemaByAnchor (schema, schemaId, anchor) {
@@ -60,6 +72,14 @@ class RefResolver {
       }
     }
 
+    const ref = schema.$ref
+    if (ref !== undefined && typeof ref === 'string') {
+      if (ref.charAt(0) !== '#') {
+        const dependencySchemaId = ref.split('#')[0]
+        this.schemas[rootSchemaId].dependencies.push(dependencySchemaId)
+      }
+    }
+
     for (const key in schema) {
       if (typeof schema[key] === 'object' && schema[key] !== null) {
         this.insertSchemaSubschemas(schema[key], rootSchemaId)

package/lib/serializer.js

@@ -1,5 +1,8 @@
 'use strict'
 
+// eslint-disable-next-line
+const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/
+
 module.exports = class Serializer {
   constructor (options = {}) {
     switch (options.rounding) {
@@ -94,6 +97,11 @@ module.exports = class Serializer {
       str = str.toString()
     }
 
+    // Fast escape chars check
+    if (!STR_ESCAPE.test(str)) {
+      return quotes + str + quotes
+    }
+
     if (str.length < 42) {
       return this.asStringSmall(str)
     } else {

package/lib/standalone.js

@@ -1,20 +1,21 @@
 const fs = require('fs')
 const path = require('path')
 
-function buildStandaloneCode (options, validator, contextFunctionCode) {
+function buildStandaloneCode (options, validator, isValidatorUsed, contextFunctionCode) {
   const serializerCode = fs.readFileSync(path.join(__dirname, 'serializer.js')).toString()
   let buildAjvCode = ''
-  let defaultAjvSchema = ''
-  const defaultMeta = validator.ajv.defaultMeta()
-  if (typeof defaultMeta === 'string') {
-    defaultAjvSchema = defaultMeta
-  } else {
-    defaultAjvSchema = defaultMeta.$id || defaultMeta.id
-  }
-  const shouldUseAjv = contextFunctionCode.indexOf('validator') !== -1
-  // we need to export the custom json schema
   let ajvSchemasCode = ''
-  if (shouldUseAjv) {
+
+  if (isValidatorUsed) {
+    let defaultAjvSchema = ''
+    // we need to export the custom json schema
+    const defaultMeta = validator.ajv.defaultMeta()
+    if (typeof defaultMeta === 'string') {
+      defaultAjvSchema = defaultMeta
+    } else {
+      defaultAjvSchema = defaultMeta.$id || defaultMeta.id
+    }
+
     ajvSchemasCode += `const validator = new Validator(${JSON.stringify(options.ajv || {})})\n`
     for (const [id, schema] of Object.entries(validator.ajv.schemas)) {
       // should skip ajv default schema

package/package.json

@@ -1,21 +1,13 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.3.0",
+  "version": "5.4.1",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
-  "scripts": {
-    "bench": "node ./benchmark/bench.js",
-    "bench:cmp": "node ./benchmark/bench-cmp-branch.js",
-    "bench:cmp:ci": "node ./benchmark/bench-cmp-branch.js --ci",
-    "benchmark": "node ./benchmark/bench-cmp-lib.js",
-    "lint:fix": "standard --fix",
-    "test:lint": "standard",
-    "test:typescript": "tsc --project ./test/types/tsconfig.json && tsd",
-    "test:unit": "tap -J test/*.test.js test/**/*.test.js",
-    "test": "npm run test:lint && npm run test:unit && npm run test:typescript"
-  },
-  "precommit": "test",
+  "precommit": [
+    "lint",
+    "test"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fastify/fast-json-stringify.git"
@@ -34,7 +26,7 @@
   "homepage": "https://github.com/fastify/fast-json-stringify#readme",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.24.9",
+    "@sinclair/typebox": "^0.25.2",
     "benchmark": "^2.1.4",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
@@ -45,7 +37,7 @@
     "simple-git": "^3.7.1",
     "standard": "^17.0.0",
     "tap": "^16.0.1",
-    "tsd": "^0.22.0",
+    "tsd": "^0.24.1",
     "typescript": "^4.0.2",
     "webpack": "^5.40.0"
   },
@@ -65,5 +57,16 @@
   "runkitExampleFilename": "./examples/example.js",
   "tsd": {
     "directory": "test/types"
+  },
+  "scripts": {
+    "bench": "node ./benchmark/bench.js",
+    "bench:cmp": "node ./benchmark/bench-cmp-branch.js",
+    "bench:cmp:ci": "node ./benchmark/bench-cmp-branch.js --ci",
+    "benchmark": "node ./benchmark/bench-cmp-lib.js",
+    "lint": "standard",
+    "lint:fix": "standard --fix",
+    "test:typescript": "tsc --project ./test/types/tsconfig.json && tsd",
+    "test:unit": "tap -J test/*.test.js test/**/*.test.js",
+    "test": "npm run test:unit && npm run test:typescript"
   }
-}
+}

package/test/allof.test.js

@@ -437,3 +437,48 @@ test('object with external $refs in allOf', (t) => {
   })
   t.equal(value, '{"id1":1,"id2":2}')
 })
+
+test('allof with local anchor reference', (t) => {
+  t.plan(1)
+
+  const externalSchemas = {
+    Test: {
+      $id: 'Test',
+      definitions: {
+        Problem: {
+          type: 'object',
+          properties: {
+            type: {
+              type: 'string'
+            }
+          }
+        },
+        ValidationFragment: {
+          type: 'string'
+        },
+        ValidationErrorProblem: {
+          type: 'object',
+          allOf: [
+            {
+              $ref: '#/definitions/Problem'
+            },
+            {
+              type: 'object',
+              properties: {
+                validation: {
+                  $ref: '#/definitions/ValidationFragment'
+                }
+              }
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const schema = { $ref: 'Test#/definitions/ValidationErrorProblem' }
+  const stringify = build(schema, { schema: externalSchemas })
+  const data = { type: 'foo', validation: 'bar' }
+
+  t.equal(stringify(data), JSON.stringify(data))
+})

package/test/anyof.test.js

@@ -596,3 +596,51 @@ test('anyOf object with invalid field date of type string with format or null',
   const withOneOfStringify = build(withOneOfSchema)
   t.throws(() => withOneOfStringify({ prop: toStringify }))
 })
+
+test('anyOf with a nested external schema', (t) => {
+  t.plan(1)
+
+  const externalSchemas = {
+    schema1: {
+      definitions: {
+        def1: {
+          $id: 'external',
+          type: 'string'
+        }
+      },
+      type: 'number'
+    }
+  }
+  const schema = { anyOf: [{ $ref: 'external' }] }
+
+  const stringify = build(schema, { schema: externalSchemas })
+  t.equal(stringify('foo'), '"foo"')
+})
+
+test('object with ref and validated properties', (t) => {
+  t.plan(1)
+
+  const externalSchemas = {
+    RefSchema: {
+      $id: 'RefSchema',
+      type: 'string'
+    }
+  }
+
+  const schema = {
+    $id: 'root',
+    type: 'object',
+    properties: {
+      id: {
+        anyOf: [
+          { type: 'string' },
+          { type: 'number' }
+        ]
+      },
+      reference: { $ref: 'RefSchema' }
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchemas })
+  t.equal(stringify({ id: 1, reference: 'hi' }), '{"id":1,"reference":"hi"}')
+})

package/test/array.test.js

@@ -4,6 +4,24 @@ const test = require('tap').test
 const validator = require('is-my-json-valid')
 const build = require('..')
 
+test('error on invalid largeArrayMechanism', (t) => {
+  t.plan(1)
+
+  t.throws(() => build({
+    title: 'large array of null values with default mechanism',
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: { type: 'null' }
+      }
+    }
+  }, {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'invalid'
+  }), Error('Unsupported large array mechanism invalid'))
+})
+
 function buildTest (schema, toStringify, options) {
   test(`render a ${schema.title} as JSON`, (t) => {
     t.plan(3)

package/test/if-then-else.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const t = require('tap')
+const { DateTime } = require('luxon')
 const build = require('..')
 
 const schema = {
@@ -368,3 +369,52 @@ t.test('nested if/then', t => {
     JSON.stringify({ a: 'A', bar: 'bar', bar1: 'bar1' })
   )
 })
+
+t.test('if/else with string format', (t) => {
+  t.plan(2)
+
+  const schema = {
+    if: { type: 'string' },
+    then: { type: 'string', format: 'date' },
+    else: { const: 'Invalid' }
+  }
+
+  const stringify = build(schema)
+
+  const date = new Date()
+
+  t.equal(stringify(date), `"${DateTime.fromJSDate(date).toISODate()}"`)
+  t.equal(stringify('Invalid'), '"Invalid"')
+})
+
+t.test('if/else with const integers', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'number',
+    if: { type: 'number', minimum: 42 },
+    then: { const: 66 },
+    else: { const: 33 }
+  }
+
+  const stringify = build(schema)
+
+  t.equal(stringify(100.32), '66')
+  t.equal(stringify(10.12), '33')
+})
+
+t.test('if/else with array', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'array',
+    if: { type: 'array', maxItems: 1 },
+    then: { items: { type: 'string' } },
+    else: { items: { type: 'number' } }
+  }
+
+  const stringify = build(schema)
+
+  t.equal(stringify(['1']), JSON.stringify(['1']))
+  t.equal(stringify(['1', '2']), JSON.stringify([1, 2]))
+})

package/test/ref.test.js

@@ -1981,3 +1981,27 @@ test('nested schema should overwrite anchor scope', (t) => {
   t.equal(output, JSON.stringify(data))
   t.throws(() => build({ $ref: 'root#anchor' }, { schema: externalSchema }))
 })
+
+test('object property reference with default value', (t) => {
+  t.plan(1)
+
+  const schema = {
+    definitions: {
+      prop: {
+        type: 'string',
+        default: 'foo'
+      }
+    },
+    type: 'object',
+    properties: {
+      prop: {
+        $ref: '#/definitions/prop'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify({})
+
+  t.equal(output, '{"prop":"foo"}')
+})