rekwest 6.2.1 → 7.0.1

package/src/postflight.js

@@ -0,0 +1,56 @@
+import http2 from 'node:http2';
+import { Cookies } from './cookies.js';
+import { mixin } from './mixin.js';
+import { redirects } from './redirects.js';
+import { augment } from './utils.js';
+
+const {
+  HTTP2_HEADER_SET_COOKIE,
+  HTTP_STATUS_BAD_REQUEST,
+} = http2.constants;
+
+export const postflight = (req, res, options, { reject, resolve }) => {
+  const { cookies, h2, url } = options;
+  let headers;
+
+  if (h2) {
+    headers = res;
+    res = req;
+  } else {
+    res.once('error', reject);
+  }
+
+  augment(res, headers, options);
+
+  if (cookies !== false && res.headers[HTTP2_HEADER_SET_COOKIE]) {
+    if (Cookies.jar.has(url.origin)) {
+      const cookie = new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options);
+
+      Cookies.jar.get(url.origin).forEach((val, key) => {
+        if (!cookie.has(key)) {
+          cookie.set(key, val);
+        }
+      });
+      Cookies.jar.set(url.origin, cookie);
+    } else {
+      Cookies.jar.set(url.origin, new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options));
+    }
+  }
+
+  Reflect.defineProperty(res, 'cookies', {
+    enumerable: true,
+    value: cookies !== false && Cookies.jar.has(url.origin) ? Cookies.jar.get(url.origin) : void 0,
+  });
+
+  const willRedirect = redirects(res, options);
+
+  if (Object(willRedirect) === willRedirect) {
+    return willRedirect.then(resolve, reject);
+  }
+
+  if (res.statusCode >= HTTP_STATUS_BAD_REQUEST) {
+    return reject(mixin(res, options));
+  }
+
+  resolve(mixin(res, options));
+};

package/src/{preflight.mjs → preflight.js}

@@ -1,91 +1,84 @@
-import http2 from 'node:http2';
-import { isZstdSupported } from './config.mjs';
-import { requestCredentials } from './constants.mjs';
-import { Cookies } from './cookies.mjs';
-
-const {
-  HTTP2_HEADER_ACCEPT_ENCODING,
-  HTTP2_HEADER_AUTHORITY,
-  HTTP2_HEADER_AUTHORIZATION,
-  HTTP2_HEADER_COOKIE,
-  HTTP2_HEADER_METHOD,
-  HTTP2_HEADER_PATH,
-  HTTP2_HEADER_SCHEME,
-  HTTP2_METHOD_GET,
-  HTTP2_METHOD_HEAD,
-} = http2.constants;
-
-export const preflight = (options) => {
-  const { cookies, credentials, h2, headers, method, url } = options;
-
-  if (h2) {
-    options.endStream = [
-      HTTP2_METHOD_GET,
-      HTTP2_METHOD_HEAD,
-    ].includes(method);
-  }
-
-  if (cookies !== false && credentials !== requestCredentials.omit) {
-    let cookie = Cookies.jar.has(url.origin);
-
-    if (cookies === Object(cookies) && [
-      requestCredentials.include,
-      requestCredentials.sameOrigin,
-    ].includes(credentials)) {
-      if (cookie) {
-        cookie = new Cookies(cookies, options);
-
-        Cookies.jar.get(url.origin).forEach((val, key) => {
-          if (!cookie.has(key)) {
-            cookie.set(key, val);
-          }
-        });
-        Cookies.jar.set(url.origin, cookie);
-      } else {
-        cookie = new Cookies(cookies, options);
-        Cookies.jar.set(url.origin, cookie);
-      }
-    } else {
-      cookie &&= Cookies.jar.get(url.origin);
-    }
-
-    options.headers = {
-      ...cookie && { [HTTP2_HEADER_COOKIE]: cookie },
-      ...headers,
-    };
-  }
-
-  if (credentials === requestCredentials.omit) {
-    options.cookies = false;
-    for (const it of Object.keys(options.headers ?? {})
-                           .filter((val) => new RegExp(`^(${
-                              HTTP2_HEADER_AUTHORIZATION }|${ HTTP2_HEADER_COOKIE
-                            })$`, 'i').test(val))) { Reflect.deleteProperty(options.headers, it); }
-
-    url.password = url.username = '';
-  }
-
-  options.headers = {
-    ...Object.entries(options.headers ?? {})
-             .reduce((acc, [key, val]) => {
-               acc[key.toLowerCase()] = val;
-
-               if (acc[HTTP2_HEADER_ACCEPT_ENCODING]?.match(/\bzstd\b/i) && !isZstdSupported) {
-                 acc[HTTP2_HEADER_ACCEPT_ENCODING] = val.replace(/\s?zstd,?/gi, '').trim();
-                 if (!acc[HTTP2_HEADER_ACCEPT_ENCODING]) {
-                   Reflect.deleteProperty(acc, HTTP2_HEADER_ACCEPT_ENCODING);
-                 }
-               }
-
-               return acc;
-             }, {}),
-    ...h2 && {
-      [HTTP2_HEADER_AUTHORITY]: url.host,
-      [HTTP2_HEADER_METHOD]: method,
-      [HTTP2_HEADER_PATH]: `${ url.pathname }${ url.search }`,
-      [HTTP2_HEADER_SCHEME]: url.protocol.replace(/\p{Punctuation}/gu, ''),
-    },
-  };
-
-  return options;
-};
+import http2 from 'node:http2';
+import { requestCredentials } from './constants.js';
+import { Cookies } from './cookies.js';
+import { stripHeaders } from './utils.js';
+
+const {
+  HTTP2_HEADER_AUTHORITY,
+  HTTP2_HEADER_AUTHORIZATION,
+  HTTP2_HEADER_COOKIE,
+  HTTP2_HEADER_METHOD,
+  HTTP2_HEADER_PATH,
+  HTTP2_HEADER_SCHEME,
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD,
+} = http2.constants;
+
+export const preflight = (options) => {
+  let { cookies, credentials, h2, headers, method, url } = options;
+
+  if (h2) {
+    options.endStream = [
+      HTTP2_METHOD_GET,
+      HTTP2_METHOD_HEAD,
+    ].includes(method);
+  } else {
+    headers = stripHeaders(headers, [
+      HTTP2_HEADER_AUTHORITY,
+      HTTP2_HEADER_METHOD,
+      HTTP2_HEADER_PATH,
+      HTTP2_HEADER_SCHEME,
+    ]);
+  }
+
+  if (credentials === requestCredentials.omit) {
+    headers = stripHeaders(headers, [
+      HTTP2_HEADER_AUTHORIZATION,
+      HTTP2_HEADER_COOKIE,
+    ]);
+    options.cookies = false;
+    url.password = url.username = '';
+  }
+
+  if (cookies !== false && credentials !== requestCredentials.omit) {
+    let cookie = Cookies.jar.has(url.origin);
+
+    if (Object(cookies) === cookies && [
+      requestCredentials.include,
+      requestCredentials.sameOrigin,
+    ].includes(credentials)) {
+      if (cookie) {
+        cookie = new Cookies(cookies, options);
+
+        Cookies.jar.get(url.origin).forEach((val, key) => {
+          if (!cookie.has(key)) {
+            cookie.set(key, val);
+          }
+        });
+        Cookies.jar.set(url.origin, cookie);
+      } else {
+        cookie = new Cookies(cookies, options);
+        Cookies.jar.set(url.origin, cookie);
+      }
+    } else {
+      cookie &&= Cookies.jar.get(url.origin);
+    }
+
+    options.headers = {
+      ...cookie && { [HTTP2_HEADER_COOKIE]: cookie },
+      ...headers,
+    };
+  }
+
+  options.headers = {
+    ...headers,
+    ...h2 && {
+      [HTTP2_HEADER_AUTHORITY]: url.host,
+      [HTTP2_HEADER_METHOD]: method,
+      [HTTP2_HEADER_PATH]: `${ url.pathname }${ url.search }`,
+      [HTTP2_HEADER_SCHEME]: url.protocol.replace(/\p{Punctuation}/gu, ''),
+    },
+  };
+
+  return options;
+};

package/src/redirects.js

@@ -0,0 +1,79 @@
+import http2 from 'node:http2';
+import { isReadable } from 'node:stream';
+import {
+  requestCredentials,
+  requestRedirect,
+  requestRedirectCodes,
+} 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 { credentials, follow, redirect, url } = options;
+
+  if (follow && /3\d{2}/.test(res.statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
+    if (!requestRedirectCodes.includes(res.statusCode)) {
+      return res.emit('error', new RangeError(`Invalid status code: ${ res.statusCode }`));
+    }
+
+    if (redirect === requestRedirect.error) {
+      return res.emit('error', new RequestError(`Unexpected redirect, redirect mode is set to '${ redirect }'.`));
+    }
+
+    if (redirect === requestRedirect.follow) {
+      const location = new URL(res.headers[HTTP2_HEADER_LOCATION], url);
+
+      if (!/^https?:/i.test(location.protocol)) {
+        return res.emit('error', new RequestError('URL scheme must be "http" or "https".'));
+      }
+
+      if (!sameOrigin(location, 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)) {
+        return res.emit('error', 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(location, options);
+    }
+  }
+};

package/src/retries.js

@@ -0,0 +1,51 @@
+import http2 from 'node:http2';
+import { isReadable } from 'node:stream';
+import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
+import { RequestError } from './errors.js';
+import rekwest from './index.js';
+import { isPipeStream } from './utils.js';
+
+const {
+  HTTP2_HEADER_RETRY_AFTER,
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD,
+} = http2.constants;
+
+export const retries = (ex, options) => {
+  const { body, maxRetryAfter, method, retry, url } = options;
+
+  if (retry?.attempts > 0) {
+    if (![
+      HTTP2_METHOD_GET,
+      HTTP2_METHOD_HEAD,
+    ].includes(method) && isPipeStream(body) && !isReadable(body)) {
+      throw new RequestError('Request stream already read.', { cause: ex });
+    }
+
+    if (retry.errorCodes?.includes(ex.code) || retry.statusCodes?.includes(ex.statusCode)) {
+      let { interval } = retry;
+
+      if (retry.retryAfter && ex.headers?.[HTTP2_HEADER_RETRY_AFTER]) {
+        interval = ex.headers[HTTP2_HEADER_RETRY_AFTER];
+        interval = Math.abs(Number(interval) * 1e3 || new Date(interval) - Date.now()) || 0;
+        if (interval > maxRetryAfter) {
+          throw new RequestError(
+            `Maximum '${ HTTP2_HEADER_RETRY_AFTER }' limit exceeded: ${ interval } ms.`,
+            { cause: ex },
+          );
+        }
+      } else {
+        interval = new Function('interval', `return Math.ceil(${ retry.backoffStrategy });`)(interval);
+      }
+
+      if (interval < 0) {
+        interval = 0;
+      }
+
+      retry.attempts--;
+      retry.interval = interval;
+
+      return setTimeoutPromise(interval).then(() => rekwest(url, options));
+    }
+  }
+};

package/src/transfer.js

@@ -0,0 +1,92 @@
+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 {
+  dispatch,
+  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 (ex) {
+    options.createConnection?.().destroy();
+    throw ex;
+  }
+
+  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);
+
+    req.once('aborted', reject);
+    req.once('error', reject);
+    req.once('frameError', reject);
+    req.once('goaway', 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 (ex) {
+    const willRetry = retries(ex, options);
+
+    if (willRetry) {
+      return willRetry;
+    }
+
+    if (digest && !redirected && ex.body) {
+      ex.body = await ex.body();
+    }
+
+    if (!thenable) {
+      throw ex;
+    } else {
+      return ex;
+    }
+  }
+};

package/src/transform.js

@@ -0,0 +1,109 @@
+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 { FormData } from './formdata.js';
+import {
+  APPLICATION_FORM_URLENCODED,
+  APPLICATION_JSON,
+  APPLICATION_OCTET_STREAM,
+} from './mediatypes.js';
+import {
+  isFileLike,
+  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 isFileLike(body): {
+        headers = {
+          [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
+          [HTTP2_HEADER_CONTENT_TYPE]: body.type || APPLICATION_OCTET_STREAM,
+        };
+        body = body.stream();
+        break;
+      }
+
+      case FormData.alike(body): {
+        body = FormData.actuate(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,
+  };
+};