fast-json-stringify 5.0.0 → 5.0.3

package/.github/workflows/ci.yml

@@ -13,5 +13,3 @@ on:
 jobs:
   test:
     uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
-    with:
-      auto-merge-exclude: 'chalk'

package/benchmark/bench-cmp-branch.js

@@ -2,8 +2,7 @@
 
 const { spawn } = require('child_process')
 
-const chalk = require('chalk')
-const inquirer = require('inquirer')
+const cliSelect = require('cli-select')
 const simpleGit = require('simple-git')
 
 const git = simpleGit(process.cwd())
@@ -11,24 +10,27 @@ const git = simpleGit(process.cwd())
 const COMMAND = 'npm run bench'
 const DEFAULT_BRANCH = 'master'
 const PERCENT_THRESHOLD = 5
+const greyColor = '\x1b[30m'
+const redColor = '\x1b[31m'
+const greenColor = '\x1b[32m'
+const resetColor = '\x1b[0m'
 
 async function selectBranchName (message, branches) {
-  const result = await inquirer.prompt([{
+  console.log(message)
+  const result = await cliSelect({
     type: 'list',
     name: 'branch',
-    choices: branches,
-    loop: false,
-    pageSize: 20,
-    message
-  }])
-  return result.branch
+    values: branches
+  })
+  console.log(result.value)
+  return result.value
 }
 
 async function executeCommandOnBranch (command, branch) {
-  console.log(chalk.grey(`Checking out "${branch}"`))
+  console.log(`${greyColor}Checking out "${branch}"${resetColor}`)
   await git.checkout(branch)
 
-  console.log(chalk.grey(`Execute "${command}"`))
+  console.log(`${greyColor}Execute "${command}"${resetColor}`)
   const childProcess = spawn(command, { stdio: 'pipe', shell: true })
 
   let result = ''
@@ -74,9 +76,9 @@ function compareResults (featureBranch, mainBranch) {
       const message = alignedName + percentString.padStart(7, '.')
 
       if (roundedPercent > PERCENT_THRESHOLD) {
-        console.log(chalk.green(message))
+        console.log(`${greenColor}${message}${resetColor}`)
       } else if (roundedPercent < -PERCENT_THRESHOLD) {
-        console.log(chalk.red(message))
+        console.log(`${redColor}${message}${resetColor}`)
       } else {
         console.log(message)
       }
@@ -110,5 +112,5 @@ function compareResults (featureBranch, mainBranch) {
   await git.checkout(currentBranch.commit)
   await git.checkout(currentBranch.name)
 
-  console.log(chalk.gray(`Back to ${currentBranch.name} ${currentBranch.commit}`))
+  console.log(`${greyColor}Back to ${currentBranch.name} ${currentBranch.commit}${resetColor}`)
 })()

package/index.js

@@ -102,10 +102,10 @@ function build (schema, options) {
   ajvInstance.addSchema(schema, rootSchemaId)
 
   if (options.schema) {
-    options.schema = clone(options.schema)
+    const externalSchemas = clone(options.schema)
 
-    for (const key of Object.keys(options.schema)) {
-      const externalSchema = options.schema[key]
+    for (const key of Object.keys(externalSchemas)) {
+      const externalSchema = externalSchemas[key]
       isValidSchema(externalSchema, key)
       extendDateTimeType(externalSchema)
 
@@ -297,7 +297,7 @@ function addPatternProperties (location) {
 }
 
 function additionalProperty (location) {
-  let ap = location.schema.additionalProperties
+  const ap = location.schema.additionalProperties
   let code = ''
   if (ap === true) {
     code += `
@@ -309,10 +309,10 @@ function additionalProperty (location) {
 
     return code
   }
+
   let apLocation = mergeLocation(location, 'additionalProperties')
-  if (ap.$ref) {
-    apLocation = resolveRef(location, ap.$ref)
-    ap = apLocation.schema
+  if (apLocation.schema.$ref) {
+    apLocation = resolveRef(apLocation, apLocation.schema.$ref)
   }
 
   const valueCode = buildValue(apLocation, 'obj[keys[i]]')
@@ -523,8 +523,9 @@ function addIfThenElse (location) {
 
   if (thenSchema.if && thenSchema.then) {
     code += addIfThenElse(thenLocation)
+  } else {
+    code += buildInnerObject(thenLocation)
   }
-  code += buildInnerObject(thenLocation)
   code += `
     }
   `
@@ -538,8 +539,9 @@ function addIfThenElse (location) {
 
   if (elseSchema.if && elseSchema.then) {
     code += addIfThenElse(elseLocation)
+  } else {
+    code += buildInnerObject(elseLocation)
   }
-  code += buildInnerObject(elseLocation)
   code += `
       }
     `
@@ -582,15 +584,13 @@ function buildObject (location) {
       var addComma = false
   `
 
-  let rCode
   if (schema.if && schema.then) {
-    rCode = addIfThenElse(location)
+    functionCode += addIfThenElse(location)
   } else {
-    rCode = buildInnerObject(location)
+    functionCode += buildInnerObject(location)
   }
 
-  // Removes the comma if is the last element of the string (in case there are not properties)
-  functionCode += `${rCode}
+  functionCode += `
       json += '}'
       return json
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.0.0",
+  "version": "5.0.3",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -35,9 +35,8 @@
   "devDependencies": {
     "@sinclair/typebox": "^0.23.3",
     "benchmark": "^2.1.4",
-    "chalk": "^4.1.2",
+    "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
-    "inquirer": "^9.0.0",
     "is-my-json-valid": "^2.20.0",
     "luxon": "^2.4.0",
     "pre-commit": "^1.2.2",

package/serializer.js

@@ -34,7 +34,7 @@ module.exports = class Serializer {
     } else {
       /* eslint no-undef: "off" */
       const integer = this.parseInteger(i)
-      if (Number.isNaN(integer)) {
+      if (Number.isNaN(integer) || !Number.isFinite(integer)) {
         throw new Error(`The value "${i}" cannot be converted to an integer.`)
       } else {
         return '' + integer
@@ -50,6 +50,8 @@ module.exports = class Serializer {
     const num = Number(i)
     if (Number.isNaN(num)) {
       throw new Error(`The value "${i}" cannot be converted to a number.`)
+    } else if (!Number.isFinite(num)) {
+      return null
     } else {
       return '' + num
     }

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

@@ -333,3 +333,38 @@ t.test('if-then-else', t => {
 
   t.end()
 })
+
+t.test('nested if/then', t => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: { a: { type: 'string' } },
+    if: {
+      type: 'object',
+      properties: { foo: { type: 'string' } }
+    },
+    then: {
+      properties: { bar: { type: 'string' } },
+      if: {
+        type: 'object',
+        properties: { foo1: { type: 'string' } }
+      },
+      then: {
+        properties: { bar1: { type: 'string' } }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  t.equal(
+    stringify({ a: 'A', foo: 'foo', bar: 'bar' }),
+    JSON.stringify({ a: 'A', bar: 'bar' })
+  )
+
+  t.equal(
+    stringify({ a: 'A', foo: 'foo', bar: 'bar', foo1: 'foo1', bar1: 'bar1' }),
+    JSON.stringify({ a: 'A', bar: 'bar', bar1: 'bar1' })
+  )
+})

package/test/infinity.test.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const test = require('tap').test
+const build = require('..')
+
+test('Finite numbers', t => {
+  const values = [-5, 0, -0, 1.33, 99, 100.0,
+    Math.E, Number.EPSILON,
+    Number.MAX_SAFE_INTEGER, Number.MAX_VALUE,
+    Number.MIN_SAFE_INTEGER, Number.MIN_VALUE]
+
+  t.plan(values.length)
+
+  const schema = {
+    type: 'number'
+  }
+
+  const stringify = build(schema)
+
+  values.forEach(v => t.equal(stringify(v), JSON.stringify(v)))
+})
+
+test('Infinite integers', t => {
+  const values = [Infinity, -Infinity]
+
+  t.plan(values.length)
+
+  const schema = {
+    type: 'integer'
+  }
+
+  const stringify = build(schema)
+
+  values.forEach(v => {
+    try {
+      stringify(v)
+    } catch (err) {
+      t.equal(err.message, `The value "${v}" cannot be converted to an integer.`)
+    }
+  })
+})
+
+test('Infinite numbers', t => {
+  const values = [Infinity, -Infinity]
+
+  t.plan(values.length)
+
+  const schema = {
+    type: 'number'
+  }
+
+  const stringify = build(schema)
+
+  values.forEach(v => t.equal(stringify(v), JSON.stringify(v)))
+})

package/test/ref.test.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const clone = require('rfdc')({ proto: true })
+
 const test = require('tap').test
 const build = require('..')
 
@@ -1822,3 +1824,70 @@ test('ref with same id in properties', (t) => {
     t.equal(output, '{"_id":"foo","image":{"_id":"bar","name":"hello","owner":"baz"}}')
   })
 })
+
+test('Should not modify external schemas', (t) => {
+  t.plan(2)
+
+  const externalSchema = {
+    uuid: {
+      format: 'uuid',
+      $id: 'UUID',
+      type: 'string'
+    },
+    Entity: {
+      $id: 'Entity',
+      type: 'object',
+      properties: {
+        id: { $ref: 'UUID' },
+        id2: { $ref: 'UUID' }
+      }
+    }
+  }
+
+  const options = { schema: externalSchema }
+  const optionsClone = clone(options)
+
+  const stringify = build({ $ref: 'Entity' }, options)
+
+  const data = { id: 'a4e4c954-9f5f-443a-aa65-74d95732249a' }
+  const output = stringify(data)
+
+  t.equal(output, JSON.stringify(data))
+  t.same(options, optionsClone)
+})
+
+test('input schema is not mutated', (t) => {
+  t.plan(3)
+
+  const schema = {
+    title: 'object with $ref',
+    type: 'object',
+    definitions: {
+      def: { type: 'string' }
+    },
+    properties: {
+      obj: {
+        $ref: '#/definitions/def'
+      }
+    }
+  }
+
+  const clonedSchema = JSON.parse(JSON.stringify(schema))
+
+  const object = {
+    obj: 'test'
+  }
+
+  const stringify = build(schema)
+  const output = stringify(object)
+
+  try {
+    JSON.parse(output)
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+
+  t.equal(output, '{"obj":"test"}')
+  t.same(schema, clonedSchema)
+})