fast-json-stringify 5.5.0 → 5.6.0

package/test/date.test.js

@@ -1,10 +1,11 @@
 'use strict'
 
 const test = require('tap').test
-const { DateTime } = require('luxon')
 const validator = require('is-my-json-valid')
 const build = require('..')
 
+process.env.TZ = 'UTC'
+
 test('render a date in a string as JSON', (t) => {
   t.plan(2)
 
@@ -12,7 +13,7 @@ test('render a date in a string as JSON', (t) => {
     title: 'a date in a string',
     type: 'string'
   }
-  const toStringify = new Date()
+  const toStringify = new Date(1674263005800)
 
   const validate = validator(schema)
   const stringify = build(schema)
@@ -30,7 +31,7 @@ test('render a date in a string when format is date-format as ISOString', (t) =>
     type: 'string',
     format: 'date-time'
   }
-  const toStringify = new Date()
+  const toStringify = new Date(1674263005800)
 
   const validate = validator(schema)
   const stringify = build(schema)
@@ -49,7 +50,7 @@ test('render a nullable date in a string when format is date-format as ISOString
     format: 'date-time',
     nullable: true
   }
-  const toStringify = new Date()
+  const toStringify = new Date(1674263005800)
 
   const validate = validator(schema)
   const stringify = build(schema)
@@ -67,13 +68,13 @@ test('render a date in a string when format is date as YYYY-MM-DD', (t) => {
     type: 'string',
     format: 'date'
   }
-  const toStringify = new Date()
+  const toStringify = new Date(1674263005800)
 
   const validate = validator(schema)
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, `"${DateTime.fromJSDate(toStringify).toISODate()}"`)
+  t.equal(output, '"2023-01-21"')
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
@@ -86,13 +87,13 @@ test('render a nullable date in a string when format is date as YYYY-MM-DD', (t)
     format: 'date',
     nullable: true
   }
-  const toStringify = new Date()
+  const toStringify = new Date(1674263005800)
 
   const validate = validator(schema)
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, `"${DateTime.fromJSDate(toStringify).toISODate()}"`)
+  t.equal(output, '"2023-01-21"')
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
@@ -110,7 +111,7 @@ test('verify padding for rendered date in a string when format is date', (t) =>
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, `"${DateTime.fromJSDate(toStringify).toISODate()}"`)
+  t.equal(output, '"2020-01-01"')
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
@@ -122,7 +123,7 @@ test('render a date in a string when format is time as kk:mm:ss', (t) => {
     type: 'string',
     format: 'time'
   }
-  const toStringify = new Date()
+  const toStringify = new Date(1674263005800)
 
   const validate = validator(schema)
   const stringify = build(schema)
@@ -131,7 +132,7 @@ test('render a date in a string when format is time as kk:mm:ss', (t) => {
   validate(JSON.parse(output))
   t.equal(validate.errors, null)
 
-  t.equal(output, `"${DateTime.fromJSDate(toStringify).toFormat('HH:mm:ss')}"`)
+  t.equal(output, '"01:03:25"')
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
@@ -144,7 +145,7 @@ test('render a nullable date in a string when format is time as kk:mm:ss', (t) =
     format: 'time',
     nullable: true
   }
-  const toStringify = new Date()
+  const toStringify = new Date(1674263005800)
 
   const validate = validator(schema)
   const stringify = build(schema)
@@ -153,7 +154,7 @@ test('render a nullable date in a string when format is time as kk:mm:ss', (t) =
   validate(JSON.parse(output))
   t.equal(validate.errors, null)
 
-  t.equal(output, `"${DateTime.fromJSDate(toStringify).toFormat('HH:mm:ss')}"`)
+  t.equal(output, '"01:03:25"')
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
@@ -165,7 +166,7 @@ test('render a midnight time', (t) => {
     type: 'string',
     format: 'time'
   }
-  const midnight = new Date(new Date().setHours(24))
+  const midnight = new Date(new Date(1674263005800).setHours(24))
 
   const validate = validator(schema)
   const stringify = build(schema)
@@ -174,7 +175,7 @@ test('render a midnight time', (t) => {
   validate(JSON.parse(output))
   t.equal(validate.errors, null)
 
-  t.equal(output, `"${DateTime.fromJSDate(midnight).toFormat('HH:mm:ss')}"`)
+  t.equal(output, '"00:03:25"')
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
@@ -195,7 +196,7 @@ test('verify padding for rendered date in a string when format is time', (t) =>
   validate(JSON.parse(output))
   t.equal(validate.errors, null)
 
-  t.equal(output, `"${DateTime.fromJSDate(toStringify).toFormat('HH:mm:ss')}"`)
+  t.equal(output, '"01:01:01"')
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
@@ -212,7 +213,7 @@ test('render a nested object in a string when type is date-format as ISOString',
       }
     }
   }
-  const toStringify = { date: new Date() }
+  const toStringify = { date: new Date(1674263005800) }
 
   const validate = validator(schema)
   const stringify = build(schema)
@@ -384,11 +385,11 @@ test('serializing null value', t => {
         ]
       }
 
-      const date = new Date()
+      const date = new Date(1674263005800)
       const input = { updatedAt: date }
       const { output } = serialize(schema, input)
 
-      t.equal(output, JSON.stringify({ updatedAt: DateTime.fromJSDate(date).toFormat('HH:mm:ss') }))
+      t.equal(output, JSON.stringify({ updatedAt: '01:03:25' }))
     })
 
     t.test('format::time, Date object', t => {
@@ -403,10 +404,10 @@ test('serializing null value', t => {
         ]
       }
 
-      const date = new Date()
+      const date = new Date(1674263005800)
       const { output } = serialize(schema, date)
 
-      t.equal(output, `"${DateTime.fromJSDate(date).toFormat('HH:mm:ss')}"`)
+      t.equal(output, '"01:03:25"')
     })
 
     t.test('format::time, Date object', t => {
@@ -497,7 +498,7 @@ test('Validate Date object as string type', (t) => {
       { type: 'string' }
     ]
   }
-  const toStringify = new Date()
+  const toStringify = new Date(1674263005800)
 
   const stringify = build(schema)
   const output = stringify(toStringify)
@@ -520,10 +521,10 @@ test('nullable date', (t) => {
 
   const stringify = build(schema)
 
-  const data = new Date()
+  const data = new Date(1674263005800)
   const result = stringify(data)
 
-  t.same(result, `"${DateTime.fromJSDate(data).toISODate()}"`)
+  t.same(result, '"2023-01-21"')
 })
 
 test('non-date format should not affect data serialization (issue #491)', (t) => {
@@ -544,3 +545,95 @@ test('non-date format should not affect data serialization (issue #491)', (t) =>
   const data = { hello: 123n }
   t.equal(stringify(data), '{"hello":"123"}')
 })
+
+test('should serialize also an invalid string value, even if it is not a valid date', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'a date in a string',
+    type: 'string',
+    format: 'date-time',
+    nullable: true
+  }
+  const toStringify = 'invalid'
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.equal(output, JSON.stringify(toStringify))
+  t.not(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('should throw an error if value can not be transformed to date-time', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'a date in a string',
+    type: 'string',
+    format: 'date-time',
+    nullable: true
+  }
+  const toStringify = true
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+
+  t.throws(() => stringify(toStringify), new Error('The value "true" cannot be converted to a date-time.'))
+  t.not(validate(toStringify))
+})
+
+test('should throw an error if value can not be transformed to date', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'a date in a string',
+    type: 'string',
+    format: 'date',
+    nullable: true
+  }
+  const toStringify = true
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+
+  t.throws(() => stringify(toStringify), new Error('The value "true" cannot be converted to a date.'))
+  t.not(validate(toStringify))
+})
+
+test('should throw an error if value can not be transformed to time', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'a time in a string',
+    type: 'string',
+    format: 'time',
+    nullable: true
+  }
+  const toStringify = true
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+
+  t.throws(() => stringify(toStringify), new Error('The value "true" cannot be converted to a time.'))
+  t.not(validate(toStringify))
+})
+
+test('should serialize also an invalid string value, even if it is not a valid time', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'a time in a string',
+    type: 'string',
+    format: 'time',
+    nullable: true
+  }
+  const toStringify = 'invalid'
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.equal(output, JSON.stringify(toStringify))
+  t.not(validate(JSON.parse(output)), 'valid schema')
+})

package/test/if-then-else.test.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const t = require('tap')
-const { DateTime } = require('luxon')
 const build = require('..')
 
+process.env.TZ = 'UTC'
+
 const schema = {
   type: 'object',
   properties: {
@@ -381,9 +382,9 @@ t.test('if/else with string format', (t) => {
 
   const stringify = build(schema)
 
-  const date = new Date()
+  const date = new Date(1674263005800)
 
-  t.equal(stringify(date), `"${DateTime.fromJSDate(date).toISODate()}"`)
+  t.equal(stringify(date), '"2023-01-21"')
   t.equal(stringify('Invalid'), '"Invalid"')
 })
 

package/test/integer.test.js

@@ -45,6 +45,14 @@ test('render a float as an integer', (t) => {
     { input: 42, output: '42' },
     { input: 1.99999, output: '1' },
     { input: -45.05, output: '-45' },
+    { input: Math.PI, output: '3', rounding: 'trunc' },
+    { input: 5.0, output: '5', rounding: 'trunc' },
+    { input: null, output: '0', rounding: 'trunc' },
+    { input: 0, output: '0', rounding: 'trunc' },
+    { input: 0.0, output: '0', rounding: 'trunc' },
+    { input: 42, output: '42', rounding: 'trunc' },
+    { input: 1.99999, output: '1', rounding: 'trunc' },
+    { input: -45.05, output: '-45', rounding: 'trunc' },
     { input: 0.95, output: '1', rounding: 'ceil' },
     { input: 0.2, output: '1', rounding: 'ceil' },
     { input: 45.95, output: '45', rounding: 'floor' },

package/test/multi-type-serializer.test.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const test = require('tap').test
+const build = require('..')
+
+test('should throw a TypeError with the path to the key of the invalid value', (t) => {
+  t.plan(1)
+  const schema = {
+    type: 'object',
+    properties: {
+      num: {
+        type: ['number']
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  t.throws(() => stringify({ num: { bla: 123 } }), new TypeError('The value of \'#/properties/num\' does not match schema definition.'))
+})

package/test/patternProperties.test.js

@@ -148,3 +148,21 @@ test('patternProperties - array coerce', (t) => {
   const incoercibleValues = { foo: 'true', ofoo: 0, objfoo: { tyrion: 'lannister' } }
   t.throws(() => stringify(incoercibleValues))
 })
+
+test('patternProperties - fail on invalid regex, handled by ajv', (t) => {
+  t.plan(1)
+
+  t.throws(() => build({
+    title: 'check array coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      'foo/\\': {
+        type: 'array',
+        items: {
+          type: 'string'
+        }
+      }
+    }
+  }), new Error('schema is invalid: data/patternProperties must match format "regex"'))
+})

package/test/ref.test.js

@@ -2005,3 +2005,76 @@ test('object property reference with default value', (t) => {
 
   t.equal(output, '{"prop":"foo"}')
 })
+
+test('should throw an Error if two non-identical schemas with same id are provided', (t) => {
+  t.plan(1)
+
+  const schema = {
+    $id: 'schema',
+    type: 'object',
+    allOf: [
+      {
+        $id: 'base',
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string'
+          }
+        },
+        required: [
+          'name'
+        ]
+      },
+      {
+        $id: 'inner_schema',
+        type: 'object',
+        properties: {
+          union: {
+            $id: '#id',
+            anyOf: [
+              {
+
+                $id: 'guid',
+                type: 'string'
+              },
+              {
+
+                $id: 'email',
+                type: 'string'
+              }
+            ]
+          }
+        },
+        required: [
+          'union'
+        ]
+      },
+      {
+        $id: 'inner_schema',
+        type: 'object',
+        properties: {
+          union: {
+            $id: '#id',
+            anyOf: [
+              {
+
+                $id: 'guid',
+                type: 'string'
+              },
+              {
+
+                $id: 'mail',
+                type: 'string'
+              }
+            ]
+          }
+        },
+        required: [
+          'union'
+        ]
+      }
+    ]
+  }
+
+  t.throws(() => build(schema), new Error('There is already another schema with id inner_schema'))
+})

package/test/string.test.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const build = require('..')
+
+test('serialize short string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+
+  const input = 'abcd'
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  t.equal(output, '"abcd"')
+  t.equal(JSON.parse(output), input)
+})
+
+test('serialize short string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+
+  const input = '\x00'
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  t.equal(output, '"\\u0000"')
+  t.equal(JSON.parse(output), input)
+})
+
+test('serialize long string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+
+  const input = new Array(2e4).fill('\x00').join('')
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  t.equal(output, `"${new Array(2e4).fill('\\u0000').join('')}"`)
+  t.equal(JSON.parse(output), input)
+})

package/test/typesArray.test.js

@@ -482,7 +482,53 @@ test('should throw an error when type is array and object is null', (t) => {
   }
 
   const stringify = build(schema)
-  t.throws(() => stringify({ arr: null }), new TypeError('The value \'null\' does not match schema definition.'))
+  t.throws(() => stringify({ arr: null }), new TypeError('The value of \'#/properties/arr\' does not match schema definition.'))
+})
+
+test('should throw an error when type is array and object is not an array', (t) => {
+  t.plan(1)
+  const schema = {
+    type: 'object',
+    properties: {
+      arr: {
+        type: 'array',
+        items: {
+          type: 'number'
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  t.throws(() => stringify({ arr: { foo: 'hello' } }), new TypeError('The value of \'#/properties/arr\' does not match schema definition.'))
+})
+
+test('should throw an error when type is array and object is not an array with external schema', (t) => {
+  t.plan(1)
+  const schema = {
+    type: 'object',
+    properties: {
+      arr: {
+        $ref: 'arrayOfNumbers#/definitions/arr'
+      }
+    }
+  }
+
+  const externalSchema = {
+    arrayOfNumbers: {
+      definitions: {
+        arr: {
+          type: 'array',
+          items: {
+            type: 'number'
+          }
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchema })
+  t.throws(() => stringify({ arr: { foo: 'hello' } }), new TypeError('The value of \'arrayOfNumbers#/definitions/arr\' does not match schema definition.'))
 })
 
 test('throw an error if none of types matches', (t) => {

package/types/index.d.ts

@@ -158,8 +158,10 @@ declare namespace build {
     ajv?: AjvOptions
     /**
      * Optionally configure how the integer will be rounded
+     * 
+     * @default 'trunc'
      */
-    rounding?: 'ceil' | 'floor' | 'round'
+    rounding?: 'ceil' | 'floor' | 'round' | 'trunc'
     /**
      * @deprecated 
      * Enable debug mode. Please use `mode: "debug"` instead
@@ -169,6 +171,22 @@ declare namespace build {
      * Running mode of fast-json-stringify
      */
     mode?: 'debug' | 'standalone'
+
+    /**
+     * Large arrays are defined as arrays containing, by default, `20000`
+     * elements or more. That value can be adjusted via the option parameter
+     * `largeArraySize`.
+     *
+     * @default 20000
+     */
+    largeArraySize?: number | string | BigInt
+
+    /**
+     * Specify the function on how large Arrays should be stringified.
+     *
+     * @default 'default'
+     */
+    largeArrayMechanism?: 'default' | 'json-stringify'
   }
 
   export const validLargeArrayMechanisms: string[]

package/types/index.test-d.ts

@@ -13,6 +13,12 @@ const schema2: Schema = {
 build(schema1)(25)
 build(schema2)(-5)
 
+build(schema2, { rounding: 'ceil' })
+build(schema2, { rounding: 'floor' })
+build(schema2, { rounding: 'round' })
+build(schema2, { rounding: 'trunc' })
+expectError(build(schema2, { rounding: 'invalid' }))
+
 // String schema
 const schema3: Schema = {
     type: 'string'
@@ -217,3 +223,14 @@ const stringify7 = build({
 });
 stringify7(true);
 expectError(stringify7("a string"));
+
+// largeArrayMechanism
+
+build({}, { largeArrayMechanism: 'json-stringify'} )
+build({}, { largeArrayMechanism: 'default'} )
+expectError(build({} as Schema, { largeArrayMechanism: 'invalid'} ))
+
+build({}, { largeArraySize: 2000 } )
+build({}, { largeArraySize: '2e4' } )
+build({}, { largeArraySize: 2n } )
+expectError(build({} as Schema, { largeArraySize: ['asdf']} ))