1586018702

Build Type

push

github

Committed by Douglas Christopher Wilson

Commit Message

Default urlencoded extended option to false

Run Details

200 of 201 branches covered (99.5%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

323 of 324 relevant lines covered (99.69%)

639.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.2

/lib/types/json.js

/*!
 * 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))
  }
}

1	/*!
2	* body-parser
3	* Copyright(c) 2014 Jonathan Ong
4	* Copyright(c) 2014-2015 Douglas Christopher Wilson
5	* MIT Licensed
6	*/
7
8	'use strict'
9
10	/**
11	* Module dependencies.
12	* @private
13	*/
14
15	var bytes = require('bytes')	2✔
16	var contentType = require('content-type')	2✔
17	var createError = require('http-errors')	2✔
18	var debug = require('debug')('body-parser:json')	2✔
19	var read = require('../read')	2✔
20	var typeis = require('type-is')	2✔
21
22	/**
23	* Module exports.
24	*/
25
26	module.exports = json	2✔
27
28	/**
29	* RegExp to match the first non-space in a string.
30	*
31	* Allowed whitespace is defined in RFC 7159:
32	*
33	* ws = *(
34	* %x20 / ; Space
35	* %x09 / ; Horizontal tab
36	* %x0A / ; Line feed or New line
37	* %x0D ) ; Carriage return
38	*/
39
40	var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*(.)/ // eslint-disable-line no-control-regex	2✔
41
42	/**
43	* Create a middleware to parse JSON bodies.
44	*
45	* @param {object} [options]
46	* @return {function}
47	* @public
48	*/
49
50	function json (options) {
51	var opts = options \|\| {}	80✔
52
53	var limit = typeof opts.limit !== 'number'	80✔
54	? bytes.parse(opts.limit \|\| '100kb')	142✔
55	: opts.limit
56	var inflate = opts.inflate !== false	80✔
57	var reviver = opts.reviver	80✔
58	var strict = opts.strict !== false	80✔
59	var type = opts.type \|\| 'application/json'	80✔
60	var verify = opts.verify \|\| false	80✔
61
62	if (verify !== false && typeof verify !== 'function') {	80✔
63	throw new TypeError('option verify must be function')	2✔
64	}
65
66	// create the appropriate type checking function
67	var shouldParse = typeof type !== 'function'	78✔
68	? typeChecker(type)
69	: type
70
71	function parse (body) {
72	if (body.length === 0) {	128✔
73	// special-case empty json body, as it's a common client-side mistake
74	// TODO: maybe make this configurable or part of "strict" option
75	return {}	4✔
76	}
77
78	if (strict) {	124✔
79	var first = firstchar(body)	122✔
80
81	if (first !== '{' && first !== '[') {	122✔
82	debug('strict violation')	10✔
83	throw createStrictSyntaxError(body, first)	10✔
84	}
85	}
86
87	try {	114✔
88	debug('parse json')	114✔
89	return JSON.parse(body, reviver)	114✔
90	} catch (e) {
91	throw normalizeJsonSyntaxError(e, {	8✔
92	message: e.message,
93	stack: e.stack
94	})
95	}
96	}
97
98	return function jsonParser (req, res, next) {	78✔
99	if (req._body) {	190✔
100	debug('body already parsed')	4✔
101	next()	4✔
102	return	4✔
103	}
104
105	req.body = req.body \|\| {}	186✔
106
107	// skip requests without bodies
108	if (!typeis.hasBody(req)) {	186✔
109	debug('skip empty body')	4✔
110	next()	4✔
111	return	4✔
112	}
113
114	debug('content-type %j', req.headers['content-type'])	182✔
115
116	// determine if request should be parsed
117	if (!shouldParse(req)) {	182✔
118	debug('skip parsing')	12✔
119	next()	12✔
120	return	12✔
121	}
122
123	// assert charset per RFC 7159 sec 8.1
124	var charset = getCharset(req) \|\| 'utf-8'	170✔
125	if (charset.substr(0, 4) !== 'utf-') {	170✔
126	debug('invalid charset')	6✔
127	next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {	6✔
128	charset: charset,
129	type: 'charset.unsupported'
130	}))
131	return	6✔
132	}
133
134	// read
135	read(req, res, next, parse, debug, {	164✔
136	encoding: charset,
137	inflate: inflate,
138	limit: limit,
139	verify: verify
140	})
141	}
142	}
143
144	/**
145	* Create strict violation syntax error matching native error.
146	*
147	* @param {string} str
148	* @param {string} char
149	* @return {Error}
150	* @private
151	*/
152
153	function createStrictSyntaxError (str, char) {
154	var index = str.indexOf(char)	10✔
155	var partial = str.substring(0, index) + '#'	10✔
156
157	try {	10✔
158	JSON.parse(partial); /* istanbul ignore next */ throw new SyntaxError('strict violation')	10✔
159	} catch (e) {
160	return normalizeJsonSyntaxError(e, {	10✔
161	message: e.message.replace('#', char),
162	stack: e.stack
163	})
164	}
165	}
166
167	/**
168	* Get the first non-whitespace character in a string.
169	*
170	* @param {string} str
171	* @return {function}
172	* @private
173	*/
174
175	function firstchar (str) {
176	return FIRST_CHAR_REGEXP.exec(str)[1]	122✔
177	}
178
179	/**
180	* Get the charset of a request.
181	*
182	* @param {object} req
183	* @api private
184	*/
185
186	function getCharset (req) {
187	try {	170✔
188	return (contentType.parse(req).parameters.charset \|\| '').toLowerCase()	170✔
189	} catch (e) {
190	return undefined	2✔
191	}
192	}
193
194	/**
195	* Normalize a SyntaxError for JSON.parse.
196	*
197	* @param {SyntaxError} error
198	* @param {object} obj
199	* @return {SyntaxError}
200	*/
201
202	function normalizeJsonSyntaxError (error, obj) {
203	var keys = Object.getOwnPropertyNames(error)	18✔
204
205	for (var i = 0; i < keys.length; i++) {	18✔
206	var key = keys[i]	36✔
207	if (key !== 'stack' && key !== 'message') {	36!
UNCOV 208	delete error[key]	×
209	}
210	}
211
212	// replace stack before message for Node.js 0.10 and below
213	error.stack = obj.stack.replace(error.message, obj.message)	18✔
214	error.message = obj.message	18✔
215
216	return error	18✔
217	}
218
219	/**
220	* Get the simple type checker.
221	*
222	* @param {string} type
223	* @return {function}
224	*/
225
226	function typeChecker (type) {
227	return function checkType (req) {	72✔
228	return Boolean(typeis(req, type))	178✔
229	}
230	}

expressjs / body-parser / 1586018702

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous