fast-json-stringify 1.19.0 → 1.21.0

package/README.md

@@ -578,6 +578,31 @@ allowing user input to directly supply a schema.
 It can't be guaranteed that allowing user input for the schema couldn't feasibly expose an attack
 vector.
 
+<a name="debug"></a>
+### Debug Mode
+
+The debug mode can be activated during your development to understand what is going on when things do not
+work as you expect.
+
+```js
+const debugCompiled = fastJson({
+  title: 'default string',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'string'
+    }
+  }
+}, { debugMode: true })
+
+console.log(debugCompiled) // it is an array of functions that can create your `stringify` function
+console.log(debugCompiled.toString()) // print a "ready to read" string function, you can save it to a file
+
+const rawString = debugCompiled.toString()
+const stringify = fastJson.restore(rawString) // use the generated string to get back the `stringify` function
+console.log(stringify({ firstName: 'Foo', surname: 'bar' })) // '{"firstName":"Foo"}'
+```
+
 <a name="acknowledgements"></a>
 ## Acknowledgements
 

package/index.js

@@ -138,6 +138,14 @@ function build (schema, options) {
   }
 
   dependenciesName.push(code)
+
+  if (options.debugMode) {
+    dependenciesName.toString = function () {
+      return dependenciesName.join('\n')
+    }
+    return dependenciesName
+  }
+
   return (Function.apply(null, dependenciesName).apply(null, dependencies))
 }
 
@@ -271,7 +279,7 @@ function $asBooleanNullable (bool) {
 function $asDatetime (date) {
   if (date instanceof Date) {
     return '"' + date.toISOString() + '"'
-  } else if (typeof date.toISOString === 'function') {
+  } else if (date && typeof date.toISOString === 'function') {
     return '"' + date.toISOString() + '"'
   } else {
     return $asString(date)
@@ -284,7 +292,7 @@ function $asDate (date) {
     var month = new Intl.DateTimeFormat('en', { month: '2-digit' }).format(date)
     var day = new Intl.DateTimeFormat('en', { day: '2-digit' }).format(date)
     return '"' + year + '-' + month + '-' + day + '"'
-  } else if (typeof date.format === 'function') {
+  } else if (date && typeof date.format === 'function') {
     return '"' + date.format('YYYY-MM-DD') + '"'
   } else {
     return $asString(date)
@@ -297,7 +305,7 @@ function $asTime (date) {
     var minute = new Intl.DateTimeFormat('en', { minute: 'numeric' }).format(date)
     var second = new Intl.DateTimeFormat('en', { second: 'numeric' }).format(date)
     return '"' + $pad2Zeros(hour) + ':' + $pad2Zeros(minute) + ':' + $pad2Zeros(second) + '"'
-  } else if (typeof date.format === 'function') {
+  } else if (date && typeof date.format === 'function') {
     return '"' + date.format('HH:mm:ss') + '"'
   } else {
     return $asString(date)
@@ -375,6 +383,11 @@ function addPatternProperties (schema, externalSchema, fullSchema) {
     var type = pp[regex].type
     var format = pp[regex].format
     var stringSerializer = getStringSerializer(format)
+    try {
+      RegExp(regex)
+    } catch (err) {
+      throw new Error(`${err.message}. Found at ${regex} matching ${JSON.stringify(pp[regex])}`)
+    }
     code += `
         if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {
     `
@@ -417,7 +430,7 @@ function addPatternProperties (schema, externalSchema, fullSchema) {
       `
     } else {
       code += `
-        throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ${type}')
+        throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
       `
     }
 
@@ -510,7 +523,7 @@ function additionalProperty (schema, externalSchema, fullSchema) {
     `
   } else {
     code += `
-        throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ${type}')
+        throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
     `
   }
   return code
@@ -579,7 +592,7 @@ function refFinder (ref, schema, externalSchema) {
       return dereferenced
     } else {
       for (var i = 1; i < walk.length; i++) {
-        code += `['${sanitizeKey(walk[i])}']`
+        code += `[${JSON.stringify(walk[i])}]`
       }
     }
   }
@@ -595,35 +608,27 @@ function refFinder (ref, schema, externalSchema) {
 
   function findBadKey (obj, keys) {
     if (keys.length === 0) return null
-    const key = sanitizeKey(keys.shift())
+    const key = keys.shift()
     if (obj[key] === undefined) {
       stringSimilarity = stringSimilarity || require('string-similarity')
       const { bestMatch } = stringSimilarity.findBestMatch(key, Object.keys(obj))
       if (bestMatch.rating >= 0.5) {
-        throw new Error(`Cannot find reference '${key}', did you mean '${bestMatch.target}'?`)
+        throw new Error(`Cannot find reference ${JSON.stringify(key)}, did you mean ${JSON.stringify(bestMatch.target)}?`)
       } else {
-        throw new Error(`Cannot find reference '${key}'`)
+        throw new Error(`Cannot find reference ${JSON.stringify(key)}`)
       }
     }
     return findBadKey(obj[key], keys)
   }
 }
 
-function sanitizeKey (key) {
-  const rep = key.replace(/(\\*)'/g, function (match, p1) {
-    var base = ''
-    if (p1.length % 2 === 1) {
-      base = p1.slice(2)
-    } else {
-      base = p1
-    }
-    var rep = base + '\\\''
-    return rep
-  })
-  return rep
-}
-
 function buildCode (schema, code, laterCode, name, externalSchema, fullSchema) {
+  if (schema.$ref) {
+    schema = refFinder(schema.$ref, fullSchema, externalSchema)
+  }
+
+  var required = schema.required
+
   Object.keys(schema.properties || {}).forEach((key, i, a) => {
     if (schema.properties[key].$ref) {
       // if the schema object is deep in the tree, we must resolve the ref in the parent scope
@@ -636,14 +641,14 @@ function buildCode (schema, code, laterCode, name, externalSchema, fullSchema) {
 
     var type = schema.properties[key].type
     var nullable = schema.properties[key].nullable
-    var sanitized = sanitizeKey(key)
-    var asString = sanitizeKey($asString(key).replace(/\\/g, '\\\\'))
+    var sanitized = JSON.stringify(key)
+    var asString = JSON.stringify(sanitized)
 
     if (nullable) {
       code += `
-        if (obj['${sanitized}'] === null) {
+        if (obj[${sanitized}] === null) {
           ${addComma}
-          json += '${asString}:null'
+          json += ${asString} + ':null'
           var rendered = true
         } else {
       `
@@ -651,10 +656,10 @@ function buildCode (schema, code, laterCode, name, externalSchema, fullSchema) {
 
     if (type === 'number') {
       code += `
-          var t = Number(obj['${sanitized}'])
+          var t = Number(obj[${sanitized}])
           if (!isNaN(t)) {
             ${addComma}
-            json += '${asString}:' + t
+            json += ${asString} + ':' + t
       `
     } else if (type === 'integer') {
       code += `
@@ -662,25 +667,25 @@ function buildCode (schema, code, laterCode, name, externalSchema, fullSchema) {
       `
       if (isLong) {
         code += `
-            if (isLong(obj['${sanitized}'])) {
+            if (isLong(obj[${sanitized}])) {
               ${addComma}
-              json += '${asString}:' + obj['${sanitized}'].toString()
+              json += ${asString} + ':' + obj[${sanitized}].toString()
               rendered = true
             } else {
-              var t = Number(obj['${sanitized}'])
+              var t = Number(obj[${sanitized}])
               if (!isNaN(t)) {
                 ${addComma}
-                json += '${asString}:' + t
+                json += ${asString} + ':' + t
                 rendered = true
               }
             }
         `
       } else {
         code += `
-            var t = Number(obj['${sanitized}'])
+            var t = Number(obj[${sanitized}])
             if (!isNaN(t)) {
               ${addComma}
-              json += '${asString}:' + t
+              json += ${asString} + ':' + t
               rendered = true
             }
         `
@@ -690,24 +695,26 @@ function buildCode (schema, code, laterCode, name, externalSchema, fullSchema) {
       `
     } else {
       code += `
-        if (obj['${sanitized}'] !== undefined) {
+        if (obj[${sanitized}] !== undefined) {
           ${addComma}
-          json += '${asString}:'
+          json += ${asString} + ':'
         `
 
-      var result = nested(laterCode, name, key, schema.properties[key], externalSchema, fullSchema)
+      var result = nested(laterCode, name, key, schema.properties[key], externalSchema, fullSchema, undefined, false)
       code += result.code
       laterCode = result.laterCode
     }
 
     var defaultValue = schema.properties[key].default
     if (defaultValue !== undefined) {
+      required = filterRequired(schema.required, key)
       code += `
       } else {
         ${addComma}
-        json += '${asString}:${sanitizeKey(JSON.stringify(defaultValue).replace(/\\/g, '\\\\'))}'
+        json += ${asString} + ':' + ${JSON.stringify(JSON.stringify(defaultValue))}
       `
     } else if (schema.required && schema.required.indexOf(key) !== -1) {
+      required = filterRequired(schema.required, key)
       code += `
       } else {
         throw new Error('${sanitized} is required!')
@@ -724,9 +731,33 @@ function buildCode (schema, code, laterCode, name, externalSchema, fullSchema) {
       `
     }
   })
+
+  if (required && required.length > 0) {
+    code += 'var required = ['
+    for (var i = 0; i < required.length; i++) {
+      if (i > 0) {
+        code += ','
+      }
+      code += `${JSON.stringify(required[i])}`
+    }
+    code += ']'
+    code += `
+      for (var i = 0; i < required.length; i++) {
+        if (obj[required[i]] === undefined) throw new Error('"' + required[i] + '" is required!')
+      }
+    `
+  }
+
   return { code: code, laterCode: laterCode }
 }
 
+function filterRequired (required, key) {
+  if (!required) {
+    return required
+  }
+  return required.filter(k => k !== key)
+}
+
 function buildCodeWithAllOfs (schema, code, laterCode, name, externalSchema, fullSchema) {
   if (schema.allOf) {
     schema.allOf.forEach((ss) => {
@@ -882,7 +913,7 @@ function buildArray (schema, code, name, externalSchema, fullSchema) {
   if (Array.isArray(schema.items)) {
     result = schema.items.reduce((res, item, i) => {
       var accessor = '[i]'
-      const tmpRes = nested(laterCode, name, accessor, item, externalSchema, fullSchema, i)
+      const tmpRes = nested(laterCode, name, accessor, item, externalSchema, fullSchema, i, true)
       var condition = `i === ${i} && ${buildArrayTypeCondition(item.type, accessor)}`
       return {
         code: `${res.code}
@@ -899,7 +930,7 @@ function buildArray (schema, code, name, externalSchema, fullSchema) {
     }
     `
   } else {
-    result = nested(laterCode, name, '[i]', schema.items, externalSchema, fullSchema)
+    result = nested(laterCode, name, '[i]', schema.items, externalSchema, fullSchema, undefined, true)
   }
 
   code += `
@@ -973,7 +1004,21 @@ function dereferenceOfRefs (schema, externalSchema, fullSchema, type) {
   })
 }
 
-function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKey) {
+var strNameCounter = 0
+function asFuncName (str) {
+  // only allow chars that can work
+  var rep = str.replace(/[^a-zA-Z0-9$_]/g, '')
+
+  if (rep.length === 0) {
+    return 'anan' + strNameCounter++
+  } else if (rep !== str) {
+    rep += strNameCounter++
+  }
+
+  return rep
+}
+
+function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKey, isArray) {
   var code = ''
   var funcName
 
@@ -993,7 +1038,8 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
   var type = schema.type
   var nullable = schema.nullable === true
 
-  var accessor = key.indexOf('[') === 0 ? sanitizeKey(key) : `['${sanitizeKey(key)}']`
+  var accessor = isArray ? key : `[${JSON.stringify(key)}]`
+
   switch (type) {
     case 'null':
       code += `
@@ -1014,14 +1060,14 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
       code += nullable ? `json += obj${accessor} === null ? null : $asBoolean(obj${accessor})` : `json += $asBoolean(obj${accessor})`
       break
     case 'object':
-      funcName = (name + key + subKey).replace(/[-.\[\] ]/g, '') // eslint-disable-line
+      funcName = asFuncName(name + key + subKey)
       laterCode = buildObject(schema, laterCode, funcName, externalSchema, fullSchema)
       code += `
         json += ${funcName}(obj${accessor})
       `
       break
     case 'array':
-      funcName = '$arr' + (name + key + subKey).replace(/[-.\[\] ]/g, '') // eslint-disable-line
+      funcName = asFuncName('$arr' + name + key + subKey) // eslint-disable-line
       laterCode = buildArray(schema, laterCode, funcName, externalSchema, fullSchema)
       code += `
         json += ${funcName}(obj${accessor})
@@ -1031,7 +1077,7 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
       if ('anyOf' in schema) {
         dereferenceOfRefs(schema, externalSchema, fullSchema, 'anyOf')
         schema.anyOf.forEach((s, index) => {
-          var nestedResult = nested(laterCode, name, key, s, externalSchema, fullSchema, subKey !== '' ? subKey : 'i' + index)
+          var nestedResult = nested(laterCode, name, key, s, externalSchema, fullSchema, subKey !== '' ? subKey : 'i' + index, isArray)
           code += `
             ${index === 0 ? 'if' : 'else if'}(ajv.validate(${require('util').inspect(s, { depth: null })}, obj${accessor}))
               ${nestedResult.code}
@@ -1044,7 +1090,7 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
       } else if ('oneOf' in schema) {
         dereferenceOfRefs(schema, externalSchema, fullSchema, 'oneOf')
         schema.oneOf.forEach((s, index) => {
-          var nestedResult = nested(laterCode, name, key, s, externalSchema, fullSchema, subKey !== '' ? subKey : 'i' + index)
+          var nestedResult = nested(laterCode, name, key, s, externalSchema, fullSchema, subKey !== '' ? subKey : 'i' + index, isArray)
           code += `
             ${index === 0 ? 'if' : 'else if'}(ajv.validate(${require('util').inspect(s, { depth: null })}, obj${accessor}))
               ${nestedResult.code}
@@ -1068,10 +1114,11 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
         const sortedTypes = nullIndex !== -1 ? [type[nullIndex]].concat(type.slice(0, nullIndex)).concat(type.slice(nullIndex + 1)) : type
         sortedTypes.forEach((type, index) => {
           var tempSchema = Object.assign({}, schema, { type })
-          var nestedResult = nested(laterCode, name, key, tempSchema, externalSchema, fullSchema, subKey)
+          var nestedResult = nested(laterCode, name, key, tempSchema, externalSchema, fullSchema, subKey, isArray)
+
           if (type === 'string') {
             code += `
-              ${index === 0 ? 'if' : 'else if'}(typeof obj${accessor} === "${type}" || obj${accessor} instanceof Date || typeof obj${accessor}.toISOString === "function" || obj${accessor} instanceof RegExp)
+              ${index === 0 ? 'if' : 'else if'}(obj${accessor} === null || typeof obj${accessor} === "${type}" || obj${accessor} instanceof Date || typeof obj${accessor}.toISOString === "function" || obj${accessor} instanceof RegExp)
                 ${nestedResult.code}
             `
           } else if (type === 'null') {
@@ -1156,3 +1203,16 @@ function isEmpty (schema) {
 }
 
 module.exports = build
+
+module.exports.restore = function (debugModeStr, options = {}) {
+  const dependencies = [debugModeStr]
+  const args = []
+  if (debugModeStr.startsWith('ajv')) {
+    dependencies.unshift('ajv')
+    args.push(new Ajv(options.ajv))
+  }
+
+  // eslint-disable-next-line
+  return (Function.apply(null, ['ajv', debugModeStr])
+    .apply(null, args))
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "1.19.0",
+  "version": "1.21.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",

package/test/allof.test.js

@@ -44,7 +44,7 @@ test('object with allOf and multiple schema on the allOf', (t) => {
       id: 1
     })
   } catch (e) {
-    t.is(e.message, 'name is required!')
+    t.is(e.message, '"name" is required!')
   }
 
   try {
@@ -52,7 +52,7 @@ test('object with allOf and multiple schema on the allOf', (t) => {
       name: 'string'
     })
   } catch (e) {
-    t.is(e.message, 'id is required!')
+    t.is(e.message, '"id" is required!')
   }
 
   try {
@@ -135,7 +135,7 @@ test('object with nested allOfs', (t) => {
     allOf: [
       {
         required: [
-          'id'
+          'id1'
         ],
         type: 'object',
         properties: {
@@ -184,3 +184,200 @@ test('object with nested allOfs', (t) => {
     t.fail()
   }
 })
+
+test('object with $ref in allOf', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with $ref in allOf',
+    type: 'object',
+    definitions: {
+      id1: {
+        type: 'object',
+        properties: {
+          id1: {
+            type: 'integer'
+          }
+        }
+      }
+    },
+    allOf: [
+      {
+        $ref: '#/definitions/id1'
+      }
+    ]
+  }
+
+  try {
+    const stringify = build(schema)
+    try {
+      const value = stringify({
+        id1: 1,
+        id2: 2 // extra prop shouldn't be in result
+      })
+      t.is(value, '{"id1":1}')
+    } catch (e) {
+      t.fail()
+    }
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('object with $ref and other object in allOf', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with $ref in allOf',
+    type: 'object',
+    definitions: {
+      id1: {
+        type: 'object',
+        properties: {
+          id1: {
+            type: 'integer'
+          }
+        }
+      }
+    },
+    allOf: [
+      {
+        $ref: '#/definitions/id1'
+      },
+      {
+        type: 'object',
+        properties: {
+          id2: {
+            type: 'integer'
+          }
+        }
+      }
+    ]
+  }
+
+  try {
+    const stringify = build(schema)
+    try {
+      const value = stringify({
+        id1: 1,
+        id2: 2,
+        id3: 3 // extra prop shouldn't be in result
+      })
+      t.is(value, '{"id1":1,"id2":2}')
+    } catch (e) {
+      t.fail()
+    }
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('object with multiple $refs in allOf', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with $ref in allOf',
+    type: 'object',
+    definitions: {
+      id1: {
+        type: 'object',
+        properties: {
+          id1: {
+            type: 'integer'
+          }
+        }
+      },
+      id2: {
+        type: 'object',
+        properties: {
+          id2: {
+            type: 'integer'
+          }
+        }
+      }
+    },
+    allOf: [
+      {
+        $ref: '#/definitions/id1'
+      },
+      {
+        $ref: '#/definitions/id2'
+      }
+    ]
+  }
+
+  try {
+    const stringify = build(schema)
+    try {
+      const value = stringify({
+        id1: 1,
+        id2: 2,
+        id3: 3 // extra prop shouldn't be in result
+      })
+      t.is(value, '{"id1":1,"id2":2}')
+    } catch (e) {
+      t.fail()
+    }
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('object with external $refs in allOf', (t) => {
+  t.plan(1)
+
+  const externalSchema = {
+    first: {
+      definitions: {
+        id1: {
+          type: 'object',
+          properties: {
+            id1: {
+              type: 'integer'
+            }
+          }
+        }
+      }
+    },
+    second: {
+      id2: {
+        $id: '#id2',
+        type: 'object',
+        properties: {
+          id2: {
+            type: 'integer'
+          }
+        }
+      }
+    }
+  }
+
+  const schema = {
+    title: 'object with $ref in allOf',
+    type: 'object',
+    allOf: [
+      {
+        $ref: 'first#/definitions/id1'
+      },
+      {
+        $ref: 'second#id2'
+      }
+    ]
+  }
+
+  try {
+    const stringify = build(schema, { schema: externalSchema })
+    try {
+      const value = stringify({
+        id1: 1,
+        id2: 2,
+        id3: 3 // extra prop shouldn't be in result
+      })
+      t.is(value, '{"id1":1,"id2":2}')
+    } catch (e) {
+      t.fail()
+    }
+  } catch (e) {
+    t.fail()
+  }
+})

package/test/array.test.js

@@ -142,6 +142,21 @@ buildTest({
   }
 }, { args: [{ a: 'test' }, { b: 1 }] })
 
+buildTest({
+  title: 'array with weird key',
+  type: 'object',
+  properties: {
+    '@data': {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    }
+  }
+}, {
+  '@data': ['test']
+})
+
 test('invalid items throw', (t) => {
   t.plan(1)
   const schema = {

package/test/basic.test.js

@@ -129,6 +129,25 @@ buildTest({
   '@version': 1
 })
 
+buildTest({
+  title: 'deep object with weird keys of type object',
+  type: 'object',
+  properties: {
+    '@data': {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string'
+        }
+      }
+    }
+  }
+}, {
+  '@data': {
+    id: 'string'
+  }
+})
+
 buildTest({
   title: 'deep object with spaces in key',
   type: 'object',

package/test/date.test.js

@@ -91,7 +91,6 @@ test('render a date in a string when format is time as HH:mm:ss', (t) => {
   const output = stringify(toStringify)
 
   validate(JSON.parse(output))
-  console.log(validate.errors)
 
   t.equal(output, `"${moment(toStringify).format('HH:mm:ss')}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
@@ -112,7 +111,6 @@ test('verify padding for rendered date in a string when format is time', (t) =>
   const output = stringify(toStringify)
 
   validate(JSON.parse(output))
-  console.log(validate.errors)
 
   t.equal(output, `"${moment(toStringify).format('HH:mm:ss')}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
@@ -194,3 +192,211 @@ test('render a nested object in a string when type is date-format as ISOString',
   t.equal(output, JSON.stringify(toStringify))
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
+
+test('serializing null value', t => {
+  const input = { updatedAt: null }
+
+  function createSchema (properties) {
+    return {
+      title: 'an object in a string',
+      type: 'object',
+      properties
+    }
+  }
+
+  function serialize (schema, input) {
+    const validate = validator(schema)
+    const stringify = build(schema)
+    const output = stringify(input)
+
+    return {
+      validate,
+      output
+    }
+  }
+
+  t.plan(3)
+
+  t.test('type::string', t => {
+    t.plan(3)
+
+    t.test('format::date-time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: 'string',
+          format: 'date-time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a date-time format')
+    })
+
+    t.test('format::date', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: 'string',
+          format: 'date'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a date format')
+    })
+
+    t.test('format::time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: 'string',
+          format: 'time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a time format')
+    })
+  })
+
+  t.test('type::array', t => {
+    t.plan(3)
+
+    t.test('format::date-time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string'],
+          format: 'date-time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a date-time format')
+    })
+
+    t.test('format::date', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string'],
+          format: 'date'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a date format')
+    })
+
+    t.test('format::time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string'],
+          format: 'time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a time format')
+    })
+  })
+
+  t.test('type::array::nullable', t => {
+    t.plan(3)
+
+    t.test('format::date-time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string', 'null'],
+          format: 'date-time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":null}')
+      t.ok(validate(JSON.parse(output)), 'valid schema')
+    })
+
+    t.test('format::date', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string', 'null'],
+          format: 'date'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":null}')
+      t.ok(validate(JSON.parse(output)), 'valid schema')
+    })
+
+    t.test('format::time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string', 'null'],
+          format: 'time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":null}')
+      t.ok(validate(JSON.parse(output)), 'valid schema')
+    })
+  })
+})

package/test/debug-mode.test.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const test = require('tap').test
+const fjs = require('..')
+
+function build (opts) {
+  return fjs({
+    title: 'default string',
+    type: 'object',
+    properties: {
+      firstName: {
+        type: 'string'
+      }
+    },
+    required: ['firstName']
+  }, opts)
+}
+
+test('activate debug mode', t => {
+  t.plan(2)
+  const debugMode = build({ debugMode: true })
+  t.type(debugMode, Array)
+  t.like(debugMode.toString.toString(), 'join', 'to string override')
+})
+
+test('activate debug mode truthy', t => {
+  t.plan(2)
+  const debugMode = build({ debugMode: 'yes' })
+  t.type(debugMode, Array)
+  t.like(debugMode.toString.toString(), 'join', 'to string override')
+})
+
+test('to string auto-consistent', t => {
+  t.plan(2)
+  const debugMode = build({ debugMode: 1 })
+  t.type(debugMode, Array)
+
+  const str = debugMode.toString()
+  const compiled = fjs.restore(str)
+  const tobe = JSON.stringify({ firstName: 'Foo' })
+  t.deepEquals(compiled({ firstName: 'Foo', surname: 'bar' }), tobe, 'surname evicted')
+})
+
+test('to string auto-consistent with ajv', t => {
+  t.plan(2)
+  const debugMode = fjs({
+    title: 'object with multiple types field',
+    type: 'object',
+    properties: {
+      str: {
+        anyOf: [{
+          type: 'string'
+        }, {
+          type: 'boolean'
+        }]
+      }
+    }
+  }, { debugMode: 1 })
+  t.type(debugMode, Array)
+
+  const str = debugMode.toString()
+  const compiled = fjs.restore(str)
+  const tobe = JSON.stringify({ str: 'Foo' })
+  t.deepEquals(compiled({ str: 'Foo', void: 'me' }), tobe)
+})

package/test/ref.test.js

@@ -820,7 +820,7 @@ test('ref external to relative definition', (t) => {
 
   const schema = {
     type: 'object',
-    required: ['foo'],
+    required: ['fooParent'],
     properties: {
       fooParent: { $ref: 'relative:to:local' }
     }
@@ -934,7 +934,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, "Cannot find reference 'porjectId', did you mean 'projectId'?")
+      t.is(err.message, 'Cannot find reference "porjectId", did you mean "projectId"?')
     }
   })
 
@@ -959,7 +959,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, "Cannot find reference 'foobar'")
+      t.is(err.message, 'Cannot find reference "foobar"')
     }
   })
 
@@ -989,7 +989,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, "Cannot find reference 'porjectId', did you mean 'projectId'?")
+      t.is(err.message, 'Cannot find reference "porjectId", did you mean "projectId"?')
     }
   })
 
@@ -1019,7 +1019,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, "Cannot find reference 'foobar'")
+      t.is(err.message, 'Cannot find reference "foobar"')
     }
   })
 
@@ -1049,7 +1049,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, "Cannot find reference 'deifnitions', did you mean 'definitions'?")
+      t.is(err.message, 'Cannot find reference "deifnitions", did you mean "definitions"?')
     }
   })
 
@@ -1074,7 +1074,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, "Cannot find reference 'deifnitions', did you mean 'definitions'?")
+      t.is(err.message, 'Cannot find reference "deifnitions", did you mean "definitions"?')
     }
   })
 
@@ -1104,7 +1104,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, "Cannot find reference 'extrenal', did you mean 'external'?")
+      t.is(err.message, 'Cannot find reference "extrenal", did you mean "external"?')
     }
   })
 

package/test/required.test.js

@@ -36,11 +36,186 @@ test('object with required field', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, 'str is required!')
+    t.is(e.message, '"str" is required!')
     t.pass()
   }
 })
 
+test('object with required field not in properties schema', (t) => {
+  t.plan(4)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    required: ['str']
+  }
+  const stringify = build(schema)
+
+  try {
+    stringify({})
+    t.fail()
+  } catch (e) {
+    t.is(e.message, '"str" is required!')
+    t.pass()
+  }
+
+  try {
+    stringify({
+      num: 42
+    })
+    t.fail()
+  } catch (e) {
+    t.is(e.message, '"str" is required!')
+    t.pass()
+  }
+})
+
+test('object with required field not in properties schema with additional properties true', (t) => {
+  t.plan(4)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    additionalProperties: true,
+    required: ['str']
+  }
+  const stringify = build(schema)
+
+  try {
+    stringify({})
+    t.fail()
+  } catch (e) {
+    t.is(e.message, '"str" is required!')
+    t.pass()
+  }
+
+  try {
+    stringify({
+      num: 42
+    })
+    t.fail()
+  } catch (e) {
+    t.is(e.message, '"str" is required!')
+    t.pass()
+  }
+})
+
+test('object with multiple required field not in properties schema', (t) => {
+  t.plan(6)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    additionalProperties: true,
+    required: ['num', 'key1', 'key2']
+  }
+  const stringify = build(schema)
+
+  try {
+    stringify({})
+    t.fail()
+  } catch (e) {
+    t.is(e.message, '"num" is required!')
+    t.pass()
+  }
+
+  try {
+    stringify({
+      num: 42
+    })
+    t.fail()
+  } catch (e) {
+    t.is(e.message, '"key1" is required!')
+    t.pass()
+  }
+
+  try {
+    stringify({
+      num: 42,
+      key1: 'some'
+    })
+    t.fail()
+  } catch (e) {
+    t.is(e.message, '"key2" is required!')
+    t.pass()
+  }
+})
+
+test('object with required bool', (t) => {
+  t.plan(3)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    additionalProperties: true,
+    required: ['bool']
+  }
+  const stringify = build(schema)
+
+  try {
+    stringify({})
+    t.fail()
+  } catch (e) {
+    t.is(e.message, '"bool" is required!')
+    t.pass()
+  }
+
+  try {
+    stringify({
+      bool: false
+    })
+    t.pass()
+  } catch (e) {
+    t.fail(e.message)
+  }
+})
+
+test('required nullable', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: ['integer']
+      }
+    },
+    additionalProperties: true,
+    required: ['null']
+  }
+  const stringify = build(schema)
+
+  try {
+    stringify({
+      null: null
+    })
+    t.pass()
+  } catch (e) {
+    t.fail(e.message)
+  }
+})
+
 test('required numbers', (t) => {
   t.plan(3)
 
@@ -74,7 +249,7 @@ test('required numbers', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, 'num is required!')
+    t.is(e.message, '"num" is required!')
     t.pass()
   }
 })

package/test/sanitize2.test.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const t = require('tap')
+const build = require('..')
+
+const payload = '(throw "pwoned")'
+
+const stringify = build({
+  properties: {
+    [`*///\\\\\\']);${payload};{/*`]: {
+      type: 'number'
+    }
+  }
+})
+
+stringify({})
+
+t.pass('no crashes')

package/test/sanitize3.test.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const t = require('tap')
+const build = require('..')
+
+const stringify = build({
+  $defs: {
+    type: 'foooo"bar'
+  },
+  patternProperties: {
+    x: { $ref: '#/$defs' }
+  }
+})
+
+t.throws(() => {
+  stringify({ x: 0 })
+}, 'Cannot coerce 0 to "foo"bar"')

package/test/sanitize4.test.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const t = require('tap')
+const build = require('..')
+
+const payload = '(throw "pwoned")'
+
+const stringify = build({
+  required: [`"];${payload}//`]
+})
+
+t.throws(() => {
+  stringify({})
+}, 'Error: ""];(throw "pwoned")//" is required!')

package/test/sanitize5.test.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const t = require('tap')
+const build = require('..')
+
+const payload = '(throw "pwoned")'
+
+const expected = 'Error: Invalid regular expression: /*/: Nothing to repeat. Found at * matching {"type":"*/(throw \\"pwoned\\")){//"}'
+
+t.throws(() => {
+  build({
+    patternProperties: {
+      '*': { type: `*/${payload}){//` }
+    }
+  })
+}, expected)

package/test/sanitize6.test.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const t = require('tap')
+const build = require('..')
+
+const payload = '(throw "pwoned")'
+
+const stringify = build({
+  type: 'object',
+  properties: {
+    '/*': { type: 'object' },
+    x: {
+      type: 'object',
+      properties: {
+        a: { type: 'string', default: `*/}${payload};{//` }
+      }
+    }
+  }
+})
+stringify({})
+
+t.pass('no crashes')