dgbuilder/dgeflows/node_modules/body-parser/lib/types/urlencoded.js

   1 /*!
   2  * body-parser
   3  * Copyright(c) 2014 Jonathan Ong
   4  * Copyright(c) 2014 Douglas Christopher Wilson
   5  * MIT Licensed
   6  */
   7
   8 /**
   9  * Module dependencies.
  10  */
  11
  12 var bytes = require('bytes')
  13 var deprecate = require('depd')('body-parser')
  14 var read = require('../read')
  15 var typer = require('media-typer')
  16 var typeis = require('type-is')
  17
  18 /**
  19  * Module exports.
  20  */
  21
  22 module.exports = urlencoded
  23
  24 /**
  25  * Cache of parser modules.
  26  */
  27
  28 var parsers = Object.create(null)
  29
  30 /**
  31  * Create a middleware to parse urlencoded bodies.
  32  *
  33  * @param {object} [options]
  34  * @return {function}
  35  * @api public
  36  */
  37
  38 function urlencoded(options){
  39   options = options || {};
  40
  41   // notice because option default will flip in next major
  42   if (options.extended === undefined) {
  43     deprecate('undefined extended: provide extended option')
  44   }
  45
  46   var extended = options.extended !== false
  47   var inflate = options.inflate !== false
  48   var limit = typeof options.limit !== 'number'
  49     ? bytes(options.limit || '100kb')
  50     : options.limit
  51   var type = options.type || 'urlencoded'
  52   var verify = options.verify || false
  53
  54   if (verify !== false && typeof verify !== 'function') {
  55     throw new TypeError('option verify must be function')
  56   }
  57
  58   var queryparse = extended
  59     ? extendedparser(options)
  60     : simpleparser(options)
  61
  62   function parse(body) {
  63     return body.length
  64       ? queryparse(body)
  65       : {}
  66   }
  67
  68   return function urlencodedParser(req, res, next) {
  69     if (req._body) return next();
  70     req.body = req.body || {}
  71
  72     if (!typeis(req, type)) return next();
  73
  74     var charset = (typer.parse(req).parameters.charset || 'utf-8').toLowerCase()
  75     if (charset !== 'utf-8') {
  76       var err = new Error('unsupported charset "' + charset.toUpperCase() + '"')
  77       err.charset = charset
  78       err.status = 415
  79       next(err)
  80       return
  81     }
  82
  83     // read
  84     read(req, res, next, parse, {
  85       encoding: charset,
  86       inflate: inflate,
  87       limit: limit,
  88       verify: verify
  89     })
  90   }
  91 }
  92
  93 /**
  94  * Get the extended query parser.
  95  *
  96  * @param {object} options
  97  */
  98
  99 function extendedparser(options) {
 100   var parameterLimit = options.parameterLimit !== undefined
 101     ? options.parameterLimit
 102     : 1000
 103   var parse = parser('qs')
 104
 105   if (isNaN(parameterLimit) || parameterLimit < 1) {
 106     throw new TypeError('option parameterLimit must be a positive number')
 107   }
 108
 109   if (isFinite(parameterLimit)) {
 110     parameterLimit = parameterLimit | 0
 111   }
 112
 113   return function queryparse(body) {
 114     var paramCount = parameterCount(body, parameterLimit)
 115
 116     if (paramCount === undefined) {
 117       var err = new Error('too many parameters')
 118       err.status = 413
 119       throw err
 120     }
 121
 122     var arrayLimit = Math.max(100, paramCount)
 123
 124     return parse(body, {
 125       arrayLimit: arrayLimit,
 126       parameterLimit: parameterLimit
 127     })
 128   }
 129 }
 130
 131 /**
 132  * Count the number of parameters, stopping once limit reached
 133  *
 134  * @param {string} body
 135  * @param {number} limit
 136  * @api private
 137  */
 138
 139 function parameterCount(body, limit) {
 140   var count = 0
 141   var index = 0
 142
 143   while ((index = body.indexOf('&', index)) !== -1) {
 144     count++
 145     index++
 146
 147     if (count === limit) {
 148       return undefined
 149     }
 150   }
 151
 152   return count
 153 }
 154
 155 /**
 156  * Get parser for module name dynamically.
 157  *
 158  * @param {string} name
 159  * @return {function}
 160  * @api private
 161  */
 162
 163 function parser(name) {
 164   var mod = parsers[name]
 165
 166   if (mod) {
 167     return mod.parse
 168   }
 169
 170   // load module
 171   mod = parsers[name] = require(name)
 172
 173   return mod.parse
 174 }
 175
 176 /**
 177  * Get the simple query parser.
 178  *
 179  * @param {object} options
 180  */
 181
 182 function simpleparser(options) {
 183   var parameterLimit = options.parameterLimit !== undefined
 184     ? options.parameterLimit
 185     : 1000
 186   var parse = parser('querystring')
 187
 188   if (isNaN(parameterLimit) || parameterLimit < 1) {
 189     throw new TypeError('option parameterLimit must be a positive number')
 190   }
 191
 192   if (isFinite(parameterLimit)) {
 193     parameterLimit = parameterLimit | 0
 194   }
 195
 196   return function queryparse(body) {
 197     var paramCount = parameterCount(body, parameterLimit)
 198
 199     if (paramCount === undefined) {
 200       var err = new Error('too many parameters')
 201       err.status = 413
 202       throw err
 203     }
 204
 205     return parse(body, undefined, undefined, {maxKeys: parameterLimit})
 206   }
 207 }