rekwest 4.1.0 → 4.2.0

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,92 @@ async function* tap(value) {
     yield await value.arrayBuffer();
   }
 }
+const transfer = async options => {
+  const {
+    url
+  } = options;
+  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));
+  }
+  try {
+    options = await transform((0, _preflight.preflight)(options));
+  } catch (ex) {
+    options.createConnection?.().destroy();
+    throw ex;
+  }
+  const {
+    digest,
+    h2,
+    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);
+    }
+    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 +403,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.0"
 }

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,
+};