rekwest 3.3.4 → 4.1.0

package/dist/formdata.js

@@ -2,97 +2,73 @@
 
 exports.__esModule = true;
 exports.FormData = void 0;
-
 var _nodeCrypto = require("node:crypto");
-
 var _nodeHttp = _interopRequireDefault(require("node:http2"));
-
 var _nodeUtil = require("node:util");
-
-var _file = require("./file.js");
-
-var _mediatypes = require("./mediatypes.js");
-
-var _utils = require("./utils.js");
-
+var _file = require("./file");
+var _mediatypes = require("./mediatypes");
+var _utils = require("./utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 const CRLF = '\r\n';
 const {
   HTTP2_HEADER_CONTENT_DISPOSITION,
   HTTP2_HEADER_CONTENT_TYPE
 } = _nodeHttp.default.constants;
-
 class FormData {
   static actuate(fd) {
     const boundary = (0, _nodeCrypto.randomBytes)(24).toString('hex');
     const contentType = `${_mediatypes.MULTIPART_FORM_DATA}; boundary=${boundary}`;
     const prefix = `--${boundary}${CRLF}${HTTP2_HEADER_CONTENT_DISPOSITION}: form-data`;
-
     const escape = str => str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22');
-
     const normalize = value => value.replace(/\r?\n|\r/g, CRLF);
-
     return {
       contentType,
-
       async *[Symbol.asyncIterator]() {
         const encoder = new TextEncoder();
-
         for (const [name, value] of fd) {
           if (value.constructor === String) {
             yield encoder.encode(`${prefix}; name="${escape(normalize(name))}"${CRLF.repeat(2)}${normalize(value)}${CRLF}`);
           } else {
             yield encoder.encode(`${prefix}; name="${escape(normalize(name))}"${value.name ? `; filename="${escape(value.name)}"` : ''}${CRLF}${HTTP2_HEADER_CONTENT_TYPE}: ${value.type || _mediatypes.APPLICATION_OCTET_STREAM}${CRLF.repeat(2)}`);
             yield* (0, _utils.tap)(value);
-            yield encoder.encode(CRLF);
+            yield new Uint8Array([13, 10]);
           }
         }
-
         yield encoder.encode(`--${boundary}--`);
       }
-
     };
   }
-
   static alike(instance) {
     return instance?.constructor.name === FormData.name;
   }
-
   static #enfoldEntry(name, value, filename) {
     name = (0, _nodeUtil.toUSVString)(name);
     filename &&= (0, _nodeUtil.toUSVString)(filename);
-
     if (_file.File.alike(value)) {
+      filename ??= value.name || 'blob';
       value = new _file.File([value], filename, value);
     } else if (this.#ensureInstance(value)) {
-      value.name = filename || value.name;
+      value.name = filename;
     } else {
       value = (0, _nodeUtil.toUSVString)(value);
     }
-
     return {
       name,
       value
     };
   }
-
   static #ensureInstance(value) {
     return _file.File.alike(value) || value === Object(value) && Reflect.has(value, Symbol.asyncIterator);
   }
-
   #entries = [];
-
   get [Symbol.toStringTag]() {
     return this.constructor.name;
   }
-
   constructor(input) {
     if (input === Object(input) && (input?.constructor === Object || Reflect.has(input, Symbol.iterator))) {
       if (input.constructor !== Object) {
         input = Array.from(input);
       }
-
       if (Array.isArray(input)) {
         if (!input.every(it => Array.isArray(it))) {
           throw new TypeError(`Failed to construct '${this[Symbol.toStringTag]}': The provided value cannot be converted to a sequence.`);
@@ -100,93 +76,77 @@ class FormData {
           throw new TypeError(`Failed to construct '${this[Symbol.toStringTag]}': Sequence initializer must only contain pair elements.`);
         }
       }
-
       if (input.constructor === Object) {
         input = Object.entries(input);
       }
-
       input.forEach(([key, value]) => this.append(key, value));
     }
   }
-
   #ensureArgs(args, expected, method) {
     if (args.length < expected) {
       throw new TypeError(`Failed to execute '${method}' on '${this[Symbol.toStringTag]}': ${expected} arguments required, but only ${args.length} present.`);
     }
-
     if (['append', 'set'].includes(method)) {
       if (args.length === 3 && !this.constructor.#ensureInstance(args[1])) {
-        throw new TypeError(`Failed to execute '${method}' on '${this[Symbol.toStringTag]}': parameter ${expected} is not of type 'Blob', 'File' or async iterable.`);
+        throw new TypeError(`Failed to execute '${method}' on '${this[Symbol.toStringTag]}': parameter ${expected} is not of type 'Blob'.`);
       }
     }
-
     if (method === 'forEach') {
       if (args[0]?.constructor !== Function) {
         throw new TypeError(`Failed to execute '${method}' on '${this[Symbol.toStringTag]}': parameter ${expected} is not of type 'Function'.`);
       }
     }
   }
-
   append(...args) {
-    (0, _utils.collate)(this, FormData);
+    (0, _utils.brandCheck)(this, FormData);
     this.#ensureArgs(args, 2, 'append');
     this.#entries.push(this.constructor.#enfoldEntry(...args));
   }
-
   delete(...args) {
-    (0, _utils.collate)(this, FormData);
+    (0, _utils.brandCheck)(this, FormData);
     this.#ensureArgs(args, 1, 'delete');
     const name = (0, _nodeUtil.toUSVString)(args[0]);
     this.#entries = this.#entries.filter(it => it.name !== name);
   }
-
   forEach(...args) {
-    (0, _utils.collate)(this, FormData);
+    (0, _utils.brandCheck)(this, FormData);
     this.#ensureArgs(args, 1, 'forEach');
     const [callback, thisArg] = args;
-
     for (const entry of this) {
       Reflect.apply(callback, thisArg, [...entry.reverse(), this]);
     }
   }
-
   get(...args) {
-    (0, _utils.collate)(this, FormData);
+    (0, _utils.brandCheck)(this, FormData);
     this.#ensureArgs(args, 1, 'get');
     const name = (0, _nodeUtil.toUSVString)(args[0]);
     return (this.#entries.find(it => it.name === name) ?? {}).value ?? null;
   }
-
   getAll(...args) {
-    (0, _utils.collate)(this, FormData);
+    (0, _utils.brandCheck)(this, FormData);
     this.#ensureArgs(args, 1, 'getAll');
     const name = (0, _nodeUtil.toUSVString)(args[0]);
     return this.#entries.filter(it => it.name === name).map(it => it.value);
   }
-
   has(...args) {
-    (0, _utils.collate)(this, FormData);
+    (0, _utils.brandCheck)(this, FormData);
     this.#ensureArgs(args, 1, 'has');
     const name = (0, _nodeUtil.toUSVString)(args[0]);
     return !!this.#entries.find(it => it.name === name);
   }
-
   set(...args) {
-    (0, _utils.collate)(this, FormData);
+    (0, _utils.brandCheck)(this, FormData);
     this.#ensureArgs(args, 2, 'set');
     const entry = this.constructor.#enfoldEntry(...args);
     const idx = this.#entries.findIndex(it => it.name === entry.name);
-
     if (idx !== -1) {
       this.#entries.splice(idx, 1, entry);
     } else {
       this.#entries.push(entry);
     }
   }
-
   *entries() {
-    (0, _utils.collate)(this, FormData);
-
+    (0, _utils.brandCheck)(this, FormData);
     for (const {
       name,
       value
@@ -194,28 +154,21 @@ class FormData {
       yield [name, value];
     }
   }
-
   *keys() {
-    (0, _utils.collate)(this, FormData);
-
+    (0, _utils.brandCheck)(this, FormData);
     for (const [name] of this) {
       yield name;
     }
   }
-
   *values() {
-    (0, _utils.collate)(this, FormData);
-
+    (0, _utils.brandCheck)(this, FormData);
     for (const [, value] of this) {
       yield value;
     }
   }
-
   [Symbol.iterator]() {
-    (0, _utils.collate)(this, FormData);
+    (0, _utils.brandCheck)(this, FormData);
     return this.entries();
   }
-
 }
-
 exports.FormData = FormData;

package/dist/index.js

@@ -8,110 +8,91 @@ var _exportNames = {
 exports.constants = void 0;
 exports.default = rekwest;
 exports.mediatypes = void 0;
-
 var _nodeHttp = _interopRequireDefault(require("node:http"));
-
 var _nodeHttp2 = _interopRequireWildcard(require("node:http2"));
-
 exports.constants = _nodeHttp2.constants;
-
 var _nodeHttps = _interopRequireDefault(require("node:https"));
-
 var _promises = require("node:timers/promises");
-
-var _ackn = require("./ackn.js");
-
+var _ackn = require("./ackn");
 Object.keys(_ackn).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _ackn[key]) return;
   exports[key] = _ackn[key];
 });
-
-var _cookies = require("./cookies.js");
-
+var _constants = require("./constants");
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  exports[key] = _constants[key];
+});
+var _cookies = require("./cookies");
 Object.keys(_cookies).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _cookies[key]) return;
   exports[key] = _cookies[key];
 });
-
-var _errors = require("./errors.js");
-
+var _errors = require("./errors");
 Object.keys(_errors).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _errors[key]) return;
   exports[key] = _errors[key];
 });
-
-var _mediatypes = _interopRequireWildcard(require("./mediatypes.js"));
-
+var _mediatypes = _interopRequireWildcard(require("./mediatypes"));
 exports.mediatypes = _mediatypes;
-
-var _utils = require("./utils.js");
-
+var _utils = require("./utils");
 Object.keys(_utils).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _utils[key]) return;
   exports[key] = _utils[key];
 });
-
-var _file = require("./file.js");
-
+var _file = require("./file");
 Object.keys(_file).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _file[key]) return;
   exports[key] = _file[key];
 });
-
-var _formdata = require("./formdata.js");
-
+var _formdata = require("./formdata");
 Object.keys(_formdata).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _formdata[key]) return;
   exports[key] = _formdata[key];
 });
-
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 const {
-  HTTP2_HEADER_CONTENT_LENGTH,
+  HTTP2_HEADER_AUTHORIZATION,
   HTTP2_HEADER_CONTENT_TYPE,
   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,
   HTTP_STATUS_SERVICE_UNAVAILABLE,
   HTTP_STATUS_TOO_MANY_REQUESTS
 } = _nodeHttp2.default.constants;
 const maxRetryAfter = Symbol('maxRetryAfter');
-
 const maxRetryAfterError = (interval, options) => new _errors.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,
@@ -122,34 +103,26 @@ let defaults = {
   },
   timeout: 3e5
 };
-
-async function rekwest(url, options = {}) {
-  ({
-    url
-  } = (0, _utils.revise)({
-    options,
+async function rekwest(...args) {
+  let options = (0, _utils.sanitize)(...args);
+  const {
     url
-  }));
-
+  } = options;
   if (!options.redirected) {
     options = (0, _utils.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 _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));
   }
-
-  options = (0, _utils.preflight)(options);
+  options = await (0, _utils.transform)((0, _utils.preflight)(options));
   const {
     cookies,
     digest,
@@ -162,36 +135,27 @@ async function rekwest(url, options = {}) {
   const {
     request
   } = url.protocol === 'http:' ? _nodeHttp.default : _nodeHttps.default;
-  let {
-    body
-  } = options;
   const promise = new Promise((resolve, reject) => {
     let client, req;
-    body &&= (0, _utils.transform)(body, options);
-
     if (h2) {
       client = _nodeHttp2.default.connect(url.origin, options);
       req = client.request(options.headers, options);
     } else {
       req = request(url, options);
     }
-
     (0, _utils.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);
       }
-
       (0, _utils.admix)(res, headers, options);
-
       if (cookies !== false && res.headers[HTTP2_HEADER_SET_COOKIE]) {
         if (_cookies.Cookies.jar.has(url.origin)) {
           new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]).forEach(function (val, key) {
@@ -201,85 +165,78 @@ async function rekwest(url, options = {}) {
           _cookies.Cookies.jar.set(url.origin, new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]));
         }
       }
-
       Reflect.defineProperty(res, 'cookies', {
         enumerable: true,
         value: cookies !== false && _cookies.Cookies.jar.has(url.origin) ? _cookies.Cookies.jar.get(url.origin) : void 0
       });
-
-      if (follow && /^3\d{2}$/.test(res.statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
-        if (redirect === _utils.redirects.error) {
+      const {
+        statusCode
+      } = res;
+      if (follow && /3\d{2}/.test(statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
+        if (!_constants.redirectStatusCodes.includes(statusCode)) {
+          return res.emit('error', new RangeError(`Invalid status code: ${statusCode}`));
+        }
+        if (redirect === _constants.redirectModes.error) {
           return res.emit('error', new _errors.RequestError(`Unexpected redirect, redirect mode is set to '${redirect}'.`));
         }
-
-        if (redirect === _utils.redirects.follow) {
-          options.url = new URL(res.headers[HTTP2_HEADER_LOCATION], url).href;
-
-          if (res.statusCode !== HTTP_STATUS_SEE_OTHER && body === Object(body) && body.pipe?.constructor === Function) {
+        if (redirect === _constants.redirectModes.follow) {
+          const location = new URL(res.headers[HTTP2_HEADER_LOCATION], url);
+          if (!/^https?:/.test(location.protocol)) {
+            return res.emit('error', new _errors.RequestError('URL scheme must be "http" or "https".'));
+          }
+          if (!(0, _utils.sameOrigin)(location, url)) {
+            Reflect.deleteProperty(options.headers, HTTP2_HEADER_AUTHORIZATION);
+            location.password = location.username = '';
+          }
+          options.url = location;
+          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.`));
           }
-
           options.follow--;
-
-          if (res.statusCode === HTTP_STATUS_SEE_OTHER) {
-            Reflect.deleteProperty(options.headers, HTTP2_HEADER_CONTENT_LENGTH);
-            options.method = HTTP2_METHOD_GET;
+          if ([HTTP_STATUS_MOVED_PERMANENTLY, HTTP_STATUS_FOUND].includes(statusCode) && request.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 (res.statusCode === HTTP_STATUS_MOVED_PERMANENTLY && res.headers[HTTP2_HEADER_RETRY_AFTER]) {
+          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: (0, _utils.mixin)(res, options)
               }));
             }
-
             return (0, _promises.setTimeout)(interval).then(() => rekwest(options.url, options).then(resolve, reject));
           }
-
           return rekwest(options.url, options).then(resolve, reject);
         }
       }
-
-      if (res.statusCode >= HTTP_STATUS_BAD_REQUEST) {
+      if (statusCode >= HTTP_STATUS_BAD_REQUEST) {
         return reject((0, _utils.mixin)(res, options));
       }
-
       resolve((0, _utils.mixin)(res, options));
     });
-    (0, _utils.dispatch)(req, { ...options,
-      body
-    });
+    (0, _utils.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
@@ -288,16 +245,13 @@ async function rekwest(url, options = {}) {
       } else {
         interval = new Function('interval', `return Math.ceil(${retry.backoffStrategy});`)(interval);
       }
-
       retry.attempts--;
       retry.interval = interval;
       return (0, _promises.setTimeout)(interval).then(() => rekwest(url, options));
     }
-
     if (digest && !redirected && ex.body) {
       ex.body = await ex.body();
     }
-
     if (!thenable) {
       throw ex;
     } else {
@@ -305,63 +259,49 @@ async function rekwest(url, options = {}) {
     }
   }
 }
-
 Reflect.defineProperty(rekwest, 'stream', {
   enumerable: true,
-
-  value(url, options = {}) {
-    ({
-      url
-    } = (0, _utils.revise)({
-      options,
-      url
-    }));
-    options = (0, _utils.preflight)({ ...(0, _utils.merge)(rekwest.defaults, {
+  value(...args) {
+    const options = (0, _utils.preflight)({
+      ...(0, _utils.merge)(rekwest.defaults, {
         headers: {
           [HTTP2_HEADER_CONTENT_TYPE]: _mediatypes.APPLICATION_OCTET_STREAM
         }
-      }, options),
-      redirect: _utils.redirects.manual
+      }, (0, _utils.sanitize)(...args)),
+      redirect: _constants.redirectModes.manual
     });
     const {
-      h2
+      h2,
+      url
     } = options;
     const {
       request
     } = url.protocol === 'http:' ? _nodeHttp.default : _nodeHttps.default;
     let client, req;
-
     if (h2) {
       client = _nodeHttp2.default.connect(url.origin, options);
       req = client.request(options.headers, options);
     } else {
       req = request(url, options);
     }
-
     (0, _utils.affix)(client, req, options);
     req.once('response', res => {
       let headers;
-
       if (h2) {
         headers = res;
         res = req;
       }
-
       (0, _utils.admix)(res, headers, options);
     });
     return req;
   }
-
 });
 Reflect.defineProperty(rekwest, 'defaults', {
   enumerable: true,
-
   get() {
     return defaults;
   },
-
   set(value) {
     defaults = (0, _utils.merge)(defaults, value);
   }
-
 });