Major refactoring

readme.md

@@ -246,7 +246,14 @@ Default: `'default'`
 
 **Note:** When using streams, this option is ignored.
 
-Parsing method used to retrieve the body from the response. Can be `'default'`, `'text'`, `'json'` or `'buffer'`. The promise has `.json()` and `.buffer()` and `.text()` functions which set this option automatically.
+Parsing method used to retrieve the body from the response.
+
+- `'default'` - if `options.encoding` is `null`, the body will be a Buffer. Otherwise it will be a string unless it's overwritten in a `afterResponse` hook,
+- `'text'` - will always give a string, no matter what's the `options.encoding` or if the body is a custom object,
+- `'json'` - will always give an object, unless it's invalid JSON - then it will throw.
+- `'buffer'` - will always give a Buffer, no matter what's the `options.encoding`. It will throw if the body is a custom object.
+
+The promise has `.json()` and `.buffer()` and `.text()` functions which set this option automatically.
 
 Example:
 

source/as-promise.ts

@@ -9,31 +9,31 @@ import requestAsEventEmitter, {proxyEvents} from './request-as-event-emitter';
 import {normalizeArguments, mergeOptions} from './normalize-arguments';
 
 const parseBody = (body: Response['body'], responseType: NormalizedOptions['responseType'], statusCode: Response['statusCode']) => {
-	if (responseType === 'json') {
+	if (responseType === 'json' && is.string(body)) {
 		return statusCode === 204 ? '' : JSON.parse(body);
 	}
 
-	if (responseType === 'buffer') {
+	if (responseType === 'buffer' && is.string(body)) {
 		return Buffer.from(body);
 	}
 
 	if (responseType === 'text') {
-		return body.toString();
+		return String(body);
 	}
 
 	if (responseType === 'default') {
 		return body;
 	}
 
-	throw new Error(`Failed to parse body of type '${responseType}'`);
+	throw new Error(`Failed to parse body of type '${typeof body}' as '${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) => {
+	const promise = new PCancelable<IncomingMessage | Response['body']>((resolve, reject, onCancel) => {
 		const emitter = requestAsEventEmitter(options);
 		onCancel(emitter.abort);
 

source/create.ts

@@ -24,7 +24,7 @@ export type HTTPAlias =
 	| 'head'
 	| 'delete';
 
-export type ReturnStream = (url: URLOrOptions | Options & {isStream: true}, options?: Options & {isStream: true}) => ProxyStream;
+export type ReturnStream = (url: string | Options & {isStream: true}, options?: Options & {isStream: true}) => ProxyStream;
 export type GotReturn = ProxyStream | CancelableRequest<Response>;
 
 const getPromiseOrStream = (options: NormalizedOptions): GotReturn => options.isStream ? asStream(options) : asPromise(options);
@@ -33,22 +33,22 @@ type OptionsOfDefaultResponseBody = Options & {isStream?: false; resolveBodyOnly
 type OptionsOfTextResponseBody = Options & {isStream?: false; resolveBodyOnly?: false; responseType: 'text'};
 type OptionsOfJSONResponseBody = Options & {isStream?: false; resolveBodyOnly?: false; responseType: 'json'};
 type OptionsOfBufferResponseBody = Options & {isStream?: false; resolveBodyOnly?: false; responseType: 'buffer'};
-type BodyOnly = {resolveBodyOnly: true};
+type ResponseBodyOnly = {resolveBodyOnly: true};
 
 interface GotFunctions {
 	// `asPromise` usage
-	(url: URLOrOptions | OptionsOfDefaultResponseBody, options?: OptionsOfDefaultResponseBody): CancelableRequest<Response>;
-	(url: URLOrOptions | OptionsOfTextResponseBody, options?: OptionsOfTextResponseBody): CancelableRequest<Response<string>>;
-	(url: URLOrOptions | OptionsOfJSONResponseBody, options?: OptionsOfJSONResponseBody): CancelableRequest<Response<object>>;
-	(url: URLOrOptions | OptionsOfBufferResponseBody, options?: OptionsOfBufferResponseBody): CancelableRequest<Response<Buffer>>;
+	(url: string | OptionsOfDefaultResponseBody, options?: OptionsOfDefaultResponseBody): CancelableRequest<Response>;
+	(url: string | OptionsOfTextResponseBody, options?: OptionsOfTextResponseBody): CancelableRequest<Response<string>>;
+	(url: string | OptionsOfJSONResponseBody, options?: OptionsOfJSONResponseBody): CancelableRequest<Response<object>>;
+	(url: string | OptionsOfBufferResponseBody, options?: OptionsOfBufferResponseBody): CancelableRequest<Response<Buffer>>;
 
-	(url: URLOrOptions | OptionsOfDefaultResponseBody & BodyOnly, options?: OptionsOfDefaultResponseBody & BodyOnly): CancelableRequest<any>;
-	(url: URLOrOptions | OptionsOfTextResponseBody & BodyOnly, options?: OptionsOfTextResponseBody & BodyOnly): CancelableRequest<string>;
-	(url: URLOrOptions | OptionsOfJSONResponseBody & BodyOnly, options?: OptionsOfJSONResponseBody & BodyOnly): CancelableRequest<object>;
-	(url: URLOrOptions | OptionsOfBufferResponseBody & BodyOnly, options?: OptionsOfBufferResponseBody & BodyOnly): CancelableRequest<Buffer>;
+	(url: string | OptionsOfDefaultResponseBody & ResponseBodyOnly, options?: OptionsOfDefaultResponseBody & ResponseBodyOnly): CancelableRequest<any>;
+	(url: string | OptionsOfTextResponseBody & ResponseBodyOnly, options?: OptionsOfTextResponseBody & ResponseBodyOnly): CancelableRequest<string>;
+	(url: string | OptionsOfJSONResponseBody & ResponseBodyOnly, options?: OptionsOfJSONResponseBody & ResponseBodyOnly): CancelableRequest<object>;
+	(url: string | OptionsOfBufferResponseBody & ResponseBodyOnly, options?: OptionsOfBufferResponseBody & ResponseBodyOnly): CancelableRequest<Buffer>;
 
 	// `asStream` usage
-	(url: URLOrOptions | Options & {isStream: true}, options?: Options & {isStream: true}): ProxyStream;
+	(url: string | Options & {isStream: true}, options?: Options & {isStream: true}): ProxyStream;
 }
 
 export interface Got extends Merge<Record<HTTPAlias, GotFunctions>, GotFunctions> {

source/utils/types.ts

@@ -45,7 +45,7 @@ export type ErrorCode =
 
 export type ResponseType = 'json' | 'buffer' | 'text' | 'default';
 
-export interface Response<BodyType = any> extends http.IncomingMessage {
+export interface Response<BodyType = unknown> extends http.IncomingMessage {
 	body: BodyType;
 	statusCode: number;
 

test/headers.ts

@@ -52,7 +52,8 @@ test('does not remove user headers from `url` object argument', withServer, asyn
 		}
 	})).body;
 
-	t.is(headers.accept, 'application/json');
+	// TODO: The response is not typed, so we need to cast as any
+	t.is((headers as any).accept, 'application/json');
 	t.is(headers['user-agent'], 'got (https://github.com/sindresorhus/got)');
 	t.is(headers['accept-encoding'], supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate');
 	t.is(headers['x-request-id'], 'value');

test/response-parse.ts

@@ -76,7 +76,7 @@ test('works if promise has been already resolved', withServer, async (t, server,
 test('throws an error on invalid response type', withServer, async (t, server, got) => {
 	server.get('/', defaultHandler);
 
-	const error = await t.throwsAsync(got({responseType: 'invalid'}), /^Failed to parse body of type 'invalid'/);
+	const error = await t.throwsAsync(got({responseType: 'invalid'}), /^Failed to parse body of type 'string\' as 'invalid'/);
 	// @ts-ignore
 	t.true(error.message.includes(error.options.url.hostname));
 	// @ts-ignore