Express.js 5.x API

https://expressjs.com/en/5x/
Admin
Express.js is a minimalist web application framework for Node.js, providing a robust set of features...
Tokens:54,997
Snippets:591
Trust Score:10
Update:21 hours ago
Show doc for...
Tokens:
Raw
### Debug output for app startup

Source: https://expressjs.com/en/5x/guide/debugging/

Example output from running the sample app with DEBUG enabled, showing Express configuration and router setup logs.

```text
$ DEBUG=express:*,router,router:* node index.js
  express:application set "x-powered-by" to true +0ms
  express:application set "etag" to 'weak' +3ms
  express:application set "etag fn" to [Function: generateETag] +0ms
  express:application set "env" to 'development' +1ms
  express:application set "query parser" to 'simple' +0ms
  express:application set "query parser fn" to [Function: parse] +0ms
  express:application set "subdomain offset" to 2 +1ms
  express:application set "trust proxy" to false +0ms
  express:application set "trust proxy fn" to [Function: trustNone] +1ms
  express:application booting in development mode +0ms
  express:application set "view" to [Function: View] +0ms
  express:application set "views" to '/projects/example/views' +1ms
  express:application set "jsonp callback name" to 'callback' +0ms
  router use '/' jsonParser +0ms
  router:layer new '/' +0ms
  router:route new '/' +0ms
  router:layer new '/' +3ms
  router:route get / +0ms
  router:layer new '/' +1ms
  router use '/users' router +4ms
  router:layer new '/users' +0ms
  router:route new '/' +1ms
  router:layer new '/' +0ms
  router:route get / +1ms
  router:layer new '/' +1ms
```

--------------------------------

### app.get() example in JavaScript

Source: https://expressjs.com/en/5x/api/application/

Routes HTTP GET requests to the homepage path. The callback sends a response using res.send().

```JavaScript
app.get('/', (req, res) => {
  res.send('GET request to homepage');
});
```

--------------------------------

### req.subdomains example

Source: https://expressjs.com/en/5x/api/request/

Shows how to get the subdomains array from the Host header. The comment shows the Host and the output is the array of subdomains.

```javascript
// Host: "tobi.ferrets.example.com"
console.dir(req.subdomains);
// => ["ferrets", "tobi"]
```

--------------------------------

### Path example: exact path '/abcd' (JavaScript)

Source: https://expressjs.com/en/5x/api/application/

Mounts middleware on the path '/abcd', matching the exact path and any sub-paths starting with '/abcd/'.

```javascript
app.use('/abcd', (req, res, next) => {
  next();
});
```

--------------------------------

### JavaScript example of app.METHOD() routing

Source: https://expressjs.com/en/5x/api/application/

Shows how to define GET and POST routes using app.get() and app.post(), and how to use bracket notation for methods that are invalid JavaScript variable names, such as 'm-search'.

```JavaScript
app.get('/', (req, res) => {
  res.send('GET request to homepage');
});

app.post('/', (req, res) => {
  res.send('POST request to homepage');
});

// methods that are invalid JavaScript variable names use bracket notation
app['m-search']('/', (req, res) => {
  res.send('M-SEARCH request to homepage');
});
```

--------------------------------

### req.route example (JavaScript and TypeScript)

Source: https://expressjs.com/en/5x/api/request/

Shows how to access the currently-matched route object. The example logs the route with depth null and sends 'GET'.

```javascript
app.get('/user/{:id}', (req, res) => {
  console.dir(req.route, { depth: null });
  res.send('GET');
});
```

```typescript
import { type Request, type Response } from 'express';

app.get('/user/{:id}', (req: Request, res: Response) => {
  console.dir(req.route, { depth: null });
  res.send('GET');
});
```

--------------------------------

### app.post() example (TypeScript)

Source: https://expressjs.com/en/5x/api/application/

TypeScript version of the app.post() example, with Request and Response type annotations.

```TypeScript
import { type Request, type Response } from 'express';

app.post('/', (req: Request, res: Response) => {
  res.send('POST request to homepage');
});
```

--------------------------------

### Router middleware and route example (JavaScript)

Source: https://expressjs.com/en/5x/api/router/

Shows how to add middleware and a GET route to a router object. The middleware is invoked for any request passed to the router, and the route handles requests ending in /events.

```javascript
// invoked for any requests passed to this router
router.use((req, res, next) => {
  // .. some logic here .. like any other middleware
  next();
});

// will handle any request that ends in /events
// depends on where the router is "use()'d"
router.get('/events', (req, res, next) => {
  // ..
});
```

--------------------------------

### app.path() example (TypeScript)

Source: https://expressjs.com/en/5x/api/application/

TypeScript version of the app.path() example, using Express type annotations. Output is the same as the JavaScript version.

```TypeScript
import express, { type Express } from 'express';

const app: Express = express();
const blog: Express = express();
const blogAdmin: Express = express();

app.use('/blog', blog);
blog.use('/admin', blogAdmin);

console.log(app.path()); // ''
console.log(blog.path()); // '/blog'
console.log(blogAdmin.path()); // '/blog/admin'
```

--------------------------------

### express.static Middleware Examples

Source: https://expressjs.com/en/5x/api/application/

Examples of using the express.static middleware to serve static content.

```APIDOC
## express.static Middleware Examples

### Description
Examples of using the express.static middleware to serve static content.

### Method
app.use()

### Endpoint
app.use(express.static(root, [options]))

### Parameters
#### Path
- **root** (string) - Required - The root directory from which to serve static assets.

#### Options
- **options** (object) - Optional - Additional options for express.static.

### Request Example
Serve static content from the 'public' directory:
```javascript
app.use(express.static(path.join(__dirname, 'public')));
```

Mount at '/static' to serve static content only when request path is prefixed with '/static':
```javascript
app.use('/static', express.static(path.join(__dirname, 'public')));
```

Disable logging for static content requests by loading logger after static middleware:
```javascript
app.use(express.static(path.join(__dirname, 'public')));
app.use(logger());
```

Serve static files from multiple directories with precedence:
```javascript
app.use(express.static(path.join(__dirname, 'public')));
app.use(express.static(path.join(__dirname, 'files')));
app.use(express.static(path.join(__dirname, 'uploads')));
```

### Response
Serves static files; no response body for middleware itself.
```

--------------------------------

### Basic route definition with router.get (JavaScript)

Source: https://expressjs.com/en/5x/api/router/

Defines a simple GET route that responds with 'hello world'. Query strings are not considered when matching, so 'GET /' and 'GET /?name=tobi' both match.

```JavaScript
router.get('/', (req, res) => {
  res.send('hello world');
});
```

--------------------------------

### app.listen() example in CommonJS (index.cjs)

Source: https://expressjs.com/en/5x/api/application/

CommonJS module example using require() to create an Express app and listen on a TCP port or a UNIX socket.

```JavaScript
const express = require('express');
const app = express();

app.listen(3000); // bind and listen on a TCP port
app.listen('/tmp/sock'); // or listen on a UNIX socket
```

--------------------------------

### req.baseUrl example (TypeScript)

Source: https://expressjs.com/en/5x/api/request/

TypeScript version of the req.baseUrl example.

```TypeScript
import express, { type Request, type Response } from 'express';

const greet = express.Router();

greet.get('/jp', (req: Request, res: Response) => {
  console.log(req.baseUrl); // /greet
  res.send('Konnichiwa!');
});

app.use('/greet', greet); // load the router on '/greet'
```

--------------------------------

### req.baseUrl example (JavaScript)

Source: https://expressjs.com/en/5x/api/request/

Shows how req.baseUrl returns the matched path string when a router is mounted on a path.

```JavaScript
const greet = express.Router();

greet.get('/jp', (req, res) => {
  console.log(req.baseUrl); // /greet
  res.send('Konnichiwa!');
});

app.use('/greet', greet); // load the router on '/greet'
```

--------------------------------

### app.get() example in TypeScript

Source: https://expressjs.com/en/5x/api/application/

TypeScript version of the app.get() example, with typed Request and Response parameters imported from 'express'.

```TypeScript
import { type Request, type Response } from 'express';

app.get('/', (req: Request, res: Response) => {
  res.send('GET request to homepage');
});
```

--------------------------------

### router.all() equivalent with separate calls

Source: https://expressjs.com/en/5x/api/router/

Equivalent to the previous example, but using two separate router.all() calls for requireAuthentication and loadUser.

```javascript
router.all('{*splat}', requireAuthentication);
router.all('{*splat}', loadUser);
```

--------------------------------

### Install TypeScript and type definitions with bun

Source: https://expressjs.com/en/5x/starter/installing/

Installs TypeScript, @types/express, and @types/node as dev dependencies using Bun.

```bash
bun add --dev typescript @types/express @types/node
```

--------------------------------

### app.post() example (JavaScript)

Source: https://expressjs.com/en/5x/api/application/

Routes HTTP POST requests to the root path and sends a response. The callback receives req and res objects.

```JavaScript
app.post('/', (req, res) => {
  res.send('POST request to homepage');
});
```

--------------------------------

### app.put() example (TypeScript)

Source: https://expressjs.com/en/5x/api/application/

TypeScript version of the app.put() example, with Request and Response type annotations.

```TypeScript
import { type Request, type Response } from 'express';

app.put('/', (req: Request, res: Response) => {
  res.send('PUT request to homepage');
});
```

--------------------------------

### Equivalent app.all() calls for authentication and user loading

Source: https://expressjs.com/en/5x/api/application/

Shows the equivalent of the previous example by splitting the middleware into two separate app.all() calls, both using the '{*splat}' pattern.

```JavaScript
app.all('{*splat}', requireAuthentication);
app.all('{*splat}', loadUser);
```

--------------------------------

### app.put() example (JavaScript)

Source: https://expressjs.com/en/5x/api/application/

Routes HTTP PUT requests to the root path and sends a response.

```JavaScript
app.put('/', (req, res) => {
  res.send('PUT request to homepage');
});
```

--------------------------------

### Path example: exact path '/abcd' (TypeScript)

Source: https://expressjs.com/en/5x/api/application/

TypeScript version of mounting middleware on '/abcd'.

```typescript
import { type Request, type Response, type NextFunction } from 'express';

app.use('/abcd', (req: Request, res: Response, next: NextFunction) => {
  next();
});
```

--------------------------------

### Router middleware and route example (TypeScript)

Source: https://expressjs.com/en/5x/api/router/

TypeScript version of the router example, with type annotations for Request, Response, and NextFunction imported from 'express'.

```typescript
import { type Request, type Response, type NextFunction } from 'express';

// invoked for any requests passed to this router
router.use((req: Request, res: Response, next: NextFunction) => {
  // .. some logic here .. like any other middleware
  next();
});

// will handle any request that ends in /events
// depends on where the router is "use()'d"
router.get('/events', (req: Request, res: Response, next: NextFunction) => {
  // ..
});
```

--------------------------------

### Install TypeScript and type definitions with pnpm

Source: https://expressjs.com/en/5x/starter/installing/

Installs TypeScript, @types/express, and @types/node as dev dependencies using pnpm.

```bash
pnpm add --save-dev typescript @types/express @types/node
```

--------------------------------

### express.static example with options (ESM)

Source: https://expressjs.com/en/5x/api/express/

Example of using express.static with an options object in ESM (index.mjs). The options are the same as the CommonJS version, using import syntax.

```javascript
import express from 'express';

const app = express();

const options = {
  dotfiles: 'ignore',
  etag: false,
  extensions: ['htm', 'html'],
  index: false,
  maxAge: '1d',
  redirect: false,
  setHeaders(res, path, stat) {
    res.set('x-timestamp', Date.now());
  },
};

app.use(express.static('public', options));
```

--------------------------------

### req.accepts() content negotiation examples

Source: https://expressjs.com/en/5x/api/request/

Shows how to use req.accepts() to check acceptable content types based on the Accept header. Returns the best match or false if none acceptable. Examples cover single MIME types, extensions, arrays, and cases returning false.

```javascript
// Accept: text/html
req.accepts('html');
// => "html"

// Accept: text/*, application/json
req.accepts('html');
// => "html"
req.accepts('text/html');
// => "text/html"
req.accepts(['json', 'text']);
// => "json"
req.accepts('application/json');
// => "application/json"

// Accept: text/*, application/json
req.accepts('image/png');
req.accepts('png');
// => false

// Accept: text/*;q=.5, application/json
req.accepts(['html', 'json']);
// => "json"
```

--------------------------------

### TypeScript example of app.METHOD() routing

Source: https://expressjs.com/en/5x/api/application/

TypeScript version of the routing example, importing Request and Response types from Express and using type annotations for the callback parameters.

```TypeScript
import { type Request, type Response } from 'express';

app.get('/', (req: Request, res: Response) => {
  res.send('GET request to homepage');
});

app.post('/', (req: Request, res: Response) => {
  res.send('POST request to homepage');
});

// methods that are invalid JavaScript variable names use bracket notation
app['m-search']('/', (req: Request, res: Response) => {
  res.send('M-SEARCH request to homepage');
});
```

--------------------------------

### app.delete() example for homepage (TypeScript)

Source: https://expressjs.com/en/5x/api/application/

TypeScript version of the app.delete() example, with explicit types for req and res. Imports Request and Response from 'express'.

```TypeScript
import { type Request, type Response } from 'express';

app.delete('/', (req: Request, res: Response) => {
  res.send('DELETE request to homepage');
});
```

--------------------------------

### Install TypeScript and type definitions with npm

Source: https://expressjs.com/en/5x/starter/installing/

Installs TypeScript, @types/express, and @types/node as development dependencies for TypeScript support.

```bash
npm install --save-dev typescript @types/express @types/node
```

--------------------------------

### Install TypeScript and type definitions with yarn

Source: https://expressjs.com/en/5x/starter/installing/

Installs TypeScript, @types/express, and @types/node as dev dependencies using Yarn.

```bash
yarn add --dev typescript @types/express @types/node
```

--------------------------------

### app.delete() example for homepage (JavaScript)

Source: https://expressjs.com/en/5x/api/application/

Handles DELETE requests to the homepage ('/') and sends a response message.

```JavaScript
app.delete('/', (req, res) => {
  res.send('DELETE request to homepage');
});
```

--------------------------------

### Create Express Application

Source: https://expressjs.com/en/5x/api/application/

Shows how to create an Express application by calling the top-level express() function and defining a simple GET route.

```APIDOC
## Create Express Application

### Description
Create an Express application by calling the top-level `express()` function. The `app` object is used to define routes and configure the application.

### Method
N/A (Application creation)

### Endpoint
N/A

### Parameters
None

### Request Example
```javascript
var express = require('express');
var app = express();

app.get('/', function (req, res) {
  res.send('hello world');
});

app.listen(3000);
```

### Response
No response body. The application starts listening on the specified port.
```

--------------------------------

### Two routers mounted on same path (TypeScript)

Source: https://expressjs.com/en/5x/api/router/

TypeScript version of the same example, using typed Request, Response, and NextFunction. Demonstrates the same middleware behavior.

```typescript
import express, { type Request, type Response, type NextFunction } from 'express';
import { basic } from './authenticate';

const authRouter = express.Router();
const openRouter = express.Router();

authRouter.use(basic(usersdb));

authRouter.get('/:user_id/edit', (req: Request, res: Response, next: NextFunction) => {
  // ... Edit user UI ...
});
openRouter.get('/', (req: Request, res: Response, next: NextFunction) => {
  // ... List users ...
});
openRouter.get('/:user_id', (req: Request, res: Response, next: NextFunction) => {
  // ... View user ...
});

app.use('/users', authRouter);
app.use('/users', openRouter);
```

--------------------------------

### Example output of req.route

Source: https://expressjs.com/en/5x/api/request/

Shows the output of console.dir(req.route, { depth: null }) for the route '/user/{:id}'. The output includes the Route object with path, stack, and methods.

```javascript
Route {
  path: '/user/{:id}',
  stack: [
    Layer {
      handle: [Function (anonymous)],
      keys: [],
      name: '<anonymous>',
      params: undefined,
      path: undefined,
      slash: false,
      matchers: [ [Function: match] ],
      method: 'get'
    }
  ],
  methods: [Object: null prototype] { get: true }
}
```

--------------------------------

### Debug output for a request to /users

Source: https://expressjs.com/en/5x/guide/debugging/

Example output when a request is made to the app, showing router dispatching and JSON parser logs.

```text
  router dispatching GET /users +712ms
  router jsonParser  : /users +1ms
  router trim prefix (/users) from url /users +2ms
  router router /users : /users +0ms
  router dispatching GET / +0ms
```

--------------------------------

### req.res example (JavaScript and TypeScript)

Source: https://expressjs.com/en/5x/api/request/

Shows that req.res holds a reference to the response object. The example logs whether req.res === res and sends 'OK'.

```javascript
app.get('/', (req, res) => {
  console.dir(req.res === res);
  // => true
  res.send('OK');
});
```

```typescript
import { type Request, type Response } from 'express';

app.get('/', (req: Request, res: Response) => {
  console.dir(req.res === res);
  // => true
  res.send('OK');
});
```

--------------------------------

### express.static example with options (CommonJS)

Source: https://expressjs.com/en/5x/api/express/

Example of using express.static with an options object in CommonJS (index.cjs). The options include dotfiles: 'ignore', etag: false, extensions: ['htm', 'html'], index: false, maxAge: '1d', redirect: false, and a setHeaders function that sets an x-timestamp header.

```javascript
const express = require('express');
const app = express();

const options = {
  dotfiles: 'ignore',
  etag: false,
  extensions: ['htm', 'html'],
  index: false,
  maxAge: '1d',
  redirect: false,
  setHeaders(res, path, stat) {
    res.set('x-timestamp', Date.now());
  },
};

app.use(express.static('public', options));
```

--------------------------------

### req.signedCookies example

Source: https://expressjs.com/en/5x/api/request/

Shows how to access a signed cookie value. The comment shows the Cookie header and the output is the unsigned value.

```javascript
// Cookie: user=tobi.CP7AWaXDfAKIRfH49dQzKJx7sKzzSoPq7/AcBBRVwlI3
console.dir(req.signedCookies.user);
// => "tobi"
```

--------------------------------

### app.route() chain for /events (TypeScript)

Source: https://expressjs.com/en/5x/api/application/

TypeScript version of the app.route() example, with type annotations for Express, Request, Response, and NextFunction.

```typescript
import express, { type Express, type Request, type Response, type NextFunction } from 'express';

const app: Express = express();

app
  .route('/events')
  .all((req: Request, res: Response, next: NextFunction) => {
    // runs for all HTTP verbs first
    // think of it as route specific middleware!
  })
  .get((req: Request, res: Response, next: NextFunction) => {
    res.json({});
  })
  .post((req: Request, res: Response, next: NextFunction) => {
    // maybe add a new event...
  });
```

--------------------------------

### Get request protocol with req.protocol

Source: https://expressjs.com/en/5x/api/request/

Shows how to get the request protocol string ('http' or 'https') using req.protocol. The example outputs 'http'.

```JavaScript
console.dir(req.protocol);
// => "http"
```

--------------------------------

### Array path: matches '/abcd', '/xyza', '/lmn', '/pqr' (TypeScript)

Source: https://expressjs.com/en/5x/api/application/

TypeScript version of the array path example.

```typescript
import { type Request, type Response, type NextFunction } from 'express';

app.use(['/abcd', '/xyza', /\/lmn|\/pqr/], (req: Request, res: Response, next: NextFunction) => {
  next();
});
```

--------------------------------

### app.path() example (JavaScript)

Source: https://expressjs.com/en/5x/api/application/

Shows how app.path() returns the canonical path for mounted apps. The output is '' for the main app, '/blog' for the blog app, and '/blog/admin' for the blogAdmin app.

```JavaScript
const app = express();
const blog = express();
const blogAdmin = express();

app.use('/blog', blog);
blog.use('/admin', blogAdmin);

console.log(app.path()); // ''
console.log(blog.path()); // '/blog'
console.log(blogAdmin.path()); // '/blog/admin'
```

--------------------------------

### req.originalUrl, req.baseUrl, req.path in mounted middleware (TypeScript)

Source: https://expressjs.com/en/5x/api/request/

TypeScript version of the mounted middleware example, with type annotations.

```typescript
import { type Request, type Response, type NextFunction } from 'express';

// GET 'http://www.example.com/admin/new?sort=desc'
app.use('/admin', (req: Request, res: Response, next: NextFunction) => {
  console.dir(req.originalUrl); // '/admin/new?sort=desc'
  console.dir(req.baseUrl); // '/admin'
  console.dir(req.path); // '/new'
  next();
});
```

--------------------------------

### Wildcard parameter array with req.params.file (JavaScript)

Source: https://expressjs.com/en/5x/api/request/

Demonstrates that wildcard parameters are arrays of path segments split on '/'. For route /files/*file, req.params.file contains an array of segments. The example shows outputs for GET /files/note.txt and GET /files/images/image.png.

```JavaScript
app.get('/files/*file', (req, res) => {
  console.dir(req.params.file);
  // GET /files/note.txt
  // => [ 'note.txt' ]
  // GET /files/images/image.png
  // => [ 'images', 'image.png' ]
});
```

--------------------------------

### Optional segment with dot extension (JavaScript)

Source: https://expressjs.com/en/5x/guide/routing/

Defines a route where the extension is optional. When the segment is absent, the parameter is omitted from req.params. Example: GET /image.png yields { file: 'image', ext: 'png' }, GET /image yields { file: 'image' }.

```JavaScript
app.get('/:file{.:ext}', (req, res) => {
  // GET /image.png => req.params = { file: 'image', ext: 'png' }
  // GET /image => req.params = { file: 'image' }
  res.send('ok');
});
```

--------------------------------

### Async route handler with async/await (TypeScript)

Source: https://expressjs.com/en/5x/guide/error-handling/

TypeScript version of the async handler example. Requires importing Request and Response types.

```TypeScript
import { type Request, type Response } from 'express';

app.get('/user/:id', async (req: Request, res: Response) => {
  const user = await getUserById(req.params.id);
  res.send(user);
});
```

--------------------------------

### router.param() called only once (TypeScript)

Source: https://expressjs.com/en/5x/api/router/

TypeScript version of the 'called only once' example. Imports Request, Response, and NextFunction types. Defines a param callback for ':id' and two GET routes for '/user/:id'. On GET /user/42, the console output is 'CALLED ONLY ONCE', 'although this matches', and 'and this matches too'.

```TypeScript
import { type Request, type Response, type NextFunction } from 'express';

router.param('id', (req: Request, res: Response, next: NextFunction, id: string) => {
  console.log('CALLED ONLY ONCE');
  next();
});

router.get('/user/:id', (req: Request, res: Response, next: NextFunction) => {
  console.log('although this matches');
  next();
});

router.get('/user/:id', (req: Request, res: Response) => {
  console.log('and this matches too');
  res.end();
});
```

--------------------------------

### Body parsing middleware to populate req.body (ESM)

Source: https://expressjs.com/en/5x/api/request/

ES module version of the body parsing example. Uses import syntax and the same middleware setup.

```javascript
import express from 'express';

const app = express();

app.use(express.json()); // for parsing application/json
app.use(express.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded

app.post('/profile', (req, res, next) => {
  console.log(req.body);
  res.json(req.body);
});
```

--------------------------------

### String route paths in TypeScript

Source: https://expressjs.com/en/5x/guide/routing/

TypeScript version of the string route paths example, with type annotations for Request and Response. Same behavior as the JavaScript version.

```TypeScript
import { type Request, type Response } from 'express';

app.get('/', (req: Request, res: Response) => {
  res.send('root');
});

app.get('/about', (req: Request, res: Response) => {
  res.send('about');
});

app.get('/random.text', (req: Request, res: Response) => {
  res.send('random.text');
});
```

--------------------------------

### Get req.host from Host header

Source: https://expressjs.com/en/5x/api/request/

Contains the host derived from the Host HTTP header. When trust proxy is enabled, uses X-Forwarded-Host. Shows examples with port and IPv6.

```javascript
// Host: "example.com:3000"
console.dir(req.host);
// => 'example.com:3000'

// Host: "[::1]:3000"
console.dir(req.host);
// => '[::1]:3000'
```

--------------------------------

### Regular expression route paths in TypeScript

Source: https://expressjs.com/en/5x/guide/routing/

TypeScript version of the regular expression route paths example, with type annotations for Request and Response.

```TypeScript
import { type Request, type Response } from 'express';

// Matches any path containing "a"
app.get(/a/, (req: Request, res: Response) => {
  res.send('/a/');
});

// Matches paths ending with "fly" (butterfly, dragonfly, etc.)
app.get(/.*fly$/, (req: Request, res: Response) => {
  res.send('/.*fly$/');
});
```

--------------------------------

### JavaScript wildcard route: /files/*filepath

Source: https://expressjs.com/en/5x/guide/routing/

Defines a wildcard route that captures any path after the prefix as an array of segments. The example shows req.params.filepath as ['images', 'logo.png'] for GET /files/images/logo.png.

```javascript
app.get('/files/*filepath', (req, res) => {
  // GET /files/images/logo.png
  console.dir(req.params.filepath);
  // => [ 'images', 'logo.png' ]
  res.send(`File: ${req.params.filepath.join('/')}`);
});
```

--------------------------------

### Start app with --inspect-brk to pause on first line

Source: https://expressjs.com/en/5x/guide/debugging/

Use --inspect-brk to pause execution on the first line until a debugger attaches, useful for debugging startup code.

```bash
$ node --inspect-brk index.js
```

--------------------------------

### router.use() middleware mounting example (CommonJS, ESM, TypeScript)

Source: https://expressjs.com/en/5x/api/router/

Shows how to mount middleware on a router using router.use() with and without a path. The mount path is stripped and not visible to the middleware. Middleware is invoked sequentially in the order defined.

```javascript
const express = require('express');
const app = express();
const router = express.Router();

// simple logger for this router's requests
// all requests to this router will first hit this middleware
router.use((req, res, next) => {
  console.log('%s %s %s', req.method, req.url, req.path);
  next();
});

// this will only be invoked if the path starts with /bar from the mount point
router.use('/bar', (req, res, next) => {
  // ... maybe some additional /bar logging ...
  next();
});

// always invoked
router.use((req, res, next) => {
  res.send('Hello World');
});

app.use('/foo', router);

app.listen(3000);
```

```javascript
import express from 'express';

const app = express();
const router = express.Router();

// simple logger for this router's requests
// all requests to this router will first hit this middleware
router.use((req, res, next) => {
  console.log('%s %s %s', req.method, req.url, req.path);
  next();
});

// this will only be invoked if the path starts with /bar from the mount point
router.use('/bar', (req, res, next) => {
  // ... maybe some additional /bar logging ...
  next();
});

// always invoked
router.use((req, res, next) => {
  res.send('Hello World');
});

app.use('/foo', router);

app.listen(3000);
```

```typescript
import express, { type Request, type Response, type NextFunction } from 'express';

const app = express();
const router = express.Router();

// simple logger for this router's requests
// all requests to this router will first hit this middleware
router.use((req: Request, res: Response, next: NextFunction) => {
  console.log('%s %s %s', req.method, req.url, req.path);
  next();
});

// this will only be invoked if the path starts with /bar from the mount point
router.use('/bar', (req: Request, res: Response, next: NextFunction) => {
  // ... maybe some additional /bar logging ...
  next();
});

// always invoked
router.use((req: Request, res: Response, next: NextFunction) => {
  res.send('Hello World');
});

app.use('/foo', router);

app.listen(3000);
```

--------------------------------

### Access named route parameter with req.params.name

Source: https://expressjs.com/en/5x/api/request/

Shows how to access a named route parameter using req.params.name. For route /user/:name, the 'name' property is available as req.params.name. The example uses GET /user/tj and outputs 'tj'.

```JavaScript
// GET /user/tj
console.dir(req.params.name);
// => "tj"
```

--------------------------------

### Regex capture group with req.params[0] (JavaScript)

Source: https://expressjs.com/en/5x/api/request/

Shows how capture groups from a regular expression route are available as integer keys on req.params. For route /^\/file\/(.*)$/, req.params[0] contains the captured group. Example uses GET /file/javascripts/jquery.js and outputs 'javascripts/jquery.js'.

```JavaScript
app.use(/^\/file\/(.*)$/, (req, res) => {
  // GET /file/javascripts/jquery.js
  console.dir(req.params[0]);
  // => "javascripts/jquery.js"
});
```

--------------------------------

### router.route() with multiple HTTP method handlers (TypeScript, index.ts)

Source: https://expressjs.com/en/5x/api/router/

TypeScript version of the router.route() example, saved as index.ts. Imports express and types. Uses router.param() for 'user_id' and defines handlers for all, get, put, post, and delete on the same path. The .all() handler runs for all HTTP verbs first.

```TypeScript
import express, { type Request, type Response, type NextFunction } from 'express';

const router = express.Router();

router.param('user_id', (req: Request, res: Response, next: NextFunction, id: string) => {
  // sample user, would actually fetch from DB, etc...
  req.user = {
    id,
    name: 'TJ',
  };
  next();
});

router
  .route('/users/:user_id')
  .all((req: Request, res: Response, next: NextFunction) => {
    // runs for all HTTP verbs first
    // think of it as route specific middleware!
    next();
  })
  .get((req: Request, res: Response, next: NextFunction) => {
    res.json(req.user);
  })
  .put((req: Request, res: Response, next: NextFunction) => {
    // just an example of maybe updating the user
    req.user.name = req.params.name;
    // save user ... etc
    res.json(req.user);
  })
  .post((req: Request, res: Response, next: NextFunction) => {
    next(new Error('not implemented'));
  })
  .delete((req: Request, res: Response, next: NextFunction) => {
    next(new Error('not implemented'));
  });
```

--------------------------------

### Handle app.on('mount') event in JavaScript

Source: https://expressjs.com/en/5x/api/application/

Shows how to listen for the 'mount' event on a sub-app. The callback receives the parent app as its only argument. Sub-apps do not inherit settings with default values; they must be set in the sub-app.

```javascript
const admin = express();

admin.on('mount', (parent) => {
  console.log('Admin Mounted');
  console.log(parent); // refers to the parent app
});

admin.get('/', (req, res) => {
  res.send('Admin Homepage');
});

app.use('/admin', admin);
```

--------------------------------

### app.all() with splat pattern for authentication and user loading

Source: https://expressjs.com/en/5x/api/application/

Uses the '{*splat}' pattern to match all paths. The callback chain requires authentication and loads a user for all routes from that point on.

```JavaScript
app.all('{*splat}', requireAuthentication, loadUser);
```

--------------------------------

### app.listen()

Source: https://expressjs.com/en/5x/api/application/

Binds and listens for connections on the specified host and port, or starts a UNIX socket and listens for connections on the given path. This method is identical to Node's http.Server.listen().

```APIDOC
## app.listen()

### Description
Binds and listens for connections on the specified host and port, or starts a UNIX socket and listens for connections on the given path. This method is identical to Node's http.Server.listen().

### Method
LISTEN

### Endpoint
N/A (method on application object)

### Parameters
#### Query Parameters
- **port** (Number | undefined) - Optional - The TCP port to listen on. If omitted or 0, the OS assigns an arbitrary unused port.
- **host** (String | undefined) - Optional - The host on which to accept connections.
- **backlog** (Number | undefined) - Optional - The maximum length of the queue of pending connections.
- **path** (String | undefined) - Optional - The path of a UNIX socket to listen on, as an alternative to host and port.
- **callback** (Function | undefined) - Optional - A function called once the server is listening. If the server emits an error event (e.g., EADDRINUSE), the error is passed to this callback.

### Returns
`http.Server`

### Request Example
```javascript
const express = require('express');
const app = express();

app.listen(3000); // bind and listen on a TCP port
app.listen('/tmp/sock'); // or listen on a UNIX socket
```

### Response
No explicit response schema documented.
```

--------------------------------

### app.route() chain for /events (JavaScript)

Source: https://expressjs.com/en/5x/api/application/

Creates a route chain for /events using app.route(), handling all HTTP verbs with .all() and then .get() and .post() with middleware. The .all() method runs first for all verbs.

```javascript
const app = express();

app
  .route('/events')
  .all((req, res, next) => {
    // runs for all HTTP verbs first
    // think of it as route specific middleware!
  })
  .get((req, res, next) => {
    res.json({});
  })
  .post((req, res, next) => {
    // maybe add a new event...
  });
```

--------------------------------

### express.static example with options (TypeScript)

Source: https://expressjs.com/en/5x/api/express/

Example of using express.static with an options object in TypeScript (index.ts). The options are the same as the other versions, with type annotations for the Express app.

```typescript
import express, { type Express } from 'express';

const app: Express = express();

const options = {
  dotfiles: 'ignore',
  etag: false,
  extensions: ['htm', 'html'],
  index: false,
  maxAge: '1d',
  redirect: false,
  setHeaders(res, path, stat) {
    res.set('x-timestamp', Date.now());
  },
};

app.use(express.static('public', options));
```

--------------------------------

### app.all()

Source: https://expressjs.com/en/5x/api/application/

This method is like the standard app.METHOD() methods, except it matches all HTTP verbs. It is useful for mapping global logic for specific path prefixes or arbitrary matches.

```APIDOC
## app.all()

### Description
This method is like the standard app.METHOD() methods, except it matches all HTTP verbs. It is useful for mapping global logic for specific path prefixes or arbitrary matches.

### Method
ALL

### Endpoint
(path)

### Parameters
#### Path Parameters
- **path** (String | RegExp | Array) - Required - The path for which the middleware function is invoked; can be a string, a path pattern, a regular expression pattern, or an array of combinations.

#### Request Body
- **callback** (Function | Function[]) - Required - Callback functions; can be a middleware function, a series of middleware functions, an array of middleware functions, or a combination. Can invoke next('route') to bypass remaining route callbacks.

### Request Example
```javascript
app.all('/secret', (req, res, next) => {
  console.log('Accessing the secret section ...');
  next(); // pass control to the next handler
});
```

### Response
No specific response is defined; the callback handles the response.

### Error Handling
No specific error handling is defined; errors are handled by the callback or subsequent middleware.
```

--------------------------------

### app.use(path, callback)

Source: https://expressjs.com/en/5x/api/application/

Mounts the specified middleware function or functions at the specified path. The middleware is executed when the base of the requested path matches the path.

```APIDOC
## app.use(path, callback)

### Description
Mounts the specified middleware function or functions at the specified path. The middleware is executed when the base of the requested path matches the path.

### Method
app.use

### Parameters
#### Path Parameters
- **path** (String | RegExp | Array | undefined) - Optional - The path for which the middleware function is invoked. Can be a string, path pattern, regular expression, or array of combinations. Defaults to '/'.

#### Callback
- **callback** (Function | Function[]) - Required - Middleware function or array of middleware functions. Can also be a series of middleware functions. These callbacks can invoke `next('route')` to bypass remaining route callbacks.

### Description Details
- A route will match any path that follows its path immediately with a `/`. For example, `app.use('/apple', ...)` matches `/apple`, `/apple/images`, `/apple/images/news`, etc.
- Middleware mounted without a path will be executed for every request.

### Request Example
```javascript
app.use((req, res, next) => {
  console.log('Time: %d', Date.now());
  next();
});
```

### TypeScript Example
```typescript
import { type Request, type Response, type NextFunction } from 'express';

app.use((req: Request, res: Response, next: NextFunction) => {
  console.log('Time: %d', Date.now());
  next();
});
```
```

--------------------------------

### Get request path with req.path

Source: https://expressjs.com/en/5x/api/request/

Shows how to get the path part of the request URL using req.path. For example.com/users?sort=desc, req.path returns '/users'.

```JavaScript
// example.com/users?sort=desc
console.dir(req.path);
// => "/users"
```

--------------------------------

### req.originalUrl: Log original URL for a GET request

Source: https://expressjs.com/en/5x/api/request/

Logs the original URL for a GET request to /search?q=something, showing the full query string.

```javascript
// GET /search?q=something
console.dir(req.originalUrl);
// => "/search?q=something"
```

--------------------------------

### req.method: Log HTTP method in middleware (JavaScript)

Source: https://expressjs.com/en/5x/api/request/

Middleware that logs the HTTP method of the request using req.method. Outputs 'GET' for a GET request.

```javascript
app.use((req, res, next) => {
  console.dir(req.method);
  // => 'GET'
  next();
});
```

--------------------------------

### res.download() usage examples

Source: https://expressjs.com/en/5x/api/response/

Shows three ways to call res.download: with just a path, with a custom filename, and with an error callback. The callback must handle errors explicitly, checking res.headersSent because the response may be partially sent.

```javascript
res.download('/report-12345.pdf');

res.download('/report-12345.pdf', 'report.pdf');

res.download('/report-12345.pdf', 'report.pdf', (err) => {
  if (err) {
    // Handle error, but keep in mind the response may be partially-sent
    // so check res.headersSent
  } else {
    // decrement a download credit, etc.
  }
});
```

--------------------------------

### res.sendFile fine-grained file serving (JavaScript)

Source: https://expressjs.com/en/5x/api/response/

Example using res.sendFile to provide fine-grained support for serving files, with a permission check via req.user.mayViewFilesFrom. If permission is granted, sends the file; otherwise responds with 403 and a message.

```JavaScript
app.get('/user/:uid/photos/:file', (req, res) => {
  const uid = req.params.uid;
  const file = req.params.file;

  req.user.mayViewFilesFrom(uid, (yes) => {
    if (yes) {
      res.sendFile(`/uploads/${uid}/${file}`);
    } else {
      res.status(403).send("Sorry! You can't see that.");
    }
  });
});
```

--------------------------------

### Create an Express application (CommonJS)

Source: https://expressjs.com/en/5x/api/express/

Shows how to import and create an Express app using CommonJS require syntax.

```javascript
const express = require('express');
const app = express();
```

--------------------------------

### JavaScript wildcard with braces: /{*splat}

Source: https://expressjs.com/en/5x/guide/routing/

Shows how wrapping a wildcard in braces matches the root path as well. For GET /, req.params is empty and splat is omitted; for GET /foo/bar, req.params.splat is ['foo', 'bar'].

```javascript
// Matches / , /foo , /foo/bar , etc.
app.get('/{*splat}', (req, res) => {
  // GET / => req.params = {}, splat is omitted
  // GET /foo/bar => req.params.splat = [ 'foo', 'bar' ]
  res.send('ok');
});
```

--------------------------------

### req.range() usage example

Source: https://expressjs.com/en/5x/api/request/

Parses the Range header from the request. Returns an array of ranges or negative numbers indicating errors (-2 malformed, -1 unsatisfiable). The example checks the range type and iterates over ranges.

```javascript
// parse header from request
const range = req.range(1000);

// the type of the range
if (range.type === 'bytes') {
  // the ranges
  range.forEach((r) => {
    // do something with r.start and r.end
  });
}
```

--------------------------------

### Optional segment with dot extension (TypeScript)

Source: https://expressjs.com/en/5x/guide/routing/

TypeScript version of the optional extension route. Uses imported Request and Response types. Same behavior: GET /image.png yields { file: 'image', ext: 'png' }, GET /image yields { file: 'image' }.

```TypeScript
import { type Request, type Response } from 'express';

app.get('/:file{.:ext}', (req: Request, res: Response) => {
  // GET /image.png => req.params = { file: 'image', ext: 'png' }
  // GET /image => req.params = { file: 'image' }
  res.send('ok');
});
```

--------------------------------

### app.listen() implementation as convenience method

Source: https://expressjs.com/en/5x/api/application/

The app.listen() method returns an http.Server object and is a convenience method for creating an HTTP server and calling listen(). All forms of Node's http.Server.listen() are supported.

```javascript
app.listen = function () {
  const server = http.createServer(this);
  return server.listen.apply(server, arguments);
};
```

--------------------------------

### Create an Express application (ESM)

Source: https://expressjs.com/en/5x/api/express/

Shows how to import and create an Express app using ES module import syntax.

```javascript
import express from 'express';

const app = express();
```

--------------------------------

### router.param() called only once (JavaScript)

Source: https://expressjs.com/en/5x/api/router/

Shows that a param callback is called only once per request-response cycle even if the parameter matches multiple routes. Defines a param callback for ':id' and two GET routes for '/user/:id'. On GET /user/42, the console output is 'CALLED ONLY ONCE', 'although this matches', and 'and this matches too'.

```JavaScript
router.param('id', (req, res, next, id) => {
  console.log('CALLED ONLY ONCE');
  next();
});

router.get('/user/:id', (req, res, next) => {
  console.log('although this matches');
  next();
});

router.get('/user/:id', (req, res) => {
  console.log('and this matches too');
  res.end();
});
```

--------------------------------

### Create an Express application (TypeScript)

Source: https://expressjs.com/en/5x/api/express/

Shows how to import and create an Express app with TypeScript type annotations.

```typescript
import express, { type Express } from 'express';

const app: Express = express();
```
Tokens:
Raw