fast-json-stringify 5.2.0 → 5.4.0

package/index.js

@@ -4,13 +4,13 @@
 
 const merge = require('@fastify/deepmerge')()
 const clone = require('rfdc')({ proto: true })
-const fjsCloned = Symbol('fast-json-stringify.cloned')
 const { randomUUID } = require('crypto')
 
-const validate = require('./schema-validator')
-const Serializer = require('./serializer')
-const Validator = require('./validator')
-const RefResolver = require('./ref-resolver')
+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'
@@ -41,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)
@@ -64,41 +56,42 @@ function resolveRef (location, ref) {
     throw new Error(`Cannot find reference "${ref}"`)
   }
 
+  if (location.isValidated) {
+    validatorSchemasIds.add(schemaId)
+  }
+
+  const newLocation = new Location(schema, schemaId, jsonPointer, location.isValidated)
   if (schema.$ref !== undefined) {
-    return resolveRef({ schema, schemaId, jsonPointer }, schema.$ref)
+    return resolveRef(newLocation, schema.$ref)
   }
 
-  return { schema, schemaId, jsonPointer }
+  return newLocation
 }
 
-const arrayItemsReferenceSerializersMap = new Map()
-const objectReferenceSerializersMap = new Map()
+const contextFunctionsNamesBySchema = new Map()
 
 let rootSchemaId = null
 let refResolver = null
-let validator = null
 let contextFunctions = null
+let validatorSchemasIds = null
 
 function build (schema, options) {
-  arrayItemsReferenceSerializersMap.clear()
-  objectReferenceSerializersMap.clear()
+  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)
     }
   }
@@ -113,7 +106,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}`)
     }
   }
 
@@ -125,9 +118,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 = `
@@ -138,7 +129,15 @@ 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 dependenciesName = ['validator', 'serializer', contextFunctionCode]
 
@@ -147,13 +146,19 @@ function build (schema, options) {
   }
 
   if (options.mode === 'debug') {
-    return { code: dependenciesName.join('\n'), validator, ajv: validator.ajv }
+    return {
+      validator,
+      serializer,
+      code: dependenciesName.join('\n'),
+      ajv: validator.ajv
+    }
   }
 
   if (options.mode === 'standalone') {
     // lazy load
-    const buildStandaloneCode = require('./standalone')
-    return buildStandaloneCode(options, validator, contextFunctionCode)
+    const isValidatorUsed = validatorSchemasIds.size > 0
+    const buildStandaloneCode = require('./lib/standalone')
+    return buildStandaloneCode(options, validator, isValidatorUsed, contextFunctionCode)
   }
 
   /* eslint no-new-func: "off" */
@@ -161,11 +166,10 @@ function build (schema, options) {
   const stringifyFunc = contextFunc(validator, serializer)
 
   refResolver = null
-  validator = null
   rootSchemaId = null
   contextFunctions = null
-  arrayItemsReferenceSerializersMap.clear()
-  objectReferenceSerializersMap.clear()
+  validatorSchemasIds = null
+  contextFunctionsNamesBySchema.clear()
 
   return stringifyFunc
 }
@@ -227,106 +231,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
-    }
+  const patternPropertiesLocation = location.getPropertyLocation('patternProperties')
+  const patternPropertiesSchema = patternPropertiesLocation.schema
 
-    try {
-      RegExp(regex)
-    } catch (err) {
-      throw new Error(`${err.message}. Found at ${regex} matching ${JSON.stringify(pp[regex])}`)
-    }
+  if (patternPropertiesSchema !== undefined) {
+    for (const propertyKey in patternPropertiesSchema) {
+      const propertyLocation = patternPropertiesLocation.getPropertyLocation(propertyKey)
 
-    const valueCode = buildValue(ppLocation, 'obj[keys[i]]')
-    code += `
-      if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {
-        ${addComma}
-        json += serializer.asString(keys[i]) + ':'
-        ${valueCode}
-        continue
+      try {
+        RegExp(propertyKey)
+      } catch (err) {
+        const jsonPointer = propertyLocation.getSchemaRef()
+        throw new Error(`${err.message}. Invalid pattern property regexp key ${propertyKey} at ${jsonPointer}`)
       }
-    `
-  })
-  if (schema.additionalProperties) {
-    code += additionalProperty(location)
-  }
 
-  code += `
-      }
-  `
-  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)
@@ -367,17 +347,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
     }
 
@@ -465,24 +449,14 @@ 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) {
+  location.isValidated = true
+  validatorSchemasIds.add(location.getSchemaId())
 
-function addIfThenElse (location) {
   const schema = merge({}, location.schema)
   const thenSchema = schema.then
   const elseSchema = schema.else || { additionalProperties: true }
@@ -491,41 +465,22 @@ function addIfThenElse (location) {
   delete schema.then
   delete schema.else
 
-  const ifLocation = mergeLocation(location, 'if')
-  const ifSchemaRef = ifLocation.schemaId + ifLocation.jsonPointer
-
-  let code = `
-    if (validator.validate("${ifSchemaRef}", obj)) {
-  `
+  const ifLocation = location.getPropertyLocation('if')
+  const ifSchemaRef = ifLocation.getSchemaRef()
 
-  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) {
@@ -538,25 +493,22 @@ function toJSON (variableName) {
 function buildObject (location) {
   const schema = location.schema
 
-  if (objectReferenceSerializersMap.has(schema)) {
-    return objectReferenceSerializersMap.get(schema)
+  if (contextFunctionsNamesBySchema.has(schema)) {
+    return contextFunctionsNamesBySchema.get(schema)
   }
 
   const functionName = generateFuncName()
-  objectReferenceSerializersMap.set(schema, functionName)
+  contextFunctionsNamesBySchema.set(schema, functionName)
+
+  let schemaRef = location.getSchemaRef()
+  if (schemaRef.startsWith(rootSchemaId)) {
+    schemaRef = schemaRef.replace(rootSchemaId, '')
+  }
 
-  const schemaId = location.schemaId === rootSchemaId ? '' : location.schemaId
   let functionCode = `
     function ${functionName} (input) {
-      // ${schemaId + location.jsonPointer}
+      // ${schemaRef}
   `
-  if (schema.nullable) {
-    functionCode += `
-      if (input === null) {
-        return 'null';
-      }
-  `
-  }
 
   functionCode += `
       var obj = ${toJSON('input')}
@@ -564,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
@@ -581,48 +528,34 @@ function buildObject (location) {
 }
 
 function buildArray (location) {
-  let schema = location.schema
-
-  // default to any items type
-  if (!schema.items) {
-    schema.items = {}
-  }
-
-  let itemsLocation = mergeLocation(location, 'items')
+  const schema = location.schema
 
-  if (schema.items.$ref) {
-    if (!schema[fjsCloned]) {
-      location.schema = clone(location.schema)
-      schema = location.schema
-      schema[fjsCloned] = true
-    }
+  let itemsLocation = location.getPropertyLocation('items')
+  itemsLocation.schema = itemsLocation.schema || {}
 
-    location = resolveRef(location, schema.items.$ref)
-    itemsLocation = location
-    schema.items = location.schema
+  if (itemsLocation.schema.$ref) {
+    itemsLocation = resolveRef(itemsLocation, itemsLocation.schema.$ref)
   }
 
-  if (arrayItemsReferenceSerializersMap.has(schema.items)) {
-    return arrayItemsReferenceSerializersMap.get(schema.items)
+  const itemsSchema = itemsLocation.schema
+
+  if (contextFunctionsNamesBySchema.has(schema)) {
+    return contextFunctionsNamesBySchema.get(schema)
   }
 
   const functionName = generateFuncName()
-  arrayItemsReferenceSerializersMap.set(schema.items, functionName)
+  contextFunctionsNamesBySchema.set(schema, functionName)
+
+  let schemaRef = location.getSchemaRef()
+  if (schemaRef.startsWith(rootSchemaId)) {
+    schemaRef = schemaRef.replace(rootSchemaId, '')
+  }
 
-  const schemaId = location.schemaId === rootSchemaId ? '' : location.schemaId
   let functionCode = `
     function ${functionName} (obj) {
-      // ${schemaId + location.jsonPointer}
+      // ${schemaRef}
   `
 
-  if (schema.nullable) {
-    functionCode += `
-      if (obj === null) {
-        return 'null';
-      }
-    `
-  }
-
   functionCode += `
     if (!Array.isArray(obj)) {
       throw new TypeError(\`The value '$\{obj}' does not match schema definition.\`)
@@ -632,8 +565,8 @@ function buildArray (location) {
 
   if (!schema.additionalItems) {
     functionCode += `
-      if (arrayLength > ${schema.items.length}) {
-        throw new Error(\`Item at ${schema.items.length} does not match schema definition.\`)
+      if (arrayLength > ${itemsSchema.length}) {
+        throw new Error(\`Item at ${itemsSchema.length} does not match schema definition.\`)
       }
     `
   }
@@ -650,10 +583,10 @@ function buildArray (location) {
     let jsonOutput = ''
   `
 
-  if (Array.isArray(schema.items)) {
-    for (let i = 0; i < schema.items.length; i++) {
-      const item = schema.items[i]
-      const tmpRes = buildValue(mergeLocation(itemsLocation, i), `obj[${i}]`)
+  if (Array.isArray(itemsSchema)) {
+    for (let i = 0; i < itemsSchema.length; i++) {
+      const item = itemsSchema[i]
+      const tmpRes = buildValue(itemsLocation.getPropertyLocation(i), `obj[${i}]`)
       functionCode += `
         if (${i} < arrayLength) {
           if (${buildArrayTypeCondition(item.type, `[${i}]`)}) {
@@ -672,7 +605,7 @@ function buildArray (location) {
 
     if (schema.additionalItems) {
       functionCode += `
-        for (let i = ${schema.items.length}; i < arrayLength; i++) {
+        for (let i = ${itemsSchema.length}; i < arrayLength; i++) {
           let json = JSON.stringify(obj[i])
           jsonOutput += json
           if (i < arrayLength - 1) {
@@ -743,6 +676,137 @@ function generateFuncName () {
   return 'anonymous' + genFuncNameCounter++
 }
 
+function buildMultiTypeSerializer (location, input) {
+  const schema = location.schema
+  const types = schema.type.sort(t1 => t1 === 'null' ? -1 : 1)
+
+  let code = ''
+
+  types.forEach((type, index) => {
+    location.schema = { ...location.schema, type }
+    const nestedResult = buildSingleTypeSerializer(location, input)
+
+    const statement = index === 0 ? 'if' : 'else if'
+    switch (type) {
+      case 'null':
+        code += `
+          ${statement} (${input} === null)
+            ${nestedResult}
+          `
+        break
+      case 'string': {
+        code += `
+          ${statement}(
+            typeof ${input} === "string" ||
+            ${input} === null ||
+            ${input} instanceof Date ||
+            ${input} instanceof RegExp ||
+            (
+              typeof ${input} === "object" &&
+              typeof ${input}.toString === "function" &&
+              ${input}.toString !== Object.prototype.toString &&
+              !(${input} instanceof Date)
+            )
+          )
+            ${nestedResult}
+        `
+        break
+      }
+      case 'array': {
+        code += `
+          ${statement}(Array.isArray(${input}))
+            ${nestedResult}
+        `
+        break
+      }
+      case 'integer': {
+        code += `
+          ${statement}(Number.isInteger(${input}) || ${input} === null)
+            ${nestedResult}
+        `
+        break
+      }
+      default: {
+        code += `
+          ${statement}(typeof ${input} === "${type}" || ${input} === null)
+            ${nestedResult}
+        `
+        break
+      }
+    }
+  })
+  code += `
+    else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
+  `
+
+  return code
+}
+
+function buildSingleTypeSerializer (location, input) {
+  const schema = location.schema
+
+  switch (schema.type) {
+    case 'null':
+      return 'json += \'null\''
+    case 'string': {
+      if (schema.format === 'date-time') {
+        return `json += serializer.asDateTime(${input})`
+      } else if (schema.format === 'date') {
+        return `json += serializer.asDate(${input})`
+      } else if (schema.format === 'time') {
+        return `json += serializer.asTime(${input})`
+      } else {
+        return `json += serializer.asString(${input})`
+      }
+    }
+    case 'integer':
+      return `json += serializer.asInteger(${input})`
+    case 'number':
+      return `json += serializer.asNumber(${input})`
+    case 'boolean':
+      return `json += serializer.asBoolean(${input})`
+    case 'object': {
+      const funcName = buildObject(location)
+      return `json += ${funcName}(${input})`
+    }
+    case 'array': {
+      const funcName = buildArray(location)
+      return `json += ${funcName}(${input})`
+    }
+    case undefined:
+      return `json += JSON.stringify(${input})`
+    default:
+      throw new Error(`${schema.type} unsupported`)
+  }
+}
+
+function buildConstSerializer (location, input) {
+  const schema = location.schema
+  const type = schema.type
+
+  const hasNullType = Array.isArray(type) && type.includes('null')
+
+  let code = ''
+
+  if (hasNullType) {
+    code += `
+      if (${input} === null) {
+        json += 'null'
+      } else {
+    `
+  }
+
+  code += `json += '${JSON.stringify(schema.const)}'`
+
+  if (hasNullType) {
+    code += `
+      }
+    `
+  }
+
+  return code
+}
+
 function buildValue (location, input) {
   let schema = location.schema
 
@@ -762,196 +826,73 @@ 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
-  const nullable = schema.nullable === true || (Array.isArray(type) && type.includes('null'))
 
   let code = ''
-  let funcName
 
-  if ('const' in schema) {
-    if (nullable) {
+  if (type === undefined && (schema.anyOf || schema.oneOf)) {
+    location.isValidated = true
+    validatorSchemasIds.add(location.getSchemaId())
+
+    const type = schema.anyOf ? 'anyOf' : 'oneOf'
+    const anyOfLocation = location.getPropertyLocation(type)
+
+    for (let index = 0; index < location.schema[type].length; index++) {
+      const optionLocation = anyOfLocation.getPropertyLocation(index)
+      const schemaRef = optionLocation.getSchemaRef()
+      const nestedResult = buildValue(optionLocation, input)
       code += `
-        json += ${input} === null ? 'null' : '${JSON.stringify(schema.const)}'
+        ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input}))
+          ${nestedResult}
       `
-      return code
     }
-    code += `json += '${JSON.stringify(schema.const)}'`
+
+    code += `
+      else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
+    `
     return code
   }
 
-  switch (type) {
-    case 'null':
-      code += 'json += serializer.asNull()'
-      break
-    case 'string': {
-      if (schema.format === 'date-time') {
-        funcName = nullable ? 'serializer.asDateTimeNullable.bind(serializer)' : 'serializer.asDateTime.bind(serializer)'
-      } else if (schema.format === 'date') {
-        funcName = nullable ? 'serializer.asDateNullable.bind(serializer)' : 'serializer.asDate.bind(serializer)'
-      } else if (schema.format === 'time') {
-        funcName = nullable ? 'serializer.asTimeNullable.bind(serializer)' : 'serializer.asTime.bind(serializer)'
-      } else {
-        funcName = nullable ? 'serializer.asStringNullable.bind(serializer)' : 'serializer.asString.bind(serializer)'
-      }
-      code += `json += ${funcName}(${input})`
-      break
-    }
-    case 'integer':
-      funcName = nullable ? 'serializer.asIntegerNullable.bind(serializer)' : 'serializer.asInteger.bind(serializer)'
-      code += `json += ${funcName}(${input})`
-      break
-    case 'number':
-      funcName = nullable ? 'serializer.asNumberNullable.bind(serializer)' : 'serializer.asNumber.bind(serializer)'
-      code += `json += ${funcName}(${input})`
-      break
-    case 'boolean':
-      funcName = nullable ? 'serializer.asBooleanNullable.bind(serializer)' : 'serializer.asBoolean.bind(serializer)'
-      code += `json += ${funcName}(${input})`
-      break
-    case 'object':
-      funcName = buildObject(location)
-      code += `json += ${funcName}(${input})`
-      break
-    case 'array':
-      funcName = buildArray(location)
-      code += `json += ${funcName}(${input})`
-      break
-    case undefined:
-      if (schema.anyOf || schema.oneOf) {
-        // beware: dereferenceOfRefs has side effects and changes schema.anyOf
-        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'}(validator.validate("${schemaRef}", ${input}))
-              ${nestedResult}
-          `
-        }
-
-        code += `
-          else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
-        `
-      } else if (isEmpty(schema)) {
-        code += `
-          json += JSON.stringify(${input})
-        `
+  const nullable = schema.nullable === true
+  if (nullable) {
+    code += `
+      if (${input} === null) {
+        json += 'null'
       } else {
-        code += `
-          json += JSON.stringify(${input})
-        `
-      }
-      break
-    default:
-      if (Array.isArray(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 {`
-        }
+    `
+  }
 
-        const locationClone = clone(location)
-        sortedTypes.forEach((type, index) => {
-          const statement = index === 0 ? 'if' : 'else if'
-          locationClone.schema.type = type
-          const nestedResult = buildValue(locationClone, input)
-          switch (type) {
-            case 'string': {
-              code += `
-                ${statement}(
-                  typeof ${input} === "string" ||
-                  ${input} === null ||
-                  ${input} instanceof Date ||
-                  ${input} instanceof RegExp ||
-                  (
-                    typeof ${input} === "object" &&
-                    typeof ${input}.toString === "function" &&
-                    ${input}.toString !== Object.prototype.toString &&
-                    !(${input} instanceof Date)
-                  )
-                )
-                  ${nestedResult}
-              `
-              break
-            }
-            case 'array': {
-              code += `
-                ${statement}(Array.isArray(${input}))
-                  ${nestedResult}
-              `
-              break
-            }
-            case 'integer': {
-              code += `
-                ${statement}(Number.isInteger(${input}) || ${input} === null)
-                  ${nestedResult}
-              `
-              break
-            }
-            case 'object': {
-              code += `
-                ${statement}(typeof ${input} === "object" || ${input} === null)
-                  ${nestedResult}
-              `
-              break
-            }
-            default: {
-              code += `
-                ${statement}(typeof ${input} === "${type}" || ${input} === null)
-                  ${nestedResult}
-              `
-              break
-            }
-          }
-        })
-        code += `
-          else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
-        `
+  if (schema.const !== undefined) {
+    code += buildConstSerializer(location, input)
+  } else if (Array.isArray(type)) {
+    code += buildMultiTypeSerializer(location, input)
+  } else {
+    code += buildSingleTypeSerializer(location, input)
+  }
 
-        if (nullable) {
-          code += `
-            }
-          `
-        }
-      } else {
-        throw new Error(`${type} unsupported`)
+  if (nullable) {
+    code += `
       }
+    `
   }
 
   return code
 }
 
-function isEmpty (schema) {
-  // eslint-disable-next-line
-  for (var key in schema) {
-    if (Object.prototype.hasOwnProperty.call(schema, key) && schema[key] !== undefined) {
-      return false
-    }
-  }
-  return true
-}
-
 module.exports = build
 
 module.exports.validLargeArrayMechanisms = validLargeArrayMechanisms
 
-module.exports.restore = function ({ code, validator }) {
-  const serializer = new Serializer()
+module.exports.restore = function ({ code, validator, serializer }) {
   // eslint-disable-next-line
   return (Function.apply(null, ['validator', 'serializer', code])
     .apply(null, [validator, serializer]))