Major refactoring

readme.md

@@ -254,11 +254,15 @@ Cookie support. You don't have to care about parsing or how to store them. [Exam
 
 ###### cookieJar.setCookie
 
-The function takes two arguments: `rawCookie` (`string`) and `url` (`string`). It needs to be an async function or some callback-style function.
+Type: `Function<Promise>`
+
+The function takes two arguments: `rawCookie` (`string`) and `url` (`string`).
 
 ###### cookieJar.getCookieString
 
-The function takes one argument: `url` (`string`). It needs to be an async function or some callback-style function.
+Type: `Function<Promise>`
+
+The function takes one argument: `url` (`string`).
 
 ###### ignoreInvalidCookies
 

source/as-promise.ts

@@ -5,25 +5,32 @@ import is from '@sindresorhus/is';
 import PCancelable = require('p-cancelable');
 import {NormalizedOptions, Response, CancelableRequest} from './utils/types';
 import {ParseError, ReadError, HTTPError} from './errors';
-import requestAsEventEmitter from './request-as-event-emitter';
+import requestAsEventEmitter, {proxyEvents} from './request-as-event-emitter';
 import {normalizeArguments, mergeOptions} from './normalize-arguments';
 
-type ResponseReturn = Response | Buffer | string | any;
+const parseBody = (body: Response['body'], responseType: NormalizedOptions['responseType'], statusCode: Response['statusCode']) => {
+	if (responseType === 'json') {
+		return statusCode === 204 ? '' : JSON.parse(body);
+	}
 
-export const isProxiedSymbol: unique symbol = Symbol('proxied');
+	if (responseType === 'buffer') {
+		return Buffer.from(body);
+	}
 
-export default function asPromise(options: NormalizedOptions): CancelableRequest<Response> {
-	const proxy = new EventEmitter();
+	if (responseType === 'text') {
+		return body.toString();
+	}
 
-	const parseBody = (response: Response): void => {
-		if (options.responseType === 'json') {
-			response.body = response.statusCode === 204 ? '' : JSON.parse(response.body);
-		} else if (options.responseType === 'buffer') {
-			response.body = Buffer.from(response.body);
-		} else if (options.responseType !== 'text' && !is.falsy(options.responseType)) {
-			throw new Error(`Failed to parse body of type '${options.responseType}'`);
-		}
-	};
+	if (responseType === '') {
+		return body;
+	}
+
+	throw new Error(`Failed to parse body of type '${responseType}'`);
+};
+
+export default function asPromise(options: NormalizedOptions) {
+	const proxy = new EventEmitter();
+	let finalResponse: Pick<Response, 'body' | 'statusCode'>;
 
 	// @ts-ignore `.json()`, `.buffer()` and `.text()` are added later
 	const promise = new PCancelable<IncomingMessage>((resolve, reject, onCancel) => {
@@ -46,11 +53,10 @@ export default function asPromise(options: NormalizedOptions): CancelableRequest
 		emitter.on('response', async (response: Response) => {
 			proxy.emit('response', response);
 
-			const stream = is.null_(options.encoding) ? getStream.buffer(response) : getStream(response, {encoding: options.encoding});
+			const streamAsPromise = is.null_(options.encoding) ? getStream.buffer(response) : getStream(response, {encoding: options.encoding});
 
-			let data: Buffer | string;
 			try {
-				data = await stream;
+				response.body = await streamAsPromise;
 			} catch (error) {
 				emitError(new ReadError(error, options));
 				return;
@@ -61,10 +67,6 @@ export default function asPromise(options: NormalizedOptions): CancelableRequest
 				return;
 			}
 
-			const limitStatusCode = options.followRedirect ? 299 : 399;
-
-			response.body = data;
-
 			try {
 				for (const [index, hook] of options.hooks.afterResponse.entries()) {
 					// eslint-disable-next-line no-await-in-loop
@@ -93,18 +95,22 @@ export default function asPromise(options: NormalizedOptions): CancelableRequest
 
 			const {statusCode} = response;
 
-			if (response.body) {
-				try {
-					parseBody(response);
-				} catch (error) {
-					if (statusCode >= 200 && statusCode < 300) {
-						const parseError = new ParseError(error, response, options);
-						emitError(parseError);
-						return;
-					}
+			finalResponse = {
+				body: response.body,
+				statusCode
+			};
+
+			try {
+				response.body = parseBody(response.body, options.responseType, response.statusCode);
+			} catch (error) {
+				if (statusCode >= 200 && statusCode < 300) {
+					const parseError = new ParseError(error, response, options);
+					emitError(parseError);
+					return;
 				}
 			}
 
+			const limitStatusCode = options.followRedirect ? 299 : 399;
 			if (statusCode !== 304 && (statusCode < 200 || statusCode > limitStatusCode)) {
 				const error = new HTTPError(response, options);
 				if (emitter.retry(error) === false) {
@@ -124,44 +130,34 @@ export default function asPromise(options: NormalizedOptions): CancelableRequest
 
 		emitter.once('error', reject);
 
-		const events = [
-			'request',
-			'redirect',
-			'uploadProgress',
-			'downloadProgress'
-		];
-
-		for (const event of events) {
-			emitter.on(event, (...args: unknown[]) => {
-				proxy.emit(event, ...args);
-			});
-		}
-	}) as CancelableRequest<ResponseReturn>;
-
-	promise[isProxiedSymbol] = true;
+		proxyEvents(proxy, emitter);
+	}) as CancelableRequest<any>;
 
-	promise.on = (name, fn) => {
+	promise.on = (name: string, fn: (...args: any[]) => void) => {
 		proxy.on(name, fn);
 		return promise;
 	};
 
-	promise.json = () => {
-		options.responseType = 'json';
-		options.resolveBodyOnly = true;
-		return promise;
-	};
+	const shortcut = (responseType: NormalizedOptions['responseType']): CancelableRequest<any> => {
+		// eslint-disable-next-line promise/prefer-await-to-then
+		const newPromise = promise.then(() => parseBody(finalResponse.body, responseType, finalResponse.statusCode));
 
-	promise.buffer = () => {
-		options.responseType = 'buffer';
-		options.resolveBodyOnly = true;
-		return promise;
+		Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));
+
+		// @ts-ignore The missing properties are added above
+		return newPromise;
 	};
 
-	promise.text = () => {
-		options.responseType = 'text';
-		options.resolveBodyOnly = true;
-		return promise;
+	promise.json = () => {
+		if (is.undefined(options.headers.accept)) {
+			options.headers.accept = 'application/json';
+		}
+
+		return shortcut('json');
 	};
 
+	promise.buffer = () => shortcut('buffer');
+	promise.text = () => shortcut('text');
+
 	return promise;
 }

source/as-stream.ts

@@ -2,7 +2,7 @@ import {PassThrough as PassThroughStream, Duplex as DuplexStream} from 'stream';
 import stream = require('stream');
 import {IncomingMessage} from 'http';
 import duplexer3 = require('duplexer3');
-import requestAsEventEmitter from './request-as-event-emitter';
+import requestAsEventEmitter, {proxyEvents} from './request-as-event-emitter';
 import {HTTPError, ReadError} from './errors';
 import {NormalizedOptions, Response, GotEvents} from './utils/types';
 
@@ -101,19 +101,8 @@ export default function asStream(options: NormalizedOptions): ProxyStream {
 		proxy.emit('response', response);
 	});
 
-	const events = [
-		'error',
-		'request',
-		'redirect',
-		'uploadProgress',
-		'downloadProgress'
-	];
-
-	for (const event of events) {
-		emitter.on(event, (...args) => {
-			proxy.emit(event, ...args);
-		});
-	}
+	proxyEvents(proxy, emitter);
+	emitter.on('error', (error: Error) => proxy.emit('error', error));
 
 	const pipe = proxy.pipe.bind(proxy);
 	const unpipe = proxy.unpipe.bind(proxy);

source/create.ts

@@ -68,6 +68,7 @@ export const defaultHandler: HandlerFunction = (options, next) => next(options);
 
 const create = (defaults: Defaults): Got => {
 	// Proxy properties from next handlers
+	defaults._rawHandlers = defaults.handlers;
 	defaults.handlers = defaults.handlers.map(fn => ((options, next) => {
 		let root: GotReturn;
 
@@ -110,18 +111,18 @@ const create = (defaults: Defaults): Got => {
 
 	got.extend = (...instancesOrOptions) => {
 		const optionsArray: Options[] = [defaults.options];
-		const handlers: HandlerFunction[] = [...defaults.handlers];
+		let handlers: HandlerFunction[] = [...defaults._rawHandlers];
 		let mutableDefaults: boolean;
 
 		for (const value of instancesOrOptions) {
 			if (Reflect.has(value, 'defaults')) {
 				optionsArray.push((value as Got).defaults.options);
 
-				handlers.push(...(value as Got).defaults.handlers.filter(handler => handler !== defaultHandler));
+				handlers.push(...(value as Got).defaults._rawHandlers);
 
 				mutableDefaults = (value as Got).defaults.mutableDefaults;
 			} else {
-				optionsArray.push(value as Options);
+				optionsArray.push(value as ExtendedOptions);
 
 				if (Reflect.has(value, 'handlers')) {
 					handlers.push(...(value as ExtendedOptions).handlers);
@@ -131,6 +132,8 @@ const create = (defaults: Defaults): Got => {
 			}
 		}
 
+		handlers = handlers.filter(handler => handler !== defaultHandler);
+
 		if (handlers.length === 0) {
 			handlers.push(defaultHandler);
 		}

source/get-response.ts

@@ -2,12 +2,15 @@ import {IncomingMessage} from 'http';
 import EventEmitter = require('events');
 import stream = require('stream');
 import decompressResponse = require('decompress-response');
+import mimicResponse = require('mimic-response');
 import {NormalizedOptions, Response} from './utils/types';
 import {downloadProgress} from './progress';
 
 export default (response: IncomingMessage, options: NormalizedOptions, emitter: EventEmitter) => {
 	const downloadBodySize = Number(response.headers['content-length']) || undefined;
-	const progressStream = downloadProgress(response, emitter, downloadBodySize);
+	const progressStream = downloadProgress(emitter, downloadBodySize);
+
+	mimicResponse(response, progressStream);
 
 	const newResponse = (
 		options.decompress === true &&

source/index.ts

@@ -53,7 +53,7 @@ const defaults: Defaults = {
 		cache: false,
 		dnsCache: false,
 		useElectronNet: false,
-		responseType: 'text',
+		responseType: '',
 		resolveBodyOnly: false,
 		maxRedirects: 10
 	},

source/normalize-arguments.ts

@@ -23,7 +23,6 @@ import getBodySize from './utils/get-body-size';
 import isFormData from './utils/is-form-data';
 import supportsBrotli from './utils/supports-brotli';
 
-// TODO: Add this to documentation:
 // `preNormalizeArguments` normalizes these options: `headers`, `prefixUrl`, `hooks`, `timeout`, `retry` and `method`.
 // `normalizeArguments` is *only* called on `got(...)`. It normalizes the URL and performs `mergeOptions(...)`.
 // `normalizeRequestArguments` converts Got options into HTTP options.
@@ -146,12 +145,16 @@ export const preNormalizeArguments = (options: Options, defaults?: NormalizedOpt
 	if (options.cookieJar) {
 		let {setCookie, getCookieString} = options.cookieJar;
 
-		if (setCookie.length !== 2) {
-			setCookie = promisify(options.cookieJar.setCookie.bind(options.cookieJar));
-		}
-
-		if (setCookie.length !== 2) {
-			getCookieString = promisify(options.cookieJar.getCookieString.bind(options.cookieJar));
+		// Horrible `tough-cookie` check
+		if (setCookie.length === 4 && getCookieString.length === 0) {
+			if (!Reflect.has(setCookie, promisify.custom)) {
+				setCookie = promisify(setCookie.bind(options.cookieJar));
+				getCookieString = promisify(getCookieString.bind(options.cookieJar));
+			}
+		} else if (setCookie.length !== 2) {
+			throw new TypeError('`options.cookieJar.setCookie` needs to be an async function with 2 arguments');
+		} else if (getCookieString.length !== 1) {
+			throw new TypeError('`options.cookieJar.getCookieString` needs to be an async function with 1 argument');
 		}
 
 		options.cookieJar = {setCookie, getCookieString};
@@ -195,7 +198,7 @@ export const mergeOptions = (...sources: Options[]): NormalizedOptions => {
 export const normalizeArguments = (url: URLOrOptions, options?: Options, defaults?: Defaults): NormalizedOptions => {
 	// Merge options
 	if (typeof url === 'undefined') {
-		throw new TypeError('Missing `url` argument.');
+		throw new TypeError('Missing `url` argument');
 	}
 
 	if (typeof options === 'undefined') {
@@ -241,7 +244,7 @@ export const normalizeArguments = (url: URLOrOptions, options?: Options, default
 	let prefixUrl = options.prefixUrl as string;
 	Object.defineProperty(options, 'prefixUrl', {
 		set: (value: string) => {
-			if (normalizedOptions.url.href.startsWith(value)) {
+			if (!normalizedOptions.url.href.startsWith(value)) {
 				throw new Error(`Cannot change \`prefixUrl\` from ${prefixUrl} to ${value}: ${normalizedOptions.url.href}`);
 			}
 
@@ -274,7 +277,7 @@ export const normalizeArguments = (url: URLOrOptions, options?: Options, default
 
 const withoutBody: ReadonlySet<string> = new Set(['GET', 'HEAD']);
 
-type NormalizedRequestArguments = https.RequestOptions & {
+export type NormalizedRequestArguments = https.RequestOptions & {
 	body: Pick<NormalizedOptions, 'body'>;
 	url: Pick<NormalizedOptions, 'url'>;
 };
@@ -293,11 +296,11 @@ export const normalizeRequestArguments = async (options: NormalizedOptions): Pro
 		throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
 	}
 
-	if (isBody) {
-		if (isForm || isJSON) {
-			throw new TypeError('The `body` option cannot be used with the `json` option or `form` option');
-		}
+	if ([isBody, isForm, isJSON].filter(isTrue => isTrue).length > 1) {
+		throw new TypeError('The `body`, `json` and `form` options are mutually exclusive');
+	}
 
+	if (isBody) {
 		if (is.object(options.body) && isFormData(options.body)) {
 			// Special case for https://github.com/form-data/form-data
 			if (!Reflect.has(headers, 'content-type')) {
@@ -405,8 +408,18 @@ export const normalizeRequestArguments = async (options: NormalizedOptions): Pro
 		options.request = electron.net.request ?? electron.remote.net.request;
 	}
 
+	// We're not compatible
 	delete options.timeout;
 
+	// Set cookies
+	if (options.cookieJar) {
+		const cookieString = await options.cookieJar.getCookieString(options.url.toString());
+
+		if (is.nonEmptyString(cookieString)) {
+			options.headers.cookie = cookieString;
+		}
+	}
+
 	// `http-cache-semantics` check this
 	delete options.url;