const fetch = require('make-fetch-happen').defaults({ cachePath: './my-cache' // path where cache will be written (and read)})fetch('https://registry.npmjs.org/make-fetch-happen').then(res => { return res.json() // download the body as JSON}).then(body => { console.log(`got ${body.name} from web`) return fetch('https://registry.npmjs.org/make-fetch-happen', { cache: 'no-cache' // forces a conditional request })}).then(res => { console.
This function implements most of the fetch API: given a uri string or a Request instance, it will fire off an http request and return a Promise containing the relevant response.
If opts is provided, the minipass-fetch-specific options will be passed to that library. There are also additional options specific to make-fetch-happen that add various features, such as HTTP caching, integrity verification, proxy support, and more.
Returns a new fetch function that will call make-fetch-happen using defaultUrl and defaultOpts as default values to any calls.
A defaulted fetch will also have a .defaults() method, so they can be chained.
Example
const fetch = require('make-fetch-happen').defaults({ cachePath: './my-local-cache'})fetch('https://registry.npmjs.org/make-fetch-happen') // will always use the cache
> minipass-fetch options
The following options for minipass-fetch are used as-is:
method
body
redirect
follow
timeout
compress
size
These other options are modified or augmented by make-fetch-happen:
headers - Default User-Agent set to make-fetch happen. Connection is set to keep-alive or close automatically depending on opts.agent.
A string Path to be used as the cache root for cacache.
NOTE: Requests will not be cached unless their response bodies are consumed. You will need to use one of the res.json(), res.buffer(), etc methods on the response, or drain the res.body stream, in order for it to be written.
The default cache manager also adds the following headers to cached responses:
X-Local-Cache: Path to the cache the content was found in
X-Local-Cache-Key: Unique cache entry key for this response
X-Local-Cache-Mode: Always stream to indicate how the response was read from cacache
X-Local-Cache-Hash: Specific integrity hash for the cached entry
X-Local-Cache-Status: One of miss, hit, stale, revalidated, updated, or skip to signal how the response was created
X-Local-Cache-Time: UTCString of the cache insertion time for the entry
Using cacache, a call like this may be used to
manually fetch the cached entry:
const h = response.headerscacache.get(h.get('x-local-cache'), h.get('x-local-cache-key'))// grab content only, directly:cacache.get.byDigest(h.get('x-local-cache'), h.get('x-local-cache-hash'))
Example
fetch('https://registry.npmjs.org/make-fetch-happen', { cachePath: './my-local-cache'}) // -> 200-level response will be written to disk
> opts.cache
This option follows the standard fetch API cache option. This option will do nothing if opts.cachePath is null. The following values are accepted (as strings):
default - Fetch will inspect the HTTP cache on the way to the network. If there is a fresh response it will be used. If there is a stale response a conditional request will be created, and a normal request otherwise. It then updates the HTTP cache with the response. If the revalidation request fails (for example, on a 500 or if you're offline), the stale response will be returned.
no-store - Fetch behaves as if there is no HTTP cache at all.
reload - Fetch behaves as if there is no HTTP cache on the way to the network. Ergo, it creates a normal request and updates the HTTP cache with the response.
no-cache - Fetch creates a conditional request if there is a response in the HTTP cache and a normal request otherwise. It then updates the HTTP cache with the response.
force-cache - Fetch uses any response in the HTTP cache matching the request, not paying attention to staleness. If there was no response, it creates a normal request and updates the HTTP cache with the response.
only-if-cached - Fetch uses any response in the HTTP cache matching the request, not paying attention to staleness. If there was no response, it returns a network error. (Can only be used when request’s mode is "same-origin". Any cached redirects will be followed assuming request’s redirect mode is "follow" and the redirects do not violate request’s mode.)
const fetch = require('make-fetch-happen').defaults({ cachePath: './my-cache'})// Will error with ENOTCACHED if we haven't already cached this urlfetch('https://registry.npmjs.org/make-fetch-happen', { cache: 'only-if-cached'})// Will refresh any local content and cache the new responsefetch('https://registry.npmjs.org/make-fetch-happen', { cache: 'reload'})// Will use any local data, even if stale. Otherwise, will hit network.fetch('https://registry.npmjs.org/make-fetch-happen', { cache: 'force-cache'})
> opts.cacheAdditionalHeaders
The following headers are always stored in the cache when present:
cache-control
content-encoding
content-language
content-type
date
etag
expires
last-modified
link
location
pragma
vary
This option allows a user to store additional custom headers in the cache.
If present, should be a comma-separated string or an array of domain extensions
that a proxy should not be used for.
This option may also be provided through process.env.NO_PROXY.
> opts.ca, opts.cert, opts.key, opts.strictSSL
These values are passed in directly to the HTTPS agent and will be used for both
proxied and unproxied outgoing HTTPS requests. They mostly correspond to the
same options the https module accepts, which will be themselves passed to
tls.connect(). opts.strictSSL corresponds to rejectUnauthorized.
> opts.localAddress
Passed directly to http and https request calls. Determines the local
address to bind to.
> opts.maxSockets
Default: 15
Maximum number of active concurrent sockets to use for the underlying
Http/Https/Proxy agents. This setting applies once per spawned agent.
15 is probably a pretty good value for most use-cases, and balances speed
with, uh, not knocking out people's routers. 🤓
> opts.retry
An object that can be used to tune request retry settings. Retries will only be attempted on the following conditions:
Request method is NOT POST AND
Request status is one of: 408, 420, 429, or any status in the 500-range. OR
Request errored with ECONNRESET, ECONNREFUSED, EADDRINUSE, ETIMEDOUT, or the fetch error request-timeout.
The following are worth noting as explicitly not retried:
getaddrinfo ENOTFOUND and will be assumed to be either an unreachable domain or the user will be assumed offline. If a response is cached, it will be returned immediately.
If opts.retry is false, it is equivalent to {retries: 0}
If opts.retry is a number, it is equivalent to {retries: num}
The following retry options are available if you want more control over it:
retries
factor
minTimeout
maxTimeout
randomize
For details on what each of these do, refer to the retry documentation.