fast-json-stringify 2.7.6 → 2.7.10

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.1.5
+        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.1.0
+      - uses: fastify/github-action-merge-dependabot@v2.4.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:
@@ -342,7 +345,7 @@ const stringify = fastJson({
           savedId: { type: 'string' }
         },
         // without "required" validation any object will match
-        required: ['saveId']
+        required: ['savedId']
       },
       {
         type: 'object',

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

@@ -72,21 +72,7 @@ function build (schema, options) {
   `
 
   code += `
-    ${$pad2Zeros.toString()}
-    ${$asAny.toString()}
-    ${$asString.toString()}
-    ${$asStringNullable.toString()}
-    ${$asStringSmall.toString()}
-    ${$asDatetime.toString()}
-    ${$asDate.toString()}
-    ${$asTime.toString()}
-    ${$asNumber.toString()}
-    ${$asNumberNullable.toString()}
-    ${$asInteger.toString()}
-    ${$asIntegerNullable.toString()}
-    ${$asNull.toString()}
-    ${$asBoolean.toString()}
-    ${$asBooleanNullable.toString()}
+    ${asFunctions}
 
     var isLong = ${isLong ? isLong.toString() : false}
 
@@ -116,19 +102,19 @@ function build (schema, options) {
       code = buildObject(location, code, main)
       break
     case 'string':
-      main = schema.nullable ? $asStringNullable.name : getStringSerializer(schema.format)
+      main = schema.nullable ? '$asStringNullable' : getStringSerializer(schema.format)
       break
     case 'integer':
-      main = schema.nullable ? $asIntegerNullable.name : $asInteger.name
+      main = schema.nullable ? '$asIntegerNullable' : '$asInteger'
       break
     case 'number':
-      main = schema.nullable ? $asNumberNullable.name : $asNumber.name
+      main = schema.nullable ? '$asNumberNullable' : '$asNumber'
       break
     case 'boolean':
-      main = schema.nullable ? $asBooleanNullable.name : $asBoolean.name
+      main = schema.nullable ? '$asBooleanNullable' : '$asBoolean'
       break
     case 'null':
-      main = $asNull.name
+      main = '$asNull'
       break
     case 'array':
       main = '$main'
@@ -233,6 +219,7 @@ function getTestSerializer (format) {
   return stringSerializerMap[format]
 }
 
+const asFunctions = `
 function $pad2Zeros (num) {
   const s = '00' + num
   return s[s.length - 2] + s[s.length - 1]
@@ -298,10 +285,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 {
@@ -372,7 +356,7 @@ function $asStringSmall (str) {
       surrogateFound = true
     }
     if (point === 34 || point === 92) {
-      result += str.slice(last, i) + '\\'
+      result += str.slice(last, i) + '\\\\'
       last = i
       found = true
     }
@@ -385,6 +369,7 @@ function $asStringSmall (str) {
   }
   return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
 }
+`
 
 function addPatternProperties (location) {
   const schema = location.schema
@@ -928,7 +913,7 @@ function buildObject (location, code, name) {
   if (schema.nullable) {
     code += `
       if(input === null) {
-        return '${$asNull()}';
+        return 'null';
       }
   `
   }
@@ -967,13 +952,10 @@ function buildArray (location, code, name, key = null) {
   if (schema.nullable) {
     code += `
       if(obj === null) {
-        return '${$asNull()}';
+        return 'null';
       }
     `
   }
-  code += `
-      var json = '['
-  `
   const laterCode = ''
 
   // default to any items type
@@ -1035,15 +1017,17 @@ function buildArray (location, code, name, key = null) {
 
   code += `
     var l = obj.length
-    var w = l - 1
+    var jsonOutput= ''
     for (var i = 0; i < l; i++) {
-      if (i > 0) {
-        json += ','
-      }
+      var json = ''
       ${result.code}
+      jsonOutput += json
+
+      if (json.length > 0 && i < l - 1) {
+        jsonOutput += ','
+      }
     }
-    json += ']'
-    return json
+    return \`[\${jsonOutput}]\`
   }
   ${result.laterCode}
   `
@@ -1226,9 +1210,12 @@ function nested (laterCode, name, key, location, subKey, isArray) {
           `
           laterCode = nestedResult.laterCode
         })
-        code += `
-          else json+= null
-        `
+
+        if (!isArray) {
+          code += `
+            else json+= null
+          `
+        }
       } else if (isEmpty(schema)) {
         code += `
           json += JSON.stringify(obj${accessor})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "2.7.6",
+  "version": "2.7.10",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -41,7 +41,8 @@
     "semver": "^7.1.0",
     "standard": "^16.0.1",
     "tap": "^15.0.0",
-    "typescript": "^4.0.2"
+    "typescript": "^4.0.2",
+    "webpack": "^5.40.0"
   },
   "dependencies": {
     "ajv": "^6.11.0",

package/test/oneof.test.js

@@ -401,3 +401,105 @@ test('oneOf object with field of type string with format or null', (t) => {
     prop: toStringify
   }), `{"prop":"${toStringify.toISOString()}"}`)
 })
+
+test('one array item match oneOf types', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['data'],
+    properties: {
+      data: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          oneOf: [
+            {
+              type: 'string'
+            },
+            {
+              type: 'number'
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  const responseWithMappedType = stringify({
+    data: [false, 'foo']
+  })
+
+  t.equal('{"data":["foo"]}', responseWithMappedType)
+})
+
+test('some array items match oneOf types', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['data'],
+    properties: {
+      data: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          oneOf: [
+            {
+              type: 'string'
+            },
+            {
+              type: 'number'
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  const responseWithMappedTypes = stringify({
+    data: [false, 'foo', true, 5]
+  })
+
+  t.equal('{"data":["foo",5]}', responseWithMappedTypes)
+})
+
+test('all array items does not match oneOf types', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['data'],
+    properties: {
+      data: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          oneOf: [
+            {
+              type: 'string'
+            },
+            {
+              type: 'number'
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  const emptyResponse = stringify({
+    data: [null, false, true, undefined, [], {}]
+  })
+
+  t.equal('{"data":[]}', emptyResponse)
+})

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())

package/test/webpack.test.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const test = require('tap').test
+const webpack = require('webpack')
+const path = require('path')
+
+test('the library should work with webpack', async (t) => {
+  t.plan(1)
+  const targetdir = path.resolve(__dirname, '..', '.cache')
+  const targetname = path.join(targetdir, 'webpacktest.js')
+  const wopts = {
+    entry: path.resolve(__dirname, '..', 'index.js'),
+    mode: 'production',
+    target: 'node',
+    output: {
+      path: targetdir,
+      filename: 'webpacktest.js',
+      library: {
+        name: 'fastJsonStringify',
+        type: 'umd'
+      }
+    }
+  }
+  await new Promise((resolve, reject) => {
+    webpack(wopts, (err, stats) => {
+      if (err) { reject(err) } else { resolve(stats) };
+    })
+  })
+  const build = require(targetname)
+  const stringify = build({
+    title: 'webpack should not rename code to be executed',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      },
+      bar: {
+        type: 'boolean'
+      }
+    },
+    patternProperties: {
+      foo: {
+        type: 'number'
+      }
+    }
+  })
+
+  const obj = { foo: '42', bar: true }
+  t.equal(stringify(obj), '{"foo":"42","bar":true}')
+})