fast-json-stringify 5.5.0 → 5.6.0

package/lib/serializer.js

@@ -4,8 +4,8 @@
 const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/
 
 module.exports = class Serializer {
-  constructor (options = {}) {
-    switch (options.rounding) {
+  constructor (options) {
+    switch (options && options.rounding) {
       case 'floor':
         this.parseInteger = Math.floor
         break
@@ -15,6 +15,7 @@ module.exports = class Serializer {
       case 'round':
         this.parseInteger = Math.round
         break
+      case 'trunc':
       default:
         this.parseInteger = Math.trunc
         break
@@ -22,30 +23,44 @@ module.exports = class Serializer {
   }
 
   asInteger (i) {
-    if (typeof i === 'bigint') {
+    if (typeof i === 'number') {
+      if (i === Infinity || i === -Infinity) {
+        throw new Error(`The value "${i}" cannot be converted to an integer.`)
+      }
+      if ((i | 0) === i) {
+        return '' + i
+      }
+      if (Number.isNaN(i)) {
+        throw new Error(`The value "${i}" cannot be converted to an integer.`)
+      }
+      return this.parseInteger(i)
+    } else if (i === null) {
+      return '0'
+    } else 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) || !Number.isFinite(integer)) {
-        throw new Error(`The value "${i}" cannot be converted to an integer.`)
-      } else {
+      if (Number.isFinite(integer)) {
         return '' + integer
+      } else {
+        throw new Error(`The value "${i}" cannot be converted to an integer.`)
       }
     }
   }
 
   asNumber (i) {
-    const num = Number(i)
-    if (Number.isNaN(num)) {
+    if (typeof i !== 'number') {
+      i = Number(i)
+    }
+    // NaN !== NaN
+    if (i !== i) { // eslint-disable-line no-self-compare
       throw new Error(`The value "${i}" cannot be converted to a number.`)
-    } else if (!Number.isFinite(num)) {
-      return null
-    } else {
-      return '' + num
     }
+    if (i === Infinity || i === -Infinity) {
+      return 'null'
+    }
+    return '' + i
   }
 
   asBoolean (bool) {
@@ -86,23 +101,24 @@ module.exports = class Serializer {
   }
 
   asString (str) {
-    const quotes = '"'
-    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 (typeof str !== 'string') {
+      if (str === null) {
+        return '""'
+      }
+      if (str instanceof Date) {
+        return '"' + str.toISOString() + '"'
+      }
+      if (str instanceof RegExp) {
+        str = str.source
+      } else {
+        str = str.toString()
+      }
     }
 
     // Fast escape chars check
     if (!STR_ESCAPE.test(str)) {
-      return quotes + str + quotes
-    }
-
-    if (str.length < 42) {
+      return '"' + str + '"'
+    } else if (str.length < 42) {
       return this.asStringSmall(str)
     } else {
       return JSON.stringify(str)

package/lib/standalone.js

@@ -25,19 +25,18 @@ function buildStandaloneCode (options, validator, isValidatorUsed, contextFuncti
     buildAjvCode = fs.readFileSync(path.join(__dirname, 'validator.js')).toString()
     buildAjvCode = buildAjvCode.replace("'use strict'", '').replace('module.exports = SchemaValidator', '')
   }
+
+  const serializerOptions = options && options.rounding ? JSON.stringify({ options: options.rounding }) : ''
   return `
   'use strict'
-
   ${serializerCode.replace("'use strict'", '').replace('module.exports = ', '')}
   ${buildAjvCode}
-
-  const serializer = new Serializer(${JSON.stringify(options || {})})
+  const serializer = new Serializer(${serializerOptions})
   ${ajvSchemasCode}
 
   ${contextFunctionCode.replace('return main', '')}
 
-  module.exports = main
-      `
+  module.exports = main`
 }
 
 module.exports = buildStandaloneCode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.5.0",
+  "version": "5.6.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -12,7 +12,7 @@
     "lint": "standard",
     "lint:fix": "standard --fix",
     "test:typescript": "tsd",
-    "test:unit": "tap -J test/*.test.js test/**/*.test.js",
+    "test:unit": "tap",
     "test": "npm run test:unit && npm run test:typescript"
   },
   "precommit": ["lint", "test"],
@@ -39,13 +39,10 @@
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
     "is-my-json-valid": "^2.20.0",
-    "luxon": "^3.0.1",
-    "proxyquire": "^2.1.3",
-    "semver": "^7.1.0",
     "simple-git": "^3.7.1",
     "standard": "^17.0.0",
     "tap": "^16.0.1",
-    "tsd": "^0.24.1",
+    "tsd": "^0.25.0",
     "webpack": "^5.40.0"
   },
   "dependencies": {

package/test/allof.test.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const test = require('tap').test
-const { DateTime } = require('luxon')
 const build = require('..')
 
+process.env.TZ = 'UTC'
+
 test('allOf: combine type and format ', (t) => {
   t.plan(1)
 
@@ -14,9 +15,9 @@ test('allOf: combine type and format ', (t) => {
     ]
   }
   const stringify = build(schema)
-  const date = new Date()
+  const date = new Date(1674263005800)
   const value = stringify(date)
-  t.equal(value, `"${DateTime.fromJSDate(date).toFormat('HH:mm:ss')}"`)
+  t.equal(value, '"01:03:25"')
 })
 
 test('allOf: combine additional properties ', (t) => {
@@ -482,3 +483,51 @@ test('allof with local anchor reference', (t) => {
 
   t.equal(stringify(data), JSON.stringify(data))
 })
+
+test('allOf: throw Error if types mismatch ', (t) => {
+  t.plan(1)
+
+  const schema = {
+    allOf: [
+      { type: 'string' },
+      { type: 'number' }
+    ]
+  }
+  t.throws(() => build(schema), new Error('allOf schemas have different type values'))
+})
+
+test('allOf: throw Error if format mismatch ', (t) => {
+  t.plan(1)
+
+  const schema = {
+    allOf: [
+      { format: 'date' },
+      { format: 'time' }
+    ]
+  }
+  t.throws(() => build(schema), new Error('allOf schemas have different format values'))
+})
+
+test('allOf: throw Error if nullable mismatch /1', (t) => {
+  t.plan(1)
+
+  const schema = {
+    allOf: [
+      { nullable: true },
+      { nullable: false }
+    ]
+  }
+  t.throws(() => build(schema), new Error('allOf schemas have different nullable values'))
+})
+
+test('allOf: throw Error if nullable mismatch /2', (t) => {
+  t.plan(1)
+
+  const schema = {
+    allOf: [
+      { nullable: false },
+      { nullable: true }
+    ]
+  }
+  t.throws(() => build(schema), new Error('allOf schemas have different nullable values'))
+})

package/test/any.test.js

@@ -152,3 +152,80 @@ test('empty schema on anyOf', (t) => {
   t.equal(stringify({ kind: 'Foo', value: true }), '{"kind":"Foo","value":true}')
   t.equal(stringify({ kind: 'Foo', value: 'hello' }), '{"kind":"Foo","value":"hello"}')
 })
+
+test('should throw a TypeError with the path to the key of the invalid value /1', (t) => {
+  t.plan(1)
+
+  // any on Foo codepath.
+  const schema = {
+    anyOf: [
+      {
+        type: 'object',
+        properties: {
+          kind: {
+            type: 'string',
+            enum: ['Foo']
+          },
+          value: {}
+        }
+      },
+      {
+        type: 'object',
+        properties: {
+          kind: {
+            type: 'string',
+            enum: ['Bar']
+          },
+          value: {
+            type: 'number'
+          }
+        }
+      }
+    ]
+  }
+
+  const stringify = build(schema)
+
+  t.throws(() => stringify({ kind: 'Baz', value: 1 }), new TypeError('The value of \'#\' does not match schema definition.'))
+})
+
+test('should throw a TypeError with the path to the key of the invalid value /2', (t) => {
+  t.plan(1)
+
+  // any on Foo codepath.
+  const schema = {
+    type: 'object',
+    properties: {
+      data: {
+        anyOf: [
+          {
+            type: 'object',
+            properties: {
+              kind: {
+                type: 'string',
+                enum: ['Foo']
+              },
+              value: {}
+            }
+          },
+          {
+            type: 'object',
+            properties: {
+              kind: {
+                type: 'string',
+                enum: ['Bar']
+              },
+              value: {
+                type: 'number'
+              }
+            }
+          }
+        ]
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  t.throws(() => stringify({ data: { kind: 'Baz', value: 1 } }), new TypeError('The value of \'#/properties/data\' does not match schema definition.'))
+})

package/test/anyof.test.js

@@ -1,9 +1,10 @@
 'use strict'
 
-const { DateTime } = require('luxon')
 const { test } = require('tap')
 const build = require('..')
 
+process.env.TZ = 'UTC'
+
 test('object with multiple types field', (t) => {
   t.plan(2)
 
@@ -519,10 +520,10 @@ test('anyOf object with nested field date of type string with format or null', (
   const withOneOfStringify = build(withOneOfSchema)
 
   const data = {
-    prop: { nestedProp: new Date() }
+    prop: { nestedProp: new Date(1674263005800) }
   }
 
-  t.equal(withOneOfStringify(data), `{"prop":{"nestedProp":"${DateTime.fromJSDate(data.prop.nestedProp).toISODate()}"}}`)
+  t.equal(withOneOfStringify(data), '{"prop":{"nestedProp":"2023-01-21"}}')
 })
 
 test('anyOf object with nested field time of type string with format or null', (t) => {
@@ -547,10 +548,9 @@ test('anyOf object with nested field time of type string with format or null', (
   const withOneOfStringify = build(withOneOfSchema)
 
   const data = {
-    prop: { nestedProp: new Date() }
+    prop: { nestedProp: new Date(1674263005800) }
   }
-
-  t.equal(withOneOfStringify(data), `{"prop":{"nestedProp":"${DateTime.fromJSDate(data.prop.nestedProp).toFormat('HH:mm:ss')}"}}`)
+  t.equal(withOneOfStringify(data), '{"prop":{"nestedProp":"01:03:25"}}')
 })
 
 test('anyOf object with field date of type string with format or null', (t) => {

package/test/array.test.js

@@ -3,6 +3,7 @@
 const test = require('tap').test
 const validator = require('is-my-json-valid')
 const build = require('..')
+const Ajv = require('ajv')
 
 test('error on invalid largeArrayMechanism', (t) => {
   t.plan(1)
@@ -265,7 +266,7 @@ test('array items is a list of schema and additionalItems is true, just the desc
   t.equal(result, '{"foo":["foo"]}')
 })
 
-test('array items is a list of schema and additionalItems is false', (t) => {
+test('array items is a list of schema and additionalItems is false /1', (t) => {
   t.plan(1)
 
   const schema = {
@@ -274,9 +275,7 @@ test('array items is a list of schema and additionalItems is false', (t) => {
       foo: {
         type: 'array',
         items: [
-          {
-            type: 'string'
-          }
+          { type: 'string' }
         ],
         additionalItems: false
       }
@@ -284,18 +283,55 @@ test('array items is a list of schema and additionalItems is false', (t) => {
   }
 
   const stringify = build(schema)
+  t.throws(() => stringify({ foo: ['foo', 'bar'] }), new Error('Item at 1 does not match schema definition.'))
+})
 
-  try {
-    stringify({
-      foo: [
-        'foo',
-        'bar'
-      ]
-    })
-    t.fail()
-  } catch (error) {
-    t.ok(/does not match schema definition./.test(error.message))
+test('array items is a list of schema and additionalItems is false /2', (t) => {
+  t.plan(3)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'array',
+        items: [
+          { type: 'string' },
+          { type: 'string' }
+        ],
+        additionalItems: false
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  t.throws(() => stringify({ foo: [1, 'bar'] }), new Error('Item at 0 does not match schema definition.'))
+  t.throws(() => stringify({ foo: ['foo', 1] }), new Error('Item at 1 does not match schema definition.'))
+  t.throws(() => stringify({ foo: ['foo', 'bar', 'baz'] }), new Error('Item at 2 does not match schema definition.'))
+})
+
+test('array items is a schema and additionalItems is false', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'array',
+        items: { type: 'string' },
+        additionalItems: false
+      }
+    }
   }
+
+  const stringify = build(schema)
+
+  // ajv ignores additionalItems if items is not an Array
+  const ajv = new Ajv({ allErrors: true, strict: false })
+
+  const validate = ajv.compile(schema)
+  t.same(stringify({ foo: ['foo', 'bar'] }), '{"foo":["foo","bar"]}')
+  t.equal(validate({ foo: ['foo', 'bar'] }), true)
 })
 
 // https://github.com/fastify/fast-json-stringify/issues/279
@@ -493,3 +529,86 @@ buildTest({
   largeArraySize: 2e4,
   largeArrayMechanism: 'default'
 })
+
+test('error on invalid value for largeArraySize /1', (t) => {
+  t.plan(1)
+
+  t.throws(() => build({
+    title: 'large array of null values with default mechanism',
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: { type: 'null' }
+      }
+    }
+  }, {
+    largeArraySize: 'invalid'
+  }), Error('Unsupported large array size. Expected integer-like, got string with value invalid'))
+})
+
+test('error on invalid value for largeArraySize /2', (t) => {
+  t.plan(1)
+
+  t.throws(() => build({
+    title: 'large array of null values with default mechanism',
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: { type: 'null' }
+      }
+    }
+  }, {
+    largeArraySize: Infinity
+  }), Error('Unsupported large array size. Expected integer-like, got number with value Infinity'))
+})
+
+test('error on invalid value for largeArraySize /3', (t) => {
+  t.plan(1)
+
+  t.throws(() => build({
+    title: 'large array of null values with default mechanism',
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: { type: 'null' }
+      }
+    }
+  }, {
+    largeArraySize: [200]
+  }), Error('Unsupported large array size. Expected integer-like, got object with value 200'))
+})
+
+buildTest({
+  title: 'large array of integers with largeArraySize is bigint',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'integer' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill(42)
+}, {
+  largeArraySize: 20000n,
+  largeArrayMechanism: 'default'
+})
+
+buildTest({
+  title: 'large array of integers with largeArraySize is valid string',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'integer' }
+    }
+  }
+}, {
+  ids: new Array(1e4).fill(42)
+}, {
+  largeArraySize: '10000',
+  largeArrayMechanism: 'default'
+})