rekwest 4.1.0 → 4.2.1

package/dist/utils.js

@@ -1,38 +1,37 @@
 "use strict";
 
 exports.__esModule = true;
-exports.sanitize = exports.sameOrigin = exports.preflight = exports.mixin = exports.merge = exports.dispatch = exports.decompress = exports.compress = exports.brandCheck = exports.affix = exports.admix = void 0;
+exports.sanitize = exports.sameOrigin = exports.mixin = exports.merge = exports.maxRetryAfterError = exports.maxRetryAfter = exports.dispatch = exports.decompress = exports.compress = exports.brandCheck = exports.affix = exports.admix = void 0;
 exports.tap = tap;
-exports.transform = void 0;
+exports.validation = exports.unwind = exports.transform = exports.transfer = void 0;
 var _nodeBuffer = require("node:buffer");
-var _nodeHttp = _interopRequireDefault(require("node:http2"));
+var _nodeHttp = _interopRequireDefault(require("node:http"));
+var _nodeHttp2 = _interopRequireDefault(require("node:http2"));
+var _nodeHttps = _interopRequireDefault(require("node:https"));
 var _nodeStream = require("node:stream");
 var _consumers = require("node:stream/consumers");
+var _promises = require("node:timers/promises");
 var _nodeUtil = require("node:util");
 var _nodeZlib = _interopRequireDefault(require("node:zlib"));
+var _ackn = require("./ackn");
 var _constants = require("./constants");
-var _cookies = require("./cookies");
 var _errors = require("./errors");
 var _file = require("./file");
 var _formdata = require("./formdata");
+var _index = _interopRequireDefault(require("./index"));
 var _mediatypes = require("./mediatypes");
+var _postflight = require("./postflight");
+var _preflight = require("./preflight");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const {
-  HTTP2_HEADER_ACCEPT,
-  HTTP2_HEADER_ACCEPT_ENCODING,
-  HTTP2_HEADER_AUTHORITY,
   HTTP2_HEADER_CONTENT_ENCODING,
   HTTP2_HEADER_CONTENT_LENGTH,
   HTTP2_HEADER_CONTENT_TYPE,
-  HTTP2_HEADER_COOKIE,
-  HTTP2_HEADER_METHOD,
-  HTTP2_HEADER_PATH,
-  HTTP2_HEADER_SCHEME,
+  HTTP2_HEADER_RETRY_AFTER,
   HTTP2_HEADER_STATUS,
   HTTP2_METHOD_GET,
   HTTP2_METHOD_HEAD
-} = _nodeHttp.default.constants;
-const unwind = encodings => encodings.split(',').map(it => it.trim());
+} = _nodeHttp2.default.constants;
 const admix = (res, headers, options) => {
   const {
     h2
@@ -126,6 +125,10 @@ const dispatch = ({
   }
 };
 exports.dispatch = dispatch;
+const maxRetryAfter = Symbol('maxRetryAfter');
+exports.maxRetryAfter = maxRetryAfter;
+const maxRetryAfterError = (interval, options) => new _errors.RequestError(`Maximum '${HTTP2_HEADER_RETRY_AFTER}' limit exceeded: ${interval} ms.`, options);
+exports.maxRetryAfterError = maxRetryAfterError;
 const merge = (target = {}, ...rest) => {
   target = JSON.parse(JSON.stringify(target));
   if (!rest.length) {
@@ -215,7 +218,7 @@ const mixin = (res, {
           if (/\bjson\b/i.test(contentType)) {
             body = JSON.parse(body.toString(charset));
           } else if (/\b(?:text|xml)\b/i.test(contentType)) {
-            if (/\b(?:latin1|ucs-2|utf-(?:8|16le))\b/.test(charset)) {
+            if (/\b(?:latin1|ucs-2|utf-(?:8|16le))\b/i.test(charset)) {
               body = body.toString(charset);
             } else {
               body = new TextDecoder(charset).decode(body);
@@ -235,66 +238,9 @@ const mixin = (res, {
   });
 };
 exports.mixin = mixin;
-const preflight = options => {
-  const {
-    cookies,
-    h2 = false,
-    headers,
-    method = HTTP2_METHOD_GET,
-    redirected,
-    url
-  } = options;
-  if (h2) {
-    options.endStream = [HTTP2_METHOD_GET, HTTP2_METHOD_HEAD].includes(method);
-  }
-  if (cookies !== false) {
-    let cookie = _cookies.Cookies.jar.get(url.origin);
-    if (cookies === Object(cookies) && !redirected) {
-      if (cookie) {
-        new _cookies.Cookies(cookies).forEach(function (val, key) {
-          this.set(key, val);
-        }, cookie);
-      } else {
-        cookie = new _cookies.Cookies(cookies);
-        _cookies.Cookies.jar.set(url.origin, cookie);
-      }
-    }
-    options.headers = {
-      ...(cookie && {
-        [HTTP2_HEADER_COOKIE]: cookie
-      }),
-      ...headers
-    };
-  }
-  options.digest ??= true;
-  options.follow ??= 20;
-  options.h2 ??= h2;
-  options.headers = {
-    [HTTP2_HEADER_ACCEPT]: `${_mediatypes.APPLICATION_JSON}, ${_mediatypes.TEXT_PLAIN}, ${_mediatypes.WILDCARD}`,
-    [HTTP2_HEADER_ACCEPT_ENCODING]: 'br, deflate, deflate-raw, gzip, identity',
-    ...Object.entries(options.headers ?? {}).reduce((acc, [key, val]) => (acc[key.toLowerCase()] = val, 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, '')
-    })
-  };
-  options.method ??= method;
-  options.parse ??= true;
-  options.redirect ??= _constants.redirectModes.follow;
-  if (!Reflect.has(_constants.redirectModes, options.redirect)) {
-    options.createConnection?.().destroy();
-    throw new TypeError(`Failed to read the 'redirect' property from 'options': The provided value '${options.redirect}' is not a valid enum value.`);
-  }
-  options.redirected ??= false;
-  options.thenable ??= false;
-  return options;
-};
-exports.preflight = preflight;
 const sanitize = (url, options = {}) => {
   if (options.trimTrailingSlashes) {
-    url = `${url}`.replace(/(?<!:)\/+/gi, '/');
+    url = `${url}`.replace(/(?<!:)\/+/g, '/');
   }
   url = new URL(url);
   return Object.assign(options, {
@@ -313,6 +259,94 @@ async function* tap(value) {
     yield await value.arrayBuffer();
   }
 }
+const transfer = async options => {
+  const {
+    digest,
+    h2,
+    redirected,
+    thenable,
+    url
+  } = options;
+  if (options.follow === 0) {
+    throw new _errors.RequestError(`Maximum redirect reached at: ${url.href}`);
+  }
+  if (url.protocol === 'https:') {
+    options = !h2 ? await (0, _ackn.ackn)(options) : {
+      ...options,
+      createConnection: null,
+      protocol: url.protocol
+    };
+  } else if (Reflect.has(options, 'alpnProtocol')) {
+    ['alpnProtocol', 'createConnection', 'h2', 'protocol'].forEach(it => Reflect.deleteProperty(options, it));
+  }
+  try {
+    options = await transform((0, _preflight.preflight)(options));
+  } catch (ex) {
+    options.createConnection?.().destroy();
+    throw ex;
+  }
+  const promise = new Promise((resolve, reject) => {
+    let client, req;
+    if (options.h2) {
+      client = _nodeHttp2.default.connect(url.origin, options);
+      req = client.request(options.headers, options);
+    } else {
+      const {
+        request
+      } = url.protocol === 'http:' ? _nodeHttp.default : _nodeHttps.default;
+      req = request(url, options);
+    }
+    affix(client, req, options);
+    req.once('error', reject);
+    req.once('frameError', reject);
+    req.once('goaway', reject);
+    req.once('response', res => (0, _postflight.postflight)(req, res, options, {
+      reject,
+      resolve
+    }));
+    dispatch(options, req);
+  });
+  try {
+    const res = await promise;
+    if (digest && !redirected) {
+      res.body = await res.body();
+    }
+    return res;
+  } catch (ex) {
+    const {
+      maxRetryAfter,
+      retry
+    } = options;
+    if (retry?.attempts && 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 = Number(interval) * 1000 || new Date(interval) - Date.now();
+        if (interval > maxRetryAfter) {
+          throw maxRetryAfterError(interval, {
+            cause: ex
+          });
+        }
+      } else {
+        interval = new Function('interval', `return Math.ceil(${retry.backoffStrategy});`)(interval);
+      }
+      retry.attempts--;
+      retry.interval = interval;
+      return (0, _promises.setTimeout)(interval).then(() => (0, _index.default)(url, options));
+    }
+    if (digest && !redirected && ex.body) {
+      ex.body = await ex.body();
+    }
+    if (!thenable) {
+      throw ex;
+    } else {
+      return ex;
+    }
+  }
+};
+exports.transfer = transfer;
 const transform = async options => {
   let {
     body,
@@ -371,4 +405,19 @@ const transform = async options => {
     body
   };
 };
-exports.transform = transform;
+exports.transform = transform;
+const unwind = encodings => encodings.split(',').map(it => it.trim());
+exports.unwind = unwind;
+const validation = (options = {}) => {
+  if (options.body && [HTTP2_METHOD_GET, HTTP2_METHOD_HEAD].includes(options.method)) {
+    throw new TypeError(`Request with ${HTTP2_METHOD_GET}/${HTTP2_METHOD_HEAD} method cannot have body.`);
+  }
+  if (!Object.values(_constants.requestCredentials).includes(options.credentials)) {
+    throw new TypeError(`Failed to read the 'credentials' property from 'options': The provided value '${options.credentials}' is not a valid enum value.`);
+  }
+  if (!Reflect.has(_constants.requestRedirect, options.redirect)) {
+    throw new TypeError(`Failed to read the 'redirect' property from 'options': The provided value '${options.redirect}' is not a valid enum value.`);
+  }
+  return options;
+};
+exports.validation = validation;

package/package.json

@@ -67,5 +67,5 @@
     "test:bail": "mocha --bail",
     "test:cover": "c8 --include=src --reporter=lcov --reporter=text npm test"
   },
-  "version": "4.1.0"
+  "version": "4.2.1"
 }

package/src/ackn.mjs

@@ -23,7 +23,7 @@ export const ackn = (options) => new Promise((resolve, reject) => {
       createConnection() {
         return socket;
       },
-      h2: /h2c?/.test(alpnProtocol),
+      h2: /h2c?/i.test(alpnProtocol),
       protocol: url.protocol,
     });
   });

package/src/constants.mjs

@@ -8,13 +8,19 @@ const {
   HTTP_STATUS_TEMPORARY_REDIRECT,
 } = http2.constants;
 
-export const redirectModes = {
+export const requestCredentials = {
+  include: 'include',
+  omit: 'omit',
+  sameOrigin: 'same-origin',
+};
+
+export const requestRedirect = {
   error: 'error',
   follow: 'follow',
   manual: 'manual',
 };
 
-export const redirectStatusCodes = [
+export const requestRedirectCodes = [
   HTTP_STATUS_MOVED_PERMANENTLY,
   HTTP_STATUS_FOUND,
   HTTP_STATUS_SEE_OTHER,

package/src/defaults.mjs

@@ -0,0 +1,44 @@
+import http2 from 'node:http2';
+import {
+  requestCredentials,
+  requestRedirect,
+} from './constants.mjs';
+import { maxRetryAfter } from './utils.mjs';
+
+const {
+  HTTP2_METHOD_GET,
+  HTTP_STATUS_SERVICE_UNAVAILABLE,
+  HTTP_STATUS_TOO_MANY_REQUESTS,
+} = http2.constants;
+
+const stash = {
+  credentials: requestCredentials.sameOrigin,
+  digest: true,
+  follow: 20,
+  get maxRetryAfter() {
+    return this[maxRetryAfter] ?? this.timeout;
+  },
+  set maxRetryAfter(value) {
+    this[maxRetryAfter] = value;
+  },
+  method: HTTP2_METHOD_GET,
+  parse: true,
+  redirect: requestRedirect.follow,
+  redirected: false,
+  retry: {
+    attempts: 0,
+    backoffStrategy: 'interval * Math.log(Math.random() * (Math.E * Math.E - Math.E) + Math.E)',
+    interval: 1e3,
+    retryAfter: true,
+    statusCodes: [
+      HTTP_STATUS_TOO_MANY_REQUESTS,
+      HTTP_STATUS_SERVICE_UNAVAILABLE,
+    ],
+  },
+  thenable: false,
+  timeout: 3e5,
+};
+
+export default {
+  stash,
+};

package/src/index.mjs

@@ -1,25 +1,17 @@
 import http from 'node:http';
 import http2 from 'node:http2';
 import https from 'node:https';
-import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
-import { ackn } from './ackn.mjs';
-import {
-  redirectModes,
-  redirectStatusCodes,
-} from './constants.mjs';
-import { Cookies } from './cookies.mjs';
-import { RequestError } from './errors.mjs';
+import { requestRedirect } from './constants.mjs';
+import defaults from './defaults.mjs';
 import { APPLICATION_OCTET_STREAM } from './mediatypes.mjs';
+import { preflight } from './preflight.mjs';
 import {
   admix,
   affix,
-  dispatch,
   merge,
-  mixin,
-  preflight,
-  sameOrigin,
   sanitize,
-  transform,
+  transfer,
+  validation,
 } from './utils.mjs';
 
 export { constants } from 'node:http2';
@@ -34,263 +26,43 @@ export * as mediatypes from './mediatypes.mjs';
 export * from './utils.mjs';
 
 const {
-  HTTP2_HEADER_AUTHORIZATION,
   HTTP2_HEADER_CONTENT_TYPE,
-  HTTP2_HEADER_LOCATION,
-  HTTP2_HEADER_RETRY_AFTER,
-  HTTP2_HEADER_SET_COOKIE,
-  HTTP2_METHOD_GET,
-  HTTP2_METHOD_HEAD,
-  HTTP2_METHOD_POST,
-  HTTP_STATUS_BAD_REQUEST,
-  HTTP_STATUS_FOUND,
-  HTTP_STATUS_MOVED_PERMANENTLY,
-  HTTP_STATUS_SEE_OTHER,
-  HTTP_STATUS_SERVICE_UNAVAILABLE,
-  HTTP_STATUS_TOO_MANY_REQUESTS,
 } = http2.constants;
 
-const maxRetryAfter = Symbol('maxRetryAfter');
-const maxRetryAfterError = (
-  interval,
-  options,
-) => new RequestError(`Maximum '${ HTTP2_HEADER_RETRY_AFTER }' limit exceeded: ${ interval } ms.`, options);
-let defaults = {
-  follow: 20,
-  get maxRetryAfter() {
-    return this[maxRetryAfter] ?? this.timeout;
-  },
-  set maxRetryAfter(value) {
-    this[maxRetryAfter] = value;
-  },
-  method: HTTP2_METHOD_GET,
-  retry: {
-    attempts: 0,
-    backoffStrategy: 'interval * Math.log(Math.random() * (Math.E * Math.E - Math.E) + Math.E)',
-    interval: 1e3,
-    retryAfter: true,
-    statusCodes: [
-      HTTP_STATUS_TOO_MANY_REQUESTS,
-      HTTP_STATUS_SERVICE_UNAVAILABLE,
-    ],
-  },
-  timeout: 3e5,
-};
-
-export default async function rekwest(...args) {
+export default function rekwest(...args) {
   let options = sanitize(...args);
-  const { url } = options;
 
   if (!options.redirected) {
     options = merge(rekwest.defaults, options);
   }
 
-  if (options.body && [
-    HTTP2_METHOD_GET,
-    HTTP2_METHOD_HEAD,
-  ].includes(options.method)) {
-    throw new TypeError(`Request with ${ HTTP2_METHOD_GET }/${ HTTP2_METHOD_HEAD } method cannot have body.`);
-  }
-
-  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')) {
-    [
-      'alpnProtocol',
-      'createConnection',
-      'h2',
-      'protocol',
-    ].forEach((it) => Reflect.deleteProperty(options, it));
-  }
-
-  options = await transform(preflight(options));
-
-  const { cookies, digest, follow, h2, redirect, redirected, thenable } = options;
-  const { request } = (url.protocol === 'http:' ? http : https);
-
-  const promise = new Promise((resolve, reject) => {
-    let client, req;
-
-    if (h2) {
-      client = http2.connect(url.origin, options);
-      req = client.request(options.headers, options);
-    } else {
-      req = request(url, options);
-    }
-
-    affix(client, req, options);
-    req.once('error', reject);
-    req.once('frameError', reject);
-    req.once('goaway', reject);
-    req.once('response', (res) => {
-      let headers;
-
-      if (h2) {
-        headers = res;
-        res = req;
-      } else {
-        res.once('error', reject);
-      }
-
-      admix(res, headers, options);
-
-      if (cookies !== false && res.headers[HTTP2_HEADER_SET_COOKIE]) {
-        if (Cookies.jar.has(url.origin)) {
-          new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]).forEach(function (val, key) {
-            this.set(key, val);
-          }, Cookies.jar.get(url.origin));
-        } else {
-          Cookies.jar.set(url.origin, new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]));
-        }
-      }
-
-      Reflect.defineProperty(res, 'cookies', {
-        enumerable: true,
-        value: cookies !== false && Cookies.jar.has(url.origin)
-               ? Cookies.jar.get(url.origin)
-               : void 0,
-      });
-
-      const { statusCode } = res;
-
-      if (follow && /3\d{2}/.test(statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
-        if (!redirectStatusCodes.includes(statusCode)) {
-          return res.emit('error', new RangeError(`Invalid status code: ${ statusCode }`));
-        }
-
-        if (redirect === redirectModes.error) {
-          return res.emit('error', new RequestError(`Unexpected redirect, redirect mode is set to '${ redirect }'.`));
-        }
-
-        if (redirect === redirectModes.follow) {
-          const location = new URL(res.headers[HTTP2_HEADER_LOCATION], url);
-
-          if (!/^https?:/.test(location.protocol)) {
-            return res.emit('error', new RequestError('URL scheme must be "http" or "https".'));
-          }
-
-          if (!sameOrigin(location, url)) {
-            Reflect.deleteProperty(options.headers, HTTP2_HEADER_AUTHORIZATION);
-            location.password = location.username = '';
-          }
-
-          options.url = location;
-
-          if (statusCode !== HTTP_STATUS_SEE_OTHER && options?.body?.pipe?.constructor === Function) {
-            return res.emit('error', new RequestError(`Unable to ${ redirect } redirect with streamable body.`));
-          }
-
-          options.follow--;
-
-          if (([
-            HTTP_STATUS_MOVED_PERMANENTLY,
-            HTTP_STATUS_FOUND,
-          ].includes(statusCode) && request.method === HTTP2_METHOD_POST) || (statusCode === HTTP_STATUS_SEE_OTHER && ![
-            HTTP2_METHOD_GET,
-            HTTP2_METHOD_HEAD,
-          ].includes(options.method))) {
-            Object.keys(options.headers).filter((it) => /^content-/i.test(it))
-                  .forEach((it) => Reflect.deleteProperty(options.headers, it));
-            options.body = null;
-            options.method = HTTP2_METHOD_GET;
-          }
-
-          Reflect.set(options, 'redirected', true);
-
-          if (statusCode === HTTP_STATUS_MOVED_PERMANENTLY && res.headers[HTTP2_HEADER_RETRY_AFTER]) {
-            let interval = res.headers[HTTP2_HEADER_RETRY_AFTER];
-
-            interval = Number(interval) * 1000 || new Date(interval) - Date.now();
-
-            if (interval > options.maxRetryAfter) {
-              return res.emit('error', maxRetryAfterError(interval, { cause: mixin(res, options) }));
-            }
-
-            return setTimeoutPromise(interval).then(() => rekwest(options.url, options).then(resolve, reject));
-          }
-
-          return rekwest(options.url, options).then(resolve, reject);
-        }
-      }
-
-      if (statusCode >= HTTP_STATUS_BAD_REQUEST) {
-        return reject(mixin(res, options));
-      }
-
-      resolve(mixin(res, options));
-    });
-
-    dispatch(options, req);
-  });
-
-  try {
-    const res = await promise;
-
-    if (digest && !redirected) {
-      res.body = await res.body();
-    }
-
-    return res;
-  } catch (ex) {
-    const { maxRetryAfter, retry } = options;
-
-    if (retry?.attempts && 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 = Number(interval) * 1000 || new Date(interval) - Date.now();
-        if (interval > maxRetryAfter) {
-          throw maxRetryAfterError(interval, { cause: ex });
-        }
-      } else {
-        interval = new Function('interval', `return Math.ceil(${ retry.backoffStrategy });`)(interval);
-      }
-
-      retry.attempts--;
-      retry.interval = interval;
-
-      return setTimeoutPromise(interval).then(() => rekwest(url, options));
-    }
-
-    if (digest && !redirected && ex.body) {
-      ex.body = await ex.body();
-    }
-
-    if (!thenable) {
-      throw ex;
-    } else {
-      return ex;
-    }
-  }
+  return transfer(validation(options));
 }
 
 Reflect.defineProperty(rekwest, 'stream', {
   enumerable: true,
   value(...args) {
     const options = preflight({
-      ...merge(rekwest.defaults, {
+      ...validation(merge(rekwest.defaults, {
         headers: { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_OCTET_STREAM },
-      }, sanitize(...args)),
-      redirect: redirectModes.manual,
+      }, sanitize(...args))),
+      redirect: requestRedirect.manual,
     });
 
     const { h2, url } = options;
-    const { request } = (url.protocol === 'http:' ? http : https);
     let client, req;
 
     if (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);
     }
 
     affix(client, req, options);
+
     req.once('response', (res) => {
       let headers;
 
@@ -308,6 +80,6 @@ Reflect.defineProperty(rekwest, 'stream', {
 
 Reflect.defineProperty(rekwest, 'defaults', {
   enumerable: true,
-  get() { return defaults; },
-  set(value) { defaults = merge(defaults, value); },
+  get() { return defaults.stash; },
+  set(value) { defaults.stash = merge(defaults.stash, value); },
 });