fast-json-stringify 7.1.2 → 7.1.4

package/README.md

@@ -127,7 +127,7 @@ const stringify = fastJson(mySchema, {
 ```
 
 - `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)
+- `ajv`: [ajv v8 instance's settings](https://ajv.js.org/options.html) for those properties that require `ajv`. [More details](#anyof) Schema strictness defaults to `false`; pass `ajv: { strictSchema: true }` to reject unknown schema keywords or `ajv: { strictSchema: 'log' }` to log warnings. This applies only to schema paths compiled by Ajv, not to every schema processed by fast-json-stringify.
 - `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

package/index.js

@@ -3,6 +3,7 @@
 /* eslint no-prototype-builtins: 0 */
 
 const { RefResolver } = require('json-schema-ref-resolver')
+const { MergeError } = require('@fastify/merge-json-schemas')
 
 const Serializer = require('./lib/serializer')
 const Validator = require('./lib/validator')
@@ -13,7 +14,7 @@ const mergeSchemas = require('./lib/merge-schemas')
 const DEFAULT_MAX_DEPTH = 100
 const NAMED_FRAGMENT_REF = /^#[a-z_][-\w._]*$/i
 
-// Minimum array lengths at which copying into a null-prototype array and
+// Minimum array lengths at which copying into a plain array and
 // calling native JSON.stringify beats the generated per-item loop. Measured
 // against main with tinybench (alternating rounds, median ops/s, output
 // consumed with Buffer.byteLength) on Node 20, 22, 24 and 26 x64.
@@ -87,6 +88,19 @@ const validLargeArrayMechanisms = new Set([
   'json-stringify'
 ])
 
+// Keywords that do not change the output, so a $ref carrying only these
+// can still be dereferenced directly instead of merged with its target.
+const IGNORED_REF_SIBLING_KEYWORDS = new Set([
+  '$ref',
+  '$comment',
+  'title',
+  'description',
+  'examples',
+  'deprecated',
+  'readOnly',
+  'writeOnly'
+])
+
 let schemaIdCounter = 0
 
 function getMaxDepth (options) {
@@ -223,10 +237,12 @@ function isValidSchema (schema, name) {
 
 function resolveRef (context, location) {
   const seen = new Set()
+  const siblingLocations = []
   let depth = 0
 
   while (location.schema.$ref !== undefined) {
-    const ref = location.schema.$ref
+    const refSchema = location.schema
+    const ref = refSchema.$ref
     const locationRef = location.getSchemaRef()
 
     if (seen.has(locationRef)) {
@@ -251,10 +267,45 @@ function resolveRef (context, location) {
       throw new Error(`Cannot find reference "${ref}"`)
     }
 
+    const siblingSchema = {}
+    for (const key in refSchema) {
+      if (!IGNORED_REF_SIBLING_KEYWORDS.has(key)) {
+        siblingSchema[key] = refSchema[key]
+      }
+    }
+
+    if (Object.keys(siblingSchema).length !== 0) {
+      siblingLocations.unshift(new Location(
+        cloneOriginSchema(context, siblingSchema, location.schemaId),
+        location.schemaId,
+        location.jsonPointer
+      ))
+    }
+
     location = new Location(schema, schemaId, jsonPointer)
   }
 
-  return location
+  if (siblingLocations.length === 0) {
+    return location
+  }
+
+  // Keyed by content, not by identity: a merged schema is cloned on every
+  // merge, so a recursive $ref would otherwise be merged again on each level.
+  const mergedSchemaKey = location.getSchemaRef() + JSON.stringify(siblingLocations.map((l) => l.schema))
+
+  let mergedSchemaId = context.mergedRefsIds.get(mergedSchemaKey)
+  if (mergedSchemaId === undefined) {
+    mergedSchemaId = `__fjs_merged_${schemaIdCounter++}`
+    try {
+      mergeLocations(context, mergedSchemaId, [location, ...siblingLocations])
+    } catch (err) {
+      if (!(err instanceof MergeError)) throw err
+      return location
+    }
+    context.mergedRefsIds.set(mergedSchemaKey, mergedSchemaId)
+  }
+
+  return getMergedLocation(context, mergedSchemaId)
 }
 
 function getSchemaDependencies (refResolver, schemaId) {
@@ -375,6 +426,7 @@ function build (schema, options) {
     validatorSchemasIds: new Set(),
     validatorSchemaRefs: new Set(),
     mergedSchemasIds: new Map(),
+    mergedRefsIds: new Map(),
     maxDepth,
     recursiveSchemas: new Set(),
     recursivePaths: new Set(),
@@ -1055,7 +1107,10 @@ function buildArray (context, location, input) {
         // Copying small arrays costs more than the existing loop.
         if (typeof arrayLength === 'number' && arrayLength >= ${fastPath.minLength} && Number.isInteger(arrayLength) && arrayLength <= 0xffffffff) {
           const copy = new Array(arrayLength)
-          Object.setPrototypeOf(copy, null)
+          // V8's side-effect-free JSON.stringify fast path (V8 >= 13.8) requires
+          // the standard Array.prototype; a null prototype halves its throughput.
+          // Only detach the prototype when a toJSON hook would otherwise be called.
+          if (Array.prototype.toJSON !== undefined) Object.setPrototypeOf(copy, null)
           for (let i = 0; i < arrayLength; i++) {
             const v = obj[i]
             if (!(${fastPath.condition})) {

package/lib/serializer.js

@@ -140,7 +140,10 @@ module.exports = class Serializer {
   // matching buildSingleTypeSerializer without rereading getters.
   asPlainStringArray (arr, len = arr.length) {
     const copy = new Array(len)
-    Object.setPrototypeOf(copy, null)
+    // V8's side-effect-free JSON.stringify fast path (V8 >= 13.8) requires the
+    // standard Array.prototype; a null prototype halves its throughput. Only
+    // detach the prototype when a toJSON hook would otherwise be called.
+    if (Array.prototype.toJSON !== undefined) Object.setPrototypeOf(copy, null)
     for (let i = 0; i < len; i++) {
       const value = arr[i]
       if (typeof value !== 'string') {

package/lib/validator.js

@@ -15,7 +15,7 @@ class Validator {
     this.ajv = new Ajv({
       ...ajvOptions,
       ...codeOptions,
-      strictSchema: false,
+      strictSchema: ajvOptions?.strictSchema ?? false,
       validateSchema: false,
       allowUnionTypes: true,
       uriResolver: fastUri
@@ -50,7 +50,7 @@ class Validator {
       const ajvSchema = clone(schema)
       this.convertSchemaToAjvFormat(ajvSchema)
       this.ajv.addSchema(ajvSchema, schemaKey)
-      this._ajvSchemas[schemaKey] = schema
+      this._ajvSchemas[schemaKey] = ajvSchema
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "7.1.2",
+  "version": "7.1.4",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "type": "commonjs",

package/test/primitive-array-prototype.test.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+// The copy-then-JSON.stringify fast path for primitive arrays must produce the
+// same output whether or not Array.prototype.toJSON has been patched, and must
+// never invoke such a hook.
+
+const numbers = Array.from({ length: 1000 }, (_, i) => i * 1.37)
+const integers = Array.from({ length: 1000 }, (_, i) => i)
+const strings = Array.from({ length: 1000 }, (_, i) => 'item-' + i)
+
+const cases = [
+  ['number', { type: 'array', items: { type: 'number' } }, numbers, {}],
+  ['integer', { type: 'array', items: { type: 'integer' } }, integers, {}],
+  ['string', { type: 'array', items: { type: 'string' } }, strings, { largeArraySize: 100 }]
+]
+
+for (const [name, schema, data, options] of cases) {
+  test(`${name} array fast path with pristine Array.prototype`, t => {
+    t.plan(2)
+    t.assert.equal(Array.prototype.toJSON, undefined)
+    const stringify = build(schema, options)
+    t.assert.equal(stringify(data), JSON.stringify(data))
+  })
+
+  test(`${name} array fast path ignores a patched Array.prototype.toJSON`, t => {
+    t.plan(2)
+    const expected = JSON.stringify(data)
+    let called = 0
+    // eslint-disable-next-line no-extend-native
+    Array.prototype.toJSON = function () { called++; return 'hooked' }
+    t.after(() => { delete Array.prototype.toJSON })
+    const stringify = build(schema, options)
+    t.assert.equal(stringify(data), expected)
+    t.assert.equal(called, 0)
+  })
+
+  test(`${name} array fast path resumes per-item coercion after a miss, with patched toJSON`, t => {
+    t.plan(1)
+    const mixed = data.slice()
+    mixed[500] = name === 'string' ? 42 : '7'
+    const stringify = build(schema, options)
+    const expected = stringify(mixed)
+    // eslint-disable-next-line no-extend-native
+    Array.prototype.toJSON = function () { return 'hooked' }
+    t.after(() => { delete Array.prototype.toJSON })
+    t.assert.equal(build(schema, options)(mixed), expected)
+  })
+}

package/test/ref.test.js

@@ -2075,3 +2075,230 @@ test('ref nested', (t) => {
   t.assert.doesNotThrow(() => JSON.parse(output))
   t.assert.equal(output, '{"str":"test"}')
 })
+
+test('ref internal - sibling keywords', (t) => {
+  t.plan(3)
+
+  const schema = {
+    definitions: {
+      def: {
+        type: 'object',
+        properties: {
+          str: {
+            type: 'string'
+          },
+          num: {
+            type: 'integer'
+          }
+        },
+        required: ['str']
+      }
+    },
+    type: 'object',
+    properties: {
+      obj: {
+        $ref: '#/definitions/def',
+        required: ['num']
+      }
+    }
+  }
+
+  const object = {
+    obj: {
+      str: 'test',
+      num: 42
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify(object)
+
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, '{"obj":{"str":"test","num":42}}')
+
+  t.assert.throws(() => {
+    stringify({
+      obj: {
+        str: 'test'
+      }
+    })
+  }, { message: '"num" is required!' })
+})
+
+test('ref external - sibling keywords', (t) => {
+  t.plan(3)
+
+  const externalSchema = {
+    external: {
+      definitions: {
+        def: {
+          type: 'object',
+          properties: {
+            str: {
+              type: 'string'
+            },
+            num: {
+              type: 'integer'
+            }
+          },
+          required: ['str']
+        }
+      }
+    }
+  }
+
+  const schema = {
+    type: 'object',
+    properties: {
+      obj: {
+        $ref: 'external#/definitions/def',
+        required: ['num']
+      }
+    }
+  }
+
+  const object = {
+    obj: {
+      str: 'test',
+      num: 42
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchema })
+  const output = stringify(object)
+
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, '{"obj":{"str":"test","num":42}}')
+
+  t.assert.throws(() => {
+    stringify({
+      obj: {
+        str: 'test'
+      }
+    })
+  }, { message: '"num" is required!' })
+})
+
+test('ref external - recursive sibling keywords', (t) => {
+  t.plan(3)
+
+  const externalSchema = {
+    node: {
+      $id: 'node',
+      type: 'object',
+      properties: {
+        str: {
+          type: 'string'
+        },
+        next: {
+          $ref: 'node#',
+          required: ['str']
+        }
+      }
+    }
+  }
+
+  const schema = {
+    type: 'object',
+    properties: {
+      root: {
+        $ref: 'node#',
+        required: ['str']
+      }
+    }
+  }
+
+  const object = {
+    root: {
+      str: 'test',
+      next: {
+        str: 'nested'
+      }
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchema })
+  const output = stringify(object)
+
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, '{"root":{"str":"test","next":{"str":"nested"}}}')
+
+  t.assert.throws(() => {
+    stringify({
+      root: {
+        str: 'test',
+        next: {}
+      }
+    })
+  }, { message: '"str" is required!' })
+})
+
+test('ref internal - conflicting sibling keywords', (t) => {
+  t.plan(2)
+
+  const schema = {
+    definitions: {
+      def: {
+        type: 'string'
+      }
+    },
+    type: 'object',
+    properties: {
+      value: {
+        $ref: '#/definitions/def',
+        type: 'integer'
+      }
+    }
+  }
+
+  const object = {
+    value: 42
+  }
+
+  const stringify = build(schema)
+  const output = stringify(object)
+
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, '{"value":"42"}')
+})
+
+test('ref external - sibling keywords with a duplicated anchor', (t) => {
+  t.plan(1)
+
+  const externalSchema = {
+    external: {
+      $id: 'external',
+      definitions: {
+        def: {
+          type: 'object',
+          properties: {
+            str: {
+              $id: '#anchor',
+              type: 'string'
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const schema = {
+    type: 'object',
+    properties: {
+      obj: {
+        $ref: 'external#/definitions/def',
+        properties: {
+          num: {
+            $id: '#anchor',
+            type: 'integer'
+          }
+        }
+      }
+    }
+  }
+
+  t.assert.throws(
+    () => build(schema, { schema: externalSchema }),
+    { message: /There is already another anchor "#anchor"/ }
+  )
+})

package/test/standalone-mode.test.js

@@ -318,6 +318,38 @@ test('inline validators with external oneOf refs and toJSON values', async (t) =
   t.assert.throws(() => stringify({ value: true }), /does not match schema definition/)
 })
 
+test('restored validator handles toJSON values', async (t) => {
+  t.plan(3)
+
+  after(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
+  const code = fjs({
+    type: 'object',
+    properties: {
+      value: {
+        oneOf: [
+          { type: 'string', format: 'date-time' },
+          { type: 'integer' }
+        ]
+      }
+    }
+  }, { mode: 'standalone', inlineValidators: false })
+
+  const destination = path.resolve(tmpDir, 'standalone-restored-toJSON.js')
+
+  await fs.promises.writeFile(destination, code)
+  const stringify = require(destination)
+
+  t.assert.equal(
+    stringify({ value: new Date('2020-01-02T03:04:05.000Z') }),
+    '{"value":"2020-01-02T03:04:05.000Z"}'
+  )
+  t.assert.equal(stringify({ value: 42 }), '{"value":42}')
+  t.assert.throws(() => stringify({ value: true }), /does not match schema definition/)
+})
+
 test('does not emit unused inline validators', (t) => {
   const code = build({ mode: 'standalone', inlineValidators: true })
 

package/test/strict-schema.test.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+function schemaWithTypo () {
+  return { anyOf: [{ type: 'number', mininum: 10 }] }
+}
+
+for (const compileValidators of [false, true]) {
+  const mode = compileValidators ? 'eager' : 'lazy'
+
+  for (const [name, ajv] of [
+    ['omitted', undefined],
+    ['empty', {}],
+    ['undefined', { strictSchema: undefined }],
+    ['null', { strictSchema: null }],
+    ['false', { strictSchema: false }],
+    ['strict true', { strict: true }],
+    ['explicit false with strict true', { strict: true, strictSchema: false }]
+  ]) {
+    test(`strictSchema keeps permissive behavior for ${name} (${mode})`, t => {
+      const stringify = build(schemaWithTypo(), { ajv, compileValidators })
+      t.assert.equal(stringify(1), '1')
+    })
+  }
+
+  test(`strictSchema true rejects unknown keywords (${mode})`, t => {
+    const options = { ajv: { strictSchema: true }, compileValidators }
+    const unknownKeyword = /unknown keyword: "mininum"/
+
+    if (compileValidators) {
+      t.assert.throws(() => build(schemaWithTypo(), options), unknownKeyword)
+    } else {
+      const stringify = build(schemaWithTypo(), options)
+      t.assert.throws(() => stringify(1), unknownKeyword)
+    }
+  })
+
+  test(`strictSchema log warns about unknown keywords (${mode})`, t => {
+    const warnings = []
+    const logger = {
+      log () {},
+      error () {},
+      warn (message) { warnings.push(message) }
+    }
+    const stringify = build(schemaWithTypo(), {
+      ajv: { strictSchema: 'log', logger },
+      compileValidators
+    })
+
+    t.assert.equal(stringify(1), '1')
+    t.assert.ok(warnings.some(message => message.includes('unknown keyword: "mininum"')))
+  })
+}