MORPH
SIGN IN SIGN UP
morphadmin / express-bench

Fast, unopinionated, minimalist web framework for node.

0 0 267 JavaScript
Normal View History Raw
Fix "trust proxy" setting to inherit when app is mounted fixes #2550 fixes #2551
2015-02-18 00:59:56 -05:00
/*!
* express
* Copyright(c) 2009-2013 TJ Holowaychuk
* Copyright(c) 2013 Roman Shtylman
* Copyright(c) 2014-2015 Douglas Christopher Wilson
* MIT Licensed
*/
perf: enable strict mode
2015-06-18 23:01:18 -04:00
'use strict';
using connect.proto.use
2011-10-07 09:29:36 -07:00
/**
* Module dependencies.
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @private
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
use finalhandler for final response handling
2014-06-05 23:59:27 -04:00
var finalhandler = require('finalhandler');
some code cleanup
2014-03-25 15:23:04 -07:00
var debug = require('debug')('express:application');
var View = require('./view');
fix(refactor): prefix built-in node module imports Since v5 relies on node >= 18, this is now possible (since v16, v14.18.0 [^1][^2]). It's functionally irrelevant: 1. It's not required for CJS nor ESM (with a few exceptions [^3]) 2. It has no performance promises However, there are upsides to this approach: 1. It brings clear boundaries to what's a built-in and what's an external dependency 2. It reduces the risk of importing unwanted deps where a built-in is expected 3. It's slightly more interoperable with other JS runtimes that provide node compatibility[^4], albeit only during development. Once imported from npm, built-ins are assumed. [^1]:https://nodejs.org/docs/latest-v22.x/api/modules.html#built-in-modules [^2]:https://github.com/nodejs/node/pull/37246 [^3]:https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix [^4]:https://docs.deno.com/runtime/fundamentals/node/#using-node's-built-in-modules
2024-12-21 22:58:33 +01:00
var http = require('node:http');
chore: replace `methods` dependency with standard library (#6196)
2025-01-02 08:00:30 +01:00
var methods = require('./utils').methods;
Merge tag '3.9.0'
2014-05-30 22:17:51 -04:00
var compileETag = require('./utils').compileETag;
Add configurable query parser closes #2215
2014-07-13 23:15:00 -04:00
var compileQueryParser = require('./utils').compileQueryParser;
Merge tag '3.7.0'
2014-05-18 11:17:37 -04:00
var compileTrust = require('./utils').compileTrust;
fix(refactor): prefix built-in node module imports Since v5 relies on node >= 18, this is now possible (since v16, v14.18.0 [^1][^2]). It's functionally irrelevant: 1. It's not required for CJS nor ESM (with a few exceptions [^3]) 2. It has no performance promises However, there are upsides to this approach: 1. It brings clear boundaries to what's a built-in and what's an external dependency 2. It reduces the risk of importing unwanted deps where a built-in is expected 3. It's slightly more interoperable with other JS runtimes that provide node compatibility[^4], albeit only during development. Once imported from npm, built-ins are assumed. [^1]:https://nodejs.org/docs/latest-v22.x/api/modules.html#built-in-modules [^2]:https://github.com/nodejs/node/pull/37246 [^3]:https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix [^4]:https://docs.deno.com/runtime/fundamentals/node/#using-node's-built-in-modules
2024-12-21 22:58:33 +01:00
var resolve = require('node:path').resolve;
call callback once on listen error
2017-02-20 17:36:39 -06:00
var once = require('once')
Use router module for routing closes #2411
2015-07-06 23:46:00 -04:00
var Router = require('router');
Ignore Object.prototype values in settings through app.set/app.get closes #4802 closes #4803
2022-02-02 19:13:54 -06:00
/**
* Module variables.
* @private
*/
Support mounted app as any argument to app.use() fixes #2277
2014-08-02 11:41:35 +02:00
var slice = Array.prototype.slice;
Use Array.flat instead of array-flatten (#5677)
2024-08-01 17:42:07 -06:00
var flatten = Array.prototype.flat;
using connect.proto.use
2011-10-07 09:29:36 -07:00
/**
typo
2011-12-09 14:32:35 -08:00
* Application prototype.
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
var app = exports = module.exports = {};
Fix "trust proxy" setting to inherit when app is mounted fixes #2550 fixes #2551
2015-02-18 00:59:56 -05:00
/**
* Variable for trust proxy inheritance back-compat
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @private
Fix "trust proxy" setting to inherit when app is mounted fixes #2550 fixes #2551
2015-02-18 00:59:56 -05:00
*/
var trustProxyDefaultSymbol = '@@symbol:trust_proxy_default';
using connect.proto.use
2011-10-07 09:29:36 -07:00
/**
* Initialize the server.
*
refactoring boot logic
2011-10-07 15:10:30 -07:00
* - setup default configuration
* - setup default middleware
* - setup route reflection methods
*
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @private
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.init = function init() {
Add app.router reference back
2014-07-14 00:27:25 -04:00
var router = null;
Use object with null prototype for various app properties `app.cache`, `app.engines`, and `app.settings` are now created with `Object.create(null)` instead of `{}`. This also updates a test to ensure that `app.locals` is created the same way.
2022-03-17 12:34:13 -05:00
this.cache = Object.create(null);
this.engines = Object.create(null);
this.settings = Object.create(null);
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
refactoring boot logic
2011-10-07 15:10:30 -07:00
this.defaultConfiguration();
Add app.router reference back
2014-07-14 00:27:25 -04:00
// Setup getting to lazily add base router
Object.defineProperty(this, 'router', {
configurable: true,
enumerable: true,
get: function getrouter() {
if (router === null) {
router = new Router({
caseSensitive: this.enabled('case sensitive routing'),
strict: this.enabled('strict routing')
});
}
return router;
}
});
refactoring boot logic
2011-10-07 15:10:30 -07:00
};
/**
* Initialize application configuration.
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @private
refactoring boot logic
2011-10-07 15:10:30 -07:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.defaultConfiguration = function defaultConfiguration() {
var env = process.env.NODE_ENV || 'development';
req.query is always present
2011-10-07 14:04:59 -07:00
// default settings
add "x-powered-by" setting
2012-09-13 09:52:35 -07:00
this.enable('x-powered-by');
improve etag control for res.send closes #1435 closes #2129
2014-05-30 21:02:21 -04:00
this.set('etag', 'weak');
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
this.set('env', env);
Change query parser setting default to 'simple' closes #3361 closes #3621
2018-04-15 10:29:03 +02:00
this.set('query parser', 'simple')
move "subdomain offset" defaulting to config
2013-01-23 20:10:29 -08:00
this.set('subdomain offset', 2);
improve proxy trust with ip address list closes #2099
2014-05-09 00:53:47 -04:00
this.set('trust proxy', false);
req.query is always present
2011-10-07 14:04:59 -07:00
Fix "trust proxy" setting to inherit when app is mounted fixes #2550 fixes #2551
2015-02-18 00:59:56 -05:00
// trust proxy inherit back-compat
Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
configurable: true,
value: true
});
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
debug('booting in %s mode', env);
using connect.proto.use
2011-10-07 09:29:36 -07:00
Fix "trust proxy" setting to inherit when app is mounted fixes #2550 fixes #2551
2015-02-18 00:59:56 -05:00
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'];
}
// inherit protos
refactor: Remove Object.setPrototypeOf polyfill (#6081)
2024-10-22 20:22:26 +02:00
Object.setPrototypeOf(this.request, parent.request)
Object.setPrototypeOf(this.response, parent.response)
Object.setPrototypeOf(this.engines, parent.engines)
Object.setPrototypeOf(this.settings, parent.settings)
Added new mvc example
2012-04-26 03:53:49 -07:00
});
Added res.locals.use(). Closes #1120
2012-05-03 08:42:18 -07:00
// setup locals
change res.locals to a plain js object. Anyone who wants something fancier should use modules. - fixes annoyance with not being able to set 'name' property on locals
2014-01-24 19:49:45 -05:00
this.locals = Object.create(null);
Added res.locals.use(). Closes #1120
2012-05-03 08:42:18 -07:00
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
// top-most app is mounted at /
this.mountpath = '/';
using connect.proto.use
2011-10-07 09:29:36 -07:00
// default locals
this.locals.settings = this.settings;
Added "json replacer" and "json spaces" settings. Closes #996 [credit to jed]
2012-02-07 03:30:34 -08:00
// default configuration
add "view" constructor setting to override view behaviour
2013-04-13 09:53:50 -07:00
this.set('view', View);
Use path.resolve for views dir instead of concat closes #2165
2014-06-08 13:59:52 -04:00
this.set('views', resolve('views'));
add "jsonp callback name" setting
2012-07-06 08:53:19 -07:00
this.set('jsonp callback name', 'callback');
Changed: enable "jsonp callback" as a default
2012-04-15 11:20:25 -07:00
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
if (env === 'production') {
using connect.proto.use
2011-10-07 09:29:36 -07:00
this.enable('view cache');
delete semicolon
2014-01-19 23:53:48 +08:00
}
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
};
using connect.proto.use
2011-10-07 09:29:36 -07:00
/**
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
* Dispatch a req, res pair into the application. Starts pipeline processing.
*
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* If no callback is provided, then default error handlers will respond
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
* in the event of an error bubbling through the stack.
*
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @private
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.handle = function handle(req, res, callback) {
use finalhandler for final response handling
2014-06-05 23:59:27 -04:00
// final handler
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
var done = callback || finalhandler(req, res, {
use finalhandler for final response handling
2014-06-05 23:59:27 -04:00
env: this.get('env'),
onerror: logerror.bind(this)
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
});
use finalhandler for final response handling
2014-06-05 23:59:27 -04:00
Refactor away init middleware
2014-07-14 00:06:33 -04:00
// set powered by header
if (this.enabled('x-powered-by')) {
res.setHeader('X-Powered-By', 'Express');
}
// set circular references
req.res = res;
res.req = req;
// alter the prototypes
refactor: Remove Object.setPrototypeOf polyfill (#6081)
2024-10-22 20:22:26 +02:00
Object.setPrototypeOf(req, this.request)
Object.setPrototypeOf(res, this.response)
Refactor away init middleware
2014-07-14 00:06:33 -04:00
// setup locals
if (!res.locals) {
res.locals = Object.create(null);
}
Add app.router reference back
2014-07-14 00:27:25 -04:00
this.router.handle(req, res, done);
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
};
/**
* 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.
using connect.proto.use
2011-10-07 09:29:36 -07:00
*
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
Support mounted app as any argument to app.use() fixes #2277
2014-08-02 11:41:35 +02:00
app.use = function use(fn) {
var offset = 0;
var path = '/';
// default path to '/'
Fix app.use to accept array of middleware without path fixes #2356
2014-09-12 17:46:49 -04:00
// disambiguate app.use([fn])
Support mounted app as any argument to app.use() fixes #2277
2014-08-02 11:41:35 +02:00
if (typeof fn !== 'function') {
Fix app.use to accept array of middleware without path fixes #2356
2014-09-12 17:46:49 -04:00
var arg = fn;
while (Array.isArray(arg) && arg.length !== 0) {
arg = arg[0];
}
Fix regression for empty string path in app.use fixes #2361 fixes #2362
2014-09-17 12:17:03 -07:00
// first arg is the path
if (typeof arg !== 'function') {
Fix app.use to accept array of middleware without path fixes #2356
2014-09-12 17:46:49 -04:00
offset = 1;
path = fn;
}
Support mounted app as any argument to app.use() fixes #2277
2014-08-02 11:41:35 +02:00
}
Use Array.flat instead of array-flatten (#5677)
2024-08-01 17:42:07 -06:00
var fns = flatten.call(slice.call(arguments, offset), Infinity);
Support mounted app as any argument to app.use() fixes #2277
2014-08-02 11:41:35 +02:00
if (fns.length === 0) {
Improve error messages when non-function provided as middleware closes #3426
2017-09-26 16:00:53 +02:00
throw new TypeError('app.use() requires a middleware function')
Support non-string path in app.use(path, fn) fixes #2207
2014-07-05 13:23:07 -04:00
}
using connect.proto.use
2011-10-07 09:29:36 -07:00
Add app.router reference back
2014-07-14 00:27:25 -04:00
// get router
var router = this.router;
using connect.proto.use
2011-10-07 09:29:36 -07:00
Support mounted app as any argument to app.use() fixes #2277
2014-08-02 11:41:35 +02:00
fns.forEach(function (fn) {
// non-express app
if (!fn || !fn.handle || !fn.set) {
return router.use(path, fn);
}
debug('.use app under %s', path);
fn.mountpath = path;
Pass context to .forEach instead of closure Has a slight performance improvement closes #2347
2014-09-06 21:35:17 +04:00
fn.parent = this;
Accept multiple callbacks to app.use() fixes #2224
2014-07-09 20:04:24 -04:00
// restore .app property on req and res
Support mounted app as any argument to app.use() fixes #2277
2014-08-02 11:41:35 +02:00
router.use(path, function mounted_app(req, res, next) {
using connect.proto.use
2011-10-07 09:29:36 -07:00
var orig = req.app;
Support mounted app as any argument to app.use() fixes #2277
2014-08-02 11:41:35 +02:00
fn.handle(req, res, function (err) {
refactor: Remove Object.setPrototypeOf polyfill (#6081)
2024-10-22 20:22:26 +02:00
Object.setPrototypeOf(req, orig.request)
Object.setPrototypeOf(res, orig.response)
using connect.proto.use
2011-10-07 09:29:36 -07:00
next(err);
});
Accept multiple callbacks to app.use() fixes #2224
2014-07-09 20:04:24 -04:00
});
using connect.proto.use
2011-10-07 09:29:36 -07:00
Accept multiple callbacks to app.use() fixes #2224
2014-07-09 20:04:24 -04:00
// mounted an app
Pass context to .forEach instead of closure Has a slight performance improvement closes #2347
2014-09-06 21:35:17 +04:00
fn.emit('mount', this);
}, this);
Accept multiple callbacks to app.use() fixes #2224
2014-07-09 20:04:24 -04:00
using connect.proto.use
2011-10-07 09:29:36 -07:00
return this;
};
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
/**
* 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.
*
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
*/
Add app.router reference back
2014-07-14 00:27:25 -04:00
app.route = function route(path) {
return this.router.route(path);
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
};
using connect.proto.use
2011-10-07 09:29:36 -07:00
/**
added app.register()
2011-10-07 13:19:29 -07:00
* Register the given template engine callback `fn`
app.engine() docs
2012-04-18 17:23:54 -07:00
* as `ext`.
*
* By default will `require()` the engine based on the
* file extension. For example if you try to render
Use ejs instead of jade within engine jsdoc closes #3222
2017-02-26 13:12:35 +00:00
* a "foo.ejs" file Express will invoke the following internally:
app.engine() docs
2012-04-18 17:23:54 -07:00
*
Use ejs instead of jade within engine jsdoc closes #3222
2017-02-26 13:12:35 +00:00
* app.engine('ejs', require('ejs').__express);
app.engine() docs
2012-04-18 17:23:54 -07:00
*
* 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
docs
2012-04-25 17:59:02 -07:00
* ".html" files:
using connect.proto.use
2011-10-07 09:29:36 -07:00
*
Added new dox API docs
2012-04-15 21:01:17 -07:00
* app.engine('html', require('ejs').renderFile);
added app.register()
2011-10-07 13:19:29 -07:00
*
Added new dox API docs
2012-04-15 21:01:17 -07:00
* In this case EJS provides a `.renderFile()` method with
app.engine() docs
2012-04-18 17:23:54 -07:00
* the same signature that Express expects: `(path, options, callback)`,
* though note that it aliases this method as `ejs.__express` internally
docs: fix typos in jsdoc closes #4564
2021-04-11 22:28:56 +02:00
* so if you're using ".ejs" extensions you don't need to do anything.
added app.register()
2011-10-07 13:19:29 -07:00
*
Added new dox API docs
2012-04-15 21:01:17 -07:00
* Some template engines do not follow this convention, the
docs: visionmedia is now tj on Github
2014-10-23 02:20:51 -04:00
* [Consolidate.js](https://github.com/tj/consolidate.js)
Added new dox API docs
2012-04-15 21:01:17 -07:00
* library was created to map all of node's popular template
* engines to follow this convention, thus allowing them to
typo
2013-02-08 08:42:47 -08:00
* work seamlessly within Express.
added app.register()
2011-10-07 13:19:29 -07:00
*
* @param {String} ext
* @param {Function} fn
Added app.listen() as a shortcut for http.createServer(app).listen()
2011-11-11 17:22:25 -08:00
* @return {app} for chaining
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.engine = function engine(ext, fn) {
if (typeof fn !== 'function') {
throw new Error('callback function required');
}
// get file extension
var extension = ext[0] !== '.'
? '.' + ext
: ext;
// store engine
this.engines[extension] = fn;
using connect.proto.use
2011-10-07 09:29:36 -07:00
return this;
};
/**
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
* 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.
using connect.proto.use
2011-10-07 09:29:36 -07:00
*
Added new dox API docs
2012-04-15 21:01:17 -07:00
* @param {String|Array} name
using connect.proto.use
2011-10-07 09:29:36 -07:00
* @param {Function} fn
Added app.listen() as a shortcut for http.createServer(app).listen()
2011-11-11 17:22:25 -08:00
* @return {app} for chaining
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
Add app.router reference back
2014-07-14 00:27:25 -04:00
app.param = function param(name, fn) {
using connect.proto.use
2011-10-07 09:29:36 -07:00
if (Array.isArray(name)) {
Add app.router reference back
2014-07-14 00:27:25 -04:00
for (var i = 0; i < name.length; i++) {
this.param(name[i], fn);
}
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
return this;
using connect.proto.use
2011-10-07 09:29:36 -07:00
}
Add app.router reference back
2014-07-14 00:27:25 -04:00
this.router.param(name, fn);
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
using connect.proto.use
2011-10-07 09:29:36 -07:00
return this;
};
/**
* Assign `setting` to `val`, or return `setting`'s value.
Added new dox API docs
2012-04-15 21:01:17 -07:00
*
* app.set('foo', 'bar');
docs: fix typo in jsdoc comment closes #3430
2017-09-27 15:17:03 +02:00
* app.set('foo');
Added new dox API docs
2012-04-15 21:01:17 -07:00
* // => "bar"
*
using connect.proto.use
2011-10-07 09:29:36 -07:00
* Mounted servers inherit their parent server's settings.
*
* @param {String} setting
Value parameter of app.set() is now typed optional mixed
2014-01-04 22:05:19 +01:00
* @param {*} [val]
Added new dox API docs
2012-04-15 21:01:17 -07:00
* @return {Server} for chaining
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.set = function set(setting, val) {
improve etag control for res.send closes #1435 closes #2129
2014-05-30 21:02:21 -04:00
if (arguments.length === 1) {
// app.get(setting)
Use object with null prototype for settings closes #4835
2022-02-21 12:17:50 -06:00
return this.settings[setting];
improve etag control for res.send closes #1435 closes #2129
2014-05-30 21:02:21 -04:00
}
improve proxy trust with ip address list closes #2099
2014-05-09 00:53:47 -04:00
Add settings to debug output closes #2675
2015-06-20 16:21:12 -04:00
debug('set "%s" to %o', setting, val);
improve etag control for res.send closes #1435 closes #2129
2014-05-30 21:02:21 -04:00
// set value
this.settings[setting] = val;
// trigger matched settings
switch (setting) {
case 'etag':
this.set('etag fn', compileETag(val));
break;
Add configurable query parser closes #2215
2014-07-13 23:15:00 -04:00
case 'query parser':
this.set('query parser fn', compileQueryParser(val));
break;
improve etag control for res.send closes #1435 closes #2129
2014-05-30 21:02:21 -04:00
case 'trust proxy':
improve proxy trust with ip address list closes #2099
2014-05-09 00:53:47 -04:00
this.set('trust proxy fn', compileTrust(val));
Fix "trust proxy" setting to inherit when app is mounted fixes #2550 fixes #2551
2015-02-18 00:59:56 -05:00
// trust proxy inherit back-compat
Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
configurable: true,
value: false
});
improve etag control for res.send closes #1435 closes #2129
2014-05-30 21:02:21 -04:00
break;
using connect.proto.use
2011-10-07 09:29:36 -07:00
}
improve etag control for res.send closes #1435 closes #2129
2014-05-30 21:02:21 -04:00
return this;
using connect.proto.use
2011-10-07 09:29:36 -07:00
};
app.path()
2011-12-06 15:36:44 -08:00
/**
* Return the app's absolute pathname
* based on the parent(s) that have
* mounted it.
*
Added new dox API docs
2012-04-15 21:01:17 -07:00
* For example if the application was
* mounted as "/admin", which itself
* was mounted as "/blog" then the
* return value would be "/blog/admin".
*
app.path()
2011-12-06 15:36:44 -08:00
* @return {String}
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @private
app.path()
2011-12-06 15:36:44 -08:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.path = function path() {
app.path()
2011-12-06 15:36:44 -08:00
return this.parent
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
? this.parent.path() + this.mountpath
app.path()
2011-12-06 15:36:44 -08:00
: '';
};
using connect.proto.use
2011-10-07 09:29:36 -07:00
/**
Added new dox API docs
2012-04-15 21:01:17 -07:00
* Check if `setting` is enabled (truthy).
*
* app.enabled('foo')
* // => false
*
* app.enable('foo')
* app.enabled('foo')
* // => true
using connect.proto.use
2011-10-07 09:29:36 -07:00
*
* @param {String} setting
* @return {Boolean}
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.enabled = function enabled(setting) {
return Boolean(this.set(setting));
using connect.proto.use
2011-10-07 09:29:36 -07:00
};
/**
* Check if `setting` is disabled.
*
Added new dox API docs
2012-04-15 21:01:17 -07:00
* app.disabled('foo')
* // => true
*
* app.enable('foo')
* app.disabled('foo')
* // => false
*
using connect.proto.use
2011-10-07 09:29:36 -07:00
* @param {String} setting
* @return {Boolean}
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.disabled = function disabled(setting) {
using connect.proto.use
2011-10-07 09:29:36 -07:00
return !this.set(setting);
};
/**
* Enable `setting`.
*
* @param {String} setting
Added app.listen() as a shortcut for http.createServer(app).listen()
2011-11-11 17:22:25 -08:00
* @return {app} for chaining
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.enable = function enable(setting) {
using connect.proto.use
2011-10-07 09:29:36 -07:00
return this.set(setting, true);
};
/**
* Disable `setting`.
*
* @param {String} setting
Added app.listen() as a shortcut for http.createServer(app).listen()
2011-11-11 17:22:25 -08:00
* @return {app} for chaining
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.disable = function disable(setting) {
using connect.proto.use
2011-10-07 09:29:36 -07:00
return this.set(setting, false);
};
/**
add http verbs methods to Router By having the method verbs available on the router, users can set up disjoint routers and organized paths easier. It is now possible to have a .js file export the router.middleware and attach these paths using an `app.use('/path', middleware)` call. This means that any routes written in the separate file do not need to have a full path hardcoded as they can be mounted by the application anywhere. This is already possible using `router.route(verb, args)` however is needlessly verbose without this patch.
2012-12-25 16:39:48 -05:00
* Delegate `.VERB(...)` calls to `router.VERB(...)`.
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
fix(refactor): prefix built-in node module imports Since v5 relies on node >= 18, this is now possible (since v16, v14.18.0 [^1][^2]). It's functionally irrelevant: 1. It's not required for CJS nor ESM (with a few exceptions [^3]) 2. It has no performance promises However, there are upsides to this approach: 1. It brings clear boundaries to what's a built-in and what's an external dependency 2. It reduces the risk of importing unwanted deps where a built-in is expected 3. It's slightly more interoperable with other JS runtimes that provide node compatibility[^4], albeit only during development. Once imported from npm, built-ins are assumed. [^1]:https://nodejs.org/docs/latest-v22.x/api/modules.html#built-in-modules [^2]:https://github.com/nodejs/node/pull/37246 [^3]:https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix [^4]:https://docs.deno.com/runtime/fundamentals/node/#using-node's-built-in-modules
2024-12-21 22:58:33 +01:00
methods.forEach(function (method) {
app[method] = function (path) {
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
if (method === 'get' && arguments.length === 1) {
// app.get(setting)
return this.set(path);
}
Revert "fix behavior of multiple app.VERB for the same path" This reverts commit 31b2e2d7b4774eed16a93f9a8a20a9967e91e524. fixes #2133
2014-05-23 18:35:20 -04:00
Add app.router reference back
2014-07-14 00:27:25 -04:00
var route = this.route(path);
Support mounted app as any argument to app.use() fixes #2277
2014-08-02 11:41:35 +02:00
route[method].apply(route, slice.call(arguments, 1));
fix route chaining regression. Closes #1397
2012-11-04 12:28:35 -08:00
return this;
};
using connect.proto.use
2011-10-07 09:29:36 -07:00
});
/**
* Special-cased "all" method, applying the given route `path`,
* middleware, and callback to _every_ HTTP method.
*
* @param {String} path
* @param {Function} ...
Added app.listen() as a shortcut for http.createServer(app).listen()
2011-11-11 17:22:25 -08:00
* @return {app} for chaining
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
using connect.proto.use
2011-10-07 09:29:36 -07:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.all = function all(path) {
Add app.router reference back
2014-07-14 00:27:25 -04:00
var route = this.route(path);
Support mounted app as any argument to app.use() fixes #2277
2014-08-02 11:41:35 +02:00
var args = slice.call(arguments, 1);
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
for (var i = 0; i < methods.length; i++) {
route[methods[i]].apply(route, args);
}
remove app.router and refactor middleware processing This is an overhaul of middleware processing, Router and Route. Connect is no longer used to process the middleware stack. This functionality has been split into two parts: middleware stack and default error response. The entry point for request processing is the `app.handle` method. It sets up the default error response handle (to run in the event of no other error handler) and then triggers the app router (instance of Router) to handle the request. The app router `handle` function contains the middleware dispatch layer previously in the connect codebase. This layer handle the logic for dispatching `.use` calls (stripping paths if needed). The app contains a base router `app._router`. New routes can be created and `.use`d on this router to organize routes into files. Routers now have the following methods `.use`, `.all`, `.param` which are all public. Additionally, Routers have a `.route(path)` method which returns a new instance of Route for the requested path. Route(s) are isolated middleware stacks and contain methods for the HTTP verbs as well as an `.all` method to act similar to middleware. These methods are chainable to easily describe requirements for a route. var route = Router.route('/foo'); // or 'app.route('/foo')' route .all(auth) .get(function(...) {}) .all(more_checks) .post(function(...) {}) Any Route and Router methods which accept handlers also accept error (arity 4) handlers which will also behave as expected. Finally, the `app.router` getter has been removed. Middleware and handlers are run IN THE ORDER they are seen in the file. This means that code which injected the `app.router` and then added error handlers (or other middleware) will need to be updated to move those handlers after any requests added on the app object. The examples have been updated accordingly. This is the largest breaking change to codebases in this commit.
2014-01-25 17:57:25 -05:00
using connect.proto.use
2011-10-07 09:29:36 -07:00
return this;
};
re-working view system
2011-10-07 13:07:19 -07:00
/**
new View
2011-10-07 14:51:06 -07:00
* Render the given view `name` name with `options`
re-working view system
2011-10-07 13:07:19 -07:00
* and a callback accepting an error and the
* rendered template string.
*
Added new dox API docs
2012-04-15 21:01:17 -07:00
* Example:
*
* app.render('email', { name: 'Tobi' }, function(err, html){
* // ...
* })
*
new View
2011-10-07 14:51:06 -07:00
* @param {String} name
Fix param definition is jsdoc for app.render fixes #2741
2015-08-25 21:03:05 +03:00
* @param {Object|Function} options or fn
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @param {Function} callback
* @public
re-working view system
2011-10-07 13:07:19 -07:00
*/
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
app.render = function render(name, options, callback) {
some code cleanup
2014-03-25 15:23:04 -07:00
var cache = this.cache;
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
var done = callback;
some code cleanup
2014-03-25 15:23:04 -07:00
var engines = this.engines;
feat: Allow passing null or undefined as the value for options in app.render (#6903) * fix: allow null options in app.render * fix: ensure options are initialized to an empty object in app.render * docs: add history entry --------- Co-authored-by: Sebastian Beltran <bjohansebas@gmail.com>
2026-02-01 08:21:17 +05:30
var opts = options || {};
some code cleanup
2014-03-25 15:23:04 -07:00
var view;
re-working view system
2011-10-07 13:07:19 -07:00
// support callback function as second arg
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
if (typeof options === 'function') {
done = options;
opts = {};
re-working view system
2011-10-07 13:07:19 -07:00
}
merging res.locals
2011-10-07 13:50:31 -07:00
// merge options
fix: Remove `utils-merge` dependency - use spread syntax instead (#6091)
2025-01-08 16:56:16 +01:00
var renderOptions = { ...this.locals, ...opts._locals, ...opts };
re-working view system
2011-10-07 13:07:19 -07:00
new View
2011-10-07 14:51:06 -07:00
// set .cache unless explicitly provided
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
if (renderOptions.cache == null) {
renderOptions.cache = this.enabled('view cache');
}
re-working view system
2011-10-07 13:07:19 -07:00
new View
2011-10-07 14:51:06 -07:00
// primed cache
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
if (renderOptions.cache) {
view = cache[name];
}
re-working view system
2011-10-07 13:07:19 -07:00
new View
2011-10-07 14:51:06 -07:00
// view
if (!view) {
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
var View = this.get('view');
view = new View(name, {
move default of "views" out so multiple cwd() calls are not made
2012-10-06 09:58:17 -07:00
defaultEngine: this.get('view engine'),
root: this.get('views'),
engines: engines
new View
2011-10-07 14:51:06 -07:00
});
added nicer error messages for failed view lookup. Closes #1065
2012-04-02 15:47:10 -07:00
if (!view.path) {
Add support for app.set('views', array) closes #2320
2014-10-23 17:18:26 -04:00
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);
add err.view property for view errors. Closes #1226
2012-07-11 08:45:37 -07:00
err.view = view;
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
return done(err);
added nicer error messages for failed view lookup. Closes #1065
2012-04-02 15:47:10 -07:00
}
new View
2011-10-07 14:51:06 -07:00
// prime the cache
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
if (renderOptions.cache) {
cache[name] = view;
}
new View
2011-10-07 14:51:06 -07:00
}
re-working view system
2011-10-07 13:07:19 -07:00
// render
perf: isolate app.render try block
2015-06-20 13:36:40 -04:00
tryRender(view, renderOptions, done);
re-working view system
2011-10-07 13:07:19 -07:00
};
Added new dox API docs
2012-04-15 21:01:17 -07:00
/**
* 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"
docs
2012-04-25 17:59:02 -07:00
* and "https" modules as shown here:
Added new dox API docs
2012-04-15 21:01:17 -07:00
*
fix(refactor): prefix built-in node module imports Since v5 relies on node >= 18, this is now possible (since v16, v14.18.0 [^1][^2]). It's functionally irrelevant: 1. It's not required for CJS nor ESM (with a few exceptions [^3]) 2. It has no performance promises However, there are upsides to this approach: 1. It brings clear boundaries to what's a built-in and what's an external dependency 2. It reduces the risk of importing unwanted deps where a built-in is expected 3. It's slightly more interoperable with other JS runtimes that provide node compatibility[^4], albeit only during development. Once imported from npm, built-ins are assumed. [^1]:https://nodejs.org/docs/latest-v22.x/api/modules.html#built-in-modules [^2]:https://github.com/nodejs/node/pull/37246 [^3]:https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix [^4]:https://docs.deno.com/runtime/fundamentals/node/#using-node's-built-in-modules
2024-12-21 22:58:33 +01:00
* var http = require('node:http')
* , https = require('node:https')
Added new dox API docs
2012-04-15 21:01:17 -07:00
* , express = require('express')
* , app = express();
*
* http.createServer(app).listen(80);
Update lib/application.js typo: http -> https
2012-09-05 05:20:37 +10:00
* https.createServer({ ... }, app).listen(443);
Added new dox API docs
2012-04-15 21:01:17 -07:00
*
* @return {http.Server}
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* @public
Added new dox API docs
2012-04-15 21:01:17 -07:00
*/
fix(refactor): prefix built-in node module imports Since v5 relies on node >= 18, this is now possible (since v16, v14.18.0 [^1][^2]). It's functionally irrelevant: 1. It's not required for CJS nor ESM (with a few exceptions [^3]) 2. It has no performance promises However, there are upsides to this approach: 1. It brings clear boundaries to what's a built-in and what's an external dependency 2. It reduces the risk of importing unwanted deps where a built-in is expected 3. It's slightly more interoperable with other JS runtimes that provide node compatibility[^4], albeit only during development. Once imported from npm, built-ins are assumed. [^1]:https://nodejs.org/docs/latest-v22.x/api/modules.html#built-in-modules [^2]:https://github.com/nodejs/node/pull/37246 [^3]:https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix [^4]:https://docs.deno.com/runtime/fundamentals/node/#using-node's-built-in-modules
2024-12-21 22:58:33 +01:00
app.listen = function listen() {
call callback once on listen error
2017-02-20 17:36:39 -06:00
var server = http.createServer(this)
refactor: use cached slice in app.listen (#6897) Signed-off-by: Tacit1 <tacitim5@gmail.com>
2025-11-24 04:52:16 +05:00
var args = slice.call(arguments)
call callback once on listen error
2017-02-20 17:36:39 -06:00
if (typeof args[args.length - 1] === 'function') {
var done = args[args.length - 1] = once(args[args.length - 1])
server.once('error', done)
}
return server.listen.apply(server, args)
}
use finalhandler for final response handling
2014-06-05 23:59:27 -04:00
/**
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
* Log error using console.error.
*
* @param {Error} err
* @private
*/
use finalhandler for final response handling
2014-06-05 23:59:27 -04:00
perf: remove argument reassignments in application
2015-06-20 13:31:03 -04:00
function logerror(err) {
/* istanbul ignore next */
use finalhandler for final response handling
2014-06-05 23:59:27 -04:00
if (this.get('env') !== 'test') console.error(err.stack || err.toString());
}
perf: isolate app.render try block
2015-06-20 13:36:40 -04:00
/**
* Try rendering a view.
* @private
*/
function tryRender(view, options, callback) {
try {
view.render(options, callback);
} catch (err) {
callback(err);
}
}
Reference in New Issue Copy Permalink