fast-json-stringify 5.0.4 → 5.1.0

package/ajv.js

@@ -7,29 +7,22 @@ const ajvFormats = require('ajv-formats')
 module.exports = buildAjv
 
 function buildAjv (options) {
-  const ajvInstance = new Ajv({ ...options, strictSchema: false, validateSchema: false, uriResolver: fastUri })
-  ajvFormats(ajvInstance)
+  const ajvInstance = new Ajv({
+    ...options,
+    strictSchema: false,
+    validateSchema: false,
+    allowUnionTypes: true,
+    uriResolver: fastUri
+  })
 
-  const validateDateTimeFormat = ajvFormats.get('date-time').validate
-  const validateDateFormat = ajvFormats.get('date').validate
-  const validateTimeFormat = ajvFormats.get('time').validate
+  ajvFormats(ajvInstance)
 
   ajvInstance.addKeyword({
-    keyword: 'fjs_date_type',
-    validate: (schema, date) => {
-      if (date instanceof Date) {
-        return true
-      }
-      if (schema === 'date-time') {
-        return validateDateTimeFormat(date)
-      }
-      if (schema === 'date') {
-        return validateDateFormat(date)
-      }
-      if (schema === 'time') {
-        return validateTimeFormat(date)
-      }
-      return false
+    keyword: 'fjs_type',
+    type: 'object',
+    errors: false,
+    validate: (type, date) => {
+      return date instanceof Date
     }
   })
 

package/index.js

@@ -2,7 +2,7 @@
 
 /* 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')
@@ -55,7 +55,7 @@ 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
 
@@ -243,15 +243,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
@@ -484,6 +475,16 @@ function mergeAllOfSchema (location, schema, mergedSchema) {
       mergedSchema.anyOf.push(...allOfSchema.anyOf)
     }
 
+    if (allOfSchema.fjs_type !== undefined) {
+      if (
+        mergedSchema.fjs_type !== undefined &&
+        mergedSchema.fjs_type !== allOfSchema.fjs_type
+      ) {
+        throw new Error('allOf schemas have different fjs_type values')
+      }
+      mergedSchema.fjs_type = allOfSchema.fjs_type
+    }
+
     if (allOfSchema.allOf !== undefined) {
       mergeAllOfSchema(location, allOfSchema, mergedSchema)
     }
@@ -493,6 +494,7 @@ function mergeAllOfSchema (location, schema, mergedSchema) {
   mergedSchema.$id = `merged_${randomUUID()}`
   ajvInstance.addSchema(mergedSchema)
   location.schemaId = mergedSchema.$id
+  location.jsonPointer = '#'
 }
 
 function buildInnerObject (location) {
@@ -770,6 +772,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
@@ -789,20 +795,22 @@ function buildValue (location, input) {
     location.schema = mergedSchema
   }
 
-  const type = schema.type
+  let type = schema.type
   const nullable = schema.nullable === true
 
   let code = ''
   let funcName
 
+  if (schema.fjs_type === 'string' && schema.format === undefined && Array.isArray(schema.type) && schema.type.length === 2) {
+    type = 'string'
+  }
+
   switch (type) {
     case 'null':
-      code += `
-        json += serializer.asNull()
-      `
+      code += 'json += serializer.asNull()'
       break
     case 'string': {
-      funcName = getStringSerializer(schema.format, nullable)
+      funcName = nullable ? 'serializer.asStringNullable.bind(serializer)' : 'serializer.asString.bind(serializer)'
       code += `json += ${funcName}(${input})`
       break
     }
@@ -819,7 +827,15 @@ function buildValue (location, input) {
       code += `json += ${funcName}(${input})`
       break
     case 'object':
-      funcName = buildObject(location)
+      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 = buildObject(location)
+      }
       code += `json += ${funcName}(${input})`
       break
     case 'array':
@@ -827,11 +843,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)
@@ -889,7 +901,7 @@ 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}(${input} === null || typeof ${input} === "${type}" || ${input} instanceof RegExp || (typeof ${input} === "object" && Object.hasOwnProperty.call(${input}, "toString")))
                   ${nestedResult}
               `
               break
@@ -908,6 +920,20 @@ function buildValue (location, input) {
               `
               break
             }
+            case 'object': {
+              if (schema.fjs_type) {
+                code += `
+                  ${statement}(${input} instanceof Date || ${input} === null)
+                    ${nestedResult}
+                `
+              } else {
+                code += `
+                  ${statement}(typeof ${input} === "object" || ${input} === null)
+                    ${nestedResult}
+                `
+              }
+              break
+            }
             default: {
               code += `
                 ${statement}(typeof ${input} === "${type}" || ${input} === null)
@@ -935,15 +961,21 @@ function buildValue (location, input) {
 }
 
 // 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.
+// 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)
 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
+  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') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.0.4",
+  "version": "5.1.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -33,7 +33,7 @@
   },
   "homepage": "https://github.com/fastify/fast-json-stringify#readme",
   "devDependencies": {
-    "@sinclair/typebox": "^0.23.3",
+    "@sinclair/typebox": "^0.24.9",
     "benchmark": "^2.1.4",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
@@ -49,9 +49,9 @@
     "webpack": "^5.40.0"
   },
   "dependencies": {
+    "@fastify/deepmerge": "^1.0.0",
     "ajv": "^8.10.0",
     "ajv-formats": "^2.1.1",
-    "deepmerge": "^4.2.2",
     "fast-uri": "^2.1.0",
     "rfdc": "^1.2.0"
   },

package/serializer.js

@@ -69,24 +69,24 @@ 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() + '"'
     }
-    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)
+    throw new Error(`The value "${date}" cannot be converted to a date.`)
   }
 
   asDateNullable (date) {
@@ -94,11 +94,11 @@ 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) + '"'
     }
-    return this.asString(date)
+    throw new Error(`The value "${date}" cannot be converted to a time.`)
   }
 
   asTimeNullable (date) {

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/date.test.js

@@ -308,7 +308,7 @@ test('serializing null value', t => {
   })
 
   t.test('type::array', t => {
-    t.plan(3)
+    t.plan(6)
 
     t.test('format::date-time', t => {
       t.plan(2)
@@ -348,13 +348,13 @@ test('serializing null value', t => {
       t.notOk(validate(JSON.parse(output)), 'an empty string is not a date format')
     })
 
-    t.test('format::time', t => {
+    t.test('format::date', t => {
       t.plan(2)
 
       const prop = {
         updatedAt: {
           type: ['string'],
-          format: 'time'
+          format: 'date'
         }
       }
 
@@ -364,7 +364,66 @@ test('serializing null value', t => {
       } = serialize(createSchema(prop), input)
 
       t.equal(output, '{"updatedAt":""}')
-      t.notOk(validate(JSON.parse(output)), 'an empty string is not a time format')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a date format')
+    })
+
+    t.test('format::time, Date object', t => {
+      t.plan(1)
+
+      const schema = {
+        oneOf: [
+          {
+            type: 'object',
+            properties: {
+              updatedAt: {
+                type: ['string', 'number'],
+                format: 'time'
+              }
+            }
+          }
+        ]
+      }
+
+      const date = new Date()
+      const input = { updatedAt: date }
+      const { output } = serialize(schema, input)
+
+      t.equal(output, JSON.stringify({ updatedAt: DateTime.fromJSDate(date).toFormat('HH:mm:ss') }))
+    })
+
+    t.test('format::time, Date object', t => {
+      t.plan(1)
+
+      const schema = {
+        oneOf: [
+          {
+            type: ['string', 'number'],
+            format: 'time'
+          }
+        ]
+      }
+
+      const date = new Date()
+      const { output } = serialize(schema, date)
+
+      t.equal(output, `"${DateTime.fromJSDate(date).toFormat('HH:mm:ss')}"`)
+    })
+
+    t.test('format::time, Date object', t => {
+      t.plan(1)
+
+      const schema = {
+        oneOf: [
+          {
+            type: ['string', 'number'],
+            format: 'time'
+          }
+        ]
+      }
+
+      const { output } = serialize(schema, 42)
+
+      t.equal(output, JSON.stringify(42))
     })
   })
 
@@ -429,3 +488,40 @@ test('serializing null value', t => {
     })
   })
 })
+
+test('Validate Date object as string type', (t) => {
+  t.plan(1)
+
+  const schema = {
+    oneOf: [
+      { type: 'string' }
+    ]
+  }
+  const toStringify = new Date()
+
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.equal(output, JSON.stringify(toStringify))
+})
+
+test('nullable date', (t) => {
+  t.plan(1)
+
+  const schema = {
+    anyOf: [
+      {
+        format: 'date',
+        type: 'string',
+        nullable: true
+      }
+    ]
+  }
+
+  const stringify = build(schema)
+
+  const data = new Date()
+  const result = stringify(data)
+
+  t.same(result, `"${DateTime.fromJSDate(data).toISODate()}"`)
+})

package/test/ref.test.js

@@ -1891,3 +1891,65 @@ test('input schema is not mutated', (t) => {
   t.equal(output, '{"obj":"test"}')
   t.same(schema, clonedSchema)
 })
+
+test('anyOf inside allOf', (t) => {
+  t.plan(1)
+
+  const schema = {
+    anyOf: [
+      {
+        type: 'object',
+        allOf: [
+          {
+            properties: {
+              a: {
+                anyOf: [
+                  { const: 'A1' },
+                  { const: 'A2' }
+                ]
+              }
+            }
+          },
+          {
+            properties: {
+              b: { const: 'B' }
+            }
+          }
+        ]
+      }
+    ]
+  }
+
+  const object = { a: 'A1', b: 'B' }
+  const stringify = build(schema)
+  const output = stringify(object)
+
+  t.equal(output, JSON.stringify(object))
+})
+
+test('should resolve absolute $refs', (t) => {
+  t.plan(1)
+
+  const externalSchema = {
+    FooSchema: {
+      $id: 'FooSchema',
+      type: 'object',
+      properties: {
+        type: {
+          anyOf: [
+            { type: 'string', const: 'bar' },
+            { type: 'string', const: 'baz' }
+          ]
+        }
+      }
+    }
+  }
+
+  const schema = { $ref: 'FooSchema' }
+
+  const object = { type: 'bar' }
+  const stringify = build(schema, { schema: externalSchema })
+  const output = stringify(object)
+
+  t.equal(output, JSON.stringify(object))
+})