fast-json-stringify 7.0.1 → 7.1.1

package/.github/dependabot.yml

@@ -34,6 +34,7 @@ updates:
       - dependency-name: "eslint"
       - dependency-name: "neostandard"
       - dependency-name: "@stylistic/*"
+      - dependency-name: "typescript" 
     open-pull-requests-limit: 10
     groups:
       # Production dependencies with breaking changes

package/.github/workflows/ci.yml

@@ -27,7 +27,7 @@ jobs:
     permissions:
       contents: write
       pull-requests: write
-    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v6
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@ef591e2186785d5ab36b9fe6a79c7ce2f1d94e57 # v7.0.0
     with:
       license-check: true
       lint: true

package/.github/workflows/lock-threads.yml

@@ -16,4 +16,4 @@ jobs:
     permissions:
       issues: write
       pull-requests: write
-    uses: fastify/workflows/.github/workflows/lock-threads.yml@v6
+    uses: fastify/workflows/.github/workflows/lock-threads.yml@ef591e2186785d5ab36b9fe6a79c7ce2f1d94e57 # v7.0.0

package/.github/workflows/release.yml

@@ -0,0 +1,24 @@
+name: Release the package
+
+on:
+  workflow_dispatch:
+    inputs:
+      semver:
+        description: 'Release bump type'
+        required: true
+        type: choice
+        options:
+          - patch
+          - minor
+          - major
+
+permissions: {}
+
+jobs:
+  release:
+    permissions:
+      id-token: write # required for npm provenance via OIDC
+      contents: write # required to push the release commit and the tag
+    uses: fastify/workflows/.github/workflows/reusable-release.yml@b1a11bce713bc857e52b2231fec3c89071ad3135
+    with:
+      semver: ${{ inputs.semver }}

package/README.md

@@ -121,15 +121,24 @@ const fastJson = require('fast-json-stringify')
 const stringify = fastJson(mySchema, {
   schema: { ... },
   ajv: { ... },
-  rounding: 'ceil'
+  rounding: 'ceil',
+  maxDepth: 100
 })
 ```
 
 - `schema`: external schemas references by $ref property. [More details](#ref)
 - `ajv`: [ajv v8 instance's settings](https://ajv.js.org/options.html) for those properties that require `ajv`. [More details](#anyof)
 - `rounding`: setup how the `integer` types will be rounded when not integers. [More details](#integer)
+- `maxDepth`: maximum number of nested schema levels allowed during compilation.
+Defaults to `100` and may be set from `0` to `100`. Schemas that exceed this limit
+are rejected before compilation.
+- `inlineValidators`: when using standalone mode, embed Ajv-generated validator functions in the output instead of compiling schemas at runtime. [More details](#standalone)
 - `largeArrayMechanism`: set the mechanism that should be used to handle large
 (by default `20000` or more items) arrays. [More details](#largearrays)
+- `compileValidators`: when `true`, the `ajv` validators used by `anyOf`, `oneOf` and
+`if/then/else` are compiled during `build()` instead of lazily, on the first serialization
+that reaches them. This makes `build()` slower but removes a potentially large one-off cost
+from the first `stringify()` call. Defaults to `false`.
 
 
 <a name="api"></a>
@@ -168,7 +177,7 @@ And nested ones, too.
 | `date`      | `2020-04-03`               |
 | `time`      | `09:11:08`                 |
 
-**Note**: In the case of a string formatted Date and not Date Object, there will be no manipulation on it. It should be properly formatted.
+**Note**: In the case of a string formatted Date and not Date Object, the value is not reformatted nor validated: it should already be properly formatted. It is only escaped, so that the resulting document is always valid JSON.
 
 Example with a Date object:
 
@@ -724,13 +733,21 @@ const code = fastJson({
       type: 'string'
     }
   }
-}, { mode: 'standalone' })
+}, { mode: 'standalone', inlineValidators: true })
 
 fs.writeFileSync('stringify.js', code)
 const stringify = require('stringify.js')
 console.log(stringify({ firstName: 'Foo', surname: 'bar' })) // '{"firstName":"Foo"}'
 ```
 
+Set `inlineValidators` to `true` to include the Ajv-generated functions used by
+`anyOf`, `oneOf`, and `if/then/else` in the same output file. This avoids
+rebuilding an Ajv instance and compiling their schemas at runtime. The
+generated module still requires `fast-json-stringify` for its serializer and
+may require Ajv runtime helpers used by the generated validation code. Custom
+Ajv formats used by these schemas must support Ajv's standalone code
+generation.
+
 <a name="acknowledgments"></a>
 ## Acknowledgments
 

package/benchmark/bench-cmp-lib.js

@@ -1,6 +1,8 @@
 'use strict'
 
+const assert = require('node:assert/strict')
 const { Bench } = require('tinybench')
+const apiResponses = require('./fixtures/api-responses')
 const suite = new Bench({
   name: 'Library Comparison Benchmarks',
   setup: (_task, mode) => {
@@ -173,139 +175,162 @@ for (let i = 0; i < MULTI_ARRAY_LENGTH; i++) {
   multiArray[i] = obj
 }
 
-suite.add('fast-json-stringify: creation', function () {
-  FJS(schema)
+// Some serializers return unflattened strings. Fastify calls Buffer.byteLength()
+// for Content-Length, which triggers flattening; include that cost in every case.
+suite.add('fast-json-stringify: creation and first stringify', function () {
+  Buffer.byteLength(FJS(schema)(obj))
 })
-suite.add('compile-json-stringify: creation', function () {
-  CJS(schemaCJS)
+suite.add('compile-json-stringify: creation and first stringify', function () {
+  Buffer.byteLength(CJS(schemaCJS)(obj))
 })
-suite.add('AJV: creation', function () {
-  ajv.compileSerializer(schemaAJVJTD)
+suite.add('AJV: creation and first stringify', function () {
+  Buffer.byteLength(ajv.compileSerializer(schemaAJVJTD)(obj))
 })
-suite.add('json-accelerator: creation', function () {
-  createAccelerator(schema)
+suite.add('json-accelerator: creation and first stringify', function () {
+  Buffer.byteLength(createAccelerator(schema)(obj))
 })
 
 suite.add('JSON.stringify: array', function () {
-  JSON.stringify(multiArray)
+  Buffer.byteLength(JSON.stringify(multiArray))
 })
 
 suite.add('fast-json-stringify [default]: array', function () {
-  stringifyArrayDefault(multiArray)
+  Buffer.byteLength(stringifyArrayDefault(multiArray))
 })
 
 suite.add('json-accelerator: array', function () {
-  accelArray(multiArray)
+  Buffer.byteLength(accelArray(multiArray))
 })
 
 suite.add('fast-json-stringify [json-stringify]: array', function () {
-  stringifyArrayJSONStringify(multiArray)
+  Buffer.byteLength(stringifyArrayJSONStringify(multiArray))
 })
 
 suite.add('compile-json-stringify: array', function () {
-  CJSStringifyArray(multiArray)
+  Buffer.byteLength(CJSStringifyArray(multiArray))
 })
 
 suite.add('AJV: array', function () {
-  ajvSerializeArray(multiArray)
+  Buffer.byteLength(ajvSerializeArray(multiArray))
 })
 
 suite.add('JSON.stringify: large array', function () {
-  JSON.stringify(largeArray)
+  Buffer.byteLength(JSON.stringify(largeArray))
 })
 
 suite.add('fast-json-stringify [default]: large array', function () {
-  stringifyArrayDefault(largeArray)
+  Buffer.byteLength(stringifyArrayDefault(largeArray))
 })
 
 suite.add('fast-json-stringify [json-stringify]: large array', function () {
-  stringifyArrayJSONStringify(largeArray)
+  Buffer.byteLength(stringifyArrayJSONStringify(largeArray))
 })
 
 suite.add('compile-json-stringify: large array', function () {
-  CJSStringifyArray(largeArray)
+  Buffer.byteLength(CJSStringifyArray(largeArray))
 })
 
 suite.add('AJV: large array', function () {
-  ajvSerializeArray(largeArray)
+  Buffer.byteLength(ajvSerializeArray(largeArray))
 })
 
 suite.add('JSON.stringify: long string', function () {
-  JSON.stringify(str)
+  Buffer.byteLength(JSON.stringify(str))
 })
 
 suite.add('fast-json-stringify: long string', function () {
-  stringifyString(str)
+  Buffer.byteLength(stringifyString(str))
 })
 
 suite.add('json-accelerator: long string', function () {
-  stringifyString(str)
+  Buffer.byteLength(stringifyString(str))
 })
 
 suite.add('compile-json-stringify: long string', function () {
-  CJSStringifyString(str)
+  Buffer.byteLength(CJSStringifyString(str))
 })
 
 suite.add('AJV: long string', function () {
-  ajvSerializeString(str)
+  Buffer.byteLength(ajvSerializeString(str))
 })
 
 suite.add('JSON.stringify: short string', function () {
-  JSON.stringify('hello world')
+  Buffer.byteLength(JSON.stringify('hello world'))
 })
 
 suite.add('fast-json-stringify: short string', function () {
-  stringifyString('hello world')
+  Buffer.byteLength(stringifyString('hello world'))
 })
 
 suite.add('json-accelerator: short string', function () {
-  accelString('hello world')
+  Buffer.byteLength(accelString('hello world'))
 })
 
 suite.add('compile-json-stringify: short string', function () {
-  CJSStringifyString('hello world')
+  Buffer.byteLength(CJSStringifyString('hello world'))
 })
 
 suite.add('AJV: short string', function () {
-  ajvSerializeString('hello world')
+  Buffer.byteLength(ajvSerializeString('hello world'))
 })
 
 suite.add('JSON.stringify: obj', function () {
-  JSON.stringify(obj)
+  Buffer.byteLength(JSON.stringify(obj))
 })
 
 suite.add('fast-json-stringify: obj', function () {
-  stringify(obj)
+  Buffer.byteLength(stringify(obj))
 })
 
 suite.add('json-accelerator: obj', function () {
-  accelStringify(obj)
+  Buffer.byteLength(accelStringify(obj))
 })
 
 suite.add('compile-json-stringify: obj', function () {
-  CJSStringify(obj)
+  Buffer.byteLength(CJSStringify(obj))
 })
 
 suite.add('AJV: obj', function () {
-  ajvSerialize(obj)
+  Buffer.byteLength(ajvSerialize(obj))
 })
 
 suite.add('JSON.stringify: date', function () {
-  JSON.stringify(date)
+  Buffer.byteLength(JSON.stringify(date))
 })
 
 suite.add('fast-json-stringify: date', function () {
-  stringifyDate(date)
+  Buffer.byteLength(stringifyDate(date))
 })
 
 suite.add('json-accelerate: date', function () {
-  accelDate(date)
+  Buffer.byteLength(accelDate(date))
 })
 
 suite.add('compile-json-stringify: date', function () {
-  CJSStringifyDate(date)
+  Buffer.byteLength(CJSStringifyDate(date))
 })
 
+for (const { name, schema: responseSchema, input } of apiResponses) {
+  const stringifyResponse = FJS(responseSchema)
+  // Check outside the timed loop that the schema preserves the complete response.
+  assert.deepStrictEqual(JSON.parse(stringifyResponse(input)), JSON.parse(JSON.stringify(input)))
+
+  suite.add(`JSON.stringify: ${name}`, function () {
+    Buffer.byteLength(JSON.stringify(input))
+  })
+  suite.add(`fast-json-stringify: ${name}`, function () {
+    Buffer.byteLength(stringifyResponse(input))
+  })
+}
+
+if (process.argv.includes('--fjs-vs-json')) {
+  for (const task of suite.tasks) {
+    if (!task.name.startsWith('fast-json-stringify') && !task.name.startsWith('JSON.stringify:')) {
+      suite.remove(task.name)
+    }
+  }
+}
+
 suite.run().then(() => {
   const results = suite.tasks.map(task => ({
     name: task.name,

package/benchmark/bench-thread.js

@@ -15,10 +15,16 @@ const bench = new Bench({
 })
 
 const FJS = require('..')
-const stringify = FJS(benchmark.schema)
+const stringify = benchmark.compile ? null : FJS(benchmark.schema, benchmark.options)
 
 bench.add(benchmark.name, () => {
-  stringify(benchmark.input)
+  // Some serializers return unflattened strings. Fastify calls Buffer.byteLength()
+  // for Content-Length, which triggers flattening; include that cost here too.
+  if (benchmark.compile) {
+    Buffer.byteLength(FJS(benchmark.schema, benchmark.options)(benchmark.input))
+  } else {
+    Buffer.byteLength(stringify(benchmark.input))
+  }
 }).run().then(() => {
   const task = bench.tasks[0]
   const hz = task.result.throughput.mean // ops/sec

package/benchmark/bench.js

@@ -300,6 +300,92 @@ const benchmarks = [
     },
     input: { firstName: 'Max', lastName: 'Power', age: 22 }
   },
+  {
+    name: 'oneOf external refs compile and first stringify',
+    compile: true,
+    schema: {
+      title: 'External refs oneOf schema',
+      type: 'object',
+      properties: {
+        content: {
+          oneOf: [
+            { $ref: 'BenchmarkFoo#' },
+            { $ref: 'BenchmarkBar#' },
+            { $ref: 'BenchmarkBaz#' }
+          ]
+        }
+      }
+    },
+    options: {
+      schema: {
+        BenchmarkFoo: {
+          type: 'object',
+          properties: {
+            kind: { const: 'foo' },
+            title: { type: 'string' },
+            count: { type: 'integer' },
+            flags: {
+              type: 'array',
+              items: { type: 'string' }
+            }
+          },
+          required: ['kind', 'title', 'count', 'flags'],
+          additionalProperties: false
+        },
+        BenchmarkBar: {
+          type: 'object',
+          properties: {
+            kind: { const: 'bar' },
+            name: { type: 'string' },
+            value: { type: 'number' },
+            meta: {
+              type: 'object',
+              properties: {
+                active: { type: 'boolean' },
+                tags: {
+                  type: 'array',
+                  items: { type: 'string' }
+                }
+              },
+              required: ['active', 'tags'],
+              additionalProperties: false
+            }
+          },
+          required: ['kind', 'name', 'value', 'meta'],
+          additionalProperties: false
+        },
+        BenchmarkBaz: {
+          type: 'object',
+          properties: {
+            kind: { const: 'baz' },
+            id: { type: 'string' },
+            nested: {
+              type: 'object',
+              properties: {
+                score: { type: 'number' },
+                note: { type: 'string' }
+              },
+              required: ['score', 'note'],
+              additionalProperties: false
+            }
+          },
+          required: ['kind', 'id', 'nested'],
+          additionalProperties: false
+        }
+      }
+    },
+    input: {
+      content: {
+        kind: 'bar',
+        name: 'benchmark',
+        value: 42.5,
+        meta: {
+          active: true,
+          tags: ['one', 'two', 'three']
+        }
+      }
+    }
+  },
   {
     name: 'object with const string property',
     schema: {