id
int64 0
3.78k
| code
stringlengths 13
37.9k
| declarations
stringlengths 16
64.6k
|
|---|---|---|
400 | constructor(error: Error, request: Request) {
super(error.message, error, request);
this.name = 'ReadError';
this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_READING_RESPONSE_STREAM' : this.code;
} | type Error = NodeJS.ErrnoException; |
401 | constructor(error: Error, request: Request) {
super(error.message, error, request);
this.name = 'ReadError';
this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_READING_RESPONSE_STREAM' : this.code;
} | class Request extends Duplex implements RequestEvents<Request> {
// @ts-expect-error - Ignoring for now.
override ['constructor']: typeof Request;
_noPipe?: boolean;
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/9568
options: Options;
response?: PlainResponse;
requestUrl?: URL;
redirectUrls: URL[];
retryCount: number;
declare private _requestOptions: NativeRequestOptions;
private _stopRetry: () => void;
private _downloadedSize: number;
private _uploadedSize: number;
private _stopReading: boolean;
private readonly _pipedServerResponses: Set<ServerResponse>;
private _request?: ClientRequest;
private _responseSize?: number;
private _bodySize?: number;
private _unproxyEvents: () => void;
private _isFromCache?: boolean;
private _cannotHaveBody: boolean;
private _triggerRead: boolean;
declare private _jobs: Array<() => void>;
private _cancelTimeouts: () => void;
private readonly _removeListeners: () => void;
private _nativeResponse?: IncomingMessageWithTimings;
private _flushed: boolean;
private _aborted: boolean;
// We need this because `this._request` if `undefined` when using cache
private _requestInitialized: boolean;
constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType) {
super({
// Don't destroy immediately, as the error may be emitted on unsuccessful retry
autoDestroy: false,
// It needs to be zero because we're just proxying the data to another stream
highWaterMark: 0,
});
this._downloadedSize = 0;
this._uploadedSize = 0;
this._stopReading = false;
this._pipedServerResponses = new Set<ServerResponse>();
this._cannotHaveBody = false;
this._unproxyEvents = noop;
this._triggerRead = false;
this._cancelTimeouts = noop;
this._removeListeners = noop;
this._jobs = [];
this._flushed = false;
this._requestInitialized = false;
this._aborted = false;
this.redirectUrls = [];
this.retryCount = 0;
this._stopRetry = noop;
this.on('pipe', source => {
if (source.headers) {
Object.assign(this.options.headers, source.headers);
}
});
this.on('newListener', event => {
if (event === 'retry' && this.listenerCount('retry') > 0) {
throw new Error('A retry listener has been attached already.');
}
});
try {
this.options = new Options(url, options, defaults);
if (!this.options.url) {
if (this.options.prefixUrl === '') {
throw new TypeError('Missing `url` property');
}
this.options.url = '';
}
this.requestUrl = this.options.url as URL;
} catch (error: any) {
const {options} = error as OptionsError;
if (options) {
this.options = options;
}
this.flush = async () => {
this.flush = async () => {};
this.destroy(error);
};
return;
}
// Important! If you replace `body` in a handler with another stream, make sure it's readable first.
// The below is run only once.
const {body} = this.options;
if (is.nodeStream(body)) {
body.once('error', error => {
if (this._flushed) {
this._beforeError(new UploadError(error, this));
} else {
this.flush = async () => {
this.flush = async () => {};
this._beforeError(new UploadError(error, this));
};
}
});
}
if (this.options.signal) {
const abort = () => {
this.destroy(new AbortError(this));
};
if (this.options.signal.aborted) {
abort();
} else {
this.options.signal.addEventListener('abort', abort);
this._removeListeners = () => {
this.options.signal.removeEventListener('abort', abort);
};
}
}
}
async flush() {
if (this._flushed) {
return;
}
this._flushed = true;
try {
await this._finalizeBody();
if (this.destroyed) {
return;
}
await this._makeRequest();
if (this.destroyed) {
this._request?.destroy();
return;
}
// Queued writes etc.
for (const job of this._jobs) {
job();
}
// Prevent memory leak
this._jobs.length = 0;
this._requestInitialized = true;
} catch (error: any) {
this._beforeError(error);
}
}
_beforeError(error: Error): void {
if (this._stopReading) {
return;
}
const {response, options} = this;
const attemptCount = this.retryCount + (error.name === 'RetryError' ? 0 : 1);
this._stopReading = true;
if (!(error instanceof RequestError)) {
error = new RequestError(error.message, error, this);
}
const typedError = error as RequestError;
void (async () => {
// Node.js parser is really weird.
// It emits post-request Parse Errors on the same instance as previous request. WTF.
// Therefore we need to check if it has been destroyed as well.
//
// Furthermore, Node.js 16 `response.destroy()` doesn't immediately destroy the socket,
// but makes the response unreadable. So we additionally need to check `response.readable`.
if (response?.readable && !response.rawBody && !this._request?.socket?.destroyed) {
// @types/node has incorrect typings. `setEncoding` accepts `null` as well.
response.setEncoding(this.readableEncoding!);
const success = await this._setRawBody(response);
if (success) {
response.body = response.rawBody!.toString();
}
}
if (this.listenerCount('retry') !== 0) {
let backoff: number;
try {
let retryAfter;
if (response && 'retry-after' in response.headers) {
retryAfter = Number(response.headers['retry-after']);
if (Number.isNaN(retryAfter)) {
retryAfter = Date.parse(response.headers['retry-after']!) - Date.now();
if (retryAfter <= 0) {
retryAfter = 1;
}
} else {
retryAfter *= 1000;
}
}
const retryOptions = options.retry as RetryOptions;
backoff = await retryOptions.calculateDelay({
attemptCount,
retryOptions,
error: typedError,
retryAfter,
computedValue: calculateRetryDelay({
attemptCount,
retryOptions,
error: typedError,
retryAfter,
computedValue: retryOptions.maxRetryAfter ?? options.timeout.request ?? Number.POSITIVE_INFINITY,
}),
});
} catch (error_: any) {
void this._error(new RequestError(error_.message, error_, this));
return;
}
if (backoff) {
await new Promise<void>(resolve => {
const timeout = setTimeout(resolve, backoff);
this._stopRetry = () => {
clearTimeout(timeout);
resolve();
};
});
// Something forced us to abort the retry
if (this.destroyed) {
return;
}
try {
for (const hook of this.options.hooks.beforeRetry) {
// eslint-disable-next-line no-await-in-loop
await hook(typedError, this.retryCount + 1);
}
} catch (error_: any) {
void this._error(new RequestError(error_.message, error, this));
return;
}
// Something forced us to abort the retry
if (this.destroyed) {
return;
}
this.destroy();
this.emit('retry', this.retryCount + 1, error, (updatedOptions?: OptionsInit) => {
const request = new Request(options.url, updatedOptions, options);
request.retryCount = this.retryCount + 1;
process.nextTick(() => {
void request.flush();
});
return request;
});
return;
}
}
void this._error(typedError);
})();
}
override _read(): void {
this._triggerRead = true;
const {response} = this;
if (response && !this._stopReading) {
// We cannot put this in the `if` above
// because `.read()` also triggers the `end` event
if (response.readableLength) {
this._triggerRead = false;
}
let data;
while ((data = response.read()) !== null) {
this._downloadedSize += data.length; // eslint-disable-line @typescript-eslint/restrict-plus-operands
const progress = this.downloadProgress;
if (progress.percent < 1) {
this.emit('downloadProgress', progress);
}
this.push(data);
}
}
}
override _write(chunk: unknown, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
const write = (): void => {
this._writeRequest(chunk, encoding, callback);
};
if (this._requestInitialized) {
write();
} else {
this._jobs.push(write);
}
}
override _final(callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
const endRequest = (): void => {
// We need to check if `this._request` is present,
// because it isn't when we use cache.
if (!this._request || this._request.destroyed) {
callback();
return;
}
this._request.end((error?: Error | null) => { // eslint-disable-line @typescript-eslint/ban-types
// The request has been destroyed before `_final` finished.
// See https://github.com/nodejs/node/issues/39356
if ((this._request as any)._writableState?.errored) {
return;
}
if (!error) {
this._bodySize = this._uploadedSize;
this.emit('uploadProgress', this.uploadProgress);
this._request!.emit('upload-complete');
}
callback(error);
});
};
if (this._requestInitialized) {
endRequest();
} else {
this._jobs.push(endRequest);
}
}
override _destroy(error: Error | null, callback: (error: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
this._stopReading = true;
this.flush = async () => {};
// Prevent further retries
this._stopRetry();
this._cancelTimeouts();
this._removeListeners();
if (this.options) {
const {body} = this.options;
if (is.nodeStream(body)) {
body.destroy();
}
}
if (this._request) {
this._request.destroy();
}
if (error !== null && !is.undefined(error) && !(error instanceof RequestError)) {
error = new RequestError(error.message, error, this);
}
callback(error);
}
override pipe<T extends NodeJS.WritableStream>(destination: T, options?: {end?: boolean}): T {
if (destination instanceof ServerResponse) {
this._pipedServerResponses.add(destination);
}
return super.pipe(destination, options);
}
override unpipe<T extends NodeJS.WritableStream>(destination: T): this {
if (destination instanceof ServerResponse) {
this._pipedServerResponses.delete(destination);
}
super.unpipe(destination);
return this;
}
private async _finalizeBody(): Promise<void> {
const {options} = this;
const {headers} = options;
const isForm = !is.undefined(options.form);
// eslint-disable-next-line @typescript-eslint/naming-convention
const isJSON = !is.undefined(options.json);
const isBody = !is.undefined(options.body);
const cannotHaveBody = methodsWithoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
this._cannotHaveBody = cannotHaveBody;
if (isForm || isJSON || isBody) {
if (cannotHaveBody) {
throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
}
// Serialize body
const noContentType = !is.string(headers['content-type']);
if (isBody) {
// Body is spec-compliant FormData
if (isFormDataLike(options.body)) {
const encoder = new FormDataEncoder(options.body);
if (noContentType) {
headers['content-type'] = encoder.headers['Content-Type'];
}
if ('Content-Length' in encoder.headers) {
headers['content-length'] = encoder.headers['Content-Length'];
}
options.body = encoder.encode();
}
// Special case for https://github.com/form-data/form-data
if (isFormData(options.body) && noContentType) {
headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
}
} else if (isForm) {
if (noContentType) {
headers['content-type'] = 'application/x-www-form-urlencoded';
}
const {form} = options;
options.form = undefined;
options.body = (new URLSearchParams(form as Record<string, string>)).toString();
} else {
if (noContentType) {
headers['content-type'] = 'application/json';
}
const {json} = options;
options.json = undefined;
options.body = options.stringifyJson(json);
}
const uploadBodySize = await getBodySize(options.body, options.headers);
// See https://tools.ietf.org/html/rfc7230#section-3.3.2
// A user agent SHOULD send a Content-Length in a request message when
// no Transfer-Encoding is sent and the request method defines a meaning
// for an enclosed payload body. For example, a Content-Length header
// field is normally sent in a POST request even when the value is 0
// (indicating an empty payload body). A user agent SHOULD NOT send a
// Content-Length header field when the request message does not contain
// a payload body and the method semantics do not anticipate such a
// body.
if (is.undefined(headers['content-length']) && is.undefined(headers['transfer-encoding']) && !cannotHaveBody && !is.undefined(uploadBodySize)) {
headers['content-length'] = String(uploadBodySize);
}
}
if (options.responseType === 'json' && !('accept' in options.headers)) {
options.headers.accept = 'application/json';
}
this._bodySize = Number(headers['content-length']) || undefined;
}
private async _onResponseBase(response: IncomingMessageWithTimings): Promise<void> {
// This will be called e.g. when using cache so we need to check if this request has been aborted.
if (this.isAborted) {
return;
}
const {options} = this;
const {url} = options;
this._nativeResponse = response;
if (options.decompress) {
response = decompressResponse(response);
}
const statusCode = response.statusCode!;
const typedResponse = response as PlainResponse;
typedResponse.statusMessage = typedResponse.statusMessage ? typedResponse.statusMessage : http.STATUS_CODES[statusCode];
typedResponse.url = options.url!.toString();
typedResponse.requestUrl = this.requestUrl!;
typedResponse.redirectUrls = this.redirectUrls;
typedResponse.request = this;
typedResponse.isFromCache = (this._nativeResponse as any).fromCache ?? false;
typedResponse.ip = this.ip;
typedResponse.retryCount = this.retryCount;
typedResponse.ok = isResponseOk(typedResponse);
this._isFromCache = typedResponse.isFromCache;
this._responseSize = Number(response.headers['content-length']) || undefined;
this.response = typedResponse;
response.once('end', () => {
this._responseSize = this._downloadedSize;
this.emit('downloadProgress', this.downloadProgress);
});
response.once('error', (error: Error) => {
this._aborted = true;
// Force clean-up, because some packages don't do this.
// TODO: Fix decompress-response
response.destroy();
this._beforeError(new ReadError(error, this));
});
response.once('aborted', () => {
this._aborted = true;
this._beforeError(new ReadError({
name: 'Error',
message: 'The server aborted pending request',
code: 'ECONNRESET',
}, this));
});
this.emit('downloadProgress', this.downloadProgress);
const rawCookies = response.headers['set-cookie'];
if (is.object(options.cookieJar) && rawCookies) {
let promises: Array<Promise<unknown>> = rawCookies.map(async (rawCookie: string) => (options.cookieJar as PromiseCookieJar).setCookie(rawCookie, url!.toString()));
if (options.ignoreInvalidCookies) {
promises = promises.map(async promise => {
try {
await promise;
} catch {}
});
}
try {
await Promise.all(promises);
} catch (error: any) {
this._beforeError(error);
return;
}
}
// The above is running a promise, therefore we need to check if this request has been aborted yet again.
if (this.isAborted) {
return;
}
if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
// We're being redirected, we don't care about the response.
// It'd be best to abort the request, but we can't because
// we would have to sacrifice the TCP connection. We don't want that.
response.resume();
this._cancelTimeouts();
this._unproxyEvents();
if (this.redirectUrls.length >= options.maxRedirects) {
this._beforeError(new MaxRedirectsError(this));
return;
}
this._request = undefined;
const updatedOptions = new Options(undefined, undefined, this.options);
const serverRequestedGet = statusCode === 303 && updatedOptions.method !== 'GET' && updatedOptions.method !== 'HEAD';
const canRewrite = statusCode !== 307 && statusCode !== 308;
const userRequestedGet = updatedOptions.methodRewriting && canRewrite;
if (serverRequestedGet || userRequestedGet) {
updatedOptions.method = 'GET';
updatedOptions.body = undefined;
updatedOptions.json = undefined;
updatedOptions.form = undefined;
delete updatedOptions.headers['content-length'];
}
try {
// We need this in order to support UTF-8
const redirectBuffer = Buffer.from(response.headers.location, 'binary').toString();
const redirectUrl = new URL(redirectBuffer, url);
if (!isUnixSocketURL(url as URL) && isUnixSocketURL(redirectUrl)) {
this._beforeError(new RequestError('Cannot redirect to UNIX socket', {}, this));
return;
}
// Redirecting to a different site, clear sensitive data.
if (redirectUrl.hostname !== (url as URL).hostname || redirectUrl.port !== (url as URL).port) {
if ('host' in updatedOptions.headers) {
delete updatedOptions.headers.host;
}
if ('cookie' in updatedOptions.headers) {
delete updatedOptions.headers.cookie;
}
if ('authorization' in updatedOptions.headers) {
delete updatedOptions.headers.authorization;
}
if (updatedOptions.username || updatedOptions.password) {
updatedOptions.username = '';
updatedOptions.password = '';
}
} else {
redirectUrl.username = updatedOptions.username;
redirectUrl.password = updatedOptions.password;
}
this.redirectUrls.push(redirectUrl);
updatedOptions.prefixUrl = '';
updatedOptions.url = redirectUrl;
for (const hook of updatedOptions.hooks.beforeRedirect) {
// eslint-disable-next-line no-await-in-loop
await hook(updatedOptions, typedResponse);
}
this.emit('redirect', updatedOptions, typedResponse);
this.options = updatedOptions;
await this._makeRequest();
} catch (error: any) {
this._beforeError(error);
return;
}
return;
}
// `HTTPError`s always have `error.response.body` defined.
// Therefore we cannot retry if `options.throwHttpErrors` is false.
// On the last retry, if `options.throwHttpErrors` is false, we would need to return the body,
// but that wouldn't be possible since the body would be already read in `error.response.body`.
if (options.isStream && options.throwHttpErrors && !isResponseOk(typedResponse)) {
this._beforeError(new HTTPError(typedResponse));
return;
}
response.on('readable', () => {
if (this._triggerRead) {
this._read();
}
});
this.on('resume', () => {
response.resume();
});
this.on('pause', () => {
response.pause();
});
response.once('end', () => {
this.push(null);
});
if (this._noPipe) {
const success = await this._setRawBody();
if (success) {
this.emit('response', response);
}
return;
}
this.emit('response', response);
for (const destination of this._pipedServerResponses) {
if (destination.headersSent) {
continue;
}
// eslint-disable-next-line guard-for-in
for (const key in response.headers) {
const isAllowed = options.decompress ? key !== 'content-encoding' : true;
const value = response.headers[key];
if (isAllowed) {
destination.setHeader(key, value!);
}
}
destination.statusCode = statusCode;
}
}
private async _setRawBody(from: Readable = this): Promise<boolean> {
if (from.readableEnded) {
return false;
}
try {
// Errors are emitted via the `error` event
const rawBody = await getBuffer(from);
// On retry Request is destroyed with no error, therefore the above will successfully resolve.
// So in order to check if this was really successfull, we need to check if it has been properly ended.
if (!this.isAborted) {
this.response!.rawBody = rawBody;
return true;
}
} catch {}
return false;
}
private async _onResponse(response: IncomingMessageWithTimings): Promise<void> {
try {
await this._onResponseBase(response);
} catch (error: any) {
/* istanbul ignore next: better safe than sorry */
this._beforeError(error);
}
}
private _onRequest(request: ClientRequest): void {
const {options} = this;
const {timeout, url} = options;
timer(request);
if (this.options.http2) {
// Unset stream timeout, as the `timeout` option was used only for connection timeout.
request.setTimeout(0);
}
this._cancelTimeouts = timedOut(request, timeout, url as URL);
const responseEventName = options.cache ? 'cacheableResponse' : 'response';
request.once(responseEventName, (response: IncomingMessageWithTimings) => {
void this._onResponse(response);
});
request.once('error', (error: Error) => {
this._aborted = true;
// Force clean-up, because some packages (e.g. nock) don't do this.
request.destroy();
error = error instanceof TimedOutTimeoutError ? new TimeoutError(error, this.timings!, this) : new RequestError(error.message, error, this);
this._beforeError(error);
});
this._unproxyEvents = proxyEvents(request, this, proxiedRequestEvents);
this._request = request;
this.emit('uploadProgress', this.uploadProgress);
this._sendBody();
this.emit('request', request);
}
private async _asyncWrite(chunk: any): Promise<void> {
return new Promise((resolve, reject) => {
super.write(chunk, error => {
if (error) {
reject(error);
return;
}
resolve();
});
});
}
private _sendBody() {
// Send body
const {body} = this.options;
const currentRequest = this.redirectUrls.length === 0 ? this : this._request ?? this;
if (is.nodeStream(body)) {
body.pipe(currentRequest);
} else if (is.generator(body) || is.asyncGenerator(body)) {
(async () => {
try {
for await (const chunk of body) {
await this._asyncWrite(chunk);
}
super.end();
} catch (error: any) {
this._beforeError(error);
}
})();
} else if (!is.undefined(body)) {
this._writeRequest(body, undefined, () => {});
currentRequest.end();
} else if (this._cannotHaveBody || this._noPipe) {
currentRequest.end();
}
}
private _prepareCache(cache: string | StorageAdapter) {
if (!cacheableStore.has(cache)) {
const cacheableRequest = new CacheableRequest(
((requestOptions: RequestOptions, handler?: (response: IncomingMessageWithTimings) => void): ClientRequest => {
const result = (requestOptions as any)._request(requestOptions, handler);
// TODO: remove this when `cacheable-request` supports async request functions.
if (is.promise(result)) {
// We only need to implement the error handler in order to support HTTP2 caching.
// The result will be a promise anyway.
// @ts-expect-error ignore
// eslint-disable-next-line @typescript-eslint/promise-function-async
result.once = (event: string, handler: (reason: unknown) => void) => {
if (event === 'error') {
(async () => {
try {
await result;
} catch (error) {
handler(error);
}
})();
} else if (event === 'abort') {
// The empty catch is needed here in case when
// it rejects before it's `await`ed in `_makeRequest`.
(async () => {
try {
const request = (await result) as ClientRequest;
request.once('abort', handler);
} catch {}
})();
} else {
/* istanbul ignore next: safety check */
throw new Error(`Unknown HTTP2 promise event: ${event}`);
}
return result;
};
}
return result;
}) as typeof http.request,
cache as StorageAdapter,
);
cacheableStore.set(cache, cacheableRequest.request());
}
}
private async _createCacheableRequest(url: URL, options: RequestOptions): Promise<ClientRequest | ResponseLike> {
return new Promise<ClientRequest | ResponseLike>((resolve, reject) => {
// TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
Object.assign(options, urlToOptions(url));
let request: ClientRequest | Promise<ClientRequest>;
// TODO: Fix `cacheable-response`. This is ugly.
const cacheRequest = cacheableStore.get((options as any).cache)!(options as CacheableOptions, async (response: any) => {
response._readableState.autoDestroy = false;
if (request) {
const fix = () => {
if (response.req) {
response.complete = response.req.res.complete;
}
};
response.prependOnceListener('end', fix);
fix();
(await request).emit('cacheableResponse', response);
}
resolve(response);
});
cacheRequest.once('error', reject);
cacheRequest.once('request', async (requestOrPromise: ClientRequest | Promise<ClientRequest>) => {
request = requestOrPromise;
resolve(request);
});
});
}
private async _makeRequest(): Promise<void> {
const {options} = this;
const {headers, username, password} = options;
const cookieJar = options.cookieJar as PromiseCookieJar | undefined;
for (const key in headers) {
if (is.undefined(headers[key])) {
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
delete headers[key];
} else if (is.null_(headers[key])) {
throw new TypeError(`Use \`undefined\` instead of \`null\` to delete the \`${key}\` header`);
}
}
if (options.decompress && is.undefined(headers['accept-encoding'])) {
headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate';
}
if (username || password) {
const credentials = Buffer.from(`${username}:${password}`).toString('base64');
headers.authorization = `Basic ${credentials}`;
}
// Set cookies
if (cookieJar) {
const cookieString: string = await cookieJar.getCookieString(options.url!.toString());
if (is.nonEmptyString(cookieString)) {
headers.cookie = cookieString;
}
}
// Reset `prefixUrl`
options.prefixUrl = '';
let request: ReturnType<Options['getRequestFunction']> | undefined;
for (const hook of options.hooks.beforeRequest) {
// eslint-disable-next-line no-await-in-loop
const result = await hook(options);
if (!is.undefined(result)) {
// @ts-expect-error Skip the type mismatch to support abstract responses
request = () => result;
break;
}
}
if (!request) {
request = options.getRequestFunction();
}
const url = options.url as URL;
this._requestOptions = options.createNativeRequestOptions() as NativeRequestOptions;
if (options.cache) {
(this._requestOptions as any)._request = request;
(this._requestOptions as any).cache = options.cache;
(this._requestOptions as any).body = options.body;
this._prepareCache(options.cache as StorageAdapter);
}
// Cache support
const fn = options.cache ? this._createCacheableRequest : request;
try {
// We can't do `await fn(...)`,
// because stream `error` event can be emitted before `Promise.resolve()`.
let requestOrResponse = fn!(url, this._requestOptions);
if (is.promise(requestOrResponse)) {
requestOrResponse = await requestOrResponse;
}
// Fallback
if (is.undefined(requestOrResponse)) {
requestOrResponse = options.getFallbackRequestFunction()!(url, this._requestOptions);
if (is.promise(requestOrResponse)) {
requestOrResponse = await requestOrResponse;
}
}
if (isClientRequest(requestOrResponse!)) {
this._onRequest(requestOrResponse);
} else if (this.writable) {
this.once('finish', () => {
void this._onResponse(requestOrResponse as IncomingMessageWithTimings);
});
this._sendBody();
} else {
void this._onResponse(requestOrResponse as IncomingMessageWithTimings);
}
} catch (error) {
if (error instanceof CacheableCacheError) {
throw new CacheError(error, this);
}
throw error;
}
}
private async _error(error: RequestError): Promise<void> {
try {
if (error instanceof HTTPError && !this.options.throwHttpErrors) {
// This branch can be reached only when using the Promise API
// Skip calling the hooks on purpose.
// See https://github.com/sindresorhus/got/issues/2103
} else {
for (const hook of this.options.hooks.beforeError) {
// eslint-disable-next-line no-await-in-loop
error = await hook(error);
}
}
} catch (error_: any) {
error = new RequestError(error_.message, error_, this);
}
this.destroy(error);
}
private _writeRequest(chunk: any, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
if (!this._request || this._request.destroyed) {
// Probably the `ClientRequest` instance will throw
return;
}
this._request.write(chunk, encoding!, (error?: Error | null) => { // eslint-disable-line @typescript-eslint/ban-types
// The `!destroyed` check is required to prevent `uploadProgress` being emitted after the stream was destroyed
if (!error && !this._request!.destroyed) {
this._uploadedSize += Buffer.byteLength(chunk, encoding);
const progress = this.uploadProgress;
if (progress.percent < 1) {
this.emit('uploadProgress', progress);
}
}
callback(error);
});
}
/**
The remote IP address.
*/
get ip(): string | undefined {
return this.socket?.remoteAddress;
}
/**
Indicates whether the request has been aborted or not.
*/
get isAborted(): boolean {
return this._aborted;
}
get socket(): Socket | undefined {
return this._request?.socket ?? undefined;
}
/**
Progress event for downloading (receiving a response).
*/
get downloadProgress(): Progress {
let percent;
if (this._responseSize) {
percent = this._downloadedSize / this._responseSize;
} else if (this._responseSize === this._downloadedSize) {
percent = 1;
} else {
percent = 0;
}
return {
percent,
transferred: this._downloadedSize,
total: this._responseSize,
};
}
/**
Progress event for uploading (sending a request).
*/
get uploadProgress(): Progress {
let percent;
if (this._bodySize) {
percent = this._uploadedSize / this._bodySize;
} else if (this._bodySize === this._uploadedSize) {
percent = 1;
} else {
percent = 0;
}
return {
percent,
transferred: this._uploadedSize,
total: this._bodySize,
};
}
/**
The object contains the following properties:
- `start` - Time when the request started.
- `socket` - Time when a socket was assigned to the request.
- `lookup` - Time when the DNS lookup finished.
- `connect` - Time when the socket successfully connected.
- `secureConnect` - Time when the socket securely connected.
- `upload` - Time when the request finished uploading.
- `response` - Time when the request fired `response` event.
- `end` - Time when the response fired `end` event.
- `error` - Time when the request fired `error` event.
- `abort` - Time when the request fired `abort` event.
- `phases`
- `wait` - `timings.socket - timings.start`
- `dns` - `timings.lookup - timings.socket`
- `tcp` - `timings.connect - timings.lookup`
- `tls` - `timings.secureConnect - timings.connect`
- `request` - `timings.upload - (timings.secureConnect || timings.connect)`
- `firstByte` - `timings.response - timings.upload`
- `download` - `timings.end - timings.response`
- `total` - `(timings.end || timings.error || timings.abort) - timings.start`
If something has not been measured yet, it will be `undefined`.
__Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
*/
get timings(): Timings | undefined {
return (this._request as ClientRequestWithTimings)?.timings;
}
/**
Whether the response was retrieved from the cache.
*/
get isFromCache(): boolean | undefined {
return this._isFromCache;
}
get reusedSocket(): boolean | undefined {
return this._request?.reusedSocket;
}
} |
402 | constructor(request: Request) {
super('Retrying', {}, request);
this.name = 'RetryError';
this.code = 'ERR_RETRYING';
} | class Request extends Duplex implements RequestEvents<Request> {
// @ts-expect-error - Ignoring for now.
override ['constructor']: typeof Request;
_noPipe?: boolean;
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/9568
options: Options;
response?: PlainResponse;
requestUrl?: URL;
redirectUrls: URL[];
retryCount: number;
declare private _requestOptions: NativeRequestOptions;
private _stopRetry: () => void;
private _downloadedSize: number;
private _uploadedSize: number;
private _stopReading: boolean;
private readonly _pipedServerResponses: Set<ServerResponse>;
private _request?: ClientRequest;
private _responseSize?: number;
private _bodySize?: number;
private _unproxyEvents: () => void;
private _isFromCache?: boolean;
private _cannotHaveBody: boolean;
private _triggerRead: boolean;
declare private _jobs: Array<() => void>;
private _cancelTimeouts: () => void;
private readonly _removeListeners: () => void;
private _nativeResponse?: IncomingMessageWithTimings;
private _flushed: boolean;
private _aborted: boolean;
// We need this because `this._request` if `undefined` when using cache
private _requestInitialized: boolean;
constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType) {
super({
// Don't destroy immediately, as the error may be emitted on unsuccessful retry
autoDestroy: false,
// It needs to be zero because we're just proxying the data to another stream
highWaterMark: 0,
});
this._downloadedSize = 0;
this._uploadedSize = 0;
this._stopReading = false;
this._pipedServerResponses = new Set<ServerResponse>();
this._cannotHaveBody = false;
this._unproxyEvents = noop;
this._triggerRead = false;
this._cancelTimeouts = noop;
this._removeListeners = noop;
this._jobs = [];
this._flushed = false;
this._requestInitialized = false;
this._aborted = false;
this.redirectUrls = [];
this.retryCount = 0;
this._stopRetry = noop;
this.on('pipe', source => {
if (source.headers) {
Object.assign(this.options.headers, source.headers);
}
});
this.on('newListener', event => {
if (event === 'retry' && this.listenerCount('retry') > 0) {
throw new Error('A retry listener has been attached already.');
}
});
try {
this.options = new Options(url, options, defaults);
if (!this.options.url) {
if (this.options.prefixUrl === '') {
throw new TypeError('Missing `url` property');
}
this.options.url = '';
}
this.requestUrl = this.options.url as URL;
} catch (error: any) {
const {options} = error as OptionsError;
if (options) {
this.options = options;
}
this.flush = async () => {
this.flush = async () => {};
this.destroy(error);
};
return;
}
// Important! If you replace `body` in a handler with another stream, make sure it's readable first.
// The below is run only once.
const {body} = this.options;
if (is.nodeStream(body)) {
body.once('error', error => {
if (this._flushed) {
this._beforeError(new UploadError(error, this));
} else {
this.flush = async () => {
this.flush = async () => {};
this._beforeError(new UploadError(error, this));
};
}
});
}
if (this.options.signal) {
const abort = () => {
this.destroy(new AbortError(this));
};
if (this.options.signal.aborted) {
abort();
} else {
this.options.signal.addEventListener('abort', abort);
this._removeListeners = () => {
this.options.signal.removeEventListener('abort', abort);
};
}
}
}
async flush() {
if (this._flushed) {
return;
}
this._flushed = true;
try {
await this._finalizeBody();
if (this.destroyed) {
return;
}
await this._makeRequest();
if (this.destroyed) {
this._request?.destroy();
return;
}
// Queued writes etc.
for (const job of this._jobs) {
job();
}
// Prevent memory leak
this._jobs.length = 0;
this._requestInitialized = true;
} catch (error: any) {
this._beforeError(error);
}
}
_beforeError(error: Error): void {
if (this._stopReading) {
return;
}
const {response, options} = this;
const attemptCount = this.retryCount + (error.name === 'RetryError' ? 0 : 1);
this._stopReading = true;
if (!(error instanceof RequestError)) {
error = new RequestError(error.message, error, this);
}
const typedError = error as RequestError;
void (async () => {
// Node.js parser is really weird.
// It emits post-request Parse Errors on the same instance as previous request. WTF.
// Therefore we need to check if it has been destroyed as well.
//
// Furthermore, Node.js 16 `response.destroy()` doesn't immediately destroy the socket,
// but makes the response unreadable. So we additionally need to check `response.readable`.
if (response?.readable && !response.rawBody && !this._request?.socket?.destroyed) {
// @types/node has incorrect typings. `setEncoding` accepts `null` as well.
response.setEncoding(this.readableEncoding!);
const success = await this._setRawBody(response);
if (success) {
response.body = response.rawBody!.toString();
}
}
if (this.listenerCount('retry') !== 0) {
let backoff: number;
try {
let retryAfter;
if (response && 'retry-after' in response.headers) {
retryAfter = Number(response.headers['retry-after']);
if (Number.isNaN(retryAfter)) {
retryAfter = Date.parse(response.headers['retry-after']!) - Date.now();
if (retryAfter <= 0) {
retryAfter = 1;
}
} else {
retryAfter *= 1000;
}
}
const retryOptions = options.retry as RetryOptions;
backoff = await retryOptions.calculateDelay({
attemptCount,
retryOptions,
error: typedError,
retryAfter,
computedValue: calculateRetryDelay({
attemptCount,
retryOptions,
error: typedError,
retryAfter,
computedValue: retryOptions.maxRetryAfter ?? options.timeout.request ?? Number.POSITIVE_INFINITY,
}),
});
} catch (error_: any) {
void this._error(new RequestError(error_.message, error_, this));
return;
}
if (backoff) {
await new Promise<void>(resolve => {
const timeout = setTimeout(resolve, backoff);
this._stopRetry = () => {
clearTimeout(timeout);
resolve();
};
});
// Something forced us to abort the retry
if (this.destroyed) {
return;
}
try {
for (const hook of this.options.hooks.beforeRetry) {
// eslint-disable-next-line no-await-in-loop
await hook(typedError, this.retryCount + 1);
}
} catch (error_: any) {
void this._error(new RequestError(error_.message, error, this));
return;
}
// Something forced us to abort the retry
if (this.destroyed) {
return;
}
this.destroy();
this.emit('retry', this.retryCount + 1, error, (updatedOptions?: OptionsInit) => {
const request = new Request(options.url, updatedOptions, options);
request.retryCount = this.retryCount + 1;
process.nextTick(() => {
void request.flush();
});
return request;
});
return;
}
}
void this._error(typedError);
})();
}
override _read(): void {
this._triggerRead = true;
const {response} = this;
if (response && !this._stopReading) {
// We cannot put this in the `if` above
// because `.read()` also triggers the `end` event
if (response.readableLength) {
this._triggerRead = false;
}
let data;
while ((data = response.read()) !== null) {
this._downloadedSize += data.length; // eslint-disable-line @typescript-eslint/restrict-plus-operands
const progress = this.downloadProgress;
if (progress.percent < 1) {
this.emit('downloadProgress', progress);
}
this.push(data);
}
}
}
override _write(chunk: unknown, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
const write = (): void => {
this._writeRequest(chunk, encoding, callback);
};
if (this._requestInitialized) {
write();
} else {
this._jobs.push(write);
}
}
override _final(callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
const endRequest = (): void => {
// We need to check if `this._request` is present,
// because it isn't when we use cache.
if (!this._request || this._request.destroyed) {
callback();
return;
}
this._request.end((error?: Error | null) => { // eslint-disable-line @typescript-eslint/ban-types
// The request has been destroyed before `_final` finished.
// See https://github.com/nodejs/node/issues/39356
if ((this._request as any)._writableState?.errored) {
return;
}
if (!error) {
this._bodySize = this._uploadedSize;
this.emit('uploadProgress', this.uploadProgress);
this._request!.emit('upload-complete');
}
callback(error);
});
};
if (this._requestInitialized) {
endRequest();
} else {
this._jobs.push(endRequest);
}
}
override _destroy(error: Error | null, callback: (error: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
this._stopReading = true;
this.flush = async () => {};
// Prevent further retries
this._stopRetry();
this._cancelTimeouts();
this._removeListeners();
if (this.options) {
const {body} = this.options;
if (is.nodeStream(body)) {
body.destroy();
}
}
if (this._request) {
this._request.destroy();
}
if (error !== null && !is.undefined(error) && !(error instanceof RequestError)) {
error = new RequestError(error.message, error, this);
}
callback(error);
}
override pipe<T extends NodeJS.WritableStream>(destination: T, options?: {end?: boolean}): T {
if (destination instanceof ServerResponse) {
this._pipedServerResponses.add(destination);
}
return super.pipe(destination, options);
}
override unpipe<T extends NodeJS.WritableStream>(destination: T): this {
if (destination instanceof ServerResponse) {
this._pipedServerResponses.delete(destination);
}
super.unpipe(destination);
return this;
}
private async _finalizeBody(): Promise<void> {
const {options} = this;
const {headers} = options;
const isForm = !is.undefined(options.form);
// eslint-disable-next-line @typescript-eslint/naming-convention
const isJSON = !is.undefined(options.json);
const isBody = !is.undefined(options.body);
const cannotHaveBody = methodsWithoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
this._cannotHaveBody = cannotHaveBody;
if (isForm || isJSON || isBody) {
if (cannotHaveBody) {
throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
}
// Serialize body
const noContentType = !is.string(headers['content-type']);
if (isBody) {
// Body is spec-compliant FormData
if (isFormDataLike(options.body)) {
const encoder = new FormDataEncoder(options.body);
if (noContentType) {
headers['content-type'] = encoder.headers['Content-Type'];
}
if ('Content-Length' in encoder.headers) {
headers['content-length'] = encoder.headers['Content-Length'];
}
options.body = encoder.encode();
}
// Special case for https://github.com/form-data/form-data
if (isFormData(options.body) && noContentType) {
headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
}
} else if (isForm) {
if (noContentType) {
headers['content-type'] = 'application/x-www-form-urlencoded';
}
const {form} = options;
options.form = undefined;
options.body = (new URLSearchParams(form as Record<string, string>)).toString();
} else {
if (noContentType) {
headers['content-type'] = 'application/json';
}
const {json} = options;
options.json = undefined;
options.body = options.stringifyJson(json);
}
const uploadBodySize = await getBodySize(options.body, options.headers);
// See https://tools.ietf.org/html/rfc7230#section-3.3.2
// A user agent SHOULD send a Content-Length in a request message when
// no Transfer-Encoding is sent and the request method defines a meaning
// for an enclosed payload body. For example, a Content-Length header
// field is normally sent in a POST request even when the value is 0
// (indicating an empty payload body). A user agent SHOULD NOT send a
// Content-Length header field when the request message does not contain
// a payload body and the method semantics do not anticipate such a
// body.
if (is.undefined(headers['content-length']) && is.undefined(headers['transfer-encoding']) && !cannotHaveBody && !is.undefined(uploadBodySize)) {
headers['content-length'] = String(uploadBodySize);
}
}
if (options.responseType === 'json' && !('accept' in options.headers)) {
options.headers.accept = 'application/json';
}
this._bodySize = Number(headers['content-length']) || undefined;
}
private async _onResponseBase(response: IncomingMessageWithTimings): Promise<void> {
// This will be called e.g. when using cache so we need to check if this request has been aborted.
if (this.isAborted) {
return;
}
const {options} = this;
const {url} = options;
this._nativeResponse = response;
if (options.decompress) {
response = decompressResponse(response);
}
const statusCode = response.statusCode!;
const typedResponse = response as PlainResponse;
typedResponse.statusMessage = typedResponse.statusMessage ? typedResponse.statusMessage : http.STATUS_CODES[statusCode];
typedResponse.url = options.url!.toString();
typedResponse.requestUrl = this.requestUrl!;
typedResponse.redirectUrls = this.redirectUrls;
typedResponse.request = this;
typedResponse.isFromCache = (this._nativeResponse as any).fromCache ?? false;
typedResponse.ip = this.ip;
typedResponse.retryCount = this.retryCount;
typedResponse.ok = isResponseOk(typedResponse);
this._isFromCache = typedResponse.isFromCache;
this._responseSize = Number(response.headers['content-length']) || undefined;
this.response = typedResponse;
response.once('end', () => {
this._responseSize = this._downloadedSize;
this.emit('downloadProgress', this.downloadProgress);
});
response.once('error', (error: Error) => {
this._aborted = true;
// Force clean-up, because some packages don't do this.
// TODO: Fix decompress-response
response.destroy();
this._beforeError(new ReadError(error, this));
});
response.once('aborted', () => {
this._aborted = true;
this._beforeError(new ReadError({
name: 'Error',
message: 'The server aborted pending request',
code: 'ECONNRESET',
}, this));
});
this.emit('downloadProgress', this.downloadProgress);
const rawCookies = response.headers['set-cookie'];
if (is.object(options.cookieJar) && rawCookies) {
let promises: Array<Promise<unknown>> = rawCookies.map(async (rawCookie: string) => (options.cookieJar as PromiseCookieJar).setCookie(rawCookie, url!.toString()));
if (options.ignoreInvalidCookies) {
promises = promises.map(async promise => {
try {
await promise;
} catch {}
});
}
try {
await Promise.all(promises);
} catch (error: any) {
this._beforeError(error);
return;
}
}
// The above is running a promise, therefore we need to check if this request has been aborted yet again.
if (this.isAborted) {
return;
}
if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
// We're being redirected, we don't care about the response.
// It'd be best to abort the request, but we can't because
// we would have to sacrifice the TCP connection. We don't want that.
response.resume();
this._cancelTimeouts();
this._unproxyEvents();
if (this.redirectUrls.length >= options.maxRedirects) {
this._beforeError(new MaxRedirectsError(this));
return;
}
this._request = undefined;
const updatedOptions = new Options(undefined, undefined, this.options);
const serverRequestedGet = statusCode === 303 && updatedOptions.method !== 'GET' && updatedOptions.method !== 'HEAD';
const canRewrite = statusCode !== 307 && statusCode !== 308;
const userRequestedGet = updatedOptions.methodRewriting && canRewrite;
if (serverRequestedGet || userRequestedGet) {
updatedOptions.method = 'GET';
updatedOptions.body = undefined;
updatedOptions.json = undefined;
updatedOptions.form = undefined;
delete updatedOptions.headers['content-length'];
}
try {
// We need this in order to support UTF-8
const redirectBuffer = Buffer.from(response.headers.location, 'binary').toString();
const redirectUrl = new URL(redirectBuffer, url);
if (!isUnixSocketURL(url as URL) && isUnixSocketURL(redirectUrl)) {
this._beforeError(new RequestError('Cannot redirect to UNIX socket', {}, this));
return;
}
// Redirecting to a different site, clear sensitive data.
if (redirectUrl.hostname !== (url as URL).hostname || redirectUrl.port !== (url as URL).port) {
if ('host' in updatedOptions.headers) {
delete updatedOptions.headers.host;
}
if ('cookie' in updatedOptions.headers) {
delete updatedOptions.headers.cookie;
}
if ('authorization' in updatedOptions.headers) {
delete updatedOptions.headers.authorization;
}
if (updatedOptions.username || updatedOptions.password) {
updatedOptions.username = '';
updatedOptions.password = '';
}
} else {
redirectUrl.username = updatedOptions.username;
redirectUrl.password = updatedOptions.password;
}
this.redirectUrls.push(redirectUrl);
updatedOptions.prefixUrl = '';
updatedOptions.url = redirectUrl;
for (const hook of updatedOptions.hooks.beforeRedirect) {
// eslint-disable-next-line no-await-in-loop
await hook(updatedOptions, typedResponse);
}
this.emit('redirect', updatedOptions, typedResponse);
this.options = updatedOptions;
await this._makeRequest();
} catch (error: any) {
this._beforeError(error);
return;
}
return;
}
// `HTTPError`s always have `error.response.body` defined.
// Therefore we cannot retry if `options.throwHttpErrors` is false.
// On the last retry, if `options.throwHttpErrors` is false, we would need to return the body,
// but that wouldn't be possible since the body would be already read in `error.response.body`.
if (options.isStream && options.throwHttpErrors && !isResponseOk(typedResponse)) {
this._beforeError(new HTTPError(typedResponse));
return;
}
response.on('readable', () => {
if (this._triggerRead) {
this._read();
}
});
this.on('resume', () => {
response.resume();
});
this.on('pause', () => {
response.pause();
});
response.once('end', () => {
this.push(null);
});
if (this._noPipe) {
const success = await this._setRawBody();
if (success) {
this.emit('response', response);
}
return;
}
this.emit('response', response);
for (const destination of this._pipedServerResponses) {
if (destination.headersSent) {
continue;
}
// eslint-disable-next-line guard-for-in
for (const key in response.headers) {
const isAllowed = options.decompress ? key !== 'content-encoding' : true;
const value = response.headers[key];
if (isAllowed) {
destination.setHeader(key, value!);
}
}
destination.statusCode = statusCode;
}
}
private async _setRawBody(from: Readable = this): Promise<boolean> {
if (from.readableEnded) {
return false;
}
try {
// Errors are emitted via the `error` event
const rawBody = await getBuffer(from);
// On retry Request is destroyed with no error, therefore the above will successfully resolve.
// So in order to check if this was really successfull, we need to check if it has been properly ended.
if (!this.isAborted) {
this.response!.rawBody = rawBody;
return true;
}
} catch {}
return false;
}
private async _onResponse(response: IncomingMessageWithTimings): Promise<void> {
try {
await this._onResponseBase(response);
} catch (error: any) {
/* istanbul ignore next: better safe than sorry */
this._beforeError(error);
}
}
private _onRequest(request: ClientRequest): void {
const {options} = this;
const {timeout, url} = options;
timer(request);
if (this.options.http2) {
// Unset stream timeout, as the `timeout` option was used only for connection timeout.
request.setTimeout(0);
}
this._cancelTimeouts = timedOut(request, timeout, url as URL);
const responseEventName = options.cache ? 'cacheableResponse' : 'response';
request.once(responseEventName, (response: IncomingMessageWithTimings) => {
void this._onResponse(response);
});
request.once('error', (error: Error) => {
this._aborted = true;
// Force clean-up, because some packages (e.g. nock) don't do this.
request.destroy();
error = error instanceof TimedOutTimeoutError ? new TimeoutError(error, this.timings!, this) : new RequestError(error.message, error, this);
this._beforeError(error);
});
this._unproxyEvents = proxyEvents(request, this, proxiedRequestEvents);
this._request = request;
this.emit('uploadProgress', this.uploadProgress);
this._sendBody();
this.emit('request', request);
}
private async _asyncWrite(chunk: any): Promise<void> {
return new Promise((resolve, reject) => {
super.write(chunk, error => {
if (error) {
reject(error);
return;
}
resolve();
});
});
}
private _sendBody() {
// Send body
const {body} = this.options;
const currentRequest = this.redirectUrls.length === 0 ? this : this._request ?? this;
if (is.nodeStream(body)) {
body.pipe(currentRequest);
} else if (is.generator(body) || is.asyncGenerator(body)) {
(async () => {
try {
for await (const chunk of body) {
await this._asyncWrite(chunk);
}
super.end();
} catch (error: any) {
this._beforeError(error);
}
})();
} else if (!is.undefined(body)) {
this._writeRequest(body, undefined, () => {});
currentRequest.end();
} else if (this._cannotHaveBody || this._noPipe) {
currentRequest.end();
}
}
private _prepareCache(cache: string | StorageAdapter) {
if (!cacheableStore.has(cache)) {
const cacheableRequest = new CacheableRequest(
((requestOptions: RequestOptions, handler?: (response: IncomingMessageWithTimings) => void): ClientRequest => {
const result = (requestOptions as any)._request(requestOptions, handler);
// TODO: remove this when `cacheable-request` supports async request functions.
if (is.promise(result)) {
// We only need to implement the error handler in order to support HTTP2 caching.
// The result will be a promise anyway.
// @ts-expect-error ignore
// eslint-disable-next-line @typescript-eslint/promise-function-async
result.once = (event: string, handler: (reason: unknown) => void) => {
if (event === 'error') {
(async () => {
try {
await result;
} catch (error) {
handler(error);
}
})();
} else if (event === 'abort') {
// The empty catch is needed here in case when
// it rejects before it's `await`ed in `_makeRequest`.
(async () => {
try {
const request = (await result) as ClientRequest;
request.once('abort', handler);
} catch {}
})();
} else {
/* istanbul ignore next: safety check */
throw new Error(`Unknown HTTP2 promise event: ${event}`);
}
return result;
};
}
return result;
}) as typeof http.request,
cache as StorageAdapter,
);
cacheableStore.set(cache, cacheableRequest.request());
}
}
private async _createCacheableRequest(url: URL, options: RequestOptions): Promise<ClientRequest | ResponseLike> {
return new Promise<ClientRequest | ResponseLike>((resolve, reject) => {
// TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
Object.assign(options, urlToOptions(url));
let request: ClientRequest | Promise<ClientRequest>;
// TODO: Fix `cacheable-response`. This is ugly.
const cacheRequest = cacheableStore.get((options as any).cache)!(options as CacheableOptions, async (response: any) => {
response._readableState.autoDestroy = false;
if (request) {
const fix = () => {
if (response.req) {
response.complete = response.req.res.complete;
}
};
response.prependOnceListener('end', fix);
fix();
(await request).emit('cacheableResponse', response);
}
resolve(response);
});
cacheRequest.once('error', reject);
cacheRequest.once('request', async (requestOrPromise: ClientRequest | Promise<ClientRequest>) => {
request = requestOrPromise;
resolve(request);
});
});
}
private async _makeRequest(): Promise<void> {
const {options} = this;
const {headers, username, password} = options;
const cookieJar = options.cookieJar as PromiseCookieJar | undefined;
for (const key in headers) {
if (is.undefined(headers[key])) {
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
delete headers[key];
} else if (is.null_(headers[key])) {
throw new TypeError(`Use \`undefined\` instead of \`null\` to delete the \`${key}\` header`);
}
}
if (options.decompress && is.undefined(headers['accept-encoding'])) {
headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate';
}
if (username || password) {
const credentials = Buffer.from(`${username}:${password}`).toString('base64');
headers.authorization = `Basic ${credentials}`;
}
// Set cookies
if (cookieJar) {
const cookieString: string = await cookieJar.getCookieString(options.url!.toString());
if (is.nonEmptyString(cookieString)) {
headers.cookie = cookieString;
}
}
// Reset `prefixUrl`
options.prefixUrl = '';
let request: ReturnType<Options['getRequestFunction']> | undefined;
for (const hook of options.hooks.beforeRequest) {
// eslint-disable-next-line no-await-in-loop
const result = await hook(options);
if (!is.undefined(result)) {
// @ts-expect-error Skip the type mismatch to support abstract responses
request = () => result;
break;
}
}
if (!request) {
request = options.getRequestFunction();
}
const url = options.url as URL;
this._requestOptions = options.createNativeRequestOptions() as NativeRequestOptions;
if (options.cache) {
(this._requestOptions as any)._request = request;
(this._requestOptions as any).cache = options.cache;
(this._requestOptions as any).body = options.body;
this._prepareCache(options.cache as StorageAdapter);
}
// Cache support
const fn = options.cache ? this._createCacheableRequest : request;
try {
// We can't do `await fn(...)`,
// because stream `error` event can be emitted before `Promise.resolve()`.
let requestOrResponse = fn!(url, this._requestOptions);
if (is.promise(requestOrResponse)) {
requestOrResponse = await requestOrResponse;
}
// Fallback
if (is.undefined(requestOrResponse)) {
requestOrResponse = options.getFallbackRequestFunction()!(url, this._requestOptions);
if (is.promise(requestOrResponse)) {
requestOrResponse = await requestOrResponse;
}
}
if (isClientRequest(requestOrResponse!)) {
this._onRequest(requestOrResponse);
} else if (this.writable) {
this.once('finish', () => {
void this._onResponse(requestOrResponse as IncomingMessageWithTimings);
});
this._sendBody();
} else {
void this._onResponse(requestOrResponse as IncomingMessageWithTimings);
}
} catch (error) {
if (error instanceof CacheableCacheError) {
throw new CacheError(error, this);
}
throw error;
}
}
private async _error(error: RequestError): Promise<void> {
try {
if (error instanceof HTTPError && !this.options.throwHttpErrors) {
// This branch can be reached only when using the Promise API
// Skip calling the hooks on purpose.
// See https://github.com/sindresorhus/got/issues/2103
} else {
for (const hook of this.options.hooks.beforeError) {
// eslint-disable-next-line no-await-in-loop
error = await hook(error);
}
}
} catch (error_: any) {
error = new RequestError(error_.message, error_, this);
}
this.destroy(error);
}
private _writeRequest(chunk: any, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
if (!this._request || this._request.destroyed) {
// Probably the `ClientRequest` instance will throw
return;
}
this._request.write(chunk, encoding!, (error?: Error | null) => { // eslint-disable-line @typescript-eslint/ban-types
// The `!destroyed` check is required to prevent `uploadProgress` being emitted after the stream was destroyed
if (!error && !this._request!.destroyed) {
this._uploadedSize += Buffer.byteLength(chunk, encoding);
const progress = this.uploadProgress;
if (progress.percent < 1) {
this.emit('uploadProgress', progress);
}
}
callback(error);
});
}
/**
The remote IP address.
*/
get ip(): string | undefined {
return this.socket?.remoteAddress;
}
/**
Indicates whether the request has been aborted or not.
*/
get isAborted(): boolean {
return this._aborted;
}
get socket(): Socket | undefined {
return this._request?.socket ?? undefined;
}
/**
Progress event for downloading (receiving a response).
*/
get downloadProgress(): Progress {
let percent;
if (this._responseSize) {
percent = this._downloadedSize / this._responseSize;
} else if (this._responseSize === this._downloadedSize) {
percent = 1;
} else {
percent = 0;
}
return {
percent,
transferred: this._downloadedSize,
total: this._responseSize,
};
}
/**
Progress event for uploading (sending a request).
*/
get uploadProgress(): Progress {
let percent;
if (this._bodySize) {
percent = this._uploadedSize / this._bodySize;
} else if (this._bodySize === this._uploadedSize) {
percent = 1;
} else {
percent = 0;
}
return {
percent,
transferred: this._uploadedSize,
total: this._bodySize,
};
}
/**
The object contains the following properties:
- `start` - Time when the request started.
- `socket` - Time when a socket was assigned to the request.
- `lookup` - Time when the DNS lookup finished.
- `connect` - Time when the socket successfully connected.
- `secureConnect` - Time when the socket securely connected.
- `upload` - Time when the request finished uploading.
- `response` - Time when the request fired `response` event.
- `end` - Time when the response fired `end` event.
- `error` - Time when the request fired `error` event.
- `abort` - Time when the request fired `abort` event.
- `phases`
- `wait` - `timings.socket - timings.start`
- `dns` - `timings.lookup - timings.socket`
- `tcp` - `timings.connect - timings.lookup`
- `tls` - `timings.secureConnect - timings.connect`
- `request` - `timings.upload - (timings.secureConnect || timings.connect)`
- `firstByte` - `timings.response - timings.upload`
- `download` - `timings.end - timings.response`
- `total` - `(timings.end || timings.error || timings.abort) - timings.start`
If something has not been measured yet, it will be `undefined`.
__Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
*/
get timings(): Timings | undefined {
return (this._request as ClientRequestWithTimings)?.timings;
}
/**
Whether the response was retrieved from the cache.
*/
get isFromCache(): boolean | undefined {
return this._isFromCache;
}
get reusedSocket(): boolean | undefined {
return this._request?.reusedSocket;
}
} |
403 | constructor(request: Request) {
super('This operation was aborted.', {}, request);
this.code = 'ERR_ABORTED';
this.name = 'AbortError';
} | class Request extends Duplex implements RequestEvents<Request> {
// @ts-expect-error - Ignoring for now.
override ['constructor']: typeof Request;
_noPipe?: boolean;
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/9568
options: Options;
response?: PlainResponse;
requestUrl?: URL;
redirectUrls: URL[];
retryCount: number;
declare private _requestOptions: NativeRequestOptions;
private _stopRetry: () => void;
private _downloadedSize: number;
private _uploadedSize: number;
private _stopReading: boolean;
private readonly _pipedServerResponses: Set<ServerResponse>;
private _request?: ClientRequest;
private _responseSize?: number;
private _bodySize?: number;
private _unproxyEvents: () => void;
private _isFromCache?: boolean;
private _cannotHaveBody: boolean;
private _triggerRead: boolean;
declare private _jobs: Array<() => void>;
private _cancelTimeouts: () => void;
private readonly _removeListeners: () => void;
private _nativeResponse?: IncomingMessageWithTimings;
private _flushed: boolean;
private _aborted: boolean;
// We need this because `this._request` if `undefined` when using cache
private _requestInitialized: boolean;
constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType) {
super({
// Don't destroy immediately, as the error may be emitted on unsuccessful retry
autoDestroy: false,
// It needs to be zero because we're just proxying the data to another stream
highWaterMark: 0,
});
this._downloadedSize = 0;
this._uploadedSize = 0;
this._stopReading = false;
this._pipedServerResponses = new Set<ServerResponse>();
this._cannotHaveBody = false;
this._unproxyEvents = noop;
this._triggerRead = false;
this._cancelTimeouts = noop;
this._removeListeners = noop;
this._jobs = [];
this._flushed = false;
this._requestInitialized = false;
this._aborted = false;
this.redirectUrls = [];
this.retryCount = 0;
this._stopRetry = noop;
this.on('pipe', source => {
if (source.headers) {
Object.assign(this.options.headers, source.headers);
}
});
this.on('newListener', event => {
if (event === 'retry' && this.listenerCount('retry') > 0) {
throw new Error('A retry listener has been attached already.');
}
});
try {
this.options = new Options(url, options, defaults);
if (!this.options.url) {
if (this.options.prefixUrl === '') {
throw new TypeError('Missing `url` property');
}
this.options.url = '';
}
this.requestUrl = this.options.url as URL;
} catch (error: any) {
const {options} = error as OptionsError;
if (options) {
this.options = options;
}
this.flush = async () => {
this.flush = async () => {};
this.destroy(error);
};
return;
}
// Important! If you replace `body` in a handler with another stream, make sure it's readable first.
// The below is run only once.
const {body} = this.options;
if (is.nodeStream(body)) {
body.once('error', error => {
if (this._flushed) {
this._beforeError(new UploadError(error, this));
} else {
this.flush = async () => {
this.flush = async () => {};
this._beforeError(new UploadError(error, this));
};
}
});
}
if (this.options.signal) {
const abort = () => {
this.destroy(new AbortError(this));
};
if (this.options.signal.aborted) {
abort();
} else {
this.options.signal.addEventListener('abort', abort);
this._removeListeners = () => {
this.options.signal.removeEventListener('abort', abort);
};
}
}
}
async flush() {
if (this._flushed) {
return;
}
this._flushed = true;
try {
await this._finalizeBody();
if (this.destroyed) {
return;
}
await this._makeRequest();
if (this.destroyed) {
this._request?.destroy();
return;
}
// Queued writes etc.
for (const job of this._jobs) {
job();
}
// Prevent memory leak
this._jobs.length = 0;
this._requestInitialized = true;
} catch (error: any) {
this._beforeError(error);
}
}
_beforeError(error: Error): void {
if (this._stopReading) {
return;
}
const {response, options} = this;
const attemptCount = this.retryCount + (error.name === 'RetryError' ? 0 : 1);
this._stopReading = true;
if (!(error instanceof RequestError)) {
error = new RequestError(error.message, error, this);
}
const typedError = error as RequestError;
void (async () => {
// Node.js parser is really weird.
// It emits post-request Parse Errors on the same instance as previous request. WTF.
// Therefore we need to check if it has been destroyed as well.
//
// Furthermore, Node.js 16 `response.destroy()` doesn't immediately destroy the socket,
// but makes the response unreadable. So we additionally need to check `response.readable`.
if (response?.readable && !response.rawBody && !this._request?.socket?.destroyed) {
// @types/node has incorrect typings. `setEncoding` accepts `null` as well.
response.setEncoding(this.readableEncoding!);
const success = await this._setRawBody(response);
if (success) {
response.body = response.rawBody!.toString();
}
}
if (this.listenerCount('retry') !== 0) {
let backoff: number;
try {
let retryAfter;
if (response && 'retry-after' in response.headers) {
retryAfter = Number(response.headers['retry-after']);
if (Number.isNaN(retryAfter)) {
retryAfter = Date.parse(response.headers['retry-after']!) - Date.now();
if (retryAfter <= 0) {
retryAfter = 1;
}
} else {
retryAfter *= 1000;
}
}
const retryOptions = options.retry as RetryOptions;
backoff = await retryOptions.calculateDelay({
attemptCount,
retryOptions,
error: typedError,
retryAfter,
computedValue: calculateRetryDelay({
attemptCount,
retryOptions,
error: typedError,
retryAfter,
computedValue: retryOptions.maxRetryAfter ?? options.timeout.request ?? Number.POSITIVE_INFINITY,
}),
});
} catch (error_: any) {
void this._error(new RequestError(error_.message, error_, this));
return;
}
if (backoff) {
await new Promise<void>(resolve => {
const timeout = setTimeout(resolve, backoff);
this._stopRetry = () => {
clearTimeout(timeout);
resolve();
};
});
// Something forced us to abort the retry
if (this.destroyed) {
return;
}
try {
for (const hook of this.options.hooks.beforeRetry) {
// eslint-disable-next-line no-await-in-loop
await hook(typedError, this.retryCount + 1);
}
} catch (error_: any) {
void this._error(new RequestError(error_.message, error, this));
return;
}
// Something forced us to abort the retry
if (this.destroyed) {
return;
}
this.destroy();
this.emit('retry', this.retryCount + 1, error, (updatedOptions?: OptionsInit) => {
const request = new Request(options.url, updatedOptions, options);
request.retryCount = this.retryCount + 1;
process.nextTick(() => {
void request.flush();
});
return request;
});
return;
}
}
void this._error(typedError);
})();
}
override _read(): void {
this._triggerRead = true;
const {response} = this;
if (response && !this._stopReading) {
// We cannot put this in the `if` above
// because `.read()` also triggers the `end` event
if (response.readableLength) {
this._triggerRead = false;
}
let data;
while ((data = response.read()) !== null) {
this._downloadedSize += data.length; // eslint-disable-line @typescript-eslint/restrict-plus-operands
const progress = this.downloadProgress;
if (progress.percent < 1) {
this.emit('downloadProgress', progress);
}
this.push(data);
}
}
}
override _write(chunk: unknown, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
const write = (): void => {
this._writeRequest(chunk, encoding, callback);
};
if (this._requestInitialized) {
write();
} else {
this._jobs.push(write);
}
}
override _final(callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
const endRequest = (): void => {
// We need to check if `this._request` is present,
// because it isn't when we use cache.
if (!this._request || this._request.destroyed) {
callback();
return;
}
this._request.end((error?: Error | null) => { // eslint-disable-line @typescript-eslint/ban-types
// The request has been destroyed before `_final` finished.
// See https://github.com/nodejs/node/issues/39356
if ((this._request as any)._writableState?.errored) {
return;
}
if (!error) {
this._bodySize = this._uploadedSize;
this.emit('uploadProgress', this.uploadProgress);
this._request!.emit('upload-complete');
}
callback(error);
});
};
if (this._requestInitialized) {
endRequest();
} else {
this._jobs.push(endRequest);
}
}
override _destroy(error: Error | null, callback: (error: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
this._stopReading = true;
this.flush = async () => {};
// Prevent further retries
this._stopRetry();
this._cancelTimeouts();
this._removeListeners();
if (this.options) {
const {body} = this.options;
if (is.nodeStream(body)) {
body.destroy();
}
}
if (this._request) {
this._request.destroy();
}
if (error !== null && !is.undefined(error) && !(error instanceof RequestError)) {
error = new RequestError(error.message, error, this);
}
callback(error);
}
override pipe<T extends NodeJS.WritableStream>(destination: T, options?: {end?: boolean}): T {
if (destination instanceof ServerResponse) {
this._pipedServerResponses.add(destination);
}
return super.pipe(destination, options);
}
override unpipe<T extends NodeJS.WritableStream>(destination: T): this {
if (destination instanceof ServerResponse) {
this._pipedServerResponses.delete(destination);
}
super.unpipe(destination);
return this;
}
private async _finalizeBody(): Promise<void> {
const {options} = this;
const {headers} = options;
const isForm = !is.undefined(options.form);
// eslint-disable-next-line @typescript-eslint/naming-convention
const isJSON = !is.undefined(options.json);
const isBody = !is.undefined(options.body);
const cannotHaveBody = methodsWithoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
this._cannotHaveBody = cannotHaveBody;
if (isForm || isJSON || isBody) {
if (cannotHaveBody) {
throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
}
// Serialize body
const noContentType = !is.string(headers['content-type']);
if (isBody) {
// Body is spec-compliant FormData
if (isFormDataLike(options.body)) {
const encoder = new FormDataEncoder(options.body);
if (noContentType) {
headers['content-type'] = encoder.headers['Content-Type'];
}
if ('Content-Length' in encoder.headers) {
headers['content-length'] = encoder.headers['Content-Length'];
}
options.body = encoder.encode();
}
// Special case for https://github.com/form-data/form-data
if (isFormData(options.body) && noContentType) {
headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
}
} else if (isForm) {
if (noContentType) {
headers['content-type'] = 'application/x-www-form-urlencoded';
}
const {form} = options;
options.form = undefined;
options.body = (new URLSearchParams(form as Record<string, string>)).toString();
} else {
if (noContentType) {
headers['content-type'] = 'application/json';
}
const {json} = options;
options.json = undefined;
options.body = options.stringifyJson(json);
}
const uploadBodySize = await getBodySize(options.body, options.headers);
// See https://tools.ietf.org/html/rfc7230#section-3.3.2
// A user agent SHOULD send a Content-Length in a request message when
// no Transfer-Encoding is sent and the request method defines a meaning
// for an enclosed payload body. For example, a Content-Length header
// field is normally sent in a POST request even when the value is 0
// (indicating an empty payload body). A user agent SHOULD NOT send a
// Content-Length header field when the request message does not contain
// a payload body and the method semantics do not anticipate such a
// body.
if (is.undefined(headers['content-length']) && is.undefined(headers['transfer-encoding']) && !cannotHaveBody && !is.undefined(uploadBodySize)) {
headers['content-length'] = String(uploadBodySize);
}
}
if (options.responseType === 'json' && !('accept' in options.headers)) {
options.headers.accept = 'application/json';
}
this._bodySize = Number(headers['content-length']) || undefined;
}
private async _onResponseBase(response: IncomingMessageWithTimings): Promise<void> {
// This will be called e.g. when using cache so we need to check if this request has been aborted.
if (this.isAborted) {
return;
}
const {options} = this;
const {url} = options;
this._nativeResponse = response;
if (options.decompress) {
response = decompressResponse(response);
}
const statusCode = response.statusCode!;
const typedResponse = response as PlainResponse;
typedResponse.statusMessage = typedResponse.statusMessage ? typedResponse.statusMessage : http.STATUS_CODES[statusCode];
typedResponse.url = options.url!.toString();
typedResponse.requestUrl = this.requestUrl!;
typedResponse.redirectUrls = this.redirectUrls;
typedResponse.request = this;
typedResponse.isFromCache = (this._nativeResponse as any).fromCache ?? false;
typedResponse.ip = this.ip;
typedResponse.retryCount = this.retryCount;
typedResponse.ok = isResponseOk(typedResponse);
this._isFromCache = typedResponse.isFromCache;
this._responseSize = Number(response.headers['content-length']) || undefined;
this.response = typedResponse;
response.once('end', () => {
this._responseSize = this._downloadedSize;
this.emit('downloadProgress', this.downloadProgress);
});
response.once('error', (error: Error) => {
this._aborted = true;
// Force clean-up, because some packages don't do this.
// TODO: Fix decompress-response
response.destroy();
this._beforeError(new ReadError(error, this));
});
response.once('aborted', () => {
this._aborted = true;
this._beforeError(new ReadError({
name: 'Error',
message: 'The server aborted pending request',
code: 'ECONNRESET',
}, this));
});
this.emit('downloadProgress', this.downloadProgress);
const rawCookies = response.headers['set-cookie'];
if (is.object(options.cookieJar) && rawCookies) {
let promises: Array<Promise<unknown>> = rawCookies.map(async (rawCookie: string) => (options.cookieJar as PromiseCookieJar).setCookie(rawCookie, url!.toString()));
if (options.ignoreInvalidCookies) {
promises = promises.map(async promise => {
try {
await promise;
} catch {}
});
}
try {
await Promise.all(promises);
} catch (error: any) {
this._beforeError(error);
return;
}
}
// The above is running a promise, therefore we need to check if this request has been aborted yet again.
if (this.isAborted) {
return;
}
if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
// We're being redirected, we don't care about the response.
// It'd be best to abort the request, but we can't because
// we would have to sacrifice the TCP connection. We don't want that.
response.resume();
this._cancelTimeouts();
this._unproxyEvents();
if (this.redirectUrls.length >= options.maxRedirects) {
this._beforeError(new MaxRedirectsError(this));
return;
}
this._request = undefined;
const updatedOptions = new Options(undefined, undefined, this.options);
const serverRequestedGet = statusCode === 303 && updatedOptions.method !== 'GET' && updatedOptions.method !== 'HEAD';
const canRewrite = statusCode !== 307 && statusCode !== 308;
const userRequestedGet = updatedOptions.methodRewriting && canRewrite;
if (serverRequestedGet || userRequestedGet) {
updatedOptions.method = 'GET';
updatedOptions.body = undefined;
updatedOptions.json = undefined;
updatedOptions.form = undefined;
delete updatedOptions.headers['content-length'];
}
try {
// We need this in order to support UTF-8
const redirectBuffer = Buffer.from(response.headers.location, 'binary').toString();
const redirectUrl = new URL(redirectBuffer, url);
if (!isUnixSocketURL(url as URL) && isUnixSocketURL(redirectUrl)) {
this._beforeError(new RequestError('Cannot redirect to UNIX socket', {}, this));
return;
}
// Redirecting to a different site, clear sensitive data.
if (redirectUrl.hostname !== (url as URL).hostname || redirectUrl.port !== (url as URL).port) {
if ('host' in updatedOptions.headers) {
delete updatedOptions.headers.host;
}
if ('cookie' in updatedOptions.headers) {
delete updatedOptions.headers.cookie;
}
if ('authorization' in updatedOptions.headers) {
delete updatedOptions.headers.authorization;
}
if (updatedOptions.username || updatedOptions.password) {
updatedOptions.username = '';
updatedOptions.password = '';
}
} else {
redirectUrl.username = updatedOptions.username;
redirectUrl.password = updatedOptions.password;
}
this.redirectUrls.push(redirectUrl);
updatedOptions.prefixUrl = '';
updatedOptions.url = redirectUrl;
for (const hook of updatedOptions.hooks.beforeRedirect) {
// eslint-disable-next-line no-await-in-loop
await hook(updatedOptions, typedResponse);
}
this.emit('redirect', updatedOptions, typedResponse);
this.options = updatedOptions;
await this._makeRequest();
} catch (error: any) {
this._beforeError(error);
return;
}
return;
}
// `HTTPError`s always have `error.response.body` defined.
// Therefore we cannot retry if `options.throwHttpErrors` is false.
// On the last retry, if `options.throwHttpErrors` is false, we would need to return the body,
// but that wouldn't be possible since the body would be already read in `error.response.body`.
if (options.isStream && options.throwHttpErrors && !isResponseOk(typedResponse)) {
this._beforeError(new HTTPError(typedResponse));
return;
}
response.on('readable', () => {
if (this._triggerRead) {
this._read();
}
});
this.on('resume', () => {
response.resume();
});
this.on('pause', () => {
response.pause();
});
response.once('end', () => {
this.push(null);
});
if (this._noPipe) {
const success = await this._setRawBody();
if (success) {
this.emit('response', response);
}
return;
}
this.emit('response', response);
for (const destination of this._pipedServerResponses) {
if (destination.headersSent) {
continue;
}
// eslint-disable-next-line guard-for-in
for (const key in response.headers) {
const isAllowed = options.decompress ? key !== 'content-encoding' : true;
const value = response.headers[key];
if (isAllowed) {
destination.setHeader(key, value!);
}
}
destination.statusCode = statusCode;
}
}
private async _setRawBody(from: Readable = this): Promise<boolean> {
if (from.readableEnded) {
return false;
}
try {
// Errors are emitted via the `error` event
const rawBody = await getBuffer(from);
// On retry Request is destroyed with no error, therefore the above will successfully resolve.
// So in order to check if this was really successfull, we need to check if it has been properly ended.
if (!this.isAborted) {
this.response!.rawBody = rawBody;
return true;
}
} catch {}
return false;
}
private async _onResponse(response: IncomingMessageWithTimings): Promise<void> {
try {
await this._onResponseBase(response);
} catch (error: any) {
/* istanbul ignore next: better safe than sorry */
this._beforeError(error);
}
}
private _onRequest(request: ClientRequest): void {
const {options} = this;
const {timeout, url} = options;
timer(request);
if (this.options.http2) {
// Unset stream timeout, as the `timeout` option was used only for connection timeout.
request.setTimeout(0);
}
this._cancelTimeouts = timedOut(request, timeout, url as URL);
const responseEventName = options.cache ? 'cacheableResponse' : 'response';
request.once(responseEventName, (response: IncomingMessageWithTimings) => {
void this._onResponse(response);
});
request.once('error', (error: Error) => {
this._aborted = true;
// Force clean-up, because some packages (e.g. nock) don't do this.
request.destroy();
error = error instanceof TimedOutTimeoutError ? new TimeoutError(error, this.timings!, this) : new RequestError(error.message, error, this);
this._beforeError(error);
});
this._unproxyEvents = proxyEvents(request, this, proxiedRequestEvents);
this._request = request;
this.emit('uploadProgress', this.uploadProgress);
this._sendBody();
this.emit('request', request);
}
private async _asyncWrite(chunk: any): Promise<void> {
return new Promise((resolve, reject) => {
super.write(chunk, error => {
if (error) {
reject(error);
return;
}
resolve();
});
});
}
private _sendBody() {
// Send body
const {body} = this.options;
const currentRequest = this.redirectUrls.length === 0 ? this : this._request ?? this;
if (is.nodeStream(body)) {
body.pipe(currentRequest);
} else if (is.generator(body) || is.asyncGenerator(body)) {
(async () => {
try {
for await (const chunk of body) {
await this._asyncWrite(chunk);
}
super.end();
} catch (error: any) {
this._beforeError(error);
}
})();
} else if (!is.undefined(body)) {
this._writeRequest(body, undefined, () => {});
currentRequest.end();
} else if (this._cannotHaveBody || this._noPipe) {
currentRequest.end();
}
}
private _prepareCache(cache: string | StorageAdapter) {
if (!cacheableStore.has(cache)) {
const cacheableRequest = new CacheableRequest(
((requestOptions: RequestOptions, handler?: (response: IncomingMessageWithTimings) => void): ClientRequest => {
const result = (requestOptions as any)._request(requestOptions, handler);
// TODO: remove this when `cacheable-request` supports async request functions.
if (is.promise(result)) {
// We only need to implement the error handler in order to support HTTP2 caching.
// The result will be a promise anyway.
// @ts-expect-error ignore
// eslint-disable-next-line @typescript-eslint/promise-function-async
result.once = (event: string, handler: (reason: unknown) => void) => {
if (event === 'error') {
(async () => {
try {
await result;
} catch (error) {
handler(error);
}
})();
} else if (event === 'abort') {
// The empty catch is needed here in case when
// it rejects before it's `await`ed in `_makeRequest`.
(async () => {
try {
const request = (await result) as ClientRequest;
request.once('abort', handler);
} catch {}
})();
} else {
/* istanbul ignore next: safety check */
throw new Error(`Unknown HTTP2 promise event: ${event}`);
}
return result;
};
}
return result;
}) as typeof http.request,
cache as StorageAdapter,
);
cacheableStore.set(cache, cacheableRequest.request());
}
}
private async _createCacheableRequest(url: URL, options: RequestOptions): Promise<ClientRequest | ResponseLike> {
return new Promise<ClientRequest | ResponseLike>((resolve, reject) => {
// TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
Object.assign(options, urlToOptions(url));
let request: ClientRequest | Promise<ClientRequest>;
// TODO: Fix `cacheable-response`. This is ugly.
const cacheRequest = cacheableStore.get((options as any).cache)!(options as CacheableOptions, async (response: any) => {
response._readableState.autoDestroy = false;
if (request) {
const fix = () => {
if (response.req) {
response.complete = response.req.res.complete;
}
};
response.prependOnceListener('end', fix);
fix();
(await request).emit('cacheableResponse', response);
}
resolve(response);
});
cacheRequest.once('error', reject);
cacheRequest.once('request', async (requestOrPromise: ClientRequest | Promise<ClientRequest>) => {
request = requestOrPromise;
resolve(request);
});
});
}
private async _makeRequest(): Promise<void> {
const {options} = this;
const {headers, username, password} = options;
const cookieJar = options.cookieJar as PromiseCookieJar | undefined;
for (const key in headers) {
if (is.undefined(headers[key])) {
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
delete headers[key];
} else if (is.null_(headers[key])) {
throw new TypeError(`Use \`undefined\` instead of \`null\` to delete the \`${key}\` header`);
}
}
if (options.decompress && is.undefined(headers['accept-encoding'])) {
headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate';
}
if (username || password) {
const credentials = Buffer.from(`${username}:${password}`).toString('base64');
headers.authorization = `Basic ${credentials}`;
}
// Set cookies
if (cookieJar) {
const cookieString: string = await cookieJar.getCookieString(options.url!.toString());
if (is.nonEmptyString(cookieString)) {
headers.cookie = cookieString;
}
}
// Reset `prefixUrl`
options.prefixUrl = '';
let request: ReturnType<Options['getRequestFunction']> | undefined;
for (const hook of options.hooks.beforeRequest) {
// eslint-disable-next-line no-await-in-loop
const result = await hook(options);
if (!is.undefined(result)) {
// @ts-expect-error Skip the type mismatch to support abstract responses
request = () => result;
break;
}
}
if (!request) {
request = options.getRequestFunction();
}
const url = options.url as URL;
this._requestOptions = options.createNativeRequestOptions() as NativeRequestOptions;
if (options.cache) {
(this._requestOptions as any)._request = request;
(this._requestOptions as any).cache = options.cache;
(this._requestOptions as any).body = options.body;
this._prepareCache(options.cache as StorageAdapter);
}
// Cache support
const fn = options.cache ? this._createCacheableRequest : request;
try {
// We can't do `await fn(...)`,
// because stream `error` event can be emitted before `Promise.resolve()`.
let requestOrResponse = fn!(url, this._requestOptions);
if (is.promise(requestOrResponse)) {
requestOrResponse = await requestOrResponse;
}
// Fallback
if (is.undefined(requestOrResponse)) {
requestOrResponse = options.getFallbackRequestFunction()!(url, this._requestOptions);
if (is.promise(requestOrResponse)) {
requestOrResponse = await requestOrResponse;
}
}
if (isClientRequest(requestOrResponse!)) {
this._onRequest(requestOrResponse);
} else if (this.writable) {
this.once('finish', () => {
void this._onResponse(requestOrResponse as IncomingMessageWithTimings);
});
this._sendBody();
} else {
void this._onResponse(requestOrResponse as IncomingMessageWithTimings);
}
} catch (error) {
if (error instanceof CacheableCacheError) {
throw new CacheError(error, this);
}
throw error;
}
}
private async _error(error: RequestError): Promise<void> {
try {
if (error instanceof HTTPError && !this.options.throwHttpErrors) {
// This branch can be reached only when using the Promise API
// Skip calling the hooks on purpose.
// See https://github.com/sindresorhus/got/issues/2103
} else {
for (const hook of this.options.hooks.beforeError) {
// eslint-disable-next-line no-await-in-loop
error = await hook(error);
}
}
} catch (error_: any) {
error = new RequestError(error_.message, error_, this);
}
this.destroy(error);
}
private _writeRequest(chunk: any, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
if (!this._request || this._request.destroyed) {
// Probably the `ClientRequest` instance will throw
return;
}
this._request.write(chunk, encoding!, (error?: Error | null) => { // eslint-disable-line @typescript-eslint/ban-types
// The `!destroyed` check is required to prevent `uploadProgress` being emitted after the stream was destroyed
if (!error && !this._request!.destroyed) {
this._uploadedSize += Buffer.byteLength(chunk, encoding);
const progress = this.uploadProgress;
if (progress.percent < 1) {
this.emit('uploadProgress', progress);
}
}
callback(error);
});
}
/**
The remote IP address.
*/
get ip(): string | undefined {
return this.socket?.remoteAddress;
}
/**
Indicates whether the request has been aborted or not.
*/
get isAborted(): boolean {
return this._aborted;
}
get socket(): Socket | undefined {
return this._request?.socket ?? undefined;
}
/**
Progress event for downloading (receiving a response).
*/
get downloadProgress(): Progress {
let percent;
if (this._responseSize) {
percent = this._downloadedSize / this._responseSize;
} else if (this._responseSize === this._downloadedSize) {
percent = 1;
} else {
percent = 0;
}
return {
percent,
transferred: this._downloadedSize,
total: this._responseSize,
};
}
/**
Progress event for uploading (sending a request).
*/
get uploadProgress(): Progress {
let percent;
if (this._bodySize) {
percent = this._uploadedSize / this._bodySize;
} else if (this._bodySize === this._uploadedSize) {
percent = 1;
} else {
percent = 0;
}
return {
percent,
transferred: this._uploadedSize,
total: this._bodySize,
};
}
/**
The object contains the following properties:
- `start` - Time when the request started.
- `socket` - Time when a socket was assigned to the request.
- `lookup` - Time when the DNS lookup finished.
- `connect` - Time when the socket successfully connected.
- `secureConnect` - Time when the socket securely connected.
- `upload` - Time when the request finished uploading.
- `response` - Time when the request fired `response` event.
- `end` - Time when the response fired `end` event.
- `error` - Time when the request fired `error` event.
- `abort` - Time when the request fired `abort` event.
- `phases`
- `wait` - `timings.socket - timings.start`
- `dns` - `timings.lookup - timings.socket`
- `tcp` - `timings.connect - timings.lookup`
- `tls` - `timings.secureConnect - timings.connect`
- `request` - `timings.upload - (timings.secureConnect || timings.connect)`
- `firstByte` - `timings.response - timings.upload`
- `download` - `timings.end - timings.response`
- `total` - `(timings.end || timings.error || timings.abort) - timings.start`
If something has not been measured yet, it will be `undefined`.
__Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
*/
get timings(): Timings | undefined {
return (this._request as ClientRequestWithTimings)?.timings;
}
/**
Whether the response was retrieved from the cache.
*/
get isFromCache(): boolean | undefined {
return this._isFromCache;
}
get reusedSocket(): boolean | undefined {
return this._request?.reusedSocket;
}
} |
404 | function timedOut(request: ClientRequest, delays: Delays, options: TimedOutOptions): () => void {
if (reentry in request) {
return noop;
}
request[reentry] = true;
const cancelers: Array<typeof noop> = [];
const {once, unhandleAll} = unhandler();
const addTimeout = (delay: number, callback: (delay: number, event: string) => void, event: string): (typeof noop) => {
const timeout = setTimeout(callback, delay, delay, event) as unknown as NodeJS.Timeout;
timeout.unref?.();
const cancel = (): void => {
clearTimeout(timeout);
};
cancelers.push(cancel);
return cancel;
};
const {host, hostname} = options;
const timeoutHandler = (delay: number, event: string): void => {
request.destroy(new TimeoutError(delay, event));
};
const cancelTimeouts = (): void => {
for (const cancel of cancelers) {
cancel();
}
unhandleAll();
};
request.once('error', error => {
cancelTimeouts();
// Save original behavior
/* istanbul ignore next */
if (request.listenerCount('error') === 0) {
throw error;
}
});
if (typeof delays.request !== 'undefined') {
const cancelTimeout = addTimeout(delays.request, timeoutHandler, 'request');
once(request, 'response', (response: IncomingMessage): void => {
once(response, 'end', cancelTimeout);
});
}
if (typeof delays.socket !== 'undefined') {
const {socket} = delays;
const socketTimeoutHandler = (): void => {
timeoutHandler(socket, 'socket');
};
request.setTimeout(socket, socketTimeoutHandler);
// `request.setTimeout(0)` causes a memory leak.
// We can just remove the listener and forget about the timer - it's unreffed.
// See https://github.com/sindresorhus/got/issues/690
cancelers.push(() => {
request.removeListener('timeout', socketTimeoutHandler);
});
}
const hasLookup = typeof delays.lookup !== 'undefined';
const hasConnect = typeof delays.connect !== 'undefined';
const hasSecureConnect = typeof delays.secureConnect !== 'undefined';
const hasSend = typeof delays.send !== 'undefined';
if (hasLookup || hasConnect || hasSecureConnect || hasSend) {
once(request, 'socket', (socket: net.Socket): void => {
const {socketPath} = request as ClientRequest & {socketPath?: string};
/* istanbul ignore next: hard to test */
if (socket.connecting) {
const hasPath = Boolean(socketPath ?? net.isIP(hostname ?? host ?? '') !== 0);
if (hasLookup && !hasPath && typeof (socket.address() as net.AddressInfo).address === 'undefined') {
const cancelTimeout = addTimeout(delays.lookup!, timeoutHandler, 'lookup');
once(socket, 'lookup', cancelTimeout);
}
if (hasConnect) {
const timeConnect = (): (() => void) => addTimeout(delays.connect!, timeoutHandler, 'connect');
if (hasPath) {
once(socket, 'connect', timeConnect());
} else {
once(socket, 'lookup', (error: Error): void => {
if (error === null) {
once(socket, 'connect', timeConnect());
}
});
}
}
if (hasSecureConnect && options.protocol === 'https:') {
once(socket, 'connect', (): void => {
const cancelTimeout = addTimeout(delays.secureConnect!, timeoutHandler, 'secureConnect');
once(socket, 'secureConnect', cancelTimeout);
});
}
}
if (hasSend) {
const timeRequest = (): (() => void) => addTimeout(delays.send!, timeoutHandler, 'send');
/* istanbul ignore next: hard to test */
if (socket.connecting) {
once(socket, 'connect', (): void => {
once(request, 'upload-complete', timeRequest());
});
} else {
once(request, 'upload-complete', timeRequest());
}
}
});
}
if (typeof delays.response !== 'undefined') {
once(request, 'upload-complete', (): void => {
const cancelTimeout = addTimeout(delays.response!, timeoutHandler, 'response');
once(request, 'response', cancelTimeout);
});
}
if (typeof delays.read !== 'undefined') {
once(request, 'response', (response: IncomingMessage): void => {
const cancelTimeout = addTimeout(delays.read!, timeoutHandler, 'read');
once(response, 'end', cancelTimeout);
});
}
return cancelTimeouts;
} | interface ClientRequest {
[reentry]?: boolean;
} |
405 | function timedOut(request: ClientRequest, delays: Delays, options: TimedOutOptions): () => void {
if (reentry in request) {
return noop;
}
request[reentry] = true;
const cancelers: Array<typeof noop> = [];
const {once, unhandleAll} = unhandler();
const addTimeout = (delay: number, callback: (delay: number, event: string) => void, event: string): (typeof noop) => {
const timeout = setTimeout(callback, delay, delay, event) as unknown as NodeJS.Timeout;
timeout.unref?.();
const cancel = (): void => {
clearTimeout(timeout);
};
cancelers.push(cancel);
return cancel;
};
const {host, hostname} = options;
const timeoutHandler = (delay: number, event: string): void => {
request.destroy(new TimeoutError(delay, event));
};
const cancelTimeouts = (): void => {
for (const cancel of cancelers) {
cancel();
}
unhandleAll();
};
request.once('error', error => {
cancelTimeouts();
// Save original behavior
/* istanbul ignore next */
if (request.listenerCount('error') === 0) {
throw error;
}
});
if (typeof delays.request !== 'undefined') {
const cancelTimeout = addTimeout(delays.request, timeoutHandler, 'request');
once(request, 'response', (response: IncomingMessage): void => {
once(response, 'end', cancelTimeout);
});
}
if (typeof delays.socket !== 'undefined') {
const {socket} = delays;
const socketTimeoutHandler = (): void => {
timeoutHandler(socket, 'socket');
};
request.setTimeout(socket, socketTimeoutHandler);
// `request.setTimeout(0)` causes a memory leak.
// We can just remove the listener and forget about the timer - it's unreffed.
// See https://github.com/sindresorhus/got/issues/690
cancelers.push(() => {
request.removeListener('timeout', socketTimeoutHandler);
});
}
const hasLookup = typeof delays.lookup !== 'undefined';
const hasConnect = typeof delays.connect !== 'undefined';
const hasSecureConnect = typeof delays.secureConnect !== 'undefined';
const hasSend = typeof delays.send !== 'undefined';
if (hasLookup || hasConnect || hasSecureConnect || hasSend) {
once(request, 'socket', (socket: net.Socket): void => {
const {socketPath} = request as ClientRequest & {socketPath?: string};
/* istanbul ignore next: hard to test */
if (socket.connecting) {
const hasPath = Boolean(socketPath ?? net.isIP(hostname ?? host ?? '') !== 0);
if (hasLookup && !hasPath && typeof (socket.address() as net.AddressInfo).address === 'undefined') {
const cancelTimeout = addTimeout(delays.lookup!, timeoutHandler, 'lookup');
once(socket, 'lookup', cancelTimeout);
}
if (hasConnect) {
const timeConnect = (): (() => void) => addTimeout(delays.connect!, timeoutHandler, 'connect');
if (hasPath) {
once(socket, 'connect', timeConnect());
} else {
once(socket, 'lookup', (error: Error): void => {
if (error === null) {
once(socket, 'connect', timeConnect());
}
});
}
}
if (hasSecureConnect && options.protocol === 'https:') {
once(socket, 'connect', (): void => {
const cancelTimeout = addTimeout(delays.secureConnect!, timeoutHandler, 'secureConnect');
once(socket, 'secureConnect', cancelTimeout);
});
}
}
if (hasSend) {
const timeRequest = (): (() => void) => addTimeout(delays.send!, timeoutHandler, 'send');
/* istanbul ignore next: hard to test */
if (socket.connecting) {
once(socket, 'connect', (): void => {
once(request, 'upload-complete', timeRequest());
});
} else {
once(request, 'upload-complete', timeRequest());
}
}
});
}
if (typeof delays.response !== 'undefined') {
once(request, 'upload-complete', (): void => {
const cancelTimeout = addTimeout(delays.response!, timeoutHandler, 'response');
once(request, 'response', cancelTimeout);
});
}
if (typeof delays.read !== 'undefined') {
once(request, 'response', (response: IncomingMessage): void => {
const cancelTimeout = addTimeout(delays.read!, timeoutHandler, 'read');
once(response, 'end', cancelTimeout);
});
}
return cancelTimeouts;
} | type Delays = {
lookup?: number;
socket?: number;
connect?: number;
secureConnect?: number;
send?: number;
response?: number;
read?: number;
request?: number;
}; |
406 | function timedOut(request: ClientRequest, delays: Delays, options: TimedOutOptions): () => void {
if (reentry in request) {
return noop;
}
request[reentry] = true;
const cancelers: Array<typeof noop> = [];
const {once, unhandleAll} = unhandler();
const addTimeout = (delay: number, callback: (delay: number, event: string) => void, event: string): (typeof noop) => {
const timeout = setTimeout(callback, delay, delay, event) as unknown as NodeJS.Timeout;
timeout.unref?.();
const cancel = (): void => {
clearTimeout(timeout);
};
cancelers.push(cancel);
return cancel;
};
const {host, hostname} = options;
const timeoutHandler = (delay: number, event: string): void => {
request.destroy(new TimeoutError(delay, event));
};
const cancelTimeouts = (): void => {
for (const cancel of cancelers) {
cancel();
}
unhandleAll();
};
request.once('error', error => {
cancelTimeouts();
// Save original behavior
/* istanbul ignore next */
if (request.listenerCount('error') === 0) {
throw error;
}
});
if (typeof delays.request !== 'undefined') {
const cancelTimeout = addTimeout(delays.request, timeoutHandler, 'request');
once(request, 'response', (response: IncomingMessage): void => {
once(response, 'end', cancelTimeout);
});
}
if (typeof delays.socket !== 'undefined') {
const {socket} = delays;
const socketTimeoutHandler = (): void => {
timeoutHandler(socket, 'socket');
};
request.setTimeout(socket, socketTimeoutHandler);
// `request.setTimeout(0)` causes a memory leak.
// We can just remove the listener and forget about the timer - it's unreffed.
// See https://github.com/sindresorhus/got/issues/690
cancelers.push(() => {
request.removeListener('timeout', socketTimeoutHandler);
});
}
const hasLookup = typeof delays.lookup !== 'undefined';
const hasConnect = typeof delays.connect !== 'undefined';
const hasSecureConnect = typeof delays.secureConnect !== 'undefined';
const hasSend = typeof delays.send !== 'undefined';
if (hasLookup || hasConnect || hasSecureConnect || hasSend) {
once(request, 'socket', (socket: net.Socket): void => {
const {socketPath} = request as ClientRequest & {socketPath?: string};
/* istanbul ignore next: hard to test */
if (socket.connecting) {
const hasPath = Boolean(socketPath ?? net.isIP(hostname ?? host ?? '') !== 0);
if (hasLookup && !hasPath && typeof (socket.address() as net.AddressInfo).address === 'undefined') {
const cancelTimeout = addTimeout(delays.lookup!, timeoutHandler, 'lookup');
once(socket, 'lookup', cancelTimeout);
}
if (hasConnect) {
const timeConnect = (): (() => void) => addTimeout(delays.connect!, timeoutHandler, 'connect');
if (hasPath) {
once(socket, 'connect', timeConnect());
} else {
once(socket, 'lookup', (error: Error): void => {
if (error === null) {
once(socket, 'connect', timeConnect());
}
});
}
}
if (hasSecureConnect && options.protocol === 'https:') {
once(socket, 'connect', (): void => {
const cancelTimeout = addTimeout(delays.secureConnect!, timeoutHandler, 'secureConnect');
once(socket, 'secureConnect', cancelTimeout);
});
}
}
if (hasSend) {
const timeRequest = (): (() => void) => addTimeout(delays.send!, timeoutHandler, 'send');
/* istanbul ignore next: hard to test */
if (socket.connecting) {
once(socket, 'connect', (): void => {
once(request, 'upload-complete', timeRequest());
});
} else {
once(request, 'upload-complete', timeRequest());
}
}
});
}
if (typeof delays.response !== 'undefined') {
once(request, 'upload-complete', (): void => {
const cancelTimeout = addTimeout(delays.response!, timeoutHandler, 'response');
once(request, 'response', cancelTimeout);
});
}
if (typeof delays.read !== 'undefined') {
once(request, 'response', (response: IncomingMessage): void => {
const cancelTimeout = addTimeout(delays.read!, timeoutHandler, 'read');
once(response, 'end', cancelTimeout);
});
}
return cancelTimeouts;
} | type TimedOutOptions = {
host?: string;
hostname?: string;
protocol?: string;
}; |
407 | (error: Error): void => {
if (error === null) {
once(socket, 'connect', timeConnect());
}
} | type Error = NodeJS.ErrnoException; |
408 | (error: Error): void => {
if (error === null) {
once(socket, 'connect', timeConnect());
}
} | type Error = NodeJS.ErrnoException; |
409 | (url: URL, options: NativeRequestOptions, callback?: (response: AcceptableResponse) => void) => AcceptableRequestResult | type AcceptableResponse = IncomingMessageWithTimings | ResponseLike; |
410 | (url: URL, options: NativeRequestOptions, callback?: (response: AcceptableResponse) => void) => AcceptableRequestResult | type NativeRequestOptions = HttpsRequestOptions & CacheOptions & {checkServerIdentity?: CheckServerIdentityFunction}; |
411 | (response: AcceptableResponse) => void | type AcceptableResponse = IncomingMessageWithTimings | ResponseLike; |
412 | (init: OptionsInit, self: Options) => void | type OptionsInit =
Except<Partial<InternalsType>, 'hooks' | 'retry'>
& {
hooks?: Partial<Hooks>;
retry?: Partial<RetryOptions>;
}; |
413 | (init: OptionsInit, self: Options) => void | class Options {
private _unixOptions?: NativeRequestOptions;
private _internals: InternalsType;
private _merging: boolean;
private readonly _init: OptionsInit[];
constructor(input?: string | URL | OptionsInit, options?: OptionsInit, defaults?: Options) {
assert.any([is.string, is.urlInstance, is.object, is.undefined], input);
assert.any([is.object, is.undefined], options);
assert.any([is.object, is.undefined], defaults);
if (input instanceof Options || options instanceof Options) {
throw new TypeError('The defaults must be passed as the third argument');
}
this._internals = cloneInternals(defaults?._internals ?? defaults ?? defaultInternals);
this._init = [...(defaults?._init ?? [])];
this._merging = false;
this._unixOptions = undefined;
// This rule allows `finally` to be considered more important.
// Meaning no matter the error thrown in the `try` block,
// if `finally` throws then the `finally` error will be thrown.
//
// Yes, we want this. If we set `url` first, then the `url.searchParams`
// would get merged. Instead we set the `searchParams` first, then
// `url.searchParams` is overwritten as expected.
//
/* eslint-disable no-unsafe-finally */
try {
if (is.plainObject(input)) {
try {
this.merge(input);
this.merge(options);
} finally {
this.url = input.url;
}
} else {
try {
this.merge(options);
} finally {
if (options?.url !== undefined) {
if (input === undefined) {
this.url = options.url;
} else {
throw new TypeError('The `url` option is mutually exclusive with the `input` argument');
}
} else if (input !== undefined) {
this.url = input;
}
}
}
} catch (error) {
(error as OptionsError).options = this;
throw error;
}
/* eslint-enable no-unsafe-finally */
}
merge(options?: OptionsInit | Options) {
if (!options) {
return;
}
if (options instanceof Options) {
for (const init of options._init) {
this.merge(init);
}
return;
}
options = cloneRaw(options);
init(this, options, this);
init(options, options, this);
this._merging = true;
// Always merge `isStream` first
if ('isStream' in options) {
this.isStream = options.isStream!;
}
try {
let push = false;
for (const key in options) {
// `got.extend()` options
if (key === 'mutableDefaults' || key === 'handlers') {
continue;
}
// Never merge `url`
if (key === 'url') {
continue;
}
if (!(key in this)) {
throw new Error(`Unexpected option: ${key}`);
}
// @ts-expect-error Type 'unknown' is not assignable to type 'never'.
this[key as keyof Options] = options[key as keyof Options];
push = true;
}
if (push) {
this._init.push(options);
}
} finally {
this._merging = false;
}
}
/**
Custom request function.
The main purpose of this is to [support HTTP2 using a wrapper](https://github.com/szmarczak/http2-wrapper).
@default http.request | https.request
*/
get request(): RequestFunction | undefined {
return this._internals.request;
}
set request(value: RequestFunction | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.request = value;
}
/**
An object representing `http`, `https` and `http2` keys for [`http.Agent`](https://nodejs.org/api/http.html#http_class_http_agent), [`https.Agent`](https://nodejs.org/api/https.html#https_class_https_agent) and [`http2wrapper.Agent`](https://github.com/szmarczak/http2-wrapper#new-http2agentoptions) instance.
This is necessary because a request to one protocol might redirect to another.
In such a scenario, Got will switch over to the right protocol agent for you.
If a key is not present, it will default to a global agent.
@example
```
import got from 'got';
import HttpAgent from 'agentkeepalive';
const {HttpsAgent} = HttpAgent;
await got('https://sindresorhus.com', {
agent: {
http: new HttpAgent(),
https: new HttpsAgent()
}
});
```
*/
get agent(): Agents {
return this._internals.agent;
}
set agent(value: Agents) {
assert.plainObject(value);
// eslint-disable-next-line guard-for-in
for (const key in value) {
if (!(key in this._internals.agent)) {
throw new TypeError(`Unexpected agent option: ${key}`);
}
// @ts-expect-error - No idea why `value[key]` doesn't work here.
assert.any([is.object, is.undefined], value[key]);
}
if (this._merging) {
Object.assign(this._internals.agent, value);
} else {
this._internals.agent = {...value};
}
}
get h2session(): ClientHttp2Session | undefined {
return this._internals.h2session;
}
set h2session(value: ClientHttp2Session | undefined) {
this._internals.h2session = value;
}
/**
Decompress the response automatically.
This will set the `accept-encoding` header to `gzip, deflate, br` unless you set it yourself.
If this is disabled, a compressed response is returned as a `Buffer`.
This may be useful if you want to handle decompression yourself or stream the raw compressed data.
@default true
*/
get decompress(): boolean {
return this._internals.decompress;
}
set decompress(value: boolean) {
assert.boolean(value);
this._internals.decompress = value;
}
/**
Milliseconds to wait for the server to end the response before aborting the request with `got.TimeoutError` error (a.k.a. `request` property).
By default, there's no timeout.
This also accepts an `object` with the following fields to constrain the duration of each phase of the request lifecycle:
- `lookup` starts when a socket is assigned and ends when the hostname has been resolved.
Does not apply when using a Unix domain socket.
- `connect` starts when `lookup` completes (or when the socket is assigned if lookup does not apply to the request) and ends when the socket is connected.
- `secureConnect` starts when `connect` completes and ends when the handshaking process completes (HTTPS only).
- `socket` starts when the socket is connected. See [request.setTimeout](https://nodejs.org/api/http.html#http_request_settimeout_timeout_callback).
- `response` starts when the request has been written to the socket and ends when the response headers are received.
- `send` starts when the socket is connected and ends with the request has been written to the socket.
- `request` starts when the request is initiated and ends when the response's end event fires.
*/
get timeout(): Delays {
// We always return `Delays` here.
// It has to be `Delays | number`, otherwise TypeScript will error because the getter and the setter have incompatible types.
return this._internals.timeout;
}
set timeout(value: Delays) {
assert.plainObject(value);
// eslint-disable-next-line guard-for-in
for (const key in value) {
if (!(key in this._internals.timeout)) {
throw new Error(`Unexpected timeout option: ${key}`);
}
// @ts-expect-error - No idea why `value[key]` doesn't work here.
assert.any([is.number, is.undefined], value[key]);
}
if (this._merging) {
Object.assign(this._internals.timeout, value);
} else {
this._internals.timeout = {...value};
}
}
/**
When specified, `prefixUrl` will be prepended to `url`.
The prefix can be any valid URL, either relative or absolute.
A trailing slash `/` is optional - one will be added automatically.
__Note__: `prefixUrl` will be ignored if the `url` argument is a URL instance.
__Note__: Leading slashes in `input` are disallowed when using this option to enforce consistency and avoid confusion.
For example, when the prefix URL is `https://example.com/foo` and the input is `/bar`, there's ambiguity whether the resulting URL would become `https://example.com/foo/bar` or `https://example.com/bar`.
The latter is used by browsers.
__Tip__: Useful when used with `got.extend()` to create niche-specific Got instances.
__Tip__: You can change `prefixUrl` using hooks as long as the URL still includes the `prefixUrl`.
If the URL doesn't include it anymore, it will throw.
@example
```
import got from 'got';
await got('unicorn', {prefixUrl: 'https://cats.com'});
//=> 'https://cats.com/unicorn'
const instance = got.extend({
prefixUrl: 'https://google.com'
});
await instance('unicorn', {
hooks: {
beforeRequest: [
options => {
options.prefixUrl = 'https://cats.com';
}
]
}
});
//=> 'https://cats.com/unicorn'
```
*/
get prefixUrl(): string | URL {
// We always return `string` here.
// It has to be `string | URL`, otherwise TypeScript will error because the getter and the setter have incompatible types.
return this._internals.prefixUrl;
}
set prefixUrl(value: string | URL) {
assert.any([is.string, is.urlInstance], value);
if (value === '') {
this._internals.prefixUrl = '';
return;
}
value = value.toString();
if (!value.endsWith('/')) {
value += '/';
}
if (this._internals.prefixUrl && this._internals.url) {
const {href} = this._internals.url as URL;
(this._internals.url as URL).href = value + href.slice((this._internals.prefixUrl as string).length);
}
this._internals.prefixUrl = value;
}
/**
__Note #1__: The `body` option cannot be used with the `json` or `form` option.
__Note #2__: If you provide this option, `got.stream()` will be read-only.
__Note #3__: If you provide a payload with the `GET` or `HEAD` method, it will throw a `TypeError` unless the method is `GET` and the `allowGetBody` option is set to `true`.
__Note #4__: This option is not enumerable and will not be merged with the instance defaults.
The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
Since Got 12, the `content-length` is not automatically set when `body` is a `fs.createReadStream`.
*/
get body(): string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined {
return this._internals.body;
}
set body(value: string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined) {
assert.any([is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, isFormData, is.undefined], value);
if (is.nodeStream(value)) {
assert.truthy(value.readable);
}
if (value !== undefined) {
assert.undefined(this._internals.form);
assert.undefined(this._internals.json);
}
this._internals.body = value;
}
/**
The form body is converted to a query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
If the `Content-Type` header is not present, it will be set to `application/x-www-form-urlencoded`.
__Note #1__: If you provide this option, `got.stream()` will be read-only.
__Note #2__: This option is not enumerable and will not be merged with the instance defaults.
*/
get form(): Record<string, any> | undefined {
return this._internals.form;
}
set form(value: Record<string, any> | undefined) {
assert.any([is.plainObject, is.undefined], value);
if (value !== undefined) {
assert.undefined(this._internals.body);
assert.undefined(this._internals.json);
}
this._internals.form = value;
}
/**
JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
__Note #1__: If you provide this option, `got.stream()` will be read-only.
__Note #2__: This option is not enumerable and will not be merged with the instance defaults.
*/
get json(): unknown {
return this._internals.json;
}
set json(value: unknown) {
if (value !== undefined) {
assert.undefined(this._internals.body);
assert.undefined(this._internals.form);
}
this._internals.json = value;
}
/**
The URL to request, as a string, a [`https.request` options object](https://nodejs.org/api/https.html#https_https_request_options_callback), or a [WHATWG `URL`](https://nodejs.org/api/url.html#url_class_url).
Properties from `options` will override properties in the parsed `url`.
If no protocol is specified, it will throw a `TypeError`.
__Note__: The query string is **not** parsed as search params.
@example
```
await got('https://example.com/?query=a b'); //=> https://example.com/?query=a%20b
await got('https://example.com/', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
// The query string is overridden by `searchParams`
await got('https://example.com/?query=a b', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
```
*/
get url(): string | URL | undefined {
return this._internals.url;
}
set url(value: string | URL | undefined) {
assert.any([is.string, is.urlInstance, is.undefined], value);
if (value === undefined) {
this._internals.url = undefined;
return;
}
if (is.string(value) && value.startsWith('/')) {
throw new Error('`url` must not start with a slash');
}
const urlString = `${this.prefixUrl as string}${value.toString()}`;
const url = new URL(urlString);
this._internals.url = url;
if (url.protocol === 'unix:') {
url.href = `http://unix${url.pathname}${url.search}`;
}
if (url.protocol !== 'http:' && url.protocol !== 'https:') {
const error: NodeJS.ErrnoException = new Error(`Unsupported protocol: ${url.protocol}`);
error.code = 'ERR_UNSUPPORTED_PROTOCOL';
throw error;
}
if (this._internals.username) {
url.username = this._internals.username;
this._internals.username = '';
}
if (this._internals.password) {
url.password = this._internals.password;
this._internals.password = '';
}
if (this._internals.searchParams) {
url.search = (this._internals.searchParams as URLSearchParams).toString();
this._internals.searchParams = undefined;
}
if (url.hostname === 'unix') {
if (!this._internals.enableUnixSockets) {
throw new Error('Using UNIX domain sockets but option `enableUnixSockets` is not enabled');
}
const matches = /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`);
if (matches?.groups) {
const {socketPath, path} = matches.groups;
this._unixOptions = {
socketPath,
path,
host: '',
};
} else {
this._unixOptions = undefined;
}
return;
}
this._unixOptions = undefined;
}
/**
Cookie support. You don't have to care about parsing or how to store them.
__Note__: If you provide this option, `options.headers.cookie` will be overridden.
*/
get cookieJar(): PromiseCookieJar | ToughCookieJar | undefined {
return this._internals.cookieJar;
}
set cookieJar(value: PromiseCookieJar | ToughCookieJar | undefined) {
assert.any([is.object, is.undefined], value);
if (value === undefined) {
this._internals.cookieJar = undefined;
return;
}
let {setCookie, getCookieString} = value;
assert.function_(setCookie);
assert.function_(getCookieString);
/* istanbul ignore next: Horrible `tough-cookie` v3 check */
if (setCookie.length === 4 && getCookieString.length === 0) {
setCookie = promisify(setCookie.bind(value));
getCookieString = promisify(getCookieString.bind(value));
this._internals.cookieJar = {
setCookie,
getCookieString: getCookieString as PromiseCookieJar['getCookieString'],
};
} else {
this._internals.cookieJar = value;
}
}
/**
You can abort the `request` using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
*Requires Node.js 16 or later.*
@example
```
import got from 'got';
const abortController = new AbortController();
const request = got('https://httpbin.org/anything', {
signal: abortController.signal
});
setTimeout(() => {
abortController.abort();
}, 100);
```
*/
// TODO: Replace `any` with `AbortSignal` when targeting Node 16.
get signal(): any | undefined {
return this._internals.signal;
}
// TODO: Replace `any` with `AbortSignal` when targeting Node 16.
set signal(value: any | undefined) {
assert.object(value);
this._internals.signal = value;
}
/**
Ignore invalid cookies instead of throwing an error.
Only useful when the `cookieJar` option has been set. Not recommended.
@default false
*/
get ignoreInvalidCookies(): boolean {
return this._internals.ignoreInvalidCookies;
}
set ignoreInvalidCookies(value: boolean) {
assert.boolean(value);
this._internals.ignoreInvalidCookies = value;
}
/**
Query string that will be added to the request URL.
This will override the query string in `url`.
If you need to pass in an array, you can do it using a `URLSearchParams` instance.
@example
```
import got from 'got';
const searchParams = new URLSearchParams([['key', 'a'], ['key', 'b']]);
await got('https://example.com', {searchParams});
console.log(searchParams.toString());
//=> 'key=a&key=b'
```
*/
get searchParams(): string | SearchParameters | URLSearchParams | undefined {
if (this._internals.url) {
return (this._internals.url as URL).searchParams;
}
if (this._internals.searchParams === undefined) {
this._internals.searchParams = new URLSearchParams();
}
return this._internals.searchParams;
}
set searchParams(value: string | SearchParameters | URLSearchParams | undefined) {
assert.any([is.string, is.object, is.undefined], value);
const url = this._internals.url as URL;
if (value === undefined) {
this._internals.searchParams = undefined;
if (url) {
url.search = '';
}
return;
}
const searchParameters = this.searchParams as URLSearchParams;
let updated;
if (is.string(value)) {
updated = new URLSearchParams(value);
} else if (value instanceof URLSearchParams) {
updated = value;
} else {
validateSearchParameters(value);
updated = new URLSearchParams();
// eslint-disable-next-line guard-for-in
for (const key in value) {
const entry = value[key];
if (entry === null) {
updated.append(key, '');
} else if (entry === undefined) {
searchParameters.delete(key);
} else {
updated.append(key, entry as string);
}
}
}
if (this._merging) {
// These keys will be replaced
for (const key of updated.keys()) {
searchParameters.delete(key);
}
for (const [key, value] of updated) {
searchParameters.append(key, value);
}
} else if (url) {
url.search = searchParameters.toString();
} else {
this._internals.searchParams = searchParameters;
}
}
get searchParameters() {
throw new Error('The `searchParameters` option does not exist. Use `searchParams` instead.');
}
set searchParameters(_value: unknown) {
throw new Error('The `searchParameters` option does not exist. Use `searchParams` instead.');
}
get dnsLookup(): CacheableLookup['lookup'] | undefined {
return this._internals.dnsLookup;
}
set dnsLookup(value: CacheableLookup['lookup'] | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.dnsLookup = value;
}
/**
An instance of [`CacheableLookup`](https://github.com/szmarczak/cacheable-lookup) used for making DNS lookups.
Useful when making lots of requests to different *public* hostnames.
`CacheableLookup` uses `dns.resolver4(..)` and `dns.resolver6(...)` under the hood and fall backs to `dns.lookup(...)` when the first two fail, which may lead to additional delay.
__Note__: This should stay disabled when making requests to internal hostnames such as `localhost`, `database.local` etc.
@default false
*/
get dnsCache(): CacheableLookup | boolean | undefined {
return this._internals.dnsCache;
}
set dnsCache(value: CacheableLookup | boolean | undefined) {
assert.any([is.object, is.boolean, is.undefined], value);
if (value === true) {
this._internals.dnsCache = getGlobalDnsCache();
} else if (value === false) {
this._internals.dnsCache = undefined;
} else {
this._internals.dnsCache = value;
}
}
/**
User data. `context` is shallow merged and enumerable. If it contains non-enumerable properties they will NOT be merged.
@example
```
import got from 'got';
const instance = got.extend({
hooks: {
beforeRequest: [
options => {
if (!options.context || !options.context.token) {
throw new Error('Token required');
}
options.headers.token = options.context.token;
}
]
}
});
const context = {
token: 'secret'
};
const response = await instance('https://httpbin.org/headers', {context});
// Let's see the headers
console.log(response.body);
```
*/
get context(): Record<string, unknown> {
return this._internals.context;
}
set context(value: Record<string, unknown>) {
assert.object(value);
if (this._merging) {
Object.assign(this._internals.context, value);
} else {
this._internals.context = {...value};
}
}
/**
Hooks allow modifications during the request lifecycle.
Hook functions may be async and are run serially.
*/
get hooks(): Hooks {
return this._internals.hooks;
}
set hooks(value: Hooks) {
assert.object(value);
// eslint-disable-next-line guard-for-in
for (const knownHookEvent in value) {
if (!(knownHookEvent in this._internals.hooks)) {
throw new Error(`Unexpected hook event: ${knownHookEvent}`);
}
const typedKnownHookEvent = knownHookEvent as keyof Hooks;
const hooks = value[typedKnownHookEvent];
assert.any([is.array, is.undefined], hooks);
if (hooks) {
for (const hook of hooks) {
assert.function_(hook);
}
}
if (this._merging) {
if (hooks) {
// @ts-expect-error FIXME
this._internals.hooks[typedKnownHookEvent].push(...hooks);
}
} else {
if (!hooks) {
throw new Error(`Missing hook event: ${knownHookEvent}`);
}
// @ts-expect-error FIXME
this._internals.hooks[knownHookEvent] = [...hooks];
}
}
}
/**
Defines if redirect responses should be followed automatically.
Note that if a `303` is sent by the server in response to any request type (`POST`, `DELETE`, etc.), Got will automatically request the resource pointed to in the location header via `GET`.
This is in accordance with [the spec](https://tools.ietf.org/html/rfc7231#section-6.4.4). You can optionally turn on this behavior also for other redirect codes - see `methodRewriting`.
@default true
*/
get followRedirect(): boolean {
return this._internals.followRedirect;
}
set followRedirect(value: boolean) {
assert.boolean(value);
this._internals.followRedirect = value;
}
get followRedirects() {
throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
}
set followRedirects(_value: unknown) {
throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
}
/**
If exceeded, the request will be aborted and a `MaxRedirectsError` will be thrown.
@default 10
*/
get maxRedirects(): number {
return this._internals.maxRedirects;
}
set maxRedirects(value: number) {
assert.number(value);
this._internals.maxRedirects = value;
}
/**
A cache adapter instance for storing cached response data.
@default false
*/
get cache(): string | StorageAdapter | boolean | undefined {
return this._internals.cache;
}
set cache(value: string | StorageAdapter | boolean | undefined) {
assert.any([is.object, is.string, is.boolean, is.undefined], value);
if (value === true) {
this._internals.cache = globalCache;
} else if (value === false) {
this._internals.cache = undefined;
} else {
this._internals.cache = value;
}
}
/**
Determines if a `got.HTTPError` is thrown for unsuccessful responses.
If this is disabled, requests that encounter an error status code will be resolved with the `response` instead of throwing.
This may be useful if you are checking for resource availability and are expecting error responses.
@default true
*/
get throwHttpErrors(): boolean {
return this._internals.throwHttpErrors;
}
set throwHttpErrors(value: boolean) {
assert.boolean(value);
this._internals.throwHttpErrors = value;
}
get username(): string {
const url = this._internals.url as URL;
const value = url ? url.username : this._internals.username;
return decodeURIComponent(value);
}
set username(value: string) {
assert.string(value);
const url = this._internals.url as URL;
const fixedValue = encodeURIComponent(value);
if (url) {
url.username = fixedValue;
} else {
this._internals.username = fixedValue;
}
}
get password(): string {
const url = this._internals.url as URL;
const value = url ? url.password : this._internals.password;
return decodeURIComponent(value);
}
set password(value: string) {
assert.string(value);
const url = this._internals.url as URL;
const fixedValue = encodeURIComponent(value);
if (url) {
url.password = fixedValue;
} else {
this._internals.password = fixedValue;
}
}
/**
If set to `true`, Got will additionally accept HTTP2 requests.
It will choose either HTTP/1.1 or HTTP/2 depending on the ALPN protocol.
__Note__: This option requires Node.js 15.10.0 or newer as HTTP/2 support on older Node.js versions is very buggy.
__Note__: Overriding `options.request` will disable HTTP2 support.
@default false
@example
```
import got from 'got';
const {headers} = await got('https://nghttp2.org/httpbin/anything', {http2: true});
console.log(headers.via);
//=> '2 nghttpx'
```
*/
get http2(): boolean {
return this._internals.http2;
}
set http2(value: boolean) {
assert.boolean(value);
this._internals.http2 = value;
}
/**
Set this to `true` to allow sending body for the `GET` method.
However, the [HTTP/2 specification](https://tools.ietf.org/html/rfc7540#section-8.1.3) says that `An HTTP GET request includes request header fields and no payload body`, therefore when using the HTTP/2 protocol this option will have no effect.
This option is only meant to interact with non-compliant servers when you have no other choice.
__Note__: The [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.1) doesn't specify any particular behavior for the GET method having a payload, therefore __it's considered an [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern)__.
@default false
*/
get allowGetBody(): boolean {
return this._internals.allowGetBody;
}
set allowGetBody(value: boolean) {
assert.boolean(value);
this._internals.allowGetBody = value;
}
/**
Request headers.
Existing headers will be overwritten. Headers set to `undefined` will be omitted.
@default {}
*/
get headers(): Headers {
return this._internals.headers;
}
set headers(value: Headers) {
assert.plainObject(value);
if (this._merging) {
Object.assign(this._internals.headers, lowercaseKeys(value));
} else {
this._internals.headers = lowercaseKeys(value);
}
}
/**
Specifies if the HTTP request method should be [rewritten as `GET`](https://tools.ietf.org/html/rfc7231#section-6.4) on redirects.
As the [specification](https://tools.ietf.org/html/rfc7231#section-6.4) prefers to rewrite the HTTP method only on `303` responses, this is Got's default behavior.
Setting `methodRewriting` to `true` will also rewrite `301` and `302` responses, as allowed by the spec. This is the behavior followed by `curl` and browsers.
__Note__: Got never performs method rewriting on `307` and `308` responses, as this is [explicitly prohibited by the specification](https://www.rfc-editor.org/rfc/rfc7231#section-6.4.7).
@default false
*/
get methodRewriting(): boolean {
return this._internals.methodRewriting;
}
set methodRewriting(value: boolean) {
assert.boolean(value);
this._internals.methodRewriting = value;
}
/**
Indicates which DNS record family to use.
Values:
- `undefined`: IPv4 (if present) or IPv6
- `4`: Only IPv4
- `6`: Only IPv6
@default undefined
*/
get dnsLookupIpVersion(): DnsLookupIpVersion {
return this._internals.dnsLookupIpVersion;
}
set dnsLookupIpVersion(value: DnsLookupIpVersion) {
if (value !== undefined && value !== 4 && value !== 6) {
throw new TypeError(`Invalid DNS lookup IP version: ${value as string}`);
}
this._internals.dnsLookupIpVersion = value;
}
/**
A function used to parse JSON responses.
@example
```
import got from 'got';
import Bourne from '@hapi/bourne';
const parsed = await got('https://example.com', {
parseJson: text => Bourne.parse(text)
}).json();
console.log(parsed);
```
*/
get parseJson(): ParseJsonFunction {
return this._internals.parseJson;
}
set parseJson(value: ParseJsonFunction) {
assert.function_(value);
this._internals.parseJson = value;
}
/**
A function used to stringify the body of JSON requests.
@example
```
import got from 'got';
await got.post('https://example.com', {
stringifyJson: object => JSON.stringify(object, (key, value) => {
if (key.startsWith('_')) {
return;
}
return value;
}),
json: {
some: 'payload',
_ignoreMe: 1234
}
});
```
@example
```
import got from 'got';
await got.post('https://example.com', {
stringifyJson: object => JSON.stringify(object, (key, value) => {
if (typeof value === 'number') {
return value.toString();
}
return value;
}),
json: {
some: 'payload',
number: 1
}
});
```
*/
get stringifyJson(): StringifyJsonFunction {
return this._internals.stringifyJson;
}
set stringifyJson(value: StringifyJsonFunction) {
assert.function_(value);
this._internals.stringifyJson = value;
}
/**
An object representing `limit`, `calculateDelay`, `methods`, `statusCodes`, `maxRetryAfter` and `errorCodes` fields for maximum retry count, retry handler, allowed methods, allowed status codes, maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.
Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 1).
The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
By default, it retries *only* on the specified methods, status codes, and on these network errors:
- `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
- `ECONNRESET`: Connection was forcibly closed by a peer.
- `EADDRINUSE`: Could not bind to any free port.
- `ECONNREFUSED`: Connection was refused by the server.
- `EPIPE`: The remote side of the stream being written has been closed.
- `ENOTFOUND`: Couldn't resolve the hostname to an IP address.
- `ENETUNREACH`: No internet connection.
- `EAI_AGAIN`: DNS lookup timed out.
__Note__: If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.
__Note__: If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
*/
get retry(): Partial<RetryOptions> {
return this._internals.retry;
}
set retry(value: Partial<RetryOptions>) {
assert.plainObject(value);
assert.any([is.function_, is.undefined], value.calculateDelay);
assert.any([is.number, is.undefined], value.maxRetryAfter);
assert.any([is.number, is.undefined], value.limit);
assert.any([is.array, is.undefined], value.methods);
assert.any([is.array, is.undefined], value.statusCodes);
assert.any([is.array, is.undefined], value.errorCodes);
assert.any([is.number, is.undefined], value.noise);
if (value.noise && Math.abs(value.noise) > 100) {
throw new Error(`The maximum acceptable retry noise is +/- 100ms, got ${value.noise}`);
}
for (const key in value) {
if (!(key in this._internals.retry)) {
throw new Error(`Unexpected retry option: ${key}`);
}
}
if (this._merging) {
Object.assign(this._internals.retry, value);
} else {
this._internals.retry = {...value};
}
const {retry} = this._internals;
retry.methods = [...new Set(retry.methods!.map(method => method.toUpperCase() as Method))];
retry.statusCodes = [...new Set(retry.statusCodes)];
retry.errorCodes = [...new Set(retry.errorCodes)];
}
/**
From `http.RequestOptions`.
The IP address used to send the request from.
*/
get localAddress(): string | undefined {
return this._internals.localAddress;
}
set localAddress(value: string | undefined) {
assert.any([is.string, is.undefined], value);
this._internals.localAddress = value;
}
/**
The HTTP method used to make the request.
@default 'GET'
*/
get method(): Method {
return this._internals.method;
}
set method(value: Method) {
assert.string(value);
this._internals.method = value.toUpperCase() as Method;
}
get createConnection(): CreateConnectionFunction | undefined {
return this._internals.createConnection;
}
set createConnection(value: CreateConnectionFunction | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.createConnection = value;
}
/**
From `http-cache-semantics`
@default {}
*/
get cacheOptions(): CacheOptions {
return this._internals.cacheOptions;
}
set cacheOptions(value: CacheOptions) {
assert.plainObject(value);
assert.any([is.boolean, is.undefined], value.shared);
assert.any([is.number, is.undefined], value.cacheHeuristic);
assert.any([is.number, is.undefined], value.immutableMinTimeToLive);
assert.any([is.boolean, is.undefined], value.ignoreCargoCult);
for (const key in value) {
if (!(key in this._internals.cacheOptions)) {
throw new Error(`Cache option \`${key}\` does not exist`);
}
}
if (this._merging) {
Object.assign(this._internals.cacheOptions, value);
} else {
this._internals.cacheOptions = {...value};
}
}
/**
Options for the advanced HTTPS API.
*/
get https(): HttpsOptions {
return this._internals.https;
}
set https(value: HttpsOptions) {
assert.plainObject(value);
assert.any([is.boolean, is.undefined], value.rejectUnauthorized);
assert.any([is.function_, is.undefined], value.checkServerIdentity);
assert.any([is.string, is.object, is.array, is.undefined], value.certificateAuthority);
assert.any([is.string, is.object, is.array, is.undefined], value.key);
assert.any([is.string, is.object, is.array, is.undefined], value.certificate);
assert.any([is.string, is.undefined], value.passphrase);
assert.any([is.string, is.buffer, is.array, is.undefined], value.pfx);
assert.any([is.array, is.undefined], value.alpnProtocols);
assert.any([is.string, is.undefined], value.ciphers);
assert.any([is.string, is.buffer, is.undefined], value.dhparam);
assert.any([is.string, is.undefined], value.signatureAlgorithms);
assert.any([is.string, is.undefined], value.minVersion);
assert.any([is.string, is.undefined], value.maxVersion);
assert.any([is.boolean, is.undefined], value.honorCipherOrder);
assert.any([is.number, is.undefined], value.tlsSessionLifetime);
assert.any([is.string, is.undefined], value.ecdhCurve);
assert.any([is.string, is.buffer, is.array, is.undefined], value.certificateRevocationLists);
for (const key in value) {
if (!(key in this._internals.https)) {
throw new Error(`HTTPS option \`${key}\` does not exist`);
}
}
if (this._merging) {
Object.assign(this._internals.https, value);
} else {
this._internals.https = {...value};
}
}
/**
[Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data.
To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set `responseType` to `buffer` instead.
Don't set this option to `null`.
__Note__: This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
@default 'utf-8'
*/
get encoding(): BufferEncoding | undefined {
return this._internals.encoding;
}
set encoding(value: BufferEncoding | undefined) {
if (value === null) {
throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead');
}
assert.any([is.string, is.undefined], value);
this._internals.encoding = value;
}
/**
When set to `true` the promise will return the Response body instead of the Response object.
@default false
*/
get resolveBodyOnly(): boolean {
return this._internals.resolveBodyOnly;
}
set resolveBodyOnly(value: boolean) {
assert.boolean(value);
this._internals.resolveBodyOnly = value;
}
/**
Returns a `Stream` instead of a `Promise`.
This is equivalent to calling `got.stream(url, options?)`.
@default false
*/
get isStream(): boolean {
return this._internals.isStream;
}
set isStream(value: boolean) {
assert.boolean(value);
this._internals.isStream = value;
}
/**
The parsing method.
The promise also has `.text()`, `.json()` and `.buffer()` methods which return another Got promise for the parsed body.
It's like setting the options to `{responseType: 'json', resolveBodyOnly: true}` but without affecting the main Got promise.
__Note__: When using streams, this option is ignored.
@example
```
const responsePromise = got(url);
const bufferPromise = responsePromise.buffer();
const jsonPromise = responsePromise.json();
const [response, buffer, json] = Promise.all([responsePromise, bufferPromise, jsonPromise]);
// `response` is an instance of Got Response
// `buffer` is an instance of Buffer
// `json` is an object
```
@example
```
// This
const body = await got(url).json();
// is semantically the same as this
const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
```
*/
get responseType(): ResponseType {
return this._internals.responseType;
}
set responseType(value: ResponseType) {
if (value === undefined) {
this._internals.responseType = 'text';
return;
}
if (value !== 'text' && value !== 'buffer' && value !== 'json') {
throw new Error(`Invalid \`responseType\` option: ${value as string}`);
}
this._internals.responseType = value;
}
get pagination(): PaginationOptions<unknown, unknown> {
return this._internals.pagination;
}
set pagination(value: PaginationOptions<unknown, unknown>) {
assert.object(value);
if (this._merging) {
Object.assign(this._internals.pagination, value);
} else {
this._internals.pagination = value;
}
}
get auth() {
throw new Error('Parameter `auth` is deprecated. Use `username` / `password` instead.');
}
set auth(_value: unknown) {
throw new Error('Parameter `auth` is deprecated. Use `username` / `password` instead.');
}
get setHost() {
return this._internals.setHost;
}
set setHost(value: boolean) {
assert.boolean(value);
this._internals.setHost = value;
}
get maxHeaderSize() {
return this._internals.maxHeaderSize;
}
set maxHeaderSize(value: number | undefined) {
assert.any([is.number, is.undefined], value);
this._internals.maxHeaderSize = value;
}
get enableUnixSockets() {
return this._internals.enableUnixSockets;
}
set enableUnixSockets(value: boolean) {
assert.boolean(value);
this._internals.enableUnixSockets = value;
}
// eslint-disable-next-line @typescript-eslint/naming-convention
toJSON() {
return {...this._internals};
}
[Symbol.for('nodejs.util.inspect.custom')](_depth: number, options: InspectOptions) {
return inspect(this._internals, options);
}
createNativeRequestOptions() {
const internals = this._internals;
const url = internals.url as URL;
let agent;
if (url.protocol === 'https:') {
agent = internals.http2 ? internals.agent : internals.agent.https;
} else {
agent = internals.agent.http;
}
const {https} = internals;
let {pfx} = https;
if (is.array(pfx) && is.plainObject(pfx[0])) {
pfx = (pfx as PfxObject[]).map(object => ({
buf: object.buffer,
passphrase: object.passphrase,
})) as any;
}
return {
...internals.cacheOptions,
...this._unixOptions,
// HTTPS options
// eslint-disable-next-line @typescript-eslint/naming-convention
ALPNProtocols: https.alpnProtocols,
ca: https.certificateAuthority,
cert: https.certificate,
key: https.key,
passphrase: https.passphrase,
pfx: https.pfx,
rejectUnauthorized: https.rejectUnauthorized,
checkServerIdentity: https.checkServerIdentity ?? checkServerIdentity,
ciphers: https.ciphers,
honorCipherOrder: https.honorCipherOrder,
minVersion: https.minVersion,
maxVersion: https.maxVersion,
sigalgs: https.signatureAlgorithms,
sessionTimeout: https.tlsSessionLifetime,
dhparam: https.dhparam,
ecdhCurve: https.ecdhCurve,
crl: https.certificateRevocationLists,
// HTTP options
lookup: internals.dnsLookup ?? (internals.dnsCache as CacheableLookup | undefined)?.lookup,
family: internals.dnsLookupIpVersion,
agent,
setHost: internals.setHost,
method: internals.method,
maxHeaderSize: internals.maxHeaderSize,
localAddress: internals.localAddress,
headers: internals.headers,
createConnection: internals.createConnection,
timeout: internals.http2 ? getHttp2TimeoutOption(internals) : undefined,
// HTTP/2 options
h2session: internals.h2session,
};
}
getRequestFunction() {
const url = this._internals.url as (URL | undefined);
const {request} = this._internals;
if (!request && url) {
return this.getFallbackRequestFunction();
}
return request;
}
getFallbackRequestFunction() {
const url = this._internals.url as (URL | undefined);
if (!url) {
return;
}
if (url.protocol === 'https:') {
if (this._internals.http2) {
if (major < 15 || (major === 15 && minor < 10)) {
const error = new Error('To use the `http2` option, install Node.js 15.10.0 or above');
(error as NodeJS.ErrnoException).code = 'EUNSUPPORTED';
throw error;
}
return http2wrapper.auto as RequestFunction;
}
return https.request;
}
return http.request;
}
freeze() {
const options = this._internals;
Object.freeze(options);
Object.freeze(options.hooks);
Object.freeze(options.hooks.afterResponse);
Object.freeze(options.hooks.beforeError);
Object.freeze(options.hooks.beforeRedirect);
Object.freeze(options.hooks.beforeRequest);
Object.freeze(options.hooks.beforeRetry);
Object.freeze(options.hooks.init);
Object.freeze(options.https);
Object.freeze(options.cacheOptions);
Object.freeze(options.agent);
Object.freeze(options.headers);
Object.freeze(options.timeout);
Object.freeze(options.retry);
Object.freeze(options.retry.errorCodes);
Object.freeze(options.retry.methods);
Object.freeze(options.retry.statusCodes);
}
} |
414 | (options: Options) => Promisable<void | Response | ResponseLike> | class Options {
private _unixOptions?: NativeRequestOptions;
private _internals: InternalsType;
private _merging: boolean;
private readonly _init: OptionsInit[];
constructor(input?: string | URL | OptionsInit, options?: OptionsInit, defaults?: Options) {
assert.any([is.string, is.urlInstance, is.object, is.undefined], input);
assert.any([is.object, is.undefined], options);
assert.any([is.object, is.undefined], defaults);
if (input instanceof Options || options instanceof Options) {
throw new TypeError('The defaults must be passed as the third argument');
}
this._internals = cloneInternals(defaults?._internals ?? defaults ?? defaultInternals);
this._init = [...(defaults?._init ?? [])];
this._merging = false;
this._unixOptions = undefined;
// This rule allows `finally` to be considered more important.
// Meaning no matter the error thrown in the `try` block,
// if `finally` throws then the `finally` error will be thrown.
//
// Yes, we want this. If we set `url` first, then the `url.searchParams`
// would get merged. Instead we set the `searchParams` first, then
// `url.searchParams` is overwritten as expected.
//
/* eslint-disable no-unsafe-finally */
try {
if (is.plainObject(input)) {
try {
this.merge(input);
this.merge(options);
} finally {
this.url = input.url;
}
} else {
try {
this.merge(options);
} finally {
if (options?.url !== undefined) {
if (input === undefined) {
this.url = options.url;
} else {
throw new TypeError('The `url` option is mutually exclusive with the `input` argument');
}
} else if (input !== undefined) {
this.url = input;
}
}
}
} catch (error) {
(error as OptionsError).options = this;
throw error;
}
/* eslint-enable no-unsafe-finally */
}
merge(options?: OptionsInit | Options) {
if (!options) {
return;
}
if (options instanceof Options) {
for (const init of options._init) {
this.merge(init);
}
return;
}
options = cloneRaw(options);
init(this, options, this);
init(options, options, this);
this._merging = true;
// Always merge `isStream` first
if ('isStream' in options) {
this.isStream = options.isStream!;
}
try {
let push = false;
for (const key in options) {
// `got.extend()` options
if (key === 'mutableDefaults' || key === 'handlers') {
continue;
}
// Never merge `url`
if (key === 'url') {
continue;
}
if (!(key in this)) {
throw new Error(`Unexpected option: ${key}`);
}
// @ts-expect-error Type 'unknown' is not assignable to type 'never'.
this[key as keyof Options] = options[key as keyof Options];
push = true;
}
if (push) {
this._init.push(options);
}
} finally {
this._merging = false;
}
}
/**
Custom request function.
The main purpose of this is to [support HTTP2 using a wrapper](https://github.com/szmarczak/http2-wrapper).
@default http.request | https.request
*/
get request(): RequestFunction | undefined {
return this._internals.request;
}
set request(value: RequestFunction | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.request = value;
}
/**
An object representing `http`, `https` and `http2` keys for [`http.Agent`](https://nodejs.org/api/http.html#http_class_http_agent), [`https.Agent`](https://nodejs.org/api/https.html#https_class_https_agent) and [`http2wrapper.Agent`](https://github.com/szmarczak/http2-wrapper#new-http2agentoptions) instance.
This is necessary because a request to one protocol might redirect to another.
In such a scenario, Got will switch over to the right protocol agent for you.
If a key is not present, it will default to a global agent.
@example
```
import got from 'got';
import HttpAgent from 'agentkeepalive';
const {HttpsAgent} = HttpAgent;
await got('https://sindresorhus.com', {
agent: {
http: new HttpAgent(),
https: new HttpsAgent()
}
});
```
*/
get agent(): Agents {
return this._internals.agent;
}
set agent(value: Agents) {
assert.plainObject(value);
// eslint-disable-next-line guard-for-in
for (const key in value) {
if (!(key in this._internals.agent)) {
throw new TypeError(`Unexpected agent option: ${key}`);
}
// @ts-expect-error - No idea why `value[key]` doesn't work here.
assert.any([is.object, is.undefined], value[key]);
}
if (this._merging) {
Object.assign(this._internals.agent, value);
} else {
this._internals.agent = {...value};
}
}
get h2session(): ClientHttp2Session | undefined {
return this._internals.h2session;
}
set h2session(value: ClientHttp2Session | undefined) {
this._internals.h2session = value;
}
/**
Decompress the response automatically.
This will set the `accept-encoding` header to `gzip, deflate, br` unless you set it yourself.
If this is disabled, a compressed response is returned as a `Buffer`.
This may be useful if you want to handle decompression yourself or stream the raw compressed data.
@default true
*/
get decompress(): boolean {
return this._internals.decompress;
}
set decompress(value: boolean) {
assert.boolean(value);
this._internals.decompress = value;
}
/**
Milliseconds to wait for the server to end the response before aborting the request with `got.TimeoutError` error (a.k.a. `request` property).
By default, there's no timeout.
This also accepts an `object` with the following fields to constrain the duration of each phase of the request lifecycle:
- `lookup` starts when a socket is assigned and ends when the hostname has been resolved.
Does not apply when using a Unix domain socket.
- `connect` starts when `lookup` completes (or when the socket is assigned if lookup does not apply to the request) and ends when the socket is connected.
- `secureConnect` starts when `connect` completes and ends when the handshaking process completes (HTTPS only).
- `socket` starts when the socket is connected. See [request.setTimeout](https://nodejs.org/api/http.html#http_request_settimeout_timeout_callback).
- `response` starts when the request has been written to the socket and ends when the response headers are received.
- `send` starts when the socket is connected and ends with the request has been written to the socket.
- `request` starts when the request is initiated and ends when the response's end event fires.
*/
get timeout(): Delays {
// We always return `Delays` here.
// It has to be `Delays | number`, otherwise TypeScript will error because the getter and the setter have incompatible types.
return this._internals.timeout;
}
set timeout(value: Delays) {
assert.plainObject(value);
// eslint-disable-next-line guard-for-in
for (const key in value) {
if (!(key in this._internals.timeout)) {
throw new Error(`Unexpected timeout option: ${key}`);
}
// @ts-expect-error - No idea why `value[key]` doesn't work here.
assert.any([is.number, is.undefined], value[key]);
}
if (this._merging) {
Object.assign(this._internals.timeout, value);
} else {
this._internals.timeout = {...value};
}
}
/**
When specified, `prefixUrl` will be prepended to `url`.
The prefix can be any valid URL, either relative or absolute.
A trailing slash `/` is optional - one will be added automatically.
__Note__: `prefixUrl` will be ignored if the `url` argument is a URL instance.
__Note__: Leading slashes in `input` are disallowed when using this option to enforce consistency and avoid confusion.
For example, when the prefix URL is `https://example.com/foo` and the input is `/bar`, there's ambiguity whether the resulting URL would become `https://example.com/foo/bar` or `https://example.com/bar`.
The latter is used by browsers.
__Tip__: Useful when used with `got.extend()` to create niche-specific Got instances.
__Tip__: You can change `prefixUrl` using hooks as long as the URL still includes the `prefixUrl`.
If the URL doesn't include it anymore, it will throw.
@example
```
import got from 'got';
await got('unicorn', {prefixUrl: 'https://cats.com'});
//=> 'https://cats.com/unicorn'
const instance = got.extend({
prefixUrl: 'https://google.com'
});
await instance('unicorn', {
hooks: {
beforeRequest: [
options => {
options.prefixUrl = 'https://cats.com';
}
]
}
});
//=> 'https://cats.com/unicorn'
```
*/
get prefixUrl(): string | URL {
// We always return `string` here.
// It has to be `string | URL`, otherwise TypeScript will error because the getter and the setter have incompatible types.
return this._internals.prefixUrl;
}
set prefixUrl(value: string | URL) {
assert.any([is.string, is.urlInstance], value);
if (value === '') {
this._internals.prefixUrl = '';
return;
}
value = value.toString();
if (!value.endsWith('/')) {
value += '/';
}
if (this._internals.prefixUrl && this._internals.url) {
const {href} = this._internals.url as URL;
(this._internals.url as URL).href = value + href.slice((this._internals.prefixUrl as string).length);
}
this._internals.prefixUrl = value;
}
/**
__Note #1__: The `body` option cannot be used with the `json` or `form` option.
__Note #2__: If you provide this option, `got.stream()` will be read-only.
__Note #3__: If you provide a payload with the `GET` or `HEAD` method, it will throw a `TypeError` unless the method is `GET` and the `allowGetBody` option is set to `true`.
__Note #4__: This option is not enumerable and will not be merged with the instance defaults.
The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
Since Got 12, the `content-length` is not automatically set when `body` is a `fs.createReadStream`.
*/
get body(): string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined {
return this._internals.body;
}
set body(value: string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined) {
assert.any([is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, isFormData, is.undefined], value);
if (is.nodeStream(value)) {
assert.truthy(value.readable);
}
if (value !== undefined) {
assert.undefined(this._internals.form);
assert.undefined(this._internals.json);
}
this._internals.body = value;
}
/**
The form body is converted to a query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
If the `Content-Type` header is not present, it will be set to `application/x-www-form-urlencoded`.
__Note #1__: If you provide this option, `got.stream()` will be read-only.
__Note #2__: This option is not enumerable and will not be merged with the instance defaults.
*/
get form(): Record<string, any> | undefined {
return this._internals.form;
}
set form(value: Record<string, any> | undefined) {
assert.any([is.plainObject, is.undefined], value);
if (value !== undefined) {
assert.undefined(this._internals.body);
assert.undefined(this._internals.json);
}
this._internals.form = value;
}
/**
JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
__Note #1__: If you provide this option, `got.stream()` will be read-only.
__Note #2__: This option is not enumerable and will not be merged with the instance defaults.
*/
get json(): unknown {
return this._internals.json;
}
set json(value: unknown) {
if (value !== undefined) {
assert.undefined(this._internals.body);
assert.undefined(this._internals.form);
}
this._internals.json = value;
}
/**
The URL to request, as a string, a [`https.request` options object](https://nodejs.org/api/https.html#https_https_request_options_callback), or a [WHATWG `URL`](https://nodejs.org/api/url.html#url_class_url).
Properties from `options` will override properties in the parsed `url`.
If no protocol is specified, it will throw a `TypeError`.
__Note__: The query string is **not** parsed as search params.
@example
```
await got('https://example.com/?query=a b'); //=> https://example.com/?query=a%20b
await got('https://example.com/', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
// The query string is overridden by `searchParams`
await got('https://example.com/?query=a b', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
```
*/
get url(): string | URL | undefined {
return this._internals.url;
}
set url(value: string | URL | undefined) {
assert.any([is.string, is.urlInstance, is.undefined], value);
if (value === undefined) {
this._internals.url = undefined;
return;
}
if (is.string(value) && value.startsWith('/')) {
throw new Error('`url` must not start with a slash');
}
const urlString = `${this.prefixUrl as string}${value.toString()}`;
const url = new URL(urlString);
this._internals.url = url;
if (url.protocol === 'unix:') {
url.href = `http://unix${url.pathname}${url.search}`;
}
if (url.protocol !== 'http:' && url.protocol !== 'https:') {
const error: NodeJS.ErrnoException = new Error(`Unsupported protocol: ${url.protocol}`);
error.code = 'ERR_UNSUPPORTED_PROTOCOL';
throw error;
}
if (this._internals.username) {
url.username = this._internals.username;
this._internals.username = '';
}
if (this._internals.password) {
url.password = this._internals.password;
this._internals.password = '';
}
if (this._internals.searchParams) {
url.search = (this._internals.searchParams as URLSearchParams).toString();
this._internals.searchParams = undefined;
}
if (url.hostname === 'unix') {
if (!this._internals.enableUnixSockets) {
throw new Error('Using UNIX domain sockets but option `enableUnixSockets` is not enabled');
}
const matches = /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`);
if (matches?.groups) {
const {socketPath, path} = matches.groups;
this._unixOptions = {
socketPath,
path,
host: '',
};
} else {
this._unixOptions = undefined;
}
return;
}
this._unixOptions = undefined;
}
/**
Cookie support. You don't have to care about parsing or how to store them.
__Note__: If you provide this option, `options.headers.cookie` will be overridden.
*/
get cookieJar(): PromiseCookieJar | ToughCookieJar | undefined {
return this._internals.cookieJar;
}
set cookieJar(value: PromiseCookieJar | ToughCookieJar | undefined) {
assert.any([is.object, is.undefined], value);
if (value === undefined) {
this._internals.cookieJar = undefined;
return;
}
let {setCookie, getCookieString} = value;
assert.function_(setCookie);
assert.function_(getCookieString);
/* istanbul ignore next: Horrible `tough-cookie` v3 check */
if (setCookie.length === 4 && getCookieString.length === 0) {
setCookie = promisify(setCookie.bind(value));
getCookieString = promisify(getCookieString.bind(value));
this._internals.cookieJar = {
setCookie,
getCookieString: getCookieString as PromiseCookieJar['getCookieString'],
};
} else {
this._internals.cookieJar = value;
}
}
/**
You can abort the `request` using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
*Requires Node.js 16 or later.*
@example
```
import got from 'got';
const abortController = new AbortController();
const request = got('https://httpbin.org/anything', {
signal: abortController.signal
});
setTimeout(() => {
abortController.abort();
}, 100);
```
*/
// TODO: Replace `any` with `AbortSignal` when targeting Node 16.
get signal(): any | undefined {
return this._internals.signal;
}
// TODO: Replace `any` with `AbortSignal` when targeting Node 16.
set signal(value: any | undefined) {
assert.object(value);
this._internals.signal = value;
}
/**
Ignore invalid cookies instead of throwing an error.
Only useful when the `cookieJar` option has been set. Not recommended.
@default false
*/
get ignoreInvalidCookies(): boolean {
return this._internals.ignoreInvalidCookies;
}
set ignoreInvalidCookies(value: boolean) {
assert.boolean(value);
this._internals.ignoreInvalidCookies = value;
}
/**
Query string that will be added to the request URL.
This will override the query string in `url`.
If you need to pass in an array, you can do it using a `URLSearchParams` instance.
@example
```
import got from 'got';
const searchParams = new URLSearchParams([['key', 'a'], ['key', 'b']]);
await got('https://example.com', {searchParams});
console.log(searchParams.toString());
//=> 'key=a&key=b'
```
*/
get searchParams(): string | SearchParameters | URLSearchParams | undefined {
if (this._internals.url) {
return (this._internals.url as URL).searchParams;
}
if (this._internals.searchParams === undefined) {
this._internals.searchParams = new URLSearchParams();
}
return this._internals.searchParams;
}
set searchParams(value: string | SearchParameters | URLSearchParams | undefined) {
assert.any([is.string, is.object, is.undefined], value);
const url = this._internals.url as URL;
if (value === undefined) {
this._internals.searchParams = undefined;
if (url) {
url.search = '';
}
return;
}
const searchParameters = this.searchParams as URLSearchParams;
let updated;
if (is.string(value)) {
updated = new URLSearchParams(value);
} else if (value instanceof URLSearchParams) {
updated = value;
} else {
validateSearchParameters(value);
updated = new URLSearchParams();
// eslint-disable-next-line guard-for-in
for (const key in value) {
const entry = value[key];
if (entry === null) {
updated.append(key, '');
} else if (entry === undefined) {
searchParameters.delete(key);
} else {
updated.append(key, entry as string);
}
}
}
if (this._merging) {
// These keys will be replaced
for (const key of updated.keys()) {
searchParameters.delete(key);
}
for (const [key, value] of updated) {
searchParameters.append(key, value);
}
} else if (url) {
url.search = searchParameters.toString();
} else {
this._internals.searchParams = searchParameters;
}
}
get searchParameters() {
throw new Error('The `searchParameters` option does not exist. Use `searchParams` instead.');
}
set searchParameters(_value: unknown) {
throw new Error('The `searchParameters` option does not exist. Use `searchParams` instead.');
}
get dnsLookup(): CacheableLookup['lookup'] | undefined {
return this._internals.dnsLookup;
}
set dnsLookup(value: CacheableLookup['lookup'] | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.dnsLookup = value;
}
/**
An instance of [`CacheableLookup`](https://github.com/szmarczak/cacheable-lookup) used for making DNS lookups.
Useful when making lots of requests to different *public* hostnames.
`CacheableLookup` uses `dns.resolver4(..)` and `dns.resolver6(...)` under the hood and fall backs to `dns.lookup(...)` when the first two fail, which may lead to additional delay.
__Note__: This should stay disabled when making requests to internal hostnames such as `localhost`, `database.local` etc.
@default false
*/
get dnsCache(): CacheableLookup | boolean | undefined {
return this._internals.dnsCache;
}
set dnsCache(value: CacheableLookup | boolean | undefined) {
assert.any([is.object, is.boolean, is.undefined], value);
if (value === true) {
this._internals.dnsCache = getGlobalDnsCache();
} else if (value === false) {
this._internals.dnsCache = undefined;
} else {
this._internals.dnsCache = value;
}
}
/**
User data. `context` is shallow merged and enumerable. If it contains non-enumerable properties they will NOT be merged.
@example
```
import got from 'got';
const instance = got.extend({
hooks: {
beforeRequest: [
options => {
if (!options.context || !options.context.token) {
throw new Error('Token required');
}
options.headers.token = options.context.token;
}
]
}
});
const context = {
token: 'secret'
};
const response = await instance('https://httpbin.org/headers', {context});
// Let's see the headers
console.log(response.body);
```
*/
get context(): Record<string, unknown> {
return this._internals.context;
}
set context(value: Record<string, unknown>) {
assert.object(value);
if (this._merging) {
Object.assign(this._internals.context, value);
} else {
this._internals.context = {...value};
}
}
/**
Hooks allow modifications during the request lifecycle.
Hook functions may be async and are run serially.
*/
get hooks(): Hooks {
return this._internals.hooks;
}
set hooks(value: Hooks) {
assert.object(value);
// eslint-disable-next-line guard-for-in
for (const knownHookEvent in value) {
if (!(knownHookEvent in this._internals.hooks)) {
throw new Error(`Unexpected hook event: ${knownHookEvent}`);
}
const typedKnownHookEvent = knownHookEvent as keyof Hooks;
const hooks = value[typedKnownHookEvent];
assert.any([is.array, is.undefined], hooks);
if (hooks) {
for (const hook of hooks) {
assert.function_(hook);
}
}
if (this._merging) {
if (hooks) {
// @ts-expect-error FIXME
this._internals.hooks[typedKnownHookEvent].push(...hooks);
}
} else {
if (!hooks) {
throw new Error(`Missing hook event: ${knownHookEvent}`);
}
// @ts-expect-error FIXME
this._internals.hooks[knownHookEvent] = [...hooks];
}
}
}
/**
Defines if redirect responses should be followed automatically.
Note that if a `303` is sent by the server in response to any request type (`POST`, `DELETE`, etc.), Got will automatically request the resource pointed to in the location header via `GET`.
This is in accordance with [the spec](https://tools.ietf.org/html/rfc7231#section-6.4.4). You can optionally turn on this behavior also for other redirect codes - see `methodRewriting`.
@default true
*/
get followRedirect(): boolean {
return this._internals.followRedirect;
}
set followRedirect(value: boolean) {
assert.boolean(value);
this._internals.followRedirect = value;
}
get followRedirects() {
throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
}
set followRedirects(_value: unknown) {
throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
}
/**
If exceeded, the request will be aborted and a `MaxRedirectsError` will be thrown.
@default 10
*/
get maxRedirects(): number {
return this._internals.maxRedirects;
}
set maxRedirects(value: number) {
assert.number(value);
this._internals.maxRedirects = value;
}
/**
A cache adapter instance for storing cached response data.
@default false
*/
get cache(): string | StorageAdapter | boolean | undefined {
return this._internals.cache;
}
set cache(value: string | StorageAdapter | boolean | undefined) {
assert.any([is.object, is.string, is.boolean, is.undefined], value);
if (value === true) {
this._internals.cache = globalCache;
} else if (value === false) {
this._internals.cache = undefined;
} else {
this._internals.cache = value;
}
}
/**
Determines if a `got.HTTPError` is thrown for unsuccessful responses.
If this is disabled, requests that encounter an error status code will be resolved with the `response` instead of throwing.
This may be useful if you are checking for resource availability and are expecting error responses.
@default true
*/
get throwHttpErrors(): boolean {
return this._internals.throwHttpErrors;
}
set throwHttpErrors(value: boolean) {
assert.boolean(value);
this._internals.throwHttpErrors = value;
}
get username(): string {
const url = this._internals.url as URL;
const value = url ? url.username : this._internals.username;
return decodeURIComponent(value);
}
set username(value: string) {
assert.string(value);
const url = this._internals.url as URL;
const fixedValue = encodeURIComponent(value);
if (url) {
url.username = fixedValue;
} else {
this._internals.username = fixedValue;
}
}
get password(): string {
const url = this._internals.url as URL;
const value = url ? url.password : this._internals.password;
return decodeURIComponent(value);
}
set password(value: string) {
assert.string(value);
const url = this._internals.url as URL;
const fixedValue = encodeURIComponent(value);
if (url) {
url.password = fixedValue;
} else {
this._internals.password = fixedValue;
}
}
/**
If set to `true`, Got will additionally accept HTTP2 requests.
It will choose either HTTP/1.1 or HTTP/2 depending on the ALPN protocol.
__Note__: This option requires Node.js 15.10.0 or newer as HTTP/2 support on older Node.js versions is very buggy.
__Note__: Overriding `options.request` will disable HTTP2 support.
@default false
@example
```
import got from 'got';
const {headers} = await got('https://nghttp2.org/httpbin/anything', {http2: true});
console.log(headers.via);
//=> '2 nghttpx'
```
*/
get http2(): boolean {
return this._internals.http2;
}
set http2(value: boolean) {
assert.boolean(value);
this._internals.http2 = value;
}
/**
Set this to `true` to allow sending body for the `GET` method.
However, the [HTTP/2 specification](https://tools.ietf.org/html/rfc7540#section-8.1.3) says that `An HTTP GET request includes request header fields and no payload body`, therefore when using the HTTP/2 protocol this option will have no effect.
This option is only meant to interact with non-compliant servers when you have no other choice.
__Note__: The [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.1) doesn't specify any particular behavior for the GET method having a payload, therefore __it's considered an [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern)__.
@default false
*/
get allowGetBody(): boolean {
return this._internals.allowGetBody;
}
set allowGetBody(value: boolean) {
assert.boolean(value);
this._internals.allowGetBody = value;
}
/**
Request headers.
Existing headers will be overwritten. Headers set to `undefined` will be omitted.
@default {}
*/
get headers(): Headers {
return this._internals.headers;
}
set headers(value: Headers) {
assert.plainObject(value);
if (this._merging) {
Object.assign(this._internals.headers, lowercaseKeys(value));
} else {
this._internals.headers = lowercaseKeys(value);
}
}
/**
Specifies if the HTTP request method should be [rewritten as `GET`](https://tools.ietf.org/html/rfc7231#section-6.4) on redirects.
As the [specification](https://tools.ietf.org/html/rfc7231#section-6.4) prefers to rewrite the HTTP method only on `303` responses, this is Got's default behavior.
Setting `methodRewriting` to `true` will also rewrite `301` and `302` responses, as allowed by the spec. This is the behavior followed by `curl` and browsers.
__Note__: Got never performs method rewriting on `307` and `308` responses, as this is [explicitly prohibited by the specification](https://www.rfc-editor.org/rfc/rfc7231#section-6.4.7).
@default false
*/
get methodRewriting(): boolean {
return this._internals.methodRewriting;
}
set methodRewriting(value: boolean) {
assert.boolean(value);
this._internals.methodRewriting = value;
}
/**
Indicates which DNS record family to use.
Values:
- `undefined`: IPv4 (if present) or IPv6
- `4`: Only IPv4
- `6`: Only IPv6
@default undefined
*/
get dnsLookupIpVersion(): DnsLookupIpVersion {
return this._internals.dnsLookupIpVersion;
}
set dnsLookupIpVersion(value: DnsLookupIpVersion) {
if (value !== undefined && value !== 4 && value !== 6) {
throw new TypeError(`Invalid DNS lookup IP version: ${value as string}`);
}
this._internals.dnsLookupIpVersion = value;
}
/**
A function used to parse JSON responses.
@example
```
import got from 'got';
import Bourne from '@hapi/bourne';
const parsed = await got('https://example.com', {
parseJson: text => Bourne.parse(text)
}).json();
console.log(parsed);
```
*/
get parseJson(): ParseJsonFunction {
return this._internals.parseJson;
}
set parseJson(value: ParseJsonFunction) {
assert.function_(value);
this._internals.parseJson = value;
}
/**
A function used to stringify the body of JSON requests.
@example
```
import got from 'got';
await got.post('https://example.com', {
stringifyJson: object => JSON.stringify(object, (key, value) => {
if (key.startsWith('_')) {
return;
}
return value;
}),
json: {
some: 'payload',
_ignoreMe: 1234
}
});
```
@example
```
import got from 'got';
await got.post('https://example.com', {
stringifyJson: object => JSON.stringify(object, (key, value) => {
if (typeof value === 'number') {
return value.toString();
}
return value;
}),
json: {
some: 'payload',
number: 1
}
});
```
*/
get stringifyJson(): StringifyJsonFunction {
return this._internals.stringifyJson;
}
set stringifyJson(value: StringifyJsonFunction) {
assert.function_(value);
this._internals.stringifyJson = value;
}
/**
An object representing `limit`, `calculateDelay`, `methods`, `statusCodes`, `maxRetryAfter` and `errorCodes` fields for maximum retry count, retry handler, allowed methods, allowed status codes, maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.
Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 1).
The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
By default, it retries *only* on the specified methods, status codes, and on these network errors:
- `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
- `ECONNRESET`: Connection was forcibly closed by a peer.
- `EADDRINUSE`: Could not bind to any free port.
- `ECONNREFUSED`: Connection was refused by the server.
- `EPIPE`: The remote side of the stream being written has been closed.
- `ENOTFOUND`: Couldn't resolve the hostname to an IP address.
- `ENETUNREACH`: No internet connection.
- `EAI_AGAIN`: DNS lookup timed out.
__Note__: If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.
__Note__: If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
*/
get retry(): Partial<RetryOptions> {
return this._internals.retry;
}
set retry(value: Partial<RetryOptions>) {
assert.plainObject(value);
assert.any([is.function_, is.undefined], value.calculateDelay);
assert.any([is.number, is.undefined], value.maxRetryAfter);
assert.any([is.number, is.undefined], value.limit);
assert.any([is.array, is.undefined], value.methods);
assert.any([is.array, is.undefined], value.statusCodes);
assert.any([is.array, is.undefined], value.errorCodes);
assert.any([is.number, is.undefined], value.noise);
if (value.noise && Math.abs(value.noise) > 100) {
throw new Error(`The maximum acceptable retry noise is +/- 100ms, got ${value.noise}`);
}
for (const key in value) {
if (!(key in this._internals.retry)) {
throw new Error(`Unexpected retry option: ${key}`);
}
}
if (this._merging) {
Object.assign(this._internals.retry, value);
} else {
this._internals.retry = {...value};
}
const {retry} = this._internals;
retry.methods = [...new Set(retry.methods!.map(method => method.toUpperCase() as Method))];
retry.statusCodes = [...new Set(retry.statusCodes)];
retry.errorCodes = [...new Set(retry.errorCodes)];
}
/**
From `http.RequestOptions`.
The IP address used to send the request from.
*/
get localAddress(): string | undefined {
return this._internals.localAddress;
}
set localAddress(value: string | undefined) {
assert.any([is.string, is.undefined], value);
this._internals.localAddress = value;
}
/**
The HTTP method used to make the request.
@default 'GET'
*/
get method(): Method {
return this._internals.method;
}
set method(value: Method) {
assert.string(value);
this._internals.method = value.toUpperCase() as Method;
}
get createConnection(): CreateConnectionFunction | undefined {
return this._internals.createConnection;
}
set createConnection(value: CreateConnectionFunction | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.createConnection = value;
}
/**
From `http-cache-semantics`
@default {}
*/
get cacheOptions(): CacheOptions {
return this._internals.cacheOptions;
}
set cacheOptions(value: CacheOptions) {
assert.plainObject(value);
assert.any([is.boolean, is.undefined], value.shared);
assert.any([is.number, is.undefined], value.cacheHeuristic);
assert.any([is.number, is.undefined], value.immutableMinTimeToLive);
assert.any([is.boolean, is.undefined], value.ignoreCargoCult);
for (const key in value) {
if (!(key in this._internals.cacheOptions)) {
throw new Error(`Cache option \`${key}\` does not exist`);
}
}
if (this._merging) {
Object.assign(this._internals.cacheOptions, value);
} else {
this._internals.cacheOptions = {...value};
}
}
/**
Options for the advanced HTTPS API.
*/
get https(): HttpsOptions {
return this._internals.https;
}
set https(value: HttpsOptions) {
assert.plainObject(value);
assert.any([is.boolean, is.undefined], value.rejectUnauthorized);
assert.any([is.function_, is.undefined], value.checkServerIdentity);
assert.any([is.string, is.object, is.array, is.undefined], value.certificateAuthority);
assert.any([is.string, is.object, is.array, is.undefined], value.key);
assert.any([is.string, is.object, is.array, is.undefined], value.certificate);
assert.any([is.string, is.undefined], value.passphrase);
assert.any([is.string, is.buffer, is.array, is.undefined], value.pfx);
assert.any([is.array, is.undefined], value.alpnProtocols);
assert.any([is.string, is.undefined], value.ciphers);
assert.any([is.string, is.buffer, is.undefined], value.dhparam);
assert.any([is.string, is.undefined], value.signatureAlgorithms);
assert.any([is.string, is.undefined], value.minVersion);
assert.any([is.string, is.undefined], value.maxVersion);
assert.any([is.boolean, is.undefined], value.honorCipherOrder);
assert.any([is.number, is.undefined], value.tlsSessionLifetime);
assert.any([is.string, is.undefined], value.ecdhCurve);
assert.any([is.string, is.buffer, is.array, is.undefined], value.certificateRevocationLists);
for (const key in value) {
if (!(key in this._internals.https)) {
throw new Error(`HTTPS option \`${key}\` does not exist`);
}
}
if (this._merging) {
Object.assign(this._internals.https, value);
} else {
this._internals.https = {...value};
}
}
/**
[Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data.
To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set `responseType` to `buffer` instead.
Don't set this option to `null`.
__Note__: This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
@default 'utf-8'
*/
get encoding(): BufferEncoding | undefined {
return this._internals.encoding;
}
set encoding(value: BufferEncoding | undefined) {
if (value === null) {
throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead');
}
assert.any([is.string, is.undefined], value);
this._internals.encoding = value;
}
/**
When set to `true` the promise will return the Response body instead of the Response object.
@default false
*/
get resolveBodyOnly(): boolean {
return this._internals.resolveBodyOnly;
}
set resolveBodyOnly(value: boolean) {
assert.boolean(value);
this._internals.resolveBodyOnly = value;
}
/**
Returns a `Stream` instead of a `Promise`.
This is equivalent to calling `got.stream(url, options?)`.
@default false
*/
get isStream(): boolean {
return this._internals.isStream;
}
set isStream(value: boolean) {
assert.boolean(value);
this._internals.isStream = value;
}
/**
The parsing method.
The promise also has `.text()`, `.json()` and `.buffer()` methods which return another Got promise for the parsed body.
It's like setting the options to `{responseType: 'json', resolveBodyOnly: true}` but without affecting the main Got promise.
__Note__: When using streams, this option is ignored.
@example
```
const responsePromise = got(url);
const bufferPromise = responsePromise.buffer();
const jsonPromise = responsePromise.json();
const [response, buffer, json] = Promise.all([responsePromise, bufferPromise, jsonPromise]);
// `response` is an instance of Got Response
// `buffer` is an instance of Buffer
// `json` is an object
```
@example
```
// This
const body = await got(url).json();
// is semantically the same as this
const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
```
*/
get responseType(): ResponseType {
return this._internals.responseType;
}
set responseType(value: ResponseType) {
if (value === undefined) {
this._internals.responseType = 'text';
return;
}
if (value !== 'text' && value !== 'buffer' && value !== 'json') {
throw new Error(`Invalid \`responseType\` option: ${value as string}`);
}
this._internals.responseType = value;
}
get pagination(): PaginationOptions<unknown, unknown> {
return this._internals.pagination;
}
set pagination(value: PaginationOptions<unknown, unknown>) {
assert.object(value);
if (this._merging) {
Object.assign(this._internals.pagination, value);
} else {
this._internals.pagination = value;
}
}
get auth() {
throw new Error('Parameter `auth` is deprecated. Use `username` / `password` instead.');
}
set auth(_value: unknown) {
throw new Error('Parameter `auth` is deprecated. Use `username` / `password` instead.');
}
get setHost() {
return this._internals.setHost;
}
set setHost(value: boolean) {
assert.boolean(value);
this._internals.setHost = value;
}
get maxHeaderSize() {
return this._internals.maxHeaderSize;
}
set maxHeaderSize(value: number | undefined) {
assert.any([is.number, is.undefined], value);
this._internals.maxHeaderSize = value;
}
get enableUnixSockets() {
return this._internals.enableUnixSockets;
}
set enableUnixSockets(value: boolean) {
assert.boolean(value);
this._internals.enableUnixSockets = value;
}
// eslint-disable-next-line @typescript-eslint/naming-convention
toJSON() {
return {...this._internals};
}
[Symbol.for('nodejs.util.inspect.custom')](_depth: number, options: InspectOptions) {
return inspect(this._internals, options);
}
createNativeRequestOptions() {
const internals = this._internals;
const url = internals.url as URL;
let agent;
if (url.protocol === 'https:') {
agent = internals.http2 ? internals.agent : internals.agent.https;
} else {
agent = internals.agent.http;
}
const {https} = internals;
let {pfx} = https;
if (is.array(pfx) && is.plainObject(pfx[0])) {
pfx = (pfx as PfxObject[]).map(object => ({
buf: object.buffer,
passphrase: object.passphrase,
})) as any;
}
return {
...internals.cacheOptions,
...this._unixOptions,
// HTTPS options
// eslint-disable-next-line @typescript-eslint/naming-convention
ALPNProtocols: https.alpnProtocols,
ca: https.certificateAuthority,
cert: https.certificate,
key: https.key,
passphrase: https.passphrase,
pfx: https.pfx,
rejectUnauthorized: https.rejectUnauthorized,
checkServerIdentity: https.checkServerIdentity ?? checkServerIdentity,
ciphers: https.ciphers,
honorCipherOrder: https.honorCipherOrder,
minVersion: https.minVersion,
maxVersion: https.maxVersion,
sigalgs: https.signatureAlgorithms,
sessionTimeout: https.tlsSessionLifetime,
dhparam: https.dhparam,
ecdhCurve: https.ecdhCurve,
crl: https.certificateRevocationLists,
// HTTP options
lookup: internals.dnsLookup ?? (internals.dnsCache as CacheableLookup | undefined)?.lookup,
family: internals.dnsLookupIpVersion,
agent,
setHost: internals.setHost,
method: internals.method,
maxHeaderSize: internals.maxHeaderSize,
localAddress: internals.localAddress,
headers: internals.headers,
createConnection: internals.createConnection,
timeout: internals.http2 ? getHttp2TimeoutOption(internals) : undefined,
// HTTP/2 options
h2session: internals.h2session,
};
}
getRequestFunction() {
const url = this._internals.url as (URL | undefined);
const {request} = this._internals;
if (!request && url) {
return this.getFallbackRequestFunction();
}
return request;
}
getFallbackRequestFunction() {
const url = this._internals.url as (URL | undefined);
if (!url) {
return;
}
if (url.protocol === 'https:') {
if (this._internals.http2) {
if (major < 15 || (major === 15 && minor < 10)) {
const error = new Error('To use the `http2` option, install Node.js 15.10.0 or above');
(error as NodeJS.ErrnoException).code = 'EUNSUPPORTED';
throw error;
}
return http2wrapper.auto as RequestFunction;
}
return https.request;
}
return http.request;
}
freeze() {
const options = this._internals;
Object.freeze(options);
Object.freeze(options.hooks);
Object.freeze(options.hooks.afterResponse);
Object.freeze(options.hooks.beforeError);
Object.freeze(options.hooks.beforeRedirect);
Object.freeze(options.hooks.beforeRequest);
Object.freeze(options.hooks.beforeRetry);
Object.freeze(options.hooks.init);
Object.freeze(options.https);
Object.freeze(options.cacheOptions);
Object.freeze(options.agent);
Object.freeze(options.headers);
Object.freeze(options.timeout);
Object.freeze(options.retry);
Object.freeze(options.retry.errorCodes);
Object.freeze(options.retry.methods);
Object.freeze(options.retry.statusCodes);
}
} |
415 | (updatedOptions: Options, plainResponse: PlainResponse) => Promisable<void> | type PlainResponse = {
/**
The original request URL.
*/
requestUrl: URL;
/**
The redirect URLs.
*/
redirectUrls: URL[];
/**
- `options` - The Got options that were set on this request.
__Note__: This is not a [http.ClientRequest](https://nodejs.org/api/http.html#http_class_http_clientrequest).
*/
request: Request;
/**
The remote IP address.
This is hopefully a temporary limitation, see [lukechilds/cacheable-request#86](https://github.com/lukechilds/cacheable-request/issues/86).
__Note__: Not available when the response is cached.
*/
ip?: string;
/**
Whether the response was retrieved from the cache.
*/
isFromCache: boolean;
/**
The status code of the response.
*/
statusCode: number;
/**
The request URL or the final URL after redirects.
*/
url: string;
/**
The object contains the following properties:
- `start` - Time when the request started.
- `socket` - Time when a socket was assigned to the request.
- `lookup` - Time when the DNS lookup finished.
- `connect` - Time when the socket successfully connected.
- `secureConnect` - Time when the socket securely connected.
- `upload` - Time when the request finished uploading.
- `response` - Time when the request fired `response` event.
- `end` - Time when the response fired `end` event.
- `error` - Time when the request fired `error` event.
- `abort` - Time when the request fired `abort` event.
- `phases`
- `wait` - `timings.socket - timings.start`
- `dns` - `timings.lookup - timings.socket`
- `tcp` - `timings.connect - timings.lookup`
- `tls` - `timings.secureConnect - timings.connect`
- `request` - `timings.upload - (timings.secureConnect || timings.connect)`
- `firstByte` - `timings.response - timings.upload`
- `download` - `timings.end - timings.response`
- `total` - `(timings.end || timings.error || timings.abort) - timings.start`
If something has not been measured yet, it will be `undefined`.
__Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
*/
timings: Timings;
/**
The number of times the request was retried.
*/
retryCount: number;
// Defined only if request errored
/**
The raw result of the request.
*/
rawBody?: Buffer;
/**
The result of the request.
*/
body?: unknown;
/**
Whether the response was successful.
__Note__: Got throws automatically when `response.ok` is `false` and `throwHttpErrors` is `true`.
*/
ok: boolean;
} & IncomingMessageWithTimings; |
416 | (updatedOptions: Options, plainResponse: PlainResponse) => Promisable<void> | class Options {
private _unixOptions?: NativeRequestOptions;
private _internals: InternalsType;
private _merging: boolean;
private readonly _init: OptionsInit[];
constructor(input?: string | URL | OptionsInit, options?: OptionsInit, defaults?: Options) {
assert.any([is.string, is.urlInstance, is.object, is.undefined], input);
assert.any([is.object, is.undefined], options);
assert.any([is.object, is.undefined], defaults);
if (input instanceof Options || options instanceof Options) {
throw new TypeError('The defaults must be passed as the third argument');
}
this._internals = cloneInternals(defaults?._internals ?? defaults ?? defaultInternals);
this._init = [...(defaults?._init ?? [])];
this._merging = false;
this._unixOptions = undefined;
// This rule allows `finally` to be considered more important.
// Meaning no matter the error thrown in the `try` block,
// if `finally` throws then the `finally` error will be thrown.
//
// Yes, we want this. If we set `url` first, then the `url.searchParams`
// would get merged. Instead we set the `searchParams` first, then
// `url.searchParams` is overwritten as expected.
//
/* eslint-disable no-unsafe-finally */
try {
if (is.plainObject(input)) {
try {
this.merge(input);
this.merge(options);
} finally {
this.url = input.url;
}
} else {
try {
this.merge(options);
} finally {
if (options?.url !== undefined) {
if (input === undefined) {
this.url = options.url;
} else {
throw new TypeError('The `url` option is mutually exclusive with the `input` argument');
}
} else if (input !== undefined) {
this.url = input;
}
}
}
} catch (error) {
(error as OptionsError).options = this;
throw error;
}
/* eslint-enable no-unsafe-finally */
}
merge(options?: OptionsInit | Options) {
if (!options) {
return;
}
if (options instanceof Options) {
for (const init of options._init) {
this.merge(init);
}
return;
}
options = cloneRaw(options);
init(this, options, this);
init(options, options, this);
this._merging = true;
// Always merge `isStream` first
if ('isStream' in options) {
this.isStream = options.isStream!;
}
try {
let push = false;
for (const key in options) {
// `got.extend()` options
if (key === 'mutableDefaults' || key === 'handlers') {
continue;
}
// Never merge `url`
if (key === 'url') {
continue;
}
if (!(key in this)) {
throw new Error(`Unexpected option: ${key}`);
}
// @ts-expect-error Type 'unknown' is not assignable to type 'never'.
this[key as keyof Options] = options[key as keyof Options];
push = true;
}
if (push) {
this._init.push(options);
}
} finally {
this._merging = false;
}
}
/**
Custom request function.
The main purpose of this is to [support HTTP2 using a wrapper](https://github.com/szmarczak/http2-wrapper).
@default http.request | https.request
*/
get request(): RequestFunction | undefined {
return this._internals.request;
}
set request(value: RequestFunction | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.request = value;
}
/**
An object representing `http`, `https` and `http2` keys for [`http.Agent`](https://nodejs.org/api/http.html#http_class_http_agent), [`https.Agent`](https://nodejs.org/api/https.html#https_class_https_agent) and [`http2wrapper.Agent`](https://github.com/szmarczak/http2-wrapper#new-http2agentoptions) instance.
This is necessary because a request to one protocol might redirect to another.
In such a scenario, Got will switch over to the right protocol agent for you.
If a key is not present, it will default to a global agent.
@example
```
import got from 'got';
import HttpAgent from 'agentkeepalive';
const {HttpsAgent} = HttpAgent;
await got('https://sindresorhus.com', {
agent: {
http: new HttpAgent(),
https: new HttpsAgent()
}
});
```
*/
get agent(): Agents {
return this._internals.agent;
}
set agent(value: Agents) {
assert.plainObject(value);
// eslint-disable-next-line guard-for-in
for (const key in value) {
if (!(key in this._internals.agent)) {
throw new TypeError(`Unexpected agent option: ${key}`);
}
// @ts-expect-error - No idea why `value[key]` doesn't work here.
assert.any([is.object, is.undefined], value[key]);
}
if (this._merging) {
Object.assign(this._internals.agent, value);
} else {
this._internals.agent = {...value};
}
}
get h2session(): ClientHttp2Session | undefined {
return this._internals.h2session;
}
set h2session(value: ClientHttp2Session | undefined) {
this._internals.h2session = value;
}
/**
Decompress the response automatically.
This will set the `accept-encoding` header to `gzip, deflate, br` unless you set it yourself.
If this is disabled, a compressed response is returned as a `Buffer`.
This may be useful if you want to handle decompression yourself or stream the raw compressed data.
@default true
*/
get decompress(): boolean {
return this._internals.decompress;
}
set decompress(value: boolean) {
assert.boolean(value);
this._internals.decompress = value;
}
/**
Milliseconds to wait for the server to end the response before aborting the request with `got.TimeoutError` error (a.k.a. `request` property).
By default, there's no timeout.
This also accepts an `object` with the following fields to constrain the duration of each phase of the request lifecycle:
- `lookup` starts when a socket is assigned and ends when the hostname has been resolved.
Does not apply when using a Unix domain socket.
- `connect` starts when `lookup` completes (or when the socket is assigned if lookup does not apply to the request) and ends when the socket is connected.
- `secureConnect` starts when `connect` completes and ends when the handshaking process completes (HTTPS only).
- `socket` starts when the socket is connected. See [request.setTimeout](https://nodejs.org/api/http.html#http_request_settimeout_timeout_callback).
- `response` starts when the request has been written to the socket and ends when the response headers are received.
- `send` starts when the socket is connected and ends with the request has been written to the socket.
- `request` starts when the request is initiated and ends when the response's end event fires.
*/
get timeout(): Delays {
// We always return `Delays` here.
// It has to be `Delays | number`, otherwise TypeScript will error because the getter and the setter have incompatible types.
return this._internals.timeout;
}
set timeout(value: Delays) {
assert.plainObject(value);
// eslint-disable-next-line guard-for-in
for (const key in value) {
if (!(key in this._internals.timeout)) {
throw new Error(`Unexpected timeout option: ${key}`);
}
// @ts-expect-error - No idea why `value[key]` doesn't work here.
assert.any([is.number, is.undefined], value[key]);
}
if (this._merging) {
Object.assign(this._internals.timeout, value);
} else {
this._internals.timeout = {...value};
}
}
/**
When specified, `prefixUrl` will be prepended to `url`.
The prefix can be any valid URL, either relative or absolute.
A trailing slash `/` is optional - one will be added automatically.
__Note__: `prefixUrl` will be ignored if the `url` argument is a URL instance.
__Note__: Leading slashes in `input` are disallowed when using this option to enforce consistency and avoid confusion.
For example, when the prefix URL is `https://example.com/foo` and the input is `/bar`, there's ambiguity whether the resulting URL would become `https://example.com/foo/bar` or `https://example.com/bar`.
The latter is used by browsers.
__Tip__: Useful when used with `got.extend()` to create niche-specific Got instances.
__Tip__: You can change `prefixUrl` using hooks as long as the URL still includes the `prefixUrl`.
If the URL doesn't include it anymore, it will throw.
@example
```
import got from 'got';
await got('unicorn', {prefixUrl: 'https://cats.com'});
//=> 'https://cats.com/unicorn'
const instance = got.extend({
prefixUrl: 'https://google.com'
});
await instance('unicorn', {
hooks: {
beforeRequest: [
options => {
options.prefixUrl = 'https://cats.com';
}
]
}
});
//=> 'https://cats.com/unicorn'
```
*/
get prefixUrl(): string | URL {
// We always return `string` here.
// It has to be `string | URL`, otherwise TypeScript will error because the getter and the setter have incompatible types.
return this._internals.prefixUrl;
}
set prefixUrl(value: string | URL) {
assert.any([is.string, is.urlInstance], value);
if (value === '') {
this._internals.prefixUrl = '';
return;
}
value = value.toString();
if (!value.endsWith('/')) {
value += '/';
}
if (this._internals.prefixUrl && this._internals.url) {
const {href} = this._internals.url as URL;
(this._internals.url as URL).href = value + href.slice((this._internals.prefixUrl as string).length);
}
this._internals.prefixUrl = value;
}
/**
__Note #1__: The `body` option cannot be used with the `json` or `form` option.
__Note #2__: If you provide this option, `got.stream()` will be read-only.
__Note #3__: If you provide a payload with the `GET` or `HEAD` method, it will throw a `TypeError` unless the method is `GET` and the `allowGetBody` option is set to `true`.
__Note #4__: This option is not enumerable and will not be merged with the instance defaults.
The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
Since Got 12, the `content-length` is not automatically set when `body` is a `fs.createReadStream`.
*/
get body(): string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined {
return this._internals.body;
}
set body(value: string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined) {
assert.any([is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, isFormData, is.undefined], value);
if (is.nodeStream(value)) {
assert.truthy(value.readable);
}
if (value !== undefined) {
assert.undefined(this._internals.form);
assert.undefined(this._internals.json);
}
this._internals.body = value;
}
/**
The form body is converted to a query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
If the `Content-Type` header is not present, it will be set to `application/x-www-form-urlencoded`.
__Note #1__: If you provide this option, `got.stream()` will be read-only.
__Note #2__: This option is not enumerable and will not be merged with the instance defaults.
*/
get form(): Record<string, any> | undefined {
return this._internals.form;
}
set form(value: Record<string, any> | undefined) {
assert.any([is.plainObject, is.undefined], value);
if (value !== undefined) {
assert.undefined(this._internals.body);
assert.undefined(this._internals.json);
}
this._internals.form = value;
}
/**
JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
__Note #1__: If you provide this option, `got.stream()` will be read-only.
__Note #2__: This option is not enumerable and will not be merged with the instance defaults.
*/
get json(): unknown {
return this._internals.json;
}
set json(value: unknown) {
if (value !== undefined) {
assert.undefined(this._internals.body);
assert.undefined(this._internals.form);
}
this._internals.json = value;
}
/**
The URL to request, as a string, a [`https.request` options object](https://nodejs.org/api/https.html#https_https_request_options_callback), or a [WHATWG `URL`](https://nodejs.org/api/url.html#url_class_url).
Properties from `options` will override properties in the parsed `url`.
If no protocol is specified, it will throw a `TypeError`.
__Note__: The query string is **not** parsed as search params.
@example
```
await got('https://example.com/?query=a b'); //=> https://example.com/?query=a%20b
await got('https://example.com/', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
// The query string is overridden by `searchParams`
await got('https://example.com/?query=a b', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
```
*/
get url(): string | URL | undefined {
return this._internals.url;
}
set url(value: string | URL | undefined) {
assert.any([is.string, is.urlInstance, is.undefined], value);
if (value === undefined) {
this._internals.url = undefined;
return;
}
if (is.string(value) && value.startsWith('/')) {
throw new Error('`url` must not start with a slash');
}
const urlString = `${this.prefixUrl as string}${value.toString()}`;
const url = new URL(urlString);
this._internals.url = url;
if (url.protocol === 'unix:') {
url.href = `http://unix${url.pathname}${url.search}`;
}
if (url.protocol !== 'http:' && url.protocol !== 'https:') {
const error: NodeJS.ErrnoException = new Error(`Unsupported protocol: ${url.protocol}`);
error.code = 'ERR_UNSUPPORTED_PROTOCOL';
throw error;
}
if (this._internals.username) {
url.username = this._internals.username;
this._internals.username = '';
}
if (this._internals.password) {
url.password = this._internals.password;
this._internals.password = '';
}
if (this._internals.searchParams) {
url.search = (this._internals.searchParams as URLSearchParams).toString();
this._internals.searchParams = undefined;
}
if (url.hostname === 'unix') {
if (!this._internals.enableUnixSockets) {
throw new Error('Using UNIX domain sockets but option `enableUnixSockets` is not enabled');
}
const matches = /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`);
if (matches?.groups) {
const {socketPath, path} = matches.groups;
this._unixOptions = {
socketPath,
path,
host: '',
};
} else {
this._unixOptions = undefined;
}
return;
}
this._unixOptions = undefined;
}
/**
Cookie support. You don't have to care about parsing or how to store them.
__Note__: If you provide this option, `options.headers.cookie` will be overridden.
*/
get cookieJar(): PromiseCookieJar | ToughCookieJar | undefined {
return this._internals.cookieJar;
}
set cookieJar(value: PromiseCookieJar | ToughCookieJar | undefined) {
assert.any([is.object, is.undefined], value);
if (value === undefined) {
this._internals.cookieJar = undefined;
return;
}
let {setCookie, getCookieString} = value;
assert.function_(setCookie);
assert.function_(getCookieString);
/* istanbul ignore next: Horrible `tough-cookie` v3 check */
if (setCookie.length === 4 && getCookieString.length === 0) {
setCookie = promisify(setCookie.bind(value));
getCookieString = promisify(getCookieString.bind(value));
this._internals.cookieJar = {
setCookie,
getCookieString: getCookieString as PromiseCookieJar['getCookieString'],
};
} else {
this._internals.cookieJar = value;
}
}
/**
You can abort the `request` using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
*Requires Node.js 16 or later.*
@example
```
import got from 'got';
const abortController = new AbortController();
const request = got('https://httpbin.org/anything', {
signal: abortController.signal
});
setTimeout(() => {
abortController.abort();
}, 100);
```
*/
// TODO: Replace `any` with `AbortSignal` when targeting Node 16.
get signal(): any | undefined {
return this._internals.signal;
}
// TODO: Replace `any` with `AbortSignal` when targeting Node 16.
set signal(value: any | undefined) {
assert.object(value);
this._internals.signal = value;
}
/**
Ignore invalid cookies instead of throwing an error.
Only useful when the `cookieJar` option has been set. Not recommended.
@default false
*/
get ignoreInvalidCookies(): boolean {
return this._internals.ignoreInvalidCookies;
}
set ignoreInvalidCookies(value: boolean) {
assert.boolean(value);
this._internals.ignoreInvalidCookies = value;
}
/**
Query string that will be added to the request URL.
This will override the query string in `url`.
If you need to pass in an array, you can do it using a `URLSearchParams` instance.
@example
```
import got from 'got';
const searchParams = new URLSearchParams([['key', 'a'], ['key', 'b']]);
await got('https://example.com', {searchParams});
console.log(searchParams.toString());
//=> 'key=a&key=b'
```
*/
get searchParams(): string | SearchParameters | URLSearchParams | undefined {
if (this._internals.url) {
return (this._internals.url as URL).searchParams;
}
if (this._internals.searchParams === undefined) {
this._internals.searchParams = new URLSearchParams();
}
return this._internals.searchParams;
}
set searchParams(value: string | SearchParameters | URLSearchParams | undefined) {
assert.any([is.string, is.object, is.undefined], value);
const url = this._internals.url as URL;
if (value === undefined) {
this._internals.searchParams = undefined;
if (url) {
url.search = '';
}
return;
}
const searchParameters = this.searchParams as URLSearchParams;
let updated;
if (is.string(value)) {
updated = new URLSearchParams(value);
} else if (value instanceof URLSearchParams) {
updated = value;
} else {
validateSearchParameters(value);
updated = new URLSearchParams();
// eslint-disable-next-line guard-for-in
for (const key in value) {
const entry = value[key];
if (entry === null) {
updated.append(key, '');
} else if (entry === undefined) {
searchParameters.delete(key);
} else {
updated.append(key, entry as string);
}
}
}
if (this._merging) {
// These keys will be replaced
for (const key of updated.keys()) {
searchParameters.delete(key);
}
for (const [key, value] of updated) {
searchParameters.append(key, value);
}
} else if (url) {
url.search = searchParameters.toString();
} else {
this._internals.searchParams = searchParameters;
}
}
get searchParameters() {
throw new Error('The `searchParameters` option does not exist. Use `searchParams` instead.');
}
set searchParameters(_value: unknown) {
throw new Error('The `searchParameters` option does not exist. Use `searchParams` instead.');
}
get dnsLookup(): CacheableLookup['lookup'] | undefined {
return this._internals.dnsLookup;
}
set dnsLookup(value: CacheableLookup['lookup'] | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.dnsLookup = value;
}
/**
An instance of [`CacheableLookup`](https://github.com/szmarczak/cacheable-lookup) used for making DNS lookups.
Useful when making lots of requests to different *public* hostnames.
`CacheableLookup` uses `dns.resolver4(..)` and `dns.resolver6(...)` under the hood and fall backs to `dns.lookup(...)` when the first two fail, which may lead to additional delay.
__Note__: This should stay disabled when making requests to internal hostnames such as `localhost`, `database.local` etc.
@default false
*/
get dnsCache(): CacheableLookup | boolean | undefined {
return this._internals.dnsCache;
}
set dnsCache(value: CacheableLookup | boolean | undefined) {
assert.any([is.object, is.boolean, is.undefined], value);
if (value === true) {
this._internals.dnsCache = getGlobalDnsCache();
} else if (value === false) {
this._internals.dnsCache = undefined;
} else {
this._internals.dnsCache = value;
}
}
/**
User data. `context` is shallow merged and enumerable. If it contains non-enumerable properties they will NOT be merged.
@example
```
import got from 'got';
const instance = got.extend({
hooks: {
beforeRequest: [
options => {
if (!options.context || !options.context.token) {
throw new Error('Token required');
}
options.headers.token = options.context.token;
}
]
}
});
const context = {
token: 'secret'
};
const response = await instance('https://httpbin.org/headers', {context});
// Let's see the headers
console.log(response.body);
```
*/
get context(): Record<string, unknown> {
return this._internals.context;
}
set context(value: Record<string, unknown>) {
assert.object(value);
if (this._merging) {
Object.assign(this._internals.context, value);
} else {
this._internals.context = {...value};
}
}
/**
Hooks allow modifications during the request lifecycle.
Hook functions may be async and are run serially.
*/
get hooks(): Hooks {
return this._internals.hooks;
}
set hooks(value: Hooks) {
assert.object(value);
// eslint-disable-next-line guard-for-in
for (const knownHookEvent in value) {
if (!(knownHookEvent in this._internals.hooks)) {
throw new Error(`Unexpected hook event: ${knownHookEvent}`);
}
const typedKnownHookEvent = knownHookEvent as keyof Hooks;
const hooks = value[typedKnownHookEvent];
assert.any([is.array, is.undefined], hooks);
if (hooks) {
for (const hook of hooks) {
assert.function_(hook);
}
}
if (this._merging) {
if (hooks) {
// @ts-expect-error FIXME
this._internals.hooks[typedKnownHookEvent].push(...hooks);
}
} else {
if (!hooks) {
throw new Error(`Missing hook event: ${knownHookEvent}`);
}
// @ts-expect-error FIXME
this._internals.hooks[knownHookEvent] = [...hooks];
}
}
}
/**
Defines if redirect responses should be followed automatically.
Note that if a `303` is sent by the server in response to any request type (`POST`, `DELETE`, etc.), Got will automatically request the resource pointed to in the location header via `GET`.
This is in accordance with [the spec](https://tools.ietf.org/html/rfc7231#section-6.4.4). You can optionally turn on this behavior also for other redirect codes - see `methodRewriting`.
@default true
*/
get followRedirect(): boolean {
return this._internals.followRedirect;
}
set followRedirect(value: boolean) {
assert.boolean(value);
this._internals.followRedirect = value;
}
get followRedirects() {
throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
}
set followRedirects(_value: unknown) {
throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
}
/**
If exceeded, the request will be aborted and a `MaxRedirectsError` will be thrown.
@default 10
*/
get maxRedirects(): number {
return this._internals.maxRedirects;
}
set maxRedirects(value: number) {
assert.number(value);
this._internals.maxRedirects = value;
}
/**
A cache adapter instance for storing cached response data.
@default false
*/
get cache(): string | StorageAdapter | boolean | undefined {
return this._internals.cache;
}
set cache(value: string | StorageAdapter | boolean | undefined) {
assert.any([is.object, is.string, is.boolean, is.undefined], value);
if (value === true) {
this._internals.cache = globalCache;
} else if (value === false) {
this._internals.cache = undefined;
} else {
this._internals.cache = value;
}
}
/**
Determines if a `got.HTTPError` is thrown for unsuccessful responses.
If this is disabled, requests that encounter an error status code will be resolved with the `response` instead of throwing.
This may be useful if you are checking for resource availability and are expecting error responses.
@default true
*/
get throwHttpErrors(): boolean {
return this._internals.throwHttpErrors;
}
set throwHttpErrors(value: boolean) {
assert.boolean(value);
this._internals.throwHttpErrors = value;
}
get username(): string {
const url = this._internals.url as URL;
const value = url ? url.username : this._internals.username;
return decodeURIComponent(value);
}
set username(value: string) {
assert.string(value);
const url = this._internals.url as URL;
const fixedValue = encodeURIComponent(value);
if (url) {
url.username = fixedValue;
} else {
this._internals.username = fixedValue;
}
}
get password(): string {
const url = this._internals.url as URL;
const value = url ? url.password : this._internals.password;
return decodeURIComponent(value);
}
set password(value: string) {
assert.string(value);
const url = this._internals.url as URL;
const fixedValue = encodeURIComponent(value);
if (url) {
url.password = fixedValue;
} else {
this._internals.password = fixedValue;
}
}
/**
If set to `true`, Got will additionally accept HTTP2 requests.
It will choose either HTTP/1.1 or HTTP/2 depending on the ALPN protocol.
__Note__: This option requires Node.js 15.10.0 or newer as HTTP/2 support on older Node.js versions is very buggy.
__Note__: Overriding `options.request` will disable HTTP2 support.
@default false
@example
```
import got from 'got';
const {headers} = await got('https://nghttp2.org/httpbin/anything', {http2: true});
console.log(headers.via);
//=> '2 nghttpx'
```
*/
get http2(): boolean {
return this._internals.http2;
}
set http2(value: boolean) {
assert.boolean(value);
this._internals.http2 = value;
}
/**
Set this to `true` to allow sending body for the `GET` method.
However, the [HTTP/2 specification](https://tools.ietf.org/html/rfc7540#section-8.1.3) says that `An HTTP GET request includes request header fields and no payload body`, therefore when using the HTTP/2 protocol this option will have no effect.
This option is only meant to interact with non-compliant servers when you have no other choice.
__Note__: The [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.1) doesn't specify any particular behavior for the GET method having a payload, therefore __it's considered an [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern)__.
@default false
*/
get allowGetBody(): boolean {
return this._internals.allowGetBody;
}
set allowGetBody(value: boolean) {
assert.boolean(value);
this._internals.allowGetBody = value;
}
/**
Request headers.
Existing headers will be overwritten. Headers set to `undefined` will be omitted.
@default {}
*/
get headers(): Headers {
return this._internals.headers;
}
set headers(value: Headers) {
assert.plainObject(value);
if (this._merging) {
Object.assign(this._internals.headers, lowercaseKeys(value));
} else {
this._internals.headers = lowercaseKeys(value);
}
}
/**
Specifies if the HTTP request method should be [rewritten as `GET`](https://tools.ietf.org/html/rfc7231#section-6.4) on redirects.
As the [specification](https://tools.ietf.org/html/rfc7231#section-6.4) prefers to rewrite the HTTP method only on `303` responses, this is Got's default behavior.
Setting `methodRewriting` to `true` will also rewrite `301` and `302` responses, as allowed by the spec. This is the behavior followed by `curl` and browsers.
__Note__: Got never performs method rewriting on `307` and `308` responses, as this is [explicitly prohibited by the specification](https://www.rfc-editor.org/rfc/rfc7231#section-6.4.7).
@default false
*/
get methodRewriting(): boolean {
return this._internals.methodRewriting;
}
set methodRewriting(value: boolean) {
assert.boolean(value);
this._internals.methodRewriting = value;
}
/**
Indicates which DNS record family to use.
Values:
- `undefined`: IPv4 (if present) or IPv6
- `4`: Only IPv4
- `6`: Only IPv6
@default undefined
*/
get dnsLookupIpVersion(): DnsLookupIpVersion {
return this._internals.dnsLookupIpVersion;
}
set dnsLookupIpVersion(value: DnsLookupIpVersion) {
if (value !== undefined && value !== 4 && value !== 6) {
throw new TypeError(`Invalid DNS lookup IP version: ${value as string}`);
}
this._internals.dnsLookupIpVersion = value;
}
/**
A function used to parse JSON responses.
@example
```
import got from 'got';
import Bourne from '@hapi/bourne';
const parsed = await got('https://example.com', {
parseJson: text => Bourne.parse(text)
}).json();
console.log(parsed);
```
*/
get parseJson(): ParseJsonFunction {
return this._internals.parseJson;
}
set parseJson(value: ParseJsonFunction) {
assert.function_(value);
this._internals.parseJson = value;
}
/**
A function used to stringify the body of JSON requests.
@example
```
import got from 'got';
await got.post('https://example.com', {
stringifyJson: object => JSON.stringify(object, (key, value) => {
if (key.startsWith('_')) {
return;
}
return value;
}),
json: {
some: 'payload',
_ignoreMe: 1234
}
});
```
@example
```
import got from 'got';
await got.post('https://example.com', {
stringifyJson: object => JSON.stringify(object, (key, value) => {
if (typeof value === 'number') {
return value.toString();
}
return value;
}),
json: {
some: 'payload',
number: 1
}
});
```
*/
get stringifyJson(): StringifyJsonFunction {
return this._internals.stringifyJson;
}
set stringifyJson(value: StringifyJsonFunction) {
assert.function_(value);
this._internals.stringifyJson = value;
}
/**
An object representing `limit`, `calculateDelay`, `methods`, `statusCodes`, `maxRetryAfter` and `errorCodes` fields for maximum retry count, retry handler, allowed methods, allowed status codes, maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.
Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 1).
The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
By default, it retries *only* on the specified methods, status codes, and on these network errors:
- `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
- `ECONNRESET`: Connection was forcibly closed by a peer.
- `EADDRINUSE`: Could not bind to any free port.
- `ECONNREFUSED`: Connection was refused by the server.
- `EPIPE`: The remote side of the stream being written has been closed.
- `ENOTFOUND`: Couldn't resolve the hostname to an IP address.
- `ENETUNREACH`: No internet connection.
- `EAI_AGAIN`: DNS lookup timed out.
__Note__: If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.
__Note__: If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
*/
get retry(): Partial<RetryOptions> {
return this._internals.retry;
}
set retry(value: Partial<RetryOptions>) {
assert.plainObject(value);
assert.any([is.function_, is.undefined], value.calculateDelay);
assert.any([is.number, is.undefined], value.maxRetryAfter);
assert.any([is.number, is.undefined], value.limit);
assert.any([is.array, is.undefined], value.methods);
assert.any([is.array, is.undefined], value.statusCodes);
assert.any([is.array, is.undefined], value.errorCodes);
assert.any([is.number, is.undefined], value.noise);
if (value.noise && Math.abs(value.noise) > 100) {
throw new Error(`The maximum acceptable retry noise is +/- 100ms, got ${value.noise}`);
}
for (const key in value) {
if (!(key in this._internals.retry)) {
throw new Error(`Unexpected retry option: ${key}`);
}
}
if (this._merging) {
Object.assign(this._internals.retry, value);
} else {
this._internals.retry = {...value};
}
const {retry} = this._internals;
retry.methods = [...new Set(retry.methods!.map(method => method.toUpperCase() as Method))];
retry.statusCodes = [...new Set(retry.statusCodes)];
retry.errorCodes = [...new Set(retry.errorCodes)];
}
/**
From `http.RequestOptions`.
The IP address used to send the request from.
*/
get localAddress(): string | undefined {
return this._internals.localAddress;
}
set localAddress(value: string | undefined) {
assert.any([is.string, is.undefined], value);
this._internals.localAddress = value;
}
/**
The HTTP method used to make the request.
@default 'GET'
*/
get method(): Method {
return this._internals.method;
}
set method(value: Method) {
assert.string(value);
this._internals.method = value.toUpperCase() as Method;
}
get createConnection(): CreateConnectionFunction | undefined {
return this._internals.createConnection;
}
set createConnection(value: CreateConnectionFunction | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.createConnection = value;
}
/**
From `http-cache-semantics`
@default {}
*/
get cacheOptions(): CacheOptions {
return this._internals.cacheOptions;
}
set cacheOptions(value: CacheOptions) {
assert.plainObject(value);
assert.any([is.boolean, is.undefined], value.shared);
assert.any([is.number, is.undefined], value.cacheHeuristic);
assert.any([is.number, is.undefined], value.immutableMinTimeToLive);
assert.any([is.boolean, is.undefined], value.ignoreCargoCult);
for (const key in value) {
if (!(key in this._internals.cacheOptions)) {
throw new Error(`Cache option \`${key}\` does not exist`);
}
}
if (this._merging) {
Object.assign(this._internals.cacheOptions, value);
} else {
this._internals.cacheOptions = {...value};
}
}
/**
Options for the advanced HTTPS API.
*/
get https(): HttpsOptions {
return this._internals.https;
}
set https(value: HttpsOptions) {
assert.plainObject(value);
assert.any([is.boolean, is.undefined], value.rejectUnauthorized);
assert.any([is.function_, is.undefined], value.checkServerIdentity);
assert.any([is.string, is.object, is.array, is.undefined], value.certificateAuthority);
assert.any([is.string, is.object, is.array, is.undefined], value.key);
assert.any([is.string, is.object, is.array, is.undefined], value.certificate);
assert.any([is.string, is.undefined], value.passphrase);
assert.any([is.string, is.buffer, is.array, is.undefined], value.pfx);
assert.any([is.array, is.undefined], value.alpnProtocols);
assert.any([is.string, is.undefined], value.ciphers);
assert.any([is.string, is.buffer, is.undefined], value.dhparam);
assert.any([is.string, is.undefined], value.signatureAlgorithms);
assert.any([is.string, is.undefined], value.minVersion);
assert.any([is.string, is.undefined], value.maxVersion);
assert.any([is.boolean, is.undefined], value.honorCipherOrder);
assert.any([is.number, is.undefined], value.tlsSessionLifetime);
assert.any([is.string, is.undefined], value.ecdhCurve);
assert.any([is.string, is.buffer, is.array, is.undefined], value.certificateRevocationLists);
for (const key in value) {
if (!(key in this._internals.https)) {
throw new Error(`HTTPS option \`${key}\` does not exist`);
}
}
if (this._merging) {
Object.assign(this._internals.https, value);
} else {
this._internals.https = {...value};
}
}
/**
[Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data.
To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set `responseType` to `buffer` instead.
Don't set this option to `null`.
__Note__: This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
@default 'utf-8'
*/
get encoding(): BufferEncoding | undefined {
return this._internals.encoding;
}
set encoding(value: BufferEncoding | undefined) {
if (value === null) {
throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead');
}
assert.any([is.string, is.undefined], value);
this._internals.encoding = value;
}
/**
When set to `true` the promise will return the Response body instead of the Response object.
@default false
*/
get resolveBodyOnly(): boolean {
return this._internals.resolveBodyOnly;
}
set resolveBodyOnly(value: boolean) {
assert.boolean(value);
this._internals.resolveBodyOnly = value;
}
/**
Returns a `Stream` instead of a `Promise`.
This is equivalent to calling `got.stream(url, options?)`.
@default false
*/
get isStream(): boolean {
return this._internals.isStream;
}
set isStream(value: boolean) {
assert.boolean(value);
this._internals.isStream = value;
}
/**
The parsing method.
The promise also has `.text()`, `.json()` and `.buffer()` methods which return another Got promise for the parsed body.
It's like setting the options to `{responseType: 'json', resolveBodyOnly: true}` but without affecting the main Got promise.
__Note__: When using streams, this option is ignored.
@example
```
const responsePromise = got(url);
const bufferPromise = responsePromise.buffer();
const jsonPromise = responsePromise.json();
const [response, buffer, json] = Promise.all([responsePromise, bufferPromise, jsonPromise]);
// `response` is an instance of Got Response
// `buffer` is an instance of Buffer
// `json` is an object
```
@example
```
// This
const body = await got(url).json();
// is semantically the same as this
const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
```
*/
get responseType(): ResponseType {
return this._internals.responseType;
}
set responseType(value: ResponseType) {
if (value === undefined) {
this._internals.responseType = 'text';
return;
}
if (value !== 'text' && value !== 'buffer' && value !== 'json') {
throw new Error(`Invalid \`responseType\` option: ${value as string}`);
}
this._internals.responseType = value;
}
get pagination(): PaginationOptions<unknown, unknown> {
return this._internals.pagination;
}
set pagination(value: PaginationOptions<unknown, unknown>) {
assert.object(value);
if (this._merging) {
Object.assign(this._internals.pagination, value);
} else {
this._internals.pagination = value;
}
}
get auth() {
throw new Error('Parameter `auth` is deprecated. Use `username` / `password` instead.');
}
set auth(_value: unknown) {
throw new Error('Parameter `auth` is deprecated. Use `username` / `password` instead.');
}
get setHost() {
return this._internals.setHost;
}
set setHost(value: boolean) {
assert.boolean(value);
this._internals.setHost = value;
}
get maxHeaderSize() {
return this._internals.maxHeaderSize;
}
set maxHeaderSize(value: number | undefined) {
assert.any([is.number, is.undefined], value);
this._internals.maxHeaderSize = value;
}
get enableUnixSockets() {
return this._internals.enableUnixSockets;
}
set enableUnixSockets(value: boolean) {
assert.boolean(value);
this._internals.enableUnixSockets = value;
}
// eslint-disable-next-line @typescript-eslint/naming-convention
toJSON() {
return {...this._internals};
}
[Symbol.for('nodejs.util.inspect.custom')](_depth: number, options: InspectOptions) {
return inspect(this._internals, options);
}
createNativeRequestOptions() {
const internals = this._internals;
const url = internals.url as URL;
let agent;
if (url.protocol === 'https:') {
agent = internals.http2 ? internals.agent : internals.agent.https;
} else {
agent = internals.agent.http;
}
const {https} = internals;
let {pfx} = https;
if (is.array(pfx) && is.plainObject(pfx[0])) {
pfx = (pfx as PfxObject[]).map(object => ({
buf: object.buffer,
passphrase: object.passphrase,
})) as any;
}
return {
...internals.cacheOptions,
...this._unixOptions,
// HTTPS options
// eslint-disable-next-line @typescript-eslint/naming-convention
ALPNProtocols: https.alpnProtocols,
ca: https.certificateAuthority,
cert: https.certificate,
key: https.key,
passphrase: https.passphrase,
pfx: https.pfx,
rejectUnauthorized: https.rejectUnauthorized,
checkServerIdentity: https.checkServerIdentity ?? checkServerIdentity,
ciphers: https.ciphers,
honorCipherOrder: https.honorCipherOrder,
minVersion: https.minVersion,
maxVersion: https.maxVersion,
sigalgs: https.signatureAlgorithms,
sessionTimeout: https.tlsSessionLifetime,
dhparam: https.dhparam,
ecdhCurve: https.ecdhCurve,
crl: https.certificateRevocationLists,
// HTTP options
lookup: internals.dnsLookup ?? (internals.dnsCache as CacheableLookup | undefined)?.lookup,
family: internals.dnsLookupIpVersion,
agent,
setHost: internals.setHost,
method: internals.method,
maxHeaderSize: internals.maxHeaderSize,
localAddress: internals.localAddress,
headers: internals.headers,
createConnection: internals.createConnection,
timeout: internals.http2 ? getHttp2TimeoutOption(internals) : undefined,
// HTTP/2 options
h2session: internals.h2session,
};
}
getRequestFunction() {
const url = this._internals.url as (URL | undefined);
const {request} = this._internals;
if (!request && url) {
return this.getFallbackRequestFunction();
}
return request;
}
getFallbackRequestFunction() {
const url = this._internals.url as (URL | undefined);
if (!url) {
return;
}
if (url.protocol === 'https:') {
if (this._internals.http2) {
if (major < 15 || (major === 15 && minor < 10)) {
const error = new Error('To use the `http2` option, install Node.js 15.10.0 or above');
(error as NodeJS.ErrnoException).code = 'EUNSUPPORTED';
throw error;
}
return http2wrapper.auto as RequestFunction;
}
return https.request;
}
return http.request;
}
freeze() {
const options = this._internals;
Object.freeze(options);
Object.freeze(options.hooks);
Object.freeze(options.hooks.afterResponse);
Object.freeze(options.hooks.beforeError);
Object.freeze(options.hooks.beforeRedirect);
Object.freeze(options.hooks.beforeRequest);
Object.freeze(options.hooks.beforeRetry);
Object.freeze(options.hooks.init);
Object.freeze(options.https);
Object.freeze(options.cacheOptions);
Object.freeze(options.agent);
Object.freeze(options.headers);
Object.freeze(options.timeout);
Object.freeze(options.retry);
Object.freeze(options.retry.errorCodes);
Object.freeze(options.retry.methods);
Object.freeze(options.retry.statusCodes);
}
} |
417 | (error: RequestError) => Promisable<RequestError> | class RequestError extends Error {
input?: string;
code: string;
override stack!: string;
declare readonly options: Options;
readonly response?: Response;
readonly request?: Request;
readonly timings?: Timings;
constructor(message: string, error: Partial<Error & {code?: string}>, self: Request | Options) {
super(message);
Error.captureStackTrace(this, this.constructor);
this.name = 'RequestError';
this.code = error.code ?? 'ERR_GOT_REQUEST_ERROR';
this.input = (error as any).input;
if (isRequest(self)) {
Object.defineProperty(this, 'request', {
enumerable: false,
value: self,
});
Object.defineProperty(this, 'response', {
enumerable: false,
value: self.response,
});
this.options = self.options;
} else {
this.options = self;
}
this.timings = this.request?.timings;
// Recover the original stacktrace
if (is.string(error.stack) && is.string(this.stack)) {
const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse();
const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message!) + error.message!.length).split('\n').reverse();
// Remove duplicated traces
while (errorStackTrace.length > 0 && errorStackTrace[0] === thisStackTrace[0]) {
thisStackTrace.shift();
}
this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`;
}
}
} |
418 | (error: RequestError, retryCount: number) => Promisable<void> | class RequestError extends Error {
input?: string;
code: string;
override stack!: string;
declare readonly options: Options;
readonly response?: Response;
readonly request?: Request;
readonly timings?: Timings;
constructor(message: string, error: Partial<Error & {code?: string}>, self: Request | Options) {
super(message);
Error.captureStackTrace(this, this.constructor);
this.name = 'RequestError';
this.code = error.code ?? 'ERR_GOT_REQUEST_ERROR';
this.input = (error as any).input;
if (isRequest(self)) {
Object.defineProperty(this, 'request', {
enumerable: false,
value: self,
});
Object.defineProperty(this, 'response', {
enumerable: false,
value: self.response,
});
this.options = self.options;
} else {
this.options = self;
}
this.timings = this.request?.timings;
// Recover the original stacktrace
if (is.string(error.stack) && is.string(this.stack)) {
const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse();
const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message!) + error.message!.length).split('\n').reverse();
// Remove duplicated traces
while (errorStackTrace.length > 0 && errorStackTrace[0] === thisStackTrace[0]) {
thisStackTrace.shift();
}
this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`;
}
}
} |
419 | (options: OptionsInit) => never | type OptionsInit =
Except<Partial<InternalsType>, 'hooks' | 'retry'>
& {
hooks?: Partial<Hooks>;
retry?: Partial<RetryOptions>;
}; |
420 | (retryObject: RetryObject) => Promisable<number> | type RetryObject = {
attemptCount: number;
retryOptions: RetryOptions;
error: RequestError;
computedValue: number;
retryAfter?: number;
}; |
421 | (options: NativeRequestOptions, oncreate: (error: NodeJS.ErrnoException, socket: Socket) => void) => Socket | type NativeRequestOptions = HttpsRequestOptions & CacheOptions & {checkServerIdentity?: CheckServerIdentityFunction}; |
422 | transform(response: Response) {
if (response.request.options.responseType === 'json') {
return response.body;
}
return JSON.parse(response.body as string);
} | type Response<T = unknown> = {
/**
The result of the request.
*/
body: T;
/**
The raw result of the request.
*/
rawBody: Buffer;
} & PlainResponse; |
423 | (raw: OptionsInit) => {
const {hooks, retry} = raw;
const result: OptionsInit = {...raw};
if (is.object(raw.context)) {
result.context = {...raw.context};
}
if (is.object(raw.cacheOptions)) {
result.cacheOptions = {...raw.cacheOptions};
}
if (is.object(raw.https)) {
result.https = {...raw.https};
}
if (is.object(raw.cacheOptions)) {
result.cacheOptions = {...result.cacheOptions};
}
if (is.object(raw.agent)) {
result.agent = {...raw.agent};
}
if (is.object(raw.headers)) {
result.headers = {...raw.headers};
}
if (is.object(retry)) {
result.retry = {...retry};
if (is.array(retry.errorCodes)) {
result.retry.errorCodes = [...retry.errorCodes];
}
if (is.array(retry.methods)) {
result.retry.methods = [...retry.methods];
}
if (is.array(retry.statusCodes)) {
result.retry.statusCodes = [...retry.statusCodes];
}
}
if (is.object(raw.timeout)) {
result.timeout = {...raw.timeout};
}
if (is.object(hooks)) {
result.hooks = {
...hooks,
};
if (is.array(hooks.init)) {
result.hooks.init = [...hooks.init];
}
if (is.array(hooks.beforeRequest)) {
result.hooks.beforeRequest = [...hooks.beforeRequest];
}
if (is.array(hooks.beforeError)) {
result.hooks.beforeError = [...hooks.beforeError];
}
if (is.array(hooks.beforeRedirect)) {
result.hooks.beforeRedirect = [...hooks.beforeRedirect];
}
if (is.array(hooks.beforeRetry)) {
result.hooks.beforeRetry = [...hooks.beforeRetry];
}
if (is.array(hooks.afterResponse)) {
result.hooks.afterResponse = [...hooks.afterResponse];
}
}
// TODO: raw.searchParams
if (is.object(raw.pagination)) {
result.pagination = {...raw.pagination};
}
return result;
} | type OptionsInit =
Except<Partial<InternalsType>, 'hooks' | 'retry'>
& {
hooks?: Partial<Hooks>;
retry?: Partial<RetryOptions>;
}; |
424 | (options: OptionsInit, withOptions: OptionsInit, self: Options): void => {
const initHooks = options.hooks?.init;
if (initHooks) {
for (const hook of initHooks) {
hook(withOptions, self);
}
}
} | type OptionsInit =
Except<Partial<InternalsType>, 'hooks' | 'retry'>
& {
hooks?: Partial<Hooks>;
retry?: Partial<RetryOptions>;
}; |
425 | (options: OptionsInit, withOptions: OptionsInit, self: Options): void => {
const initHooks = options.hooks?.init;
if (initHooks) {
for (const hook of initHooks) {
hook(withOptions, self);
}
}
} | class Options {
private _unixOptions?: NativeRequestOptions;
private _internals: InternalsType;
private _merging: boolean;
private readonly _init: OptionsInit[];
constructor(input?: string | URL | OptionsInit, options?: OptionsInit, defaults?: Options) {
assert.any([is.string, is.urlInstance, is.object, is.undefined], input);
assert.any([is.object, is.undefined], options);
assert.any([is.object, is.undefined], defaults);
if (input instanceof Options || options instanceof Options) {
throw new TypeError('The defaults must be passed as the third argument');
}
this._internals = cloneInternals(defaults?._internals ?? defaults ?? defaultInternals);
this._init = [...(defaults?._init ?? [])];
this._merging = false;
this._unixOptions = undefined;
// This rule allows `finally` to be considered more important.
// Meaning no matter the error thrown in the `try` block,
// if `finally` throws then the `finally` error will be thrown.
//
// Yes, we want this. If we set `url` first, then the `url.searchParams`
// would get merged. Instead we set the `searchParams` first, then
// `url.searchParams` is overwritten as expected.
//
/* eslint-disable no-unsafe-finally */
try {
if (is.plainObject(input)) {
try {
this.merge(input);
this.merge(options);
} finally {
this.url = input.url;
}
} else {
try {
this.merge(options);
} finally {
if (options?.url !== undefined) {
if (input === undefined) {
this.url = options.url;
} else {
throw new TypeError('The `url` option is mutually exclusive with the `input` argument');
}
} else if (input !== undefined) {
this.url = input;
}
}
}
} catch (error) {
(error as OptionsError).options = this;
throw error;
}
/* eslint-enable no-unsafe-finally */
}
merge(options?: OptionsInit | Options) {
if (!options) {
return;
}
if (options instanceof Options) {
for (const init of options._init) {
this.merge(init);
}
return;
}
options = cloneRaw(options);
init(this, options, this);
init(options, options, this);
this._merging = true;
// Always merge `isStream` first
if ('isStream' in options) {
this.isStream = options.isStream!;
}
try {
let push = false;
for (const key in options) {
// `got.extend()` options
if (key === 'mutableDefaults' || key === 'handlers') {
continue;
}
// Never merge `url`
if (key === 'url') {
continue;
}
if (!(key in this)) {
throw new Error(`Unexpected option: ${key}`);
}
// @ts-expect-error Type 'unknown' is not assignable to type 'never'.
this[key as keyof Options] = options[key as keyof Options];
push = true;
}
if (push) {
this._init.push(options);
}
} finally {
this._merging = false;
}
}
/**
Custom request function.
The main purpose of this is to [support HTTP2 using a wrapper](https://github.com/szmarczak/http2-wrapper).
@default http.request | https.request
*/
get request(): RequestFunction | undefined {
return this._internals.request;
}
set request(value: RequestFunction | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.request = value;
}
/**
An object representing `http`, `https` and `http2` keys for [`http.Agent`](https://nodejs.org/api/http.html#http_class_http_agent), [`https.Agent`](https://nodejs.org/api/https.html#https_class_https_agent) and [`http2wrapper.Agent`](https://github.com/szmarczak/http2-wrapper#new-http2agentoptions) instance.
This is necessary because a request to one protocol might redirect to another.
In such a scenario, Got will switch over to the right protocol agent for you.
If a key is not present, it will default to a global agent.
@example
```
import got from 'got';
import HttpAgent from 'agentkeepalive';
const {HttpsAgent} = HttpAgent;
await got('https://sindresorhus.com', {
agent: {
http: new HttpAgent(),
https: new HttpsAgent()
}
});
```
*/
get agent(): Agents {
return this._internals.agent;
}
set agent(value: Agents) {
assert.plainObject(value);
// eslint-disable-next-line guard-for-in
for (const key in value) {
if (!(key in this._internals.agent)) {
throw new TypeError(`Unexpected agent option: ${key}`);
}
// @ts-expect-error - No idea why `value[key]` doesn't work here.
assert.any([is.object, is.undefined], value[key]);
}
if (this._merging) {
Object.assign(this._internals.agent, value);
} else {
this._internals.agent = {...value};
}
}
get h2session(): ClientHttp2Session | undefined {
return this._internals.h2session;
}
set h2session(value: ClientHttp2Session | undefined) {
this._internals.h2session = value;
}
/**
Decompress the response automatically.
This will set the `accept-encoding` header to `gzip, deflate, br` unless you set it yourself.
If this is disabled, a compressed response is returned as a `Buffer`.
This may be useful if you want to handle decompression yourself or stream the raw compressed data.
@default true
*/
get decompress(): boolean {
return this._internals.decompress;
}
set decompress(value: boolean) {
assert.boolean(value);
this._internals.decompress = value;
}
/**
Milliseconds to wait for the server to end the response before aborting the request with `got.TimeoutError` error (a.k.a. `request` property).
By default, there's no timeout.
This also accepts an `object` with the following fields to constrain the duration of each phase of the request lifecycle:
- `lookup` starts when a socket is assigned and ends when the hostname has been resolved.
Does not apply when using a Unix domain socket.
- `connect` starts when `lookup` completes (or when the socket is assigned if lookup does not apply to the request) and ends when the socket is connected.
- `secureConnect` starts when `connect` completes and ends when the handshaking process completes (HTTPS only).
- `socket` starts when the socket is connected. See [request.setTimeout](https://nodejs.org/api/http.html#http_request_settimeout_timeout_callback).
- `response` starts when the request has been written to the socket and ends when the response headers are received.
- `send` starts when the socket is connected and ends with the request has been written to the socket.
- `request` starts when the request is initiated and ends when the response's end event fires.
*/
get timeout(): Delays {
// We always return `Delays` here.
// It has to be `Delays | number`, otherwise TypeScript will error because the getter and the setter have incompatible types.
return this._internals.timeout;
}
set timeout(value: Delays) {
assert.plainObject(value);
// eslint-disable-next-line guard-for-in
for (const key in value) {
if (!(key in this._internals.timeout)) {
throw new Error(`Unexpected timeout option: ${key}`);
}
// @ts-expect-error - No idea why `value[key]` doesn't work here.
assert.any([is.number, is.undefined], value[key]);
}
if (this._merging) {
Object.assign(this._internals.timeout, value);
} else {
this._internals.timeout = {...value};
}
}
/**
When specified, `prefixUrl` will be prepended to `url`.
The prefix can be any valid URL, either relative or absolute.
A trailing slash `/` is optional - one will be added automatically.
__Note__: `prefixUrl` will be ignored if the `url` argument is a URL instance.
__Note__: Leading slashes in `input` are disallowed when using this option to enforce consistency and avoid confusion.
For example, when the prefix URL is `https://example.com/foo` and the input is `/bar`, there's ambiguity whether the resulting URL would become `https://example.com/foo/bar` or `https://example.com/bar`.
The latter is used by browsers.
__Tip__: Useful when used with `got.extend()` to create niche-specific Got instances.
__Tip__: You can change `prefixUrl` using hooks as long as the URL still includes the `prefixUrl`.
If the URL doesn't include it anymore, it will throw.
@example
```
import got from 'got';
await got('unicorn', {prefixUrl: 'https://cats.com'});
//=> 'https://cats.com/unicorn'
const instance = got.extend({
prefixUrl: 'https://google.com'
});
await instance('unicorn', {
hooks: {
beforeRequest: [
options => {
options.prefixUrl = 'https://cats.com';
}
]
}
});
//=> 'https://cats.com/unicorn'
```
*/
get prefixUrl(): string | URL {
// We always return `string` here.
// It has to be `string | URL`, otherwise TypeScript will error because the getter and the setter have incompatible types.
return this._internals.prefixUrl;
}
set prefixUrl(value: string | URL) {
assert.any([is.string, is.urlInstance], value);
if (value === '') {
this._internals.prefixUrl = '';
return;
}
value = value.toString();
if (!value.endsWith('/')) {
value += '/';
}
if (this._internals.prefixUrl && this._internals.url) {
const {href} = this._internals.url as URL;
(this._internals.url as URL).href = value + href.slice((this._internals.prefixUrl as string).length);
}
this._internals.prefixUrl = value;
}
/**
__Note #1__: The `body` option cannot be used with the `json` or `form` option.
__Note #2__: If you provide this option, `got.stream()` will be read-only.
__Note #3__: If you provide a payload with the `GET` or `HEAD` method, it will throw a `TypeError` unless the method is `GET` and the `allowGetBody` option is set to `true`.
__Note #4__: This option is not enumerable and will not be merged with the instance defaults.
The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
Since Got 12, the `content-length` is not automatically set when `body` is a `fs.createReadStream`.
*/
get body(): string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined {
return this._internals.body;
}
set body(value: string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined) {
assert.any([is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, isFormData, is.undefined], value);
if (is.nodeStream(value)) {
assert.truthy(value.readable);
}
if (value !== undefined) {
assert.undefined(this._internals.form);
assert.undefined(this._internals.json);
}
this._internals.body = value;
}
/**
The form body is converted to a query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
If the `Content-Type` header is not present, it will be set to `application/x-www-form-urlencoded`.
__Note #1__: If you provide this option, `got.stream()` will be read-only.
__Note #2__: This option is not enumerable and will not be merged with the instance defaults.
*/
get form(): Record<string, any> | undefined {
return this._internals.form;
}
set form(value: Record<string, any> | undefined) {
assert.any([is.plainObject, is.undefined], value);
if (value !== undefined) {
assert.undefined(this._internals.body);
assert.undefined(this._internals.json);
}
this._internals.form = value;
}
/**
JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
__Note #1__: If you provide this option, `got.stream()` will be read-only.
__Note #2__: This option is not enumerable and will not be merged with the instance defaults.
*/
get json(): unknown {
return this._internals.json;
}
set json(value: unknown) {
if (value !== undefined) {
assert.undefined(this._internals.body);
assert.undefined(this._internals.form);
}
this._internals.json = value;
}
/**
The URL to request, as a string, a [`https.request` options object](https://nodejs.org/api/https.html#https_https_request_options_callback), or a [WHATWG `URL`](https://nodejs.org/api/url.html#url_class_url).
Properties from `options` will override properties in the parsed `url`.
If no protocol is specified, it will throw a `TypeError`.
__Note__: The query string is **not** parsed as search params.
@example
```
await got('https://example.com/?query=a b'); //=> https://example.com/?query=a%20b
await got('https://example.com/', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
// The query string is overridden by `searchParams`
await got('https://example.com/?query=a b', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
```
*/
get url(): string | URL | undefined {
return this._internals.url;
}
set url(value: string | URL | undefined) {
assert.any([is.string, is.urlInstance, is.undefined], value);
if (value === undefined) {
this._internals.url = undefined;
return;
}
if (is.string(value) && value.startsWith('/')) {
throw new Error('`url` must not start with a slash');
}
const urlString = `${this.prefixUrl as string}${value.toString()}`;
const url = new URL(urlString);
this._internals.url = url;
if (url.protocol === 'unix:') {
url.href = `http://unix${url.pathname}${url.search}`;
}
if (url.protocol !== 'http:' && url.protocol !== 'https:') {
const error: NodeJS.ErrnoException = new Error(`Unsupported protocol: ${url.protocol}`);
error.code = 'ERR_UNSUPPORTED_PROTOCOL';
throw error;
}
if (this._internals.username) {
url.username = this._internals.username;
this._internals.username = '';
}
if (this._internals.password) {
url.password = this._internals.password;
this._internals.password = '';
}
if (this._internals.searchParams) {
url.search = (this._internals.searchParams as URLSearchParams).toString();
this._internals.searchParams = undefined;
}
if (url.hostname === 'unix') {
if (!this._internals.enableUnixSockets) {
throw new Error('Using UNIX domain sockets but option `enableUnixSockets` is not enabled');
}
const matches = /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`);
if (matches?.groups) {
const {socketPath, path} = matches.groups;
this._unixOptions = {
socketPath,
path,
host: '',
};
} else {
this._unixOptions = undefined;
}
return;
}
this._unixOptions = undefined;
}
/**
Cookie support. You don't have to care about parsing or how to store them.
__Note__: If you provide this option, `options.headers.cookie` will be overridden.
*/
get cookieJar(): PromiseCookieJar | ToughCookieJar | undefined {
return this._internals.cookieJar;
}
set cookieJar(value: PromiseCookieJar | ToughCookieJar | undefined) {
assert.any([is.object, is.undefined], value);
if (value === undefined) {
this._internals.cookieJar = undefined;
return;
}
let {setCookie, getCookieString} = value;
assert.function_(setCookie);
assert.function_(getCookieString);
/* istanbul ignore next: Horrible `tough-cookie` v3 check */
if (setCookie.length === 4 && getCookieString.length === 0) {
setCookie = promisify(setCookie.bind(value));
getCookieString = promisify(getCookieString.bind(value));
this._internals.cookieJar = {
setCookie,
getCookieString: getCookieString as PromiseCookieJar['getCookieString'],
};
} else {
this._internals.cookieJar = value;
}
}
/**
You can abort the `request` using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
*Requires Node.js 16 or later.*
@example
```
import got from 'got';
const abortController = new AbortController();
const request = got('https://httpbin.org/anything', {
signal: abortController.signal
});
setTimeout(() => {
abortController.abort();
}, 100);
```
*/
// TODO: Replace `any` with `AbortSignal` when targeting Node 16.
get signal(): any | undefined {
return this._internals.signal;
}
// TODO: Replace `any` with `AbortSignal` when targeting Node 16.
set signal(value: any | undefined) {
assert.object(value);
this._internals.signal = value;
}
/**
Ignore invalid cookies instead of throwing an error.
Only useful when the `cookieJar` option has been set. Not recommended.
@default false
*/
get ignoreInvalidCookies(): boolean {
return this._internals.ignoreInvalidCookies;
}
set ignoreInvalidCookies(value: boolean) {
assert.boolean(value);
this._internals.ignoreInvalidCookies = value;
}
/**
Query string that will be added to the request URL.
This will override the query string in `url`.
If you need to pass in an array, you can do it using a `URLSearchParams` instance.
@example
```
import got from 'got';
const searchParams = new URLSearchParams([['key', 'a'], ['key', 'b']]);
await got('https://example.com', {searchParams});
console.log(searchParams.toString());
//=> 'key=a&key=b'
```
*/
get searchParams(): string | SearchParameters | URLSearchParams | undefined {
if (this._internals.url) {
return (this._internals.url as URL).searchParams;
}
if (this._internals.searchParams === undefined) {
this._internals.searchParams = new URLSearchParams();
}
return this._internals.searchParams;
}
set searchParams(value: string | SearchParameters | URLSearchParams | undefined) {
assert.any([is.string, is.object, is.undefined], value);
const url = this._internals.url as URL;
if (value === undefined) {
this._internals.searchParams = undefined;
if (url) {
url.search = '';
}
return;
}
const searchParameters = this.searchParams as URLSearchParams;
let updated;
if (is.string(value)) {
updated = new URLSearchParams(value);
} else if (value instanceof URLSearchParams) {
updated = value;
} else {
validateSearchParameters(value);
updated = new URLSearchParams();
// eslint-disable-next-line guard-for-in
for (const key in value) {
const entry = value[key];
if (entry === null) {
updated.append(key, '');
} else if (entry === undefined) {
searchParameters.delete(key);
} else {
updated.append(key, entry as string);
}
}
}
if (this._merging) {
// These keys will be replaced
for (const key of updated.keys()) {
searchParameters.delete(key);
}
for (const [key, value] of updated) {
searchParameters.append(key, value);
}
} else if (url) {
url.search = searchParameters.toString();
} else {
this._internals.searchParams = searchParameters;
}
}
get searchParameters() {
throw new Error('The `searchParameters` option does not exist. Use `searchParams` instead.');
}
set searchParameters(_value: unknown) {
throw new Error('The `searchParameters` option does not exist. Use `searchParams` instead.');
}
get dnsLookup(): CacheableLookup['lookup'] | undefined {
return this._internals.dnsLookup;
}
set dnsLookup(value: CacheableLookup['lookup'] | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.dnsLookup = value;
}
/**
An instance of [`CacheableLookup`](https://github.com/szmarczak/cacheable-lookup) used for making DNS lookups.
Useful when making lots of requests to different *public* hostnames.
`CacheableLookup` uses `dns.resolver4(..)` and `dns.resolver6(...)` under the hood and fall backs to `dns.lookup(...)` when the first two fail, which may lead to additional delay.
__Note__: This should stay disabled when making requests to internal hostnames such as `localhost`, `database.local` etc.
@default false
*/
get dnsCache(): CacheableLookup | boolean | undefined {
return this._internals.dnsCache;
}
set dnsCache(value: CacheableLookup | boolean | undefined) {
assert.any([is.object, is.boolean, is.undefined], value);
if (value === true) {
this._internals.dnsCache = getGlobalDnsCache();
} else if (value === false) {
this._internals.dnsCache = undefined;
} else {
this._internals.dnsCache = value;
}
}
/**
User data. `context` is shallow merged and enumerable. If it contains non-enumerable properties they will NOT be merged.
@example
```
import got from 'got';
const instance = got.extend({
hooks: {
beforeRequest: [
options => {
if (!options.context || !options.context.token) {
throw new Error('Token required');
}
options.headers.token = options.context.token;
}
]
}
});
const context = {
token: 'secret'
};
const response = await instance('https://httpbin.org/headers', {context});
// Let's see the headers
console.log(response.body);
```
*/
get context(): Record<string, unknown> {
return this._internals.context;
}
set context(value: Record<string, unknown>) {
assert.object(value);
if (this._merging) {
Object.assign(this._internals.context, value);
} else {
this._internals.context = {...value};
}
}
/**
Hooks allow modifications during the request lifecycle.
Hook functions may be async and are run serially.
*/
get hooks(): Hooks {
return this._internals.hooks;
}
set hooks(value: Hooks) {
assert.object(value);
// eslint-disable-next-line guard-for-in
for (const knownHookEvent in value) {
if (!(knownHookEvent in this._internals.hooks)) {
throw new Error(`Unexpected hook event: ${knownHookEvent}`);
}
const typedKnownHookEvent = knownHookEvent as keyof Hooks;
const hooks = value[typedKnownHookEvent];
assert.any([is.array, is.undefined], hooks);
if (hooks) {
for (const hook of hooks) {
assert.function_(hook);
}
}
if (this._merging) {
if (hooks) {
// @ts-expect-error FIXME
this._internals.hooks[typedKnownHookEvent].push(...hooks);
}
} else {
if (!hooks) {
throw new Error(`Missing hook event: ${knownHookEvent}`);
}
// @ts-expect-error FIXME
this._internals.hooks[knownHookEvent] = [...hooks];
}
}
}
/**
Defines if redirect responses should be followed automatically.
Note that if a `303` is sent by the server in response to any request type (`POST`, `DELETE`, etc.), Got will automatically request the resource pointed to in the location header via `GET`.
This is in accordance with [the spec](https://tools.ietf.org/html/rfc7231#section-6.4.4). You can optionally turn on this behavior also for other redirect codes - see `methodRewriting`.
@default true
*/
get followRedirect(): boolean {
return this._internals.followRedirect;
}
set followRedirect(value: boolean) {
assert.boolean(value);
this._internals.followRedirect = value;
}
get followRedirects() {
throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
}
set followRedirects(_value: unknown) {
throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
}
/**
If exceeded, the request will be aborted and a `MaxRedirectsError` will be thrown.
@default 10
*/
get maxRedirects(): number {
return this._internals.maxRedirects;
}
set maxRedirects(value: number) {
assert.number(value);
this._internals.maxRedirects = value;
}
/**
A cache adapter instance for storing cached response data.
@default false
*/
get cache(): string | StorageAdapter | boolean | undefined {
return this._internals.cache;
}
set cache(value: string | StorageAdapter | boolean | undefined) {
assert.any([is.object, is.string, is.boolean, is.undefined], value);
if (value === true) {
this._internals.cache = globalCache;
} else if (value === false) {
this._internals.cache = undefined;
} else {
this._internals.cache = value;
}
}
/**
Determines if a `got.HTTPError` is thrown for unsuccessful responses.
If this is disabled, requests that encounter an error status code will be resolved with the `response` instead of throwing.
This may be useful if you are checking for resource availability and are expecting error responses.
@default true
*/
get throwHttpErrors(): boolean {
return this._internals.throwHttpErrors;
}
set throwHttpErrors(value: boolean) {
assert.boolean(value);
this._internals.throwHttpErrors = value;
}
get username(): string {
const url = this._internals.url as URL;
const value = url ? url.username : this._internals.username;
return decodeURIComponent(value);
}
set username(value: string) {
assert.string(value);
const url = this._internals.url as URL;
const fixedValue = encodeURIComponent(value);
if (url) {
url.username = fixedValue;
} else {
this._internals.username = fixedValue;
}
}
get password(): string {
const url = this._internals.url as URL;
const value = url ? url.password : this._internals.password;
return decodeURIComponent(value);
}
set password(value: string) {
assert.string(value);
const url = this._internals.url as URL;
const fixedValue = encodeURIComponent(value);
if (url) {
url.password = fixedValue;
} else {
this._internals.password = fixedValue;
}
}
/**
If set to `true`, Got will additionally accept HTTP2 requests.
It will choose either HTTP/1.1 or HTTP/2 depending on the ALPN protocol.
__Note__: This option requires Node.js 15.10.0 or newer as HTTP/2 support on older Node.js versions is very buggy.
__Note__: Overriding `options.request` will disable HTTP2 support.
@default false
@example
```
import got from 'got';
const {headers} = await got('https://nghttp2.org/httpbin/anything', {http2: true});
console.log(headers.via);
//=> '2 nghttpx'
```
*/
get http2(): boolean {
return this._internals.http2;
}
set http2(value: boolean) {
assert.boolean(value);
this._internals.http2 = value;
}
/**
Set this to `true` to allow sending body for the `GET` method.
However, the [HTTP/2 specification](https://tools.ietf.org/html/rfc7540#section-8.1.3) says that `An HTTP GET request includes request header fields and no payload body`, therefore when using the HTTP/2 protocol this option will have no effect.
This option is only meant to interact with non-compliant servers when you have no other choice.
__Note__: The [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.1) doesn't specify any particular behavior for the GET method having a payload, therefore __it's considered an [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern)__.
@default false
*/
get allowGetBody(): boolean {
return this._internals.allowGetBody;
}
set allowGetBody(value: boolean) {
assert.boolean(value);
this._internals.allowGetBody = value;
}
/**
Request headers.
Existing headers will be overwritten. Headers set to `undefined` will be omitted.
@default {}
*/
get headers(): Headers {
return this._internals.headers;
}
set headers(value: Headers) {
assert.plainObject(value);
if (this._merging) {
Object.assign(this._internals.headers, lowercaseKeys(value));
} else {
this._internals.headers = lowercaseKeys(value);
}
}
/**
Specifies if the HTTP request method should be [rewritten as `GET`](https://tools.ietf.org/html/rfc7231#section-6.4) on redirects.
As the [specification](https://tools.ietf.org/html/rfc7231#section-6.4) prefers to rewrite the HTTP method only on `303` responses, this is Got's default behavior.
Setting `methodRewriting` to `true` will also rewrite `301` and `302` responses, as allowed by the spec. This is the behavior followed by `curl` and browsers.
__Note__: Got never performs method rewriting on `307` and `308` responses, as this is [explicitly prohibited by the specification](https://www.rfc-editor.org/rfc/rfc7231#section-6.4.7).
@default false
*/
get methodRewriting(): boolean {
return this._internals.methodRewriting;
}
set methodRewriting(value: boolean) {
assert.boolean(value);
this._internals.methodRewriting = value;
}
/**
Indicates which DNS record family to use.
Values:
- `undefined`: IPv4 (if present) or IPv6
- `4`: Only IPv4
- `6`: Only IPv6
@default undefined
*/
get dnsLookupIpVersion(): DnsLookupIpVersion {
return this._internals.dnsLookupIpVersion;
}
set dnsLookupIpVersion(value: DnsLookupIpVersion) {
if (value !== undefined && value !== 4 && value !== 6) {
throw new TypeError(`Invalid DNS lookup IP version: ${value as string}`);
}
this._internals.dnsLookupIpVersion = value;
}
/**
A function used to parse JSON responses.
@example
```
import got from 'got';
import Bourne from '@hapi/bourne';
const parsed = await got('https://example.com', {
parseJson: text => Bourne.parse(text)
}).json();
console.log(parsed);
```
*/
get parseJson(): ParseJsonFunction {
return this._internals.parseJson;
}
set parseJson(value: ParseJsonFunction) {
assert.function_(value);
this._internals.parseJson = value;
}
/**
A function used to stringify the body of JSON requests.
@example
```
import got from 'got';
await got.post('https://example.com', {
stringifyJson: object => JSON.stringify(object, (key, value) => {
if (key.startsWith('_')) {
return;
}
return value;
}),
json: {
some: 'payload',
_ignoreMe: 1234
}
});
```
@example
```
import got from 'got';
await got.post('https://example.com', {
stringifyJson: object => JSON.stringify(object, (key, value) => {
if (typeof value === 'number') {
return value.toString();
}
return value;
}),
json: {
some: 'payload',
number: 1
}
});
```
*/
get stringifyJson(): StringifyJsonFunction {
return this._internals.stringifyJson;
}
set stringifyJson(value: StringifyJsonFunction) {
assert.function_(value);
this._internals.stringifyJson = value;
}
/**
An object representing `limit`, `calculateDelay`, `methods`, `statusCodes`, `maxRetryAfter` and `errorCodes` fields for maximum retry count, retry handler, allowed methods, allowed status codes, maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.
Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 1).
The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
By default, it retries *only* on the specified methods, status codes, and on these network errors:
- `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
- `ECONNRESET`: Connection was forcibly closed by a peer.
- `EADDRINUSE`: Could not bind to any free port.
- `ECONNREFUSED`: Connection was refused by the server.
- `EPIPE`: The remote side of the stream being written has been closed.
- `ENOTFOUND`: Couldn't resolve the hostname to an IP address.
- `ENETUNREACH`: No internet connection.
- `EAI_AGAIN`: DNS lookup timed out.
__Note__: If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.
__Note__: If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
*/
get retry(): Partial<RetryOptions> {
return this._internals.retry;
}
set retry(value: Partial<RetryOptions>) {
assert.plainObject(value);
assert.any([is.function_, is.undefined], value.calculateDelay);
assert.any([is.number, is.undefined], value.maxRetryAfter);
assert.any([is.number, is.undefined], value.limit);
assert.any([is.array, is.undefined], value.methods);
assert.any([is.array, is.undefined], value.statusCodes);
assert.any([is.array, is.undefined], value.errorCodes);
assert.any([is.number, is.undefined], value.noise);
if (value.noise && Math.abs(value.noise) > 100) {
throw new Error(`The maximum acceptable retry noise is +/- 100ms, got ${value.noise}`);
}
for (const key in value) {
if (!(key in this._internals.retry)) {
throw new Error(`Unexpected retry option: ${key}`);
}
}
if (this._merging) {
Object.assign(this._internals.retry, value);
} else {
this._internals.retry = {...value};
}
const {retry} = this._internals;
retry.methods = [...new Set(retry.methods!.map(method => method.toUpperCase() as Method))];
retry.statusCodes = [...new Set(retry.statusCodes)];
retry.errorCodes = [...new Set(retry.errorCodes)];
}
/**
From `http.RequestOptions`.
The IP address used to send the request from.
*/
get localAddress(): string | undefined {
return this._internals.localAddress;
}
set localAddress(value: string | undefined) {
assert.any([is.string, is.undefined], value);
this._internals.localAddress = value;
}
/**
The HTTP method used to make the request.
@default 'GET'
*/
get method(): Method {
return this._internals.method;
}
set method(value: Method) {
assert.string(value);
this._internals.method = value.toUpperCase() as Method;
}
get createConnection(): CreateConnectionFunction | undefined {
return this._internals.createConnection;
}
set createConnection(value: CreateConnectionFunction | undefined) {
assert.any([is.function_, is.undefined], value);
this._internals.createConnection = value;
}
/**
From `http-cache-semantics`
@default {}
*/
get cacheOptions(): CacheOptions {
return this._internals.cacheOptions;
}
set cacheOptions(value: CacheOptions) {
assert.plainObject(value);
assert.any([is.boolean, is.undefined], value.shared);
assert.any([is.number, is.undefined], value.cacheHeuristic);
assert.any([is.number, is.undefined], value.immutableMinTimeToLive);
assert.any([is.boolean, is.undefined], value.ignoreCargoCult);
for (const key in value) {
if (!(key in this._internals.cacheOptions)) {
throw new Error(`Cache option \`${key}\` does not exist`);
}
}
if (this._merging) {
Object.assign(this._internals.cacheOptions, value);
} else {
this._internals.cacheOptions = {...value};
}
}
/**
Options for the advanced HTTPS API.
*/
get https(): HttpsOptions {
return this._internals.https;
}
set https(value: HttpsOptions) {
assert.plainObject(value);
assert.any([is.boolean, is.undefined], value.rejectUnauthorized);
assert.any([is.function_, is.undefined], value.checkServerIdentity);
assert.any([is.string, is.object, is.array, is.undefined], value.certificateAuthority);
assert.any([is.string, is.object, is.array, is.undefined], value.key);
assert.any([is.string, is.object, is.array, is.undefined], value.certificate);
assert.any([is.string, is.undefined], value.passphrase);
assert.any([is.string, is.buffer, is.array, is.undefined], value.pfx);
assert.any([is.array, is.undefined], value.alpnProtocols);
assert.any([is.string, is.undefined], value.ciphers);
assert.any([is.string, is.buffer, is.undefined], value.dhparam);
assert.any([is.string, is.undefined], value.signatureAlgorithms);
assert.any([is.string, is.undefined], value.minVersion);
assert.any([is.string, is.undefined], value.maxVersion);
assert.any([is.boolean, is.undefined], value.honorCipherOrder);
assert.any([is.number, is.undefined], value.tlsSessionLifetime);
assert.any([is.string, is.undefined], value.ecdhCurve);
assert.any([is.string, is.buffer, is.array, is.undefined], value.certificateRevocationLists);
for (const key in value) {
if (!(key in this._internals.https)) {
throw new Error(`HTTPS option \`${key}\` does not exist`);
}
}
if (this._merging) {
Object.assign(this._internals.https, value);
} else {
this._internals.https = {...value};
}
}
/**
[Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data.
To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set `responseType` to `buffer` instead.
Don't set this option to `null`.
__Note__: This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
@default 'utf-8'
*/
get encoding(): BufferEncoding | undefined {
return this._internals.encoding;
}
set encoding(value: BufferEncoding | undefined) {
if (value === null) {
throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead');
}
assert.any([is.string, is.undefined], value);
this._internals.encoding = value;
}
/**
When set to `true` the promise will return the Response body instead of the Response object.
@default false
*/
get resolveBodyOnly(): boolean {
return this._internals.resolveBodyOnly;
}
set resolveBodyOnly(value: boolean) {
assert.boolean(value);
this._internals.resolveBodyOnly = value;
}
/**
Returns a `Stream` instead of a `Promise`.
This is equivalent to calling `got.stream(url, options?)`.
@default false
*/
get isStream(): boolean {
return this._internals.isStream;
}
set isStream(value: boolean) {
assert.boolean(value);
this._internals.isStream = value;
}
/**
The parsing method.
The promise also has `.text()`, `.json()` and `.buffer()` methods which return another Got promise for the parsed body.
It's like setting the options to `{responseType: 'json', resolveBodyOnly: true}` but without affecting the main Got promise.
__Note__: When using streams, this option is ignored.
@example
```
const responsePromise = got(url);
const bufferPromise = responsePromise.buffer();
const jsonPromise = responsePromise.json();
const [response, buffer, json] = Promise.all([responsePromise, bufferPromise, jsonPromise]);
// `response` is an instance of Got Response
// `buffer` is an instance of Buffer
// `json` is an object
```
@example
```
// This
const body = await got(url).json();
// is semantically the same as this
const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
```
*/
get responseType(): ResponseType {
return this._internals.responseType;
}
set responseType(value: ResponseType) {
if (value === undefined) {
this._internals.responseType = 'text';
return;
}
if (value !== 'text' && value !== 'buffer' && value !== 'json') {
throw new Error(`Invalid \`responseType\` option: ${value as string}`);
}
this._internals.responseType = value;
}
get pagination(): PaginationOptions<unknown, unknown> {
return this._internals.pagination;
}
set pagination(value: PaginationOptions<unknown, unknown>) {
assert.object(value);
if (this._merging) {
Object.assign(this._internals.pagination, value);
} else {
this._internals.pagination = value;
}
}
get auth() {
throw new Error('Parameter `auth` is deprecated. Use `username` / `password` instead.');
}
set auth(_value: unknown) {
throw new Error('Parameter `auth` is deprecated. Use `username` / `password` instead.');
}
get setHost() {
return this._internals.setHost;
}
set setHost(value: boolean) {
assert.boolean(value);
this._internals.setHost = value;
}
get maxHeaderSize() {
return this._internals.maxHeaderSize;
}
set maxHeaderSize(value: number | undefined) {
assert.any([is.number, is.undefined], value);
this._internals.maxHeaderSize = value;
}
get enableUnixSockets() {
return this._internals.enableUnixSockets;
}
set enableUnixSockets(value: boolean) {
assert.boolean(value);
this._internals.enableUnixSockets = value;
}
// eslint-disable-next-line @typescript-eslint/naming-convention
toJSON() {
return {...this._internals};
}
[Symbol.for('nodejs.util.inspect.custom')](_depth: number, options: InspectOptions) {
return inspect(this._internals, options);
}
createNativeRequestOptions() {
const internals = this._internals;
const url = internals.url as URL;
let agent;
if (url.protocol === 'https:') {
agent = internals.http2 ? internals.agent : internals.agent.https;
} else {
agent = internals.agent.http;
}
const {https} = internals;
let {pfx} = https;
if (is.array(pfx) && is.plainObject(pfx[0])) {
pfx = (pfx as PfxObject[]).map(object => ({
buf: object.buffer,
passphrase: object.passphrase,
})) as any;
}
return {
...internals.cacheOptions,
...this._unixOptions,
// HTTPS options
// eslint-disable-next-line @typescript-eslint/naming-convention
ALPNProtocols: https.alpnProtocols,
ca: https.certificateAuthority,
cert: https.certificate,
key: https.key,
passphrase: https.passphrase,
pfx: https.pfx,
rejectUnauthorized: https.rejectUnauthorized,
checkServerIdentity: https.checkServerIdentity ?? checkServerIdentity,
ciphers: https.ciphers,
honorCipherOrder: https.honorCipherOrder,
minVersion: https.minVersion,
maxVersion: https.maxVersion,
sigalgs: https.signatureAlgorithms,
sessionTimeout: https.tlsSessionLifetime,
dhparam: https.dhparam,
ecdhCurve: https.ecdhCurve,
crl: https.certificateRevocationLists,
// HTTP options
lookup: internals.dnsLookup ?? (internals.dnsCache as CacheableLookup | undefined)?.lookup,
family: internals.dnsLookupIpVersion,
agent,
setHost: internals.setHost,
method: internals.method,
maxHeaderSize: internals.maxHeaderSize,
localAddress: internals.localAddress,
headers: internals.headers,
createConnection: internals.createConnection,
timeout: internals.http2 ? getHttp2TimeoutOption(internals) : undefined,
// HTTP/2 options
h2session: internals.h2session,
};
}
getRequestFunction() {
const url = this._internals.url as (URL | undefined);
const {request} = this._internals;
if (!request && url) {
return this.getFallbackRequestFunction();
}
return request;
}
getFallbackRequestFunction() {
const url = this._internals.url as (URL | undefined);
if (!url) {
return;
}
if (url.protocol === 'https:') {
if (this._internals.http2) {
if (major < 15 || (major === 15 && minor < 10)) {
const error = new Error('To use the `http2` option, install Node.js 15.10.0 or above');
(error as NodeJS.ErrnoException).code = 'EUNSUPPORTED';
throw error;
}
return http2wrapper.auto as RequestFunction;
}
return https.request;
}
return http.request;
}
freeze() {
const options = this._internals;
Object.freeze(options);
Object.freeze(options.hooks);
Object.freeze(options.hooks.afterResponse);
Object.freeze(options.hooks.beforeError);
Object.freeze(options.hooks.beforeRedirect);
Object.freeze(options.hooks.beforeRequest);
Object.freeze(options.hooks.beforeRetry);
Object.freeze(options.hooks.init);
Object.freeze(options.https);
Object.freeze(options.cacheOptions);
Object.freeze(options.agent);
Object.freeze(options.headers);
Object.freeze(options.timeout);
Object.freeze(options.retry);
Object.freeze(options.retry.errorCodes);
Object.freeze(options.retry.methods);
Object.freeze(options.retry.statusCodes);
}
} |
426 | set agent(value: Agents) {
assert.plainObject(value);
// eslint-disable-next-line guard-for-in
for (const key in value) {
if (!(key in this._internals.agent)) {
throw new TypeError(`Unexpected agent option: ${key}`);
}
// @ts-expect-error - No idea why `value[key]` doesn't work here.
assert.any([is.object, is.undefined], value[key]);
}
if (this._merging) {
Object.assign(this._internals.agent, value);
} else {
this._internals.agent = {...value};
}
} | type Agents = {
http?: HttpAgent | false;
https?: HttpsAgent | false;
http2?: unknown | false;
}; |
427 | set timeout(value: Delays) {
assert.plainObject(value);
// eslint-disable-next-line guard-for-in
for (const key in value) {
if (!(key in this._internals.timeout)) {
throw new Error(`Unexpected timeout option: ${key}`);
}
// @ts-expect-error - No idea why `value[key]` doesn't work here.
assert.any([is.number, is.undefined], value[key]);
}
if (this._merging) {
Object.assign(this._internals.timeout, value);
} else {
this._internals.timeout = {...value};
}
} | type Delays = {
lookup?: number;
socket?: number;
connect?: number;
secureConnect?: number;
send?: number;
response?: number;
read?: number;
request?: number;
}; |
428 | set hooks(value: Hooks) {
assert.object(value);
// eslint-disable-next-line guard-for-in
for (const knownHookEvent in value) {
if (!(knownHookEvent in this._internals.hooks)) {
throw new Error(`Unexpected hook event: ${knownHookEvent}`);
}
const typedKnownHookEvent = knownHookEvent as keyof Hooks;
const hooks = value[typedKnownHookEvent];
assert.any([is.array, is.undefined], hooks);
if (hooks) {
for (const hook of hooks) {
assert.function_(hook);
}
}
if (this._merging) {
if (hooks) {
// @ts-expect-error FIXME
this._internals.hooks[typedKnownHookEvent].push(...hooks);
}
} else {
if (!hooks) {
throw new Error(`Missing hook event: ${knownHookEvent}`);
}
// @ts-expect-error FIXME
this._internals.hooks[knownHookEvent] = [...hooks];
}
}
} | type Hooks = {
/**
Called with the plain request options, right before their normalization.
The second argument represents the current `Options` instance.
@default []
**Note:**
> - This hook must be synchronous.
**Note:**
> - This is called every time options are merged.
**Note:**
> - The `options` object may not have the `url` property. To modify it, use a `beforeRequest` hook instead.
**Note:**
> - This hook is called when a new instance of `Options` is created.
> - Do not confuse this with the creation of `Request` or `got(…)`.
**Note:**
> - When using `got(url)` or `got(url, undefined, defaults)` this hook will **not** be called.
This is especially useful in conjunction with `got.extend()` when the input needs custom handling.
For example, this can be used to fix typos to migrate from older versions faster.
@example
```
import got from 'got';
const instance = got.extend({
hooks: {
init: [
plain => {
if ('followRedirects' in plain) {
plain.followRedirect = plain.followRedirects;
delete plain.followRedirects;
}
}
]
}
});
// Normally, the following would throw:
const response = await instance(
'https://example.com',
{
followRedirects: true
}
);
// There is no option named `followRedirects`, but we correct it in an `init` hook.
```
Or you can create your own option and store it in a context:
```
import got from 'got';
const instance = got.extend({
hooks: {
init: [
(plain, options) => {
if ('secret' in plain) {
options.context.secret = plain.secret;
delete plain.secret;
}
}
],
beforeRequest: [
options => {
options.headers.secret = options.context.secret;
}
]
}
});
const {headers} = await instance(
'https://httpbin.org/anything',
{
secret: 'passphrase'
}
).json();
console.log(headers.Secret);
//=> 'passphrase'
```
*/
init: InitHook[];
/**
Called right before making the request with `options.createNativeRequestOptions()`.
This hook is especially useful in conjunction with `got.extend()` when you want to sign your request.
@default []
**Note:**
> - Got will make no further changes to the request before it is sent.
**Note:**
> - Changing `options.json` or `options.form` has no effect on the request. You should change `options.body` instead. If needed, update the `options.headers` accordingly.
@example
```
import got from 'got';
const response = await got.post(
'https://httpbin.org/anything',
{
json: {payload: 'old'},
hooks: {
beforeRequest: [
options => {
options.body = JSON.stringify({payload: 'new'});
options.headers['content-length'] = options.body.length.toString();
}
]
}
}
);
```
**Tip:**
> - You can indirectly override the `request` function by early returning a [`ClientRequest`-like](https://nodejs.org/api/http.html#http_class_http_clientrequest) instance or a [`IncomingMessage`-like](https://nodejs.org/api/http.html#http_class_http_incomingmessage) instance. This is very useful when creating a custom cache mechanism.
> - [Read more about this tip](https://github.com/sindresorhus/got/blob/main/documentation/cache.md#advanced-caching-mechanisms).
*/
beforeRequest: BeforeRequestHook[];
/**
The equivalent of `beforeRequest` but when redirecting.
@default []
**Tip:**
> - This is especially useful when you want to avoid dead sites.
@example
```
import got from 'got';
const response = await got('https://example.com', {
hooks: {
beforeRedirect: [
(options, response) => {
if (options.hostname === 'deadSite') {
options.hostname = 'fallbackSite';
}
}
]
}
});
```
*/
beforeRedirect: BeforeRedirectHook[];
/**
Called with a `RequestError` instance. The error is passed to the hook right before it's thrown.
This is especially useful when you want to have more detailed errors.
@default []
```
import got from 'got';
await got('https://api.github.com/repos/sindresorhus/got/commits', {
responseType: 'json',
hooks: {
beforeError: [
error => {
const {response} = error;
if (response && response.body) {
error.name = 'GitHubError';
error.message = `${response.body.message} (${response.statusCode})`;
}
return error;
}
]
}
});
```
*/
beforeError: BeforeErrorHook[];
/**
The equivalent of `beforeError` but when retrying. Additionally, there is a second argument `retryCount`, the current retry number.
@default []
**Note:**
> - When using the Stream API, this hook is ignored.
**Note:**
> - When retrying, the `beforeRequest` hook is called afterwards.
**Note:**
> - If no retry occurs, the `beforeError` hook is called instead.
This hook is especially useful when you want to retrieve the cause of a retry.
@example
```
import got from 'got';
await got('https://httpbin.org/status/500', {
hooks: {
beforeRetry: [
(error, retryCount) => {
console.log(`Retrying [${retryCount}]: ${error.code}`);
// Retrying [1]: ERR_NON_2XX_3XX_RESPONSE
}
]
}
});
```
*/
beforeRetry: BeforeRetryHook[];
/**
Each function should return the response. This is especially useful when you want to refresh an access token.
@default []
**Note:**
> - When using the Stream API, this hook is ignored.
**Note:**
> - Calling the `retryWithMergedOptions` function will trigger `beforeRetry` hooks. If the retry is successful, all remaining `afterResponse` hooks will be called. In case of an error, `beforeRetry` hooks will be called instead.
Meanwhile the `init`, `beforeRequest` , `beforeRedirect` as well as already executed `afterResponse` hooks will be skipped.
@example
```
import got from 'got';
const instance = got.extend({
hooks: {
afterResponse: [
(response, retryWithMergedOptions) => {
// Unauthorized
if (response.statusCode === 401) {
// Refresh the access token
const updatedOptions = {
headers: {
token: getNewToken()
}
};
// Update the defaults
instance.defaults.options.merge(updatedOptions);
// Make a new retry
return retryWithMergedOptions(updatedOptions);
}
// No changes otherwise
return response;
}
],
beforeRetry: [
error => {
// This will be called on `retryWithMergedOptions(...)`
}
]
},
mutableDefaults: true
});
```
*/
afterResponse: AfterResponseHook[];
}; |
429 | set headers(value: Headers) {
assert.plainObject(value);
if (this._merging) {
Object.assign(this._internals.headers, lowercaseKeys(value));
} else {
this._internals.headers = lowercaseKeys(value);
}
} | type Headers = Record<string, string | string[] | undefined>; |
430 | set dnsLookupIpVersion(value: DnsLookupIpVersion) {
if (value !== undefined && value !== 4 && value !== 6) {
throw new TypeError(`Invalid DNS lookup IP version: ${value as string}`);
}
this._internals.dnsLookupIpVersion = value;
} | type DnsLookupIpVersion = undefined | 4 | 6; |
431 | set parseJson(value: ParseJsonFunction) {
assert.function_(value);
this._internals.parseJson = value;
} | type ParseJsonFunction = (text: string) => unknown; |
432 | set stringifyJson(value: StringifyJsonFunction) {
assert.function_(value);
this._internals.stringifyJson = value;
} | type StringifyJsonFunction = (object: unknown) => string; |
433 | set method(value: Method) {
assert.string(value);
this._internals.method = value.toUpperCase() as Method;
} | type Method =
| 'GET'
| 'POST'
| 'PUT'
| 'PATCH'
| 'HEAD'
| 'DELETE'
| 'OPTIONS'
| 'TRACE'
| 'get'
| 'post'
| 'put'
| 'patch'
| 'head'
| 'delete'
| 'options'
| 'trace'; |
434 | set cacheOptions(value: CacheOptions) {
assert.plainObject(value);
assert.any([is.boolean, is.undefined], value.shared);
assert.any([is.number, is.undefined], value.cacheHeuristic);
assert.any([is.number, is.undefined], value.immutableMinTimeToLive);
assert.any([is.boolean, is.undefined], value.ignoreCargoCult);
for (const key in value) {
if (!(key in this._internals.cacheOptions)) {
throw new Error(`Cache option \`${key}\` does not exist`);
}
}
if (this._merging) {
Object.assign(this._internals.cacheOptions, value);
} else {
this._internals.cacheOptions = {...value};
}
} | type CacheOptions = {
shared?: boolean;
cacheHeuristic?: number;
immutableMinTimeToLive?: number;
ignoreCargoCult?: boolean;
}; |
435 | set https(value: HttpsOptions) {
assert.plainObject(value);
assert.any([is.boolean, is.undefined], value.rejectUnauthorized);
assert.any([is.function_, is.undefined], value.checkServerIdentity);
assert.any([is.string, is.object, is.array, is.undefined], value.certificateAuthority);
assert.any([is.string, is.object, is.array, is.undefined], value.key);
assert.any([is.string, is.object, is.array, is.undefined], value.certificate);
assert.any([is.string, is.undefined], value.passphrase);
assert.any([is.string, is.buffer, is.array, is.undefined], value.pfx);
assert.any([is.array, is.undefined], value.alpnProtocols);
assert.any([is.string, is.undefined], value.ciphers);
assert.any([is.string, is.buffer, is.undefined], value.dhparam);
assert.any([is.string, is.undefined], value.signatureAlgorithms);
assert.any([is.string, is.undefined], value.minVersion);
assert.any([is.string, is.undefined], value.maxVersion);
assert.any([is.boolean, is.undefined], value.honorCipherOrder);
assert.any([is.number, is.undefined], value.tlsSessionLifetime);
assert.any([is.string, is.undefined], value.ecdhCurve);
assert.any([is.string, is.buffer, is.array, is.undefined], value.certificateRevocationLists);
for (const key in value) {
if (!(key in this._internals.https)) {
throw new Error(`HTTPS option \`${key}\` does not exist`);
}
}
if (this._merging) {
Object.assign(this._internals.https, value);
} else {
this._internals.https = {...value};
}
} | type HttpsOptions = {
alpnProtocols?: string[];
// From `http.RequestOptions` and `tls.CommonConnectionOptions`
rejectUnauthorized?: NativeRequestOptions['rejectUnauthorized'];
// From `tls.ConnectionOptions`
checkServerIdentity?: CheckServerIdentityFunction;
// From `tls.SecureContextOptions`
/**
Override the default Certificate Authorities ([from Mozilla](https://ccadb-public.secure.force.com/mozilla/IncludedCACertificateReport)).
@example
```
// Single Certificate Authority
await got('https://example.com', {
https: {
certificateAuthority: fs.readFileSync('./my_ca.pem')
}
});
```
*/
certificateAuthority?: SecureContextOptions['ca'];
/**
Private keys in [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) format.
[PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) allows the option of private keys being encrypted.
Encrypted keys will be decrypted with `options.https.passphrase`.
Multiple keys with different passphrases can be provided as an array of `{pem: <string | Buffer>, passphrase: <string>}`
*/
key?: SecureContextOptions['key'];
/**
[Certificate chains](https://en.wikipedia.org/wiki/X.509#Certificate_chains_and_cross-certification) in [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) format.
One cert chain should be provided per private key (`options.https.key`).
When providing multiple cert chains, they do not have to be in the same order as their private keys in `options.https.key`.
If the intermediate certificates are not provided, the peer will not be able to validate the certificate, and the handshake will fail.
*/
certificate?: SecureContextOptions['cert'];
/**
The passphrase to decrypt the `options.https.key` (if different keys have different passphrases refer to `options.https.key` documentation).
*/
passphrase?: SecureContextOptions['passphrase'];
pfx?: PfxType;
ciphers?: SecureContextOptions['ciphers'];
honorCipherOrder?: SecureContextOptions['honorCipherOrder'];
minVersion?: SecureContextOptions['minVersion'];
maxVersion?: SecureContextOptions['maxVersion'];
signatureAlgorithms?: SecureContextOptions['sigalgs'];
tlsSessionLifetime?: SecureContextOptions['sessionTimeout'];
dhparam?: SecureContextOptions['dhparam'];
ecdhCurve?: SecureContextOptions['ecdhCurve'];
certificateRevocationLists?: SecureContextOptions['crl'];
}; |
436 | set responseType(value: ResponseType) {
if (value === undefined) {
this._internals.responseType = 'text';
return;
}
if (value !== 'text' && value !== 'buffer' && value !== 'json') {
throw new Error(`Invalid \`responseType\` option: ${value as string}`);
}
this._internals.responseType = value;
} | type ResponseType = 'json' | 'buffer' | 'text'; |
437 | (origin: Origin, event: Event, fn: Fn) => void | type Origin = EventEmitter; |
438 | (origin: Origin, event: Event, fn: Fn) => void | type Event = string | symbol; |
439 | (origin: Origin, event: Event, fn: Fn) => void | type Fn = (...args: unknown[]) => void; |
440 | (origin: Origin, event: Event, fn: Fn) => void | type Fn = (...args: any[]) => void; |
441 | once(origin: Origin, event: Event, fn: Fn) {
origin.once(event, fn);
handlers.push({origin, event, fn});
} | type Origin = EventEmitter; |
442 | once(origin: Origin, event: Event, fn: Fn) {
origin.once(event, fn);
handlers.push({origin, event, fn});
} | type Event = string | symbol; |
443 | once(origin: Origin, event: Event, fn: Fn) {
origin.once(event, fn);
handlers.push({origin, event, fn});
} | type Fn = (...args: unknown[]) => void; |
444 | once(origin: Origin, event: Event, fn: Fn) {
origin.once(event, fn);
handlers.push({origin, event, fn});
} | type Fn = (...args: any[]) => void; |
445 | constructor(request: Request) {
super('Promise was canceled', {}, request);
this.name = 'CancelError';
this.code = 'ERR_CANCELED';
} | class Request extends Duplex implements RequestEvents<Request> {
// @ts-expect-error - Ignoring for now.
override ['constructor']: typeof Request;
_noPipe?: boolean;
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/9568
options: Options;
response?: PlainResponse;
requestUrl?: URL;
redirectUrls: URL[];
retryCount: number;
declare private _requestOptions: NativeRequestOptions;
private _stopRetry: () => void;
private _downloadedSize: number;
private _uploadedSize: number;
private _stopReading: boolean;
private readonly _pipedServerResponses: Set<ServerResponse>;
private _request?: ClientRequest;
private _responseSize?: number;
private _bodySize?: number;
private _unproxyEvents: () => void;
private _isFromCache?: boolean;
private _cannotHaveBody: boolean;
private _triggerRead: boolean;
declare private _jobs: Array<() => void>;
private _cancelTimeouts: () => void;
private readonly _removeListeners: () => void;
private _nativeResponse?: IncomingMessageWithTimings;
private _flushed: boolean;
private _aborted: boolean;
// We need this because `this._request` if `undefined` when using cache
private _requestInitialized: boolean;
constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType) {
super({
// Don't destroy immediately, as the error may be emitted on unsuccessful retry
autoDestroy: false,
// It needs to be zero because we're just proxying the data to another stream
highWaterMark: 0,
});
this._downloadedSize = 0;
this._uploadedSize = 0;
this._stopReading = false;
this._pipedServerResponses = new Set<ServerResponse>();
this._cannotHaveBody = false;
this._unproxyEvents = noop;
this._triggerRead = false;
this._cancelTimeouts = noop;
this._removeListeners = noop;
this._jobs = [];
this._flushed = false;
this._requestInitialized = false;
this._aborted = false;
this.redirectUrls = [];
this.retryCount = 0;
this._stopRetry = noop;
this.on('pipe', source => {
if (source.headers) {
Object.assign(this.options.headers, source.headers);
}
});
this.on('newListener', event => {
if (event === 'retry' && this.listenerCount('retry') > 0) {
throw new Error('A retry listener has been attached already.');
}
});
try {
this.options = new Options(url, options, defaults);
if (!this.options.url) {
if (this.options.prefixUrl === '') {
throw new TypeError('Missing `url` property');
}
this.options.url = '';
}
this.requestUrl = this.options.url as URL;
} catch (error: any) {
const {options} = error as OptionsError;
if (options) {
this.options = options;
}
this.flush = async () => {
this.flush = async () => {};
this.destroy(error);
};
return;
}
// Important! If you replace `body` in a handler with another stream, make sure it's readable first.
// The below is run only once.
const {body} = this.options;
if (is.nodeStream(body)) {
body.once('error', error => {
if (this._flushed) {
this._beforeError(new UploadError(error, this));
} else {
this.flush = async () => {
this.flush = async () => {};
this._beforeError(new UploadError(error, this));
};
}
});
}
if (this.options.signal) {
const abort = () => {
this.destroy(new AbortError(this));
};
if (this.options.signal.aborted) {
abort();
} else {
this.options.signal.addEventListener('abort', abort);
this._removeListeners = () => {
this.options.signal.removeEventListener('abort', abort);
};
}
}
}
async flush() {
if (this._flushed) {
return;
}
this._flushed = true;
try {
await this._finalizeBody();
if (this.destroyed) {
return;
}
await this._makeRequest();
if (this.destroyed) {
this._request?.destroy();
return;
}
// Queued writes etc.
for (const job of this._jobs) {
job();
}
// Prevent memory leak
this._jobs.length = 0;
this._requestInitialized = true;
} catch (error: any) {
this._beforeError(error);
}
}
_beforeError(error: Error): void {
if (this._stopReading) {
return;
}
const {response, options} = this;
const attemptCount = this.retryCount + (error.name === 'RetryError' ? 0 : 1);
this._stopReading = true;
if (!(error instanceof RequestError)) {
error = new RequestError(error.message, error, this);
}
const typedError = error as RequestError;
void (async () => {
// Node.js parser is really weird.
// It emits post-request Parse Errors on the same instance as previous request. WTF.
// Therefore we need to check if it has been destroyed as well.
//
// Furthermore, Node.js 16 `response.destroy()` doesn't immediately destroy the socket,
// but makes the response unreadable. So we additionally need to check `response.readable`.
if (response?.readable && !response.rawBody && !this._request?.socket?.destroyed) {
// @types/node has incorrect typings. `setEncoding` accepts `null` as well.
response.setEncoding(this.readableEncoding!);
const success = await this._setRawBody(response);
if (success) {
response.body = response.rawBody!.toString();
}
}
if (this.listenerCount('retry') !== 0) {
let backoff: number;
try {
let retryAfter;
if (response && 'retry-after' in response.headers) {
retryAfter = Number(response.headers['retry-after']);
if (Number.isNaN(retryAfter)) {
retryAfter = Date.parse(response.headers['retry-after']!) - Date.now();
if (retryAfter <= 0) {
retryAfter = 1;
}
} else {
retryAfter *= 1000;
}
}
const retryOptions = options.retry as RetryOptions;
backoff = await retryOptions.calculateDelay({
attemptCount,
retryOptions,
error: typedError,
retryAfter,
computedValue: calculateRetryDelay({
attemptCount,
retryOptions,
error: typedError,
retryAfter,
computedValue: retryOptions.maxRetryAfter ?? options.timeout.request ?? Number.POSITIVE_INFINITY,
}),
});
} catch (error_: any) {
void this._error(new RequestError(error_.message, error_, this));
return;
}
if (backoff) {
await new Promise<void>(resolve => {
const timeout = setTimeout(resolve, backoff);
this._stopRetry = () => {
clearTimeout(timeout);
resolve();
};
});
// Something forced us to abort the retry
if (this.destroyed) {
return;
}
try {
for (const hook of this.options.hooks.beforeRetry) {
// eslint-disable-next-line no-await-in-loop
await hook(typedError, this.retryCount + 1);
}
} catch (error_: any) {
void this._error(new RequestError(error_.message, error, this));
return;
}
// Something forced us to abort the retry
if (this.destroyed) {
return;
}
this.destroy();
this.emit('retry', this.retryCount + 1, error, (updatedOptions?: OptionsInit) => {
const request = new Request(options.url, updatedOptions, options);
request.retryCount = this.retryCount + 1;
process.nextTick(() => {
void request.flush();
});
return request;
});
return;
}
}
void this._error(typedError);
})();
}
override _read(): void {
this._triggerRead = true;
const {response} = this;
if (response && !this._stopReading) {
// We cannot put this in the `if` above
// because `.read()` also triggers the `end` event
if (response.readableLength) {
this._triggerRead = false;
}
let data;
while ((data = response.read()) !== null) {
this._downloadedSize += data.length; // eslint-disable-line @typescript-eslint/restrict-plus-operands
const progress = this.downloadProgress;
if (progress.percent < 1) {
this.emit('downloadProgress', progress);
}
this.push(data);
}
}
}
override _write(chunk: unknown, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
const write = (): void => {
this._writeRequest(chunk, encoding, callback);
};
if (this._requestInitialized) {
write();
} else {
this._jobs.push(write);
}
}
override _final(callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
const endRequest = (): void => {
// We need to check if `this._request` is present,
// because it isn't when we use cache.
if (!this._request || this._request.destroyed) {
callback();
return;
}
this._request.end((error?: Error | null) => { // eslint-disable-line @typescript-eslint/ban-types
// The request has been destroyed before `_final` finished.
// See https://github.com/nodejs/node/issues/39356
if ((this._request as any)._writableState?.errored) {
return;
}
if (!error) {
this._bodySize = this._uploadedSize;
this.emit('uploadProgress', this.uploadProgress);
this._request!.emit('upload-complete');
}
callback(error);
});
};
if (this._requestInitialized) {
endRequest();
} else {
this._jobs.push(endRequest);
}
}
override _destroy(error: Error | null, callback: (error: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
this._stopReading = true;
this.flush = async () => {};
// Prevent further retries
this._stopRetry();
this._cancelTimeouts();
this._removeListeners();
if (this.options) {
const {body} = this.options;
if (is.nodeStream(body)) {
body.destroy();
}
}
if (this._request) {
this._request.destroy();
}
if (error !== null && !is.undefined(error) && !(error instanceof RequestError)) {
error = new RequestError(error.message, error, this);
}
callback(error);
}
override pipe<T extends NodeJS.WritableStream>(destination: T, options?: {end?: boolean}): T {
if (destination instanceof ServerResponse) {
this._pipedServerResponses.add(destination);
}
return super.pipe(destination, options);
}
override unpipe<T extends NodeJS.WritableStream>(destination: T): this {
if (destination instanceof ServerResponse) {
this._pipedServerResponses.delete(destination);
}
super.unpipe(destination);
return this;
}
private async _finalizeBody(): Promise<void> {
const {options} = this;
const {headers} = options;
const isForm = !is.undefined(options.form);
// eslint-disable-next-line @typescript-eslint/naming-convention
const isJSON = !is.undefined(options.json);
const isBody = !is.undefined(options.body);
const cannotHaveBody = methodsWithoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
this._cannotHaveBody = cannotHaveBody;
if (isForm || isJSON || isBody) {
if (cannotHaveBody) {
throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
}
// Serialize body
const noContentType = !is.string(headers['content-type']);
if (isBody) {
// Body is spec-compliant FormData
if (isFormDataLike(options.body)) {
const encoder = new FormDataEncoder(options.body);
if (noContentType) {
headers['content-type'] = encoder.headers['Content-Type'];
}
if ('Content-Length' in encoder.headers) {
headers['content-length'] = encoder.headers['Content-Length'];
}
options.body = encoder.encode();
}
// Special case for https://github.com/form-data/form-data
if (isFormData(options.body) && noContentType) {
headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
}
} else if (isForm) {
if (noContentType) {
headers['content-type'] = 'application/x-www-form-urlencoded';
}
const {form} = options;
options.form = undefined;
options.body = (new URLSearchParams(form as Record<string, string>)).toString();
} else {
if (noContentType) {
headers['content-type'] = 'application/json';
}
const {json} = options;
options.json = undefined;
options.body = options.stringifyJson(json);
}
const uploadBodySize = await getBodySize(options.body, options.headers);
// See https://tools.ietf.org/html/rfc7230#section-3.3.2
// A user agent SHOULD send a Content-Length in a request message when
// no Transfer-Encoding is sent and the request method defines a meaning
// for an enclosed payload body. For example, a Content-Length header
// field is normally sent in a POST request even when the value is 0
// (indicating an empty payload body). A user agent SHOULD NOT send a
// Content-Length header field when the request message does not contain
// a payload body and the method semantics do not anticipate such a
// body.
if (is.undefined(headers['content-length']) && is.undefined(headers['transfer-encoding']) && !cannotHaveBody && !is.undefined(uploadBodySize)) {
headers['content-length'] = String(uploadBodySize);
}
}
if (options.responseType === 'json' && !('accept' in options.headers)) {
options.headers.accept = 'application/json';
}
this._bodySize = Number(headers['content-length']) || undefined;
}
private async _onResponseBase(response: IncomingMessageWithTimings): Promise<void> {
// This will be called e.g. when using cache so we need to check if this request has been aborted.
if (this.isAborted) {
return;
}
const {options} = this;
const {url} = options;
this._nativeResponse = response;
if (options.decompress) {
response = decompressResponse(response);
}
const statusCode = response.statusCode!;
const typedResponse = response as PlainResponse;
typedResponse.statusMessage = typedResponse.statusMessage ? typedResponse.statusMessage : http.STATUS_CODES[statusCode];
typedResponse.url = options.url!.toString();
typedResponse.requestUrl = this.requestUrl!;
typedResponse.redirectUrls = this.redirectUrls;
typedResponse.request = this;
typedResponse.isFromCache = (this._nativeResponse as any).fromCache ?? false;
typedResponse.ip = this.ip;
typedResponse.retryCount = this.retryCount;
typedResponse.ok = isResponseOk(typedResponse);
this._isFromCache = typedResponse.isFromCache;
this._responseSize = Number(response.headers['content-length']) || undefined;
this.response = typedResponse;
response.once('end', () => {
this._responseSize = this._downloadedSize;
this.emit('downloadProgress', this.downloadProgress);
});
response.once('error', (error: Error) => {
this._aborted = true;
// Force clean-up, because some packages don't do this.
// TODO: Fix decompress-response
response.destroy();
this._beforeError(new ReadError(error, this));
});
response.once('aborted', () => {
this._aborted = true;
this._beforeError(new ReadError({
name: 'Error',
message: 'The server aborted pending request',
code: 'ECONNRESET',
}, this));
});
this.emit('downloadProgress', this.downloadProgress);
const rawCookies = response.headers['set-cookie'];
if (is.object(options.cookieJar) && rawCookies) {
let promises: Array<Promise<unknown>> = rawCookies.map(async (rawCookie: string) => (options.cookieJar as PromiseCookieJar).setCookie(rawCookie, url!.toString()));
if (options.ignoreInvalidCookies) {
promises = promises.map(async promise => {
try {
await promise;
} catch {}
});
}
try {
await Promise.all(promises);
} catch (error: any) {
this._beforeError(error);
return;
}
}
// The above is running a promise, therefore we need to check if this request has been aborted yet again.
if (this.isAborted) {
return;
}
if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
// We're being redirected, we don't care about the response.
// It'd be best to abort the request, but we can't because
// we would have to sacrifice the TCP connection. We don't want that.
response.resume();
this._cancelTimeouts();
this._unproxyEvents();
if (this.redirectUrls.length >= options.maxRedirects) {
this._beforeError(new MaxRedirectsError(this));
return;
}
this._request = undefined;
const updatedOptions = new Options(undefined, undefined, this.options);
const serverRequestedGet = statusCode === 303 && updatedOptions.method !== 'GET' && updatedOptions.method !== 'HEAD';
const canRewrite = statusCode !== 307 && statusCode !== 308;
const userRequestedGet = updatedOptions.methodRewriting && canRewrite;
if (serverRequestedGet || userRequestedGet) {
updatedOptions.method = 'GET';
updatedOptions.body = undefined;
updatedOptions.json = undefined;
updatedOptions.form = undefined;
delete updatedOptions.headers['content-length'];
}
try {
// We need this in order to support UTF-8
const redirectBuffer = Buffer.from(response.headers.location, 'binary').toString();
const redirectUrl = new URL(redirectBuffer, url);
if (!isUnixSocketURL(url as URL) && isUnixSocketURL(redirectUrl)) {
this._beforeError(new RequestError('Cannot redirect to UNIX socket', {}, this));
return;
}
// Redirecting to a different site, clear sensitive data.
if (redirectUrl.hostname !== (url as URL).hostname || redirectUrl.port !== (url as URL).port) {
if ('host' in updatedOptions.headers) {
delete updatedOptions.headers.host;
}
if ('cookie' in updatedOptions.headers) {
delete updatedOptions.headers.cookie;
}
if ('authorization' in updatedOptions.headers) {
delete updatedOptions.headers.authorization;
}
if (updatedOptions.username || updatedOptions.password) {
updatedOptions.username = '';
updatedOptions.password = '';
}
} else {
redirectUrl.username = updatedOptions.username;
redirectUrl.password = updatedOptions.password;
}
this.redirectUrls.push(redirectUrl);
updatedOptions.prefixUrl = '';
updatedOptions.url = redirectUrl;
for (const hook of updatedOptions.hooks.beforeRedirect) {
// eslint-disable-next-line no-await-in-loop
await hook(updatedOptions, typedResponse);
}
this.emit('redirect', updatedOptions, typedResponse);
this.options = updatedOptions;
await this._makeRequest();
} catch (error: any) {
this._beforeError(error);
return;
}
return;
}
// `HTTPError`s always have `error.response.body` defined.
// Therefore we cannot retry if `options.throwHttpErrors` is false.
// On the last retry, if `options.throwHttpErrors` is false, we would need to return the body,
// but that wouldn't be possible since the body would be already read in `error.response.body`.
if (options.isStream && options.throwHttpErrors && !isResponseOk(typedResponse)) {
this._beforeError(new HTTPError(typedResponse));
return;
}
response.on('readable', () => {
if (this._triggerRead) {
this._read();
}
});
this.on('resume', () => {
response.resume();
});
this.on('pause', () => {
response.pause();
});
response.once('end', () => {
this.push(null);
});
if (this._noPipe) {
const success = await this._setRawBody();
if (success) {
this.emit('response', response);
}
return;
}
this.emit('response', response);
for (const destination of this._pipedServerResponses) {
if (destination.headersSent) {
continue;
}
// eslint-disable-next-line guard-for-in
for (const key in response.headers) {
const isAllowed = options.decompress ? key !== 'content-encoding' : true;
const value = response.headers[key];
if (isAllowed) {
destination.setHeader(key, value!);
}
}
destination.statusCode = statusCode;
}
}
private async _setRawBody(from: Readable = this): Promise<boolean> {
if (from.readableEnded) {
return false;
}
try {
// Errors are emitted via the `error` event
const rawBody = await getBuffer(from);
// On retry Request is destroyed with no error, therefore the above will successfully resolve.
// So in order to check if this was really successfull, we need to check if it has been properly ended.
if (!this.isAborted) {
this.response!.rawBody = rawBody;
return true;
}
} catch {}
return false;
}
private async _onResponse(response: IncomingMessageWithTimings): Promise<void> {
try {
await this._onResponseBase(response);
} catch (error: any) {
/* istanbul ignore next: better safe than sorry */
this._beforeError(error);
}
}
private _onRequest(request: ClientRequest): void {
const {options} = this;
const {timeout, url} = options;
timer(request);
if (this.options.http2) {
// Unset stream timeout, as the `timeout` option was used only for connection timeout.
request.setTimeout(0);
}
this._cancelTimeouts = timedOut(request, timeout, url as URL);
const responseEventName = options.cache ? 'cacheableResponse' : 'response';
request.once(responseEventName, (response: IncomingMessageWithTimings) => {
void this._onResponse(response);
});
request.once('error', (error: Error) => {
this._aborted = true;
// Force clean-up, because some packages (e.g. nock) don't do this.
request.destroy();
error = error instanceof TimedOutTimeoutError ? new TimeoutError(error, this.timings!, this) : new RequestError(error.message, error, this);
this._beforeError(error);
});
this._unproxyEvents = proxyEvents(request, this, proxiedRequestEvents);
this._request = request;
this.emit('uploadProgress', this.uploadProgress);
this._sendBody();
this.emit('request', request);
}
private async _asyncWrite(chunk: any): Promise<void> {
return new Promise((resolve, reject) => {
super.write(chunk, error => {
if (error) {
reject(error);
return;
}
resolve();
});
});
}
private _sendBody() {
// Send body
const {body} = this.options;
const currentRequest = this.redirectUrls.length === 0 ? this : this._request ?? this;
if (is.nodeStream(body)) {
body.pipe(currentRequest);
} else if (is.generator(body) || is.asyncGenerator(body)) {
(async () => {
try {
for await (const chunk of body) {
await this._asyncWrite(chunk);
}
super.end();
} catch (error: any) {
this._beforeError(error);
}
})();
} else if (!is.undefined(body)) {
this._writeRequest(body, undefined, () => {});
currentRequest.end();
} else if (this._cannotHaveBody || this._noPipe) {
currentRequest.end();
}
}
private _prepareCache(cache: string | StorageAdapter) {
if (!cacheableStore.has(cache)) {
const cacheableRequest = new CacheableRequest(
((requestOptions: RequestOptions, handler?: (response: IncomingMessageWithTimings) => void): ClientRequest => {
const result = (requestOptions as any)._request(requestOptions, handler);
// TODO: remove this when `cacheable-request` supports async request functions.
if (is.promise(result)) {
// We only need to implement the error handler in order to support HTTP2 caching.
// The result will be a promise anyway.
// @ts-expect-error ignore
// eslint-disable-next-line @typescript-eslint/promise-function-async
result.once = (event: string, handler: (reason: unknown) => void) => {
if (event === 'error') {
(async () => {
try {
await result;
} catch (error) {
handler(error);
}
})();
} else if (event === 'abort') {
// The empty catch is needed here in case when
// it rejects before it's `await`ed in `_makeRequest`.
(async () => {
try {
const request = (await result) as ClientRequest;
request.once('abort', handler);
} catch {}
})();
} else {
/* istanbul ignore next: safety check */
throw new Error(`Unknown HTTP2 promise event: ${event}`);
}
return result;
};
}
return result;
}) as typeof http.request,
cache as StorageAdapter,
);
cacheableStore.set(cache, cacheableRequest.request());
}
}
private async _createCacheableRequest(url: URL, options: RequestOptions): Promise<ClientRequest | ResponseLike> {
return new Promise<ClientRequest | ResponseLike>((resolve, reject) => {
// TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
Object.assign(options, urlToOptions(url));
let request: ClientRequest | Promise<ClientRequest>;
// TODO: Fix `cacheable-response`. This is ugly.
const cacheRequest = cacheableStore.get((options as any).cache)!(options as CacheableOptions, async (response: any) => {
response._readableState.autoDestroy = false;
if (request) {
const fix = () => {
if (response.req) {
response.complete = response.req.res.complete;
}
};
response.prependOnceListener('end', fix);
fix();
(await request).emit('cacheableResponse', response);
}
resolve(response);
});
cacheRequest.once('error', reject);
cacheRequest.once('request', async (requestOrPromise: ClientRequest | Promise<ClientRequest>) => {
request = requestOrPromise;
resolve(request);
});
});
}
private async _makeRequest(): Promise<void> {
const {options} = this;
const {headers, username, password} = options;
const cookieJar = options.cookieJar as PromiseCookieJar | undefined;
for (const key in headers) {
if (is.undefined(headers[key])) {
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
delete headers[key];
} else if (is.null_(headers[key])) {
throw new TypeError(`Use \`undefined\` instead of \`null\` to delete the \`${key}\` header`);
}
}
if (options.decompress && is.undefined(headers['accept-encoding'])) {
headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate';
}
if (username || password) {
const credentials = Buffer.from(`${username}:${password}`).toString('base64');
headers.authorization = `Basic ${credentials}`;
}
// Set cookies
if (cookieJar) {
const cookieString: string = await cookieJar.getCookieString(options.url!.toString());
if (is.nonEmptyString(cookieString)) {
headers.cookie = cookieString;
}
}
// Reset `prefixUrl`
options.prefixUrl = '';
let request: ReturnType<Options['getRequestFunction']> | undefined;
for (const hook of options.hooks.beforeRequest) {
// eslint-disable-next-line no-await-in-loop
const result = await hook(options);
if (!is.undefined(result)) {
// @ts-expect-error Skip the type mismatch to support abstract responses
request = () => result;
break;
}
}
if (!request) {
request = options.getRequestFunction();
}
const url = options.url as URL;
this._requestOptions = options.createNativeRequestOptions() as NativeRequestOptions;
if (options.cache) {
(this._requestOptions as any)._request = request;
(this._requestOptions as any).cache = options.cache;
(this._requestOptions as any).body = options.body;
this._prepareCache(options.cache as StorageAdapter);
}
// Cache support
const fn = options.cache ? this._createCacheableRequest : request;
try {
// We can't do `await fn(...)`,
// because stream `error` event can be emitted before `Promise.resolve()`.
let requestOrResponse = fn!(url, this._requestOptions);
if (is.promise(requestOrResponse)) {
requestOrResponse = await requestOrResponse;
}
// Fallback
if (is.undefined(requestOrResponse)) {
requestOrResponse = options.getFallbackRequestFunction()!(url, this._requestOptions);
if (is.promise(requestOrResponse)) {
requestOrResponse = await requestOrResponse;
}
}
if (isClientRequest(requestOrResponse!)) {
this._onRequest(requestOrResponse);
} else if (this.writable) {
this.once('finish', () => {
void this._onResponse(requestOrResponse as IncomingMessageWithTimings);
});
this._sendBody();
} else {
void this._onResponse(requestOrResponse as IncomingMessageWithTimings);
}
} catch (error) {
if (error instanceof CacheableCacheError) {
throw new CacheError(error, this);
}
throw error;
}
}
private async _error(error: RequestError): Promise<void> {
try {
if (error instanceof HTTPError && !this.options.throwHttpErrors) {
// This branch can be reached only when using the Promise API
// Skip calling the hooks on purpose.
// See https://github.com/sindresorhus/got/issues/2103
} else {
for (const hook of this.options.hooks.beforeError) {
// eslint-disable-next-line no-await-in-loop
error = await hook(error);
}
}
} catch (error_: any) {
error = new RequestError(error_.message, error_, this);
}
this.destroy(error);
}
private _writeRequest(chunk: any, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
if (!this._request || this._request.destroyed) {
// Probably the `ClientRequest` instance will throw
return;
}
this._request.write(chunk, encoding!, (error?: Error | null) => { // eslint-disable-line @typescript-eslint/ban-types
// The `!destroyed` check is required to prevent `uploadProgress` being emitted after the stream was destroyed
if (!error && !this._request!.destroyed) {
this._uploadedSize += Buffer.byteLength(chunk, encoding);
const progress = this.uploadProgress;
if (progress.percent < 1) {
this.emit('uploadProgress', progress);
}
}
callback(error);
});
}
/**
The remote IP address.
*/
get ip(): string | undefined {
return this.socket?.remoteAddress;
}
/**
Indicates whether the request has been aborted or not.
*/
get isAborted(): boolean {
return this._aborted;
}
get socket(): Socket | undefined {
return this._request?.socket ?? undefined;
}
/**
Progress event for downloading (receiving a response).
*/
get downloadProgress(): Progress {
let percent;
if (this._responseSize) {
percent = this._downloadedSize / this._responseSize;
} else if (this._responseSize === this._downloadedSize) {
percent = 1;
} else {
percent = 0;
}
return {
percent,
transferred: this._downloadedSize,
total: this._responseSize,
};
}
/**
Progress event for uploading (sending a request).
*/
get uploadProgress(): Progress {
let percent;
if (this._bodySize) {
percent = this._uploadedSize / this._bodySize;
} else if (this._bodySize === this._uploadedSize) {
percent = 1;
} else {
percent = 0;
}
return {
percent,
transferred: this._uploadedSize,
total: this._bodySize,
};
}
/**
The object contains the following properties:
- `start` - Time when the request started.
- `socket` - Time when a socket was assigned to the request.
- `lookup` - Time when the DNS lookup finished.
- `connect` - Time when the socket successfully connected.
- `secureConnect` - Time when the socket securely connected.
- `upload` - Time when the request finished uploading.
- `response` - Time when the request fired `response` event.
- `end` - Time when the response fired `end` event.
- `error` - Time when the request fired `error` event.
- `abort` - Time when the request fired `abort` event.
- `phases`
- `wait` - `timings.socket - timings.start`
- `dns` - `timings.lookup - timings.socket`
- `tcp` - `timings.connect - timings.lookup`
- `tls` - `timings.secureConnect - timings.connect`
- `request` - `timings.upload - (timings.secureConnect || timings.connect)`
- `firstByte` - `timings.response - timings.upload`
- `download` - `timings.end - timings.response`
- `total` - `(timings.end || timings.error || timings.abort) - timings.start`
If something has not been measured yet, it will be `undefined`.
__Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
*/
get timings(): Timings | undefined {
return (this._request as ClientRequestWithTimings)?.timings;
}
/**
Whether the response was retrieved from the cache.
*/
get isFromCache(): boolean | undefined {
return this._isFromCache;
}
get reusedSocket(): boolean | undefined {
return this._request?.reusedSocket;
}
} |
446 | function asPromise<T>(firstRequest?: Request): CancelableRequest<T> {
let globalRequest: Request;
let globalResponse: Response;
let normalizedOptions: Options;
const emitter = new EventEmitter();
const promise = new PCancelable<T>((resolve, reject, onCancel) => {
onCancel(() => {
globalRequest.destroy();
});
onCancel.shouldReject = false;
onCancel(() => {
reject(new CancelError(globalRequest));
});
const makeRequest = (retryCount: number): void => {
// Errors when a new request is made after the promise settles.
// Used to detect a race condition.
// See https://github.com/sindresorhus/got/issues/1489
onCancel(() => {});
const request = firstRequest ?? new Request(undefined, undefined, normalizedOptions);
request.retryCount = retryCount;
request._noPipe = true;
globalRequest = request;
request.once('response', async (response: Response) => {
// Parse body
const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br';
const {options} = request;
if (isCompressed && !options.decompress) {
response.body = response.rawBody;
} else {
try {
response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
} catch (error: any) {
// Fall back to `utf8`
response.body = response.rawBody.toString();
if (isResponseOk(response)) {
request._beforeError(error);
return;
}
}
}
try {
const hooks = options.hooks.afterResponse;
for (const [index, hook] of hooks.entries()) {
// @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
// eslint-disable-next-line no-await-in-loop
response = await hook(response, async (updatedOptions): CancelableRequest<Response> => {
options.merge(updatedOptions);
options.prefixUrl = '';
if (updatedOptions.url) {
options.url = updatedOptions.url;
}
// Remove any further hooks for that request, because we'll call them anyway.
// The loop continues. We don't want duplicates (asPromise recursion).
options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
throw new RetryError(request);
});
if (!(is.object(response) && is.number(response.statusCode) && !is.nullOrUndefined(response.body))) {
throw new TypeError('The `afterResponse` hook returned an invalid value');
}
}
} catch (error: any) {
request._beforeError(error);
return;
}
globalResponse = response;
if (!isResponseOk(response)) {
request._beforeError(new HTTPError(response));
return;
}
request.destroy();
resolve(request.options.resolveBodyOnly ? response.body as T : response as unknown as T);
});
const onError = (error: RequestError) => {
if (promise.isCanceled) {
return;
}
const {options} = request;
if (error instanceof HTTPError && !options.throwHttpErrors) {
const {response} = error;
request.destroy();
resolve(request.options.resolveBodyOnly ? response.body as T : response as unknown as T);
return;
}
reject(error);
};
request.once('error', onError);
const previousBody = request.options?.body;
request.once('retry', (newRetryCount: number, error: RequestError) => {
firstRequest = undefined;
const newBody = request.options.body;
if (previousBody === newBody && is.nodeStream(newBody)) {
error.message = 'Cannot retry with consumed body stream';
onError(error);
return;
}
// This is needed! We need to reuse `request.options` because they can get modified!
// For example, by calling `promise.json()`.
normalizedOptions = request.options;
makeRequest(newRetryCount);
});
proxyEvents(request, emitter, proxiedRequestEvents);
if (is.undefined(firstRequest)) {
void request.flush();
}
};
makeRequest(0);
}) as CancelableRequest<T>;
promise.on = (event: string, fn: (...args: any[]) => void) => {
emitter.on(event, fn);
return promise;
};
promise.off = (event: string, fn: (...args: any[]) => void) => {
emitter.off(event, fn);
return promise;
};
const shortcut = <T>(responseType: Options['responseType']): CancelableRequest<T> => {
const newPromise = (async () => {
// Wait until downloading has ended
await promise;
const {options} = globalResponse.request;
return parseBody(globalResponse, responseType, options.parseJson, options.encoding);
})();
// eslint-disable-next-line @typescript-eslint/no-floating-promises
Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));
return newPromise as CancelableRequest<T>;
};
promise.json = () => {
if (globalRequest.options) {
const {headers} = globalRequest.options;
if (!globalRequest.writableFinished && !('accept' in headers)) {
headers.accept = 'application/json';
}
}
return shortcut('json');
};
promise.buffer = () => shortcut('buffer');
promise.text = () => shortcut('text');
return promise;
} | class Request extends Duplex implements RequestEvents<Request> {
// @ts-expect-error - Ignoring for now.
override ['constructor']: typeof Request;
_noPipe?: boolean;
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/9568
options: Options;
response?: PlainResponse;
requestUrl?: URL;
redirectUrls: URL[];
retryCount: number;
declare private _requestOptions: NativeRequestOptions;
private _stopRetry: () => void;
private _downloadedSize: number;
private _uploadedSize: number;
private _stopReading: boolean;
private readonly _pipedServerResponses: Set<ServerResponse>;
private _request?: ClientRequest;
private _responseSize?: number;
private _bodySize?: number;
private _unproxyEvents: () => void;
private _isFromCache?: boolean;
private _cannotHaveBody: boolean;
private _triggerRead: boolean;
declare private _jobs: Array<() => void>;
private _cancelTimeouts: () => void;
private readonly _removeListeners: () => void;
private _nativeResponse?: IncomingMessageWithTimings;
private _flushed: boolean;
private _aborted: boolean;
// We need this because `this._request` if `undefined` when using cache
private _requestInitialized: boolean;
constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType) {
super({
// Don't destroy immediately, as the error may be emitted on unsuccessful retry
autoDestroy: false,
// It needs to be zero because we're just proxying the data to another stream
highWaterMark: 0,
});
this._downloadedSize = 0;
this._uploadedSize = 0;
this._stopReading = false;
this._pipedServerResponses = new Set<ServerResponse>();
this._cannotHaveBody = false;
this._unproxyEvents = noop;
this._triggerRead = false;
this._cancelTimeouts = noop;
this._removeListeners = noop;
this._jobs = [];
this._flushed = false;
this._requestInitialized = false;
this._aborted = false;
this.redirectUrls = [];
this.retryCount = 0;
this._stopRetry = noop;
this.on('pipe', source => {
if (source.headers) {
Object.assign(this.options.headers, source.headers);
}
});
this.on('newListener', event => {
if (event === 'retry' && this.listenerCount('retry') > 0) {
throw new Error('A retry listener has been attached already.');
}
});
try {
this.options = new Options(url, options, defaults);
if (!this.options.url) {
if (this.options.prefixUrl === '') {
throw new TypeError('Missing `url` property');
}
this.options.url = '';
}
this.requestUrl = this.options.url as URL;
} catch (error: any) {
const {options} = error as OptionsError;
if (options) {
this.options = options;
}
this.flush = async () => {
this.flush = async () => {};
this.destroy(error);
};
return;
}
// Important! If you replace `body` in a handler with another stream, make sure it's readable first.
// The below is run only once.
const {body} = this.options;
if (is.nodeStream(body)) {
body.once('error', error => {
if (this._flushed) {
this._beforeError(new UploadError(error, this));
} else {
this.flush = async () => {
this.flush = async () => {};
this._beforeError(new UploadError(error, this));
};
}
});
}
if (this.options.signal) {
const abort = () => {
this.destroy(new AbortError(this));
};
if (this.options.signal.aborted) {
abort();
} else {
this.options.signal.addEventListener('abort', abort);
this._removeListeners = () => {
this.options.signal.removeEventListener('abort', abort);
};
}
}
}
async flush() {
if (this._flushed) {
return;
}
this._flushed = true;
try {
await this._finalizeBody();
if (this.destroyed) {
return;
}
await this._makeRequest();
if (this.destroyed) {
this._request?.destroy();
return;
}
// Queued writes etc.
for (const job of this._jobs) {
job();
}
// Prevent memory leak
this._jobs.length = 0;
this._requestInitialized = true;
} catch (error: any) {
this._beforeError(error);
}
}
_beforeError(error: Error): void {
if (this._stopReading) {
return;
}
const {response, options} = this;
const attemptCount = this.retryCount + (error.name === 'RetryError' ? 0 : 1);
this._stopReading = true;
if (!(error instanceof RequestError)) {
error = new RequestError(error.message, error, this);
}
const typedError = error as RequestError;
void (async () => {
// Node.js parser is really weird.
// It emits post-request Parse Errors on the same instance as previous request. WTF.
// Therefore we need to check if it has been destroyed as well.
//
// Furthermore, Node.js 16 `response.destroy()` doesn't immediately destroy the socket,
// but makes the response unreadable. So we additionally need to check `response.readable`.
if (response?.readable && !response.rawBody && !this._request?.socket?.destroyed) {
// @types/node has incorrect typings. `setEncoding` accepts `null` as well.
response.setEncoding(this.readableEncoding!);
const success = await this._setRawBody(response);
if (success) {
response.body = response.rawBody!.toString();
}
}
if (this.listenerCount('retry') !== 0) {
let backoff: number;
try {
let retryAfter;
if (response && 'retry-after' in response.headers) {
retryAfter = Number(response.headers['retry-after']);
if (Number.isNaN(retryAfter)) {
retryAfter = Date.parse(response.headers['retry-after']!) - Date.now();
if (retryAfter <= 0) {
retryAfter = 1;
}
} else {
retryAfter *= 1000;
}
}
const retryOptions = options.retry as RetryOptions;
backoff = await retryOptions.calculateDelay({
attemptCount,
retryOptions,
error: typedError,
retryAfter,
computedValue: calculateRetryDelay({
attemptCount,
retryOptions,
error: typedError,
retryAfter,
computedValue: retryOptions.maxRetryAfter ?? options.timeout.request ?? Number.POSITIVE_INFINITY,
}),
});
} catch (error_: any) {
void this._error(new RequestError(error_.message, error_, this));
return;
}
if (backoff) {
await new Promise<void>(resolve => {
const timeout = setTimeout(resolve, backoff);
this._stopRetry = () => {
clearTimeout(timeout);
resolve();
};
});
// Something forced us to abort the retry
if (this.destroyed) {
return;
}
try {
for (const hook of this.options.hooks.beforeRetry) {
// eslint-disable-next-line no-await-in-loop
await hook(typedError, this.retryCount + 1);
}
} catch (error_: any) {
void this._error(new RequestError(error_.message, error, this));
return;
}
// Something forced us to abort the retry
if (this.destroyed) {
return;
}
this.destroy();
this.emit('retry', this.retryCount + 1, error, (updatedOptions?: OptionsInit) => {
const request = new Request(options.url, updatedOptions, options);
request.retryCount = this.retryCount + 1;
process.nextTick(() => {
void request.flush();
});
return request;
});
return;
}
}
void this._error(typedError);
})();
}
override _read(): void {
this._triggerRead = true;
const {response} = this;
if (response && !this._stopReading) {
// We cannot put this in the `if` above
// because `.read()` also triggers the `end` event
if (response.readableLength) {
this._triggerRead = false;
}
let data;
while ((data = response.read()) !== null) {
this._downloadedSize += data.length; // eslint-disable-line @typescript-eslint/restrict-plus-operands
const progress = this.downloadProgress;
if (progress.percent < 1) {
this.emit('downloadProgress', progress);
}
this.push(data);
}
}
}
override _write(chunk: unknown, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
const write = (): void => {
this._writeRequest(chunk, encoding, callback);
};
if (this._requestInitialized) {
write();
} else {
this._jobs.push(write);
}
}
override _final(callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
const endRequest = (): void => {
// We need to check if `this._request` is present,
// because it isn't when we use cache.
if (!this._request || this._request.destroyed) {
callback();
return;
}
this._request.end((error?: Error | null) => { // eslint-disable-line @typescript-eslint/ban-types
// The request has been destroyed before `_final` finished.
// See https://github.com/nodejs/node/issues/39356
if ((this._request as any)._writableState?.errored) {
return;
}
if (!error) {
this._bodySize = this._uploadedSize;
this.emit('uploadProgress', this.uploadProgress);
this._request!.emit('upload-complete');
}
callback(error);
});
};
if (this._requestInitialized) {
endRequest();
} else {
this._jobs.push(endRequest);
}
}
override _destroy(error: Error | null, callback: (error: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
this._stopReading = true;
this.flush = async () => {};
// Prevent further retries
this._stopRetry();
this._cancelTimeouts();
this._removeListeners();
if (this.options) {
const {body} = this.options;
if (is.nodeStream(body)) {
body.destroy();
}
}
if (this._request) {
this._request.destroy();
}
if (error !== null && !is.undefined(error) && !(error instanceof RequestError)) {
error = new RequestError(error.message, error, this);
}
callback(error);
}
override pipe<T extends NodeJS.WritableStream>(destination: T, options?: {end?: boolean}): T {
if (destination instanceof ServerResponse) {
this._pipedServerResponses.add(destination);
}
return super.pipe(destination, options);
}
override unpipe<T extends NodeJS.WritableStream>(destination: T): this {
if (destination instanceof ServerResponse) {
this._pipedServerResponses.delete(destination);
}
super.unpipe(destination);
return this;
}
private async _finalizeBody(): Promise<void> {
const {options} = this;
const {headers} = options;
const isForm = !is.undefined(options.form);
// eslint-disable-next-line @typescript-eslint/naming-convention
const isJSON = !is.undefined(options.json);
const isBody = !is.undefined(options.body);
const cannotHaveBody = methodsWithoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
this._cannotHaveBody = cannotHaveBody;
if (isForm || isJSON || isBody) {
if (cannotHaveBody) {
throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
}
// Serialize body
const noContentType = !is.string(headers['content-type']);
if (isBody) {
// Body is spec-compliant FormData
if (isFormDataLike(options.body)) {
const encoder = new FormDataEncoder(options.body);
if (noContentType) {
headers['content-type'] = encoder.headers['Content-Type'];
}
if ('Content-Length' in encoder.headers) {
headers['content-length'] = encoder.headers['Content-Length'];
}
options.body = encoder.encode();
}
// Special case for https://github.com/form-data/form-data
if (isFormData(options.body) && noContentType) {
headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
}
} else if (isForm) {
if (noContentType) {
headers['content-type'] = 'application/x-www-form-urlencoded';
}
const {form} = options;
options.form = undefined;
options.body = (new URLSearchParams(form as Record<string, string>)).toString();
} else {
if (noContentType) {
headers['content-type'] = 'application/json';
}
const {json} = options;
options.json = undefined;
options.body = options.stringifyJson(json);
}
const uploadBodySize = await getBodySize(options.body, options.headers);
// See https://tools.ietf.org/html/rfc7230#section-3.3.2
// A user agent SHOULD send a Content-Length in a request message when
// no Transfer-Encoding is sent and the request method defines a meaning
// for an enclosed payload body. For example, a Content-Length header
// field is normally sent in a POST request even when the value is 0
// (indicating an empty payload body). A user agent SHOULD NOT send a
// Content-Length header field when the request message does not contain
// a payload body and the method semantics do not anticipate such a
// body.
if (is.undefined(headers['content-length']) && is.undefined(headers['transfer-encoding']) && !cannotHaveBody && !is.undefined(uploadBodySize)) {
headers['content-length'] = String(uploadBodySize);
}
}
if (options.responseType === 'json' && !('accept' in options.headers)) {
options.headers.accept = 'application/json';
}
this._bodySize = Number(headers['content-length']) || undefined;
}
private async _onResponseBase(response: IncomingMessageWithTimings): Promise<void> {
// This will be called e.g. when using cache so we need to check if this request has been aborted.
if (this.isAborted) {
return;
}
const {options} = this;
const {url} = options;
this._nativeResponse = response;
if (options.decompress) {
response = decompressResponse(response);
}
const statusCode = response.statusCode!;
const typedResponse = response as PlainResponse;
typedResponse.statusMessage = typedResponse.statusMessage ? typedResponse.statusMessage : http.STATUS_CODES[statusCode];
typedResponse.url = options.url!.toString();
typedResponse.requestUrl = this.requestUrl!;
typedResponse.redirectUrls = this.redirectUrls;
typedResponse.request = this;
typedResponse.isFromCache = (this._nativeResponse as any).fromCache ?? false;
typedResponse.ip = this.ip;
typedResponse.retryCount = this.retryCount;
typedResponse.ok = isResponseOk(typedResponse);
this._isFromCache = typedResponse.isFromCache;
this._responseSize = Number(response.headers['content-length']) || undefined;
this.response = typedResponse;
response.once('end', () => {
this._responseSize = this._downloadedSize;
this.emit('downloadProgress', this.downloadProgress);
});
response.once('error', (error: Error) => {
this._aborted = true;
// Force clean-up, because some packages don't do this.
// TODO: Fix decompress-response
response.destroy();
this._beforeError(new ReadError(error, this));
});
response.once('aborted', () => {
this._aborted = true;
this._beforeError(new ReadError({
name: 'Error',
message: 'The server aborted pending request',
code: 'ECONNRESET',
}, this));
});
this.emit('downloadProgress', this.downloadProgress);
const rawCookies = response.headers['set-cookie'];
if (is.object(options.cookieJar) && rawCookies) {
let promises: Array<Promise<unknown>> = rawCookies.map(async (rawCookie: string) => (options.cookieJar as PromiseCookieJar).setCookie(rawCookie, url!.toString()));
if (options.ignoreInvalidCookies) {
promises = promises.map(async promise => {
try {
await promise;
} catch {}
});
}
try {
await Promise.all(promises);
} catch (error: any) {
this._beforeError(error);
return;
}
}
// The above is running a promise, therefore we need to check if this request has been aborted yet again.
if (this.isAborted) {
return;
}
if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
// We're being redirected, we don't care about the response.
// It'd be best to abort the request, but we can't because
// we would have to sacrifice the TCP connection. We don't want that.
response.resume();
this._cancelTimeouts();
this._unproxyEvents();
if (this.redirectUrls.length >= options.maxRedirects) {
this._beforeError(new MaxRedirectsError(this));
return;
}
this._request = undefined;
const updatedOptions = new Options(undefined, undefined, this.options);
const serverRequestedGet = statusCode === 303 && updatedOptions.method !== 'GET' && updatedOptions.method !== 'HEAD';
const canRewrite = statusCode !== 307 && statusCode !== 308;
const userRequestedGet = updatedOptions.methodRewriting && canRewrite;
if (serverRequestedGet || userRequestedGet) {
updatedOptions.method = 'GET';
updatedOptions.body = undefined;
updatedOptions.json = undefined;
updatedOptions.form = undefined;
delete updatedOptions.headers['content-length'];
}
try {
// We need this in order to support UTF-8
const redirectBuffer = Buffer.from(response.headers.location, 'binary').toString();
const redirectUrl = new URL(redirectBuffer, url);
if (!isUnixSocketURL(url as URL) && isUnixSocketURL(redirectUrl)) {
this._beforeError(new RequestError('Cannot redirect to UNIX socket', {}, this));
return;
}
// Redirecting to a different site, clear sensitive data.
if (redirectUrl.hostname !== (url as URL).hostname || redirectUrl.port !== (url as URL).port) {
if ('host' in updatedOptions.headers) {
delete updatedOptions.headers.host;
}
if ('cookie' in updatedOptions.headers) {
delete updatedOptions.headers.cookie;
}
if ('authorization' in updatedOptions.headers) {
delete updatedOptions.headers.authorization;
}
if (updatedOptions.username || updatedOptions.password) {
updatedOptions.username = '';
updatedOptions.password = '';
}
} else {
redirectUrl.username = updatedOptions.username;
redirectUrl.password = updatedOptions.password;
}
this.redirectUrls.push(redirectUrl);
updatedOptions.prefixUrl = '';
updatedOptions.url = redirectUrl;
for (const hook of updatedOptions.hooks.beforeRedirect) {
// eslint-disable-next-line no-await-in-loop
await hook(updatedOptions, typedResponse);
}
this.emit('redirect', updatedOptions, typedResponse);
this.options = updatedOptions;
await this._makeRequest();
} catch (error: any) {
this._beforeError(error);
return;
}
return;
}
// `HTTPError`s always have `error.response.body` defined.
// Therefore we cannot retry if `options.throwHttpErrors` is false.
// On the last retry, if `options.throwHttpErrors` is false, we would need to return the body,
// but that wouldn't be possible since the body would be already read in `error.response.body`.
if (options.isStream && options.throwHttpErrors && !isResponseOk(typedResponse)) {
this._beforeError(new HTTPError(typedResponse));
return;
}
response.on('readable', () => {
if (this._triggerRead) {
this._read();
}
});
this.on('resume', () => {
response.resume();
});
this.on('pause', () => {
response.pause();
});
response.once('end', () => {
this.push(null);
});
if (this._noPipe) {
const success = await this._setRawBody();
if (success) {
this.emit('response', response);
}
return;
}
this.emit('response', response);
for (const destination of this._pipedServerResponses) {
if (destination.headersSent) {
continue;
}
// eslint-disable-next-line guard-for-in
for (const key in response.headers) {
const isAllowed = options.decompress ? key !== 'content-encoding' : true;
const value = response.headers[key];
if (isAllowed) {
destination.setHeader(key, value!);
}
}
destination.statusCode = statusCode;
}
}
private async _setRawBody(from: Readable = this): Promise<boolean> {
if (from.readableEnded) {
return false;
}
try {
// Errors are emitted via the `error` event
const rawBody = await getBuffer(from);
// On retry Request is destroyed with no error, therefore the above will successfully resolve.
// So in order to check if this was really successfull, we need to check if it has been properly ended.
if (!this.isAborted) {
this.response!.rawBody = rawBody;
return true;
}
} catch {}
return false;
}
private async _onResponse(response: IncomingMessageWithTimings): Promise<void> {
try {
await this._onResponseBase(response);
} catch (error: any) {
/* istanbul ignore next: better safe than sorry */
this._beforeError(error);
}
}
private _onRequest(request: ClientRequest): void {
const {options} = this;
const {timeout, url} = options;
timer(request);
if (this.options.http2) {
// Unset stream timeout, as the `timeout` option was used only for connection timeout.
request.setTimeout(0);
}
this._cancelTimeouts = timedOut(request, timeout, url as URL);
const responseEventName = options.cache ? 'cacheableResponse' : 'response';
request.once(responseEventName, (response: IncomingMessageWithTimings) => {
void this._onResponse(response);
});
request.once('error', (error: Error) => {
this._aborted = true;
// Force clean-up, because some packages (e.g. nock) don't do this.
request.destroy();
error = error instanceof TimedOutTimeoutError ? new TimeoutError(error, this.timings!, this) : new RequestError(error.message, error, this);
this._beforeError(error);
});
this._unproxyEvents = proxyEvents(request, this, proxiedRequestEvents);
this._request = request;
this.emit('uploadProgress', this.uploadProgress);
this._sendBody();
this.emit('request', request);
}
private async _asyncWrite(chunk: any): Promise<void> {
return new Promise((resolve, reject) => {
super.write(chunk, error => {
if (error) {
reject(error);
return;
}
resolve();
});
});
}
private _sendBody() {
// Send body
const {body} = this.options;
const currentRequest = this.redirectUrls.length === 0 ? this : this._request ?? this;
if (is.nodeStream(body)) {
body.pipe(currentRequest);
} else if (is.generator(body) || is.asyncGenerator(body)) {
(async () => {
try {
for await (const chunk of body) {
await this._asyncWrite(chunk);
}
super.end();
} catch (error: any) {
this._beforeError(error);
}
})();
} else if (!is.undefined(body)) {
this._writeRequest(body, undefined, () => {});
currentRequest.end();
} else if (this._cannotHaveBody || this._noPipe) {
currentRequest.end();
}
}
private _prepareCache(cache: string | StorageAdapter) {
if (!cacheableStore.has(cache)) {
const cacheableRequest = new CacheableRequest(
((requestOptions: RequestOptions, handler?: (response: IncomingMessageWithTimings) => void): ClientRequest => {
const result = (requestOptions as any)._request(requestOptions, handler);
// TODO: remove this when `cacheable-request` supports async request functions.
if (is.promise(result)) {
// We only need to implement the error handler in order to support HTTP2 caching.
// The result will be a promise anyway.
// @ts-expect-error ignore
// eslint-disable-next-line @typescript-eslint/promise-function-async
result.once = (event: string, handler: (reason: unknown) => void) => {
if (event === 'error') {
(async () => {
try {
await result;
} catch (error) {
handler(error);
}
})();
} else if (event === 'abort') {
// The empty catch is needed here in case when
// it rejects before it's `await`ed in `_makeRequest`.
(async () => {
try {
const request = (await result) as ClientRequest;
request.once('abort', handler);
} catch {}
})();
} else {
/* istanbul ignore next: safety check */
throw new Error(`Unknown HTTP2 promise event: ${event}`);
}
return result;
};
}
return result;
}) as typeof http.request,
cache as StorageAdapter,
);
cacheableStore.set(cache, cacheableRequest.request());
}
}
private async _createCacheableRequest(url: URL, options: RequestOptions): Promise<ClientRequest | ResponseLike> {
return new Promise<ClientRequest | ResponseLike>((resolve, reject) => {
// TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
Object.assign(options, urlToOptions(url));
let request: ClientRequest | Promise<ClientRequest>;
// TODO: Fix `cacheable-response`. This is ugly.
const cacheRequest = cacheableStore.get((options as any).cache)!(options as CacheableOptions, async (response: any) => {
response._readableState.autoDestroy = false;
if (request) {
const fix = () => {
if (response.req) {
response.complete = response.req.res.complete;
}
};
response.prependOnceListener('end', fix);
fix();
(await request).emit('cacheableResponse', response);
}
resolve(response);
});
cacheRequest.once('error', reject);
cacheRequest.once('request', async (requestOrPromise: ClientRequest | Promise<ClientRequest>) => {
request = requestOrPromise;
resolve(request);
});
});
}
private async _makeRequest(): Promise<void> {
const {options} = this;
const {headers, username, password} = options;
const cookieJar = options.cookieJar as PromiseCookieJar | undefined;
for (const key in headers) {
if (is.undefined(headers[key])) {
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
delete headers[key];
} else if (is.null_(headers[key])) {
throw new TypeError(`Use \`undefined\` instead of \`null\` to delete the \`${key}\` header`);
}
}
if (options.decompress && is.undefined(headers['accept-encoding'])) {
headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate';
}
if (username || password) {
const credentials = Buffer.from(`${username}:${password}`).toString('base64');
headers.authorization = `Basic ${credentials}`;
}
// Set cookies
if (cookieJar) {
const cookieString: string = await cookieJar.getCookieString(options.url!.toString());
if (is.nonEmptyString(cookieString)) {
headers.cookie = cookieString;
}
}
// Reset `prefixUrl`
options.prefixUrl = '';
let request: ReturnType<Options['getRequestFunction']> | undefined;
for (const hook of options.hooks.beforeRequest) {
// eslint-disable-next-line no-await-in-loop
const result = await hook(options);
if (!is.undefined(result)) {
// @ts-expect-error Skip the type mismatch to support abstract responses
request = () => result;
break;
}
}
if (!request) {
request = options.getRequestFunction();
}
const url = options.url as URL;
this._requestOptions = options.createNativeRequestOptions() as NativeRequestOptions;
if (options.cache) {
(this._requestOptions as any)._request = request;
(this._requestOptions as any).cache = options.cache;
(this._requestOptions as any).body = options.body;
this._prepareCache(options.cache as StorageAdapter);
}
// Cache support
const fn = options.cache ? this._createCacheableRequest : request;
try {
// We can't do `await fn(...)`,
// because stream `error` event can be emitted before `Promise.resolve()`.
let requestOrResponse = fn!(url, this._requestOptions);
if (is.promise(requestOrResponse)) {
requestOrResponse = await requestOrResponse;
}
// Fallback
if (is.undefined(requestOrResponse)) {
requestOrResponse = options.getFallbackRequestFunction()!(url, this._requestOptions);
if (is.promise(requestOrResponse)) {
requestOrResponse = await requestOrResponse;
}
}
if (isClientRequest(requestOrResponse!)) {
this._onRequest(requestOrResponse);
} else if (this.writable) {
this.once('finish', () => {
void this._onResponse(requestOrResponse as IncomingMessageWithTimings);
});
this._sendBody();
} else {
void this._onResponse(requestOrResponse as IncomingMessageWithTimings);
}
} catch (error) {
if (error instanceof CacheableCacheError) {
throw new CacheError(error, this);
}
throw error;
}
}
private async _error(error: RequestError): Promise<void> {
try {
if (error instanceof HTTPError && !this.options.throwHttpErrors) {
// This branch can be reached only when using the Promise API
// Skip calling the hooks on purpose.
// See https://github.com/sindresorhus/got/issues/2103
} else {
for (const hook of this.options.hooks.beforeError) {
// eslint-disable-next-line no-await-in-loop
error = await hook(error);
}
}
} catch (error_: any) {
error = new RequestError(error_.message, error_, this);
}
this.destroy(error);
}
private _writeRequest(chunk: any, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void { // eslint-disable-line @typescript-eslint/ban-types
if (!this._request || this._request.destroyed) {
// Probably the `ClientRequest` instance will throw
return;
}
this._request.write(chunk, encoding!, (error?: Error | null) => { // eslint-disable-line @typescript-eslint/ban-types
// The `!destroyed` check is required to prevent `uploadProgress` being emitted after the stream was destroyed
if (!error && !this._request!.destroyed) {
this._uploadedSize += Buffer.byteLength(chunk, encoding);
const progress = this.uploadProgress;
if (progress.percent < 1) {
this.emit('uploadProgress', progress);
}
}
callback(error);
});
}
/**
The remote IP address.
*/
get ip(): string | undefined {
return this.socket?.remoteAddress;
}
/**
Indicates whether the request has been aborted or not.
*/
get isAborted(): boolean {
return this._aborted;
}
get socket(): Socket | undefined {
return this._request?.socket ?? undefined;
}
/**
Progress event for downloading (receiving a response).
*/
get downloadProgress(): Progress {
let percent;
if (this._responseSize) {
percent = this._downloadedSize / this._responseSize;
} else if (this._responseSize === this._downloadedSize) {
percent = 1;
} else {
percent = 0;
}
return {
percent,
transferred: this._downloadedSize,
total: this._responseSize,
};
}
/**
Progress event for uploading (sending a request).
*/
get uploadProgress(): Progress {
let percent;
if (this._bodySize) {
percent = this._uploadedSize / this._bodySize;
} else if (this._bodySize === this._uploadedSize) {
percent = 1;
} else {
percent = 0;
}
return {
percent,
transferred: this._uploadedSize,
total: this._bodySize,
};
}
/**
The object contains the following properties:
- `start` - Time when the request started.
- `socket` - Time when a socket was assigned to the request.
- `lookup` - Time when the DNS lookup finished.
- `connect` - Time when the socket successfully connected.
- `secureConnect` - Time when the socket securely connected.
- `upload` - Time when the request finished uploading.
- `response` - Time when the request fired `response` event.
- `end` - Time when the response fired `end` event.
- `error` - Time when the request fired `error` event.
- `abort` - Time when the request fired `abort` event.
- `phases`
- `wait` - `timings.socket - timings.start`
- `dns` - `timings.lookup - timings.socket`
- `tcp` - `timings.connect - timings.lookup`
- `tls` - `timings.secureConnect - timings.connect`
- `request` - `timings.upload - (timings.secureConnect || timings.connect)`
- `firstByte` - `timings.response - timings.upload`
- `download` - `timings.end - timings.response`
- `total` - `(timings.end || timings.error || timings.abort) - timings.start`
If something has not been measured yet, it will be `undefined`.
__Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
*/
get timings(): Timings | undefined {
return (this._request as ClientRequestWithTimings)?.timings;
}
/**
Whether the response was retrieved from the cache.
*/
get isFromCache(): boolean | undefined {
return this._isFromCache;
}
get reusedSocket(): boolean | undefined {
return this._request?.reusedSocket;
}
} |
447 | async (response: Response) => {
// Parse body
const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br';
const {options} = request;
if (isCompressed && !options.decompress) {
response.body = response.rawBody;
} else {
try {
response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
} catch (error: any) {
// Fall back to `utf8`
response.body = response.rawBody.toString();
if (isResponseOk(response)) {
request._beforeError(error);
return;
}
}
}
try {
const hooks = options.hooks.afterResponse;
for (const [index, hook] of hooks.entries()) {
// @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
// eslint-disable-next-line no-await-in-loop
response = await hook(response, async (updatedOptions): CancelableRequest<Response> => {
options.merge(updatedOptions);
options.prefixUrl = '';
if (updatedOptions.url) {
options.url = updatedOptions.url;
}
// Remove any further hooks for that request, because we'll call them anyway.
// The loop continues. We don't want duplicates (asPromise recursion).
options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
throw new RetryError(request);
});
if (!(is.object(response) && is.number(response.statusCode) && !is.nullOrUndefined(response.body))) {
throw new TypeError('The `afterResponse` hook returned an invalid value');
}
}
} catch (error: any) {
request._beforeError(error);
return;
}
globalResponse = response;
if (!isResponseOk(response)) {
request._beforeError(new HTTPError(response));
return;
}
request.destroy();
resolve(request.options.resolveBodyOnly ? response.body as T : response as unknown as T);
} | type Response<T = unknown> = {
/**
The result of the request.
*/
body: T;
/**
The raw result of the request.
*/
rawBody: Buffer;
} & PlainResponse; |
448 | (error: RequestError) => {
if (promise.isCanceled) {
return;
}
const {options} = request;
if (error instanceof HTTPError && !options.throwHttpErrors) {
const {response} = error;
request.destroy();
resolve(request.options.resolveBodyOnly ? response.body as T : response as unknown as T);
return;
}
reject(error);
} | class RequestError extends Error {
input?: string;
code: string;
override stack!: string;
declare readonly options: Options;
readonly response?: Response;
readonly request?: Request;
readonly timings?: Timings;
constructor(message: string, error: Partial<Error & {code?: string}>, self: Request | Options) {
super(message);
Error.captureStackTrace(this, this.constructor);
this.name = 'RequestError';
this.code = error.code ?? 'ERR_GOT_REQUEST_ERROR';
this.input = (error as any).input;
if (isRequest(self)) {
Object.defineProperty(this, 'request', {
enumerable: false,
value: self,
});
Object.defineProperty(this, 'response', {
enumerable: false,
value: self.response,
});
this.options = self.options;
} else {
this.options = self;
}
this.timings = this.request?.timings;
// Recover the original stacktrace
if (is.string(error.stack) && is.string(this.stack)) {
const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse();
const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message!) + error.message!.length).split('\n').reverse();
// Remove duplicated traces
while (errorStackTrace.length > 0 && errorStackTrace[0] === thisStackTrace[0]) {
thisStackTrace.shift();
}
this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`;
}
}
} |
449 | function isGitIgnored(options?: GitignoreOptions): Promise<GlobbyFilterFunction>; | interface GitignoreOptions {
readonly cwd?: URL | string;
} |
450 | function isGitIgnoredSync(options?: GitignoreOptions): GlobbyFilterFunction; | interface GitignoreOptions {
readonly cwd?: URL | string;
} |
451 | function genericsWorker(this: GenericsContext, task: number, cb: fastq.done<string>) {
cb(null, 'the meaning of life is ' + (this.base * task))
} | interface GenericsContext {
base: number;
} |
452 | function createModuleTypeClassifier(
options: ModuleTypeClassifierOptions
) {
const { patterns, basePath: _basePath } = options;
const basePath =
_basePath !== undefined
? normalizeSlashes(_basePath).replace(/\/$/, '')
: undefined;
const patternTypePairs = Object.entries(patterns ?? []).map(
([_pattern, type]) => {
const pattern = normalizeSlashes(_pattern);
return { pattern: parsePattern(basePath!, pattern), type };
}
);
const classifications: Record<ModuleTypeOverride, ModuleTypeClassification> =
{
package: {
moduleType: 'auto',
},
cjs: {
moduleType: 'cjs',
},
esm: {
moduleType: 'esm',
},
};
const auto = classifications.package;
// Passed path must be normalized!
function classifyModuleNonCached(path: string): ModuleTypeClassification {
const matched = matchPatterns(patternTypePairs, (_) => _.pattern, path);
if (matched) return classifications[matched.type];
return auto;
}
const classifyModule = cachedLookup(classifyModuleNonCached);
function classifyModuleAuto(path: String) {
return auto;
}
return {
classifyModuleByModuleTypeOverrides: patternTypePairs.length
? classifyModule
: classifyModuleAuto,
};
} | interface ModuleTypeClassifierOptions {
basePath?: string;
patterns?: ModuleTypes;
} |
453 | (t: T) => RegExp | type T = ExecutionContext<ctxTsNode.Ctx>; |
454 | setService(service: Service): void | interface Service {
/** @internal */
[TS_NODE_SERVICE_BRAND]: true;
ts: TSCommon;
/** @internal */
compilerPath: string;
config: _ts.ParsedCommandLine;
options: RegisterOptions;
enabled(enabled?: boolean): boolean;
ignored(fileName: string): boolean;
compile(code: string, fileName: string, lineOffset?: number): string;
getTypeInfo(code: string, fileName: string, position: number): TypeInfo;
/** @internal */
configFilePath: string | undefined;
/** @internal */
moduleTypeClassifier: ModuleTypeClassifier;
/** @internal */
readonly shouldReplAwait: boolean;
/** @internal */
addDiagnosticFilter(filter: DiagnosticFilter): void;
/** @internal */
installSourceMapSupport(): void;
/** @internal */
transpileOnly: boolean;
/** @internal */
projectLocalResolveHelper: ProjectLocalResolveHelper;
/** @internal */
getNodeEsmResolver: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-resolve').createResolve
>;
/** @internal */
getNodeEsmGetFormat: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-get_format').createGetFormat
>;
/** @internal */
getNodeCjsLoader: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-cjs-loader').createCjsLoader
>;
/** @internal */
extensions: Extensions;
} |
455 | function createRepl(options: CreateReplOptions = {}) {
const { ignoreDiagnosticsThatAreAnnoyingInInteractiveRepl = true } = options;
let service = options.service;
let nodeReplServer: REPLServer;
// If `useGlobal` is not true, then REPL creates a context when started.
// This stores a reference to it or to `global`, whichever is used, after REPL has started.
let context: Context | undefined;
const state =
options.state ?? new EvalState(join(process.cwd(), REPL_FILENAME));
const evalAwarePartialHost = createEvalAwarePartialHost(
state,
options.composeWithEvalAwarePartialHost
);
const stdin = options.stdin ?? process.stdin;
const stdout = options.stdout ?? process.stdout;
const stderr = options.stderr ?? process.stderr;
const _console =
stdout === process.stdout && stderr === process.stderr
? console
: new Console(stdout, stderr);
const replService: ReplService = {
state: options.state ?? new EvalState(join(process.cwd(), EVAL_FILENAME)),
setService,
evalCode,
evalCodeInternal,
nodeEval,
evalAwarePartialHost,
start,
startInternal,
stdin,
stdout,
stderr,
console: _console,
};
return replService;
function setService(_service: Service) {
service = _service;
if (ignoreDiagnosticsThatAreAnnoyingInInteractiveRepl) {
service.addDiagnosticFilter({
appliesToAllFiles: false,
filenamesAbsolute: [state.path],
diagnosticsIgnored: [
2393, // Duplicate function implementation: https://github.com/TypeStrong/ts-node/issues/729
6133, // <identifier> is declared but its value is never read. https://github.com/TypeStrong/ts-node/issues/850
7027, // Unreachable code detected. https://github.com/TypeStrong/ts-node/issues/469
...(service.shouldReplAwait ? topLevelAwaitDiagnosticCodes : []),
],
});
}
}
function evalCode(code: string) {
const result = appendCompileAndEvalInput({
service: service!,
state,
input: code,
context,
overrideIsCompletion: false,
});
assert(result.containsTopLevelAwait === false);
return result.value;
}
function evalCodeInternal(options: {
code: string;
enableTopLevelAwait?: boolean;
context: Context;
}) {
const { code, enableTopLevelAwait, context } = options;
return appendCompileAndEvalInput({
service: service!,
state,
input: code,
enableTopLevelAwait,
context,
});
}
function nodeEval(
code: string,
context: Context,
_filename: string,
callback: (err: Error | null, result?: any) => any
) {
// TODO: Figure out how to handle completion here.
if (code === '.scope') {
callback(null);
return;
}
try {
const evalResult = evalCodeInternal({
code,
enableTopLevelAwait: true,
context,
});
if (evalResult.containsTopLevelAwait) {
(async () => {
try {
callback(null, await evalResult.valuePromise);
} catch (promiseError) {
handleError(promiseError);
}
})();
} else {
callback(null, evalResult.value);
}
} catch (error) {
handleError(error);
}
// Log TSErrors, check if they're recoverable, log helpful hints for certain
// well-known errors, and invoke `callback()`
// TODO should evalCode API get the same error-handling benefits?
function handleError(error: unknown) {
// Don't show TLA hint if the user explicitly disabled repl top level await
const canLogTopLevelAwaitHint =
service!.options.experimentalReplAwait !== false &&
!service!.shouldReplAwait;
if (error instanceof TSError) {
// Support recoverable compilations using >= node 6.
if (Recoverable && isRecoverable(error)) {
callback(new Recoverable(error));
return;
} else {
_console.error(error);
if (
canLogTopLevelAwaitHint &&
error.diagnosticCodes.some((dC) =>
topLevelAwaitDiagnosticCodes.includes(dC)
)
) {
_console.error(getTopLevelAwaitHint());
}
callback(null);
}
} else {
let _error = error as Error | undefined;
if (
canLogTopLevelAwaitHint &&
_error instanceof SyntaxError &&
_error.message?.includes('await is only valid')
) {
try {
// Only way I know to make our hint appear after the error
_error.message += `\n\n${getTopLevelAwaitHint()}`;
_error.stack = _error.stack?.replace(
/(SyntaxError:.*)/,
(_, $1) => `${$1}\n\n${getTopLevelAwaitHint()}`
);
} catch {}
}
callback(_error as Error);
}
}
function getTopLevelAwaitHint() {
return `Hint: REPL top-level await requires TypeScript version 3.8 or higher and target ES2018 or higher. You are using TypeScript ${
service!.ts.version
} and target ${
service!.ts.ScriptTarget[service!.config.options.target!]
}.`;
}
}
// Note: `code` argument is deprecated
function start(code?: string) {
startInternal({ code });
}
// Note: `code` argument is deprecated
function startInternal(
options?: ReplOptions & { code?: string; forceToBeModule?: boolean }
) {
const { code, forceToBeModule = true, ...optionsOverride } = options ?? {};
// TODO assert that `service` is set; remove all `service!` non-null assertions
// Eval incoming code before the REPL starts.
// Note: deprecated
if (code) {
try {
evalCode(`${code}\n`);
} catch (err) {
_console.error(err);
// Note: should not be killing the process here, but this codepath is deprecated anyway
process.exit(1);
}
}
// In case the typescript compiler hasn't compiled anything yet,
// make it run though compilation at least one time before
// the REPL starts for a snappier user experience on startup.
service?.compile('', state.path);
const repl = nodeReplStart({
prompt: '> ',
input: replService.stdin,
output: replService.stdout,
// Mimicking node's REPL implementation: https://github.com/nodejs/node/blob/168b22ba073ee1cbf8d0bcb4ded7ff3099335d04/lib/internal/repl.js#L28-L30
terminal:
(stdout as tty.WriteStream).isTTY &&
!parseInt(env.NODE_NO_READLINE!, 10),
eval: nodeEval,
useGlobal: true,
...optionsOverride,
});
nodeReplServer = repl;
context = repl.context;
// Bookmark the point where we should reset the REPL state.
const resetEval = appendToEvalState(state, '');
function reset() {
resetEval();
// Hard fix for TypeScript forcing `Object.defineProperty(exports, ...)`.
runInContext('exports = module.exports', state.path, context);
if (forceToBeModule) {
state.input += 'export {};void 0;\n';
}
// Declare node builtins.
// Skip the same builtins as `addBuiltinLibsToObject`:
// those starting with _
// those containing /
// those that already exist as globals
// Intentionally suppress type errors in case @types/node does not declare any of them, and because
// `declare import` is technically invalid syntax.
// Avoid this when in transpileOnly, because third-party transpilers may not handle `declare import`.
if (!service?.transpileOnly) {
state.input += `// @ts-ignore\n${builtinModules
.filter(
(name) =>
!name.startsWith('_') &&
!name.includes('/') &&
!['console', 'module', 'process'].includes(name)
)
.map((name) => `declare import ${name} = require('${name}')`)
.join(';')}\n`;
}
}
reset();
repl.on('reset', reset);
repl.defineCommand('type', {
help: 'Check the type of a TypeScript identifier',
action: function (identifier: string) {
if (!identifier) {
repl.displayPrompt();
return;
}
const undo = appendToEvalState(state, identifier);
const { name, comment } = service!.getTypeInfo(
state.input,
state.path,
state.input.length
);
undo();
if (name) repl.outputStream.write(`${name}\n`);
if (comment) repl.outputStream.write(`${comment}\n`);
repl.displayPrompt();
},
});
// Set up REPL history when available natively via node.js >= 11.
if (repl.setupHistory) {
const historyPath =
env.TS_NODE_HISTORY || join(homedir(), '.ts_node_repl_history');
repl.setupHistory(historyPath, (err) => {
if (!err) return;
_console.error(err);
process.exit(1);
});
}
return repl;
}
} | interface CreateReplOptions {
service?: Service;
state?: EvalState;
stdin?: NodeJS.ReadableStream;
stdout?: NodeJS.WritableStream;
stderr?: NodeJS.WritableStream;
/** @internal */
composeWithEvalAwarePartialHost?: EvalAwarePartialHost;
/**
* @internal
* Ignore diagnostics that are annoying when interactively entering input line-by-line.
*/
ignoreDiagnosticsThatAreAnnoyingInInteractiveRepl?: boolean;
} |
456 | function setService(_service: Service) {
service = _service;
if (ignoreDiagnosticsThatAreAnnoyingInInteractiveRepl) {
service.addDiagnosticFilter({
appliesToAllFiles: false,
filenamesAbsolute: [state.path],
diagnosticsIgnored: [
2393, // Duplicate function implementation: https://github.com/TypeStrong/ts-node/issues/729
6133, // <identifier> is declared but its value is never read. https://github.com/TypeStrong/ts-node/issues/850
7027, // Unreachable code detected. https://github.com/TypeStrong/ts-node/issues/469
...(service.shouldReplAwait ? topLevelAwaitDiagnosticCodes : []),
],
});
}
} | interface Service {
/** @internal */
[TS_NODE_SERVICE_BRAND]: true;
ts: TSCommon;
/** @internal */
compilerPath: string;
config: _ts.ParsedCommandLine;
options: RegisterOptions;
enabled(enabled?: boolean): boolean;
ignored(fileName: string): boolean;
compile(code: string, fileName: string, lineOffset?: number): string;
getTypeInfo(code: string, fileName: string, position: number): TypeInfo;
/** @internal */
configFilePath: string | undefined;
/** @internal */
moduleTypeClassifier: ModuleTypeClassifier;
/** @internal */
readonly shouldReplAwait: boolean;
/** @internal */
addDiagnosticFilter(filter: DiagnosticFilter): void;
/** @internal */
installSourceMapSupport(): void;
/** @internal */
transpileOnly: boolean;
/** @internal */
projectLocalResolveHelper: ProjectLocalResolveHelper;
/** @internal */
getNodeEsmResolver: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-resolve').createResolve
>;
/** @internal */
getNodeEsmGetFormat: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-get_format').createGetFormat
>;
/** @internal */
getNodeCjsLoader: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-cjs-loader').createCjsLoader
>;
/** @internal */
extensions: Extensions;
} |
457 | function createEvalAwarePartialHost(
state: EvalState,
composeWith?: EvalAwarePartialHost
): EvalAwarePartialHost {
function readFile(path: string) {
if (path === state.path) return state.input;
if (composeWith?.readFile) return composeWith.readFile(path);
try {
return readFileSync(path, 'utf8');
} catch (err) {
/* Ignore. */
}
}
function fileExists(path: string) {
if (path === state.path) return true;
if (composeWith?.fileExists) return composeWith.fileExists(path);
try {
const stats = statSync(path);
return stats.isFile() || stats.isFIFO();
} catch (err) {
return false;
}
}
return { readFile, fileExists };
} | type EvalAwarePartialHost = Pick<
CreateOptions,
'readFile' | 'fileExists'
>; |
458 | function createEvalAwarePartialHost(
state: EvalState,
composeWith?: EvalAwarePartialHost
): EvalAwarePartialHost {
function readFile(path: string) {
if (path === state.path) return state.input;
if (composeWith?.readFile) return composeWith.readFile(path);
try {
return readFileSync(path, 'utf8');
} catch (err) {
/* Ignore. */
}
}
function fileExists(path: string) {
if (path === state.path) return true;
if (composeWith?.fileExists) return composeWith.fileExists(path);
try {
const stats = statSync(path);
return stats.isFile() || stats.isFIFO();
} catch (err) {
return false;
}
}
return { readFile, fileExists };
} | class EvalState {
/** @internal */
input = '';
/** @internal */
output = '';
/** @internal */
version = 0;
/** @internal */
lines = 0;
__tsNodeEvalStateBrand: unknown;
constructor(public path: string) {}
} |
459 | function appendToEvalState(state: EvalState, input: string) {
const undoInput = state.input;
const undoVersion = state.version;
const undoOutput = state.output;
const undoLines = state.lines;
state.input += input;
state.lines += lineCount(input);
state.version++;
return function () {
state.input = undoInput;
state.output = undoOutput;
state.version = undoVersion;
state.lines = undoLines;
};
} | class EvalState {
/** @internal */
input = '';
/** @internal */
output = '';
/** @internal */
version = 0;
/** @internal */
lines = 0;
__tsNodeEvalStateBrand: unknown;
constructor(public path: string) {}
} |
460 | function isRecoverable(error: TSError) {
return error.diagnosticCodes.every((code) => {
const deps = RECOVERY_CODES.get(code);
return (
deps === null ||
(deps && error.diagnosticCodes.some((code) => deps.has(code)))
);
});
} | class TSError extends BaseError {
name = 'TSError';
diagnosticText!: string;
diagnostics!: ReadonlyArray<_ts.Diagnostic>;
constructor(
diagnosticText: string,
public diagnosticCodes: number[],
diagnostics: ReadonlyArray<_ts.Diagnostic> = []
) {
super(`⨯ Unable to compile TypeScript:\n${diagnosticText}`);
Object.defineProperty(this, 'diagnosticText', {
configurable: true,
writable: true,
value: diagnosticText,
});
Object.defineProperty(this, 'diagnostics', {
configurable: true,
writable: true,
value: diagnostics,
});
}
/**
* @internal
*/
[INSPECT_CUSTOM]() {
return this.diagnosticText;
}
} |
461 | (arg: T) => U | type T = ExecutionContext<ctxTsNode.Ctx>; |
462 | (x: T) => {
debug(key, x, ++i);
return fn(x);
} | type T = ExecutionContext<ctxTsNode.Ctx>; |
463 | addDiagnosticFilter(filter: DiagnosticFilter): void | interface DiagnosticFilter {
/** if true, filter applies to all files */
appliesToAllFiles: boolean;
/** Filter applies onto to these filenames. Only used if appliesToAllFiles is false */
filenamesAbsolute: string[];
/** these diagnostic codes are ignored */
diagnosticsIgnored: number[];
} |
464 | function register(opts?: RegisterOptions): Service; | interface RegisterOptions extends CreateOptions {
/**
* Enable experimental features that re-map imports and require calls to support:
* `baseUrl`, `paths`, `rootDirs`, `.js` to `.ts` file extension mappings,
* `outDir` to `rootDir` mappings for composite projects and monorepos.
*
* For details, see https://github.com/TypeStrong/ts-node/issues/1514
*/
experimentalResolver?: boolean;
} |
465 | function register(service: Service): Service; | interface Service {
/** @internal */
[TS_NODE_SERVICE_BRAND]: true;
ts: TSCommon;
/** @internal */
compilerPath: string;
config: _ts.ParsedCommandLine;
options: RegisterOptions;
enabled(enabled?: boolean): boolean;
ignored(fileName: string): boolean;
compile(code: string, fileName: string, lineOffset?: number): string;
getTypeInfo(code: string, fileName: string, position: number): TypeInfo;
/** @internal */
configFilePath: string | undefined;
/** @internal */
moduleTypeClassifier: ModuleTypeClassifier;
/** @internal */
readonly shouldReplAwait: boolean;
/** @internal */
addDiagnosticFilter(filter: DiagnosticFilter): void;
/** @internal */
installSourceMapSupport(): void;
/** @internal */
transpileOnly: boolean;
/** @internal */
projectLocalResolveHelper: ProjectLocalResolveHelper;
/** @internal */
getNodeEsmResolver: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-resolve').createResolve
>;
/** @internal */
getNodeEsmGetFormat: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-get_format').createGetFormat
>;
/** @internal */
getNodeCjsLoader: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-cjs-loader').createCjsLoader
>;
/** @internal */
extensions: Extensions;
} |
466 | function create(rawOptions: CreateOptions = {}): Service {
const foundConfigResult = findAndReadConfig(rawOptions);
return createFromPreloadedConfig(foundConfigResult);
} | interface CreateOptions {
/**
* Behave as if invoked within this working directory. Roughly equivalent to `cd $dir && ts-node ...`
*
* @default process.cwd()
*/
cwd?: string;
/**
* Legacy alias for `cwd`
*
* @deprecated use `projectSearchDir` or `cwd`
*/
dir?: string;
/**
* Emit output files into `.ts-node` directory.
*
* @default false
*/
emit?: boolean;
/**
* Scope compiler to files within `scopeDir`.
*
* @default false
*/
scope?: boolean;
/**
* @default First of: `tsconfig.json` "rootDir" if specified, directory containing `tsconfig.json`, or cwd if no `tsconfig.json` is loaded.
*/
scopeDir?: string;
/**
* Use pretty diagnostic formatter.
*
* @default false
*/
pretty?: boolean;
/**
* Use TypeScript's faster `transpileModule`.
*
* @default false
*/
transpileOnly?: boolean;
/**
* **DEPRECATED** Specify type-check is enabled (e.g. `transpileOnly == false`).
*
* @default true
*/
typeCheck?: boolean;
/**
* Use TypeScript's compiler host API instead of the language service API.
*
* @default false
*/
compilerHost?: boolean;
/**
* Logs TypeScript errors to stderr instead of throwing exceptions.
*
* @default false
*/
logError?: boolean;
/**
* Load "files" and "include" from `tsconfig.json` on startup.
*
* Default is to override `tsconfig.json` "files" and "include" to only include the entrypoint script.
*
* @default false
*/
files?: boolean;
/**
* Specify a custom TypeScript compiler.
*
* @default "typescript"
*/
compiler?: string;
/**
* Specify a custom transpiler for use with transpileOnly
*/
transpiler?: string | [string, object];
/**
* Transpile with swc instead of the TypeScript compiler, and skip typechecking.
*
* Equivalent to setting both `transpileOnly: true` and `transpiler: 'ts-node/transpilers/swc'`
*
* For complete instructions: https://typestrong.org/ts-node/docs/transpilers
*/
swc?: boolean;
/**
* Paths which should not be compiled.
*
* Each string in the array is converted to a regular expression via `new RegExp()` and tested against source paths prior to compilation.
*
* Source paths are normalized to posix-style separators, relative to the directory containing `tsconfig.json` or to cwd if no `tsconfig.json` is loaded.
*
* Default is to ignore all node_modules subdirectories.
*
* @default ["(?:^|/)node_modules/"]
*/
ignore?: string[];
/**
* Path to TypeScript config file or directory containing a `tsconfig.json`.
* Similar to the `tsc --project` flag: https://www.typescriptlang.org/docs/handbook/compiler-options.html
*/
project?: string;
/**
* Search for TypeScript config file (`tsconfig.json`) in this or parent directories.
*/
projectSearchDir?: string;
/**
* Skip project config resolution and loading.
*
* @default false
*/
skipProject?: boolean;
/**
* Skip ignore check, so that compilation will be attempted for all files with matching extensions.
*
* @default false
*/
skipIgnore?: boolean;
/**
* JSON object to merge with TypeScript `compilerOptions`.
*
* @allOf [{"$ref": "https://schemastore.azurewebsites.net/schemas/json/tsconfig.json#definitions/compilerOptionsDefinition/properties/compilerOptions"}]
*/
compilerOptions?: object;
/**
* Ignore TypeScript warnings by diagnostic code.
*/
ignoreDiagnostics?: Array<number | string>;
/**
* Modules to require, like node's `--require` flag.
*
* If specified in `tsconfig.json`, the modules will be resolved relative to the `tsconfig.json` file.
*
* If specified programmatically, each input string should be pre-resolved to an absolute path for
* best results.
*/
require?: Array<string>;
readFile?: (path: string) => string | undefined;
fileExists?: (path: string) => boolean;
transformers?:
| _ts.CustomTransformers
| ((p: _ts.Program) => _ts.CustomTransformers);
/**
* Allows the usage of top level await in REPL.
*
* Uses node's implementation which accomplishes this with an AST syntax transformation.
*
* Enabled by default when tsconfig target is es2018 or above. Set to false to disable.
*
* **Note**: setting to `true` when tsconfig target is too low will throw an Error. Leave as `undefined`
* to get default, automatic behavior.
*/
experimentalReplAwait?: boolean;
/**
* Override certain paths to be compiled and executed as CommonJS or ECMAScript modules.
* When overridden, the tsconfig "module" and package.json "type" fields are overridden, and
* the file extension is ignored.
* This is useful if you cannot use .mts, .cts, .mjs, or .cjs file extensions;
* it achieves the same effect.
*
* Each key is a glob pattern following the same rules as tsconfig's "include" array.
* When multiple patterns match the same file, the last pattern takes precedence.
*
* `cjs` overrides matches files to compile and execute as CommonJS.
* `esm` overrides matches files to compile and execute as native ECMAScript modules.
* `package` overrides either of the above to default behavior, which obeys package.json "type" and
* tsconfig.json "module" options.
*/
moduleTypes?: ModuleTypes;
/**
* @internal
* Set by our configuration loader whenever a config file contains options that
* are relative to the config file they came from, *and* when other logic needs
* to know this. Some options can be eagerly resolved to absolute paths by
* the configuration loader, so it is *not* necessary for their source to be set here.
*/
optionBasePaths?: OptionBasePaths;
/**
* A function to collect trace messages from the TypeScript compiler, for example when `traceResolution` is enabled.
*
* @default console.log
*/
tsTrace?: (str: string) => void;
/**
* Enable native ESM support.
*
* For details, see https://typestrong.org/ts-node/docs/imports#native-ecmascript-modules
*/
esm?: boolean;
/**
* Re-order file extensions so that TypeScript imports are preferred.
*
* For example, when both `index.js` and `index.ts` exist, enabling this option causes `require('./index')` to resolve to `index.ts` instead of `index.js`
*
* @default false
*/
preferTsExts?: boolean;
/**
* Like node's `--experimental-specifier-resolution`, , but can also be set in your `tsconfig.json` for convenience.
*
* For details, see https://nodejs.org/dist/latest-v18.x/docs/api/esm.html#customizing-esm-specifier-resolution-algorithm
*/
experimentalSpecifierResolution?: 'node' | 'explicit';
/**
* Allow using voluntary `.ts` file extension in import specifiers.
*
* Typically, in ESM projects, import specifiers must have an emit extension, `.js`, `.cjs`, or `.mjs`,
* and we automatically map to the corresponding `.ts`, `.cts`, or `.mts` source file. This is the
* recommended approach.
*
* However, if you really want to use `.ts` in import specifiers, and are aware that this may
* break tooling, you can enable this flag.
*/
experimentalTsImportSpecifiers?: boolean;
} |
467 | function addDiagnosticFilter(filter: DiagnosticFilter) {
diagnosticFilters.push({
...filter,
filenamesAbsolute: filter.filenamesAbsolute.map((f) =>
normalizeSlashes(f)
),
});
} | interface DiagnosticFilter {
/** if true, filter applies to all files */
appliesToAllFiles: boolean;
/** Filter applies onto to these filenames. Only used if appliesToAllFiles is false */
filenamesAbsolute: string[];
/** these diagnostic codes are ignored */
diagnosticsIgnored: number[];
} |
468 | function getTokenAtPosition(
ts: TSCommon,
sourceFile: _ts.SourceFile,
position: number
): _ts.Node {
let current: _ts.Node = sourceFile;
outer: while (true) {
for (const child of current.getChildren(sourceFile)) {
const start = child.getFullStart();
if (start > position) break;
const end = child.getEnd();
if (position <= end) {
current = child;
continue outer;
}
}
return current;
}
} | interface TSCommon {
version: typeof _ts.version;
sys: typeof _ts.sys;
ScriptSnapshot: typeof _ts.ScriptSnapshot;
displayPartsToString: typeof _ts.displayPartsToString;
createLanguageService: typeof _ts.createLanguageService;
getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath;
getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics;
flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText;
transpileModule: typeof _ts.transpileModule;
ModuleKind: TSCommon.ModuleKindEnum;
ScriptTarget: typeof _ts.ScriptTarget;
findConfigFile: typeof _ts.findConfigFile;
readConfigFile: typeof _ts.readConfigFile;
parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent;
formatDiagnostics: typeof _ts.formatDiagnostics;
formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext;
createDocumentRegistry: typeof _ts.createDocumentRegistry;
JsxEmit: typeof _ts.JsxEmit;
createModuleResolutionCache: typeof _ts.createModuleResolutionCache;
resolveModuleName: typeof _ts.resolveModuleName;
resolveModuleNameFromCache: typeof _ts.resolveModuleNameFromCache;
resolveTypeReferenceDirective: typeof _ts.resolveTypeReferenceDirective;
createIncrementalCompilerHost: typeof _ts.createIncrementalCompilerHost;
createSourceFile: typeof _ts.createSourceFile;
getDefaultLibFileName: typeof _ts.getDefaultLibFileName;
createIncrementalProgram: typeof _ts.createIncrementalProgram;
createEmitAndSemanticDiagnosticsBuilderProgram: typeof _ts.createEmitAndSemanticDiagnosticsBuilderProgram;
Extension: typeof _ts.Extension;
ModuleResolutionKind: typeof _ts.ModuleResolutionKind;
} |
469 | (
tsNodeService: Service
) => (require('./esm') as typeof import('./esm')).createEsmHooks(tsNodeService) | interface Service {
/** @internal */
[TS_NODE_SERVICE_BRAND]: true;
ts: TSCommon;
/** @internal */
compilerPath: string;
config: _ts.ParsedCommandLine;
options: RegisterOptions;
enabled(enabled?: boolean): boolean;
ignored(fileName: string): boolean;
compile(code: string, fileName: string, lineOffset?: number): string;
getTypeInfo(code: string, fileName: string, position: number): TypeInfo;
/** @internal */
configFilePath: string | undefined;
/** @internal */
moduleTypeClassifier: ModuleTypeClassifier;
/** @internal */
readonly shouldReplAwait: boolean;
/** @internal */
addDiagnosticFilter(filter: DiagnosticFilter): void;
/** @internal */
installSourceMapSupport(): void;
/** @internal */
transpileOnly: boolean;
/** @internal */
projectLocalResolveHelper: ProjectLocalResolveHelper;
/** @internal */
getNodeEsmResolver: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-resolve').createResolve
>;
/** @internal */
getNodeEsmGetFormat: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-get_format').createGetFormat
>;
/** @internal */
getNodeCjsLoader: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-cjs-loader').createCjsLoader
>;
/** @internal */
extensions: Extensions;
} |
470 | function assign<T extends object>(
initialValue: T,
...sources: Array<T>
): T {
for (const source of sources) {
for (const key of Object.keys(source)) {
const value = (source as any)[key];
if (value !== undefined) (initialValue as any)[key] = value;
}
}
return initialValue;
} | type T = ExecutionContext<ctxTsNode.Ctx>; |
471 | (arg: T) => R | type T = ExecutionContext<ctxTsNode.Ctx>; |
472 | (arg: T): R => {
if (!cache.has(arg)) {
const v = fn(arg);
cache.set(arg, v);
return v;
}
return cache.get(arg)!;
} | type T = ExecutionContext<ctxTsNode.Ctx>; |
473 | function bootstrap(state: BootstrapState) {
if (!state.phase2Result) {
state.phase2Result = phase2(state);
if (state.shouldUseChildProcess && !state.isInChildProcess) {
// Note: When transitioning into the child-process after `phase2`,
// the updated working directory needs to be preserved.
return callInChild(state);
}
}
if (!state.phase3Result) {
state.phase3Result = phase3(state);
if (state.shouldUseChildProcess && !state.isInChildProcess) {
// Note: When transitioning into the child-process after `phase2`,
// the updated working directory needs to be preserved.
return callInChild(state);
}
}
return phase4(state);
} | interface BootstrapState {
isInChildProcess: boolean;
shouldUseChildProcess: boolean;
/**
* True if bootstrapping the ts-node CLI process or the direct child necessitated by `--esm`.
* false if bootstrapping a subsequently `fork()`ed child.
*/
isCli: boolean;
tsNodeScript: string;
parseArgvResult: ReturnType<typeof parseArgv>;
phase2Result?: ReturnType<typeof phase2>;
phase3Result?: ReturnType<typeof phase3>;
} |
474 | function phase2(payload: BootstrapState) {
const { help, version, cwdArg, esm } = payload.parseArgvResult;
if (help) {
console.log(`
Usage: ts-node [options] [ -e script | script.ts ] [arguments]
Options:
-e, --eval [code] Evaluate code
-p, --print Print result of \`--eval\`
-r, --require [path] Require a node module before execution
-i, --interactive Opens the REPL even if stdin does not appear to be a terminal
--esm Bootstrap with the ESM loader, enabling full ESM support
--swc Use the faster swc transpiler
-h, --help Print CLI usage
-v, --version Print module version information. -vvv to print additional information
--showConfig Print resolved configuration and exit
-T, --transpileOnly Use TypeScript's faster \`transpileModule\` or a third-party transpiler
-H, --compilerHost Use TypeScript's compiler host API
-I, --ignore [pattern] Override the path patterns to skip compilation
-P, --project [path] Path to TypeScript JSON project file
-C, --compiler [name] Specify a custom TypeScript compiler
--transpiler [name] Specify a third-party, non-typechecking transpiler
-D, --ignoreDiagnostics [code] Ignore TypeScript warnings by diagnostic code
-O, --compilerOptions [opts] JSON object to merge with compiler options
--cwd Behave as if invoked within this working directory.
--files Load \`files\`, \`include\` and \`exclude\` from \`tsconfig.json\` on startup
--pretty Use pretty diagnostic formatter (usually enabled by default)
--cwdMode Use current directory instead of <script.ts> for config resolution
--skipProject Skip reading \`tsconfig.json\`
--skipIgnore Skip \`--ignore\` checks
--emit Emit output files into \`.ts-node\` directory
--scope Scope compiler to files within \`scopeDir\`. Anything outside this directory is ignored.
--scopeDir Directory for \`--scope\`
--preferTsExts Prefer importing TypeScript files over JavaScript files
--logError Logs TypeScript errors to stderr instead of throwing exceptions
--noExperimentalReplAwait Disable top-level await in REPL. Equivalent to node's --no-experimental-repl-await
--experimentalSpecifierResolution [node|explicit]
Equivalent to node's --experimental-specifier-resolution
`);
process.exit(0);
}
// Output project information.
if (version === 1) {
console.log(`v${VERSION}`);
process.exit(0);
}
const cwd = cwdArg ? resolve(cwdArg) : process.cwd();
// If ESM is explicitly enabled through the flag, stage3 should be run in a child process
// with the ESM loaders configured.
if (esm) payload.shouldUseChildProcess = true;
return {
cwd,
};
} | interface BootstrapState {
isInChildProcess: boolean;
shouldUseChildProcess: boolean;
/**
* True if bootstrapping the ts-node CLI process or the direct child necessitated by `--esm`.
* false if bootstrapping a subsequently `fork()`ed child.
*/
isCli: boolean;
tsNodeScript: string;
parseArgvResult: ReturnType<typeof parseArgv>;
phase2Result?: ReturnType<typeof phase2>;
phase3Result?: ReturnType<typeof phase3>;
} |
475 | function phase3(payload: BootstrapState) {
const {
emit,
files,
pretty,
transpileOnly,
transpiler,
noExperimentalReplAwait,
typeCheck,
swc,
compilerHost,
ignore,
preferTsExts,
logError,
scriptMode,
cwdMode,
project,
skipProject,
skipIgnore,
compiler,
ignoreDiagnostics,
compilerOptions,
argsRequire,
scope,
scopeDir,
esm,
experimentalSpecifierResolution,
} = payload.parseArgvResult;
const { cwd } = payload.phase2Result!;
// NOTE: When we transition to a child process for ESM, the entry-point script determined
// here might not be the one used later in `phase4`. This can happen when we execute the
// original entry-point but then the process forks itself using e.g. `child_process.fork`.
// We will always use the original TS project in forked processes anyway, so it is
// expected and acceptable to retrieve the entry-point information here in `phase2`.
// See: https://github.com/TypeStrong/ts-node/issues/1812.
const { entryPointPath } = getEntryPointInfo(payload);
const preloadedConfig = findAndReadConfig({
cwd,
emit,
files,
pretty,
transpileOnly: transpileOnly ?? transpiler != null ? true : undefined,
experimentalReplAwait: noExperimentalReplAwait ? false : undefined,
typeCheck,
transpiler,
swc,
compilerHost,
ignore,
logError,
projectSearchDir: getProjectSearchDir(
cwd,
scriptMode,
cwdMode,
entryPointPath
),
project,
skipProject,
skipIgnore,
compiler,
ignoreDiagnostics,
compilerOptions,
require: argsRequire,
scope,
scopeDir,
preferTsExts,
esm,
experimentalSpecifierResolution:
experimentalSpecifierResolution as ExperimentalSpecifierResolution,
});
// If ESM is enabled through the parsed tsconfig, stage4 should be run in a child
// process with the ESM loaders configured.
if (preloadedConfig.options.esm) payload.shouldUseChildProcess = true;
return { preloadedConfig };
} | interface BootstrapState {
isInChildProcess: boolean;
shouldUseChildProcess: boolean;
/**
* True if bootstrapping the ts-node CLI process or the direct child necessitated by `--esm`.
* false if bootstrapping a subsequently `fork()`ed child.
*/
isCli: boolean;
tsNodeScript: string;
parseArgvResult: ReturnType<typeof parseArgv>;
phase2Result?: ReturnType<typeof phase2>;
phase3Result?: ReturnType<typeof phase3>;
} |
476 | function getEntryPointInfo(state: BootstrapState) {
const { code, interactive, restArgs } = state.parseArgvResult!;
const { cwd } = state.phase2Result!;
const { isCli } = state;
// Figure out which we are executing: piped stdin, --eval, REPL, and/or entrypoint
// This is complicated because node's behavior is complicated
// `node -e code -i ./script.js` ignores -e
const executeEval = code != null && !(interactive && restArgs.length);
const executeEntrypoint = !executeEval && restArgs.length > 0;
const executeRepl =
!executeEntrypoint &&
(interactive || (process.stdin.isTTY && !executeEval));
const executeStdin = !executeEval && !executeRepl && !executeEntrypoint;
/**
* Unresolved. May point to a symlink, not realpath. May be missing file extension
* NOTE: resolution relative to cwd option (not `process.cwd()`) is legacy backwards-compat; should be changed in next major: https://github.com/TypeStrong/ts-node/issues/1834
*/
const entryPointPath = executeEntrypoint
? isCli
? resolve(cwd, restArgs[0])
: resolve(restArgs[0])
: undefined;
return {
executeEval,
executeEntrypoint,
executeRepl,
executeStdin,
entryPointPath,
};
} | interface BootstrapState {
isInChildProcess: boolean;
shouldUseChildProcess: boolean;
/**
* True if bootstrapping the ts-node CLI process or the direct child necessitated by `--esm`.
* false if bootstrapping a subsequently `fork()`ed child.
*/
isCli: boolean;
tsNodeScript: string;
parseArgvResult: ReturnType<typeof parseArgv>;
phase2Result?: ReturnType<typeof phase2>;
phase3Result?: ReturnType<typeof phase3>;
} |
477 | function phase4(payload: BootstrapState) {
const { isInChildProcess, tsNodeScript } = payload;
const { version, showConfig, restArgs, code, print, argv } =
payload.parseArgvResult;
const { cwd } = payload.phase2Result!;
const { preloadedConfig } = payload.phase3Result!;
const {
entryPointPath,
executeEntrypoint,
executeEval,
executeRepl,
executeStdin,
} = getEntryPointInfo(payload);
/**
* <repl>, [stdin], and [eval] are all essentially virtual files that do not exist on disc and are backed by a REPL
* service to handle eval-ing of code.
*/
interface VirtualFileState {
state: EvalState;
repl: ReplService;
module?: Module;
}
let evalStuff: VirtualFileState | undefined;
let replStuff: VirtualFileState | undefined;
let stdinStuff: VirtualFileState | undefined;
let evalAwarePartialHost: EvalAwarePartialHost | undefined = undefined;
if (executeEval) {
const state = new EvalState(join(cwd, EVAL_FILENAME));
evalStuff = {
state,
repl: createRepl({
state,
composeWithEvalAwarePartialHost: evalAwarePartialHost,
ignoreDiagnosticsThatAreAnnoyingInInteractiveRepl: false,
}),
};
({ evalAwarePartialHost } = evalStuff.repl);
// Create a local module instance based on `cwd`.
const module = (evalStuff.module = new Module(EVAL_NAME));
module.filename = evalStuff.state.path;
module.paths = (Module as any)._nodeModulePaths(cwd);
}
if (executeStdin) {
const state = new EvalState(join(cwd, STDIN_FILENAME));
stdinStuff = {
state,
repl: createRepl({
state,
composeWithEvalAwarePartialHost: evalAwarePartialHost,
ignoreDiagnosticsThatAreAnnoyingInInteractiveRepl: false,
}),
};
({ evalAwarePartialHost } = stdinStuff.repl);
// Create a local module instance based on `cwd`.
const module = (stdinStuff.module = new Module(STDIN_NAME));
module.filename = stdinStuff.state.path;
module.paths = (Module as any)._nodeModulePaths(cwd);
}
if (executeRepl) {
const state = new EvalState(join(cwd, REPL_FILENAME));
replStuff = {
state,
repl: createRepl({
state,
composeWithEvalAwarePartialHost: evalAwarePartialHost,
}),
};
({ evalAwarePartialHost } = replStuff.repl);
}
// Register the TypeScript compiler instance.
const service = createFromPreloadedConfig({
// Since this struct may have been marshalled across thread or process boundaries, we must restore
// un-marshall-able values.
...preloadedConfig,
options: {
...preloadedConfig.options,
readFile: evalAwarePartialHost?.readFile ?? undefined,
fileExists: evalAwarePartialHost?.fileExists ?? undefined,
tsTrace: DEFAULTS.tsTrace,
},
});
register(service);
if (isInChildProcess)
(
require('./child/child-loader') as typeof import('./child/child-loader')
).lateBindHooks(createEsmHooks(service));
// Bind REPL service to ts-node compiler service (chicken-and-egg problem)
replStuff?.repl.setService(service);
evalStuff?.repl.setService(service);
stdinStuff?.repl.setService(service);
// Output project information.
if (version === 2) {
console.log(`ts-node v${VERSION}`);
console.log(`node ${process.version}`);
console.log(`compiler v${service.ts.version}`);
process.exit(0);
}
if (version >= 3) {
console.log(`ts-node v${VERSION} ${dirname(__dirname)}`);
console.log(`node ${process.version}`);
console.log(
`compiler v${service.ts.version} ${service.compilerPath ?? ''}`
);
process.exit(0);
}
if (showConfig) {
const ts = service.ts as any as TSInternal;
if (typeof ts.convertToTSConfig !== 'function') {
console.error(
'Error: --showConfig requires a typescript versions >=3.2 that support --showConfig'
);
process.exit(1);
}
let moduleTypes = undefined;
if (service.options.moduleTypes) {
// Assumption: this codepath requires CLI invocation, so moduleTypes must have come from a tsconfig, not API.
const showRelativeTo = dirname(service.configFilePath!);
moduleTypes = {} as Record<string, string>;
for (const [key, value] of Object.entries(service.options.moduleTypes)) {
moduleTypes[
relative(
showRelativeTo,
resolve(service.options.optionBasePaths?.moduleTypes!, key)
)
] = value;
}
}
const json = {
['ts-node']: {
...service.options,
require: service.options.require?.length
? service.options.require
: undefined,
moduleTypes,
optionBasePaths: undefined,
compilerOptions: undefined,
project: service.configFilePath ?? service.options.project,
},
...ts.convertToTSConfig(
service.config,
service.configFilePath ?? join(cwd, 'ts-node-implicit-tsconfig.json'),
service.ts.sys
),
};
console.log(
// Assumes that all configuration options which can possibly be specified via the CLI are JSON-compatible.
// If, in the future, we must log functions, for example readFile and fileExists, then we can implement a JSON
// replacer function.
JSON.stringify(json, null, 2)
);
process.exit(0);
}
// Prepend `ts-node` arguments to CLI for child processes.
process.execArgv.push(
tsNodeScript,
...argv.slice(2, argv.length - restArgs.length)
);
// TODO this comes from BootstrapState
process.argv = [process.argv[1]]
.concat(executeEntrypoint ? ([entryPointPath] as string[]) : [])
.concat(restArgs.slice(executeEntrypoint ? 1 : 0));
// Execute the main contents (either eval, script or piped).
if (executeEntrypoint) {
if (
payload.isInChildProcess &&
versionGteLt(process.versions.node, '18.6.0', '18.7.0')
) {
// HACK workaround node regression
require('../dist-raw/runmain-hack.js').run(entryPointPath);
} else {
Module.runMain();
}
} else {
// Note: eval and repl may both run, but never with stdin.
// If stdin runs, eval and repl will not.
if (executeEval) {
addBuiltinLibsToObject(global);
evalAndExitOnTsError(
evalStuff!.repl,
evalStuff!.module!,
code!,
print,
'eval'
);
}
if (executeRepl) {
replStuff!.repl.start();
}
if (executeStdin) {
let buffer = code || '';
process.stdin.on('data', (chunk: Buffer) => (buffer += chunk));
process.stdin.on('end', () => {
evalAndExitOnTsError(
stdinStuff!.repl,
stdinStuff!.module!,
buffer,
// `echo 123 | node -p` still prints 123
print,
'stdin'
);
});
}
}
} | interface BootstrapState {
isInChildProcess: boolean;
shouldUseChildProcess: boolean;
/**
* True if bootstrapping the ts-node CLI process or the direct child necessitated by `--esm`.
* false if bootstrapping a subsequently `fork()`ed child.
*/
isCli: boolean;
tsNodeScript: string;
parseArgvResult: ReturnType<typeof parseArgv>;
phase2Result?: ReturnType<typeof phase2>;
phase3Result?: ReturnType<typeof phase3>;
} |
478 | function evalAndExitOnTsError(
replService: ReplService,
module: Module,
code: string,
isPrinted: boolean,
filenameAndDirname: 'eval' | 'stdin'
) {
let result: any;
setupContext(global, module, filenameAndDirname);
try {
result = replService.evalCode(code);
} catch (error) {
if (error instanceof TSError) {
console.error(error);
process.exit(1);
}
throw error;
}
if (isPrinted) {
console.log(
typeof result === 'string'
? result
: inspect(result, { colors: process.stdout.isTTY })
);
}
} | interface ReplService {
readonly state: EvalState;
/**
* Bind this REPL to a ts-node compiler service. A compiler service must be bound before `eval`-ing code or starting the REPL
*/
setService(service: Service): void;
/**
* Append code to the virtual <repl> source file, compile it to JavaScript, throw semantic errors if the typechecker is enabled,
* and execute it.
*
* Note: typically, you will want to call `start()` instead of using this method.
*
* @param code string of TypeScript.
*/
evalCode(code: string): any;
/** @internal */
evalCodeInternal(opts: {
code: string;
enableTopLevelAwait?: boolean;
context?: Context;
}):
| {
containsTopLevelAwait: true;
valuePromise: Promise<any>;
}
| {
containsTopLevelAwait: false;
value: any;
};
/**
* `eval` implementation compatible with node's REPL API
*
* Can be used in advanced scenarios if you want to manually create your own
* node REPL instance and delegate eval to this `ReplService`.
*
* Example:
*
* import {start} from 'repl';
* const replService: tsNode.ReplService = ...; // assuming you have already created a ts-node ReplService
* const nodeRepl = start({eval: replService.eval});
*/
nodeEval(
code: string,
context: Context,
_filename: string,
callback: (err: Error | null, result?: any) => any
): void;
evalAwarePartialHost: EvalAwarePartialHost;
/** Start a node REPL */
start(): void;
/**
* Start a node REPL, evaling a string of TypeScript before it starts.
* @deprecated
*/
start(code: string): void;
/** @internal */
startInternal(opts?: ReplOptions): REPLServer;
/** @internal */
readonly stdin: NodeJS.ReadableStream;
/** @internal */
readonly stdout: NodeJS.WritableStream;
/** @internal */
readonly stderr: NodeJS.WritableStream;
/** @internal */
readonly console: Console;
} |
479 | function registerAndCreateEsmHooks(opts?: RegisterOptions) {
// Automatically performs registration just like `-r ts-node/register`
const tsNodeInstance = register(opts);
return createEsmHooks(tsNodeInstance);
} | interface RegisterOptions extends CreateOptions {
/**
* Enable experimental features that re-map imports and require calls to support:
* `baseUrl`, `paths`, `rootDirs`, `.js` to `.ts` file extension mappings,
* `outDir` to `rootDir` mappings for composite projects and monorepos.
*
* For details, see https://github.com/TypeStrong/ts-node/issues/1514
*/
experimentalResolver?: boolean;
} |
480 | function createEsmHooks(tsNodeService: Service) {
// Custom implementation that considers additional file extensions and automatically adds file extensions
const nodeResolveImplementation = tsNodeService.getNodeEsmResolver();
const nodeGetFormatImplementation = tsNodeService.getNodeEsmGetFormat();
const extensions = tsNodeService.extensions;
const hooksAPI = filterHooksByAPIVersion({
resolve,
load,
getFormat,
transformSource,
});
function isFileUrlOrNodeStyleSpecifier(parsed: UrlWithStringQuery) {
// We only understand file:// URLs, but in node, the specifier can be a node-style `./foo` or `foo`
const { protocol } = parsed;
return protocol === null || protocol === 'file:';
}
const runMainHackUrl = pathToFileURL(
pathResolve(__dirname, '../dist-raw/runmain-hack.js')
).toString();
/**
* Named "probably" as a reminder that this is a guess.
* node does not explicitly tell us if we're resolving the entrypoint or not.
*/
function isProbablyEntrypoint(specifier: string, parentURL: string) {
return (
(parentURL === undefined || parentURL === runMainHackUrl) &&
specifier.startsWith('file://')
);
}
// Side-channel between `resolve()` and `load()` hooks
const rememberIsProbablyEntrypoint = new Set();
const rememberResolvedViaCommonjsFallback = new Set();
async function resolve(
specifier: string,
context: { parentURL: string },
defaultResolve: typeof resolve
): Promise<{ url: string; format?: NodeLoaderHooksFormat }> {
const defer = async () => {
const r = await defaultResolve(specifier, context, defaultResolve);
return r;
};
// See: https://github.com/nodejs/node/discussions/41711
// nodejs will likely implement a similar fallback. Till then, we can do our users a favor and fallback today.
async function entrypointFallback(
cb: () => ReturnType<typeof resolve> | Awaited<ReturnType<typeof resolve>>
): ReturnType<typeof resolve> {
try {
const resolution = await cb();
if (
resolution?.url &&
isProbablyEntrypoint(specifier, context.parentURL)
)
rememberIsProbablyEntrypoint.add(resolution.url);
return resolution;
} catch (esmResolverError) {
if (!isProbablyEntrypoint(specifier, context.parentURL))
throw esmResolverError;
try {
let cjsSpecifier = specifier;
// Attempt to convert from ESM file:// to CommonJS path
try {
if (specifier.startsWith('file://'))
cjsSpecifier = fileURLToPath(specifier);
} catch {}
const resolution = pathToFileURL(
createRequire(process.cwd()).resolve(cjsSpecifier)
).toString();
rememberIsProbablyEntrypoint.add(resolution);
rememberResolvedViaCommonjsFallback.add(resolution);
return { url: resolution, format: 'commonjs' };
} catch (commonjsResolverError) {
throw esmResolverError;
}
}
}
return addShortCircuitFlag(async () => {
const parsed = parseUrl(specifier);
const { pathname, protocol, hostname } = parsed;
if (!isFileUrlOrNodeStyleSpecifier(parsed)) {
return entrypointFallback(defer);
}
if (protocol !== null && protocol !== 'file:') {
return entrypointFallback(defer);
}
// Malformed file:// URL? We should always see `null` or `''`
if (hostname) {
// TODO file://./foo sets `hostname` to `'.'`. Perhaps we should special-case this.
return entrypointFallback(defer);
}
// pathname is the path to be resolved
return entrypointFallback(() =>
nodeResolveImplementation.defaultResolve(
specifier,
context,
defaultResolve
)
);
});
}
// `load` from new loader hook API (See description at the top of this file)
async function load(
url: string,
context: {
format: NodeLoaderHooksFormat | null | undefined;
importAssertions?: NodeLoaderHooksAPI2.NodeImportAssertions;
},
defaultLoad: typeof load
): Promise<{
format: NodeLoaderHooksFormat;
source: string | Buffer | undefined;
}> {
return addShortCircuitFlag(async () => {
// If we get a format hint from resolve() on the context then use it
// otherwise call the old getFormat() hook using node's old built-in defaultGetFormat() that ships with ts-node
const format =
context.format ??
(
await getFormat(
url,
context,
nodeGetFormatImplementation.defaultGetFormat
)
).format;
let source = undefined;
if (format !== 'builtin' && format !== 'commonjs') {
// Call the new defaultLoad() to get the source
const { source: rawSource } = await defaultLoad(
url,
{
...context,
format,
},
defaultLoad
);
if (rawSource === undefined || rawSource === null) {
throw new Error(
`Failed to load raw source: Format was '${format}' and url was '${url}''.`
);
}
// Emulate node's built-in old defaultTransformSource() so we can re-use the old transformSource() hook
const defaultTransformSource: typeof transformSource = async (
source,
_context,
_defaultTransformSource
) => ({ source });
// Call the old hook
const { source: transformedSource } = await transformSource(
rawSource,
{ url, format },
defaultTransformSource
);
source = transformedSource;
}
return { format, source };
});
}
async function getFormat(
url: string,
context: {},
defaultGetFormat: typeof getFormat
): Promise<{ format: NodeLoaderHooksFormat }> {
const defer = (overrideUrl: string = url) =>
defaultGetFormat(overrideUrl, context, defaultGetFormat);
// See: https://github.com/nodejs/node/discussions/41711
// nodejs will likely implement a similar fallback. Till then, we can do our users a favor and fallback today.
async function entrypointFallback(
cb: () => ReturnType<typeof getFormat>
): ReturnType<typeof getFormat> {
try {
return await cb();
} catch (getFormatError) {
if (!rememberIsProbablyEntrypoint.has(url)) throw getFormatError;
return { format: 'commonjs' };
}
}
const parsed = parseUrl(url);
if (!isFileUrlOrNodeStyleSpecifier(parsed)) {
return entrypointFallback(defer);
}
const { pathname } = parsed;
assert(
pathname !== null,
'ESM getFormat() hook: URL should never have null pathname'
);
const nativePath = fileURLToPath(url);
let nodeSays: { format: NodeLoaderHooksFormat };
// If file has extension not understood by node, then ask node how it would treat the emitted extension.
// E.g. .mts compiles to .mjs, so ask node how to classify an .mjs file.
const ext = extname(nativePath);
const tsNodeIgnored = tsNodeService.ignored(nativePath);
const nodeEquivalentExt = extensions.nodeEquivalents.get(ext);
if (nodeEquivalentExt && !tsNodeIgnored) {
nodeSays = await entrypointFallback(() =>
defer(formatUrl(pathToFileURL(nativePath + nodeEquivalentExt)))
);
} else {
try {
nodeSays = await entrypointFallback(defer);
} catch (e) {
if (
e instanceof Error &&
tsNodeIgnored &&
extensions.nodeDoesNotUnderstand.includes(ext)
) {
e.message +=
`\n\n` +
`Hint:\n` +
`ts-node is configured to ignore this file.\n` +
`If you want ts-node to handle this file, consider enabling the "skipIgnore" option or adjusting your "ignore" patterns.\n` +
`https://typestrong.org/ts-node/docs/scope\n`;
}
throw e;
}
}
// For files compiled by ts-node that node believes are either CJS or ESM, check if we should override that classification
if (
!tsNodeService.ignored(nativePath) &&
(nodeSays.format === 'commonjs' || nodeSays.format === 'module')
) {
const { moduleType } =
tsNodeService.moduleTypeClassifier.classifyModuleByModuleTypeOverrides(
normalizeSlashes(nativePath)
);
if (moduleType === 'cjs') {
return { format: 'commonjs' };
} else if (moduleType === 'esm') {
return { format: 'module' };
}
}
return nodeSays;
}
async function transformSource(
source: string | Buffer,
context: { url: string; format: NodeLoaderHooksFormat },
defaultTransformSource: typeof transformSource
): Promise<{ source: string | Buffer }> {
if (source === null || source === undefined) {
throw new Error('No source');
}
const defer = () =>
defaultTransformSource(source, context, defaultTransformSource);
const sourceAsString =
typeof source === 'string' ? source : source.toString('utf8');
const { url } = context;
const parsed = parseUrl(url);
if (!isFileUrlOrNodeStyleSpecifier(parsed)) {
return defer();
}
const nativePath = fileURLToPath(url);
if (tsNodeService.ignored(nativePath)) {
return defer();
}
const emittedJs = tsNodeService.compile(sourceAsString, nativePath);
return { source: emittedJs };
}
return hooksAPI;
} | interface Service {
/** @internal */
[TS_NODE_SERVICE_BRAND]: true;
ts: TSCommon;
/** @internal */
compilerPath: string;
config: _ts.ParsedCommandLine;
options: RegisterOptions;
enabled(enabled?: boolean): boolean;
ignored(fileName: string): boolean;
compile(code: string, fileName: string, lineOffset?: number): string;
getTypeInfo(code: string, fileName: string, position: number): TypeInfo;
/** @internal */
configFilePath: string | undefined;
/** @internal */
moduleTypeClassifier: ModuleTypeClassifier;
/** @internal */
readonly shouldReplAwait: boolean;
/** @internal */
addDiagnosticFilter(filter: DiagnosticFilter): void;
/** @internal */
installSourceMapSupport(): void;
/** @internal */
transpileOnly: boolean;
/** @internal */
projectLocalResolveHelper: ProjectLocalResolveHelper;
/** @internal */
getNodeEsmResolver: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-resolve').createResolve
>;
/** @internal */
getNodeEsmGetFormat: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-get_format').createGetFormat
>;
/** @internal */
getNodeCjsLoader: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-cjs-loader').createCjsLoader
>;
/** @internal */
extensions: Extensions;
} |
481 | function fixConfig(ts: TSCommon, config: _ts.ParsedCommandLine) {
// Delete options that *should not* be passed through.
delete config.options.out;
delete config.options.outFile;
delete config.options.composite;
delete config.options.declarationDir;
delete config.options.declarationMap;
delete config.options.emitDeclarationOnly;
// Target ES5 output by default (instead of ES3).
if (config.options.target === undefined) {
config.options.target = ts.ScriptTarget.ES5;
}
// Target CommonJS modules by default (instead of magically switching to ES6 when the target is ES6).
if (config.options.module === undefined) {
config.options.module = ts.ModuleKind.CommonJS;
}
return config;
} | interface TSCommon {
version: typeof _ts.version;
sys: typeof _ts.sys;
ScriptSnapshot: typeof _ts.ScriptSnapshot;
displayPartsToString: typeof _ts.displayPartsToString;
createLanguageService: typeof _ts.createLanguageService;
getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath;
getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics;
flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText;
transpileModule: typeof _ts.transpileModule;
ModuleKind: TSCommon.ModuleKindEnum;
ScriptTarget: typeof _ts.ScriptTarget;
findConfigFile: typeof _ts.findConfigFile;
readConfigFile: typeof _ts.readConfigFile;
parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent;
formatDiagnostics: typeof _ts.formatDiagnostics;
formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext;
createDocumentRegistry: typeof _ts.createDocumentRegistry;
JsxEmit: typeof _ts.JsxEmit;
createModuleResolutionCache: typeof _ts.createModuleResolutionCache;
resolveModuleName: typeof _ts.resolveModuleName;
resolveModuleNameFromCache: typeof _ts.resolveModuleNameFromCache;
resolveTypeReferenceDirective: typeof _ts.resolveTypeReferenceDirective;
createIncrementalCompilerHost: typeof _ts.createIncrementalCompilerHost;
createSourceFile: typeof _ts.createSourceFile;
getDefaultLibFileName: typeof _ts.getDefaultLibFileName;
createIncrementalProgram: typeof _ts.createIncrementalProgram;
createEmitAndSemanticDiagnosticsBuilderProgram: typeof _ts.createEmitAndSemanticDiagnosticsBuilderProgram;
Extension: typeof _ts.Extension;
ModuleResolutionKind: typeof _ts.ModuleResolutionKind;
} |
482 | function findAndReadConfig(rawOptions: CreateOptions) {
const cwd = resolve(
rawOptions.cwd ?? rawOptions.dir ?? DEFAULTS.cwd ?? process.cwd()
);
const compilerName = rawOptions.compiler ?? DEFAULTS.compiler;
// Compute minimum options to read the config file.
let projectLocalResolveDir = getBasePathForProjectLocalDependencyResolution(
undefined,
rawOptions.projectSearchDir,
rawOptions.project,
cwd
);
let { compiler, ts } = resolveAndLoadCompiler(
compilerName,
projectLocalResolveDir
);
// Read config file and merge new options between env and CLI options.
const { configFilePath, config, tsNodeOptionsFromTsconfig, optionBasePaths } =
readConfig(cwd, ts, rawOptions);
const options = assign<RegisterOptions>(
{},
DEFAULTS,
tsNodeOptionsFromTsconfig || {},
{ optionBasePaths },
rawOptions
);
options.require = [
...(tsNodeOptionsFromTsconfig.require || []),
...(rawOptions.require || []),
];
// Re-resolve the compiler in case it has changed.
// Compiler is loaded relative to tsconfig.json, so tsconfig discovery may cause us to load a
// different compiler than we did above, even if the name has not changed.
if (configFilePath) {
projectLocalResolveDir = getBasePathForProjectLocalDependencyResolution(
configFilePath,
rawOptions.projectSearchDir,
rawOptions.project,
cwd
);
({ compiler } = resolveCompiler(
options.compiler,
optionBasePaths.compiler ?? projectLocalResolveDir
));
}
return {
options,
config,
projectLocalResolveDir,
optionBasePaths,
configFilePath,
cwd,
compiler,
};
} | interface CreateOptions {
/**
* Behave as if invoked within this working directory. Roughly equivalent to `cd $dir && ts-node ...`
*
* @default process.cwd()
*/
cwd?: string;
/**
* Legacy alias for `cwd`
*
* @deprecated use `projectSearchDir` or `cwd`
*/
dir?: string;
/**
* Emit output files into `.ts-node` directory.
*
* @default false
*/
emit?: boolean;
/**
* Scope compiler to files within `scopeDir`.
*
* @default false
*/
scope?: boolean;
/**
* @default First of: `tsconfig.json` "rootDir" if specified, directory containing `tsconfig.json`, or cwd if no `tsconfig.json` is loaded.
*/
scopeDir?: string;
/**
* Use pretty diagnostic formatter.
*
* @default false
*/
pretty?: boolean;
/**
* Use TypeScript's faster `transpileModule`.
*
* @default false
*/
transpileOnly?: boolean;
/**
* **DEPRECATED** Specify type-check is enabled (e.g. `transpileOnly == false`).
*
* @default true
*/
typeCheck?: boolean;
/**
* Use TypeScript's compiler host API instead of the language service API.
*
* @default false
*/
compilerHost?: boolean;
/**
* Logs TypeScript errors to stderr instead of throwing exceptions.
*
* @default false
*/
logError?: boolean;
/**
* Load "files" and "include" from `tsconfig.json` on startup.
*
* Default is to override `tsconfig.json` "files" and "include" to only include the entrypoint script.
*
* @default false
*/
files?: boolean;
/**
* Specify a custom TypeScript compiler.
*
* @default "typescript"
*/
compiler?: string;
/**
* Specify a custom transpiler for use with transpileOnly
*/
transpiler?: string | [string, object];
/**
* Transpile with swc instead of the TypeScript compiler, and skip typechecking.
*
* Equivalent to setting both `transpileOnly: true` and `transpiler: 'ts-node/transpilers/swc'`
*
* For complete instructions: https://typestrong.org/ts-node/docs/transpilers
*/
swc?: boolean;
/**
* Paths which should not be compiled.
*
* Each string in the array is converted to a regular expression via `new RegExp()` and tested against source paths prior to compilation.
*
* Source paths are normalized to posix-style separators, relative to the directory containing `tsconfig.json` or to cwd if no `tsconfig.json` is loaded.
*
* Default is to ignore all node_modules subdirectories.
*
* @default ["(?:^|/)node_modules/"]
*/
ignore?: string[];
/**
* Path to TypeScript config file or directory containing a `tsconfig.json`.
* Similar to the `tsc --project` flag: https://www.typescriptlang.org/docs/handbook/compiler-options.html
*/
project?: string;
/**
* Search for TypeScript config file (`tsconfig.json`) in this or parent directories.
*/
projectSearchDir?: string;
/**
* Skip project config resolution and loading.
*
* @default false
*/
skipProject?: boolean;
/**
* Skip ignore check, so that compilation will be attempted for all files with matching extensions.
*
* @default false
*/
skipIgnore?: boolean;
/**
* JSON object to merge with TypeScript `compilerOptions`.
*
* @allOf [{"$ref": "https://schemastore.azurewebsites.net/schemas/json/tsconfig.json#definitions/compilerOptionsDefinition/properties/compilerOptions"}]
*/
compilerOptions?: object;
/**
* Ignore TypeScript warnings by diagnostic code.
*/
ignoreDiagnostics?: Array<number | string>;
/**
* Modules to require, like node's `--require` flag.
*
* If specified in `tsconfig.json`, the modules will be resolved relative to the `tsconfig.json` file.
*
* If specified programmatically, each input string should be pre-resolved to an absolute path for
* best results.
*/
require?: Array<string>;
readFile?: (path: string) => string | undefined;
fileExists?: (path: string) => boolean;
transformers?:
| _ts.CustomTransformers
| ((p: _ts.Program) => _ts.CustomTransformers);
/**
* Allows the usage of top level await in REPL.
*
* Uses node's implementation which accomplishes this with an AST syntax transformation.
*
* Enabled by default when tsconfig target is es2018 or above. Set to false to disable.
*
* **Note**: setting to `true` when tsconfig target is too low will throw an Error. Leave as `undefined`
* to get default, automatic behavior.
*/
experimentalReplAwait?: boolean;
/**
* Override certain paths to be compiled and executed as CommonJS or ECMAScript modules.
* When overridden, the tsconfig "module" and package.json "type" fields are overridden, and
* the file extension is ignored.
* This is useful if you cannot use .mts, .cts, .mjs, or .cjs file extensions;
* it achieves the same effect.
*
* Each key is a glob pattern following the same rules as tsconfig's "include" array.
* When multiple patterns match the same file, the last pattern takes precedence.
*
* `cjs` overrides matches files to compile and execute as CommonJS.
* `esm` overrides matches files to compile and execute as native ECMAScript modules.
* `package` overrides either of the above to default behavior, which obeys package.json "type" and
* tsconfig.json "module" options.
*/
moduleTypes?: ModuleTypes;
/**
* @internal
* Set by our configuration loader whenever a config file contains options that
* are relative to the config file they came from, *and* when other logic needs
* to know this. Some options can be eagerly resolved to absolute paths by
* the configuration loader, so it is *not* necessary for their source to be set here.
*/
optionBasePaths?: OptionBasePaths;
/**
* A function to collect trace messages from the TypeScript compiler, for example when `traceResolution` is enabled.
*
* @default console.log
*/
tsTrace?: (str: string) => void;
/**
* Enable native ESM support.
*
* For details, see https://typestrong.org/ts-node/docs/imports#native-ecmascript-modules
*/
esm?: boolean;
/**
* Re-order file extensions so that TypeScript imports are preferred.
*
* For example, when both `index.js` and `index.ts` exist, enabling this option causes `require('./index')` to resolve to `index.ts` instead of `index.js`
*
* @default false
*/
preferTsExts?: boolean;
/**
* Like node's `--experimental-specifier-resolution`, , but can also be set in your `tsconfig.json` for convenience.
*
* For details, see https://nodejs.org/dist/latest-v18.x/docs/api/esm.html#customizing-esm-specifier-resolution-algorithm
*/
experimentalSpecifierResolution?: 'node' | 'explicit';
/**
* Allow using voluntary `.ts` file extension in import specifiers.
*
* Typically, in ESM projects, import specifiers must have an emit extension, `.js`, `.cjs`, or `.mjs`,
* and we automatically map to the corresponding `.ts`, `.cts`, or `.mts` source file. This is the
* recommended approach.
*
* However, if you really want to use `.ts` in import specifiers, and are aware that this may
* break tooling, you can enable this flag.
*/
experimentalTsImportSpecifiers?: boolean;
} |
483 | function createTsInternalsUncached(_ts: TSCommon) {
const ts = _ts as TSCommon & TSInternal;
/**
* Copied from:
* https://github.com/microsoft/TypeScript/blob/v4.3.2/src/compiler/commandLineParser.ts#L2821-L2846
*/
function getExtendsConfigPath(
extendedConfig: string,
host: _ts.ParseConfigHost,
basePath: string,
errors: _ts.Push<_ts.Diagnostic>,
createDiagnostic: (
message: _ts.DiagnosticMessage,
arg1?: string
) => _ts.Diagnostic
) {
extendedConfig = normalizeSlashes(extendedConfig);
if (
isRootedDiskPath(extendedConfig) ||
startsWith(extendedConfig, './') ||
startsWith(extendedConfig, '../')
) {
let extendedConfigPath = getNormalizedAbsolutePath(
extendedConfig,
basePath
);
if (
!host.fileExists(extendedConfigPath) &&
!endsWith(extendedConfigPath, ts.Extension.Json)
) {
extendedConfigPath = `${extendedConfigPath}.json`;
if (!host.fileExists(extendedConfigPath)) {
errors.push(
createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig)
);
return undefined;
}
}
return extendedConfigPath;
}
// If the path isn't a rooted or relative path, resolve like a module
const resolved = ts.nodeModuleNameResolver(
extendedConfig,
combinePaths(basePath, 'tsconfig.json'),
{ moduleResolution: ts.ModuleResolutionKind.NodeJs },
host,
/*cache*/ undefined,
/*projectRefs*/ undefined,
/*lookupConfig*/ true
);
if (resolved.resolvedModule) {
return resolved.resolvedModule.resolvedFileName;
}
errors.push(
createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig)
);
return undefined;
}
return { getExtendsConfigPath };
} | interface TSCommon {
version: typeof _ts.version;
sys: typeof _ts.sys;
ScriptSnapshot: typeof _ts.ScriptSnapshot;
displayPartsToString: typeof _ts.displayPartsToString;
createLanguageService: typeof _ts.createLanguageService;
getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath;
getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics;
flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText;
transpileModule: typeof _ts.transpileModule;
ModuleKind: TSCommon.ModuleKindEnum;
ScriptTarget: typeof _ts.ScriptTarget;
findConfigFile: typeof _ts.findConfigFile;
readConfigFile: typeof _ts.readConfigFile;
parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent;
formatDiagnostics: typeof _ts.formatDiagnostics;
formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext;
createDocumentRegistry: typeof _ts.createDocumentRegistry;
JsxEmit: typeof _ts.JsxEmit;
createModuleResolutionCache: typeof _ts.createModuleResolutionCache;
resolveModuleName: typeof _ts.resolveModuleName;
resolveModuleNameFromCache: typeof _ts.resolveModuleNameFromCache;
resolveTypeReferenceDirective: typeof _ts.resolveTypeReferenceDirective;
createIncrementalCompilerHost: typeof _ts.createIncrementalCompilerHost;
createSourceFile: typeof _ts.createSourceFile;
getDefaultLibFileName: typeof _ts.getDefaultLibFileName;
createIncrementalProgram: typeof _ts.createIncrementalProgram;
createEmitAndSemanticDiagnosticsBuilderProgram: typeof _ts.createEmitAndSemanticDiagnosticsBuilderProgram;
Extension: typeof _ts.Extension;
ModuleResolutionKind: typeof _ts.ModuleResolutionKind;
} |
484 | (value: T) => boolean | type T = ExecutionContext<ctxTsNode.Ctx>; |
485 | function getDefaultTsconfigJsonForNodeVersion(ts: TSCommon): any {
const tsInternal = ts as any as TSInternal;
if (nodeMajor >= 18) {
const config = require('@tsconfig/node18/tsconfig.json');
if (configCompatible(config)) return config;
}
if (nodeMajor >= 16) {
const config = require('@tsconfig/node16/tsconfig.json');
if (configCompatible(config)) return config;
}
return require('@tsconfig/node14/tsconfig.json');
// Verify that tsconfig target and lib options are compatible with TypeScript compiler
function configCompatible(config: {
compilerOptions: {
lib: string[];
target: string;
};
}) {
return (
typeof (ts.ScriptTarget as any)[
config.compilerOptions.target.toUpperCase()
] === 'number' &&
tsInternal.libs &&
config.compilerOptions.lib.every((lib) => tsInternal.libs!.includes(lib))
);
}
} | interface TSCommon {
version: typeof _ts.version;
sys: typeof _ts.sys;
ScriptSnapshot: typeof _ts.ScriptSnapshot;
displayPartsToString: typeof _ts.displayPartsToString;
createLanguageService: typeof _ts.createLanguageService;
getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath;
getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics;
flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText;
transpileModule: typeof _ts.transpileModule;
ModuleKind: TSCommon.ModuleKindEnum;
ScriptTarget: typeof _ts.ScriptTarget;
findConfigFile: typeof _ts.findConfigFile;
readConfigFile: typeof _ts.readConfigFile;
parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent;
formatDiagnostics: typeof _ts.formatDiagnostics;
formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext;
createDocumentRegistry: typeof _ts.createDocumentRegistry;
JsxEmit: typeof _ts.JsxEmit;
createModuleResolutionCache: typeof _ts.createModuleResolutionCache;
resolveModuleName: typeof _ts.resolveModuleName;
resolveModuleNameFromCache: typeof _ts.resolveModuleNameFromCache;
resolveTypeReferenceDirective: typeof _ts.resolveTypeReferenceDirective;
createIncrementalCompilerHost: typeof _ts.createIncrementalCompilerHost;
createSourceFile: typeof _ts.createSourceFile;
getDefaultLibFileName: typeof _ts.getDefaultLibFileName;
createIncrementalProgram: typeof _ts.createIncrementalProgram;
createEmitAndSemanticDiagnosticsBuilderProgram: typeof _ts.createEmitAndSemanticDiagnosticsBuilderProgram;
Extension: typeof _ts.Extension;
ModuleResolutionKind: typeof _ts.ModuleResolutionKind;
} |
486 | function createTsTranspileModule(
ts: TSCommon,
transpileOptions: Pick<
TranspileOptions,
'compilerOptions' | 'reportDiagnostics' | 'transformers'
>
) {
const {
createProgram,
createSourceFile,
getDefaultCompilerOptions,
getImpliedNodeFormatForFile,
fixupCompilerOptions,
transpileOptionValueCompilerOptions,
getNewLineCharacter,
fileExtensionIs,
normalizePath,
Debug,
toPath,
getSetExternalModuleIndicator,
getEntries,
addRange,
hasProperty,
getEmitScriptTarget,
getDirectoryPath,
} = ts as any;
const compilerOptionsDiagnostics: Diagnostic[] = [];
const options: CompilerOptions = transpileOptions.compilerOptions
? fixupCompilerOptions(
transpileOptions.compilerOptions,
compilerOptionsDiagnostics
)
: {};
// mix in default options
const defaultOptions = getDefaultCompilerOptions();
for (const key in defaultOptions) {
if (hasProperty(defaultOptions, key) && options[key] === undefined) {
options[key] = defaultOptions[key];
}
}
for (const option of transpileOptionValueCompilerOptions) {
options[option.name] = option.transpileOptionValue;
}
// transpileModule does not write anything to disk so there is no need to verify that there are no conflicts between input and output paths.
options.suppressOutputPathCheck = true;
// Filename can be non-ts file.
options.allowNonTsExtensions = true;
const newLine = getNewLineCharacter(options);
// Create a compilerHost object to allow the compiler to read and write files
const compilerHost: CompilerHost = {
getSourceFile: (fileName) =>
fileName === normalizePath(inputFileName) ? sourceFile : undefined,
writeFile: (name, text) => {
if (fileExtensionIs(name, '.map')) {
Debug.assertEqual(
sourceMapText,
undefined,
'Unexpected multiple source map outputs, file:',
name
);
sourceMapText = text;
} else {
Debug.assertEqual(
outputText,
undefined,
'Unexpected multiple outputs, file:',
name
);
outputText = text;
}
},
getDefaultLibFileName: () => 'lib.d.ts',
useCaseSensitiveFileNames: () => true,
getCanonicalFileName: (fileName) => fileName,
getCurrentDirectory: () => '',
getNewLine: () => newLine,
fileExists: (fileName): boolean =>
fileName === inputFileName || fileName === packageJsonFileName,
readFile: (fileName) =>
fileName === packageJsonFileName ? `{"type": "${_packageJsonType}"}` : '',
directoryExists: () => true,
getDirectories: () => [],
};
let inputFileName: string;
let packageJsonFileName: string;
let _packageJsonType: 'module' | 'commonjs';
let sourceFile: SourceFile;
let outputText: string | undefined;
let sourceMapText: string | undefined;
return transpileModule;
function transpileModule(
input: string,
transpileOptions2: Pick<
TranspileOptions,
'fileName' | 'moduleName' | 'renamedDependencies'
>,
packageJsonType: 'module' | 'commonjs' = 'commonjs'
): TranspileOutput {
// if jsx is specified then treat file as .tsx
inputFileName =
transpileOptions2.fileName ||
(transpileOptions.compilerOptions && transpileOptions.compilerOptions.jsx
? 'module.tsx'
: 'module.ts');
packageJsonFileName = getDirectoryPath(inputFileName) + '/package.json';
_packageJsonType = packageJsonType;
sourceFile = createSourceFile(inputFileName, input, {
languageVersion: getEmitScriptTarget(options),
impliedNodeFormat: getImpliedNodeFormatForFile(
toPath(inputFileName, '', compilerHost.getCanonicalFileName),
/*cache*/ undefined,
compilerHost,
options
),
setExternalModuleIndicator: getSetExternalModuleIndicator(options),
});
if (transpileOptions2.moduleName) {
sourceFile.moduleName = transpileOptions2.moduleName;
}
if (transpileOptions2.renamedDependencies) {
(sourceFile as any).renamedDependencies = new Map(
getEntries(transpileOptions2.renamedDependencies)
);
}
// Output
outputText = undefined;
sourceMapText = undefined;
const program = createProgram([inputFileName], options, compilerHost);
const diagnostics = compilerOptionsDiagnostics.slice();
if (transpileOptions.reportDiagnostics) {
addRange(
/*to*/ diagnostics,
/*from*/ program.getSyntacticDiagnostics(sourceFile)
);
addRange(/*to*/ diagnostics, /*from*/ program.getOptionsDiagnostics());
}
// Emit
program.emit(
/*targetSourceFile*/ undefined,
/*writeFile*/ undefined,
/*cancellationToken*/ undefined,
/*emitOnlyDtsFiles*/ undefined,
transpileOptions.transformers
);
if (outputText === undefined) return Debug.fail('Output generation failed');
return { outputText, diagnostics, sourceMapText };
}
} | interface TSCommon {
version: typeof _ts.version;
sys: typeof _ts.sys;
ScriptSnapshot: typeof _ts.ScriptSnapshot;
displayPartsToString: typeof _ts.displayPartsToString;
createLanguageService: typeof _ts.createLanguageService;
getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath;
getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics;
flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText;
transpileModule: typeof _ts.transpileModule;
ModuleKind: TSCommon.ModuleKindEnum;
ScriptTarget: typeof _ts.ScriptTarget;
findConfigFile: typeof _ts.findConfigFile;
readConfigFile: typeof _ts.readConfigFile;
parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent;
formatDiagnostics: typeof _ts.formatDiagnostics;
formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext;
createDocumentRegistry: typeof _ts.createDocumentRegistry;
JsxEmit: typeof _ts.JsxEmit;
createModuleResolutionCache: typeof _ts.createModuleResolutionCache;
resolveModuleName: typeof _ts.resolveModuleName;
resolveModuleNameFromCache: typeof _ts.resolveModuleNameFromCache;
resolveTypeReferenceDirective: typeof _ts.resolveTypeReferenceDirective;
createIncrementalCompilerHost: typeof _ts.createIncrementalCompilerHost;
createSourceFile: typeof _ts.createSourceFile;
getDefaultLibFileName: typeof _ts.getDefaultLibFileName;
createIncrementalProgram: typeof _ts.createIncrementalProgram;
createEmitAndSemanticDiagnosticsBuilderProgram: typeof _ts.createEmitAndSemanticDiagnosticsBuilderProgram;
Extension: typeof _ts.Extension;
ModuleResolutionKind: typeof _ts.ModuleResolutionKind;
} |
487 | function installCommonjsResolveHooksIfNecessary(tsNodeService: Service) {
const Module = require('module') as ModuleConstructorWithInternals;
const originalResolveFilename = Module._resolveFilename;
const originalFindPath = Module._findPath;
const shouldInstallHook = tsNodeService.options.experimentalResolver;
if (shouldInstallHook) {
const { Module_findPath, Module_resolveFilename } =
tsNodeService.getNodeCjsLoader();
Module._resolveFilename = _resolveFilename;
Module._findPath = _findPath;
function _resolveFilename(
this: any,
request: string,
parent?: Module,
isMain?: boolean,
options?: ModuleResolveFilenameOptions,
...rest: []
): string {
if (!tsNodeService.enabled())
return originalResolveFilename.call(
this,
request,
parent,
isMain,
options,
...rest
);
return Module_resolveFilename.call(
this,
request,
parent,
isMain,
options,
...rest
);
}
function _findPath(this: any): string {
if (!tsNodeService.enabled())
return originalFindPath.apply(this, arguments as any);
return Module_findPath.apply(this, arguments as any);
}
}
} | interface Service {
/** @internal */
[TS_NODE_SERVICE_BRAND]: true;
ts: TSCommon;
/** @internal */
compilerPath: string;
config: _ts.ParsedCommandLine;
options: RegisterOptions;
enabled(enabled?: boolean): boolean;
ignored(fileName: string): boolean;
compile(code: string, fileName: string, lineOffset?: number): string;
getTypeInfo(code: string, fileName: string, position: number): TypeInfo;
/** @internal */
configFilePath: string | undefined;
/** @internal */
moduleTypeClassifier: ModuleTypeClassifier;
/** @internal */
readonly shouldReplAwait: boolean;
/** @internal */
addDiagnosticFilter(filter: DiagnosticFilter): void;
/** @internal */
installSourceMapSupport(): void;
/** @internal */
transpileOnly: boolean;
/** @internal */
projectLocalResolveHelper: ProjectLocalResolveHelper;
/** @internal */
getNodeEsmResolver: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-resolve').createResolve
>;
/** @internal */
getNodeEsmGetFormat: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-esm-get_format').createGetFormat
>;
/** @internal */
getNodeCjsLoader: () => ReturnType<
typeof import('../dist-raw/node-internal-modules-cjs-loader').createCjsLoader
>;
/** @internal */
extensions: Extensions;
} |
488 | function errorPostprocessor<T extends Function>(fn: T): T {
return async function (this: any) {
try {
return await fn.call(this, arguments);
} catch (error: any) {
delete error?.matcherResult;
// delete error?.matcherResult?.message;
if (error?.message) error.message = `\n${error.message}\n`;
throw error;
}
} as any;
} | type T = ExecutionContext<ctxTsNode.Ctx>; |
489 | function once<T extends Function>(func: T): T {
let run = false;
let ret: any = undefined;
return function (...args: any[]) {
if (run) return ret;
run = true;
ret = func(...args);
return ret;
} as any as T;
} | type T = ExecutionContext<ctxTsNode.Ctx>; |
490 | function createExec<T extends Partial<ExecOptions>>(
preBoundOptions?: T
) {
/**
* Helper to exec a child process.
* Returns a Promise and a reference to the child process to suite multiple situations.
* Promise resolves with the process's stdout, stderr, and error.
*/
return function exec(
cmd: string,
opts?: Pick<ExecOptions, Exclude<keyof ExecOptions, keyof T>> &
Partial<Pick<ExecOptions, keyof T & keyof ExecOptions>>
): ExecReturn {
let child!: ChildProcess;
return Object.assign(
new Promise<ExecResult>((resolve, reject) => {
child = childProcessExec(
cmd,
{
...preBoundOptions,
...opts,
},
(err, stdout, stderr) => {
resolve({ err, stdout, stderr, child });
}
);
}),
{
child,
}
);
};
} | type T = ExecutionContext<ctxTsNode.Ctx>; |
491 | function createSpawn<T extends Partial<SpawnOptions>>(
preBoundOptions?: T
) {
/**
* Helper to spawn a child process.
* Returns a Promise and a reference to the child process to suite multiple situations.
*
* Should almost always avoid this helper, and instead use `createExec` / `exec`. `spawn`
* may be necessary if you need to avoid `exec`'s intermediate shell.
*/
return function spawn(
cmd: string[],
opts?: Pick<SpawnOptions, Exclude<keyof SpawnOptions, keyof T>> &
Partial<Pick<SpawnOptions, keyof T & keyof SpawnOptions>>
): SpawnReturn {
let child!: ChildProcess;
let stdout!: GetStream;
let stderr!: GetStream;
const promise = Object.assign(
new Promise<SpawnResult>((resolve, reject) => {
child = childProcessSpawn(cmd[0], cmd.slice(1), {
...preBoundOptions,
...opts,
});
stdout = getStream(child.stdout!);
stderr = getStream(child.stderr!);
child.on('exit', (code) => {
promise.code = code;
resolve({ stdout, stderr, code, child });
});
child.on('error', (error) => {
reject(error);
});
}),
{
child,
stdout,
stderr,
code: null as number | null,
}
);
return promise;
};
} | type T = ExecutionContext<ctxTsNode.Ctx>; |
492 | function createExecTester<T extends Partial<ExecTesterOptions>>(
preBoundOptions: T
) {
return async function (
options: Pick<
ExecTesterOptions,
Exclude<keyof ExecTesterOptions, keyof T>
> &
Partial<Pick<ExecTesterOptions, keyof T & keyof ExecTesterOptions>>
) {
const {
cmd,
flags = '',
stdin,
expectError = false,
env,
exec = defaultExec,
} = {
...preBoundOptions,
...options,
};
const execPromise = exec(`${cmd} ${flags}`, {
env: { ...process.env, ...env },
});
if (stdin !== undefined) {
execPromise.child.stdin!.end(stdin);
}
const { err, stdout, stderr } = await execPromise;
if (expectError) {
expect(err).toBeDefined();
} else {
expect(err).toBeNull();
}
return { stdout, stderr, err };
};
} | type T = ExecutionContext<ctxTsNode.Ctx>; |
493 | function declareProject(_test: Test, project: Project) {
const test =
project.useTsNodeNext && !tsSupportsStableNodeNextNode16
? _test.skip
: _test;
test(`${project.identifier}`, async (t) => {
t.teardown(() => {
resetNodeEnvironment();
});
const p = fsProject(project.identifier);
p.rm();
p.addJsonFile('package.json', {
type: project.typeModule ? 'module' : undefined,
});
p.addJsonFile('tsconfig.json', {
'ts-node': {
experimentalResolver: true,
preferTsExts: project.preferSrc,
transpileOnly: true,
experimentalSpecifierResolution:
project.experimentalSpecifierResolutionNode ? 'node' : undefined,
skipIgnore: project.skipIgnore,
} as RegisterOptions,
compilerOptions: {
allowJs: project.allowJs,
skipLibCheck: true,
// TODO add nodenext permutation
module: project.useTsNodeNext
? 'NodeNext'
: project.typeModule
? 'esnext'
: 'commonjs',
jsx: 'react',
target: 'esnext',
},
});
const targets = generateTargets(project, p);
const entrypoints = generateEntrypoints(project, p, targets);
p.write();
await execute(t, p, entrypoints);
});
} | type Test = TestInterface<ctxTsNode.Ctx>; |
494 | function declareProject(_test: Test, project: Project) {
const test =
project.useTsNodeNext && !tsSupportsStableNodeNextNode16
? _test.skip
: _test;
test(`${project.identifier}`, async (t) => {
t.teardown(() => {
resetNodeEnvironment();
});
const p = fsProject(project.identifier);
p.rm();
p.addJsonFile('package.json', {
type: project.typeModule ? 'module' : undefined,
});
p.addJsonFile('tsconfig.json', {
'ts-node': {
experimentalResolver: true,
preferTsExts: project.preferSrc,
transpileOnly: true,
experimentalSpecifierResolution:
project.experimentalSpecifierResolutionNode ? 'node' : undefined,
skipIgnore: project.skipIgnore,
} as RegisterOptions,
compilerOptions: {
allowJs: project.allowJs,
skipLibCheck: true,
// TODO add nodenext permutation
module: project.useTsNodeNext
? 'NodeNext'
: project.typeModule
? 'esnext'
: 'commonjs',
jsx: 'react',
target: 'esnext',
},
});
const targets = generateTargets(project, p);
const entrypoints = generateEntrypoints(project, p, targets);
p.write();
await execute(t, p, entrypoints);
});
} | type Test = typeof test; |
495 | function declareProject(_test: Test, project: Project) {
const test =
project.useTsNodeNext && !tsSupportsStableNodeNextNode16
? _test.skip
: _test;
test(`${project.identifier}`, async (t) => {
t.teardown(() => {
resetNodeEnvironment();
});
const p = fsProject(project.identifier);
p.rm();
p.addJsonFile('package.json', {
type: project.typeModule ? 'module' : undefined,
});
p.addJsonFile('tsconfig.json', {
'ts-node': {
experimentalResolver: true,
preferTsExts: project.preferSrc,
transpileOnly: true,
experimentalSpecifierResolution:
project.experimentalSpecifierResolutionNode ? 'node' : undefined,
skipIgnore: project.skipIgnore,
} as RegisterOptions,
compilerOptions: {
allowJs: project.allowJs,
skipLibCheck: true,
// TODO add nodenext permutation
module: project.useTsNodeNext
? 'NodeNext'
: project.typeModule
? 'esnext'
: 'commonjs',
jsx: 'react',
target: 'esnext',
},
});
const targets = generateTargets(project, p);
const entrypoints = generateEntrypoints(project, p, targets);
p.write();
await execute(t, p, entrypoints);
});
} | interface Project {
identifier: string;
allowJs: boolean;
preferSrc: boolean;
typeModule: boolean;
/** Use TS's new module: `nodenext` option */
useTsNodeNext: boolean;
experimentalSpecifierResolutionNode: boolean;
skipIgnore: boolean;
} |
496 | function declareProject(_test: Test, project: Project) {
const test =
project.useTsNodeNext && !tsSupportsStableNodeNextNode16
? _test.skip
: _test;
test(`${project.identifier}`, async (t) => {
t.teardown(() => {
resetNodeEnvironment();
});
const p = fsProject(project.identifier);
p.rm();
p.addJsonFile('package.json', {
type: project.typeModule ? 'module' : undefined,
});
p.addJsonFile('tsconfig.json', {
'ts-node': {
experimentalResolver: true,
preferTsExts: project.preferSrc,
transpileOnly: true,
experimentalSpecifierResolution:
project.experimentalSpecifierResolutionNode ? 'node' : undefined,
skipIgnore: project.skipIgnore,
} as RegisterOptions,
compilerOptions: {
allowJs: project.allowJs,
skipLibCheck: true,
// TODO add nodenext permutation
module: project.useTsNodeNext
? 'NodeNext'
: project.typeModule
? 'esnext'
: 'commonjs',
jsx: 'react',
target: 'esnext',
},
});
const targets = generateTargets(project, p);
const entrypoints = generateEntrypoints(project, p, targets);
p.write();
await execute(t, p, entrypoints);
});
} | type Project = ReturnType<typeof project>; |
497 | function generateTargets(project: Project, p: FsProject) {
/** Array of metadata about target files to be imported */
const targets: Array<Target> = [];
// TODO does allowJs matter?
for (const inOut of [false, true]) {
for (const inSrc of [false, true]) {
for (const srcExt of [
'ts',
'tsx',
'cts',
'mts',
'jsx',
'js',
'cjs',
'mjs',
]) {
for (const targetPackageStyle of targetPackageStyles) {
const packageTypeModulePermutations = targetPackageStyle
? [true, false]
: [project.typeModule];
for (const packageTypeModule of packageTypeModulePermutations) {
const isIndexPermutations = targetPackageStyle
? [false]
: [true, false];
// TODO test main pointing to a directory containing an `index.` file?
for (const isIndex of isIndexPermutations) {
//#region SKIPPING
if (!inSrc && !inOut) continue;
// Don't bother with jsx if we don't have allowJs enabled
// TODO Get rid of this? "Just work" in this case?
if (srcExt === 'jsx' && !project.allowJs) continue;
// Don't bother with src-only extensions when only emitting to `out`
if (!inSrc && ['ts', 'tsx', 'cts', 'mts', 'jsx'].includes(srcExt))
continue;
// TODO re-enable with src <-> out mapping
if (
!inOut &&
isOneOf(targetPackageStyle, [
'main-out-with-extension',
'main-out-extensionless',
'exports-out-with-extension',
])
)
continue;
if (
!inSrc &&
isOneOf(targetPackageStyle, [
'main-src-with-extension',
'main-src-extensionless',
'exports-src-with-extension',
])
)
continue;
if (
isOneOf(targetPackageStyle, [
'main-out-with-extension',
'main-out-extensionless',
'exports-out-with-extension',
])
)
continue;
//#endregion
targets.push(
generateTarget(project, p, {
inSrc,
inOut,
srcExt,
targetPackageStyle,
packageTypeModule,
isIndex,
})
);
}
}
}
}
}
}
return targets;
} | interface Project {
identifier: string;
allowJs: boolean;
preferSrc: boolean;
typeModule: boolean;
/** Use TS's new module: `nodenext` option */
useTsNodeNext: boolean;
experimentalSpecifierResolutionNode: boolean;
skipIgnore: boolean;
} |
498 | function generateTargets(project: Project, p: FsProject) {
/** Array of metadata about target files to be imported */
const targets: Array<Target> = [];
// TODO does allowJs matter?
for (const inOut of [false, true]) {
for (const inSrc of [false, true]) {
for (const srcExt of [
'ts',
'tsx',
'cts',
'mts',
'jsx',
'js',
'cjs',
'mjs',
]) {
for (const targetPackageStyle of targetPackageStyles) {
const packageTypeModulePermutations = targetPackageStyle
? [true, false]
: [project.typeModule];
for (const packageTypeModule of packageTypeModulePermutations) {
const isIndexPermutations = targetPackageStyle
? [false]
: [true, false];
// TODO test main pointing to a directory containing an `index.` file?
for (const isIndex of isIndexPermutations) {
//#region SKIPPING
if (!inSrc && !inOut) continue;
// Don't bother with jsx if we don't have allowJs enabled
// TODO Get rid of this? "Just work" in this case?
if (srcExt === 'jsx' && !project.allowJs) continue;
// Don't bother with src-only extensions when only emitting to `out`
if (!inSrc && ['ts', 'tsx', 'cts', 'mts', 'jsx'].includes(srcExt))
continue;
// TODO re-enable with src <-> out mapping
if (
!inOut &&
isOneOf(targetPackageStyle, [
'main-out-with-extension',
'main-out-extensionless',
'exports-out-with-extension',
])
)
continue;
if (
!inSrc &&
isOneOf(targetPackageStyle, [
'main-src-with-extension',
'main-src-extensionless',
'exports-src-with-extension',
])
)
continue;
if (
isOneOf(targetPackageStyle, [
'main-out-with-extension',
'main-out-extensionless',
'exports-out-with-extension',
])
)
continue;
//#endregion
targets.push(
generateTarget(project, p, {
inSrc,
inOut,
srcExt,
targetPackageStyle,
packageTypeModule,
isIndex,
})
);
}
}
}
}
}
}
return targets;
} | type Project = ReturnType<typeof project>; |
499 | function generateTarget(
project: Project,
p: FsProject,
options: GenerateTargetOptions
) {
const {
inSrc,
inOut,
srcExt,
targetPackageStyle,
packageTypeModule,
isIndex,
} = options;
const outExt = srcExt.replace('ts', 'js').replace('x', '');
let targetIdentifier = `target-${targetSeq()}-${
inOut && inSrc ? 'inboth' : inOut ? 'onlyout' : 'onlysrc'
}-${srcExt}`;
if (targetPackageStyle)
targetIdentifier = `${targetIdentifier}-${targetPackageStyle}-${
packageTypeModule ? 'module' : 'commonjs'
}`;
let prefix = targetPackageStyle ? `node_modules/${targetIdentifier}/` : '';
let suffix =
targetPackageStyle === 'empty-manifest'
? 'index'
: targetPackageStyle
? 'target'
: targetIdentifier;
if (isIndex) suffix += '-dir/index';
const srcDirInfix = targetPackageStyle === 'empty-manifest' ? '' : 'src/';
const outDirInfix = targetPackageStyle === 'empty-manifest' ? '' : 'out/';
const srcName = `${prefix}${srcDirInfix}${suffix}.${srcExt}`;
const srcDirOutExtName = `${prefix}${srcDirInfix}${suffix}.${outExt}`;
const outName = `${prefix}${outDirInfix}${suffix}.${outExt}`;
const selfImporterCjsName = `${prefix}self-import-cjs.cjs`;
const selfImporterMjsName = `${prefix}self-import-mjs.mjs`;
const target: Target = {
targetIdentifier,
srcName,
outName,
srcExt,
outExt,
inSrc,
inOut,
isNamedFile: !isIndex && !targetPackageStyle,
isIndex,
isPackage: !!targetPackageStyle,
packageStyle: targetPackageStyle,
typeModule: packageTypeModule,
};
const { isMjs: targetIsMjs } = fileInfo(
'.' + srcExt,
packageTypeModule,
project.allowJs
);
function targetContent(loc: string) {
let content = '';
if (targetIsMjs) {
content += String.raw`
const {fileURLToPath} = await import('url');
const filenameNative = fileURLToPath(import.meta.url);
export const directory = filenameNative.replace(/.*[\\\/](.*?)[\\\/]/, '$1');
export const filename = filenameNative.replace(/.*[\\\/]/, '');
export const targetIdentifier = '${targetIdentifier}';
export const ext = filenameNative.replace(/.*\./, '');
export const loc = '${loc}';
`;
} else {
content += String.raw`
const filenameNative = __filename;
exports.filename = filenameNative.replace(/.*[\\\/]/, '');
exports.directory = filenameNative.replace(/.*[\\\/](.*?)[\\\/].*/, '$1');
exports.targetIdentifier = '${targetIdentifier}';
exports.ext = filenameNative.replace(/.*\./, '');
exports.loc = '${loc}';
`;
}
return content;
}
if (inOut) {
p.addFile(outName, targetContent('out'));
// TODO so we can test multiple file extensions in a single directory, preferTsExt
p.addFile(srcDirOutExtName, targetContent('out'));
}
if (inSrc) {
p.addFile(srcName, targetContent('src'));
}
if (targetPackageStyle) {
const selfImporterIsCompiled = project.allowJs;
const cjsSelfImporterMustUseDynamicImportHack =
!project.useTsNodeNext && selfImporterIsCompiled && targetIsMjs;
p.addFile(
selfImporterCjsName,
targetIsMjs
? cjsSelfImporterMustUseDynamicImportHack
? `${declareDynamicImportFunction}\nmodule.exports = dynamicImport('${targetIdentifier}');`
: `module.exports = import("${targetIdentifier}");`
: `module.exports = require("${targetIdentifier}");`
);
p.addFile(
selfImporterMjsName,
`
export * from "${targetIdentifier}";
`
);
function writePackageJson(obj: any) {
p.addJsonFile(`${prefix}/package.json`, {
name: targetIdentifier,
type: packageTypeModule ? 'module' : undefined,
...obj,
});
}
switch (targetPackageStyle) {
case 'empty-manifest':
writePackageJson({});
break;
case 'exports-src-with-extension':
writePackageJson({
exports: {
'.': `./src/${suffix}.${srcExt}`,
},
});
break;
case 'exports-src-with-out-extension':
writePackageJson({
exports: {
'.': `./src/${suffix}.${outExt}`,
},
});
break;
case 'exports-out-with-extension':
writePackageJson({
exports: {
'.': `./out/${suffix}.${outExt}`,
},
});
break;
case 'main-src-extensionless':
writePackageJson({
main: `src/${suffix}`,
});
break;
case 'main-out-extensionless':
writePackageJson({
main: `out/${suffix}`,
});
break;
case 'main-src-with-extension':
writePackageJson({
main: `src/${suffix}.${srcExt}`,
});
break;
case 'main-src-with-out-extension':
writePackageJson({
main: `src/${suffix}.${outExt}`,
});
break;
case 'main-out-with-extension':
writePackageJson({
main: `src/${suffix}.${outExt}`,
});
break;
default:
const _assert: never = targetPackageStyle;
}
}
return target;
} | interface GenerateTargetOptions {
inSrc: boolean;
inOut: boolean;
srcExt: string;
/** If true, is an index.* file within a directory */
isIndex: boolean;
targetPackageStyle: TargetPackageStyle;
packageTypeModule: boolean;
} |
Subsets and Splits