Merge branch 'master' into next

Author: mcollina

index.js

@@ -274,7 +274,7 @@ function $asBooleanNullable (bool) {
 function $asDatetime (date) {
   if (date instanceof Date) {
     return '"' + date.toISOString() + '"'
-  } else if (typeof date.toISOString === 'function') {
+  } else if (date && typeof date.toISOString === 'function') {
     return '"' + date.toISOString() + '"'
   } else {
     return $asString(date)
@@ -287,7 +287,7 @@ function $asDate (date) {
     var month = new Intl.DateTimeFormat('en', { month: '2-digit' }).format(date)
     var day = new Intl.DateTimeFormat('en', { day: '2-digit' }).format(date)
     return '"' + year + '-' + month + '-' + day + '"'
-  } else if (typeof date.format === 'function') {
+  } else if (date && typeof date.format === 'function') {
     return '"' + date.format('YYYY-MM-DD') + '"'
   } else {
     return $asString(date)
@@ -300,7 +300,7 @@ function $asTime (date) {
     var minute = new Intl.DateTimeFormat('en', { minute: 'numeric' }).format(date)
     var second = new Intl.DateTimeFormat('en', { second: 'numeric' }).format(date)
     return '"' + $pad2Zeros(hour) + ':' + $pad2Zeros(minute) + ':' + $pad2Zeros(second) + '"'
-  } else if (typeof date.format === 'function') {
+  } else if (date && typeof date.format === 'function') {
     return '"' + date.format('HH:mm:ss') + '"'
   } else {
     return $asString(date)
@@ -1072,9 +1072,10 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
         sortedTypes.forEach((type, index) => {
           var tempSchema = Object.assign({}, schema, { type })
           var nestedResult = nested(laterCode, name, key, tempSchema, externalSchema, fullSchema, subKey)
+
           if (type === 'string') {
             code += `
-              ${index === 0 ? 'if' : 'else if'}(typeof obj${accessor} === "${type}" || obj${accessor} instanceof Date || typeof obj${accessor}.toISOString === "function" || obj${accessor} instanceof RegExp)
+              ${index === 0 ? 'if' : 'else if'}(obj${accessor} === null || typeof obj${accessor} === "${type}" || obj${accessor} instanceof Date || typeof obj${accessor}.toISOString === "function" || obj${accessor} instanceof RegExp)
                 ${nestedResult.code}
             `
           } else if (type === 'null') {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "1.20.0",
+  "version": "1.20.1",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -49,6 +49,9 @@
     "deepmerge": "^4.2.2",
     "string-similarity": "^4.0.1"
   },
+  "engines": {
+    "node": ">= 10.0.0"
+  },
   "standard": {
     "ignore": [
       "schema-validator.js"

test/date.test.js

@@ -194,3 +194,211 @@ test('render a nested object in a string when type is date-format as ISOString',
   t.equal(output, JSON.stringify(toStringify))
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
+
+test('serializing null value', t => {
+  const input = { updatedAt: null }
+
+  function createSchema (properties) {
+    return {
+      title: 'an object in a string',
+      type: 'object',
+      properties
+    }
+  }
+
+  function serialize (schema, input) {
+    const validate = validator(schema)
+    const stringify = build(schema)
+    const output = stringify(input)
+
+    return {
+      validate,
+      output
+    }
+  }
+
+  t.plan(3)
+
+  t.test('type::string', t => {
+    t.plan(3)
+
+    t.test('format::date-time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: 'string',
+          format: 'date-time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a date-time format')
+    })
+
+    t.test('format::date', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: 'string',
+          format: 'date'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a date format')
+    })
+
+    t.test('format::time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: 'string',
+          format: 'time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a time format')
+    })
+  })
+
+  t.test('type::array', t => {
+    t.plan(3)
+
+    t.test('format::date-time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string'],
+          format: 'date-time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a date-time format')
+    })
+
+    t.test('format::date', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string'],
+          format: 'date'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a date format')
+    })
+
+    t.test('format::time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string'],
+          format: 'time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":""}')
+      t.notOk(validate(JSON.parse(output)), 'an empty string is not a time format')
+    })
+  })
+
+  t.test('type::array::nullable', t => {
+    t.plan(3)
+
+    t.test('format::date-time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string', 'null'],
+          format: 'date-time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":null}')
+      t.ok(validate(JSON.parse(output)), 'valid schema')
+    })
+
+    t.test('format::date', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string', 'null'],
+          format: 'date'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":null}')
+      t.ok(validate(JSON.parse(output)), 'valid schema')
+    })
+
+    t.test('format::time', t => {
+      t.plan(2)
+
+      const prop = {
+        updatedAt: {
+          type: ['string', 'null'],
+          format: 'time'
+        }
+      }
+
+      const {
+        output,
+        validate
+      } = serialize(createSchema(prop), input)
+
+      t.equal(output, '{"updatedAt":null}')
+      t.ok(validate(JSON.parse(output)), 'valid schema')
+    })
+  })
+})