fast-json-stringify 5.6.2 → 5.8.0

package/.github/workflows/benchmark.yml

@@ -1,4 +1,4 @@
-name: Benchmark
+name: Benchmark PR
 
 on:
   pull_request_target:
@@ -11,15 +11,8 @@ jobs:
     permissions:
       contents: read
     outputs:
-      PR-BENCH-14: ${{ steps.benchmark-pr.outputs.BENCH_RESULT14 }}
-      PR-BENCH-16: ${{ steps.benchmark-pr.outputs.BENCH_RESULT16 }}
-      PR-BENCH-18: ${{ steps.benchmark-pr.outputs.BENCH_RESULT18 }}
-      MAIN-BENCH-14: ${{ steps.benchmark-main.outputs.BENCH_RESULT14 }}
-      MAIN-BENCH-16: ${{ steps.benchmark-main.outputs.BENCH_RESULT16 }}
-      MAIN-BENCH-18: ${{ steps.benchmark-main.outputs.BENCH_RESULT18 }}
-    strategy:
-      matrix:
-        node-version: [14, 16, 18]
+      PR-BENCH: ${{ steps.benchmark-pr.outputs.BENCH_RESULT }}
+      MASTER-BENCH: ${{ steps.benchmark-master.outputs.BENCH_RESULT }}
     steps:
       - uses: actions/checkout@v3
         with:
@@ -29,7 +22,7 @@ jobs:
 
       - uses: actions/setup-node@v3
         with:
-          node-version: ${{ matrix.node-version }}
+          node-version: 18
 
       - name: Install
         run: |
@@ -38,14 +31,14 @@ jobs:
       - name: Run benchmark
         id: benchmark-pr
         run: |
-          npm run --silent benchmark > ./bench-result
+          npm run --silent bench > ./bench-result
           content=$(cat ./bench-result)
           content="${content//'%'/'%25'}"
           content="${content//$'\n'/'%0A'}"
           content="${content//$'\r'/'%0D'}"
-          echo "::set-output name=BENCH_RESULT${{matrix.node-version}}::$content"
+          echo "::set-output name=BENCH_RESULT::$content"
 
-      # main benchmark
+      # master benchmark
       - uses: actions/checkout@v3
         with:
           ref: 'master'
@@ -57,14 +50,15 @@ jobs:
       - name: Run benchmark
         id: benchmark-master
         run: |
-          npm run --silent benchmark > ./bench-result
+          npm run --silent bench > ./bench-result
           content=$(cat ./bench-result)
           content="${content//'%'/'%25'}"
           content="${content//$'\n'/'%0A'}"
           content="${content//$'\r'/'%0D'}"
-          echo "::set-output name=BENCH_RESULT${{matrix.node-version}}::$content"
+          echo "::set-output name=BENCH_RESULT::$content"
 
   output-benchmark:
+    if: "always()"
     needs: [benchmark]
     runs-on: ubuntu-latest
     permissions:
@@ -75,38 +69,13 @@ jobs:
         with:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           message: |
-            **Node**: 14
             **PR**:
             ```
-            ${{ needs.benchmark.outputs.PR-BENCH-14 }}
+            ${{ needs.benchmark.outputs.PR-BENCH }}
             ```
-            **MAIN**:
+            **MASTER**:
             ```
-            ${{ needs.benchmark.outputs.MAIN-BENCH-14 }}
-            ```
-            
-            ---
-            
-            **Node**: 16
-            **PR**:
-            ```
-            ${{ needs.benchmark.outputs.PR-BENCH-16 }}
-            ```
-            **MAIN**:
-            ```
-            ${{ needs.benchmark.outputs.MAIN-BENCH-16 }}
-            ```
-            
-            ---
-            
-            **Node**: 18
-            **PR**:
-            ```
-            ${{ needs.benchmark.outputs.PR-BENCH-18 }}
-            ```
-            **MAIN**:
-            ```
-            ${{ needs.benchmark.outputs.MAIN-BENCH-18 }}
+            ${{ needs.benchmark.outputs.MASTER-BENCH }}
             ```
             
       - uses: actions-ecosystem/action-remove-labels@v1

package/.github/workflows/ci.yml

@@ -2,6 +2,11 @@ name: CI
 
 on:
   push:
+    branches:
+     - main
+     - master
+     - next
+     - 'v*'
     paths-ignore:
       - 'docs/**'
       - '*.md'

package/README.md

@@ -689,8 +689,7 @@ console.log(stringify({ firstName: 'Foo', surname: 'bar' })) // '{"firstName":"F
 ### Standalone Mode
 
 The standalone mode is used to compile the code that can be directly run by `node`
-itself. You need to install `ajv`, `fast-uri` and `ajv-formats` for
-the standalone code to work.
+itself. You need to have `fast-json-stringify` installed for the standalone code to work.
 
 ```js
 const fs = require('fs')

package/benchmark/bench-thread.js

@@ -3,7 +3,7 @@
 const { workerData: benchmark, parentPort } = require('worker_threads')
 
 const Benchmark = require('benchmark')
-Benchmark.options.minSamples = 500
+Benchmark.options.minSamples = 100
 
 const suite = Benchmark.Suite()
 

package/benchmark/bench.js

@@ -18,6 +18,11 @@ function getRandomInt (max) {
   return Math.floor(Math.random() * max)
 }
 
+let longSimpleString = ''
+for (let i = 0; i < LONG_STRING_LENGTH; i++) {
+  longSimpleString += i
+}
+
 let longString = ''
 for (let i = 0; i < LONG_STRING_LENGTH; i++) {
   longString += i
@@ -42,6 +47,20 @@ const benchmarks = [
     },
     input: 'hello world'
   },
+  {
+    name: 'short string with double quote',
+    schema: {
+      type: 'string'
+    },
+    input: 'hello " world'
+  },
+  {
+    name: 'long string without double quotes',
+    schema: {
+      type: 'string'
+    },
+    input: longSimpleString
+  },
   {
     name: 'long string',
     schema: {
@@ -235,6 +254,28 @@ const benchmarks = [
     },
     input: { firstName: 'Max', lastName: 'Power', age: 22 }
   },
+  {
+    name: 'simple object with required fields',
+    schema: {
+      title: 'Example Schema',
+      type: 'object',
+      properties: {
+        firstName: {
+          type: 'string'
+        },
+        lastName: {
+          type: ['string', 'null']
+        },
+        age: {
+          description: 'Age in years',
+          type: 'integer',
+          minimum: 0
+        }
+      },
+      required: ['firstName', 'lastName', 'age']
+    },
+    input: { firstName: 'Max', lastName: 'Power', age: 22 }
+  },
   {
     name: 'object with const string property',
     schema: {

package/index.js

@@ -76,6 +76,7 @@ function build (schema, options) {
     functionsCounter: 0,
     functionsNamesBySchema: new Map(),
     options,
+    wrapObjects: true,
     refResolver: new RefResolver(),
     rootSchemaId: schema.$id || randomUUID(),
     validatorSchemasIds: new Set()
@@ -123,7 +124,7 @@ function build (schema, options) {
 
   // If we have only the invocation of the 'anonymous0' function, we would
   // basically just wrap the 'anonymous0' function in the 'main' function and
-  // and the overhead of the intermediate variabe 'json'. We can avoid the
+  // and the overhead of the intermediate variable 'json'. We can avoid the
   // wrapping and the unnecessary memory allocation by aliasing 'anonymous0' to
   // 'main'
   if (code === 'json += anonymous0(input)') {
@@ -170,18 +171,15 @@ function build (schema, options) {
     }
   }
 
+  /* eslint no-new-func: "off" */
+  const contextFunc = new Function('validator', 'serializer', contextFunctionCode)
+
   if (options.mode === 'standalone') {
-    // lazy load
-    const isValidatorUsed = context.validatorSchemasIds.size > 0
     const buildStandaloneCode = require('./lib/standalone')
-    return buildStandaloneCode(options, validator, isValidatorUsed, contextFunctionCode)
+    return buildStandaloneCode(contextFunc, context, serializer, validator)
   }
 
-  /* eslint no-new-func: "off" */
-  const contextFunc = new Function('validator', 'serializer', contextFunctionCode)
-  const stringifyFunc = contextFunc(validator, serializer)
-
-  return stringifyFunc
+  return contextFunc(validator, serializer)
 }
 
 const objectKeywords = [
@@ -300,59 +298,96 @@ function buildExtraObjectPropertiesSerializer (context, location) {
 }
 
 function buildInnerObject (context, location) {
+  let code = ''
   const schema = location.schema
   const required = schema.required || []
 
-  let code = ''
-
   const propertiesLocation = location.getPropertyLocation('properties')
-  Object.keys(schema.properties || {}).forEach((key) => {
-    let propertyLocation = propertiesLocation.getPropertyLocation(key)
-    if (propertyLocation.schema.$ref) {
-      propertyLocation = resolveRef(context, location, propertyLocation.schema.$ref)
-    }
 
-    const sanitized = JSON.stringify(key)
+  const requiredWithDefault = []
+  const requiredWithoutDefault = []
+  if (schema.properties) {
+    for (const key of Object.keys(schema.properties)) {
+      if (required.indexOf(key) === -1) {
+        continue
+      }
+      let propertyLocation = propertiesLocation.getPropertyLocation(key)
+      if (propertyLocation.schema.$ref) {
+        propertyLocation = resolveRef(context, location, propertyLocation.schema.$ref)
+      }
 
-    // Using obj['key'] !== undefined instead of obj.hasOwnProperty(prop) for perf reasons,
-    // see https://github.com/mcollina/fast-json-stringify/pull/3 for discussion.
+      const sanitizedKey = JSON.stringify(key)
 
-    code += `
-      if (obj[${sanitized}] !== undefined) {
-        ${addComma}
-        json += ${JSON.stringify(sanitized + ':')}
-      `
+      // Using obj['key'] !== undefined instead of obj.hasOwnProperty(prop) for perf reasons,
+      // see https://github.com/mcollina/fast-json-stringify/pull/3 for discussion.
+      const defaultValue = propertyLocation.schema.default
+      if (defaultValue === undefined) {
+        code += `if (obj[${sanitizedKey}] === undefined) throw new Error('${sanitizedKey} is required!')\n`
+        requiredWithoutDefault.push(key)
+      }
+      requiredWithDefault.push(key)
+    }
+  }
 
-    code += buildValue(context, propertyLocation, `obj[${sanitized}]`)
+  // handle extraneous required fields
+  for (const requiredProperty of required) {
+    if (requiredWithDefault.indexOf(requiredProperty) !== -1) continue
+    code += `if (obj['${requiredProperty}'] === undefined) throw new Error('"${requiredProperty}" is required!')\n`
+  }
 
-    const defaultValue = propertyLocation.schema.default
-    if (defaultValue !== undefined) {
-      code += `
-      } else {
+  code += `
+    let addComma = false
+    let json = '${context.wrapObjects ? '{' : ''}'
+  `
+  const wrapObjects = context.wrapObjects
+  context.wrapObjects = true
+
+  if (schema.properties) {
+    for (const key of Object.keys(schema.properties)) {
+      let propertyLocation = propertiesLocation.getPropertyLocation(key)
+      if (propertyLocation.schema.$ref) {
+        propertyLocation = resolveRef(context, location, propertyLocation.schema.$ref)
+      }
+
+      const sanitizedKey = JSON.stringify(key)
+
+      if (requiredWithoutDefault.indexOf(key) !== -1) {
+        code += `
         ${addComma}
-        json += ${JSON.stringify(sanitized + ':' + JSON.stringify(defaultValue))}
+        json += ${JSON.stringify(sanitizedKey + ':')}
+        ${buildValue(context, propertyLocation, `obj[${sanitizedKey}]`)}
       `
-    } else if (required.includes(key)) {
-      code += `
       } else {
-        throw new Error('${sanitized} is required!')
-      `
-    }
-
-    code += `
+        // Using obj['key'] !== undefined instead of obj.hasOwnProperty(prop) for perf reasons,
+        // see https://github.com/mcollina/fast-json-stringify/pull/3 for discussion.
+        code += `
+        if (obj[${sanitizedKey}] !== undefined) {
+          ${addComma}
+          json += ${JSON.stringify(sanitizedKey + ':')}
+          ${buildValue(context, propertyLocation, `obj[${sanitizedKey}]`)}
+        }
+        `
+        const defaultValue = propertyLocation.schema.default
+        if (defaultValue !== undefined) {
+          code += `
+        else {
+          ${addComma}
+          json += ${JSON.stringify(sanitizedKey + ':' + JSON.stringify(defaultValue))}
+        }
+        `
+        }
       }
-    `
-  })
-
-  for (const requiredProperty of required) {
-    if (schema.properties && schema.properties[requiredProperty] !== undefined) continue
-    code += `if (obj['${requiredProperty}'] === undefined) throw new Error('"${requiredProperty}" is required!')\n`
+    }
   }
 
   if (schema.patternProperties || schema.additionalProperties) {
     code += buildExtraObjectPropertiesSerializer(context, location)
   }
 
+  context.wrapObjects = wrapObjects
+  code += `
+  return json${context.wrapObjects ? ' + \'}\'' : ''}
+  `
   return code
 }
 
@@ -507,19 +542,13 @@ function buildObject (context, location) {
   }
 
   let functionCode = `
-    function ${functionName} (input) {
-      // ${schemaRef}
   `
 
   functionCode += `
+    // ${schemaRef}
+    function ${functionName} (input) {
       const obj = ${toJSON('input')}
-      let json = '{'
-      let addComma = false
-  `
-
-  functionCode += buildInnerObject(context, location)
-  functionCode += `
-      return json + '}'
+      ${buildInnerObject(context, location)}
     }
   `
 
@@ -571,12 +600,8 @@ function buildArray (context, location) {
     `
   }
 
-  if (largeArrayMechanism !== 'default') {
-    if (largeArrayMechanism === 'json-stringify') {
-      functionCode += `if (arrayLength && arrayLength >= ${largeArraySize}) return JSON.stringify(obj)\n`
-    } else {
-      throw new Error(`Unsupported large array mechanism ${largeArrayMechanism}`)
-    }
+  if (largeArrayMechanism === 'json-stringify') {
+    functionCode += `if (arrayLength && arrayLength >= ${largeArraySize}) return JSON.stringify(obj)\n`
   }
 
   functionCode += `
@@ -663,8 +688,6 @@ function buildArrayTypeCondition (type, accessor) {
           return buildArrayTypeCondition(subType, accessor)
         })
         condition = `(${conditions.join(' || ')})`
-      } else {
-        throw new Error(`${type} unsupported`)
       }
   }
   return condition
@@ -841,9 +864,19 @@ function buildValue (context, location, input) {
 
   let code = ''
 
-  if (type === undefined && (schema.anyOf || schema.oneOf)) {
+  if ((type === undefined || type === 'object') && (schema.anyOf || schema.oneOf)) {
     context.validatorSchemasIds.add(location.getSchemaId())
 
+    if (schema.type === 'object') {
+      context.wrapObjects = false
+      const funcName = buildObject(context, location)
+      code += `
+        json += '{'
+        json += ${funcName}(${input})
+        json += ','
+      `
+    }
+
     const type = schema.anyOf ? 'anyOf' : 'oneOf'
     const anyOfLocation = location.getPropertyLocation(type)
 
@@ -865,6 +898,12 @@ function buildValue (context, location, input) {
     code += `
       else throw new TypeError(\`The value of '${schemaRef}' does not match schema definition.\`)
     `
+    if (schema.type === 'object') {
+      code += `
+        json += '}'
+      `
+      context.wrapObjects = true
+    }
     return code
   }
 

package/lib/serializer.js

@@ -20,6 +20,7 @@ module.exports = class Serializer {
         this.parseInteger = Math.trunc
         break
     }
+    this._options = options
   }
 
   asInteger (i) {
@@ -54,7 +55,7 @@ module.exports = class Serializer {
     if (Number.isNaN(num)) {
       throw new Error(`The value "${i}" cannot be converted to a number.`)
     } else if (!Number.isFinite(num)) {
-      return null
+      return 'null'
     } else {
       return '' + num
     }
@@ -112,11 +113,10 @@ module.exports = class Serializer {
       }
     }
 
-    // Fast escape chars check
-    if (!STR_ESCAPE.test(str)) {
-      return '"' + str + '"'
-    } else if (str.length < 42) {
+    if (str.length < 42) {
       return this.asStringSmall(str)
+    } else if (STR_ESCAPE.test(str) === false) {
+      return '"' + str + '"'
     } else {
       return JSON.stringify(str)
     }
@@ -129,31 +129,39 @@ module.exports = class Serializer {
   // 34 and 92 happens all the time, so we
   // have a fast case for them
   asStringSmall (str) {
-    const l = str.length
+    const len = str.length
     let result = ''
-    let last = 0
-    let found = false
-    let surrogateFound = false
+    let last = -1
     let point = 255
+
     // eslint-disable-next-line
-    for (var i = 0; i < l && point >= 32; i++) {
+    for (var i = 0; i < len; i++) {
       point = str.charCodeAt(i)
+      if (point < 32) {
+        return JSON.stringify(str)
+      }
       if (point >= 0xD800 && point <= 0xDFFF) {
         // The current character is a surrogate.
-        surrogateFound = true
+        return JSON.stringify(str)
       }
-      if (point === 34 || point === 92) {
+      if (
+        point === 0x22 || // '"'
+        point === 0x5c // '\'
+      ) {
+        last === -1 && (last = 0)
         result += str.slice(last, i) + '\\'
         last = i
-        found = true
       }
     }
 
-    if (!found) {
-      result = str
-    } else {
-      result += str.slice(last)
-    }
-    return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
+    return (last === -1 && ('"' + str + '"')) || ('"' + result + str.slice(last) + '"')
+  }
+
+  getState () {
+    return this._options
+  }
+
+  static restoreFromState (state) {
+    return new Serializer(state)
   }
 }

package/lib/standalone.js

@@ -1,42 +1,31 @@
-const fs = require('fs')
-const path = require('path')
-
-function buildStandaloneCode (options, validator, isValidatorUsed, contextFunctionCode) {
-  const serializerCode = fs.readFileSync(path.join(__dirname, 'serializer.js')).toString()
-  let buildAjvCode = ''
-  let ajvSchemasCode = ''
-
-  if (isValidatorUsed) {
-    let defaultAjvSchema = ''
-    // we need to export the custom json schema
-    const defaultMeta = validator.ajv.defaultMeta()
-    if (typeof defaultMeta === 'string') {
-      defaultAjvSchema = defaultMeta
-    } else {
-      defaultAjvSchema = defaultMeta.$id || defaultMeta.id
-    }
-
-    ajvSchemasCode += `const validator = new Validator(${JSON.stringify(options.ajv || {})})\n`
-    for (const [id, schema] of Object.entries(validator.ajv.schemas)) {
-      // should skip ajv default schema
-      if (id === defaultAjvSchema) continue
-      ajvSchemasCode += `validator.ajv.addSchema(${JSON.stringify(schema.schema)}, "${id}")\n`
-    }
-    buildAjvCode = fs.readFileSync(path.join(__dirname, 'validator.js')).toString()
-    buildAjvCode = buildAjvCode.replace("'use strict'", '').replace('module.exports = SchemaValidator', '')
+'use strict'
+
+function buildStandaloneCode (contextFunc, context, serializer, validator) {
+  let ajvDependencyCode = ''
+  if (context.validatorSchemasIds.size > 0) {
+    ajvDependencyCode += `const validatorState = ${JSON.stringify(validator.getState())}\n`
+    ajvDependencyCode += 'const validator = Validator.restoreFromState(validatorState)\n'
+  } else {
+    ajvDependencyCode += 'const validator = null\n'
   }
 
-  const serializerOptions = options && options.rounding ? JSON.stringify({ options: options.rounding }) : ''
   return `
   'use strict'
-  ${serializerCode.replace("'use strict'", '').replace('module.exports = ', '')}
-  ${buildAjvCode}
-  const serializer = new Serializer(${serializerOptions})
-  ${ajvSchemasCode}
+  const { dependencies } = require('fast-json-stringify/lib/standalone')
+
+  const { Serializer, Validator } = dependencies
+
+  const serializerState = ${JSON.stringify(serializer.getState())}
+  const serializer = Serializer.restoreFromState(serializerState)
 
-  ${contextFunctionCode.replace('return main', '')}
+  ${ajvDependencyCode}
 
-  module.exports = main`
+  module.exports = ${contextFunc.toString()}(validator, serializer)`
 }
 
 module.exports = buildStandaloneCode
+
+module.exports.dependencies = {
+  Serializer: require('./serializer'),
+  Validator: require('./validator')
+}

package/lib/validator.js

@@ -25,6 +25,9 @@ class Validator {
         return date instanceof Date
       }
     })
+
+    this._ajvSchemas = {}
+    this._ajvOptions = ajvOptions || {}
   }
 
   addSchema (schema, schemaName) {
@@ -40,6 +43,7 @@ class Validator {
       const ajvSchema = clone(schema)
       this.convertSchemaToAjvFormat(ajvSchema)
       this.ajv.addSchema(ajvSchema, schemaKey)
+      this._ajvSchemas[schemaKey] = schema
     }
   }
 
@@ -70,6 +74,21 @@ class Validator {
       }
     }
   }
+
+  getState () {
+    return {
+      ajvOptions: this._ajvOptions,
+      ajvSchemas: this._ajvSchemas
+    }
+  }
+
+  static restoreFromState (state) {
+    const validator = new Validator(state.ajvOptions)
+    for (const [id, ajvSchema] of Object.entries(state.ajvSchemas)) {
+      validator.ajv.addSchema(ajvSchema, id)
+    }
+    return validator
+  }
 }
 
 module.exports = Validator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.6.2",
+  "version": "5.8.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -34,7 +34,7 @@
   "homepage": "https://github.com/fastify/fast-json-stringify#readme",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.25.2",
+    "@sinclair/typebox": "^0.29.1",
     "benchmark": "^2.1.4",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
@@ -42,8 +42,9 @@
     "simple-git": "^3.7.1",
     "standard": "^17.0.0",
     "tap": "^16.0.1",
-    "tsd": "^0.25.0",
-    "webpack": "^5.40.0"
+    "tsd": "^0.28.0",
+    "webpack": "^5.40.0",
+    "fast-json-stringify": "."
   },
   "dependencies": {
     "@fastify/deepmerge": "^1.0.0",

package/test/allof.test.js

@@ -220,6 +220,75 @@ test('object with nested allOfs', (t) => {
   t.equal(value, '{"id1":1,"id2":2,"id3":3}')
 })
 
+test('object with anyOf nested inside allOf', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with anyOf nested inside allOf',
+    type: 'object',
+    allOf: [
+      {
+        required: ['id1', 'obj'],
+        type: 'object',
+        properties: {
+          id1: {
+            type: 'integer'
+          },
+          obj: {
+            type: 'object',
+            properties: {
+              nested: { type: 'string' }
+            }
+          }
+        }
+      },
+      {
+        anyOf: [
+          {
+            type: 'object',
+            properties: {
+              id2: { type: 'string' }
+            },
+            required: ['id2']
+          },
+          {
+            type: 'object',
+            properties: {
+              id3: {
+                type: 'integer'
+              },
+              nestedObj: {
+                type: 'object',
+                properties: {
+                  nested: { type: 'string' }
+                }
+              }
+            },
+            required: ['id3']
+          },
+          {
+            type: 'object',
+            properties: {
+              id4: { type: 'integer' }
+            },
+            required: ['id4']
+          }
+        ]
+      }
+    ]
+  }
+
+  const stringify = build(schema)
+  const value = stringify({
+    id1: 1,
+    id3: 3,
+    id4: 4, // extra prop shouldn't be in result
+    obj: { nested: 'yes' },
+    nestedObj: { nested: 'yes' }
+  })
+  t.equal(value, '{"id1":1,"obj":{"nested":"yes"},"id3":3,"nestedObj":{"nested":"yes"}}')
+})
+
 test('object with $ref in allOf', (t) => {
   t.plan(1)
 

package/test/basic.test.js

@@ -344,7 +344,7 @@ test('patternProperties - throw on unknown type', (t) => {
   }
 })
 
-test('render a single quote as JSON', (t) => {
+test('render a double quote as JSON /1', (t) => {
   t.plan(2)
 
   const schema = {
@@ -360,6 +360,38 @@ test('render a single quote as JSON', (t) => {
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
+test('render a double quote as JSON /2', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+  const toStringify = 'double quote " 2'
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.equal(output, JSON.stringify(toStringify))
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('render a long string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+  const toStringify = 'the Ultimate Question of Life, the Universe, and Everything.'
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.equal(output, JSON.stringify(toStringify))
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
 test('returns JSON.stringify if schema type is boolean', t => {
   t.plan(1)
 

package/test/integer.test.js

@@ -35,6 +35,18 @@ test('render a float as an integer', (t) => {
   }
 })
 
+test('throws on NaN', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'integer',
+    type: 'integer'
+  }
+
+  const stringify = build(schema)
+  t.throws(() => stringify(NaN), new Error('The value "NaN" cannot be converted to an integer.'))
+})
+
 test('render a float as an integer', (t) => {
   const cases = [
     { input: Math.PI, output: '3' },

package/test/ref.test.js

@@ -2078,3 +2078,42 @@ test('should throw an Error if two non-identical schemas with same id are provid
 
   t.throws(() => build(schema), new Error('There is already another schema with id inner_schema'))
 })
+
+test('ref internal - throw if schema has definition twice with different shape', (t) => {
+  t.plan(1)
+
+  const schema = {
+    $id: 'test',
+    title: 'object with $ref',
+    definitions: {
+      def: {
+        $id: '#uri',
+        type: 'object',
+        properties: {
+          str: {
+            type: 'string'
+          }
+        },
+        required: ['str']
+      },
+      def2: {
+        $id: '#uri',
+        type: 'object',
+        properties: {
+          num: {
+            type: 'number'
+          }
+        },
+        required: ['num']
+      }
+    },
+    type: 'object',
+    properties: {
+      obj: {
+        $ref: '#uri'
+      }
+    }
+  }
+
+  t.throws(() => build(schema), Error('There is already another schema with id test##uri'))
+})