fast-json-stringify 7.0.0 → 7.1.0

package/test/const.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('schema with const string', (t) => {
@@ -24,6 +24,26 @@ test('schema with const string', (t) => {
   t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
+test('schema with const string containing characters that need escaping', (t) => {
+  const values = ['back\\slash', 'tab\there', 'quote"here', 'new\nline', "tick's"]
+  t.plan(values.length * 2)
+
+  for (const value of values) {
+    const schema = {
+      type: 'object',
+      properties: {
+        foo: { const: value }
+      }
+    }
+
+    const stringify = build(schema)
+    const output = stringify({ foo: value })
+
+    t.assert.equal(output, JSON.stringify({ foo: value }))
+    t.assert.deepStrictEqual(JSON.parse(output), { foo: value })
+  }
+})
+
 test('schema with const string and different input', (t) => {
   t.plan(2)
 
@@ -259,7 +279,9 @@ test('schema with const and null as type', (t) => {
   })
 
   t.assert.equal(output, '{"foo":null}')
-  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
+  // `const` applies regardless of `type` in JSON Schema, so ajv rejects null
+  // here even though the serializer lets it through because the type allows it.
+  t.assert.equal(validate(JSON.parse(output)), false)
 
   const output2 = stringify({ foo: 'baz' })
   t.assert.equal(output2, '{"foo":"baz"}')
@@ -267,7 +289,7 @@ test('schema with const and null as type', (t) => {
 })
 
 test('schema with const as nullable', (t) => {
-  t.plan(4)
+  t.plan(2)
 
   const schema = {
     type: 'object',
@@ -276,20 +298,19 @@ test('schema with const as nullable', (t) => {
     }
   }
 
-  const validate = validator(schema)
+  // ajv refuses to compile `nullable` without a `type`, so the output is not
+  // validated against the schema in this test.
   const stringify = build(schema)
   const output = stringify({
     foo: null
   })
 
   t.assert.equal(output, '{"foo":null}')
-  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 
   const output2 = stringify({
     foo: 'baz'
   })
   t.assert.equal(output2, '{"foo":"baz"}')
-  t.assert.ok(validate(JSON.parse(output2)), 'valid schema')
 })
 
 test('schema with const and invalid object', (t) => {

package/test/date.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('..')
 
 process.env.TZ = 'UTC'
@@ -637,3 +637,30 @@ test('should serialize also an invalid string value, even if it is not a valid t
   t.assert.equal(output, JSON.stringify(toStringify))
   t.assert.equal(validate(JSON.parse(output)), false, 'valid schema')
 })
+
+test('should escape strings that are not valid dates', (t) => {
+  const formats = ['date-time', 'date', 'time']
+  const values = [
+    '2026-01-01T00:00:00Z","admin":true,"x":"',
+    'back\\slash',
+    'new\nline',
+    'lone \ud800 surrogate'
+  ]
+
+  t.plan(formats.length * values.length * 2)
+
+  for (const format of formats) {
+    const stringify = build({
+      type: 'object',
+      properties: {
+        ts: { type: 'string', format }
+      }
+    })
+
+    for (const value of values) {
+      const output = stringify({ ts: value })
+      t.assert.equal(output, `{"ts":${JSON.stringify(value)}}`)
+      t.assert.deepStrictEqual(JSON.parse(output), { ts: value })
+    }
+  }
+})

package/test/debug-mode.test.js

@@ -128,3 +128,11 @@ test('Validator restoreFromState', t => {
   const restored = Validator.restoreFromState(state)
   t.assert.ok(restored instanceof Validator)
 })
+
+test('Validator ignores null schemas while converting nested values', t => {
+  t.plan(1)
+
+  const validator = new Validator()
+
+  t.assert.doesNotThrow(() => validator.convertSchemaToAjvFormat(null))
+})

package/test/deopt.test.js

@@ -0,0 +1,251 @@
+'use strict'
+
+// V8 has to optimize the generated serializers and keep them optimized when they see again the
+// values they were optimized for. To see why a case fails: node --trace-deopt test/deopt.test.js
+
+const { test } = require('node:test')
+const v8 = require('node:v8')
+
+// before the library loads, so its functions collect feedback from the first call
+v8.setFlagsFromString('--allow-natives-syntax')
+v8.setFlagsFromString('--no-lazy-feedback-allocation')
+
+const build = require('..')
+
+/* eslint no-new-func: "off" */
+const prepare = new Function('fn', '%PrepareFunctionForOptimization(fn)')
+const optimize = new Function('fn', '%OptimizeFunctionOnNextCall(fn)')
+const isOptimized = new Function('fn', 'return %ActiveTierIsTurbofan(fn)')
+
+function assertStaysOptimized (t, stringify, inputs) {
+  prepare(stringify)
+  for (const input of inputs) stringify(input)
+  optimize(stringify)
+  stringify(inputs[0])
+  t.assert.ok(isOptimized(stringify), 'V8 did not optimize it')
+
+  for (let round = 0; round < 100; round++) {
+    for (let i = 0; i < inputs.length; i++) {
+      stringify(inputs[i])
+      if (!isOptimized(stringify)) t.assert.fail(`deoptimized by input ${i} in round ${round}`)
+    }
+  }
+}
+
+test('string', (t) => {
+  assertStaysOptimized(t, build({ type: 'string' }), [
+    'hello', 'say "hi"', 'π', '😀', 'line\nbreak', '',
+    'x'.repeat(100), 'y"'.repeat(50), 'z'.repeat(6000), null, new Date(0), /re/, 42
+  ])
+})
+
+test('string formats', (t) => {
+  const stringify = build({
+    type: 'object',
+    properties: {
+      dateTime: { type: 'string', format: 'date-time' },
+      date: { type: 'string', format: 'date' },
+      time: { type: 'string', format: 'time' },
+      unsafe: { type: 'string', format: 'unsafe' }
+    }
+  })
+  assertStaysOptimized(t, stringify, [
+    { dateTime: new Date(0), date: new Date(0), time: new Date(0), unsafe: 'raw' },
+    { dateTime: '2020-01-01T00:00:00.000Z', date: '2020-01-01', time: '10:00:00', unsafe: 'raw' },
+    { dateTime: null, date: null, time: null }
+  ])
+})
+
+test('number', (t) => {
+  assertStaysOptimized(t, build({ type: 'number' }), [42, -1.5, 1e21, Infinity, '42'])
+})
+
+test('integer', (t) => {
+  assertStaysOptimized(t, build({ type: 'integer' }), [42, -42, 4.7, 2 ** 40, 10n])
+})
+
+test('integer with rounding', (t) => {
+  assertStaysOptimized(t, build({ type: 'integer' }, { rounding: 'round' }), [42, 4.7, -4.2])
+})
+
+test('boolean', (t) => {
+  assertStaysOptimized(t, build({ type: 'boolean' }), [true, false, 0, 'yes'])
+})
+
+test('object', (t) => {
+  const stringify = build({
+    type: 'object',
+    properties: {
+      id: { type: 'integer' },
+      name: { type: 'string' },
+      score: { type: 'number' },
+      active: { type: 'boolean' },
+      role: { type: 'string', default: 'user' },
+      note: { type: 'string', nullable: true },
+      address: {
+        type: 'object',
+        properties: { city: { type: 'string' }, zip: { type: 'integer' } }
+      }
+    },
+    required: ['id', 'name']
+  })
+  assertStaysOptimized(t, stringify, [
+    { id: 1, name: 'a', score: 1.5, active: true, role: 'admin', note: 'n', address: { city: 'c', zip: 1 } },
+    { id: 2, name: 'b', score: 2, note: null, address: null },
+    { id: 3, name: 'c' }
+  ])
+})
+
+test('array', (t) => {
+  const stringify = build({
+    type: 'object',
+    properties: {
+      numbers: { type: 'array', items: { type: 'number' } },
+      strings: { type: 'array', items: { type: 'string' } },
+      objects: {
+        type: 'array',
+        items: { type: 'object', properties: { s: { type: 'string' }, n: { type: 'number' } } }
+      },
+      tuple: { type: 'array', items: [{ type: 'string' }, { type: 'integer' }] },
+      open: { type: 'array', items: [{ type: 'string' }], additionalItems: true }
+    }
+  })
+  assertStaysOptimized(t, stringify, [
+    {
+      numbers: [1, 2.5],
+      strings: ['a', 'b"'],
+      objects: [{ s: 'a', n: 1 }, { s: 'b', n: 2.5 }],
+      tuple: ['a', 1],
+      open: ['a', 1, true]
+    },
+    { numbers: [], strings: [], objects: [], tuple: ['a'], open: [] }
+  ])
+})
+
+test('large array mechanism', (t) => {
+  const stringify = build(
+    { type: 'array', items: { type: 'integer' } },
+    { largeArrayMechanism: 'json-stringify', largeArraySize: 3 }
+  )
+  assertStaysOptimized(t, stringify, [[1, 2], [1, 2, 3, 4]])
+})
+
+test('additionalProperties and patternProperties', (t) => {
+  const stringify = build({
+    type: 'object',
+    properties: { a: { type: 'string' } },
+    patternProperties: { '^n': { type: 'number' } },
+    additionalProperties: { type: 'string' }
+  })
+  assertStaysOptimized(t, stringify, [{ a: 'x', n1: 1, n2: 2.5, other: 'y' }, { other: 'y' }])
+})
+
+test('additionalProperties true', (t) => {
+  const stringify = build({ type: 'object', additionalProperties: true })
+  assertStaysOptimized(t, stringify, [{ a: 'x', b: 1, c: [1, { d: null }] }, {}])
+})
+
+test('multiple types', (t) => {
+  const stringify = build({
+    type: 'object',
+    properties: {
+      value: { type: ['string', 'integer', 'null'] },
+      list: { type: ['array', 'object'], items: { type: 'integer' }, properties: { a: { type: 'integer' } } }
+    }
+  })
+  assertStaysOptimized(t, stringify, [
+    { value: 'a', list: [1, 2] },
+    { value: 1, list: { a: 1 } },
+    { value: null }
+  ])
+})
+
+test('anyOf and oneOf', (t) => {
+  const stringify = build({
+    type: 'object',
+    properties: {
+      any: { anyOf: [{ type: 'string' }, { type: 'number' }] },
+      one: {
+        oneOf: [
+          { type: 'object', properties: { kind: { const: 'a' }, a: { type: 'string' } }, required: ['kind'] },
+          { type: 'object', properties: { kind: { const: 'b' }, b: { type: 'number' } }, required: ['kind'] }
+        ]
+      }
+    }
+  })
+  assertStaysOptimized(t, stringify, [
+    { any: 'x', one: { kind: 'a', a: 'x' } },
+    { any: 1, one: { kind: 'b', b: 1 } }
+  ])
+})
+
+test('if then else', (t) => {
+  const stringify = build({
+    type: 'object',
+    properties: { kind: { type: 'string' } },
+    if: { type: 'object', properties: { kind: { const: 'a' } } },
+    then: { properties: { a: { type: 'string' } } },
+    else: { properties: { b: { type: 'number' } } }
+  })
+  assertStaysOptimized(t, stringify, [{ kind: 'a', a: 'x' }, { kind: 'b', b: 1 }])
+})
+
+test('allOf', (t) => {
+  const stringify = build({
+    allOf: [
+      { type: 'object', properties: { a: { type: 'string' } } },
+      { properties: { b: { type: 'number' } } }
+    ]
+  })
+  assertStaysOptimized(t, stringify, [{ a: 'x', b: 1 }, {}])
+})
+
+test('recursive ref', (t) => {
+  const stringify = build({
+    $id: 'tree',
+    type: 'object',
+    properties: {
+      value: { type: 'integer' },
+      children: { type: 'array', items: { $ref: 'tree#' } }
+    }
+  })
+  assertStaysOptimized(t, stringify, [
+    { value: 1, children: [{ value: 2, children: [] }, { value: 3, children: [{ value: 4 }] }] },
+    { value: 5 }
+  ])
+})
+
+test('external ref', (t) => {
+  const defs = {
+    $id: 'defs',
+    definitions: { item: { type: 'object', properties: { x: { type: 'string' } } } }
+  }
+  const stringify = build(
+    { type: 'object', properties: { item: { $ref: 'defs#/definitions/item' } } },
+    { schema: { defs } }
+  )
+  assertStaysOptimized(t, stringify, [{ item: { x: 'y' } }, {}])
+})
+
+test('toJSON', (t) => {
+  const stringify = build({ type: 'object', properties: { a: { type: 'string' } } })
+  assertStaysOptimized(t, stringify, [{ a: 'x' }, { toJSON () { return { a: 'y' } } }])
+})
+
+// V8 does not optimize a function over a size, so a serializer whose code grows too much with
+// every property stops being optimized for a wide object like this one
+test('wide object', (t) => {
+  const properties = {}
+  const input = {}
+  for (let i = 0; i < 300; i++) {
+    switch (i % 4) {
+      case 0: properties[`s${i}`] = { type: 'string' }; input[`s${i}`] = 'x'; break
+      case 1: properties[`n${i}`] = { type: 'number' }; input[`n${i}`] = i; break
+      case 2: properties[`b${i}`] = { type: 'boolean' }; input[`b${i}`] = true; break
+      case 3:
+        properties[`o${i}`] = { type: 'object', properties: { a: { type: 'string' }, b: { type: 'integer' } } }
+        input[`o${i}`] = { a: 'y', b: i }
+    }
+  }
+  assertStaysOptimized(t, build({ type: 'object', properties }), [input, {}])
+})

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

@@ -538,3 +538,148 @@ test('if-then-else with allOf', (t) => {
   t.assert.doesNotThrow(() => JSON.parse(output))
   t.assert.equal(output, '{"base":"test","foo":"value"}')
 })
+
+test('if with a bare top-level $ref validates directly against the registered schema', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    if: { $ref: 'IsFoo#' },
+    then: {
+      type: 'object',
+      properties: {
+        foo: { type: 'string' }
+      }
+    },
+    else: {
+      type: 'object',
+      properties: {
+        bar: { type: 'string' }
+      }
+    }
+  }
+  const externalSchema = {
+    IsFoo: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', const: 'foo' }
+      },
+      required: ['kind']
+    }
+  }
+
+  const code = build(schema, { mode: 'standalone', schema: externalSchema })
+  t.assert.ok(code.includes('validator.validate("IsFoo#"'), 'validates directly against the bare registered id')
+
+  const stringify = build(schema, { schema: externalSchema })
+  t.assert.equal(stringify({ kind: 'foo', foo: 'value', bar: 'ignored' }), '{"foo":"value"}')
+})
+
+test('if with a $ref into a JSON-pointer sub-path validates directly against that sub-path', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    if: { $ref: 'Rules#/definitions/IsFoo' },
+    then: {
+      type: 'object',
+      properties: {
+        foo: { type: 'string' }
+      }
+    },
+    else: {
+      type: 'object',
+      properties: {
+        bar: { type: 'string' }
+      }
+    }
+  }
+  const externalSchema = {
+    Rules: {
+      definitions: {
+        IsFoo: {
+          type: 'object',
+          properties: {
+            kind: { type: 'string', const: 'foo' }
+          },
+          required: ['kind']
+        }
+      }
+    }
+  }
+
+  const code = build(schema, { mode: 'standalone', schema: externalSchema })
+  t.assert.ok(code.includes('validator.validate("Rules#/definitions/IsFoo"'), 'validates directly against the registered sub-path ref')
+
+  const stringify = build(schema, { schema: externalSchema })
+  t.assert.equal(stringify({ kind: 'foo', foo: 'value', bar: 'ignored' }), '{"foo":"value"}')
+})
+
+test('if with a $ref that has sibling keywords is left unchanged', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    if: { $ref: 'IsFoo#', required: ['extra'] },
+    then: {
+      type: 'object',
+      properties: {
+        foo: { type: 'string' }
+      }
+    },
+    else: {
+      type: 'object',
+      properties: {
+        bar: { type: 'string' }
+      }
+    }
+  }
+  const externalSchema = {
+    IsFoo: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', const: 'foo' }
+      },
+      required: ['kind']
+    }
+  }
+
+  const code = build(schema, { mode: 'standalone', schema: externalSchema })
+  t.assert.ok(!code.includes('validator.validate("IsFoo#"'), 'ref with sibling keywords is not redirected')
+
+  const stringify = build(schema, { schema: externalSchema })
+  t.assert.equal(stringify({ kind: 'foo', foo: 'ignored', bar: 'fallback' }), '{"bar":"fallback"}')
+})
+
+test('if/else without then applies the else branch', (t) => {
+  t.plan(4)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      kind: { type: 'string' }
+    },
+    if: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', enum: ['foobar'] }
+      }
+    },
+    else: {
+      type: 'object',
+      properties: {
+        bar: { type: 'string' }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  const elseOutput = stringify({ kind: 'other', bar: 'value' })
+  t.assert.equal(elseOutput, '{"kind":"other","bar":"value"}')
+  t.assert.deepStrictEqual(JSON.parse(elseOutput), { kind: 'other', bar: 'value' })
+
+  const thenOutput = stringify({ kind: 'foobar', bar: 'value' })
+  t.assert.equal(thenOutput, '{"kind":"foobar"}')
+  t.assert.deepStrictEqual(JSON.parse(thenOutput), { kind: 'foobar' })
+})

package/test/inferType.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('..')
 
 function buildTest (schema, toStringify) {

package/test/integer.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('node:test')
 
-const validator = require('is-my-json-valid')
+const validator = require('./utils/validator')
 const build = require('..')
 const ROUNDING_TYPES = ['ceil', 'floor', 'round']