fast-json-stringify 5.0.5 → 5.2.0

package/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/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')
 })

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

@@ -2,7 +2,9 @@
 
 const test = require('tap').test
 const fjs = require('..')
+
 const Ajv = require('ajv').default
+const Validator = require('../validator')
 
 function build (opts) {
   return fjs({
@@ -18,31 +20,34 @@ function build (opts) {
 }
 
 test('activate debug mode', t => {
-  t.plan(3)
+  t.plan(4)
   const debugMode = build({ debugMode: true })
 
   t.type(debugMode, 'object')
   t.ok(debugMode.ajv instanceof Ajv)
+  t.ok(debugMode.validator instanceof Validator)
   t.type(debugMode.code, 'string')
 })
 
 test('activate debug mode truthy', t => {
-  t.plan(3)
+  t.plan(4)
 
   const debugMode = build({ debugMode: 'yes' })
 
   t.type(debugMode, 'object')
   t.type(debugMode.code, 'string')
   t.ok(debugMode.ajv instanceof Ajv)
+  t.ok(debugMode.validator instanceof Validator)
 })
 
 test('to string auto-consistent', t => {
-  t.plan(4)
+  t.plan(5)
   const debugMode = build({ debugMode: 1 })
 
   t.type(debugMode, 'object')
   t.type(debugMode.code, 'string')
   t.ok(debugMode.ajv instanceof Ajv)
+  t.ok(debugMode.validator instanceof Validator)
 
   const compiled = fjs.restore(debugMode)
   const tobe = JSON.stringify({ firstName: 'Foo' })
@@ -50,7 +55,7 @@ test('to string auto-consistent', t => {
 })
 
 test('to string auto-consistent with ajv', t => {
-  t.plan(4)
+  t.plan(5)
 
   const debugMode = fjs({
     title: 'object with multiple types field',
@@ -69,6 +74,7 @@ test('to string auto-consistent with ajv', t => {
   t.type(debugMode, 'object')
   t.type(debugMode.code, 'string')
   t.ok(debugMode.ajv instanceof Ajv)
+  t.ok(debugMode.validator instanceof Validator)
 
   const compiled = fjs.restore(debugMode)
   const tobe = JSON.stringify({ str: 'Foo' })

package/test/nullable.test.js

@@ -444,3 +444,100 @@ test('large array of nullable booleans with default mechanism', (t) => {
   t.same(result, JSON.stringify(data))
   t.same(JSON.parse(result), data)
 })
+
+test('nullable type in the schema', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: ['object', 'null'],
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  const data = { foo: 'bar' }
+
+  t.same(stringify(data), JSON.stringify(data))
+  t.same(stringify(null), JSON.stringify(null))
+})
+
+test('throw an error if the value doesn\'t match the type', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['data'],
+    properties: {
+      data: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          oneOf: [
+            {
+              type: 'string'
+            },
+            {
+              type: 'number'
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  const validData = { data: [1, 'testing'] }
+  t.equal(stringify(validData), JSON.stringify(validData))
+
+  const invalidData = { data: [false, 'testing'] }
+  t.throws(() => stringify(invalidData))
+})
+
+test('nullable value in oneOf', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      data: {
+        oneOf: [
+          {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                id: { type: 'integer', minimum: 1 }
+              },
+              additionalProperties: false,
+              required: ['id']
+            }
+          },
+          {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                job: { type: 'string', nullable: true }
+              },
+              additionalProperties: false,
+              required: ['job']
+            }
+          }
+        ]
+      }
+    },
+    required: ['data'],
+    additionalProperties: false
+  }
+
+  const stringify = build(schema)
+
+  const data = { data: [{ job: null }] }
+  t.equal(stringify(data), JSON.stringify(data))
+})

package/test/ref.test.js

@@ -1926,3 +1926,58 @@ test('anyOf inside allOf', (t) => {
 
   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))
+})
+
+test('nested schema should overwrite anchor scope', (t) => {
+  t.plan(2)
+
+  const externalSchema = {
+    root: {
+      $id: 'root',
+      definitions: {
+        subschema: {
+          $id: 'subschema',
+          definitions: {
+            anchorSchema: {
+              $id: '#anchor',
+              type: 'string'
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const data = 'test'
+  const stringify = build({ $ref: 'subschema#anchor' }, { schema: externalSchema })
+  const output = stringify(data)
+
+  t.equal(output, JSON.stringify(data))
+  t.throws(() => build({ $ref: 'root#anchor' }, { schema: externalSchema }))
+})

package/test/typesArray.test.js

@@ -438,6 +438,35 @@ test('object that is simultaneously a string and a json switched', (t) => {
   t.equal(valueObj, '{"simultaneously":{"foo":"hello"}}')
 })
 
+test('class instance that is simultaneously a string and a json', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      simultaneously: {
+        type: ['string', 'object'],
+        properties: {
+          foo: { type: 'string' }
+        }
+      }
+    }
+  }
+
+  class Test {
+    toString () { return 'hello' }
+  }
+
+  const likeObjectId = new Test()
+
+  const stringify = build(schema)
+  const valueStr = stringify({ simultaneously: likeObjectId })
+  t.equal(valueStr, '{"simultaneously":"hello"}')
+
+  const valueObj = stringify({ simultaneously: { foo: likeObjectId } })
+  t.equal(valueObj, '{"simultaneously":{"foo":"hello"}}')
+})
+
 test('should throw an error when type is array and object is null', (t) => {
   t.plan(1)
   const schema = {