fast-json-stringify 5.0.6 → 5.3.0

package/lib/ref-resolver.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const deepEqual = require('fast-deep-equal')
+
+class RefResolver {
+  constructor () {
+    this.schemas = {}
+  }
+
+  addSchema (schema, schemaId) {
+    if (schema.$id !== undefined && schema.$id.charAt(0) !== '#') {
+      schemaId = schema.$id
+    }
+    if (this.getSchema(schemaId) === undefined) {
+      this.insertSchemaBySchemaId(schema, schemaId)
+      this.insertSchemaSubschemas(schema, schemaId)
+    }
+  }
+
+  getSchema (schemaId, jsonPointer = '#') {
+    const schema = this.schemas[schemaId]
+    if (schema === undefined) {
+      return undefined
+    }
+    if (schema.anchors[jsonPointer] !== undefined) {
+      return schema.anchors[jsonPointer]
+    }
+    return getDataByJSONPointer(schema.schema, jsonPointer)
+  }
+
+  insertSchemaBySchemaId (schema, schemaId) {
+    if (
+      this.schemas[schemaId] !== undefined &&
+      !deepEqual(schema, this.schemas[schemaId].schema)
+    ) {
+      throw new Error(`There is already another schema with id ${schemaId}`)
+    }
+    this.schemas[schemaId] = { schema, anchors: {} }
+  }
+
+  insertSchemaByAnchor (schema, schemaId, anchor) {
+    const { anchors } = this.schemas[schemaId]
+    if (
+      anchors[anchor] !== undefined &&
+      !deepEqual(schema, anchors[anchor])
+    ) {
+      throw new Error(`There is already another schema with id ${schemaId}#${anchor}`)
+    }
+    anchors[anchor] = schema
+  }
+
+  insertSchemaSubschemas (schema, rootSchemaId) {
+    const schemaId = schema.$id
+    if (schemaId !== undefined && typeof schemaId === 'string') {
+      if (schemaId.charAt(0) === '#') {
+        this.insertSchemaByAnchor(schema, rootSchemaId, schemaId)
+      } else {
+        this.insertSchemaBySchemaId(schema, schemaId)
+        rootSchemaId = schemaId
+      }
+    }
+
+    for (const key in schema) {
+      if (typeof schema[key] === 'object' && schema[key] !== null) {
+        this.insertSchemaSubschemas(schema[key], rootSchemaId)
+      }
+    }
+  }
+}
+
+function getDataByJSONPointer (data, jsonPointer) {
+  const parts = jsonPointer.split('/')
+  let current = data
+  for (const part of parts) {
+    if (part === '' || part === '#') continue
+    if (typeof current !== 'object' || current === null) {
+      return undefined
+    }
+    current = current[part]
+  }
+  return current
+}
+
+module.exports = RefResolver

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,52 +45,41 @@ 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) {
-    const quotes = '"'
+  asDateTime (date) {
+    if (date === null) return '""'
     if (date instanceof Date) {
-      return quotes + date.toISOString() + quotes
+      return '"' + date.toISOString() + '"'
     }
-    return this.asString(date)
-  }
-
-  asDatetimeNullable (date) {
-    return date === null ? 'null' : this.asDatetime(date)
+    if (typeof date === 'string') {
+      return '"' + date + '"'
+    }
+    throw new Error(`The value "${date}" cannot be converted to a date-time.`)
   }
 
   asDate (date) {
-    const quotes = '"'
+    if (date === null) return '""'
     if (date instanceof Date) {
-      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + quotes
+      return '"' + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + '"'
     }
-    return this.asString(date)
-  }
-
-  asDateNullable (date) {
-    return date === null ? 'null' : this.asDate(date)
+    if (typeof date === 'string') {
+      return '"' + date + '"'
+    }
+    throw new Error(`The value "${date}" cannot be converted to a date.`)
   }
 
   asTime (date) {
-    const quotes = '"'
+    if (date === null) return '""'
     if (date instanceof Date) {
-      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + quotes
+      return '"' + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + '"'
     }
-    return this.asString(date)
-  }
-
-  asTimeNullable (date) {
-    return date === null ? 'null' : this.asTime(date)
+    if (typeof date === 'string') {
+      return '"' + date + '"'
+    }
+    throw new Error(`The value "${date}" cannot be converted to a time.`)
   }
 
   asString (str) {
@@ -124,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,28 +1,28 @@
 const fs = require('fs')
 const path = require('path')
 
-function buildStandaloneCode (options, ajvInstance, contextFunctionCode) {
+function buildStandaloneCode (options, validator, contextFunctionCode) {
   const serializerCode = fs.readFileSync(path.join(__dirname, 'serializer.js')).toString()
   let buildAjvCode = ''
   let defaultAjvSchema = ''
-  const defaultMeta = ajvInstance.defaultMeta()
+  const defaultMeta = validator.ajv.defaultMeta()
   if (typeof defaultMeta === 'string') {
     defaultAjvSchema = defaultMeta
   } else {
     defaultAjvSchema = defaultMeta.$id || defaultMeta.id
   }
-  const shouldUseAjv = contextFunctionCode.indexOf('ajv') !== -1
+  const shouldUseAjv = contextFunctionCode.indexOf('validator') !== -1
   // we need to export the custom json schema
   let ajvSchemasCode = ''
   if (shouldUseAjv) {
-    ajvSchemasCode += `const ajv = buildAjv(${JSON.stringify(options.ajv || {})})\n`
-    for (const [id, schema] of Object.entries(ajvInstance.schemas)) {
+    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
       if (id === defaultAjvSchema) continue
-      ajvSchemasCode += `ajv.addSchema(${JSON.stringify(schema.schema)}, "${id}")\n`
+      ajvSchemasCode += `validator.ajv.addSchema(${JSON.stringify(schema.schema)}, "${id}")\n`
     }
-    buildAjvCode = fs.readFileSync(path.join(__dirname, 'ajv.js')).toString()
-    buildAjvCode = buildAjvCode.replace("'use strict'", '').replace('module.exports = buildAjv', '')
+    buildAjvCode = fs.readFileSync(path.join(__dirname, 'validator.js')).toString()
+    buildAjvCode = buildAjvCode.replace("'use strict'", '').replace('module.exports = SchemaValidator', '')
   }
   return `
   'use strict'

package/lib/validator.js

@@ -0,0 +1,75 @@
+'use strict'
+
+const Ajv = require('ajv')
+const fastUri = require('fast-uri')
+const ajvFormats = require('ajv-formats')
+const clone = require('rfdc')({ proto: true })
+
+class Validator {
+  constructor (ajvOptions) {
+    this.ajv = new Ajv({
+      ...ajvOptions,
+      strictSchema: false,
+      validateSchema: false,
+      allowUnionTypes: true,
+      uriResolver: fastUri
+    })
+
+    ajvFormats(this.ajv)
+
+    this.ajv.addKeyword({
+      keyword: 'fjs_type',
+      type: 'object',
+      errors: false,
+      validate: (type, date) => {
+        return date instanceof Date
+      }
+    })
+  }
+
+  addSchema (schema, schemaName) {
+    let schemaKey = schema.$id || schemaName
+    if (schema.$id !== undefined && schema.$id[0] === '#') {
+      schemaKey = schemaName + schema.$id // relative URI
+    }
+
+    if (
+      this.ajv.refs[schemaKey] === undefined &&
+      this.ajv.schemas[schemaKey] === undefined
+    ) {
+      const ajvSchema = clone(schema)
+      this.convertSchemaToAjvFormat(ajvSchema)
+      this.ajv.addSchema(ajvSchema, schemaKey)
+    }
+  }
+
+  validate (schemaRef, data) {
+    return this.ajv.validate(schemaRef, data)
+  }
+
+  // Ajv does not support js date format. In order to properly validate objects containing a date,
+  // it needs to replace all occurrences of the string date format with a custom keyword fjs_type.
+  // (see https://github.com/fastify/fast-json-stringify/pull/441)
+  convertSchemaToAjvFormat (schema) {
+    if (schema === null) return
+
+    if (schema.type === 'string') {
+      schema.fjs_type = 'string'
+      schema.type = ['string', 'object']
+    } else if (
+      Array.isArray(schema.type) &&
+      schema.type.includes('string') &&
+      !schema.type.includes('object')
+    ) {
+      schema.fjs_type = 'string'
+      schema.type.push('object')
+    }
+    for (const property in schema) {
+      if (typeof schema[property] === 'object') {
+        this.convertSchemaToAjvFormat(schema[property])
+      }
+    }
+  }
+}
+
+module.exports = Validator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.0.6",
+  "version": "5.3.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -11,7 +11,7 @@
     "benchmark": "node ./benchmark/bench-cmp-lib.js",
     "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"
   },
@@ -33,25 +33,27 @@
   },
   "homepage": "https://github.com/fastify/fast-json-stringify#readme",
   "devDependencies": {
+    "@fastify/pre-commit": "^2.0.2",
     "@sinclair/typebox": "^0.24.9",
     "benchmark": "^2.1.4",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
     "is-my-json-valid": "^2.20.0",
-    "luxon": "^2.4.0",
-    "pre-commit": "^1.2.2",
+    "luxon": "^3.0.1",
     "proxyquire": "^2.1.3",
     "semver": "^7.1.0",
     "simple-git": "^3.7.1",
     "standard": "^17.0.0",
     "tap": "^16.0.1",
+    "tsd": "^0.22.0",
     "typescript": "^4.0.2",
     "webpack": "^5.40.0"
   },
   "dependencies": {
+    "@fastify/deepmerge": "^1.0.0",
     "ajv": "^8.10.0",
     "ajv-formats": "^2.1.1",
-    "deepmerge": "^4.2.2",
+    "fast-deep-equal": "^3.1.3",
     "fast-uri": "^2.1.0",
     "rfdc": "^1.2.0"
   },
@@ -60,5 +62,8 @@
       "schema-validator.js"
     ]
   },
-  "runkitExampleFilename": "example.js"
+  "runkitExampleFilename": "./examples/example.js",
+  "tsd": {
+    "directory": "test/types"
+  }
 }

package/test/array.test.js

@@ -327,6 +327,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/basic.test.js

@@ -359,3 +359,16 @@ test('render a single quote as JSON', (t) => {
   t.equal(output, JSON.stringify(toStringify))
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
+
+test('returns JSON.stringify if schema type is boolean', t => {
+  t.plan(1)
+
+  const schema = {
+    type: 'array',
+    items: true
+  }
+
+  const array = [1, true, 'test']
+  const stringify = build(schema)
+  t.equal(stringify(array), JSON.stringify(array))
+})

package/test/const.test.js

@@ -24,6 +24,184 @@ test('schema with const string', (t) => {
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
+test('schema with const string and different input', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: 'bar' }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: 'baz'
+  })
+
+  t.equal(output, '{"foo":"bar"}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('schema with const string and different type input', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: 'bar' }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: 1
+  })
+
+  t.equal(output, '{"foo":"bar"}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('schema with const string and no input', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: 'bar' }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({})
+
+  t.equal(output, '{}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('schema with const number', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: 1 }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: 1
+  })
+
+  t.equal(output, '{"foo":1}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('schema with const number and different input', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: 1 }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: 2
+  })
+
+  t.equal(output, '{"foo":1}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('schema with const bool', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: true }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: true
+  })
+
+  t.equal(output, '{"foo":true}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('schema with const number', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: 1 }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: 1
+  })
+
+  t.equal(output, '{"foo":1}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('schema with const null', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: null }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: null
+  })
+
+  t.equal(output, '{"foo":null}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('schema with const array', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: [1, 2, 3] }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: [1, 2, 3]
+  })
+
+  t.equal(output, '{"foo":[1,2,3]}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
 test('schema with const object', (t) => {
   t.plan(2)
 
@@ -44,6 +222,56 @@ test('schema with const object', (t) => {
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
+test('schema with const and null as type', (t) => {
+  t.plan(4)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { type: ['string', 'null'], const: 'baz' }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: null
+  })
+
+  t.equal(output, '{"foo":null}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+
+  const output2 = stringify({ foo: 'baz' })
+  t.equal(output2, '{"foo":"baz"}')
+  t.ok(validate(JSON.parse(output2)), 'valid schema')
+})
+
+test('schema with const as nullable', (t) => {
+  t.plan(4)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { nullable: true, const: 'baz' }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: null
+  })
+
+  t.equal(output, '{"foo":null}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+
+  const output2 = stringify({
+    foo: 'baz'
+  })
+  t.equal(output2, '{"foo":"baz"}')
+  t.ok(validate(JSON.parse(output2)), 'valid schema')
+})
+
 test('schema with const and invalid object', (t) => {
   t.plan(2)
 
@@ -55,13 +283,12 @@ test('schema with const and invalid object', (t) => {
     required: ['foo']
   }
 
+  const validate = validator(schema)
   const stringify = build(schema)
-  try {
-    stringify({
-      foo: { foo: 'baz' }
-    })
-  } catch (err) {
-    t.match(err.message, /^Item .* does not match schema definition/, 'Given object has invalid const value')
-    t.ok(err)
-  }
+  const result = stringify({
+    foo: { foo: 'baz' }
+  })
+
+  t.equal(result, '{"foo":{"foo":"bar"}}')
+  t.ok(validate(JSON.parse(result)), 'valid schema')
 })