feat: fix for failing tests due to dep changes

Author: devlux76

packages/protocol-http/src/http-client.ts

@@ -3,6 +3,7 @@
  */
 import { AbortError, setMaxListeners } from '@libp2p/interface'
 import { pbStream } from 'it-protobuf-stream'
+import { URL } from './common/url.js'
 import { HttpConstants } from './constants.js'
 import { type HttpComponents } from './http-components-interface.js'
 import { http } from './http-proto-api.js'
@@ -97,29 +98,66 @@ export class HttpClient implements Startable {
         const result = JSON.parse(contentString) as ProtocolDiscoveryResult
         this.log.trace('discovered %d protocols from %p', result.protocols.length, peer)
         return result
-      } catch (err) {
-        throw new Error('Invalid protocol discovery response: ' + err.message)
+      } catch (err: unknown) {
+        const errMessage = err instanceof Error ? err.message : String(err)
+        throw new Error('Invalid protocol discovery response: ' + errMessage)
       }
-    } catch (err) {
-      this.log.error('protocol discovery failed - %e', err)
+    } catch (err: any) {
+      this.log.error('protocol discovery failed - %e', err?.message)
       throw err
     }
   }
 
-  async fetch (peer: PeerId, request: http.HttpRequest, options: AbortOptions = {}): Promise<http.HttpResponse> {
+  /**
+   * Send an HTTP request to a peer or URL
+   */
+  async fetch (peerOrUrl: PeerId | string | URL, request: http.HttpRequest, options: AbortOptions = {}): Promise<http.HttpResponse> {
     if (!this.isStarted()) {
       // Auto-start the client if it hasn't been started
       await this.start()
     }
 
-    this.log.trace('sending %s request to %p for %s', request.method, peer, request.targetUri)
+    // Handle URL version of the overload
+    if (typeof peerOrUrl === 'string' || peerOrUrl instanceof URL) {
+      const urlString = typeof peerOrUrl === 'string' ? peerOrUrl : peerOrUrl.toString()
+      const url = typeof peerOrUrl === 'string' ? new URL(peerOrUrl) : peerOrUrl
+      const hostname = url.hostname
+
+      if (hostname === undefined || hostname === null || hostname === '') {
+        throw new Error(`Invalid URL: ${urlString}, missing hostname`)
+      }
+
+      try {
+        // Import PeerId dynamically to avoid circular dependencies
+        const { peerIdFromString } = await import('@libp2p/peer-id')
+        const peer = peerIdFromString(hostname)
+
+        // Set the target URI to the path and query of the URL
+        const targetUri = url.pathname + (url.search !== '' ? url.search : '')
+        const modifiedRequest = {
+          ...request,
+          targetUri
+        }
+
+        this.log.trace('sending %s request to peer %s for %s', modifiedRequest.method, hostname, modifiedRequest.targetUri)
+        return await this.fetch(peer, modifiedRequest, options)
+      } catch (err) {
+        // If we can't create a peer ID from the hostname, this is likely a regular web URL
+        // In this case, we should handle it as a clear web request or throw an appropriate error
+        this.log.error('not a valid peer ID in URL hostname: %s', hostname)
+        throw new Error(`Cannot route to ${urlString}: hostname is not a valid peer ID`)
+      }
+    }
+
+    // Original implementation for PeerId
+    this.log.trace('sending %s request to %p for %s', request.method, peerOrUrl, request.targetUri)
     let connection
     let stream: Stream | undefined
     let signal = options.signal
     let onAbort = (): void => {}
 
     try {
-      connection = await this.components.connectionManager.openConnection(peer, options)
+      connection = await this.components.connectionManager.openConnection(peerOrUrl, options)
 
       if (signal == null) {
         const timeout = this.init.timeout ?? DEFAULT_TIMEOUT
@@ -143,10 +181,10 @@ export class HttpClient implements Startable {
       const response = await pb.read(http.HttpResponse, options)
       await pb.unwrap().close(options)
 
-      this.log.trace('received response with status %d from %p', response.statusCode, peer)
+      this.log.trace('received response with status %d from %p', response.statusCode, peerOrUrl)
       return response
     } catch (err: any) {
-      this.log.error('error fetching from %p - %e', peer, err)
+      this.log.error('error fetching from %p - %e', peerOrUrl, err)
       if (stream != null) {
         stream.abort(err)
       }

packages/protocol-http/src/interfaces/http-client-interface.ts

@@ -10,9 +10,14 @@ import type { AbortOptions, PeerId } from '@libp2p/interface'
  */
 export interface HttpClientInterface {
   /**
-   * Sends an HTTP request to a remote peer
+   * Sends an HTTP request to a remote peer or URL
+   * 
+   * @param peerOrUrl - The peer ID or URL to send the request to
+   * @param request - The HTTP request to send
+   * @param options - Optional abort options
+   * @returns A promise that resolves to the HTTP response
    */
-  fetch(peer: PeerId, request: http.HttpRequest, options?: AbortOptions): Promise<http.HttpResponse>
+  fetch(peerOrUrl: PeerId | string | URL, request: http.HttpRequest, options?: AbortOptions): Promise<http.HttpResponse>
 
   /**
    * Discover protocols supported by a remote peer

packages/protocol-http/test/007-http-client.spec.ts

@@ -8,6 +8,7 @@ import { webRTC, webRTCDirect } from '@libp2p/webrtc'
 import { expect } from 'aegir/chai'
 import { createLibp2p } from 'libp2p'
 import { createSandbox } from 'sinon'
+import { URL } from '../src/common/url.js'
 import { HttpClientFactory } from '../src/http-client-factory.js'
 import { getNodeConfig } from './common/node-config.js'
 import type { http } from '../src/http-proto-api.js'
@@ -82,8 +83,8 @@ describe('007-HTTP Client Implementation', () => {
         trailers: []
       }
     }
-    await expect(client.fetch(new URL('libp2p://test'), request))
-      .to.be.rejectedWith('Invalid URL: could not extract peer ID from libp2p://test')
+    await expect(client.fetch(new URL('https://test'), request))
+      .to.be.rejectedWith('Invalid URL: could not extract peer ID from https://test')
   })
 
   it('should handle invalid address', async () => {
@@ -98,7 +99,7 @@ describe('007-HTTP Client Implementation', () => {
       }
     }
     const validPeerId = '12D3KooWGC6nRXh5ZXvpeqscJCEiYkGYvXZr5RfKJ6iBXqE3Xa7X'
-    await expect(client.fetch(new URL(`libp2p://${validPeerId}`), request))
+    await expect(client.fetch(new URL(`https://${validPeerId}`), request))
       .to.be.rejectedWith('The dial request has no valid addresses')
   })
 })