fast-json-stringify 7.1.4 → 7.1.5

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.4",
+  "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)
+})