fast-json-stringify 5.7.0 → 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/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)') {
@@ -297,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
 }
 
@@ -504,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)}
     }
   `
 
@@ -832,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)
 
@@ -856,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

@@ -113,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)
     }
@@ -130,32 +129,32 @@ 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 () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.7.0",
+  "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.26.5",
+    "@sinclair/typebox": "^0.29.1",
     "benchmark": "^2.1.4",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",

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)