rekwest 6.2.0 → 7.0.0

package/dist/retries.cjs

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.retries = void 0;
+var _nodeHttp = _interopRequireDefault(require("node:http2"));
+var _nodeStream = require("node:stream");
+var _promises = require("node:timers/promises");
+var _errors = require("./errors.cjs");
+var _index = _interopRequireDefault(require("./index.cjs"));
+var _utils = require("./utils.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  HTTP2_HEADER_RETRY_AFTER,
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD
+} = _nodeHttp.default.constants;
+const retries = (ex, options) => {
+  const {
+    body,
+    maxRetryAfter,
+    method,
+    retry,
+    url
+  } = options;
+  if (retry?.attempts > 0) {
+    if (![HTTP2_METHOD_GET, HTTP2_METHOD_HEAD].includes(method) && (0, _utils.isPipeStream)(body) && !(0, _nodeStream.isReadable)(body)) {
+      throw new _errors.RequestError('Request stream already read.', {
+        cause: ex
+      });
+    }
+    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 = Math.abs(Number(interval) * 1e3 || new Date(interval) - Date.now()) || 0;
+        if (interval > maxRetryAfter) {
+          throw new _errors.RequestError(`Maximum '${HTTP2_HEADER_RETRY_AFTER}' limit exceeded: ${interval} ms.`, {
+            cause: ex
+          });
+        }
+      } else {
+        interval = new Function('interval', `return Math.ceil(${retry.backoffStrategy});`)(interval);
+      }
+      if (interval < 0) {
+        interval = 0;
+      }
+      retry.attempts--;
+      retry.interval = interval;
+      return (0, _promises.setTimeout)(interval).then(() => (0, _index.default)(url, options));
+    }
+  }
+};
+exports.retries = retries;

package/dist/{transfer.js → transfer.cjs}

@@ -7,18 +7,15 @@ exports.transfer = void 0;
 var _nodeHttp = _interopRequireDefault(require("node:http"));
 var _nodeHttp2 = _interopRequireDefault(require("node:http2"));
 var _nodeHttps = _interopRequireDefault(require("node:https"));
-var _promises = require("node:timers/promises");
-var _ackn = require("./ackn");
-var _errors = require("./errors");
-var _postflight = require("./postflight");
-var _preflight = require("./preflight");
-var _transform = require("./transform");
-var _utils = require("./utils");
+var _ackn = require("./ackn.cjs");
+var _errors = require("./errors.cjs");
+var _postflight = require("./postflight.cjs");
+var _preflight = require("./preflight.cjs");
+var _retries = require("./retries.cjs");
+var _transform = require("./transform.cjs");
+var _utils = require("./utils.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const {
-  HTTP2_HEADER_RETRY_AFTER
-} = _nodeHttp2.default.constants;
-const transfer = async (options, overact) => {
+const transfer = async options => {
   const {
     digest,
     redirected,
@@ -56,7 +53,7 @@ const transfer = async (options, overact) => {
       } = url.protocol === 'http:' ? _nodeHttp.default : _nodeHttps.default;
       req = request(url, options);
     }
-    (0, _utils.affix)(client, req, options);
+    (0, _utils.snoop)(client, req, options);
     req.once('aborted', reject);
     req.once('error', reject);
     req.once('frameError', reject);
@@ -65,7 +62,7 @@ const transfer = async (options, overact) => {
       reject,
       resolve
     }));
-    (0, _utils.dispatch)(options, req);
+    (0, _utils.dispatch)(req, options);
   });
   try {
     const res = await promise;
@@ -74,33 +71,9 @@ const transfer = async (options, overact) => {
     }
     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 (0, _utils.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 (0, _promises.setTimeout)(interval).then(() => overact(url, options));
-      }
+    const willRetry = (0, _retries.retries)(ex, options);
+    if (willRetry) {
+      return willRetry;
     }
     if (digest && !redirected && ex.body) {
       ex.body = await ex.body();

package/dist/transform.cjs

@@ -0,0 +1,105 @@
+"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 _codecs = require("./codecs.cjs");
+var _formdata = require("./formdata.cjs");
+var _mediatypes = require("./mediatypes.cjs");
+var _utils = require("./utils.cjs");
+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 (!Buffer.isBuffer(body)) {
+    switch (true) {
+      case (0, _utils.isFileLike)(body):
+        {
+          headers = {
+            [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
+            [HTTP2_HEADER_CONTENT_TYPE]: body.type || _mediatypes.APPLICATION_OCTET_STREAM
+          };
+          body = body.stream();
+          break;
+        }
+      case _formdata.FormData.alike(body):
+        {
+          body = _formdata.FormData.actuate(body);
+          headers = {
+            [HTTP2_HEADER_CONTENT_TYPE]: body.contentType
+          };
+          break;
+        }
+      case _nodeUtil.types.isAnyArrayBuffer(body):
+        {
+          body = Buffer.from(body);
+          break;
+        }
+      case _nodeUtil.types.isArrayBufferView(body):
+        {
+          body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+          break;
+        }
+      case Object(body) === 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);
+          }
+          break;
+        }
+      default:
+        break;
+    }
+  }
+  const encodings = options.headers[HTTP2_HEADER_CONTENT_ENCODING];
+  if (Object(body) === 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, _codecs.encode)(body, encodings, options) : body;
+  } else if (encodings) {
+    body = await (0, _consumers.buffer)((0, _codecs.encode)(_nodeStream.Readable.from(body), encodings, options));
+  }
+  if (options.bufferBody && Object(body) === body) {
+    if ((0, _nodeStream.isReadable)(body)) {
+      body = await (0, _consumers.buffer)(body);
+    } else if (Reflect.has(body, Symbol.asyncIterator)) {
+      body = await (0, _consumers.buffer)(body);
+    }
+  }
+  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/dist/utils.cjs

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.snoop = exports.sameOrigin = exports.normalize = exports.merge = exports.isReadableStream = exports.isPipeStream = exports.isFileLike = exports.dispatch = exports.copyWithMerge = exports.brandCheck = exports.augment = void 0;
+exports.tap = tap;
+exports.unwind = exports.toCamelCase = void 0;
+var _nodeBuffer = require("node:buffer");
+var _nodeHttp = _interopRequireDefault(require("node:http2"));
+var _nodeStream = require("node:stream");
+var _config = _interopRequireDefault(require("./config.cjs"));
+var _errors = require("./errors.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  HTTP2_HEADER_STATUS
+} = _nodeHttp.default.constants;
+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
+  });
+};
+exports.augment = augment;
+const brandCheck = (value, ctor) => {
+  if (!(value instanceof ctor)) {
+    throw new TypeError('Illegal invocation.');
+  }
+};
+exports.brandCheck = brandCheck;
+const copyWithMerge = (target, ...rest) => {
+  target = structuredClone(target);
+  if (!rest.length) {
+    return target;
+  }
+  return merge(target, ...rest);
+};
+exports.copyWithMerge = copyWithMerge;
+const dispatch = (req, {
+  body
+}) => {
+  if ((0, _nodeStream.isReadable)(body)) {
+    body.pipe(req);
+  } else {
+    req.end(body);
+  }
+};
+exports.dispatch = dispatch;
+const isFileLike = value => {
+  return [_nodeBuffer.Blob, _nodeBuffer.File].some(it => value instanceof it);
+};
+exports.isFileLike = isFileLike;
+const isPipeStream = value => {
+  return value instanceof _nodeStream.Readable;
+};
+exports.isPipeStream = isPipeStream;
+const isReadableStream = value => {
+  return value instanceof ReadableStream;
+};
+exports.isReadableStream = isReadableStream;
+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;
+};
+exports.merge = merge;
+const normalize = (url, options = {}) => {
+  if (!options.redirected) {
+    options = copyWithMerge(_config.default.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
+  });
+};
+exports.normalize = normalize;
+const sameOrigin = (a, b) => a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port;
+exports.sameOrigin = sameOrigin;
+const snoop = (client, req, options) => {
+  req.once('close', () => client?.close());
+  req.once('end', () => client?.close());
+  req.once('timeout', () => req.destroy(new _errors.TimeoutError(`Timed out after ${options.timeout} ms.`)));
+  req.once('trailers', trailers => {
+    Reflect.defineProperty(req, 'trailers', {
+      enumerable: true,
+      value: trailers
+    });
+  });
+};
+exports.snoop = snoop;
+async function* tap(value) {
+  if (Reflect.has(value, Symbol.asyncIterator)) {
+    yield* value;
+  } else if (value.stream) {
+    yield* value.stream();
+  } else {
+    yield await value.arrayBuffer();
+  }
+}
+const toCamelCase = str => str?.toLowerCase().replace(/\p{Punctuation}.|\p{White_Space}./gu, val => val.replace(/\p{Punctuation}+|\p{White_Space}+/gu, '').toUpperCase());
+exports.toCamelCase = toCamelCase;
+const unwind = encodings => encodings.split(',').map(it => it.toLowerCase().trim());
+exports.unwind = unwind;

package/dist/{validation.js → validation.cjs}

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.validation = void 0;
 var _nodeHttp = _interopRequireDefault(require("node:http2"));
-var _constants = require("./constants");
+var _constants = require("./constants.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const {
   HTTP2_METHOD_GET,

package/package.json

@@ -7,23 +7,23 @@
   "bugs": {
     "url": "https://github.com/bricss/rekwest/issues"
   },
+  "description": "The robust request library that humanity deserves 🌐",
   "devDependencies": {
-    "@babel/cli": "^7.28.3",
-    "@babel/core": "^7.28.4",
-    "@babel/eslint-parser": "^7.28.4",
-    "@babel/preset-env": "^7.28.3",
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.29.0",
+    "@babel/eslint-parser": "^7.28.6",
+    "@babel/preset-env": "^7.29.0",
     "c8": "^10.1.3",
-    "eslint": "^9.35.0",
-    "eslint-config-ultra-refined": "^3.8.0",
-    "mocha": "^11.7.2"
+    "eslint": "^9.39.2",
+    "eslint-config-ultra-refined": "^3.8.5",
+    "mocha": "^11.7.5"
   },
-  "description": "The robust request library that humanity deserves 🌐",
   "engines": {
     "node": ">=20.0.0"
   },
   "exports": {
-    "import": "./src/index.mjs",
-    "require": "./dist/index.js"
+    "import": "./src/index.js",
+    "require": "./dist/index.cjs"
   },
   "files": [
     "dist",
@@ -61,15 +61,16 @@
     "url": "git+https://github.com/bricss/rekwest.git"
   },
   "scripts": {
-    "build": "rm -rf dist && npx babel src -d dist",
+    "build": "rm -rf dist && npx babel src --out-dir dist --out-file-extension .cjs",
     "cert:gen": "openssl req -days 365 -keyout localhost.key -newkey ec -nodes -pkeyopt ec_paramgen_curve:prime256v1 -subj //SKIP=1/CN=localhost -out localhost.cert -x509",
     "cert:ken": "openssl x509 -in localhost.cert -noout -text",
-    "lint": "eslint",
-    "prepack": "npm run build && sh pony.sh",
+    "lint": "eslint --concurrency=auto",
+    "prepack": "npm run build && sh misc.sh && npm run lint",
     "pretest": "rm -rf coverage && npm run cert:gen",
     "test": "mocha",
     "test:bail": "mocha --bail",
     "test:cover": "c8 --include=src --reporter=lcov --reporter=text npm test"
   },
-  "version": "6.2.0"
+  "type": "module",
+  "version": "7.0.0"
 }

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

@@ -1,33 +1,33 @@
-import { connect } from 'node:tls';
-
-export const ackn = (options) => new Promise((resolve, reject) => {
-  const { url } = options;
-  const socket = connect({
-    ...options,
-    ALPNProtocols: [
-      'h2',
-      'http/1.1',
-    ],
-    host: url.hostname,
-    port: parseInt(url.port) || 443,
-    servername: url.hostname,
-  }, () => {
-    socket.off('error', reject);
-    socket.off('timeout', reject);
-
-    const { alpnProtocol } = socket;
-
-    resolve({
-      ...options,
-      alpnProtocol,
-      createConnection() {
-        return socket;
-      },
-      h2: /h2c?/i.test(alpnProtocol),
-      protocol: url.protocol,
-    });
-  });
-
-  socket.on('error', reject);
-  socket.on('timeout', reject);
-});
+import { connect } from 'node:tls';
+
+export const ackn = (options) => new Promise((resolve, reject) => {
+  const { url } = options;
+  const socket = connect({
+    ...options,
+    ALPNProtocols: [
+      'h2',
+      'http/1.1',
+    ],
+    host: url.hostname,
+    port: parseInt(url.port) || 443,
+    servername: url.hostname,
+  }, () => {
+    socket.off('error', reject);
+    socket.off('timeout', reject);
+
+    const { alpnProtocol } = socket;
+
+    resolve({
+      ...options,
+      alpnProtocol,
+      createConnection() {
+        return socket;
+      },
+      h2: /h2c?/i.test(alpnProtocol),
+      protocol: url.protocol,
+    });
+  });
+
+  socket.on('error', reject);
+  socket.on('timeout', reject);
+});

package/src/codecs.js

@@ -0,0 +1,55 @@
+import { pipeline } from 'node:stream';
+import zlib from 'node:zlib';
+import { isZstdSupported } from './config.js';
+import { unwind } from './utils.js';
+
+export const decodeCodecs = {
+  br: (opts) => zlib.createBrotliDecompress(opts?.brotli),
+  deflate: (opts) => zlib.createInflate(opts?.zlib),
+  'deflate-raw': (opts) => zlib.createInflateRaw(opts?.zlib),
+  gzip: (opts) => zlib.createGunzip(opts?.zlib),
+  zstd: (opts) => isZstdSupported && zlib.createZstdDecompress(opts?.zstd),
+};
+
+export const decode = (readable, encodings = '', { decodersOptions } = {}) => {
+  const decoders = [];
+
+  encodings = unwind(encodings).reverse();
+
+  for (const encoding of encodings) {
+    const decoder = decodeCodecs[encoding]?.(decodersOptions);
+
+    if (!decoder) {
+      return readable;
+    }
+
+    decoders.push(decoder);
+  }
+
+  return pipeline(readable, ...decoders, () => void 0);
+};
+
+export const encodeCodecs = {
+  br: (opts) => zlib.createBrotliCompress(opts?.brotli),
+  deflate: (opts) => zlib.createDeflate(opts?.zlib),
+  'deflate-raw': (opts) => zlib.createDeflateRaw(opts?.zlib),
+  gzip: (opts) => zlib.createGzip(opts?.zlib),
+  zstd: (opts) => isZstdSupported && zlib.createZstdCompress(opts?.zstd),
+};
+export const encode = (readable, encodings = '', { encodersOptions } = {}) => {
+  const encoders = [];
+
+  encodings = unwind(encodings);
+
+  for (const encoding of encodings) {
+    const encoder = encodeCodecs[encoding]?.(encodersOptions);
+
+    if (!encoder) {
+      return readable;
+    }
+
+    encoders.push(encoder);
+  }
+
+  return pipeline(readable, ...encoders, () => void 0);
+};