fast-json-stringify 7.1.3 → 7.1.5

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')
@@ -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(),

package/lib/validator.js

@@ -6,6 +6,18 @@ const fastUri = require('fast-uri')
 const ajvFormats = require('ajv-formats')
 const clone = require('rfdc')({ proto: true })
 
+// Keywords whose value is a map of <name> -> schema rather than a schema.
+// Their keys are user-defined, so an entry named "propertyNames" is a
+// regular schema and must still be converted.
+const SCHEMA_MAP_KEYWORDS = new Set([
+  'properties',
+  'patternProperties',
+  'definitions',
+  '$defs',
+  'dependentSchemas',
+  'dependencies'
+])
+
 class Validator {
   constructor (ajvOptions, inlineValidators) {
     const codeOptions = inlineValidators
@@ -90,7 +102,16 @@ class Validator {
       schema.type.push('object')
     }
     for (const property in schema) {
-      if (typeof schema[property] === 'object') {
+      if (typeof schema[property] !== 'object') continue
+      // propertyNames validates object keys, which are always strings:
+      // adding "object" + fjs_type there only triggers Ajv strictTypes warnings
+      if (property === 'propertyNames') continue
+
+      if (SCHEMA_MAP_KEYWORDS.has(property)) {
+        for (const key in schema[property]) {
+          this.convertSchemaToAjvFormat(schema[property][key])
+        }
+      } else {
         this.convertSchemaToAjvFormat(schema[property])
       }
     }

package/package.json

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

package/test/anyof.test.js

@@ -852,3 +852,105 @@ test('invalid anyOf schema', (t) => {
     t.assert.ok(err.message.includes('schema is invalid'))
   }
 })
+
+test('anyOf branch with propertyNames does not emit Ajv strictTypes warnings', (t) => {
+  t.plan(7)
+
+  const warnMock = t.mock.method(console, 'warn')
+
+  const stringify = build({
+    type: 'object',
+    definitions: {
+      KeySchema: { type: 'string', minLength: 1 }
+    },
+    properties: {
+      fields: {
+        anyOf: [
+          { type: 'object', propertyNames: { type: 'string' }, additionalProperties: { type: 'string' } },
+          { type: 'null' }
+        ]
+      },
+      nestedCombinators: {
+        anyOf: [
+          {
+            type: 'object',
+            propertyNames: {
+              allOf: [{ type: 'string', minLength: 1 }, { $ref: '#/definitions/KeySchema' }],
+              anyOf: [{ type: 'string', pattern: '^[a-z]+$' }],
+              oneOf: [{ type: 'string' }],
+              not: { type: 'string', enum: ['forbidden'] }
+            },
+            additionalProperties: { type: 'string' }
+          },
+          { type: 'null' }
+        ]
+      }
+    }
+  })
+
+  t.assert.equal(stringify({ fields: { a: 'b' }, nestedCombinators: { abc: 'x' } }), '{"fields":{"a":"b"},"nestedCombinators":{"abc":"x"}}')
+  t.assert.equal(stringify({ fields: { a: new Date('2026-01-01T00:00:00.000Z') }, nestedCombinators: null }), '{"fields":{"a":"2026-01-01T00:00:00.000Z"},"nestedCombinators":null}')
+  t.assert.equal(stringify({ fields: null, nestedCombinators: null }), '{"fields":null,"nestedCombinators":null}')
+  t.assert.throws(() => stringify({ fields: { a: 'b' }, nestedCombinators: { forbidden: 'x' } }))
+  t.assert.throws(() => stringify({ fields: { a: 'b' }, nestedCombinators: { 123: 'x' } }))
+  t.assert.throws(() => stringify({ fields: 123, nestedCombinators: null }))
+  t.assert.equal(warnMock.mock.callCount(), 0)
+})
+
+test('anyOf branch with user-defined property named propertyNames preserves Date serialization', (t) => {
+  t.plan(3)
+
+  const warnMock = t.mock.method(console, 'warn')
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      data: {
+        anyOf: [
+          {
+            type: 'object',
+            properties: {
+              propertyNames: { type: 'string', format: 'date-time' }
+            },
+            required: ['propertyNames']
+          },
+          { type: 'null' }
+        ]
+      }
+    }
+  })
+
+  t.assert.equal(
+    stringify({ data: { propertyNames: new Date('2026-01-01T00:00:00.000Z') } }),
+    '{"data":{"propertyNames":"2026-01-01T00:00:00.000Z"}}'
+  )
+  t.assert.equal(stringify({ data: null }), '{"data":null}')
+  t.assert.equal(warnMock.mock.callCount(), 0)
+})
+
+test('$defs entry named propertyNames is still converted (Date serialization)', (t) => {
+  t.plan(2)
+
+  const warnMock = t.mock.method(console, 'warn')
+
+  const stringify = build({
+    type: 'object',
+    $defs: {
+      propertyNames: { type: 'string', format: 'date-time' }
+    },
+    properties: {
+      data: {
+        anyOf: [
+          { $ref: '#/$defs/propertyNames' },
+          { type: 'null' }
+        ]
+      }
+    }
+  })
+
+  t.assert.equal(
+    stringify({ data: new Date('2026-01-01T00:00:00.000Z') }),
+    '{"data":"2026-01-01T00:00:00.000Z"}'
+  )
+  t.assert.equal(warnMock.mock.callCount(), 0)
+})

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"/ }
+  )
+})