got 8.2.0 → 9.0.0

package/source/as-promise.js

@@ -0,0 +1,112 @@
+'use strict';
+const EventEmitter = require('events');
+const getStream = require('get-stream');
+const is = require('@sindresorhus/is');
+const PCancelable = require('p-cancelable');
+const requestAsEventEmitter = require('./request-as-event-emitter');
+const {HTTPError, ParseError, ReadError} = require('./errors');
+
+module.exports = options => {
+	const proxy = new EventEmitter();
+
+	const cancelable = new PCancelable((resolve, reject, onCancel) => {
+		const emitter = requestAsEventEmitter(options);
+		let cancelOnRequest = false;
+
+		onCancel(() => {
+			cancelOnRequest = true;
+		});
+
+		emitter.on('request', request => {
+			if (cancelOnRequest) {
+				request.abort();
+			}
+
+			proxy.emit('request', request);
+
+			const uploadComplete = () => {
+				request.emit('upload-complete');
+			};
+
+			onCancel(() => {
+				request.abort();
+			});
+
+			if (is.nodeStream(options.body)) {
+				options.body.once('end', uploadComplete);
+				options.body.pipe(request);
+				options.body = undefined;
+				return;
+			}
+
+			request.end(options.body, uploadComplete);
+		});
+
+		emitter.on('response', async response => {
+			proxy.emit('response', response);
+
+			const stream = is.null(options.encoding) ? getStream.buffer(response) : getStream(response, options);
+
+			let data;
+			try {
+				data = await stream;
+			} catch (error) {
+				reject(new ReadError(error, options));
+				return;
+			}
+
+			const {statusCode} = response;
+			const limitStatusCode = options.followRedirect ? 299 : 399;
+
+			response.body = data;
+
+			if (options.json && response.body) {
+				try {
+					response.body = JSON.parse(response.body);
+				} catch (error) {
+					if (statusCode >= 200 && statusCode < 300) {
+						const parseError = new ParseError(error, statusCode, options, data);
+						Object.defineProperty(parseError, 'response', {value: response});
+						reject(parseError);
+					}
+				}
+			}
+
+			if (statusCode !== 304 && (statusCode < 200 || statusCode > limitStatusCode)) {
+				const error = new HTTPError(statusCode, response.statusMessage, response.headers, options);
+				Object.defineProperty(error, 'response', {value: response});
+				emitter.emit('retry', error, retried => {
+					if (!retried) {
+						if (options.throwHttpErrors) {
+							reject(error);
+							return;
+						}
+
+						resolve(response);
+					}
+				});
+				return;
+			}
+
+			resolve(response);
+		});
+
+		emitter.once('error', reject);
+		[
+			'redirect',
+			'uploadProgress',
+			'downloadProgress'
+		].forEach(event => emitter.on(event, (...args) => proxy.emit(event, ...args)));
+	});
+
+	const promise = cancelable;
+
+	promise.cancel = cancelable.cancel.bind(cancelable);
+
+	promise.on = (name, fn) => {
+		proxy.on(name, fn);
+		return promise;
+	};
+
+	return promise;
+};

package/source/as-stream.js

@@ -0,0 +1,115 @@
+'use strict';
+const {PassThrough} = require('stream');
+const duplexer3 = require('duplexer3');
+const is = require('@sindresorhus/is');
+const requestAsEventEmitter = require('./request-as-event-emitter');
+const {HTTPError, ReadError} = require('./errors');
+
+module.exports = options => {
+	const input = new PassThrough();
+	const output = new PassThrough();
+	const proxy = duplexer3(input, output);
+	const piped = new Set();
+	let isFinished = false;
+
+	options.gotRetry.retries = () => 0;
+
+	if (options.body) {
+		proxy.write = () => {
+			throw new Error('Got\'s stream is not writable when the `body` option is used');
+		};
+	}
+
+	const emitter = requestAsEventEmitter(options);
+
+	emitter.on('request', request => {
+		proxy.emit('request', request);
+		const uploadComplete = () => {
+			request.emit('upload-complete');
+		};
+
+		if (is.nodeStream(options.body)) {
+			options.body.once('end', uploadComplete);
+			options.body.pipe(request);
+			return;
+		}
+
+		if (options.body) {
+			request.end(options.body, uploadComplete);
+			return;
+		}
+
+		if (options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH') {
+			input.once('end', uploadComplete);
+			input.pipe(request);
+			return;
+		}
+
+		request.end(uploadComplete);
+	});
+
+	emitter.on('response', response => {
+		const {statusCode} = response;
+
+		response.on('error', error => {
+			proxy.emit('error', new ReadError(error, options));
+		});
+
+		if (options.throwHttpErrors && statusCode !== 304 && (statusCode < 200 || statusCode > 299)) {
+			proxy.emit('error', new HTTPError(statusCode, response.statusMessage, response.headers, options), null, response);
+			return;
+		}
+
+		isFinished = true;
+
+		response.pipe(output);
+
+		for (const destination of piped) {
+			if (destination.headersSent) {
+				continue;
+			}
+
+			for (const [key, value] of Object.entries(response.headers)) {
+				// Got gives *uncompressed* data. Overriding `content-encoding` header would result in an error.
+				// It's not possible to decompress uncompressed data, is it?
+				const allowed = options.decompress ? key !== 'content-encoding' : true;
+				if (allowed) {
+					destination.setHeader(key, value);
+				}
+			}
+
+			destination.statusCode = response.statusCode;
+		}
+
+		proxy.emit('response', response);
+	});
+
+	[
+		'error',
+		'redirect',
+		'uploadProgress',
+		'downloadProgress'
+	].forEach(event => emitter.on(event, (...args) => proxy.emit(event, ...args)));
+
+	const pipe = proxy.pipe.bind(proxy);
+	const unpipe = proxy.unpipe.bind(proxy);
+	proxy.pipe = (destination, options) => {
+		if (isFinished) {
+			throw new Error('Failed to pipe. The response has been emitted already.');
+		}
+
+		const result = pipe(destination, options);
+
+		if (Reflect.has(destination, 'setHeader')) {
+			piped.add(destination);
+		}
+
+		return result;
+	};
+	proxy.unpipe = stream => {
+		piped.delete(stream);
+		return unpipe(stream);
+	};
+
+	return proxy;
+};

package/source/create.js

@@ -0,0 +1,56 @@
+'use strict';
+const errors = require('./errors');
+const asStream = require('./as-stream');
+const asPromise = require('./as-promise');
+const normalizeArguments = require('./normalize-arguments');
+const merge = require('./merge');
+const deepFreeze = require('./deep-freeze');
+
+const next = options => options.stream ? asStream(options) : asPromise(options);
+const mergeOptions = (defaults, options = {}) => merge({}, defaults, options);
+
+const create = defaults => {
+	defaults = merge({}, defaults);
+	if (!defaults.handler) {
+		defaults.handler = next;
+	}
+
+	function got(url, options) {
+		try {
+			options = mergeOptions(defaults.options, options);
+			return defaults.handler(normalizeArguments(url, options, defaults), next);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+
+	got.create = create;
+	got.extend = (options = {}) => create({
+		options: mergeOptions(defaults.options, options),
+		methods: defaults.methods,
+		handler: defaults.handler
+	});
+
+	got.stream = (url, options) => {
+		options = mergeOptions(defaults.options, options);
+		options.stream = true;
+		return defaults.handler(normalizeArguments(url, options, defaults), next);
+	};
+
+	for (const method of defaults.methods) {
+		got[method] = (url, options) => got(url, {...options, method});
+		got.stream[method] = (url, options) => got.stream(url, {...options, method});
+	}
+
+	Object.assign(got, {...errors, mergeOptions});
+	Object.defineProperty(got, 'defaults', {
+		value: deepFreeze(defaults),
+		writable: false,
+		enumerable: true,
+		configurable: true
+	});
+
+	return got;
+};
+
+module.exports = create;

package/source/deep-freeze.js

@@ -0,0 +1,12 @@
+'use strict';
+const is = require('@sindresorhus/is');
+
+module.exports = function deepFreeze(object) {
+	for (const [key, value] of Object.entries(object)) {
+		if (is.object(value)) {
+			deepFreeze(object[key]);
+		}
+	}
+
+	return Object.freeze(object);
+};

package/{errors.js → source/errors.js}

@@ -19,6 +19,7 @@ class GotError extends Error {
 			hostname: opts.hostname,
 			method: opts.method,
 			path: opts.path,
+			socketPath: opts.socketPath,
 			protocol: opts.protocol,
 			url: opts.href
 		});
@@ -89,4 +90,12 @@ module.exports.UnsupportedProtocolError = class extends GotError {
 	}
 };
 
+module.exports.TimeoutError = class extends GotError {
+	constructor(threshold, event, opts) {
+		super(`Timeout awaiting '${event}' for ${threshold}ms`, {code: 'ETIMEDOUT'}, opts);
+		this.name = 'TimeoutError';
+		this.event = event;
+	}
+};
+
 module.exports.CancelError = PCancelable.CancelError;

package/source/get-body-size.js

@@ -0,0 +1,40 @@
+'use strict';
+const fs = require('fs');
+const util = require('util');
+const is = require('@sindresorhus/is');
+const isFormData = require('./is-form-data');
+
+module.exports = async options => {
+	const {body} = options;
+
+	if (options.headers['content-length']) {
+		return Number(options.headers['content-length']);
+	}
+
+	if (!body && !options.stream) {
+		return 0;
+	}
+
+	if (is.string(body)) {
+		return Buffer.byteLength(body);
+	}
+
+	if (is.buffer(body)) {
+		return body.length;
+	}
+
+	if (isFormData(body)) {
+		return util.promisify(body.getLength.bind(body))();
+	}
+
+	if (body instanceof fs.ReadStream) {
+		const {size} = await util.promisify(fs.stat)(body.path);
+		return size;
+	}
+
+	if (is.nodeStream(body) && is.buffer(body._buffer)) {
+		return body._buffer.length;
+	}
+
+	return null;
+};

package/source/get-response.js

@@ -0,0 +1,60 @@
+'use strict';
+const {Transform} = require('stream');
+const decompressResponse = require('decompress-response');
+const is = require('@sindresorhus/is');
+const mimicResponse = require('mimic-response');
+
+module.exports = (response, options, emitter, redirects) => {
+	const downloadBodySize = Number(response.headers['content-length']) || null;
+	let downloaded = 0;
+
+	const progressStream = new Transform({
+		transform(chunk, encoding, callback) {
+			downloaded += chunk.length;
+
+			const percent = downloadBodySize ? downloaded / downloadBodySize : 0;
+
+			// Let `flush()` be responsible for emitting the last event
+			if (percent < 1) {
+				emitter.emit('downloadProgress', {
+					percent,
+					transferred: downloaded,
+					total: downloadBodySize
+				});
+			}
+
+			callback(null, chunk);
+		},
+
+		flush(callback) {
+			emitter.emit('downloadProgress', {
+				percent: 1,
+				transferred: downloaded,
+				total: downloadBodySize
+			});
+
+			callback();
+		}
+	});
+
+	mimicResponse(response, progressStream);
+	progressStream.redirectUrls = redirects;
+
+	const newResponse = options.decompress === true &&
+		is.function(decompressResponse) &&
+		options.method !== 'HEAD' ? decompressResponse(progressStream) : progressStream;
+
+	if (!options.decompress && ['gzip', 'deflate'].includes(response.headers['content-encoding'])) {
+		options.encoding = null;
+	}
+
+	emitter.emit('response', newResponse);
+
+	emitter.emit('downloadProgress', {
+		percent: 0,
+		transferred: 0,
+		total: downloadBodySize
+	});
+
+	response.pipe(progressStream);
+};

package/source/index.js

@@ -0,0 +1,49 @@
+'use strict';
+const pkg = require('../package.json');
+const create = require('./create');
+
+const defaults = {
+	methods: [
+		'get',
+		'post',
+		'put',
+		'patch',
+		'head',
+		'delete'
+	],
+	options: {
+		retry: {
+			retries: 2,
+			methods: [
+				'get',
+				'put',
+				'head',
+				'delete',
+				'options',
+				'trace'
+			],
+			statusCodes: [
+				408,
+				413,
+				429,
+				502,
+				503,
+				504
+			]
+		},
+		cache: false,
+		decompress: true,
+		useElectronNet: false,
+		throwHttpErrors: true,
+		headers: {
+			'user-agent': `${pkg.name}/${pkg.version} (https://github.com/sindresorhus/got)`
+		},
+		hooks: {
+			beforeRequest: []
+		}
+	}
+};
+
+const got = create(defaults);
+
+module.exports = got;

package/source/is-form-data.js

@@ -0,0 +1,4 @@
+'use strict';
+const is = require('@sindresorhus/is');
+
+module.exports = body => is.nodeStream(body) && is.function(body.getBoundary);

package/source/is-retry-on-network-error-allowed.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const WHITELIST = new Set([
+	'ETIMEDOUT',
+	'ECONNRESET',
+	'EADDRINUSE',
+	'ECONNREFUSED',
+	'EPIPE'
+]);
+
+module.exports = error => {
+	if (error && WHITELIST.has(error.code)) {
+		return true;
+	}
+
+	return false;
+};

package/source/merge.js

@@ -0,0 +1,32 @@
+'use strict';
+const {URL} = require('url');
+const is = require('@sindresorhus/is');
+
+const merge = (target, ...sources) => {
+	for (const source of sources) {
+		for (const [key, sourceValue] of Object.entries(source)) {
+			if (is.undefined(sourceValue)) {
+				continue;
+			}
+
+			const targetValue = target[key];
+			if (is.urlInstance(targetValue) && (is.urlInstance(sourceValue) || is.string(sourceValue))) {
+				target[key] = new URL(sourceValue, targetValue);
+			} else if (is.plainObject(sourceValue)) {
+				if (is.plainObject(targetValue)) {
+					target[key] = merge({}, targetValue, sourceValue);
+				} else {
+					target[key] = merge({}, sourceValue);
+				}
+			} else if (is.array(sourceValue)) {
+				target[key] = merge([], sourceValue);
+			} else {
+				target[key] = sourceValue;
+			}
+		}
+	}
+
+	return target;
+};
+
+module.exports = merge;