rekwest 7.2.7 → 8.1.0

package/src/redirects.js

@@ -1,86 +1,86 @@
-import http2 from 'node:http2';
-import { isReadable } from 'node:stream';
-import {
-  requestCredentials,
-  requestRedirect,
-} from './constants.js';
-import { RequestError } from './errors.js';
-import rekwest from './index.js';
-import {
-  isPipeStream,
-  sameOrigin,
-} from './utils.js';
-
-const {
-  HTTP2_HEADER_LOCATION,
-  HTTP2_METHOD_GET,
-  HTTP2_METHOD_HEAD,
-  HTTP2_METHOD_POST,
-  HTTP_STATUS_FOUND,
-  HTTP_STATUS_MOVED_PERMANENTLY,
-  HTTP_STATUS_PERMANENT_REDIRECT,
-  HTTP_STATUS_SEE_OTHER,
-  HTTP_STATUS_TEMPORARY_REDIRECT,
-} = http2.constants;
-
-export const redirects = (res, options) => {
-  const {
-    allowDowngrade,
-    credentials,
-    follow,
-    redirect,
-    url,
-  } = options;
-
-  if (follow && /3\d{2}/.test(res.statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
-    if (redirect === requestRedirect.error) {
-      throw new RequestError(`Unexpected redirect, redirect mode is set to: ${ redirect }`);
-    }
-
-    if (redirect === requestRedirect.follow) {
-      const loc = new URL(res.headers[HTTP2_HEADER_LOCATION], url);
-
-      if (!/^https?:/i.test(loc.protocol)) {
-        throw new RequestError('URL scheme must be "http" or "https"');
-      }
-
-      if (!allowDowngrade && loc.protocol === 'http:' && url.protocol === 'https:') {
-        throw new RequestError(
-          `Protocol downgrade detected, redirect from "${ url.protocol }" to "${ loc.protocol }": ${ loc }`,
-        );
-      }
-
-      if (!sameOrigin(loc, url)) {
-        if (credentials !== requestCredentials.include) {
-          options.credentials = requestCredentials.omit;
-        }
-
-        options.h2 = false;
-      }
-
-      if ([
-        HTTP_STATUS_PERMANENT_REDIRECT,
-        HTTP_STATUS_TEMPORARY_REDIRECT,
-      ].includes(res.statusCode) && isPipeStream(options.body) && !isReadable(options.body)) {
-        throw new RequestError(`Unable to ${ redirect } redirect with streamable body`);
-      }
-
-      if (([
-        HTTP_STATUS_MOVED_PERMANENTLY,
-        HTTP_STATUS_FOUND,
-      ].includes(res.statusCode) && options.method === HTTP2_METHOD_POST)
-      || (res.statusCode === HTTP_STATUS_SEE_OTHER && ![
-        HTTP2_METHOD_GET,
-        HTTP2_METHOD_HEAD,
-      ].includes(options.method))) {
-        options.body = null;
-        options.method = HTTP2_METHOD_GET;
-      }
-
-      options.follow--;
-      options.redirected = true;
-
-      return rekwest(loc, options);
-    }
-  }
-};
+import http2 from 'node:http2';
+import { isReadable } from 'node:stream';
+import {
+  requestCredentials,
+  requestRedirect,
+} from './constants.js';
+import { RequestError } from './errors.js';
+import rekwest from './index.js';
+import {
+  isPipeStream,
+  sameOrigin,
+} from './utils.js';
+
+const {
+  HTTP2_HEADER_LOCATION,
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD,
+  HTTP2_METHOD_POST,
+  HTTP_STATUS_FOUND,
+  HTTP_STATUS_MOVED_PERMANENTLY,
+  HTTP_STATUS_PERMANENT_REDIRECT,
+  HTTP_STATUS_SEE_OTHER,
+  HTTP_STATUS_TEMPORARY_REDIRECT,
+} = http2.constants;
+
+export const redirects = (res, options) => {
+  const {
+    allowDowngrade,
+    credentials,
+    follow,
+    redirect,
+    url,
+  } = options;
+
+  if (follow && /3\d{2}/.test(res.statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
+    if (redirect === requestRedirect.error) {
+      throw new RequestError(`Unexpected redirect, redirect mode is set to: ${ redirect }`);
+    }
+
+    if (redirect === requestRedirect.follow) {
+      const loc = new URL(res.headers[HTTP2_HEADER_LOCATION], url);
+
+      if (!/^https?:/i.test(loc.protocol)) {
+        throw new RequestError('URL scheme must be "http" or "https"');
+      }
+
+      if (!allowDowngrade && loc.protocol === 'http:' && url.protocol === 'https:') {
+        throw new RequestError(
+          `Protocol downgrade detected, redirect from "${ url.protocol }" to "${ loc.protocol }": ${ loc }`,
+        );
+      }
+
+      if (!sameOrigin(loc, url)) {
+        if (credentials !== requestCredentials.include) {
+          options.credentials = requestCredentials.omit;
+        }
+
+        options.h2 = false;
+      }
+
+      if ([
+        HTTP_STATUS_PERMANENT_REDIRECT,
+        HTTP_STATUS_TEMPORARY_REDIRECT,
+      ].includes(res.statusCode) && isPipeStream(options.body) && !isReadable(options.body)) {
+        throw new RequestError(`Unable to ${ redirect } redirect with streamable body`);
+      }
+
+      if (([
+        HTTP_STATUS_MOVED_PERMANENTLY,
+        HTTP_STATUS_FOUND,
+      ].includes(res.statusCode) && options.method === HTTP2_METHOD_POST)
+      || (res.statusCode === HTTP_STATUS_SEE_OTHER && ![
+        HTTP2_METHOD_GET,
+        HTTP2_METHOD_HEAD,
+      ].includes(options.method))) {
+        options.body = null;
+        options.method = HTTP2_METHOD_GET;
+      }
+
+      options.follow--;
+      options.redirected = true;
+
+      return rekwest(loc, options);
+    }
+  }
+};

package/src/transfer.js

@@ -1,106 +1,104 @@
-import http from 'node:http';
-import http2 from 'node:http2';
-import https from 'node:https';
-import { ackn } from './ackn.js';
-import { RequestError } from './errors.js';
-import { postflight } from './postflight.js';
-import { preflight } from './preflight.js';
-import { retries } from './retries.js';
-import { transform } from './transform.js';
-import {
-  deepMerge,
-  dispatch,
-  isLikelyH2cPrefaceError,
-  snoop,
-} from './utils.js';
-
-export const transfer = async (options) => {
-  const { digest, redirected, thenable, url } = options;
-
-  if (options.follow === 0) {
-    throw new RequestError(`Maximum redirect reached at: ${ url.href }`);
-  }
-
-  if (url.protocol === 'https:') {
-    options = !options.h2 ? await ackn(options) : {
-      ...options, createConnection: null, protocol: url.protocol,
-    };
-  } else if (Reflect.has(options, 'alpnProtocol')) {
-    for (const it of [
-      'alpnProtocol',
-      'createConnection',
-      'h2',
-      'protocol',
-    ]) { Reflect.deleteProperty(options, it); }
-  }
-
-  try {
-    options = await transform(preflight(options));
-  } catch (err) {
-    options.createConnection?.().destroy();
-    throw err;
-  }
-
-  const promise = new Promise((resolve, reject) => {
-    let client, req;
-
-    if (options.h2) {
-      client = http2.connect(url.origin, options);
-      req = client.request(options.headers, options);
-    } else {
-      const { request } = url.protocol === 'http:' ? http : https;
-
-      req = request(url, options);
-    }
-
-    snoop(client, req, options, { reject });
-
-    req.once('response', (res) => postflight(req, res, options, {
-      reject, resolve,
-    }));
-
-    dispatch(req, options);
-  });
-
-  try {
-    const res = await promise;
-
-    if (digest && !redirected) {
-      res.body = await res.body();
-    }
-
-    return res;
-  } catch (err) {
-    if (isLikelyH2cPrefaceError(err)) {
-      const { retry } = options;
-
-      options = deepMerge(options, {
-        h2: true,
-        retry: {
-          attempts: ++retry.attempts,
-          errorCodes: [
-            err.code,
-            ...retry.errorCodes,
-          ],
-          interval: 1,
-        },
-      });
-    }
-
-    const result = retries(err, options);
-
-    if (result) {
-      return result;
-    }
-
-    if (digest && !redirected && err.body) {
-      err.body = await err.body();
-    }
-
-    if (!thenable) {
-      throw err;
-    } else {
-      return err;
-    }
-  }
-};
+import http from 'node:http';
+import http2 from 'node:http2';
+import https from 'node:https';
+import { ackn } from './ackn.js';
+import { RequestError } from './errors.js';
+import { postflight } from './postflight.js';
+import { preflight } from './preflight.js';
+import { retries } from './retries.js';
+import { transform } from './transform.js';
+import {
+  deepMerge,
+  dispatch,
+  isLikelyH2cPrefaceError,
+  snoop,
+} from './utils.js';
+
+export const transfer = async (options) => {
+  const { digest, redirected, thenable, url } = options;
+
+  if (options.follow === 0) {
+    throw new RequestError(`Maximum redirect reached at: ${ url.href }`);
+  }
+
+  if (url.protocol === 'https:') {
+    options = await ackn(options);
+  } else if (Reflect.has(options, 'alpnProtocol')) {
+    for (const it of [
+      'alpnProtocol',
+      'createConnection',
+      'h2',
+      'protocol',
+    ]) { Reflect.deleteProperty(options, it); }
+  }
+
+  try {
+    options = await transform(preflight(options));
+  } catch (err) {
+    options.createConnection?.().destroy();
+    throw err;
+  }
+
+  const promise = new Promise((resolve, reject) => {
+    let client, req;
+
+    if (options.h2) {
+      client = http2.connect(url.origin, options);
+      req = client.request(options.headers, options);
+    } else {
+      const { request } = url.protocol === 'http:' ? http : https;
+
+      req = request(url, options);
+    }
+
+    snoop(client, req, options, { reject });
+
+    req.once('response', (res) => postflight(req, res, options, {
+      reject, resolve,
+    }));
+
+    dispatch(req, options);
+  });
+
+  try {
+    const res = await promise;
+
+    if (digest && !redirected) {
+      res.body = await res.body();
+    }
+
+    return res;
+  } catch (err) {
+    if (isLikelyH2cPrefaceError(err)) {
+      const { retry } = options;
+
+      options = deepMerge(options, {
+        h2: true,
+        retry: {
+          attempts: ++retry.attempts,
+          errorCodes: [
+            err.code,
+            ...retry.errorCodes,
+          ],
+          interval: 1,
+        },
+      });
+    }
+
+    const result = retries(err, options);
+
+    if (result) {
+      return result;
+    }
+
+    if (digest && !redirected && err.body) {
+      err.body = await err.body();
+    }
+
+    if (!thenable) {
+      throw err;
+    } else {
+      return err;
+    }
+  }
+};

package/src/transform.js

@@ -1,112 +1,112 @@
-import http2 from 'node:http2';
-import {
-  isReadable,
-  Readable,
-} from 'node:stream';
-import { buffer } from 'node:stream/consumers';
-import { types } from 'node:util';
-import { encode } from './codecs.js';
-import {
-  fdToAsyncIterable,
-  isFormData,
-} from './formdata.js';
-import {
-  APPLICATION_FORM_URLENCODED,
-  APPLICATION_JSON,
-  APPLICATION_OCTET_STREAM,
-} from './mediatypes.js';
-import {
-  isBlobLike,
-  isReadableStream,
-} from './utils.js';
-
-const {
-  HTTP2_HEADER_CONTENT_ENCODING,
-  HTTP2_HEADER_CONTENT_LENGTH,
-  HTTP2_HEADER_CONTENT_TYPE,
-} = http2.constants;
-
-export const transform = async (options) => {
-  let { body, headers } = options;
-
-  if (!body) {
-    return options;
-  }
-
-  if (!Buffer.isBuffer(body)) {
-    switch (true) {
-      case isBlobLike(body): {
-        headers = {
-          [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
-          [HTTP2_HEADER_CONTENT_TYPE]: body.type || APPLICATION_OCTET_STREAM,
-        };
-        body = body.stream();
-        break;
-      }
-
-      case isFormData(body): {
-        body = fdToAsyncIterable(body);
-        headers = { [HTTP2_HEADER_CONTENT_TYPE]: body.contentType };
-        break;
-      }
-
-      case types.isAnyArrayBuffer(body): {
-        body = Buffer.from(body);
-        break;
-      }
-
-      case types.isArrayBufferView(body): {
-        body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
-        break;
-      }
-
-      case Object(body) === body && !Reflect.has(body, Symbol.asyncIterator): {
-        if (body.constructor === URLSearchParams) {
-          headers = { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_FORM_URLENCODED };
-          body = body.toString();
-        } else if (!(!Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
-          headers = { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_JSON };
-          body = JSON.stringify(body);
-        }
-
-        break;
-      }
-
-      default:
-        break;
-    }
-  }
-
-  const encodings = options.headers[HTTP2_HEADER_CONTENT_ENCODING];
-
-  if (Object(body) === body
-    && (Reflect.has(body, Symbol.asyncIterator) || (!Array.isArray(body) && Reflect.has(body, Symbol.iterator)))) {
-    body = isReadable(body) ? (isReadableStream(body) ? Readable.fromWeb(body) : body) : Readable.from(body);
-    body = encodings ? encode(body, encodings, options) : body;
-  } else if (encodings) {
-    body = await buffer(encode(Readable.from(body), encodings, options));
-  }
-
-  if (options.bufferBody && Object(body) === body) {
-    if (isReadable(body)) {
-      body = await buffer(body);
-    } else if (Reflect.has(body, Symbol.asyncIterator)) {
-      body = await buffer(body);
-    }
-  }
-
-  Object.assign(options.headers, {
-    ...headers,
-    ...!body[Symbol.asyncIterator] && {
-      [HTTP2_HEADER_CONTENT_LENGTH]: Buffer.byteLength(body),
-    },
-    ...options.headers[HTTP2_HEADER_CONTENT_TYPE] && {
-      [HTTP2_HEADER_CONTENT_TYPE]: options.headers[HTTP2_HEADER_CONTENT_TYPE],
-    },
-  });
-
-  return {
-    ...options,
-    body,
-  };
-};
+import http2 from 'node:http2';
+import {
+  isReadable,
+  Readable,
+} from 'node:stream';
+import { buffer } from 'node:stream/consumers';
+import { types } from 'node:util';
+import { encode } from './codecs.js';
+import {
+  fdToAsyncIterable,
+  isFormData,
+} from './formdata.js';
+import {
+  APPLICATION_FORM_URLENCODED,
+  APPLICATION_JSON,
+  APPLICATION_OCTET_STREAM,
+} from './mediatypes.js';
+import {
+  isBlobLike,
+  isReadableStream,
+} from './utils.js';
+
+const {
+  HTTP2_HEADER_CONTENT_ENCODING,
+  HTTP2_HEADER_CONTENT_LENGTH,
+  HTTP2_HEADER_CONTENT_TYPE,
+} = http2.constants;
+
+export const transform = async (options) => {
+  let { body, headers } = options;
+
+  if (!body) {
+    return options;
+  }
+
+  if (!Buffer.isBuffer(body)) {
+    switch (true) {
+      case isBlobLike(body): {
+        headers = {
+          [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
+          [HTTP2_HEADER_CONTENT_TYPE]: body.type || APPLICATION_OCTET_STREAM,
+        };
+        body = body.stream();
+        break;
+      }
+
+      case isFormData(body): {
+        body = fdToAsyncIterable(body);
+        headers = { [HTTP2_HEADER_CONTENT_TYPE]: body.contentType };
+        break;
+      }
+
+      case types.isAnyArrayBuffer(body): {
+        body = Buffer.from(body);
+        break;
+      }
+
+      case types.isArrayBufferView(body): {
+        body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+        break;
+      }
+
+      case Object(body) === body && !Reflect.has(body, Symbol.asyncIterator): {
+        if (body.constructor === URLSearchParams) {
+          headers = { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_FORM_URLENCODED };
+          body = body.toString();
+        } else if (!(!Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
+          headers = { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_JSON };
+          body = JSON.stringify(body);
+        }
+
+        break;
+      }
+
+      default:
+        break;
+    }
+  }
+
+  const encodings = options.headers[HTTP2_HEADER_CONTENT_ENCODING];
+
+  if (Object(body) === body
+    && (Reflect.has(body, Symbol.asyncIterator) || (!Array.isArray(body) && Reflect.has(body, Symbol.iterator)))) {
+    body = isReadable(body) ? (isReadableStream(body) ? Readable.fromWeb(body) : body) : Readable.from(body);
+    body = encodings ? encode(body, encodings, options) : body;
+  } else if (encodings) {
+    body = await buffer(encode(Readable.from(body), encodings, options));
+  }
+
+  if (options.bufferBody && Object(body) === body) {
+    if (isReadable(body)) {
+      body = await buffer(body);
+    } else if (Reflect.has(body, Symbol.asyncIterator)) {
+      body = await buffer(body);
+    }
+  }
+
+  Object.assign(options.headers, {
+    ...headers,
+    ...!body[Symbol.asyncIterator] && {
+      [HTTP2_HEADER_CONTENT_LENGTH]: Buffer.byteLength(body),
+    },
+    ...options.headers[HTTP2_HEADER_CONTENT_TYPE] && {
+      [HTTP2_HEADER_CONTENT_TYPE]: options.headers[HTTP2_HEADER_CONTENT_TYPE],
+    },
+  });
+
+  return {
+    ...options,
+    body,
+  };
+};