@helia/verified-fetch 0.0.0-8a5bc6f → 0.0.0-9b1ddf8

package/src/index.ts

@@ -1,57 +1,49 @@
 /**
  * @packageDocumentation
  *
- * `@helia/verified-fetch` is a library that provides a fetch-like API for fetching trustless content from IPFS and verifying it.
+ * `@helia/verified-fetch` provides a [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)-like API for retrieving content from the [IPFS](https://ipfs.tech/) network.
  *
- * This library should act as a replacement for the `fetch()` API for fetching content from IPFS, and will return a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) object that can be used in a similar manner to the `fetch()` API. This means browser and HTTP caching inside browser main threads, web-workers, and service workers, as well as other features of the `fetch()` API should work in a way familiar to developers.
+ * All content is retrieved in a [trustless manner](https://www.techopedia.com/definition/trustless), and the integrity of all bytes are verified by comparing hashes of the data.
  *
- * Exports a `createVerifiedFetch` function that returns a `fetch()` like API method {@link Helia} for fetching IPFS content.
+ * This is a marked improvement over `fetch` which offers no such protections and is vulnerable to all sorts of attacks like [Content Spoofing](https://owasp.org/www-community/attacks/Content_Spoofing), [DNS Hijacking](https://en.wikipedia.org/wiki/DNS_hijacking), etc.
+ *
+ * A `verifiedFetch` function is exported to get up and running quickly, and a `createVerifiedFetch` function is also available that allows customizing the underlying [Helia](https://helia.io/) node for complete control over how content is retrieved.
+ *
+ * Browser-cache-friendly [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) objects are returned which should be instantly familiar to web developers.
  *
  * You may use any supported resource argument to fetch content:
  *
- * - CID instance
+ * - [CID](https://multiformats.github.io/js-multiformats/classes/cid.CID.html) instance
  * - IPFS URL
  * - IPNS URL
  *
- * @example
+ * @example Getting started
  *
  * ```typescript
- * import { createVerifiedFetch } from '@helia/verified-fetch'
+ * import { verifiedFetch } from '@helia/verified-fetch'
  *
- * const fetch = await createVerifiedFetch({
- *  gateways: ['https://mygateway.example.net', 'https://trustless-gateway.link']
- *})
- *
- * const resp = await fetch('ipfs://bafy...')
+ * const resp = await verifiedFetch('ipfs://bafy...')
  *
  * const json = await resp.json()
  *```
  *
- *
  * @example Using a CID instance to fetch JSON
  *
  * ```typescript
- * import { createVerifiedFetch } from '@helia/verified-fetch'
+ * import { verifiedFetch } from '@helia/verified-fetch'
  * import { CID } from 'multiformats/cid'
  *
- * const fetch = await createVerifiedFetch({
- *  gateways: ['https://mygateway.example.net', 'https://trustless-gateway.link']
- * })
- *
  * const cid = CID.parse('bafyFoo') // some image file
- * const response = await fetch(cid)
+ * const response = await verifiedFetch(cid)
  * const json = await response.json()
  * ```
  *
  * @example Using IPFS protocol to fetch an image
  *
  * ```typescript
- * import { createVerifiedFetch } from '@helia/verified-fetch'
+ * import { verifiedFetch } from '@helia/verified-fetch'
  *
- * const fetch = await createVerifiedFetch({
- *  gateways: ['https://mygateway.example.net', 'https://trustless-gateway.link']
- * })
- * const response = await fetch('ipfs://bafyFoo') // CID for some image file
+ * const response = await verifiedFetch('ipfs://bafyFoo') // CID for some image file
  * const blob = await response.blob()
  * const image = document.createElement('img')
  * image.src = URL.createObjectURL(blob)
@@ -61,22 +53,42 @@
  * @example Using IPNS protocol to stream a big file
  *
  * ```typescript
+ * import { verifiedFetch } from '@helia/verified-fetch'
+ *
+ * const response = await verifiedFetch('ipns://mydomain.com/path/to/very-long-file.log')
+ * const bigFileStreamReader = await response.body.getReader()
+ * ```
+ *
+ * ## Configuration
+ *
+ * ### Custom HTTP gateways and routers
+ *
+ * Out of the box `@helia/verified-fetch` uses a default set of [trustless gateways](https://specs.ipfs.tech/http-gateways/trustless-gateway/) for fetching blocks and [HTTP delegated routers](https://specs.ipfs.tech/routing/http-routing-v1/) for performing routing tasks - looking up peers, resolving/publishing [IPNS](https://docs.ipfs.tech/concepts/ipns/) names, etc.
+ *
+ * It's possible to override these by passing `gateways` and `routers` keys to the `createVerifiedFetch` function:
+ *
+ * @example Configuring gateways and routers
+ *
+ * ```typescript
  * import { createVerifiedFetch } from '@helia/verified-fetch'
  *
  * const fetch = await createVerifiedFetch({
- *  gateways: ['https://mygateway.example.net', 'https://trustless-gateway.link']
+ *  gateways: ['https://trustless-gateway.link'],
+ *  routers: ['http://delegated-ipfs.dev']
  * })
- * const response = await fetch('ipns://mydomain.com/path/to/very-long-file.log')
- * const bigFileStreamReader = await response.body.getReader()
- * ```
  *
- * ### Configuration
+ * const resp = await fetch('ipfs://bafy...')
+ *
+ * const json = await resp.json()
+ *```
  *
- * #### Usage with customized Helia
+ * ### Usage with customized Helia
  *
- * You can see variations of Helia and js-libp2p configuration options at https://helia.io/interfaces/helia.index.HeliaInit.html.
+ * For full control of how `@helia/verified-fetch` fetches content from the distributed web you can pass a preconfigured Helia node to `createVerifiedFetch`.
  *
- * The `@helia/http` module is currently in-progress, but the init options should be a subset of the `helia` module's init options. See https://github.com/ipfs/helia/issues/289 for more information.
+ * The [helia](https://www.npmjs.com/package/helia) module is configured with a libp2p node that is suited for decentralized applications, alternatively [@helia/http](https://www.npmjs.com/package/@helia/http) is available which uses HTTP gateways for all network operations.
+ *
+ * You can see variations of Helia and js-libp2p configuration options at https://helia.io/interfaces/helia.index.HeliaInit.html.
  *
  * ```typescript
  * import { trustlessGateway } from '@helia/block-brokers'
@@ -100,28 +112,54 @@
  * const json = await resp.json()
  * ```
  *
- * ### Comparison to fetch
+ * ### Custom content-type parsing
+ *
+ * By default, `@helia/verified-fetch` sets the `Content-Type` header as `application/octet-stream` - this is because the `.json()`, `.text()`, `.blob()`, and `.arrayBuffer()` methods will usually work as expected without a detailed content type.
  *
- * First, this library will require instantiation in order to configure the gateways and delegated routers, or potentially a custom Helia instance. Secondly, once your verified-fetch method is created, it will act as similar to the `fetch()` API as possible.
+ * If you require an accurate content-type you can provide a `contentTypeParser` function as an option to `createVerifiedFetch` to handle parsing the content type.
+ *
+ * The function you provide will be called with the first chunk of bytes from the file and should return a string or a promise of a string.
+ *
+ * @example Customizing content-type parsing
+ *
+ * ```typescript
+ * import { createVerifiedFetch } from '@helia/verified-fetch'
+ * import { fileTypeFromBuffer } from '@sgtpooki/file-type'
+ *
+ * const fetch = await createVerifiedFetch({
+ *  gateways: ['https://trustless-gateway.link'],
+ *  routers: ['http://delegated-ipfs.dev']
+ * }, {
+ *  contentTypeParser: async (bytes) => {
+ *    // call to some magic-byte recognition library like magic-bytes, file-type, or your own custom byte recognition
+ *    const result = await fileTypeFromBuffer(bytes)
+ *    return result?.mime
+ *  }
+ * })
+ * ```
+ *
+ * ## Comparison to fetch
+ *
+ * This module attempts to act as similarly to the `fetch()` API as possible.
  *
  * [The `fetch()` API](https://developer.mozilla.org/en-US/docs/Web/API/fetch) takes two parameters:
  *
  * 1. A [resource](https://developer.mozilla.org/en-US/docs/Web/API/fetch#resource)
  * 2. An [options object](https://developer.mozilla.org/en-US/docs/Web/API/fetch#options)
  *
- * #### Resource argument
+ * ### Resource argument
  *
- * This library intends to support the following methods of fetching web3 content from IPFS:
+ * This library supports the following methods of fetching web3 content from IPFS:
  *
  * 1. IPFS protocol: `ipfs://<cidv0>` & `ipfs://<cidv0>`
  * 2. IPNS protocol: `ipns://<peerId>` & `ipns://<publicKey>` & `ipns://<hostUri_Supporting_DnsLink_TxtRecords>`
  * 3. CID instances: An actual CID instance `CID.parse('bafy...')`
  *
- * As well as support for pathing & params for item 1&2 above according to [IPFS - Path Gateway Specification](https://specs.ipfs.tech/http-gateways/path-gateway) & [IPFS - Trustless Gateway Specification](https://specs.ipfs.tech/http-gateways/trustless-gateway/). Further refinement of those specifications specifically for web-based scenarios can be found in the [Web Pathing Specification IPIP](https://github.com/ipfs/specs/pull/453).
+ * As well as support for pathing & params for item 1 & 2 above according to [IPFS - Path Gateway Specification](https://specs.ipfs.tech/http-gateways/path-gateway) & [IPFS - Trustless Gateway Specification](https://specs.ipfs.tech/http-gateways/trustless-gateway/). Further refinement of those specifications specifically for web-based scenarios can be found in the [Web Pathing Specification IPIP](https://github.com/ipfs/specs/pull/453).
  *
- * If you pass a CID instance, we assume you want the content for that specific CID only, and do not support pathing or params for that CID.
+ * If you pass a CID instance, it assumes you want the content for that specific CID only, and does not support pathing or params for that CID.
  *
- * #### Options argument
+ * ### Options argument
  *
  * This library does not plan to support the exact Fetch API options object, as some of the arguments don't make sense. Instead, it will only support options necessary to meet [IPFS specs](https://specs.ipfs.tech/) related to specifying the resultant shape of desired content.
  *
@@ -146,7 +184,6 @@
  * 5. `body` - An object that specifies the body of the request. Best effort to adhere to the [Fetch API body](https://developer.mozilla.org/en-US/docs/Web/API/fetch#body) parameter.
  * 6. `cache` - Will basically act as `force-cache` for the request. Best effort to adhere to the [Fetch API cache](https://developer.mozilla.org/en-US/docs/Web/API/fetch#cache) parameter.
  *
- *
  * Non-Fetch API options that will be supported:
  *
  * 1. `onProgress` - Similar to Helia `onProgress` options, this will be a function that will be called with a progress event. Supported progress events are:
@@ -167,7 +204,7 @@
  * 4. [IPIP-0328: JSON and CBOR Response Formats on HTTP Gateways](https://specs.ipfs.tech/ipips/ipip-0328/)
  * 5. [IPIP-0288: TAR Response Format on HTTP Gateways](https://specs.ipfs.tech/ipips/ipip-0288/)
  *
- * #### Response types
+ * ### Response types
  *
  * This library's purpose is to return reasonably representable content from IPFS. In other words, fetching content is intended for leaf-node content -- such as images/videos/audio & other assets, or other IPLD content (with link) -- that can be represented by https://developer.mozilla.org/en-US/docs/Web/API/Response#instance_methods. The content type you receive back will depend upon the CID you request as well as the `Accept` header value you provide.
  *
@@ -175,7 +212,7 @@
  *
  * If your content doesn't have a mime-type or an [IPFS spec](https://specs.ipfs.tech), this library will not support it, but you can use the [`helia`](https://github.com/ipfs/helia) library directly for those use cases. See [Unsupported response types](#unsupported-response-types) for more information.
  *
- * ##### Handling response types
+ * #### Handling response types
  *
  * For handling responses we want to follow conventions/abstractions from Fetch API where possible:
  *
@@ -184,12 +221,12 @@
  * - For plain text in utf-8, you would call `.text()`
  * - For streaming response data, use something like `response.body.getReader()` to get a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Using_readable_streams#consuming_a_fetch_as_a_stream).
  *
- * ##### Unsupported response types
+ * #### Unsupported response types
  *
  * * Returning IPLD nodes or DAGs as JS objects is not supported, as there is no currently well-defined structure for representing this data in an [HTTP Response](https://developer.mozilla.org/en-US/docs/Web/API/Response). Instead, users should request `aplication/vnd.ipld.car` or use the [`helia`](https://github.com/ipfs/helia) library directly for this use case.
  * * Others? Open an issue or PR!
  *
- * #### Response headers
+ * ### Response headers
  *
  * This library will set the [HTTP Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) headers to the appropriate values for the content type according to the appropriate [IPFS Specifications](https://specs.ipfs.tech/).
  *
@@ -199,13 +236,13 @@
  * * https://specs.ipfs.tech/http-gateways/trustless-gateway/#response-headers
  * * https://specs.ipfs.tech/http-gateways/subdomain-gateway/#response-headers
  *
- * #### Possible Scenarios that could cause confusion
+ * ### Possible Scenarios that could cause confusion
  *
- * ##### Attempting to fetch the CID for content that does not make sense
+ * #### Attempting to fetch the CID for content that does not make sense
  *
  * If you request `bafybeiaysi4s6lnjev27ln5icwm6tueaw2vdykrtjkwiphwekaywqhcjze`, which points to the root of the en.wikipedia.org mirror, a response object does not make sense.
  *
- * #### Errors
+ * ### Errors
  *
  * Known Errors that can be thrown:
  *
@@ -231,7 +268,7 @@ import type { ProgressEvent, ProgressOptions } from 'progress-events'
 export type Resource = string | CID
 
 export interface CIDDetail {
-  cid: string
+  cid: CID
   path: string
 }
 
@@ -246,13 +283,38 @@ export interface VerifiedFetch {
 }
 
 /**
- * Instead of passing a Helia instance, you can pass a list of gateways and routers, and a HeliaHTTP instance will be created for you.
+ * Instead of passing a Helia instance, you can pass a list of gateways and
+ * routers, and a HeliaHTTP instance will be created for you.
  */
-export interface CreateVerifiedFetchWithOptions {
+export interface CreateVerifiedFetchInit {
   gateways: string[]
   routers?: string[]
 }
 
+export interface CreateVerifiedFetchOptions {
+  /**
+   * A function to handle parsing content type from bytes. The function you
+   * provide will be passed the first set of bytes we receive from the network,
+   * and should return a string that will be used as the value for the
+   * `Content-Type` header in the response.
+   */
+  contentTypeParser?: ContentTypeParser
+}
+
+/**
+ * A ContentTypeParser attempts to return the mime type of a given file. It
+ * receives the first chunk of the file data and the file name, if it is
+ * available.  The function can be sync or async and if it returns/resolves to
+ * `undefined`, `application/octet-stream` will be used.
+ */
+export interface ContentTypeParser {
+  /**
+   * Attempt to determine a mime type, either via of the passed bytes or the
+   * filename if it is available.
+   */
+  (bytes: Uint8Array, fileName?: string): Promise<string | undefined> | string | undefined
+}
+
 export type BubbledProgressEvents =
   // unixfs
   GetEvents |
@@ -269,8 +331,9 @@ export type VerifiedFetchProgressEvents =
 /**
  * Options for the `fetch` function returned by `createVerifiedFetch`.
  *
- * This method accepts all the same options as the `fetch` function in the browser, plus an `onProgress` option to
- * listen for progress events.
+ * This interface contains all the same fields as the [options object](https://developer.mozilla.org/en-US/docs/Web/API/fetch#options)
+ * passed to `fetch` in browsers, plus an `onProgress` option to listen for
+ * progress events.
  */
 export interface VerifiedFetchInit extends RequestInit, ProgressOptions<BubbledProgressEvents | VerifiedFetchProgressEvents> {
 }
@@ -278,7 +341,9 @@ export interface VerifiedFetchInit extends RequestInit, ProgressOptions<BubbledP
 /**
  * Create and return a Helia node
  */
-export async function createVerifiedFetch (init?: Helia | CreateVerifiedFetchWithOptions): Promise<VerifiedFetch> {
+export async function createVerifiedFetch (init?: Helia | CreateVerifiedFetchInit, options?: CreateVerifiedFetchOptions): Promise<VerifiedFetch> {
+  const contentTypeParser: ContentTypeParser | undefined = options?.contentTypeParser
+
   if (!isHelia(init)) {
     init = await createHeliaHTTP({
       blockBrokers: [
@@ -290,7 +355,7 @@ export async function createVerifiedFetch (init?: Helia | CreateVerifiedFetchWit
     })
   }
 
-  const verifiedFetchInstance = new VerifiedFetchClass({ helia: init })
+  const verifiedFetchInstance = new VerifiedFetchClass({ helia: init }, { contentTypeParser })
   async function verifiedFetch (resource: Resource, options?: VerifiedFetchInit): Promise<Response> {
     return verifiedFetchInstance.fetch(resource, options)
   }
@@ -300,6 +365,8 @@ export async function createVerifiedFetch (init?: Helia | CreateVerifiedFetchWit
   return verifiedFetch
 }
 
+export { verifiedFetch } from './singleton.js'
+
 function isHelia (obj: any): obj is Helia {
   // test for the presence of known Helia properties, return a boolean value
   return obj?.blockstore != null &&

package/src/singleton.ts

@@ -0,0 +1,20 @@
+import { createVerifiedFetch } from './index.js'
+import type { Resource, VerifiedFetch, VerifiedFetchInit } from './index.js'
+
+let impl: VerifiedFetch | undefined
+
+export const verifiedFetch: VerifiedFetch = async function verifiedFetch (resource: Resource, options?: VerifiedFetchInit): Promise<Response> {
+  if (impl == null) {
+    impl = await createVerifiedFetch()
+  }
+
+  return impl(resource, options)
+}
+
+verifiedFetch.start = async function () {
+  await impl?.start()
+}
+
+verifiedFetch.stop = async function () {
+  await impl?.stop()
+}

package/src/utils/{get-stream-and-content-type.ts → get-stream-from-async-iterable.ts}

@@ -1,27 +1,25 @@
 import { CustomProgressEvent } from 'progress-events'
-import { getContentType } from './get-content-type.js'
 import type { VerifiedFetchInit } from '../index.js'
 import type { ComponentLogger } from '@libp2p/interface'
 
 /**
- * Converts an async iterator of Uint8Array bytes to a stream and attempts to determine the content type of those bytes.
+ * Converts an async iterator of Uint8Array bytes to a stream and returns the first chunk of bytes
  */
-export async function getStreamAndContentType (iterator: AsyncIterable<Uint8Array>, path: string, logger: ComponentLogger, options?: Pick<VerifiedFetchInit, 'onProgress'>): Promise<{ contentType: string, stream: ReadableStream<Uint8Array> }> {
-  const log = logger.forComponent('helia:verified-fetch:get-stream-and-content-type')
+export async function getStreamFromAsyncIterable (iterator: AsyncIterable<Uint8Array>, path: string, logger: ComponentLogger, options?: Pick<VerifiedFetchInit, 'onProgress'>): Promise<{ stream: ReadableStream<Uint8Array>, firstChunk: Uint8Array }> {
+  const log = logger.forComponent('helia:verified-fetch:get-stream-from-async-iterable')
   const reader = iterator[Symbol.asyncIterator]()
-  const { value, done } = await reader.next()
+  const { value: firstChunk, done } = await reader.next()
 
   if (done === true) {
     log.error('No content found for path', path)
     throw new Error('No content found')
   }
 
-  const contentType = await getContentType({ bytes: value, path })
   const stream = new ReadableStream({
     async start (controller) {
       // the initial value is already available
       options?.onProgress?.(new CustomProgressEvent<void>('verified-fetch:request:progress:chunk'))
-      controller.enqueue(value)
+      controller.enqueue(firstChunk)
     },
     async pull (controller) {
       const { value, done } = await reader.next()
@@ -40,5 +38,8 @@ export async function getStreamAndContentType (iterator: AsyncIterable<Uint8Arra
     }
   })
 
-  return { contentType, stream }
+  return {
+    stream,
+    firstChunk
+  }
 }

package/src/verified-fetch.ts

@@ -10,10 +10,10 @@ import { code as dagPbCode } from '@ipld/dag-pb'
 import { code as jsonCode } from 'multiformats/codecs/json'
 import { decode, code as rawCode } from 'multiformats/codecs/raw'
 import { CustomProgressEvent } from 'progress-events'
-import { getStreamAndContentType } from './utils/get-stream-and-content-type.js'
+import { getStreamFromAsyncIterable } from './utils/get-stream-from-async-iterable.js'
 import { parseResource } from './utils/parse-resource.js'
 import { walkPath, type PathWalkerFn } from './utils/walk-path.js'
-import type { CIDDetail, Resource, VerifiedFetchInit as VerifiedFetchOptions } from './index.js'
+import type { CIDDetail, ContentTypeParser, Resource, VerifiedFetchInit as VerifiedFetchOptions } from './index.js'
 import type { Helia } from '@helia/interface'
 import type { AbortOptions, Logger } from '@libp2p/interface'
 import type { UnixFSEntry } from 'ipfs-unixfs-exporter'
@@ -32,9 +32,8 @@ interface VerifiedFetchComponents {
 /**
  * Potential future options for the VerifiedFetch constructor.
  */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 interface VerifiedFetchInit {
-
+  contentTypeParser?: ContentTypeParser
 }
 
 interface FetchHandlerFunctionArg {
@@ -72,6 +71,7 @@ export class VerifiedFetch {
   private readonly json: JSON
   private readonly pathWalker: PathWalkerFn
   private readonly log: Logger
+  private readonly contentTypeParser: ContentTypeParser | undefined
 
   constructor ({ helia, ipns, unixfs, dagJson, json, dagCbor, pathWalker }: VerifiedFetchComponents, init?: VerifiedFetchInit) {
     this.helia = helia
@@ -87,6 +87,7 @@ export class VerifiedFetch {
     this.json = json ?? heliaJson(helia)
     this.dagCbor = dagCbor ?? heliaDagCbor(helia)
     this.pathWalker = pathWalker ?? walkPath
+    this.contentTypeParser = init?.contentTypeParser
     this.log.trace('created VerifiedFetch instance')
   }
 
@@ -106,12 +107,12 @@ export class VerifiedFetch {
 
   private async handleDagJson ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
     this.log.trace('fetching %c/%s', cid, path)
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: cid.toString(), path }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid, path }))
     const result = await this.dagJson.get(cid, {
       signal: options?.signal,
       onProgress: options?.onProgress
     })
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: cid.toString(), path }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid, path }))
     const response = new Response(JSON.stringify(result), { status: 200 })
     response.headers.set('content-type', 'application/json')
     return response
@@ -119,12 +120,12 @@ export class VerifiedFetch {
 
   private async handleJson ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
     this.log.trace('fetching %c/%s', cid, path)
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: cid.toString(), path }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid, path }))
     const result: Record<any, any> = await this.json.get(cid, {
       signal: options?.signal,
       onProgress: options?.onProgress
     })
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: cid.toString(), path }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid, path }))
     const response = new Response(JSON.stringify(result), { status: 200 })
     response.headers.set('content-type', 'application/json')
     return response
@@ -132,14 +133,14 @@ export class VerifiedFetch {
 
   private async handleDagCbor ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
     this.log.trace('fetching %c/%s', cid, path)
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: cid.toString(), path }))
-    const result = await this.dagCbor.get(cid, {
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid, path }))
+    const result = await this.dagCbor.get<Uint8Array>(cid, {
       signal: options?.signal,
       onProgress: options?.onProgress
     })
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: cid.toString(), path }))
-    const response = new Response(JSON.stringify(result), { status: 200 })
-    response.headers.set('content-type', 'application/json')
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid, path }))
+    const response = new Response(result, { status: 200 })
+    await this.setContentType(result, path, response)
     return response
   }
 
@@ -153,7 +154,7 @@ export class VerifiedFetch {
       const rootFilePath = 'index.html'
       try {
         this.log.trace('found directory at %c/%s, looking for index.html', cid, path)
-        options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: dirCid.toString(), path: rootFilePath }))
+        options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: dirCid, path: rootFilePath }))
         stat = await this.unixfs.stat(dirCid, {
           path: rootFilePath,
           signal: options?.signal,
@@ -167,37 +168,63 @@ export class VerifiedFetch {
         this.log('error loading path %c/%s', dirCid, rootFilePath, err)
         return new Response('Unable to find index.html for directory at given path. Support for directories with implicit root is not implemented', { status: 501 })
       } finally {
-        options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: dirCid.toString(), path: rootFilePath }))
+        options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: dirCid, path: rootFilePath }))
       }
     }
 
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: resolvedCID.toString(), path: '' }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: resolvedCID, path: '' }))
     const asyncIter = this.unixfs.cat(resolvedCID, {
       signal: options?.signal,
       onProgress: options?.onProgress
     })
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: resolvedCID.toString(), path: '' }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: resolvedCID, path: '' }))
     this.log('got async iterator for %c/%s', cid, path)
 
-    const { contentType, stream } = await getStreamAndContentType(asyncIter, path ?? '', this.helia.logger, {
+    const { stream, firstChunk } = await getStreamFromAsyncIterable(asyncIter, path ?? '', this.helia.logger, {
       onProgress: options?.onProgress
     })
     const response = new Response(stream, { status: 200 })
-    response.headers.set('content-type', contentType)
+    await this.setContentType(firstChunk, path, response)
 
     return response
   }
 
   private async handleRaw ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
     this.log.trace('fetching %c/%s', cid, path)
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: cid.toString(), path }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid, path }))
     const result = await this.helia.blockstore.get(cid)
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: cid.toString(), path }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid, path }))
     const response = new Response(decode(result), { status: 200 })
-    response.headers.set('content-type', 'application/octet-stream')
+    await this.setContentType(result, path, response)
     return response
   }
 
+  private async setContentType (bytes: Uint8Array, path: string, response: Response): Promise<void> {
+    let contentType = 'application/octet-stream'
+
+    if (this.contentTypeParser != null) {
+      try {
+        let fileName = path.split('/').pop()?.trim()
+        fileName = fileName === '' ? undefined : fileName
+        const parsed = this.contentTypeParser(bytes, fileName)
+
+        if (isPromise(parsed)) {
+          const result = await parsed
+
+          if (result != null) {
+            contentType = result
+          }
+        } else if (parsed != null) {
+          contentType = parsed
+        }
+      } catch (err) {
+        this.log.error('Error parsing content type', err)
+      }
+    }
+
+    response.headers.set('content-type', contentType)
+  }
+
   /**
    * Determines the format requested by the client, defaults to `null` if no format is requested.
    *
@@ -321,3 +348,7 @@ export class VerifiedFetch {
     await this.helia.stop()
   }
 }
+
+function isPromise <T> (p?: any): p is Promise<T> {
+  return p?.then != null
+}

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

@@ -1,11 +0,0 @@
-interface TestInput {
-    bytes: Uint8Array;
-    path: string;
-}
-export declare const DEFAULT_MIME_TYPE = "application/octet-stream";
-/**
- * Get the content type from the input based on the tests.
- */
-export declare function getContentType(input: TestInput): Promise<string>;
-export {};
-//# sourceMappingURL=get-content-type.d.ts.map

package/dist/src/utils/get-content-type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-content-type.d.ts","sourceRoot":"","sources":["../../../src/utils/get-content-type.ts"],"names":[],"mappings":"AAEA,UAAU,SAAS;IACjB,KAAK,EAAE,UAAU,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;CACb;AAID,eAAO,MAAM,iBAAiB,6BAA6B,CAAA;AAkC3D;;GAEG;AACH,wBAAsB,cAAc,CAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAQvE"}

package/dist/src/utils/get-content-type.js

@@ -1,43 +0,0 @@
-import mime from 'mime-types';
-export const DEFAULT_MIME_TYPE = 'application/octet-stream';
-const xmlRegex = /^(<\?xml[^>]+>)?[^<^\w]+<svg/ig;
-/**
- * Tests to determine the content type of the input.
- * The order is important on this one.
- */
-const tests = [
-    // svg
-    async ({ bytes }) => xmlRegex.test(new TextDecoder().decode(bytes.slice(0, 64)))
-        ? 'image/svg+xml'
-        : undefined,
-    // testing file-type from path
-    async ({ path }) => {
-        const mimeType = mime.lookup(path);
-        if (mimeType !== false) {
-            return mimeType;
-        }
-        return undefined;
-    }
-];
-const overrides = {
-    'video/quicktime': 'video/mp4'
-};
-/**
- * Override the content type based on overrides.
- */
-function overrideContentType(type) {
-    return overrides[type] ?? type;
-}
-/**
- * Get the content type from the input based on the tests.
- */
-export async function getContentType(input) {
-    for (const test of tests) {
-        const type = await test(input);
-        if (type !== undefined) {
-            return overrideContentType(type);
-        }
-    }
-    return DEFAULT_MIME_TYPE;
-}
-//# sourceMappingURL=get-content-type.js.map

package/dist/src/utils/get-content-type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-content-type.js","sourceRoot":"","sources":["../../../src/utils/get-content-type.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,YAAY,CAAA;AAS7B,MAAM,CAAC,MAAM,iBAAiB,GAAG,0BAA0B,CAAA;AAE3D,MAAM,QAAQ,GAAG,gCAAgC,CAAA;AAEjD;;;GAGG;AACH,MAAM,KAAK,GAA4C;IACrD,MAAM;IACN,KAAK,EAAE,EAAE,KAAK,EAAE,EAAc,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QAC1F,CAAC,CAAC,eAAe;QACjB,CAAC,CAAC,SAAS;IACb,8BAA8B;IAC9B,KAAK,EAAE,EAAE,IAAI,EAAE,EAAc,EAAE;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QAClC,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;YACvB,OAAO,QAAQ,CAAA;QACjB,CAAC;QACD,OAAO,SAAS,CAAA;IAClB,CAAC;CACF,CAAA;AAED,MAAM,SAAS,GAA2B;IACxC,iBAAiB,EAAE,WAAW;CAC/B,CAAA;AAED;;GAEG;AACH,SAAS,mBAAmB,CAAE,IAAY;IACxC,OAAO,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,CAAA;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAE,KAAgB;IACpD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,CAAA;QAC9B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAA;QAClC,CAAC;IACH,CAAC;IACD,OAAO,iBAAiB,CAAA;AAC1B,CAAC"}

package/dist/src/utils/get-stream-and-content-type.d.ts

@@ -1,10 +0,0 @@
-import type { VerifiedFetchInit } from '../index.js';
-import type { ComponentLogger } from '@libp2p/interface';
-/**
- * Converts an async iterator of Uint8Array bytes to a stream and attempts to determine the content type of those bytes.
- */
-export declare function getStreamAndContentType(iterator: AsyncIterable<Uint8Array>, path: string, logger: ComponentLogger, options?: Pick<VerifiedFetchInit, 'onProgress'>): Promise<{
-    contentType: string;
-    stream: ReadableStream<Uint8Array>;
-}>;
-//# sourceMappingURL=get-stream-and-content-type.d.ts.map