Workbox v6.0.0
Overview of Workbox v6
We're happy to announce the release of Workbox v6!
🎉 What's New?
webpack improvements
This release includes additional bug fixes for better compatibility with webpack
. As of this release, workbox-webpack-plugin
requires webpack
v4.40.0 or later (for those still on the v4.x branch) or webpack
v.5.9.0 or later (for those who have updated to webpack
v5.x).
workbox-webpack-plugin
will also now take advantage of the immutable
metadata that webpack
automatically adds to hashed assets. In most cases, this means that explicitly using dontCacheBustURLMatching
in your workbox-webpack-plugin
configuration is no longer necessary.
workbox-strategies improvements
The best way to ensure third-party developers have the power to extend Workbox in ways that fully meet their needs is to base our own strategies on top of the extensibility mechanisms we expose to third-party developers.
Specifically, v6 introduces a new way for third-party developers to define their own Workbox strategies, and all of our built-in strategies have been rewritten on top of this mechanism.
This change also allowed us to rewrite the workbox-precaching
codebase to use workbox-strategies
as a base. This should not result in any breaking changes, and should lead to better long-term consistency in how the two modules access the network and cache.
See #2446, #2459 and #2569 for more details.
New strategy base class
In v6, all Workbox strategy classes (both built-in strategies as well as custom, third-party strategies) must extend the new Strategy
base class.
The Strategy
base class is responsible for two primary things:
- Invoking plugin lifecycle callbacks common to all strategy handlers (e.g. when they start, respond, and end).
- Creating a "handler" instance, that can manage state for each individual request a strategy is handling.
A new "handler" class
We previously had internal modules call fetchWrapper
and cacheWrapper
, which (as their name implies) wrap the various fetch and cache APIs with hooks into their lifecycle. This is the mechanism that currently allows plugins to work, but it's not exposed to developers.
The new "handler" class (which this proposal calls StrategyHandler
) will expose these methods so custom strategies can call fetch()
or cacheMatch()
and have any plugins that were added to the strategy instance automatically invoked.
This class would also make it possible for developers to add their own custom, lifecycle callbacks that might be specific to their strategies, and they would "just work" with the existing plugin interface.
New plugin lifecycle state
In Workbox v5, plugins are stateless. That means if a request for /index.html
triggers both the requestWillFetch
and cachedResponseWillBeUsed
callbacks, those two callbacks have no way of communicating with each other or even knowing that they were triggered by the same request.
In this proposal, all plugin callbacks will also be passed a new state
object. This state object will be unique to this particular plugin object and this particular strategy invocation (i.e. the call to handle()
).
This allows developers to write plugins where one callback can conditionally do something based on what another callback in the same plugin did (e.g. compute the time delta between running requestWillFetch
and fetchDidSucceed
or fetchDidFail
).
New plugin lifecycle callbacks
In order to fully leverage the plugin lifecycle state (mentioned above), you need to know when the lifecycle of a given strategy invocation starts and finishes.
To address this need (and others), the following new plugin lifecycle callbacks will be added:
- handlerWillStart: called before any handler logic starts running. This callback can be used to set the initial handler state (e.g. record the start time).
- handlerWillRespond: called before the strategies
handle()
method returns a response. This callback can be used to modify that response before returning it to a route handler or other custom logic. - handlerDidRespond: called after the strategy's
handle()
method returns a response. This callback can be used to record any final response details, e.g. after changes made by other plugins. - handlerDidComplete: called after all extend lifetime promises added to the event from the invocation of this strategy have settled. This callback can be used to report on any data that needs to wait until the handler is done in order to calculate (e.g. cache hit status, cache latency, network latency).
- handlerDidError: called if the handler was unable to provide a valid response from any source. This callback can be used to provide "fallback" content as an alternative to a network error.
Developers implementing their own custom strategies do not have to worry about invoking these callbacks themselves; that's all handled by a new Strategy
base class.
More accurate TypeScript types for handlers
TypeScript definitions for various callback methods have been normalized. This should lead to a better experience for developers who use TypeScript and write their own code to implement or call handlers.
See #2548.
workbox-recipes
This release includes a new module, workbox-recipes
, that combines common routing and caching strategy configurations into ready-to-use code that can be dropped in to your service worker.
You can read more about what's included in the first batch of recipes, as well as how to use them, in #2664.
workbox-window improvements
New messageSkipWaiting() method
A new method, messageSkipWaiting()
, has been added to the workbox-window
module to simplify the process of telling the "waiting" service worker to activate.
This offers some improvements over alternatives:
-
It calls
postMessage()
with the de facto standard message body,{type: 'SKIP_WAITING'}
, that a service worker generated by Workbox checks for to triggerskipWaiting()
. -
It chooses the correct "waiting" service worker to post this message to, even if it's not the same service worker that
workbox-window
was registered with.
See #2394.
Removal of "external" events in favor of an isExternal property
Many developers were confused by the concept of "external" events in workbox-window
, and in practice, they did not end up being a net-positive.
All "external" events are now represented as "normal" events with an isExternal
property set to true
. This allows developers who care about the distinction to still detect it, and developers who don't need to know can ignore the property.
See #2031.
Cleaner "Offer a page reload for users" recipe
Taken together, these two changes make the "Offer a page reload for users" recipe cleaner:
<script type="module">
import {Workbox} from 'https://storage.googleapis.com/workbox-cdn/releases/6.0.0/workbox-window.prod.mjs';
if ('serviceWorker' in navigator) {
const wb = new Workbox('/sw.js');
const showSkipWaitingPrompt = () => {
// This assumes a hypothetical createUIPrompt() method with
// onAccept and onReject callbacks:
const prompt = createUIPrompt({
onAccept: () => {
wb.addEventListener('controlling', () => {
window.location.reload();
});
// This will postMessage() to the waiting service worker.
wb.messageSkipWaiting();
},
onReject: () => {
prompt.dismiss();
}
});
};
// Listening for externalwaiting is no longer needed.
wb.addEventListener('waiting', showSkipWaitingPrompt);
wb.register();
}
</script>
sameOrigin parameter in matchCallback functions
A new boolean parameter, sameOrigin
, is passed to the matchCallback
function used in workbox-routing.
It's set to true
if the request is for a same-origin URL, and false
otherwise.
This simplifies some common boilerplate:
// In v5:
registerRoute(
({url}) => url.origin === self.location.origin &&
url.pathname.endsWith('.png'),
new StaleWhileRevalidate({cacheName: 'local-png'}),
);
// In v6:
registerRoute(
({sameOrigin, url}) => sameOrigin &&
url.pathname.endsWith('.png'),
new StaleWhileRevalidate({cacheName: 'local-png'}),
);
See #2487.
matchOptions are supported in workbox-expiration
You can now set matchOptions
in workbox-expiration
, which will then be passed through as the CacheQueryOptions
to the underlying cache.delete()
call. (Most developers won't need to do this.)
See #2206.
Precaching now processes entries one by one, not in bulk
workbox-precaching
has been updated so that only one entry in the precache manifest is requested and cached at a time, instead of attempting to request and cache all of them at once (leaving it to the browser to figure out how to throttle).
This should reduce the likelihood of net::ERR_INSUFFICIENT_RESOURCES
errors while precaching, and also should reduce the bandwidth contention between precaching and simultaneous requests made by the web app.
See #2528.
PrecacheFallbackPlugin allows for easier offline fallback
workbox-precaching
now includes a PrecacheFallbackPlugin
, which implements the new handlerDidError
lifecycle method added in v6.
This makes it easy to specify a precached URL as a "fallback" for a given strategy when a response otherwise wouldn't be available. The plugin will take care of properly constructing the correct cache key for the precached URL, including any revision parameter that's needed.
Here's a sample of using it to respond with a precached /offline.html
when the NetworkOnly
strategy can't generate a response for a navigation request—in other words, displaying a custom offline HTML page:
import {PrecacheFallbackPlugin, precacheAndRoute} from 'workbox-precaching';
import {registerRoute} from 'workbox-routing';
import {NetworkOnly} from 'workbox-strategies';
// Ensure that /offline.html is part of your precache manifest!
precacheAndRoute(self.__WB_MANIFEST);
registerRoute(
({request}) => request.mode === 'navigate',
new NetworkOnly({
plugins: [
new PrecacheFallbackPlugin({
fallbackURL: '/offline.html',
}),
],
}),
);
precacheFallback in runtime caching
If you're using generateSW
to create a service worker for you instead of writing your service worker by hand, you can use the new precacheFallback
configuration option in runtimeCaching
to accomplish the same thing:
{
// ... other generateSW config options...
runtimeCaching: [{
urlPattern: ({request}) => request.mode === 'navigate',
handler: 'NetworkOnly',
options: {
precacheFallback: {
// This URL needs to be included in your precache manifest.
fallbackURL: '/offline.html',
},
},
}],
}
Under-the-hood workbox-precaching improvements
This release includes a substantial rewrite to the implementation of workbox-precaching
, to build on top of other standard Workbox idioms (like Route
s, Strategy
subclasses, and custom plugins) as much as possible. There are a few breaking changes, described in the follow section, but they are mostly limited to uncommon use cases, when PrecacheController
is instantiated directly. For the most part, these changes are meant to be invisible to developers, but should lead to be better consistency in how routing and request handling works across all of Workbox.
You can read more about what's change in #2638
cacheKeyWillBeUsed can be used to cache non-GET requests
Only GET
requests can be used as cache keys, but there are scenarios in which you might want to use a combination of plugins to transform a POST
or PUT
request into a cacheable GET
request.
You can now use the cacheKeyWillBeUsed
lifecycle callback in a plugin to return a GET
request with whatever URL you'd like to use as a cache key, and that can then allow the response associated with a POST
or PUT
to be cached.
See #2615 for more details. Thanks to @markbrocato for their contribution.
⚠️ Breaking Changes
Build Tools
-
The minimum required version of node has been increased to
v10.0.0
. This applies toworkbox-build
,workbox-cli
, andworkbox-webpack-plugin
. [#2462] -
mode
was not intended to be a supported parameter for theinjectManifest
andgetManifest
modes ofworkbox-build
andworkbox-cli
. It's been removed from the documentation and attempting to use it outside ofgenerateSW
will now trigger a build error. This does not apply toworkbox-webpack-plugin
, which does supportmode
in itsInjectManifest
plugin. [#2464]
workbox-core
- The
skipWaiting()
method inworkbox-core
wrapped the underlying call toself.skipWaiting()
in aninstall
handler. In practice, this caused undue confusion and offered little value, as it's valid to callself.skipWaiting()
outside of aninstall
event. As of v6, Workbox'sskipWaiting()
will no longer add in aninstall
handler, and is equivalent to just callingself.skipWaiting()
. Because of this, developers should migrate to callingself.skipWaiting()
directly, and Workbox'sskipWaiting()
will likely be removed in v7. [#2547]
workbox-precaching
-
While this scenario is uncommon, if you precache a URL that corresponds to an HTTP redirect to an HTML document on a different origin, that cross-origin HTML document can no longer be used to satisfy a navigation request. [#2484]
-
By default, the
fbclid
URL query parameter is now ignored when looking up a precached response for a given request. [#2532]
Note: The following changes primarily apply to direct usage of the PrecacheController
class. Most developers don't use PrecacheController
directly, and instead use static helper methods like precacheAndRoute()
exported by workbox-precaching
. [#2639]
-
The
PrecacheController
constructor now takes in an object with specific properties as its parameter, instead of a string. This object supports the following properties:cacheName
(serving the same purpose as the string that was passed in to the constructor in v5),plugins
(replacing theaddPlugins()
method from v5), andfallbackToNetwork
(replacing the similar option that was passed tocreateHandler()
and `createHandlerBoundToURL() in v5). -
The
install()
andactivate()
methods ofPrecacheController
now take exactly one parameter, which should be set to a correspondingInstallEvent
orActivateEvent
, respectively. -
The
addRoute()
method has been removed fromPrecacheController
. In its place, the newPrecacheRoute
class can be used to create a route that you can then register. -
The
precacheAndRoute()
method has been removed fromPrecacheController
. (It still exists as a static helper method exported by theworkbox-precaching
module.) It was removed becausePrecacheRoute
can be used instead. -
The
createMatchCalback()
method has been removed fromPrecacheController
. The newPrecacheRoute
can be used instead. -
The
createHandler()
method has been removed fromPrecacheController
. Thestrategy
property of thePrecacheController
object can be used to handle requests instead. -
The
createHandler()
static export has already been removed from theworkbox-precaching
module. In its place, developers should construct aPrecacheController
instance and use itsstrategy
property. -
The route registered with
precacheAndRoute()
is now a "real" route that usesworkbox-routing
'sRouter
class under the hood. This may lead to a different evaluation order of your routes if you interleave calls toregisterRoute()
andprecacheAndRoute()
. See #1857 and #2402 for more details.
workbox-routing
- The
setDefaultHandler()
method now takes an optional second parameter corresponding to the HTTP method that it applies to, defaulting to'GET'
. It no longer applies to requests with any HTTP method. If you were usingsetDefaultHandler()
and all of your web app's requests are'GET'
, then no changes need to be made. [#2463]
workbox-webpack-plugin
- The minimum required version of webpack has been increased to
v4.40.0
(for users remaining on the webpackv4.x
major release) orv5.9.0
(for users who have updated to the webpackv5.x
major release). [#2641]