expressjs / body-parser / 752

pending completion

Build # 752

Build Type

Pull #338

travis-ci

Committed by

web-flow

Commit Message

Add String or Number Only JSONString Support

JSON.parse(`"text"`) // "text"
JSON.parse(`123`) // 123

Pull Request Pull Request #338: Add String or Number Only JSONString Support

Run Details

197 of 197 branches covered (100.0%)

Branch coverage included in aggregate %.

348 of 353 relevant lines covered (98.58%)

3538.21 hits per line

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

95.33

/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 {}
    }

    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')	12✔
16	var contentType = require('content-type')	12✔
17	var createError = require('http-errors')	12✔
18	var debug = require('debug')('body-parser:json')	12✔
19	var read = require('../read')	12✔
20	var typeis = require('type-is')	12✔
21
22	/**
23	* Module exports.
24	*/
25
26	module.exports = json	12✔
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	12✔
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) {	12✔
51	var opts = options \|\| {}	480✔
52
53	var limit = typeof opts.limit !== 'number'	480✔
54	? bytes.parse(opts.limit \|\| '100kb')	852✔
55	: opts.limit
56	var inflate = opts.inflate !== false	480✔
57	var reviver = opts.reviver	480✔
58	var strict = opts.strict !== false	480✔
59	var type = opts.type \|\| 'application/json'	480✔
60	var verify = opts.verify \|\| false	480✔
61
62	if (verify !== false && typeof verify !== 'function') {	480✔
63	throw new TypeError('option verify must be function')	12✔
64	}
65
66	// create the appropriate type checking function
67	var shouldParse = typeof type !== 'function'	468✔
68	? typeChecker(type)
69	: type
70
71	function parse (body) {	12✔
72	if (body.length === 0) {	777✔
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 {}	24✔
76	}
77
78	try {	753✔
79	debug('parse json')	753✔
80	return JSON.parse(body, reviver)	753✔
81	} catch (e) {
82	throw normalizeJsonSyntaxError(e, {	48✔
83	message: e.message,
84	stack: e.stack
85	})
86	}
87	}
88
89	return function jsonParser (req, res, next) {	468✔
90	if (req._body) {	1,149✔
91	debug('body already parsed')	24✔
92	next()	24✔
93	return	24✔
94	}
95
96	req.body = req.body \|\| {}	1,125✔
97
98	// skip requests without bodies
99	if (!typeis.hasBody(req)) {	1,125✔
100	debug('skip empty body')	24✔
101	next()	24✔
102	return	24✔
103	}
104
105	debug('content-type %j', req.headers['content-type'])	1,101✔
106
107	// determine if request should be parsed
108	if (!shouldParse(req)) {	1,101✔
109	debug('skip parsing')	72✔
110	next()	72✔
111	return	72✔
112	}
113
114	// assert charset per RFC 7159 sec 8.1
115	var charset = getCharset(req) \|\| 'utf-8'	1,029✔
116	if (charset.substr(0, 4) !== 'utf-') {	1,029✔
117	debug('invalid charset')	36✔
118	next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {	36✔
119	charset: charset,
120	type: 'charset.unsupported'
121	}))
122	return	36✔
123	}
124
125	// read
126	read(req, res, next, parse, debug, {	993✔
127	encoding: charset,
128	inflate: inflate,
129	limit: limit,
130	verify: verify
131	})
132	}
133	}
134
135	/**
136	* Create strict violation syntax error matching native error.
137	*
138	* @param {string} str
139	* @param {string} char
140	* @return {Error}
141	* @private
142	*/
143
144	function createStrictSyntaxError (str, char) {	12✔
145	var index = str.indexOf(char)	×
146	var partial = str.substring(0, index) + '#'	×
147
148	try {	×
149	JSON.parse(partial); /* istanbul ignore next */ throw new SyntaxError('strict violation')	12✔
150	} catch (e) {
151	return normalizeJsonSyntaxError(e, {	×
152	message: e.message.replace('#', char),
153	stack: e.stack
154	})
155	}
156	}
157
158	/**
159	* Get the first non-whitespace character in a string.
160	*
161	* @param {string} str
162	* @return {function}
163	* @private
164	*/
165
166	function firstchar (str) {	12✔
167	return FIRST_CHAR_REGEXP.exec(str)[1]	×
168	}
169
170	/**
171	* Get the charset of a request.
172	*
173	* @param {object} req
174	* @api private
175	*/
176
177	function getCharset (req) {	12✔
178	try {	1,029✔
179	return (contentType.parse(req).parameters.charset \|\| '').toLowerCase()	1,029✔
180	} catch (e) {
181	return undefined	12✔
182	}
183	}
184
185	/**
186	* Normalize a SyntaxError for JSON.parse.
187	*
188	* @param {SyntaxError} error
189	* @param {object} obj
190	* @return {SyntaxError}
191	*/
192
193	function normalizeJsonSyntaxError (error, obj) {	12✔
194	var keys = Object.getOwnPropertyNames(error)	48✔
195
196	for (var i = 0; i < keys.length; i++) {	48✔
197	var key = keys[i]	104✔
198	if (key !== 'stack' && key !== 'message') {	104✔
199	delete error[key]	8✔
200	}
201	}
202
203	// replace stack before message for Node.js 0.10 and below
204	error.stack = obj.stack.replace(error.message, obj.message)	48✔
205	error.message = obj.message	48✔
206
207	return error	48✔
208	}
209
210	/**
211	* Get the simple type checker.
212	*
213	* @param {string} type
214	* @return {function}
215	*/
216
217	function typeChecker (type) {	12✔
218	return function checkType (req) {	432✔
219	return Boolean(typeis(req, type))	1,077✔
220	}
221	}

expressjs / body-parser / 752

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