fast-json-stringify 3.1.0 → 4.1.0

package/.github/workflows/benchmark.yml

@@ -21,13 +21,13 @@ jobs:
       matrix:
         node-version: [12, 14, 16]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           persist-credentials: false
           ref: ${{github.event.pull_request.head.sha}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/setup-node@v2
+      - uses: actions/setup-node@v3
         with:
           node-version: ${{ matrix.node-version }}
 
@@ -46,7 +46,7 @@ jobs:
           echo "::set-output name=BENCH_RESULT${{matrix.node-version}}::$content"
 
       # main benchmark
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           ref: 'master'
 

package/.github/workflows/ci.yml

@@ -12,36 +12,6 @@ on:
 
 jobs:
   test:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        node-version: [14, 16, 17]
-        os: [macos-latest, ubuntu-latest, windows-latest]
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Use Node.js
-        uses: actions/setup-node@v2
-        with:
-          node-version: ${{ matrix.node-version }}
-
-      - name: Install Dependencies
-        run: |
-          npm install --ignore-scripts
-
-      - name: Run Tests
-        run: |
-          npm test
-
-  automerge:
-    needs: test
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-      contents: write
-    steps:
-      - uses: fastify/github-action-merge-dependabot@v3
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          target: minor
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
+    with:
+      auto-merge-exclude: 'chalk'

package/README.md

@@ -2,13 +2,12 @@
 
 ![CI](https://github.com/fastify/fast-json-stringify/workflows/CI/badge.svg)
 [![NPM version](https://img.shields.io/npm/v/fast-json-stringify.svg?style=flat)](https://www.npmjs.com/package/fast-json-stringify)
-[![Known Vulnerabilities](https://snyk.io/test/github/fastify/fast-json-stringify/badge.svg)](https://snyk.io/test/github/fastify/fast-json-stringify)
 [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
 [![NPM downloads](https://img.shields.io/npm/dm/fast-json-stringify.svg?style=flat)](https://www.npmjs.com/package/fast-json-stringify)
 
 
-__fast-json-stringify__ is significantly faster than `JSON.stringify()` for small payloads.  
-Its performance advantage shrinks as your payload grows.  
+__fast-json-stringify__ is significantly faster than `JSON.stringify()` for small payloads.
+Its performance advantage shrinks as your payload grows.
 It pairs well with [__flatstr__](https://www.npmjs.com/package/flatstr), which triggers a V8 optimization that improves performance when eventually converting the string to a `Buffer`.
 
 
@@ -63,6 +62,8 @@ compile-json-stringify date format x 1,086,187 ops/sec ±0.16% (99 runs sampled)
  - <a href="#nullable">`Nullable`</a>
  - <a href="#largearrays">`Large Arrays`</a>
 - <a href="#security">`Security Notice`</a>
+- <a href="#debug">`Debug Mode`</a>
+- <a href="#standalone">`Standalone Mode`</a>
 - <a href="#acknowledgements">`Acknowledgements`</a>
 - <a href="#license">`License`</a>
 
@@ -160,18 +161,17 @@ And nested ones, too.
 
 **Note**: In the case of string formatted Date and not Date Object, there will be no manipulation on it. It should be properly formatted.
 
-Example with a MomentJS object:
+Example with a Date object:
 
 ```javascript
-const moment = require('moment')
-
 const stringify = fastJson({
   title: 'Example Schema with string date-time field',
   type: 'string',
   format: 'date-time'
 })
 
-console.log(stringify(moment())) // '"YYYY-MM-DDTHH:mm:ss.sssZ"'
+const date = new Date()
+console.log(stringify(date)) // '"YYYY-MM-DDTHH:mm:ss.sssZ"'
 ```
 
 
@@ -287,7 +287,7 @@ console.log(stringify(obj)) // '{"matchfoo":"42","otherfoo":"str","matchnum":3,"
 If *additionalProperties* is not present or is set to `false`, every property that is not explicitly listed in the *properties* and *patternProperties* objects,will be ignored, as described in <a href="#missingFields">Missing fields</a>.
 Missing fields are ignored to avoid having to rewrite objects before serializing. However, other schema rules would throw in similar situations.
 If *additionalProperties* is set to `true`, it will be used by `JSON.stringify` to stringify the additional properties. If you want to achieve maximum performance, we strongly encourage you to use a fixed schema where possible.
-The additional properties will always be serialzied at the end of the object.
+The additional properties will always be serialized at the end of the object.
 Example:
 ```javascript
 const stringify = fastJson({
@@ -665,13 +665,37 @@ const debugCompiled = fastJson({
       type: 'string'
     }
   }
-}, { debugMode: true })
+}, { mode: 'debug' })
+
+console.log(debugCompiled) // it is a object contain code, ajv instance
+const rawString = debugCompiled.code // it is the generated code
+console.log(rawString) 
+
+const stringify = fastJson.restore(debugCompiled) // use the generated string to get back the `stringify` function
+console.log(stringify({ firstName: 'Foo', surname: 'bar' })) // '{"firstName":"Foo"}'
+```
+
+<a name="standalone"></a>
+### Standalone Mode
 
-console.log(debugCompiled) // it is an array of functions that can create your `stringify` function
-console.log(debugCompiled.toString()) // print a "ready to read" string function, you can save it to a file
+The standalone mode is used to compile the code that can be directly run by `node`
+itself. You need to install `fast-json-stringify`, `ajv`, `fast-uri` and `ajv-formats`
+in order to let the standalone code works.
+
+```js
+const fs = require('fs')
+const code = fastJson({
+  title: 'default string',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'string'
+    }
+  }
+}, { mode: 'standalone' })
 
-const rawString = debugCompiled.toString()
-const stringify = fastJson.restore(rawString) // use the generated string to get back the `stringify` function
+fs.writeFileSync('stringify.js', code)
+const stringify = require('stringify.js')
 console.log(stringify({ firstName: 'Foo', surname: 'bar' })) // '{"firstName":"Foo"}'
 ```
 

package/ajv.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const Ajv = require('ajv')
+const fastUri = require('fast-uri')
+const ajvFormats = require('ajv-formats')
+
+module.exports = buildAjv
+
+function buildAjv (options) {
+  const ajvInstance = new Ajv({ ...options, strictSchema: false, uriResolver: fastUri })
+  ajvFormats(ajvInstance)
+
+  const validateDateTimeFormat = ajvFormats.get('date-time').validate
+  const validateDateFormat = ajvFormats.get('date').validate
+  const validateTimeFormat = ajvFormats.get('time').validate
+
+  ajvInstance.addKeyword({
+    keyword: 'fjs_date_type',
+    validate: (schema, date) => {
+      if (date instanceof Date) {
+        return true
+      }
+      if (schema === 'date-time') {
+        return validateDateTimeFormat(date)
+      }
+      if (schema === 'date') {
+        return validateDateFormat(date)
+      }
+      if (schema === 'time') {
+        return validateTimeFormat(date)
+      }
+      return false
+    }
+  })
+
+  return ajvInstance
+}

package/benchmark/bench-cmp-branch.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const { spawn } = require('child_process')
+
+const chalk = require('chalk')
+const inquirer = require('inquirer')
+const simpleGit = require('simple-git')
+
+const git = simpleGit(process.cwd())
+
+const COMMAND = 'npm run bench'
+const DEFAULT_BRANCH = 'master'
+const PERCENT_THRESHOLD = 5
+
+async function selectBranchName (message, branches) {
+  const result = await inquirer.prompt([{
+    type: 'list',
+    name: 'branch',
+    choices: branches,
+    loop: false,
+    pageSize: 20,
+    message
+  }])
+  return result.branch
+}
+
+async function executeCommandOnBranch (command, branch) {
+  console.log(chalk.grey(`Checking out "${branch}"`))
+  await git.checkout(branch)
+
+  console.log(chalk.grey(`Execute "${command}"`))
+  const childProcess = spawn(command, { stdio: 'pipe', shell: true })
+
+  let result = ''
+  childProcess.stdout.on('data', (data) => {
+    process.stdout.write(data.toString())
+    result += data.toString()
+  })
+
+  await new Promise(resolve => childProcess.on('close', resolve))
+
+  console.log()
+
+  return parseBenchmarksStdout(result)
+}
+
+function parseBenchmarksStdout (text) {
+  const results = []
+
+  const lines = text.split('\n')
+  for (const line of lines) {
+    const match = /^(.+?)(\.*) x (.+) ops\/sec .*$/.exec(line)
+    if (match !== null) {
+      results.push({
+        name: match[1],
+        alignedName: match[1] + match[2],
+        result: parseInt(match[3].split(',').join(''))
+      })
+    }
+  }
+
+  return results
+}
+
+function compareResults (featureBranch, mainBranch) {
+  for (const { name, alignedName, result: mainBranchResult } of mainBranch) {
+    const featureBranchBenchmark = featureBranch.find(result => result.name === name)
+    if (featureBranchBenchmark) {
+      const featureBranchResult = featureBranchBenchmark.result
+      const percent = (featureBranchResult - mainBranchResult) * 100 / mainBranchResult
+      const roundedPercent = Math.round(percent * 100) / 100
+
+      const percentString = roundedPercent > 0 ? `+${roundedPercent}%` : `${roundedPercent}%`
+      const message = alignedName + percentString.padStart(7, '.')
+
+      if (roundedPercent > PERCENT_THRESHOLD) {
+        console.log(chalk.green(message))
+      } else if (roundedPercent < -PERCENT_THRESHOLD) {
+        console.log(chalk.red(message))
+      } else {
+        console.log(message)
+      }
+    }
+  }
+}
+
+(async function () {
+  const branches = await git.branch()
+  const currentBranch = branches.branches[branches.current]
+
+  let featureBranch = null
+  let mainBranch = null
+
+  if (process.argv[2] === '--ci') {
+    featureBranch = currentBranch.name
+    mainBranch = DEFAULT_BRANCH
+  } else {
+    featureBranch = await selectBranchName('Select the branch you want to compare (feature branch):', branches.all)
+    mainBranch = await selectBranchName('Select the branch you want to compare with (main branch):', branches.all)
+  }
+
+  try {
+    const featureBranchResult = await executeCommandOnBranch(COMMAND, featureBranch)
+    const mainBranchResult = await executeCommandOnBranch(COMMAND, mainBranch)
+    compareResults(featureBranchResult, mainBranchResult)
+  } catch (error) {
+    console.error('Switch to origin branch due to an error', error.message)
+  }
+
+  await git.checkout(currentBranch.commit)
+  await git.checkout(currentBranch.name)
+
+  console.log(chalk.gray(`Back to ${currentBranch.name} ${currentBranch.commit}`))
+})()

package/{bench.js → benchmark/bench-cmp-lib.js}

@@ -5,7 +5,7 @@ const suite = new benchmark.Suite()
 
 const STR_LEN = 1e4
 const LARGE_ARRAY_SIZE = 2e4
-const MULTI_ARRAY_LENGHT = 1e3
+const MULTI_ARRAY_LENGTH = 1e3
 
 const schema = {
   title: 'Example Schema',
@@ -93,7 +93,7 @@ const obj = {
 
 const date = new Date()
 
-const multiArray = new Array(MULTI_ARRAY_LENGHT)
+const multiArray = new Array(MULTI_ARRAY_LENGTH)
 const largeArray = new Array(LARGE_ARRAY_SIZE)
 
 const CJS = require('compile-json-stringify')
@@ -102,7 +102,7 @@ const CJSStringifyArray = CJS(arraySchemaCJS)
 const CJSStringifyDate = CJS(dateFormatSchemaCJS)
 const CJSStringifyString = CJS({ type: 'string' })
 
-const FJS = require('.')
+const FJS = require('..')
 const stringify = FJS(schema)
 const stringifyArrayDefault = FJS(arraySchema)
 const stringifyArrayJSONStringify = FJS(arraySchema, {
@@ -158,7 +158,7 @@ for (let i = STR_LEN; i < LARGE_ARRAY_SIZE; ++i) {
 
 Number(str)
 
-for (let i = 0; i < MULTI_ARRAY_LENGHT; i++) {
+for (let i = 0; i < MULTI_ARRAY_LENGTH; i++) {
   multiArray[i] = obj
 }
 

package/benchmark/bench-thread.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { workerData: benchmark, parentPort } = require('worker_threads')
+
+const Benchmark = require('benchmark')
+Benchmark.options.minSamples = 500
+
+const suite = Benchmark.Suite()
+
+const FJS = require('..')
+const stringify = FJS(benchmark.schema)
+
+suite
+  .add(benchmark.name, () => {
+    stringify(benchmark.input)
+  })
+  .on('cycle', (event) => {
+    parentPort.postMessage(String(event.target))
+  })
+  .on('complete', () => {})
+  .run()

package/benchmark/bench.js

@@ -0,0 +1,251 @@
+'use strict'
+
+const path = require('path')
+const { Worker } = require('worker_threads')
+
+const BENCH_THREAD_PATH = path.join(__dirname, 'bench-thread.js')
+
+const LONG_STRING_LENGTH = 1e4
+const SHORT_ARRAY_SIZE = 1e3
+
+const shortArrayOfNumbers = new Array(SHORT_ARRAY_SIZE)
+const shortArrayOfIntegers = new Array(SHORT_ARRAY_SIZE)
+const shortArrayOfShortStrings = new Array(SHORT_ARRAY_SIZE)
+const shortArrayOfLongStrings = new Array(SHORT_ARRAY_SIZE)
+const shortArrayOfMultiObject = new Array(SHORT_ARRAY_SIZE)
+
+function getRandomInt (max) {
+  return Math.floor(Math.random() * max)
+}
+
+let longString = ''
+for (let i = 0; i < LONG_STRING_LENGTH; i++) {
+  longString += i
+  if (i % 100 === 0) {
+    longString += '"'
+  }
+}
+
+for (let i = 0; i < SHORT_ARRAY_SIZE; i++) {
+  shortArrayOfNumbers[i] = getRandomInt(1000)
+  shortArrayOfIntegers[i] = getRandomInt(1000)
+  shortArrayOfShortStrings[i] = 'hello world'
+  shortArrayOfLongStrings[i] = longString
+  shortArrayOfMultiObject[i] = { s: 'hello world', n: 42, b: true }
+}
+
+const benchmarks = [
+  {
+    name: 'short string',
+    schema: {
+      type: 'string'
+    },
+    input: 'hello world'
+  },
+  {
+    name: 'long string',
+    schema: {
+      type: 'string'
+    },
+    input: longString
+  },
+  {
+    name: 'number',
+    schema: {
+      type: 'number'
+    },
+    input: 42
+  },
+  {
+    name: 'integer',
+    schema: {
+      type: 'integer'
+    },
+    input: 42
+  },
+  {
+    name: 'formatted date-time',
+    schema: {
+      type: 'string',
+      format: 'date-time'
+    },
+    input: new Date()
+  },
+  {
+    name: 'formatted date',
+    schema: {
+      type: 'string',
+      format: 'date'
+    },
+    input: new Date()
+  },
+  {
+    name: 'formatted time',
+    schema: {
+      type: 'string',
+      format: 'time'
+    },
+    input: new Date()
+  },
+  {
+    name: 'short array of numbers',
+    schema: {
+      type: 'array',
+      items: { type: 'number' }
+    },
+    input: shortArrayOfNumbers
+  },
+  {
+    name: 'short array of integers',
+    schema: {
+      type: 'array',
+      items: { type: 'integer' }
+    },
+    input: shortArrayOfIntegers
+  },
+  {
+    name: 'short array of short strings',
+    schema: {
+      type: 'array',
+      items: { type: 'string' }
+    },
+    input: shortArrayOfShortStrings
+  },
+  {
+    name: 'short array of long strings',
+    schema: {
+      type: 'array',
+      items: { type: 'string' }
+    },
+    input: shortArrayOfShortStrings
+  },
+  {
+    name: 'short array of objects with properties of different types',
+    schema: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          s: { type: 'string' },
+          n: { type: 'number' },
+          b: { type: 'boolean' }
+        }
+      }
+    },
+    input: shortArrayOfMultiObject
+  },
+  {
+    name: 'object with number property',
+    schema: {
+      type: 'object',
+      properties: {
+        a: { type: 'number' }
+      }
+    },
+    input: { a: 42 }
+  },
+  {
+    name: 'object with integer property',
+    schema: {
+      type: 'object',
+      properties: {
+        a: { type: 'integer' }
+      }
+    },
+    input: { a: 42 }
+  },
+  {
+    name: 'object with short string property',
+    schema: {
+      type: 'object',
+      properties: {
+        a: { type: 'string' }
+      }
+    },
+    input: { a: 'hello world' }
+  },
+  {
+    name: 'object with long string property',
+    schema: {
+      type: 'object',
+      properties: {
+        a: { type: 'string' }
+      }
+    },
+    input: { a: longString }
+  },
+  {
+    name: 'object with properties of different types',
+    schema: {
+      type: 'object',
+      properties: {
+        s1: { type: 'string' },
+        n1: { type: 'number' },
+        b1: { type: 'boolean' },
+        s2: { type: 'string' },
+        n2: { type: 'number' },
+        b2: { type: 'boolean' },
+        s3: { type: 'string' },
+        n3: { type: 'number' },
+        b3: { type: 'boolean' },
+        s4: { type: 'string' },
+        n4: { type: 'number' },
+        b4: { type: 'boolean' },
+        s5: { type: 'string' },
+        n5: { type: 'number' },
+        b5: { type: 'boolean' }
+      }
+    },
+    input: {
+      s1: 'hello world',
+      n1: 42,
+      b1: true,
+      s2: 'hello world',
+      n2: 42,
+      b2: true,
+      s3: 'hello world',
+      n3: 42,
+      b3: true,
+      s4: 'hello world',
+      n4: 42,
+      b4: true,
+      s5: 'hello world',
+      n5: 42,
+      b5: true
+    }
+  }
+]
+
+async function runBenchmark (benchmark) {
+  const worker = new Worker(BENCH_THREAD_PATH, { workerData: benchmark })
+
+  return new Promise((resolve, reject) => {
+    let result = null
+    worker.on('error', reject)
+    worker.on('message', (benchResult) => {
+      result = benchResult
+    })
+    worker.on('exit', (code) => {
+      if (code === 0) {
+        resolve(result)
+      } else {
+        reject(new Error(`Worker stopped with exit code ${code}`))
+      }
+    })
+  })
+}
+
+async function runBenchmarks () {
+  let maxNameLength = 0
+  for (const benchmark of benchmarks) {
+    maxNameLength = Math.max(benchmark.name.length, maxNameLength)
+  }
+
+  for (const benchmark of benchmarks) {
+    benchmark.name = benchmark.name.padEnd(maxNameLength, '.')
+    const resultMessage = await runBenchmark(benchmark)
+    console.log(resultMessage)
+  }
+}
+
+runBenchmarks()

package/example.js

@@ -1,4 +1,3 @@
-const moment = require('moment')
 const fastJson = require('.')
 const stringify = fastJson({
   title: 'Example Schema',
@@ -67,12 +66,10 @@ console.log(stringify({
   lastName: 'Collina',
   age: 32,
   now: new Date(),
-  birthdate: moment(),
   reg: /"([^"]|\\")*"/,
   foo: 'hello',
   numfoo: 42,
   test: 42,
-  date: moment(),
   strtest: '23',
   arr: [{ str: 'stark' }, { str: 'lannister' }],
   obj: { bool: true },

package/index.d.ts

@@ -1,6 +1,10 @@
 import { Options as AjvOptions } from "ajv"
 declare namespace build {
   interface BaseSchema {
+    /**
+     * Schema id
+     */
+    $id?: string
     /**
      * Schema title
      */