fast-json-stringify 2.5.1 → 2.6.0

package/.github/workflows/ci.yml

@@ -1,27 +1,43 @@
-name: CI workflow
-on: [push, pull_request]
+name: CI
+
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+
 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         node-version: [10.x, 12.x, 13.x, 14.x]
+        os: [macos-latest, ubuntu-latest, windows-latest]
+
     steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2.1.5
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: Install Dependencies
-      run: npm install --ignore-scripts
-    - name: Test
-      run: npm run test
+      - uses: actions/checkout@v2
+
+      - name: Use Node.js
+        uses: actions/setup-node@v2.1.5
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install Dependencies
+        run: |
+          npm install --ignore-scripts
+
+      - name: Run Tests
+        run: |
+          npm run test
 
   automerge:
     needs: test
     runs-on: ubuntu-latest
     steps:
-      - uses: fastify/github-action-merge-dependabot@v1.2.1
-        if: ${{ github.actor == 'dependabot[bot]' && github.event_name == 'pull_request' }}
+      - uses: fastify/github-action-merge-dependabot@v2.0.0
         with:
-          github-token: ${{secrets.github_token}}
+          github-token: ${{ secrets.GITHUB_TOKEN }}

package/.taprc

@@ -1,4 +1,3 @@
-esm: false
 ts: false
 jsx: false
 coverage: false

package/README.md

@@ -1,7 +1,9 @@
 # fast-json-stringify
 
-[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)
-![Ci Workflow](https://github.com/fastify/fast-json-stringify/workflows/CI%20workflow/badge.svg)
+![CI](https://github.com/fastify/fast-json-stringify/workflows/CI/badge.svg)
+[![NPM version](https://img.shields.io/npm/v/fast-json-stringify.svg?style=flat)](https://www.npmjs.com/package/fast-json-stringify)
+[![Known Vulnerabilities](https://snyk.io/test/github/fastify/fast-json-stringify/badge.svg)](https://snyk.io/test/github/fastify/fast-json-stringify)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
 [![NPM downloads](https://img.shields.io/npm/dm/fast-json-stringify.svg?style=flat)](https://www.npmjs.com/package/fast-json-stringify)
 
 
@@ -106,7 +108,7 @@ const stringify = fastJson(mySchema, {
 <a name="fastJsonStringify"></a>
 ### fastJsonStringify(schema)
 
-Build a `stringify()` function based on [jsonschema](http://json-schema.org/).
+Build a `stringify()` function based on [jsonschema](https://json-schema.org/).
 
 Supported types:
 
@@ -399,7 +401,7 @@ console.log(stringify({
 })) // {"kind":"foobar","foo":"FOO","bar":42}
 ```
 
-**NB:** don't declare the properties twice or you'll print them twice!
+**NB** Do not declare the properties twice or you will print them twice!
 
 <a name="ref"></a>
 #### Reuse - $ref
@@ -514,7 +516,7 @@ const stringify = fastJson(schema, { schema: externalSchema })
 
 <a name="long"></a>
 #### Long integers
-By default the library will handle automatically [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) from Node.js v10.3 and above.
+By default the library will automatically handle [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) from Node.js v10.3 and above.
 If you can't use BigInts in your environment, long integers (64-bit) are also supported using the [long](https://github.com/dcodeIO/long.js) module.
 Example:
 ```javascript
@@ -641,7 +643,7 @@ console.log(stringify({ firstName: 'Foo', surname: 'bar' })) // '{"firstName":"F
 <a name="acknowledgements"></a>
 ## Acknowledgements
 
-This project was kindly sponsored by [nearForm](http://nearform.com).
+This project was kindly sponsored by [nearForm](https://nearform.com).
 
 <a name="license"></a>
 ## License

package/example.js

@@ -1,7 +1,5 @@
-'use strict'
-
 const moment = require('moment')
-const fastJson = require('.')
+const fastJson = require('fast-json-stringify')
 const stringify = fastJson({
   title: 'Example Schema',
   type: 'object',

package/index.js

@@ -132,6 +132,7 @@ function build (schema, options) {
     case 'array':
       main = '$main'
       code = buildArray(location, code, main)
+      schema = location.schema
       break
     case undefined:
       main = '$asAny'
@@ -145,13 +146,8 @@ function build (schema, options) {
      return ${main}
   `
 
-  const dependencies = []
-  const dependenciesName = []
-  if (dependsOnAjv(schema)) {
-    dependencies.push(new Ajv(options.ajv))
-    dependenciesName.push('ajv')
-  }
-
+  const dependencies = [new Ajv(options.ajv)]
+  const dependenciesName = ['ajv']
   dependenciesName.push(code)
 
   if (options.debugMode) {
@@ -222,11 +218,6 @@ function inferTypeByKeyword (schema) {
   return schema.type
 }
 
-function dependsOnAjv (schema) {
-  const str = JSON.stringify(schema)
-  return (/"if":{.*"then":{|"(anyOf|oneOf)":\[|"const":/.test(str))
-}
-
 const stringSerializerMap = {
   'date-time': '$asDatetime',
   date: '$asDate',
@@ -957,7 +948,7 @@ function buildObject (location, code, name) {
 }
 
 function buildArray (location, code, name, key = null) {
-  const schema = location.schema
+  let schema = location.schema
   code += `
     function ${name} (obj) {
   `
@@ -979,6 +970,11 @@ function buildArray (location, code, name, key = null) {
   }
 
   if (schema.items.$ref) {
+    if (!schema[fjsCloned]) {
+      location.schema = clone(location.schema)
+      schema = location.schema
+      schema[fjsCloned] = true
+    }
     location = refFinder(schema.items.$ref, location)
     schema.items = location.schema
   }
@@ -1215,7 +1211,7 @@ function nested (laterCode, name, key, location, subKey, isArray) {
         `
       } else if ('const' in schema) {
         code += `
-          if(ajv.validate(${require('util').inspect(schema, { depth: null, showHidden: false })}, obj${accessor}))
+          if(ajv.validate(${JSON.stringify(schema)}, obj${accessor}))
             json += '${JSON.stringify(schema.const)}'
           else
             throw new Error(\`Item $\{JSON.stringify(obj${accessor})} does not match schema definition.\`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -40,7 +40,7 @@
     "proxyquire": "^2.1.3",
     "semver": "^7.1.0",
     "standard": "^16.0.1",
-    "tap": "^14.0.0",
+    "tap": "^15.0.0",
     "typescript": "^4.0.2"
   },
   "dependencies": {

package/test/allof.test.js

@@ -44,7 +44,7 @@ test('object with allOf and multiple schema on the allOf', (t) => {
       id: 1
     })
   } catch (e) {
-    t.is(e.message, '"name" is required!')
+    t.equal(e.message, '"name" is required!')
   }
 
   try {
@@ -52,15 +52,15 @@ test('object with allOf and multiple schema on the allOf', (t) => {
       name: 'string'
     })
   } catch (e) {
-    t.is(e.message, '"id" is required!')
+    t.equal(e.message, '"id" is required!')
   }
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1,
     name: 'string'
   }), '{"name":"string","id":1}')
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1,
     name: 'string',
     tag: 'otherString'
@@ -92,7 +92,7 @@ test('object with allOf and one schema on the allOf', (t) => {
   const value = stringify({
     id: 1
   })
-  t.is(value, '{"id":1}')
+  t.equal(value, '{"id":1}')
 })
 
 test('object with allOf and no schema on the allOf', (t) => {
@@ -108,7 +108,7 @@ test('object with allOf and no schema on the allOf', (t) => {
     build(schema)
     t.fail()
   } catch (e) {
-    t.is(e.message, 'schema is invalid: data.allOf should NOT have fewer than 1 items')
+    t.equal(e.message, 'schema is invalid: data.allOf should NOT have fewer than 1 items')
   }
 })
 
@@ -160,7 +160,7 @@ test('object with nested allOfs', (t) => {
     id3: 3,
     id4: 4 // extra prop shouldn't be in result
   })
-  t.is(value, '{"id1":1,"id2":2,"id3":3}')
+  t.equal(value, '{"id1":1,"id2":2,"id3":3}')
 })
 
 test('object with $ref in allOf', (t) => {
@@ -191,7 +191,7 @@ test('object with $ref in allOf', (t) => {
     id1: 1,
     id2: 2 // extra prop shouldn't be in result
   })
-  t.is(value, '{"id1":1}')
+  t.equal(value, '{"id1":1}')
 })
 
 test('object with $ref and other object in allOf', (t) => {
@@ -231,7 +231,7 @@ test('object with $ref and other object in allOf', (t) => {
     id2: 2,
     id3: 3 // extra prop shouldn't be in result
   })
-  t.is(value, '{"id1":1,"id2":2}')
+  t.equal(value, '{"id1":1,"id2":2}')
 })
 
 test('object with multiple $refs in allOf', (t) => {
@@ -274,7 +274,7 @@ test('object with multiple $refs in allOf', (t) => {
     id2: 2,
     id3: 3 // extra prop shouldn't be in result
   })
-  t.is(value, '{"id1":1,"id2":2}')
+  t.equal(value, '{"id1":1,"id2":2}')
 })
 
 test('object with external $refs in allOf', (t) => {
@@ -325,5 +325,5 @@ test('object with external $refs in allOf', (t) => {
     id2: 2,
     id3: 3 // extra prop shouldn't be in result
   })
-  t.is(value, '{"id1":1,"id2":2}')
+  t.equal(value, '{"id1":1,"id2":2}')
 })

package/test/any.test.js

@@ -16,19 +16,19 @@ test('object with nested random property', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1, name: 'string'
   }), '{"id":1,"name":"string"}')
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1, name: { first: 'name', last: 'last' }
   }), '{"id":1,"name":{"first":"name","last":"last"}}')
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1, name: null
   }), '{"id":1,"name":null}')
 
-  t.is(stringify({
+  t.equal(stringify({
     id: 1, name: ['first', 'last']
   }), '{"id":1,"name":["first","last"]}')
 })
@@ -45,7 +45,7 @@ test('object with empty schema with $id: undefined set', (t) => {
     }
   }
   const stringify = build(schema)
-  t.is(stringify({
+  t.equal(stringify({
     name: 'string'
   }), '{"name":"string"}')
 })
@@ -61,7 +61,7 @@ test('array with random items', (t) => {
   const stringify = build(schema)
 
   const value = stringify([1, 'string', null])
-  t.is(value, '[1,"string",null]')
+  t.equal(value, '[1,"string",null]')
 })
 
 test('empty schema', (t) => {
@@ -71,13 +71,13 @@ test('empty schema', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify(null), 'null')
-  t.is(stringify(1), '1')
-  t.is(stringify(true), 'true')
-  t.is(stringify('hello'), '"hello"')
-  t.is(stringify({}), '{}')
-  t.is(stringify({ x: 10 }), '{"x":10}')
-  t.is(stringify([true, 1, 'hello']), '[true,1,"hello"]')
+  t.equal(stringify(null), 'null')
+  t.equal(stringify(1), '1')
+  t.equal(stringify(true), 'true')
+  t.equal(stringify('hello'), '"hello"')
+  t.equal(stringify({}), '{}')
+  t.equal(stringify({ x: 10 }), '{"x":10}')
+  t.equal(stringify([true, 1, 'hello']), '[true,1,"hello"]')
 })
 
 test('empty schema on nested object', (t) => {
@@ -92,13 +92,13 @@ test('empty schema on nested object', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ x: null }), '{"x":null}')
-  t.is(stringify({ x: 1 }), '{"x":1}')
-  t.is(stringify({ x: true }), '{"x":true}')
-  t.is(stringify({ x: 'hello' }), '{"x":"hello"}')
-  t.is(stringify({ x: {} }), '{"x":{}}')
-  t.is(stringify({ x: { x: 10 } }), '{"x":{"x":10}}')
-  t.is(stringify({ x: [true, 1, 'hello'] }), '{"x":[true,1,"hello"]}')
+  t.equal(stringify({ x: null }), '{"x":null}')
+  t.equal(stringify({ x: 1 }), '{"x":1}')
+  t.equal(stringify({ x: true }), '{"x":true}')
+  t.equal(stringify({ x: 'hello' }), '{"x":"hello"}')
+  t.equal(stringify({ x: {} }), '{"x":{}}')
+  t.equal(stringify({ x: { x: 10 } }), '{"x":{"x":10}}')
+  t.equal(stringify({ x: [true, 1, 'hello'] }), '{"x":[true,1,"hello"]}')
 })
 
 test('empty schema on array', (t) => {
@@ -111,7 +111,7 @@ test('empty schema on array', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify([1, true, 'hello', [], { x: 1 }]), '[1,true,"hello",[],{"x":1}]')
+  t.equal(stringify([1, true, 'hello', [], { x: 1 }]), '[1,true,"hello",[],{"x":1}]')
 })
 
 test('empty schema on anyOf', (t) => {
@@ -147,8 +147,8 @@ test('empty schema on anyOf', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ kind: 'Bar', value: 1 }), '{"kind":"Bar","value":1}')
-  t.is(stringify({ kind: 'Foo', value: 1 }), '{"kind":"Foo","value":1}')
-  t.is(stringify({ kind: 'Foo', value: true }), '{"kind":"Foo","value":true}')
-  t.is(stringify({ kind: 'Foo', value: 'hello' }), '{"kind":"Foo","value":"hello"}')
+  t.equal(stringify({ kind: 'Bar', value: 1 }), '{"kind":"Bar","value":1}')
+  t.equal(stringify({ kind: 'Foo', value: 1 }), '{"kind":"Foo","value":1}')
+  t.equal(stringify({ kind: 'Foo', value: true }), '{"kind":"Foo","value":true}')
+  t.equal(stringify({ kind: 'Foo', value: 'hello' }), '{"kind":"Foo","value":"hello"}')
 })

package/test/anyof.test.js

@@ -21,11 +21,11 @@ test('object with multiple types field', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     str: 'string'
   }), '{"str":"string"}')
 
-  t.is(stringify({
+  t.equal(stringify({
     str: true
   }), '{"str":true}')
 })
@@ -53,11 +53,11 @@ test('object with field of type object or null', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: null
   }), '{"prop":null}')
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: {
       str: 'string'
     }
@@ -87,13 +87,13 @@ test('object with field of type object or array', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: {
       str: 'string'
     }
   }), '{"prop":{"str":"string"}}')
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: ['string']
   }), '{"prop":["string"]}')
 })
@@ -117,7 +117,7 @@ test('object with field of type string and coercion disable ', (t) => {
   const value = stringify({
     str: 1
   })
-  t.is(value, '{"str":null}')
+  t.equal(value, '{"str":null}')
 })
 
 test('object with field of type string and coercion enable ', (t) => {
@@ -145,7 +145,7 @@ test('object with field of type string and coercion enable ', (t) => {
   const value = stringify({
     str: 1
   })
-  t.is(value, '{"str":"1"}')
+  t.equal(value, '{"str":"1"}')
 })
 
 test('object with field with type union of multiple objects', (t) => {
@@ -179,9 +179,9 @@ test('object with field with type union of multiple objects', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ anyOfSchema: { baz: 5 } }), '{"anyOfSchema":{"baz":5}}')
+  t.equal(stringify({ anyOfSchema: { baz: 5 } }), '{"anyOfSchema":{"baz":5}}')
 
-  t.is(stringify({ anyOfSchema: { bar: 'foo' } }), '{"anyOfSchema":{"bar":"foo"}}')
+  t.equal(stringify({ anyOfSchema: { bar: 'foo' } }), '{"anyOfSchema":{"bar":"foo"}}')
 })
 
 test('null value in schema', (t) => {
@@ -221,10 +221,10 @@ test('symbol value in schema', (t) => {
   }
 
   const stringify = build(schema)
-  t.is(stringify({ value: 'foo' }), '{"value":"foo"}')
-  t.is(stringify({ value: 'bar' }), '{"value":"bar"}')
-  t.is(stringify({ value: 'baz' }), '{"value":"baz"}')
-  t.is(stringify({ value: 'qux' }), '{"value":null}')
+  t.equal(stringify({ value: 'foo' }), '{"value":"foo"}')
+  t.equal(stringify({ value: 'bar' }), '{"value":"bar"}')
+  t.equal(stringify({ value: 'baz' }), '{"value":"baz"}')
+  t.equal(stringify({ value: 'qux' }), '{"value":null}')
 })
 
 test('anyOf and $ref together', (t) => {
@@ -253,9 +253,9 @@ test('anyOf and $ref together', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ cs: 'franco' }), '{"cs":"franco"}')
+  t.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}')
 
-  t.is(stringify({ cs: true }), '{"cs":true}')
+  t.equal(stringify({ cs: true }), '{"cs":true}')
 })
 
 test('anyOf and $ref: 2 levels are fine', (t) => {
@@ -291,7 +291,7 @@ test('anyOf and $ref: 2 levels are fine', (t) => {
 
   const stringify = build(schema)
   const value = stringify({ cs: 3 })
-  t.is(value, '{"cs":3}')
+  t.equal(value, '{"cs":3}')
 })
 
 test('anyOf and $ref: multiple levels should throw at build.', (t) => {
@@ -330,9 +330,9 @@ test('anyOf and $ref: multiple levels should throw at build.', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ cs: 3 }), '{"cs":3}')
-  t.is(stringify({ cs: true }), '{"cs":true}')
-  t.is(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
+  t.equal(stringify({ cs: 3 }), '{"cs":3}')
+  t.equal(stringify({ cs: true }), '{"cs":true}')
+  t.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
 })
 
 test('anyOf and $ref - multiple external $ref', (t) => {
@@ -423,7 +423,7 @@ test('anyOf looks for all of the array items', (t) => {
   const stringify = build(schema)
 
   const value = stringify([{ savedId: 'great' }, { error: 'oops' }])
-  t.is(value, '[{"savedId":"great"},{"error":"oops"}]')
+  t.equal(value, '[{"savedId":"great"},{"error":"oops"}]')
 })
 
 test('anyOf with enum with more than 100 entries', (t) => {
@@ -445,5 +445,5 @@ test('anyOf with enum with more than 100 entries', (t) => {
   const stringify = build(schema)
 
   const value = stringify(['EUR', 'USD', null])
-  t.is(value, '["EUR","USD",null]')
+  t.equal(value, '["EUR","USD",null]')
 })

package/test/array.test.js

@@ -13,7 +13,7 @@ function buildTest (schema, toStringify) {
     const stringify = build(schema)
     const output = stringify(toStringify)
 
-    t.deepEqual(JSON.parse(output), toStringify)
+    t.same(JSON.parse(output), toStringify)
     t.equal(output, JSON.stringify(toStringify))
     t.ok(validate(JSON.parse(output)), 'valid schema')
   })
@@ -195,7 +195,7 @@ test('moment array', (t) => {
   const value = stringify({
     times: [moment('2018-04-21T07:52:31.017Z')]
   })
-  t.is(value, '{"times":["2018-04-21T07:52:31.017Z"]}')
+  t.equal(value, '{"times":["2018-04-21T07:52:31.017Z"]}')
 })
 
 buildTest({
@@ -254,5 +254,5 @@ test('object array with anyOf and symbol', (t) => {
     { name: 'name-0', option: 'Foo' },
     { name: 'name-1', option: 'Bar' }
   ])
-  t.is(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]')
+  t.equal(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]')
 })

package/test/basic.test.js

@@ -12,7 +12,7 @@ function buildTest (schema, toStringify) {
     const stringify = build(schema)
     const output = stringify(toStringify)
 
-    t.deepEqual(JSON.parse(output), toStringify)
+    t.same(JSON.parse(output), toStringify)
     t.equal(output, JSON.stringify(toStringify))
     t.ok(validate(JSON.parse(output)), 'valid schema')
   })
@@ -280,14 +280,14 @@ test('skip or coerce numbers and integers that are not numbers', (t) => {
     distance: 'long'
   })
 
-  t.deepEqual(JSON.parse(result), {})
+  t.same(JSON.parse(result), {})
 
   result = stringify({
     age: '42',
     distance: true
   })
 
-  t.deepEqual(JSON.parse(result), { age: 42, distance: 1 })
+  t.same(JSON.parse(result), { age: 42, distance: 1 })
   t.end()
 })
 

package/test/debug-mode.test.js

@@ -20,14 +20,14 @@ test('activate debug mode', t => {
   t.plan(2)
   const debugMode = build({ debugMode: true })
   t.type(debugMode, Array)
-  t.like(debugMode.toString.toString(), 'join', 'to string override')
+  t.match(debugMode.toString.toString(), 'join', 'to string override')
 })
 
 test('activate debug mode truthy', t => {
   t.plan(2)
   const debugMode = build({ debugMode: 'yes' })
   t.type(debugMode, Array)
-  t.like(debugMode.toString.toString(), 'join', 'to string override')
+  t.match(debugMode.toString.toString(), 'join', 'to string override')
 })
 
 test('to string auto-consistent', t => {
@@ -38,7 +38,7 @@ test('to string auto-consistent', t => {
   const str = debugMode.toString()
   const compiled = fjs.restore(str)
   const tobe = JSON.stringify({ firstName: 'Foo' })
-  t.deepEquals(compiled({ firstName: 'Foo', surname: 'bar' }), tobe, 'surname evicted')
+  t.same(compiled({ firstName: 'Foo', surname: 'bar' }), tobe, 'surname evicted')
 })
 
 test('to string auto-consistent with ajv', t => {
@@ -61,5 +61,5 @@ test('to string auto-consistent with ajv', t => {
   const str = debugMode.toString()
   const compiled = fjs.restore(str)
   const tobe = JSON.stringify({ str: 'Foo' })
-  t.deepEquals(compiled({ str: 'Foo', void: 'me' }), tobe)
+  t.same(compiled({ str: 'Foo', void: 'me' }), tobe)
 })

package/test/defaults.test.js

@@ -11,7 +11,7 @@ function buildTest (schema, toStringify, expected) {
 
     const output = stringify(toStringify)
 
-    t.strictEqual(output, JSON.stringify(expected))
+    t.equal(output, JSON.stringify(expected))
   })
 }
 

package/test/inferType.test.js

@@ -12,7 +12,7 @@ function buildTest (schema, toStringify) {
     const stringify = build(schema)
     const output = stringify(toStringify)
 
-    t.deepEqual(JSON.parse(output), toStringify)
+    t.same(JSON.parse(output), toStringify)
     t.equal(output, JSON.stringify(toStringify))
     t.ok(validate(JSON.parse(output)), 'valid schema')
   })

package/test/integer.test.js

@@ -32,7 +32,7 @@ test('render a float as an integer', (t) => {
     }, { rounding: 'foobar' })
   } catch (error) {
     t.ok(error)
-    t.equals(error.message, 'Unsupported integer rounding method foobar')
+    t.equal(error.message, 'Unsupported integer rounding method foobar')
   }
 })
 

package/test/nestedObjects.test.js

@@ -28,5 +28,5 @@ test('nested objects with same properties', (t) => {
       numberProperty: 42
     }
   })
-  t.is(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}')
+  t.equal(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}')
 })

package/test/nullable.test.js

@@ -108,6 +108,6 @@ Object.keys(testSet).forEach(key => {
     const data = testSet[key][1]
     const expected = testSet[key][2]
     const result = stringifier(data)
-    t.deepEqual(JSON.parse(result), expected)
+    t.same(JSON.parse(result), expected)
   })
 })

package/test/oneof.test.js

@@ -21,8 +21,8 @@ test('object with multiple types field', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({ str: 'string' }), '{"str":"string"}')
-  t.is(stringify({ str: true }), '{"str":true}')
+  t.equal(stringify({ str: 'string' }), '{"str":"string"}')
+  t.equal(stringify({ str: true }), '{"str":true}')
 })
 
 test('object with field of type object or null', (t) => {
@@ -48,9 +48,9 @@ test('object with field of type object or null', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({ prop: null }), '{"prop":null}')
+  t.equal(stringify({ prop: null }), '{"prop":null}')
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: {
       str: 'string', remove: 'this'
     }
@@ -80,11 +80,11 @@ test('object with field of type object or array', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: { str: 'string' }
   }), '{"prop":{"str":"string"}}')
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: ['string']
   }), '{"prop":["string"]}')
 })
@@ -108,7 +108,7 @@ test('object with field of type string and coercion disable ', (t) => {
   const value = stringify({
     str: 1
   })
-  t.is(value, '{"str":null}')
+  t.equal(value, '{"str":null}')
 })
 
 test('object with field of type string and coercion enable ', (t) => {
@@ -136,7 +136,7 @@ test('object with field of type string and coercion enable ', (t) => {
   const value = stringify({
     str: 1
   })
-  t.is(value, '{"str":"1"}')
+  t.equal(value, '{"str":"1"}')
 })
 
 test('object with field with type union of multiple objects', (t) => {
@@ -170,9 +170,9 @@ test('object with field with type union of multiple objects', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
+  t.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
 
-  t.is(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
+  t.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
 })
 
 test('null value in schema', (t) => {
@@ -214,9 +214,9 @@ test('oneOf and $ref together', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ cs: 'franco' }), '{"cs":"franco"}')
+  t.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}')
 
-  t.is(stringify({ cs: true }), '{"cs":true}')
+  t.equal(stringify({ cs: true }), '{"cs":true}')
 })
 
 test('oneOf and $ref: 2 levels are fine', (t) => {
@@ -254,7 +254,7 @@ test('oneOf and $ref: 2 levels are fine', (t) => {
   const value = stringify({
     cs: 3
   })
-  t.is(value, '{"cs":3}')
+  t.equal(value, '{"cs":3}')
 })
 
 test('oneOf and $ref: multiple levels should throw at build.', (t) => {
@@ -293,9 +293,9 @@ test('oneOf and $ref: multiple levels should throw at build.', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ cs: 3 }), '{"cs":3}')
-  t.is(stringify({ cs: true }), '{"cs":true}')
-  t.is(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
+  t.equal(stringify({ cs: 3 }), '{"cs":3}')
+  t.equal(stringify({ cs: true }), '{"cs":true}')
+  t.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
 })
 
 test('oneOf and $ref - multiple external $ref', (t) => {
@@ -373,5 +373,5 @@ test('oneOf with enum with more than 100 entries', (t) => {
   const stringify = build(schema)
 
   const value = stringify(['EUR', 'USD', null])
-  t.is(value, '["EUR","USD",null]')
+  t.equal(value, '["EUR","USD",null]')
 })

package/test/ref.test.js

@@ -1026,7 +1026,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "porjectId", did you mean "projectId"?')
+      t.equal(err.message, 'Cannot find reference "porjectId", did you mean "projectId"?')
     }
   })
 
@@ -1051,7 +1051,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "foobar"')
+      t.equal(err.message, 'Cannot find reference "foobar"')
     }
   })
 
@@ -1081,7 +1081,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "porjectId", did you mean "projectId"?')
+      t.equal(err.message, 'Cannot find reference "porjectId", did you mean "projectId"?')
     }
   })
 
@@ -1111,7 +1111,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "foobar"')
+      t.equal(err.message, 'Cannot find reference "foobar"')
     }
   })
 
@@ -1141,7 +1141,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "deifnitions", did you mean "definitions"?')
+      t.equal(err.message, 'Cannot find reference "deifnitions", did you mean "definitions"?')
     }
   })
 
@@ -1166,7 +1166,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "deifnitions", did you mean "definitions"?')
+      t.equal(err.message, 'Cannot find reference "deifnitions", did you mean "definitions"?')
     }
   })
 
@@ -1196,9 +1196,56 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "extrenal", did you mean "external"?')
+      t.equal(err.message, 'Cannot find reference "extrenal", did you mean "external"?')
     }
   })
 
   t.end()
 })
+
+test('Regression 2.5.2', t => {
+  t.plan(1)
+
+  const externalSchema = {
+    '/models/Bar': {
+      $id: '/models/Bar',
+      $schema: 'http://json-schema.org/schema#',
+      definitions: {
+        entity: {
+          type: 'object',
+          properties: { field: { type: 'string' } }
+        }
+      }
+    },
+    '/models/Foo': {
+      $id: '/models/Foo',
+      $schema: 'http://json-schema.org/schema#',
+      definitions: {
+        entity: {
+          type: 'object',
+          properties: {
+            field: { type: 'string' },
+            sub: {
+              oneOf: [
+                { $ref: '/models/Bar#/definitions/entity' },
+                { type: 'null' }
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const schema = {
+    type: 'array',
+    items: {
+      $ref: '/models/Foo#/definitions/entity'
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchema })
+  const output = stringify([{ field: 'parent', sub: { field: 'joined' } }])
+
+  t.equal(output, '[{"field":"parent","sub":{"field":"joined"}}]')
+})

package/test/required.test.js

@@ -32,7 +32,7 @@ test('object with required field', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"str" is required!')
+    t.equal(e.message, '"str" is required!')
     t.pass()
   }
 })
@@ -56,7 +56,7 @@ test('object with required field not in properties schema', (t) => {
     stringify({})
     t.fail()
   } catch (e) {
-    t.is(e.message, '"str" is required!')
+    t.equal(e.message, '"str" is required!')
     t.pass()
   }
 
@@ -66,7 +66,7 @@ test('object with required field not in properties schema', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"str" is required!')
+    t.equal(e.message, '"str" is required!')
     t.pass()
   }
 })
@@ -91,7 +91,7 @@ test('object with required field not in properties schema with additional proper
     stringify({})
     t.fail()
   } catch (e) {
-    t.is(e.message, '"str" is required!')
+    t.equal(e.message, '"str" is required!')
     t.pass()
   }
 
@@ -101,7 +101,7 @@ test('object with required field not in properties schema with additional proper
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"str" is required!')
+    t.equal(e.message, '"str" is required!')
     t.pass()
   }
 })
@@ -126,7 +126,7 @@ test('object with multiple required field not in properties schema', (t) => {
     stringify({})
     t.fail()
   } catch (e) {
-    t.is(e.message, '"num" is required!')
+    t.equal(e.message, '"num" is required!')
     t.pass()
   }
 
@@ -136,7 +136,7 @@ test('object with multiple required field not in properties schema', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"key1" is required!')
+    t.equal(e.message, '"key1" is required!')
     t.pass()
   }
 
@@ -147,7 +147,7 @@ test('object with multiple required field not in properties schema', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"key2" is required!')
+    t.equal(e.message, '"key2" is required!')
     t.pass()
   }
 })
@@ -172,7 +172,7 @@ test('object with required bool', (t) => {
     stringify({})
     t.fail()
   } catch (e) {
-    t.is(e.message, '"bool" is required!')
+    t.equal(e.message, '"bool" is required!')
     t.pass()
   }
 
@@ -232,7 +232,7 @@ test('required numbers', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"num" is required!')
+    t.equal(e.message, '"num" is required!')
     t.pass()
   }
 })

package/test/requiresAjv.test.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const t = require('tap')
+const build = require('..')
+
+t.test('nested ref requires ajv', async t => {
+  const schemaA = {
+    $id: 'urn:schema:a',
+    definitions: {
+      foo: { anyOf: [{ type: 'string' }, { type: 'null' }] }
+    }
+  }
+
+  const schemaB = {
+    $id: 'urn:schema:b',
+    type: 'object',
+    properties: {
+      results: {
+        type: 'object',
+        properties: {
+          items: {
+            type: 'object',
+            properties: {
+              bar: {
+                type: 'array',
+                items: { $ref: 'urn:schema:a#/definitions/foo' }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const stringify = build(schemaB, {
+    schema: {
+      [schemaA.$id]: schemaA
+    }
+  })
+  const result = stringify({
+    results: {
+      items: {
+        bar: ['baz']
+      }
+    }
+  })
+  t.same(result, '{"results":{"items":{"bar":["baz"]}}}')
+})

package/test/sanitize.test.js

@@ -105,7 +105,7 @@ const stringify2 = build({
   }
 })
 
-t.deepEqual(JSON.parse(stringify2({
+t.same(JSON.parse(stringify2({
   '"\'phra////': 42,
   asd: 42
 })), {
@@ -135,7 +135,7 @@ const stringify4 = build({
   }
 })
 
-t.deepEqual(JSON.parse(stringify4({})), {
+t.same(JSON.parse(stringify4({})), {
   '"\\\\\\\\\'w00t': '"\'w00t'
 })
 

package/test/side-effect.test.js

@@ -32,8 +32,8 @@ test('oneOf with $ref should not change the input schema', t => {
   })
 
   const value = stringify({ people: { name: 'hello', foo: 'bar' } })
-  t.is(value, '{"people":{"name":"hello"}}')
-  t.deepEqual(schema, clonedSchema)
+  t.equal(value, '{"people":{"name":"hello"}}')
+  t.same(schema, clonedSchema)
 })
 
 test('oneOf and anyOf with $ref should not change the input schema', t => {
@@ -77,7 +77,7 @@ test('oneOf and anyOf with $ref should not change the input schema', t => {
 
   t.equal(valueAny1, '{"people":{"name":"hello"},"love":"music"}')
   t.equal(valueAny2, '{"people":{"name":"hello"},"love":true}')
-  t.deepEqual(schema, clonedSchema)
+  t.same(schema, clonedSchema)
 })
 
 test('multiple $ref tree', t => {
@@ -118,6 +118,40 @@ test('multiple $ref tree', t => {
   })
 
   const value = stringify({ people: { name: 'hello', foo: 'bar', age: 42 } })
-  t.is(value, '{"people":{"name":"hello","age":42}}')
-  t.deepEqual(schema, clonedSchema)
+  t.equal(value, '{"people":{"name":"hello","age":42}}')
+  t.same(schema, clonedSchema)
+})
+
+test('must not mutate items $ref', t => {
+  t.plan(2)
+
+  const referenceSchema = {
+    $id: 'ShowSchema',
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string'
+      }
+    }
+  }
+
+  const schema = {
+    $id: 'ListSchema',
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'array',
+    items: {
+      $ref: 'ShowSchema#'
+    }
+  }
+  const clonedSchema = clone(schema)
+  const stringify = build(schema, {
+    schema: {
+      [referenceSchema.$id]: referenceSchema
+    }
+  })
+
+  const value = stringify([{ name: 'foo' }])
+  t.equal(value, '[{"name":"foo"}]')
+  t.same(schema, clonedSchema)
 })

package/test/typesArray.test.js

@@ -22,7 +22,7 @@ test('possibly nullable integer primitive alternative', (t) => {
   const value = stringify({
     data: 4
   })
-  t.is(value, '{"data":4}')
+  t.equal(value, '{"data":4}')
 })
 
 test('possibly nullable number primitive alternative', (t) => {
@@ -43,7 +43,7 @@ test('possibly nullable number primitive alternative', (t) => {
   const value = stringify({
     data: 4
   })
-  t.is(value, '{"data":4}')
+  t.equal(value, '{"data":4}')
 })
 
 test('possibly nullable integer primitive alternative with null value', (t) => {
@@ -64,7 +64,7 @@ test('possibly nullable integer primitive alternative with null value', (t) => {
   const value = stringify({
     data: null
   })
-  t.is(value, '{"data":0}')
+  t.equal(value, '{"data":0}')
 })
 
 test('possibly nullable number primitive alternative with null value', (t) => {
@@ -85,7 +85,7 @@ test('possibly nullable number primitive alternative with null value', (t) => {
   const value = stringify({
     data: null
   })
-  t.is(value, '{"data":0}')
+  t.equal(value, '{"data":0}')
 })
 
 test('nullable integer primitive', (t) => {
@@ -106,7 +106,7 @@ test('nullable integer primitive', (t) => {
   const value = stringify({
     data: 4
   })
-  t.is(value, '{"data":4}')
+  t.equal(value, '{"data":4}')
 })
 
 test('nullable number primitive', (t) => {
@@ -127,7 +127,7 @@ test('nullable number primitive', (t) => {
   const value = stringify({
     data: 4
   })
-  t.is(value, '{"data":4}')
+  t.equal(value, '{"data":4}')
 })
 
 test('nullable primitive with null value', (t) => {
@@ -148,7 +148,7 @@ test('nullable primitive with null value', (t) => {
   const value = stringify({
     data: null
   })
-  t.is(value, '{"data":null}')
+  t.equal(value, '{"data":null}')
 })
 
 test('nullable number primitive with null value', (t) => {
@@ -169,7 +169,7 @@ test('nullable number primitive with null value', (t) => {
   const value = stringify({
     data: null
   })
-  t.is(value, '{"data":null}')
+  t.equal(value, '{"data":null}')
 })
 
 test('possibly null object with multi-type property', (t) => {
@@ -191,19 +191,19 @@ test('possibly null object with multi-type property', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     objectOrNull: {
       stringOrNumber: 'string'
     }
   }), '{"objectOrNull":{"stringOrNumber":"string"}}')
 
-  t.is(stringify({
+  t.equal(stringify({
     objectOrNull: {
       stringOrNumber: 42
     }
   }), '{"objectOrNull":{"stringOrNumber":42}}')
 
-  t.is(stringify({
+  t.equal(stringify({
     objectOrNull: null
   }), '{"objectOrNull":null}')
 })
@@ -229,7 +229,7 @@ test('object with possibly null array of multiple types', (t) => {
     const value = stringify({
       arrayOfStringsAndNumbers: null
     })
-    t.is(value, '{"arrayOfStringsAndNumbers":null}')
+    t.equal(value, '{"arrayOfStringsAndNumbers":null}')
   } catch (e) {
     console.log(e)
     t.fail()
@@ -239,21 +239,21 @@ test('object with possibly null array of multiple types', (t) => {
     const value = stringify({
       arrayOfStringsAndNumbers: ['string1', 'string2']
     })
-    t.is(value, '{"arrayOfStringsAndNumbers":["string1","string2"]}')
+    t.equal(value, '{"arrayOfStringsAndNumbers":["string1","string2"]}')
   } catch (e) {
     console.log(e)
     t.fail()
   }
 
-  t.is(stringify({
+  t.equal(stringify({
     arrayOfStringsAndNumbers: [42, 7]
   }), '{"arrayOfStringsAndNumbers":[42,7]}')
 
-  t.is(stringify({
+  t.equal(stringify({
     arrayOfStringsAndNumbers: ['string1', 42, 7, 'string2']
   }), '{"arrayOfStringsAndNumbers":["string1",42,7,"string2"]}')
 
-  t.is(stringify({
+  t.equal(stringify({
     arrayOfStringsAndNumbers: ['string1', null, 42, 7, 'string2', null]
   }), '{"arrayOfStringsAndNumbers":["string1",null,42,7,"string2",null]}')
 })
@@ -287,7 +287,7 @@ test('object with tuple of multiple types', (t) => {
     const value = stringify({
       fixedTupleOfStringsAndNumbers: ['string1', 42, 7]
     })
-    t.is(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,7]}')
+    t.equal(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,7]}')
   } catch (e) {
     console.log(e)
     t.fail()
@@ -297,7 +297,7 @@ test('object with tuple of multiple types', (t) => {
     const value = stringify({
       fixedTupleOfStringsAndNumbers: ['string1', 42, 'string2']
     })
-    t.is(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,"string2"]}')
+    t.equal(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,"string2"]}')
   } catch (e) {
     console.log(e)
     t.fail()
@@ -334,17 +334,17 @@ test('object with anyOf and multiple types', (t) => {
     const value = stringify({
       objectOrBoolean: { stringOrNumber: 'string' }
     })
-    t.is(value, '{"objectOrBoolean":{"stringOrNumber":"string"}}')
+    t.equal(value, '{"objectOrBoolean":{"stringOrNumber":"string"}}')
   } catch (e) {
     console.log(e)
     t.fail()
   }
 
-  t.is(stringify({
+  t.equal(stringify({
     objectOrBoolean: { stringOrNumber: 42 }
   }), '{"objectOrBoolean":{"stringOrNumber":42}}')
 
-  t.is(stringify({
+  t.equal(stringify({
     objectOrBoolean: true
   }), '{"objectOrBoolean":true}')
 })
@@ -363,7 +363,7 @@ test('string type array can handle dates', (t) => {
     date: new Date('2018-04-20T07:52:31.017Z'),
     dateObject: moment('2018-04-21T07:52:31.017Z')
   })
-  t.is(value, '{"date":"2018-04-20T07:52:31.017Z","dateObject":"2018-04-21T07:52:31.017Z"}')
+  t.equal(value, '{"date":"2018-04-20T07:52:31.017Z","dateObject":"2018-04-21T07:52:31.017Z"}')
 })
 
 test('object that is simultaneously a string and a json', (t) => {
@@ -386,10 +386,10 @@ test('object that is simultaneously a string and a json', (t) => {
 
   const stringify = build(schema)
   const valueStr = stringify({ simultaneously: likeObjectId })
-  t.is(valueStr, '{"simultaneously":"hello"}')
+  t.equal(valueStr, '{"simultaneously":"hello"}')
 
   const valueObj = stringify({ simultaneously: { foo: likeObjectId } })
-  t.is(valueObj, '{"simultaneously":{"foo":"hello"}}')
+  t.equal(valueObj, '{"simultaneously":{"foo":"hello"}}')
 })
 
 test('object that is simultaneously a string and a json switched', (t) => {
@@ -412,10 +412,10 @@ test('object that is simultaneously a string and a json switched', (t) => {
 
   const stringify = build(schema)
   const valueStr = stringify({ simultaneously: likeObjectId })
-  t.is(valueStr, '{"simultaneously":{}}')
+  t.equal(valueStr, '{"simultaneously":{}}')
 
   const valueObj = stringify({ simultaneously: { foo: likeObjectId } })
-  t.is(valueObj, '{"simultaneously":{"foo":"hello"}}')
+  t.equal(valueObj, '{"simultaneously":{"foo":"hello"}}')
 })
 
 test('should throw an error when type is array and object is null', (t) => {