rekwest 6.2.1 → 7.0.0

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

package/src/transform.mjs

@@ -1,82 +0,0 @@
-import http2 from 'node:http2';
-import {
-  isReadable,
-  Readable,
-} from 'node:stream';
-import { buffer } from 'node:stream/consumers';
-import { types } from 'node:util';
-import { FormData } from './formdata.mjs';
-import {
-  APPLICATION_FORM_URLENCODED,
-  APPLICATION_JSON,
-  APPLICATION_OCTET_STREAM,
-} from './mediatypes.mjs';
-import {
-  compress,
-  isFileLike,
-  isReadableStream,
-} from './utils.mjs';
-
-const {
-  HTTP2_HEADER_CONTENT_ENCODING,
-  HTTP2_HEADER_CONTENT_LENGTH,
-  HTTP2_HEADER_CONTENT_TYPE,
-} = http2.constants;
-
-export const transform = async (options) => {
-  let { body, headers } = options;
-
-  if (!body) {
-    return options;
-  }
-
-  if (isFileLike(body)) {
-    headers = {
-      [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
-      [HTTP2_HEADER_CONTENT_TYPE]: body.type || APPLICATION_OCTET_STREAM,
-    };
-    body = body.stream();
-  } else if (FormData.alike(body)) {
-    body = FormData.actuate(body);
-    headers = { [HTTP2_HEADER_CONTENT_TYPE]: body.contentType };
-  } else if (!Buffer.isBuffer(body)) {
-    if (types.isAnyArrayBuffer(body)) {
-      body = Buffer.from(body);
-    } else if (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]: APPLICATION_FORM_URLENCODED };
-        body = body.toString();
-      } else if (!(!Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
-        headers = { [HTTP2_HEADER_CONTENT_TYPE]: 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 = isReadable(body) ? (isReadableStream(body) ? Readable.fromWeb(body) : body) : Readable.from(body);
-    body = encodings ? compress(body, encodings, options) : body;
-  } else if (encodings) {
-    body = await buffer(compress(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,
-  };
-};

package/src/utils.mjs

@@ -1,205 +0,0 @@
-import {
-  Blob,
-  File,
-} from 'node:buffer';
-import http2 from 'node:http2';
-import { pipeline } from 'node:stream';
-import zlib from 'node:zlib';
-import config, { isZstdSupported } from './config.mjs';
-import {
-  RequestError,
-  TimeoutError,
-} from './errors.mjs';
-
-const {
-  HTTP2_HEADER_RETRY_AFTER,
-  HTTP2_HEADER_STATUS,
-} = http2.constants;
-
-export const admix = (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 affix = (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 brandCheck = (value, ctor) => {
-  if (!(value instanceof ctor)) {
-    throw new TypeError('Illegal invocation');
-  }
-};
-
-export const compress = (readable, encodings = '', { compression } = {}) => {
-  const encoders = [];
-
-  encodings = unwind(encodings);
-
-  for (const encoding of encodings) {
-    if (/\bbr\b/i.test(encoding)) {
-      encoders.push(zlib.createBrotliCompress(compression?.brotliOptions));
-    } else if (/\bdeflate(?!-(?:\w+)?)\b/i.test(encoding)) {
-      encoders.push(zlib.createDeflate(compression?.zlibOptions));
-    } else if (/\bdeflate-raw\b/i.test(encoding)) {
-      encoders.push(zlib.createDeflateRaw(compression?.zlibOptions));
-    } else if (/\bgzip\b/i.test(encoding)) {
-      encoders.push(zlib.createGzip(compression?.zlibOptions));
-    } else if (isZstdSupported && /\bzstd\b/i.test(encoding)) {
-      encoders.push(zlib.createZstdCompress(compression?.zstdOptions));
-    } else {
-      return readable;
-    }
-  }
-
-  return pipeline(readable, ...encoders, () => void 0);
-};
-
-export const copyWithMerge = (target, ...rest) => {
-  target = structuredClone(target);
-  if (!rest.length) {
-    return target;
-  }
-
-  return merge(target, ...rest);
-};
-
-export const decompress = (readable, encodings = '', { decompression } = {}) => {
-  const decoders = [];
-
-  encodings = unwind(encodings);
-
-  for (const encoding of encodings) {
-    if (/\bbr\b/i.test(encoding)) {
-      decoders.push(zlib.createBrotliDecompress(decompression?.brotliOptions));
-    } else if (/\bdeflate(?!-(?:\w+)?)\b/i.test(encoding)) {
-      decoders.push(zlib.createInflate(decompression?.zlibOptions));
-    } else if (/\bdeflate-raw\b/i.test(encoding)) {
-      decoders.push(zlib.createInflateRaw(decompression?.zlibOptions));
-    } else if (/\bgzip\b/i.test(encoding)) {
-      decoders.push(zlib.createGunzip(decompression?.zlibOptions));
-    } else if (isZstdSupported && /\bzstd\b/i.test(encoding)) {
-      decoders.push(zlib.createZstdDecompress(decompression?.zstdOptions));
-    } else {
-      return readable;
-    }
-  }
-
-  return pipeline(readable, ...decoders, () => void 0);
-};
-
-export const dispatch = ({ body }, req) => {
-  if (body?.pipe?.constructor === Function) {
-    body.pipe(req);
-  } else {
-    req.end(body);
-  }
-};
-
-export const isFileLike = (instance) => {
-  return [
-    Blob.name,
-    File.name,
-  ].includes(instance?.[Symbol.toStringTag]);
-};
-
-export const isReadableStream = (instance) => {
-  return ReadableStream.name === instance?.[Symbol.toStringTag];
-};
-
-export const maxRetryAfter = Symbol('maxRetryAfter');
-
-export const maxRetryAfterError = (
-  interval,
-  options,
-) => new RequestError(`Maximum '${ HTTP2_HEADER_RETRY_AFTER }' limit exceeded: ${ interval } ms.`, options);
-
-export const merge = (target, ...rest) => {
-  rest = rest.filter((it) => it === Object(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, '');
-  }
-
-  url = new URL(url, options.baseURL);
-
-  return Object.assign(options, { url });
-};
-
-export const sameOrigin = (a, b) => a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port;
-
-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.trim());