rekwest 4.1.0 → 4.2.0

package/dist/index.js

@@ -12,14 +12,6 @@ var _nodeHttp = _interopRequireDefault(require("node:http"));
 var _nodeHttp2 = _interopRequireWildcard(require("node:http2"));
 exports.constants = _nodeHttp2.constants;
 var _nodeHttps = _interopRequireDefault(require("node:https"));
-var _promises = require("node:timers/promises");
-var _ackn = require("./ackn");
-Object.keys(_ackn).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _ackn[key]) return;
-  exports[key] = _ackn[key];
-});
 var _constants = require("./constants");
 Object.keys(_constants).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -27,6 +19,24 @@ Object.keys(_constants).forEach(function (key) {
   if (key in exports && exports[key] === _constants[key]) return;
   exports[key] = _constants[key];
 });
+var _defaults = _interopRequireDefault(require("./defaults"));
+var _mediatypes = _interopRequireWildcard(require("./mediatypes"));
+exports.mediatypes = _mediatypes;
+var _preflight = require("./preflight");
+var _utils = require("./utils");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  exports[key] = _utils[key];
+});
+var _ackn = require("./ackn");
+Object.keys(_ackn).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ackn[key]) return;
+  exports[key] = _ackn[key];
+});
 var _cookies = require("./cookies");
 Object.keys(_cookies).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -41,15 +51,6 @@ Object.keys(_errors).forEach(function (key) {
   if (key in exports && exports[key] === _errors[key]) return;
   exports[key] = _errors[key];
 });
-var _mediatypes = _interopRequireWildcard(require("./mediatypes"));
-exports.mediatypes = _mediatypes;
-var _utils = require("./utils");
-Object.keys(_utils).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _utils[key]) return;
-  exports[key] = _utils[key];
-});
 var _file = require("./file");
 Object.keys(_file).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -68,207 +69,25 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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_HEADER_CONTENT_TYPE
 } = _nodeHttp2.default.constants;
-const maxRetryAfter = Symbol('maxRetryAfter');
-const maxRetryAfterError = (interval, options) => new _errors.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
-};
-async function rekwest(...args) {
+function rekwest(...args) {
   let options = (0, _utils.sanitize)(...args);
-  const {
-    url
-  } = options;
   if (!options.redirected) {
     options = (0, _utils.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 _errors.RequestError(`Maximum redirect reached at: ${url.href}`);
-  }
-  if (url.protocol === 'https:') {
-    options = await (0, _ackn.ackn)(options);
-  } else if (Reflect.has(options, 'alpnProtocol')) {
-    ['alpnProtocol', 'createConnection', 'h2', 'protocol'].forEach(it => Reflect.deleteProperty(options, it));
-  }
-  options = await (0, _utils.transform)((0, _utils.preflight)(options));
-  const {
-    cookies,
-    digest,
-    follow,
-    h2,
-    redirect,
-    redirected,
-    thenable
-  } = options;
-  const {
-    request
-  } = url.protocol === 'http:' ? _nodeHttp.default : _nodeHttps.default;
-  const promise = new Promise((resolve, reject) => {
-    let client, req;
-    if (h2) {
-      client = _nodeHttp2.default.connect(url.origin, options);
-      req = client.request(options.headers, options);
-    } else {
-      req = request(url, options);
-    }
-    (0, _utils.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);
-      }
-      (0, _utils.admix)(res, headers, options);
-      if (cookies !== false && res.headers[HTTP2_HEADER_SET_COOKIE]) {
-        if (_cookies.Cookies.jar.has(url.origin)) {
-          new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]).forEach(function (val, key) {
-            this.set(key, val);
-          }, _cookies.Cookies.jar.get(url.origin));
-        } else {
-          _cookies.Cookies.jar.set(url.origin, new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]));
-        }
-      }
-      Reflect.defineProperty(res, 'cookies', {
-        enumerable: true,
-        value: cookies !== false && _cookies.Cookies.jar.has(url.origin) ? _cookies.Cookies.jar.get(url.origin) : void 0
-      });
-      const {
-        statusCode
-      } = res;
-      if (follow && /3\d{2}/.test(statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
-        if (!_constants.redirectStatusCodes.includes(statusCode)) {
-          return res.emit('error', new RangeError(`Invalid status code: ${statusCode}`));
-        }
-        if (redirect === _constants.redirectModes.error) {
-          return res.emit('error', new _errors.RequestError(`Unexpected redirect, redirect mode is set to '${redirect}'.`));
-        }
-        if (redirect === _constants.redirectModes.follow) {
-          const location = new URL(res.headers[HTTP2_HEADER_LOCATION], url);
-          if (!/^https?:/.test(location.protocol)) {
-            return res.emit('error', new _errors.RequestError('URL scheme must be "http" or "https".'));
-          }
-          if (!(0, _utils.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 _errors.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: (0, _utils.mixin)(res, options)
-              }));
-            }
-            return (0, _promises.setTimeout)(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((0, _utils.mixin)(res, options));
-      }
-      resolve((0, _utils.mixin)(res, options));
-    });
-    (0, _utils.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(() => rekwest(url, options));
-    }
-    if (digest && !redirected && ex.body) {
-      ex.body = await ex.body();
-    }
-    if (!thenable) {
-      throw ex;
-    } else {
-      return ex;
-    }
-  }
+  return (0, _utils.transfer)((0, _utils.validation)(options));
 }
 Reflect.defineProperty(rekwest, 'stream', {
   enumerable: true,
   value(...args) {
-    const options = (0, _utils.preflight)({
-      ...(0, _utils.merge)(rekwest.defaults, {
+    const options = (0, _preflight.preflight)({
+      ...(0, _utils.validation)((0, _utils.merge)(rekwest.defaults, {
         headers: {
           [HTTP2_HEADER_CONTENT_TYPE]: _mediatypes.APPLICATION_OCTET_STREAM
         }
-      }, (0, _utils.sanitize)(...args)),
-      redirect: _constants.redirectModes.manual
+      }, (0, _utils.sanitize)(...args))),
+      redirect: _constants.requestRedirect.manual
     });
     const {
       h2,
@@ -299,9 +118,9 @@ Reflect.defineProperty(rekwest, 'stream', {
 Reflect.defineProperty(rekwest, 'defaults', {
   enumerable: true,
   get() {
-    return defaults;
+    return _defaults.default.stash;
   },
   set(value) {
-    defaults = (0, _utils.merge)(defaults, value);
+    _defaults.default.stash = (0, _utils.merge)(_defaults.default.stash, value);
   }
 });

package/dist/postflight.js

@@ -0,0 +1,110 @@
+"use strict";
+
+exports.__esModule = true;
+exports.postflight = void 0;
+var _nodeHttp = _interopRequireDefault(require("node:http2"));
+var _promises = require("node:timers/promises");
+var _constants = require("./constants");
+var _cookies = require("./cookies");
+var _errors = require("./errors");
+var _index = _interopRequireDefault(require("./index"));
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  HTTP2_HEADER_AUTHORIZATION,
+  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
+} = _nodeHttp.default.constants;
+const postflight = (req, res, options, {
+  reject,
+  resolve
+}) => {
+  const {
+    cookies,
+    credentials,
+    follow,
+    h2,
+    redirect,
+    url
+  } = options;
+  let headers;
+  if (h2) {
+    headers = res;
+    res = req;
+  } else {
+    res.once('error', reject);
+  }
+  (0, _utils.admix)(res, headers, options);
+  if (cookies !== false && res.headers[HTTP2_HEADER_SET_COOKIE]) {
+    if (_cookies.Cookies.jar.has(url.origin)) {
+      new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]).forEach(function (val, key) {
+        this.set(key, val);
+      }, _cookies.Cookies.jar.get(url.origin));
+    } else {
+      _cookies.Cookies.jar.set(url.origin, new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]));
+    }
+  }
+  Reflect.defineProperty(res, 'cookies', {
+    enumerable: true,
+    value: cookies !== false && _cookies.Cookies.jar.has(url.origin) ? _cookies.Cookies.jar.get(url.origin) : void 0
+  });
+  const {
+    statusCode
+  } = res;
+  if (follow && /3\d{2}/.test(statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
+    if (!_constants.requestRedirectCodes.includes(statusCode)) {
+      return res.emit('error', new RangeError(`Invalid status code: ${statusCode}`));
+    }
+    if (redirect === _constants.requestRedirect.error) {
+      return res.emit('error', new _errors.RequestError(`Unexpected redirect, redirect mode is set to '${redirect}'.`));
+    }
+    if (redirect === _constants.requestRedirect.follow) {
+      const location = new URL(res.headers[HTTP2_HEADER_LOCATION], url);
+      if (!/^https?:/i.test(location.protocol)) {
+        return res.emit('error', new _errors.RequestError('URL scheme must be "http" or "https".'));
+      }
+      if (!(0, _utils.sameOrigin)(location, url) && [_constants.requestCredentials.omit, _constants.requestCredentials.sameOrigin].includes(credentials)) {
+        Reflect.deleteProperty(options.headers, HTTP2_HEADER_AUTHORIZATION);
+        location.password = location.username = '';
+        if (credentials === _constants.requestCredentials.omit) {
+          options.cookies = false;
+        }
+      }
+      options.url = location;
+      if (statusCode !== HTTP_STATUS_SEE_OTHER && options.body?.pipe?.constructor === Function) {
+        return res.emit('error', new _errors.RequestError(`Unable to ${redirect} redirect with streamable body.`));
+      }
+      options.follow--;
+      if ([HTTP_STATUS_MOVED_PERMANENTLY, HTTP_STATUS_FOUND].includes(statusCode) && options.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', (0, _utils.maxRetryAfterError)(interval, {
+            cause: (0, _utils.mixin)(res, options)
+          }));
+        }
+        return (0, _promises.setTimeout)(interval).then(() => (0, _index.default)(options.url, options).then(resolve, reject));
+      }
+      return (0, _index.default)(options.url, options).then(resolve, reject);
+    }
+  }
+  if (statusCode >= HTTP_STATUS_BAD_REQUEST) {
+    return reject((0, _utils.mixin)(res, options));
+  }
+  resolve((0, _utils.mixin)(res, options));
+};
+exports.postflight = postflight;

package/dist/preflight.js

@@ -0,0 +1,66 @@
+"use strict";
+
+exports.__esModule = true;
+exports.preflight = void 0;
+var _nodeHttp = _interopRequireDefault(require("node:http2"));
+var _constants = require("./constants");
+var _cookies = require("./cookies");
+var _mediatypes = require("./mediatypes");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  HTTP2_HEADER_ACCEPT,
+  HTTP2_HEADER_ACCEPT_ENCODING,
+  HTTP2_HEADER_AUTHORITY,
+  HTTP2_HEADER_COOKIE,
+  HTTP2_HEADER_METHOD,
+  HTTP2_HEADER_PATH,
+  HTTP2_HEADER_SCHEME,
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD
+} = _nodeHttp.default.constants;
+const preflight = options => {
+  const {
+    cookies,
+    credentials,
+    h2 = false,
+    headers,
+    method,
+    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) && [_constants.requestCredentials.include, _constants.requestCredentials.sameOrigin].includes(credentials)) {
+      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.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, '')
+    })
+  };
+  return options;
+};
+exports.preflight = preflight;