got 10.5.5 → 10.7.0

package/dist/source/as-stream.js

@@ -21,7 +21,7 @@ function asStream(options) {
             throw new Error('Got\'s stream is not writable when the `body`, `json` or `form` option is used');
         };
     }
-    else if (options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH') {
+    else if (options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH' || (options.allowGetBody && options.method === 'GET')) {
         options.body = input;
     }
     else {

package/dist/source/create.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Merge } from 'type-fest';
+import { Merge, Except } from 'type-fest';
 import { ProxyStream } from './as-stream';
 import * as errors from './errors';
 import { CancelableRequest, Defaults, ExtendOptions, HandlerFunction, NormalizedOptions, Options, Response, URLOrOptions, PaginationOptions } from './types';
@@ -51,9 +51,11 @@ export interface GotRequestMethod {
         isStream: true;
     }>): ProxyStream<T>;
 }
+export declare type GotPaginateOptions<T> = Except<Options, keyof PaginationOptions<unknown>> & PaginationOptions<T>;
+export declare type URLOrGotPaginateOptions<T> = string | GotPaginateOptions<T>;
 export interface GotPaginate {
-    <T>(url: URLOrOptions & PaginationOptions<T>, options?: Options & PaginationOptions<T>): AsyncIterableIterator<T>;
-    all<T>(url: URLOrOptions & PaginationOptions<T>, options?: Options & PaginationOptions<T>): Promise<T[]>;
+    <T>(url: URLOrGotPaginateOptions<T>, options?: GotPaginateOptions<T>): AsyncIterableIterator<T>;
+    all<T>(url: URLOrGotPaginateOptions<T>, options?: GotPaginateOptions<T>): Promise<T[]>;
 }
 export interface Got extends Record<HTTPAlias, GotRequestMethod>, GotRequestMethod {
     stream: GotStream;

package/dist/source/create.js

@@ -111,19 +111,21 @@ const create = (defaults) => {
             const result = await got(normalizedOptions);
             // eslint-disable-next-line no-await-in-loop
             const parsed = await pagination.transform(result);
+            const current = [];
             for (const item of parsed) {
-                if (pagination.filter(item, all)) {
-                    if (!pagination.shouldContinue(item, all)) {
+                if (pagination.filter(item, all, current)) {
+                    if (!pagination.shouldContinue(item, all, current)) {
                         return;
                     }
                     yield item;
                     all.push(item);
+                    current.push(item);
                     if (all.length === pagination.countLimit) {
                         return;
                     }
                 }
             }
-            const optionsToMerge = pagination.paginate(result);
+            const optionsToMerge = pagination.paginate(result, all, current);
             if (optionsToMerge === false) {
                 return;
             }

package/dist/source/index.js

@@ -67,10 +67,14 @@ const defaults = {
         maxRedirects: 10,
         prefixUrl: '',
         methodRewriting: true,
+        allowGetBody: false,
         ignoreInvalidCookies: false,
         context: {},
         _pagination: {
             transform: (response) => {
+                if (response.request.options.responseType === 'json') {
+                    return response.body;
+                }
                 return JSON.parse(response.body);
             },
             paginate: response => {

package/dist/source/known-hook-events.d.ts

@@ -6,7 +6,7 @@ Called with plain request options, right before their normalization. This is esp
 
 @see [Request migration guide](https://github.com/sindresorhus/got/blob/master/migration-guides.md#breaking-changes) for an example.
 */
-export declare type InitHook = (options: NormalizedOptions) => void;
+export declare type InitHook = (options: Options) => void;
 /**
 Called with normalized [request options](https://github.com/sindresorhus/got#options). Got will make no further changes to the request before it is sent (except the body serialization). This is especially useful in conjunction with [`got.extend()`](https://github.com/sindresorhus/got#instances) when you want to create an API client that, for example, uses HMAC-signing.
 

package/dist/source/normalize-arguments.js

@@ -193,6 +193,7 @@ exports.preNormalizeArguments = (options, defaults) => {
     options.dnsCache = (_e = options.dnsCache, (_e !== null && _e !== void 0 ? _e : false));
     options.useElectronNet = Boolean(options.useElectronNet);
     options.methodRewriting = Boolean(options.methodRewriting);
+    options.allowGetBody = Boolean(options.allowGetBody);
     options.context = (_f = options.context, (_f !== null && _f !== void 0 ? _f : {}));
     return options;
 };
@@ -218,27 +219,52 @@ exports.mergeOptions = (...sources) => {
     return mergedOptions;
 };
 exports.normalizeArguments = (url, options, defaults) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     // Merge options
     if (typeof url === 'undefined') {
         throw new TypeError('Missing `url` argument');
     }
-    if (typeof options === 'undefined') {
-        options = {};
-    }
-    if (is_1.default.urlInstance(url) || is_1.default.string(url)) {
-        if (Reflect.has(options, 'url')) {
-            throw new TypeError('The `url` option cannot be used if the input is a valid URL.');
+    const runInitHooks = (hooks, options) => {
+        if (hooks && options) {
+            for (const hook of hooks) {
+                const result = hook(options);
+                if (is_1.default.promise(result)) {
+                    throw new TypeError('The `init` hook must be a synchronous function');
+                }
+            }
+        }
+    };
+    const hasUrl = is_1.default.urlInstance(url) || is_1.default.string(url);
+    if (hasUrl) {
+        if (options) {
+            if (Reflect.has(options, 'url')) {
+                throw new TypeError('The `url` option cannot be used if the input is a valid URL.');
+            }
+        }
+        else {
+            options = {};
         }
         // @ts-ignore URL is not URL
         options.url = url;
-        options = exports.mergeOptions((_b = (_a = defaults) === null || _a === void 0 ? void 0 : _a.options, (_b !== null && _b !== void 0 ? _b : {})), options);
+        runInitHooks((_a = defaults) === null || _a === void 0 ? void 0 : _a.options.hooks.init, options);
+        runInitHooks((_b = options.hooks) === null || _b === void 0 ? void 0 : _b.init, options);
+    }
+    else if (Reflect.has(url, 'resolve')) {
+        throw new Error('The legacy `url.Url` is deprecated. Use `URL` instead.');
     }
     else {
-        if (Reflect.has(url, 'resolve')) {
-            throw new Error('The legacy `url.Url` is deprecated. Use `URL` instead.');
+        runInitHooks((_c = defaults) === null || _c === void 0 ? void 0 : _c.options.hooks.init, url);
+        runInitHooks((_d = url.hooks) === null || _d === void 0 ? void 0 : _d.init, url);
+        if (options) {
+            runInitHooks((_e = defaults) === null || _e === void 0 ? void 0 : _e.options.hooks.init, options);
+            runInitHooks((_f = options.hooks) === null || _f === void 0 ? void 0 : _f.init, options);
         }
-        options = exports.mergeOptions((_d = (_c = defaults) === null || _c === void 0 ? void 0 : _c.options, (_d !== null && _d !== void 0 ? _d : {})), url, options);
+    }
+    if (hasUrl) {
+        options = exports.mergeOptions((_h = (_g = defaults) === null || _g === void 0 ? void 0 : _g.options, (_h !== null && _h !== void 0 ? _h : {})), (options !== null && options !== void 0 ? options : {}));
+    }
+    else {
+        options = exports.mergeOptions((_k = (_j = defaults) === null || _j === void 0 ? void 0 : _j.options, (_k !== null && _k !== void 0 ? _k : {})), url, (options !== null && options !== void 0 ? options : {}));
     }
     // Normalize URL
     // TODO: drop `optionsToUrl` in Got 12
@@ -278,15 +304,10 @@ exports.normalizeArguments = (url, options, defaults) => {
             delete normalizedOptions.headers[key];
         }
     }
-    for (const hook of normalizedOptions.hooks.init) {
-        const result = hook(normalizedOptions);
-        if (is_1.default.promise(result)) {
-            throw new TypeError('The `init` hook must be a synchronous function');
-        }
-    }
     return normalizedOptions;
 };
-const withoutBody = new Set(['GET', 'HEAD']);
+const withoutBody = new Set(['HEAD']);
+const withoutBodyUnlessSpecified = 'GET';
 exports.normalizeRequestArguments = async (options) => {
     var _a, _b, _c;
     options = exports.mergeOptions(options);
@@ -301,6 +322,9 @@ exports.normalizeRequestArguments = async (options) => {
         if ((isBody || isForm || isJson) && withoutBody.has(options.method)) {
             throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
         }
+        if (!options.allowGetBody && (isBody || isForm || isJson) && withoutBodyUnlessSpecified === options.method) {
+            throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
+        }
         if ([isBody, isForm, isJson].filter(isTrue => isTrue).length > 1) {
             throw new TypeError('The `body`, `json` and `form` options are mutually exclusive');
         }
@@ -347,7 +371,7 @@ exports.normalizeRequestArguments = async (options) => {
     // a payload body and the method semantics do not anticipate such a
     // body.
     if (is_1.default.undefined(headers['content-length']) && is_1.default.undefined(headers['transfer-encoding'])) {
-        if ((options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH' || options.method === 'DELETE') &&
+        if ((options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH' || options.method === 'DELETE' || (options.allowGetBody && options.method === 'GET')) &&
             !is_1.default.undefined(uploadBodySize)) {
             // @ts-ignore We assign if it is undefined, so this IS correct
             headers['content-length'] = String(uploadBodySize);

package/dist/source/request-as-event-emitter.js

@@ -81,6 +81,7 @@ exports.default = (options) => {
                 }
                 if (options.followRedirect && Reflect.has(typedResponse.headers, 'location') && redirectCodes.has(statusCode)) {
                     typedResponse.resume(); // We're being redirected, we don't care about the response.
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare
                     if (statusCode === 303 || options.methodRewriting === false) {
                         if (options.method !== 'GET' && options.method !== 'HEAD') {
                             // Server responded with "see other", indicating that the resource exists at another location,

package/dist/source/types.d.ts

@@ -104,9 +104,9 @@ export declare type DefaultOptions = Merge<Required<Except<GotOptions, 'hooks' |
 export interface PaginationOptions<T> {
     _pagination?: {
         transform?: (response: Response) => Promise<T[]> | T[];
-        filter?: (item: T, allItems: T[]) => boolean;
-        paginate?: (response: Response) => Options | false;
-        shouldContinue?: (item: T, allItems: T[]) => boolean;
+        filter?: (item: T, allItems: T[], currentItems: T[]) => boolean;
+        paginate?: (response: Response, allItems: T[], currentItems: T[]) => Options | false;
+        shouldContinue?: (item: T, allItems: T[], currentItems: T[]) => boolean;
         countLimit?: number;
     };
 }
@@ -145,6 +145,7 @@ export interface GotOptions extends PaginationOptions<unknown> {
     };
     maxRedirects?: number;
     lookup?: CacheableLookup['lookup'];
+    allowGetBody?: boolean;
     methodRewriting?: boolean;
 }
 export declare type Options = Merge<https.RequestOptions, Merge<GotOptions, URLOptions>>;
@@ -173,6 +174,7 @@ export interface NormalizedOptions extends Options {
     followRedirect: boolean;
     useElectronNet: boolean;
     methodRewriting: boolean;
+    allowGetBody: boolean;
     context: {
         [key: string]: any;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "got",
-	"version": "10.5.5",
+	"version": "10.7.0",
 	"description": "Human-friendly and powerful HTTP request library for Node.js",
 	"license": "MIT",
 	"repository": "sindresorhus/got",
@@ -41,7 +41,7 @@
 		"superagent"
 	],
 	"dependencies": {
-		"@sindresorhus/is": "^1.0.0",
+		"@sindresorhus/is": "^2.0.0",
 		"@szmarczak/http-timer": "^4.0.0",
 		"@types/cacheable-request": "^6.0.1",
 		"cacheable-lookup": "^2.0.0",
@@ -50,15 +50,15 @@
 		"duplexer3": "^0.1.4",
 		"get-stream": "^5.0.0",
 		"lowercase-keys": "^2.0.0",
-		"mimic-response": "^2.0.0",
+		"mimic-response": "^2.1.0",
 		"p-cancelable": "^2.0.0",
 		"p-event": "^4.0.0",
 		"responselike": "^2.0.0",
 		"to-readable-stream": "^2.0.0",
-		"type-fest": "^0.9.0"
+		"type-fest": "^0.10.0"
 	},
 	"devDependencies": {
-		"@ava/typescript": "^1.1.0",
+		"@ava/typescript": "^1.1.1",
 		"@sindresorhus/tsconfig": "^0.7.0",
 		"@types/duplexer3": "^0.1.0",
 		"@types/express": "^4.17.2",
@@ -67,34 +67,33 @@
 		"@types/proxyquire": "^1.3.28",
 		"@types/sinon": "^7.0.13",
 		"@types/tough-cookie": "^2.3.5",
-		"@typescript-eslint/eslint-plugin": "^2.17.0",
-		"@typescript-eslint/parser": "^2.17.0",
-		"ava": "^3.2.0",
+		"@typescript-eslint/eslint-plugin": "^2.19.2",
+		"@typescript-eslint/parser": "^2.19.2",
+		"ava": "^3.3.0",
 		"coveralls": "^3.0.4",
 		"create-test-server": "^3.0.1",
 		"del-cli": "^3.0.0",
 		"delay": "^4.3.0",
-		"eslint-config-xo-typescript": "^0.24.1",
+		"eslint-config-xo-typescript": "^0.26.0",
 		"express": "^4.17.1",
 		"form-data": "^3.0.0",
 		"get-port": "^5.0.0",
 		"keyv": "^4.0.0",
-		"lolex": "^5.1.1",
-		"nock": "^11.3.4",
-		"np": "^5.1.3",
+		"lolex": "^6.0.0",
+		"nock": "^12.0.0",
+		"np": "^6.0.0",
 		"nyc": "^15.0.0",
 		"proxyquire": "^2.0.1",
 		"sinon": "^8.1.1",
 		"slow-stream": "0.0.4",
-		"tempy": "^0.3.0",
+		"tempy": "^0.4.0",
 		"tough-cookie": "^3.0.0",
 		"typescript": "3.7.5",
-		"xo": "^0.25.3"
+		"xo": "^0.26.0"
 	},
 	"types": "dist/source",
 	"sideEffects": false,
 	"browser": {
-		"decompress-response": false,
 		"electron": false
 	},
 	"ava": {

package/readme.md

@@ -188,7 +188,9 @@ Type: `string | Buffer | stream.Readable` or [`form-data` instance](https://gith
 
 **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`.
+**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` / `fs.createReadStream` instance / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
 
@@ -196,7 +198,8 @@ The `content-length` header will be automatically set if `body` is a `string` /
 
 Type: `object | Array | number | string | boolean | null` *(JSON-serializable values)*
 
-**Note:** If you provide this option, `got.stream()` will be read-only.
+**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.
 
 JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
 
@@ -217,7 +220,7 @@ const instance = got.extend({
 	hooks: {
 		beforeRequest: [
 			options => {
-				if (!options.context && !options.context.token) {
+				if (!options.context || !options.context.token) {
 					throw new Error('Token required');
 				}
 
@@ -248,21 +251,35 @@ Default: `'text'`
 
 The parsing method. Can be `'text'`, `'json'` or `'buffer'`.
 
-The promise also has `.text()`, `.json()` and `.buffer()` methods which sets this and the `resolveBodyOnly` option automatically.
+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.
 
 Example:
 
+```js
+(async () => {
+	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
+})();
+```
+
 ```js
 // This
 const body = await got(url).json();
 
-// is the same as this
+// is semantically the same as this
 const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
 ```
 
 ###### resolveBodyOnly
 
-Type: `string`\
+Type: `boolean`\
 Default: `false`
 
 When set to `true` the promise will return the [Response body](#body-1) instead of the [Response](#response) object.
@@ -307,7 +324,8 @@ To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set [`respo
 
 Type: `object | true`
 
-**Note:** If you provide this option, `got.stream()` will be read-only.
+**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.
 
 The form body is converted to query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
 
@@ -410,6 +428,15 @@ Default: `true`
 
 By default, redirects will use [method rewriting](https://tools.ietf.org/html/rfc7231#section-6.4). For example, when sending a POST request and receiving a `302`, it will resend the body to the new location using the same HTTP method (`POST` in this case).
 
+###### allowGetBody
+
+Type: `boolean`\
+Default: `false`
+
+**Note:** The [RFC 7321](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)**.
+
+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.
+
 ###### maxRedirects
 
 Type: `number`\
@@ -551,7 +578,7 @@ got.post('https://example.com', {
 	hooks: {
 		beforeRetry: [
 			(options, error, retryCount) => {
-				if (error.statusCode === 413) { // Payload too large
+				if (error.response.statusCode === 413) { // Payload too large
 					options.body = getNewBody();
 				}
 			}
@@ -627,7 +654,7 @@ got('https://api.github.com/some-endpoint', {
 				const {response} = error;
  				if (response && response.body) {
 					error.name = 'GitHubError';
-					error.message = `${response.body.message} (${error.statusCode})`;
+					error.message = `${response.body.message} (${response.statusCode})`;
 				}
 
  				return error;
@@ -655,23 +682,64 @@ A function that transform [`Response`](#response) into an array of items. This i
 Type: `Function`\
 Default: [`Link` header logic](source/index.ts)
 
-A function that returns an object representing Got options pointing to the next page. If there are no more pages, `false` should be returned.
+The function takes three arguments:
+- `response` - The current response object.
+- `allItems` - An array of the emitted items.
+- `currentItems` - Items from the current response.
+
+It should return an object representing Got options pointing to the next page. If there are no more pages, `false` should be returned.
+
+For example, if you want to stop when the response contains less items than expected, you can use something like this:
+
+```js
+const got = require('got');
+
+(async () => {
+	const limit = 10;
+
+	const items = got.paginate('https://example.com/items', {
+		searchParams: {
+			limit,
+			offset: 0
+		},
+		_pagination: {
+			paginate: (response, allItems, currentItems) => {
+				const previousSearchParams = response.request.options.searchParams;
+				const {offset: previousOffset} = previousSearchParams;
+
+				if (currentItems.length < limit) {
+					return false;
+				}
+
+				return {
+					searchParams: {
+						...previousSearchParams,
+						offset: previousOffset + limit,
+					}
+				};
+			}
+		}
+	});
+
+	console.log('Items from all pages:', items);
+})();
+```
 
 ###### \_pagination.filter
 
 Type: `Function`\
-Default: `(item, allItems) => true`
+Default: `(item, allItems, currentItems) => true`
 
 Checks whether the item should be emitted or not.
 
 ###### \_pagination.shouldContinue
 
 Type: `Function`\
-Default: `(item, allItems) => true`
+Default: `(item, allItems, currentItems) => true`
 
 Checks whether the pagination should continue.
 
-For example, if you need to stop **before** emitting an entry with some flag, you should use `(item, allItems) => !item.flag`. If you want to stop **after** emitting the entry, you should use `(item, allItems) => allItems.some(entry => entry.flag)` instead.
+For example, if you need to stop **before** emitting an entry with some flag, you should use `(item, allItems, currentItems) => !item.flag`. If you want to stop **after** emitting the entry, you should use `(item, allItems, currentItems) => allItems.some(entry => entry.flag)` instead.
 
 ###### \_pagination.countLimit
 
@@ -810,7 +878,7 @@ Progress events for uploading (sending a request) and downloading (receiving a r
 }
 ```
 
-If it's not possible to retrieve the body size (can happen when streaming), `total` will be `undefined`.
+If the `content-length` header is missing, `total` will be `undefined`.
 
 ```js
 (async () => {
@@ -1003,6 +1071,14 @@ Options are deeply merged to a new object. The value of each key is determined a
 	- If the parent property is a plain `object` too, both values are merged recursively into a new `object`.
 	- Otherwise, only the new value is deeply cloned.
 - If the new property is an `Array`, it overwrites the old one with a deep clone of the new property.
+- Properties that are not enumerable, such as `context`, `body`, `json`, and `form`, will not be merged.
+```js
+const a = {json: {cat: 'meow'}};
+const b = {json: {cow: 'moo'}};
+
+got.mergeOptions(a, b);
+//=> {json: {cow: 'moo'}}
+```
 - Otherwise, the new value is assigned to the key.
 
 #### got.defaults