got 12.0.0-beta.1 → 12.0.0

package/dist/source/core/options.js

@@ -1,12 +1,14 @@
-import { promisify, inspect } from 'util';
-import { URL, URLSearchParams } from 'url';
-import { checkServerIdentity } from 'tls';
-import { request as httpRequest } from 'http';
-import { request as httpsRequest } from 'https';
+import process from 'node:process';
+import { promisify, inspect } from 'node:util';
+import { URL, URLSearchParams } from 'node:url';
+import { checkServerIdentity } from 'node:tls';
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
 import is, { assert } from '@sindresorhus/is';
 import lowercaseKeys from 'lowercase-keys';
 import CacheableLookup from 'cacheable-lookup';
 import http2wrapper from 'http2-wrapper';
+import { isFormDataLike } from 'form-data-encoder';
 import parseLinkHeader from './parse-link-header.js';
 const [major, minor] = process.versions.node.split('.').map(v => Number(v));
 function validateSearchParameters(searchParameters) {
@@ -162,7 +164,9 @@ const defaultInternals = {
             const parsed = parseLinkHeader(rawLinkHeader);
             const next = parsed.find(entry => entry.parameters.rel === 'next' || entry.parameters.rel === '"next"');
             if (next) {
-                return { url: next.reference };
+                return {
+                    url: new URL(next.reference, response.url),
+                };
             }
             return false;
         },
@@ -200,7 +204,7 @@ const cloneInternals = (internals) => {
             beforeRetry: [...hooks.beforeRetry],
             afterResponse: [...hooks.afterResponse],
         },
-        searchParameters: internals.searchParams ? new URLSearchParams(internals.searchParams) : undefined,
+        searchParams: internals.searchParams ? new URLSearchParams(internals.searchParams) : undefined,
         pagination: { ...internals.pagination },
     };
     if (result.url !== undefined) {
@@ -208,6 +212,71 @@ const cloneInternals = (internals) => {
     }
     return result;
 };
+const cloneRaw = (raw) => {
+    const { hooks, retry } = raw;
+    const result = { ...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;
+};
 const getHttp2TimeoutOption = (internals) => {
     const delays = [internals.timeout.socket, internals.timeout.connect, internals.timeout.lookup, internals.timeout.request, internals.timeout.secureConnect].filter(delay => typeof delay === 'number');
     if (delays.length > 0) {
@@ -313,19 +382,9 @@ export default class Options {
             }
             return;
         }
+        options = cloneRaw(options);
         init(this, options, this);
         init(options, options, this);
-        // This is way much faster than cloning ^_^
-        Object.freeze(options);
-        Object.freeze(options.hooks);
-        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.hooks);
-        Object.freeze(options.context);
         this._merging = true;
         // Always merge `isStream` first
         if ('isStream' in options) {
@@ -539,7 +598,7 @@ export default class Options {
 
     __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` / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
+    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`.
     */
@@ -547,7 +606,7 @@ export default class Options {
         return this._internals.body;
     }
     set body(value) {
-        assert.any([is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, is.undefined], value);
+        assert.any([is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, isFormDataLike, is.undefined], value);
         if (is.nodeStream(value)) {
             assert.truthy(value.readable);
         }
@@ -607,10 +666,10 @@ export default class Options {
     @example
     ```
     await got('https://example.com/?query=a b'); //=> https://example.com/?query=a%20b
-    await got('https://example.com/', {searchParameters: {query: 'a b'}}); //=> https://example.com/?query=a+b
+    await got('https://example.com/', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
 
-    // The query string is overridden by `searchParameters`
-    await got('https://example.com/?query=a b', {searchParameters: {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() {
@@ -719,11 +778,11 @@ export default class Options {
     ```
     import got from 'got';
 
-    const searchParameters = new URLSearchParams([['key', 'a'], ['key', 'b']]);
+    const searchParams = new URLSearchParams([['key', 'a'], ['key', 'b']]);
 
-    await got('https://example.com', {searchParameters});
+    await got('https://example.com', {searchParams});
 
-    console.log(searchParameters.toString());
+    console.log(searchParams.toString());
     //=> 'key=a&key=b'
     ```
     */
@@ -731,6 +790,9 @@ export default class Options {
         if (this._internals.url) {
             return this._internals.url.searchParams;
         }
+        if (this._internals.searchParams === undefined) {
+            this._internals.searchParams = new URLSearchParams();
+        }
         return this._internals.searchParams;
     }
     set searchParams(value) {
@@ -743,11 +805,14 @@ export default class Options {
             }
             return;
         }
-        let searchParameters = (this.searchParams ?? new URLSearchParams());
+        const searchParameters = this.searchParams;
         let updated;
-        if (is.string(value) || (value instanceof URLSearchParams)) {
+        if (is.string(value)) {
             updated = new URLSearchParams(value);
         }
+        else if (value instanceof URLSearchParams) {
+            updated = value;
+        }
         else {
             validateSearchParameters(value);
             updated = new URLSearchParams();
@@ -757,21 +822,27 @@ export default class Options {
                 if (entry === null) {
                     updated.append(key, '');
                 }
-                else if (entry !== undefined) {
+                else if (entry === undefined) {
+                    searchParameters.delete(key);
+                }
+                else {
                     updated.append(key, entry);
                 }
             }
         }
         if (this._merging) {
-            // eslint-disable-next-line unicorn/no-array-for-each
-            updated.forEach((value, key) => {
-                searchParameters.set(key, value);
-            });
+            // 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 {
-            searchParameters = updated;
+        else if (url) {
+            url.search = searchParameters.toString();
         }
-        if (!url) {
+        else {
             this._internals.searchParams = searchParameters;
         }
     }
@@ -870,24 +941,27 @@ export default class Options {
             if (!(knownHookEvent in this._internals.hooks)) {
                 throw new Error(`Unexpected hook event: ${knownHookEvent}`);
             }
-            const hooks = value[knownHookEvent];
+            const typedKnownHookEvent = knownHookEvent;
+            const typedValue = value;
+            const hooks = typedValue[typedKnownHookEvent];
             assert.any([is.array, is.undefined], hooks);
-            for (const hook of hooks) {
-                assert.function_(hook);
+            if (hooks) {
+                for (const hook of hooks) {
+                    assert.function_(hook);
+                }
             }
             if (this._merging) {
                 if (hooks) {
                     // @ts-expect-error FIXME
-                    this._internals.hooks[knownHookEvent].push(...hooks);
+                    this._internals.hooks[typedKnownHookEvent].push(...hooks);
                 }
             }
-            else if (hooks) {
-                // @ts-expect-error FIXME
-                this._internals.hooks[knownHookEvent] = [...hooks];
-            }
             else {
+                if (!hooks) {
+                    throw new Error(`Missing hook event: ${knownHookEvent}`);
+                }
                 // @ts-expect-error FIXME
-                this._internals.hooks[knownHookEvent] = [];
+                this._internals.hooks[knownHookEvent] = [...hooks];
             }
         }
     }
@@ -961,36 +1035,34 @@ export default class Options {
     }
     get username() {
         const url = this._internals.url;
-        if (url) {
-            return url.username;
-        }
-        return this._internals.username;
+        const value = url ? url.username : this._internals.username;
+        return decodeURIComponent(value);
     }
     set username(value) {
         assert.string(value);
         const url = this._internals.url;
+        const fixedValue = encodeURIComponent(value);
         if (url) {
-            url.username = value;
+            url.username = fixedValue;
         }
         else {
-            this._internals.username = value;
+            this._internals.username = fixedValue;
         }
     }
     get password() {
         const url = this._internals.url;
-        if (url) {
-            return url.password;
-        }
-        return this._internals.password;
+        const value = url ? url.password : this._internals.password;
+        return decodeURIComponent(value);
     }
     set password(value) {
         assert.string(value);
         const url = this._internals.url;
+        const fixedValue = encodeURIComponent(value);
         if (url) {
-            url.password = value;
+            url.password = fixedValue;
         }
         else {
-            this._internals.password = value;
+            this._internals.password = fixedValue;
         }
     }
     /**
@@ -1426,6 +1498,7 @@ export default class Options {
         assert.any([is.number, is.undefined], value);
         this._internals.maxHeaderSize = value;
     }
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     toJSON() {
         return { ...this._internals };
     }
@@ -1454,6 +1527,8 @@ export default class Options {
             ...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,
@@ -1495,6 +1570,9 @@ export default class Options {
     }
     getFallbackRequestFunction() {
         const url = this._internals.url;
+        if (!url) {
+            return;
+        }
         if (url.protocol === 'https:') {
             if (this._internals.http2) {
                 if (major < 15 || (major === 15 && minor < 10)) {
@@ -1512,53 +1590,21 @@ export default class Options {
         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.hooks);
+        Object.freeze(options.retry.errorCodes);
+        Object.freeze(options.retry.methods);
+        Object.freeze(options.retry.statusCodes);
         Object.freeze(options.context);
     }
 }
-// It's user responsibility to make sensitive data in `context` non-enumerable
-const nonEnumerableProperties = new Set([
-    // Functions
-    'constructor',
-    'merge',
-    'tryMerge',
-    'createNativeRequestOptions',
-    'getRequestFunction',
-    'getFallbackRequestFunction',
-    'freeze',
-    // Payload
-    'body',
-    'form',
-    'json',
-    // Getters that always throw
-    'auth',
-    'followRedirects',
-    'searchParameters',
-    // May contain sensitive data
-    'username',
-    'password',
-    'headers',
-    'searchParams',
-    'url',
-    // Privates
-    '_unixOptions',
-    '_internals',
-    '_merging',
-    '_init',
-]);
-// We want all the properties to be enumerable, so people instead doing
-// `util.inspect(options, {getters: true, showHidden: true})`
-// can do just `util.inspect(options, {getters: true})`.
-const propertyDescriptors = {};
-const keys = Object.getOwnPropertyNames(Options.prototype).filter(property => !nonEnumerableProperties.has(property));
-const makeEnumerable = { enumerable: true };
-for (const key of keys) {
-    propertyDescriptors[key] = makeEnumerable;
-}
-Object.defineProperties(Options.prototype, propertyDescriptors);

package/dist/source/core/response.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" />
+import type { Buffer } from 'node:buffer';
+import type { URL } from 'node:url';
 import type { IncomingMessageWithTimings, Timings } from '@szmarczak/http-timer';
 import { RequestError } from './errors.js';
 import type { ParseJsonFunction, ResponseType } from './options.js';

package/dist/source/core/response.js

@@ -28,12 +28,12 @@ export const parseBody = (response, responseType, parseJson, encoding) => {
         if (responseType === 'buffer') {
             return rawBody;
         }
-        throw new ParseError({
-            message: `Unknown body type '${responseType}'`,
-            name: 'Error',
-        }, response);
     }
     catch (error) {
         throw new ParseError(error, response);
     }
+    throw new ParseError({
+        message: `Unknown body type '${responseType}'`,
+        name: 'Error',
+    }, response);
 };

package/dist/source/core/timed-out.d.ts

@@ -1,4 +1,4 @@
-import { ClientRequest } from 'http';
+import { ClientRequest } from 'node:http';
 declare const reentry: unique symbol;
 interface TimedOutOptions {
     host?: string;

package/dist/source/core/timed-out.js

@@ -1,4 +1,4 @@
-import net from 'net';
+import net from 'node:net';
 import unhandler from './utils/unhandle.js';
 const reentry = Symbol('reentry');
 const noop = () => { };

package/dist/source/core/utils/get-body-size.d.ts

@@ -1,3 +1,3 @@
 /// <reference types="node" />
-import { ClientRequestArgs } from 'http';
+import { ClientRequestArgs } from 'node:http';
 export default function getBodySize(body: unknown, headers: ClientRequestArgs['headers']): Promise<number | undefined>;

package/dist/source/core/utils/get-body-size.js

@@ -1,4 +1,5 @@
-import { promisify } from 'util';
+import { Buffer } from 'node:buffer';
+import { promisify } from 'node:util';
 import is from '@sindresorhus/is';
 import isFormData from './is-form-data.js';
 export default async function getBodySize(body, headers) {

package/dist/source/core/utils/is-client-request.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { Writable, Readable } from 'stream';
-import type { ClientRequest } from 'http';
+import type { Writable, Readable } from 'node:stream';
+import type { ClientRequest } from 'node:http';
 declare function isClientRequest(clientRequest: Writable | Readable): clientRequest is ClientRequest;
 export default isClientRequest;

package/dist/source/core/utils/is-form-data.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Readable } from 'stream';
+import { Readable } from 'node:stream';
 interface FormData extends Readable {
     getBoundary: () => string;
     getLength: (callback: (error: Error | null, length: number) => void) => void;

package/dist/source/core/utils/options-to-url.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { URL } from 'url';
+import { URL } from 'node:url';
 export interface URLOptions {
     href?: string;
     protocol?: string;

package/dist/source/core/utils/options-to-url.js

@@ -1,5 +1,5 @@
 /* istanbul ignore file: deprecated */
-import { URL } from 'url';
+import { URL } from 'node:url';
 const keys = [
     'protocol',
     'host',

package/dist/source/core/utils/proxy-events.d.ts

@@ -1,3 +1,3 @@
 /// <reference types="node" />
-import { EventEmitter } from 'events';
-export default function proxyEvents(from: EventEmitter, to: EventEmitter, events: string[]): () => void;
+import { EventEmitter } from 'node:events';
+export default function proxyEvents(from: EventEmitter, to: EventEmitter, events: Readonly<string[]>): () => void;

package/dist/source/core/utils/unhandle.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 declare type Origin = EventEmitter;
 declare type Event = string | symbol;
 declare type Fn = (...args: any[]) => void;

package/dist/source/core/utils/url-to-options.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { URL, UrlWithStringQuery } from 'url';
+import { URL, UrlWithStringQuery } from 'node:url';
 export interface LegacyUrlOptions {
     protocol: string;
     hostname: string;

package/dist/source/create.js

@@ -6,7 +6,7 @@ import Options from './core/options.js';
 const delay = async (ms) => new Promise(resolve => {
     setTimeout(resolve, ms);
 });
-const isGotInstance = (value) => ('defaults' in value && 'options' in value.defaults);
+const isGotInstance = (value) => is.function_(value);
 const aliases = [
     'get',
     'post',
@@ -146,6 +146,7 @@ const create = (defaults) => {
             }
             else {
                 normalizedOptions.merge(optionsToMerge);
+                assert.any([is.urlInstance, is.undefined], optionsToMerge.url);
                 if (optionsToMerge.url !== undefined) {
                     normalizedOptions.prefixUrl = '';
                     normalizedOptions.url = optionsToMerge.url;

package/dist/source/types.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
-import type { URL } from 'url';
+import type { Buffer } from 'node:buffer';
+import type { URL } from 'node:url';
 import type { CancelableRequest } from './as-promise/types.js';
 import type { Response } from './core/response.js';
 import type Options from './core/options.js';
-import type { PaginationOptions, OptionsInit, InternalsType } from './core/options.js';
+import type { PaginationOptions, OptionsInit } from './core/options.js';
 import type Request from './core/index.js';
 declare type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>;
 declare type Merge<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
@@ -14,7 +15,7 @@ export interface InstanceDefaults {
     /**
     An object containing the default options of Got.
     */
-    options: InternalsType | Options;
+    options: Options;
     /**
     An array of functions. You execute them directly by calling `got()`.
     They are some sort of "global hooks" - these functions are called first.