fast-json-stringify 6.3.0 → 7.0.0

package/.github/workflows/ci.yml

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

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

@@ -0,0 +1,19 @@
+name: Lock Threads
+
+on:
+  schedule:
+    - cron: '0 0 1 * *'
+  workflow_dispatch:
+
+concurrency:
+  group: lock
+
+permissions:
+  contents: read
+
+jobs:
+  lock-threads:
+    permissions:
+      issues: write
+      pull-requests: write
+    uses: fastify/workflows/.github/workflows/lock-threads.yml@v6

package/LICENSE

@@ -1,9 +1,7 @@
 MIT License
 
 Copyright (c) 2016-present Matteo Collina
-Copyright (c) 2016-present The Fastify team
-
-The Fastify team members are listed at https://github.com/fastify/fastify#team.
+Copyright (c) 2016-present The Fastify team <https://github.com/fastify/fastify#team>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/benchmark/bench-cmp-lib.js

@@ -169,155 +169,171 @@ for (let i = STR_LEN; i < LARGE_ARRAY_SIZE; ++i) {
   }
 }
 
-Number(str)
-
 for (let i = 0; i < MULTI_ARRAY_LENGTH; i++) {
   multiArray[i] = obj
 }
 
-suite.add('FJS creation', function () {
+suite.add('fast-json-stringify: creation', function () {
   FJS(schema)
 })
-suite.add('CJS creation', function () {
+suite.add('compile-json-stringify: creation', function () {
   CJS(schemaCJS)
 })
-suite.add('AJV Serialize creation', function () {
+suite.add('AJV: creation', function () {
   ajv.compileSerializer(schemaAJVJTD)
 })
-suite.add('json-accelerator creation', function () {
+suite.add('json-accelerator: creation', function () {
   createAccelerator(schema)
 })
 
-suite.add('JSON.stringify array', function () {
+suite.add('JSON.stringify: array', function () {
   JSON.stringify(multiArray)
 })
 
-suite.add('fast-json-stringify array default', function () {
+suite.add('fast-json-stringify [default]: array', function () {
   stringifyArrayDefault(multiArray)
 })
 
-suite.add('json-accelerator array', function () {
+suite.add('json-accelerator: array', function () {
   accelArray(multiArray)
 })
 
-suite.add('fast-json-stringify array json-stringify', function () {
+suite.add('fast-json-stringify [json-stringify]: array', function () {
   stringifyArrayJSONStringify(multiArray)
 })
 
-suite.add('compile-json-stringify array', function () {
+suite.add('compile-json-stringify: array', function () {
   CJSStringifyArray(multiArray)
 })
 
-suite.add('AJV Serialize array', function () {
+suite.add('AJV: array', function () {
   ajvSerializeArray(multiArray)
 })
 
-suite.add('JSON.stringify large array', function () {
+suite.add('JSON.stringify: large array', function () {
   JSON.stringify(largeArray)
 })
 
-suite.add('fast-json-stringify large array default', function () {
+suite.add('fast-json-stringify [default]: large array', function () {
   stringifyArrayDefault(largeArray)
 })
 
-suite.add('fast-json-stringify large array json-stringify', function () {
+suite.add('fast-json-stringify [json-stringify]: large array', function () {
   stringifyArrayJSONStringify(largeArray)
 })
 
-suite.add('compile-json-stringify large array', function () {
+suite.add('compile-json-stringify: large array', function () {
   CJSStringifyArray(largeArray)
 })
 
-suite.add('AJV Serialize large array', function () {
+suite.add('AJV: large array', function () {
   ajvSerializeArray(largeArray)
 })
 
-suite.add('JSON.stringify long string', function () {
+suite.add('JSON.stringify: long string', function () {
   JSON.stringify(str)
 })
 
-suite.add('fast-json-stringify long string', function () {
+suite.add('fast-json-stringify: long string', function () {
   stringifyString(str)
 })
 
-suite.add('json-accelerator long string', function () {
+suite.add('json-accelerator: long string', function () {
   stringifyString(str)
 })
 
-suite.add('compile-json-stringify long string', function () {
+suite.add('compile-json-stringify: long string', function () {
   CJSStringifyString(str)
 })
 
-suite.add('AJV Serialize long string', function () {
+suite.add('AJV: long string', function () {
   ajvSerializeString(str)
 })
 
-suite.add('JSON.stringify short string', function () {
+suite.add('JSON.stringify: short string', function () {
   JSON.stringify('hello world')
 })
 
-suite.add('fast-json-stringify short string', function () {
+suite.add('fast-json-stringify: short string', function () {
   stringifyString('hello world')
 })
 
-suite.add('json-accelerator short string', function () {
+suite.add('json-accelerator: short string', function () {
   accelString('hello world')
 })
 
-suite.add('compile-json-stringify short string', function () {
+suite.add('compile-json-stringify: short string', function () {
   CJSStringifyString('hello world')
 })
 
-suite.add('AJV Serialize short string', function () {
+suite.add('AJV: short string', function () {
   ajvSerializeString('hello world')
 })
 
-suite.add('JSON.stringify obj', function () {
+suite.add('JSON.stringify: obj', function () {
   JSON.stringify(obj)
 })
 
-suite.add('fast-json-stringify obj', function () {
+suite.add('fast-json-stringify: obj', function () {
   stringify(obj)
 })
 
-suite.add('json-accelerator obj', function () {
+suite.add('json-accelerator: obj', function () {
   accelStringify(obj)
 })
 
-suite.add('compile-json-stringify obj', function () {
+suite.add('compile-json-stringify: obj', function () {
   CJSStringify(obj)
 })
 
-suite.add('AJV Serialize obj', function () {
+suite.add('AJV: obj', function () {
   ajvSerialize(obj)
 })
 
-suite.add('JSON stringify date', function () {
+suite.add('JSON.stringify: date', function () {
   JSON.stringify(date)
 })
 
-suite.add('fast-json-stringify date format', function () {
+suite.add('fast-json-stringify: date', function () {
   stringifyDate(date)
 })
 
-suite.add('json-accelerate date format', function () {
+suite.add('json-accelerate: date', function () {
   accelDate(date)
 })
 
-suite.add('compile-json-stringify date format', function () {
+suite.add('compile-json-stringify: date', function () {
   CJSStringifyDate(date)
 })
 
 suite.run().then(() => {
-  for (const task of suite.tasks) {
-    const hz = task.result.throughput.mean // ops/sec
-    const rme = task.result.latency.rme // relative margin of error (%)
-    const samples = task.result.latency.df + 1 // degrees of freedom + 1 = sample count
+  const results = suite.tasks.map(task => ({
+    name: task.name,
+    hz: task.result.throughput.mean,
+    rme: task.result.latency.rme,
+    samples: task.result.latency.df + 1
+  }))
+
+  const scenarios = {}
+  for (const result of results) {
+    const [library, scenario] = result.name.split(':').map(s => s.trim())
+
+    if (!scenarios[scenario]) scenarios[scenario] = []
+    scenarios[scenario].push({ ...result, library })
+  }
 
-    const formattedHz = hz.toLocaleString('en-US', { maximumFractionDigits: 0 })
-    const formattedRme = rme.toFixed(2)
+  for (const [scenario, tasks] of Object.entries(scenarios)) {
+    console.log(`\n--- ${scenario} ---`)
+    const sorted = tasks.sort((a, b) => b.hz - a.hz)
+    const winner = sorted[0]
 
-    const output = `${task.name} x ${formattedHz} ops/sec ±${formattedRme}% (${samples} runs sampled)`
-    console.log(output)
+    for (const task of sorted) {
+      const formattedHz = task.hz.toLocaleString('en-US', { maximumFractionDigits: 0 })
+      const formattedRme = task.rme.toFixed(2)
+      const isWinner = task === winner
+      const prefix = isWinner ? '🏆 ' : '   '
+
+      console.log(`${prefix}${task.library.padEnd(40)} x ${formattedHz.padStart(15)} ops/sec ±${formattedRme}% (${task.samples} runs sampled)`)
+    }
   }
 }).catch(err => console.error(`Error: ${err.message}`))

package/index.js

@@ -222,10 +222,6 @@ function build (schema, options) {
     }
   }
 
-  if (options.debugMode) {
-    options.mode = 'debug'
-  }
-
   if (options.mode === 'debug') {
     return {
       validator,
@@ -568,7 +564,7 @@ function buildObject (context, location, input) {
   const jsonPointer = location.jsonPointer || ''
   const fullPath = `${schemaId}#${jsonPointer}`
 
-  if (context.recursivePaths.has(fullPath) || context.buildingSet.has(schema)) {
+  if (context.recursivePaths.has(fullPath) || context.buildingSet.has(schema) || schemaId !== '') {
     const functionName = generateFuncName(context)
     context.functionsNamesBySchema.set(schema, functionName)
 
@@ -627,7 +623,7 @@ function buildArray (context, location, input) {
   const jsonPointer = location.jsonPointer || ''
   const fullPath = `${schemaId}#${jsonPointer}`
 
-  if (context.recursivePaths.has(fullPath) || context.buildingSet.has(schema)) {
+  if (context.recursivePaths.has(fullPath) || context.buildingSet.has(schema) || schemaId !== '') {
     const functionName = generateFuncName(context)
     context.functionsNamesBySchema.set(schema, functionName)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "6.3.0",
+  "version": "7.0.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "type": "commonjs",
@@ -12,7 +12,7 @@
     "benchmark": "node --expose-gc ./benchmark/bench-cmp-lib.js",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
-    "test:typescript": "tsd",
+    "test:typescript": "tstyche",
     "test:unit": "c8 node --test",
     "test": "npm run test:unit && npm run test:typescript"
   },
@@ -62,19 +62,19 @@
     }
   ],
   "devDependencies": {
-    "@sinclair/typebox": "^0.34.48",
-    "c8": "^10.1.3",
+    "c8": "^11.0.0",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
     "eslint": "^9.39.2",
     "fast-json-stringify": ".",
     "is-my-json-valid": "^2.20.6",
     "json-accelerator": "^0.1.7",
-    "neostandard": "^0.12.2",
+    "neostandard": "^0.13.0",
     "simple-git": "^3.30.0",
     "tinybench": "^6.0.0",
-    "tsd": "^0.33.0",
-    "typescript": "^5.9.3",
+    "tstyche": "^7.1.0",
+    "typebox": "^1.0.81",
+    "typescript": "~6.0.2",
     "webpack": "^5.104.1"
   },
   "dependencies": {

package/test/anyof.test.js

@@ -790,3 +790,23 @@ test('should build merged schemas twice', (t) => {
     t.assert.equal(stringify({ enums: 'BAR' }), '{"enums":"BAR"}')
   }
 })
+
+test('invalid anyOf schema', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      prop: {
+        anyOf: 'not array'  // invalid, anyOf must be array
+      }
+    }
+  }
+
+  try {
+    build(schema)
+    t.assert.fail('Should throw')
+  } catch (err) {
+    t.assert.ok(err.message.includes('schema is invalid'))
+  }
+})

package/test/array.test.js

@@ -386,6 +386,28 @@ test('array items is a schema and additionalItems is false', (t) => {
   t.assert.equal(validate({ foo: ['foo', 'bar'] }), true)
 })
 
+test('array items is a list of schema and additionalItems is a schema', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'array',
+        items: [
+          { type: 'string' }
+        ],
+        additionalItems: { type: 'number' }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const result = stringify({ foo: ['foo', 42] })
+
+  t.assert.equal(result, '{"foo":["foo",42]}')
+})
+
 // https://github.com/fastify/fast-json-stringify/issues/279
 test('object array with anyOf and symbol', (t) => {
   t.plan(1)

package/test/debug-mode.test.js

@@ -22,7 +22,7 @@ function build (opts) {
 
 test('activate debug mode', t => {
   t.plan(5)
-  const debugMode = build({ debugMode: true })
+  const debugMode = build({ mode: 'debug' })
 
   t.assert.ok(typeof debugMode === 'object')
   t.assert.ok(debugMode.ajv instanceof Ajv)
@@ -31,21 +31,9 @@ test('activate debug mode', t => {
   t.assert.ok(typeof debugMode.code === 'string')
 })
 
-test('activate debug mode truthy', t => {
-  t.plan(5)
-
-  const debugMode = build({ debugMode: 'yes' })
-
-  t.assert.ok(typeof debugMode === 'object')
-  t.assert.ok(typeof debugMode.code === 'string')
-  t.assert.ok(debugMode.ajv instanceof Ajv)
-  t.assert.ok(debugMode.validator instanceof Validator)
-  t.assert.ok(debugMode.serializer instanceof Serializer)
-})
-
 test('to string auto-consistent', t => {
   t.plan(6)
-  const debugMode = build({ debugMode: 1 })
+  const debugMode = build({ mode: 'debug' })
 
   t.assert.ok(typeof debugMode === 'object')
   t.assert.ok(typeof debugMode.code === 'string')
@@ -73,7 +61,7 @@ test('to string auto-consistent with ajv', t => {
         }]
       }
     }
-  }, { debugMode: 1 })
+  }, { mode: 'debug' })
 
   t.assert.ok(typeof debugMode === 'object')
   t.assert.ok(typeof debugMode.code === 'string')
@@ -102,7 +90,7 @@ test('to string auto-consistent with ajv-formats', t => {
         }]
       }
     }
-  }, { debugMode: 1 })
+  }, { mode: 'debug' })
 
   t.assert.ok(typeof debugMode === 'object')
 
@@ -115,7 +103,28 @@ test('to string auto-consistent with ajv-formats', t => {
 test('debug should restore the same serializer instance', t => {
   t.plan(1)
 
-  const debugMode = fjs({ type: 'integer' }, { debugMode: 1, rounding: 'ceil' })
+  const debugMode = fjs({ type: 'integer' }, { mode: 'debug', rounding: 'ceil' })
   const compiled = fjs.restore(debugMode)
   t.assert.equal(compiled(3.95), 4)
 })
+
+test('Serializer restoreFromState', t => {
+  t.plan(1)
+
+  const Serializer = require('../lib/serializer')
+  const serializer = new Serializer()
+  const state = serializer.getState()
+  const restored = Serializer.restoreFromState(state)
+  t.assert.ok(restored instanceof Serializer)
+})
+
+test('Validator restoreFromState', t => {
+  t.plan(1)
+
+  const Validator = require('../lib/validator')
+  const validator = new Validator()
+  validator.addSchema({ type: 'string' }, 'test')
+  const state = validator.getState()
+  const restored = Validator.restoreFromState(state)
+  t.assert.ok(restored instanceof Validator)
+})

package/test/if-then-else.test.js

@@ -466,3 +466,75 @@ test('external recursive if/then/else', (t) => {
   const stringify = build(schema, { schema: { externalSchema } })
   t.assert.equal(stringify(data), '{"a":{"base":"a","bar":"42"},"b":{"base":"b","baz":"43"}}')
 })
+
+test('invalid if-then-else schema', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    if: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', enum: ['foobar'] }
+      }
+    },
+    then: {
+      type: 'object',
+      properties: {
+        foo: { type: 'string' }
+      }
+    },
+    else: {
+      type: 'object',
+      properties: 'invalid'  // properties must be object
+    }
+  }
+
+  try {
+    build(schema)
+    t.assert.fail('Should throw')
+  } catch (err) {
+    t.assert.ok(err.message.includes('schema is invalid'))
+  }
+})
+
+test('if-then-else with allOf', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    allOf: [
+      {
+        type: 'object',
+        properties: {
+          base: { type: 'string' }
+        }
+      }
+    ],
+    if: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', enum: ['foobar'] }
+      }
+    },
+    then: {
+      type: 'object',
+      properties: {
+        foo: { type: 'string' }
+      }
+    },
+    else: {
+      type: 'object',
+      properties: {
+        bar: { type: 'string' }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const data = { base: 'test', kind: 'foobar', foo: 'value' }
+  const output = stringify(data)
+
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, '{"base":"test","foo":"value"}')
+})

package/test/invalidSchema.test.js

@@ -16,3 +16,23 @@ test('Should throw on invalid schema', t => {
     })
   }, { message: /^"invalid" schema is invalid:.*/ })
 })
+
+test('invalid not schema', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      prop: {
+        not: 'not object'  // invalid, not must be object
+      }
+    }
+  }
+
+  try {
+    build(schema)
+    t.assert.fail('Should throw')
+  } catch (err) {
+    t.assert.ok(err.message.includes('schema is invalid'))
+  }
+})

package/test/issue-836.test.js

@@ -0,0 +1,183 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('external $ref schema should be reused, not inlined at every reference', (t) => {
+  t.plan(3)
+
+  const contactSchema = {
+    $id: 'contact.json',
+    type: 'object',
+    properties: {
+      firstName: { type: 'string' },
+      lastName: { type: 'string' },
+      email: { type: 'string' }
+    }
+  }
+
+  // Schema referencing the same external $ref multiple times
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      owner: { $ref: 'contact.json' },
+      assignee: { $ref: 'contact.json' },
+      reporter: { $ref: 'contact.json' }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'contact.json': contactSchema } })
+  const code = serializer.toString()
+
+  // The serialized function should contain extracted anonymous functions
+  // rather than inlining the full contact schema at every reference.
+  // With the fix, `firstName` appears 0 times in the main serializer body
+  // (it is inside the extracted function, which is not included in .toString())
+  // or at most 1 time if in a single extracted function.
+  const firstNameMatches = code.match(/firstName/g)
+  t.assert.ok(firstNameMatches === null || firstNameMatches.length <= 1,
+    `firstName should appear at most once (extracted function), got ${firstNameMatches ? firstNameMatches.length : 0}`)
+
+  // Verify correct serialization
+  const data = {
+    owner: { firstName: 'John', lastName: 'Doe', email: 'john@example.com' },
+    assignee: { firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com' },
+    reporter: { firstName: 'Bob', lastName: 'Jones', email: 'bob@example.com' }
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('external $ref schema reused with anyOf wrapping', (t) => {
+  t.plan(2)
+
+  const contactSchema = {
+    $id: 'contact.json',
+    type: 'object',
+    properties: {
+      firstName: { type: 'string' },
+      lastName: { type: 'string' },
+      email: { type: 'string' }
+    }
+  }
+
+  // Common pattern: anyOf wrapping $ref for polymorphic fields (populated object OR string ID OR null)
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      owner: {
+        anyOf: [{ type: ['string', 'null'] }, { $ref: 'contact.json' }]
+      },
+      assignee: {
+        anyOf: [{ type: ['string', 'null'] }, { $ref: 'contact.json' }]
+      },
+      reporter: {
+        anyOf: [{ type: ['string', 'null'] }, { $ref: 'contact.json' }]
+      }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'contact.json': contactSchema } })
+
+  // Serialize with populated objects
+  const data = {
+    owner: { firstName: 'John', lastName: 'Doe', email: 'john@example.com' },
+    assignee: { firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com' },
+    reporter: { firstName: 'Bob', lastName: 'Jones', email: 'bob@example.com' }
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('external $ref schema reused in array items', (t) => {
+  t.plan(2)
+
+  const contactSchema = {
+    $id: 'contact.json',
+    type: 'object',
+    properties: {
+      firstName: { type: 'string' },
+      lastName: { type: 'string' }
+    }
+  }
+
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      contacts: {
+        type: 'array',
+        items: { $ref: 'contact.json' }
+      },
+      primary: { $ref: 'contact.json' },
+      secondary: { $ref: 'contact.json' }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'contact.json': contactSchema } })
+
+  const data = {
+    contacts: [
+      { firstName: 'Alice', lastName: 'Wonder' },
+      { firstName: 'Bob', lastName: 'Builder' }
+    ],
+    primary: { firstName: 'Charlie', lastName: 'Charm' },
+    secondary: { firstName: 'Diana', lastName: 'Prince' }
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('external array $ref schema should be reused, not inlined at every reference', (t) => {
+  t.plan(2)
+
+  const tagsSchema = {
+    $id: 'tags.json',
+    type: 'array',
+    items: { type: 'string' }
+  }
+
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      a: { $ref: 'tags.json' },
+      b: { $ref: 'tags.json' },
+      c: { $ref: 'tags.json' }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'tags.json': tagsSchema } })
+
+  const data = {
+    a: ['x', 'y'],
+    b: ['z'],
+    c: []
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('inline anonymous schemas should still be inlined (not extracted)', (t) => {
+  t.plan(1)
+
+  // Inline schemas (no external $ref) should continue to work normally
+  const schema = {
+    type: 'object',
+    properties: {
+      a: { type: 'object', properties: { x: { type: 'string' } } },
+      b: { type: 'object', properties: { x: { type: 'string' } } }
+    }
+  }
+
+  const serializer = build(schema)
+  const output = serializer({ a: { x: 'hello' }, b: { x: 'world' } })
+
+  t.assert.equal(output, '{"a":{"x":"hello"},"b":{"x":"world"}}')
+})

package/test/json-add-comma.test.js

@@ -1,57 +1,57 @@
-'use strict'
-
-const { test } = require('node:test')
-const build = require('..')
-
-test('additionalProperties: false', (t) => {
-  t.plan(1)
-  const stringify = build({
-    title: 'additionalProperties',
-    type: 'object',
-    properties: {
-      foo: {
-        type: 'string'
-      }
-    },
-    additionalProperties: false
-  })
-
-  const obj = { foo: 'a', bar: 'b', baz: 'c' }
-  t.assert.equal(stringify(obj), '{"foo":"a"}')
-})
-
-test('additionalProperties: {}', (t) => {
-  t.plan(1)
-  const stringify = build({
-    title: 'additionalProperties',
-    type: 'object',
-    properties: {
-      foo: {
-        type: 'string'
-      }
-    },
-    additionalProperties: {}
-  })
-
-  const obj = { foo: 'a', bar: 'b', baz: 'c' }
-  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
-})
-
-test('additionalProperties: {type: string}', (t) => {
-  t.plan(1)
-  const stringify = build({
-    title: 'additionalProperties',
-    type: 'object',
-    properties: {
-      foo: {
-        type: 'string'
-      }
-    },
-    additionalProperties: {
-      type: 'string'
-    }
-  })
-
-  const obj = { foo: 'a', bar: 'b', baz: 'c' }
-  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
-})
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('additionalProperties: false', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: false
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a"}')
+})
+
+test('additionalProperties: {}', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {}
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
+})
+
+test('additionalProperties: {type: string}', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {
+      type: 'string'
+    }
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
+})

package/test/oneof.test.js

@@ -488,3 +488,23 @@ test('all array items does not match oneOf types', (t) => {
 
   t.assert.throws(() => stringify({ data: [null, false, true, undefined, [], {}] }))
 })
+
+test('invalid oneOf schema', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      prop: {
+        oneOf: 'not array'  // invalid, oneOf must be array
+      }
+    }
+  }
+
+  try {
+    build(schema)
+    t.assert.fail('Should throw')
+  } catch (err) {
+    t.assert.ok(err.message.includes('schema is invalid'))
+  }
+})

package/test/ref.test.js

@@ -2044,3 +2044,34 @@ test('ref internal - throw if schema has definition twice with different shape',
     t.assert.equal(err.message, 'There is already another anchor "#uri" in schema "test".')
   }
 })
+
+test('ref nested', (t) => {
+  t.plan(2)
+
+  const schema = {
+    definitions: {
+      def1: {
+        $ref: '#/definitions/def2'
+      },
+      def2: {
+        type: 'string'
+      }
+    },
+    type: 'object',
+    properties: {
+      str: {
+        $ref: '#/definitions/def1'
+      }
+    }
+  }
+
+  const object = {
+    str: 'test'
+  }
+
+  const stringify = build(schema)
+  const output = stringify(object)
+
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, '{"str":"test"}')
+})

package/test/typebox.test.js

@@ -4,7 +4,7 @@ const { test } = require('node:test')
 const build = require('..')
 
 test('nested object in pattern properties for typebox', (t) => {
-  const { Type } = require('@sinclair/typebox')
+  const { Type } = require('typebox')
 
   t.plan(1)
 

package/types/index.d.ts

@@ -162,16 +162,10 @@ declare namespace build {
      * @default 'trunc'
      */
     rounding?: 'ceil' | 'floor' | 'round' | 'trunc'
-    /**
-     * @deprecated
-     * Enable debug mode. Please use `mode: "debug"` instead
-     */
-    debugMode?: boolean
     /**
      * Running mode of fast-json-stringify
      */
     mode?: 'debug' | 'standalone'
-
     /**
      * Large arrays are defined as arrays containing, by default, `20000`
      * elements or more. That value can be adjusted via the option parameter
@@ -180,7 +174,6 @@ declare namespace build {
      * @default 20000
      */
     largeArraySize?: number | string | BigInt
-
     /**
      * Specify the function on how large Arrays should be stringified.
      *
@@ -200,10 +193,6 @@ interface DebugOption extends build.Options {
   mode: 'debug'
 }
 
-interface DeprecateDebugOption extends build.Options {
-  debugMode: true
-}
-
 interface StandaloneOption extends build.Options {
   mode: 'standalone'
 }
@@ -217,7 +206,6 @@ type IntegerCoercible = number | BigInt
  * @param options The options to use (optional)
  */
 declare function build (schema: build.AnySchema, options: DebugOption): { code: string, ajv: Ajv }
-declare function build (schema: build.AnySchema, options: DeprecateDebugOption): { code: string, ajv: Ajv }
 declare function build (schema: build.AnySchema, options: StandaloneOption): string
 declare function build (schema: build.AnySchema, options?: build.Options): <TDoc = any>(doc: TDoc) => any
 declare function build (schema: build.StringSchema, options?: build.Options): <TDoc extends StringCoercible = StringCoercible>(doc: TDoc) => string

package/types/{index.test-d.ts → index.tst.ts}

@@ -1,7 +1,7 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Test using this disabled, see https://github.com/fastify/fast-json-stringify/pull/683
 import Ajv from 'ajv'
 import build, { restore, Schema, validLargeArrayMechanisms } from '..'
-import { expectError, expectType } from 'tsd'
+import { expect } from 'tstyche'
 
 // Number schemas
 build({
@@ -26,9 +26,10 @@ build({
 build({
   type: 'number'
 }, { rounding: 'trunc' })
-expectError(build({
+
+expect(build).type.not.toBeCallableWith({
   type: 'number'
-}, { rounding: 'invalid' }))
+}, { rounding: 'invalid' })
 
 // String schema
 build({
@@ -153,7 +154,6 @@ build({
 })({ something: 'a string', somethingElse: 42 })
 
 // String schema with format
-
 build({
   type: 'string',
   format: 'date-time'
@@ -181,7 +181,6 @@ str = build({
     type: 'number'
 }, { mode: 'standalone' })
 */
-
 const debugCompiled = build({
   title: 'default string',
   type: 'object',
@@ -191,11 +190,12 @@ const debugCompiled = build({
     }
   }
 }, { mode: 'debug' })
-expectType<ReturnType<typeof build>>(build.restore(debugCompiled))
-expectType<ReturnType<typeof build>>(restore(debugCompiled))
 
-expectType<string[]>(build.validLargeArrayMechanisms)
-expectType<string[]>(validLargeArrayMechanisms)
+expect(build.restore(debugCompiled)).type.toBe(build({} as Schema))
+expect(restore(debugCompiled)).type.toBe(build({} as Schema))
+
+expect(build.validLargeArrayMechanisms).type.toBe<string[]>()
+expect(validLargeArrayMechanisms).type.toBe<string[]>()
 
 /**
  * Schema inference
@@ -211,10 +211,11 @@ const stringify3 = build({
   type: 'object',
   properties: { a: { type: 'string' } },
 })
+
 stringify3<InferenceSchema>({ id: '123' })
 stringify3<InferenceSchema>({ a: 123, id: '123' })
-expectError(stringify3<InferenceSchema>({ anotherOne: 'bar' }))
-expectError(stringify3<Schema>({ a: 'bar' }))
+expect(stringify3<InferenceSchema>).type.not.toBeCallableWith({ anotherOne: 'bar' })
+expect(stringify3<Schema>).type.not.toBeCallableWith({ a: 'bar' })
 
 // Without inference
 const stringify4 = build({
@@ -231,29 +232,28 @@ const stringify5 = build({
   type: 'string',
 })
 stringify5('foo')
-expectError(stringify5({ id: '123' }))
+expect(stringify5).type.not.toBeCallableWith({ id: '123' })
 
 // Without inference - null type
 const stringify6 = build({
   type: 'null',
 })
 stringify6(null)
-expectError(stringify6('a string'))
+expect(stringify6).type.not.toBeCallableWith('a string')
 
 // Without inference - boolean type
 const stringify7 = build({
   type: 'boolean',
 })
 stringify7(true)
-expectError(stringify7('a string'))
+expect(stringify7).type.not.toBeCallableWith('a string')
 
 // largeArrayMechanism
-
 build({}, { largeArrayMechanism: 'json-stringify' })
 build({}, { largeArrayMechanism: 'default' })
-expectError(build({} as Schema, { largeArrayMechanism: 'invalid' }))
+expect(build).type.not.toBeCallableWith({} as Schema, { largeArrayMechanism: 'invalid' })
 
 build({}, { largeArraySize: 2000 })
 build({}, { largeArraySize: '2e4' })
 build({}, { largeArraySize: 2n })
-expectError(build({} as Schema, { largeArraySize: ['asdf'] }))
+expect(build).type.not.toBeCallableWith({} as Schema, { largeArraySize: ['asdf'] })

package/.github/stale.yml

@@ -1,21 +0,0 @@
-# Number of days of inactivity before an issue becomes stale
-daysUntilStale: 15
-# Number of days of inactivity before a stale issue is closed
-daysUntilClose: 7
-# Issues with these labels will never be considered stale
-exemptLabels:
-  - "discussion"
-  - "feature request"
-  - "bug"
-  - "help wanted"
-  - "plugin suggestion"
-  - "good first issue"
-# Label to use when marking an issue as stale
-staleLabel: stale
-# Comment to post when marking an issue as stale. Set to `false` to disable
-markComment: >
-  This issue has been automatically marked as stale because it has not had
-  recent activity. It will be closed if no further activity occurs. Thank you
-  for your contributions.
-# Comment to post when closing a stale issue. Set to `false` to disable
-closeComment: false