rekwest 4.0.0 → 4.2.0

package/src/index.mjs

@@ -1,282 +1,84 @@
-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 { Cookies } from './cookies.mjs';
-import { RequestError } from './errors.mjs';
-import { APPLICATION_OCTET_STREAM } from './mediatypes.mjs';
-import {
-  admix,
-  affix,
-  dispatch,
-  merge,
-  mixin,
-  preflight,
-  redirects,
-  sanitize,
-  transform,
-} from './utils.mjs';
-
-export { constants } from 'node:http2';
-
-export * from './ackn.mjs';
-export * from './cookies.mjs';
-export * from './errors.mjs';
-export * from './file.mjs';
-export * from './formdata.mjs';
-export * as mediatypes from './mediatypes.mjs';
-export * from './utils.mjs';
-
-const {
-  HTTP2_HEADER_CONTENT_LENGTH,
-  HTTP2_HEADER_CONTENT_TYPE,
-  HTTP2_HEADER_LOCATION,
-  HTTP2_HEADER_RETRY_AFTER,
-  HTTP2_HEADER_SET_COOKIE,
-  HTTP2_METHOD_GET,
-  HTTP2_METHOD_HEAD,
-  HTTP_STATUS_BAD_REQUEST,
-  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) {
-  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,
-      });
-
-      if (follow && /^3\d{2}$/.test(res.statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
-        if (redirect === redirects.error) {
-          return res.emit('error', new RequestError(`Unexpected redirect, redirect mode is set to '${ redirect }'.`));
-        }
-
-        if (redirect === redirects.follow) {
-          options.url = new URL(res.headers[HTTP2_HEADER_LOCATION], url).href;
-
-          if (res.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 (res.statusCode === HTTP_STATUS_SEE_OTHER) {
-            Reflect.deleteProperty(options.headers, HTTP2_HEADER_CONTENT_LENGTH);
-            options.method = HTTP2_METHOD_GET;
-            options.body = null;
-          }
-
-          Reflect.set(options, 'redirected', true);
-
-          if (res.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 (res.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;
-    }
-  }
-}
-
-Reflect.defineProperty(rekwest, 'stream', {
-  enumerable: true,
-  value(...args) {
-    const options = preflight({
-      ...merge(rekwest.defaults, {
-        headers: { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_OCTET_STREAM },
-      }, sanitize(...args)),
-      redirect: redirects.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 {
-      req = request(url, options);
-    }
-
-    affix(client, req, options);
-    req.once('response', (res) => {
-      let headers;
-
-      if (h2) {
-        headers = res;
-        res = req;
-      }
-
-      admix(res, headers, options);
-    });
-
-    return req;
-  },
-});
-
-Reflect.defineProperty(rekwest, 'defaults', {
-  enumerable: true,
-  get() { return defaults; },
-  set(value) { defaults = merge(defaults, value); },
-});
+import http from 'node:http';
+import http2 from 'node:http2';
+import https from 'node:https';
+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,
+  merge,
+  sanitize,
+  transfer,
+  validation,
+} from './utils.mjs';
+
+export { constants } from 'node:http2';
+
+export * from './ackn.mjs';
+export * from './constants.mjs';
+export * from './cookies.mjs';
+export * from './errors.mjs';
+export * from './file.mjs';
+export * from './formdata.mjs';
+export * as mediatypes from './mediatypes.mjs';
+export * from './utils.mjs';
+
+const {
+  HTTP2_HEADER_CONTENT_TYPE,
+} = http2.constants;
+
+export default function rekwest(...args) {
+  let options = sanitize(...args);
+
+  if (!options.redirected) {
+    options = merge(rekwest.defaults, options);
+  }
+
+  return transfer(validation(options));
+}
+
+Reflect.defineProperty(rekwest, 'stream', {
+  enumerable: true,
+  value(...args) {
+    const options = preflight({
+      ...validation(merge(rekwest.defaults, {
+        headers: { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_OCTET_STREAM },
+      }, 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 {
+      req = request(url, options);
+    }
+
+    affix(client, req, options);
+
+    req.once('response', (res) => {
+      let headers;
+
+      if (h2) {
+        headers = res;
+        res = req;
+      }
+
+      admix(res, headers, options);
+    });
+
+    return req;
+  },
+});
+
+Reflect.defineProperty(rekwest, 'defaults', {
+  enumerable: true,
+  get() { return defaults.stash; },
+  set(value) { defaults.stash = merge(defaults.stash, value); },
+});

package/src/postflight.mjs

@@ -0,0 +1,135 @@
+import http2 from 'node:http2';
+import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
+import {
+  requestCredentials,
+  requestRedirect,
+  requestRedirectCodes,
+} from './constants.mjs';
+import { Cookies } from './cookies.mjs';
+import { RequestError } from './errors.mjs';
+import rekwest from './index.mjs';
+import {
+  admix,
+  maxRetryAfterError,
+  mixin,
+  sameOrigin,
+} from './utils.mjs';
+
+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,
+} = http2.constants;
+
+export 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);
+  }
+
+  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 (!requestRedirectCodes.includes(statusCode)) {
+      return res.emit('error', new RangeError(`Invalid status code: ${ 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) && [
+        requestCredentials.omit,
+        requestCredentials.sameOrigin,
+      ].includes(credentials)) {
+        Reflect.deleteProperty(options.headers, HTTP2_HEADER_AUTHORIZATION);
+        location.password = location.username = '';
+        if (credentials === requestCredentials.omit) {
+          options.cookies = false;
+        }
+      }
+
+      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) && 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', 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));
+};

package/src/preflight.mjs

@@ -0,0 +1,70 @@
+import http2 from 'node:http2';
+import { requestCredentials } from './constants.mjs';
+import { Cookies } from './cookies.mjs';
+import {
+  APPLICATION_JSON,
+  TEXT_PLAIN,
+  WILDCARD,
+} from './mediatypes.mjs';
+
+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,
+} = http2.constants;
+
+export 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.jar.get(url.origin);
+
+    if (cookies === Object(cookies) && [
+      requestCredentials.include,
+      requestCredentials.sameOrigin,
+    ].includes(credentials)) {
+      if (cookie) {
+        new Cookies(cookies).forEach(function (val, key) {
+          this.set(key, val);
+        }, cookie);
+      } else {
+        cookie = new Cookies(cookies);
+        Cookies.jar.set(url.origin, cookie);
+      }
+    }
+
+    options.headers = {
+      ...cookie && { [HTTP2_HEADER_COOKIE]: cookie },
+      ...headers,
+    };
+  }
+
+  options.h2 ??= h2;
+  options.headers = {
+    [HTTP2_HEADER_ACCEPT]: `${ APPLICATION_JSON }, ${ TEXT_PLAIN }, ${ 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;
+};