fast-json-stringify 3.0.3 → 4.0.0

package/test/date.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const test = require('tap').test
-const moment = require('moment')
+const { DateTime } = require('luxon')
 const validator = require('is-my-json-valid')
 const build = require('..')
 
@@ -40,13 +40,14 @@ test('render a date in a string when format is date-format as ISOString', (t) =>
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('render a date in a string when format is date as YYYY-MM-DD', (t) => {
+test('render a nullable date in a string when format is date-format as ISOString', (t) => {
   t.plan(2)
 
   const schema = {
     title: 'a date in a string',
     type: 'string',
-    format: 'date'
+    format: 'date-time',
+    nullable: true
   }
   const toStringify = new Date()
 
@@ -54,11 +55,11 @@ test('render a date in a string when format is date as YYYY-MM-DD', (t) => {
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, `"${moment(toStringify).format('YYYY-MM-DD')}"`)
+  t.equal(output, JSON.stringify(toStringify))
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('verify padding for rendered date in a string when format is date', (t) => {
+test('render a date in a string when format is date as YYYY-MM-DD', (t) => {
   t.plan(2)
 
   const schema = {
@@ -66,23 +67,24 @@ test('verify padding for rendered date in a string when format is date', (t) =>
     type: 'string',
     format: 'date'
   }
-  const toStringify = new Date(2020, 0, 1, 0, 0, 0, 0)
+  const toStringify = new Date()
 
   const validate = validator(schema)
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, `"${moment(toStringify).format('YYYY-MM-DD')}"`)
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toISODate()}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('render a date in a string when format is time as kk:mm:ss', (t) => {
-  t.plan(3)
+test('render a nullable date in a string when format is date as YYYY-MM-DD', (t) => {
+  t.plan(2)
 
   const schema = {
     title: 'a date in a string',
     type: 'string',
-    format: 'time'
+    format: 'date',
+    nullable: true
   }
   const toStringify = new Date()
 
@@ -90,14 +92,29 @@ test('render a date in a string when format is time as kk:mm:ss', (t) => {
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  validate(JSON.parse(output))
-  t.equal(validate.errors, null)
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toISODate()}"`)
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
 
-  t.equal(output, `"${moment(toStringify).format('HH:mm:ss')}"`)
+test('verify padding for rendered date in a string when format is date', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'a date in a string',
+    type: 'string',
+    format: 'date'
+  }
+  const toStringify = new Date(2020, 0, 1, 0, 0, 0, 0)
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toISODate()}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('verify padding for rendered date in a string when format is time', (t) => {
+test('render a date in a string when format is time as kk:mm:ss', (t) => {
   t.plan(3)
 
   const schema = {
@@ -105,7 +122,7 @@ test('verify padding for rendered date in a string when format is time', (t) =>
     type: 'string',
     format: 'time'
   }
-  const toStringify = new Date(2020, 0, 1, 1, 1, 1, 1)
+  const toStringify = new Date()
 
   const validate = validator(schema)
   const stringify = build(schema)
@@ -114,61 +131,71 @@ 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, `"${moment(toStringify).format('HH:mm:ss')}"`)
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toFormat('HH:mm:ss')}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('render a moment.js instance in a string when format is date-time as ISOString', (t) => {
-  t.plan(2)
+test('render a nullable date in a string when format is time as kk:mm:ss', (t) => {
+  t.plan(3)
 
   const schema = {
-    title: 'a moment.js object in a string',
+    title: 'a date in a string',
     type: 'string',
-    format: 'date-time'
+    format: 'time',
+    nullable: true
   }
-  const toStringify = moment()
+  const toStringify = new Date()
 
   const validate = validator(schema)
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, JSON.stringify(toStringify))
+  validate(JSON.parse(output))
+  t.equal(validate.errors, null)
+
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toFormat('HH:mm:ss')}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('render a moment.js instance in a string when format is date as YYYY-MM-DD', (t) => {
-  t.plan(2)
+test('render a midnight time', (t) => {
+  t.plan(3)
 
   const schema = {
-    title: 'a moment.js object in a string',
+    title: 'a date in a string',
     type: 'string',
-    format: 'date'
+    format: 'time'
   }
-  const toStringify = moment()
+  const midnight = new Date(new Date().setHours(24))
 
   const validate = validator(schema)
   const stringify = build(schema)
-  const output = stringify(toStringify)
+  const output = stringify(midnight)
 
-  t.equal(output, `"${toStringify.format('YYYY-MM-DD')}"`)
+  validate(JSON.parse(output))
+  t.equal(validate.errors, null)
+
+  t.equal(output, `"${DateTime.fromJSDate(midnight).toFormat('HH:mm:ss')}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('render a moment.js instance in a string when format is time as HH:mm:ss', (t) => {
-  t.plan(2)
+test('verify padding for rendered date in a string when format is time', (t) => {
+  t.plan(3)
 
   const schema = {
-    title: 'a moment.js object in a string',
+    title: 'a date in a string',
     type: 'string',
     format: 'time'
   }
-  const toStringify = moment()
+  const toStringify = new Date(2020, 0, 1, 1, 1, 1, 1)
 
   const validate = validator(schema)
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, `"${toStringify.format('HH:mm:ss')}"`)
+  validate(JSON.parse(output))
+  t.equal(validate.errors, null)
+
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toFormat('HH:mm:ss')}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
@@ -185,7 +212,7 @@ test('render a nested object in a string when type is date-format as ISOString',
       }
     }
   }
-  const toStringify = { date: moment() }
+  const toStringify = { date: new Date() }
 
   const validate = validator(schema)
   const stringify = build(schema)

package/test/debug-mode.test.js

@@ -98,5 +98,5 @@ test('to string auto-consistent with ajv-formats', t => {
   const compiled = fjs.restore(debugMode)
   const tobe = JSON.stringify({ str: 'foo@bar.com' })
   t.same(compiled({ str: 'foo@bar.com' }), tobe)
-  t.same(compiled({ str: 'foo' }), JSON.stringify({ str: null }), 'invalid format is ignored')
+  t.throws(() => compiled({ str: 'foo' }))
 })

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

@@ -261,13 +261,13 @@ t.test('if-then-else', t => {
   const tests = [
     {
       name: 'foobar',
-      schema: schema,
+      schema,
       input: fooBarInput,
       expected: foobarOutput
     },
     {
       name: 'greeting',
-      schema: schema,
+      schema,
       input: greetingInput,
       expected: greetingOutput
     },

package/test/nestedObjects.test.js

@@ -30,3 +30,34 @@ test('nested objects with same properties', (t) => {
   })
   t.equal(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}')
 })
+
+test('names collision', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'nested objects with same properties',
+    type: 'object',
+    properties: {
+      test: {
+        type: 'object',
+        properties: {
+          a: { type: 'string' }
+        }
+      },
+      tes: {
+        type: 'object',
+        properties: {
+          b: { type: 'string' },
+          t: { type: 'object' }
+        }
+      }
+    }
+  }
+  const stringify = build(schema)
+  const data = {
+    test: { a: 'a' },
+    tes: { b: 'b', t: {} }
+  }
+
+  t.equal(stringify(data), JSON.stringify(data))
+})

package/test/nullable.test.js

@@ -9,11 +9,11 @@ const nullable = true
 const complexObject = {
   type: 'object',
   properties: {
-    nullableString: { type: 'string', nullable: nullable },
-    nullableNumber: { type: 'number', nullable: nullable },
-    nullableInteger: { type: 'integer', nullable: nullable },
-    nullableBoolean: { type: 'boolean', nullable: nullable },
-    nullableNull: { type: 'null', nullable: nullable },
+    nullableString: { type: 'string', nullable },
+    nullableNumber: { type: 'number', nullable },
+    nullableInteger: { type: 'integer', nullable },
+    nullableBoolean: { type: 'boolean', nullable },
+    nullableNull: { type: 'null', nullable },
     nullableArray: {
       type: 'array',
       nullable: true,
@@ -25,11 +25,11 @@ const complexObject = {
       nullable: false,
       additionalProperties: true,
       properties: {
-        nullableString: { type: 'string', nullable: nullable },
-        nullableNumber: { type: 'number', nullable: nullable },
-        nullableInteger: { type: 'integer', nullable: nullable },
-        nullableBoolean: { type: 'boolean', nullable: nullable },
-        nullableNull: { type: 'null', nullable: nullable },
+        nullableString: { type: 'string', nullable },
+        nullableNumber: { type: 'number', nullable },
+        nullableInteger: { type: 'integer', nullable },
+        nullableBoolean: { type: 'boolean', nullable },
+        nullableNull: { type: 'null', nullable },
         nullableArray: {
           type: 'array',
           nullable: true,
@@ -86,11 +86,11 @@ const complexExpectedResult = {
 }
 
 const testSet = {
-  nullableString: [{ type: 'string', nullable: nullable }, null, null],
-  nullableNumber: [{ type: 'number', nullable: nullable }, null, null],
-  nullableInteger: [{ type: 'integer', nullable: nullable }, null, null],
-  nullableBoolean: [{ type: 'boolean', nullable: nullable }, null, null],
-  nullableNull: [{ type: 'null', nullable: nullable }, null, null],
+  nullableString: [{ type: 'string', nullable }, null, null],
+  nullableNumber: [{ type: 'number', nullable }, null, null],
+  nullableInteger: [{ type: 'integer', nullable }, null, null],
+  nullableBoolean: [{ type: 'boolean', nullable }, null, null],
+  nullableNull: [{ type: 'null', nullable }, null, null],
   nullableArray: [{
     type: 'array',
     nullable: true,
@@ -116,3 +116,331 @@ Object.keys(testSet).forEach(key => {
     t.same(JSON.parse(result), expected)
   })
 })
+
+test('handle nullable number correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'number',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable integer correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'integer',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable boolean correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'boolean',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable string correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable date-time correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    format: 'date-time',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable date correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    format: 'date',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable time correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    format: 'time',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable strings with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'string',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable date-time strings with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'string',
+          format: 'date-time',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable date-time strings with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'string',
+          format: 'date',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable date-time strings with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'string',
+          format: 'time',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable numbers with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'number',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable integers with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'integer',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable booleans with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'boolean',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})