fast-json-stringify 6.2.0 → 6.4.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/README.md

@@ -79,7 +79,6 @@ compile-json-stringify date format x 803,214 ops/sec ±0.23% (97 runs sampled)
 
 
 <a name="example"></a>
-Try it out on RunKit: <a href="https://runkit.com/npm/fast-json-stringify">https://runkit.com/npm/fast-json-stringify</a>
 ## Example
 
 ```js
@@ -347,9 +346,9 @@ const stringify = fastJson({
   properties: {
     'undecidedType': {
       'anyOf': [{
-	type: 'string'
+        type: 'string'
       }, {
-	type: 'boolean'
+        type: 'boolean'
       }]
     }
   }
@@ -645,8 +644,8 @@ const stringify = fastJson({
   type: 'object',
   properties: {
     'code': {
-	    type: 'string',
-	    format 'unsafe'
+      type: 'string',
+      format: 'unsafe'
     }
   }
 })

package/benchmark/bench-cmp-lib.js

@@ -84,13 +84,13 @@ const arraySchemaAJVJTD = {
 const dateFormatSchema = {
   description: 'Date of birth',
   type: 'string',
-  format: 'date'
+  format: 'datetime'
 }
 
 const dateFormatSchemaCJS = {
   description: 'Date of birth',
   type: 'string',
-  format: 'date'
+  format: 'datetime'
 }
 
 const obj = {
@@ -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.hz // ops/sec
-    const rme = task.result.rme // relative margin of error (%)
-    const samples = task.result.samples.length
+  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/benchmark/bench-thread.js

@@ -21,9 +21,9 @@ bench.add(benchmark.name, () => {
   stringify(benchmark.input)
 }).run().then(() => {
   const task = bench.tasks[0]
-  const hz = task.result.hz // ops/sec
-  const rme = task.result.rme // relative margin of error (%)
-  const samples = task.result.samples.length
+  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 formattedHz = hz.toLocaleString('en-US', { maximumFractionDigits: 0 })
   const formattedRme = rme.toFixed(2)

package/index.js

@@ -304,14 +304,14 @@ function buildExtraObjectPropertiesSerializer (context, location, addComma, objV
   const propertiesKeys = Object.keys(schema.properties || {})
 
   let code = `
-    const propertiesKeys = ${JSON.stringify(propertiesKeys)}
-    for (const [key, value] of Object.entries(${objVar})) {
+    for (const key of Object.keys(${objVar})) {
       if (
-        propertiesKeys.includes(key) ||
-        value === undefined ||
-        typeof value === 'function' ||
-        typeof value === 'symbol'
+        ${propertiesKeys.length > 0 ? propertiesKeys.map(k => `key === ${JSON.stringify(k)}`).join(' || ') + ' ||' : ''}
+        ${objVar}[key] === undefined ||
+        typeof ${objVar}[key] === 'function' ||
+        typeof ${objVar}[key] === 'symbol'
       ) continue
+      const value = ${objVar}[key]
   `
 
   const patternPropertiesLocation = location.getPropertyLocation('patternProperties')
@@ -385,45 +385,99 @@ function buildInnerObject (context, location, objVar) {
 
   const localUid = context.uid++
   let addComma = ''
-  const needsRuntimeComma = propertiesKeys.length > 1 || schema.patternProperties || (schema.additionalProperties !== undefined && schema.additionalProperties !== false)
 
-  if (needsRuntimeComma) {
-    code += `let addComma_${localUid} = false\n`
-    addComma = `!addComma_${localUid} && (addComma_${localUid} = true) || (json += JSON_STR_COMMA)`
-  }
+  if (requiredProperties.length > 0) {
+    // If we have required properties, we know that at least one property will be serialized.
+    // We can avoid the runtime check for the comma.
 
-  for (const key of propertiesKeys) {
-    let propertyLocation = propertiesLocation.getPropertyLocation(key)
-    if (propertyLocation.schema.$ref) {
-      propertyLocation = resolveRef(context, propertyLocation)
-    }
+    // The first property is required, so we don't need a comma.
+    // For the subsequent properties, we can blindly add a comma.
 
-    const sanitizedKey = JSON.stringify(key)
-    const value = `value_${key.replace(/[^a-zA-Z0-9]/g, '_')}_${context.uid++}`
-    const defaultValue = propertyLocation.schema.default
-    const isRequired = requiredProperties.includes(key)
+    for (let i = 0; i < propertiesKeys.length; i++) {
+      const key = propertiesKeys[i]
+      const propertyLocation = propertiesLocation.getPropertyLocation(key)
 
-    code += `
+      let resolvedLocation = propertyLocation
+      if (propertyLocation.schema.$ref) {
+        resolvedLocation = resolveRef(context, propertyLocation)
+      }
+
+      const sanitizedKey = JSON.stringify(key)
+      const value = `value_${key.replace(/[^a-zA-Z0-9]/g, '_')}_${context.uid++}`
+      const defaultValue = resolvedLocation.schema.default
+      const isRequired = requiredProperties.includes(key)
+
+      // i === 0 means it's the first property, and it IS required (due to sort). No comma.
+      // i > 0 means it follows a required property (or a sequence starting with one). Unconditional comma.
+      const currentAddComma = i === 0 ? '' : 'json += JSON_STR_COMMA'
+
+      code += `
       const ${value} = ${objVar}[${sanitizedKey}]
       if (${value} !== undefined) {
-        ${addComma}
+        ${currentAddComma}
         json += ${JSON.stringify(sanitizedKey + ':')}
-        ${buildValue(context, propertyLocation, `${value}`)}
+        ${buildValue(context, resolvedLocation, `${value}`)}
       }`
 
-    if (defaultValue !== undefined) {
-      code += ` else {
-        ${addComma}
+      if (defaultValue !== undefined) {
+        code += ` else {
+        ${currentAddComma}
         json += ${JSON.stringify(sanitizedKey + ':' + JSON.stringify(defaultValue))}
       }
       `
-    } else if (isRequired) {
-      code += ` else {
+      } else if (isRequired) {
+        code += ` else {
         throw new Error('${sanitizedKey.replace(/'/g, '\\\'')} is required!')
       }
       `
-    } else {
-      code += '\n'
+      } else {
+        code += '\n'
+      }
+    }
+
+    addComma = 'json += JSON_STR_COMMA'
+  } else {
+    const needsRuntimeComma = propertiesKeys.length > 1 || schema.patternProperties || (schema.additionalProperties !== undefined && schema.additionalProperties !== false)
+
+    if (needsRuntimeComma) {
+      code += `let addComma_${localUid} = false\n`
+      addComma = `!addComma_${localUid} && (addComma_${localUid} = true) || (json += JSON_STR_COMMA)`
+    }
+
+    for (const key of propertiesKeys) {
+      let propertyLocation = propertiesLocation.getPropertyLocation(key)
+      if (propertyLocation.schema.$ref) {
+        propertyLocation = resolveRef(context, propertyLocation)
+      }
+
+      const sanitizedKey = JSON.stringify(key)
+      const value = `value_${key.replace(/[^a-zA-Z0-9]/g, '_')}_${context.uid++}`
+      const defaultValue = propertyLocation.schema.default
+      const isRequired = requiredProperties.includes(key) // Should be false here but good to keep
+
+      code += `
+          const ${value} = ${objVar}[${sanitizedKey}]
+          if (${value} !== undefined) {
+            ${addComma}
+            json += ${JSON.stringify(sanitizedKey + ':')}
+            ${buildValue(context, propertyLocation, `${value}`)}
+          }`
+
+      if (defaultValue !== undefined) {
+        code += ` else {
+            ${addComma}
+            json += ${JSON.stringify(sanitizedKey + ':' + JSON.stringify(defaultValue))}
+          }
+          `
+      } else if (isRequired) {
+        // Should not happen if requiredProperties.length === 0 but safety
+        code += ` else {
+            throw new Error('${sanitizedKey.replace(/'/g, '\\\'')} is required!')
+          }
+          `
+      } else {
+        code += '\n'
+      }
     }
   }
 
@@ -514,7 +568,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)
 
@@ -573,7 +627,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)
 
@@ -611,10 +665,15 @@ function buildArray (context, location, input) {
 
     if (Array.isArray(itemsSchema)) {
       for (let i = 0, itemsSchemaLength = itemsSchema.length; i < itemsSchemaLength; i++) {
-        const item = itemsSchema[i]
+        let item = itemsSchema[i]
+        let itemLocation = itemsLocation.getPropertyLocation(i)
+        if (itemLocation.schema.$ref) {
+          itemLocation = resolveRef(context, itemLocation)
+          item = itemLocation.schema
+        }
         const value = `value_${i}`
         functionCode += `const ${value} = obj[${i}]`
-        const tmpRes = buildValue(context, itemsLocation.getPropertyLocation(i), value)
+        const tmpRes = buildValue(context, itemLocation, value)
         functionCode += `
         if (${i} < arrayLength) {
           if (${buildArrayTypeCondition(item.type, value)}) {
@@ -641,12 +700,14 @@ function buildArray (context, location, input) {
     } else {
       const code = buildValue(context, itemsLocation, 'value')
       functionCode += `
-      for (let i = 0; i < arrayLength; i++) {
-        if (i) {
+      if (arrayLength > 0) {
+        const value = obj[0]
+        ${code}
+        for (let i = 1; i < arrayLength; i++) {
           json += JSON_STR_COMMA
+          const value = obj[i]
+          ${code}
         }
-        const value = obj[i]
-        ${code}
       }`
     }
 
@@ -691,10 +752,15 @@ function buildArray (context, location, input) {
     const localUid = context.uid++
     inlinedCode += `let addComma_${localUid} = false\n`
     for (let i = 0, itemsSchemaLength = itemsSchema.length; i < itemsSchemaLength; i++) {
-      const item = itemsSchema[i]
+      let item = itemsSchema[i]
+      let itemLocation = itemsLocation.getPropertyLocation(i)
+      if (itemLocation.schema.$ref) {
+        itemLocation = resolveRef(context, itemLocation)
+        item = itemLocation.schema
+      }
       const value = `value_${i}_${context.uid++}`
       inlinedCode += `const ${value} = ${objVar}[${i}]`
-      const tmpRes = buildValue(context, itemsLocation.getPropertyLocation(i), value)
+      const tmpRes = buildValue(context, itemLocation, value)
       inlinedCode += `
         if (${i} < arrayLength_${objVar}) {
           if (${buildArrayTypeCondition(item.type, value)}) {
@@ -717,12 +783,14 @@ function buildArray (context, location, input) {
   } else {
     const code = buildValue(context, itemsLocation, 'value')
     inlinedCode += `
-      for (let i = 0; i < arrayLength_${objVar}; i++) {
-        if (i) {
+      if (arrayLength_${objVar} > 0) {
+        const value = ${objVar}[0]
+        ${code}
+        for (let i = 1; i < arrayLength_${objVar}; i++) {
           json += JSON_STR_COMMA
+          const value = ${objVar}[i]
+          ${code}
         }
-        const value = ${objVar}[i]
-        ${code}
       }`
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "6.2.0",
+  "version": "6.4.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,20 @@
     }
   ],
   "devDependencies": {
-    "@sinclair/typebox": "^0.34.3",
-    "c8": "^10.1.2",
+    "c8": "^11.0.0",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
-    "eslint": "^9.17.0",
+    "eslint": "^9.39.2",
     "fast-json-stringify": ".",
     "is-my-json-valid": "^2.20.6",
-    "json-accelerator": "^0.0.2",
-    "neostandard": "^0.12.0",
-    "simple-git": "^3.23.0",
-    "tinybench": "^5.0.1",
-    "tsd": "^0.32.0",
-    "webpack": "^5.90.3"
+    "json-accelerator": "^0.1.7",
+    "neostandard": "^0.13.0",
+    "simple-git": "^3.30.0",
+    "tinybench": "^6.0.0",
+    "tstyche": "^7.1.0",
+    "typebox": "^1.0.81",
+    "typescript": "~6.0.2",
+    "webpack": "^5.104.1"
   },
   "dependencies": {
     "@fastify/merge-json-schemas": "^0.2.0",

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

@@ -61,6 +61,34 @@ buildTest({
   dates: [new Date(1), new Date(2)]
 })
 
+buildTest({
+  title: 'dates tuple $ref',
+  definitions: {
+    dateTime: {
+      type: 'string',
+      format: 'date-time'
+    }
+  },
+  type: 'object',
+  properties: {
+    dates: {
+      type: 'array',
+      minItems: 2,
+      maxItems: 2,
+      items: [
+        {
+          $ref: '#/definitions/dateTime'
+        },
+        {
+          $ref: '#/definitions/dateTime'
+        }
+      ]
+    }
+  }
+}, {
+  dates: [new Date(1), new Date(2)]
+})
+
 buildTest({
   title: 'string array',
   type: 'object',
@@ -358,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

@@ -119,3 +119,24 @@ test('debug should restore the same serializer instance', t => {
   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.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