fast-json-stringify 3.2.0 → 4.0.0

package/index.js

@@ -56,6 +56,173 @@ const schemaReferenceMap = new Map()
 
 let ajvInstance = null
 
+class Serializer {
+  constructor (options = {}) {
+    switch (options.rounding) {
+      case 'floor':
+        this.parseInteger = Math.floor
+        break
+      case 'ceil':
+        this.parseInteger = Math.ceil
+        break
+      case 'round':
+        this.parseInteger = Math.round
+        break
+      default:
+        this.parseInteger = Math.trunc
+        break
+    }
+  }
+
+  asAny (i) {
+    return JSON.stringify(i)
+  }
+
+  asNull () {
+    return 'null'
+  }
+
+  asInteger (i) {
+    if (typeof i === 'bigint') {
+      return i.toString()
+    } else if (Number.isInteger(i)) {
+      return '' + i
+    } else {
+      /* eslint no-undef: "off" */
+      const integer = this.parseInteger(i)
+      if (Number.isNaN(integer)) {
+        throw new Error(`The value "${i}" cannot be converted to an integer.`)
+      } else {
+        return '' + integer
+      }
+    }
+  }
+
+  asIntegerNullable (i) {
+    return i === null ? 'null' : this.asInteger(i)
+  }
+
+  asNumber (i) {
+    const num = Number(i)
+    if (Number.isNaN(num)) {
+      throw new Error(`The value "${i}" cannot be converted to a number.`)
+    } else {
+      return '' + num
+    }
+  }
+
+  asNumberNullable (i) {
+    return i === null ? 'null' : this.asNumber(i)
+  }
+
+  asBoolean (bool) {
+    return bool && 'true' || 'false' // eslint-disable-line
+  }
+
+  asBooleanNullable (bool) {
+    return bool === null ? 'null' : this.asBoolean(bool)
+  }
+
+  asDatetime (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + date.toISOString() + quotes
+    }
+    return this.asString(date, skipQuotes)
+  }
+
+  asDatetimeNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asDatetime(date, skipQuotes)
+  }
+
+  asDate (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + quotes
+    }
+    return this.asString(date, skipQuotes)
+  }
+
+  asDateNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asDate(date, skipQuotes)
+  }
+
+  asTime (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + quotes
+    }
+    return this.asString(date, skipQuotes)
+  }
+
+  asTimeNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asTime(date, skipQuotes)
+  }
+
+  asString (str, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (str instanceof Date) {
+      return quotes + str.toISOString() + quotes
+    } else if (str === null) {
+      return quotes + quotes
+    } else if (str instanceof RegExp) {
+      str = str.source
+    } else if (typeof str !== 'string') {
+      str = str.toString()
+    }
+    // If we skipQuotes it means that we are using it as test
+    // no need to test the string length for the render
+    if (skipQuotes) {
+      return str
+    }
+
+    if (str.length < 42) {
+      return this.asStringSmall(str)
+    } else {
+      return JSON.stringify(str)
+    }
+  }
+
+  asStringNullable (str) {
+    return str === null ? 'null' : this.asString(str)
+  }
+
+  // magically escape strings for json
+  // relying on their charCodeAt
+  // everything below 32 needs JSON.stringify()
+  // every string that contain surrogate needs JSON.stringify()
+  // 34 and 92 happens all the time, so we
+  // have a fast case for them
+  asStringSmall (str) {
+    const l = str.length
+    let result = ''
+    let last = 0
+    let found = false
+    let surrogateFound = false
+    let point = 255
+    // eslint-disable-next-line
+    for (var i = 0; i < l && point >= 32; i++) {
+      point = str.charCodeAt(i)
+      if (point >= 0xD800 && point <= 0xDFFF) {
+        // The current character is a surrogate.
+        surrogateFound = true
+      }
+      if (point === 34 || point === 92) {
+        result += str.slice(last, i) + '\\'
+        last = i
+        found = true
+      }
+    }
+
+    if (!found) {
+      result = str
+    } else {
+      result += str.slice(last)
+    }
+    return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
+  }
+}
+
 function build (schema, options) {
   arrayItemsReferenceSerializersMap.clear()
   objectReferenceSerializersMap.clear()
@@ -66,6 +233,29 @@ function build (schema, options) {
   ajvInstance = new Ajv({ ...options.ajv, strictSchema: false, uriResolver: fastUri })
   ajvFormats(ajvInstance)
 
+  const validateDateTimeFormat = ajvFormats.get('date-time').validate
+  const validateDateFormat = ajvFormats.get('date').validate
+  const validateTimeFormat = ajvFormats.get('time').validate
+
+  ajvInstance.addKeyword({
+    keyword: 'fjs_date_type',
+    validate: (schema, date) => {
+      if (date instanceof Date) {
+        return true
+      }
+      if (schema === 'date-time') {
+        return validateDateTimeFormat(date)
+      }
+      if (schema === 'date') {
+        return validateDateFormat(date)
+      }
+      if (schema === 'time') {
+        return validateTimeFormat(date)
+      }
+      return false
+    }
+  })
+
   isValidSchema(schema)
   if (options.schema) {
     // eslint-disable-next-line
@@ -74,11 +264,8 @@ function build (schema, options) {
     }
   }
 
-  let intParseFunctionName = 'trunc'
   if (options.rounding) {
-    if (['floor', 'ceil', 'round'].includes(options.rounding)) {
-      intParseFunctionName = options.rounding
-    } else {
+    if (!['floor', 'ceil', 'round'].includes(options.rounding)) {
       throw new Error(`Unsupported integer rounding method ${options.rounding}`)
     }
   }
@@ -99,15 +286,7 @@ function build (schema, options) {
     }
   }
 
-  /* eslint no-new-func: "off" */
-  let code = `
-    'use strict'
-  `
-
-  code += `
-    ${asFunctions}
-    function parseInteger(int) { return Math.${intParseFunctionName}(int) }
-    `
+  const serializer = new Serializer(options)
 
   let location = {
     schema,
@@ -124,62 +303,34 @@ function build (schema, options) {
     schema.type = inferTypeByKeyword(schema)
   }
 
-  let main
-
-  switch (schema.type) {
-    case 'object':
-      main = '$main'
-      code = buildObject(location, code, main)
-      break
-    case 'string':
-      main = schema.nullable ? '$asStringNullable' : getStringSerializer(schema.format)
-      break
-    case 'integer':
-      main = schema.nullable ? '$asIntegerNullable' : '$asInteger'
-      break
-    case 'number':
-      main = schema.nullable ? '$asNumberNullable' : '$asNumber'
-      break
-    case 'boolean':
-      main = schema.nullable ? '$asBooleanNullable' : '$asBoolean'
-      break
-    case 'null':
-      main = '$asNull'
-      break
-    case 'array':
-      main = '$main'
-      code = buildArray(location, code, main)
-      schema = location.schema
-      break
-    case undefined:
-      main = '$asAny'
-      break
-    default:
-      throw new Error(`${schema.type} unsupported`)
-  }
-
-  code += `
-    ;
-     return ${main}
-  `
-  const dependencies = [ajvInstance]
-  const dependenciesName = ['ajv']
-  ajvInstance = null
+  const { code, laterCode } = buildValue('', 'main', 'input', location)
+  const contextFunctionCode = `
+    'use strict'
+    function main (input) {
+      let json = ''
+      ${code}
+      return json
+    }
+    ${laterCode}
+    return main
+    `
 
-  dependenciesName.push(code)
+  const dependenciesName = ['ajv', 'serializer', contextFunctionCode]
 
   if (options.debugMode) {
-    return {
-      code: dependenciesName.join('\n'),
-      ajv: dependencies[0]
-    }
+    return { code: dependenciesName.join('\n'), ajv: ajvInstance }
   }
 
+  /* eslint no-new-func: "off" */
+  const contextFunc = new Function('ajv', 'serializer', contextFunctionCode)
+  const stringifyFunc = contextFunc(ajvInstance, serializer)
+
+  ajvInstance = null
   arrayItemsReferenceSerializersMap.clear()
   objectReferenceSerializersMap.clear()
   schemaReferenceMap.clear()
 
-  return (Function.apply(null, dependenciesName).apply(null, dependencies))
+  return stringifyFunc
 }
 
 const objectKeywords = [
@@ -239,171 +390,15 @@ function inferTypeByKeyword (schema) {
   return schema.type
 }
 
-const stringSerializerMap = {
-  'date-time': '$asDatetime',
-  date: '$asDate',
-  time: '$asTime'
-}
-
-function getStringSerializer (format) {
-  return stringSerializerMap[format] ||
-  '$asString'
-}
-
-function getTestSerializer (format) {
-  return stringSerializerMap[format]
-}
-
-const asFunctions = `
-function $pad2Zeros (num) {
-  const s = '00' + num
-  return s[s.length - 2] + s[s.length - 1]
-}
-
-function $asAny (i) {
-  return JSON.stringify(i)
-}
-
-function $asNull () {
-  return 'null'
-}
-
-function $asInteger (i) {
-  if (typeof i === 'bigint') {
-    return i.toString()
-  } else if (Number.isInteger(i)) {
-    return $asNumber(i)
-  } else {
-    /* eslint no-undef: "off" */
-    return $asNumber(parseInteger(i))
-  }
-}
-
-function $asIntegerNullable (i) {
-  return i === null ? null : $asInteger(i)
-}
-
-function $asNumber (i) {
-  const num = Number(i)
-  if (isNaN(num)) {
-    return 'null'
-  } else {
-    return '' + num
+function getStringSerializer (format, nullable) {
+  switch (format) {
+    case 'date-time': return nullable ? 'serializer.asDatetimeNullable.bind(serializer)' : 'serializer.asDatetime.bind(serializer)'
+    case 'date': return nullable ? 'serializer.asDateNullable.bind(serializer)' : 'serializer.asDate.bind(serializer)'
+    case 'time': return nullable ? 'serializer.asTimeNullable.bind(serializer)' : 'serializer.asTime.bind(serializer)'
+    default: return nullable ? 'serializer.asStringNullable.bind(serializer)' : 'serializer.asString.bind(serializer)'
   }
 }
 
-function $asNumberNullable (i) {
-  return i === null ? null : $asNumber(i)
-}
-
-function $asBoolean (bool) {
-  return bool && 'true' || 'false' // eslint-disable-line
-}
-
-function $asBooleanNullable (bool) {
-  return bool === null ? null : $asBoolean(bool)
-}
-
-function $asDatetime (date, skipQuotes) {
-  const quotes = skipQuotes === true ? '' : '"'
-  if (date instanceof Date) {
-    return quotes + date.toISOString() + quotes
-  } else if (date && typeof date.toISOString === 'function') {
-    return quotes + date.toISOString() + quotes
-  } else {
-    return $asString(date, skipQuotes)
-  }
-}
-
-function $asDate (date, skipQuotes) {
-  const quotes = skipQuotes === true ? '' : '"'
-  if (date instanceof Date) {
-    return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000 )).toISOString().slice(0, 10) + quotes
-  } else if (date && typeof date.format === 'function') {
-    return quotes + date.format('YYYY-MM-DD') + quotes
-  } else {
-    return $asString(date, skipQuotes)
-  }
-}
-
-function $asTime (date, skipQuotes) {
-  const quotes = skipQuotes === true ? '' : '"'
-  if (date instanceof Date) {
-    const hour = new Intl.DateTimeFormat('en', { hour: 'numeric', hour12: false }).format(date)
-    const minute = new Intl.DateTimeFormat('en', { minute: 'numeric' }).format(date)
-    const second = new Intl.DateTimeFormat('en', { second: 'numeric' }).format(date)
-    return quotes + $pad2Zeros(hour) + ':' + $pad2Zeros(minute) + ':' + $pad2Zeros(second) + quotes
-  } else if (date && typeof date.format === 'function') {
-    return quotes + date.format('HH:mm:ss') + quotes
-  } else {
-    return $asString(date, skipQuotes)
-  }
-}
-
-function $asString (str, skipQuotes) {
-  const quotes = skipQuotes === true ? '' : '"'
-  if (str instanceof Date) {
-    return quotes + str.toISOString() + quotes
-  } else if (str === null) {
-    return quotes + quotes
-  } else if (str instanceof RegExp) {
-    str = str.source
-  } else if (typeof str !== 'string') {
-    str = str.toString()
-  }
-  // If we skipQuotes it means that we are using it as test
-  // no need to test the string length for the render
-  if (skipQuotes) {
-    return str
-  }
-
-  if (str.length < 42) {
-    return $asStringSmall(str)
-  } else {
-    return JSON.stringify(str)
-  }
-}
-
-function $asStringNullable (str) {
-  return str === null ? null : $asString(str)
-}
-
-// magically escape strings for json
-// relying on their charCodeAt
-// everything below 32 needs JSON.stringify()
-// every string that contain surrogate needs JSON.stringify()
-// 34 and 92 happens all the time, so we
-// have a fast case for them
-function $asStringSmall (str) {
-  const l = str.length
-  let result = ''
-  let last = 0
-  let found = false
-  let surrogateFound = false
-  let point = 255
-  // eslint-disable-next-line
-  for (var i = 0; i < l && point >= 32; i++) {
-    point = str.charCodeAt(i)
-    if (point >= 0xD800 && point <= 0xDFFF) {
-      // The current character is a surrogate.
-      surrogateFound = true
-    }
-    if (point === 34 || point === 92) {
-      result += str.slice(last, i) + '\\\\'
-      last = i
-      found = true
-    }
-  }
-
-  if (!found) {
-    result = str
-  } else {
-    result += str.slice(last)
-  }
-  return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
-}
-`
-
 function addPatternProperties (location) {
   const schema = location.schema
   const pp = schema.patternProperties
@@ -413,103 +408,56 @@ function addPatternProperties (location) {
       for (var i = 0; i < keys.length; i++) {
         if (properties[keys[i]]) continue
   `
+  let laterCode = ''
+
   Object.keys(pp).forEach((regex, index) => {
     let ppLocation = mergeLocation(location, { schema: pp[regex] })
     if (pp[regex].$ref) {
       ppLocation = refFinder(pp[regex].$ref, location)
       pp[regex] = ppLocation.schema
     }
-    const type = pp[regex].type
-    const format = pp[regex].format
-    const stringSerializer = getStringSerializer(format)
+
     try {
       RegExp(regex)
     } catch (err) {
       throw new Error(`${err.message}. Found at ${regex} matching ${JSON.stringify(pp[regex])}`)
     }
 
-    const ifPpKeyExists = `if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {`
-
-    if (type === 'object') {
-      code += `${buildObject(ppLocation, '', 'buildObjectPP' + index)}
-          ${ifPpKeyExists}
-          ${addComma}
-          json += $asString(keys[i]) + ':' + buildObjectPP${index}(obj[keys[i]])
-      `
-    } else if (type === 'array') {
-      code += `${buildArray(ppLocation, '', 'buildArrayPP' + index)}
-          ${ifPpKeyExists}
-          ${addComma}
-          json += $asString(keys[i]) + ':' + buildArrayPP${index}(obj[keys[i]])
-      `
-    } else if (type === 'null') {
-      code += `
-          ${ifPpKeyExists}
-          ${addComma}
-          json += $asString(keys[i]) +':null'
-      `
-    } else if (type === 'string') {
-      code += `
-          ${ifPpKeyExists}
-          ${addComma}
-          json += $asString(keys[i]) + ':' + ${stringSerializer}(obj[keys[i]])
-      `
-    } else if (type === 'integer') {
-      code += `
-          ${ifPpKeyExists}
-          ${addComma}
-          json += $asString(keys[i]) + ':' + $asInteger(obj[keys[i]])
-      `
-    } else if (type === 'number') {
-      code += `
-          ${ifPpKeyExists}
-          ${addComma}
-          json += $asString(keys[i]) + ':' + $asNumber(obj[keys[i]])
-      `
-    } else if (type === 'boolean') {
-      code += `
-          ${ifPpKeyExists}
-          ${addComma}
-          json += $asString(keys[i]) + ':' + $asBoolean(obj[keys[i]])
-      `
-    } else if (type === undefined) {
-      code += `
-          ${ifPpKeyExists}
-          ${addComma}
-          json += $asString(keys[i]) + ':' + $asAny(obj[keys[i]])
-      `
-    } else {
-      code += `
-        ${ifPpKeyExists}
-        throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
-      `
-    }
-
+    const valueCode = buildValue('', '', 'obj[keys[i]]', ppLocation)
+    laterCode += valueCode.laterCode
     code += `
-          continue
-        }
+      if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {
+        ${addComma}
+        json += serializer.asString(keys[i]) + ':'
+        ${valueCode.code}
+        continue
+      }
     `
   })
   if (schema.additionalProperties) {
-    code += additionalProperty(location)
+    const additionalPropertyCode = additionalProperty(location)
+    code += additionalPropertyCode.code
+    laterCode += additionalPropertyCode.laterCode
   }
 
   code += `
       }
   `
-  return code
+  return { code, laterCode }
 }
 
 function additionalProperty (location) {
   let ap = location.schema.additionalProperties
   let code = ''
   if (ap === true) {
-    return `
+    code += `
         if (obj[keys[i]] !== undefined && typeof obj[keys[i]] !== 'function' && typeof obj[keys[i]] !== 'symbol') {
           ${addComma}
-          json += $asString(keys[i]) + ':' + JSON.stringify(obj[keys[i]])
+          json += serializer.asString(keys[i]) + ':' + JSON.stringify(obj[keys[i]])
         }
     `
+
+    return { code, laterCode: '' }
   }
   let apLocation = mergeLocation(location, { schema: ap })
   if (ap.$ref) {
@@ -517,72 +465,29 @@ function additionalProperty (location) {
     ap = apLocation.schema
   }
 
-  const type = ap.type
-  const format = ap.format
-  const stringSerializer = getStringSerializer(format)
-  if (type === 'object') {
-    code += `${buildObject(apLocation, '', 'buildObjectAP')}
-        ${addComma}
-        json += $asString(keys[i]) + ':' + buildObjectAP(obj[keys[i]])
-    `
-  } else if (type === 'array') {
-    code += `${buildArray(apLocation, '', 'buildArrayAP')}
-        ${addComma}
-        json += $asString(keys[i]) + ':' + buildArrayAP(obj[keys[i]])
-    `
-  } else if (type === 'null') {
-    code += `
-        ${addComma}
-        json += $asString(keys[i]) +':null'
-    `
-  } else if (type === 'string') {
-    code += `
-        ${addComma}
-        json += $asString(keys[i]) + ':' + ${stringSerializer}(obj[keys[i]])
-    `
-  } else if (type === 'integer') {
-    code += `
-        var t = Number(obj[keys[i]])
-        if (!isNaN(t)) {
-          ${addComma}
-          json += $asString(keys[i]) + ':' + t
-        }
-    `
-  } else if (type === 'number') {
-    code += `
-        var t = Number(obj[keys[i]])
-        if (!isNaN(t)) {
-          ${addComma}
-          json += $asString(keys[i]) + ':' + t
-        }
-    `
-  } else if (type === 'boolean') {
-    code += `
-        ${addComma}
-        json += $asString(keys[i]) + ':' + $asBoolean(obj[keys[i]])
-    `
-  } else if (type === undefined) {
-    code += `
-        ${addComma}
-        json += $asString(keys[i]) + ':' + $asAny(obj[keys[i]])
-    `
-  } else {
-    code += `
-        throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
-    `
-  }
-  return code
+  const valueCode = buildValue('', '', 'obj[keys[i]]', apLocation)
+
+  code += `
+    ${addComma}
+    json += serializer.asString(keys[i]) + ':'
+    ${valueCode.code}
+  `
+
+  return { code, laterCode: valueCode.laterCode }
 }
 
 function addAdditionalProperties (location) {
-  return `
+  const additionalPropertyCode = additionalProperty(location)
+  const code = `
       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)}
+        ${additionalPropertyCode.code}
       }
   `
+
+  return { code, laterCode: additionalPropertyCode.laterCode }
 }
 
 function idFinder (schema, searchedId) {
@@ -716,15 +621,15 @@ function refFinder (ref, location) {
   }
 }
 
-function buildCode (location, code, laterCode, name) {
+function buildCode (location, code, laterCode, locationPath) {
   if (location.schema.$ref) {
     location = refFinder(location.schema.$ref, location)
   }
 
   const schema = location.schema
-  let required = schema.required
+  const required = schema.required || []
 
-  Object.keys(schema.properties || {}).forEach((key, i, a) => {
+  Object.keys(schema.properties || {}).forEach((key) => {
     let propertyLocation = mergeLocation(location, { schema: schema.properties[key] })
     if (schema.properties[key].$ref) {
       propertyLocation = refFinder(schema.properties[key].$ref, location)
@@ -734,61 +639,27 @@ function buildCode (location, code, laterCode, name) {
     // Using obj['key'] !== undefined instead of obj.hasOwnProperty(prop) for perf reasons,
     // see https://github.com/mcollina/fast-json-stringify/pull/3 for discussion.
 
-    const type = schema.properties[key].type
-    const nullable = schema.properties[key].nullable
     const sanitized = JSON.stringify(key)
     const asString = JSON.stringify(sanitized)
 
-    if (nullable) {
-      code += `
-        if (obj[${sanitized}] === null) {
-          ${addComma}
-          json += ${asString} + ':null'
-          var rendered = true
-        } else {
-      `
-    }
-
-    if (type === 'number') {
-      code += `
-          var t = Number(obj[${sanitized}])
-          if (!isNaN(t)) {
-            ${addComma}
-            json += ${asString} + ':' + t
-      `
-    } else if (type === 'integer') {
-      code += `
-          var rendered = false
-          var t = $asInteger(obj[${sanitized}])
-          if (!isNaN(t)) {
-            ${addComma}
-            json += ${asString} + ':' + t
-            rendered = true
-          }
-          if (rendered) {
+    code += `
+      if (obj[${sanitized}] !== undefined) {
+        ${addComma}
+        json += ${asString} + ':'
       `
-    } else {
-      code += `
-        if (obj[${sanitized}] !== undefined) {
-          ${addComma}
-          json += ${asString} + ':'
-        `
 
-      const result = nested(laterCode, name, key, mergeLocation(propertyLocation, { schema: schema.properties[key] }), undefined, false)
-      code += result.code
-      laterCode = result.laterCode
-    }
+    const result = buildValue(laterCode, locationPath + key, `obj[${JSON.stringify(key)}]`, mergeLocation(propertyLocation, { schema: schema.properties[key] }))
+    code += result.code
+    laterCode = result.laterCode
 
     const defaultValue = schema.properties[key].default
     if (defaultValue !== undefined) {
-      required = filterRequired(required, key)
       code += `
       } else {
         ${addComma}
         json += ${asString} + ':' + ${JSON.stringify(JSON.stringify(defaultValue))}
       `
-    } else if (required && required.indexOf(key) !== -1) {
-      required = filterRequired(required, key)
+    } else if (required.includes(key)) {
       code += `
       } else {
         throw new Error('${sanitized} is required!')
@@ -798,75 +669,122 @@ function buildCode (location, code, laterCode, name) {
     code += `
       }
     `
+  })
 
-    if (nullable) {
-      code += `
-        }
-      `
+  for (const requiredProperty of required) {
+    if (schema.properties && schema.properties[requiredProperty] !== undefined) continue
+    code += `if (obj['${requiredProperty}'] === undefined) throw new Error('"${requiredProperty}" is required!')\n`
+  }
+
+  return { code, laterCode }
+}
+
+function mergeAllOfSchema (location, schema, mergedSchema) {
+  for (let allOfSchema of schema.allOf) {
+    if (allOfSchema.$ref) {
+      allOfSchema = refFinder(allOfSchema.$ref, mergeLocation(location, { schema: allOfSchema })).schema
     }
-  })
 
-  if (required && required.length > 0) {
-    code += 'var required = ['
-    // eslint-disable-next-line
-    for (var i = 0; i < required.length; i++) {
-      if (i > 0) {
-        code += ','
+    let allOfSchemaType = allOfSchema.type
+    if (allOfSchemaType === undefined) {
+      allOfSchemaType = inferTypeByKeyword(allOfSchema)
+    }
+
+    if (allOfSchemaType !== undefined) {
+      if (
+        mergedSchema.type !== undefined &&
+        mergedSchema.type !== allOfSchemaType
+      ) {
+        throw new Error('allOf schemas have different type values')
       }
-      code += `${JSON.stringify(required[i])}`
+      mergedSchema.type = allOfSchemaType
     }
-    code += `]
-      for (var i = 0; i < required.length; i++) {
-        if (obj[required[i]] === undefined) throw new Error('"' + required[i] + '" is required!')
+
+    if (allOfSchema.format !== undefined) {
+      if (
+        mergedSchema.format !== undefined &&
+        mergedSchema.format !== allOfSchema.format
+      ) {
+        throw new Error('allOf schemas have different format values')
       }
-    `
-  }
+      mergedSchema.format = allOfSchema.format
+    }
 
-  if (schema.allOf) {
-    const builtCode = buildCodeWithAllOfs(location, code, laterCode, name)
-    code = builtCode.code
-    laterCode = builtCode.laterCode
-  }
+    if (allOfSchema.nullable !== undefined) {
+      if (
+        mergedSchema.nullable !== undefined &&
+        mergedSchema.nullable !== allOfSchema.nullable
+      ) {
+        throw new Error('allOf schemas have different nullable values')
+      }
+      mergedSchema.nullable = allOfSchema.nullable
+    }
 
-  return { code, laterCode }
-}
+    if (allOfSchema.properties !== undefined) {
+      if (mergedSchema.properties === undefined) {
+        mergedSchema.properties = {}
+      }
+      Object.assign(mergedSchema.properties, allOfSchema.properties)
+    }
 
-function filterRequired (required, key) {
-  if (!required) {
-    return required
-  }
-  return required.filter(k => k !== key)
-}
+    if (allOfSchema.additionalProperties !== undefined) {
+      if (mergedSchema.additionalProperties === undefined) {
+        mergedSchema.additionalProperties = {}
+      }
+      Object.assign(mergedSchema.additionalProperties, allOfSchema.additionalProperties)
+    }
 
-function buildCodeWithAllOfs (location, code, laterCode, name) {
-  if (location.schema.allOf) {
-    location.schema.allOf.forEach((ss) => {
-      const builtCode = buildCodeWithAllOfs(mergeLocation(location, { schema: ss }), code, laterCode, name)
-      code = builtCode.code
-      laterCode = builtCode.laterCode
-    })
-  } else {
-    const builtCode = buildCode(location, code, laterCode, name)
+    if (allOfSchema.patternProperties !== undefined) {
+      if (mergedSchema.patternProperties === undefined) {
+        mergedSchema.patternProperties = {}
+      }
+      Object.assign(mergedSchema.patternProperties, allOfSchema.patternProperties)
+    }
 
-    code = builtCode.code
-    laterCode = builtCode.laterCode
-  }
+    if (allOfSchema.required !== undefined) {
+      if (mergedSchema.required === undefined) {
+        mergedSchema.required = []
+      }
+      mergedSchema.required.push(...allOfSchema.required)
+    }
 
-  return { code, laterCode }
+    if (allOfSchema.oneOf !== undefined) {
+      if (mergedSchema.oneOf === undefined) {
+        mergedSchema.oneOf = []
+      }
+      mergedSchema.oneOf.push(...allOfSchema.oneOf)
+    }
+
+    if (allOfSchema.anyOf !== undefined) {
+      if (mergedSchema.anyOf === undefined) {
+        mergedSchema.anyOf = []
+      }
+      mergedSchema.anyOf.push(...allOfSchema.anyOf)
+    }
+
+    if (allOfSchema.allOf !== undefined) {
+      mergeAllOfSchema(location, allOfSchema, mergedSchema)
+    }
+  }
+  delete mergedSchema.allOf
 }
 
-function buildInnerObject (location, name) {
+function buildInnerObject (location, locationPath) {
   const schema = location.schema
-  const result = buildCodeWithAllOfs(location, '', '', name)
+  const result = buildCode(location, '', '', locationPath)
   if (schema.patternProperties) {
-    result.code += addPatternProperties(location)
+    const { code, laterCode } = addPatternProperties(location)
+    result.code += code
+    result.laterCode += laterCode
   } else if (schema.additionalProperties && !schema.patternProperties) {
-    result.code += addAdditionalProperties(location)
+    const { code, laterCode } = addAdditionalProperties(location)
+    result.code += code
+    result.laterCode += laterCode
   }
   return result
 }
 
-function addIfThenElse (location, name) {
+function addIfThenElse (location, locationPath) {
   let code = ''
   let r
   let laterCode = ''
@@ -891,12 +809,12 @@ function addIfThenElse (location, name) {
     if (valid) {
   `
   if (merged.if && merged.then) {
-    innerR = addIfThenElse(mergedLocation, name + 'Then')
+    innerR = addIfThenElse(mergedLocation, locationPath + 'Then')
     code += innerR.code
     laterCode = innerR.laterCode
   }
 
-  r = buildInnerObject(mergedLocation, name + 'Then')
+  r = buildInnerObject(mergedLocation, locationPath + 'Then')
   code += r.code
   laterCode += r.laterCode
 
@@ -911,12 +829,12 @@ function addIfThenElse (location, name) {
     `
 
   if (merged.if && merged.then) {
-    innerR = addIfThenElse(mergedLocation, name + 'Else')
+    innerR = addIfThenElse(mergedLocation, locationPath + 'Else')
     code += innerR.code
     laterCode += innerR.laterCode
   }
 
-  r = buildInnerObject(mergedLocation, name + 'Else')
+  r = buildInnerObject(mergedLocation, locationPath + 'Else')
   code += r.code
   laterCode += r.laterCode
 
@@ -933,13 +851,14 @@ function toJSON (variableName) {
   `
 }
 
-function buildObject (location, code, name) {
+function buildObject (location, code, functionName, locationPath) {
   const schema = location.schema
   if (schema.$id !== undefined) {
     schemaReferenceMap.set(schema.$id, schema)
   }
   code += `
-    function ${name} (input) {
+    function ${functionName} (input) {
+      // ${locationPath}
   `
   if (schema.nullable) {
     code += `
@@ -949,14 +868,14 @@ function buildObject (location, code, name) {
   `
   }
 
-  if (objectReferenceSerializersMap.has(schema) && objectReferenceSerializersMap.get(schema) !== name) {
+  if (objectReferenceSerializersMap.has(schema) && objectReferenceSerializersMap.get(schema) !== functionName) {
     code += `
       return ${objectReferenceSerializersMap.get(schema)}(input)
     }
     `
     return code
   }
-  objectReferenceSerializersMap.set(schema, name)
+  objectReferenceSerializersMap.set(schema, functionName)
 
   code += `
       var obj = ${toJSON('input')}
@@ -969,9 +888,9 @@ function buildObject (location, code, name) {
     code += `
       var valid
     `
-    r = addIfThenElse(location, name)
+    r = addIfThenElse(location, locationPath)
   } else {
-    r = buildInnerObject(location, name)
+    r = buildInnerObject(location, locationPath)
   }
 
   // Removes the comma if is the last element of the string (in case there are not properties)
@@ -985,13 +904,14 @@ function buildObject (location, code, name) {
   return code
 }
 
-function buildArray (location, code, name, key = null) {
+function buildArray (location, code, functionName, locationPath) {
   let schema = location.schema
   if (schema.$id !== undefined) {
     schemaReferenceMap.set(schema.$id, schema)
   }
   code += `
-    function ${name} (obj) {
+    function ${functionName} (obj) {
+      // ${locationPath}
   `
   if (schema.nullable) {
     code += `
@@ -1024,14 +944,14 @@ function buildArray (location, code, name, key = null) {
       `
       return code
     }
-    arrayItemsReferenceSerializersMap.set(schema.items, name)
+    arrayItemsReferenceSerializersMap.set(schema.items, functionName)
   }
 
   let result = { code: '', laterCode: '' }
   const accessor = '[i]'
   if (Array.isArray(schema.items)) {
     result = schema.items.reduce((res, item, i) => {
-      const tmpRes = nested(laterCode, name, accessor, mergeLocation(location, { schema: item }), i, true)
+      const tmpRes = buildValue(laterCode, locationPath + accessor + i, 'obj[i]', mergeLocation(location, { schema: item }))
       const condition = `i === ${i} && ${buildArrayTypeCondition(item.type, accessor)}`
       return {
         code: `${res.code}
@@ -1044,7 +964,7 @@ function buildArray (location, code, name, key = null) {
     }, result)
 
     if (schema.additionalItems) {
-      const tmpRes = nested(laterCode, name, accessor, mergeLocation(location, { schema: schema.items }), undefined, true)
+      const tmpRes = buildValue(laterCode, locationPath + accessor, 'obj[i]', mergeLocation(location, { schema: schema.items }))
       result.code += `
       else if (i >= ${schema.items.length}) {
         ${tmpRes.code}
@@ -1058,54 +978,39 @@ function buildArray (location, code, name, key = null) {
     }
     `
   } else {
-    result = nested(laterCode, name, accessor, mergeLocation(location, { schema: schema.items }), undefined, true)
-  }
-
-  if (key) {
-    code += `
-    if(!Array.isArray(obj)) {
-      throw new TypeError(\`Property '${key}' should be of type array, received '$\{obj}' instead.\`)
-    }
-    `
+    result = buildValue(laterCode, locationPath + accessor, 'obj[i]', mergeLocation(location, { schema: schema.items }))
   }
 
   code += `
-    var l = obj.length
-    if (l && l >= ${largeArraySize}) {`
+    if (!Array.isArray(obj)) {
+      throw new TypeError(\`The value '$\{obj}' does not match schema definition.\`)
+    }
+  `
 
-  const concatSnippet = `
+  code += 'const arrayLength = obj.length\n'
+  if (largeArrayMechanism !== 'default') {
+    if (largeArrayMechanism === 'json-stringify') {
+      code += `if (arrayLength && arrayLength >= ${largeArraySize}) return JSON.stringify(obj)\n`
+    } else {
+      throw new Error(`Unsupported large array mechanism ${largeArrayMechanism}`)
     }
+  }
 
-    var jsonOutput= ''
-    for (var i = 0; i < l; i++) {
-      var json = ''
+  code += `
+    let jsonOutput= ''
+    for (let i = 0; i < arrayLength; i++) {
+      let json = ''
       ${result.code}
       jsonOutput += json
 
-      if (json.length > 0 && i < l - 1) {
+      if (json.length > 0 && i < arrayLength - 1) {
         jsonOutput += ','
       }
     }
     return \`[\${jsonOutput}]\`
   }`
 
-  switch (largeArrayMechanism) {
-    case 'default':
-      code += `
-      return \`[\${obj.map(${result.mapFnName}).join(',')}]\``
-      break
-
-    case 'json-stringify':
-      code += `
-      return JSON.stringify(obj)`
-      break
-
-    default:
-      throw new Error(`Unsupported large array mechanism ${largeArrayMechanism}`)
-  }
-
   code += `
-  ${concatSnippet}
   ${result.laterCode}
   `
 
@@ -1173,26 +1078,12 @@ function dereferenceOfRefs (location, type) {
   return locations
 }
 
-let strNameCounter = 0
-function asFuncName (str) {
-  // only allow chars that can work
-  let rep = str.replace(/[^a-zA-Z0-9$_]/g, '')
-
-  if (rep.length === 0) {
-    return 'anan' + strNameCounter++
-  } else if (rep !== str) {
-    rep += strNameCounter++
-  }
-
-  return rep
+let genFuncNameCounter = 0
+function generateFuncName () {
+  return 'anonymous' + genFuncNameCounter++
 }
 
-function nested (laterCode, name, key, location, subKey, isArray) {
-  let code = ''
-  let funcName
-
-  subKey = subKey || ''
-
+function buildValue (laterCode, locationPath, input, location) {
   let schema = location.schema
 
   if (schema.$ref) {
@@ -1206,121 +1097,99 @@ function nested (laterCode, name, key, location, subKey, isArray) {
     }
   }
 
+  if (schema.allOf) {
+    const mergedSchema = clone(schema)
+    mergeAllOfSchema(location, schema, mergedSchema)
+    schema = mergedSchema
+    location.schema = mergedSchema
+  }
+
   const type = schema.type
   const nullable = schema.nullable === true
 
-  const accessor = isArray ? key : `[${JSON.stringify(key)}]`
+  let code = ''
+  let funcName
 
   switch (type) {
     case 'null':
-      funcName = '$asNull'
       code += `
-        json += $asNull()
+        json += serializer.asNull()
       `
       break
     case 'string': {
-      funcName = '$asString'
-      const stringSerializer = getStringSerializer(schema.format)
-      code += nullable ? `json += obj${accessor} === null ? null : ${stringSerializer}(obj${accessor})` : `json += ${stringSerializer}(obj${accessor})`
+      funcName = getStringSerializer(schema.format, nullable)
+      code += `json += ${funcName}(${input})`
       break
     }
     case 'integer':
-      funcName = '$asInteger'
-      code += nullable ? `json += obj${accessor} === null ? null : $asInteger(obj${accessor})` : `json += $asInteger(obj${accessor})`
+      funcName = nullable ? 'serializer.asIntegerNullable.bind(serializer)' : 'serializer.asInteger.bind(serializer)'
+      code += `json += ${funcName}(${input})`
       break
     case 'number':
-      funcName = '$asNumber'
-      code += nullable ? `json += obj${accessor} === null ? null : $asNumber(obj${accessor})` : `json += $asNumber(obj${accessor})`
+      funcName = nullable ? 'serializer.asNumberNullable.bind(serializer)' : 'serializer.asNumber.bind(serializer)'
+      code += `json += ${funcName}(${input})`
       break
     case 'boolean':
-      funcName = '$asBoolean'
-      code += nullable ? `json += obj${accessor} === null ? null : $asBoolean(obj${accessor})` : `json += $asBoolean(obj${accessor})`
+      funcName = nullable ? 'serializer.asBooleanNullable.bind(serializer)' : 'serializer.asBoolean.bind(serializer)'
+      code += `json += ${funcName}(${input})`
       break
     case 'object':
-      funcName = asFuncName(name + key + subKey)
-      laterCode = buildObject(location, laterCode, funcName)
-      code += `
-        json += ${funcName}(obj${accessor})
-      `
+      funcName = generateFuncName()
+      laterCode = buildObject(location, laterCode, funcName, locationPath)
+      code += `json += ${funcName}(${input})`
       break
     case 'array':
-      funcName = asFuncName('$arr' + name + key + subKey) // eslint-disable-line
-      laterCode = buildArray(location, laterCode, funcName, key)
-      code += `
-        json += ${funcName}(obj${accessor})
-      `
+      funcName = generateFuncName()
+      laterCode = buildArray(location, laterCode, funcName, locationPath)
+      code += `json += ${funcName}(${input})`
       break
     case undefined:
-      funcName = '$asNull'
-      if ('anyOf' in schema) {
+      if (schema.anyOf || schema.oneOf) {
         // beware: dereferenceOfRefs has side effects and changes schema.anyOf
-        const anyOfLocations = dereferenceOfRefs(location, 'anyOf')
-        anyOfLocations.forEach((location, index) => {
-          const nestedResult = nested(laterCode, name, key, location, subKey !== '' ? subKey : 'i' + index, isArray)
-          // We need a test serializer as the String serializer will not work with
-          // date/time ajv validations
-          // see: https://github.com/fastify/fast-json-stringify/issues/325
-          const testSerializer = getTestSerializer(location.schema.format)
-          const testValue = testSerializer !== undefined ? `${testSerializer}(obj${accessor}, true)` : `obj${accessor}`
-
+        const locations = dereferenceOfRefs(location, schema.anyOf ? 'anyOf' : 'oneOf')
+        locations.forEach((location, index) => {
+          const nestedResult = buildValue(laterCode, 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. `nested`, through `buildCode`, replaces any reference in object properties 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)
 
-          const schemaKey = location.schema.$id || randomUUID()
-          ajvInstance.addSchema(location.schema, schemaKey)
-
-          code += `
-            ${index === 0 ? 'if' : 'else if'}(ajv.validate("${schemaKey}", ${testValue}))
-              ${nestedResult.code}
-          `
-          laterCode = nestedResult.laterCode
-        })
-        code += `
-          else json+= null
-        `
-      } else if ('oneOf' in schema) {
-        // beware: dereferenceOfRefs has side effects and changes schema.oneOf
-        const oneOfLocations = dereferenceOfRefs(location, 'oneOf')
-        oneOfLocations.forEach((location, index) => {
-          const nestedResult = nested(laterCode, name, key, location, subKey !== '' ? subKey : 'i' + index, isArray)
-          const testSerializer = getTestSerializer(location.schema.format)
-          const testValue = testSerializer !== undefined ? `${testSerializer}(obj${accessor}, true)` : `obj${accessor}`
-          // see comment on anyOf about dereferencing the schema before calling ajv.validate
+          // 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(location.schema, schemaKey)
+          ajvInstance.addSchema(extendedSchema, schemaKey)
 
           code += `
-            ${index === 0 ? 'if' : 'else if'}(ajv.validate("${schemaKey}", ${testValue}))
+            ${index === 0 ? 'if' : 'else if'}(ajv.validate("${schemaKey}", ${input}))
               ${nestedResult.code}
           `
           laterCode = nestedResult.laterCode
         })
 
-        if (!isArray) {
-          code += `
-            else json+= null
-          `
-        }
+        code += `
+          else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
+        `
       } else if (isEmpty(schema)) {
         code += `
-          json += JSON.stringify(obj${accessor})
+          json += JSON.stringify(${input})
         `
       } else if ('const' in schema) {
         code += `
-          if(ajv.validate(${JSON.stringify(schema)}, obj${accessor}))
+          if(ajv.validate(${JSON.stringify(schema)}, ${input}))
             json += '${JSON.stringify(schema.const)}'
           else
-            throw new Error(\`Item $\{JSON.stringify(obj${accessor})} does not match schema definition.\`)
+            throw new Error(\`Item $\{JSON.stringify(${input})} does not match schema definition.\`)
         `
       } else if (schema.type === undefined) {
         code += `
-          json += JSON.stringify(obj${accessor})
+          json += JSON.stringify(${input})
         `
       } else {
         throw new Error(`${schema.type} unsupported`)
@@ -1328,51 +1197,46 @@ function nested (laterCode, name, key, location, subKey, isArray) {
       break
     default:
       if (Array.isArray(type)) {
-        const nullIndex = type.indexOf('null')
-        const sortedTypes = nullIndex !== -1 ? [type[nullIndex]].concat(type.slice(0, nullIndex)).concat(type.slice(nullIndex + 1)) : type
+        let sortedTypes = type
+        const nullable = schema.nullable === true || type.includes('null')
+
+        if (nullable) {
+          sortedTypes = sortedTypes.filter(type => type !== 'null')
+          code += `
+            if (${input} === null) {
+              json += null
+            } else {`
+        }
+
         sortedTypes.forEach((type, index) => {
           const statement = index === 0 ? 'if' : 'else if'
           const tempSchema = Object.assign({}, schema, { type })
-          const nestedResult = nested(laterCode, name, key, mergeLocation(location, { schema: tempSchema }), subKey, isArray)
+          const nestedResult = buildValue(laterCode, locationPath, input, mergeLocation(location, { schema: tempSchema }))
           switch (type) {
             case 'string': {
               code += `
-                ${statement}(obj${accessor} === null || typeof obj${accessor} === "${type}" || obj${accessor} instanceof Date || typeof obj${accessor}.toISOString === "function" || obj${accessor} instanceof RegExp || (typeof obj${accessor} === "object" && Object.hasOwnProperty.call(obj${accessor}, "toString")))
-                  ${nestedResult.code}
-              `
-              break
-            }
-            case 'null': {
-              code += `
-                ${statement}(obj${accessor} == null)
+                ${statement}(${input} === null || typeof ${input} === "${type}" || ${input} instanceof Date || ${input} instanceof RegExp || (typeof ${input} === "object" && Object.hasOwnProperty.call(${input}, "toString")))
                   ${nestedResult.code}
               `
               break
             }
             case 'array': {
               code += `
-                ${statement}(Array.isArray(obj${accessor}))
+                ${statement}(Array.isArray(${input}))
                   ${nestedResult.code}
               `
               break
             }
             case 'integer': {
               code += `
-                ${statement}(Number.isInteger(obj${accessor}) || obj${accessor} === null)
-                  ${nestedResult.code}
-              `
-              break
-            }
-            case 'number': {
-              code += `
-                ${statement}(isNaN(obj${accessor}) === false)
+                ${statement}(Number.isInteger(${input}) || ${input} === null)
                   ${nestedResult.code}
               `
               break
             }
             default: {
               code += `
-                ${statement}(typeof obj${accessor} === "${type}")
+                ${statement}(typeof ${input} === "${type}" || ${input} === null)
                   ${nestedResult.code}
               `
               break
@@ -1381,17 +1245,32 @@ function nested (laterCode, name, key, location, subKey, isArray) {
           laterCode = nestedResult.laterCode
         })
         code += `
-          else json+= null
+          else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
         `
+
+        if (nullable) {
+          code += `
+            }
+          `
+        }
       } else {
         throw new Error(`${type} unsupported`)
       }
   }
 
-  return {
-    code,
-    laterCode,
-    mapFnName: funcName
+  return { code, laterCode }
+}
+
+function extendDateTimeType (schema) {
+  if (schema.type === 'string' && ['date-time', 'date', 'time'].includes(schema.format)) {
+    schema.fjs_date_type = schema.format
+    delete schema.type
+    delete schema.format
+  }
+  for (const property in schema) {
+    if (typeof schema[property] === 'object') {
+      extendDateTimeType(schema[property])
+    }
   }
 }
 
@@ -1410,7 +1289,8 @@ module.exports = build
 module.exports.validLargeArrayMechanisms = validLargeArrayMechanisms
 
 module.exports.restore = function ({ code, ajv }) {
+  const serializer = new Serializer()
   // eslint-disable-next-line
-  return (Function.apply(null, ['ajv', code])
-    .apply(null, [ajv]))
+  return (Function.apply(null, ['ajv', 'serializer', code])
+    .apply(null, [ajv, serializer]))
 }