rekwest 6.2.1 → 7.0.1

package/src/utils.js

@@ -0,0 +1,187 @@
+import {
+  Blob,
+  File,
+} from 'node:buffer';
+import http2 from 'node:http2';
+import {
+  isReadable,
+  Readable,
+} from 'node:stream';
+import config, { isZstdSupported } from './config.js';
+import { TimeoutError } from './errors.js';
+
+const {
+  HTTP2_HEADER_ACCEPT_ENCODING,
+  HTTP2_HEADER_STATUS,
+} = http2.constants;
+
+export const augment = (res, headers, options) => {
+  const { h2 } = options;
+
+  if (h2) {
+    Reflect.defineProperty(res, 'headers', {
+      enumerable: true,
+      value: headers,
+    });
+
+    Reflect.defineProperty(res, 'httpVersion', {
+      enumerable: true,
+      value: `${ h2 + 1 }.0`,
+    });
+
+    Reflect.defineProperty(res, 'statusCode', {
+      enumerable: true,
+      value: headers[HTTP2_HEADER_STATUS],
+    });
+  }
+
+  Reflect.defineProperty(res, 'ok', {
+    enumerable: true,
+    value: /^2\d{2}$/.test(res.statusCode),
+  });
+
+  Reflect.defineProperty(res, 'redirected', {
+    enumerable: true,
+    value: !!options.redirected,
+  });
+};
+
+export const brandCheck = (value, ctor) => {
+  if (!(value instanceof ctor)) {
+    throw new TypeError('Illegal invocation.');
+  }
+};
+
+export const copyWithMerge = (target, ...rest) => {
+  target = structuredClone(target);
+  if (!rest.length) {
+    return target;
+  }
+
+  return merge(target, ...rest);
+};
+
+export const dispatch = (req, { body }) => {
+  if (isReadable(body)) {
+    body.pipe(req);
+  } else {
+    req.end(body);
+  }
+};
+
+export const isFileLike = (value) => {
+  return [
+    Blob,
+    File,
+  ].some((it) => value instanceof it);
+};
+
+export const isPipeStream = (value) => {
+  return value instanceof Readable;
+};
+
+export const isReadableStream = (value) => {
+  return value instanceof ReadableStream;
+};
+
+export const merge = (target, ...rest) => {
+  rest = rest.filter((it) => Object(it) === it);
+  for (const source of rest) {
+    for (const key of Object.getOwnPropertyNames(source)) {
+      const sv = source[key];
+      const tv = target[key];
+
+      if (Object(sv) === sv && Object(tv) === tv) {
+        target[key] = merge(tv, sv);
+        continue;
+      }
+
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+};
+
+export const normalize = (url, options = {}) => {
+  if (!options.redirected) {
+    options = copyWithMerge(config.defaults, options);
+  }
+
+  if (options.trimTrailingSlashes) {
+    url = `${ url }`.replace(/(?<!:)\/+/g, '/');
+  }
+
+  if (options.stripTrailingSlash) {
+    url = `${ url }`.replace(/\/$|\/(?=#)|\/(?=\?)/g, '');
+  }
+
+  return Object.assign(options, {
+    headers: normalizeHeaders(options.headers),
+    method: options.method.toUpperCase(),
+    url: new URL(url, options.baseURL),
+  });
+};
+
+export const normalizeHeaders = (headers) => {
+  const collector = {};
+
+  for (const [key, value] of Object.entries(headers ?? {})) {
+    const name = key.toLowerCase();
+
+    collector[key] = value;
+
+    if (key === HTTP2_HEADER_ACCEPT_ENCODING && !isZstdSupported) {
+      const stripped = value.replace(/\s?zstd,?/gi, '').trim();
+
+      if (stripped) {
+        collector[key] = stripped;
+      } else {
+        Reflect.deleteProperty(collector, name);
+      }
+    }
+  }
+
+  return collector;
+};
+
+export const sameOrigin = (a, b) => a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port;
+
+export const snoop = (client, req, options) => {
+  req.once('close', () => client?.close());
+  req.once('end', () => client?.close());
+  req.once('timeout', () => req.destroy(new TimeoutError(`Timed out after ${ options.timeout } ms.`)));
+  req.once('trailers', (trailers) => {
+    Reflect.defineProperty(req, 'trailers', {
+      enumerable: true,
+      value: trailers,
+    });
+  });
+};
+
+export const stripHeaders = (headers = {}, names = []) => {
+  names = new Set(names);
+
+  return Object.fromEntries(
+    Object.entries(headers).filter(
+      ([key]) => !names.has(key.toLowerCase()),
+    ),
+  );
+};
+
+export async function* tap(value) {
+  if (Reflect.has(value, Symbol.asyncIterator)) {
+    yield* value;
+  } else if (value.stream) {
+    yield* value.stream();
+  } else {
+    yield await value.arrayBuffer();
+  }
+}
+
+export const toCamelCase = (str) => str?.toLowerCase().replace(
+  /\p{Punctuation}.|\p{White_Space}./gu,
+  (val) => val.replace(/\p{Punctuation}+|\p{White_Space}+/gu, '').toUpperCase(),
+);
+
+export const unwind = (encodings) => encodings.split(',').map((it) => it.toLowerCase().trim());

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

@@ -1,33 +1,33 @@
-import http2 from 'node:http2';
-import {
-  requestCredentials,
-  requestRedirect,
-} from './constants.mjs';
-
-const {
-  HTTP2_METHOD_GET,
-  HTTP2_METHOD_HEAD,
-} = http2.constants;
-
-export 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(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(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;
-};
+import http2 from 'node:http2';
+import {
+  requestCredentials,
+  requestRedirect,
+} from './constants.js';
+
+const {
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD,
+} = http2.constants;
+
+export 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(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(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;
+};

package/dist/postflight.js

@@ -1,117 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: 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 _mixin = require("./mixin");
-var _utils = require("./utils");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const {
-  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)) {
-      const cookie = new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options);
-      _cookies.Cookies.jar.get(url.origin).forEach((val, key) => {
-        if (!cookie.has(key)) {
-          cookie.set(key, val);
-        }
-      });
-      _cookies.Cookies.jar.set(url.origin, cookie);
-    } else {
-      _cookies.Cookies.jar.set(url.origin, new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options));
-    }
-  }
-  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)) {
-        if (credentials !== _constants.requestCredentials.include) {
-          options.credentials = _constants.requestCredentials.omit;
-        }
-        options.h2 = false;
-      }
-      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.`));
-      }
-      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)) {
-        for (const it of Object.keys(options.headers).filter(val => /^content-/i.test(val))) {
-          Reflect.deleteProperty(options.headers, it);
-        }
-        options.body = null;
-        options.method = HTTP2_METHOD_GET;
-      }
-      options.follow--;
-      options.redirected = true;
-      options.url = location;
-      if (statusCode === HTTP_STATUS_MOVED_PERMANENTLY && res.headers[HTTP2_HEADER_RETRY_AFTER]) {
-        let interval = res.headers[HTTP2_HEADER_RETRY_AFTER];
-        interval = Number(interval) * 1e3 || new Date(interval) - Date.now();
-        if (interval > options.maxRetryAfter) {
-          return res.emit('error', (0, _utils.maxRetryAfterError)(interval, {
-            cause: (0, _mixin.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, _mixin.mixin)(res, options));
-  }
-  resolve((0, _mixin.mixin)(res, options));
-};
-exports.postflight = postflight;

package/dist/transform.js

@@ -1,79 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transform = void 0;
-var _nodeHttp = _interopRequireDefault(require("node:http2"));
-var _nodeStream = require("node:stream");
-var _consumers = require("node:stream/consumers");
-var _nodeUtil = require("node:util");
-var _formdata = require("./formdata");
-var _mediatypes = require("./mediatypes");
-var _utils = require("./utils");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const {
-  HTTP2_HEADER_CONTENT_ENCODING,
-  HTTP2_HEADER_CONTENT_LENGTH,
-  HTTP2_HEADER_CONTENT_TYPE
-} = _nodeHttp.default.constants;
-const transform = async options => {
-  let {
-    body,
-    headers
-  } = options;
-  if (!body) {
-    return options;
-  }
-  if ((0, _utils.isFileLike)(body)) {
-    headers = {
-      [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
-      [HTTP2_HEADER_CONTENT_TYPE]: body.type || _mediatypes.APPLICATION_OCTET_STREAM
-    };
-    body = body.stream();
-  } else if (_formdata.FormData.alike(body)) {
-    body = _formdata.FormData.actuate(body);
-    headers = {
-      [HTTP2_HEADER_CONTENT_TYPE]: body.contentType
-    };
-  } else if (!Buffer.isBuffer(body)) {
-    if (_nodeUtil.types.isAnyArrayBuffer(body)) {
-      body = Buffer.from(body);
-    } else if (_nodeUtil.types.isArrayBufferView(body)) {
-      body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
-    } else if (body === Object(body) && !Reflect.has(body, Symbol.asyncIterator)) {
-      if (body.constructor === URLSearchParams) {
-        headers = {
-          [HTTP2_HEADER_CONTENT_TYPE]: _mediatypes.APPLICATION_FORM_URLENCODED
-        };
-        body = body.toString();
-      } else if (!(!Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
-        headers = {
-          [HTTP2_HEADER_CONTENT_TYPE]: _mediatypes.APPLICATION_JSON
-        };
-        body = JSON.stringify(body);
-      }
-    }
-  }
-  const encodings = options.headers[HTTP2_HEADER_CONTENT_ENCODING];
-  if (body === Object(body) && (Reflect.has(body, Symbol.asyncIterator) || !Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
-    body = (0, _nodeStream.isReadable)(body) ? (0, _utils.isReadableStream)(body) ? _nodeStream.Readable.fromWeb(body) : body : _nodeStream.Readable.from(body);
-    body = encodings ? (0, _utils.compress)(body, encodings, options) : body;
-  } else if (encodings) {
-    body = await (0, _consumers.buffer)((0, _utils.compress)(_nodeStream.Readable.from(body), encodings, options));
-  }
-  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
-  };
-};
-exports.transform = transform;

package/src/postflight.mjs

@@ -1,136 +0,0 @@
-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 { mixin } from './mixin.mjs';
-import {
-  admix,
-  maxRetryAfterError,
-  sameOrigin,
-} from './utils.mjs';
-
-const {
-  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)) {
-      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 { 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)) {
-        if (credentials !== requestCredentials.include) {
-          options.credentials = requestCredentials.omit;
-        }
-
-        options.h2 = false;
-      }
-
-      if (statusCode !== HTTP_STATUS_SEE_OTHER && options.body?.pipe?.constructor === Function) {
-        return res.emit('error', new RequestError(`Unable to ${ redirect } redirect with streamable body.`));
-      }
-
-      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))) {
-        for (const it of Object.keys(options.headers).filter((val) => /^content-/i.test(val))) {
-          Reflect.deleteProperty(options.headers, it);
-        }
-
-        options.body = null;
-        options.method = HTTP2_METHOD_GET;
-      }
-
-      options.follow--;
-      options.redirected = true;
-      options.url = location;
-
-      if (statusCode === HTTP_STATUS_MOVED_PERMANENTLY && res.headers[HTTP2_HEADER_RETRY_AFTER]) {
-        let interval = res.headers[HTTP2_HEADER_RETRY_AFTER];
-
-        interval = Number(interval) * 1e3 || 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/transfer.mjs

@@ -1,121 +0,0 @@
-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 { RequestError } from './errors.mjs';
-import { postflight } from './postflight.mjs';
-import { preflight } from './preflight.mjs';
-import { transform } from './transform.mjs';
-import {
-  affix,
-  dispatch,
-  maxRetryAfterError,
-} from './utils.mjs';
-
-const {
-  HTTP2_HEADER_RETRY_AFTER,
-} = http2.constants;
-
-export const transfer = async (options, overact) => {
-  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);
-    }
-
-    affix(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(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 > 0) {
-      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 = Number(interval) * 1e3 || new Date(interval) - Date.now();
-          if (interval > maxRetryAfter) {
-            throw maxRetryAfterError(interval, { 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(() => overact(url, options));
-      }
-    }
-
-    if (digest && !redirected && ex.body) {
-      ex.body = await ex.body();
-    }
-
-    if (!thenable) {
-      throw ex;
-    } else {
-      return ex;
-    }
-  }
-};