Adds abort signal to requests

Enables request abortion using AbortSignal in all transports.
The change ensures requests can be cancelled,
prevents memory leaks and improves user experience by rejecting requests that are no longer relevant.

Implements AbortError class to differentiate RPC errors from aborts.
Ran `npm i baseline-browser-mapping@latest -D` to update browser mappings, and `npm audit fix` to fix 3 vulnerabilities (1 low, 1 moderate, 1 high).

Author: francislavoie

package-lock.json

@@ -43,6 +43,7 @@
     "@types/websocket": "1.0.10",
     "@types/ws": "8.18.1",
     "@typescript-eslint/eslint-plugin": "8.44.0",
+    "baseline-browser-mapping": "^2.9.5",
     "eslint-config-prettier": "10.0.1",
     "eslint-plugin-prettier": "5.2.3",
     "jest": "29.7.0",
@@ -58,4 +59,4 @@
     "strict-event-emitter-types": "2.0.0",
     "ws": "8.18.3"
   }
-}
+}

package.json

@@ -3,6 +3,8 @@ import { IJSONRPCNotification } from "./Request.js";
 interface Arguments {
   readonly method: string;
   readonly params?: readonly unknown[] | object;
+  readonly timeout?: number;
+  readonly signal?: AbortSignal;
 }
 
 export type RequestArguments = Arguments;

src/ClientInterface.ts

@@ -2,6 +2,13 @@ export const ERR_TIMEOUT = 7777;
 export const ERR_MISSIING_ID = 7878;
 export const ERR_UNKNOWN = 7979;
 
+export class AbortError extends Error {
+  constructor(message: string = "Request aborted") {
+    super(message);
+    this.name = "AbortError";
+  }
+}
+
 export class JSONRPCError extends Error {
   public message: string;
   public code: number;

src/Error.ts

@@ -89,7 +89,11 @@ class RequestManager {
       });
       return result;
     }
-    return this.getPrimaryTransport().sendData(payload, timeout);
+    return this.getPrimaryTransport().sendData(
+      payload,
+      requestObject.timeout || timeout,
+      requestObject.signal,
+    );
   }
 
   public close(): void {

src/RequestManager.ts

@@ -1,11 +1,28 @@
-import { Client } from "./index.js";
-import RequestManager from "./RequestManager.js";
-import EventEmitterTransport from "./transports/EventEmitterTransport.js";
+import Client, {
+  RequestManager,
+  EventEmitterTransport,
+  HTTPTransport,
+  WebSocketTransport,
+  PostMessageWindowTransport,
+  PostMessageIframeTransport,
+  JSONRPCError,
+} from "./index.js";
 import { EventEmitter } from "events";
 import { addMockServerTransport } from "./__mocks__/eventEmitter.js";
 import { generateMockNotificationRequest } from "./__mocks__/requestData.js";
 
 describe("client-js", () => {
+  it("exposes the package exports", () => {
+    expect(Client).toBeDefined();
+    expect(RequestManager).toBeDefined();
+    expect(EventEmitterTransport).toBeDefined();
+    expect(HTTPTransport).toBeDefined();
+    expect(WebSocketTransport).toBeDefined();
+    expect(PostMessageWindowTransport).toBeDefined();
+    expect(PostMessageIframeTransport).toBeDefined();
+    expect(JSONRPCError).toBeDefined();
+  });
+
   it("can be constructed", () => {
     const emitter = new EventEmitter();
     const c = new Client(

src/index.test.ts

@@ -27,9 +27,10 @@ class EventEmitterTransport extends Transport {
   public sendData(
     data: JSONRPCRequestData,
     timeout: number | null = null,
+    signal?: AbortSignal | null,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ): Promise<any> {
-    const prom = this.transportRequestManager.addRequest(data, timeout);
+    const prom = this.transportRequestManager.addRequest(data, timeout, signal);
     const notifications = getNotifications(data);
     const parsedData = this.parseData(data);
     try {

src/transports/EventEmitterTransport.ts

@@ -1,5 +1,6 @@
 import { HTTPTransport, HTTPTransportOptions } from "./HTTPTransport.js";
 import * as reqMocks from "../__mocks__/requestData.js";
+import { AbortError } from "../Error.js";
 
 describe("HTTPTransport", () => {
   let mockFetch: jest.MockedFunction<typeof fetch>;
@@ -179,4 +180,56 @@ describe("HTTPTransport", () => {
     expect(injectedFetchMock.mock.calls.length).toEqual(1);
     expect(result).toEqual(undefined);
   });
+
+  it("should use global fetch if no fetcher provided", async () => {
+    const globalFetch = jest.fn().mockImplementation((url, options) => {
+      const body = options?.body as string;
+      const responseText = reqMocks.generateMockResponseData(url.toString(), body);
+      return Promise.resolve({
+        text: () => Promise.resolve(responseText),
+      });
+    }) as any;
+    global.fetch = globalFetch;
+
+    const httpTransport = new HTTPTransport("http://localhost:8545/rpc-request");
+    await httpTransport.sendData({
+      request: reqMocks.generateMockRequest(1, "foo", ["bar"]),
+      internalID: 1,
+    });
+
+    expect(globalFetch).toHaveBeenCalled();
+  });
+
+  it("should abort the fetch request when signal is aborted", async () => {
+    const controller = new AbortController();
+    const httpTransport = new HTTPTransport("http://localhost:8545", {
+      fetcher: mockFetch,
+    });
+    const data = reqMocks.generateMockRequest(1, "foo", ["bar"]);
+
+    // Setup mock to fail if aborted (simulating fetch behavior)
+    mockFetch.mockImplementation(async (_url, options) => {
+      if (options?.signal?.aborted) {
+        throw new DOMException("The user aborted a request.", "AbortError");
+      }
+      return new Promise((_, reject) => {
+        options?.signal?.addEventListener("abort", () => {
+          reject(new DOMException("The user aborted a request.", "AbortError"));
+        });
+      });
+    });
+
+    const prom = httpTransport.sendData({
+      request: data,
+      internalID: 1,
+    }, null, controller.signal);
+
+    controller.abort();
+
+    await expect(prom).rejects.toThrow(AbortError);
+
+    const callArgs = mockFetch.mock.calls[0];
+    expect(callArgs[1]?.signal).toBeDefined();
+    expect(callArgs[1]?.signal?.aborted).toBe(true);
+  });
 });

src/transports/HTTPTransport.test.ts

@@ -34,9 +34,10 @@ class HTTPTransport extends Transport {
   public async sendData(
     data: JSONRPCRequestData,
     timeout: number | null = null,
+    signal?: AbortSignal | null,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ): Promise<any> {
-    const prom = this.transportRequestManager.addRequest(data, timeout);
+    const prom = this.transportRequestManager.addRequest(data, timeout, signal);
     const notifications = getNotifications(data);
     const batch = getBatchRequests(data);
     const fetcher = this.injectedFetcher || fetch;
@@ -46,6 +47,7 @@ class HTTPTransport extends Transport {
         headers: this.headers,
         body: JSON.stringify(this.parseData(data)),
         credentials: this.credentials,
+        signal,
       });
       // requirements are that notifications are successfully sent
       this.transportRequestManager.settlePendingRequest(notifications);
@@ -55,23 +57,28 @@ class HTTPTransport extends Transport {
       const body = await result.text();
       const responseErr = this.transportRequestManager.resolveResponse(body);
       if (responseErr) {
-        // requirements are that batch requuests are successfully resolved
+        // requirements are that batch requests are successfully resolved
         // this ensures that individual requests within the batch request are settled
         this.transportRequestManager.settlePendingRequest(batch, responseErr);
         return Promise.reject(responseErr);
       }
     } catch (e) {
       const error = e as Error;
       const responseErr = new JSONRPCError(error.message, ERR_UNKNOWN, error);
+      // requirements are that notifications are successfully resolved
       this.transportRequestManager.settlePendingRequest(
         notifications,
         responseErr,
       );
+      // requirements are that batch requests are successfully resolved
       this.transportRequestManager.settlePendingRequest(
         getBatchRequests(data),
         responseErr,
       );
-      return Promise.reject(responseErr);
+      // requirements are that individual requests are successfully resolved
+      if (!Array.isArray(data)) {
+        this.transportRequestManager.settlePendingRequest([data], responseErr);
+      }
     }
     return prom;
   }

src/transports/HTTPTransport.ts

@@ -51,9 +51,10 @@ class PostMessageIframeTransport extends Transport {
   public async sendData(
     data: JSONRPCRequestData,
     _timeout: number | null = 5000,
+    signal?: AbortSignal | null,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ): Promise<any> {
-    const prom = this.transportRequestManager.addRequest(data, null);
+    const prom = this.transportRequestManager.addRequest(data, null, signal);
     const notifications = getNotifications(data);
     if (this.frame) {
       this.frame.postMessage((data as IJSONRPCData).request, "*");