@helia/verified-fetch 3.2.2 → 4.0.0

package/src/utils/handle-redirects.ts

@@ -37,19 +37,21 @@ export async function getRedirectResponse ({ resource, options, logger, cid, fet
   const forwardedHost = headers.get('x-forwarded-host')
   const headerHost = headers.get('host')
   const forwardedFor = headers.get('x-forwarded-for')
+
   if (forwardedFor == null && forwardedHost == null && headerHost == null) {
     log.trace('no redirect info found in headers')
     return null
   }
 
   log.trace('checking for redirect info')
-  // if x-forwarded-host is passed, we need to set the location header to the subdomain
-  // so that the browser can redirect to the correct subdomain
+  // if x-forwarded-host is passed, we need to set the location header to the
+  // subdomain so that the browser can redirect to the correct subdomain
   try {
     const urlParts = matchURLString(resource)
     const reqUrl = new URL(resource)
     const actualHost = forwardedHost ?? reqUrl.host
     const subdomainUrl = new URL(reqUrl)
+
     if (urlParts.protocol === 'ipfs' && cid.version === 0) {
       subdomainUrl.host = `${cid.toV1()}.ipfs.${actualHost}`
     } else {
@@ -65,6 +67,7 @@ export async function getRedirectResponse ({ resource, options, logger, cid, fet
       log.trace('host header is not the same as the subdomain url host, not setting location header')
       return null
     }
+
     if (reqUrl.host === subdomainUrl.host) {
       log.trace('req url is the same as the subdomain url, not setting location header')
       return null
@@ -75,6 +78,7 @@ export async function getRedirectResponse ({ resource, options, logger, cid, fet
     const pathUrl = new URL(reqUrl, `${reqUrl.protocol}//${actualHost}`)
     pathUrl.pathname = maybeAddTrailingSlash(reqUrl.pathname)
     log.trace('path url %s', pathUrl.href)
+
     // try to query subdomain with HEAD request to see if it's supported
     try {
       const subdomainTest = await fetch(subdomainUrl, { method: 'HEAD' })
@@ -86,11 +90,14 @@ export async function getRedirectResponse ({ resource, options, logger, cid, fet
         throw new SubdomainNotSupportedError('subdomain not supported')
       }
     } catch (err: any) {
-      log('subdomain not supported', err)
+      log('subdomain not supported - %e', err)
+
       if (pathUrl.href === reqUrl.href) {
         log('path url is the same as the request url, not setting location header')
+
         return null
       }
+
       // pathUrl is different from request URL (maybe even with just a trailing slash)
       return movedPermanentlyResponse(resource.toString(), pathUrl.href)
     }

package/src/utils/ipfs-path-to-string.ts

@@ -0,0 +1,9 @@
+/**
+ * Joins an array of strings as an IPFS path and URI encodes individual
+ * components
+ */
+export function uriEncodeIPFSPath (str: string): string {
+  return str.split('/')
+    .map(p => encodeURIComponent(p))
+    .join('/')
+}

package/src/utils/is-accept-explicit.ts

@@ -1,29 +1,36 @@
 import { FORMAT_TO_MIME_TYPE } from './select-output-type.js'
-import type { ParsedUrlStringResults } from './parse-url-string.js'
+import type { UrlQuery } from '../index.ts'
 
 export interface IsAcceptExplicitOptions {
-  query?: ParsedUrlStringResults['query']
+  query?: UrlQuery
   headers: Headers
 }
 
 export function isExplicitAcceptHeader (headers: Headers): boolean {
   const incomingAcceptHeader = headers.get('accept')
-  if (incomingAcceptHeader != null && Object.values(FORMAT_TO_MIME_TYPE).includes(incomingAcceptHeader)) {
-    return true
+
+  if (incomingAcceptHeader == null) {
+    return false
   }
-  return false
+
+  return Object.values(FORMAT_TO_MIME_TYPE)
+    .some(mimeType => incomingAcceptHeader.includes(mimeType))
 }
 
-export function isExplicitFormatQuery (query?: ParsedUrlStringResults['query']): boolean {
+export function isExplicitFormatQuery (query?: UrlQuery): boolean {
   const formatQuery = query?.format
+
   if (formatQuery != null && Object.keys(FORMAT_TO_MIME_TYPE).includes(formatQuery)) {
     return true
   }
+
   return false
 }
 
 /**
- * The user can provide an explicit `accept` header in the request headers or a `format` query parameter in the URL.
+ * The user can provide an explicit `accept` header in the request headers or a
+ * `format` query parameter in the URL.
+ *
  * If either of these are provided, this function returns true.
  */
 export function isExplicitIpldAcceptRequest ({ query, headers }: IsAcceptExplicitOptions): boolean {

package/src/utils/parse-url-string.ts

@@ -1,68 +1,13 @@
-import { AbortError } from '@libp2p/interface'
-import { CID } from 'multiformats/cid'
-import { getPeerIdFromString } from './get-peer-id-from-string.js'
-import { serverTiming } from './server-timing.js'
-import { TLRU } from './tlru.js'
-import type { ServerTimingResult } from './server-timing.js'
-import type { RequestFormatShorthand } from '../types.js'
-import type { DNSLinkResolveResult, IPNS, IPNSResolveResult, IPNSRoutingEvents, ResolveDNSLinkProgressEvents, ResolveProgressEvents, ResolveResult } from '@helia/ipns'
-import type { AbortOptions, ComponentLogger, PeerId } from '@libp2p/interface'
-import type { ProgressOptions } from 'progress-events'
-
-export const ipnsCache = new TLRU<DNSLinkResolveResult | IPNSResolveResult>(1000)
-
-export interface ParseUrlStringInput {
-  urlString: string
-  ipns: IPNS
-  logger: ComponentLogger
-  withServerTiming?: boolean
-}
-export interface ParseUrlStringOptions extends ProgressOptions<ResolveProgressEvents | IPNSRoutingEvents | ResolveDNSLinkProgressEvents>, AbortOptions {
-
-}
-
-export interface ParsedUrlQuery extends Record<string, string | unknown> {
-  format?: RequestFormatShorthand
-  download?: boolean
-  filename?: string
-  'dag-scope'?: string
-}
-
-export interface ParsedUrlStringResults extends ResolveResult {
-  protocol: 'ipfs' | 'ipns'
-  query: ParsedUrlQuery
-
-  /**
-   * The value for the IPFS gateway spec compliant header `X-Ipfs-Path` on the
-   * response.
-   * The value of this header should be the original requested content path,
-   * prior to any path resolution or traversal.
-   *
-   * @see https://specs.ipfs.tech/http-gateways/path-gateway/#x-ipfs-path-response-header
-   */
-  ipfsPath: string
-
-  /**
-   * seconds as a number
-   */
-  ttl?: number
-
-  /**
-   * serverTiming items
-   */
-  serverTimings: Array<ServerTimingResult<any>>
-}
-
-const URL_REGEX = /^(?<protocol>ip[fn]s):\/\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\/?(?<path>[^?]*)\??(?<queryString>.*)$/
-const PATH_REGEX = /^\/(?<protocol>ip[fn]s)\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\/?(?<path>[^?]*)\??(?<queryString>.*)$/
-const PATH_GATEWAY_REGEX = /^https?:\/\/(.*[^/])\/(?<protocol>ip[fn]s)\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\/?(?<path>[^?]*)\??(?<queryString>.*)$/
-const SUBDOMAIN_GATEWAY_REGEX = /^https?:\/\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\.(?<protocol>ip[fn]s)\.([^/?]+)\/?(?<path>[^?]*)\??(?<queryString>.*)$/
+const URL_REGEX = /^(?<protocol>ip[fn]s):\/\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\/?(?<path>[^?]*)\??(?<query>.*)$/
+const PATH_REGEX = /^\/(?<protocol>ip[fn]s)\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\/?(?<path>[^?]*)\??(?<query>.*)$/
+const PATH_GATEWAY_REGEX = /^https?:\/\/(.*[^/])\/(?<protocol>ip[fn]s)\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\/?(?<path>[^?]*)\??(?<query>.*)$/
+const SUBDOMAIN_GATEWAY_REGEX = /^https?:\/\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\.(?<protocol>ip[fn]s)\.([^/?]+)\/?(?<path>[^?]*)\??(?<query>.*)$/
 
 interface MatchUrlGroups {
   protocol: 'ipfs' | 'ipns'
   cidOrPeerIdOrDnsLink: string
   path?: string
-  queryString?: string
+  query?: string
 }
 
 function matchUrlGroupsGuard (groups?: null | { [key in string]: string; } | MatchUrlGroups): groups is MatchUrlGroups {
@@ -71,50 +16,38 @@ function matchUrlGroupsGuard (groups?: null | { [key in string]: string; } | Mat
   const cidOrPeerIdOrDnsLink = groups?.cidOrPeerIdOrDnsLink
   if (cidOrPeerIdOrDnsLink == null) { return false }
   const path = groups?.path
-  const queryString = groups?.queryString
+  const query = groups?.query
 
   return ['ipns', 'ipfs'].includes(protocol) &&
     typeof cidOrPeerIdOrDnsLink === 'string' &&
     (path == null || typeof path === 'string') &&
-    (queryString == null || typeof queryString === 'string')
+    (query == null || typeof query === 'string')
 }
 
+// TODO: can this be replaced with `new URL`?
 export function matchURLString (urlString: string): MatchUrlGroups {
   for (const pattern of [SUBDOMAIN_GATEWAY_REGEX, URL_REGEX, PATH_GATEWAY_REGEX, PATH_REGEX]) {
     const match = urlString.match(pattern)
 
     if (matchUrlGroupsGuard(match?.groups)) {
-      return match.groups satisfies MatchUrlGroups
+      const groups = match.groups satisfies MatchUrlGroups
+
+      if (groups.path != null) {
+        groups.path = decodeURIComponent(groups.path)
+      }
+
+      // decode inline dnslink domain if present
+      if (pattern === SUBDOMAIN_GATEWAY_REGEX && groups.protocol === 'ipns' && isInlinedDnsLink(groups.cidOrPeerIdOrDnsLink)) {
+        groups.cidOrPeerIdOrDnsLink = dnsLinkLabelDecoder(groups.cidOrPeerIdOrDnsLink)
+      }
+
+      return groups
     }
   }
 
   throw new TypeError(`Invalid URL: ${urlString}, please use ipfs://, ipns://, or gateway URLs only`)
 }
 
-/**
- * determines the TTL for the resolved resource that will be used for the `Cache-Control` header's `max-age` directive.
- * max-age is in seconds
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#response_directives
- *
- * If we have ipnsTtlNs, it will be a BigInt representing "nanoseconds". We need to convert it back to seconds.
- *
- * For more TTL nuances:
- *
- * @see https://github.com/ipfs/js-ipns/blob/16e0e10682fa9a663e0bb493a44d3e99a5200944/src/index.ts#L200
- * @see https://github.com/ipfs/js-ipns/pull/308
- * @returns the ttl in seconds
- */
-function calculateTtl (resolveResult?: IPNSResolveResult | DNSLinkResolveResult): number | undefined {
-  if (resolveResult == null) {
-    return undefined
-  }
-  const dnsLinkTtl = (resolveResult as DNSLinkResolveResult).answer?.TTL
-  const ipnsTtlNs = (resolveResult as IPNSResolveResult).record?.ttl
-  const ipnsTtl = ipnsTtlNs != null ? Number(ipnsTtlNs / BigInt(1e9)) : undefined
-  return dnsLinkTtl ?? ipnsTtl
-}
-
 /**
  * For DNSLink see https://specs.ipfs.tech/http-gateways/subdomain-gateway/#host-request-header
  * DNSLink names include . which means they must be inlined into a single DNS label to provide unique origin and work with wildcard TLS certificates.
@@ -142,202 +75,3 @@ function isInlinedDnsLink (label: string): boolean {
 function dnsLinkLabelDecoder (linkLabel: string): string {
   return linkLabel.replace(/--/g, '%').replace(/-/g, '.').replace(/%/g, '-')
 }
-
-/**
- * A function that parses ipfs:// and ipns:// URLs, returning an object with easily recognizable properties.
- *
- * After determining the protocol successfully, we process the cidOrPeerIdOrDnsLink:
- * - If it's ipfs, it parses the CID or throws Error[]
- * - If it's ipns, it attempts to resolve the PeerId and then the DNSLink. If both fail, Error[] is thrown.
- *
- * @todo we need to break out each step of this function (cid parsing, ipns resolving, dnslink resolving) into separate functions and then remove the eslint-disable comment
- *
- * @throws {Error[]}
- */
-// eslint-disable-next-line complexity
-export async function parseUrlString ({ urlString, ipns, logger, withServerTiming = false }: ParseUrlStringInput, options?: ParseUrlStringOptions): Promise<ParsedUrlStringResults> {
-  const log = logger.forComponent('helia:verified-fetch:parse-url-string')
-  const { protocol, cidOrPeerIdOrDnsLink, path: urlPath, queryString } = matchURLString(urlString)
-
-  let cid: CID | undefined
-  let resolvedPath: string | undefined
-  const errors: Error[] = []
-  let resolveResult: IPNSResolveResult | DNSLinkResolveResult | undefined
-  const serverTimings: Array<ServerTimingResult<any>> = []
-
-  if (protocol === 'ipfs') {
-    try {
-      cid = CID.parse(cidOrPeerIdOrDnsLink)
-      /**
-       * no ttl set. @link {setCacheControlHeader}
-       */
-    } catch (err) {
-      log.error(err)
-      errors.push(new TypeError('Invalid CID for ipfs://<cid> URL'))
-    }
-  } else {
-    // protocol is ipns
-    resolveResult = ipnsCache.get(cidOrPeerIdOrDnsLink)
-
-    if (resolveResult != null) {
-      cid = resolveResult.cid
-      resolvedPath = resolveResult.path
-      log.trace('resolved %s to %c from cache', cidOrPeerIdOrDnsLink, cid)
-    } else {
-      log.trace('Attempting to resolve PeerId for %s', cidOrPeerIdOrDnsLink)
-      let peerId: PeerId | undefined
-      try {
-        // try resolving as an IPNS name
-
-        peerId = getPeerIdFromString(cidOrPeerIdOrDnsLink)
-        const pubKey = peerId?.publicKey
-        if (pubKey == null) {
-          throw new TypeError('cidOrPeerIdOrDnsLink contains no public key')
-        }
-
-        if (withServerTiming) {
-          const resolveIpns = async (): Promise<IPNSResolveResult> => {
-            return ipns.resolve(pubKey, options)
-          }
-          const resolveResultWithServerTiming = await serverTiming('ipns.resolve', `Resolve IPNS name ${cidOrPeerIdOrDnsLink}`, resolveIpns)
-          serverTimings.push(resolveResultWithServerTiming)
-
-          // eslint-disable-next-line max-depth
-          if (resolveResultWithServerTiming.error != null) {
-            throw resolveResultWithServerTiming.error
-          }
-          resolveResult = resolveResultWithServerTiming.result
-        } else {
-          resolveResult = await ipns.resolve(pubKey, options)
-        }
-        cid = resolveResult?.cid
-        resolvedPath = resolveResult?.path
-        log.trace('resolved %s to %c', cidOrPeerIdOrDnsLink, cid)
-      } catch (err) {
-        if (options?.signal?.aborted) {
-          throw new AbortError(options?.signal?.reason)
-        }
-        if (peerId == null) {
-          log.error('could not parse PeerId string "%s"', cidOrPeerIdOrDnsLink, err)
-          errors.push(new TypeError(`Could not parse PeerId in ipns url "${cidOrPeerIdOrDnsLink}", ${(err as Error).message}`))
-        } else {
-          log.error('could not resolve PeerId %c', peerId, err)
-          errors.push(new TypeError(`Could not resolve PeerId "${cidOrPeerIdOrDnsLink}": ${(err as Error).message}`))
-        }
-      }
-
-      if (cid == null) {
-        // cid is still null, try resolving as a DNSLink
-        let decodedDnsLinkLabel = cidOrPeerIdOrDnsLink
-        if (isInlinedDnsLink(cidOrPeerIdOrDnsLink)) {
-          decodedDnsLinkLabel = dnsLinkLabelDecoder(cidOrPeerIdOrDnsLink)
-          log.trace('decoded dnslink from "%s" to "%s"', cidOrPeerIdOrDnsLink, decodedDnsLinkLabel)
-        }
-        log.trace('Attempting to resolve DNSLink for %s', decodedDnsLinkLabel)
-
-        try {
-          // eslint-disable-next-line max-depth
-          if (withServerTiming) {
-            const resolveResultWithServerTiming = await serverTiming('ipns.resolveDNSLink', `Resolve DNSLink ${decodedDnsLinkLabel}`, ipns.resolveDNSLink.bind(ipns, decodedDnsLinkLabel, options))
-            serverTimings.push(resolveResultWithServerTiming)
-            // eslint-disable-next-line max-depth
-            if (resolveResultWithServerTiming.error != null) {
-              throw resolveResultWithServerTiming.error
-            }
-            resolveResult = resolveResultWithServerTiming.result
-          } else {
-            resolveResult = await ipns.resolveDNSLink(decodedDnsLinkLabel, options)
-          }
-
-          cid = resolveResult?.cid
-          resolvedPath = resolveResult?.path
-          log.trace('resolved %s to %c', decodedDnsLinkLabel, cid)
-        } catch (err: any) {
-          // eslint-disable-next-line max-depth
-          if (options?.signal?.aborted) {
-            throw new AbortError(options?.signal?.reason)
-          }
-          log.error('could not resolve DnsLink for "%s"', cidOrPeerIdOrDnsLink, err)
-          errors.push(err)
-        }
-      }
-    }
-  }
-
-  if (cid == null) {
-    if (errors.length === 1) {
-      throw errors[0]
-    }
-
-    errors.push(new Error(`Invalid resource. Cannot determine CID from URL "${urlString}".`))
-
-    // eslint-disable-next-line @typescript-eslint/only-throw-error
-    throw errors
-  }
-
-  let ttl = calculateTtl(resolveResult)
-
-  if (resolveResult != null) {
-    // use the ttl for the resolved resource for the cache, but fallback to 2 minutes if not available
-    ttl = ttl ?? 60 * 2
-    log.trace('caching %s resolved to %s with TTL: %s', cidOrPeerIdOrDnsLink, cid, ttl)
-    // convert ttl from seconds to ms for the cache
-    ipnsCache.set(cidOrPeerIdOrDnsLink, resolveResult, ttl * 1000)
-  }
-
-  // parse query string
-  const query: Record<string, any> = {}
-
-  if (queryString != null && queryString.length > 0) {
-    const queryParts = queryString.split('&')
-    for (const part of queryParts) {
-      const [key, value] = part.split('=')
-      query[key] = decodeURIComponent(value)
-    }
-
-    if (query.download != null) {
-      query.download = query.download === 'true'
-    }
-
-    if (query.filename != null) {
-      query.filename = query.filename.toString()
-    }
-  }
-
-  return {
-    protocol,
-    cid,
-    path: joinPaths(resolvedPath, urlPath ?? ''),
-    query,
-    ttl,
-    ipfsPath: `/${protocol}/${cidOrPeerIdOrDnsLink}${urlPath != null && urlPath !== '' ? `/${urlPath}` : ''}`,
-    serverTimings
-  } satisfies ParsedUrlStringResults
-}
-
-/**
- * join the path from resolve result & given path.
- * e.g. /ipns/<peerId>/ that is resolved to /ipfs/<cid>/<path1>, when requested as /ipns/<peerId>/<path2>, should be
- * resolved to /ipfs/<cid>/<path1>/<path2>
- */
-function joinPaths (resolvedPath: string | undefined, urlPath: string): string {
-  let path = ''
-
-  if (resolvedPath != null) {
-    path += resolvedPath
-  }
-
-  if (urlPath.length > 0) {
-    path = `${path.length > 0 ? `${path}/` : path}${urlPath}`
-  }
-
-  // replace duplicate forward slashes
-  path = path.replace(/\/(\/)+/g, '/')
-
-  // strip trailing forward slash if present
-  if (path.startsWith('/')) {
-    path = path.substring(1)
-  }
-
-  return path.split('/').map(decodeURIComponent).join('/')
-}

package/src/utils/response-headers.ts

@@ -8,7 +8,7 @@ interface CacheControlHeaderOptions {
    * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#response_directives
    */
   ttl?: number
-  protocol: 'ipfs' | 'ipns'
+  protocol: string
   response: Response
 }
 

package/src/utils/responses.ts

@@ -1,5 +1,5 @@
 import type { ByteRangeContext } from './byte-range-context.js'
-import type { SupportedBodyTypes } from '../types.js'
+import type { SupportedBodyTypes } from '../index.js'
 import type { Logger } from '@libp2p/interface'
 
 function setField (response: Response, name: string, value: string | boolean): void {

package/src/utils/select-output-type.ts

@@ -3,7 +3,7 @@ import { code as dagJsonCode } from '@ipld/dag-json'
 import { code as dagPbCode } from '@ipld/dag-pb'
 import { code as jsonCode } from 'multiformats/codecs/json'
 import { code as rawCode } from 'multiformats/codecs/raw'
-import type { RequestFormatShorthand } from '../types.js'
+import type { RequestFormatShorthand } from '../index.js'
 import type { CID } from 'multiformats/cid'
 
 /**
@@ -62,10 +62,15 @@ const CID_TYPE_MAP: Record<number, string[]> = {
   ]
 }
 
+export interface AcceptHeader {
+  mimeType: string
+  options: Record<string, string>
+}
+
 /**
  * Selects an output mime-type based on the CID and a passed `Accept` header
  */
-export function selectOutputType (cid: CID, accept?: string): string | undefined {
+export function selectOutputType (cid: CID, accept?: string): AcceptHeader | undefined {
   const cidMimeTypes = CID_TYPE_MAP[cid.code]
 
   if (accept != null) {
@@ -73,80 +78,69 @@ export function selectOutputType (cid: CID, accept?: string): string | undefined
   }
 }
 
-function chooseMimeType (accept: string, validMimeTypes: string[]): string | undefined {
+function chooseMimeType (accept: string, validMimeTypes: string[]): AcceptHeader | undefined {
   const requestedMimeTypes = accept
     .split(',')
     .map(s => {
       const parts = s.trim().split(';')
 
+      const options: Record<string, string> = {
+        q: '0'
+      }
+
+      for (let i = 1; i < parts.length; i++) {
+        const [key, value] = parts[i].split('=').map(s => s.trim())
+
+        options[key] = value
+      }
+
       return {
         mimeType: `${parts[0]}`.trim(),
-        weight: parseQFactor(parts[1])
+        options
       }
     })
     .sort((a, b) => {
-      if (a.weight === b.weight) {
+      if (a.options.q === b.options.q) {
         return 0
       }
 
-      if (a.weight > b.weight) {
+      if (a.options.q > b.options.q) {
         return -1
       }
 
       return 1
     })
-    .map(s => s.mimeType)
 
   for (const headerFormat of requestedMimeTypes) {
     for (const mimeType of validMimeTypes) {
-      if (headerFormat.includes(mimeType)) {
-        return mimeType
+      if (headerFormat.mimeType.includes(mimeType)) {
+        return headerFormat
       }
 
-      if (headerFormat === '*/*') {
-        return mimeType
+      if (headerFormat.mimeType === '*/*') {
+        return {
+          mimeType,
+          options: headerFormat.options
+        }
       }
 
-      if (headerFormat.startsWith('*/') && mimeType.split('/')[1] === headerFormat.split('/')[1]) {
-        return mimeType
+      if (headerFormat.mimeType.startsWith('*/') && mimeType.split('/')[1] === headerFormat.mimeType.split('/')[1]) {
+        return {
+          mimeType,
+          options: headerFormat.options
+        }
       }
 
-      if (headerFormat.endsWith('/*') && mimeType.split('/')[0] === headerFormat.split('/')[0]) {
-        return mimeType
+      if (headerFormat.mimeType.endsWith('/*') && mimeType.split('/')[0] === headerFormat.mimeType.split('/')[0]) {
+        return {
+          mimeType,
+          options: headerFormat.options
+        }
       }
     }
   }
 }
 
-/**
- * Parses q-factor weighting from the accept header to allow letting some mime
- * types take precedence over others.
- *
- * If the q-factor for an acceptable mime representation is omitted it defaults
- * to `1`.
- *
- * All specified values should be in the range 0-1.
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept#q
- */
-function parseQFactor (str?: string): number {
-  if (str != null) {
-    str = str.trim()
-  }
-
-  if (str?.startsWith('q=') !== true) {
-    return 1
-  }
-
-  const factor = parseFloat(str.replace('q=', ''))
-
-  if (isNaN(factor)) {
-    return 0
-  }
-
-  return factor
-}
-
 export const FORMAT_TO_MIME_TYPE: Record<RequestFormatShorthand, string> = {
   raw: 'application/vnd.ipld.raw',
   car: 'application/vnd.ipld.car',

package/src/utils/server-timing.ts

@@ -1,37 +1,24 @@
-export interface ServerTimingSuccess<T> {
-  error: null
-  result: T
-  header: string
-}
-export interface ServerTimingError {
-  result: null
-  error: Error
-  header: string
-}
-export type ServerTimingResult<T> = ServerTimingSuccess<T> | ServerTimingError
+export class ServerTiming {
+  private headers: string[]
 
-export async function serverTiming<T> (
-  name: string,
-  description: string,
-  fn: () => Promise<T>
-): Promise<ServerTimingResult<T>> {
-  const startTime = performance.now()
+  constructor () {
+    this.headers = []
+  }
 
-  try {
-    const result = await fn() // Execute the function
-    const endTime = performance.now()
+  getHeader (): string {
+    return this.headers.join(',')
+  }
 
-    const duration = (endTime - startTime).toFixed(1) // Duration in milliseconds
+  async time <T> (name: string, description: string, promise: Promise<T>): Promise<T> {
+    const startTime = performance.now()
 
-    // Create the Server-Timing header string
-    const header = `${name};dur=${duration};desc="${description}"`
-    return { result, header, error: null }
-  } catch (error: any) {
-    const endTime = performance.now()
-    const duration = (endTime - startTime).toFixed(1)
+    try {
+      return await promise // Execute the function
+    } finally {
+      const endTime = performance.now()
+      const duration = (endTime - startTime).toFixed(1) // Duration in milliseconds
 
-    // Still return a timing header even on error
-    const header = `${name};dur=${duration};desc="${description}"`
-    return { result: null, error, header } // Pass error with timing info
+      this.headers.push(`${name};dur=${duration};desc="${description}"`)
+    }
   }
 }

package/src/utils/walk-path.ts

@@ -62,7 +62,7 @@ export async function handlePathWalking ({ cid, path, resource, options, blockst
       return notFoundResponse(resource)
     }
 
-    log.error('error walking path %s', path, err)
+    log.error('error walking path "%s" - %e', path, err)
     return badGatewayResponse(resource, 'Error walking path')
   }
 }