chore: formatting

Author: siddsriv

packages/fetch-http-handler/src/fetch-http-handler.spec.ts

@@ -305,35 +305,33 @@ const globalFetch = global.fetch;
     it("should use per-request timeout over handler config timeout", async () => {
       const mockFetch = vi.fn(() => new Promise(() => {})); // never resolve
       (global as any).fetch = mockFetch;
-      
+
       const fetchHttpHandler = new FetchHttpHandler({ requestTimeout: 5000 });
-      
+
       const start = Date.now();
-      await expect(
-        fetchHttpHandler.handle({} as any, { requestTimeout: 50 })
-      ).rejects.toHaveProperty("name", "TimeoutError");
-      
+      await expect(fetchHttpHandler.handle({} as any, { requestTimeout: 50 })).rejects.toHaveProperty(
+        "name",
+        "TimeoutError"
+      );
+
       const elapsed = Date.now() - start;
       expect(elapsed).toBeLessThan(100); // should timeout quickly
     });
 
     it("should fall back to handler config timeout when per-request timeout not provided", async () => {
       const mockFetch = vi.fn(() => new Promise(() => {}));
       (global as any).fetch = mockFetch;
-      
+
       const fetchHttpHandler = new FetchHttpHandler({ requestTimeout: 50 });
-      
+
       const start = Date.now();
-      await expect(
-        fetchHttpHandler.handle({} as any, {})
-      ).rejects.toHaveProperty("name", "TimeoutError");
-      
+      await expect(fetchHttpHandler.handle({} as any, {})).rejects.toHaveProperty("name", "TimeoutError");
+
       const elapsed = Date.now() - start;
       expect(elapsed).toBeLessThan(100);
     });
   });
 
-  
   it("will throw timeout error it timeout finishes before request", async () => {
     const mockFetch = vi.fn(() => {
       return new Promise(() => {});

packages/fetch-http-handler/src/fetch-http-handler.ts

@@ -73,7 +73,10 @@ export class FetchHttpHandler implements HttpHandler<FetchHttpHandlerOptions> {
     // Do nothing. TLS and HTTP/2 connection pooling is handled by the browser.
   }
 
-  async handle(request: HttpRequest, { abortSignal, requestTimeout }: HttpHandlerOptions = {}): Promise<{ response: HttpResponse }> {
+  async handle(
+    request: HttpRequest,
+    { abortSignal, requestTimeout }: HttpHandlerOptions = {}
+  ): Promise<{ response: HttpResponse }> {
     if (!this.config) {
       this.config = await this.configProvider;
     }

packages/node-http-handler/src/node-http-handler.spec.ts

@@ -262,17 +262,17 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
   describe("per-request requestTimeout", () => {
     it("should use per-request timeout over handler config timeout", () => {
       const nodeHttpHandler = new NodeHttpHandler({ requestTimeout: 5000 });
-      const mockHandle = vi.spyOn(nodeHttpHandler, 'handle');
+      const mockHandle = vi.spyOn(nodeHttpHandler, "handle");
       const testTimeout = (handlerTimeout: number, requestTimeout?: number) => {
         const handler = new NodeHttpHandler({ requestTimeout: handlerTimeout });
         const options = requestTimeout !== undefined ? { requestTimeout } : {};
         const expectedTimeout = requestTimeout ?? handlerTimeout;
         return expectedTimeout;
       };
-      
+
       // per-request timeout takes precedence
       expect(testTimeout(5000, 100)).toBe(100);
-      
+
       // fallback to handler config
       expect(testTimeout(200, undefined)).toBe(200);
       expect(testTimeout(200)).toBe(200);
@@ -284,7 +284,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         requestTimeout: 5000,
         httpAgent: new http.Agent(),
         httpsAgent: new https.Agent(),
-        logger: console
+        logger: console,
       };
 
       const httpRequest = new HttpRequest({
@@ -294,13 +294,13 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         path: "/",
         headers: {},
       });
-    
+
       const options1 = { requestTimeout: 100 };
       const options2 = {};
-      
+
       const effectiveTimeout1 = options1.requestTimeout ?? (nodeHttpHandler as any).config.requestTimeout;
       const effectiveTimeout2 = options2.requestTimeout ?? (nodeHttpHandler as any).config.requestTimeout;
-      
+
       expect(effectiveTimeout1).toBe(100); // per-request timeout
       expect(effectiveTimeout2).toBe(5000); // handler config timeout
     });

packages/node-http-handler/src/node-http-handler.ts

@@ -152,7 +152,10 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
     this.config?.httpsAgent?.destroy();
   }
 
-  async handle(request: HttpRequest, { abortSignal, requestTimeout }: HttpHandlerOptions = {}): Promise<{ response: HttpResponse }> {
+  async handle(
+    request: HttpRequest,
+    { abortSignal, requestTimeout }: HttpHandlerOptions = {}
+  ): Promise<{ response: HttpResponse }> {
     if (!this.config) {
       this.config = await this.configProvider;
     }

packages/node-http-handler/src/node-http2-handler.spec.ts

@@ -568,45 +568,42 @@ describe(NodeHttp2Handler.name, () => {
   describe("per-request requestTimeout", () => {
     it("should use per-request timeout over handler config timeout", async () => {
       const nodeH2Handler = new NodeHttp2Handler({ requestTimeout: 5000 });
-      
+
       const mockH2Server = mockH2Servers[port1];
       mockH2Server.removeAllListeners("request");
       mockH2Server.on("request", () => {
         // don't respond - let it timeout
       });
-      
+
       const mockRequest = new HttpRequest(getMockReqOptions());
 
       const start = Date.now();
-      await expect(
-        nodeH2Handler.handle(mockRequest, { requestTimeout: 100 })
-      ).rejects.toHaveProperty("name", "TimeoutError");
-      
+      await expect(nodeH2Handler.handle(mockRequest, { requestTimeout: 100 })).rejects.toHaveProperty(
+        "name",
+        "TimeoutError"
+      );
+
       const elapsed = Date.now() - start;
       expect(elapsed).toBeLessThan(200);
     });
 
     it("should fall back to handler config timeout when per-request timeout not provided", async () => {
       const nodeH2Handler = new NodeHttp2Handler({ requestTimeout: 100 });
-      
+
       const mockH2Server = mockH2Servers[port1];
       mockH2Server.removeAllListeners("request");
-      mockH2Server.on("request", () => {
-      });
-      
+      mockH2Server.on("request", () => {});
+
       const mockRequest = new HttpRequest(getMockReqOptions());
 
       const start = Date.now();
-      await expect(
-        nodeH2Handler.handle(mockRequest, {})
-      ).rejects.toHaveProperty("name", "TimeoutError");
-      
+      await expect(nodeH2Handler.handle(mockRequest, {})).rejects.toHaveProperty("name", "TimeoutError");
+
       const elapsed = Date.now() - start;
       expect(elapsed).toBeLessThan(200);
     });
   });
 
-
   describe.each([
     ["object provider", async () => ({ disableConcurrentStreams: true })],
     ["static object", { disableConcurrentStreams: true }],

packages/node-http-handler/src/node-http2-handler.ts

@@ -87,7 +87,10 @@ export class NodeHttp2Handler implements HttpHandler<NodeHttp2HandlerOptions> {
     this.connectionManager.destroy();
   }
 
-  async handle(request: HttpRequest, { abortSignal, requestTimeout }: HttpHandlerOptions = {}): Promise<{ response: HttpResponse }> {
+  async handle(
+    request: HttpRequest,
+    { abortSignal, requestTimeout }: HttpHandlerOptions = {}
+  ): Promise<{ response: HttpResponse }> {
     if (!this.config) {
       this.config = await this.configProvider;
       this.connectionManager.setDisableConcurrentStreams(this.config.disableConcurrentStreams || false);