@helia/ipns 0.0.0

package/src/utils/resolve-dns-link.browser.ts

@@ -0,0 +1,61 @@
+/* eslint-env browser */
+
+import { TLRU } from './tlru.js'
+import PQueue from 'p-queue'
+import type { AbortOptions } from '@libp2p/interfaces'
+
+// Avoid sending multiple queries for the same hostname by caching results
+const cache = new TLRU<{ Path: string, Message: string }>(1000)
+// TODO: /api/v0/dns does not return TTL yet: https://github.com/ipfs/go-ipfs/issues/5884
+// However we know browsers themselves cache DNS records for at least 1 minute,
+// which acts a provisional default ttl: https://stackoverflow.com/a/36917902/11518426
+const ttl = 60 * 1000
+
+// browsers limit concurrent connections per host,
+// we don't want preload calls to exhaust the limit (~6)
+const httpQueue = new PQueue({ concurrency: 4 })
+
+const ipfsPath = (response: { Path: string, Message: string }): string => {
+  if (response.Path != null) {
+    return response.Path
+  }
+  throw new Error(response.Message)
+}
+
+export interface ResolveDnsLinkOptions extends AbortOptions {
+  nocache?: boolean
+}
+
+export async function resolveDnslink (fqdn: string, opts: ResolveDnsLinkOptions = {}): Promise<string> { // eslint-disable-line require-await
+  const resolve = async (fqdn: string, opts: ResolveDnsLinkOptions = {}): Promise<string> => {
+    // @ts-expect-error - URLSearchParams does not take boolean options, only strings
+    const searchParams = new URLSearchParams(opts)
+    searchParams.set('arg', fqdn)
+
+    // try cache first
+    const query = searchParams.toString()
+    if (opts.nocache !== true && cache.has(query)) {
+      const response = cache.get(query)
+
+      if (response != null) {
+        return ipfsPath(response)
+      }
+    }
+
+    // fallback to delegated DNS resolver
+    const response = await httpQueue.add(async () => {
+      // Delegated HTTP resolver sending DNSLink queries to ipfs.io
+      // TODO: replace hardcoded host with configurable DNS over HTTPS: https://github.com/ipfs/js-ipfs/issues/2212
+      const res = await fetch(`https://ipfs.io/api/v0/dns?${searchParams}`)
+      const query = new URL(res.url).search.slice(1)
+      const json = await res.json()
+      cache.set(query, json, ttl)
+
+      return json
+    })
+
+    return ipfsPath(response)
+  }
+
+  return await resolve(fqdn, opts)
+}

package/src/utils/resolve-dns-link.ts

@@ -0,0 +1,65 @@
+import dns from 'dns'
+import { promisify } from 'util'
+import type { AbortOptions } from '@libp2p/interfaces'
+import * as isIPFS from 'is-ipfs'
+
+const MAX_RECURSIVE_DEPTH = 32
+
+export async function resolveDnslink (domain: string, options: AbortOptions = {}): Promise<string> {
+  return await recursiveResolveDnslink(domain, MAX_RECURSIVE_DEPTH, options)
+}
+
+async function recursiveResolveDnslink (domain: string, depth: number, options: AbortOptions = {}): Promise<string> {
+  if (depth === 0) {
+    throw new Error('recursion limit exceeded')
+  }
+
+  let dnslinkRecord
+
+  try {
+    dnslinkRecord = await resolve(domain)
+  } catch (err: any) {
+    // If the code is not ENOTFOUND or ERR_DNSLINK_NOT_FOUND or ENODATA then throw the error
+    if (err.code !== 'ENOTFOUND' && err.code !== 'ERR_DNSLINK_NOT_FOUND' && err.code !== 'ENODATA') {
+      throw err
+    }
+
+    if (domain.startsWith('_dnslink.')) {
+      // The supplied domain contains a _dnslink component
+      // Check the non-_dnslink domain
+      dnslinkRecord = await resolve(domain.replace('_dnslink.', ''))
+    } else {
+      // Check the _dnslink subdomain
+      const _dnslinkDomain = `_dnslink.${domain}`
+      // If this throws then we propagate the error
+      dnslinkRecord = await resolve(_dnslinkDomain)
+    }
+  }
+
+  const result = dnslinkRecord.replace('dnslink=', '')
+  const domainOrCID = result.split('/')[2]
+  const isIPFSCID = isIPFS.cid(domainOrCID)
+
+  if (isIPFSCID || depth === 0) {
+    return result
+  }
+
+  return await recursiveResolveDnslink(domainOrCID, depth - 1, options)
+}
+
+async function resolve (domain: string, options: AbortOptions = {}): Promise<string> {
+  const DNSLINK_REGEX = /^dnslink=.+$/
+  const records = await promisify(dns.resolveTxt)(domain)
+  const dnslinkRecords = records.reduce((rs, r) => rs.concat(r), [])
+    .filter(record => DNSLINK_REGEX.test(record))
+
+  const dnslinkRecord = dnslinkRecords[0]
+
+  // we now have dns text entries as an array of strings
+  // only records passing the DNSLINK_REGEX text are included
+  if (dnslinkRecord == null) {
+    throw new Error(`No dnslink records found for domain: ${domain}`)
+  }
+
+  return dnslinkRecord
+}

package/src/utils/tlru.ts

@@ -0,0 +1,52 @@
+import hashlru from 'hashlru'
+
+/**
+ * Time Aware Least Recent Used Cache
+ *
+ * @see https://arxiv.org/pdf/1801.00390
+ */
+export class TLRU<T> {
+  private readonly lru: ReturnType<typeof hashlru>
+
+  constructor (maxSize: number) {
+    this.lru = hashlru(maxSize)
+  }
+
+  get (key: string): T | undefined {
+    const value = this.lru.get(key)
+
+    if (value != null) {
+      if (value.expire != null && value.expire < Date.now()) {
+        this.lru.remove(key)
+
+        return undefined
+      }
+
+      return value.value
+    }
+
+    return undefined
+  }
+
+  set (key: string, value: T, ttl: number): void {
+    this.lru.set(key, { value, expire: Date.now() + ttl })
+  }
+
+  has (key: string): boolean {
+    const value = this.get(key)
+
+    if (value != null) {
+      return true
+    }
+
+    return false
+  }
+
+  remove (key: string): void {
+    this.lru.remove(key)
+  }
+
+  clear (): void {
+    this.lru.clear()
+  }
+}