fast-json-stringify 3.2.0 → 4.2.0

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "fast-json-stringify",
-  "version": "3.2.0",
+  "version": "4.2.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "benchmark": "node bench.js",
+    "bench": "node ./benchmark/bench.js",
+    "bench:cmp": "node ./benchmark/bench-cmp-branch.js",
+    "bench:cmp:ci": "node ./benchmark/bench-cmp-branch.js --ci",
+    "benchmark": "node ./benchmark/bench-cmp-lib.js",
     "lint:fix": "standard --fix",
     "test:lint": "standard",
     "test:typescript": "tsc --project ./test/types/tsconfig.json",
@@ -32,12 +35,15 @@
   "devDependencies": {
     "@sinclair/typebox": "^0.23.3",
     "benchmark": "^2.1.4",
+    "chalk": "^4.1.2",
     "compile-json-stringify": "^0.1.2",
+    "inquirer": "^8.2.4",
     "is-my-json-valid": "^2.20.0",
-    "moment": "^2.24.0",
+    "luxon": "^2.4.0",
     "pre-commit": "^1.2.2",
     "proxyquire": "^2.1.3",
     "semver": "^7.1.0",
+    "simple-git": "^3.7.1",
     "standard": "^17.0.0",
     "tap": "^16.0.1",
     "typescript": "^4.0.2",
@@ -47,7 +53,7 @@
     "ajv": "^8.10.0",
     "ajv-formats": "^2.1.1",
     "deepmerge": "^4.2.2",
-    "fast-uri": "^1.0.1",
+    "fast-uri": "^2.0.0",
     "rfdc": "^1.2.0",
     "string-similarity": "^4.0.1"
   },

package/serializer.js

@@ -0,0 +1,168 @@
+'use strict'
+
+module.exports = 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 + '"'
+  }
+}

package/standalone.js

@@ -0,0 +1,42 @@
+const fs = require('fs')
+const path = require('path')
+
+function buildStandaloneCode (options, ajvInstance, contextFunctionCode) {
+  const serializerCode = fs.readFileSync(path.join(__dirname, 'serializer.js')).toString()
+  let buildAjvCode = ''
+  let defaultAjvSchema = ''
+  const defaultMeta = ajvInstance.defaultMeta()
+  if (typeof defaultMeta === 'string') {
+    defaultAjvSchema = defaultMeta
+  } else {
+    defaultAjvSchema = defaultMeta.$id || defaultMeta.id
+  }
+  const shouldUseAjv = contextFunctionCode.indexOf('ajv') !== -1
+  // we need to export the custom json schema
+  let ajvSchemasCode = ''
+  if (shouldUseAjv) {
+    ajvSchemasCode += `const ajv = buildAjv(${JSON.stringify(options.ajv || {})})\n`
+    for (const [id, schema] of Object.entries(ajvInstance.schemas)) {
+      // should skip ajv default schema
+      if (id === defaultAjvSchema) continue
+      ajvSchemasCode += `ajv.addSchema(${JSON.stringify(schema.schema)}, "${id}")\n`
+    }
+    buildAjvCode = fs.readFileSync(path.join(__dirname, 'ajv.js')).toString()
+    buildAjvCode = buildAjvCode.replace("'use strict'", '').replace('module.exports = buildAjv', '')
+  }
+  return `
+  'use strict'
+
+  ${serializerCode.replace("'use strict'", '').replace('module.exports = ', '')}
+  ${buildAjvCode}
+
+  const serializer = new Serializer(${JSON.stringify(options || {})})
+  ${ajvSchemasCode}
+
+  ${contextFunctionCode.replace('return main', '')}
+
+  module.exports = main
+      `
+}
+
+module.exports = buildStandaloneCode

package/test/additionalProperties.test.js

@@ -19,7 +19,7 @@ test('additionalProperties', (t) => {
   })
 
   const obj = { str: 'test', foo: 42, ofoo: true, foof: 'string', objfoo: { a: true } }
-  t.equal('{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}', stringify(obj))
+  t.equal(stringify(obj), '{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}')
 })
 
 test('additionalProperties should not change properties', (t) => {
@@ -38,7 +38,7 @@ test('additionalProperties should not change properties', (t) => {
   })
 
   const obj = { foo: '42', ofoo: 42 }
-  t.equal('{"foo":"42","ofoo":42}', stringify(obj))
+  t.equal(stringify(obj), '{"foo":"42","ofoo":42}')
 })
 
 test('additionalProperties should not change properties and patternProperties', (t) => {
@@ -62,7 +62,7 @@ test('additionalProperties should not change properties and patternProperties',
   })
 
   const obj = { foo: '42', ofoo: 42, test: '42' }
-  t.equal('{"foo":"42","ofoo":"42","test":42}', stringify(obj))
+  t.equal(stringify(obj), '{"foo":"42","ofoo":"42","test":42}')
 })
 
 test('additionalProperties set to true, use of fast-safe-stringify', (t) => {
@@ -75,7 +75,7 @@ test('additionalProperties set to true, use of fast-safe-stringify', (t) => {
   })
 
   const obj = { foo: true, ofoo: 42, arrfoo: ['array', 'test'], objfoo: { a: 'world' } }
-  t.equal('{"foo":true,"ofoo":42,"arrfoo":["array","test"],"objfoo":{"a":"world"}}', stringify(obj))
+  t.equal(stringify(obj), '{"foo":true,"ofoo":42,"arrfoo":["array","test"],"objfoo":{"a":"world"}}')
 })
 
 test('additionalProperties - string coerce', (t) => {
@@ -90,7 +90,7 @@ test('additionalProperties - string coerce', (t) => {
   })
 
   const obj = { foo: true, ofoo: 42, arrfoo: ['array', 'test'], objfoo: { a: 'world' } }
-  t.equal('{"foo":"true","ofoo":"42","arrfoo":"array,test","objfoo":"[object Object]"}', stringify(obj))
+  t.equal(stringify(obj), '{"foo":"true","ofoo":"42","arrfoo":"array,test","objfoo":"[object Object]"}')
 })
 
 test('additionalProperties - number skip', (t) => {
@@ -104,7 +104,8 @@ test('additionalProperties - number skip', (t) => {
     }
   })
 
-  const obj = { foo: true, ofoo: '42', xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } }
+  // const obj = { foo: true, ofoo: '42', xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } }
+  const obj = { foo: true, ofoo: '42' }
   t.equal(stringify(obj), '{"foo":1,"ofoo":42}')
 })
 
@@ -140,11 +141,11 @@ test('additionalProperties - object coerce', (t) => {
   })
 
   const obj = { objfoo: { answer: 42 } }
-  t.equal('{"objfoo":{"answer":42}}', stringify(obj))
+  t.equal(stringify(obj), '{"objfoo":{"answer":42}}')
 })
 
 test('additionalProperties - array coerce', (t) => {
-  t.plan(1)
+  t.plan(2)
   const stringify = build({
     title: 'check array coerce',
     type: 'object',
@@ -157,8 +158,11 @@ test('additionalProperties - array coerce', (t) => {
     }
   })
 
-  const obj = { foo: 'true', ofoo: 0, arrfoo: [1, 2], objfoo: { tyrion: 'lannister' } }
-  t.equal('{"foo":["t","r","u","e"],"ofoo":[],"arrfoo":["1","2"],"objfoo":[]}', stringify(obj))
+  const coercibleValues = { arrfoo: [1, 2] }
+  t.equal(stringify(coercibleValues), '{"arrfoo":["1","2"]}')
+
+  const incoercibleValues = { foo: 'true', ofoo: 0, objfoo: { tyrion: 'lannister' } }
+  t.throws(() => stringify(incoercibleValues))
 })
 
 test('additionalProperties with empty schema', (t) => {
@@ -169,7 +173,7 @@ test('additionalProperties with empty schema', (t) => {
   })
 
   const obj = { a: 1, b: true, c: null }
-  t.equal('{"a":1,"b":true,"c":null}', stringify(obj))
+  t.equal(stringify(obj), '{"a":1,"b":true,"c":null}')
 })
 
 test('additionalProperties with nested empty schema', (t) => {
@@ -183,7 +187,7 @@ test('additionalProperties with nested empty schema', (t) => {
   })
 
   const obj = { data: { a: 1, b: true, c: null } }
-  t.equal('{"data":{"a":1,"b":true,"c":null}}', stringify(obj))
+  t.equal(stringify(obj), '{"data":{"a":1,"b":true,"c":null}}')
 })
 
 test('nested additionalProperties', (t) => {
@@ -203,7 +207,7 @@ test('nested additionalProperties', (t) => {
   })
 
   const obj = [{ ap: { value: 'string' } }]
-  t.equal('[{"ap":{"value":"string"}}]', stringify(obj))
+  t.equal(stringify(obj), '[{"ap":{"value":"string"}}]')
 })
 
 test('very nested additionalProperties', (t) => {
@@ -240,7 +244,7 @@ test('very nested additionalProperties', (t) => {
   })
 
   const obj = [{ ap: { nested: { moarNested: { finally: { value: 'str' } } } } }]
-  t.equal('[{"ap":{"nested":{"moarNested":{"finally":{"value":"str"}}}}}]', stringify(obj))
+  t.equal(stringify(obj), '[{"ap":{"nested":{"moarNested":{"finally":{"value":"str"}}}}}]')
 })
 
 test('nested additionalProperties set to true', (t) => {
@@ -257,7 +261,7 @@ test('nested additionalProperties set to true', (t) => {
   })
 
   const obj = { ap: { value: 'string', someNumber: 42 } }
-  t.equal('{"ap":{"value":"string","someNumber":42}}', stringify(obj))
+  t.equal(stringify(obj), '{"ap":{"value":"string","someNumber":42}}')
 })
 
 test('field passed to fastSafeStringify as undefined should be removed', (t) => {
@@ -274,7 +278,7 @@ test('field passed to fastSafeStringify as undefined should be removed', (t) =>
   })
 
   const obj = { ap: { value: 'string', someNumber: undefined } }
-  t.equal('{"ap":{"value":"string"}}', stringify(obj))
+  t.equal(stringify(obj), '{"ap":{"value":"string"}}')
 })
 
 test('property without type but with enum, will acts as additionalProperties', (t) => {
@@ -290,7 +294,7 @@ test('property without type but with enum, will acts as additionalProperties', (
   })
 
   const obj = { ap: { additional: 'field' } }
-  t.equal('{"ap":{"additional":"field"}}', stringify(obj))
+  t.equal(stringify(obj), '{"ap":{"additional":"field"}}')
 })
 
 test('property without type but with enum, will acts as additionalProperties without overwriting', (t) => {
@@ -307,7 +311,7 @@ test('property without type but with enum, will acts as additionalProperties wit
   })
 
   const obj = { ap: { additional: 'field' } }
-  t.equal('{"ap":{}}', stringify(obj))
+  t.equal(stringify(obj), '{"ap":{}}')
 })
 
 test('function and symbol references are not serialized as undefined', (t) => {
@@ -324,5 +328,5 @@ test('function and symbol references are not serialized as undefined', (t) => {
   })
 
   const obj = { str: 'x', test: 'test', meth: () => 'x', sym: Symbol('x') }
-  t.equal('{"str":"x","test":"test"}', stringify(obj))
+  t.equal(stringify(obj), '{"str":"x","test":"test"}')
 })

package/test/allof.test.js

@@ -1,8 +1,64 @@
 'use strict'
 
 const test = require('tap').test
+const { DateTime } = require('luxon')
 const build = require('..')
 
+test('allOf: combine type and format ', (t) => {
+  t.plan(1)
+
+  const schema = {
+    allOf: [
+      { type: 'string' },
+      { format: 'time' }
+    ]
+  }
+  const stringify = build(schema)
+  const date = new Date()
+  const value = stringify(date)
+  t.equal(value, `"${DateTime.fromJSDate(date).toFormat('HH:mm:ss')}"`)
+})
+
+test('allOf: combine additional properties ', (t) => {
+  t.plan(1)
+
+  const schema = {
+    allOf: [
+      { type: 'object' },
+      {
+        type: 'object',
+        additionalProperties: { type: 'boolean' }
+      }
+    ]
+  }
+  const stringify = build(schema)
+  const data = { property: true }
+  const value = stringify(data)
+  t.equal(value, JSON.stringify(data))
+})
+
+test('allOf: combine pattern properties', (t) => {
+  t.plan(1)
+
+  const schema = {
+    allOf: [
+      { type: 'object' },
+      {
+        type: 'object',
+        patternProperties: {
+          foo: {
+            type: 'number'
+          }
+        }
+      }
+    ]
+  }
+  const stringify = build(schema)
+  const data = { foo: 42 }
+  const value = stringify(data)
+  t.equal(value, JSON.stringify(data))
+})
+
 test('object with allOf and multiple schema on the allOf', (t) => {
   t.plan(4)
 

package/test/anyof.test.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { DateTime } = require('luxon')
 const { test } = require('tap')
 const build = require('..')
 
@@ -113,11 +114,7 @@ test('object with field of type string and coercion disable ', (t) => {
     }
   }
   const stringify = build(schema)
-
-  const value = stringify({
-    str: 1
-  })
-  t.equal(value, '{"str":null}')
+  t.throws(() => stringify({ str: 1 }))
 })
 
 test('object with field of type string and coercion enable ', (t) => {
@@ -224,7 +221,7 @@ test('symbol value in schema', (t) => {
   t.equal(stringify({ value: 'foo' }), '{"value":"foo"}')
   t.equal(stringify({ value: 'bar' }), '{"value":"bar"}')
   t.equal(stringify({ value: 'baz' }), '{"value":"baz"}')
-  t.equal(stringify({ value: 'qux' }), '{"value":null}')
+  t.throws(() => stringify({ value: 'qux' }))
 })
 
 test('anyOf and $ref together', (t) => {
@@ -472,6 +469,90 @@ test('anyOf object with field date-time of type string with format or null', (t)
   }), `{"prop":"${toStringify.toISOString()}"}`)
 })
 
+test('anyOf object with nested field date-time of type string with format or null', (t) => {
+  t.plan(1)
+  const withOneOfSchema = {
+    type: 'object',
+    properties: {
+      prop: {
+        anyOf: [{
+          type: 'object',
+          properties: {
+            nestedProp: {
+              type: 'string',
+              format: 'date-time'
+            }
+          }
+        }]
+      }
+    }
+  }
+
+  const withOneOfStringify = build(withOneOfSchema)
+
+  const data = {
+    prop: { nestedProp: new Date() }
+  }
+
+  t.equal(withOneOfStringify(data), JSON.stringify(data))
+})
+
+test('anyOf object with nested field date of type string with format or null', (t) => {
+  t.plan(1)
+  const withOneOfSchema = {
+    type: 'object',
+    properties: {
+      prop: {
+        anyOf: [{
+          type: 'object',
+          properties: {
+            nestedProp: {
+              type: 'string',
+              format: 'date'
+            }
+          }
+        }]
+      }
+    }
+  }
+
+  const withOneOfStringify = build(withOneOfSchema)
+
+  const data = {
+    prop: { nestedProp: new Date() }
+  }
+
+  t.equal(withOneOfStringify(data), `{"prop":{"nestedProp":"${DateTime.fromJSDate(data.prop.nestedProp).toISODate()}"}}`)
+})
+
+test('anyOf object with nested field time of type string with format or null', (t) => {
+  t.plan(1)
+  const withOneOfSchema = {
+    type: 'object',
+    properties: {
+      prop: {
+        anyOf: [{
+          type: 'object',
+          properties: {
+            nestedProp: {
+              type: 'string',
+              format: 'time'
+            }
+          }
+        }]
+      }
+    }
+  }
+
+  const withOneOfStringify = build(withOneOfSchema)
+
+  const data = {
+    prop: { nestedProp: new Date() }
+  }
+
+  t.equal(withOneOfStringify(data), `{"prop":{"nestedProp":"${DateTime.fromJSDate(data.prop.nestedProp).toFormat('HH:mm:ss')}"}}`)
+})
+
 test('anyOf object with field date of type string with format or null', (t) => {
   t.plan(1)
   const toStringify = '2011-01-01'
@@ -513,7 +594,5 @@ test('anyOf object with invalid field date of type string with format or null',
   }
 
   const withOneOfStringify = build(withOneOfSchema)
-  t.equal(withOneOfStringify({
-    prop: toStringify
-  }), '{"prop":null}')
+  t.throws(() => withOneOfStringify({ prop: toStringify }))
 })