fast-json-stringify 5.11.1 → 5.13.0

package/index.js

@@ -2,14 +2,13 @@
 
 /* eslint no-prototype-builtins: 0 */
 
-const merge = require('@fastify/deepmerge')()
-const clone = require('rfdc')({ proto: true })
 const { RefResolver } = require('json-schema-ref-resolver')
 
-const validate = require('./lib/schema-validator')
 const Serializer = require('./lib/serializer')
 const Validator = require('./lib/validator')
 const Location = require('./lib/location')
+const validate = require('./lib/schema-validator')
+const mergeSchemas = require('./lib/merge-schemas')
 
 const SINGLE_TICK = /'/g
 
@@ -28,8 +27,6 @@ const validLargeArrayMechanisms = [
   'json-stringify'
 ]
 
-const addComma = '!addComma && (addComma = true) || (json += \',\')'
-
 let schemaIdCounter = 0
 
 function isValidSchema (schema, name) {
@@ -46,13 +43,15 @@ function isValidSchema (schema, name) {
   }
 }
 
-function resolveRef (context, location, ref) {
+function resolveRef (context, location) {
+  const ref = location.schema.$ref
+
   let hashIndex = ref.indexOf('#')
   if (hashIndex === -1) {
     hashIndex = ref.length
   }
 
-  const schemaId = ref.slice(0, hashIndex) || location.getOriginSchemaId()
+  const schemaId = ref.slice(0, hashIndex) || location.schemaId
   const jsonPointer = ref.slice(hashIndex) || '#'
 
   const schema = context.refResolver.getSchema(schemaId, jsonPointer)
@@ -62,12 +61,17 @@ function resolveRef (context, location, ref) {
 
   const newLocation = new Location(schema, schemaId, jsonPointer)
   if (schema.$ref !== undefined) {
-    return resolveRef(context, newLocation, schema.$ref)
+    return resolveRef(context, newLocation)
   }
 
   return newLocation
 }
 
+function getMergedLocation (context, mergedSchemaId) {
+  const mergedSchema = context.refResolver.getSchema(mergedSchemaId, '#')
+  return new Location(mergedSchema, mergedSchemaId, '#')
+}
+
 function getSchemaId (schema, rootSchemaId) {
   if (schema.$id && schema.$id.charAt(0) !== '#') {
     return schema.$id
@@ -85,10 +89,10 @@ function build (schema, options) {
     functionsCounter: 0,
     functionsNamesBySchema: new Map(),
     options,
-    wrapObjects: true,
     refResolver: new RefResolver(),
     rootSchemaId: schema.$id || `__fjs_root_${schemaIdCounter++}`,
-    validatorSchemasIds: new Set()
+    validatorSchemasIds: new Set(),
+    mergedSchemasIds: new Map()
   }
 
   const schemaId = getSchemaId(schema, context.rootSchemaId)
@@ -255,7 +259,7 @@ function inferTypeByKeyword (schema) {
   return schema.type
 }
 
-function buildExtraObjectPropertiesSerializer (context, location) {
+function buildExtraObjectPropertiesSerializer (context, location, addComma) {
   const schema = location.schema
   const propertiesKeys = Object.keys(schema.properties || {})
 
@@ -314,225 +318,138 @@ function buildExtraObjectPropertiesSerializer (context, location) {
 }
 
 function buildInnerObject (context, location) {
-  let code = ''
   const schema = location.schema
-  const required = schema.required || []
 
   const propertiesLocation = location.getPropertyLocation('properties')
+  const requiredProperties = schema.required || []
 
-  const requiredWithDefault = []
-  const requiredWithoutDefault = []
-  if (schema.properties) {
-    for (const key of Object.keys(schema.properties)) {
-      if (required.indexOf(key) === -1) {
-        continue
-      }
-      let propertyLocation = propertiesLocation.getPropertyLocation(key)
-      if (propertyLocation.schema.$ref) {
-        propertyLocation = resolveRef(context, location, propertyLocation.schema.$ref)
-      }
+  // Should serialize required properties first
+  const propertiesKeys = Object.keys(schema.properties || {}).sort(
+    (key1, key2) => {
+      const required1 = requiredProperties.includes(key1)
+      const required2 = requiredProperties.includes(key2)
+      return required1 === required2 ? 0 : required1 ? -1 : 1
+    }
+  )
+  const hasRequiredProperties = requiredProperties.includes(propertiesKeys[0])
 
-      const sanitizedKey = JSON.stringify(key)
+  let code = ''
 
-      // 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 defaultValue = propertyLocation.schema.default
-      if (defaultValue === undefined) {
-        code += `if (obj[${sanitizedKey}] === undefined) throw new Error('${sanitizedKey} is required!')\n`
-        requiredWithoutDefault.push(key)
-      }
-      requiredWithDefault.push(key)
+  for (const key of requiredProperties) {
+    if (!propertiesKeys.includes(key)) {
+      code += `if (obj['${key}'] === undefined) throw new Error('"${key}" is required!')\n`
     }
   }
 
-  // handle extraneous required fields
-  for (const requiredProperty of required) {
-    if (requiredWithDefault.indexOf(requiredProperty) !== -1) continue
-    code += `if (obj['${requiredProperty}'] === undefined) throw new Error('"${requiredProperty}" is required!')\n`
+  code += 'let json = \'{\'\n'
+
+  let addComma = ''
+  if (!hasRequiredProperties) {
+    code += 'let addComma = false\n'
+    addComma = '!addComma && (addComma = true) || (json += \',\')'
   }
 
-  code += `
-    let addComma = false
-    let json = '${context.wrapObjects ? '{' : ''}'
-  `
-  const wrapObjects = context.wrapObjects
-  context.wrapObjects = true
-
-  if (schema.properties) {
-    for (const key of Object.keys(schema.properties)) {
-      let propertyLocation = propertiesLocation.getPropertyLocation(key)
-      if (propertyLocation.schema.$ref) {
-        propertyLocation = resolveRef(context, location, propertyLocation.schema.$ref)
-      }
+  for (const key of propertiesKeys) {
+    let propertyLocation = propertiesLocation.getPropertyLocation(key)
+    if (propertyLocation.schema.$ref) {
+      propertyLocation = resolveRef(context, propertyLocation)
+    }
 
-      const sanitizedKey = JSON.stringify(key)
+    const sanitizedKey = JSON.stringify(key)
+    const defaultValue = propertyLocation.schema.default
+    const isRequired = requiredProperties.includes(key)
 
-      if (requiredWithoutDefault.indexOf(key) !== -1) {
-        code += `
+    code += `
+      if (obj[${sanitizedKey}] !== undefined) {
         ${addComma}
         json += ${JSON.stringify(sanitizedKey + ':')}
         ${buildValue(context, propertyLocation, `obj[${sanitizedKey}]`)}
+      }`
+
+    if (defaultValue !== undefined) {
+      code += ` else {
+        ${addComma}
+        json += ${JSON.stringify(sanitizedKey + ':' + JSON.stringify(defaultValue))}
+      }
       `
-      } else {
-        // Using obj['key'] !== undefined instead of obj.hasOwnProperty(prop) for perf reasons,
-        // see https://github.com/mcollina/fast-json-stringify/pull/3 for discussion.
-        code += `
-        if (obj[${sanitizedKey}] !== undefined) {
-          ${addComma}
-          json += ${JSON.stringify(sanitizedKey + ':')}
-          ${buildValue(context, propertyLocation, `obj[${sanitizedKey}]`)}
-        }
-        `
-        const defaultValue = propertyLocation.schema.default
-        if (defaultValue !== undefined) {
-          code += `
-        else {
-          ${addComma}
-          json += ${JSON.stringify(sanitizedKey + ':' + JSON.stringify(defaultValue))}
-        }
-        `
-        }
+    } else if (isRequired) {
+      code += ` else {
+        throw new Error('${sanitizedKey} is required!')
       }
+      `
+    } else {
+      code += '\n'
+    }
+
+    if (hasRequiredProperties) {
+      addComma = 'json += \',\''
     }
   }
 
   if (schema.patternProperties || schema.additionalProperties) {
-    code += buildExtraObjectPropertiesSerializer(context, location)
+    code += buildExtraObjectPropertiesSerializer(context, location, addComma)
   }
 
-  context.wrapObjects = wrapObjects
   code += `
-  return json${context.wrapObjects ? ' + \'}\'' : ''}
+    return json + '}'
   `
   return code
 }
 
-function mergeAllOfSchema (context, location, schema, mergedSchema) {
-  const allOfLocation = location.getPropertyLocation('allOf')
-
-  for (let i = 0; i < schema.allOf.length; i++) {
-    let allOfSchema = schema.allOf[i]
-
-    if (allOfSchema.$ref) {
-      const allOfSchemaLocation = allOfLocation.getPropertyLocation(i)
-      allOfSchema = resolveRef(context, allOfSchemaLocation, allOfSchema.$ref).schema
+function mergeLocations (context, mergedSchemaId, mergedLocations) {
+  for (let i = 0; i < mergedLocations.length; i++) {
+    const location = mergedLocations[i]
+    const schema = location.schema
+    if (schema.$ref) {
+      mergedLocations[i] = resolveRef(context, location)
     }
+  }
 
-    let allOfSchemaType = allOfSchema.type
-    if (allOfSchemaType === undefined) {
-      allOfSchemaType = inferTypeByKeyword(allOfSchema)
-    }
+  const mergedSchemas = []
+  for (const location of mergedLocations) {
+    const schema = cloneOriginSchema(context, location.schema, location.schemaId)
+    delete schema.$id
 
-    if (allOfSchemaType !== undefined) {
-      if (
-        mergedSchema.type !== undefined &&
-        mergedSchema.type !== allOfSchemaType
-      ) {
-        throw new Error('allOf schemas have different type values')
-      }
-      mergedSchema.type = allOfSchemaType
-    }
+    mergedSchemas.push(schema)
+  }
 
-    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
-    }
+  const mergedSchema = mergeSchemas(mergedSchemas)
+  const mergedLocation = new Location(mergedSchema, mergedSchemaId)
 
-    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
-    }
+  context.refResolver.addSchema(mergedSchema, mergedSchemaId)
+  return mergedLocation
+}
 
-    if (allOfSchema.properties !== undefined) {
-      if (mergedSchema.properties === undefined) {
-        mergedSchema.properties = {}
-      }
-      Object.assign(mergedSchema.properties, allOfSchema.properties)
-    }
+function cloneOriginSchema (context, schema, schemaId) {
+  const clonedSchema = Array.isArray(schema) ? [] : {}
 
-    if (allOfSchema.additionalProperties !== undefined) {
-      if (mergedSchema.additionalProperties === undefined) {
-        mergedSchema.additionalProperties = {}
-      }
-      Object.assign(mergedSchema.additionalProperties, allOfSchema.additionalProperties)
-    }
+  if (
+    schema.$id !== undefined &&
+    schema.$id.charAt(0) !== '#'
+  ) {
+    schemaId = schema.$id
+  }
 
-    if (allOfSchema.patternProperties !== undefined) {
-      if (mergedSchema.patternProperties === undefined) {
-        mergedSchema.patternProperties = {}
-      }
-      Object.assign(mergedSchema.patternProperties, allOfSchema.patternProperties)
-    }
+  const mergedSchemaRef = context.mergedSchemasIds.get(schema)
+  if (mergedSchemaRef) {
+    context.mergedSchemasIds.set(clonedSchema, mergedSchemaRef)
+  }
 
-    if (allOfSchema.required !== undefined) {
-      if (mergedSchema.required === undefined) {
-        mergedSchema.required = []
-      }
-      mergedSchema.required.push(...allOfSchema.required)
-    }
+  for (const key in schema) {
+    let value = schema[key]
 
-    if (allOfSchema.oneOf !== undefined) {
-      if (mergedSchema.oneOf === undefined) {
-        mergedSchema.oneOf = []
-      }
-      mergedSchema.oneOf.push(...allOfSchema.oneOf)
+    if (key === '$ref' && value.charAt(0) === '#') {
+      value = schemaId + value
     }
 
-    if (allOfSchema.anyOf !== undefined) {
-      if (mergedSchema.anyOf === undefined) {
-        mergedSchema.anyOf = []
-      }
-      mergedSchema.anyOf.push(...allOfSchema.anyOf)
+    if (typeof value === 'object' && value !== null) {
+      value = cloneOriginSchema(context, value, schemaId)
     }
 
-    if (allOfSchema.allOf !== undefined) {
-      mergeAllOfSchema(context, location, allOfSchema, mergedSchema)
-    }
+    clonedSchema[key] = value
   }
-  delete mergedSchema.allOf
-
-  mergedSchema.$id = `__fjs_merged_${schemaIdCounter++}`
-  context.refResolver.addSchema(mergedSchema)
-  location.addMergedSchema(mergedSchema, mergedSchema.$id)
-}
-
-function addIfThenElse (context, location, input) {
-  context.validatorSchemasIds.add(location.getSchemaId())
-
-  const schema = merge({}, location.schema)
-  const thenSchema = schema.then
-  const elseSchema = schema.else || { additionalProperties: true }
-
-  delete schema.if
-  delete schema.then
-  delete schema.else
 
-  const ifLocation = location.getPropertyLocation('if')
-  const ifSchemaRef = ifLocation.getSchemaRef()
-
-  const thenLocation = location.getPropertyLocation('then')
-  thenLocation.schema = merge(schema, thenSchema)
-
-  const elseLocation = location.getPropertyLocation('else')
-  elseLocation.schema = merge(schema, elseSchema)
-
-  return `
-    if (validator.validate("${ifSchemaRef}", ${input})) {
-      ${buildValue(context, thenLocation, input)}
-    } else {
-      ${buildValue(context, elseLocation, input)}
-    }
-  `
+  return clonedSchema
 }
 
 function toJSON (variableName) {
@@ -582,7 +499,7 @@ function buildArray (context, location) {
   itemsLocation.schema = itemsLocation.schema || {}
 
   if (itemsLocation.schema.$ref) {
-    itemsLocation = resolveRef(context, itemsLocation, itemsLocation.schema.$ref)
+    itemsLocation = resolveRef(context, itemsLocation)
   }
 
   const itemsSchema = itemsLocation.schema
@@ -808,8 +725,24 @@ function buildSingleTypeSerializer (context, location, input) {
         return `json += serializer.asDate(${input})`
       } else if (schema.format === 'time') {
         return `json += serializer.asTime(${input})`
+      } else if (schema.format === 'unsafe') {
+        return `json += serializer.asUnsafeString(${input})`
       } else {
-        return `json += serializer.asString(${input})`
+        return `
+        if (typeof ${input} !== 'string') {
+          if (${input} === null) {
+            json += '""'
+          } else if (${input} instanceof Date) {
+            json += '"' + ${input}.toISOString() + '"'
+          } else if (${input} instanceof RegExp) {
+            json += serializer.asString(${input}.source)
+          } else {
+            json += serializer.asString(${input}.toString())
+          }
+        } else {
+          json += serializer.asString(${input})
+        }
+        `
       }
     }
     case 'integer':
@@ -860,81 +793,193 @@ function buildConstSerializer (location, input) {
   return code
 }
 
-function buildValue (context, location, input) {
-  let schema = location.schema
+function buildAllOf (context, location, input) {
+  const schema = location.schema
 
-  if (typeof schema === 'boolean') {
-    return `json += JSON.stringify(${input})`
+  let mergedSchemaId = context.mergedSchemasIds.get(schema)
+  if (mergedSchemaId) {
+    const mergedLocation = getMergedLocation(context, mergedSchemaId)
+    return buildValue(context, mergedLocation, input)
   }
 
-  if (schema.$ref) {
-    location = resolveRef(context, location, schema.$ref)
-    schema = location.schema
+  mergedSchemaId = `__fjs_merged_${schemaIdCounter++}`
+  context.mergedSchemasIds.set(schema, mergedSchemaId)
+
+  const { allOf, ...schemaWithoutAllOf } = location.schema
+  const locations = [
+    new Location(
+      schemaWithoutAllOf,
+      location.schemaId,
+      location.jsonPointer
+    )
+  ]
+
+  const allOfsLocation = location.getPropertyLocation('allOf')
+  for (let i = 0; i < allOf.length; i++) {
+    locations.push(allOfsLocation.getPropertyLocation(i))
   }
 
-  if (schema.type === undefined) {
-    const inferredType = inferTypeByKeyword(schema)
-    if (inferredType) {
-      schema.type = inferredType
+  const mergedLocation = mergeLocations(context, mergedSchemaId, locations)
+  return buildValue(context, mergedLocation, input)
+}
+
+function buildOneOf (context, location, input) {
+  context.validatorSchemasIds.add(location.schemaId)
+
+  const schema = location.schema
+
+  const type = schema.anyOf ? 'anyOf' : 'oneOf'
+  const { [type]: oneOfs, ...schemaWithoutAnyOf } = location.schema
+
+  const locationWithoutOneOf = new Location(
+    schemaWithoutAnyOf,
+    location.schemaId,
+    location.jsonPointer
+  )
+  const oneOfsLocation = location.getPropertyLocation(type)
+
+  let code = ''
+
+  for (let index = 0; index < oneOfs.length; index++) {
+    const optionLocation = oneOfsLocation.getPropertyLocation(index)
+    const optionSchema = optionLocation.schema
+
+    let mergedSchemaId = context.mergedSchemasIds.get(optionSchema)
+    let mergedLocation = null
+    if (mergedSchemaId) {
+      mergedLocation = getMergedLocation(context, mergedSchemaId)
+    } else {
+      mergedSchemaId = `__fjs_merged_${schemaIdCounter++}`
+      context.mergedSchemasIds.set(optionSchema, mergedSchemaId)
+
+      mergedLocation = mergeLocations(context, mergedSchemaId, [
+        locationWithoutOneOf,
+        optionLocation
+      ])
     }
+
+    const nestedResult = buildValue(context, mergedLocation, input)
+    const schemaRef = optionLocation.getSchemaRef()
+    code += `
+      ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input}))
+        ${nestedResult}
+    `
   }
 
-  if (schema.if && schema.then) {
-    return addIfThenElse(context, location, input)
+  let schemaRef = location.getSchemaRef()
+  if (schemaRef.startsWith(context.rootSchemaId)) {
+    schemaRef = schemaRef.replace(context.rootSchemaId, '')
   }
 
-  if (schema.allOf) {
-    mergeAllOfSchema(context, location, schema, clone(schema))
-    schema = location.schema
+  code += `
+    else throw new TypeError(\`The value of '${schemaRef}' does not match schema definition.\`)
+  `
+
+  return code
+}
+
+function buildIfThenElse (context, location, input) {
+  context.validatorSchemasIds.add(location.schemaId)
+
+  const {
+    if: ifSchema,
+    then: thenSchema,
+    else: elseSchema,
+    ...schemaWithoutIfThenElse
+  } = location.schema
+
+  const rootLocation = new Location(
+    schemaWithoutIfThenElse,
+    location.schemaId,
+    location.jsonPointer
+  )
+
+  const ifLocation = location.getPropertyLocation('if')
+  const ifSchemaRef = ifLocation.getSchemaRef()
+
+  const thenLocation = location.getPropertyLocation('then')
+  let thenMergedSchemaId = context.mergedSchemasIds.get(thenSchema)
+  let thenMergedLocation = null
+  if (thenMergedSchemaId) {
+    thenMergedLocation = getMergedLocation(context, thenMergedSchemaId)
+  } else {
+    thenMergedSchemaId = `__fjs_merged_${schemaIdCounter++}`
+    context.mergedSchemasIds.set(thenSchema, thenMergedSchemaId)
+
+    thenMergedLocation = mergeLocations(context, thenMergedSchemaId, [
+      rootLocation,
+      thenLocation
+    ])
   }
 
-  const type = schema.type
+  if (!elseSchema) {
+    return `
+      if (validator.validate("${ifSchemaRef}", ${input})) {
+        ${buildValue(context, thenMergedLocation, input)}
+      } else {
+        ${buildValue(context, rootLocation, input)}
+      }
+    `
+  }
 
-  let code = ''
+  const elseLocation = location.getPropertyLocation('else')
+  let elseMergedSchemaId = context.mergedSchemasIds.get(elseSchema)
+  let elseMergedLocation = null
+  if (elseMergedSchemaId) {
+    elseMergedLocation = getMergedLocation(context, elseMergedSchemaId)
+  } else {
+    elseMergedSchemaId = `__fjs_merged_${schemaIdCounter++}`
+    context.mergedSchemasIds.set(elseSchema, elseMergedSchemaId)
 
-  if ((type === undefined || type === 'object') && (schema.anyOf || schema.oneOf)) {
-    context.validatorSchemasIds.add(location.getSchemaId())
+    elseMergedLocation = mergeLocations(context, elseMergedSchemaId, [
+      rootLocation,
+      elseLocation
+    ])
+  }
 
-    if (schema.type === 'object') {
-      context.wrapObjects = false
-      const funcName = buildObject(context, location)
-      code += `
-        json += '{'
-        json += ${funcName}(${input})
-        json += ','
-      `
+  return `
+    if (validator.validate("${ifSchemaRef}", ${input})) {
+      ${buildValue(context, thenMergedLocation, input)}
+    } else {
+      ${buildValue(context, elseMergedLocation, input)}
     }
+  `
+}
 
-    const type = schema.anyOf ? 'anyOf' : 'oneOf'
-    const anyOfLocation = location.getPropertyLocation(type)
+function buildValue (context, location, input) {
+  let schema = location.schema
 
-    for (let index = 0; index < location.schema[type].length; index++) {
-      const optionLocation = anyOfLocation.getPropertyLocation(index)
-      const schemaRef = optionLocation.getSchemaRef()
-      const nestedResult = buildValue(context, optionLocation, input)
-      code += `
-        ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input}))
-          ${nestedResult}
-      `
-    }
+  if (typeof schema === 'boolean') {
+    return `json += JSON.stringify(${input})`
+  }
 
-    let schemaRef = location.getSchemaRef()
-    if (schemaRef.startsWith(context.rootSchemaId)) {
-      schemaRef = schemaRef.replace(context.rootSchemaId, '')
-    }
+  if (schema.$ref) {
+    location = resolveRef(context, location)
+    schema = location.schema
+  }
 
-    code += `
-      else throw new TypeError(\`The value of '${schemaRef}' does not match schema definition.\`)
-    `
-    if (schema.type === 'object') {
-      code += `
-        json += '}'
-      `
-      context.wrapObjects = true
+  if (schema.allOf) {
+    return buildAllOf(context, location, input)
+  }
+
+  if (schema.anyOf || schema.oneOf) {
+    return buildOneOf(context, location, input)
+  }
+
+  if (schema.if && schema.then) {
+    return buildIfThenElse(context, location, input)
+  }
+
+  if (schema.type === undefined) {
+    const inferredType = inferTypeByKeyword(schema)
+    if (inferredType) {
+      schema.type = inferredType
     }
-    return code
   }
 
+  let code = ''
+
+  const type = schema.type
   const nullable = schema.nullable === true
   if (nullable) {
     code += `