@helia/verified-fetch 3.2.3 → 4.0.1

package/src/plugins/plugin-handle-dag-walk.ts

@@ -1,38 +1,44 @@
 import { code as dagCborCode } from '@ipld/dag-cbor'
 import { code as dagPbCode } from '@ipld/dag-pb'
+import { CODEC_IDENTITY } from '../constants.ts'
 import { handlePathWalking } from '../utils/walk-path.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
 
 /**
- * This plugin should almost always run first because it's going to handle path walking if needed, and will only say it can handle
- * the request if path walking is possible (path is not empty, terminalCid is unknown, and the path has not been walked yet).
+ * This plugin should almost always run first because it's going to handle path
+ * walking if needed, and will only say it can handle the request if path
+ * walking is possible (path is not empty, terminalCid is unknown, and the path
+ * has not been walked yet).
  *
- * Once this plugin has run, the PluginContext will be updated and then this plugin will return false for canHandle, so it won't run again.
+ * Once this plugin has run, the PluginContext will be updated and then this
+ * plugin will return false for canHandle, so it won't run again.
  */
 export class DagWalkPlugin extends BasePlugin {
   readonly id = 'dag-walk-plugin'
+
   /**
-   * Return false if the path has already been walked, otherwise return true if the CID is encoded with a codec that supports pathing.
+   * Return false if the path has already been walked, otherwise return true if
+   * the CID is encoded with a codec that supports pathing.
    */
   canHandle (context: PluginContext): boolean {
-    this.log('checking if we can handle %c with accept %s', context.cid, context.accept)
     const { pathDetails, cid } = context
+
     if (pathDetails != null) {
       // path has already been walked
       return false
     }
 
-    return (cid.code === dagPbCode || cid.code === dagCborCode)
+    return (cid.code === dagPbCode || cid.code === dagCborCode || cid.multihash.code === CODEC_IDENTITY)
   }
 
   async handle (context: PluginContext): Promise<Response | null> {
-    const { cid, resource, options, withServerTiming = false } = context
-    const { getBlockstore, handleServerTiming } = this.pluginOptions
+    const { cid, resource, options } = context
+    const { getBlockstore } = this.pluginOptions
     const blockstore = getBlockstore(cid, resource, options?.session ?? true, options)
 
     // TODO: migrate handlePathWalking into this plugin
-    const pathDetails = await handleServerTiming('path-walking', '', async () => handlePathWalking({ ...context, blockstore, log: this.log }), withServerTiming)
+    const pathDetails = await context.serverTiming.time('path-walking', '', handlePathWalking({ ...context, blockstore, log: this.log }))
 
     if (pathDetails instanceof Response) {
       this.log.trace('path walking failed')

package/src/plugins/plugin-handle-ipns-record.ts

@@ -1,11 +1,6 @@
-import { Record as DHTRecord } from '@libp2p/kad-dht'
-import { Key } from 'interface-datastore'
-import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { marshalIPNSRecord } from 'ipns'
 import { getPeerIdFromString } from '../utils/get-peer-id-from-string.js'
 import { badRequestResponse, okRangeResponse } from '../utils/responses.js'
-import { PluginFatalError } from './errors.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
 import type { PeerId } from '@libp2p/interface'
@@ -17,27 +12,30 @@ import type { PeerId } from '@libp2p/interface'
 export class IpnsRecordPlugin extends BasePlugin {
   readonly id = 'ipns-record-plugin'
   readonly codes = []
-  canHandle ({ cid, accept, query, byteRangeContext }: PluginContext): boolean {
-    this.log('checking if we can handle %c with accept %s', cid, accept)
+
+  canHandle ({ resource, accept, query, path, byteRangeContext }: PluginContext): boolean {
     if (byteRangeContext == null) {
       return false
     }
 
-    return accept === 'application/vnd.ipfs.ipns-record' || query.format === 'ipns-record'
+    return accept?.mimeType === 'application/vnd.ipfs.ipns-record' || query.format === 'ipns-record'
   }
 
   async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {
-    const { resource, path, options } = context
-    const { helia } = this.pluginOptions
+    const { resource, path, query, options } = context
+    const { ipnsResolver } = this.pluginOptions
     context.reqFormat = 'ipns-record'
+
     if (path !== '' || !(resource.startsWith('ipns://') || resource.includes('.ipns.') || resource.includes('/ipns/'))) {
       this.log.error('invalid request for IPNS name "%s" and path "%s"', resource, path)
-      throw new PluginFatalError('ERR_INVALID_IPNS_NAME', 'Invalid IPNS name', { response: badRequestResponse(resource, new Error('Invalid IPNS name')) })
+      return badRequestResponse(resource, new Error('Invalid IPNS name'))
     }
+
     let peerId: PeerId
 
     try {
       let peerIdString: string
+
       if (resource.startsWith('ipns://')) {
         peerIdString = resource.replace('ipns://', '')
       } else if (resource.includes('/ipns/')) {
@@ -51,24 +49,23 @@ export class IpnsRecordPlugin extends BasePlugin {
     } catch (err: any) {
       this.log.error('could not parse peer id from IPNS url %s', resource, err)
 
-      throw new PluginFatalError('ERR_NO_PEER_ID_FOUND', 'could not parse peer id from url', { response: badRequestResponse(resource, err) })
+      return badRequestResponse(resource, err)
     }
 
-    // since this call happens after parseResource, we've already resolved the
-    // IPNS name so a local copy should be in the helia datastore, so we can
-    // just read it out..
-    const routingKey = uint8ArrayConcat([
-      uint8ArrayFromString('/ipns/'),
-      peerId.toMultihash().bytes
-    ])
-    const datastoreKey = new Key('/dht/record/' + uint8ArrayToString(routingKey, 'base32'), false)
-    const buf = await helia.datastore.get(datastoreKey, options)
-    const record = DHTRecord.deserialize(buf)
+    // force download in handleFinalResponse
+    query.filename = query.filename ?? `${peerId}.bin`
+    query.download = true
+
+    // @ts-expect-error progress handler types are incompatible
+    const result = await ipnsResolver.resolve(peerId, options)
+    const buf = marshalIPNSRecord(result.record)
 
-    context.byteRangeContext.setBody(record.value)
+    context.byteRangeContext.setBody(buf)
 
     const response = okRangeResponse(resource, context.byteRangeContext.getBody('application/vnd.ipfs.ipns-record'), { byteRangeContext: context.byteRangeContext, log: this.log })
     response.headers.set('content-type', context.byteRangeContext.getContentType() ?? 'application/vnd.ipfs.ipns-record')
+    response.headers.set('content-length', buf.byteLength.toString())
+    response.headers.set('x-ipfs-roots', result.cid.toV1().toString())
 
     return response
   }

package/src/plugins/plugin-handle-json.ts

@@ -1,5 +1,6 @@
 import * as ipldDagCbor from '@ipld/dag-cbor'
 import * as ipldDagJson from '@ipld/dag-json'
+import toBuffer from 'it-to-buffer'
 import { code as jsonCode } from 'multiformats/codecs/json'
 import { notAcceptableResponse, okRangeResponse } from '../utils/responses.js'
 import { BasePlugin } from './plugin-base.js'
@@ -11,13 +12,13 @@ import type { PluginContext } from './types.js'
 export class JsonPlugin extends BasePlugin {
   readonly id = 'json-plugin'
   readonly codes = [ipldDagJson.code, jsonCode]
+
   canHandle ({ cid, accept, byteRangeContext }: PluginContext): boolean {
-    this.log('checking if we can handle %c with accept %s', cid, accept)
     if (byteRangeContext == null) {
       return false
     }
 
-    if (accept === 'application/vnd.ipld.dag-json' && cid.code !== ipldDagCbor.code) {
+    if (accept?.mimeType === 'application/vnd.ipld.dag-json' && cid.code !== ipldDagCbor.code) {
       // we can handle application/vnd.ipld.dag-json, but if the CID codec is ipldDagCbor, DagCborPlugin should handle it
       // TODO: remove the need for deny-listing cases in plugins
       return true
@@ -35,10 +36,10 @@ export class JsonPlugin extends BasePlugin {
 
     const terminalCid = context.pathDetails?.terminalElement.cid ?? context.cid
     const blockstore = getBlockstore(terminalCid, resource, session, options)
-    const block = await blockstore.get(terminalCid, options)
+    const block = await toBuffer(blockstore.get(terminalCid, options))
     let body: string | Uint8Array
 
-    if (accept === 'application/vnd.ipld.dag-cbor' || accept === 'application/cbor') {
+    if (accept?.mimeType === 'application/vnd.ipld.dag-cbor' || accept?.mimeType === 'application/cbor') {
       try {
         // if vnd.ipld.dag-cbor has been specified, convert to the format - note
         // that this supports more data types than regular JSON, the content-type
@@ -62,7 +63,7 @@ export class JsonPlugin extends BasePlugin {
         contentType = 'application/json'
       }
     } else {
-      contentType = accept.split(';')[0]
+      contentType = accept?.mimeType.split(';')[0]
     }
 
     context.byteRangeContext.setBody(body)

package/src/plugins/plugin-handle-raw.ts

@@ -1,10 +1,11 @@
+import toBuffer from 'it-to-buffer'
 import { code as rawCode } from 'multiformats/codecs/raw'
 import { identity } from 'multiformats/hashes/identity'
 import { getContentType } from '../utils/get-content-type.js'
 import { notFoundResponse, okRangeResponse } from '../utils/responses.js'
-import { PluginFatalError } from './errors.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
+import type { AcceptHeader } from '../utils/select-output-type.ts'
 
 /**
  * These are Accept header values that will cause content type sniffing to be
@@ -22,9 +23,9 @@ const RAW_HEADERS = [
  * type. This avoids the user from receiving something different when they
  * signal that they want to `Accept` a specific mime type.
  */
-function getOverriddenRawContentType ({ headers, accept }: { headers?: HeadersInit, accept?: string }): string | undefined {
+function getOverriddenRawContentType ({ headers, accept }: { headers?: HeadersInit, accept?: AcceptHeader }): string | undefined {
   // accept has already been resolved by getResolvedAcceptHeader, if we have it, use it.
-  const acceptHeader = accept ?? new Headers(headers).get('accept') ?? ''
+  const acceptHeader = accept?.mimeType ?? new Headers(headers).get('accept') ?? ''
 
   // e.g. "Accept: text/html, application/xhtml+xml, application/xml;q=0.9, image/webp, */*;q=0.8"
   const acceptHeaders = acceptHeader.split(',')
@@ -47,11 +48,11 @@ export class RawPlugin extends BasePlugin {
   codes: number[] = [rawCode, identity.code]
 
   canHandle ({ cid, accept, query, byteRangeContext }: PluginContext): boolean {
-    this.log('checking if we can handle %c with accept %s', cid, accept)
     if (byteRangeContext == null) {
       return false
     }
-    return accept === 'application/vnd.ipld.raw' || query.format === 'raw'
+
+    return accept?.mimeType === 'application/vnd.ipld.raw' || query.format === 'raw'
   }
 
   async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {
@@ -60,36 +61,49 @@ export class RawPlugin extends BasePlugin {
     const session = options?.session ?? true
     const log = this.log
 
-    if (accept === 'application/vnd.ipld.raw' || query.format === 'raw') {
+    if (accept?.mimeType === 'application/vnd.ipld.raw' || query.format === 'raw') {
       context.reqFormat = 'raw'
       context.query.download = true
       context.query.filename = context.query.filename ?? `${cid.toString()}.bin`
-      log.trace('Set content disposition...')
+      log.trace('set content disposition to force download')
     } else {
-      log.trace('Did NOT set content disposition...')
+      log.trace('did not set content disposition, raw block will display inline')
     }
 
     if (path !== '' && cid.code === rawCode) {
       log.trace('404-ing raw codec request for %c/%s', cid, path)
-      // throw new PluginError('ERR_RAW_PATHS_NOT_SUPPORTED', 'Raw codec does not support paths')
-      // return notFoundResponse(resource, 'Raw codec does not support paths')
-      throw new PluginFatalError('ERR_RAW_PATHS_NOT_SUPPORTED', 'Raw codec does not support paths', { response: notFoundResponse(resource, 'Raw codec does not support paths') })
+      return notFoundResponse(resource)
     }
 
     const terminalCid = context.pathDetails?.terminalElement.cid ?? context.cid
     const blockstore = getBlockstore(terminalCid, resource, session, options)
-    const result = await blockstore.get(terminalCid, options)
+    const result = await toBuffer(blockstore.get(terminalCid, options))
+
     context.byteRangeContext.setBody(result)
 
     // if the user has specified an `Accept` header that corresponds to a raw
     // type, honour that header, so for example they don't request
     // `application/vnd.ipld.raw` but get `application/octet-stream`
-    const contentType = await getContentType({ filename: query.filename, bytes: result, path, defaultContentType: getOverriddenRawContentType({ headers: options?.headers, accept }), contentTypeParser, log })
+    const contentType = await getContentType({
+      filename: query.filename,
+      bytes: result,
+      path,
+      defaultContentType: getOverriddenRawContentType({ headers: options?.headers, accept }),
+      contentTypeParser,
+      log
+    })
+
     const response = okRangeResponse(resource, context.byteRangeContext.getBody(contentType), { byteRangeContext: context.byteRangeContext, log }, {
       redirected: false
     })
 
     response.headers.set('content-type', context.byteRangeContext.getContentType() ?? contentType)
+    response.headers.set('x-ipfs-roots', terminalCid.toV1().toString())
+
+    // only set content-length if it is not a range request
+    if (!context.byteRangeContext.isRangeRequest) {
+      response.headers.set('content-length', result.byteLength.toString())
+    }
 
     return response
   }

package/src/plugins/plugin-handle-tar.ts

@@ -14,12 +14,13 @@ import type { PluginContext } from './types.js'
 export class TarPlugin extends BasePlugin {
   readonly id = 'tar-plugin'
   readonly codes = []
+
   canHandle ({ cid, accept, query, byteRangeContext }: PluginContext): boolean {
-    this.log('checking if we can handle %c with accept %s', cid, accept)
     if (byteRangeContext == null) {
       return false
     }
-    return accept === 'application/x-tar' || query.format === 'tar'
+
+    return accept?.mimeType === 'application/x-tar' || query.format === 'tar'
   }
 
   async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {

package/src/plugins/types.ts

@@ -1,10 +1,10 @@
-import type { PluginError } from './errors.js'
-import type { VerifiedFetchInit } from '../index.js'
-import type { ContentTypeParser, RequestFormatShorthand } from '../types.js'
+import type { ResolveURLResult, UrlQuery, VerifiedFetchInit, ContentTypeParser, RequestFormatShorthand } from '../index.js'
 import type { ByteRangeContext } from '../utils/byte-range-context.js'
-import type { ParsedUrlStringResults } from '../utils/parse-url-string.js'
+import type { AcceptHeader } from '../utils/select-output-type.ts'
+import type { ServerTiming } from '../utils/server-timing.ts'
 import type { PathWalkerResponse } from '../utils/walk-path.js'
-import type { AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
+import type { IPNSResolver } from '@helia/ipns'
+import type { AbortOptions, Logger } from '@libp2p/interface'
 import type { Helia } from 'helia'
 import type { Blockstore } from 'interface-blockstore'
 import type { UnixFSEntry } from 'ipfs-unixfs-exporter'
@@ -17,11 +17,11 @@ import type { CustomProgressEvent } from 'progress-events'
  * - Persistent: Relevant even after the request completes (e.g., logging or metrics).
  */
 export interface PluginOptions {
-  logger: ComponentLogger
+  logger: Logger
   getBlockstore(cid: CID, resource: string | CID, useSession?: boolean, options?: AbortOptions): Blockstore
-  handleServerTiming<T>(name: string, description: string, fn: () => Promise<T>, withServerTiming: boolean): Promise<T>
   contentTypeParser?: ContentTypeParser
   helia: Helia
+  ipnsResolver: IPNSResolver
 }
 
 /**
@@ -30,30 +30,30 @@ export interface PluginOptions {
  * - Shared Data: Allows plugins to communicate partial results, discovered data, or interim errors.
  * - Ephemeral: Typically discarded once fetch(...) completes.
  */
-export interface PluginContext extends ParsedUrlStringResults {
+export interface PluginContext extends ResolveURLResult {
   readonly cid: CID
   readonly path: string
   readonly resource: string
-  readonly accept?: string
+  readonly accept?: AcceptHeader
 
   /**
    * An array of plugin IDs that are all enabled. You can use this to check if a plugin is enabled and respond accordingly.
    */
   plugins: string[]
+
   /**
    * The last time the context is modified, so we know whether a plugin has modified it.
    * A plugin should increment this value if it modifies the context.
    */
   modified: number
-  withServerTiming?: boolean
   onProgress?(evt: CustomProgressEvent<any>): void
   options?: Omit<VerifiedFetchInit, 'signal'> & AbortOptions
   isDirectory?: boolean
   directoryEntries?: UnixFSEntry[]
-  errors?: PluginError[]
   reqFormat?: RequestFormatShorthand
   pathDetails?: PathWalkerResponse
-  query: ParsedUrlStringResults['query']
+  query: UrlQuery
+
   /**
    * ByteRangeContext contains information about the size of the content and range requests.
    * This can be used to set the Content-Length header without loading the entire body.
@@ -61,6 +61,12 @@ export interface PluginContext extends ParsedUrlStringResults {
    * This is set by the ByteRangeContextPlugin
    */
   byteRangeContext?: ByteRangeContext
+  serverTiming: ServerTiming
+  ipfsPath: string
+
+  /**
+   * Allow arbitrary keys/values
+   */
   [key: string]: unknown
 }
 
@@ -81,7 +87,3 @@ export interface PluginErrorOptions {
   details?: Record<string, any>
   response?: Response
 }
-
-export interface FatalPluginErrorOptions extends PluginErrorOptions {
-  response: Response
-}

package/src/url-resolver.ts

@@ -0,0 +1,159 @@
+import { peerIdFromCID, peerIdFromString } from '@libp2p/peer-id'
+import { CID } from 'multiformats/cid'
+import { matchURLString } from './utils/parse-url-string.ts'
+import type { ResolveURLOptions, ResolveURLResult, Resource, URLResolver as URLResolverInterface } from './index.ts'
+import type { ServerTiming } from './utils/server-timing.ts'
+import type { DNSLink } from '@helia/dnslink'
+import type { IPNSResolver } from '@helia/ipns'
+import type { AbortOptions, PeerId } from '@libp2p/interface'
+
+const CODEC_LIBP2P_KEY = 0x72
+
+export interface URLResolverComponents {
+  ipnsResolver: IPNSResolver
+  dnsLink: DNSLink
+  timing: ServerTiming
+}
+
+function toQuery (query?: string): Record<string, any> {
+  if (query == null) {
+    return {}
+  }
+
+  const params = new URLSearchParams(query)
+  const output: Record<string, any> = {}
+
+  for (const [key, value] of params.entries()) {
+    output[key] = value
+
+    if (value === 'true') {
+      output[key] = true
+    }
+
+    if (value === 'false') {
+      output[key] = false
+    }
+  }
+
+  return output
+}
+
+export class URLResolver implements URLResolverInterface {
+  private readonly components: URLResolverComponents
+
+  constructor (components: URLResolverComponents) {
+    this.components = components
+  }
+
+  async resolve (resource: Resource, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
+    if (typeof resource === 'string') {
+      return this.parseUrlString(resource, options)
+    }
+
+    const cid = CID.asCID(resource)
+
+    if (cid != null) {
+      return this.resolveCIDResource(cid, '', {}, options)
+    }
+
+    throw new TypeError(`Invalid resource. Cannot determine CID from resource: ${resource}`)
+  }
+
+  async parseUrlString (urlString: string, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
+    const { protocol, cidOrPeerIdOrDnsLink, path, query } = matchURLString(urlString)
+
+    if (protocol === 'ipfs') {
+      const cid = CID.parse(cidOrPeerIdOrDnsLink)
+
+      return this.resolveCIDResource(cid, path ?? '', toQuery(query), options)
+    }
+
+    if (protocol === 'ipns') {
+      // try to parse target as peer id
+      let peerId: PeerId
+
+      try {
+        peerId = peerIdFromString(cidOrPeerIdOrDnsLink)
+      } catch {
+        // fall back to DNSLink (e.g. /ipns/example.com)
+        return this.resolveDNSLink(cidOrPeerIdOrDnsLink, path ?? '', toQuery(query), options)
+      }
+
+      // parse multihash from string (e.g. /ipns/QmFoo...)
+      return this.resolveIPNSName(cidOrPeerIdOrDnsLink, peerId, path ?? '', toQuery(query), options)
+    }
+
+    throw new TypeError(`Invalid resource. Cannot determine CID from resource: ${urlString}`)
+  }
+
+  async resolveCIDResource (cid: CID, path: string, query: Record<string, any>, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
+    if (cid.code === CODEC_LIBP2P_KEY) {
+      // special case - peer id encoded as a CID
+      return this.resolveIPNSName(cid.toString(), peerIdFromCID(cid), path, query, options)
+    }
+
+    return {
+      cid,
+      protocol: 'ipfs',
+      query,
+      path,
+      ttl: 29030400, // 1 year for ipfs content
+      ipfsPath: `/ipfs/${cid}${path === '' ? '' : `/${path}`}`
+    }
+  }
+
+  async resolveDNSLink (domain: string, path: string, query: Record<string, any>, options?: ResolveURLOptions): Promise<ResolveURLResult> {
+    const results = await this.components.timing.time('dnsLink.resolve', `Resolve DNSLink ${domain}`, this.components.dnsLink.resolve(domain, options))
+    const result = results?.[0]
+
+    if (result == null) {
+      throw new TypeError(`Invalid resource. Cannot resolve DNSLink from domain: ${domain}`)
+    }
+
+    // dnslink resolved to IPNS name
+    if (result.namespace === 'ipns') {
+      return this.resolveIPNSName(domain, result.peerId, path, query, options)
+    }
+
+    // dnslink resolved to CID
+    if (result.namespace !== 'ipfs') {
+      // @ts-expect-error result namespace should only be ipns or ipfs
+      throw new TypeError(`Invalid resource. Unexpected DNSLink namespace ${result.namespace} from domain: ${domain}`)
+    }
+
+    return {
+      cid: result.cid,
+      path: concatPaths(result.path, path),
+      // dnslink is mutable so return 'ipns' protocol so we do not include immutable in cache-control header
+      protocol: 'ipns',
+      ttl: result.answer.TTL,
+      query,
+      ipfsPath: `/ipns/${domain}${path === '' ? '' : `/${path}`}`
+    }
+  }
+
+  async resolveIPNSName (resource: string, key: PeerId, path: string, query: Record<string, any>, options?: AbortOptions): Promise<ResolveURLResult> {
+    const result = await this.components.timing.time('ipns.resolve', `Resolve IPNS name ${key}`, this.components.ipnsResolver.resolve(key, options))
+
+    return {
+      cid: result.cid,
+      path: concatPaths(result.path, path),
+      query,
+      protocol: 'ipns',
+      // IPNS ttl is in nanoseconds, convert to seconds
+      ttl: Number((result.record.ttl ?? 0n) / BigInt(1e9)),
+      ipfsPath: `/ipns/${resource}${path === '' ? '' : `/${path}`}`
+    }
+  }
+}
+
+function concatPaths (...paths: Array<string | undefined>): string {
+  return `${
+    paths
+      .filter(p => p != null && p !== '')
+      .join('/')
+      .replaceAll(/(\/+)/g, '/')
+      .replace(/^(\/)+/, '')
+      .replace(/(\/)+$/, '/')
+  }`
+}

package/src/utils/byte-range-context.ts

@@ -2,8 +2,8 @@ import toBrowserReadableStream from 'it-to-browser-readablestream'
 import { InvalidRangeError } from '../errors.js'
 import { calculateByteRangeIndexes, getHeader } from './request-headers.js'
 import { getContentRangeHeader } from './response-headers.js'
-import type { SupportedBodyTypes } from '../types.js'
-import type { ComponentLogger, Logger } from '@libp2p/interface'
+import type { SupportedBodyTypes } from '../index.js'
+import type { Logger } from '@libp2p/interface'
 
 type SliceableBody = Exclude<SupportedBodyTypes, ReadableStream<Uint8Array> | null>
 
@@ -90,8 +90,8 @@ export class ByteRangeContext {
   // to be set by isValidRangeRequest so that we don't need to re-check the byteRanges
   private _isValidRangeRequest: boolean = false
 
-  constructor (logger: ComponentLogger, private readonly headers?: HeadersInit) {
-    this.log = logger.forComponent('helia:verified-fetch:byte-range-context')
+  constructor (logger: Logger, private readonly headers?: HeadersInit) {
+    this.log = logger.newScope('byte-range-context')
     this.rangeRequestHeader = getHeader(this.headers, 'Range')
 
     if (this.rangeRequestHeader != null) {

package/src/utils/content-type-parser.ts

@@ -1,28 +1,22 @@
-import { logger } from '@libp2p/logger'
 import { fileTypeFromBuffer } from 'file-type'
 
-const log = logger('helia:verified-fetch:content-type-parser')
-
 export const defaultMimeType = 'application/octet-stream'
 function checkForSvg (text: string): boolean {
-  log('checking for svg')
   return /^(<\?xml[^>]+>)?[^<^\w]+<svg/ig.test(text)
 }
 
 async function checkForJson (text: string): Promise<boolean> {
-  log('checking for json')
   try {
     JSON.parse(text)
     return true
   } catch (err) {
-    log('failed to parse as json', err)
     return false
   }
 }
 
 function getText (bytes: Uint8Array): string | null {
-  log('checking for text')
   const decoder = new TextDecoder('utf-8', { fatal: true })
+
   try {
     return decoder.decode(bytes)
   } catch (err) {
@@ -31,25 +25,24 @@ function getText (bytes: Uint8Array): string | null {
 }
 
 async function checkForHtml (text: string): Promise<boolean> {
-  log('checking for html')
   return /^\s*<(?:!doctype\s+html|html|head|body)\b/i.test(text)
 }
 
 export async function contentTypeParser (bytes: Uint8Array, fileName?: string): Promise<string> {
-  log('contentTypeParser called for fileName: %s, byte size=%s', fileName, bytes.length)
   const detectedType = (await fileTypeFromBuffer(bytes))?.mime
+
   if (detectedType != null) {
-    log('detectedType: %s', detectedType)
     if (detectedType === 'application/xml' && fileName?.toLowerCase().endsWith('.svg')) {
       return 'image/svg+xml'
     }
+
     return detectedType
   }
-  log('no detectedType')
 
   if (fileName == null) {
     // it's likely text... no other way to determine file-type.
     const text = getText(bytes)
+
     if (text != null) {
       // check for svg, json, html, or it's plain text.
       if (checkForSvg(text)) {
@@ -62,6 +55,7 @@ export async function contentTypeParser (bytes: Uint8Array, fileName?: string):
         return 'text/plain; charset=utf-8'
       }
     }
+
     return defaultMimeType
   }
 

package/src/utils/error-to-object.ts

@@ -0,0 +1,22 @@
+function isAggregateError (err?: any): err is AggregateError {
+  return err instanceof AggregateError || (err?.name === 'AggregateError' && Array.isArray(err?.errors))
+}
+
+/**
+ * Error instance properties are not enumerable so we must transform the error
+ * into a plain object if we want to pass it to `JSON.stringify` or similar.
+ */
+export function errorToObject (err: Error): any {
+  let errors
+
+  if (isAggregateError(err)) {
+    errors = err.errors.map(err => errorToObject(err))
+  }
+
+  return {
+    name: err.name,
+    message: err.message,
+    stack: err.stack,
+    errors
+  }
+}