fast-json-stringify 5.11.1 → 5.13.0

package/lib/location.js

@@ -5,7 +5,6 @@ class Location {
     this.schema = schema
     this.schemaId = schemaId
     this.jsonPointer = jsonPointer
-    this.mergedSchemaId = null
   }
 
   getPropertyLocation (propertyName) {
@@ -14,39 +13,11 @@ class Location {
       this.schemaId,
       this.jsonPointer + '/' + propertyName
     )
-
-    if (this.mergedSchemaId !== null) {
-      propertyLocation.addMergedSchema(
-        this.schema[propertyName],
-        this.mergedSchemaId,
-        this.jsonPointer + '/' + propertyName
-      )
-    }
-
     return propertyLocation
   }
 
-  // Use this method to get current schema location.
-  // Use it when you need to create reference to the current location.
-  getSchemaId () {
-    return this.mergedSchemaId || this.schemaId
-  }
-
-  // Use this method to get original schema id for resolving user schema $refs
-  // Don't join it with a JSON pointer to get the current location.
-  getOriginSchemaId () {
-    return this.schemaId
-  }
-
   getSchemaRef () {
-    const schemaId = this.getSchemaId()
-    return schemaId + this.jsonPointer
-  }
-
-  addMergedSchema (mergedSchema, schemaId, jsonPointer = '#') {
-    this.schema = mergedSchema
-    this.mergedSchemaId = schemaId
-    this.jsonPointer = jsonPointer
+    return this.schemaId + this.jsonPointer
   }
 }
 

package/lib/merge-schemas.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { mergeSchemas: _mergeSchemas } = require('@fastify/merge-json-schemas')
+
+function mergeSchemas (schemas) {
+  return _mergeSchemas(schemas, { onConflict: 'skip' })
+}
+
+module.exports = mergeSchemas

package/lib/serializer.js

@@ -99,29 +99,20 @@ module.exports = class Serializer {
   }
 
   asString (str) {
-    if (typeof str !== 'string') {
-      if (str === null) {
-        return '""'
-      }
-      if (str instanceof Date) {
-        return '"' + str.toISOString() + '"'
-      }
-      if (str instanceof RegExp) {
-        str = str.source
-      } else {
-        str = str.toString()
-      }
-    }
-
     if (str.length < 42) {
       return this.asStringSmall(str)
-    } else if (STR_ESCAPE.test(str) === false) {
+    } else if (str.length < 5000 && STR_ESCAPE.test(str) === false) {
+      // Only use the regular expression for shorter input. The overhead is otherwise too much.
       return '"' + str + '"'
     } else {
       return JSON.stringify(str)
     }
   }
 
+  asUnsafeString (str) {
+    return '"' + str + '"'
+  }
+
   // magically escape strings for json
   // relying on their charCodeAt
   // everything below 32 needs JSON.stringify()
@@ -137,11 +128,8 @@ module.exports = class Serializer {
     // eslint-disable-next-line
     for (var i = 0; i < len; i++) {
       point = str.charCodeAt(i)
-      if (point < 32) {
-        return JSON.stringify(str)
-      }
-      if (point >= 0xD800 && point <= 0xDFFF) {
-        // The current character is a surrogate.
+      if (point < 32 || (point >= 0xD800 && point <= 0xDFFF)) {
+        // The current character is non-printable characters or a surrogate.
         return JSON.stringify(str)
       }
       if (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.11.1",
+  "version": "5.13.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "type": "commonjs",
@@ -51,13 +51,13 @@
     "fast-json-stringify": "."
   },
   "dependencies": {
-    "@fastify/deepmerge": "^1.0.0",
     "ajv": "^8.10.0",
     "ajv-formats": "^2.1.1",
     "fast-deep-equal": "^3.1.3",
     "fast-uri": "^2.1.0",
     "rfdc": "^1.2.0",
-    "json-schema-ref-resolver": "^1.0.1"
+    "json-schema-ref-resolver": "^1.0.1",
+    "@fastify/merge-json-schemas": "^0.1.0"
   },
   "standard": {
     "ignore": [

package/test/allof.test.js

@@ -121,7 +121,7 @@ test('object with allOf and multiple schema on the allOf', (t) => {
     id: 1,
     name: 'string',
     tag: 'otherString'
-  }), '{"name":"string","tag":"otherString","id":1}')
+  }), '{"name":"string","id":1,"tag":"otherString"}')
 })
 
 test('object with allOf and one schema on the allOf', (t) => {
@@ -553,8 +553,60 @@ test('allof with local anchor reference', (t) => {
   t.equal(stringify(data), JSON.stringify(data))
 })
 
+test('allOf: multiple nested $ref properties', (t) => {
+  t.plan(2)
+
+  const externalSchema1 = {
+    $id: 'externalSchema1',
+    oneOf: [
+      { $ref: '#/definitions/id1' }
+    ],
+    definitions: {
+      id1: {
+        type: 'object',
+        properties: {
+          id1: {
+            type: 'integer'
+          }
+        },
+        additionalProperties: false
+      }
+    }
+  }
+
+  const externalSchema2 = {
+    $id: 'externalSchema2',
+    oneOf: [
+      { $ref: '#/definitions/id2' }
+    ],
+    definitions: {
+      id2: {
+        type: 'object',
+        properties: {
+          id2: {
+            type: 'integer'
+          }
+        },
+        additionalProperties: false
+      }
+    }
+  }
+
+  const schema = {
+    anyOf: [
+      { $ref: 'externalSchema1' },
+      { $ref: 'externalSchema2' }
+    ]
+  }
+
+  const stringify = build(schema, { schema: [externalSchema1, externalSchema2] })
+
+  t.equal(stringify({ id1: 1 }), JSON.stringify({ id1: 1 }))
+  t.equal(stringify({ id2: 2 }), JSON.stringify({ id2: 2 }))
+})
+
 test('allOf: throw Error if types mismatch ', (t) => {
-  t.plan(1)
+  t.plan(3)
 
   const schema = {
     allOf: [
@@ -562,11 +614,18 @@ test('allOf: throw Error if types mismatch ', (t) => {
       { type: 'number' }
     ]
   }
-  t.throws(() => build(schema), new Error('allOf schemas have different type values'))
+  try {
+    build(schema)
+    t.fail('should throw the MergeError')
+  } catch (error) {
+    t.ok(error instanceof Error)
+    t.equal(error.message, 'Failed to merge "type" keyword schemas.')
+    t.same(error.schemas, [['string'], ['number']])
+  }
 })
 
 test('allOf: throw Error if format mismatch ', (t) => {
-  t.plan(1)
+  t.plan(3)
 
   const schema = {
     allOf: [
@@ -574,29 +633,87 @@ test('allOf: throw Error if format mismatch ', (t) => {
       { format: 'time' }
     ]
   }
-  t.throws(() => build(schema), new Error('allOf schemas have different format values'))
+  try {
+    build(schema)
+    t.fail('should throw the MergeError')
+  } catch (error) {
+    t.ok(error instanceof Error)
+    t.equal(error.message, 'Failed to merge "format" keyword schemas.')
+    t.same(error.schemas, ['date', 'time'])
+  }
 })
 
-test('allOf: throw Error if nullable mismatch /1', (t) => {
+test('recursive nested allOfs', (t) => {
   t.plan(1)
 
   const schema = {
-    allOf: [
-      { nullable: true },
-      { nullable: false }
-    ]
+    type: 'object',
+    properties: {
+      foo: {
+        additionalProperties: false,
+        allOf: [{ $ref: '#' }]
+      }
+    }
   }
-  t.throws(() => build(schema), new Error('allOf schemas have different nullable values'))
+
+  const data = { foo: {} }
+  const stringify = build(schema)
+  t.equal(stringify(data), JSON.stringify(data))
 })
 
-test('allOf: throw Error if nullable mismatch /2', (t) => {
+test('recursive nested allOfs', (t) => {
   t.plan(1)
 
   const schema = {
-    allOf: [
-      { nullable: false },
-      { nullable: true }
-    ]
+    type: 'object',
+    properties: {
+      foo: {
+        additionalProperties: false,
+        allOf: [{ allOf: [{ $ref: '#' }] }]
+      }
+    }
+  }
+
+  const data = { foo: {} }
+  const stringify = build(schema)
+  t.equal(stringify(data), JSON.stringify(data))
+})
+
+test('external recursive allOfs', (t) => {
+  t.plan(1)
+
+  const externalSchema = {
+    type: 'object',
+    properties: {
+      foo: {
+        properties: {
+          bar: { type: 'string' }
+        },
+        allOf: [{ $ref: '#' }]
+      }
+    }
+  }
+
+  const schema = {
+    type: 'object',
+    properties: {
+      a: { $ref: 'externalSchema#/properties/foo' },
+      b: { $ref: 'externalSchema#/properties/foo' }
+    }
+  }
+
+  const data = {
+    a: {
+      foo: {},
+      bar: '42',
+      baz: 42
+    },
+    b: {
+      foo: {},
+      bar: '42',
+      baz: 42
+    }
   }
-  t.throws(() => build(schema), new Error('allOf schemas have different nullable values'))
+  const stringify = build(schema, { schema: { externalSchema } })
+  t.equal(stringify(data), '{"a":{"bar":"42","foo":{}},"b":{"bar":"42","foo":{}}}')
 })

package/test/anyof.test.js

@@ -644,3 +644,151 @@ test('object with ref and validated properties', (t) => {
   const stringify = build(schema, { schema: externalSchemas })
   t.equal(stringify({ id: 1, reference: 'hi' }), '{"id":1,"reference":"hi"}')
 })
+
+test('anyOf required props', (t) => {
+  t.plan(3)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      prop1: { type: 'string' },
+      prop2: { type: 'string' },
+      prop3: { type: 'string' }
+    },
+    required: ['prop1'],
+    anyOf: [{ required: ['prop2'] }, { required: ['prop3'] }]
+  }
+  const stringify = build(schema)
+  t.equal(stringify({ prop1: 'test', prop2: 'test2' }), '{"prop1":"test","prop2":"test2"}')
+  t.equal(stringify({ prop1: 'test', prop3: 'test3' }), '{"prop1":"test","prop3":"test3"}')
+  t.equal(stringify({ prop1: 'test', prop2: 'test2', prop3: 'test3' }), '{"prop1":"test","prop2":"test2","prop3":"test3"}')
+})
+
+test('anyOf required props', (t) => {
+  t.plan(3)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      prop1: { type: 'string' }
+    },
+    anyOf: [
+      {
+        properties: {
+          prop2: { type: 'string' }
+        }
+      },
+      {
+        properties: {
+          prop3: { type: 'string' }
+        }
+      }
+    ]
+  }
+  const stringify = build(schema)
+  t.equal(stringify({ prop1: 'test1' }), '{"prop1":"test1"}')
+  t.equal(stringify({ prop2: 'test2' }), '{"prop2":"test2"}')
+  t.equal(stringify({ prop1: 'test1', prop2: 'test2' }), '{"prop1":"test1","prop2":"test2"}')
+})
+
+test('recursive nested anyOfs', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: {
+        additionalProperties: false,
+        anyOf: [{ $ref: '#' }]
+      }
+    }
+  }
+
+  const data = { foo: {} }
+  const stringify = build(schema)
+  t.equal(stringify(data), JSON.stringify(data))
+})
+
+test('recursive nested anyOfs', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: {
+        additionalProperties: false,
+        anyOf: [{ anyOf: [{ $ref: '#' }] }]
+      }
+    }
+  }
+
+  const data = { foo: {} }
+  const stringify = build(schema)
+  t.equal(stringify(data), JSON.stringify(data))
+})
+
+test('external recursive anyOfs', (t) => {
+  t.plan(1)
+
+  const externalSchema = {
+    type: 'object',
+    properties: {
+      foo: {
+        properties: {
+          bar: { type: 'string' }
+        },
+        anyOf: [{ $ref: '#' }]
+      }
+    }
+  }
+
+  const schema = {
+    type: 'object',
+    properties: {
+      a: { $ref: 'externalSchema#/properties/foo' },
+      b: { $ref: 'externalSchema#/properties/foo' }
+    }
+  }
+
+  const data = {
+    a: {
+      foo: {},
+      bar: '42',
+      baz: 42
+    },
+    b: {
+      foo: {},
+      bar: '42',
+      baz: 42
+    }
+  }
+  const stringify = build(schema, { schema: { externalSchema } })
+  t.equal(stringify(data), '{"a":{"bar":"42","foo":{}},"b":{"bar":"42","foo":{}}}')
+})
+
+test('should build merged schemas twice', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      enums: {
+        type: 'string',
+        anyOf: [
+          { type: 'string', const: 'FOO' },
+          { type: 'string', const: 'BAR' }
+        ]
+      }
+    }
+  }
+
+  {
+    const stringify = build(schema)
+    t.equal(stringify({ enums: 'FOO' }), '{"enums":"FOO"}')
+  }
+
+  {
+    const stringify = build(schema)
+    t.equal(stringify({ enums: 'BAR' }), '{"enums":"BAR"}')
+  }
+})

package/test/basic.test.js

@@ -18,6 +18,12 @@ function buildTest (schema, toStringify) {
   })
 }
 
+buildTest({
+  title: 'string',
+  type: 'string',
+  format: 'unsafe'
+}, 'hello world')
+
 buildTest({
   title: 'basic',
   type: 'object',

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

@@ -249,15 +249,7 @@ const alphabetOutput = JSON.stringify({
 const deepFoobarOutput = JSON.stringify({
   foobar: JSON.parse(foobarOutput)
 })
-const noElseGreetingOutput = JSON.stringify({
-  kind: 'greeting',
-  foo: 'FOO',
-  bar: 42,
-  hi: 'HI',
-  hello: 45,
-  a: 'A',
-  b: 35
-})
+const noElseGreetingOutput = JSON.stringify({})
 
 t.test('if-then-else', t => {
   const tests = [
@@ -419,3 +411,60 @@ t.test('if/else with array', (t) => {
   t.equal(stringify(['1']), JSON.stringify(['1']))
   t.equal(stringify(['1', '2']), JSON.stringify([1, 2]))
 })
+
+t.test('external recursive if/then/else', (t) => {
+  t.plan(1)
+
+  const externalSchema = {
+    type: 'object',
+    properties: {
+      base: { type: 'string' },
+      self: { $ref: 'externalSchema#' }
+    },
+    if: {
+      type: 'object',
+      properties: {
+        foo: { type: 'string', const: '41' }
+      }
+    },
+    then: {
+      type: 'object',
+      properties: {
+        bar: { type: 'string', const: '42' }
+      }
+    },
+    else: {
+      type: 'object',
+      properties: {
+        baz: { type: 'string', const: '43' }
+      }
+    }
+  }
+
+  const schema = {
+    type: 'object',
+    properties: {
+      a: { $ref: 'externalSchema#/properties/self' },
+      b: { $ref: 'externalSchema#/properties/self' }
+    }
+  }
+
+  const data = {
+    a: {
+      base: 'a',
+      foo: '41',
+      bar: '42',
+      baz: '43',
+      ignore: 'ignored'
+    },
+    b: {
+      base: 'b',
+      foo: 'not-41',
+      bar: '42',
+      baz: '43',
+      ignore: 'ignored'
+    }
+  }
+  const stringify = build(schema, { schema: { externalSchema } })
+  t.equal(stringify(data), '{"a":{"base":"a","bar":"42"},"b":{"base":"b","baz":"43"}}')
+})

package/test/required.test.js

@@ -126,17 +126,18 @@ test('object with multiple required field not in properties schema', (t) => {
     stringify({})
     t.fail()
   } catch (e) {
-    t.equal(e.message, '"num" is required!')
+    t.equal(e.message, '"key1" is required!')
     t.pass()
   }
 
   try {
     stringify({
-      num: 42
+      key1: 42,
+      key2: 42
     })
     t.fail()
   } catch (e) {
-    t.equal(e.message, '"key1" is required!')
+    t.equal(e.message, '"num" is required!')
     t.pass()
   }
 

package/test/string.test.js

@@ -48,3 +48,37 @@ test('serialize long string', (t) => {
   t.equal(output, `"${new Array(2e4).fill('\\u0000').join('')}"`)
   t.equal(JSON.parse(output), input)
 })
+
+test('unsafe string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    format: 'unsafe'
+  }
+
+  const input = 'abcd'
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  t.equal(output, `"${input}"`)
+  t.equal(JSON.parse(output), input)
+})
+
+test('unsafe unescaped string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    format: 'unsafe'
+  }
+
+  const input = 'abcd "abcd"'
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  t.equal(output, `"${input}"`)
+  t.throws(function () {
+    JSON.parse(output)
+  })
+})

package/types/index.d.ts

@@ -208,6 +208,9 @@ interface StandaloneOption extends build.Options {
   mode: 'standalone'
 }
 
+type StringCoercible = string | Date | RegExp;
+type IntegerCoercible = number | BigInt;
+
 /**
  * Build a stringify function using a schema of the documents that should be stringified
  * @param schema The schema used to stringify values
@@ -217,8 +220,8 @@ declare function build(schema: build.AnySchema, options: DebugOption): { code: s
 declare function build(schema: build.AnySchema, options: DeprecateDebugOption): { code: string, ajv: Ajv };
 declare function build(schema: build.AnySchema, options: StandaloneOption): string;
 declare function build(schema: build.AnySchema, options?: build.Options): <TDoc = any>(doc: TDoc) => any;
-declare function build(schema: build.StringSchema, options?: build.Options): <TDoc extends string = string>(doc: TDoc) => string;
-declare function build(schema: build.IntegerSchema | build.NumberSchema, options?: build.Options): <TDoc extends number = number>(doc: TDoc) => string;
+declare function build(schema: build.StringSchema, options?: build.Options): <TDoc extends StringCoercible = StringCoercible>(doc: TDoc) => string;
+declare function build(schema: build.IntegerSchema | build.NumberSchema, options?: build.Options): <TDoc extends IntegerCoercible = IntegerCoercible>(doc: TDoc) => string;
 declare function build(schema: build.NullSchema, options?: build.Options): <TDoc extends null = null>(doc: TDoc) => "null";
 declare function build(schema: build.BooleanSchema, options?: build.Options): <TDoc extends boolean = boolean>(doc: TDoc) => string;
 declare function build(schema: build.ArraySchema | build.TupleSchema, options?: build.Options): <TDoc extends any[]= any[]>(doc: TDoc) => string;