fetch-har 8.1.4 → 8.1.5

package/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+  "editor.codeActionsOnSave": {
+    "source.fixAll": true
+  }
+}

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## <small>8.1.5 (2023-01-23)</small>
+
+* fix: support urls with hashes that also have query params (#363) ([7a51342](https://github.com/readmeio/fetch-har/commit/7a51342)), closes [#363](https://github.com/readmeio/fetch-har/issues/363)
+* chore(deps-dev): bumping deps (#362) ([3279246](https://github.com/readmeio/fetch-har/commit/3279246)), closes [#362](https://github.com/readmeio/fetch-har/issues/362)
+
+
+
 ## <small>8.1.4 (2023-01-03)</small>
 
 * chore(deps-dev): bump @readme/eslint-config from 10.1.0 to 10.1.1 (#331) ([75de615](https://github.com/readmeio/fetch-har/commit/75de615)), closes [#331](https://github.com/readmeio/fetch-har/issues/331)

package/dist/index.d.ts

@@ -1,9 +1,22 @@
 /// <reference types="node" />
 import type { Har } from 'har-format';
+interface RequestInitWithDuplex extends RequestInit {
+    /**
+     * `RequestInit#duplex` does not yet exist in the TS `lib.dom.d.ts` definition yet the native
+     * fetch implementation in Node 18+, `undici`, requires it for certain POST payloads.
+     *
+     * @see {@link https://github.com/microsoft/TypeScript-DOM-lib-generator/issues/1483}
+     * @see {@link https://github.com/nodejs/node/issues/46221}
+     * @see {@link https://fetch.spec.whatwg.org/#request-class}
+     * @see {@link https://github.com/microsoft/TypeScript/blob/main/lib/lib.dom.d.ts}
+     */
+    duplex?: 'half';
+}
 export interface FetchHAROptions {
     userAgent?: string;
     files?: Record<string, Blob | Buffer>;
     multipartEncoder?: any;
-    init?: RequestInit;
+    init?: RequestInitWithDuplex;
 }
 export default function fetchHAR(har: Har, opts?: FetchHAROptions): Promise<Response>;
+export {};

package/dist/index.js

@@ -101,6 +101,7 @@ function fetchHAR(har, opts) {
     var request = har.log.entries[0].request;
     var url = request.url;
     var querystring = '';
+    var shouldSetDuplex = false;
     var options = __assign(__assign({}, (opts.init ? opts.init : {})), { method: request.method });
     if (!options.headers) {
         options.headers = new Headers();
@@ -260,6 +261,7 @@ function fetchHAR(har, opts) {
                         });
                         // @ts-expect-error "Property 'from' does not exist on type 'typeof Readable'." but it does!
                         options.body = readable_stream_1.Readable.from(encoder_1);
+                        shouldSetDuplex = true;
                     }
                     else {
                         options.body = form_1;
@@ -300,6 +302,7 @@ function fetchHAR(har, opts) {
                                 else {
                                     // @ts-expect-error "Property 'from' does not exist on type 'typeof Readable'." but it does!
                                     options.body = readable_stream_1.Readable.from(fileContents.stream());
+                                    shouldSetDuplex = true;
                                     // Supplying a polyfilled `File` stream into `Request.body` doesn't automatically
                                     // add `Content-Length`.
                                     if (!headers.has('content-length')) {
@@ -315,11 +318,27 @@ function fetchHAR(har, opts) {
                 options.body = request.postData.text;
             }
         }
+        /**
+         * The fetch spec, which Node 18+ strictly abides by, now requires that `duplex` be sent with
+         * requests that have payloads.
+         *
+         * As `RequestInit#duplex` isn't supported by any browsers, or even mentioned on MDN, we aren't
+         * sending it in browser environments. This work is purely to support Node 18+ and `undici`
+         * environments.
+         *
+         * @see {@link https://github.com/nodejs/node/issues/46221}
+         * @see {@link https://github.com/whatwg/fetch/pull/1457}
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request}
+         */
+        if (shouldSetDuplex && !isBrowser()) {
+            options.duplex = 'half';
+        }
     }
     // We automaticaly assume that the HAR that we have already has query parameters encoded within
     // it so we do **not** use the `URLSearchParams` API here for composing the query string.
+    var requestURL = url;
     if ('queryString' in request && request.queryString.length) {
-        var urlObj = new URL(url);
+        var urlObj = new URL(requestURL);
         var queryParams_1 = Array.from(urlObj.searchParams).map(function (_a) {
             var k = _a[0], v = _a[1];
             return "".concat(k, "=").concat(v);
@@ -328,11 +347,21 @@ function fetchHAR(har, opts) {
             queryParams_1.push("".concat(q.name, "=").concat(q.value));
         });
         querystring = queryParams_1.join('&');
+        // Because anchor hashes before query strings will prevent query strings from being delivered
+        // we need to pop them off and re-add them after.
+        if (urlObj.hash) {
+            var urlWithoutHashes = requestURL.replace(urlObj.hash, '');
+            requestURL = "".concat(urlWithoutHashes.split('?')[0]).concat(querystring ? "?".concat(querystring) : '');
+            requestURL += urlObj.hash;
+        }
+        else {
+            requestURL = "".concat(requestURL.split('?')[0]).concat(querystring ? "?".concat(querystring) : '');
+        }
     }
     if (opts.userAgent) {
         headers.append('User-Agent', opts.userAgent);
     }
     options.headers = headers;
-    return fetch("".concat(url.split('?')[0]).concat(querystring ? "?".concat(querystring) : ''), options);
+    return fetch(requestURL, options);
 }
 exports["default"] = fetchHAR;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fetch-har",
-  "version": "8.1.4",
+  "version": "8.1.5",
   "description": "Make a fetch request from a HAR definition",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,7 +40,7 @@
   "devDependencies": {
     "@jsdevtools/host-environment": "^2.1.2",
     "@jsdevtools/karma-config": "^3.1.7",
-    "@readme/eslint-config": "^10.3.2",
+    "@readme/eslint-config": "^10.4.5",
     "@types/chai": "^4.3.1",
     "@types/express": "^4.17.15",
     "@types/mocha": "^10.0.0",
@@ -49,7 +49,7 @@
     "@types/readable-stream": "^2.3.15",
     "chai": "^4.3.4",
     "datauri": "^4.1.0",
-    "eslint": "^8.31.0",
+    "eslint": "^8.32.0",
     "express": "^4.18.1",
     "fetch-mock": "^9.11.0",
     "form-data": "^4.0.0",
@@ -59,15 +59,15 @@
     "isomorphic-fetch": "^3.0.0",
     "mocha": "^10.2.0",
     "multer": "^1.4.5-lts.1",
-    "nock": "^13.2.4",
+    "nock": "^13.3.0",
     "node-fetch": "^2.6.0",
     "nyc": "^15.1.0",
-    "prettier": "^2.8.1",
+    "prettier": "^2.8.3",
     "temp-dir": "^2.0.0",
     "ts-loader": "^8.4.0",
     "ts-node": "^10.7.0",
     "typescript": "^4.9.4",
-    "undici": "^5.14.0",
+    "undici": "^5.16.0",
     "webpack": "^4.46.0"
   },
   "browserslist": [

package/src/index.ts

@@ -37,11 +37,24 @@ if (!globalThis.FormData) {
   }
 }
 
+interface RequestInitWithDuplex extends RequestInit {
+  /**
+   * `RequestInit#duplex` does not yet exist in the TS `lib.dom.d.ts` definition yet the native
+   * fetch implementation in Node 18+, `undici`, requires it for certain POST payloads.
+   *
+   * @see {@link https://github.com/microsoft/TypeScript-DOM-lib-generator/issues/1483}
+   * @see {@link https://github.com/nodejs/node/issues/46221}
+   * @see {@link https://fetch.spec.whatwg.org/#request-class}
+   * @see {@link https://github.com/microsoft/TypeScript/blob/main/lib/lib.dom.d.ts}
+   */
+  duplex?: 'half';
+}
+
 export interface FetchHAROptions {
   userAgent?: string;
   files?: Record<string, Blob | Buffer>;
   multipartEncoder?: any; // form-data-encoder
-  init?: RequestInit;
+  init?: RequestInitWithDuplex;
 }
 
 type DataURL = npmDataURL & {
@@ -117,8 +130,9 @@ export default function fetchHAR(har: Har, opts: FetchHAROptions = {}) {
   const { request } = har.log.entries[0];
   const { url } = request;
   let querystring = '';
+  let shouldSetDuplex = false;
 
-  const options: RequestInit = {
+  const options: RequestInitWithDuplex = {
     // If we have custom options for the `Request` API we need to add them in here now before we
     // fill it in with everything we need from the HAR.
     ...(opts.init ? opts.init : {}),
@@ -309,6 +323,7 @@ export default function fetchHAR(har: Har, opts: FetchHAROptions = {}) {
 
             // @ts-expect-error "Property 'from' does not exist on type 'typeof Readable'." but it does!
             options.body = Readable.from(encoder);
+            shouldSetDuplex = true;
           } else {
             options.body = form;
           }
@@ -347,6 +362,7 @@ export default function fetchHAR(har: Har, opts: FetchHAROptions = {}) {
                 } else {
                   // @ts-expect-error "Property 'from' does not exist on type 'typeof Readable'." but it does!
                   options.body = Readable.from((fileContents as File).stream());
+                  shouldSetDuplex = true;
 
                   // Supplying a polyfilled `File` stream into `Request.body` doesn't automatically
                   // add `Content-Length`.
@@ -364,12 +380,29 @@ export default function fetchHAR(har: Har, opts: FetchHAROptions = {}) {
         options.body = request.postData.text;
       }
     }
+
+    /**
+     * The fetch spec, which Node 18+ strictly abides by, now requires that `duplex` be sent with
+     * requests that have payloads.
+     *
+     * As `RequestInit#duplex` isn't supported by any browsers, or even mentioned on MDN, we aren't
+     * sending it in browser environments. This work is purely to support Node 18+ and `undici`
+     * environments.
+     *
+     * @see {@link https://github.com/nodejs/node/issues/46221}
+     * @see {@link https://github.com/whatwg/fetch/pull/1457}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request}
+     */
+    if (shouldSetDuplex && !isBrowser()) {
+      options.duplex = 'half';
+    }
   }
 
   // We automaticaly assume that the HAR that we have already has query parameters encoded within
   // it so we do **not** use the `URLSearchParams` API here for composing the query string.
+  let requestURL = url;
   if ('queryString' in request && request.queryString.length) {
-    const urlObj = new URL(url);
+    const urlObj = new URL(requestURL);
 
     const queryParams = Array.from(urlObj.searchParams).map(([k, v]) => `${k}=${v}`);
     request.queryString.forEach(q => {
@@ -377,6 +410,16 @@ export default function fetchHAR(har: Har, opts: FetchHAROptions = {}) {
     });
 
     querystring = queryParams.join('&');
+
+    // Because anchor hashes before query strings will prevent query strings from being delivered
+    // we need to pop them off and re-add them after.
+    if (urlObj.hash) {
+      const urlWithoutHashes = requestURL.replace(urlObj.hash, '');
+      requestURL = `${urlWithoutHashes.split('?')[0]}${querystring ? `?${querystring}` : ''}`;
+      requestURL += urlObj.hash;
+    } else {
+      requestURL = `${requestURL.split('?')[0]}${querystring ? `?${querystring}` : ''}`;
+    }
   }
 
   if (opts.userAgent) {
@@ -385,5 +428,5 @@ export default function fetchHAR(har: Har, opts: FetchHAROptions = {}) {
 
   options.headers = headers;
 
-  return fetch(`${url.split('?')[0]}${querystring ? `?${querystring}` : ''}`, options);
+  return fetch(requestURL, options);
 }