fast-json-stringify 5.2.0 → 5.4.0

package/lib/location.js

@@ -0,0 +1,55 @@
+'use strict'
+
+class Location {
+  constructor (schema, schemaId, jsonPointer = '#', isValidated = false) {
+    this.schema = schema
+    this.schemaId = schemaId
+    this.jsonPointer = jsonPointer
+    this.isValidated = isValidated
+    this.mergedSchemaId = null
+  }
+
+  getPropertyLocation (propertyName) {
+    const propertyLocation = new Location(
+      this.schema[propertyName],
+      this.schemaId,
+      this.jsonPointer + '/' + propertyName,
+      this.isValidated
+    )
+
+    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
+  }
+}
+
+module.exports = Location

package/{serializer.js → lib/serializer.js}

@@ -18,14 +18,6 @@ module.exports = class Serializer {
     }
   }
 
-  asAny (i) {
-    return JSON.stringify(i)
-  }
-
-  asNull () {
-    return 'null'
-  }
-
   asInteger (i) {
     if (typeof i === 'bigint') {
       return i.toString()
@@ -42,10 +34,6 @@ module.exports = class Serializer {
     }
   }
 
-  asIntegerNullable (i) {
-    return i === null ? 'null' : this.asInteger(i)
-  }
-
   asNumber (i) {
     const num = Number(i)
     if (Number.isNaN(num)) {
@@ -57,18 +45,10 @@ module.exports = class Serializer {
     }
   }
 
-  asNumberNullable (i) {
-    return i === null ? 'null' : this.asNumber(i)
-  }
-
   asBoolean (bool) {
     return bool && 'true' || 'false' // eslint-disable-line
   }
 
-  asBooleanNullable (bool) {
-    return bool === null ? 'null' : this.asBoolean(bool)
-  }
-
   asDateTime (date) {
     if (date === null) return '""'
     if (date instanceof Date) {
@@ -80,10 +60,6 @@ module.exports = class Serializer {
     throw new Error(`The value "${date}" cannot be converted to a date-time.`)
   }
 
-  asDateTimeNullable (date) {
-    return date === null ? 'null' : this.asDateTime(date)
-  }
-
   asDate (date) {
     if (date === null) return '""'
     if (date instanceof Date) {
@@ -95,10 +71,6 @@ module.exports = class Serializer {
     throw new Error(`The value "${date}" cannot be converted to a date.`)
   }
 
-  asDateNullable (date) {
-    return date === null ? 'null' : this.asDate(date)
-  }
-
   asTime (date) {
     if (date === null) return '""'
     if (date instanceof Date) {
@@ -110,10 +82,6 @@ module.exports = class Serializer {
     throw new Error(`The value "${date}" cannot be converted to a time.`)
   }
 
-  asTimeNullable (date) {
-    return date === null ? 'null' : this.asTime(date)
-  }
-
   asString (str) {
     const quotes = '"'
     if (str instanceof Date) {
@@ -133,10 +101,6 @@ module.exports = class Serializer {
     }
   }
 
-  asStringNullable (str) {
-    return str === null ? 'null' : this.asString(str)
-  }
-
   // magically escape strings for json
   // relying on their charCodeAt
   // everything below 32 needs JSON.stringify()

package/{standalone.js → lib/standalone.js}

@@ -1,20 +1,21 @@
 const fs = require('fs')
 const path = require('path')
 
-function buildStandaloneCode (options, validator, contextFunctionCode) {
+function buildStandaloneCode (options, validator, isValidatorUsed, contextFunctionCode) {
   const serializerCode = fs.readFileSync(path.join(__dirname, 'serializer.js')).toString()
   let buildAjvCode = ''
-  let defaultAjvSchema = ''
-  const defaultMeta = validator.ajv.defaultMeta()
-  if (typeof defaultMeta === 'string') {
-    defaultAjvSchema = defaultMeta
-  } else {
-    defaultAjvSchema = defaultMeta.$id || defaultMeta.id
-  }
-  const shouldUseAjv = contextFunctionCode.indexOf('validator') !== -1
-  // we need to export the custom json schema
   let ajvSchemasCode = ''
-  if (shouldUseAjv) {
+
+  if (isValidatorUsed) {
+    let defaultAjvSchema = ''
+    // we need to export the custom json schema
+    const defaultMeta = validator.ajv.defaultMeta()
+    if (typeof defaultMeta === 'string') {
+      defaultAjvSchema = defaultMeta
+    } else {
+      defaultAjvSchema = defaultMeta.$id || defaultMeta.id
+    }
+
     ajvSchemasCode += `const validator = new Validator(${JSON.stringify(options.ajv || {})})\n`
     for (const [id, schema] of Object.entries(validator.ajv.schemas)) {
       // should skip ajv default schema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.2.0",
+  "version": "5.4.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,13 +9,13 @@
     "bench:cmp": "node ./benchmark/bench-cmp-branch.js",
     "bench:cmp:ci": "node ./benchmark/bench-cmp-branch.js --ci",
     "benchmark": "node ./benchmark/bench-cmp-lib.js",
+    "lint": "standard",
     "lint:fix": "standard --fix",
-    "test:lint": "standard",
-    "test:typescript": "tsc --project ./test/types/tsconfig.json",
+    "test:typescript": "tsc --project ./test/types/tsconfig.json && tsd",
     "test:unit": "tap -J test/*.test.js test/**/*.test.js",
-    "test": "npm run test:lint && npm run test:unit && npm run test:typescript"
+    "test": "npm run test:unit && npm run test:typescript"
   },
-  "precommit": "test",
+  "precommit": ["lint", "test"],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fastify/fast-json-stringify.git"
@@ -45,6 +45,7 @@
     "simple-git": "^3.7.1",
     "standard": "^17.0.0",
     "tap": "^16.0.1",
+    "tsd": "^0.24.1",
     "typescript": "^4.0.2",
     "webpack": "^5.40.0"
   },
@@ -61,5 +62,8 @@
       "schema-validator.js"
     ]
   },
-  "runkitExampleFilename": "example.js"
+  "runkitExampleFilename": "./examples/example.js",
+  "tsd": {
+    "directory": "test/types"
+  }
 }

package/test/allof.test.js

@@ -437,3 +437,48 @@ test('object with external $refs in allOf', (t) => {
   })
   t.equal(value, '{"id1":1,"id2":2}')
 })
+
+test('allof with local anchor reference', (t) => {
+  t.plan(1)
+
+  const externalSchemas = {
+    Test: {
+      $id: 'Test',
+      definitions: {
+        Problem: {
+          type: 'object',
+          properties: {
+            type: {
+              type: 'string'
+            }
+          }
+        },
+        ValidationFragment: {
+          type: 'string'
+        },
+        ValidationErrorProblem: {
+          type: 'object',
+          allOf: [
+            {
+              $ref: '#/definitions/Problem'
+            },
+            {
+              type: 'object',
+              properties: {
+                validation: {
+                  $ref: '#/definitions/ValidationFragment'
+                }
+              }
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const schema = { $ref: 'Test#/definitions/ValidationErrorProblem' }
+  const stringify = build(schema, { schema: externalSchemas })
+  const data = { type: 'foo', validation: 'bar' }
+
+  t.equal(stringify(data), JSON.stringify(data))
+})

package/test/anyof.test.js

@@ -596,3 +596,23 @@ test('anyOf object with invalid field date of type string with format or null',
   const withOneOfStringify = build(withOneOfSchema)
   t.throws(() => withOneOfStringify({ prop: toStringify }))
 })
+
+test('anyOf with a nested external schema', (t) => {
+  t.plan(1)
+
+  const externalSchemas = {
+    schema1: {
+      definitions: {
+        def1: {
+          $id: 'external',
+          type: 'string'
+        }
+      },
+      type: 'number'
+    }
+  }
+  const schema = { anyOf: [{ $ref: 'external' }] }
+
+  const stringify = build(schema, { schema: externalSchemas })
+  t.equal(stringify('foo'), '"foo"')
+})

package/test/array.test.js

@@ -4,6 +4,24 @@ const test = require('tap').test
 const validator = require('is-my-json-valid')
 const build = require('..')
 
+test('error on invalid largeArrayMechanism', (t) => {
+  t.plan(1)
+
+  t.throws(() => build({
+    title: 'large array of null values with default mechanism',
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: { type: 'null' }
+      }
+    }
+  }, {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'invalid'
+  }), Error('Unsupported large array mechanism invalid'))
+})
+
 function buildTest (schema, toStringify, options) {
   test(`render a ${schema.title} as JSON`, (t) => {
     t.plan(3)
@@ -327,6 +345,31 @@ test('object array with anyOf and symbol', (t) => {
   t.equal(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]')
 })
 
+test('different arrays with same item schemas', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      array1: {
+        type: 'array',
+        items: [{ type: 'string' }],
+        additionalItems: false
+      },
+      array2: {
+        type: 'array',
+        items: { $ref: '#/properties/array1/items' },
+        additionalItems: true
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const data = { array1: ['bar'], array2: ['foo', 'bar'] }
+
+  t.equal(stringify(data), '{"array1":["bar"],"array2":["foo","bar"]}')
+})
+
 const largeArray = new Array(2e4).fill({ a: 'test', b: 1 })
 buildTest({
   title: 'large array with default mechanism',

package/test/date.test.js

@@ -525,3 +525,22 @@ test('nullable date', (t) => {
 
   t.same(result, `"${DateTime.fromJSDate(data).toISODate()}"`)
 })
+
+test('non-date format should not affect data serialization (issue #491)', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      hello: {
+        type: 'string',
+        format: 'int64',
+        pattern: '^[0-9]*$'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const data = { hello: 123n }
+  t.equal(stringify(data), '{"hello":"123"}')
+})

package/test/debug-mode.test.js

@@ -4,7 +4,8 @@ const test = require('tap').test
 const fjs = require('..')
 
 const Ajv = require('ajv').default
-const Validator = require('../validator')
+const Validator = require('../lib/validator')
+const Serializer = require('../lib/serializer')
 
 function build (opts) {
   return fjs({
@@ -20,17 +21,18 @@ function build (opts) {
 }
 
 test('activate debug mode', t => {
-  t.plan(4)
+  t.plan(5)
   const debugMode = build({ debugMode: true })
 
   t.type(debugMode, 'object')
   t.ok(debugMode.ajv instanceof Ajv)
   t.ok(debugMode.validator instanceof Validator)
+  t.ok(debugMode.serializer instanceof Serializer)
   t.type(debugMode.code, 'string')
 })
 
 test('activate debug mode truthy', t => {
-  t.plan(4)
+  t.plan(5)
 
   const debugMode = build({ debugMode: 'yes' })
 
@@ -38,15 +40,17 @@ test('activate debug mode truthy', t => {
   t.type(debugMode.code, 'string')
   t.ok(debugMode.ajv instanceof Ajv)
   t.ok(debugMode.validator instanceof Validator)
+  t.ok(debugMode.serializer instanceof Serializer)
 })
 
 test('to string auto-consistent', t => {
-  t.plan(5)
+  t.plan(6)
   const debugMode = build({ debugMode: 1 })
 
   t.type(debugMode, 'object')
   t.type(debugMode.code, 'string')
   t.ok(debugMode.ajv instanceof Ajv)
+  t.ok(debugMode.serializer instanceof Serializer)
   t.ok(debugMode.validator instanceof Validator)
 
   const compiled = fjs.restore(debugMode)
@@ -55,7 +59,7 @@ test('to string auto-consistent', t => {
 })
 
 test('to string auto-consistent with ajv', t => {
-  t.plan(5)
+  t.plan(6)
 
   const debugMode = fjs({
     title: 'object with multiple types field',
@@ -75,6 +79,7 @@ test('to string auto-consistent with ajv', t => {
   t.type(debugMode.code, 'string')
   t.ok(debugMode.ajv instanceof Ajv)
   t.ok(debugMode.validator instanceof Validator)
+  t.ok(debugMode.serializer instanceof Serializer)
 
   const compiled = fjs.restore(debugMode)
   const tobe = JSON.stringify({ str: 'Foo' })
@@ -106,3 +111,11 @@ test('to string auto-consistent with ajv-formats', t => {
   t.same(compiled({ str: 'foo@bar.com' }), tobe)
   t.throws(() => compiled({ str: 'foo' }))
 })
+
+test('debug should restore the same serializer instance', t => {
+  t.plan(1)
+
+  const debugMode = fjs({ type: 'integer' }, { debugMode: 1, rounding: 'ceil' })
+  const compiled = fjs.restore(debugMode)
+  t.same(compiled(3.95), 4)
+})

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const t = require('tap')
+const { DateTime } = require('luxon')
 const build = require('..')
 
 const schema = {
@@ -368,3 +369,52 @@ t.test('nested if/then', t => {
     JSON.stringify({ a: 'A', bar: 'bar', bar1: 'bar1' })
   )
 })
+
+t.test('if/else with string format', (t) => {
+  t.plan(2)
+
+  const schema = {
+    if: { type: 'string' },
+    then: { type: 'string', format: 'date' },
+    else: { const: 'Invalid' }
+  }
+
+  const stringify = build(schema)
+
+  const date = new Date()
+
+  t.equal(stringify(date), `"${DateTime.fromJSDate(date).toISODate()}"`)
+  t.equal(stringify('Invalid'), '"Invalid"')
+})
+
+t.test('if/else with const integers', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'number',
+    if: { type: 'number', minimum: 42 },
+    then: { const: 66 },
+    else: { const: 33 }
+  }
+
+  const stringify = build(schema)
+
+  t.equal(stringify(100.32), '66')
+  t.equal(stringify(10.12), '33')
+})
+
+t.test('if/else with array', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'array',
+    if: { type: 'array', maxItems: 1 },
+    then: { items: { type: 'string' } },
+    else: { items: { type: 'number' } }
+  }
+
+  const stringify = build(schema)
+
+  t.equal(stringify(['1']), JSON.stringify(['1']))
+  t.equal(stringify(['1', '2']), JSON.stringify([1, 2]))
+})

package/test/ref.test.js

@@ -1981,3 +1981,27 @@ test('nested schema should overwrite anchor scope', (t) => {
   t.equal(output, JSON.stringify(data))
   t.throws(() => build({ $ref: 'root#anchor' }, { schema: externalSchema }))
 })
+
+test('object property reference with default value', (t) => {
+  t.plan(1)
+
+  const schema = {
+    definitions: {
+      prop: {
+        type: 'string',
+        default: 'foo'
+      }
+    },
+    type: 'object',
+    properties: {
+      prop: {
+        $ref: '#/definitions/prop'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify({})
+
+  t.equal(output, '{"prop":"foo"}')
+})

package/test/types/schema-inference.test-d.ts

@@ -0,0 +1,48 @@
+import { expectError } from "tsd";
+import build from "../..";
+
+// With inference
+interface Schema {
+  id: string;
+  a?: number;
+}
+
+const stringify3 = build({
+  type: "object",
+  properties: { a: { type: "string" } },
+});
+stringify3<Schema>({ id: "123" });
+stringify3<Schema>({ a: 123, id: "123" });
+expectError(stringify3<Schema>({ anotherOne: "bar" }));
+expectError(stringify3<Schema>({ a: "bar" }));
+
+// Without inference
+const stringify4 = build({
+  type: "object",
+  properties: { a: { type: "string" } },
+});
+stringify4({ id: "123" });
+stringify4({ a: 123, id: "123" });
+stringify4({ anotherOne: "bar" });
+stringify4({ a: "bar" });
+
+// Without inference - string type
+const stringify5 = build({
+  type: "string",
+});
+stringify5("foo");
+expectError(stringify5({ id: "123" }));
+
+// Without inference - null type
+const stringify6 = build({
+  type: "null",
+});
+stringify6(null);
+expectError(stringify6("a string"));
+
+// Without inference - boolean type
+const stringify7 = build({
+  type: "boolean",
+});
+stringify7(true);
+expectError(stringify7("a string"));