fast-json-stringify 2.7.10 → 3.0.0

package/test/allof.test.js

@@ -108,7 +108,7 @@ test('object with allOf and no schema on the allOf', (t) => {
     build(schema)
     t.fail()
   } catch (e) {
-    t.equal(e.message, 'schema is invalid: data.allOf should NOT have fewer than 1 items')
+    t.equal(e.message, 'schema is invalid: data/allOf must NOT have fewer than 1 items')
   }
 })
 
@@ -277,6 +277,58 @@ test('object with multiple $refs in allOf', (t) => {
   t.equal(value, '{"id1":1,"id2":2}')
 })
 
+test('allOf with nested allOf in $ref', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'allOf with nested allOf in $ref',
+    type: 'object',
+    definitions: {
+      group: {
+        type: 'object',
+        allOf: [{
+          properties: {
+            id2: {
+              type: 'integer'
+            }
+          }
+        }, {
+          properties: {
+            id3: {
+              type: 'integer'
+            }
+          }
+        }]
+      }
+    },
+    allOf: [
+      {
+        type: 'object',
+        properties: {
+          id1: {
+            type: 'integer'
+          }
+        },
+        required: [
+          'id1'
+        ]
+      },
+      {
+        $ref: '#/definitions/group'
+      }
+    ]
+  }
+
+  const stringify = build(schema)
+  const value = stringify({
+    id1: 1,
+    id2: 2,
+    id3: 3,
+    id4: 4 // extra prop shouldn't be in result
+  })
+  t.equal(value, '{"id1":1,"id2":2,"id3":3}')
+})
+
 test('object with external $refs in allOf', (t) => {
   t.plan(1)
 

package/test/bigint.test.js

@@ -0,0 +1,76 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const build = require('..')
+
+test('render a bigint as JSON', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'bigint',
+    type: 'integer'
+  }
+
+  const stringify = build(schema)
+  const output = stringify(1615n)
+
+  t.equal(output, '1615')
+})
+
+test('render an object with a bigint as JSON', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with bigint',
+    type: 'object',
+    properties: {
+      id: {
+        type: 'integer'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify({
+    id: 1615n
+  })
+
+  t.equal(output, '{"id":1615}')
+})
+
+test('render an array with a bigint as JSON', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'array with bigint',
+    type: 'array',
+    items: {
+      type: 'integer'
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify([1615n])
+
+  t.equal(output, '[1615]')
+})
+
+test('render an object with an additionalProperty of type bigint as JSON', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with bigint',
+    type: 'object',
+    additionalProperties: {
+      type: 'integer'
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify({
+    num: 1615n
+  })
+
+  t.equal(output, '{"num":1615}')
+})

package/test/debug-mode.test.js

@@ -63,3 +63,29 @@ test('to string auto-consistent with ajv', t => {
   const tobe = JSON.stringify({ str: 'Foo' })
   t.same(compiled({ str: 'Foo', void: 'me' }), tobe)
 })
+
+test('to string auto-consistent with ajv-formats', t => {
+  t.plan(3)
+  const debugMode = fjs({
+    title: 'object with multiple types field and format keyword',
+    type: 'object',
+    properties: {
+      str: {
+        anyOf: [{
+          type: 'string',
+          format: 'email'
+        }, {
+          type: 'boolean'
+        }]
+      }
+    }
+  }, { debugMode: 1 })
+  t.type(debugMode, Array)
+
+  const str = debugMode.toString()
+
+  const compiled = fjs.restore(str)
+  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')
+})

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

@@ -8,11 +8,13 @@ const schema = {
   properties: {
   },
   if: {
+    type: 'object',
     properties: {
       kind: { type: 'string', enum: ['foobar'] }
     }
   },
   then: {
+    type: 'object',
     properties: {
       kind: { type: 'string', enum: ['foobar'] },
       foo: { type: 'string' },
@@ -30,6 +32,7 @@ const schema = {
     }
   },
   else: {
+    type: 'object',
     properties: {
       kind: { type: 'string', enum: ['greeting'] },
       hi: { type: 'string' },
@@ -52,17 +55,20 @@ const nestedIfSchema = {
   type: 'object',
   properties: { },
   if: {
+    type: 'object',
     properties: {
       kind: { type: 'string', enum: ['foobar', 'greeting'] }
     }
   },
   then: {
     if: {
+      type: 'object',
       properties: {
         kind: { type: 'string', enum: ['foobar'] }
       }
     },
     then: {
+      type: 'object',
       properties: {
         kind: { type: 'string', enum: ['foobar'] },
         foo: { type: 'string' },
@@ -80,6 +86,7 @@ const nestedIfSchema = {
       }
     },
     else: {
+      type: 'object',
       properties: {
         kind: { type: 'string', enum: ['greeting'] },
         hi: { type: 'string' },
@@ -88,6 +95,7 @@ const nestedIfSchema = {
     }
   },
   else: {
+    type: 'object',
     properties: {
       kind: { type: 'string', enum: ['alphabet'] },
       a: { type: 'string' },
@@ -100,11 +108,13 @@ const nestedElseSchema = {
   type: 'object',
   properties: { },
   if: {
+    type: 'object',
     properties: {
       kind: { type: 'string', enum: ['foobar'] }
     }
   },
   then: {
+    type: 'object',
     properties: {
       kind: { type: 'string', enum: ['foobar'] },
       foo: { type: 'string' },
@@ -123,11 +133,13 @@ const nestedElseSchema = {
   },
   else: {
     if: {
+      type: 'object',
       properties: {
         kind: { type: 'string', enum: ['greeting'] }
       }
     },
     then: {
+      type: 'object',
       properties: {
         kind: { type: 'string', enum: ['greeting'] },
         hi: { type: 'string' },
@@ -135,6 +147,7 @@ const nestedElseSchema = {
       }
     },
     else: {
+      type: 'object',
       properties: {
         kind: { type: 'string', enum: ['alphabet'] },
         a: { type: 'string' },
@@ -154,11 +167,13 @@ const noElseSchema = {
   properties: {
   },
   if: {
+    type: 'object',
     properties: {
       kind: { type: 'string', enum: ['foobar'] }
     }
   },
   then: {
+    type: 'object',
     properties: {
       kind: { type: 'string', enum: ['foobar'] },
       foo: { type: 'string' },
@@ -310,7 +325,7 @@ t.test('if-then-else', t => {
     t.test(test.name + ' - normal', t => {
       t.plan(1)
 
-      const stringify = build(JSON.parse(JSON.stringify(test.schema)))
+      const stringify = build(JSON.parse(JSON.stringify(test.schema)), { ajv: { strictTypes: false } })
       const serialized = stringify(test.input)
       t.equal(serialized, test.expected)
     })

package/test/integer.test.js

@@ -2,10 +2,8 @@
 
 const t = require('tap')
 const test = t.test
-const semver = require('semver')
 const validator = require('is-my-json-valid')
-const proxyquire = require('proxyquire')
-const build = proxyquire('..', { long: null })
+const build = require('..')
 const ROUNDING_TYPES = ['ceil', 'floor', 'round']
 
 test('render an integer as JSON', (t) => {
@@ -136,13 +134,6 @@ test('render an object with an additionalProperty of type integer as JSON', (t)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-if (semver.gt(process.versions.node, '10.3.0')) {
-  require('./bigint')(t.test, build)
-} else {
-  t.pass('Skip because Node version < 10.4')
-  t.end()
-}
-
 test('should round integer object parameter', t => {
   t.plan(2)
 

package/test/nullable.test.js

@@ -97,16 +97,21 @@ const testSet = {
     items: {}
   }, null, null],
   nullableObject: [{ type: 'object', nullable: true }, null, null],
-  complexObject: [complexObject, complexData, complexExpectedResult]
+  complexObject: [complexObject, complexData, complexExpectedResult, { ajv: { allowUnionTypes: true } }]
 }
 
 Object.keys(testSet).forEach(key => {
   test(`handle nullable:true in ${key} correctly`, (t) => {
     t.plan(1)
 
-    const stringifier = build(testSet[key][0])
-    const data = testSet[key][1]
-    const expected = testSet[key][2]
+    const [
+      schema,
+      data,
+      expected,
+      extraOptions
+    ] = testSet[key]
+
+    const stringifier = build(schema, extraOptions)
     const result = stringifier(data)
     t.same(JSON.parse(result), expected)
   })

package/test/recursion.test.js

@@ -0,0 +1,180 @@
+'use strict'
+
+const test = require('tap').test
+const build = require('..')
+
+test('can stringify recursive directory tree (issue #181)', (t) => {
+  t.plan(1)
+
+  const schema = {
+    definitions: {
+      directory: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          subDirectories: {
+            type: 'array',
+            items: { $ref: '#/definitions/directory' },
+            default: []
+          }
+        }
+      }
+    },
+    type: 'array',
+    items: { $ref: '#/definitions/directory' }
+  }
+  const stringify = build(schema)
+
+  t.equal(stringify([
+    { name: 'directory 1', subDirectories: [] },
+    {
+      name: 'directory 2',
+      subDirectories: [
+        { name: 'directory 2.1', subDirectories: [] },
+        { name: 'directory 2.2', subDirectories: [] }
+      ]
+    }
+  ]), '[{"name":"directory 1","subDirectories":[]},{"name":"directory 2","subDirectories":[{"name":"directory 2.1","subDirectories":[]},{"name":"directory 2.2","subDirectories":[]}]}]')
+})
+
+test('can stringify when recursion in external schema', t => {
+  t.plan(1)
+
+  const referenceSchema = {
+    $id: 'person',
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      children: {
+        type: 'array',
+        items: { $ref: '#' }
+      }
+    }
+  }
+
+  const schema = {
+    $id: 'mainSchema',
+    type: 'object',
+    properties: {
+      people: {
+        $ref: 'person'
+      }
+    }
+  }
+  const stringify = build(schema, {
+    schema: {
+      [referenceSchema.$id]: referenceSchema
+    }
+  })
+
+  const value = stringify({ people: { name: 'Elizabeth', children: [{ name: 'Charles' }] } })
+  t.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles"}]}}')
+})
+
+test('use proper serialize function', t => {
+  t.plan(1)
+
+  const personSchema = {
+    $id: 'person',
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      children: {
+        type: 'array',
+        items: { $ref: '#' }
+      }
+    }
+  }
+
+  const directorySchema = {
+    $id: 'directory',
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      subDirectories: {
+        type: 'array',
+        items: { $ref: '#' },
+        default: []
+      }
+    }
+  }
+
+  const schema = {
+    $id: 'mainSchema',
+    type: 'object',
+    properties: {
+      people: { $ref: 'person' },
+      directory: { $ref: 'directory' }
+    }
+  }
+  const stringify = build(schema, {
+    schema: {
+      [personSchema.$id]: personSchema,
+      [directorySchema.$id]: directorySchema
+    }
+  })
+
+  const value = stringify({
+    people: {
+      name: 'Elizabeth',
+      children: [{
+        name: 'Charles',
+        children: [{ name: 'William', children: [{ name: 'George' }, { name: 'Charlotte' }] }, { name: 'Harry' }]
+      }]
+    },
+    directory: {
+      name: 'directory 1',
+      subDirectories: [
+        { name: 'directory 1.1', subDirectories: [] },
+        {
+          name: 'directory 1.2',
+          subDirectories: [{ name: 'directory 1.2.1' }, { name: 'directory 1.2.2' }]
+        }
+      ]
+    }
+  })
+  t.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles","children":[{"name":"William","children":[{"name":"George"},{"name":"Charlotte"}]},{"name":"Harry"}]}]},"directory":{"name":"directory 1","subDirectories":[{"name":"directory 1.1","subDirectories":[]},{"name":"directory 1.2","subDirectories":[{"name":"directory 1.2.1","subDirectories":[]},{"name":"directory 1.2.2","subDirectories":[]}]}]}}')
+})
+
+test('can stringify recursive references in object types (issue #365)', t => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    definitions: {
+      parentCategory: {
+        type: 'object',
+        properties: {
+          parent: {
+            $ref: '#/definitions/parentCategory'
+          }
+        }
+      }
+    },
+    properties: {
+      category: {
+        type: 'object',
+        properties: {
+          parent: {
+            $ref: '#/definitions/parentCategory'
+          }
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const data = {
+    category: {
+      parent: {
+        parent: {
+          parent: {
+            parent: {}
+          }
+        }
+      }
+    }
+  }
+  const value = stringify(data)
+  t.equal(value, '{"category":{"parent":{"parent":{"parent":{"parent":{}}}}}}')
+})

package/test/side-effect.test.js

@@ -155,3 +155,42 @@ test('must not mutate items $ref', t => {
   t.equal(value, '[{"name":"foo"}]')
   t.same(schema, clonedSchema)
 })
+
+test('must not mutate items referred by $ref', t => {
+  t.plan(2)
+
+  const firstSchema = {
+    $id: 'example1',
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string'
+      }
+    }
+  }
+
+  const reusedSchema = {
+    $id: 'example2',
+    type: 'object',
+    properties: {
+      name: {
+        oneOf: [
+          {
+            $ref: 'example1'
+          }
+        ]
+      }
+    }
+  }
+
+  const clonedSchema = clone(firstSchema)
+  const stringify = build(reusedSchema, {
+    schema: {
+      [firstSchema.$id]: firstSchema
+    }
+  })
+
+  const value = stringify({ name: { name: 'foo' } })
+  t.equal(value, '{"name":{"name":"foo"}}')
+  t.same(firstSchema, clonedSchema)
+})

package/test/types/tsconfig.json

@@ -3,7 +3,9 @@
     "esModuleInterop": true,
     "noEmit": true,
     "rootDir": "../..",
-    "strict": true
+    "strict": true,
+    "target": "ES2015",
+    "moduleResolution": "node"
   },
   "include": [
     "./test.ts"

package/test/typesArray.test.js

@@ -17,7 +17,7 @@ test('possibly nullable integer primitive alternative', (t) => {
     }
   }
 
-  const stringify = build(schema)
+  const stringify = build(schema, { ajv: { allowUnionTypes: true } })
 
   const value = stringify({
     data: 4
@@ -328,7 +328,7 @@ test('object with anyOf and multiple types', (t) => {
       }
     }
   }
-  const stringify = build(schema)
+  const stringify = build(schema, { ajv: { allowUnionTypes: true } })
 
   try {
     const value = stringify({

package/test/bigint.js

@@ -1,74 +0,0 @@
-'use strict'
-
-module.exports = function (test, build) {
-  test('render a bigint as JSON', (t) => {
-    t.plan(1)
-
-    const schema = {
-      title: 'bigint',
-      type: 'integer'
-    }
-
-    const stringify = build(schema)
-    const output = stringify(1615n)
-
-    t.equal(output, '1615')
-  })
-
-  test('render an object with a bigint as JSON', (t) => {
-    t.plan(1)
-
-    const schema = {
-      title: 'object with bigint',
-      type: 'object',
-      properties: {
-        id: {
-          type: 'integer'
-        }
-      }
-    }
-
-    const stringify = build(schema)
-    const output = stringify({
-      id: 1615n
-    })
-
-    t.equal(output, '{"id":1615}')
-  })
-
-  test('render an array with a bigint as JSON', (t) => {
-    t.plan(1)
-
-    const schema = {
-      title: 'array with bigint',
-      type: 'array',
-      items: {
-        type: 'integer'
-      }
-    }
-
-    const stringify = build(schema)
-    const output = stringify([1615n])
-
-    t.equal(output, '[1615]')
-  })
-
-  test('render an object with an additionalProperty of type bigint as JSON', (t) => {
-    t.plan(1)
-
-    const schema = {
-      title: 'object with bigint',
-      type: 'object',
-      additionalProperties: {
-        type: 'integer'
-      }
-    }
-
-    const stringify = build(schema)
-    const output = stringify({
-      num: 1615n
-    })
-
-    t.equal(output, '{"num":1615}')
-  })
-}