fast-json-stringify 3.0.3 → 4.0.0

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "fast-json-stringify",
-  "version": "3.0.3",
+  "version": "4.0.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,21 +35,25 @@
   "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",
-    "standard": "^16.0.1",
-    "tap": "^15.0.0",
+    "simple-git": "^3.7.1",
+    "standard": "^17.0.0",
+    "tap": "^16.0.1",
     "typescript": "^4.0.2",
     "webpack": "^5.40.0"
   },
   "dependencies": {
-    "ajv": "^8.6.2",
+    "ajv": "^8.10.0",
     "ajv-formats": "^2.1.1",
     "deepmerge": "^4.2.2",
+    "fast-uri": "^2.0.0",
     "rfdc": "^1.2.0",
     "string-similarity": "^4.0.1"
   },

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 }))
 })

package/test/array.test.js

@@ -1,16 +1,15 @@
 'use strict'
 
-const moment = require('moment')
 const test = require('tap').test
 const validator = require('is-my-json-valid')
 const build = require('..')
 
-function buildTest (schema, toStringify) {
+function buildTest (schema, toStringify, options) {
   test(`render a ${schema.title} as JSON`, (t) => {
     t.plan(3)
 
     const validate = validator(schema)
-    const stringify = build(schema)
+    const stringify = build(schema, options)
     const output = stringify(toStringify)
 
     t.same(JSON.parse(output), toStringify)
@@ -177,27 +176,6 @@ test('invalid items throw', (t) => {
   t.throws(() => stringify({ args: ['invalid'] }))
 })
 
-test('moment array', (t) => {
-  t.plan(1)
-  const schema = {
-    type: 'object',
-    properties: {
-      times: {
-        type: 'array',
-        items: {
-          type: 'string',
-          format: 'date-time'
-        }
-      }
-    }
-  }
-  const stringify = build(schema)
-  const value = stringify({
-    times: [moment('2018-04-21T07:52:31.017Z')]
-  })
-  t.equal(value, '{"times":["2018-04-21T07:52:31.017Z"]}')
-})
-
 buildTest({
   title: 'item types in array default to any',
   type: 'object',
@@ -319,3 +297,127 @@ test('object array with anyOf and symbol', (t) => {
   ])
   t.equal(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]')
 })
+
+const largeArray = new Array(2e4).fill({ a: 'test', b: 1 })
+buildTest({
+  title: 'large array with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          a: { type: 'string' },
+          b: { type: 'number' }
+        }
+      }
+    }
+  }
+}, {
+  ids: largeArray
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})
+
+buildTest({
+  title: 'large array of objects with json-stringify mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          a: { type: 'string' },
+          b: { type: 'number' }
+        }
+      }
+    }
+  }
+}, {
+  ids: largeArray
+}, {
+  largeArrayMechanism: 'json-stringify'
+})
+
+buildTest({
+  title: 'large array of strings with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'string' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill('string')
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})
+
+buildTest({
+  title: 'large array of numbers with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'number' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill(42)
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})
+
+buildTest({
+  title: 'large array of integers with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'integer' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill(42)
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})
+
+buildTest({
+  title: 'large array of booleans with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'boolean' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill(true)
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})
+
+buildTest({
+  title: 'large array of null values with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'null' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill(null)
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})

package/test/basic.test.js

@@ -261,7 +261,7 @@ buildTest({
   readonly: true
 })
 
-test('skip or coerce numbers and integers that are not numbers', (t) => {
+test('throw an error or coerce numbers and integers that are not numbers', (t) => {
   const stringify = build({
     title: 'basic',
     type: 'object',
@@ -275,14 +275,14 @@ test('skip or coerce numbers and integers that are not numbers', (t) => {
     }
   })
 
-  let result = stringify({
-    age: 'hello  ',
-    distance: 'long'
-  })
-
-  t.same(JSON.parse(result), {})
+  try {
+    stringify({ age: 'hello  ', distance: 'long' })
+    t.fail('should throw an error')
+  } catch (err) {
+    t.ok(err)
+  }
 
-  result = stringify({
+  const result = stringify({
     age: '42',
     distance: true
   })