fast-json-stringify 3.2.0 → 4.2.0

package/test/nullable.test.js

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

package/test/oneof.test.js

@@ -104,11 +104,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) => {
@@ -403,7 +399,7 @@ test('oneOf object with field of type string with format or null', (t) => {
 })
 
 test('one array item match oneOf types', (t) => {
-  t.plan(1)
+  t.plan(3)
 
   const schema = {
     type: 'object',
@@ -429,15 +425,13 @@ test('one array item match oneOf types', (t) => {
 
   const stringify = build(schema)
 
-  const responseWithMappedType = stringify({
-    data: [false, 'foo']
-  })
-
-  t.equal('{"data":["foo"]}', responseWithMappedType)
+  t.equal(stringify({ data: ['foo'] }), '{"data":["foo"]}')
+  t.equal(stringify({ data: [1] }), '{"data":[1]}')
+  t.throws(() => stringify({ data: [false, 'foo'] }))
 })
 
 test('some array items match oneOf types', (t) => {
-  t.plan(1)
+  t.plan(2)
 
   const schema = {
     type: 'object',
@@ -463,11 +457,8 @@ test('some array items match oneOf types', (t) => {
 
   const stringify = build(schema)
 
-  const responseWithMappedTypes = stringify({
-    data: [false, 'foo', true, 5]
-  })
-
-  t.equal('{"data":["foo",5]}', responseWithMappedTypes)
+  t.equal(stringify({ data: ['foo', 5] }), '{"data":["foo",5]}')
+  t.throws(() => stringify({ data: [false, 'foo', true, 5] }))
 })
 
 test('all array items does not match oneOf types', (t) => {
@@ -497,9 +488,5 @@ test('all array items does not match oneOf types', (t) => {
 
   const stringify = build(schema)
 
-  const emptyResponse = stringify({
-    data: [null, false, true, undefined, [], {}]
-  })
-
-  t.equal('{"data":[]}', emptyResponse)
+  t.throws(() => stringify({ data: [null, false, true, undefined, [], {}] }))
 })

package/test/patternProperties.test.js

@@ -63,7 +63,7 @@ test('patternProperties - string coerce', (t) => {
 })
 
 test('patternProperties - number coerce', (t) => {
-  t.plan(1)
+  t.plan(2)
   const stringify = build({
     title: 'check number coerce',
     type: 'object',
@@ -75,8 +75,16 @@ test('patternProperties - number coerce', (t) => {
     }
   })
 
-  const obj = { foo: true, ofoo: '42', xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } }
-  t.equal(stringify(obj), '{"foo":1,"ofoo":42,"xfoo":null,"arrfoo":null,"objfoo":null}')
+  const coercibleValues = { foo: true, ofoo: '42' }
+  t.equal(stringify(coercibleValues), '{"foo":1,"ofoo":42}')
+
+  const incoercibleValues = { xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } }
+  try {
+    stringify(incoercibleValues)
+    t.fail('should throw an error')
+  } catch (err) {
+    t.ok(err)
+  }
 })
 
 test('patternProperties - boolean coerce', (t) => {
@@ -119,7 +127,7 @@ test('patternProperties - object coerce', (t) => {
 })
 
 test('patternProperties - array coerce', (t) => {
-  t.plan(1)
+  t.plan(2)
   const stringify = build({
     title: 'check array coerce',
     type: 'object',
@@ -134,6 +142,9 @@ test('patternProperties - array coerce', (t) => {
     }
   })
 
-  const obj = { foo: 'true', ofoo: 0, arrfoo: [1, 2], objfoo: { tyrion: 'lannister' } }
-  t.equal(stringify(obj), '{"foo":["t","r","u","e"],"ofoo":[],"arrfoo":["1","2"],"objfoo":[]}')
+  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))
 })

package/test/required.test.js

@@ -232,7 +232,7 @@ test('required numbers', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.equal(e.message, '"num" is required!')
+    t.equal(e.message, 'The value "aaa" cannot be converted to an integer.')
     t.pass()
   }
 })

package/test/sanitize3.test.js

@@ -3,15 +3,13 @@
 const t = require('tap')
 const build = require('..')
 
-const stringify = build({
-  $defs: {
-    type: 'foooo"bar'
-  },
-  patternProperties: {
-    x: { $ref: '#/$defs' }
-  }
-})
-
 t.throws(() => {
-  stringify({ x: 0 })
-}, 'Cannot coerce 0 to "foo"bar"')
+  build({
+    $defs: {
+      type: 'foooo"bar'
+    },
+    patternProperties: {
+      x: { $ref: '#/$defs' }
+    }
+  })
+}, 'foooo"bar unsupported')

package/test/standalone-mode.test.js

@@ -0,0 +1,121 @@
+'use strict'
+
+const test = require('tap').test
+const fjs = require('..')
+const fs = require('fs')
+const path = require('path')
+
+function build (opts, schema) {
+  return fjs(schema || {
+    title: 'default string',
+    type: 'object',
+    properties: {
+      firstName: {
+        type: 'string'
+      }
+    },
+    required: ['firstName']
+  }, opts)
+}
+
+const tmpDir = 'test/fixtures'
+
+test('activate standalone mode', async (t) => {
+  t.plan(3)
+  const code = build({ mode: 'standalone' })
+  t.type(code, 'string')
+  t.equal(code.indexOf('ajv'), -1)
+
+  const destionation = path.resolve(tmpDir, 'standalone.js')
+
+  t.teardown(async () => {
+    await fs.promises.rm(destionation, { force: true })
+  })
+
+  await fs.promises.writeFile(destionation, code)
+  const standalone = require(destionation)
+  t.same(standalone({ firstName: 'Foo', surname: 'bar' }), JSON.stringify({ firstName: 'Foo' }), 'surname evicted')
+})
+
+test('test ajv schema', async (t) => {
+  t.plan(3)
+  const code = build({ mode: 'standalone' }, {
+    type: 'object',
+    properties: {
+    },
+    if: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', enum: ['foobar'] }
+      }
+    },
+    then: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', enum: ['foobar'] },
+        foo: { type: 'string' },
+        bar: { type: 'number' },
+        list: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              value: { type: 'string' }
+            }
+          }
+        }
+      }
+    },
+    else: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', enum: ['greeting'] },
+        hi: { type: 'string' },
+        hello: { type: 'number' },
+        list: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              value: { type: 'string' }
+            }
+          }
+        }
+      }
+    }
+  })
+  t.type(code, 'string')
+  t.equal(code.indexOf('ajv') > 0, true)
+
+  const destionation = path.resolve(tmpDir, 'standalone2.js')
+
+  t.teardown(async () => {
+    await fs.promises.rm(destionation, { force: true })
+  })
+
+  await fs.promises.writeFile(destionation, code)
+  const standalone = require(destionation)
+  t.same(standalone({
+    kind: 'foobar',
+    foo: 'FOO',
+    list: [{
+      name: 'name',
+      value: 'foo'
+    }],
+    bar: 42,
+    hi: 'HI',
+    hello: 45,
+    a: 'A',
+    b: 35
+  }), JSON.stringify({
+    kind: 'foobar',
+    foo: 'FOO',
+    bar: 42,
+    list: [{
+      name: 'name',
+      value: 'foo'
+    }]
+  }))
+})

package/test/types/test.ts

@@ -1,3 +1,4 @@
+import Ajv from 'ajv'
 import build, { Schema } from '../..'
 
 // Number schemas
@@ -142,4 +143,11 @@ const schema12: Schema = {
   format: 'date-time'
 }
 
-build(schema12)(new Date())
+build(schema12)(new Date())
+
+let str: string, ajv: Ajv
+str = build(schema1, { debugMode: true }).code
+ajv = build(schema1, { debugMode: true }).ajv
+str = build(schema1, { mode: 'debug' }).code
+ajv = build(schema1, { mode: 'debug' }).ajv
+str = build(schema1, { mode: 'standalone' })

package/test/typesArray.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const test = require('tap').test
-const moment = require('moment')
 const build = require('..')
 
 test('possibly nullable integer primitive alternative', (t) => {
@@ -88,6 +87,27 @@ test('possibly nullable number primitive alternative with null value', (t) => {
   t.equal(value, '{"data":0}')
 })
 
+test('possibly nullable number primitive alternative with null value', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'simple object with multi-type nullable primitive',
+    type: 'object',
+    properties: {
+      data: {
+        type: ['boolean']
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  const value = stringify({
+    data: null
+  })
+  t.equal(value, '{"data":false}')
+})
+
 test('nullable integer primitive', (t) => {
   t.plan(1)
 
@@ -361,7 +381,7 @@ test('string type array can handle dates', (t) => {
   const stringify = build(schema)
   const value = stringify({
     date: new Date('2018-04-20T07:52:31.017Z'),
-    dateObject: moment('2018-04-21T07:52:31.017Z')
+    dateObject: new Date('2018-04-21T07:52:31.017Z')
   })
   t.equal(value, '{"date":"2018-04-20T07:52:31.017Z","dateObject":"2018-04-21T07:52:31.017Z"}')
 })
@@ -433,5 +453,22 @@ 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('Property \'arr\' should be of type array, received \'null\' instead.'))
+  t.throws(() => stringify({ arr: null }), new TypeError('The value \'null\' does not match schema definition.'))
+})
+
+test('throw an error if none of types matches', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'simple object with multi-type nullable primitive',
+    type: 'object',
+    properties: {
+      data: {
+        type: ['number', 'boolean']
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  t.throws(() => stringify({ data: 'string' }), 'The value "string" does not match schema definition.')
 })