Generic Body Parser implemented

README.md

@@ -91,16 +91,27 @@ specifies the number of bytes; if it is a string, the value is passed to the
 [bytes](https://www.npmjs.com/package/bytes) library for parsing. Defaults
 to `'100kb'`.
 
+##### parser
+
+The `parser` option is the function called against the request body to convert
+it to a Javascript object. If a `reviver` is supplied, it is supplied as the
+second argument to this function.
+
+```
+parser(body, reviver) -> req.body
+```
+
+Defaults to `JSON.parse`.
+
 ##### reviver
 
-The `reviver` option is passed directly to `JSON.parse` as the second
-argument. You can find more information on this argument
+You can find more information on this argument
 [in the MDN documentation about JSON.parse](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Example.3A_Using_the_reviver_parameter).
 
 ##### strict
 
 When set to `true`, will only accept arrays and objects; when `false` will
-accept anything `JSON.parse` accepts. Defaults to `true`.
+accept anything the `parser` accepts. Defaults to `true`.
 
 ##### type
 
@@ -279,6 +290,16 @@ The `verify` option, if supplied, is called as `verify(req, res, buf, encoding)`
 where `buf` is a `Buffer` of the raw request body and `encoding` is the
 encoding of the request. The parsing can be aborted by throwing an error.
 
+##### parser
+
+The `parser` option, if supplied, is used to in place of the default parser to
+convert the request body into a Javascript object. If this option is supplied,
+both the `extended` and `parameterLimit` options are ignored.
+
+```
+parser(body) -> req.body
+```
+
 ## Errors
 
 The middlewares provided by this module create errors using the

index.js

@@ -81,6 +81,17 @@ Object.defineProperty(exports, 'urlencoded', {
   get: createParserGetter('urlencoded')
 })
 
+/**
+ * Generic parser used to build parsers.
+ * @public
+ */
+
+Object.defineProperty(exports, 'generic', {
+  configurable: true,
+  enumerable: true,
+  get: createParserGetter('generic')
+})
+
 /**
  * Create a middleware to parse json and urlencoded bodies.
  *
@@ -150,6 +161,9 @@ function loadParser (parserName) {
     case 'urlencoded':
       parser = require('./lib/types/urlencoded')
       break
+    case 'generic':
+      parser = require('./lib/generic-parser')
+      break
   }
 
   // store to prevent invoking require()

lib/generic-parser.js

@@ -0,0 +1,168 @@
+/*!
+ * 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:generic')
+var read = require('./read')
+var typeis = require('type-is')
+
+/**
+ * Module exports.
+ */
+
+module.exports = generic
+
+/**
+ * Use this to create a middleware that parses request bodies
+ *
+ * @param {object} [options]
+ * @return {function}
+ * @public
+ */
+
+function generic (parserOptions, parserOverrides) {
+  var opts = {}
+
+  // Squash the options and the overrides down into one object
+  var squashKey
+  for (squashKey in (parserOptions || {})) {
+    if (Object.prototype.hasOwnProperty.call(parserOptions, squashKey)) {
+      opts[squashKey] = parserOptions[squashKey]
+    }
+  }
+  for (squashKey in (parserOverrides || {})) {
+    if (Object.prototype.hasOwnProperty.call(parserOverrides, squashKey)) {
+      opts[squashKey] = parserOverrides[squashKey]
+    }
+  }
+
+  var limit = typeof opts.limit !== 'number'
+    ? bytes.parse(opts.limit || '100kb')
+    : opts.limit
+  var charset = opts.charset
+  var inflate = opts.inflate !== false
+  var verify = opts.verify || false
+  var parse = opts.parse || defaultParse
+  var defaultReqCharset = opts.defaultCharset || 'utf-8'
+  var type = opts.type
+
+  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
+
+  // create the appropriate charset validating function
+  var validCharset = typeof charset !== 'function'
+    ? charsetValidator(charset)
+    : charset
+
+  return function genericParser (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 reqCharset = null
+    if (charset !== undefined) {
+      reqCharset = getCharset(req) || defaultReqCharset
+      if (!validCharset(reqCharset)) {
+        debug('invalid charset')
+        next(createError(415, 'unsupported charset "' + reqCharset.toUpperCase() + '"', {
+          charset: reqCharset,
+          type: 'charset.unsupported'
+        }))
+        return
+      }
+    }
+
+    // read
+    read(req, res, next, parse, debug, {
+      encoding: reqCharset,
+      inflate: inflate,
+      limit: limit,
+      verify: verify
+    })
+  }
+}
+
+function defaultParse (buf) {
+  return buf
+}
+
+/**
+ * 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
+  }
+}
+
+/**
+ * Get the simple type checker.
+ *
+ * @param {string} type
+ * @return {function}
+ */
+
+function typeChecker (type) {
+  return function checkType (req) {
+    return Boolean(typeis(req, type))
+  }
+}
+
+/**
+ * Get the simple charset validator.
+ *
+ * @param {string} type
+ * @return {function}
+ */
+
+function charsetValidator (charset) {
+  return function validateCharset (reqCharset) {
+    return charset === reqCharset
+  }
+}