@helia/delegated-routing-v1-http-api-client 5.1.1 → 5.1.3

package/src/client.ts

@@ -1,5 +1,4 @@
 import { NotFoundError, contentRoutingSymbol, peerRoutingSymbol, setMaxListeners } from '@libp2p/interface'
-import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import { anySignal } from 'any-signal'
@@ -11,14 +10,12 @@ import defer from 'p-defer'
 import PQueue from 'p-queue'
 import { BadResponseError, InvalidRequestError } from './errors.js'
 import { DelegatedRoutingV1HttpApiClientContentRouting, DelegatedRoutingV1HttpApiClientPeerRouting } from './routings.js'
-import type { DelegatedRoutingV1HttpApiClient, DelegatedRoutingV1HttpApiClientInit, GetProvidersOptions, GetPeersOptions, GetIPNSOptions, PeerRecord } from './index.js'
-import type { ContentRouting, PeerRouting, AbortOptions, PeerId } from '@libp2p/interface'
+import type { DelegatedRoutingV1HttpApiClient as DelegatedRoutingV1HttpApiClientInterface, DelegatedRoutingV1HttpApiClientInit, GetProvidersOptions, GetPeersOptions, GetIPNSOptions, PeerRecord, DelegatedRoutingV1HttpApiClientComponents } from './index.js'
+import type { ContentRouting, PeerRouting, AbortOptions, PeerId, Logger } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { IPNSRecord } from 'ipns'
 import type { CID } from 'multiformats'
 
-const log = logger('delegated-routing-v1-http-api-client')
-
 const defaultValues = {
   concurrentRequests: 4,
   timeout: 30e3,
@@ -26,11 +23,11 @@ const defaultValues = {
   cacheName: 'delegated-routing-v1-cache'
 }
 
-export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpApiClient {
+export class DelegatedRoutingV1HttpApiClient implements DelegatedRoutingV1HttpApiClientInterface {
+  public readonly url: URL
   private started: boolean
   private readonly httpQueue: PQueue
   private readonly shutDownController: AbortController
-  private readonly clientUrl: URL
   private readonly timeout: number
   private readonly contentRouting: ContentRouting
   private readonly peerRouting: PeerRouting
@@ -40,10 +37,13 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
   private readonly cacheName: string
   private cache?: Cache
   private readonly cacheTTL: number
+  private log: Logger
+
   /**
    * Create a new DelegatedContentRouting instance
    */
-  constructor (url: string | URL, init: DelegatedRoutingV1HttpApiClientInit = {}) {
+  constructor (components: DelegatedRoutingV1HttpApiClientComponents, init: DelegatedRoutingV1HttpApiClientInit & { url: string | URL }) {
+    this.log = components.logger.forComponent('delegated-routing-v1-http-api-client')
     this.started = false
     this.shutDownController = new AbortController()
     setMaxListeners(Infinity, this.shutDownController.signal)
@@ -51,7 +51,7 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
       concurrency: init.concurrentRequests ?? defaultValues.concurrentRequests
     })
     this.inFlightRequests = new Map() // Tracks in-flight requests to avoid duplicate requests
-    this.clientUrl = url instanceof URL ? url : new URL(url)
+    this.url = init.url instanceof URL ? init.url : new URL(init.url)
     this.timeout = init.timeout ?? defaultValues.timeout
     this.filterAddrs = init.filterAddrs
     this.filterProtocols = init.filterProtocols
@@ -85,7 +85,7 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
       this.cache = await globalThis.caches?.open(this.cacheName)
 
       if (this.cache != null) {
-        log('cache enabled with ttl %d', this.cacheTTL)
+        this.log('cache enabled with ttl %d', this.cacheTTL)
       }
     }
   }
@@ -101,7 +101,7 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
   }
 
   async * getProviders (cid: CID, options: GetProvidersOptions = {}): AsyncGenerator<PeerRecord> {
-    log('getProviders starts: %c', cid)
+    this.log('getProviders starts: %c', cid)
 
     const timeoutSignal = AbortSignal.timeout(this.timeout)
     const signal = anySignal([this.shutDownController.signal, timeoutSignal, options.signal])
@@ -118,10 +118,15 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
       await onStart.promise
 
       // https://specs.ipfs.tech/routing/http-routing-v1/
-      const url = new URL(`${this.clientUrl}routing/v1/providers/${cid}`)
+      const url = new URL(`${this.url}routing/v1/providers/${cid}`)
 
       this.#addFilterParams(url, options.filterAddrs, options.filterProtocols)
-      const getOptions = { headers: { Accept: 'application/x-ndjson' }, signal }
+      const getOptions = {
+        headers: {
+          accept: 'application/x-ndjson, application/json'
+        },
+        signal
+      }
       const res = await this.#makeRequest(url.toString(), getOptions)
 
       if (!res.ok) {
@@ -142,15 +147,22 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
         throw new BadResponseError(`Unexpected status code: ${res.status}`)
       }
 
-      if (res.body == null) {
-        throw new BadResponseError('Routing response had no body')
-      }
-
       const contentType = res.headers.get('Content-Type')
+
       if (contentType == null) {
         throw new BadResponseError('No Content-Type header received')
       }
 
+      if (res.body == null) {
+        if (contentType !== 'application/x-ndjson') {
+          throw new BadResponseError('Routing response had no body')
+        }
+
+        // cached ndjson responses have no body property if the gateway returned
+        // no results
+        return
+      }
+
       if (contentType.startsWith('application/json')) {
         const body = await res.json()
         // Handle null/undefined Providers from servers (both old and new may return empty arrays)
@@ -175,12 +187,12 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
     } finally {
       signal.clear()
       onFinish.resolve()
-      log('getProviders finished: %c', cid)
+      this.log('getProviders finished: %c', cid)
     }
   }
 
   async * getPeers (peerId: PeerId, options: GetPeersOptions = {}): AsyncGenerator<PeerRecord> {
-    log('getPeers starts: %c', peerId)
+    this.log('getPeers starts: %c', peerId)
 
     const timeoutSignal = AbortSignal.timeout(this.timeout)
     const signal = anySignal([this.shutDownController.signal, timeoutSignal, options.signal])
@@ -197,7 +209,7 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
       await onStart.promise
 
       // https://specs.ipfs.tech/routing/http-routing-v1/
-      const url = new URL(`${this.clientUrl}routing/v1/peers/${peerId.toCID().toString()}`)
+      const url = new URL(`${this.url}routing/v1/peers/${peerId.toCID().toString()}`)
       this.#addFilterParams(url, options.filterAddrs, options.filterProtocols)
 
       const getOptions = { headers: { Accept: 'application/x-ndjson' }, signal }
@@ -241,16 +253,16 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
         }
       }
     } catch (err) {
-      log.error('getPeers errored:', err)
+      this.log.error('getPeers errored - %e', err)
     } finally {
       signal.clear()
       onFinish.resolve()
-      log('getPeers finished: %c', peerId)
+      this.log('getPeers finished: %c', peerId)
     }
   }
 
   async getIPNS (libp2pKey: CID<unknown, 0x72, 0x00 | 0x12, 1>, options: GetIPNSOptions = {}): Promise<IPNSRecord> {
-    log('getIPNS starts: %s', libp2pKey)
+    this.log('getIPNS starts: %s', libp2pKey)
 
     const timeoutSignal = AbortSignal.timeout(this.timeout)
     const signal = anySignal([this.shutDownController.signal, timeoutSignal, options.signal])
@@ -264,7 +276,7 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
     })
 
     // https://specs.ipfs.tech/routing/http-routing-v1/
-    const resource = `${this.clientUrl}routing/v1/ipns/${libp2pKey}`
+    const resource = `${this.url}routing/v1/ipns/${libp2pKey}`
 
     try {
       await onStart.promise
@@ -272,7 +284,7 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
       const getOptions = { headers: { Accept: 'application/vnd.ipfs.ipns-record' }, signal }
       const res = await this.#makeRequest(resource, getOptions)
 
-      log('getIPNS GET %s %d', resource, res.status)
+      this.log('getIPNS GET %s %d', resource, res.status)
 
       // Per IPIP-0513: Handle 404 as "no record found" for backward compatibility
       // IPNS is different - we still throw NotFoundError for 404 (backward compat)
@@ -311,18 +323,18 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
 
       return unmarshalIPNSRecord(body)
     } catch (err: any) {
-      log.error('getIPNS GET %s error:', resource, err)
+      this.log.error('getIPNS GET %s error - %e', resource, err)
 
       throw err
     } finally {
       signal.clear()
       onFinish.resolve()
-      log('getIPNS finished: %s', libp2pKey)
+      this.log('getIPNS finished: %s', libp2pKey)
     }
   }
 
   async putIPNS (libp2pKey: CID<unknown, 0x72, 0x00 | 0x12, 1>, record: IPNSRecord, options: AbortOptions = {}): Promise<void> {
-    log('putIPNS starts: %c', libp2pKey)
+    this.log('putIPNS starts: %c', libp2pKey)
 
     const timeoutSignal = AbortSignal.timeout(this.timeout)
     const signal = anySignal([this.shutDownController.signal, timeoutSignal, options.signal])
@@ -336,7 +348,7 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
     })
 
     // https://specs.ipfs.tech/routing/http-routing-v1/
-    const resource = `${this.clientUrl}routing/v1/ipns/${libp2pKey}`
+    const resource = `${this.url}routing/v1/ipns/${libp2pKey}`
 
     try {
       await onStart.promise
@@ -346,19 +358,19 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
       const getOptions = { method: 'PUT', headers: { 'Content-Type': 'application/vnd.ipfs.ipns-record' }, body, signal }
       const res = await this.#makeRequest(resource, getOptions)
 
-      log('putIPNS PUT %s %d', resource, res.status)
+      this.log('putIPNS PUT %s %d', resource, res.status)
 
       if (res.status !== 200) {
         throw new BadResponseError('PUT ipns response had status other than 200')
       }
     } catch (err: any) {
-      log.error('putIPNS PUT %s error:', resource, err.stack)
+      this.log.error('putIPNS PUT %s error - %e', resource, err.stack)
 
       throw err
     } finally {
       signal.clear()
       onFinish.resolve()
-      log('putIPNS finished: %c', libp2pKey)
+      this.log('putIPNS finished: %c', libp2pKey)
     }
   }
 
@@ -384,7 +396,7 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
         Protocols: protocols
       }
     } catch (err) {
-      log.error('could not conform record to peer schema', err)
+      this.log.error('could not conform record to peer schema - %e', err)
     }
   }
 
@@ -416,16 +428,22 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
     // Only try to use cache for GET requests
     if (requestMethod === 'GET') {
       const cachedResponse = await this.cache?.match(url)
+
       if (cachedResponse != null) {
         // Check if the cached response has expired
         const expires = parseInt(cachedResponse.headers.get('x-cache-expires') ?? '0', 10)
         if (expires > Date.now()) {
-          log('returning cached response for %s', key)
+          this.log('returning cached response for %s', key)
+          this.logResponse(cachedResponse)
+
           return cachedResponse
         } else {
+          this.log('evicting cached response for %s', key)
           // Remove expired response from cache
           await this.cache?.delete(url)
         }
+      } else if (this.cache != null) {
+        this.log('cache miss for %s', key)
       }
     }
 
@@ -433,12 +451,18 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
     const existingRequest = this.inFlightRequests.get(key)
     if (existingRequest != null) {
       const response = await existingRequest
-      log('deduplicating outgoing request for %s', key)
+      this.log('deduplicating outgoing request for %s', key)
       return response.clone()
     }
 
+    this.log('outgoing request:')
+    this.logRequest(url, options)
+
     // Create new request and track it
     const requestPromise = fetch(url, options).then(async response => {
+      this.log('incoming response:')
+      this.logResponse(response)
+
       // Only cache successful GET requests
       if (this.cache != null && response.ok && requestMethod === 'GET') {
         const expires = Date.now() + this.cacheTTL
@@ -464,4 +488,25 @@ export class DefaultDelegatedRoutingV1HttpApiClient implements DelegatedRoutingV
     const response = await requestPromise
     return response
   }
+
+  toString (): string {
+    return `DefaultDelegatedRoutingV1HttpApiClient(${this.url})`
+  }
+
+  private logRequest (url: string, init: RequestInit): void {
+    const headers = new Headers(init.headers)
+    this.log('%s %s HTTP/1.1', init.method ?? 'GET', url)
+
+    for (const [key, value] of headers.entries()) {
+      this.log('%s: %s', key, value)
+    }
+  }
+
+  private logResponse (response: Response): void {
+    this.log('HTTP/1.1 %d %s', response.status, response.statusText)
+
+    for (const [key, value] of response.headers.entries()) {
+      this.log('%s: %s', key, value)
+    }
+  }
 }

package/src/index.ts

@@ -83,8 +83,9 @@
  * ```
  */
 
-import { DefaultDelegatedRoutingV1HttpApiClient } from './client.js'
-import type { AbortOptions, PeerId } from '@libp2p/interface'
+import { defaultLogger } from '@libp2p/logger'
+import { DelegatedRoutingV1HttpApiClient as DelegatedRoutingV1HttpApiClientClass } from './client.js'
+import type { AbortOptions, ComponentLogger, PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { IPNSRecord } from 'ipns'
 import type { CID } from 'multiformats/cid'
@@ -155,6 +156,10 @@ export interface DelegatedRoutingV1HttpApiClientInit extends FilterOptions {
   cacheName?: string
 }
 
+export interface DelegatedRoutingV1HttpApiClientComponents {
+  logger: ComponentLogger
+}
+
 export interface GetIPNSOptions extends AbortOptions {
   /**
    * By default incoming IPNS records are validated, pass false here to skip
@@ -169,6 +174,11 @@ export type GetProvidersOptions = FilterOptions & AbortOptions
 export type GetPeersOptions = FilterOptions & AbortOptions
 
 export interface DelegatedRoutingV1HttpApiClient {
+  /**
+   * The URL that requests are sent to
+   */
+  url: URL
+
   /**
    * Returns an async generator of {@link PeerRecord}s that can provide the
    * content for the passed {@link CID}
@@ -206,7 +216,23 @@ export interface DelegatedRoutingV1HttpApiClient {
 
 /**
  * Create and return a client to use with a Routing V1 HTTP API server
+ *
+ * @deprecated use `delegatedRoutingV1HttpApiClient` instead - this function will be removed in a future release
+ */
+export function createDelegatedRoutingV1HttpApiClient (url: URL | string, init: Omit<DelegatedRoutingV1HttpApiClientInit, 'url'> = {}): DelegatedRoutingV1HttpApiClient {
+  return new DelegatedRoutingV1HttpApiClientClass({
+    logger: defaultLogger()
+  }, {
+    ...init,
+    url: new URL(url)
+  })
+}
+
+/**
+ * Create and return a client to use with a Routing V1 HTTP API server
+ *
+ * TODO: add `url` to `DelegatedRoutingV1HttpApiClientInit` interface and release as breaking change
  */
-export function createDelegatedRoutingV1HttpApiClient (url: URL | string, init: DelegatedRoutingV1HttpApiClientInit = {}): DelegatedRoutingV1HttpApiClient {
-  return new DefaultDelegatedRoutingV1HttpApiClient(new URL(url), init)
+export function delegatedRoutingV1HttpApiClient (init: DelegatedRoutingV1HttpApiClientInit & { url: string | URL }): (components: DelegatedRoutingV1HttpApiClientComponents) => DelegatedRoutingV1HttpApiClient {
+  return (components) => new DelegatedRoutingV1HttpApiClientClass(components, init)
 }

package/src/routings.ts

@@ -86,6 +86,10 @@ export class DelegatedRoutingV1HttpApiClientContentRouting implements ContentRou
       throw err
     }
   }
+
+  toString (): string {
+    return `DelegatedRoutingV1HttpApiClientContentRouting(${this.client.url})`
+  }
 }
 
 /**
@@ -114,4 +118,8 @@ export class DelegatedRoutingV1HttpApiClientPeerRouting implements PeerRouting {
   async * getClosestPeers (key: Uint8Array, options: AbortOptions = {}): AsyncIterable<PeerInfo> {
     // noop
   }
+
+  toString (): string {
+    return `DelegatedRoutingV1HttpApiClientPeerRouting(${this.client.url})`
+  }
 }