fast-json-stringify 7.1.2 → 7.1.3

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

@@ -13,7 +13,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.
@@ -1055,7 +1055,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.3",
   "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/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"')))
+  })
+}