fast-json-stringify 5.0.5 → 5.2.0

package/.github/workflows/benchmark.yml

@@ -11,15 +11,15 @@ jobs:
     permissions:
       contents: read
     outputs:
-      PR-BENCH-12: ${{ steps.benchmark-pr.outputs.BENCH_RESULT12 }}
       PR-BENCH-14: ${{ steps.benchmark-pr.outputs.BENCH_RESULT14 }}
       PR-BENCH-16: ${{ steps.benchmark-pr.outputs.BENCH_RESULT16 }}
-      MAIN-BENCH-12: ${{ steps.benchmark-main.outputs.BENCH_RESULT12 }}
+      PR-BENCH-18: ${{ steps.benchmark-pr.outputs.BENCH_RESULT18 }}
       MAIN-BENCH-14: ${{ steps.benchmark-main.outputs.BENCH_RESULT14 }}
       MAIN-BENCH-16: ${{ steps.benchmark-main.outputs.BENCH_RESULT16 }}
+      MAIN-BENCH-18: ${{ steps.benchmark-main.outputs.BENCH_RESULT18 }}
     strategy:
       matrix:
-        node-version: [12, 14, 16]
+        node-version: [14, 16, 18]
     steps:
       - uses: actions/checkout@v3
         with:
@@ -75,38 +75,38 @@ jobs:
         with:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           message: |
-            **Node**: 12
+            **Node**: 14
             **PR**:
             ```
-            ${{ needs.benchmark.outputs.PR-BENCH-12 }}
+            ${{ needs.benchmark.outputs.PR-BENCH-14 }}
             ```
             **MAIN**:
             ```
-            ${{ needs.benchmark.outputs.MAIN-BENCH-12 }}
+            ${{ needs.benchmark.outputs.MAIN-BENCH-14 }}
             ```
             
             ---
             
-            **Node**: 14
+            **Node**: 16
             **PR**:
             ```
-            ${{ needs.benchmark.outputs.PR-BENCH-14 }}
+            ${{ needs.benchmark.outputs.PR-BENCH-16 }}
             ```
             **MAIN**:
             ```
-            ${{ needs.benchmark.outputs.MAIN-BENCH-14 }}
+            ${{ needs.benchmark.outputs.MAIN-BENCH-16 }}
             ```
             
             ---
             
-            **Node**: 16
+            **Node**: 18
             **PR**:
             ```
-            ${{ needs.benchmark.outputs.PR-BENCH-16 }}
+            ${{ needs.benchmark.outputs.PR-BENCH-18 }}
             ```
             **MAIN**:
             ```
-            ${{ needs.benchmark.outputs.MAIN-BENCH-16 }}
+            ${{ needs.benchmark.outputs.MAIN-BENCH-18 }}
             ```
             
       - uses: actions-ecosystem/action-remove-labels@v1

package/.github/workflows/ci.yml

@@ -13,3 +13,5 @@ on:
 jobs:
   test:
     uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
+    with:
+      license-check: true

package/benchmark/bench.js

@@ -213,6 +213,60 @@ const benchmarks = [
       n5: 42,
       b5: true
     }
+  },
+  {
+    name: 'object with const string property',
+    schema: {
+      type: 'object',
+      properties: {
+        a: { const: 'const string' }
+      }
+    },
+    input: { a: 'const string' }
+  },
+  {
+    name: 'object with const number property',
+    schema: {
+      type: 'object',
+      properties: {
+        a: { const: 1 }
+      }
+    },
+    input: { a: 1 }
+  },
+  {
+    name: 'object with const bool property',
+    schema: {
+      type: 'object',
+      properties: {
+        a: { const: true }
+      }
+    },
+    input: { a: true }
+  },
+  {
+    name: 'object with const object property',
+    schema: {
+      type: 'object',
+      properties: {
+        foo: { const: { bar: 'baz' } }
+      }
+    },
+    input: {
+      foo: { bar: 'baz' }
+    }
+  },
+  {
+    name: 'object with const null property',
+    schema: {
+      type: 'object',
+      properties: {
+        foo: { const: null }
+      }
+    },
+    input: {
+      foo: null
+    }
   }
 ]
 

package/index.js

@@ -2,14 +2,15 @@
 
 /* eslint no-prototype-builtins: 0 */
 
-const merge = require('deepmerge')
+const merge = require('@fastify/deepmerge')()
 const clone = require('rfdc')({ proto: true })
 const fjsCloned = Symbol('fast-json-stringify.cloned')
 const { randomUUID } = require('crypto')
 
 const validate = require('./schema-validator')
 const Serializer = require('./serializer')
-const buildAjv = require('./ajv')
+const Validator = require('./validator')
+const RefResolver = require('./ref-resolver')
 
 let largeArraySize = 2e4
 let largeArrayMechanism = 'default'
@@ -55,22 +56,14 @@ function resolveRef (location, ref) {
   }
 
   const schemaId = ref.slice(0, hashIndex) || location.schemaId
-  const jsonPointer = ref.slice(hashIndex)
+  const jsonPointer = ref.slice(hashIndex) || '#'
 
-  const schemaRef = schemaId + jsonPointer
+  const schema = refResolver.getSchema(schemaId, jsonPointer)
 
-  let ajvSchema
-  try {
-    ajvSchema = ajvInstance.getSchema(schemaRef)
-  } catch (error) {
+  if (schema === undefined) {
     throw new Error(`Cannot find reference "${ref}"`)
   }
 
-  if (ajvSchema === undefined) {
-    throw new Error(`Cannot find reference "${ref}"`)
-  }
-
-  const schema = ajvSchema.schema
   if (schema.$ref !== undefined) {
     return resolveRef({ schema, schemaId, jsonPointer }, schema.$ref)
   }
@@ -82,41 +75,31 @@ const arrayItemsReferenceSerializersMap = new Map()
 const objectReferenceSerializersMap = new Map()
 
 let rootSchemaId = null
-let ajvInstance = null
+let refResolver = null
+let validator = null
 let contextFunctions = null
 
 function build (schema, options) {
-  schema = clone(schema)
-
   arrayItemsReferenceSerializersMap.clear()
   objectReferenceSerializersMap.clear()
 
   contextFunctions = []
   options = options || {}
 
-  ajvInstance = buildAjv(options.ajv)
+  refResolver = new RefResolver()
+  validator = new Validator(options.ajv)
+
   rootSchemaId = schema.$id || randomUUID()
 
   isValidSchema(schema)
-  extendDateTimeType(schema)
-  ajvInstance.addSchema(schema, rootSchemaId)
+  validator.addSchema(schema, rootSchemaId)
+  refResolver.addSchema(schema, rootSchemaId)
 
   if (options.schema) {
-    const externalSchemas = clone(options.schema)
-
-    for (const key of Object.keys(externalSchemas)) {
-      const externalSchema = externalSchemas[key]
-      isValidSchema(externalSchema, key)
-      extendDateTimeType(externalSchema)
-
-      let schemaKey = externalSchema.$id || key
-      if (externalSchema.$id !== undefined && externalSchema.$id[0] === '#') {
-        schemaKey = key + externalSchema.$id // relative URI
-      }
-
-      if (ajvInstance.getSchema(schemaKey) === undefined) {
-        ajvInstance.addSchema(externalSchema, schemaKey)
-      }
+    for (const key of Object.keys(options.schema)) {
+      isValidSchema(options.schema[key], key)
+      validator.addSchema(options.schema[key], key)
+      refResolver.addSchema(options.schema[key], key)
     }
   }
 
@@ -157,27 +140,28 @@ function build (schema, options) {
     return main
     `
 
-  const dependenciesName = ['ajv', 'serializer', contextFunctionCode]
+  const dependenciesName = ['validator', 'serializer', contextFunctionCode]
 
   if (options.debugMode) {
     options.mode = 'debug'
   }
 
   if (options.mode === 'debug') {
-    return { code: dependenciesName.join('\n'), ajv: ajvInstance }
+    return { code: dependenciesName.join('\n'), validator, ajv: validator.ajv }
   }
 
   if (options.mode === 'standalone') {
     // lazy load
     const buildStandaloneCode = require('./standalone')
-    return buildStandaloneCode(options, ajvInstance, contextFunctionCode)
+    return buildStandaloneCode(options, validator, contextFunctionCode)
   }
 
   /* eslint no-new-func: "off" */
-  const contextFunc = new Function('ajv', 'serializer', contextFunctionCode)
-  const stringifyFunc = contextFunc(ajvInstance, serializer)
+  const contextFunc = new Function('validator', 'serializer', contextFunctionCode)
+  const stringifyFunc = contextFunc(validator, serializer)
 
-  ajvInstance = null
+  refResolver = null
+  validator = null
   rootSchemaId = null
   contextFunctions = null
   arrayItemsReferenceSerializersMap.clear()
@@ -243,15 +227,6 @@ function inferTypeByKeyword (schema) {
   return schema.type
 }
 
-function getStringSerializer (format, nullable) {
-  switch (format) {
-    case 'date-time': return nullable ? 'serializer.asDatetimeNullable.bind(serializer)' : 'serializer.asDatetime.bind(serializer)'
-    case 'date': return nullable ? 'serializer.asDateNullable.bind(serializer)' : 'serializer.asDate.bind(serializer)'
-    case 'time': return nullable ? 'serializer.asTimeNullable.bind(serializer)' : 'serializer.asTime.bind(serializer)'
-    default: return nullable ? 'serializer.asStringNullable.bind(serializer)' : 'serializer.asString.bind(serializer)'
-  }
-}
-
 function addPatternProperties (location) {
   const schema = location.schema
   const pp = schema.patternProperties
@@ -350,17 +325,16 @@ function buildCode (location) {
   const propertiesLocation = mergeLocation(location, 'properties')
   Object.keys(schema.properties || {}).forEach((key) => {
     let propertyLocation = mergeLocation(propertiesLocation, key)
-    if (schema.properties[key].$ref) {
-      propertyLocation = resolveRef(location, schema.properties[key].$ref)
-      schema.properties[key] = propertyLocation.schema
+    if (propertyLocation.$ref) {
+      propertyLocation = resolveRef(location, propertyLocation.$ref)
     }
 
-    // Using obj['key'] !== undefined instead of obj.hasOwnProperty(prop) for perf reasons,
-    // see https://github.com/mcollina/fast-json-stringify/pull/3 for discussion.
-
     const sanitized = JSON.stringify(key)
     const asString = JSON.stringify(sanitized)
 
+    // Using obj['key'] !== undefined instead of obj.hasOwnProperty(prop) for perf reasons,
+    // see https://github.com/mcollina/fast-json-stringify/pull/3 for discussion.
+
     code += `
       if (obj[${sanitized}] !== undefined) {
         ${addComma}
@@ -369,7 +343,7 @@ function buildCode (location) {
 
     code += buildValue(propertyLocation, `obj[${JSON.stringify(key)}]`)
 
-    const defaultValue = schema.properties[key].default
+    const defaultValue = propertyLocation.schema.default
     if (defaultValue !== undefined) {
       code += `
       } else {
@@ -491,7 +465,8 @@ function mergeAllOfSchema (location, schema, mergedSchema) {
   delete mergedSchema.allOf
 
   mergedSchema.$id = `merged_${randomUUID()}`
-  ajvInstance.addSchema(mergedSchema)
+  validator.addSchema(mergedSchema)
+  refResolver.addSchema(mergedSchema)
   location.schemaId = mergedSchema.$id
   location.jsonPointer = '#'
 }
@@ -520,7 +495,7 @@ function addIfThenElse (location) {
   const ifSchemaRef = ifLocation.schemaId + ifLocation.jsonPointer
 
   let code = `
-    if (ajv.validate("${ifSchemaRef}", obj)) {
+    if (validator.validate("${ifSchemaRef}", obj)) {
   `
 
   const thenLocation = mergeLocation(location, 'then')
@@ -771,6 +746,10 @@ function generateFuncName () {
 function buildValue (location, input) {
   let schema = location.schema
 
+  if (typeof schema === 'boolean') {
+    return `json += JSON.stringify(${input})`
+  }
+
   if (schema.$ref) {
     location = resolveRef(location, schema.$ref)
     schema = location.schema
@@ -791,19 +770,36 @@ function buildValue (location, input) {
   }
 
   const type = schema.type
-  const nullable = schema.nullable === true
+  const nullable = schema.nullable === true || (Array.isArray(type) && type.includes('null'))
 
   let code = ''
   let funcName
 
-  switch (type) {
-    case 'null':
+  if ('const' in schema) {
+    if (nullable) {
       code += `
-        json += serializer.asNull()
+        json += ${input} === null ? 'null' : '${JSON.stringify(schema.const)}'
       `
+      return code
+    }
+    code += `json += '${JSON.stringify(schema.const)}'`
+    return code
+  }
+
+  switch (type) {
+    case 'null':
+      code += 'json += serializer.asNull()'
       break
     case 'string': {
-      funcName = getStringSerializer(schema.format, nullable)
+      if (schema.format === 'date-time') {
+        funcName = nullable ? 'serializer.asDateTimeNullable.bind(serializer)' : 'serializer.asDateTime.bind(serializer)'
+      } else if (schema.format === 'date') {
+        funcName = nullable ? 'serializer.asDateNullable.bind(serializer)' : 'serializer.asDate.bind(serializer)'
+      } else if (schema.format === 'time') {
+        funcName = nullable ? 'serializer.asTimeNullable.bind(serializer)' : 'serializer.asTime.bind(serializer)'
+      } else {
+        funcName = nullable ? 'serializer.asStringNullable.bind(serializer)' : 'serializer.asString.bind(serializer)'
+      }
       code += `json += ${funcName}(${input})`
       break
     }
@@ -828,11 +824,7 @@ function buildValue (location, input) {
       code += `json += ${funcName}(${input})`
       break
     case undefined:
-      if (schema.fjs_date_type) {
-        funcName = getStringSerializer(schema.fjs_date_type, nullable)
-        code += `json += ${funcName}(${input})`
-        break
-      } else if (schema.anyOf || schema.oneOf) {
+      if (schema.anyOf || schema.oneOf) {
         // beware: dereferenceOfRefs has side effects and changes schema.anyOf
         const type = schema.anyOf ? 'anyOf' : 'oneOf'
         const anyOfLocation = mergeLocation(location, type)
@@ -842,7 +834,7 @@ function buildValue (location, input) {
           const schemaRef = optionLocation.schemaId + optionLocation.jsonPointer
           const nestedResult = buildValue(optionLocation, input)
           code += `
-            ${index === 0 ? 'if' : 'else if'}(ajv.validate("${schemaRef}", ${input}))
+            ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input}))
               ${nestedResult}
           `
         }
@@ -854,19 +846,10 @@ function buildValue (location, input) {
         code += `
           json += JSON.stringify(${input})
         `
-      } else if ('const' in schema) {
-        code += `
-          if(ajv.validate(${JSON.stringify(schema)}, ${input}))
-            json += '${JSON.stringify(schema.const)}'
-          else
-            throw new Error(\`Item $\{JSON.stringify(${input})} does not match schema definition.\`)
-        `
-      } else if (schema.type === undefined) {
+      } else {
         code += `
           json += JSON.stringify(${input})
         `
-      } else {
-        throw new Error(`${schema.type} unsupported`)
       }
       break
     default:
@@ -890,7 +873,18 @@ function buildValue (location, input) {
           switch (type) {
             case 'string': {
               code += `
-                ${statement}(${input} === null || typeof ${input} === "${type}" || ${input} instanceof Date || ${input} instanceof RegExp || (typeof ${input} === "object" && Object.hasOwnProperty.call(${input}, "toString")))
+                ${statement}(
+                  typeof ${input} === "string" ||
+                  ${input} === null ||
+                  ${input} instanceof Date ||
+                  ${input} instanceof RegExp ||
+                  (
+                    typeof ${input} === "object" &&
+                    typeof ${input}.toString === "function" &&
+                    ${input}.toString !== Object.prototype.toString &&
+                    !(${input} instanceof Date)
+                  )
+                )
                   ${nestedResult}
               `
               break
@@ -909,6 +903,13 @@ function buildValue (location, input) {
               `
               break
             }
+            case 'object': {
+              code += `
+                ${statement}(typeof ${input} === "object" || ${input} === null)
+                  ${nestedResult}
+              `
+              break
+            }
             default: {
               code += `
                 ${statement}(typeof ${input} === "${type}" || ${input} === null)
@@ -935,28 +936,10 @@ function buildValue (location, input) {
   return code
 }
 
-// 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_date_type.
-// (see https://github.com/fastify/fast-json-stringify/pull/441)
-function extendDateTimeType (schema) {
-  if (schema === null) return
-
-  if (schema.type === 'string' && ['date-time', 'date', 'time'].includes(schema.format)) {
-    schema.fjs_date_type = schema.format
-    delete schema.type
-    delete schema.format
-  }
-  for (const property in schema) {
-    if (typeof schema[property] === 'object') {
-      extendDateTimeType(schema[property])
-    }
-  }
-}
-
 function isEmpty (schema) {
   // eslint-disable-next-line
   for (var key in schema) {
-    if (schema.hasOwnProperty(key) && schema[key] !== undefined) {
+    if (Object.prototype.hasOwnProperty.call(schema, key) && schema[key] !== undefined) {
       return false
     }
   }
@@ -967,9 +950,9 @@ module.exports = build
 
 module.exports.validLargeArrayMechanisms = validLargeArrayMechanisms
 
-module.exports.restore = function ({ code, ajv }) {
+module.exports.restore = function ({ code, validator }) {
   const serializer = new Serializer()
   // eslint-disable-next-line
-  return (Function.apply(null, ['ajv', 'serializer', code])
-    .apply(null, [ajv, serializer]))
+  return (Function.apply(null, ['validator', 'serializer', code])
+    .apply(null, [validator, serializer]))
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.0.5",
+  "version": "5.2.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -33,13 +33,13 @@
   },
   "homepage": "https://github.com/fastify/fast-json-stringify#readme",
   "devDependencies": {
-    "@sinclair/typebox": "^0.23.3",
+    "@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",
@@ -49,9 +49,10 @@
     "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"
   },

package/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

@@ -69,24 +69,30 @@ module.exports = class Serializer {
     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() + '"'
+    }
+    if (typeof date === 'string') {
+      return '"' + date + '"'
     }
-    return this.asString(date)
+    throw new Error(`The value "${date}" cannot be converted to a date-time.`)
   }
 
-  asDatetimeNullable (date) {
-    return date === null ? 'null' : this.asDatetime(date)
+  asDateTimeNullable (date) {
+    return date === null ? 'null' : this.asDateTime(date)
   }
 
   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)
+    if (typeof date === 'string') {
+      return '"' + date + '"'
+    }
+    throw new Error(`The value "${date}" cannot be converted to a date.`)
   }
 
   asDateNullable (date) {
@@ -94,11 +100,14 @@ module.exports = class Serializer {
   }
 
   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) + '"'
+    }
+    if (typeof date === 'string') {
+      return '"' + date + '"'
     }
-    return this.asString(date)
+    throw new Error(`The value "${date}" cannot be converted to a time.`)
   }
 
   asTimeNullable (date) {