feat: customize ipns dnsResolvers

packages/verified-fetch/src/index.ts

@@ -138,6 +138,29 @@
  * })
  * ```
  *
+ * ### Custom DNS resolvers
+ *
+ * If you don't want to leek DNS queries to the default resolvers, you can provide your own list of DNS resolvers to `createVerifiedFetch`.
+ *
+ * Note that you do not need to provide both a DNS-over-HTTPS and a DNS-over-JSON resolver, and you should prefer `dnsJsonOverHttps` resolvers for usage in the browser for a smaller bundle size. See https://github.com/ipfs/helia/tree/main/packages/ipns#example---using-dns-json-over-https for more information.
+ *
+ * @example Customizing DNS resolvers
+ *
+ * ```typescript
+ * import { createVerifiedFetch } from '@helia/verified-fetch'
+ * import { dnsJsonOverHttps, dnsOverHttps } from '@helia/ipns/dns-resolvers'
+ *
+ * const fetch = await createVerifiedFetch({
+ *   gateways: ['https://trustless-gateway.link'],
+ *   routers: ['http://delegated-ipfs.dev']
+ * }, {
+ *   dnsResolvers: [
+ *     dnsJsonOverHttps('https://my-dns-resolver.example.com/dns-json'),
+ *     dnsOverHttps('https://my-dns-resolver.example.com/dns-query')
+ *   ]
+ * })
+ * ```
+ *
  * ### IPLD codec handling
  *
  * IPFS supports several data formats (typically referred to as codecs) which are included in the CID. `@helia/verified-fetch` attempts to abstract away some of the details for easier consumption.
@@ -439,7 +462,7 @@ import { createHeliaHTTP } from '@helia/http'
 import { delegatedHTTPRouting } from '@helia/routers'
 import { VerifiedFetch as VerifiedFetchClass } from './verified-fetch.js'
 import type { Helia } from '@helia/interface'
-import type { IPNSRoutingEvents, ResolveDnsLinkProgressEvents, ResolveProgressEvents } from '@helia/ipns'
+import type { DNSResolver, IPNSRoutingEvents, ResolveDnsLinkProgressEvents, ResolveProgressEvents } from '@helia/ipns'
 import type { GetEvents } from '@helia/unixfs'
 import type { CID } from 'multiformats/cid'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
@@ -479,8 +502,22 @@ export interface CreateVerifiedFetchOptions {
    * 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.
+   *
+   * @default undefined
    */
   contentTypeParser?: ContentTypeParser
+
+  /**
+   * In order to parse DNSLink records, we need to resolve DNS queries. You can
+   * pass a list of DNS resolvers that we will provide to the @helia/ipns
+   * instance for you. You must construct them using the `dnsJsonOverHttps` or
+   * `dnsOverHttps` functions exported from `@helia/ipns/dns-resolvers`.
+   *
+   * We use cloudflare and google's dnsJsonOverHttps resolvers by default.
+   *
+   * @default [dnsJsonOverHttps('https://mozilla.cloudflare-dns.com/dns-query'),dnsJsonOverHttps('https://dns.google/resolve')]
+   */
+  dnsResolvers?: DNSResolver[]
 }
 
 /**
@@ -524,8 +561,6 @@ export interface VerifiedFetchInit extends RequestInit, ProgressOptions<BubbledP
  * Create and return a Helia node
  */
 export async function createVerifiedFetch (init?: Helia | CreateVerifiedFetchInit, options?: CreateVerifiedFetchOptions): Promise<VerifiedFetch> {
-  const contentTypeParser: ContentTypeParser | undefined = options?.contentTypeParser
-
   if (!isHelia(init)) {
     init = await createHeliaHTTP({
       blockBrokers: [
@@ -537,7 +572,7 @@ export async function createVerifiedFetch (init?: Helia | CreateVerifiedFetchIni
     })
   }
 
-  const verifiedFetchInstance = new VerifiedFetchClass({ helia: init }, { contentTypeParser })
+  const verifiedFetchInstance = new VerifiedFetchClass({ helia: init }, options)
   async function verifiedFetch (resource: Resource, options?: VerifiedFetchInit): Promise<Response> {
     return verifiedFetchInstance.fetch(resource, options)
   }

packages/verified-fetch/src/verified-fetch.ts

@@ -1,4 +1,4 @@
-import { ipns as heliaIpns, type IPNS } from '@helia/ipns'
+import { ipns as heliaIpns, type DNSResolver, type IPNS } from '@helia/ipns'
 import { dnsJsonOverHttps } from '@helia/ipns/dns-resolvers'
 import { unixfs as heliaUnixFs, type UnixFS as HeliaUnixFs, type UnixFSStats } from '@helia/unixfs'
 import { code as dagCborCode } from '@ipld/dag-cbor'
@@ -32,6 +32,7 @@ interface VerifiedFetchComponents {
  */
 interface VerifiedFetchInit {
   contentTypeParser?: ContentTypeParser
+  dnsResolvers?: DNSResolver[]
 }
 
 interface FetchHandlerFunctionArg {
@@ -86,7 +87,7 @@ export class VerifiedFetch {
     this.helia = helia
     this.log = helia.logger.forComponent('helia:verified-fetch')
     this.ipns = ipns ?? heliaIpns(helia, {
-      resolvers: [
+      resolvers: init?.dnsResolvers ?? [
         dnsJsonOverHttps('https://mozilla.cloudflare-dns.com/dns-query'),
         dnsJsonOverHttps('https://dns.google/resolve')
       ]

packages/verified-fetch/test/index.spec.ts

@@ -1,5 +1,6 @@
 /* eslint-env mocha */
 import { createHeliaHTTP } from '@helia/http'
+import { dnsJsonOverHttps, dnsOverHttps } from '@helia/ipns/dns-resolvers'
 import { expect } from 'aegir/chai'
 import { createHelia } from 'helia'
 import { createVerifiedFetch, verifiedFetch } from '../src/index.js'
@@ -51,4 +52,23 @@ describe('createVerifiedFetch', () => {
     expect(verifiedFetch.stop).to.be.a('function')
     expect(verifiedFetch.start).to.be.a('function')
   })
+
+  it('can be passed a contentTypeParser', async () => {
+    const contentTypeParser = (_bytes: Uint8Array): string => 'application/json'
+    const verifiedFetch = await createVerifiedFetch(undefined, {
+      contentTypeParser
+    })
+    expect(verifiedFetch).to.be.ok()
+    await verifiedFetch.stop()
+  })
+
+  it('can be passed custom dnsResolvers', async () => {
+    const dnsResolver = dnsOverHttps('https://example.com/dns-query')
+    const dnsJsonResolver = dnsJsonOverHttps('https://example.com/dns-json')
+    const verifiedFetch = await createVerifiedFetch(undefined, {
+      dnsResolvers: [dnsResolver, dnsJsonResolver]
+    })
+    expect(verifiedFetch).to.be.ok()
+    await verifiedFetch.stop()
+  })
 })

packages/verified-fetch/test/verified-fetch.spec.ts

@@ -523,4 +523,23 @@ describe('@helia/verifed-fetch', () => {
       await expect(resp.text()).to.eventually.equal('hello world')
     })
   })
+
+  describe('custom dns-resolvers', () => {
+    it('uses custom dnsResolvers if provided', async () => {
+      const customDnsResolver = Sinon.stub()
+
+      customDnsResolver.returns(Promise.resolve('/ipfs/QmVP2ip92jQuMDezVSzQBWDqWFbp9nyCHNQSiciRauPLDg'))
+
+      const verifiedFetch = new VerifiedFetch({
+        helia
+      }, {
+        dnsResolvers: [customDnsResolver]
+      })
+      // error of walking the CID/dag because we haven't actually added the block to the blockstore
+      await expect(verifiedFetch.fetch('ipns://some-non-cached-domain.com')).to.eventually.be.rejected.with.property('errors').that.has.lengthOf(0)
+
+      expect(customDnsResolver.callCount).to.equal(1)
+      expect(customDnsResolver.getCall(0).args).to.deep.equal(['some-non-cached-domain.com', { onProgress: undefined }])
+    })
+  })
 })