Comparing version 1.0.11 to 1.0.12
@@ -0,5 +1,13 @@ | ||
1.0.12 / 2020-10-03 | ||
================= | ||
* depds: xprezzo-json-parser update to v1.0.3 | ||
* depds: xprezzo-raw-parser update to v1.0.1 | ||
* depds: xprezzo-text-parser update to v1.0.2 | ||
* depds: xprezzo-urlencoded-parser update to v1.0.1 | ||
1.0.11 / 2020-09-29 | ||
================== | ||
* remove depds of xprezzo-body-parser | ||
* remove depds of xprezzo-body-parser | ||
* add depds xprezzo-json-parser v1.0.2 | ||
@@ -6,0 +14,0 @@ * add depds xprezzo-raw-parser v1.0.0 |
28
index.js
@@ -7,16 +7,16 @@ /*! | ||
'use strict'; | ||
var serveStatic = require("xprezzo-serve-static"); | ||
var buffer = require("xprezzo-buffer"); | ||
var setprototypeof = require("xprezzo-setprototypeof"); | ||
var finalhandler = require('xprezzo-finalhandler'); | ||
'use strict' | ||
const serveStatic = require("xprezzo-serve-static") | ||
const buffer = require("xprezzo-buffer") | ||
const setprototypeof = require("xprezzo-setprototypeof") | ||
const finalhandler = require('xprezzo-finalhandler') | ||
module.exports = require('./lib/xprezzo'); | ||
module.exports.buffer = buffer; | ||
module.exports.debug = serveStatic.debug; | ||
module.exports.finalhandler = finalhandler; | ||
module.exports.mime = serveStatic.mime; | ||
module.exports.mixim = buffer.mixim; | ||
module.exports.ms = serveStatic.ms; | ||
module.exports.send = serveStatic.send; | ||
module.exports.setprototypeof = setprototypeof; | ||
module.exports = require('./lib/xprezzo') | ||
module.exports.buffer = buffer | ||
module.exports.debug = serveStatic.debug | ||
module.exports.finalhandler = finalhandler | ||
module.exports.mime = serveStatic.mime | ||
module.exports.mixim = buffer.mixim | ||
module.exports.ms = serveStatic.ms | ||
module.exports.send = serveStatic.send | ||
module.exports.setprototypeof = setprototypeof |
@@ -14,3 +14,3 @@ /** | ||
var setPrototypeOf = require('xprezzo-setprototypeof') | ||
const setPrototypeOf = require('xprezzo-setprototypeof') | ||
@@ -27,8 +27,8 @@ /** | ||
exports.init = function(app){ | ||
return function xprezzoInit(req, res, next){ | ||
if (app.enabled('x-powered-by')) res.setHeader('X-Powered-By', 'Xprezzo'); | ||
req.res = res; | ||
res.req = req; | ||
req.next = next; | ||
exports.init = (app) => { | ||
return (req, res, next) => { | ||
if (app.enabled('x-powered-by')) res.setHeader('X-Powered-By', 'Xprezzo') | ||
req.res = res | ||
res.req = req | ||
req.next = next | ||
@@ -38,6 +38,6 @@ setPrototypeOf(req, app.request) | ||
res.locals = res.locals || Object.create(null); | ||
res.locals = res.locals || Object.create(null) | ||
next(); | ||
}; | ||
}; | ||
next() | ||
} | ||
} |
@@ -13,5 +13,5 @@ /** | ||
var mixin = require('xprezzo-buffer').mixin | ||
var parseUrl = require('parseurl'); | ||
var qs = require('qs'); | ||
const mixin = require('xprezzo-buffer').mixin | ||
const parseUrl = require('parseurl'); | ||
const qs = require('qs'); | ||
@@ -24,9 +24,9 @@ /** | ||
module.exports = function query(options) { | ||
var opts = mixin({}, options) | ||
var queryparse = qs.parse; | ||
module.exports = (options) => { | ||
let opts = mixin({}, options) | ||
let queryparse = qs.parse | ||
if (typeof options === 'function') { | ||
queryparse = options; | ||
opts = undefined; | ||
queryparse = options | ||
opts = undefined | ||
} | ||
@@ -36,13 +36,13 @@ | ||
// back-compat for qs module | ||
opts.allowPrototypes = true; | ||
opts.allowPrototypes = true | ||
} | ||
return function query(req, res, next){ | ||
return (req, res, next) => { | ||
if (!req.query) { | ||
var val = parseUrl(req).query; | ||
req.query = queryparse(val, opts); | ||
let val = parseUrl(req).query | ||
req.query = queryparse(val, opts) | ||
} | ||
next(); | ||
}; | ||
}; | ||
next() | ||
} | ||
} |
865
lib/proto.js
@@ -7,3 +7,3 @@ /** | ||
'use strict'; | ||
'use strict' | ||
@@ -15,27 +15,21 @@ /** | ||
var finalhandler = require('xprezzo-finalhandler'); | ||
var Router = require('./router'); | ||
var methods = require('methods'); | ||
var middleware = require('./middleware/init'); | ||
var query = require('./middleware/query'); | ||
var debug = require('xprezzo-serve-static').debug('xprezzo:proto'); | ||
var View = require('./view'); | ||
var http = require('http'); | ||
var compileETag = require('./utils').compileETag; | ||
var compileQueryParser = require('./utils').compileQueryParser; | ||
var compileTrust = require('./utils').compileTrust; | ||
var deprecate = require('depd')('xprezzo'); | ||
var { flatten } = require('array-flatten'); | ||
var mixin = require('xprezzo-buffer').mixin; | ||
var resolve = require('path').resolve; | ||
var setPrototypeOf = require('xprezzo-setprototypeof'); | ||
var mixin = require('xprezzo-buffer').mixin; | ||
var slice = Array.prototype.slice; | ||
const finalhandler = require('xprezzo-finalhandler') | ||
const Router = require('./router') | ||
const methods = require('methods') | ||
const middleware = require('./middleware/init') | ||
const query = require('./middleware/query') | ||
const debug = require('xprezzo-serve-static').debug('xprezzo:proto') | ||
const View = require('./view') | ||
const http = require('http') | ||
const compileETag = require('./utils').compileETag | ||
const compileQueryParser = require('./utils').compileQueryParser | ||
const compileTrust = require('./utils').compileTrust | ||
const deprecate = require('depd')('xprezzo') | ||
const { flatten } = require('array-flatten') | ||
const mixin = require('xprezzo-buffer').mixin | ||
const resolve = require('path').resolve | ||
const setPrototypeOf = require('xprezzo-setprototypeof') | ||
const slice = Array.prototype.slice | ||
/** | ||
* Application prototype. | ||
*/ | ||
var app = exports = module.exports = {}; | ||
/** | ||
@@ -46,3 +40,3 @@ * Variable for trust proxy inheritance back-compat | ||
var trustProxyDefaultSymbol = '@@symbol:trust_proxy_default'; | ||
let trustProxyDefaultSymbol = '@@symbol:trust_proxy_default' | ||
@@ -59,427 +53,319 @@ /** | ||
app.init = function init() { | ||
this.cache = {}; | ||
this.engines = {}; | ||
this.settings = {}; | ||
return this.defaultConfiguration(); | ||
}; | ||
let app = { | ||
init: function() { | ||
this.cache = {} | ||
this.engines = {} | ||
this.settings = {} | ||
return this.defaultConfiguration() | ||
}, | ||
defaultConfiguration: function(){ | ||
debug('defaultConfiguration start') | ||
let env = process.env.NODE_ENV || 'development' | ||
// default settings | ||
this.enable('x-powered-by') | ||
.set('etag', 'weak') | ||
.set('env', env) | ||
.set('query parser', 'extended') | ||
.set('subdomain offset', 2) | ||
.set('trust proxy', false) | ||
/** | ||
* Initialize application configuration. | ||
* @private | ||
*/ | ||
// trust proxy inherit back-compat | ||
Object.defineProperty(this.settings, trustProxyDefaultSymbol, { | ||
configurable: true, | ||
value: true | ||
}) | ||
debug('booting in %s mode', env) | ||
this.on('mount', function onmount(parent) { | ||
// inherit trust proxy | ||
if (this.settings[trustProxyDefaultSymbol] === true | ||
&& typeof parent.settings['trust proxy fn'] === 'function') { | ||
delete this.settings['trust proxy'] | ||
delete this.settings['trust proxy fn'] | ||
} | ||
app.defaultConfiguration = function defaultConfiguration() { | ||
debug('defaultConfiguration start'); | ||
var env = process.env.NODE_ENV || 'development'; | ||
// inherit protos | ||
setPrototypeOf(this.request, parent.request) | ||
setPrototypeOf(this.response, parent.response) | ||
setPrototypeOf(this.engines, parent.engines) | ||
setPrototypeOf(this.settings, parent.settings) | ||
}) | ||
// setup locals | ||
this.locals = Object.create(null) | ||
// top-most app is mounted at / | ||
this.mountpath = '/' | ||
// default locals | ||
this.locals.settings = this.settings | ||
// default configuration | ||
this.set('view', View) | ||
.set('views', resolve('views')) | ||
.set('jsonp callback name', 'callback') | ||
if (env === 'production') { | ||
this.enable('view cache') | ||
} | ||
Object.defineProperty(this, 'router', { | ||
get: function() { | ||
throw new Error('\'app.router\' is deprecated!\nPlease see the 3.x to 4.x migration guide for details on how to update your app.') | ||
} | ||
}) | ||
debug('defaultConfiguration done') | ||
return this | ||
}, | ||
lazyrouter: function(){ | ||
debug('lazyrouter start') | ||
if (!this._router) { | ||
debug('call new Router()') | ||
this._router = new Router({ | ||
app: this, | ||
caseSensitive: this.enabled('case sensitive routing'), | ||
strict: this.enabled('strict routing') | ||
}) | ||
debug('call router use()') | ||
this._router.use(query(this.get('query parser fn'))) | ||
debug('call router use()') | ||
this._router.use(middleware.init(this)) | ||
} | ||
debug('lazyrouter done') | ||
return this | ||
}, | ||
handle: function(req, res, callback){ | ||
let router = this._router | ||
debug("handle start") | ||
// final handler | ||
let done = callback || finalhandler(req, res, { | ||
env: this.get('env'), | ||
onerror: function(err) { | ||
if (this.get('env') !== 'test') console.error(err.stack || err.toString()) | ||
return this | ||
}.bind(this) | ||
}) | ||
if (!router) { | ||
// no routes | ||
debug('no routes defined on app') | ||
done() | ||
} else { | ||
router.handle(req, res, done) | ||
} | ||
debug("handle done") | ||
this.emit("done") | ||
return this | ||
}, | ||
use: function(fn){ | ||
debug("use start") | ||
let offset = 0 | ||
let path = '/' | ||
// default path to '/' | ||
// disambiguate app.use([fn]) | ||
this.emit('use') | ||
if (typeof fn !== 'function') { | ||
let arg = fn | ||
while (Array.isArray(arg) && arg.length !== 0) { | ||
arg = arg[0] | ||
} | ||
// default settings | ||
this.enable('x-powered-by'); | ||
this.set('etag', 'weak'); | ||
this.set('env', env); | ||
this.set('query parser', 'extended'); | ||
this.set('subdomain offset', 2); | ||
this.set('trust proxy', false); | ||
// trust proxy inherit back-compat | ||
Object.defineProperty(this.settings, trustProxyDefaultSymbol, { | ||
configurable: true, | ||
value: true | ||
}); | ||
debug('booting in %s mode', env); | ||
this.on('mount', function onmount(parent) { | ||
// inherit trust proxy | ||
if (this.settings[trustProxyDefaultSymbol] === true | ||
&& typeof parent.settings['trust proxy fn'] === 'function') { | ||
delete this.settings['trust proxy']; | ||
delete this.settings['trust proxy fn']; | ||
// first arg is the path | ||
if (typeof arg !== 'function') { | ||
offset = 1 | ||
path = fn | ||
} | ||
} | ||
let fns = flatten(slice.call(arguments, offset)) | ||
// inherit protos | ||
setPrototypeOf(this.request, parent.request) | ||
setPrototypeOf(this.response, parent.response) | ||
setPrototypeOf(this.engines, parent.engines) | ||
setPrototypeOf(this.settings, parent.settings) | ||
}); | ||
// setup locals | ||
this.locals = Object.create(null); | ||
// top-most app is mounted at / | ||
this.mountpath = '/'; | ||
// default locals | ||
this.locals.settings = this.settings; | ||
// default configuration | ||
this.set('view', View); | ||
this.set('views', resolve('views')); | ||
this.set('jsonp callback name', 'callback'); | ||
if (env === 'production') { | ||
this.enable('view cache'); | ||
} | ||
Object.defineProperty(this, 'router', { | ||
get: function() { | ||
throw new Error('\'app.router\' is deprecated!\nPlease see the 3.x to 4.x migration guide for details on how to update your app.'); | ||
if (fns.length === 0) { | ||
throw new TypeError('app.use() requires a middleware function') | ||
} | ||
}); | ||
debug('defaultConfiguration done'); | ||
return this; | ||
}; | ||
// setup router | ||
this.lazyrouter() | ||
let router = this._router | ||
fns.forEach(function (fn) { | ||
// non-express app | ||
if (!fn || !fn.handle || !fn.set) { | ||
return router.use(path, fn) | ||
} | ||
/** | ||
* lazily adds the base router if it has not yet been added. | ||
* | ||
* We cannot add the base router in the defaultConfiguration because | ||
* it reads app settings which might be set after that has run. | ||
* | ||
* @private | ||
*/ | ||
app.lazyrouter = function lazyrouter() { | ||
debug('lazyrouter start'); | ||
if (!this._router) { | ||
debug('call new Router()'); | ||
this._router = new Router({ | ||
app: this, | ||
caseSensitive: this.enabled('case sensitive routing'), | ||
strict: this.enabled('strict routing') | ||
}); | ||
debug('call router use()'); | ||
this._router.use(query(this.get('query parser fn'))); | ||
debug('call router use()'); | ||
this._router.use(middleware.init(this)); | ||
} | ||
debug('lazyrouter done'); | ||
return this; | ||
}; | ||
debug('.use app under %s', path) | ||
fn.mountpath = path | ||
fn.parent = this | ||
/** | ||
* Dispatch a req, res pair into the application. Starts pipeline processing. | ||
* | ||
* If no callback is provided, then default error handlers will respond | ||
* in the event of an error bubbling through the stack. | ||
* | ||
* @private | ||
*/ | ||
// restore .app property on req and res | ||
router.use(path, function mounted_app(req, res, next) { | ||
let orig = req.app | ||
fn.handle(req, res, function (err) { | ||
setPrototypeOf(req, orig.request) | ||
setPrototypeOf(res, orig.response) | ||
next(err) | ||
}) | ||
}) | ||
app.handle = function handle(req, res, callback) { | ||
var router = this._router; | ||
debug("handle start"); | ||
// final handler | ||
var done = callback || finalhandler(req, res, { | ||
env: this.get('env'), | ||
onerror: function(err) { | ||
if (this.get('env') !== 'test') console.error(err.stack || err.toString()); | ||
return this; | ||
}.bind(this) | ||
}); | ||
if (!router) { | ||
// no routes | ||
debug('no routes defined on app'); | ||
done(); | ||
} else { | ||
router.handle(req, res, done); | ||
} | ||
debug("handle done"); | ||
this.emit("done") | ||
return this; | ||
}; | ||
/** | ||
* Proxy `Router#use()` to add middleware to the app router. | ||
* See Router#use() documentation for details. | ||
* | ||
* If the _fn_ parameter is an express app, then it will be | ||
* mounted at the _route_ specified. | ||
* | ||
* @public | ||
*/ | ||
app.use = function use(fn) { | ||
debug("use start"); | ||
var offset = 0; | ||
var path = '/'; | ||
// default path to '/' | ||
// disambiguate app.use([fn]) | ||
this.emit('use'); | ||
if (typeof fn !== 'function') { | ||
var arg = fn; | ||
while (Array.isArray(arg) && arg.length !== 0) { | ||
arg = arg[0]; | ||
// mounted an app | ||
fn.emit('mount', this) | ||
}, this) | ||
debug("use done") | ||
return this | ||
}, | ||
route: function(path){ | ||
this.lazyrouter() | ||
return this._router.route(path) | ||
}, | ||
engine: function (ext, fn){ | ||
if (typeof fn !== 'function') { | ||
throw new Error('callback function required') | ||
} | ||
// first arg is the path | ||
if (typeof arg !== 'function') { | ||
offset = 1; | ||
path = fn; | ||
// get file extension | ||
let extension = ext[0] !== '.' | ||
? '.' + ext | ||
: ext | ||
// store engine | ||
this.engines[extension] = fn | ||
return this | ||
}, | ||
param: function(name, fn){ | ||
this.lazyrouter() | ||
if (Array.isArray(name)) { | ||
for (let i = 0 ;i < name.length; i++) { | ||
this.param(name[i], fn) | ||
} | ||
return this | ||
} | ||
} | ||
this._router.param(name, fn) | ||
return this | ||
}, | ||
set: function(setting, val){ | ||
if (arguments.length === 1) { | ||
// app.get(setting) | ||
return this.settings[setting] | ||
} | ||
var fns = flatten(slice.call(arguments, offset)); | ||
debug('set "%s" to %o', setting, val) | ||
if (fns.length === 0) { | ||
throw new TypeError('app.use() requires a middleware function') | ||
} | ||
// set value | ||
this.settings[setting] = val | ||
// setup router | ||
this.lazyrouter(); | ||
var router = this._router; | ||
fns.forEach(function (fn) { | ||
// non-express app | ||
if (!fn || !fn.handle || !fn.set) { | ||
return router.use(path, fn); | ||
// trigger matched settings | ||
switch (setting) { | ||
case 'etag': | ||
this.set('etag fn', compileETag(val)) | ||
break | ||
case 'query parser': | ||
this.set('query parser fn', compileQueryParser(val)) | ||
break | ||
case 'trust proxy': | ||
this.set('trust proxy fn', compileTrust(val)) | ||
// trust proxy inherit back-compat | ||
Object.defineProperty(this.settings, trustProxyDefaultSymbol, { | ||
configurable: true, | ||
value: false | ||
}) | ||
break | ||
} | ||
return this | ||
}, | ||
path: function() { | ||
return this.parent | ||
? this.parent.path() + this.mountpath | ||
: '' | ||
}, | ||
enabled: function(setting) { | ||
return Boolean(this.set(setting)) | ||
}, | ||
disabled: function (setting){ | ||
return !this.set(setting) | ||
}, | ||
enable: function(setting){ | ||
this.set(setting, true) | ||
return this | ||
}, | ||
disable: function (setting) { | ||
return this.set(setting, false) | ||
}, | ||
all: function(path){ | ||
this.lazyrouter() | ||
debug('.use app under %s', path); | ||
fn.mountpath = path; | ||
fn.parent = this; | ||
let route = this._router.route(path) | ||
let args = slice.call(arguments, 1) | ||
// restore .app property on req and res | ||
router.use(path, function mounted_app(req, res, next) { | ||
var orig = req.app; | ||
fn.handle(req, res, function (err) { | ||
setPrototypeOf(req, orig.request) | ||
setPrototypeOf(res, orig.response) | ||
next(err); | ||
}); | ||
}); | ||
for (let i = 0; i < methods.length; i++) { | ||
route[methods[i]].apply(route, args); | ||
} | ||
// mounted an app | ||
fn.emit('mount', this); | ||
}, this); | ||
debug("use done"); | ||
return this; | ||
}; | ||
return this | ||
}, | ||
render: function(name, options, callback) { | ||
let cache = this.cache | ||
let done = callback | ||
let engines = this.engines | ||
let opts = options | ||
let renderOptions = {} | ||
let view | ||
/** | ||
* Proxy to the app `Router#route()` | ||
* Returns a new `Route` instance for the _path_. | ||
* | ||
* Routes are isolated middleware stacks for specific paths. | ||
* See the Route api docs for details. | ||
* | ||
* @public | ||
*/ | ||
// support callback function as second arg | ||
if (typeof options === 'function') { | ||
done = options | ||
opts = {} | ||
} | ||
app.route = function route(path) { | ||
this.lazyrouter(); | ||
return this._router.route(path); | ||
}; | ||
// mixin app.locals, options | ||
mixin(renderOptions, this.locals) | ||
/** | ||
* Register the given template engine callback `fn` | ||
* as `ext`. | ||
* | ||
* By default will `require()` the engine based on the | ||
* file extension. For example if you try to render | ||
* a "foo.ejs" file Express will invoke the following internally: | ||
* | ||
* app.engine('ejs', require('ejs').__express); | ||
* | ||
* For engines that do not provide `.__express` out of the box, | ||
* or if you wish to "map" a different extension to the template engine | ||
* you may use this method. For example mapping the EJS template engine to | ||
* ".html" files: | ||
* | ||
* app.engine('html', require('ejs').renderFile); | ||
* | ||
* In this case EJS provides a `.renderFile()` method with | ||
* the same signature that Express expects: `(path, options, callback)`, | ||
* though note that it aliases this method as `ejs.__express` internally | ||
* so if you're using ".ejs" extensions you dont need to do anything. | ||
* | ||
* Some template engines do not follow this convention, the | ||
* [Consolidate.js](https://github.com/tj/consolidate.js) | ||
* library was created to map all of node's popular template | ||
* engines to follow this convention, thus allowing them to | ||
* work seamlessly within Express. | ||
* | ||
* @param {String} ext | ||
* @param {Function} fn | ||
* @return {app} for chaining | ||
* @public | ||
*/ | ||
// mixin options._locals | ||
if (opts._locals) { | ||
mixin(renderOptions, opts._locals) | ||
} | ||
app.engine = function engine(ext, fn) { | ||
if (typeof fn !== 'function') { | ||
throw new Error('callback function required'); | ||
} | ||
// mixin | ||
mixin(renderOptions, opts) | ||
// get file extension | ||
var extension = ext[0] !== '.' | ||
? '.' + ext | ||
: ext; | ||
// set .cache unless explicitly provided | ||
if (renderOptions.cache == null) { | ||
renderOptions.cache = this.enabled('view cache') | ||
} | ||
// store engine | ||
this.engines[extension] = fn; | ||
// primed cache | ||
if (renderOptions.cache) { | ||
view = cache[name] | ||
} | ||
return this; | ||
}; | ||
// view | ||
if (!view) { | ||
let View = this.get('view') | ||
/** | ||
* Proxy to `Router#param()` with one added api feature. The _name_ parameter | ||
* can be an array of names. | ||
* | ||
* See the Router#param() docs for more details. | ||
* | ||
* @param {String|Array} name | ||
* @param {Function} fn | ||
* @return {app} for chaining | ||
* @public | ||
*/ | ||
view = new View(name, { | ||
defaultEngine: this.get('view engine'), | ||
root: this.get('views'), | ||
engines: engines | ||
}) | ||
app.param = function param(name, fn) { | ||
this.lazyrouter(); | ||
if (!view.path) { | ||
let dirs = Array.isArray(view.root) && view.root.length > 1 | ||
? 'directories "' + view.root.slice(0, -1).join('", "') + '" or "' + view.root[view.root.length - 1] + '"' | ||
: 'directory "' + view.root + '"' | ||
let err = new Error('Failed to lookup view "' + name + '" in views ' + dirs) | ||
err.view = view | ||
return done(err) | ||
} | ||
if (Array.isArray(name)) { | ||
for (var i = 0; i < name.length; i++) { | ||
this.param(name[i], fn); | ||
// prime the cache | ||
if (renderOptions.cache) { | ||
cache[name] = view | ||
} | ||
} | ||
// render | ||
(function (view, options, callback) { | ||
try { | ||
view.render(options, callback) | ||
} catch (err) { | ||
callback(err) | ||
} | ||
})(view, renderOptions, done) | ||
return this; | ||
return this | ||
}, | ||
listen: function() { | ||
debug("beforeListen") | ||
this.emit("beforeListen") | ||
let server = http.createServer(this) | ||
return server.listen.apply(server, arguments) | ||
} | ||
} | ||
this._router.param(name, fn); | ||
return this; | ||
}; | ||
/** | ||
* Assign `setting` to `val`, or return `setting`'s value. | ||
* | ||
* app.set('foo', 'bar'); | ||
* app.set('foo'); | ||
* // => "bar" | ||
* | ||
* Mounted servers inherit their parent server's settings. | ||
* | ||
* @param {String} setting | ||
* @param {*} [val] | ||
* @return {Server} for chaining | ||
* @public | ||
*/ | ||
app.set = function set(setting, val) { | ||
if (arguments.length === 1) { | ||
// app.get(setting) | ||
return this.settings[setting]; | ||
} | ||
debug('set "%s" to %o', setting, val); | ||
// set value | ||
this.settings[setting] = val; | ||
// trigger matched settings | ||
switch (setting) { | ||
case 'etag': | ||
this.set('etag fn', compileETag(val)); | ||
break; | ||
case 'query parser': | ||
this.set('query parser fn', compileQueryParser(val)); | ||
break; | ||
case 'trust proxy': | ||
this.set('trust proxy fn', compileTrust(val)); | ||
// trust proxy inherit back-compat | ||
Object.defineProperty(this.settings, trustProxyDefaultSymbol, { | ||
configurable: true, | ||
value: false | ||
}); | ||
break; | ||
} | ||
return this; | ||
}; | ||
/** | ||
* Return the app's absolute pathname | ||
* based on the parent(s) that have | ||
* mounted it. | ||
* | ||
* For example if the application was | ||
* mounted as "/admin", which itself | ||
* was mounted as "/blog" then the | ||
* return value would be "/blog/admin". | ||
* | ||
* @return {String} | ||
* @private | ||
*/ | ||
app.path = function path() { | ||
return this.parent | ||
? this.parent.path() + this.mountpath | ||
: ''; | ||
}; | ||
/** | ||
* Check if `setting` is enabled (truthy). | ||
* | ||
* app.enabled('foo') | ||
* // => false | ||
* | ||
* app.enable('foo') | ||
* app.enabled('foo') | ||
* // => true | ||
* | ||
* @param {String} setting | ||
* @return {Boolean} | ||
* @public | ||
*/ | ||
app.enabled = function enabled(setting) { | ||
return Boolean(this.set(setting)); | ||
}; | ||
/** | ||
* Check if `setting` is disabled. | ||
* | ||
* app.disabled('foo') | ||
* // => true | ||
* | ||
* app.enable('foo') | ||
* app.disabled('foo') | ||
* // => false | ||
* | ||
* @param {String} setting | ||
* @return {Boolean} | ||
* @public | ||
*/ | ||
app.disabled = function disabled(setting) { | ||
return !this.set(setting); | ||
}; | ||
/** | ||
* Enable `setting`. | ||
* | ||
* @param {String} setting | ||
* @return {app} for chaining | ||
* @public | ||
*/ | ||
app.enable = function enable(setting) { | ||
return this.set(setting, true); | ||
}; | ||
/** | ||
* Disable `setting`. | ||
* | ||
* @param {String} setting | ||
* @return {app} for chaining | ||
* @public | ||
*/ | ||
app.disable = function disable(setting) { | ||
return this.set(setting, false); | ||
}; | ||
/** | ||
* Delegate `.VERB(...)` calls to `router.VERB(...)`. | ||
@@ -492,12 +378,12 @@ */ | ||
// app.get(setting) | ||
return this.set(path); | ||
return this.set(path) | ||
} | ||
this.lazyrouter(); | ||
this.lazyrouter() | ||
var route = this._router.route(path); | ||
route[method].apply(route, slice.call(arguments, 1)); | ||
return this; | ||
}; | ||
}); | ||
let route = this._router.route(path) | ||
route[method].apply(route, slice.call(arguments, 1)) | ||
return this | ||
} | ||
}) | ||
@@ -514,133 +400,6 @@ /** | ||
app.all = function all(path) { | ||
this.lazyrouter(); | ||
var route = this._router.route(path); | ||
var args = slice.call(arguments, 1); | ||
for (var i = 0; i < methods.length; i++) { | ||
route[methods[i]].apply(route, args); | ||
} | ||
return this; | ||
}; | ||
// del -> delete alias | ||
app.del = deprecate.function(app.delete, 'app.del: Use app.delete instead'); | ||
app.del = deprecate.function(app.delete, 'app.del: Use app.delete instead') | ||
/** | ||
* Render the given view `name` name with `options` | ||
* and a callback accepting an error and the | ||
* rendered template string. | ||
* | ||
* Example: | ||
* | ||
* app.render('email', { name: 'Tobi' }, function(err, html){ | ||
* // ... | ||
* }) | ||
* | ||
* @param {String} name | ||
* @param {Object|Function} options or fn | ||
* @param {Function} callback | ||
* @public | ||
*/ | ||
app.render = function render(name, options, callback) { | ||
var cache = this.cache; | ||
var done = callback; | ||
var engines = this.engines; | ||
var opts = options; | ||
var renderOptions = {}; | ||
var view; | ||
// support callback function as second arg | ||
if (typeof options === 'function') { | ||
done = options; | ||
opts = {}; | ||
} | ||
// mixin app.locals, options | ||
mixin(renderOptions, this.locals); | ||
// mixin options._locals | ||
if (opts._locals) { | ||
mixin(renderOptions, opts._locals); | ||
} | ||
// mixin | ||
mixin(renderOptions, opts); | ||
// set .cache unless explicitly provided | ||
if (renderOptions.cache == null) { | ||
renderOptions.cache = this.enabled('view cache'); | ||
} | ||
// primed cache | ||
if (renderOptions.cache) { | ||
view = cache[name]; | ||
} | ||
// view | ||
if (!view) { | ||
var View = this.get('view'); | ||
view = new View(name, { | ||
defaultEngine: this.get('view engine'), | ||
root: this.get('views'), | ||
engines: engines | ||
}); | ||
if (!view.path) { | ||
var dirs = Array.isArray(view.root) && view.root.length > 1 | ||
? 'directories "' + view.root.slice(0, -1).join('", "') + '" or "' + view.root[view.root.length - 1] + '"' | ||
: 'directory "' + view.root + '"' | ||
var err = new Error('Failed to lookup view "' + name + '" in views ' + dirs); | ||
err.view = view; | ||
return done(err); | ||
} | ||
// prime the cache | ||
if (renderOptions.cache) { | ||
cache[name] = view; | ||
} | ||
} | ||
// render | ||
(function (view, options, callback) { | ||
try { | ||
view.render(options, callback); | ||
} catch (err) { | ||
callback(err); | ||
} | ||
})(view, renderOptions, done); | ||
return this; | ||
}; | ||
/** | ||
* Listen for connections. | ||
* | ||
* A node `http.Server` is returned, with this | ||
* application (which is a `Function`) as its | ||
* callback. If you wish to create both an HTTP | ||
* and HTTPS server you may do so with the "http" | ||
* and "https" modules as shown here: | ||
* | ||
* var http = require('http') | ||
* , https = require('https') | ||
* , express = require('express') | ||
* , app = express(); | ||
* | ||
* http.createServer(app).listen(80); | ||
* https.createServer({ ... }, app).listen(443); | ||
* | ||
* @return {http.Server} | ||
* @public | ||
*/ | ||
app.listen = function listen() { | ||
debug("beforeListen"); | ||
this.emit("beforeListen"); | ||
var server = http.createServer(this); | ||
return server.listen.apply(server, arguments); | ||
}; | ||
module.exports = app |
@@ -14,11 +14,11 @@ /** | ||
var accepts = require('accepts'); | ||
var deprecate = require('depd')('xprezzo'); | ||
var isIP = require('net').isIP; | ||
var typeis = require('type-is'); | ||
var http = require('http'); | ||
var fresh = require('fresh'); | ||
var parseRange = require('range-parser'); | ||
var parse = require('parseurl'); | ||
var proxyaddr = require('proxy-addr'); | ||
const accepts = require('accepts'); | ||
const deprecate = require('depd')('xprezzo'); | ||
const isIP = require('net').isIP; | ||
const typeis = require('type-is'); | ||
const http = require('http'); | ||
const fresh = require('fresh'); | ||
const parseRange = require('range-parser'); | ||
const parse = require('parseurl'); | ||
const proxyaddr = require('proxy-addr'); | ||
@@ -30,3 +30,3 @@ /** | ||
var req = Object.create(http.IncomingMessage.prototype) | ||
const req = Object.create(http.IncomingMessage.prototype) | ||
@@ -73,3 +73,3 @@ /** | ||
var lc = name.toLowerCase(); | ||
let lc = name.toLowerCase(); | ||
@@ -134,3 +134,3 @@ switch (lc) { | ||
req.accepts = function(){ | ||
var accept = accepts(this); | ||
let accept = accepts(this); | ||
return accept.types.apply(accept, arguments); | ||
@@ -148,3 +148,3 @@ }; | ||
req.acceptsEncodings = function(){ | ||
var accept = accepts(this); | ||
let accept = accepts(this); | ||
return accept.encodings.apply(accept, arguments); | ||
@@ -166,3 +166,3 @@ }; | ||
req.acceptsCharsets = function(){ | ||
var accept = accepts(this); | ||
let accept = accepts(this); | ||
return accept.charsets.apply(accept, arguments); | ||
@@ -184,3 +184,3 @@ }; | ||
req.acceptsLanguages = function(){ | ||
var accept = accepts(this); | ||
let accept = accepts(this); | ||
return accept.languages.apply(accept, arguments); | ||
@@ -218,3 +218,3 @@ }; | ||
req.range = function range(size, options) { | ||
var range = this.get('Range'); | ||
let range = this.get('Range'); | ||
if (!range) return; | ||
@@ -242,7 +242,7 @@ return parseRange(size, range, options); | ||
req.param = function param(name, defaultValue) { | ||
var params = this.params || {}; | ||
var body = this.body || {}; | ||
var query = this.query || {}; | ||
let params = this.params || {}; | ||
let body = this.body || {}; | ||
let query = this.query || {}; | ||
var args = arguments.length === 1 | ||
let args = arguments.length === 1 | ||
? 'name' | ||
@@ -286,3 +286,3 @@ : 'name, default'; | ||
req.is = function is(types) { | ||
var arr = types; | ||
let arr = types; | ||
@@ -292,3 +292,3 @@ // support flattened arguments | ||
arr = new Array(arguments.length); | ||
for (var i = 0; i < arr.length; i++) { | ||
for (let i = 0; i < arr.length; i++) { | ||
arr[i] = arguments[i]; | ||
@@ -316,6 +316,6 @@ } | ||
defineGetter(req, 'protocol', function protocol(){ | ||
var proto = this.connection.encrypted | ||
let proto = this.connection.encrypted | ||
? 'https' | ||
: 'http'; | ||
var trust = this.app.get('trust proxy fn'); | ||
let trust = this.app.get('trust proxy fn'); | ||
@@ -328,4 +328,4 @@ if (!trust(this.connection.remoteAddress, 0)) { | ||
// single value, but this is to be safe. | ||
var header = this.get('X-Forwarded-Proto') || proto | ||
var index = header.indexOf(',') | ||
let header = this.get('X-Forwarded-Proto') || proto | ||
let index = header.indexOf(',') | ||
@@ -361,3 +361,3 @@ return index !== -1 | ||
defineGetter(req, 'ip', function ip(){ | ||
var trust = this.app.get('trust proxy fn'); | ||
let trust = this.app.get('trust proxy fn'); | ||
return proxyaddr(this, trust); | ||
@@ -379,4 +379,4 @@ }); | ||
defineGetter(req, 'ips', function ips() { | ||
var trust = this.app.get('trust proxy fn'); | ||
var addrs = proxyaddr.all(this, trust); | ||
let trust = this.app.get('trust proxy fn'); | ||
let addrs = proxyaddr.all(this, trust); | ||
@@ -406,8 +406,8 @@ // reverse the order (to farthest -> closest) | ||
defineGetter(req, 'subdomains', function subdomains() { | ||
var hostname = this.hostname; | ||
let hostname = this.hostname; | ||
if (!hostname) return []; | ||
var offset = this.app.get('subdomain offset'); | ||
var subdomains = !isIP(hostname) | ||
let offset = this.app.get('subdomain offset'); | ||
let subdomains = !isIP(hostname) | ||
? hostname.split('.').reverse() | ||
@@ -442,4 +442,4 @@ : [hostname]; | ||
defineGetter(req, 'hostname', function hostname(){ | ||
var trust = this.app.get('trust proxy fn'); | ||
var host = this.get('X-Forwarded-Host'); | ||
let trust = this.app.get('trust proxy fn'); | ||
let host = this.get('X-Forwarded-Host'); | ||
@@ -457,6 +457,6 @@ if (!host || !trust(this.connection.remoteAddress, 0)) { | ||
// IPv6 literal support | ||
var offset = host[0] === '[' | ||
let offset = host[0] === '[' | ||
? host.indexOf(']') + 1 | ||
: 0; | ||
var index = host.indexOf(':', offset); | ||
let index = host.indexOf(':', offset); | ||
@@ -484,5 +484,5 @@ return index !== -1 | ||
defineGetter(req, 'fresh', function(){ | ||
var method = this.method; | ||
var res = this.res | ||
var status = res.statusCode | ||
let method = this.method; | ||
let res = this.res | ||
let status = res.statusCode | ||
@@ -524,3 +524,3 @@ // GET or HEAD for weak freshness validation only | ||
defineGetter(req, 'xhr', function xhr(){ | ||
var val = this.get('X-Requested-With') || ''; | ||
let val = this.get('X-Requested-With') || ''; | ||
return val.toLowerCase() === 'xmlhttprequest'; | ||
@@ -527,0 +527,0 @@ }); |
@@ -14,23 +14,23 @@ /** | ||
var Buffer = require('xprezzo-buffer').Buffer | ||
var contentDisposition = require('content-disposition'); | ||
var deprecate = require('depd')('xprezzo'); | ||
var encodeUrl = require('encodeurl'); | ||
var escapeHtml = require('escape-html'); | ||
var http = require('http'); | ||
var isAbsolute = require('./utils').isAbsolute; | ||
var onFinished = require('xprezzo-on-finished'); | ||
var path = require('path'); | ||
var statuses = require('statuses') | ||
var mixin = require('xprezzo-buffer').mixin; | ||
var sign = require('cookie-signature').sign; | ||
var normalizeType = require('./utils').normalizeType; | ||
var normalizeTypes = require('./utils').normalizeTypes; | ||
var setCharset = require('./utils').setCharset; | ||
var cookie = require('cookie'); | ||
var send = require('xprezzo-send'); | ||
var extname = path.extname; | ||
var mime = send.mime; | ||
var resolve = path.resolve; | ||
var vary = require('vary'); | ||
const Buffer = require('xprezzo-buffer').Buffer | ||
const contentDisposition = require('content-disposition'); | ||
const deprecate = require('depd')('xprezzo'); | ||
const encodeUrl = require('encodeurl'); | ||
const escapeHtml = require('escape-html'); | ||
const http = require('http'); | ||
const isAbsolute = require('./utils').isAbsolute; | ||
const onFinished = require('xprezzo-on-finished'); | ||
const path = require('path'); | ||
const statuses = require('statuses') | ||
const mixin = require('xprezzo-buffer').mixin; | ||
const sign = require('cookie-signature').sign; | ||
const normalizeType = require('./utils').normalizeType; | ||
const normalizeTypes = require('./utils').normalizeTypes; | ||
const setCharset = require('./utils').setCharset; | ||
const cookie = require('cookie'); | ||
const send = require('xprezzo-send'); | ||
const extname = path.extname; | ||
const mime = send.mime; | ||
const resolve = path.resolve; | ||
const vary = require('vary'); | ||
@@ -56,3 +56,3 @@ /** | ||
var charsetRegExp = /;\s*charset\s*=/; | ||
let charsetRegExp = /;\s*charset\s*=/; | ||
@@ -88,3 +88,3 @@ /** | ||
res.links = function(links){ | ||
var link = this.get('Link') || ''; | ||
let link = this.get('Link') || ''; | ||
if (link) link += ', '; | ||
@@ -110,9 +110,9 @@ return this.set('Link', link + Object.keys(links).map(function(rel){ | ||
res.send = function send(body) { | ||
var chunk = body; | ||
var encoding; | ||
var req = this.req; | ||
var type; | ||
let chunk = body; | ||
let encoding; | ||
let req = this.req; | ||
let type; | ||
// settings | ||
var app = this.app; | ||
let app = this.app; | ||
@@ -178,7 +178,7 @@ // allow status / body | ||
// determine if ETag should be generated | ||
var etagFn = app.get('etag fn') | ||
var generateETag = !this.get('ETag') && typeof etagFn === 'function' | ||
let etagFn = app.get('etag fn') | ||
let generateETag = !this.get('ETag') && typeof etagFn === 'function' | ||
// populate Content-Length | ||
var len | ||
let len | ||
if (chunk !== undefined) { | ||
@@ -202,3 +202,3 @@ if (Buffer.isBuffer(chunk)) { | ||
// populate ETag | ||
var etag; | ||
let etag; | ||
if (generateETag && len !== undefined) { | ||
@@ -245,3 +245,3 @@ if ((etag = etagFn(chunk, encoding))) { | ||
res.json = function json(obj) { | ||
var val = obj; | ||
let val = obj; | ||
@@ -262,7 +262,7 @@ // allow status / body | ||
// settings | ||
var app = this.app; | ||
var escape = app.get('json escape') | ||
var replacer = app.get('json replacer'); | ||
var spaces = app.get('json spaces'); | ||
var body = stringify(val, replacer, spaces, escape) | ||
let app = this.app; | ||
let escape = app.get('json escape') | ||
let replacer = app.get('json replacer'); | ||
let spaces = app.get('json spaces'); | ||
let body = stringify(val, replacer, spaces, escape) | ||
@@ -290,3 +290,3 @@ // content-type | ||
res.jsonp = function jsonp(obj) { | ||
var val = obj; | ||
let val = obj; | ||
@@ -307,8 +307,8 @@ // allow status / body | ||
// settings | ||
var app = this.app; | ||
var escape = app.get('json escape') | ||
var replacer = app.get('json replacer'); | ||
var spaces = app.get('json spaces'); | ||
var body = stringify(val, replacer, spaces, escape) | ||
var callback = this.req.query[app.get('jsonp callback name')]; | ||
let app = this.app; | ||
let escape = app.get('json escape') | ||
let replacer = app.get('json replacer'); | ||
let spaces = app.get('json spaces'); | ||
let body = stringify(val, replacer, spaces, escape) | ||
let callback = this.req.query[app.get('jsonp callback name')]; | ||
@@ -363,3 +363,3 @@ // content-type | ||
res.sendStatus = function sendStatus(statusCode) { | ||
var body = statuses.message[statusCode] || String(statusCode) | ||
let body = statuses.message[statusCode] || String(statusCode) | ||
@@ -398,3 +398,3 @@ this.statusCode = statusCode; | ||
* app.get('/user/:uid/photos/:file', function(req, res){ | ||
* var uid = req.params.uid | ||
* let uid = req.params.uid | ||
* , file = req.params.file; | ||
@@ -415,7 +415,7 @@ * | ||
res.sendFile = function sendFile(path, options, callback) { | ||
var done = callback; | ||
var req = this.req; | ||
var res = this; | ||
var next = req.next; | ||
var opts = options || {}; | ||
let done = callback; | ||
let req = this.req; | ||
let res = this; | ||
let next = req.next; | ||
let opts = options || {}; | ||
@@ -441,4 +441,4 @@ if (!path) { | ||
// create file stream | ||
var pathname = encodeURI(path); | ||
var file = send(req, pathname, opts); | ||
let pathname = encodeURI(path); | ||
let file = send(req, pathname, opts); | ||
@@ -484,3 +484,3 @@ // transfer | ||
* app.get('/user/:uid/photos/:file', function(req, res){ | ||
* var uid = req.params.uid | ||
* let uid = req.params.uid | ||
* , file = req.params.file; | ||
@@ -501,7 +501,7 @@ * | ||
res.sendfile = function (path, options, callback) { | ||
var done = callback; | ||
var req = this.req; | ||
var res = this; | ||
var next = req.next; | ||
var opts = options || {}; | ||
let done = callback; | ||
let req = this.req; | ||
let res = this; | ||
let next = req.next; | ||
let opts = options || {}; | ||
@@ -515,3 +515,3 @@ // support function as second arg | ||
// create file stream | ||
var file = send(req, path, opts); | ||
let file = send(req, path, opts); | ||
@@ -553,5 +553,5 @@ // transfer | ||
res.download = function download (path, filename, options, callback) { | ||
var done = callback; | ||
var name = filename; | ||
var opts = options || null | ||
let done = callback; | ||
let name = filename; | ||
let opts = options || null | ||
@@ -569,3 +569,3 @@ // support function as second or third arg | ||
// set Content-Disposition when file is sent | ||
var headers = { | ||
let headers = { | ||
'Content-Disposition': contentDisposition(name || path) | ||
@@ -576,5 +576,5 @@ }; | ||
if (opts && opts.headers) { | ||
var keys = Object.keys(opts.headers) | ||
for (var i = 0; i < keys.length; i++) { | ||
var key = keys[i] | ||
let keys = Object.keys(opts.headers) | ||
for (let i = 0; i < keys.length; i++) { | ||
let key = keys[i] | ||
if (key.toLowerCase() !== 'content-disposition') { | ||
@@ -591,3 +591,3 @@ headers[key] = opts.headers[key] | ||
// Resolve the full path for sendFile | ||
var fullPath = resolve(path); | ||
let fullPath = resolve(path); | ||
@@ -617,3 +617,3 @@ // send file | ||
res.type = function contentType(type) { | ||
var ct = type.indexOf('/') === -1 | ||
let ct = type.indexOf('/') === -1 | ||
? mime.lookup(type) | ||
@@ -683,10 +683,10 @@ : type; | ||
res.format = function(obj){ | ||
var req = this.req; | ||
var next = req.next; | ||
let req = this.req; | ||
let next = req.next; | ||
var fn = obj.default; | ||
let fn = obj.default; | ||
if (fn) delete obj.default; | ||
var keys = Object.keys(obj); | ||
let keys = Object.keys(obj); | ||
var key = keys.length > 0 | ||
let key = keys.length > 0 | ||
? req.accepts(keys) | ||
@@ -703,3 +703,3 @@ : false; | ||
} else { | ||
var err = new Error('Not Acceptable'); | ||
let err = new Error('Not Acceptable'); | ||
err.status = err.statusCode = 406; | ||
@@ -747,4 +747,4 @@ err.types = normalizeTypes(keys).map(function(o){ return o.value }); | ||
res.append = function append(field, val) { | ||
var prev = this.get(field); | ||
var value = val; | ||
let prev = this.get(field); | ||
let value = val; | ||
@@ -781,3 +781,3 @@ if (prev) { | ||
if (arguments.length === 2) { | ||
var value = Array.isArray(val) | ||
let value = Array.isArray(val) | ||
? val.map(String) | ||
@@ -792,3 +792,3 @@ : String(val); | ||
if (!charsetRegExp.test(value)) { | ||
var charset = mime.charsets.lookup(value.split(';')[0]); | ||
let charset = mime.charsets.lookup(value.split(';')[0]); | ||
if (charset) value += '; charset=' + charset.toLowerCase(); | ||
@@ -800,3 +800,3 @@ } | ||
} else { | ||
for (var key in field) { | ||
for (let key in field) { | ||
this.set(key, field[key]); | ||
@@ -830,3 +830,3 @@ } | ||
res.clearCookie = function clearCookie(name, options) { | ||
var opts = mixin({ expires: new Date(1), path: '/' }, options); | ||
let opts = mixin({ expires: new Date(1), path: '/' }, options); | ||
@@ -861,5 +861,5 @@ return this.cookie(name, '', opts); | ||
res.cookie = function (name, value, options) { | ||
var opts = mixin({}, options); | ||
var secret = this.req.secret; | ||
var signed = opts.signed; | ||
let opts = mixin({}, options); | ||
let secret = this.req.secret; | ||
let signed = opts.signed; | ||
@@ -870,3 +870,3 @@ if (signed && !secret) { | ||
var val = typeof value === 'object' | ||
let val = typeof value === 'object' | ||
? 'j:' + JSON.stringify(value) | ||
@@ -911,3 +911,3 @@ : String(value); | ||
res.location = function location(url) { | ||
var loc = url; | ||
let loc = url; | ||
@@ -942,5 +942,5 @@ // "back" is an alias for the referrer | ||
res.redirect = function redirect(url) { | ||
var address = url; | ||
var body; | ||
var status = 302; | ||
let address = url; | ||
let body; | ||
let status = 302; | ||
@@ -968,3 +968,3 @@ // allow status / url | ||
html: function(){ | ||
var u = escapeHtml(address); | ||
let u = escapeHtml(address); | ||
body = '<p>' + statuses(status) + '. Redirecting to <a href="' + u + '">' + u + '</a></p>' | ||
@@ -1025,7 +1025,7 @@ }, | ||
res.render = function render(view, options, callback) { | ||
var app = this.req.app; | ||
var done = callback; | ||
var opts = options || {}; | ||
var req = this.req; | ||
var self = this; | ||
let app = this.req.app; | ||
let done = callback; | ||
let opts = options || {}; | ||
let req = this.req; | ||
let self = this; | ||
@@ -1053,4 +1053,4 @@ // support callback function as second arg | ||
function sendfile(res, file, options, callback) { | ||
var done = false; | ||
var streaming; | ||
let done = false; | ||
let streaming; | ||
@@ -1062,3 +1062,3 @@ // request aborted | ||
var err = new Error('Request aborted'); | ||
let err = new Error('Request aborted'); | ||
err.code = 'ECONNABORTED'; | ||
@@ -1073,3 +1073,3 @@ callback(err); | ||
var err = new Error('EISDIR, read'); | ||
let err = new Error('EISDIR, read'); | ||
err.code = 'EISDIR'; | ||
@@ -1131,7 +1131,7 @@ callback(err); | ||
file.on('headers', function headers(res) { | ||
var obj = options.headers; | ||
var keys = Object.keys(obj); | ||
let obj = options.headers; | ||
let keys = Object.keys(obj); | ||
for (var i = 0; i < keys.length; i++) { | ||
var k = keys[i]; | ||
for (let i = 0; i < keys.length; i++) { | ||
let k = keys[i]; | ||
res.setHeader(k, obj[k]); | ||
@@ -1162,3 +1162,3 @@ } | ||
// https://bugs.chromium.org/p/v8/issues/detail?id=4730 | ||
var json = replacer || spaces | ||
let json = replacer || spaces | ||
? JSON.stringify(value, replacer, spaces) | ||
@@ -1165,0 +1165,0 @@ : JSON.stringify(value); |
@@ -14,11 +14,11 @@ /** | ||
var Route = require('./route'); | ||
var Layer = require('./layer'); | ||
var methods = require('methods'); | ||
var mixin = require('xprezzo-buffer').mixin; | ||
var debug = require('xprezzo-serve-static').debug('xprezzo:router'); | ||
var deprecate = require('depd')('xprezzo'); | ||
var { flatten } = require('array-flatten'); | ||
var parseUrl = require('parseurl'); | ||
var setPrototypeOf = require('xprezzo-setprototypeof'); | ||
const Route = require('./route'); | ||
const Layer = require('./layer'); | ||
const methods = require('methods'); | ||
const mixin = require('xprezzo-buffer').mixin; | ||
const debug = require('xprezzo-serve-static').debug('xprezzo:router'); | ||
const deprecate = require('depd')('xprezzo'); | ||
const { flatten } = require('array-flatten'); | ||
const parseUrl = require('parseurl'); | ||
const setPrototypeOf = require('xprezzo-setprototypeof'); | ||
@@ -30,18 +30,10 @@ /** | ||
var objectRegExp = /^\[object (\S+)\]$/; | ||
var slice = Array.prototype.slice; | ||
var toString = Object.prototype.toString; | ||
let objectRegExp = /^\[object (\S+)\]$/; | ||
let slice = Array.prototype.slice; | ||
let toString = Object.prototype.toString; | ||
/** | ||
* Initialize a new `Router` with the given `options`. | ||
* | ||
* @param {Object} [options] | ||
* @return {Router} which is an callable function | ||
* @public | ||
*/ | ||
var proto = module.exports = function(options) { | ||
var opts = options || {}; | ||
debug('start'); | ||
function router(req, res, next) { | ||
const createCallableFunction = (options) => { | ||
let opts = options || {}; | ||
let router = (req, res, next) => { | ||
debug("Handle next()") | ||
router.handle(req, res, next); | ||
@@ -51,5 +43,5 @@ } | ||
// mixin Router class functions | ||
setPrototypeOf(router, proto); | ||
setPrototypeOf(router, routerFactory); | ||
if(opts.app && typeof opts.app.emit==='function'){ | ||
router.emit=function(arg){ | ||
router.emit=(arg) => { | ||
if(arguments.length > 2){ | ||
@@ -62,2 +54,3 @@ opts.app.emit(arg,arguments[1]); | ||
} | ||
router.params = {}; | ||
@@ -69,7 +62,17 @@ router._params = []; | ||
router.stack = []; | ||
debug('done'); | ||
return router; | ||
}; | ||
} | ||
/** | ||
* Initialize a new `Router` with the given `options`. | ||
* | ||
* @param {Object} [options] | ||
* @return {Router} which is an callable function | ||
* @public | ||
*/ | ||
let routerFactory = function(options) { | ||
return createCallableFunction(options) | ||
} | ||
/** | ||
* Map the given param placeholder `name`(s) to the given callback. | ||
@@ -108,3 +111,3 @@ * | ||
proto.param = function param(name, fn) { | ||
routerFactory.param = function(name, fn) { | ||
// param logic | ||
@@ -118,5 +121,5 @@ if (typeof name === 'function') { | ||
// apply param functions | ||
var params = this._params; | ||
var len = params.length; | ||
var ret; | ||
let params = this._params; | ||
let len = params.length; | ||
let ret; | ||
@@ -128,3 +131,3 @@ if (name[0] === ':') { | ||
for (var i = 0; i < len; ++i) { | ||
for (let i = 0; i < len; ++i) { | ||
if (ret = params[i](name, fn)) { | ||
@@ -150,6 +153,6 @@ fn = ret; | ||
proto.handle = function handle(req, res, out) { | ||
var self = this; | ||
routerFactory.handle = function(req, res, out) { | ||
let self = this; | ||
debug('dispatching %s %s', req.method, req.url); | ||
debug('Handle: dispatching %s %s', req.method, req.url); | ||
if(typeof this.emit==='function'){ | ||
@@ -161,19 +164,19 @@ this.emit('dispatch',{ | ||
} | ||
var idx = 0; | ||
var protohost = getProtohost(req.url) || '' | ||
var removed = ''; | ||
var slashAdded = false; | ||
var paramcalled = {}; | ||
let idx = 0; | ||
let protohost = getProtohost(req.url) || '' | ||
let removed = ''; | ||
let slashAdded = false; | ||
let paramcalled = {}; | ||
// store options for OPTIONS request | ||
// only used if OPTIONS request | ||
var options = []; | ||
let options = []; | ||
// middleware and routes | ||
var stack = self.stack; | ||
let stack = self.stack; | ||
// manage inter-router variables | ||
var parentParams = req.params; | ||
var parentUrl = req.baseUrl || ''; | ||
var done = restore(out, req, 'baseUrl', 'next', 'params'); | ||
let parentParams = req.params; | ||
let parentUrl = req.baseUrl || ''; | ||
let done = restore(out, req, 'baseUrl', 'next', 'params'); | ||
@@ -198,3 +201,3 @@ // setup next layer | ||
function next(err) { | ||
var layerError = err === 'route' | ||
let layerError = err === 'route' | ||
? null | ||
@@ -229,3 +232,3 @@ : err; | ||
// get pathname of request | ||
var path = getPathname(req); | ||
let path = getPathname(req); | ||
@@ -237,5 +240,5 @@ if (path == null) { | ||
// find next matching layer | ||
var layer; | ||
var match; | ||
var route; | ||
let layer; | ||
let match; | ||
let route; | ||
@@ -267,4 +270,4 @@ while (match !== true && idx < stack.length) { | ||
var method = req.method; | ||
var has_method = route._handles_method(method); | ||
let method = req.method; | ||
let has_method = route._handles_method(method); | ||
@@ -297,3 +300,3 @@ // build up automatic options response | ||
: layer.params; | ||
var layerPath = layer.path; | ||
let layerPath = layer.path; | ||
@@ -317,3 +320,3 @@ // this should be done for the layer | ||
// Validate path breaks on a path separator | ||
var c = path[layerPath.length] | ||
let c = path[layerPath.length] | ||
if (c && c !== '/' && c !== '.') return next(layerError) | ||
@@ -323,3 +326,3 @@ | ||
// middleware (.use stuff) needs to have the path stripped | ||
debug('trim prefix (%s) from url %s', layerPath, req.url); | ||
//debug('trim prefix (%s) from url %s', layerPath, req.url); | ||
removed = layerPath; | ||
@@ -340,3 +343,3 @@ req.url = protohost + req.url.substr(protohost.length + removed.length); | ||
debug('%s %s : %s', layer.name, layerPath, req.originalUrl); | ||
//debug('%s %s : %s', layer.name, layerPath, req.originalUrl); | ||
@@ -356,7 +359,7 @@ if (layerError) { | ||
proto.process_params = function process_params(layer, called, req, res, done) { | ||
var params = this.params; | ||
routerFactory.process_params = function process_params(layer, called, req, res, done) { | ||
let params = this.params; | ||
// captured parameters from the layer, keys and values | ||
var keys = layer.keys; | ||
let keys = layer.keys; | ||
@@ -368,9 +371,9 @@ // fast track | ||
var i = 0; | ||
var name; | ||
var paramIndex = 0; | ||
var key; | ||
var paramVal; | ||
var paramCallbacks; | ||
var paramCalled; | ||
let i = 0; | ||
let name; | ||
let paramIndex = 0; | ||
let key; | ||
let paramVal; | ||
let paramCallbacks; | ||
let paramCalled; | ||
@@ -420,3 +423,3 @@ // process params in order | ||
function paramCallback(err) { | ||
var fn = paramCallbacks[paramIndex++]; | ||
let fn = paramCallbacks[paramIndex++]; | ||
@@ -460,5 +463,5 @@ // store updated value | ||
proto.use = function use(fn) { | ||
var offset = 0; | ||
var path = '/'; | ||
routerFactory.use = function use(fn) { | ||
let offset = 0; | ||
let path = '/'; | ||
@@ -468,3 +471,3 @@ // default path to '/' | ||
if (typeof fn !== 'function') { | ||
var arg = fn; | ||
let arg = fn; | ||
@@ -482,3 +485,3 @@ while (Array.isArray(arg) && arg.length !== 0) { | ||
var callbacks = flatten(slice.call(arguments, offset)); | ||
let callbacks = flatten(slice.call(arguments, offset)); | ||
@@ -489,4 +492,4 @@ if (callbacks.length === 0) { | ||
for (var i = 0; i < callbacks.length; i++) { | ||
var fn = callbacks[i]; | ||
for (let i = 0; i < callbacks.length; i++) { | ||
let fn = callbacks[i]; | ||
@@ -498,5 +501,5 @@ if (typeof fn !== 'function') { | ||
// add the middleware | ||
debug('use %o %s', path, fn.name || '<anonymous>') | ||
//debug('use %o %s', path, fn.name || '<anonymous>') | ||
var layer = new Layer(path, { | ||
let layer = new Layer(path, { | ||
sensitive: this.caseSensitive, | ||
@@ -528,6 +531,6 @@ strict: false, | ||
proto.route = function route(path) { | ||
var route = new Route(path); | ||
routerFactory.route = function route(path) { | ||
let route = new Route(path); | ||
var layer = new Layer(path, { | ||
let layer = new Layer(path, { | ||
sensitive: this.caseSensitive, | ||
@@ -546,4 +549,4 @@ strict: this.strict, | ||
methods.concat('all').forEach(function(method){ | ||
proto[method] = function(path){ | ||
var route = this.route(path) | ||
routerFactory[method] = function(path){ | ||
let route = this.route(path) | ||
route[method].apply(route, slice.call(arguments, 1)); | ||
@@ -556,4 +559,4 @@ return this; | ||
function appendMethods(list, addition) { | ||
for (var i = 0; i < addition.length; i++) { | ||
var method = addition[i]; | ||
for (let i = 0; i < addition.length; i++) { | ||
let method = addition[i]; | ||
if (list.indexOf(method) === -1) { | ||
@@ -566,3 +569,3 @@ list.push(method); | ||
// get pathname of request | ||
function getPathname(req) { | ||
const getPathname = (req) => { | ||
try { | ||
@@ -576,3 +579,3 @@ return parseUrl(req).pathname; | ||
// Get get protocol + host for a URL | ||
function getProtohost(url) { | ||
const getProtohost = (url) => { | ||
if (typeof url !== 'string' || url.length === 0 || url[0] === '/') { | ||
@@ -582,7 +585,7 @@ return undefined | ||
var searchIndex = url.indexOf('?') | ||
var pathLength = searchIndex !== -1 | ||
let searchIndex = url.indexOf('?') | ||
let pathLength = searchIndex !== -1 | ||
? searchIndex | ||
: url.length | ||
var fqdnIndex = url.substr(0, pathLength).indexOf('://') | ||
let fqdnIndex = url.substr(0, pathLength).indexOf('://') | ||
@@ -595,4 +598,4 @@ return fqdnIndex !== -1 | ||
// get type for error message | ||
function gettype(obj) { | ||
var type = typeof obj; | ||
const gettype = (obj) => { | ||
let type = typeof obj; | ||
@@ -616,3 +619,3 @@ if (type !== 'object') { | ||
function matchLayer(layer, path) { | ||
const matchLayer =(layer, path) => { | ||
try { | ||
@@ -626,3 +629,3 @@ return layer.match(path); | ||
// merge params with parent params | ||
function mergeParams(params, parent) { | ||
const mergeParams = (params, parent) => { | ||
if (typeof parent !== 'object' || !parent) { | ||
@@ -633,3 +636,3 @@ return params; | ||
// make copy of parent for base | ||
var obj = mixin({}, parent); | ||
let obj = mixin({}, parent); | ||
@@ -641,4 +644,4 @@ // simple non-numeric merging | ||
var i = 0; | ||
var o = 0; | ||
let i = 0; | ||
let o = 0; | ||
@@ -669,6 +672,6 @@ // determine numeric gaps | ||
function restore(fn, obj) { | ||
var props = new Array(arguments.length - 2); | ||
var vals = new Array(arguments.length - 2); | ||
let props = new Array(arguments.length - 2); | ||
let vals = new Array(arguments.length - 2); | ||
for (var i = 0; i < props.length; i++) { | ||
for (let i = 0; i < props.length; i++) { | ||
props[i] = arguments[i + 2]; | ||
@@ -680,3 +683,3 @@ vals[i] = obj[props[i]]; | ||
// restore vals | ||
for (var i = 0; i < props.length; i++) { | ||
for (let i = 0; i < props.length; i++) { | ||
obj[props[i]] = vals[i]; | ||
@@ -690,5 +693,5 @@ } | ||
// send an OPTIONS response | ||
function sendOptionsResponse(res, options, next) { | ||
const sendOptionsResponse = (res, options, next) => { | ||
try { | ||
var body = options.join(','); | ||
let body = options.join(','); | ||
res.set('Allow', body); | ||
@@ -704,6 +707,6 @@ res.send(body); | ||
return function proxy() { | ||
var args = new Array(arguments.length + 1); | ||
let args = new Array(arguments.length + 1); | ||
args[0] = old; | ||
for (var i = 0, len = arguments.length; i < len; i++) { | ||
for (let i = 0, len = arguments.length; i < len; i++) { | ||
args[i + 1] = arguments[i]; | ||
@@ -715,1 +718,3 @@ } | ||
} | ||
module.exports = routerFactory |
@@ -14,12 +14,12 @@ /** | ||
var Buffer = require('xprezzo-buffer').Buffer | ||
var contentDisposition = require('content-disposition'); | ||
var contentType = require('content-type'); | ||
var deprecate = require('depd')('xprezzo'); | ||
var { flatten } = require('array-flatten'); | ||
var mime = require('xprezzo-serve-static').mime; | ||
var etag = require('etag'); | ||
var proxyaddr = require('proxy-addr'); | ||
var qs = require('qs'); | ||
var querystring = require('querystring'); | ||
const Buffer = require('xprezzo-buffer').Buffer | ||
const contentDisposition = require('content-disposition'); | ||
const contentType = require('content-type'); | ||
const deprecate = require('depd')('xprezzo'); | ||
const { flatten } = require('array-flatten'); | ||
const mime = require('xprezzo-serve-static').mime; | ||
const etag = require('etag'); | ||
const proxyaddr = require('proxy-addr'); | ||
const qs = require('qs'); | ||
const querystring = require('querystring'); | ||
@@ -96,5 +96,5 @@ /** | ||
exports.normalizeTypes = function(types){ | ||
var ret = []; | ||
let ret = []; | ||
for (var i = 0; i < types.length; ++i) { | ||
for (let i = 0; i < types.length; ++i) { | ||
ret.push(exports.normalizeType(types[i])); | ||
@@ -129,7 +129,7 @@ } | ||
function acceptParams(str, index) { | ||
var parts = str.split(/ *; */); | ||
var ret = { value: parts[0], quality: 1, params: {}, originalIndex: index }; | ||
let parts = str.split(/ *; */); | ||
let ret = { value: parts[0], quality: 1, params: {}, originalIndex: index }; | ||
for (var i = 1; i < parts.length; ++i) { | ||
var pms = parts[i].split(/ *= */); | ||
for (let i = 1; i < parts.length; ++i) { | ||
let pms = parts[i].split(/ *= */); | ||
if ('q' === pms[0]) { | ||
@@ -154,3 +154,3 @@ ret.quality = parseFloat(pms[1]); | ||
exports.compileETag = function(val) { | ||
var fn; | ||
let fn; | ||
@@ -189,3 +189,3 @@ if (typeof val === 'function') { | ||
exports.compileQueryParser = function compileQueryParser(val) { | ||
var fn; | ||
let fn; | ||
@@ -260,3 +260,3 @@ if (typeof val === 'function') { | ||
// parse type | ||
var parsed = contentType.parse(type); | ||
let parsed = contentType.parse(type); | ||
@@ -281,3 +281,3 @@ // set charset | ||
return function generateETag (body, encoding) { | ||
var buf = !Buffer.isBuffer(body) | ||
let buf = !Buffer.isBuffer(body) | ||
? Buffer.from(body, encoding) | ||
@@ -284,0 +284,0 @@ : body |
@@ -14,5 +14,5 @@ /** | ||
var debug = require('xprezzo-serve-static').debug('xprezzo:view'); | ||
var path = require('path'); | ||
var fs = require('fs'); | ||
const debug = require('xprezzo-serve-static').debug('xprezzo:view'); | ||
const path = require('path'); | ||
const fs = require('fs'); | ||
@@ -24,7 +24,7 @@ /** | ||
var dirname = path.dirname; | ||
var basename = path.basename; | ||
var extname = path.extname; | ||
var join = path.join; | ||
var resolve = path.resolve; | ||
let dirname = path.dirname; | ||
let basename = path.basename; | ||
let extname = path.extname; | ||
let join = path.join; | ||
let resolve = path.resolve; | ||
@@ -53,3 +53,3 @@ /** | ||
function View(name, options) { | ||
var opts = options || {}; | ||
let opts = options || {}; | ||
@@ -65,3 +65,3 @@ this.defaultEngine = opts.defaultEngine; | ||
var fileName = name; | ||
let fileName = name; | ||
@@ -78,3 +78,3 @@ if (!this.ext) { | ||
if (!opts.engines[this.ext]) { | ||
var mod, fn; | ||
let mod, fn; | ||
// add reverse support for extension using .send | ||
@@ -119,14 +119,14 @@ if(this.ext === ".send" ){ | ||
View.prototype.lookup = function lookup(name) { | ||
var path; | ||
var roots = [].concat(this.root); | ||
let path; | ||
let roots = [].concat(this.root); | ||
debug('lookup "%s"', name); | ||
for (var i = 0; i < roots.length && !path; i++) { | ||
var root = roots[i]; | ||
for (let i = 0; i < roots.length && !path; i++) { | ||
let root = roots[i]; | ||
// resolve the path | ||
var loc = resolve(root, name); | ||
var dir = dirname(loc); | ||
var file = basename(loc); | ||
let loc = resolve(root, name); | ||
let dir = dirname(loc); | ||
let file = basename(loc); | ||
@@ -162,7 +162,7 @@ // resolve the file | ||
View.prototype.resolve = function resolve(dir, file) { | ||
var ext = this.ext; | ||
let ext = this.ext; | ||
// <path>.<ext> | ||
var path = join(dir, file); | ||
var stat = tryStat(path); | ||
let path = join(dir, file); | ||
let stat = tryStat(path); | ||
@@ -169,0 +169,0 @@ if (stat && stat.isFile()) { |
@@ -7,3 +7,3 @@ /** | ||
'use strict'; | ||
'use strict' | ||
@@ -14,17 +14,17 @@ /** | ||
var JsonParser = require('xprezzo-json-parser'); | ||
var RawParser = require('xprezzo-raw-parser'); | ||
var TextParser = require('xprezzo-text-parser'); | ||
var UrlencodedParser = require('xprezzo-urlencoded-parser'); | ||
var EventEmitter = require('events').EventEmitter; | ||
var mixin = require('xprezzo-buffer').mixin; | ||
var proto = require('./proto'); | ||
var Route = require('./router/route'); | ||
var Router = require('./router'); | ||
var req = require('./request'); | ||
var res = require('./response'); | ||
var debug = require('xprezzo-serve-static').debug('xprezzo:xprezzo'); | ||
const JsonParser = require('xprezzo-json-parser') | ||
const RawParser = require('xprezzo-raw-parser') | ||
const TextParser = require('xprezzo-text-parser') | ||
const UrlencodedParser = require('xprezzo-urlencoded-parser') | ||
const EventEmitter = require('events').EventEmitter | ||
const mixin = require('xprezzo-buffer').mixin | ||
const proto = require('./proto') | ||
const Route = require('./router/route') | ||
const Router = require('./router') | ||
const req = require('./request') | ||
const res = require('./response') | ||
const debug = require('xprezzo-serve-static').debug('xprezzo:xprezzo') | ||
/** | ||
/** | ||
* Create an xprezzo application. | ||
@@ -35,7 +35,7 @@ * | ||
*/ | ||
exports = module.exports = function() { | ||
debug('start'); | ||
var app = function(req, res, next) { | ||
return app.handle(req, res, next); | ||
}; | ||
exports = module.exports = () => { | ||
debug('start') | ||
let app = (req, res, next) => { | ||
return app.handle(req, res, next) | ||
} | ||
mixin(app, EventEmitter.prototype, proto, | ||
@@ -50,9 +50,9 @@ { | ||
} | ||
); | ||
) | ||
if(typeof app.init === 'function'){ | ||
debug('call proto init()'); | ||
app.init(); | ||
debug('call proto init()') | ||
app.init() | ||
} | ||
debug('done'); | ||
return app; | ||
debug('done') | ||
return app | ||
} | ||
@@ -63,5 +63,5 @@ | ||
*/ | ||
exports.application = proto; | ||
exports.request = req; | ||
exports.response = res; | ||
exports.application = proto | ||
exports.request = req | ||
exports.response = res | ||
@@ -71,4 +71,4 @@ /** | ||
*/ | ||
exports.Route = Route; | ||
exports.Router = Router; | ||
exports.Route = Route | ||
exports.Router = Router | ||
@@ -78,7 +78,7 @@ /** | ||
*/ | ||
exports.json = JsonParser; | ||
exports.query = require('./middleware/query'); | ||
exports.raw = RawParser; | ||
exports.static = require('xprezzo-serve-static'); | ||
exports.text = TextParser; | ||
exports.urlencoded = UrlencodedParser; | ||
exports.json = JsonParser | ||
exports.query = require('./middleware/query') | ||
exports.raw = RawParser | ||
exports.static = require('xprezzo-serve-static') | ||
exports.text = TextParser | ||
exports.urlencoded = UrlencodedParser |
{ | ||
"name": "xprezzo", | ||
"description": "the NodeJS web framework", | ||
"version": "1.0.11", | ||
"description": "the most updated MVC web framework for NodeJS", | ||
"version": "1.0.12", | ||
"author": "Leolio Mcleon <info@leolio.page>", | ||
@@ -42,6 +42,6 @@ "license": "MIT", | ||
"vary": "~1.1.2", | ||
"xprezzo-json-parser": "1.0.2", | ||
"xprezzo-raw-parser": "1.0.0", | ||
"xprezzo-text-parser": "1.0.1", | ||
"xprezzo-urlencoded-parser": "1.0.0", | ||
"xprezzo-json-parser": "1.0.3", | ||
"xprezzo-raw-parser": "1.0.1", | ||
"xprezzo-text-parser": "1.0.2", | ||
"xprezzo-urlencoded-parser": "1.0.1", | ||
"xprezzo-buffer": "1.0.1", | ||
@@ -48,0 +48,0 @@ "xprezzo-finalhandler": "1.0.3", |
# Xprezzo | ||
A lightweight test-driven MVC framework. | ||
The most updated MVC web framework for NodeJS | ||
## Philosophy of Xprezzo | ||
## Examples | ||
Problems faced: | ||
* Too many requires which creates problem when project grow | ||
* The dependencies update are slow | ||
* Test cases of difficult to design | ||
How Xprezzo try to tackle those problems: | ||
* Useful internal libraries/packages are exposed | ||
* Merge small libraries into a larger one. | ||
* Provide easy to use test framework | ||
```js | ||
@@ -67,10 +54,3 @@ const xprezzo = require('xprezzo') | ||
## Exposes | ||
* exposed [xprezzo-buffer](https://github.com/xprezzo/xprezzo-buffer) | ||
* exposed [xprezzo-debug](https://github.com/xprezzo/xprezzo-debug) | ||
* exposed [xprezzo-mixin](https://github.com/xprezzo/xprezzo-mixin) | ||
* exposed [xprezzo-ms](https://github.com/xprezzo/xprezzo-ms) | ||
* exposed [xprezzo-send](https://github.com/xprezzo/xprezzo-send) | ||
## People | ||
@@ -80,3 +60,2 @@ | ||
It is originated from Express and the current lead maintainer Express is [Douglas Christopher Wilson](https://github.com/dougwilson) | ||
@@ -83,0 +62,0 @@ ## License |
92974
3236
63
+ Addedxprezzo-json-parser@1.0.3(transitive)
+ Addedxprezzo-raw-body@1.0.7(transitive)
+ Addedxprezzo-raw-parser@1.0.1(transitive)
+ Addedxprezzo-text-parser@1.0.2(transitive)
+ Addedxprezzo-urlencoded-parser@1.0.1(transitive)
- Removedxprezzo-json-parser@1.0.2(transitive)
- Removedxprezzo-raw-body@1.0.6(transitive)
- Removedxprezzo-raw-parser@1.0.0(transitive)
- Removedxprezzo-text-parser@1.0.1(transitive)
- Removedxprezzo-urlencoded-parser@1.0.0(transitive)
Updatedxprezzo-json-parser@1.0.3
Updatedxprezzo-raw-parser@1.0.1
Updatedxprezzo-text-parser@1.0.2