lgoad-upload-action/node_modules/undici/lib/fetch/index.js

2149 lines
74 KiB
JavaScript
Raw Normal View History

// https://github.com/Ethan-Arrowood/undici-fetch
'use strict'
const {
Response,
makeNetworkError,
makeAppropriateNetworkError,
filterResponse,
makeResponse
} = require('./response')
const { Headers } = require('./headers')
const { Request, makeRequest } = require('./request')
const zlib = require('zlib')
const {
bytesMatch,
makePolicyContainer,
clonePolicyContainer,
requestBadPort,
TAOCheck,
appendRequestOriginHeader,
responseLocationURL,
requestCurrentURL,
setRequestReferrerPolicyOnRedirect,
tryUpgradeRequestToAPotentiallyTrustworthyURL,
createOpaqueTimingInfo,
appendFetchMetadata,
corsCheck,
crossOriginResourcePolicyCheck,
determineRequestsReferrer,
coarsenedSharedCurrentTime,
createDeferredPromise,
isBlobLike,
sameOrigin,
isCancelled,
isAborted,
isErrorLike,
fullyReadBody,
readableStreamClose,
isomorphicEncode,
urlIsLocal,
urlIsHttpHttpsScheme,
urlHasHttpsScheme
} = require('./util')
const { kState, kHeaders, kGuard, kRealm } = require('./symbols')
const assert = require('assert')
const { safelyExtractBody } = require('./body')
const {
redirectStatusSet,
nullBodyStatus,
safeMethodsSet,
requestBodyHeader,
subresourceSet,
DOMException
} = require('./constants')
const { kHeadersList } = require('../core/symbols')
const EE = require('events')
const { Readable, pipeline } = require('stream')
const { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = require('../core/util')
const { dataURLProcessor, serializeAMimeType } = require('./dataURL')
const { TransformStream } = require('stream/web')
const { getGlobalDispatcher } = require('../global')
const { webidl } = require('./webidl')
const { STATUS_CODES } = require('http')
const GET_OR_HEAD = ['GET', 'HEAD']
/** @type {import('buffer').resolveObjectURL} */
let resolveObjectURL
let ReadableStream = globalThis.ReadableStream
class Fetch extends EE {
constructor (dispatcher) {
super()
this.dispatcher = dispatcher
this.connection = null
this.dump = false
this.state = 'ongoing'
// 2 terminated listeners get added per request,
// but only 1 gets removed. If there are 20 redirects,
// 21 listeners will be added.
// See https://github.com/nodejs/undici/issues/1711
// TODO (fix): Find and fix root cause for leaked listener.
this.setMaxListeners(21)
}
terminate (reason) {
if (this.state !== 'ongoing') {
return
}
this.state = 'terminated'
this.connection?.destroy(reason)
this.emit('terminated', reason)
}
// https://fetch.spec.whatwg.org/#fetch-controller-abort
abort (error) {
if (this.state !== 'ongoing') {
return
}
// 1. Set controllers state to "aborted".
this.state = 'aborted'
// 2. Let fallbackError be an "AbortError" DOMException.
// 3. Set error to fallbackError if it is not given.
if (!error) {
error = new DOMException('The operation was aborted.', 'AbortError')
}
// 4. Let serializedError be StructuredSerialize(error).
// If that threw an exception, catch it, and let
// serializedError be StructuredSerialize(fallbackError).
// 5. Set controllers serialized abort reason to serializedError.
this.serializedAbortReason = error
this.connection?.destroy(error)
this.emit('terminated', error)
}
}
// https://fetch.spec.whatwg.org/#fetch-method
function fetch (input, init = {}) {
webidl.argumentLengthCheck(arguments, 1, { header: 'globalThis.fetch' })
// 1. Let p be a new promise.
const p = createDeferredPromise()
// 2. Let requestObject be the result of invoking the initial value of
// Request as constructor with input and init as arguments. If this throws
// an exception, reject p with it and return p.
let requestObject
try {
requestObject = new Request(input, init)
} catch (e) {
p.reject(e)
return p.promise
}
// 3. Let request be requestObjects request.
const request = requestObject[kState]
// 4. If requestObjects signals aborted flag is set, then:
if (requestObject.signal.aborted) {
// 1. Abort the fetch() call with p, request, null, and
// requestObjects signals abort reason.
abortFetch(p, request, null, requestObject.signal.reason)
// 2. Return p.
return p.promise
}
// 5. Let globalObject be requests clients global object.
const globalObject = request.client.globalObject
// 6. If globalObject is a ServiceWorkerGlobalScope object, then set
// requests service-workers mode to "none".
if (globalObject?.constructor?.name === 'ServiceWorkerGlobalScope') {
request.serviceWorkers = 'none'
}
// 7. Let responseObject be null.
let responseObject = null
// 8. Let relevantRealm be thiss relevant Realm.
const relevantRealm = null
// 9. Let locallyAborted be false.
let locallyAborted = false
// 10. Let controller be null.
let controller = null
// 11. Add the following abort steps to requestObjects signal:
addAbortListener(
requestObject.signal,
() => {
// 1. Set locallyAborted to true.
locallyAborted = true
// 2. Assert: controller is non-null.
assert(controller != null)
// 3. Abort controller with requestObjects signals abort reason.
controller.abort(requestObject.signal.reason)
// 4. Abort the fetch() call with p, request, responseObject,
// and requestObjects signals abort reason.
abortFetch(p, request, responseObject, requestObject.signal.reason)
}
)
// 12. Let handleFetchDone given response response be to finalize and
// report timing with response, globalObject, and "fetch".
const handleFetchDone = (response) =>
finalizeAndReportTiming(response, 'fetch')
// 13. Set controller to the result of calling fetch given request,
// with processResponseEndOfBody set to handleFetchDone, and processResponse
// given response being these substeps:
const processResponse = (response) => {
// 1. If locallyAborted is true, terminate these substeps.
if (locallyAborted) {
return Promise.resolve()
}
// 2. If responses aborted flag is set, then:
if (response.aborted) {
// 1. Let deserializedError be the result of deserialize a serialized
// abort reason given controllers serialized abort reason and
// relevantRealm.
// 2. Abort the fetch() call with p, request, responseObject, and
// deserializedError.
abortFetch(p, request, responseObject, controller.serializedAbortReason)
return Promise.resolve()
}
// 3. If response is a network error, then reject p with a TypeError
// and terminate these substeps.
if (response.type === 'error') {
p.reject(
Object.assign(new TypeError('fetch failed'), { cause: response.error })
)
return Promise.resolve()
}
// 4. Set responseObject to the result of creating a Response object,
// given response, "immutable", and relevantRealm.
responseObject = new Response()
responseObject[kState] = response
responseObject[kRealm] = relevantRealm
responseObject[kHeaders][kHeadersList] = response.headersList
responseObject[kHeaders][kGuard] = 'immutable'
responseObject[kHeaders][kRealm] = relevantRealm
// 5. Resolve p with responseObject.
p.resolve(responseObject)
}
controller = fetching({
request,
processResponseEndOfBody: handleFetchDone,
processResponse,
dispatcher: init.dispatcher ?? getGlobalDispatcher() // undici
})
// 14. Return p.
return p.promise
}
// https://fetch.spec.whatwg.org/#finalize-and-report-timing
function finalizeAndReportTiming (response, initiatorType = 'other') {
// 1. If response is an aborted network error, then return.
if (response.type === 'error' && response.aborted) {
return
}
// 2. If responses URL list is null or empty, then return.
if (!response.urlList?.length) {
return
}
// 3. Let originalURL be responses URL list[0].
const originalURL = response.urlList[0]
// 4. Let timingInfo be responses timing info.
let timingInfo = response.timingInfo
// 5. Let cacheState be responses cache state.
let cacheState = response.cacheState
// 6. If originalURLs scheme is not an HTTP(S) scheme, then return.
if (!urlIsHttpHttpsScheme(originalURL)) {
return
}
// 7. If timingInfo is null, then return.
if (timingInfo === null) {
return
}
// 8. If responses timing allow passed flag is not set, then:
if (!response.timingAllowPassed) {
// 1. Set timingInfo to a the result of creating an opaque timing info for timingInfo.
timingInfo = createOpaqueTimingInfo({
startTime: timingInfo.startTime
})
// 2. Set cacheState to the empty string.
cacheState = ''
}
// 9. Set timingInfos end time to the coarsened shared current time
// given globals relevant settings objects cross-origin isolated
// capability.
// TODO: given globals relevant settings objects cross-origin isolated
// capability?
timingInfo.endTime = coarsenedSharedCurrentTime()
// 10. Set responses timing info to timingInfo.
response.timingInfo = timingInfo
// 11. Mark resource timing for timingInfo, originalURL, initiatorType,
// global, and cacheState.
markResourceTiming(
timingInfo,
originalURL,
initiatorType,
globalThis,
cacheState
)
}
// https://w3c.github.io/resource-timing/#dfn-mark-resource-timing
function markResourceTiming (timingInfo, originalURL, initiatorType, globalThis, cacheState) {
if (nodeMajor > 18 || (nodeMajor === 18 && nodeMinor >= 2)) {
performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis, cacheState)
}
}
// https://fetch.spec.whatwg.org/#abort-fetch
function abortFetch (p, request, responseObject, error) {
// Note: AbortSignal.reason was added in node v17.2.0
// which would give us an undefined error to reject with.
// Remove this once node v16 is no longer supported.
if (!error) {
error = new DOMException('The operation was aborted.', 'AbortError')
}
// 1. Reject promise with error.
p.reject(error)
// 2. If requests body is not null and is readable, then cancel requests
// body with error.
if (request.body != null && isReadable(request.body?.stream)) {
request.body.stream.cancel(error).catch((err) => {
if (err.code === 'ERR_INVALID_STATE') {
// Node bug?
return
}
throw err
})
}
// 3. If responseObject is null, then return.
if (responseObject == null) {
return
}
// 4. Let response be responseObjects response.
const response = responseObject[kState]
// 5. If responses body is not null and is readable, then error responses
// body with error.
if (response.body != null && isReadable(response.body?.stream)) {
response.body.stream.cancel(error).catch((err) => {
if (err.code === 'ERR_INVALID_STATE') {
// Node bug?
return
}
throw err
})
}
}
// https://fetch.spec.whatwg.org/#fetching
function fetching ({
request,
processRequestBodyChunkLength,
processRequestEndOfBody,
processResponse,
processResponseEndOfBody,
processResponseConsumeBody,
useParallelQueue = false,
dispatcher // undici
}) {
// 1. Let taskDestination be null.
let taskDestination = null
// 2. Let crossOriginIsolatedCapability be false.
let crossOriginIsolatedCapability = false
// 3. If requests client is non-null, then:
if (request.client != null) {
// 1. Set taskDestination to requests clients global object.
taskDestination = request.client.globalObject
// 2. Set crossOriginIsolatedCapability to requests clients cross-origin
// isolated capability.
crossOriginIsolatedCapability =
request.client.crossOriginIsolatedCapability
}
// 4. If useParallelQueue is true, then set taskDestination to the result of
// starting a new parallel queue.
// TODO
// 5. Let timingInfo be a new fetch timing info whose start time and
// post-redirect start time are the coarsened shared current time given
// crossOriginIsolatedCapability.
const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability)
const timingInfo = createOpaqueTimingInfo({
startTime: currenTime
})
// 6. Let fetchParams be a new fetch params whose
// request is request,
// timing info is timingInfo,
// process request body chunk length is processRequestBodyChunkLength,
// process request end-of-body is processRequestEndOfBody,
// process response is processResponse,
// process response consume body is processResponseConsumeBody,
// process response end-of-body is processResponseEndOfBody,
// task destination is taskDestination,
// and cross-origin isolated capability is crossOriginIsolatedCapability.
const fetchParams = {
controller: new Fetch(dispatcher),
request,
timingInfo,
processRequestBodyChunkLength,
processRequestEndOfBody,
processResponse,
processResponseConsumeBody,
processResponseEndOfBody,
taskDestination,
crossOriginIsolatedCapability
}
// 7. If requests body is a byte sequence, then set requests body to
// requests body as a body.
// NOTE: Since fetching is only called from fetch, body should already be
// extracted.
assert(!request.body || request.body.stream)
// 8. If requests window is "client", then set requests window to requests
// client, if requests clients global object is a Window object; otherwise
// "no-window".
if (request.window === 'client') {
// TODO: What if request.client is null?
request.window =
request.client?.globalObject?.constructor?.name === 'Window'
? request.client
: 'no-window'
}
// 9. If requests origin is "client", then set requests origin to requests
// clients origin.
if (request.origin === 'client') {
// TODO: What if request.client is null?
request.origin = request.client?.origin
}
// 10. If all of the following conditions are true:
// TODO
// 11. If requests policy container is "client", then:
if (request.policyContainer === 'client') {
// 1. If requests client is non-null, then set requests policy
// container to a clone of requests clients policy container. [HTML]
if (request.client != null) {
request.policyContainer = clonePolicyContainer(
request.client.policyContainer
)
} else {
// 2. Otherwise, set requests policy container to a new policy
// container.
request.policyContainer = makePolicyContainer()
}
}
// 12. If requests header list does not contain `Accept`, then:
if (!request.headersList.contains('accept')) {
// 1. Let value be `*/*`.
const value = '*/*'
// 2. A user agent should set value to the first matching statement, if
// any, switching on requests destination:
// "document"
// "frame"
// "iframe"
// `text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8`
// "image"
// `image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5`
// "style"
// `text/css,*/*;q=0.1`
// TODO
// 3. Append `Accept`/value to requests header list.
request.headersList.append('accept', value)
}
// 13. If requests header list does not contain `Accept-Language`, then
// user agents should append `Accept-Language`/an appropriate value to
// requests header list.
if (!request.headersList.contains('accept-language')) {
request.headersList.append('accept-language', '*')
}
// 14. If requests priority is null, then use requests initiator and
// destination appropriately in setting requests priority to a
// user-agent-defined object.
if (request.priority === null) {
// TODO
}
// 15. If request is a subresource request, then:
if (subresourceSet.has(request.destination)) {
// TODO
}
// 16. Run main fetch given fetchParams.
mainFetch(fetchParams)
.catch(err => {
fetchParams.controller.terminate(err)
})
// 17. Return fetchParam's controller
return fetchParams.controller
}
// https://fetch.spec.whatwg.org/#concept-main-fetch
async function mainFetch (fetchParams, recursive = false) {
// 1. Let request be fetchParamss request.
const request = fetchParams.request
// 2. Let response be null.
let response = null
// 3. If requests local-URLs-only flag is set and requests current URL is
// not local, then set response to a network error.
if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) {
response = makeNetworkError('local URLs only')
}
// 4. Run report Content Security Policy violations for request.
// TODO
// 5. Upgrade request to a potentially trustworthy URL, if appropriate.
tryUpgradeRequestToAPotentiallyTrustworthyURL(request)
// 6. If should request be blocked due to a bad port, should fetching request
// be blocked as mixed content, or should request be blocked by Content
// Security Policy returns blocked, then set response to a network error.
if (requestBadPort(request) === 'blocked') {
response = makeNetworkError('bad port')
}
// TODO: should fetching request be blocked as mixed content?
// TODO: should request be blocked by Content Security Policy?
// 7. If requests referrer policy is the empty string, then set requests
// referrer policy to requests policy containers referrer policy.
if (request.referrerPolicy === '') {
request.referrerPolicy = request.policyContainer.referrerPolicy
}
// 8. If requests referrer is not "no-referrer", then set requests
// referrer to the result of invoking determine requests referrer.
if (request.referrer !== 'no-referrer') {
request.referrer = determineRequestsReferrer(request)
}
// 9. Set requests current URLs scheme to "https" if all of the following
// conditions are true:
// - requests current URLs scheme is "http"
// - requests current URLs host is a domain
// - Matching requests current URLs host per Known HSTS Host Domain Name
// Matching results in either a superdomain match with an asserted
// includeSubDomains directive or a congruent match (with or without an
// asserted includeSubDomains directive). [HSTS]
// TODO
// 10. If recursive is false, then run the remaining steps in parallel.
// TODO
// 11. If response is null, then set response to the result of running
// the steps corresponding to the first matching statement:
if (response === null) {
response = await (async () => {
const currentURL = requestCurrentURL(request)
if (
// - requests current URLs origin is same origin with requests origin,
// and requests response tainting is "basic"
(sameOrigin(currentURL, request.url) && request.responseTainting === 'basic') ||
// requests current URLs scheme is "data"
(currentURL.protocol === 'data:') ||
// - requests mode is "navigate" or "websocket"
(request.mode === 'navigate' || request.mode === 'websocket')
) {
// 1. Set requests response tainting to "basic".
request.responseTainting = 'basic'
// 2. Return the result of running scheme fetch given fetchParams.
return await schemeFetch(fetchParams)
}
// requests mode is "same-origin"
if (request.mode === 'same-origin') {
// 1. Return a network error.
return makeNetworkError('request mode cannot be "same-origin"')
}
// requests mode is "no-cors"
if (request.mode === 'no-cors') {
// 1. If requests redirect mode is not "follow", then return a network
// error.
if (request.redirect !== 'follow') {
return makeNetworkError(
'redirect mode cannot be "follow" for "no-cors" request'
)
}
// 2. Set requests response tainting to "opaque".
request.responseTainting = 'opaque'
// 3. Return the result of running scheme fetch given fetchParams.
return await schemeFetch(fetchParams)
}
// requests current URLs scheme is not an HTTP(S) scheme
if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) {
// Return a network error.
return makeNetworkError('URL scheme must be a HTTP(S) scheme')
}
// - requests use-CORS-preflight flag is set
// - requests unsafe-request flag is set and either requests method is
// not a CORS-safelisted method or CORS-unsafe request-header names with
// requests header list is not empty
// 1. Set requests response tainting to "cors".
// 2. Let corsWithPreflightResponse be the result of running HTTP fetch
// given fetchParams and true.
// 3. If corsWithPreflightResponse is a network error, then clear cache
// entries using request.
// 4. Return corsWithPreflightResponse.
// TODO
// Otherwise
// 1. Set requests response tainting to "cors".
request.responseTainting = 'cors'
// 2. Return the result of running HTTP fetch given fetchParams.
return await httpFetch(fetchParams)
})()
}
// 12. If recursive is true, then return response.
if (recursive) {
return response
}
// 13. If response is not a network error and response is not a filtered
// response, then:
if (response.status !== 0 && !response.internalResponse) {
// If requests response tainting is "cors", then:
if (request.responseTainting === 'cors') {
// 1. Let headerNames be the result of extracting header list values
// given `Access-Control-Expose-Headers` and responses header list.
// TODO
// 2. If requests credentials mode is not "include" and headerNames
// contains `*`, then set responses CORS-exposed header-name list to
// all unique header names in responses header list.
// TODO
// 3. Otherwise, if headerNames is not null or failure, then set
// responses CORS-exposed header-name list to headerNames.
// TODO
}
// Set response to the following filtered response with response as its
// internal response, depending on requests response tainting:
if (request.responseTainting === 'basic') {
response = filterResponse(response, 'basic')
} else if (request.responseTainting === 'cors') {
response = filterResponse(response, 'cors')
} else if (request.responseTainting === 'opaque') {
response = filterResponse(response, 'opaque')
} else {
assert(false)
}
}
// 14. Let internalResponse be response, if response is a network error,
// and responses internal response otherwise.
let internalResponse =
response.status === 0 ? response : response.internalResponse
// 15. If internalResponses URL list is empty, then set it to a clone of
// requests URL list.
if (internalResponse.urlList.length === 0) {
internalResponse.urlList.push(...request.urlList)
}
// 16. If requests timing allow failed flag is unset, then set
// internalResponses timing allow passed flag.
if (!request.timingAllowFailed) {
response.timingAllowPassed = true
}
// 17. If response is not a network error and any of the following returns
// blocked
// - should internalResponse to request be blocked as mixed content
// - should internalResponse to request be blocked by Content Security Policy
// - should internalResponse to request be blocked due to its MIME type
// - should internalResponse to request be blocked due to nosniff
// TODO
// 18. If responses type is "opaque", internalResponses status is 206,
// internalResponses range-requested flag is set, and requests header
// list does not contain `Range`, then set response and internalResponse
// to a network error.
if (
response.type === 'opaque' &&
internalResponse.status === 206 &&
internalResponse.rangeRequested &&
!request.headers.contains('range')
) {
response = internalResponse = makeNetworkError()
}
// 19. If response is not a network error and either requests method is
// `HEAD` or `CONNECT`, or internalResponses status is a null body status,
// set internalResponses body to null and disregard any enqueuing toward
// it (if any).
if (
response.status !== 0 &&
(request.method === 'HEAD' ||
request.method === 'CONNECT' ||
nullBodyStatus.includes(internalResponse.status))
) {
internalResponse.body = null
fetchParams.controller.dump = true
}
// 20. If requests integrity metadata is not the empty string, then:
if (request.integrity) {
// 1. Let processBodyError be this step: run fetch finale given fetchParams
// and a network error.
const processBodyError = (reason) =>
fetchFinale(fetchParams, makeNetworkError(reason))
// 2. If requests response tainting is "opaque", or responses body is null,
// then run processBodyError and abort these steps.
if (request.responseTainting === 'opaque' || response.body == null) {
processBodyError(response.error)
return
}
// 3. Let processBody given bytes be these steps:
const processBody = (bytes) => {
// 1. If bytes do not match requests integrity metadata,
// then run processBodyError and abort these steps. [SRI]
if (!bytesMatch(bytes, request.integrity)) {
processBodyError('integrity mismatch')
return
}
// 2. Set responses body to bytes as a body.
response.body = safelyExtractBody(bytes)[0]
// 3. Run fetch finale given fetchParams and response.
fetchFinale(fetchParams, response)
}
// 4. Fully read responses body given processBody and processBodyError.
await fullyReadBody(response.body, processBody, processBodyError)
} else {
// 21. Otherwise, run fetch finale given fetchParams and response.
fetchFinale(fetchParams, response)
}
}
// https://fetch.spec.whatwg.org/#concept-scheme-fetch
// given a fetch params fetchParams
function schemeFetch (fetchParams) {
// Note: since the connection is destroyed on redirect, which sets fetchParams to a
// cancelled state, we do not want this condition to trigger *unless* there have been
// no redirects. See https://github.com/nodejs/undici/issues/1776
// 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
return Promise.resolve(makeAppropriateNetworkError(fetchParams))
}
// 2. Let request be fetchParamss request.
const { request } = fetchParams
const { protocol: scheme } = requestCurrentURL(request)
// 3. Switch on requests current URLs scheme and run the associated steps:
switch (scheme) {
case 'about:': {
// If requests current URLs path is the string "blank", then return a new response
// whose status message is `OK`, header list is « (`Content-Type`, `text/html;charset=utf-8`) »,
// and body is the empty byte sequence as a body.
// Otherwise, return a network error.
return Promise.resolve(makeNetworkError('about scheme is not supported'))
}
case 'blob:': {
if (!resolveObjectURL) {
resolveObjectURL = require('buffer').resolveObjectURL
}
// 1. Let blobURLEntry be requests current URLs blob URL entry.
const blobURLEntry = requestCurrentURL(request)
// https://github.com/web-platform-tests/wpt/blob/7b0ebaccc62b566a1965396e5be7bb2bc06f841f/FileAPI/url/resources/fetch-tests.js#L52-L56
// Buffer.resolveObjectURL does not ignore URL queries.
if (blobURLEntry.search.length !== 0) {
return Promise.resolve(makeNetworkError('NetworkError when attempting to fetch resource.'))
}
const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString())
// 2. If requests method is not `GET`, blobURLEntry is null, or blobURLEntrys
// object is not a Blob object, then return a network error.
if (request.method !== 'GET' || !isBlobLike(blobURLEntryObject)) {
return Promise.resolve(makeNetworkError('invalid method'))
}
// 3. Let bodyWithType be the result of safely extracting blobURLEntrys object.
const bodyWithType = safelyExtractBody(blobURLEntryObject)
// 4. Let body be bodyWithTypes body.
const body = bodyWithType[0]
// 5. Let length be bodys length, serialized and isomorphic encoded.
const length = isomorphicEncode(`${body.length}`)
// 6. Let type be bodyWithTypes type if it is non-null; otherwise the empty byte sequence.
const type = bodyWithType[1] ?? ''
// 7. Return a new response whose status message is `OK`, header list is
// « (`Content-Length`, length), (`Content-Type`, type) », and body is body.
const response = makeResponse({
statusText: 'OK',
headersList: [
['content-length', { name: 'Content-Length', value: length }],
['content-type', { name: 'Content-Type', value: type }]
]
})
response.body = body
return Promise.resolve(response)
}
case 'data:': {
// 1. Let dataURLStruct be the result of running the
// data: URL processor on requests current URL.
const currentURL = requestCurrentURL(request)
const dataURLStruct = dataURLProcessor(currentURL)
// 2. If dataURLStruct is failure, then return a
// network error.
if (dataURLStruct === 'failure') {
return Promise.resolve(makeNetworkError('failed to fetch the data URL'))
}
// 3. Let mimeType be dataURLStructs MIME type, serialized.
const mimeType = serializeAMimeType(dataURLStruct.mimeType)
// 4. Return a response whose status message is `OK`,
// header list is « (`Content-Type`, mimeType) »,
// and body is dataURLStructs body as a body.
return Promise.resolve(makeResponse({
statusText: 'OK',
headersList: [
['content-type', { name: 'Content-Type', value: mimeType }]
],
body: safelyExtractBody(dataURLStruct.body)[0]
}))
}
case 'file:': {
// For now, unfortunate as it is, file URLs are left as an exercise for the reader.
// When in doubt, return a network error.
return Promise.resolve(makeNetworkError('not implemented... yet...'))
}
case 'http:':
case 'https:': {
// Return the result of running HTTP fetch given fetchParams.
return httpFetch(fetchParams)
.catch((err) => makeNetworkError(err))
}
default: {
return Promise.resolve(makeNetworkError('unknown scheme'))
}
}
}
// https://fetch.spec.whatwg.org/#finalize-response
function finalizeResponse (fetchParams, response) {
// 1. Set fetchParamss requests done flag.
fetchParams.request.done = true
// 2, If fetchParamss process response done is not null, then queue a fetch
// task to run fetchParamss process response done given response, with
// fetchParamss task destination.
if (fetchParams.processResponseDone != null) {
queueMicrotask(() => fetchParams.processResponseDone(response))
}
}
// https://fetch.spec.whatwg.org/#fetch-finale
function fetchFinale (fetchParams, response) {
// 1. If response is a network error, then:
if (response.type === 'error') {
// 1. Set responses URL list to « fetchParamss requests URL list[0] ».
response.urlList = [fetchParams.request.urlList[0]]
// 2. Set responses timing info to the result of creating an opaque timing
// info for fetchParamss timing info.
response.timingInfo = createOpaqueTimingInfo({
startTime: fetchParams.timingInfo.startTime
})
}
// 2. Let processResponseEndOfBody be the following steps:
const processResponseEndOfBody = () => {
// 1. Set fetchParamss requests done flag.
fetchParams.request.done = true
// If fetchParamss process response end-of-body is not null,
// then queue a fetch task to run fetchParamss process response
// end-of-body given response with fetchParamss task destination.
if (fetchParams.processResponseEndOfBody != null) {
queueMicrotask(() => fetchParams.processResponseEndOfBody(response))
}
}
// 3. If fetchParamss process response is non-null, then queue a fetch task
// to run fetchParamss process response given response, with fetchParamss
// task destination.
if (fetchParams.processResponse != null) {
queueMicrotask(() => fetchParams.processResponse(response))
}
// 4. If responses body is null, then run processResponseEndOfBody.
if (response.body == null) {
processResponseEndOfBody()
} else {
// 5. Otherwise:
// 1. Let transformStream be a new a TransformStream.
// 2. Let identityTransformAlgorithm be an algorithm which, given chunk,
// enqueues chunk in transformStream.
const identityTransformAlgorithm = (chunk, controller) => {
controller.enqueue(chunk)
}
// 3. Set up transformStream with transformAlgorithm set to identityTransformAlgorithm
// and flushAlgorithm set to processResponseEndOfBody.
const transformStream = new TransformStream({
start () {},
transform: identityTransformAlgorithm,
flush: processResponseEndOfBody
}, {
size () {
return 1
}
}, {
size () {
return 1
}
})
// 4. Set responses body to the result of piping responses body through transformStream.
response.body = { stream: response.body.stream.pipeThrough(transformStream) }
}
// 6. If fetchParamss process response consume body is non-null, then:
if (fetchParams.processResponseConsumeBody != null) {
// 1. Let processBody given nullOrBytes be this step: run fetchParamss
// process response consume body given response and nullOrBytes.
const processBody = (nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes)
// 2. Let processBodyError be this step: run fetchParamss process
// response consume body given response and failure.
const processBodyError = (failure) => fetchParams.processResponseConsumeBody(response, failure)
// 3. If responses body is null, then queue a fetch task to run processBody
// given null, with fetchParamss task destination.
if (response.body == null) {
queueMicrotask(() => processBody(null))
} else {
// 4. Otherwise, fully read responses body given processBody, processBodyError,
// and fetchParamss task destination.
return fullyReadBody(response.body, processBody, processBodyError)
}
return Promise.resolve()
}
}
// https://fetch.spec.whatwg.org/#http-fetch
async function httpFetch (fetchParams) {
// 1. Let request be fetchParamss request.
const request = fetchParams.request
// 2. Let response be null.
let response = null
// 3. Let actualResponse be null.
let actualResponse = null
// 4. Let timingInfo be fetchParamss timing info.
const timingInfo = fetchParams.timingInfo
// 5. If requests service-workers mode is "all", then:
if (request.serviceWorkers === 'all') {
// TODO
}
// 6. If response is null, then:
if (response === null) {
// 1. If makeCORSPreflight is true and one of these conditions is true:
// TODO
// 2. If requests redirect mode is "follow", then set requests
// service-workers mode to "none".
if (request.redirect === 'follow') {
request.serviceWorkers = 'none'
}
// 3. Set response and actualResponse to the result of running
// HTTP-network-or-cache fetch given fetchParams.
actualResponse = response = await httpNetworkOrCacheFetch(fetchParams)
// 4. If requests response tainting is "cors" and a CORS check
// for request and response returns failure, then return a network error.
if (
request.responseTainting === 'cors' &&
corsCheck(request, response) === 'failure'
) {
return makeNetworkError('cors failure')
}
// 5. If the TAO check for request and response returns failure, then set
// requests timing allow failed flag.
if (TAOCheck(request, response) === 'failure') {
request.timingAllowFailed = true
}
}
// 7. If either requests response tainting or responses type
// is "opaque", and the cross-origin resource policy check with
// requests origin, requests client, requests destination,
// and actualResponse returns blocked, then return a network error.
if (
(request.responseTainting === 'opaque' || response.type === 'opaque') &&
crossOriginResourcePolicyCheck(
request.origin,
request.client,
request.destination,
actualResponse
) === 'blocked'
) {
return makeNetworkError('blocked')
}
// 8. If actualResponses status is a redirect status, then:
if (redirectStatusSet.has(actualResponse.status)) {
// 1. If actualResponses status is not 303, requests body is not null,
// and the connection uses HTTP/2, then user agents may, and are even
// encouraged to, transmit an RST_STREAM frame.
// See, https://github.com/whatwg/fetch/issues/1288
if (request.redirect !== 'manual') {
fetchParams.controller.connection.destroy()
}
// 2. Switch on requests redirect mode:
if (request.redirect === 'error') {
// Set response to a network error.
response = makeNetworkError('unexpected redirect')
} else if (request.redirect === 'manual') {
// Set response to an opaque-redirect filtered response whose internal
// response is actualResponse.
// NOTE(spec): On the web this would return an `opaqueredirect` response,
// but that doesn't make sense server side.
// See https://github.com/nodejs/undici/issues/1193.
response = actualResponse
} else if (request.redirect === 'follow') {
// Set response to the result of running HTTP-redirect fetch given
// fetchParams and response.
response = await httpRedirectFetch(fetchParams, response)
} else {
assert(false)
}
}
// 9. Set responses timing info to timingInfo.
response.timingInfo = timingInfo
// 10. Return response.
return response
}
// https://fetch.spec.whatwg.org/#http-redirect-fetch
function httpRedirectFetch (fetchParams, response) {
// 1. Let request be fetchParamss request.
const request = fetchParams.request
// 2. Let actualResponse be response, if response is not a filtered response,
// and responses internal response otherwise.
const actualResponse = response.internalResponse
? response.internalResponse
: response
// 3. Let locationURL be actualResponses location URL given requests current
// URLs fragment.
let locationURL
try {
locationURL = responseLocationURL(
actualResponse,
requestCurrentURL(request).hash
)
// 4. If locationURL is null, then return response.
if (locationURL == null) {
return response
}
} catch (err) {
// 5. If locationURL is failure, then return a network error.
return Promise.resolve(makeNetworkError(err))
}
// 6. If locationURLs scheme is not an HTTP(S) scheme, then return a network
// error.
if (!urlIsHttpHttpsScheme(locationURL)) {
return Promise.resolve(makeNetworkError('URL scheme must be a HTTP(S) scheme'))
}
// 7. If requests redirect count is 20, then return a network error.
if (request.redirectCount === 20) {
return Promise.resolve(makeNetworkError('redirect count exceeded'))
}
// 8. Increase requests redirect count by 1.
request.redirectCount += 1
// 9. If requests mode is "cors", locationURL includes credentials, and
// requests origin is not same origin with locationURLs origin, then return
// a network error.
if (
request.mode === 'cors' &&
(locationURL.username || locationURL.password) &&
!sameOrigin(request, locationURL)
) {
return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'))
}
// 10. If requests response tainting is "cors" and locationURL includes
// credentials, then return a network error.
if (
request.responseTainting === 'cors' &&
(locationURL.username || locationURL.password)
) {
return Promise.resolve(makeNetworkError(
'URL cannot contain credentials for request mode "cors"'
))
}
// 11. If actualResponses status is not 303, requests body is non-null,
// and requests bodys source is null, then return a network error.
if (
actualResponse.status !== 303 &&
request.body != null &&
request.body.source == null
) {
return Promise.resolve(makeNetworkError())
}
// 12. If one of the following is true
// - actualResponses status is 301 or 302 and requests method is `POST`
// - actualResponses status is 303 and requests method is not `GET` or `HEAD`
if (
([301, 302].includes(actualResponse.status) && request.method === 'POST') ||
(actualResponse.status === 303 &&
!GET_OR_HEAD.includes(request.method))
) {
// then:
// 1. Set requests method to `GET` and requests body to null.
request.method = 'GET'
request.body = null
// 2. For each headerName of request-body-header name, delete headerName from
// requests header list.
for (const headerName of requestBodyHeader) {
request.headersList.delete(headerName)
}
}
// 13. If requests current URLs origin is not same origin with locationURLs
// origin, then for each headerName of CORS non-wildcard request-header name,
// delete headerName from requests header list.
if (!sameOrigin(requestCurrentURL(request), locationURL)) {
// https://fetch.spec.whatwg.org/#cors-non-wildcard-request-header-name
request.headersList.delete('authorization')
// https://fetch.spec.whatwg.org/#authentication-entries
request.headersList.delete('proxy-authorization', true)
// "Cookie" and "Host" are forbidden request-headers, which undici doesn't implement.
request.headersList.delete('cookie')
request.headersList.delete('host')
}
// 14. If requests body is non-null, then set requests body to the first return
// value of safely extracting requests bodys source.
if (request.body != null) {
assert(request.body.source != null)
request.body = safelyExtractBody(request.body.source)[0]
}
// 15. Let timingInfo be fetchParamss timing info.
const timingInfo = fetchParams.timingInfo
// 16. Set timingInfos redirect end time and post-redirect start time to the
// coarsened shared current time given fetchParamss cross-origin isolated
// capability.
timingInfo.redirectEndTime = timingInfo.postRedirectStartTime =
coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability)
// 17. If timingInfos redirect start time is 0, then set timingInfos
// redirect start time to timingInfos start time.
if (timingInfo.redirectStartTime === 0) {
timingInfo.redirectStartTime = timingInfo.startTime
}
// 18. Append locationURL to requests URL list.
request.urlList.push(locationURL)
// 19. Invoke set requests referrer policy on redirect on request and
// actualResponse.
setRequestReferrerPolicyOnRedirect(request, actualResponse)
// 20. Return the result of running main fetch given fetchParams and true.
return mainFetch(fetchParams, true)
}
// https://fetch.spec.whatwg.org/#http-network-or-cache-fetch
async function httpNetworkOrCacheFetch (
fetchParams,
isAuthenticationFetch = false,
isNewConnectionFetch = false
) {
// 1. Let request be fetchParamss request.
const request = fetchParams.request
// 2. Let httpFetchParams be null.
let httpFetchParams = null
// 3. Let httpRequest be null.
let httpRequest = null
// 4. Let response be null.
let response = null
// 5. Let storedResponse be null.
// TODO: cache
// 6. Let httpCache be null.
const httpCache = null
// 7. Let the revalidatingFlag be unset.
const revalidatingFlag = false
// 8. Run these steps, but abort when the ongoing fetch is terminated:
// 1. If requests window is "no-window" and requests redirect mode is
// "error", then set httpFetchParams to fetchParams and httpRequest to
// request.
if (request.window === 'no-window' && request.redirect === 'error') {
httpFetchParams = fetchParams
httpRequest = request
} else {
// Otherwise:
// 1. Set httpRequest to a clone of request.
httpRequest = makeRequest(request)
// 2. Set httpFetchParams to a copy of fetchParams.
httpFetchParams = { ...fetchParams }
// 3. Set httpFetchParamss request to httpRequest.
httpFetchParams.request = httpRequest
}
// 3. Let includeCredentials be true if one of
const includeCredentials =
request.credentials === 'include' ||
(request.credentials === 'same-origin' &&
request.responseTainting === 'basic')
// 4. Let contentLength be httpRequests bodys length, if httpRequests
// body is non-null; otherwise null.
const contentLength = httpRequest.body ? httpRequest.body.length : null
// 5. Let contentLengthHeaderValue be null.
let contentLengthHeaderValue = null
// 6. If httpRequests body is null and httpRequests method is `POST` or
// `PUT`, then set contentLengthHeaderValue to `0`.
if (
httpRequest.body == null &&
['POST', 'PUT'].includes(httpRequest.method)
) {
contentLengthHeaderValue = '0'
}
// 7. If contentLength is non-null, then set contentLengthHeaderValue to
// contentLength, serialized and isomorphic encoded.
if (contentLength != null) {
contentLengthHeaderValue = isomorphicEncode(`${contentLength}`)
}
// 8. If contentLengthHeaderValue is non-null, then append
// `Content-Length`/contentLengthHeaderValue to httpRequests header
// list.
if (contentLengthHeaderValue != null) {
httpRequest.headersList.append('content-length', contentLengthHeaderValue)
}
// 9. If contentLengthHeaderValue is non-null, then append (`Content-Length`,
// contentLengthHeaderValue) to httpRequests header list.
// 10. If contentLength is non-null and httpRequests keepalive is true,
// then:
if (contentLength != null && httpRequest.keepalive) {
// NOTE: keepalive is a noop outside of browser context.
}
// 11. If httpRequests referrer is a URL, then append
// `Referer`/httpRequests referrer, serialized and isomorphic encoded,
// to httpRequests header list.
if (httpRequest.referrer instanceof URL) {
httpRequest.headersList.append('referer', isomorphicEncode(httpRequest.referrer.href))
}
// 12. Append a request `Origin` header for httpRequest.
appendRequestOriginHeader(httpRequest)
// 13. Append the Fetch metadata headers for httpRequest. [FETCH-METADATA]
appendFetchMetadata(httpRequest)
// 14. If httpRequests header list does not contain `User-Agent`, then
// user agents should append `User-Agent`/default `User-Agent` value to
// httpRequests header list.
if (!httpRequest.headersList.contains('user-agent')) {
httpRequest.headersList.append('user-agent', typeof esbuildDetection === 'undefined' ? 'undici' : 'node')
}
// 15. If httpRequests cache mode is "default" and httpRequests header
// list contains `If-Modified-Since`, `If-None-Match`,
// `If-Unmodified-Since`, `If-Match`, or `If-Range`, then set
// httpRequests cache mode to "no-store".
if (
httpRequest.cache === 'default' &&
(httpRequest.headersList.contains('if-modified-since') ||
httpRequest.headersList.contains('if-none-match') ||
httpRequest.headersList.contains('if-unmodified-since') ||
httpRequest.headersList.contains('if-match') ||
httpRequest.headersList.contains('if-range'))
) {
httpRequest.cache = 'no-store'
}
// 16. If httpRequests cache mode is "no-cache", httpRequests prevent
// no-cache cache-control header modification flag is unset, and
// httpRequests header list does not contain `Cache-Control`, then append
// `Cache-Control`/`max-age=0` to httpRequests header list.
if (
httpRequest.cache === 'no-cache' &&
!httpRequest.preventNoCacheCacheControlHeaderModification &&
!httpRequest.headersList.contains('cache-control')
) {
httpRequest.headersList.append('cache-control', 'max-age=0')
}
// 17. If httpRequests cache mode is "no-store" or "reload", then:
if (httpRequest.cache === 'no-store' || httpRequest.cache === 'reload') {
// 1. If httpRequests header list does not contain `Pragma`, then append
// `Pragma`/`no-cache` to httpRequests header list.
if (!httpRequest.headersList.contains('pragma')) {
httpRequest.headersList.append('pragma', 'no-cache')
}
// 2. If httpRequests header list does not contain `Cache-Control`,
// then append `Cache-Control`/`no-cache` to httpRequests header list.
if (!httpRequest.headersList.contains('cache-control')) {
httpRequest.headersList.append('cache-control', 'no-cache')
}
}
// 18. If httpRequests header list contains `Range`, then append
// `Accept-Encoding`/`identity` to httpRequests header list.
if (httpRequest.headersList.contains('range')) {
httpRequest.headersList.append('accept-encoding', 'identity')
}
// 19. Modify httpRequests header list per HTTP. Do not append a given
// header if httpRequests header list contains that headers name.
// TODO: https://github.com/whatwg/fetch/issues/1285#issuecomment-896560129
if (!httpRequest.headersList.contains('accept-encoding')) {
if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) {
httpRequest.headersList.append('accept-encoding', 'br, gzip, deflate')
} else {
httpRequest.headersList.append('accept-encoding', 'gzip, deflate')
}
}
httpRequest.headersList.delete('host')
// 20. If includeCredentials is true, then:
if (includeCredentials) {
// 1. If the user agent is not configured to block cookies for httpRequest
// (see section 7 of [COOKIES]), then:
// TODO: credentials
// 2. If httpRequests header list does not contain `Authorization`, then:
// TODO: credentials
}
// 21. If theres a proxy-authentication entry, use it as appropriate.
// TODO: proxy-authentication
// 22. Set httpCache to the result of determining the HTTP cache
// partition, given httpRequest.
// TODO: cache
// 23. If httpCache is null, then set httpRequests cache mode to
// "no-store".
if (httpCache == null) {
httpRequest.cache = 'no-store'
}
// 24. If httpRequests cache mode is neither "no-store" nor "reload",
// then:
if (httpRequest.mode !== 'no-store' && httpRequest.mode !== 'reload') {
// TODO: cache
}
// 9. If aborted, then return the appropriate network error for fetchParams.
// TODO
// 10. If response is null, then:
if (response == null) {
// 1. If httpRequests cache mode is "only-if-cached", then return a
// network error.
if (httpRequest.mode === 'only-if-cached') {
return makeNetworkError('only if cached')
}
// 2. Let forwardResponse be the result of running HTTP-network fetch
// given httpFetchParams, includeCredentials, and isNewConnectionFetch.
const forwardResponse = await httpNetworkFetch(
httpFetchParams,
includeCredentials,
isNewConnectionFetch
)
// 3. If httpRequests method is unsafe and forwardResponses status is
// in the range 200 to 399, inclusive, invalidate appropriate stored
// responses in httpCache, as per the "Invalidation" chapter of HTTP
// Caching, and set storedResponse to null. [HTTP-CACHING]
if (
!safeMethodsSet.has(httpRequest.method) &&
forwardResponse.status >= 200 &&
forwardResponse.status <= 399
) {
// TODO: cache
}
// 4. If the revalidatingFlag is set and forwardResponses status is 304,
// then:
if (revalidatingFlag && forwardResponse.status === 304) {
// TODO: cache
}
// 5. If response is null, then:
if (response == null) {
// 1. Set response to forwardResponse.
response = forwardResponse
// 2. Store httpRequest and forwardResponse in httpCache, as per the
// "Storing Responses in Caches" chapter of HTTP Caching. [HTTP-CACHING]
// TODO: cache
}
}
// 11. Set responses URL list to a clone of httpRequests URL list.
response.urlList = [...httpRequest.urlList]
// 12. If httpRequests header list contains `Range`, then set responses
// range-requested flag.
if (httpRequest.headersList.contains('range')) {
response.rangeRequested = true
}
// 13. Set responses request-includes-credentials to includeCredentials.
response.requestIncludesCredentials = includeCredentials
// 14. If responses status is 401, httpRequests response tainting is not
// "cors", includeCredentials is true, and requests window is an environment
// settings object, then:
// TODO
// 15. If responses status is 407, then:
if (response.status === 407) {
// 1. If requests window is "no-window", then return a network error.
if (request.window === 'no-window') {
return makeNetworkError()
}
// 2. ???
// 3. If fetchParams is canceled, then return the appropriate network error for fetchParams.
if (isCancelled(fetchParams)) {
return makeAppropriateNetworkError(fetchParams)
}
// 4. Prompt the end user as appropriate in requests window and store
// the result as a proxy-authentication entry. [HTTP-AUTH]
// TODO: Invoke some kind of callback?
// 5. Set response to the result of running HTTP-network-or-cache fetch given
// fetchParams.
// TODO
return makeNetworkError('proxy authentication required')
}
// 16. If all of the following are true
if (
// responses status is 421
response.status === 421 &&
// isNewConnectionFetch is false
!isNewConnectionFetch &&
// requests body is null, or requests body is non-null and requests bodys source is non-null
(request.body == null || request.body.source != null)
) {
// then:
// 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
if (isCancelled(fetchParams)) {
return makeAppropriateNetworkError(fetchParams)
}
// 2. Set response to the result of running HTTP-network-or-cache
// fetch given fetchParams, isAuthenticationFetch, and true.
// TODO (spec): The spec doesn't specify this but we need to cancel
// the active response before we can start a new one.
// https://github.com/whatwg/fetch/issues/1293
fetchParams.controller.connection.destroy()
response = await httpNetworkOrCacheFetch(
fetchParams,
isAuthenticationFetch,
true
)
}
// 17. If isAuthenticationFetch is true, then create an authentication entry
if (isAuthenticationFetch) {
// TODO
}
// 18. Return response.
return response
}
// https://fetch.spec.whatwg.org/#http-network-fetch
async function httpNetworkFetch (
fetchParams,
includeCredentials = false,
forceNewConnection = false
) {
assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed)
fetchParams.controller.connection = {
abort: null,
destroyed: false,
destroy (err) {
if (!this.destroyed) {
this.destroyed = true
this.abort?.(err ?? new DOMException('The operation was aborted.', 'AbortError'))
}
}
}
// 1. Let request be fetchParamss request.
const request = fetchParams.request
// 2. Let response be null.
let response = null
// 3. Let timingInfo be fetchParamss timing info.
const timingInfo = fetchParams.timingInfo
// 4. Let httpCache be the result of determining the HTTP cache partition,
// given request.
// TODO: cache
const httpCache = null
// 5. If httpCache is null, then set requests cache mode to "no-store".
if (httpCache == null) {
request.cache = 'no-store'
}
// 6. Let networkPartitionKey be the result of determining the network
// partition key given request.
// TODO
// 7. Let newConnection be "yes" if forceNewConnection is true; otherwise
// "no".
const newConnection = forceNewConnection ? 'yes' : 'no' // eslint-disable-line no-unused-vars
// 8. Switch on requests mode:
if (request.mode === 'websocket') {
// Let connection be the result of obtaining a WebSocket connection,
// given requests current URL.
// TODO
} else {
// Let connection be the result of obtaining a connection, given
// networkPartitionKey, requests current URLs origin,
// includeCredentials, and forceNewConnection.
// TODO
}
// 9. Run these steps, but abort when the ongoing fetch is terminated:
// 1. If connection is failure, then return a network error.
// 2. Set timingInfos final connection timing info to the result of
// calling clamp and coarsen connection timing info with connections
// timing info, timingInfos post-redirect start time, and fetchParamss
// cross-origin isolated capability.
// 3. If connection is not an HTTP/2 connection, requests body is non-null,
// and requests bodys source is null, then append (`Transfer-Encoding`,
// `chunked`) to requests header list.
// 4. Set timingInfos final network-request start time to the coarsened
// shared current time given fetchParamss cross-origin isolated
// capability.
// 5. Set response to the result of making an HTTP request over connection
// using request with the following caveats:
// - Follow the relevant requirements from HTTP. [HTTP] [HTTP-SEMANTICS]
// [HTTP-COND] [HTTP-CACHING] [HTTP-AUTH]
// - If requests body is non-null, and requests bodys source is null,
// then the user agent may have a buffer of up to 64 kibibytes and store
// a part of requests body in that buffer. If the user agent reads from
// requests body beyond that buffers size and the user agent needs to
// resend request, then instead return a network error.
// - Set timingInfos final network-response start time to the coarsened
// shared current time given fetchParamss cross-origin isolated capability,
// immediately after the user agents HTTP parser receives the first byte
// of the response (e.g., frame header bytes for HTTP/2 or response status
// line for HTTP/1.x).
// - Wait until all the headers are transmitted.
// - Any responses whose status is in the range 100 to 199, inclusive,
// and is not 101, are to be ignored, except for the purposes of setting
// timingInfos final network-response start time above.
// - If requests header list contains `Transfer-Encoding`/`chunked` and
// response is transferred via HTTP/1.0 or older, then return a network
// error.
// - If the HTTP request results in a TLS client certificate dialog, then:
// 1. If requests window is an environment settings object, make the
// dialog available in requests window.
// 2. Otherwise, return a network error.
// To transmit requests body body, run these steps:
let requestBody = null
// 1. If body is null and fetchParamss process request end-of-body is
// non-null, then queue a fetch task given fetchParamss process request
// end-of-body and fetchParamss task destination.
if (request.body == null && fetchParams.processRequestEndOfBody) {
queueMicrotask(() => fetchParams.processRequestEndOfBody())
} else if (request.body != null) {
// 2. Otherwise, if body is non-null:
// 1. Let processBodyChunk given bytes be these steps:
const processBodyChunk = async function * (bytes) {
// 1. If the ongoing fetch is terminated, then abort these steps.
if (isCancelled(fetchParams)) {
return
}
// 2. Run this step in parallel: transmit bytes.
yield bytes
// 3. If fetchParamss process request body is non-null, then run
// fetchParamss process request body given bytess length.
fetchParams.processRequestBodyChunkLength?.(bytes.byteLength)
}
// 2. Let processEndOfBody be these steps:
const processEndOfBody = () => {
// 1. If fetchParams is canceled, then abort these steps.
if (isCancelled(fetchParams)) {
return
}
// 2. If fetchParamss process request end-of-body is non-null,
// then run fetchParamss process request end-of-body.
if (fetchParams.processRequestEndOfBody) {
fetchParams.processRequestEndOfBody()
}
}
// 3. Let processBodyError given e be these steps:
const processBodyError = (e) => {
// 1. If fetchParams is canceled, then abort these steps.
if (isCancelled(fetchParams)) {
return
}
// 2. If e is an "AbortError" DOMException, then abort fetchParamss controller.
if (e.name === 'AbortError') {
fetchParams.controller.abort()
} else {
fetchParams.controller.terminate(e)
}
}
// 4. Incrementally read requests body given processBodyChunk, processEndOfBody,
// processBodyError, and fetchParamss task destination.
requestBody = (async function * () {
try {
for await (const bytes of request.body.stream) {
yield * processBodyChunk(bytes)
}
processEndOfBody()
} catch (err) {
processBodyError(err)
}
})()
}
try {
// socket is only provided for websockets
const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody })
if (socket) {
response = makeResponse({ status, statusText, headersList, socket })
} else {
const iterator = body[Symbol.asyncIterator]()
fetchParams.controller.next = () => iterator.next()
response = makeResponse({ status, statusText, headersList })
}
} catch (err) {
// 10. If aborted, then:
if (err.name === 'AbortError') {
// 1. If connection uses HTTP/2, then transmit an RST_STREAM frame.
fetchParams.controller.connection.destroy()
// 2. Return the appropriate network error for fetchParams.
return makeAppropriateNetworkError(fetchParams, err)
}
return makeNetworkError(err)
}
// 11. Let pullAlgorithm be an action that resumes the ongoing fetch
// if it is suspended.
const pullAlgorithm = () => {
fetchParams.controller.resume()
}
// 12. Let cancelAlgorithm be an algorithm that aborts fetchParamss
// controller with reason, given reason.
const cancelAlgorithm = (reason) => {
fetchParams.controller.abort(reason)
}
// 13. Let highWaterMark be a non-negative, non-NaN number, chosen by
// the user agent.
// TODO
// 14. Let sizeAlgorithm be an algorithm that accepts a chunk object
// and returns a non-negative, non-NaN, non-infinite number, chosen by the user agent.
// TODO
// 15. Let stream be a new ReadableStream.
// 16. Set up stream with pullAlgorithm set to pullAlgorithm,
// cancelAlgorithm set to cancelAlgorithm, highWaterMark set to
// highWaterMark, and sizeAlgorithm set to sizeAlgorithm.
if (!ReadableStream) {
ReadableStream = require('stream/web').ReadableStream
}
const stream = new ReadableStream(
{
async start (controller) {
fetchParams.controller.controller = controller
},
async pull (controller) {
await pullAlgorithm(controller)
},
async cancel (reason) {
await cancelAlgorithm(reason)
}
},
{
highWaterMark: 0,
size () {
return 1
}
}
)
// 17. Run these steps, but abort when the ongoing fetch is terminated:
// 1. Set responses body to a new body whose stream is stream.
response.body = { stream }
// 2. If response is not a network error and requests cache mode is
// not "no-store", then update response in httpCache for request.
// TODO
// 3. If includeCredentials is true and the user agent is not configured
// to block cookies for request (see section 7 of [COOKIES]), then run the
// "set-cookie-string" parsing algorithm (see section 5.2 of [COOKIES]) on
// the value of each header whose name is a byte-case-insensitive match for
// `Set-Cookie` in responses header list, if any, and requests current URL.
// TODO
// 18. If aborted, then:
// TODO
// 19. Run these steps in parallel:
// 1. Run these steps, but abort when fetchParams is canceled:
fetchParams.controller.on('terminated', onAborted)
fetchParams.controller.resume = async () => {
// 1. While true
while (true) {
// 1-3. See onData...
// 4. Set bytes to the result of handling content codings given
// codings and bytes.
let bytes
let isFailure
try {
const { done, value } = await fetchParams.controller.next()
if (isAborted(fetchParams)) {
break
}
bytes = done ? undefined : value
} catch (err) {
if (fetchParams.controller.ended && !timingInfo.encodedBodySize) {
// zlib doesn't like empty streams.
bytes = undefined
} else {
bytes = err
// err may be propagated from the result of calling readablestream.cancel,
// which might not be an error. https://github.com/nodejs/undici/issues/2009
isFailure = true
}
}
if (bytes === undefined) {
// 2. Otherwise, if the bytes transmission for responses message
// body is done normally and stream is readable, then close
// stream, finalize response for fetchParams and response, and
// abort these in-parallel steps.
readableStreamClose(fetchParams.controller.controller)
finalizeResponse(fetchParams, response)
return
}
// 5. Increase timingInfos decoded body size by bytess length.
timingInfo.decodedBodySize += bytes?.byteLength ?? 0
// 6. If bytes is failure, then terminate fetchParamss controller.
if (isFailure) {
fetchParams.controller.terminate(bytes)
return
}
// 7. Enqueue a Uint8Array wrapping an ArrayBuffer containing bytes
// into stream.
fetchParams.controller.controller.enqueue(new Uint8Array(bytes))
// 8. If stream is errored, then terminate the ongoing fetch.
if (isErrored(stream)) {
fetchParams.controller.terminate()
return
}
// 9. If stream doesnt need more data ask the user agent to suspend
// the ongoing fetch.
if (!fetchParams.controller.controller.desiredSize) {
return
}
}
}
// 2. If aborted, then:
function onAborted (reason) {
// 2. If fetchParams is aborted, then:
if (isAborted(fetchParams)) {
// 1. Set responses aborted flag.
response.aborted = true
// 2. If stream is readable, then error stream with the result of
// deserialize a serialized abort reason given fetchParamss
// controllers serialized abort reason and an
// implementation-defined realm.
if (isReadable(stream)) {
fetchParams.controller.controller.error(
fetchParams.controller.serializedAbortReason
)
}
} else {
// 3. Otherwise, if stream is readable, error stream with a TypeError.
if (isReadable(stream)) {
fetchParams.controller.controller.error(new TypeError('terminated', {
cause: isErrorLike(reason) ? reason : undefined
}))
}
}
// 4. If connection uses HTTP/2, then transmit an RST_STREAM frame.
// 5. Otherwise, the user agent should close connection unless it would be bad for performance to do so.
fetchParams.controller.connection.destroy()
}
// 20. Return response.
return response
async function dispatch ({ body }) {
const url = requestCurrentURL(request)
/** @type {import('../..').Agent} */
const agent = fetchParams.controller.dispatcher
return new Promise((resolve, reject) => agent.dispatch(
{
path: url.pathname + url.search,
origin: url.origin,
method: request.method,
body: fetchParams.controller.dispatcher.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
headers: request.headersList.entries,
maxRedirections: 0,
upgrade: request.mode === 'websocket' ? 'websocket' : undefined
},
{
body: null,
abort: null,
onConnect (abort) {
// TODO (fix): Do we need connection here?
const { connection } = fetchParams.controller
if (connection.destroyed) {
abort(new DOMException('The operation was aborted.', 'AbortError'))
} else {
fetchParams.controller.on('terminated', abort)
this.abort = connection.abort = abort
}
},
onHeaders (status, headersList, resume, statusText) {
if (status < 200) {
return
}
let codings = []
let location = ''
const headers = new Headers()
// For H2, the headers are a plain JS object
// We distinguish between them and iterate accordingly
if (Array.isArray(headersList)) {
for (let n = 0; n < headersList.length; n += 2) {
const key = headersList[n + 0].toString('latin1')
const val = headersList[n + 1].toString('latin1')
if (key.toLowerCase() === 'content-encoding') {
// https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1
// "All content-coding values are case-insensitive..."
codings = val.toLowerCase().split(',').map((x) => x.trim())
} else if (key.toLowerCase() === 'location') {
location = val
}
headers[kHeadersList].append(key, val)
}
} else {
const keys = Object.keys(headersList)
for (const key of keys) {
const val = headersList[key]
if (key.toLowerCase() === 'content-encoding') {
// https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1
// "All content-coding values are case-insensitive..."
codings = val.toLowerCase().split(',').map((x) => x.trim()).reverse()
} else if (key.toLowerCase() === 'location') {
location = val
}
headers[kHeadersList].append(key, val)
}
}
this.body = new Readable({ read: resume })
const decoders = []
const willFollow = request.redirect === 'follow' &&
location &&
redirectStatusSet.has(status)
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
if (request.method !== 'HEAD' && request.method !== 'CONNECT' && !nullBodyStatus.includes(status) && !willFollow) {
for (const coding of codings) {
// https://www.rfc-editor.org/rfc/rfc9112.html#section-7.2
if (coding === 'x-gzip' || coding === 'gzip') {
decoders.push(zlib.createGunzip({
// Be less strict when decoding compressed responses, since sometimes
// servers send slightly invalid responses that are still accepted
// by common browsers.
// Always using Z_SYNC_FLUSH is what cURL does.
flush: zlib.constants.Z_SYNC_FLUSH,
finishFlush: zlib.constants.Z_SYNC_FLUSH
}))
} else if (coding === 'deflate') {
decoders.push(zlib.createInflate())
} else if (coding === 'br') {
decoders.push(zlib.createBrotliDecompress())
} else {
decoders.length = 0
break
}
}
}
resolve({
status,
statusText,
headersList: headers[kHeadersList],
body: decoders.length
? pipeline(this.body, ...decoders, () => { })
: this.body.on('error', () => {})
})
return true
},
onData (chunk) {
if (fetchParams.controller.dump) {
return
}
// 1. If one or more bytes have been transmitted from responses
// message body, then:
// 1. Let bytes be the transmitted bytes.
const bytes = chunk
// 2. Let codings be the result of extracting header list values
// given `Content-Encoding` and responses header list.
// See pullAlgorithm.
// 3. Increase timingInfos encoded body size by bytess length.
timingInfo.encodedBodySize += bytes.byteLength
// 4. See pullAlgorithm...
return this.body.push(bytes)
},
onComplete () {
if (this.abort) {
fetchParams.controller.off('terminated', this.abort)
}
fetchParams.controller.ended = true
this.body.push(null)
},
onError (error) {
if (this.abort) {
fetchParams.controller.off('terminated', this.abort)
}
this.body?.destroy(error)
fetchParams.controller.terminate(error)
reject(error)
},
onUpgrade (status, headersList, socket) {
if (status !== 101) {
return
}
const headers = new Headers()
for (let n = 0; n < headersList.length; n += 2) {
const key = headersList[n + 0].toString('latin1')
const val = headersList[n + 1].toString('latin1')
headers[kHeadersList].append(key, val)
}
resolve({
status,
statusText: STATUS_CODES[status],
headersList: headers[kHeadersList],
socket
})
return true
}
}
))
}
}
module.exports = {
fetch,
Fetch,
fetching,
finalizeAndReportTiming
}