fast-json-stringify 1.16.0 → 1.16.4

package/README.md

@@ -220,6 +220,7 @@ console.log(stringify(obj)) // '{"matchfoo":"42","otherfoo":"str","matchnum":3,"
 If *additionalProperties* is not present or is set to `false`, every property that is not explicitly listed in the *properties* and *patternProperties* objects,will be ignored, as described in <a href="#missingFields">Missing fields</a>.
 Missing fields are ignored to avoid having to rewrite objects before serializing. However, other schema rules would throw in similar situations.
 If *additionalProperties* is set to `true`, it will be used by `JSON.stringify` to stringify the additional properties. If you want to achieve maximum performance, we strongly encourage you to use a fixed schema where possible.
+The additional properties will always be serialzied at the end of the object.
 Example:
 ```javascript
 const stringify = fastJson({
@@ -252,7 +253,7 @@ const obj = {
   nomatchint: 313
 }
 
-console.log(stringify(obj)) // '{"matchfoo":"42","otherfoo":"str","matchnum":3,"nomatchstr":"valar morghulis",nomatchint:"313","nickname":"nick"}'
+console.log(stringify(obj)) // '{"nickname":"nick","matchfoo":"42","otherfoo":"str","matchnum":3,"nomatchstr":"valar morghulis",nomatchint:"313"}'
 ```
 
 #### AnyOf

package/index.js

@@ -6,6 +6,7 @@ var Ajv = require('ajv')
 var merge = require('deepmerge')
 var util = require('util')
 var validate = require('./schema-validator')
+var stringSimilarity = null
 
 var uglify = null
 var isLong
@@ -74,6 +75,7 @@ function build (schema, options) {
     `
   }
 
+  const fullSchema = schema
   if (schema.$ref) {
     schema = refFinder(schema.$ref, schema, options.schema)
   }
@@ -89,7 +91,7 @@ function build (schema, options) {
   switch (schema.type) {
     case 'object':
       main = '$main'
-      code = buildObject(schema, code, main, options.schema, schema)
+      code = buildObject(schema, code, main, options.schema, fullSchema)
       break
     case 'string':
       main = schema.nullable ? $asStringNullable.name : $asString.name
@@ -490,6 +492,10 @@ function refFinder (ref, schema, externalSchema) {
   if (ref[0]) {
     schema = externalSchema[ref[0]]
 
+    if (schema === undefined) {
+      findBadKey(externalSchema, [ref[0]])
+    }
+
     if (schema.$ref) {
       return refFinder(schema.$ref, schema, externalSchema)
     }
@@ -517,8 +523,30 @@ function refFinder (ref, schema, externalSchema) {
       }
     }
   }
-  const result = (new Function('schema', code))(schema)
+  var result
+  try {
+    result = (new Function('schema', code))(schema)
+  } catch (err) {}
+
+  if (result === undefined) {
+    findBadKey(schema, walk.slice(1))
+  }
   return result.$ref ? refFinder(result.$ref, schema, externalSchema) : result
+
+  function findBadKey (obj, keys) {
+    if (keys.length === 0) return null
+    const key = sanitizeKey(keys.shift())
+    if (obj[key] === undefined) {
+      stringSimilarity = stringSimilarity || require('string-similarity')
+      const { bestMatch } = stringSimilarity.findBestMatch(key, Object.keys(obj))
+      if (bestMatch.rating >= 0.5) {
+        throw new Error(`Cannot find reference '${key}', did you mean '${bestMatch.target}'?`)
+      } else {
+        throw new Error(`Cannot find reference '${key}'`)
+      }
+    }
+    return findBadKey(obj[key], keys)
+  }
 }
 
 function sanitizeKey (key) {
@@ -658,15 +686,13 @@ function buildCodeWithAllOfs (schema, code, laterCode, name, externalSchema, ful
 }
 
 function buildInnerObject (schema, name, externalSchema, fullSchema) {
-  var laterCode = ''
-  var code = ''
+  var result = buildCodeWithAllOfs(schema, '', '', name, externalSchema, fullSchema)
   if (schema.patternProperties) {
-    code += addPatternProperties(schema, externalSchema, fullSchema)
+    result.code += addPatternProperties(schema, externalSchema, fullSchema)
   } else if (schema.additionalProperties && !schema.patternProperties) {
-    code += addAdditionalProperties(schema, externalSchema, fullSchema)
+    result.code += addAdditionalProperties(schema, externalSchema, fullSchema)
   }
-
-  return buildCodeWithAllOfs(schema, code, laterCode, name, externalSchema, fullSchema)
+  return result
 }
 
 function addIfThenElse (schema, name, externalSchema, fullSchema) {
@@ -879,12 +905,26 @@ function buildArrayTypeCondition (type, accessor) {
   return condition
 }
 
+function dereferenceAnyOfRefs (schema, externalSchema, fullSchema) {
+  schema.anyOf.forEach((s, index) => {
+    // follow the refs
+    while (s.$ref) {
+      schema.anyOf[index] = refFinder(s.$ref, fullSchema, externalSchema)
+      s = schema.anyOf[index]
+    }
+  })
+}
+
 function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKey) {
   var code = ''
   var funcName
 
   subKey = subKey || ''
 
+  if (schema.$ref) {
+    schema = refFinder(schema.$ref, fullSchema, externalSchema)
+  }
+
   if (schema.type === undefined) {
     var inferedType = inferTypeByKeyword(schema)
     if (inferedType) {
@@ -930,6 +970,7 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
       break
     case undefined:
       if ('anyOf' in schema) {
+        dereferenceAnyOfRefs(schema, externalSchema, fullSchema)
         schema.anyOf.forEach((s, index) => {
           var nestedResult = nested(laterCode, name, key, s, externalSchema, fullSchema, subKey !== '' ? subKey : 'i' + index)
           code += `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "1.16.0",
+  "version": "1.16.4",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -39,16 +39,17 @@
     "long": "^4.0.0",
     "pre-commit": "^1.2.2",
     "proxyquire": "^2.1.3",
-    "semver": "^6.3.0",
+    "semver": "^7.1.0",
     "standard": "^14.0.0",
     "tap": "^12.6.5",
     "tap-mocha-reporter": "^3.0.9",
-    "typescript": "^3.6.3",
+    "typescript": "^3.7.5",
     "uglify-es": "^3.3.9"
   },
   "dependencies": {
-    "ajv": "^6.10.2",
-    "deepmerge": "^4.0.0"
+    "ajv": "^6.11.0",
+    "deepmerge": "^4.2.2",
+    "string-similarity": "^4.0.1"
   },
   "standard": {
     "ignore": [

package/test/additionalProperties.test.js

@@ -19,7 +19,7 @@ test('additionalProperties', (t) => {
   })
 
   const obj = { str: 'test', foo: 42, ofoo: true, foof: 'string', objfoo: { a: true } }
-  t.equal('{"foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]","str":"test"}', stringify(obj))
+  t.equal('{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}', stringify(obj))
 })
 
 test('additionalProperties should not change properties', (t) => {
@@ -38,7 +38,7 @@ test('additionalProperties should not change properties', (t) => {
   })
 
   const obj = { foo: '42', ofoo: 42 }
-  t.equal('{"ofoo":42,"foo":"42"}', stringify(obj))
+  t.equal('{"foo":"42","ofoo":42}', stringify(obj))
 })
 
 test('additionalProperties should not change properties and patternProperties', (t) => {
@@ -62,7 +62,7 @@ test('additionalProperties should not change properties and patternProperties',
   })
 
   const obj = { foo: '42', ofoo: 42, test: '42' }
-  t.equal('{"ofoo":"42","test":42,"foo":"42"}', stringify(obj))
+  t.equal('{"foo":"42","ofoo":"42","test":42}', stringify(obj))
 })
 
 test('additionalProperties set to true, use of fast-safe-stringify', (t) => {

package/test/anyof.test.js

@@ -248,3 +248,151 @@ test('null value in schema', (t) => {
     t.fail()
   }
 })
+
+test('anyOf and $ref together', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      cs: {
+        anyOf: [
+          {
+            $ref: '#/definitions/Option'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    },
+    definitions: {
+      Option: {
+        type: 'string'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      cs: 'franco'
+    })
+    t.is(value, '{"cs":"franco"}')
+  } catch (e) {
+    t.fail()
+  }
+
+  try {
+    const value = stringify({
+      cs: true
+    })
+    t.is(value, '{"cs":true}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('anyOf and $ref: 2 levels are fine', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      cs: {
+        anyOf: [
+          {
+            $ref: '#/definitions/Option'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    },
+    definitions: {
+      Option: {
+        anyOf: [
+          {
+            type: 'number'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  try {
+    const value = stringify({
+      cs: 3
+    })
+    t.is(value, '{"cs":3}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('anyOf and $ref: multiple levels should throw at build.', (t) => {
+  t.plan(3)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      cs: {
+        anyOf: [
+          {
+            $ref: '#/definitions/Option'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    },
+    definitions: {
+      Option: {
+        anyOf: [
+          {
+            $ref: '#/definitions/Option2'
+          },
+          {
+            type: 'string'
+          }
+        ]
+      },
+      Option2: {
+        type: 'number'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  try {
+    const value = stringify({
+      cs: 3
+    })
+    t.is(value, '{"cs":3}')
+  } catch (e) {
+    t.fail(e)
+  }
+  try {
+    const value = stringify({
+      cs: true
+    })
+    t.is(value, '{"cs":true}')
+  } catch (e) {
+    t.fail(e)
+  }
+  try {
+    const value = stringify({
+      cs: 'pippo'
+    })
+    t.is(value, '{"cs":"pippo"}')
+  } catch (e) {
+    t.fail(e)
+  }
+})

package/test/patternProperties.test.js

@@ -21,7 +21,7 @@ test('patternProperties', (t) => {
   })
 
   const obj = { str: 'test', foo: 42, ofoo: true, foof: 'string', objfoo: { a: true }, notMe: false }
-  t.equal(stringify(obj), '{"foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]","str":"test"}')
+  t.equal(stringify(obj), '{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}')
 })
 
 test('patternProperties should not change properties', (t) => {
@@ -42,7 +42,7 @@ test('patternProperties should not change properties', (t) => {
   })
 
   const obj = { foo: '42', ofoo: 42 }
-  t.equal(stringify(obj), '{"ofoo":42,"foo":"42"}')
+  t.equal(stringify(obj), '{"foo":"42","ofoo":42}')
 })
 
 test('patternProperties - string coerce', (t) => {

package/test/ref.test.js

@@ -685,6 +685,41 @@ test('ref internal - multiple $ref format', (t) => {
   t.equal(output, '{"zero":"test","a":"test","b":"test","c":"test","d":"test","e":"test"}')
 })
 
+test('ref in root internal', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with $ref in root schema',
+    $ref: '#/definitions/num',
+    definitions: {
+      num: {
+        type: 'object',
+        properties: {
+          int: {
+            $ref: '#/definitions/int'
+          }
+        }
+      },
+      int: {
+        type: 'integer'
+      }
+    }
+  }
+
+  const object = { int: 42 }
+  const stringify = build(schema)
+  const output = stringify(object)
+
+  try {
+    JSON.parse(output)
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+
+  t.equal(output, '{"int":42}')
+})
+
 test('ref in root external', (t) => {
   t.plan(2)
 
@@ -876,3 +911,202 @@ test('ref in definition with exact match', (t) => {
 
   t.equal(output, '{"foo":"foo"}')
 })
+
+test('Bad key', t => {
+  t.test('Find match', t => {
+    t.plan(1)
+    try {
+      build({
+        definitions: {
+          projectId: {
+            type: 'object',
+            properties: {
+              id: { type: 'integer' }
+            }
+          }
+        },
+        type: 'object',
+        properties: {
+          data: {
+            $ref: '#/definitions/porjectId'
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'porjectId', did you mean 'projectId'?")
+    }
+  })
+
+  t.test('No match', t => {
+    t.plan(1)
+    try {
+      build({
+        definitions: {
+          projectId: {
+            type: 'object',
+            properties: {
+              id: { type: 'integer' }
+            }
+          }
+        },
+        type: 'object',
+        properties: {
+          data: {
+            $ref: '#/definitions/foobar'
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'foobar'")
+    }
+  })
+
+  t.test('Find match (external schema)', t => {
+    t.plan(1)
+    try {
+      build({
+        type: 'object',
+        properties: {
+          data: {
+            $ref: 'external#/definitions/porjectId'
+          }
+        }
+      }, {
+        schema: {
+          external: {
+            definitions: {
+              projectId: {
+                type: 'object',
+                properties: {
+                  id: { type: 'integer' }
+                }
+              }
+            }
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'porjectId', did you mean 'projectId'?")
+    }
+  })
+
+  t.test('No match (external schema)', t => {
+    t.plan(1)
+    try {
+      build({
+        type: 'object',
+        properties: {
+          data: {
+            $ref: 'external#/definitions/foobar'
+          }
+        }
+      }, {
+        schema: {
+          external: {
+            definitions: {
+              projectId: {
+                type: 'object',
+                properties: {
+                  id: { type: 'integer' }
+                }
+              }
+            }
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'foobar'")
+    }
+  })
+
+  t.test('Find match (external definitions typo)', t => {
+    t.plan(1)
+    try {
+      build({
+        type: 'object',
+        properties: {
+          data: {
+            $ref: 'external#/deifnitions/projectId'
+          }
+        }
+      }, {
+        schema: {
+          external: {
+            definitions: {
+              projectId: {
+                type: 'object',
+                properties: {
+                  id: { type: 'integer' }
+                }
+              }
+            }
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'deifnitions', did you mean 'definitions'?")
+    }
+  })
+
+  t.test('Find match (definitions typo)', t => {
+    t.plan(1)
+    try {
+      build({
+        definitions: {
+          projectId: {
+            type: 'object',
+            properties: {
+              id: { type: 'integer' }
+            }
+          }
+        },
+        type: 'object',
+        properties: {
+          data: {
+            $ref: '#/deifnitions/projectId'
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'deifnitions', did you mean 'definitions'?")
+    }
+  })
+
+  t.test('Find match (external schema typo)', t => {
+    t.plan(1)
+    try {
+      build({
+        type: 'object',
+        properties: {
+          data: {
+            $ref: 'extrenal#/definitions/projectId'
+          }
+        }
+      }, {
+        schema: {
+          external: {
+            definitions: {
+              projectId: {
+                type: 'object',
+                properties: {
+                  id: { type: 'integer' }
+                }
+              }
+            }
+          }
+        }
+      })
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, "Cannot find reference 'extrenal', did you mean 'external'?")
+    }
+  })
+
+  t.end()
+})