fast-json-stringify 7.0.1 → 7.1.0

package/test/oneof.test.js

@@ -348,6 +348,248 @@ test('oneOf and $ref - multiple external $ref', (t) => {
   t.assert.equal(output, '{"obj":{"prop":{"prop2":"test"}}}')
 })
 
+test('oneOf with a bare top-level $ref branch validates directly against the registered schema, not a root-relative pointer', (t) => {
+  t.plan(3)
+
+  const schema = {
+    title: 'oneOf with bare $ref branches',
+    type: 'object',
+    properties: {
+      content: {
+        oneOf: [
+          { $ref: 'Foo#' },
+          { $ref: 'Bar#' }
+        ]
+      }
+    }
+  }
+  const externalSchema = {
+    Foo: {
+      type: 'object',
+      properties: { a: { type: 'string' } },
+      required: ['a'],
+      additionalProperties: false
+    },
+    Bar: {
+      type: 'object',
+      properties: { b: { type: 'string' } },
+      required: ['b'],
+      additionalProperties: false
+    }
+  }
+
+  const code = build(schema, { mode: 'standalone', schema: externalSchema })
+  t.assert.ok(code.includes('validator.validate("Foo#"'), 'validates directly against the bare registered id')
+  t.assert.ok(code.includes('validator.validate("Bar#"'), 'validates directly against the bare registered id')
+
+  const stringify = build(schema, { schema: externalSchema })
+  t.assert.equal(stringify({ content: { b: 'yo' } }), '{"content":{"b":"yo"}}')
+})
+
+test('oneOf with a bare top-level $ref branch to a $id schema validates directly against the registered schema', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'oneOf with bare $id $ref branch',
+    type: 'object',
+    properties: {
+      content: {
+        oneOf: [
+          { $ref: 'urn:fjs:test:Foo#' },
+          { type: 'null' }
+        ]
+      }
+    }
+  }
+  const externalSchema = {
+    Foo: {
+      $id: 'urn:fjs:test:Foo',
+      type: 'object',
+      properties: { a: { type: 'string' } },
+      required: ['a'],
+      additionalProperties: false
+    }
+  }
+
+  const code = build(schema, { mode: 'standalone', schema: externalSchema })
+  t.assert.ok(code.includes('validator.validate("urn:fjs:test:Foo#"'), 'validates directly against the bare registered $id')
+
+  const stringify = build(schema, { schema: externalSchema })
+  t.assert.equal(stringify({ content: { a: 'yo' } }), '{"content":{"a":"yo"}}')
+})
+
+test('oneOf with a bare top-level $ref branch to a relative $id schema is left unchanged', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'oneOf with bare $ref branch to relative $id',
+    type: 'object',
+    properties: {
+      content: {
+        oneOf: [
+          { $ref: 'Foo#' },
+          { type: 'null' }
+        ]
+      }
+    }
+  }
+  const externalSchema = {
+    Foo: {
+      $id: '#foo',
+      type: 'object',
+      properties: { a: { type: 'string' } },
+      required: ['a']
+    }
+  }
+
+  const code = build(schema, { mode: 'standalone', schema: externalSchema })
+  t.assert.ok(!code.includes('validator.validate("Foo#"'), 'relative $id schema is not redirected to the bare parent id')
+})
+
+test('oneOf with a $ref branch to a relative root $id validates directly against the registered schema', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'oneOf with $ref branch to relative root $id',
+    type: 'object',
+    properties: {
+      content: {
+        oneOf: [
+          { $ref: 'Foo#foo' },
+          { type: 'null' }
+        ]
+      }
+    }
+  }
+  const externalSchema = {
+    Foo: {
+      $id: '#foo',
+      type: 'object',
+      properties: { a: { type: 'string' } },
+      required: ['a']
+    }
+  }
+
+  const code = build(schema, { mode: 'standalone', schema: externalSchema })
+  t.assert.ok(code.includes('validator.validate("Foo#foo"'), 'validates directly against the relative root $id')
+
+  const stringify = build(schema, { schema: externalSchema })
+  t.assert.equal(stringify({ content: { a: 'yo' } }), '{"content":{"a":"yo"}}')
+})
+
+test('oneOf with a named-fragment $ref branch validates directly against the registered schema anchor', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'oneOf with named-fragment $ref branch',
+    type: 'object',
+    properties: {
+      content: {
+        oneOf: [
+          { $ref: 'Foo#tag' },
+          { type: 'null' }
+        ]
+      }
+    }
+  }
+  const externalSchema = {
+    Foo: {
+      $id: 'Foo',
+      $defs: {
+        tag: { $id: '#tag', type: 'string' }
+      }
+    }
+  }
+
+  const code = build(schema, { mode: 'standalone', schema: externalSchema })
+  t.assert.ok(code.includes('validator.validate("Foo#tag"'), 'validates directly against the registered schema anchor')
+
+  const stringify = build(schema, { schema: externalSchema })
+  t.assert.equal(stringify({ content: 'yo' }), '{"content":"yo"}')
+})
+
+test('oneOf with a $ref into a JSON-pointer sub-path validates directly against that sub-path', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'oneOf with a sub-path $ref branch',
+    type: 'object',
+    properties: {
+      content: {
+        oneOf: [
+          { $ref: 'Foo#/definitions/Bar' },
+          { type: 'null' }
+        ]
+      }
+    }
+  }
+  const externalSchema = {
+    Foo: {
+      definitions: {
+        Bar: { type: 'object', properties: { b: { type: 'string' } } }
+      }
+    }
+  }
+
+  const code = build(schema, { mode: 'standalone', schema: externalSchema })
+  t.assert.ok(code.includes('validator.validate("Foo#/definitions/Bar"'), 'validates directly against the sub-path ref')
+
+  const stringify = build(schema, { schema: externalSchema })
+  t.assert.equal(stringify({ content: { b: 'yo' } }), '{"content":{"b":"yo"}}')
+})
+
+test('oneOf with a $ref branch that has sibling keywords is left unchanged', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'oneOf with a $ref branch with sibling keywords',
+    type: 'object',
+    properties: {
+      content: {
+        oneOf: [
+          { $ref: 'Foo#', required: ['c'] },
+          { type: 'null' }
+        ]
+      }
+    }
+  }
+  const externalSchema = {
+    Foo: {
+      type: 'object',
+      properties: { a: { type: 'string' } },
+      required: ['a']
+    }
+  }
+
+  const code = build(schema, { mode: 'standalone', schema: externalSchema })
+  t.assert.ok(!code.includes('validator.validate("Foo#"'), 'ref with sibling keywords is not redirected')
+
+  const stringify = build(schema, { schema: externalSchema })
+  t.assert.throws(() => stringify({ content: { a: 'yo' } }))
+})
+
+test('oneOf with an inline (non-$ref) branch is left unchanged', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'oneOf with an inline branch, no $ref',
+    type: 'object',
+    properties: {
+      content: {
+        oneOf: [
+          { type: 'string' },
+          { type: 'object', properties: { a: { type: 'string' } }, required: ['a'] }
+        ]
+      }
+    }
+  }
+
+  // Should compile and serialize exactly as before -- this is a pure
+  // regression guard, not exercising the new code path at all.
+  const stringify = build(schema)
+  t.assert.equal(stringify({ content: 'hello' }), '{"content":"hello"}')
+})
+
 test('oneOf with enum with more than 100 entries', (t) => {
   t.plan(1)
 

package/test/optional-property-prefix.test.js

@@ -0,0 +1,119 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+function compile (schema, mode) {
+  if (mode === 'normal') return build(schema)
+  const output = { exports: {} }
+  // eslint-disable-next-line no-new-func
+  new Function('require', 'module', build(schema, { mode: 'standalone' }))(require, output)
+  return output.exports
+}
+
+for (const mode of ['normal', 'standalone']) {
+  test('optional property prefixes preserve omissions and escaped keys: ' + mode, t => {
+    const keys = ['first', 'quote"', 'back\\slash', 'line\nbreak']
+    const properties = Object.fromEntries(keys.map(key => [key, { type: 'integer' }]))
+    const stringify = compile({ type: 'object', properties, additionalProperties: false }, mode)
+
+    for (let mask = 0; mask < 16; mask++) {
+      const input = { ignored: true }
+      const expected = {}
+      for (let i = keys.length - 1; i >= 0; i--) {
+        input[keys[i]] = mask & (1 << i) ? i : undefined
+      }
+      for (let i = 0; i < keys.length; i++) {
+        if (mask & (1 << i)) expected[keys[i]] = i
+      }
+      t.assert.equal(stringify(input), JSON.stringify(expected))
+    }
+  })
+
+  test('optional property prefixes share comma state with defaults and extra properties: ' + mode, t => {
+    const stringify = compile({
+      type: 'object',
+      properties: {
+        first: { type: 'string' },
+        middle: { type: 'string', default: 'fallback' },
+        last: { type: 'boolean' }
+      },
+      patternProperties: { '^x': { type: 'integer' } },
+      additionalProperties: { type: 'string' }
+    }, mode)
+
+    t.assert.equal(stringify({}), '{"middle":"fallback"}')
+    t.assert.equal(stringify({ first: 'a', last: false, x: 2, extra: 'b' }), '{"first":"a","middle":"fallback","last":false,"x":2,"extra":"b"}')
+    t.assert.equal(stringify({ middle: 'b', extra: 'c' }), '{"middle":"b","extra":"c"}')
+
+    const noDefaults = compile({
+      type: 'object',
+      properties: { first: { type: 'string' } },
+      additionalProperties: true
+    }, mode)
+    t.assert.equal(noDefaults({ extra: 1 }), '{"extra":1}')
+    t.assert.equal(noDefaults({ first: 'a', extra: 1 }), '{"first":"a","extra":1}')
+  })
+
+  test('optional property prefixes reset for nested objects and array items: ' + mode, t => {
+    const item = {
+      type: 'object',
+      properties: { first: { type: 'integer' }, last: { type: 'integer' } }
+    }
+    const stringify = compile({
+      type: 'object',
+      properties: {
+        before: item,
+        items: { type: 'array', items: item },
+        after: item
+      }
+    }, mode)
+    const input = {
+      before: {},
+      items: [{ last: 1 }, {}, { first: 2, last: 3 }, { first: 4 }],
+      after: { last: 5 }
+    }
+    t.assert.equal(stringify(input), JSON.stringify(input))
+    t.assert.equal(stringify({ after: { first: 6 } }), '{"after":{"first":6}}')
+  })
+
+  test('optional property prefixes preserve getter and coercion order: ' + mode, t => {
+    const stringify = compile({
+      type: 'object',
+      properties: {
+        first: { type: 'string' },
+        second: { type: 'integer' },
+        last: { type: 'boolean' }
+      }
+    }, mode)
+    const events = []
+    const failure = new Error('coercion failed')
+    let fail = false
+    const input = {
+      get first () {
+        events.push('first')
+        return {
+          toString () {
+            events.push('coerce first')
+            if (fail) throw failure
+            return 'a'
+          }
+        }
+      },
+      get second () {
+        events.push('second')
+        return 2
+      },
+      get last () {
+        events.push('last')
+        return undefined
+      }
+    }
+    t.assert.equal(stringify(input), '{"first":"a","second":2}')
+    t.assert.deepStrictEqual(events, ['first', 'coerce first', 'second', 'last'])
+    events.length = 0
+    fail = true
+    t.assert.throws(() => stringify(input), error => error === failure)
+    t.assert.deepStrictEqual(events, ['first', 'coerce first'])
+  })
+}

package/test/property-names.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+// the schema ref of a property with anyOf, oneOf or if goes into the generated code as a
+// string and into a JSON pointer, so a name that needs escaping in either broke the build
+const names = ['new\nline', 'q"uote', 'back\\slash', 'a/b', 'a~b', 'a%b', 'a#b', 'a b', 'tick`', 'dollar$' + '{x}', '\\u', "single'quote"]
+const branches = {
+  oneOf: { oneOf: [{ type: 'string' }, { type: 'object', properties: { k: { type: 'integer' } }, required: ['k'] }] },
+  anyOf: { anyOf: [{ type: 'string' }, { type: 'object', properties: { k: { type: 'integer' } }, required: ['k'] }] },
+  if: { if: { type: 'string' }, then: { type: 'string' }, else: { type: 'integer' } }
+}
+
+for (const name of names) {
+  for (const [keyword, subschema] of Object.entries(branches)) {
+    test(`a property named ${JSON.stringify(name)} with ${keyword}`, (t) => {
+      t.plan(2)
+
+      const stringify = build({ type: 'object', properties: { [name]: subschema } })
+      t.assert.equal(stringify({ [name]: 'v' }), JSON.stringify({ [name]: 'v' }))
+      t.assert.throws(() => stringify({ [name]: {} }), keyword === 'if' ? Error : new TypeError(`The value of '#/properties/${name.replace(/~/g, '~0').replace(/\//g, '~1')}' does not match schema definition.`))
+    })
+  }
+}
+
+// the ref also goes on a comment line of the generated code, above the function of a nested
+// object or array, where a line terminator in the name ends the comment early
+for (const name of ['new' + String.fromCharCode(10) + 'line', 'line' + String.fromCharCode(0x2028) + 'sep', 'para' + String.fromCharCode(0x2029) + 'graph']) {
+  test(`a property named ${JSON.stringify(name)} with a nested object and array`, (t) => {
+    t.plan(1)
+
+    const stringify = build({
+      type: 'object',
+      properties: {
+        [name]: { type: 'object', properties: { list: { type: 'array', items: { type: 'integer' } } }, nullable: true }
+      }
+    })
+    t.assert.equal(stringify({ [name]: { list: [1] } }), JSON.stringify({ [name]: { list: [1] } }))
+  })
+}

package/test/regex.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { test } = require('node:test')
-const validator = require('is-my-json-valid')
+const validator = require('./utils/validator')
 const build = require('..')
 
 test('object with RexExp', (t) => {

package/test/schema-depth.test.js

@@ -0,0 +1,227 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+function createNestedSchema (depth) {
+  let schema = { type: 'string' }
+
+  for (let i = 0; i < depth; i++) {
+    schema = {
+      type: 'object',
+      properties: { value: schema }
+    }
+  }
+
+  return schema
+}
+
+function createNestedNotSchema (depth) {
+  let schema = { type: 'string' }
+  for (let i = 0; i < depth; i++) schema = { not: schema }
+  return { anyOf: [schema] }
+}
+
+function createReferencedNotSchema (depth) {
+  const definitions = {}
+  for (let i = 0; i < depth; i++) {
+    definitions[`schema-${i}`] = {
+      not: i + 1 < depth
+        ? { $ref: `#/definitions/schema-${i + 1}` }
+        : { type: 'string' }
+    }
+  }
+  return {
+    definitions,
+    anyOf: [{ $ref: '#/definitions/schema-0' }]
+  }
+}
+
+test('rejects schemas deeper than the default maximum without exhausting the stack', (t) => {
+  t.assert.throws(
+    () => build(createNestedSchema(101)),
+    (error) => {
+      t.assert.equal(error.constructor, Error)
+      t.assert.equal(error.message, 'schema exceeds maximum depth of 100')
+      return true
+    }
+  )
+  t.assert.doesNotThrow(() => build(createNestedSchema(100)))
+})
+
+test('accepted boundary is safe for eager and lazy Ajv compilation', (t) => {
+  for (const createSchema of [createNestedNotSchema, createReferencedNotSchema]) {
+    for (const compileValidators of [false, true]) {
+      const stringify = build(createSchema(99), { compileValidators })
+      t.assert.doesNotThrow(() => stringify(42))
+    }
+  }
+
+  t.assert.throws(
+    () => build(createReferencedNotSchema(100)),
+    { message: 'schema exceeds maximum depth of 100' }
+  )
+})
+
+test('rejects deeply nested non-schema values before dependency traversal', (t) => {
+  let defaultValue = 'value'
+  for (let i = 0; i < 2000; i++) defaultValue = { value: defaultValue }
+
+  t.assert.throws(
+    () => build({ allOf: [{ type: 'object', default: defaultValue }] }),
+    { message: 'schema exceeds maximum depth of 100' }
+  )
+})
+
+test('supports a configurable maximum schema depth', (t) => {
+  t.assert.throws(
+    () => build(createNestedSchema(3), { maxDepth: 2 }),
+    { message: 'schema exceeds maximum depth of 2' }
+  )
+  t.assert.throws(
+    () => build({ not: { not: { not: { type: 'string' } } } }, { maxDepth: 2 }),
+    { message: 'schema exceeds maximum depth of 2' }
+  )
+  t.assert.doesNotThrow(() => build(createNestedSchema(3), { maxDepth: 3 }))
+  t.assert.doesNotThrow(() => build({ type: 'string' }, { maxDepth: 0 }))
+  t.assert.doesNotThrow(() => build(false, { maxDepth: 0 }))
+  t.assert.throws(
+    () => build({ type: 'object', properties: { value: true } }, { maxDepth: 0 }),
+    { message: 'schema exceeds maximum depth of 0' }
+  )
+})
+
+test('rejects invalid maximum schema depths', (t) => {
+  t.assert.throws(() => build(null), { message: /^schema is invalid:/ })
+  t.assert.throws(
+    () => build({}, { maxDepth: '100' }),
+    { message: 'Unsupported max schema depth 100. Expected an integer between 0 and 100.' }
+  )
+  t.assert.throws(
+    () => build({}, { maxDepth: -1 }),
+    { message: 'Unsupported max schema depth -1. Expected an integer between 0 and 100.' }
+  )
+  t.assert.throws(
+    () => build({}, { maxDepth: 101 }),
+    { message: 'Unsupported max schema depth 101. Expected an integer between 0 and 100.' }
+  )
+})
+
+test('checks schema dependencies without treating property lists as schemas', (t) => {
+  t.assert.doesNotThrow(() => build({
+    type: 'object',
+    dependencies: {
+      enabled: { properties: { value: { type: 'string' } } },
+      value: ['enabled']
+    }
+  }, { maxDepth: 2 }))
+})
+
+test('checks external schemas before validating them recursively', (t) => {
+  t.assert.throws(
+    () => build({ type: 'string' }, {
+      maxDepth: 1,
+      schema: { external: createNestedSchema(2) }
+    }),
+    { message: '"external" schema exceeds maximum depth of 1' }
+  )
+})
+
+test('counts nested schema levels reached through external references', (t) => {
+  const externalSchemas = {
+    first: {
+      $id: 'first',
+      type: 'object',
+      properties: { value: { $ref: 'second' } }
+    },
+    second: {
+      $id: 'second',
+      type: 'object',
+      properties: { value: { $ref: 'third' } }
+    },
+    third: {
+      $id: 'third',
+      type: 'object',
+      properties: { value: { type: 'string' } }
+    }
+  }
+
+  t.assert.throws(
+    () => build({ $ref: 'first' }, { maxDepth: 1, schema: externalSchemas }),
+    { message: 'schema exceeds maximum depth of 1' }
+  )
+  t.assert.doesNotThrow(() => build({ $ref: 'first' }, { maxDepth: 3, schema: externalSchemas }))
+})
+
+test('limits reference chains reached through validator-only keywords', (t) => {
+  const externalSchemas = {}
+  const dependencyCount = 1000
+
+  for (let i = 0; i < dependencyCount; i++) {
+    externalSchemas[`dependency-${i}`] = {
+      $id: `dependency-${i}`,
+      ...(i + 1 < dependencyCount
+        ? { $ref: `dependency-${i + 1}` }
+        : { type: 'string' })
+    }
+  }
+
+  const schema = {
+    anyOf: [{ not: { $ref: 'dependency-0' } }]
+  }
+
+  for (const compileValidators of [false, true]) {
+    t.assert.throws(
+      () => build(schema, { compileValidators, schema: externalSchemas }),
+      { message: 'schema exceeds maximum depth of 100' }
+    )
+  }
+})
+
+test('walks references in non-schema values without recursive dependency discovery', (t) => {
+  const externalSchemas = {}
+  const dependencyCount = 10000
+
+  for (let i = 0; i < dependencyCount; i++) {
+    externalSchemas[`annotation-${i}`] = {
+      $id: `annotation-${i}`,
+      $ref: i + 1 < dependencyCount ? `annotation-${i + 1}` : 'root'
+    }
+  }
+
+  t.assert.doesNotThrow(() => build({
+    $id: 'root',
+    type: 'string',
+    anyOf: [{ type: 'string' }],
+    default: { $ref: 'annotation-0' }
+  }, { schema: externalSchemas }))
+})
+
+test('limits and detects reference-only chains', (t) => {
+  const externalSchemas = {
+    first: { $id: 'first', $ref: 'second' },
+    second: { $id: 'second', $ref: 'third' },
+    third: { $id: 'third', type: 'string' }
+  }
+
+  t.assert.throws(
+    () => build({ $ref: 'first' }, { maxDepth: 1, schema: externalSchemas }),
+    { message: 'schema exceeds maximum depth of 1' }
+  )
+
+  externalSchemas.third = { $id: 'third', $ref: 'first' }
+  t.assert.throws(
+    () => build({ $ref: 'first' }, { schema: externalSchemas }),
+    { message: 'Cannot resolve circular reference "second"' }
+  )
+})
+
+test('rejects circular object graphs before schema validation', (t) => {
+  const schema = { type: 'object', properties: {} }
+  schema.properties.self = schema
+
+  t.assert.throws(
+    () => build(schema),
+    { message: 'schema contains a circular object reference; use $ref instead' }
+  )
+})