fast-json-stringify 2.7.8 → 2.7.12

package/.github/workflows/benchmark.yml

@@ -0,0 +1,111 @@
+name: Benchmark
+
+on:
+  pull_request_target:
+    types: [labeled]
+
+jobs:
+  benchmark:
+    if: ${{ github.event.label.name == 'benchmark' }}
+    runs-on: ubuntu-latest
+    outputs:
+      PR-BENCH-12: ${{ steps.benchmark-pr.outputs.BENCH_RESULT12 }}
+      PR-BENCH-14: ${{ steps.benchmark-pr.outputs.BENCH_RESULT14 }}
+      PR-BENCH-16: ${{ steps.benchmark-pr.outputs.BENCH_RESULT16 }}
+      MAIN-BENCH-12: ${{ steps.benchmark-main.outputs.BENCH_RESULT12 }}
+      MAIN-BENCH-14: ${{ steps.benchmark-main.outputs.BENCH_RESULT14 }}
+      MAIN-BENCH-16: ${{ steps.benchmark-main.outputs.BENCH_RESULT16 }}
+    strategy:
+      matrix:
+        node-version: [12, 14, 16]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          ref: ${{github.event.pull_request.head.ref}}
+          repository: ${{github.event.pull_request.head.repo.full_name}}
+
+      - uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install
+        run: |
+          npm install --ignore-scripts
+
+      - name: Run benchmark
+        id: benchmark-pr
+        run: |
+          npm run --silent benchmark > ./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"
+
+      # main benchmark
+      - uses: actions/checkout@v2
+        with:
+          ref: 'master'
+
+      - name: Install
+        run: |
+          npm install --ignore-scripts
+
+      - name: Run benchmark
+        id: benchmark-master
+        run: |
+          npm run --silent benchmark > ./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"
+
+  output-benchmark:
+    needs: [benchmark]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Comment PR
+        uses: thollander/actions-comment-pull-request@v1
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          message: |
+            **Node**: 12
+            **PR**:
+            ```
+            ${{ needs.benchmark.outputs.PR-BENCH-12 }}
+            ```
+            **MAIN**:
+            ```
+            ${{ needs.benchmark.outputs.MAIN-BENCH-12 }}
+            ```
+            
+            ---
+            
+            **Node**: 14
+            **PR**:
+            ```
+            ${{ needs.benchmark.outputs.PR-BENCH-14 }}
+            ```
+            **MAIN**:
+            ```
+            ${{ needs.benchmark.outputs.MAIN-BENCH-14 }}
+            ```
+            
+            ---
+            
+            **Node**: 16
+            **PR**:
+            ```
+            ${{ needs.benchmark.outputs.PR-BENCH-16 }}
+            ```
+            **MAIN**:
+            ```
+            ${{ needs.benchmark.outputs.MAIN-BENCH-16 }}
+            ```
+            
+      - uses: actions-ecosystem/action-remove-labels@v1
+        with:
+          labels: |
+            benchmark
+          github_token: ${{ secrets.GITHUB_TOKEN }}

package/.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
       - uses: actions/checkout@v2.3.4
 
       - name: Use Node.js
-        uses: actions/setup-node@v2.3.0
+        uses: actions/setup-node@v2.4.0
         with:
           node-version: ${{ matrix.node-version }}
 
@@ -38,6 +38,6 @@ jobs:
     needs: test
     runs-on: ubuntu-latest
     steps:
-      - uses: fastify/github-action-merge-dependabot@v2.2.0
+      - uses: fastify/github-action-merge-dependabot@v2.5.0
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}

package/README.md

@@ -12,22 +12,25 @@ __fast-json-stringify__ is significantly faster than `JSON.stringify()` for smal
 ##### Benchmarks
 
 - Machine: `EX41S-SSD, Intel Core i7, 4Ghz, 64GB RAM, 4C/8T, SSD`.
-- Node.js `v12.16.2`
+- Node.js `v16.9.1`
 
 ```
-FJS creation x 59,805 ops/sec ±0.23% (91 runs sampled)
+FJS creation x 6,040 ops/sec ±1.17% (91 runs sampled)
 
-JSON.stringify array x 5,330 ops/sec ±0.54% (97 runs sampled)
-fast-json-stringify array x 6,995 ops/sec ±0.24% (94 runs sampled)
+JSON.stringify array x 5,519 ops/sec ±0.08% (99 runs sampled)
+fast-json-stringify array x 7,143 ops/sec ±0.14% (97 runs sampled)
 
-JSON.stringify long string x 15,108 ops/sec ±0.13% (100 runs sampled)
-fast-json-stringify long string x 15,089 ops/sec ±0.15% (98 runs sampled)
+JSON.stringify long string x 16,438 ops/sec ±0.32% (98 runs sampled)
+fast-json-stringify long string x 16,457 ops/sec ±0.09% (97 runs sampled)
 
-JSON.stringify short string x 13,214,696 ops/sec ±0.19% (97 runs sampled)
-fast-json-stringify short string x 33,378,500 ops/sec ±0.27% (95 runs sampled)
+JSON.stringify short string x 12,061,258 ops/sec ±0.32% (97 runs sampled)
+fast-json-stringify short string x 35,531,071 ops/sec ±0.17% (94 runs sampled)
 
-JSON.stringify obj x 3,172,653 ops/sec ±0.15% (98 runs sampled)
-fast-json-stringify obj x 13,537,123 ops/sec ±0.19% (95 runs sampled)
+JSON.stringify obj x 3,079,746 ops/sec ±0.09% (95 runs sampled)
+fast-json-stringify obj x 7,721,569 ops/sec ±0.12% (98 runs sampled)
+
+JSON stringify date x 1,149,786 ops/sec ±0.10% (99 runs sampled)
+fast-json-stringify date format x 1,674,498 ops/sec ±0.12% (99 runs sampled)
 ```
 
 #### Table of contents:

package/bench.js

@@ -50,22 +50,38 @@ const arraySchemaCJS = {
   items: schemaCJS
 }
 
+const dateFormatSchema = {
+  description: 'Date of birth',
+  type: 'string',
+  format: 'date'
+}
+
+const dateFormatSchemaCJS = {
+  description: 'Date of birth',
+  type: 'string',
+  format: 'date'
+}
+
 const obj = {
   firstName: 'Matteo',
   lastName: 'Collina',
   age: 32
 }
 
+const date = new Date()
+
 const multiArray = []
 
 const CJS = require('compile-json-stringify')
 const CJSStringify = CJS(schemaCJS)
 const CJSStringifyArray = CJS(arraySchemaCJS)
+const CJSStringifyDate = CJS(dateFormatSchemaCJS)
 const CJSStringifyString = CJS({ type: 'string' })
 
 const FJS = require('.')
 const stringify = FJS(schema)
 const stringifyArray = FJS(arraySchema)
+const stringifyDate = FJS(dateFormatSchema)
 const stringifyString = FJS({ type: 'string' })
 let str = ''
 
@@ -138,6 +154,18 @@ suite.add('compile-json-stringify obj', function () {
   CJSStringify(obj)
 })
 
+suite.add('JSON stringify date', function () {
+  JSON.stringify(date)
+})
+
+suite.add('fast-json-stringify date format', function () {
+  stringifyDate(date)
+})
+
+suite.add('compile-json-stringify date format', function () {
+  CJSStringifyDate(date)
+})
+
 suite.on('cycle', cycle)
 
 suite.run()

package/index.d.ts

@@ -64,6 +64,7 @@ declare namespace build {
 
   export interface StringSchema extends BaseSchema {
     type: "string";
+    format?: string;
   }
 
   export interface IntegerSchema extends BaseSchema {

package/index.js

@@ -47,7 +47,12 @@ function mergeLocation (source, dest) {
   }
 }
 
+const arrayItemsReferenceSerializersMap = new Map()
+const objectReferenceSerializersMap = new Map()
+
 function build (schema, options) {
+  arrayItemsReferenceSerializersMap.clear()
+  objectReferenceSerializersMap.clear()
   options = options || {}
   isValidSchema(schema)
   if (options.schema) {
@@ -144,6 +149,9 @@ function build (schema, options) {
     return dependenciesName
   }
 
+  arrayItemsReferenceSerializersMap.clear()
+  objectReferenceSerializersMap.clear()
+
   return (Function.apply(null, dependenciesName).apply(null, dependencies))
 }
 
@@ -285,10 +293,7 @@ function $asDatetime (date, skipQuotes) {
 function $asDate (date, skipQuotes) {
   const quotes = skipQuotes === true ? '' : '"'
   if (date instanceof Date) {
-    const year = new Intl.DateTimeFormat('en', { year: 'numeric' }).format(date)
-    const month = new Intl.DateTimeFormat('en', { month: '2-digit' }).format(date)
-    const day = new Intl.DateTimeFormat('en', { day: '2-digit' }).format(date)
-    return quotes + year + '-' + month + '-' + day + quotes
+    return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000 )).toISOString().slice(0, 10) + quotes
   } else if (date && typeof date.format === 'function') {
     return quotes + date.format('YYYY-MM-DD') + quotes
   } else {
@@ -397,51 +402,60 @@ function addPatternProperties (location) {
     } catch (err) {
       throw new Error(`${err.message}. Found at ${regex} matching ${JSON.stringify(pp[regex])}`)
     }
-    code += `
-        if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {
-    `
+
+    const ifPpKeyExists = `if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {`
+
     if (type === 'object') {
       code += `${buildObject(ppLocation, '', 'buildObjectPP' + index)}
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + buildObjectPP${index}(obj[keys[i]])
       `
     } else if (type === 'array') {
       code += `${buildArray(ppLocation, '', 'buildArrayPP' + index)}
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + buildArrayPP${index}(obj[keys[i]])
       `
     } else if (type === 'null') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) +':null'
       `
     } else if (type === 'string') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + ${stringSerializer}(obj[keys[i]])
       `
     } else if (type === 'integer') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asInteger(obj[keys[i]])
       `
     } else if (type === 'number') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asNumber(obj[keys[i]])
       `
     } else if (type === 'boolean') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asBoolean(obj[keys[i]])
       `
     } else if (type === undefined) {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asAny(obj[keys[i]])
       `
     } else {
       code += `
+        ${ifPpKeyExists}
         throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
       `
     }
@@ -920,6 +934,16 @@ function buildObject (location, code, name) {
       }
   `
   }
+
+  if (objectReferenceSerializersMap.has(schema)) {
+    code += `
+      return ${objectReferenceSerializersMap.get(schema)}(input)
+    }
+    `
+    return code
+  }
+  objectReferenceSerializersMap.set(schema, name)
+
   code += `
       var obj = ${toJSON('input')}
       var json = '{'
@@ -959,9 +983,6 @@ function buildArray (location, code, name, key = null) {
       }
     `
   }
-  code += `
-      var json = '['
-  `
   const laterCode = ''
 
   // default to any items type
@@ -975,8 +996,18 @@ function buildArray (location, code, name, key = null) {
       schema = location.schema
       schema[fjsCloned] = true
     }
+
     location = refFinder(schema.items.$ref, location)
     schema.items = location.schema
+
+    if (arrayItemsReferenceSerializersMap.has(schema.items)) {
+      code += `
+      return ${arrayItemsReferenceSerializersMap.get(schema.items)}(obj)
+      }
+      `
+      return code
+    }
+    arrayItemsReferenceSerializersMap.set(schema.items, name)
   }
 
   let result = { code: '', laterCode: '' }
@@ -1023,17 +1054,17 @@ function buildArray (location, code, name, key = null) {
 
   code += `
     var l = obj.length
-
+    var jsonOutput= ''
     for (var i = 0; i < l; i++) {
-      var jsonLastChar = json[json.length - 1]
+      var json = ''
+      ${result.code}
+      jsonOutput += json
 
-      if (i > 0 && jsonLastChar !== '[' && jsonLastChar !== ',') {
-        json += ','
+      if (json.length > 0 && i < l - 1) {
+        jsonOutput += ','
       }
-      ${result.code}
     }
-    json += ']'
-    return json
+    return \`[\${jsonOutput}]\`
   }
   ${result.laterCode}
   `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "2.7.8",
+  "version": "2.7.12",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",

package/test/recursion.test.js

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

package/test/types/test.ts

@@ -135,3 +135,11 @@ const schema11: Schema = {
 }
 
 build(schema11)({ something: 'a string', somethingElse: 42 })
+
+// String schema with format
+const schema12: Schema = {
+  type: 'string',
+  format: 'date-time'
+}
+
+build(schema12)(new Date())