@helia/verified-fetch 3.2.3 → 4.0.1

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

@@ -1,13 +1,13 @@
 import { defaultMimeType } from './content-type-parser.js'
 import { isPromise } from './type-guards.js'
-import type { ContentTypeParser } from '../types.js'
+import type { ContentTypeParser } from '../index.js'
 import type { Logger } from '@libp2p/interface'
 
 export interface GetContentTypeOptions {
   bytes: Uint8Array
-  path: string
+  path?: string
   defaultContentType?: string
-  contentTypeParser: ContentTypeParser | undefined
+  contentTypeParser?: ContentTypeParser
   log: Logger
 
   /**
@@ -25,7 +25,7 @@ export async function getContentType ({ bytes, path, contentTypeParser, log, def
     try {
       let fileName
       if (filenameParam == null) {
-        fileName = path.split('/').pop()?.trim()
+        fileName = path?.split('/').pop()?.trim()
         fileName = (fileName === '' || fileName?.split('.').length === 1) ? undefined : fileName
       } else {
         fileName = filenameParam
@@ -46,6 +46,7 @@ export async function getContentType ({ bytes, path, contentTypeParser, log, def
       log.error('error parsing content type', err)
     }
   }
+
   if (contentType === defaultMimeType) {
     // if the content type is the default in our content-type-parser, instead, set it to the default content type provided to this function.
     contentType = defaultContentType

package/src/utils/get-e-tag.ts

@@ -1,4 +1,4 @@
-import type { RequestFormatShorthand } from '../types.js'
+import type { RequestFormatShorthand } from '../index.js'
 import type { CID } from 'multiformats/cid'
 
 interface GetETagArg {

package/src/utils/get-offset-and-length.ts

@@ -0,0 +1,54 @@
+import type { UnixFSEntry } from 'ipfs-unixfs-exporter'
+
+export function getOffsetAndLength (entry: UnixFSEntry, entityBytes?: string): { offset: number, length: number } {
+  if (entityBytes == null) {
+    return {
+      offset: 0,
+      length: Infinity
+    }
+  }
+
+  const parts = entityBytes.split(':')
+  const start = parseInt(parts[0], 10)
+  const end = parts[1] === '*' ? Infinity : parseInt(parts[1], 10)
+
+  if (isNaN(start) || isNaN(end)) {
+    throw new Error('Could not parse entity-bytes')
+  }
+
+  const entrySize = Number(entry.size)
+
+  if (start >= 0) {
+    if (end >= 0) {
+      return {
+        offset: start,
+        length: end - start
+      }
+    } else {
+      return {
+        offset: start,
+        length: (entrySize - start) + end
+      }
+    }
+  }
+
+  // start < 0
+  let offset = entrySize + start
+
+  if (Math.abs(start) > entrySize) {
+    offset = 0
+  }
+
+  if (end >= 0) {
+    return {
+      offset,
+      length: (entrySize - offset) + end
+    }
+  }
+
+  // end < 0
+  return {
+    offset,
+    length: (entrySize - offset) + end
+  }
+}

package/src/utils/get-resolved-accept-header.ts

@@ -1,10 +1,10 @@
 import { isExplicitAcceptHeader, isExplicitFormatQuery, isExplicitIpldAcceptRequest } from './is-accept-explicit.js'
 import { queryFormatToAcceptHeader } from './select-output-type.js'
-import type { ParsedUrlStringResults } from './parse-url-string.js'
+import type { UrlQuery } from '../index.ts'
 import type { ComponentLogger } from '@libp2p/interface'
 
 export interface ResolvedAcceptHeaderOptions {
-  query?: ParsedUrlStringResults['query']
+  query?: UrlQuery
   headers?: RequestInit['headers']
   logger: ComponentLogger
 }

package/src/utils/get-stream-from-async-iterable.ts

@@ -2,18 +2,18 @@ import { AbortError } from '@libp2p/interface'
 import { CustomProgressEvent } from 'progress-events'
 import { NoContentError } from '../errors.js'
 import type { VerifiedFetchInit } from '../index.js'
-import type { ComponentLogger } from '@libp2p/interface'
+import type { Logger } from '@libp2p/interface'
 
 /**
  * Converts an async iterator of Uint8Array bytes to a stream and returns the first chunk of bytes
  */
-export async function getStreamFromAsyncIterable (iterator: AsyncIterable<Uint8Array>, path: string, logger: ComponentLogger, options?: Pick<VerifiedFetchInit, 'onProgress' | 'signal'>): Promise<{ stream: ReadableStream<Uint8Array>, firstChunk: Uint8Array }> {
-  const log = logger.forComponent('helia:verified-fetch:get-stream-from-async-iterable')
+export async function getStreamFromAsyncIterable (iterator: AsyncIterable<Uint8Array>, path: string, logger: Logger, options?: Pick<VerifiedFetchInit, 'onProgress' | 'signal'>): Promise<{ stream: ReadableStream<Uint8Array>, firstChunk: Uint8Array }> {
+  const log = logger.newScope('get-stream-from-async-iterable')
   const reader = iterator[Symbol.asyncIterator]()
   const { value: firstChunk, done } = await reader.next()
 
   if (done === true) {
-    log.error('no content found for path', path)
+    log.error('no content found for path "%s"', path)
     throw new NoContentError()
   }
 

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 {
@@ -44,6 +44,20 @@ export function okResponse (url: string, body?: SupportedBodyTypes, init?: Respo
   return response
 }
 
+export function internalServerErrorResponse (url: string, body?: SupportedBodyTypes, init?: ResponseInit): Response {
+  const response = new Response(body, {
+    ...(init ?? {}),
+    status: 500,
+    statusText: 'Internal Server Error'
+  })
+  response.headers.set('X-Content-Type-Options', 'nosniff') // see https://specs.ipfs.tech/http-gateways/path-gateway/#x-content-type-options-response-header
+
+  setType(response, 'basic')
+  setUrl(response, url)
+
+  return response
+}
+
 export function badGatewayResponse (url: string, body?: SupportedBodyTypes, init?: ResponseInit): Response {
   const response = new Response(body, {
     ...(init ?? {}),
@@ -57,7 +71,7 @@ export function badGatewayResponse (url: string, body?: SupportedBodyTypes, init
   return response
 }
 
-export function notSupportedResponse (url: string, body?: SupportedBodyTypes, init?: ResponseInit): Response {
+export function notImplementedResponse (url: string, body?: SupportedBodyTypes, init?: ResponseInit): Response {
   const response = new Response(body, {
     ...(init ?? {}),
     status: 501,