twitst4tz

json.js (4918B)

---

 /*!
  * body-parser
  * Copyright(c) 2014 Jonathan Ong
  * Copyright(c) 2014-2015 Douglas Christopher Wilson
  * MIT Licensed
  */
 
 'use strict'
 
 /**
  * Module dependencies.
  * @private
  */
 
 var bytes = require('bytes')
 var contentType = require('content-type')
 var createError = require('http-errors')
 var debug = require('debug')('body-parser:json')
 var read = require('../read')
 var typeis = require('type-is')
 
 /**
  * Module exports.
  */
 
 module.exports = json
 
 /**
  * RegExp to match the first non-space in a string.
  *
  * Allowed whitespace is defined in RFC 7159:
  *
  *    ws = *(
  *            %x20 /              ; Space
  *            %x09 /              ; Horizontal tab
  *            %x0A /              ; Line feed or New line
  *            %x0D )              ; Carriage return
  */
 
 var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*(.)/ // eslint-disable-line no-control-regex
 
 /**
  * Create a middleware to parse JSON bodies.
  *
  * @param {object} [options]
  * @return {function}
  * @public
  */
 
 function json (options) {
   var opts = options || {}
 
   var limit = typeof opts.limit !== 'number'
     ? bytes.parse(opts.limit || '100kb')
     : opts.limit
   var inflate = opts.inflate !== false
   var reviver = opts.reviver
   var strict = opts.strict !== false
   var type = opts.type || 'application/json'
   var verify = opts.verify || false
 
   if (verify !== false && typeof verify !== 'function') {
     throw new TypeError('option verify must be function')
   }
 
   // create the appropriate type checking function
   var shouldParse = typeof type !== 'function'
     ? typeChecker(type)
     : type
 
   function parse (body) {
     if (body.length === 0) {
       // special-case empty json body, as it's a common client-side mistake
       // TODO: maybe make this configurable or part of "strict" option
       return {}
     }
 
     if (strict) {
       var first = firstchar(body)
 
       if (first !== '{' && first !== '[') {
         debug('strict violation')
         throw createStrictSyntaxError(body, first)
       }
     }
 
     try {
       debug('parse json')
       return JSON.parse(body, reviver)
     } catch (e) {
       throw normalizeJsonSyntaxError(e, {
         message: e.message,
         stack: e.stack
       })
     }
   }
 
   return function jsonParser (req, res, next) {
     if (req._body) {
       debug('body already parsed')
       next()
       return
     }
 
     req.body = req.body || {}
 
     // skip requests without bodies
     if (!typeis.hasBody(req)) {
       debug('skip empty body')
       next()
       return
     }
 
     debug('content-type %j', req.headers['content-type'])
 
     // determine if request should be parsed
     if (!shouldParse(req)) {
       debug('skip parsing')
       next()
       return
     }
 
     // assert charset per RFC 7159 sec 8.1
     var charset = getCharset(req) || 'utf-8'
     if (charset.substr(0, 4) !== 'utf-') {
       debug('invalid charset')
       next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {
         charset: charset,
         type: 'charset.unsupported'
       }))
       return
     }
 
     // read
     read(req, res, next, parse, debug, {
       encoding: charset,
       inflate: inflate,
       limit: limit,
       verify: verify
     })
   }
 }
 
 /**
  * Create strict violation syntax error matching native error.
  *
  * @param {string} str
  * @param {string} char
  * @return {Error}
  * @private
  */
 
 function createStrictSyntaxError (str, char) {
   var index = str.indexOf(char)
   var partial = str.substring(0, index) + '#'
 
   try {
     JSON.parse(partial); /* istanbul ignore next */ throw new SyntaxError('strict violation')
   } catch (e) {
     return normalizeJsonSyntaxError(e, {
       message: e.message.replace('#', char),
       stack: e.stack
     })
   }
 }
 
 /**
  * Get the first non-whitespace character in a string.
  *
  * @param {string} str
  * @return {function}
  * @private
  */
 
 function firstchar (str) {
   return FIRST_CHAR_REGEXP.exec(str)[1]
 }
 
 /**
  * Get the charset of a request.
  *
  * @param {object} req
  * @api private
  */
 
 function getCharset (req) {
   try {
     return (contentType.parse(req).parameters.charset || '').toLowerCase()
   } catch (e) {
     return undefined
   }
 }
 
 /**
  * Normalize a SyntaxError for JSON.parse.
  *
  * @param {SyntaxError} error
  * @param {object} obj
  * @return {SyntaxError}
  */
 
 function normalizeJsonSyntaxError (error, obj) {
   var keys = Object.getOwnPropertyNames(error)
 
   for (var i = 0; i < keys.length; i++) {
     var key = keys[i]
     if (key !== 'stack' && key !== 'message') {
       delete error[key]
     }
   }
 
   // replace stack before message for Node.js 0.10 and below
   error.stack = obj.stack.replace(error.message, obj.message)
   error.message = obj.message
 
   return error
 }
 
 /**
  * Get the simple type checker.
  *
  * @param {string} type
  * @return {function}
  */
 
 function typeChecker (type) {
   return function checkType (req) {
     return Boolean(typeis(req, type))
   }
 }