[![npm][npm]][npm-url]
[![node][node]][node-url]
[![tests][tests]][tests-url]
[![coverage][cover]][cover-url]
[![discussion][discussion]][discussion-url]
[![size][size]][size-url]
# webpack-dev-middleware
An express-style development middleware for use with [webpack](https://webpack.js.org)
bundles and allows for serving of the files emitted from webpack.
This should be used for **development only**.
Some of the benefits of using this middleware include:
- No files are written to disk, rather it handles files in memory
- If files changed in watch mode, the middleware delays requests until compiling
has completed.
- Supports hot module reload (HMR).
## Getting Started
First thing's first, install the module:
```console
npm install webpack-dev-middleware --save-dev
```
> [!WARNING]
>
> _We do not recommend installing this module globally._
## Usage
```js
const express = require("express");
const webpack = require("webpack");
const middleware = require("webpack-dev-middleware");
const compiler = webpack({
// webpack options
});
const app = express();
app.use(
middleware(compiler, {
// webpack-dev-middleware options
}),
);
app.listen(3000, () => console.log("Example app listening on port 3000!"));
```
See [below](#other-servers) for an example of use with fastify.
## Options
| Name | Type | Default | Description |
| :---------------------------------------------: | :-------------------------------: | :-------------------------------------------: | :------------------------------------------------------------------------------------------------------------------- |
| **[`methods`](#methods)** | `Array` | `[ 'GET', 'HEAD' ]` | Allows to pass the list of HTTP request methods accepted by the middleware |
| **[`headers`](#headers)** | `Array\|Object\|Function` | `undefined` | Allows to pass custom HTTP headers on each request. |
| **[`index`](#index)** | `boolean\|string` | `index.html` | If `false` (but not `undefined`), the server will not respond to requests to the root URL. |
| **[`mimeTypes`](#mimetypes)** | `Object` | `undefined` | Allows to register custom mime types or extension mappings. |
| **[`mimeTypeDefault`](#mimetypedefault)** | `string` | `undefined` | Allows to register a default mime type when we can't determine the content type. |
| **[`etag`](#tag)** | `boolean\| "weak"\| "strong"` | `undefined` | Enable or disable etag generation. |
| **[`lastModified`](#lastmodified)** | `boolean` | `undefined` | Enable or disable `Last-Modified` header. Uses the file system's last modified value. |
| **[`cacheControl`](#cachecontrol)** | `boolean\|number\|string\|Object` | `undefined` | Enable or disable setting `Cache-Control` response header. |
| **[`cacheImmutable`](#cacheimmutable)** | `boolean` | `undefined` | Enable or disable setting `Cache-Control: public, max-age=31536000, immutable` response header for immutable assets. |
| **[`publicPath`](#publicpath)** | `string` | `undefined` | The public path that the middleware is bound to. |
| **[`stats`](#stats)** | `boolean\|string\|Object` | `stats` (from a configuration) | Stats options object or preset name. |
| **[`serverSideRender`](#serversiderender)** | `boolean` | `undefined` | Instructs the module to enable or disable the server-side rendering mode. |
| **[`writeToDisk`](#writetodisk)** | `boolean\|Function` | `false` | Instructs the module to write files to the configured location on disk as specified in your `webpack` configuration. |
| **[`outputFileSystem`](#outputfilesystem)** | `Object` | [`memfs`](https://github.com/streamich/memfs) | Set the default file system which will be used by webpack as primary destination of generated files. |
| **[`modifyResponseData`](#modifyresponsedata)** | `Function` | `undefined` | Allows to set up a callback to change the response data. |
| **[`hot`](#hot)** | `boolean\|Object` | `false` | Enables a Server-Sent Events endpoint that drives the browser HMR client. |
| **[`forwardError`](#forwarderror)** | `boolean` | `false` | Enable or disable forwarding errors to the next middleware. |
The middleware accepts an `options` Object. The following is a property reference for the Object.
### methods
Type: `Array`
Default: `[ 'GET', 'HEAD' ]`
This property allows a user to pass the list of HTTP request methods accepted by the middleware\*\*.
### headers
Type: `Array|Object|Function`
Default: `undefined`
This property allows a user to pass custom HTTP headers on each request.
eg. `{ "X-Custom-Header": "yes" }`
or
```js
webpackDevMiddleware(compiler, {
headers: () => ({
"Last-Modified": new Date(),
}),
});
```
or
```js
webpackDevMiddleware(compiler, {
headers: (req, res, context) => {
res.setHeader("Last-Modified", new Date());
},
});
```
or
```js
webpackDevMiddleware(compiler, {
headers: [
{
key: "X-custom-header",
value: "foo",
},
{
key: "Y-custom-header",
value: "bar",
},
],
});
```
or
```js
webpackDevMiddleware(compiler, {
headers: () => [
{
key: "X-custom-header",
value: "foo",
},
{
key: "Y-custom-header",
value: "bar",
},
],
});
```
### index
Type: `Boolean|String`
Default: `index.html`
If `false` (but not `undefined`), the server will not respond to requests to the root URL.
### mimeTypes
Type: `Object`
Default: `undefined`
This property allows a user to register custom mime types or extension mappings.
eg. `mimeTypes: { phtml: 'text/html' }`.
Please see the documentation for [`mime-types`](https://github.com/jshttp/mime-types) for more information.
### mimeTypeDefault
Type: `String`
Default: `undefined`
This property allows a user to register a default mime type when we can't determine the content type.
### etag
Type: `"weak" | "strong"`
Default: `undefined`
Enable or disable etag generation. Boolean value use
### lastModified
Type: `Boolean`
Default: `undefined`
Enable or disable `Last-Modified` header. Uses the file system's last modified value.
### cacheControl
Type: `Boolean | Number | String | { maxAge?: number, immutable?: boolean }`
Default: `undefined`
Depending on the setting, the following headers will be generated:
- `Boolean` - `Cache-Control: public, max-age=31536000000`
- `Number` - `Cache-Control: public, max-age=YOUR_NUMBER`
- `String` - `Cache-Control: YOUR_STRING`
- `{ maxAge?: number, immutable?: boolean }` - `Cache-Control: public, max-age=YOUR_MAX_AGE_or_31536000000`, also `, immutable` can be added if you set the `immutable` option to `true`
Enable or disable setting `Cache-Control` response header.
### cacheImmutable
Type: `Boolean`
Default: `undefined`
Enable or disable setting `Cache-Control: public, max-age=31536000, immutable` response header for immutable assets (i.e. asset with a hash like `image.a4c12bde.jpg`).
Immutable assets are assets that have their hash in the file name therefore they can be cached, because if you change their contents the file name will be changed.
Take preference over the `cacheControl` option if the asset was defined as immutable.
### publicPath
Type: `String`
Default: `output.publicPath` (from a configuration)
The public path that the middleware is bound to.
_Best Practice: use the same `publicPath` defined in your webpack config. For more information about `publicPath`, please see [the webpack documentation](https://webpack.js.org/guides/public-path)._
### stats
Type: `Boolean|String|Object`
Default: `stats` (from a configuration)
Stats options object or preset name.
### serverSideRender
Type: `Boolean`
Default: `undefined`
Instructs the module to enable or disable the server-side rendering mode.
Please see [Server-Side Rendering](#server-side-rendering) for more information.
### writeToDisk
Type: `Boolean|Function`
Default: `false`
If `true`, the option will instruct the module to write files to the configured location on disk as specified in your `webpack` config file.
_Setting `writeToDisk: true` won't change the behavior of the `webpack-dev-middleware`, and bundle files accessed through the browser will still be served from memory._
This option provides the same capabilities as the [`WriteFilePlugin`](https://github.com/gajus/write-file-webpack-plugin/pulls).
This option also accepts a `Function` value, which can be used to filter which files are written to disk.
The function follows the same premise as [`Array#filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) in which a return value of `false` _will not_ write the file, and a return value of `true` _will_ write the file to disk. eg.
```js
const webpack = require("webpack");
const configuration = {/* Webpack configuration */};
const compiler = webpack(configuration);
middleware(compiler, {
writeToDisk: (filePath) => /superman\.css$/.test(filePath),
});
```
### outputFileSystem
Type: `Object`
Default: [memfs](https://github.com/streamich/memfs)
Set the default file system which will be used by webpack as primary destination of generated files.
This option isn't affected by the [writeToDisk](#writeToDisk) option.
You have to provide `.join()` and `mkdirp` method to the `outputFileSystem` instance manually for compatibility with `webpack@4`.
This can be done simply by using `path.join`:
```js
const path = require("node:path");
const mkdirp = require("mkdirp");
const myOutputFileSystem = require("my-fs");
const webpack = require("webpack");
myOutputFileSystem.join = path.join.bind(path); // no need to bind
myOutputFileSystem.mkdirp = mkdirp.bind(mkdirp); // no need to bind
const compiler = webpack({/* Webpack configuration */});
middleware(compiler, { outputFileSystem: myOutputFileSystem });
```
### modifyResponseData
Allows to set up a callback to change the response data.
```js
const webpack = require("webpack");
const configuration = {/* Webpack configuration */};
const compiler = webpack(configuration);
middleware(compiler, {
// Note - if you send the `Range` header you will have `ReadStream`
// Also `data` can be `string` or `Buffer`
modifyResponseData: (req, res, data, byteLength) =>
// Your logic
// Don't use `res.end()` or `res.send()` here
({ data, byteLength }),
});
```
### hot
Type: `Boolean | Object`
Default: `false`
Enables hot module replacement by serving a [Server-Sent Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events) endpoint that publishes the webpack compiler's `building`, `built` and `sync` events to connected clients. Whether those events carry errors and warnings follows the [`stats`](#stats) option, so one setting governs what a build reports in the terminal and in the browser — `stats: "errors-only"` keeps warnings out of both, and `stats: false` keeps both out. When `true`, defaults are used; pass an object to customise. Use this option together with the browser runtime shipped as `webpack-dev-middleware/client`.
```js
const webpack = require("webpack");
const compiler = webpack({
/* Webpack configuration with HotModuleReplacementPlugin and the client entry */
});
middleware(compiler, { hot: true });
```
The object form accepts these options:
| Name | Type | Default | Description |
| :------------------------------------: | :-------: | :----------------: | :---------------------------------------------------- |
| **[`path`](#hotpath)** | `string` | `'/__webpack_hmr'` | Path the SSE endpoint is served at. |
| **[`heartbeat`](#hotheartbeat)** | `number` | `10000` | Interval (in milliseconds) between keep-alive frames. |
| **[`progress`](#hotprogress)** | `boolean` | `false` | Publish compilation progress events to the clients. |
| **[`statsOptions`](#hotstatsoptions)** | `object` | `undefined` | Deprecated — do not use; see [`stats`](#stats). |
#### `hot.path`
Type: `String`
Default: `'/__webpack_hmr'`
Path the SSE endpoint is served at. Must start with a slash and match the `path` option used by the client.
#### `hot.heartbeat`
Type: `Number`
Default: `10000`
Heartbeat interval (in milliseconds) used to keep the SSE connection alive when no compilation events are produced. Must be `1` or greater.
#### `hot.progress`
Type: `Boolean`
Default: `false`
Publish compilation progress events (`{ action: "progress", percent, message }`) to the clients using webpack's `ProgressPlugin`. The bundled client shows the percentage in its building badge (see the client `progress` option).
#### `hot.statsOptions`
> [!WARNING]
>
> Deprecated, and removed in the next major release. Do not use it.
Use these instead:
| To | Use |
| :-------------------------------------------------------------- | :----------------------------------------------------------------------------------------------- |
| decide what a build reports, in the terminal and in the payload | [`stats`](#stats) |
| quiet the browser console alone | the client's [`logging`](#client-options) |
| hide problems from the overlay alone | the client's [`overlay`](#client-overlay-options) |
| drop a warning everywhere at once | webpack's [`ignoreWarnings`](https://webpack.js.org/configuration/other-options/#ignorewarnings) |
Values still passed here apply until the option is removed, except `hash`, `timings` and `children`, which are ignored: the client compares `hash` against its own bundle's to decide whether an update applies, `timings` carries the build time it reports, and `children` would replace the bundle's hash with a child compilation's, so a page would reload instead of updating.
## Hot Module Replacement client
When the server is configured to serve the hot module replacement endpoint, the bundled application needs a small runtime that subscribes to that stream and applies the updates. `webpack-dev-middleware` ships that runtime under the `./client` subpath. Add it as a webpack entry next to your application code and enable `HotModuleReplacementPlugin`:
```js
const webpack = require("webpack");
module.exports = {
entry: ["webpack-dev-middleware/client", "./src/app.js"],
plugins: [new webpack.HotModuleReplacementPlugin()],
};
```
The runtime connects to `/__webpack_hmr` by default. Any of the options below can be set by adding a query string to the entry path:
```js
entry: [
"webpack-dev-middleware/client?reload=false&overlay=false",
"./src/app.js",
];
```
The runtime ships as ES5 and uses no built-in newer than ES5, apart from
`EventSource` and `Promise` (which HMR itself needs), so it runs in old
browsers too — set [`target`](https://webpack.js.org/configuration/target/) to
`["web", "es5"]` in your configuration so webpack emits its own runtime as ES5
as well.
### Client options
| Name | Type | Default | Description |
| :-----------------: | :---------------: | :--------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `path` | `string` | `/__webpack_hmr` | Path the SSE endpoint is served at. Must match the server `hot.path`. |
| `timeout` | `number` | `20000` | Reconnection / heartbeat watchdog timeout in milliseconds. |
| `overlay` | `boolean\|Object` | `true` | In-page overlay for problems: a boolean, or a JSON object — see [overlay options](#client-overlay-options). Same value shape as webpack-dev-server's [`client.overlay`](https://webpack.js.org/configuration/dev-server/#overlay), plus a few webpack-dev-middleware extensions. |
| `reload` | `boolean` | `true` | Fall back to a full page reload when an update cannot be applied through HMR (e.g. recovering from a broken build). Enabled by default, unlike webpack-hot-middleware; set to `false` to keep HMR-only. |
| `logging` | `string` | `"info"` | Logger level — one of `"none"`, `"error"`, `"warn"`, `"info"`, `"log"`, `"verbose"`. Uses webpack's runtime logger. |
| `name` | `string` | `""` | Restrict updates to a specific compilation name (useful with multi-compiler). |
| `autoConnect` | `boolean` | `true` | Connect on load; set to `false` and call `setOptionsAndConnect()` manually. |
| `progress` | `boolean` | `true` | Show a small badge in the page while a rebuild is in progress (with the compilation percentage when the server enables `hot.progress`). Set to `false` to disable. |
| `dynamicPublicPath` | `boolean` | `false` | Prefix `path` with `__webpack_public_path__` at runtime. The leading slash of `path` is stripped and no other normalization is applied, so the public path should end with `/`. |
#### Client `overlay` options
Passed as a JSON object, e.g. `?overlay={"warnings":false}`. The three problem
kinds default to `true` when the object leaves them out; a filter function
(URI-encoded) shows only the messages it accepts.
| Name | Type | Default | Description |
| :----------------------: | :-----------------: | :---------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `errors` | `boolean\|Function` | `true` | Show build errors. |
| `warnings` | `boolean\|Function` | `true` | Show build warnings. |
| `runtimeErrors` | `boolean\|Function` | `true` | Show uncaught runtime errors and unhandled rejections. |
| `trustedTypesPolicyName` | `string` | `undefined` | Trusted Types policy name used for the overlay's HTML. |
| `styles` | `Object` | `undefined` | webpack-dev-middleware extension: CSS overrides for the overlay card (`element.style` keys). |
| `ansiColors` | `Object` | `undefined` | webpack-dev-middleware extension: ANSI → HTML color map, as in [ansi-html-community](https://github.com/mahdyar/ansi-html-community#set-colors). |
| `openEditorEndpoint` | `string` | `""` | webpack-dev-middleware extension: when set, file references become clickable and issue `GET ?fileName=`; your server provides it, e.g. a route calling [launch-editor](https://github.com/yyx990803/launch-editor). |
| `paginate` | `boolean` | `true` | webpack-dev-middleware extension: show one problem at a time with prev/next navigation. |
### Programmatic API
`webpack-dev-middleware/client` also exports a few functions for advanced cases:
```js
const hotClient = require("webpack-dev-middleware/client");
// Receive every HMR payload (building / built / sync / custom).
hotClient.subscribeAll((payload) => {
console.log("hot event", payload);
});
// Receive payloads whose `action` is not recognised by the client (i.e. custom
// payloads published via the server's `instance.context.hot.publish(...)`).
hotClient.subscribe((payload) => {
// do something
});
// Replace the default error overlay with your own implementation.
hotClient.useCustomOverlay({
showProblems(type, lines) {
/* ... */
},
clear() {
/* ... */
},
});
// Connect manually when `autoConnect=false`. Accepts the same option keys as
// the query-string API above.
hotClient.setOptionsAndConnect({ path: "/__hmr" });
// Close the SSE connection and stop reconnecting (e.g. before tearing the
// page down). A later `setOptionsAndConnect` call opens a fresh connection.
hotClient.disconnect();
```
The error overlay is also exposed as a standalone module so other tooling
(e.g. `webpack-dev-server`) can reuse it without the SSE client:
```js
import configureOverlay, {
clear,
showProblems,
} from "webpack-dev-middleware/client/overlay";
const overlay = configureOverlay({
// ansiColors, overlayStyles, trustedTypesPolicyName, catchRuntimeError,
// openEditorEndpoint, paginate
});
overlay.showProblems("errors", ["Something broke"]);
overlay.clear();
```
The overlay state is a per-page singleton: every bundled copy of the module
renders into the same overlay. Multiple clients can report side by side by
passing a `source` — each source keeps its own slot and the overlay shows the
union, with errors from any source taking precedence over warnings:
```js
overlay.showProblems("errors", ["Something broke"], "my-client");
// Drop only this client's problems; other sources stay on screen.
overlay.clear("my-client");
// Without a source, everything is dismissed (same as Esc / backdrop / ×).
overlay.clear();
```
The building indicator is exposed the same way:
```js
import { hide, show } from "webpack-dev-middleware/client/indicator";
show("Rebuilding…"); // pulsing dot
show("Rebuilding… 42%", 42); // progress ring
hide();
```
The badge is a per-page singleton shared by every bundled copy of the module.
Concurrent builds can report through a `source` — the badge stays until every
source finished:
```js
show("Rebuilding app…", undefined, "app");
show("Rebuilding admin…", undefined, "admin");
hide("app"); // still shown — "admin" is building
hide("admin"); // removed
hide(); // without a source: removed unconditionally
```
## Migrating from webpack-hot-middleware
The `hot` option replaces [`webpack-hot-middleware`](https://github.com/webpack/webpack-hot-middleware): one middleware serves the assets and the SSE endpoint, and the client runtime ships under `webpack-dev-middleware/client`. The endpoint (`/__webpack_hmr`) and its Server-Sent Events transport are unchanged, so the browser reaches the new server the same way; the payloads, option names and a few defaults need a look.
See [migration-from-webpack-hot-middleware.md](migration-from-webpack-hot-middleware.md) — it walks the whole move: prerequisites, the server and webpack-configuration changes, every option mapped, the behavior differences worth knowing, the other frameworks, troubleshooting, and a checklist.
## HMR notes and troubleshooting
### Browser connection limits (many tabs)
Each open tab keeps one SSE connection to the `hot.path` endpoint. Over
HTTP/1.1, browsers allow only ~6 concurrent connections per origin, so opening
many tabs can leave the extra ones hanging (browsers have marked this
[Won't Fix](https://developer.mozilla.org/en-US/docs/Web/API/EventSource)).
Multiple webpack entries on the same page already share a single connection,
and the endpoint works over HTTP/2 out of the box — serve your development
server over HTTP/2 if you need many simultaneous tabs.
### Filtering warnings
Three layers, from build to presentation:
- webpack's [`ignoreWarnings`](https://webpack.js.org/configuration/other-options/#ignorewarnings) removes them from the stats, so nothing reports them anywhere.
- The middleware's [`stats`](#stats) option decides what a build reports, in the terminal and in the SSE payload alike: `stats: "errors-only"` keeps warnings out of both.
- On the client, `?overlay={"warnings":false}` hides them from the overlay and `?logging=error` from the console, per page rather than per server.
### Paths and public paths
- The client `path` option accepts absolute URLs (the endpoint sends
`Access-Control-Allow-Origin: *`), which allows connecting across ports or
hosts. Pages served over HTTPS need the endpoint over HTTPS too.
- For apps with nested routes (`/some/route`), use an absolute
`output.publicPath` (e.g. `"/"`): with a relative one the browser resolves
`*.hot-update.json` requests against the current route and they 404.
### Custom events
The server can broadcast arbitrary payloads and the client can react to them —
for example, forcing every open tab to reload on demand:
```js
// Server
const instance = middleware(compiler, { hot: true });
instance.context.hot.publish({ action: "reload-all" });
```
```js
// Client
const hotClient = require("webpack-dev-middleware/client");
hotClient.subscribe((payload) => {
if (payload.action === "reload-all") {
globalThis.location.reload();
}
});
```
## API
`webpack-dev-middleware` also provides convenience methods that can be use to
interact with the middleware at runtime:
### `close(callback)`
Instructs `webpack-dev-middleware` instance to stop watching for file changes.
#### Parameters
##### `callback`
Type: `Function`
Required: `No`
A function executed once the middleware has stopped watching.
```js
const express = require("express");
const webpack = require("webpack");
const compiler = webpack({/* Webpack configuration */});
const middleware = require("webpack-dev-middleware");
const instance = middleware(compiler);
// eslint-disable-next-line new-cap
const app = new express();
app.use(instance);
setTimeout(() => {
// Says `webpack` to stop watch changes
instance.close();
}, 1000);
```
### `invalidate(callback)`
Instructs `webpack-dev-middleware` instance to recompile the bundle, e.g. after a change to the configuration.
#### Parameters
##### `callback`
Type: `Function`
Required: `No`
A function executed once the middleware has invalidated.
```js
const express = require("express");
const webpack = require("webpack");
const compiler = webpack({/* Webpack configuration */});
const middleware = require("webpack-dev-middleware");
const instance = middleware(compiler);
// eslint-disable-next-line new-cap
const app = new express();
app.use(instance);
setTimeout(() => {
// After a short delay the configuration is changed and a banner plugin is added to the config
new webpack.BannerPlugin("A new banner").apply(compiler);
// Recompile the bundle with the banner plugin:
instance.invalidate();
}, 1000);
```
### `waitUntilValid(callback)`
Executes a callback function when the compiler bundle is valid, typically after
compilation.
#### Parameters
##### `callback`
Type: `Function`
Required: `No`
A function executed when the bundle becomes valid.
If the bundle is valid at the time of calling, the callback is executed immediately.
```js
const express = require("express");
const webpack = require("webpack");
const compiler = webpack({/* Webpack configuration */});
const middleware = require("webpack-dev-middleware");
const instance = middleware(compiler);
// eslint-disable-next-line new-cap
const app = new express();
app.use(instance);
instance.waitUntilValid(() => {
console.log("Package is in a valid state");
});
```
### `getFilenameFromUrl(url)`
Get filename from URL.
#### Parameters
##### `url`
Type: `String`
Required: `Yes`
URL for the requested file.
```js
const express = require("express");
const webpack = require("webpack");
const compiler = webpack({/* Webpack configuration */});
const middleware = require("webpack-dev-middleware");
const instance = middleware(compiler);
// eslint-disable-next-line new-cap
const app = new express();
app.use(instance);
instance.waitUntilValid(() => {
instance
.getFilenameFromUrl("/bundle.js")
.then((filename) => {
if (!filename) {
return;
}
console.log(`Filename is ${filename}`);
})
.catch((err) => {
console.log(`Error: ${err}`);
});
});
```
### `plugin(compiler, options)`
Creates middleware instance in plugin mode.
In plugin mode, stats output is written through custom code (i.e. in callback for `watch` or where you are calling `stats.toString(options)`) instead of `console.log`.
In this case, the `stats` option is not supported because `webpack-dev-middleware` does not have access to the code where the stats will be output.
You will also need to manually run the `watch` method.
Why do you need this mode? In some cases, you may want to have multiple dev servers or run only one dev server when you have multiple configurations, and this is suitable for you.
```js
const webpack = require("webpack");
const middleware = require("webpack-dev-middleware");
const compiler = webpack({
plugins: [
{
apply(compiler) {
const devMiddleware = middleware(
compiler,
{/* webpack-dev-middleware options */},
true,
);
},
},
],
/* Webpack configuration */
});
compiler.watch((err, stats) => {
if (err) {
console.error(err);
return;
}
console.log(stats.toString());
});
```
### Plugin wrappers
The following wrappers enable plugin mode for framework integrations:
- `middleware(compiler, options, true)` (connect/express like middleware)
- `middleware.koaWrapper(compiler, options, true)`
- `middleware.hapiWrapper(true)`
- `middleware.honoWrapper(compiler, options, true)`
They are equivalent to `koaWrapper`/`hapiWrapper`/`honoWrapper`, but use plugin mode logging behavior.
### `forwardError`
Type: `boolean`
Default: `false`
Enable or disable forwarding errors to the next middleware. If `true`, errors will be forwarded to the next middleware, otherwise, they will be handled by `webpack-dev-middleware` and a response will be handled case by case.
This option don't work with hono, koa and hapi, because of the differences in error handling between these frameworks and express.
```js
const express = require("express");
const webpack = require("webpack");
const middleware = require("webpack-dev-middleware");
const compiler = webpack({/* Webpack configuration */});
const instance = middleware(compiler, { forwardError: true });
const app = express();
app.use(instance);
app.use((err, req, res, next) => {
console.log(`Error: ${err}`);
res.status(500).send("Something broke!");
});
```
## FAQ
### Avoid blocking requests to non-webpack resources.
Since `output.publicPath` and `output.filename`/`output.chunkFilename` can be dynamic, it's not possible to know which files are webpack bundles (and they public paths) and which are not, so we can't avoid blocking requests.
But there is a solution to avoid it - mount the middleware to a non-root route, for example:
```js
const express = require("express");
const webpack = require("webpack");
const middleware = require("webpack-dev-middleware");
const compiler = webpack({
// webpack options
});
const app = express();
// Mounting the middleware to the non-root route allows avoids this.
// Note - check your public path, if you want to handle `/dist/`, you need to setup `output.publicPath` to `/` value.
app.use(
"/dist/",
middleware(compiler, {
// webpack-dev-middleware options
}),
);
app.listen(3000, () => console.log("Example app listening on port 3000!"));
```
## Server-Side Rendering
_Note: this feature is experimental and may be removed or changed completely in the future._
In order to develop an app using server-side rendering, we need access to the
[`stats`](https://github.com/webpack/docs/wiki/node.js-api#stats), which is
generated with each build.
With server-side rendering enabled, `webpack-dev-middleware` sets the `stats` to `res.locals.webpack.devMiddleware.stats`
and the filesystem to `res.locals.webpack.devMiddleware.outputFileSystem` before invoking the next middleware,
allowing a developer to render the page body and manage the response to clients.
_Note: Requests for bundle files will still be handled by
`webpack-dev-middleware` and all requests will be pending until the build
process is finished with server-side rendering enabled._
Example Implementation:
```js
const express = require("express");
const isObject = require("is-object");
const webpack = require("webpack");
const middleware = require("webpack-dev-middleware");
const compiler = webpack({/* Webpack configuration */});
// eslint-disable-next-line new-cap
const app = new express();
// This function makes server rendering of asset references consistent with different webpack chunk/entry configurations
function normalizeAssets(assets) {
if (isObject(assets)) {
return Object.values(assets);
}
return Array.isArray(assets) ? assets : [assets];
}
app.use(middleware(compiler, { serverSideRender: true }));
// The following middleware would not be invoked until the latest build is finished.
app.use((req, res) => {
const { devMiddleware } = res.locals.webpack;
const { outputFileSystem } = devMiddleware;
const jsonWebpackStats = devMiddleware.stats.toJson();
const { assetsByChunkName, outputPath } = jsonWebpackStats;
// Then use `assetsByChunkName` for server-side rendering
// For example, if you have only one main chunk:
res.send(`
My App
${normalizeAssets(assetsByChunkName.main)
.filter((path) => path.endsWith(".js"))
.map((path) => ``)
.join("\n")}
`);
});
```
## Support
We do our best to keep Issues in the repository focused on bugs, features, and
needed modifications to the code for the module. Because of that, we ask users
with general support, "how-to", or "why isn't this working" questions to try one
of the other support channels that are available.
Your first-stop-shop for support for webpack-dev-server should by the excellent
[documentation][docs-url] for the module. If you see an opportunity for improvement
of those docs, please head over to the [webpack.js.org repo][wjo-url] and open a
pull request.
From there, we encourage users to visit the [webpack discussions][chat-url] and
talk to the fine folks there. If your quest for answers comes up dry in chat,
head over to [StackOverflow][stack-url] and do a quick search or open a new
question. Remember; It's always much easier to answer questions that include your
`webpack.config.js` and relevant files!
If you're twitter-savvy you can tweet [#webpack][hash-url] with your question
and someone should be able to reach out and lend a hand.
If you have discovered a :bug:, have a feature suggestion, or would like to see
a modification, please feel free to create an issue on Github. _Note: The issue
template isn't optional, so please be sure not to remove it, and please fill it
out completely._
## Other servers
Examples of use with other servers will follow here.
### Connect
```js
const http = require("node:http");
const connect = require("connect");
const webpack = require("webpack");
const devMiddleware = require("webpack-dev-middleware");
const webpackConfig = require("./webpack.config.js");
const compiler = webpack(webpackConfig);
const devMiddlewareOptions = {/** Your webpack-dev-middleware-options */};
const app = connect();
app.use(devMiddleware(compiler, devMiddlewareOptions));
http.createServer(app).listen(3000);
```
### Router
```js
const http = require("node:http");
const finalhandler = require("finalhandler");
const Router = require("router");
const webpack = require("webpack");
const devMiddleware = require("webpack-dev-middleware");
const webpackConfig = require("./webpack.config.js");
const compiler = webpack(webpackConfig);
const devMiddlewareOptions = {/** Your webpack-dev-middleware-options */};
// eslint-disable-next-line new-cap
const router = Router();
router.use(devMiddleware(compiler, devMiddlewareOptions));
const server = http.createServer((req, res) => {
router(req, res, finalhandler(req, res));
});
server.listen(3000);
```
### Express
```js
const express = require("express");
const webpack = require("webpack");
const devMiddleware = require("webpack-dev-middleware");
const webpackConfig = require("./webpack.config.js");
const compiler = webpack(webpackConfig);
const devMiddlewareOptions = {/** Your webpack-dev-middleware-options */};
const app = express();
app.use(devMiddleware(compiler, devMiddlewareOptions));
app.listen(3000, () => console.log("Example app listening on port 3000!"));
```
### Koa
```js
const Koa = require("koa");
const webpack = require("webpack");
const middleware = require("webpack-dev-middleware");
const webpackConfig = require("./webpack.simple.config");
const compiler = webpack(webpackConfig);
const devMiddlewareOptions = {/** Your webpack-dev-middleware-options */};
const app = new Koa();
app.use(middleware.koaWrapper(compiler, devMiddlewareOptions));
// Alternative usage (when you want to use as a plugin, i.e. all stats will be printed by other code):
// app.use(middleware.koaWrapper(compiler, devMiddlewareOptions, true));
app.listen(3000);
```
### Hapi
```js
const Hapi = require("@hapi/hapi");
const webpack = require("webpack");
const devMiddleware = require("webpack-dev-middleware");
const webpackConfig = require("./webpack.config.js");
const compiler = webpack(webpackConfig);
const devMiddlewareOptions = {};
const server = Hapi.server({ port: 3000, host: "localhost" });
await server.register({
plugin: devMiddleware.hapiWrapper(),
options: {
// The `compiler` option is required
compiler,
...devMiddlewareOptions,
},
});
// Alternative usage (when you want to use as a plugin, i.e. all stats will be printed by other code):
// await server.register({
// plugin: devMiddleware.hapiWrapper(true),
// options: {
// // The `compiler` option is required
// compiler,
// ...devMiddlewareOptions,
// },
// });
await server.start();
console.log("Server running on %s", server.info.uri);
process.on("unhandledRejection", (err) => {
console.log(err);
process.exit(1);
});
```
### Fastify
Fastify interop will require the use of `fastify-express` instead of `middie` for providing middleware support. As the authors of `fastify-express` recommend, this should only be used as a stopgap while full Fastify support is worked on.
```js
const fastify = require("fastify")();
const webpack = require("webpack");
const devMiddleware = require("webpack-dev-middleware");
const webpackConfig = require("./webpack.config.js");
const compiler = webpack(webpackConfig);
const devMiddlewareOptions = {/** Your webpack-dev-middleware-options */};
await fastify.register(require("@fastify/express"));
await fastify.use(devMiddleware(compiler, devMiddlewareOptions));
await fastify.listen(3000);
```
### Hono
```js
import { serve } from "@hono/node-server";
import { Hono } from "hono";
import webpack from "webpack";
import devMiddleware from "webpack-dev-middleware";
import webpackConfig from "./webpack.config.js";
const compiler = webpack(webpackConfig);
const devMiddlewareOptions = {/** Your webpack-dev-middleware-options */};
const app = new Hono();
app.use(devMiddleware.honoWrapper(compiler, devMiddlewareOptions));
// Alternative usage (when you want to use as a plugin, i.e. all stats will be printed by other code):
// const honoDevMiddleware = devMiddleware.honoWrapper(compiler, devMiddlewareOptions, true)
serve(app);
```
## Contributing
Please take a moment to read our contributing guidelines if you haven't yet done so.
[CONTRIBUTING](https://github.com/webpack/sass-loader?tab=contributing-ov-file#contributing)
## License
[MIT](./LICENSE)
[npm]: https://img.shields.io/npm/v/webpack-dev-middleware.svg
[npm-url]: https://npmjs.com/package/webpack-dev-middleware
[node]: https://img.shields.io/node/v/webpack-dev-middleware.svg
[node-url]: https://nodejs.org
[tests]: https://github.com/webpack/webpack-dev-middleware/workflows/webpack-dev-middleware/badge.svg
[tests-url]: https://github.com/webpack/webpack-dev-middleware/actions
[cover]: https://codecov.io/gh/webpack/webpack-dev-middleware/branch/main/graph/badge.svg
[cover-url]: https://codecov.io/gh/webpack/webpack-dev-middleware
[discussion]: https://img.shields.io/github/discussions/webpack/webpack
[discussion-url]: https://github.com/webpack/webpack/discussions
[size]: https://packagephobia.com/badge?p=webpack-dev-middleware
[size-url]: https://packagephobia.com/result?p=webpack-dev-middleware
[docs-url]: https://webpack.js.org/guides/development/#using-webpack-dev-middleware
[hash-url]: https://twitter.com/search?q=webpack
[middleware-url]: https://github.com/webpack/webpack-dev-middleware
[stack-url]: https://stackoverflow.com/questions/tagged/webpack-dev-middleware
[chat-url]: https://github.com/webpack/webpack/discussions
[wjo-url]: https://github.com/webpack/webpack.js.org