fast-json-stringify 5.2.0 → 5.3.0

package/{build-schema-validator.js → build/build-schema-validator.js}

@@ -23,4 +23,4 @@ const validationCode = standaloneCode(ajv, validate)
 
 const moduleCode = `/* CODE GENERATED BY '${path.basename(__filename)}' DO NOT EDIT! */\n${validationCode}`
 
-fs.writeFileSync(path.join(__dirname, 'schema-validator.js'), moduleCode)
+fs.writeFileSync(path.join(__dirname, '../lib/schema-validator.js'), moduleCode)

package/{example.js → examples/example.js}

@@ -1,4 +1,4 @@
-const fastJson = require('.')
+const fastJson = require('..')
 const stringify = fastJson({
   title: 'Example Schema',
   type: 'object',

package/{server.js → examples/server.js}

@@ -2,7 +2,7 @@
 
 const http = require('http')
 
-const stringify = require('.')({
+const stringify = require('fast-json-stringify')({
   type: 'object',
   properties: {
     hello: {

package/index.d.ts

@@ -1,4 +1,5 @@
 import Ajv, { Options as AjvOptions } from "ajv"
+
 declare namespace build {
   interface BaseSchema {
     /**
@@ -189,13 +190,13 @@ interface StandaloneOption extends build.Options {
 declare function build(schema: build.AnySchema, options: DebugOption): { code: string, ajv: Ajv };
 declare function build(schema: build.AnySchema, options: DeprecateDebugOption): { code: string, ajv: Ajv };
 declare function build(schema: build.AnySchema, options: StandaloneOption): string;
-declare function build(schema: build.AnySchema, options?: build.Options): (doc: any) => any;
-declare function build(schema: build.StringSchema, options?: build.Options): (doc: string) => string;
-declare function build(schema: build.IntegerSchema | build.NumberSchema, options?: build.Options): (doc: number) => string;
-declare function build(schema: build.NullSchema, options?: build.Options): (doc: null) => "null";
-declare function build(schema: build.BooleanSchema, options?: build.Options): (doc: boolean) => string;
-declare function build(schema: build.ArraySchema | build.TupleSchema, options?: build.Options): (doc: any[]) => string;
-declare function build(schema: build.ObjectSchema, options?: build.Options): (doc: object) => string;
-declare function build(schema: build.Schema, options?: build.Options): (doc: object | any[] | string | number | boolean | null) => string;
+declare function build(schema: build.AnySchema, options?: build.Options): <TDoc = any>(doc: TDoc) => any;
+declare function build(schema: build.StringSchema, options?: build.Options): <TDoc extends string = string>(doc: TDoc) => string;
+declare function build(schema: build.IntegerSchema | build.NumberSchema, options?: build.Options): <TDoc extends number = number>(doc: TDoc) => string;
+declare function build(schema: build.NullSchema, options?: build.Options): <TDoc extends null = null>(doc: TDoc) => "null";
+declare function build(schema: build.BooleanSchema, options?: build.Options): <TDoc extends boolean = boolean>(doc: TDoc) => string;
+declare function build(schema: build.ArraySchema | build.TupleSchema, options?: build.Options): <TDoc extends any[]= any[]>(doc: TDoc) => string;
+declare function build(schema: build.ObjectSchema, options?: build.Options): <TDoc extends object = object>(doc: TDoc) => string;
+declare function build(schema: build.Schema, options?: build.Options): <TDoc = object | any[] | string | number | boolean | null> (doc: TDoc) => string;
 
 export = build;

package/index.js

@@ -4,13 +4,12 @@
 
 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 Validator = require('./validator')
-const RefResolver = require('./ref-resolver')
+const validate = require('./lib/schema-validator')
+const Serializer = require('./lib/serializer')
+const Validator = require('./lib/validator')
+const RefResolver = require('./lib/ref-resolver')
 
 let largeArraySize = 2e4
 let largeArrayMechanism = 'default'
@@ -71,8 +70,7 @@ function resolveRef (location, ref) {
   return { schema, schemaId, jsonPointer }
 }
 
-const arrayItemsReferenceSerializersMap = new Map()
-const objectReferenceSerializersMap = new Map()
+const contextFunctionsNamesBySchema = new Map()
 
 let rootSchemaId = null
 let refResolver = null
@@ -80,8 +78,7 @@ let validator = null
 let contextFunctions = null
 
 function build (schema, options) {
-  arrayItemsReferenceSerializersMap.clear()
-  objectReferenceSerializersMap.clear()
+  contextFunctionsNamesBySchema.clear()
 
   contextFunctions = []
   options = options || {}
@@ -147,12 +144,17 @@ function build (schema, options) {
   }
 
   if (options.mode === 'debug') {
-    return { code: dependenciesName.join('\n'), validator, ajv: validator.ajv }
+    return {
+      validator,
+      serializer,
+      code: dependenciesName.join('\n'),
+      ajv: validator.ajv
+    }
   }
 
   if (options.mode === 'standalone') {
     // lazy load
-    const buildStandaloneCode = require('./standalone')
+    const buildStandaloneCode = require('./lib/standalone')
     return buildStandaloneCode(options, validator, contextFunctionCode)
   }
 
@@ -164,8 +166,7 @@ function build (schema, options) {
   validator = null
   rootSchemaId = null
   contextFunctions = null
-  arrayItemsReferenceSerializersMap.clear()
-  objectReferenceSerializersMap.clear()
+  contextFunctionsNamesBySchema.clear()
 
   return stringifyFunc
 }
@@ -538,25 +539,18 @@ function toJSON (variableName) {
 function buildObject (location) {
   const schema = location.schema
 
-  if (objectReferenceSerializersMap.has(schema)) {
-    return objectReferenceSerializersMap.get(schema)
+  if (contextFunctionsNamesBySchema.has(schema)) {
+    return contextFunctionsNamesBySchema.get(schema)
   }
 
   const functionName = generateFuncName()
-  objectReferenceSerializersMap.set(schema, functionName)
+  contextFunctionsNamesBySchema.set(schema, functionName)
 
   const schemaId = location.schemaId === rootSchemaId ? '' : location.schemaId
   let functionCode = `
     function ${functionName} (input) {
       // ${schemaId + location.jsonPointer}
   `
-  if (schema.nullable) {
-    functionCode += `
-      if (input === null) {
-        return 'null';
-      }
-  `
-  }
 
   functionCode += `
       var obj = ${toJSON('input')}
@@ -581,33 +575,23 @@ function buildObject (location) {
 }
 
 function buildArray (location) {
-  let schema = location.schema
-
-  // default to any items type
-  if (!schema.items) {
-    schema.items = {}
-  }
+  const schema = location.schema
 
   let itemsLocation = mergeLocation(location, 'items')
+  itemsLocation.schema = itemsLocation.schema || {}
 
-  if (schema.items.$ref) {
-    if (!schema[fjsCloned]) {
-      location.schema = clone(location.schema)
-      schema = location.schema
-      schema[fjsCloned] = true
-    }
-
-    location = resolveRef(location, schema.items.$ref)
-    itemsLocation = location
-    schema.items = location.schema
+  if (itemsLocation.schema.$ref) {
+    itemsLocation = resolveRef(itemsLocation, itemsLocation.schema.$ref)
   }
 
-  if (arrayItemsReferenceSerializersMap.has(schema.items)) {
-    return arrayItemsReferenceSerializersMap.get(schema.items)
+  const itemsSchema = itemsLocation.schema
+
+  if (contextFunctionsNamesBySchema.has(schema)) {
+    return contextFunctionsNamesBySchema.get(schema)
   }
 
   const functionName = generateFuncName()
-  arrayItemsReferenceSerializersMap.set(schema.items, functionName)
+  contextFunctionsNamesBySchema.set(schema, functionName)
 
   const schemaId = location.schemaId === rootSchemaId ? '' : location.schemaId
   let functionCode = `
@@ -615,14 +599,6 @@ function buildArray (location) {
       // ${schemaId + location.jsonPointer}
   `
 
-  if (schema.nullable) {
-    functionCode += `
-      if (obj === null) {
-        return 'null';
-      }
-    `
-  }
-
   functionCode += `
     if (!Array.isArray(obj)) {
       throw new TypeError(\`The value '$\{obj}' does not match schema definition.\`)
@@ -632,8 +608,8 @@ function buildArray (location) {
 
   if (!schema.additionalItems) {
     functionCode += `
-      if (arrayLength > ${schema.items.length}) {
-        throw new Error(\`Item at ${schema.items.length} does not match schema definition.\`)
+      if (arrayLength > ${itemsSchema.length}) {
+        throw new Error(\`Item at ${itemsSchema.length} does not match schema definition.\`)
       }
     `
   }
@@ -650,9 +626,9 @@ function buildArray (location) {
     let jsonOutput = ''
   `
 
-  if (Array.isArray(schema.items)) {
-    for (let i = 0; i < schema.items.length; i++) {
-      const item = schema.items[i]
+  if (Array.isArray(itemsSchema)) {
+    for (let i = 0; i < itemsSchema.length; i++) {
+      const item = itemsSchema[i]
       const tmpRes = buildValue(mergeLocation(itemsLocation, i), `obj[${i}]`)
       functionCode += `
         if (${i} < arrayLength) {
@@ -672,7 +648,7 @@ function buildArray (location) {
 
     if (schema.additionalItems) {
       functionCode += `
-        for (let i = ${schema.items.length}; i < arrayLength; i++) {
+        for (let i = ${itemsSchema.length}; i < arrayLength; i++) {
           let json = JSON.stringify(obj[i])
           jsonOutput += json
           if (i < arrayLength - 1) {
@@ -743,6 +719,137 @@ function generateFuncName () {
   return 'anonymous' + genFuncNameCounter++
 }
 
+function buildMultiTypeSerializer (location, input) {
+  const schema = location.schema
+  const types = schema.type.sort(t1 => t1 === 'null' ? -1 : 1)
+
+  let code = ''
+
+  const locationClone = clone(location)
+  types.forEach((type, index) => {
+    const statement = index === 0 ? 'if' : 'else if'
+    locationClone.schema.type = type
+    const nestedResult = buildSingleTypeSerializer(locationClone, input)
+    switch (type) {
+      case 'null':
+        code += `
+          ${statement} (${input} === null)
+            ${nestedResult}
+          `
+        break
+      case 'string': {
+        code += `
+          ${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
+      }
+      case 'array': {
+        code += `
+          ${statement}(Array.isArray(${input}))
+            ${nestedResult}
+        `
+        break
+      }
+      case 'integer': {
+        code += `
+          ${statement}(Number.isInteger(${input}) || ${input} === null)
+            ${nestedResult}
+        `
+        break
+      }
+      default: {
+        code += `
+          ${statement}(typeof ${input} === "${type}" || ${input} === null)
+            ${nestedResult}
+        `
+        break
+      }
+    }
+  })
+  code += `
+    else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
+  `
+
+  return code
+}
+
+function buildSingleTypeSerializer (location, input) {
+  const schema = location.schema
+
+  switch (schema.type) {
+    case 'null':
+      return 'json += \'null\''
+    case 'string': {
+      if (schema.format === 'date-time') {
+        return `json += serializer.asDateTime(${input})`
+      } else if (schema.format === 'date') {
+        return `json += serializer.asDate(${input})`
+      } else if (schema.format === 'time') {
+        return `json += serializer.asTime(${input})`
+      } else {
+        return `json += serializer.asString(${input})`
+      }
+    }
+    case 'integer':
+      return `json += serializer.asInteger(${input})`
+    case 'number':
+      return `json += serializer.asNumber(${input})`
+    case 'boolean':
+      return `json += serializer.asBoolean(${input})`
+    case 'object': {
+      const funcName = buildObject(location)
+      return `json += ${funcName}(${input})`
+    }
+    case 'array': {
+      const funcName = buildArray(location)
+      return `json += ${funcName}(${input})`
+    }
+    case undefined:
+      return `json += JSON.stringify(${input})`
+    default:
+      throw new Error(`${schema.type} unsupported`)
+  }
+}
+
+function buildConstSerializer (location, input) {
+  const schema = location.schema
+  const type = schema.type
+
+  const hasNullType = Array.isArray(type) && type.includes('null')
+
+  let code = ''
+
+  if (hasNullType) {
+    code += `
+      if (${input} === null) {
+        json += 'null'
+      } else {
+    `
+  }
+
+  code += `json += '${JSON.stringify(schema.const)}'`
+
+  if (hasNullType) {
+    code += `
+      }
+    `
+  }
+
+  return code
+}
+
 function buildValue (location, input) {
   let schema = location.schema
 
@@ -770,188 +877,60 @@ function buildValue (location, input) {
   }
 
   const type = schema.type
-  const nullable = schema.nullable === true || (Array.isArray(type) && type.includes('null'))
 
   let code = ''
-  let funcName
 
-  if ('const' in schema) {
-    if (nullable) {
+  if (type === undefined && (schema.anyOf || schema.oneOf)) {
+    const type = schema.anyOf ? 'anyOf' : 'oneOf'
+    const anyOfLocation = mergeLocation(location, type)
+
+    for (let index = 0; index < location.schema[type].length; index++) {
+      const optionLocation = mergeLocation(anyOfLocation, index)
+      const schemaRef = optionLocation.schemaId + optionLocation.jsonPointer
+      const nestedResult = buildValue(optionLocation, input)
       code += `
-        json += ${input} === null ? 'null' : '${JSON.stringify(schema.const)}'
+        ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input}))
+          ${nestedResult}
       `
-      return code
     }
-    code += `json += '${JSON.stringify(schema.const)}'`
+
+    code += `
+      else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
+    `
     return code
   }
 
-  switch (type) {
-    case 'null':
-      code += 'json += serializer.asNull()'
-      break
-    case 'string': {
-      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
-    }
-    case 'integer':
-      funcName = nullable ? 'serializer.asIntegerNullable.bind(serializer)' : 'serializer.asInteger.bind(serializer)'
-      code += `json += ${funcName}(${input})`
-      break
-    case 'number':
-      funcName = nullable ? 'serializer.asNumberNullable.bind(serializer)' : 'serializer.asNumber.bind(serializer)'
-      code += `json += ${funcName}(${input})`
-      break
-    case 'boolean':
-      funcName = nullable ? 'serializer.asBooleanNullable.bind(serializer)' : 'serializer.asBoolean.bind(serializer)'
-      code += `json += ${funcName}(${input})`
-      break
-    case 'object':
-      funcName = buildObject(location)
-      code += `json += ${funcName}(${input})`
-      break
-    case 'array':
-      funcName = buildArray(location)
-      code += `json += ${funcName}(${input})`
-      break
-    case undefined:
-      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)
-
-        for (let index = 0; index < location.schema[type].length; index++) {
-          const optionLocation = mergeLocation(anyOfLocation, index)
-          const schemaRef = optionLocation.schemaId + optionLocation.jsonPointer
-          const nestedResult = buildValue(optionLocation, input)
-          code += `
-            ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input}))
-              ${nestedResult}
-          `
-        }
-
-        code += `
-          else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
-        `
-      } else if (isEmpty(schema)) {
-        code += `
-          json += JSON.stringify(${input})
-        `
+  const nullable = schema.nullable === true
+  if (nullable) {
+    code += `
+      if (${input} === null) {
+        json += 'null'
       } else {
-        code += `
-          json += JSON.stringify(${input})
-        `
-      }
-      break
-    default:
-      if (Array.isArray(type)) {
-        let sortedTypes = type
-        const nullable = schema.nullable === true || type.includes('null')
-
-        if (nullable) {
-          sortedTypes = sortedTypes.filter(type => type !== 'null')
-          code += `
-            if (${input} === null) {
-              json += null
-            } else {`
-        }
+    `
+  }
 
-        const locationClone = clone(location)
-        sortedTypes.forEach((type, index) => {
-          const statement = index === 0 ? 'if' : 'else if'
-          locationClone.schema.type = type
-          const nestedResult = buildValue(locationClone, input)
-          switch (type) {
-            case 'string': {
-              code += `
-                ${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
-            }
-            case 'array': {
-              code += `
-                ${statement}(Array.isArray(${input}))
-                  ${nestedResult}
-              `
-              break
-            }
-            case 'integer': {
-              code += `
-                ${statement}(Number.isInteger(${input}) || ${input} === null)
-                  ${nestedResult}
-              `
-              break
-            }
-            case 'object': {
-              code += `
-                ${statement}(typeof ${input} === "object" || ${input} === null)
-                  ${nestedResult}
-              `
-              break
-            }
-            default: {
-              code += `
-                ${statement}(typeof ${input} === "${type}" || ${input} === null)
-                  ${nestedResult}
-              `
-              break
-            }
-          }
-        })
-        code += `
-          else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
-        `
+  if (schema.const !== undefined) {
+    code += buildConstSerializer(location, input)
+  } else if (Array.isArray(type)) {
+    code += buildMultiTypeSerializer(location, input)
+  } else {
+    code += buildSingleTypeSerializer(location, input)
+  }
 
-        if (nullable) {
-          code += `
-            }
-          `
-        }
-      } else {
-        throw new Error(`${type} unsupported`)
+  if (nullable) {
+    code += `
       }
+    `
   }
 
   return code
 }
 
-function isEmpty (schema) {
-  // eslint-disable-next-line
-  for (var key in schema) {
-    if (Object.prototype.hasOwnProperty.call(schema, key) && schema[key] !== undefined) {
-      return false
-    }
-  }
-  return true
-}
-
 module.exports = build
 
 module.exports.validLargeArrayMechanisms = validLargeArrayMechanisms
 
-module.exports.restore = function ({ code, validator }) {
-  const serializer = new Serializer()
+module.exports.restore = function ({ code, validator, serializer }) {
   // eslint-disable-next-line
   return (Function.apply(null, ['validator', 'serializer', code])
     .apply(null, [validator, serializer]))

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,18 +45,10 @@ 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) {
     if (date === null) return '""'
     if (date instanceof Date) {
@@ -80,10 +60,6 @@ module.exports = class Serializer {
     throw new Error(`The value "${date}" cannot be converted to a date-time.`)
   }
 
-  asDateTimeNullable (date) {
-    return date === null ? 'null' : this.asDateTime(date)
-  }
-
   asDate (date) {
     if (date === null) return '""'
     if (date instanceof Date) {
@@ -95,10 +71,6 @@ module.exports = class Serializer {
     throw new Error(`The value "${date}" cannot be converted to a date.`)
   }
 
-  asDateNullable (date) {
-    return date === null ? 'null' : this.asDate(date)
-  }
-
   asTime (date) {
     if (date === null) return '""'
     if (date instanceof Date) {
@@ -110,10 +82,6 @@ module.exports = class Serializer {
     throw new Error(`The value "${date}" cannot be converted to a time.`)
   }
 
-  asTimeNullable (date) {
-    return date === null ? 'null' : this.asTime(date)
-  }
-
   asString (str) {
     const quotes = '"'
     if (str instanceof Date) {
@@ -133,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.2.0",
+  "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"
   },
@@ -45,6 +45,7 @@
     "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"
   },
@@ -61,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/date.test.js

@@ -525,3 +525,22 @@ test('nullable date', (t) => {
 
   t.same(result, `"${DateTime.fromJSDate(data).toISODate()}"`)
 })
+
+test('non-date format should not affect data serialization (issue #491)', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      hello: {
+        type: 'string',
+        format: 'int64',
+        pattern: '^[0-9]*$'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const data = { hello: 123n }
+  t.equal(stringify(data), '{"hello":"123"}')
+})

package/test/debug-mode.test.js

@@ -4,7 +4,8 @@ const test = require('tap').test
 const fjs = require('..')
 
 const Ajv = require('ajv').default
-const Validator = require('../validator')
+const Validator = require('../lib/validator')
+const Serializer = require('../lib/serializer')
 
 function build (opts) {
   return fjs({
@@ -20,17 +21,18 @@ function build (opts) {
 }
 
 test('activate debug mode', t => {
-  t.plan(4)
+  t.plan(5)
   const debugMode = build({ debugMode: true })
 
   t.type(debugMode, 'object')
   t.ok(debugMode.ajv instanceof Ajv)
   t.ok(debugMode.validator instanceof Validator)
+  t.ok(debugMode.serializer instanceof Serializer)
   t.type(debugMode.code, 'string')
 })
 
 test('activate debug mode truthy', t => {
-  t.plan(4)
+  t.plan(5)
 
   const debugMode = build({ debugMode: 'yes' })
 
@@ -38,15 +40,17 @@ test('activate debug mode truthy', t => {
   t.type(debugMode.code, 'string')
   t.ok(debugMode.ajv instanceof Ajv)
   t.ok(debugMode.validator instanceof Validator)
+  t.ok(debugMode.serializer instanceof Serializer)
 })
 
 test('to string auto-consistent', t => {
-  t.plan(5)
+  t.plan(6)
   const debugMode = build({ debugMode: 1 })
 
   t.type(debugMode, 'object')
   t.type(debugMode.code, 'string')
   t.ok(debugMode.ajv instanceof Ajv)
+  t.ok(debugMode.serializer instanceof Serializer)
   t.ok(debugMode.validator instanceof Validator)
 
   const compiled = fjs.restore(debugMode)
@@ -55,7 +59,7 @@ test('to string auto-consistent', t => {
 })
 
 test('to string auto-consistent with ajv', t => {
-  t.plan(5)
+  t.plan(6)
 
   const debugMode = fjs({
     title: 'object with multiple types field',
@@ -75,6 +79,7 @@ test('to string auto-consistent with ajv', t => {
   t.type(debugMode.code, 'string')
   t.ok(debugMode.ajv instanceof Ajv)
   t.ok(debugMode.validator instanceof Validator)
+  t.ok(debugMode.serializer instanceof Serializer)
 
   const compiled = fjs.restore(debugMode)
   const tobe = JSON.stringify({ str: 'Foo' })
@@ -106,3 +111,11 @@ test('to string auto-consistent with ajv-formats', t => {
   t.same(compiled({ str: 'foo@bar.com' }), tobe)
   t.throws(() => compiled({ str: 'foo' }))
 })
+
+test('debug should restore the same serializer instance', t => {
+  t.plan(1)
+
+  const debugMode = fjs({ type: 'integer' }, { debugMode: 1, rounding: 'ceil' })
+  const compiled = fjs.restore(debugMode)
+  t.same(compiled(3.95), 4)
+})

package/test/types/schema-inference.test-d.ts

@@ -0,0 +1,48 @@
+import { expectError } from "tsd";
+import build from "../..";
+
+// With inference
+interface Schema {
+  id: string;
+  a?: number;
+}
+
+const stringify3 = build({
+  type: "object",
+  properties: { a: { type: "string" } },
+});
+stringify3<Schema>({ id: "123" });
+stringify3<Schema>({ a: 123, id: "123" });
+expectError(stringify3<Schema>({ anotherOne: "bar" }));
+expectError(stringify3<Schema>({ a: "bar" }));
+
+// Without inference
+const stringify4 = build({
+  type: "object",
+  properties: { a: { type: "string" } },
+});
+stringify4({ id: "123" });
+stringify4({ a: 123, id: "123" });
+stringify4({ anotherOne: "bar" });
+stringify4({ a: "bar" });
+
+// Without inference - string type
+const stringify5 = build({
+  type: "string",
+});
+stringify5("foo");
+expectError(stringify5({ id: "123" }));
+
+// Without inference - null type
+const stringify6 = build({
+  type: "null",
+});
+stringify6(null);
+expectError(stringify6("a string"));
+
+// Without inference - boolean type
+const stringify7 = build({
+  type: "boolean",
+});
+stringify7(true);
+expectError(stringify7("a string"));