converted urlencoded parser to use generic parser

Author: Shawn Dellysse

lib/types/urlencoded.js

@@ -12,14 +12,10 @@
  * @private
  */
 
-var bytes = require('bytes')
-var contentType = require('content-type')
+var assign = require('object-assign')
 var createError = require('http-errors')
 var debug = require('debug')('body-parser:urlencoded')
-var isFinished = require('on-finished').isFinished
-var read = require('../read')
-var typeis = require('type-is')
-var qs = require('qs')
+var genericParser = require('../generic-parser.js')
 
 /**
  * Module exports.
@@ -34,7 +30,6 @@ module.exports = urlencoded
  * @return {function}
  * @public
  */
-
 function urlencoded (options) {
   var opts = options || {}
 
@@ -44,86 +39,24 @@ function urlencoded (options) {
     ? bytes.parse(opts.limit || '100kb')
     : opts.limit
   var type = opts.type || 'application/x-www-form-urlencoded'
-  var verify = opts.verify || false
-  var charsetSentinel = opts.charsetSentinel
-  var interpretNumericEntities = opts.interpretNumericEntities
-
-  if (verify !== false && typeof verify !== 'function') {
-    throw new TypeError('option verify must be function')
-  }
+  var charset = opts.charset || 'utf-8'
 
-  var defaultCharset = opts.defaultCharset || 'utf-8'
-  if (defaultCharset !== 'utf-8' && defaultCharset !== 'iso-8859-1') {
-    throw new TypeError('option defaultCharset must be either utf-8 or iso-8859-1')
-  }
-
-  // create the appropriate query parser
-  var parser = opts.parser || (
+  var queryparse = opts.parser || (
     extended
     ? extendedparser(opts)
     : simpleparser(opts)
   )
 
-  // create the appropriate type checking function
-  var shouldParse = typeof type !== 'function'
-    ? typeChecker(type)
-    : type
-
-  function parse (body, encoding) {
-    return body.length
-      ? parser(body)
-      : {}
-  }
-
-  return function urlencodedParser (req, res, next) {
-    if (isFinished(req)) {
-      debug('body already parsed')
-      next()
-      return
-    }
-
-    if (!('body' in req)) {
-      req.body = undefined
-    }
-
-    // skip requests without bodies
-    if (!typeis.hasBody(req)) {
-      debug('skip empty body')
-      next()
-      return
-    }
-
-    debug('content-type %j', req.headers['content-type'])
+  return genericParser(assign({}, opts, {
+    type: type,
+    charset: charset,
 
-    // determine if request should be parsed
-    if (!shouldParse(req)) {
-      debug('skip parsing')
-      next()
-      return
+    parse: function parse (buf) {
+      return buf.length
+        ? queryparse(buf)
+        : {}
     }
-
-    // assert charset
-    var charset = getCharset(req) || defaultCharset
-    if (charset !== 'utf-8' && charset !== 'iso-8859-1') {
-      debug('invalid charset')
-      next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {
-        charset: charset,
-        type: 'charset.unsupported'
-      }))
-      return
-    }
-
-    // read
-    read(req, res, next, parse, debug, {
-      debug: debug,
-      encoding: charset,
-      inflate: inflate,
-      limit: limit,
-      verify: verify,
-      charsetSentinel: charsetSentinel,
-      interpretNumericEntities: interpretNumericEntities
-    })
-  }
+  }))
 }
 
 /**
@@ -228,14 +161,67 @@ function parameterCount (body, limit) {
 }
 
 /**
- * Get the simple type checker.
+ * Get parser for module name dynamically.
  *
- * @param {string} type
+ * @param {string} name
  * @return {function}
+ * @api private
  */
 
-function typeChecker (type) {
-  return function checkType (req) {
-    return Boolean(typeis(req, type))
+function parser (name) {
+  var mod = parsers[name]
+
+  if (mod !== undefined) {
+    return mod.parse
+  }
+
+  // this uses a switch for static require analysis
+  switch (name) {
+    case 'qs':
+      mod = require('qs')
+      break
+    case 'querystring':
+      mod = require('querystring')
+      break
+  }
+
+  // store to prevent invoking require()
+  parsers[name] = mod
+
+  return mod.parse
+}
+
+/**
+ * Get the simple query parser.
+ *
+ * @param {object} options
+ */
+
+function simpleparser (options) {
+  var parameterLimit = options.parameterLimit !== undefined
+    ? options.parameterLimit
+    : 1000
+  var parse = parser('querystring')
+
+  if (isNaN(parameterLimit) || parameterLimit < 1) {
+    throw new TypeError('option parameterLimit must be a positive number')
+  }
+
+  if (isFinite(parameterLimit)) {
+    parameterLimit = parameterLimit | 0
+  }
+
+  return function queryparse (body) {
+    var paramCount = parameterCount(body, parameterLimit)
+
+    if (paramCount === undefined) {
+      debug('too many parameters')
+      throw createError(413, 'too many parameters', {
+        type: 'parameters.too.many'
+      })
+    }
+
+    debug('parse urlencoding')
+    return parse(body, undefined, undefined, { maxKeys: parameterLimit })
   }
 }