@helia/verified-fetch 4.1.0 → 5.0.0

package/src/plugins/plugin-handle-unixfs.ts

@@ -0,0 +1,217 @@
+import { code as dagPbCode } from '@ipld/dag-pb'
+import { isPromise } from '@libp2p/utils'
+import { exporter } from 'ipfs-unixfs-exporter'
+import first from 'it-first'
+import itToBrowserReadableStream from 'it-to-browser-readablestream'
+import toBuffer from 'it-to-buffer'
+import * as raw from 'multiformats/codecs/raw'
+import { MEDIA_TYPE_OCTET_STREAM, MEDIA_TYPE_DAG_PB } from '../utils/content-types.ts'
+import { getContentDispositionFilename } from '../utils/get-content-disposition-filename.ts'
+import { badGatewayResponse, movedPermanentlyResponse, partialContentResponse, okResponse } from '../utils/responses.js'
+import { BasePlugin } from './plugin-base.js'
+import type { PluginContext } from '../index.js'
+import type { RangeHeader } from '../utils/get-range-header.ts'
+import type { AbortOptions } from '@libp2p/interface'
+import type { IdentityNode, RawNode, UnixFSEntry, UnixFSFile } from 'ipfs-unixfs-exporter'
+
+/**
+ * @see https://specs.ipfs.tech/http-gateways/path-gateway/#use-in-directory-url-normalization
+ */
+function getRedirectUrl (resource: string, url: URL, terminalElement: UnixFSEntry): string | undefined {
+  let uri: URL
+
+  try {
+    // try the requested resource
+    uri = new URL(resource)
+  } catch {
+    // fall back to the canonical URL
+    uri = url
+  }
+
+  // directories must be requested with a trailing slash
+  if (terminalElement?.type === 'directory' && !uri.pathname.endsWith('/')) {
+    // make sure we append slash to end of the path
+    uri.pathname += '/'
+
+    return uri.toString()
+  }
+}
+
+/**
+ * Handles UnixFS content
+ */
+export class UnixFSPlugin extends BasePlugin {
+  readonly id = 'unixfs-plugin'
+  readonly codes = [dagPbCode, raw.code]
+
+  canHandle ({ terminalElement, accept }: PluginContext): boolean {
+    const supportsCid = this.codes.includes(terminalElement.cid.code)
+    const supportsAccept = accept.length === 0 || accept.some(header => header.contentType.mediaType === MEDIA_TYPE_OCTET_STREAM ||
+      header.contentType.mediaType === MEDIA_TYPE_DAG_PB
+    )
+
+    return supportsCid && supportsAccept
+  }
+
+  async handle (context: PluginContext): Promise<Response> {
+    let { url, resource, terminalElement, ipfsRoots } = context
+    let filename = url.searchParams.get('filename') ?? terminalElement.name
+    let redirected: undefined | true
+
+    if (terminalElement.type === 'directory') {
+      const redirectUrl = getRedirectUrl(resource, url, terminalElement)
+
+      if (redirectUrl != null) {
+        this.log.trace('directory url normalization spec requires redirect')
+
+        if (context.options?.redirect === 'error') {
+          this.log('could not redirect to %s as redirect option was set to "error"', redirectUrl)
+          throw new TypeError('Failed to fetch')
+        } else if (context.options?.redirect === 'manual') {
+          this.log('returning 301 permanent redirect to %s', redirectUrl)
+          return movedPermanentlyResponse(context.resource, redirectUrl)
+        }
+
+        this.log('following redirect to %s', redirectUrl)
+
+        // fall-through simulates following the redirect?
+        resource = redirectUrl
+        redirected = true
+      }
+
+      const dirCid = terminalElement.cid
+
+      // if not disabled, search the directory for an index.html file
+      if (context.options?.supportDirectoryIndexes !== false) {
+        const rootFilePath = 'index.html'
+
+        try {
+          this.log.trace('found directory at %c/%s, looking for index.html', dirCid, url.pathname)
+
+          const entry = await context.serverTiming.time('exporter-dir', '', exporter(`/ipfs/${dirCid}/${rootFilePath}`, context.blockstore, context.options))
+
+          if (entry.type === 'directory' || entry.type === 'object') {
+            return badGatewayResponse(resource, 'Unable to stream content')
+          }
+
+          // use `index.html` as the file name to help with content types
+          filename = rootFilePath
+
+          this.log.trace('found directory index at %c/%s with cid %c', dirCid, rootFilePath, entry.cid)
+
+          return await this.streamFile(resource, entry, filename, redirected, context.range, context.options)
+        } catch (err: any) {
+          if (err.name !== 'NotFoundError') {
+            this.log.error('error loading path %c/%s - %e', dirCid, rootFilePath, err)
+            throw err
+          }
+        }
+      }
+
+      // no index file found, return the directory listing
+      const block = await toBuffer(context.blockstore.get(dirCid, context.options))
+
+      return okResponse(resource, block, {
+        headers: {
+          'content-type': MEDIA_TYPE_DAG_PB,
+          'content-length': `${block.byteLength}`,
+          'content-disposition': `${url.searchParams.get('download') === 'true' ? 'attachment' : 'inline'}; ${
+            getContentDispositionFilename(`${dirCid}.dir`)
+          }`,
+          'x-ipfs-roots': ipfsRoots.map(cid => cid.toV1()).join(','),
+          'accept-ranges': 'bytes'
+        },
+        redirected
+      })
+    } else if (terminalElement.type === 'file' || terminalElement.type === 'raw' || terminalElement.type === 'identity') {
+      this.log('streaming file')
+      return this.streamFile(resource, terminalElement, filename, redirected, context.range, context.options)
+    } else {
+      this.log.error('cannot stream terminal element type %s', terminalElement.type)
+      return badGatewayResponse(resource, 'Unable to stream content')
+    }
+  }
+
+  private async streamFile (resource: string, entry: UnixFSFile | RawNode | IdentityNode, filename: string, redirected?: boolean, rangeHeader?: RangeHeader, options?: AbortOptions): Promise<Response> {
+    let contentType = MEDIA_TYPE_OCTET_STREAM
+
+    // only detect content type for non-range requests to avoid loading blocks
+    // we aren't going to stream to the user
+    if (rangeHeader == null) {
+      contentType = await this.detectContentType(entry, filename, options)
+    }
+
+    if (rangeHeader != null) {
+      return partialContentResponse(resource, (offset, length) => {
+        return entry.content({
+          ...(options ?? {}),
+          offset,
+          length
+        })
+      }, rangeHeader, entry.size, {
+        headers: {
+          'content-type': contentType,
+          'content-disposition': `inline; ${
+            getContentDispositionFilename(filename)
+          }`,
+          'x-ipfs-roots': entry.cid.toString(),
+          'accept-ranges': 'bytes'
+        },
+        redirected
+      })
+    }
+
+    // nb. if streaming the output fails (network error, unresolvable block,
+    // etc), a "TypeError: Failed to fetch" error will occur
+    return okResponse(resource, itToBrowserReadableStream(entry.content(options)), {
+      headers: {
+        'content-type': contentType,
+        'content-length': `${entry.size}`,
+        'content-disposition': `inline; ${
+          getContentDispositionFilename(filename)
+        }`,
+        'x-ipfs-roots': entry.cid.toString(),
+        'accept-ranges': 'bytes'
+      },
+      redirected
+    })
+  }
+
+  private async detectContentType (entry: UnixFSFile | RawNode | IdentityNode, filename?: string, options?: AbortOptions): Promise<string> {
+    let buf: Uint8Array | undefined
+
+    if (entry.type === 'raw' || entry.type === 'identity') {
+      buf = entry.node
+    } else {
+      // read the first block of the file
+      buf = await first(entry.content(options))
+    }
+
+    if (buf == null) {
+      throw new Error('stream ended before first block was read')
+    }
+
+    let contentType: string | undefined
+
+    if (this.pluginOptions.contentTypeParser != null) {
+      try {
+        const parsed = this.pluginOptions.contentTypeParser(buf, filename)
+
+        if (isPromise(parsed)) {
+          const result = await parsed
+
+          if (result != null) {
+            contentType = result
+          }
+        } else if (parsed != null) {
+          contentType = parsed
+        }
+        this.log.trace('contentTypeParser returned %s for file with name %s', contentType, filename)
+      } catch (err) {
+        this.log.error('error parsing content type - %e', err)
+      }
+    }
+
+    return contentType ?? MEDIA_TYPE_OCTET_STREAM
+  }
+}

package/src/plugins/types.ts

@@ -1,86 +0,0 @@
-import type { ResolveURLResult, VerifiedFetchInit, ContentTypeParser, RequestFormatShorthand } from '../index.js'
-import type { ByteRangeContext } from '../utils/byte-range-context.js'
-import type { AcceptHeader } from '../utils/select-output-type.ts'
-import type { ServerTiming } from '../utils/server-timing.ts'
-import type { PathWalkerResponse } from '../utils/walk-path.js'
-import type { IPNSResolver } from '@helia/ipns'
-import type { AbortOptions, Logger } from '@libp2p/interface'
-import type { Helia } from 'helia'
-import type { Blockstore } from 'interface-blockstore'
-import type { UnixFSEntry } from 'ipfs-unixfs-exporter'
-import type { CID } from 'multiformats/cid'
-import type { CustomProgressEvent } from 'progress-events'
-
-/**
- * Contains common components and functions required by plugins to handle a request.
- * - Read-Only: Plugins can read but shouldn't rewrite them.
- * - Persistent: Relevant even after the request completes (e.g., logging or metrics).
- */
-export interface PluginOptions {
-  logger: Logger
-  getBlockstore(cid: CID, resource: string | CID, useSession?: boolean, options?: AbortOptions): Blockstore
-  contentTypeParser?: ContentTypeParser
-  helia: Helia
-  ipnsResolver: IPNSResolver
-}
-
-/**
- * Represents the ephemeral, modifiable state used by the pipeline.
- * - Mutable: Evolves as you walk the plugin chain.
- * - Shared Data: Allows plugins to communicate partial results, discovered data, or interim errors.
- * - Ephemeral: Typically discarded once fetch(...) completes.
- */
-export interface PluginContext extends ResolveURLResult {
-  readonly resource: string
-  readonly accept?: AcceptHeader
-
-  /**
-   * An array of plugin IDs that are all enabled. You can use this to check if a plugin is enabled and respond accordingly.
-   */
-  plugins: string[]
-
-  /**
-   * The last time the context is modified, so we know whether a plugin has modified it.
-   * A plugin should increment this value if it modifies the context.
-   */
-  modified: number
-  onProgress?(evt: CustomProgressEvent<any>): void
-  options?: Omit<VerifiedFetchInit, 'signal'> & AbortOptions
-  isDirectory?: boolean
-  directoryEntries?: UnixFSEntry[]
-  reqFormat?: RequestFormatShorthand
-  pathDetails?: PathWalkerResponse
-
-  /**
-   * ByteRangeContext contains information about the size of the content and range requests.
-   * This can be used to set the Content-Length header without loading the entire body.
-   *
-   * This is set by the ByteRangeContextPlugin
-   */
-  byteRangeContext?: ByteRangeContext
-  serverTiming: ServerTiming
-  ipfsPath: string
-
-  /**
-   * Allow arbitrary keys/values
-   */
-  [key: string]: unknown
-}
-
-export interface VerifiedFetchPlugin {
-  readonly id: string
-  readonly codes: number[]
-  readonly log: Logger
-  canHandle (context: PluginContext): boolean
-  handle (context: PluginContext): Promise<Response | null>
-}
-
-export interface VerifiedFetchPluginFactory {
-  (options: PluginOptions): VerifiedFetchPlugin
-}
-
-export interface PluginErrorOptions {
-  fatal?: boolean
-  details?: Record<string, any>
-  response?: Response
-}

package/src/url-resolver.ts

@@ -1,100 +1,145 @@
-import { peerIdFromCID, peerIdFromString } from '@libp2p/peer-id'
+import { DoesNotExistError } from '@helia/unixfs/errors'
+import * as dagCbor from '@ipld/dag-cbor'
+import * as dagJson from '@ipld/dag-json'
+import * as dagPb from '@ipld/dag-pb'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { InvalidParametersError, walkPath } from 'ipfs-unixfs-exporter'
+import toBuffer from 'it-to-buffer'
 import { CID } from 'multiformats/cid'
-import { parseURLString } from './utils/parse-url-string.ts'
-import type { ResolveURLOptions, ResolveURLResult, Resource, URLResolver as URLResolverInterface } from './index.ts'
-import type { ParsedURL } from './utils/parse-url-string.ts'
-import type { ServerTiming } from './utils/server-timing.ts'
+import * as json from 'multiformats/codecs/json'
+import * as raw from 'multiformats/codecs/raw'
+import QuickLRU from 'quick-lru'
+import { SESSION_CACHE_MAX_SIZE, SESSION_CACHE_TTL_MS, CODEC_CBOR, CODEC_IDENTITY } from './constants.ts'
+import { resourceToSessionCacheKey } from './utils/resource-to-cache-key.ts'
+import { ServerTiming } from './utils/server-timing.ts'
+import type { ResolveURLResult, URLResolver as URLResolverInterface } from './index.ts'
 import type { DNSLink } from '@helia/dnslink'
 import type { IPNSResolver } from '@helia/ipns'
-import type { AbortOptions, PeerId } from '@libp2p/interface'
+import type { AbortOptions } from '@libp2p/interface'
+import type { Helia, SessionBlockstore } from 'helia'
+import type { Blockstore } from 'interface-blockstore'
+import type { UnixFSEntry } from 'ipfs-unixfs-exporter'
+
+// 1 year in seconds for ipfs content
+const IPFS_CONTENT_TTL = 29030400
+
+const ENTITY_CODECS = [
+  CODEC_CBOR,
+  json.code,
+  raw.code
+]
+
+/**
+ * These are supported by the UnixFS exporter
+ */
+const EXPORTABLE_CODECS = [
+  dagPb.code,
+  dagCbor.code,
+  dagJson.code,
+  raw.code
+]
+
+interface GetBlockstoreOptions extends AbortOptions {
+  session?: boolean
+}
 
-const CODEC_LIBP2P_KEY = 0x72
+export interface WalkPathResult {
+  ipfsRoots: CID[]
+  terminalElement: UnixFSEntry
+  blockstore: Blockstore
+}
+
+function basicEntry (type: 'raw' | 'object', cid: CID, bytes: Uint8Array): UnixFSEntry {
+  return {
+    name: cid.toString(),
+    path: cid.toString(),
+    depth: 0,
+    type,
+    node: bytes,
+    cid,
+    size: BigInt(bytes.byteLength),
+    content: async function * () {
+      yield bytes
+    }
+  }
+}
 
 export interface URLResolverComponents {
+  helia: Helia
   ipnsResolver: IPNSResolver
   dnsLink: DNSLink
-  timing: ServerTiming
+}
+
+export interface URLResolverInit {
+  sessionCacheSize?: number
+  sessionTTLms?: number
+}
+
+export interface ResolveURLOptions extends AbortOptions {
+  session?: boolean
+  isRawBlockRequest?: boolean
+  onlyIfCached?: boolean
 }
 
 export class URLResolver implements URLResolverInterface {
   private readonly components: URLResolverComponents
+  private readonly blockstoreSessions: QuickLRU<string, SessionBlockstore>
 
-  constructor (components: URLResolverComponents) {
+  constructor (components: URLResolverComponents, init: URLResolverInit = {}) {
     this.components = components
+
+    this.blockstoreSessions = new QuickLRU({
+      maxSize: init.sessionCacheSize ?? SESSION_CACHE_MAX_SIZE,
+      maxAge: init.sessionTTLms ?? SESSION_CACHE_TTL_MS,
+      onEviction: (key, store) => {
+        store.close()
+      }
+    })
   }
 
-  async resolve (resource: Resource, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
-    if (typeof resource === 'string') {
-      return this.parseUrlString(resource, options)
+  async resolve (url: URL, serverTiming: ServerTiming = new ServerTiming(), options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
+    if (url.protocol === 'ipfs:') {
+      return this.resolveIPFSPath(url, serverTiming, options)
     }
 
-    const cid = CID.asCID(resource)
-
-    if (cid != null) {
-      return this.resolveCIDResource(cid, {
-        url: new URL(`ipfs://${cid}`)
-      }, options)
+    if (url.protocol === 'ipns:') {
+      return this.resolveIPNSName(url, serverTiming, options)
     }
 
-    throw new TypeError(`Invalid resource. Cannot determine CID from resource: ${resource}`)
-  }
-
-  async parseUrlString (urlString: string, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
-    const result = parseURLString(urlString)
-
-    if (result.protocol === 'ipfs') {
-      const cid = CID.parse(result.cidOrPeerIdOrDnsLink)
-
-      return this.resolveCIDResource(cid, result, options)
+    if (url.protocol === 'dnslink:') {
+      return this.resolveDNSLink(url, serverTiming, options)
     }
 
-    if (result.protocol === 'ipns') {
-      // try to parse target as peer id
-      let peerId: PeerId
-
-      try {
-        peerId = peerIdFromString(result.cidOrPeerIdOrDnsLink)
-      } catch {
-        // fall back to DNSLink (e.g. /ipns/example.com)
-        return this.resolveDNSLink(result.cidOrPeerIdOrDnsLink, result, options)
-      }
+    throw new InvalidParametersError(`Invalid resource. Unsupported protocol in URL, must be ipfs:, ipns:, or dnslink: ${url}`)
+  }
 
-      // parse multihash from string (e.g. /ipns/QmFoo...)
-      return this.resolveIPNSName(result.cidOrPeerIdOrDnsLink, peerId, result, options)
+  private getBlockstore (root: CID, options: GetBlockstoreOptions = {}): Blockstore {
+    if (options.session === false) {
+      return this.components.helia.blockstore
     }
 
-    throw new TypeError(`Invalid resource. Cannot determine CID from resource: ${urlString}`)
-  }
+    const key = resourceToSessionCacheKey(root)
+    let session = this.blockstoreSessions.get(key)
 
-  async resolveCIDResource (cid: CID, parsed: Partial<ParsedURL> & Pick<ParsedURL, 'url'>, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
-    if (cid.code === CODEC_LIBP2P_KEY) {
-      // special case - peer id encoded as a CID
-      return this.resolveIPNSName(cid.toString(), peerIdFromCID(cid), parsed, options)
+    if (session == null) {
+      session = this.components.helia.blockstore.createSession(root, options)
+      this.blockstoreSessions.set(key, session)
     }
 
-    return {
-      url: parsed.url,
-      cid,
-      protocol: 'ipfs',
-      query: parsed.query ?? {},
-      path: parsed.path ?? [],
-      fragment: parsed.fragment ?? '',
-      ttl: 29030400, // 1 year for ipfs content
-      ipfsPath: `/ipfs/${cid}${parsed.url.pathname}`
-    }
+    return session
   }
 
-  async resolveDNSLink (domain: string, parsed: ParsedURL, options?: ResolveURLOptions): Promise<ResolveURLResult> {
-    const results = await this.components.timing.time('dnsLink.resolve', `Resolve DNSLink ${domain}`, this.components.dnsLink.resolve(domain, options))
+  private async resolveDNSLink (url: URL, serverTiming: ServerTiming, options?: ResolveURLOptions): Promise<ResolveURLResult> {
+    const results = await serverTiming.time('dnsLink.resolve', `Resolve DNSLink ${url.hostname}`, this.components.dnsLink.resolve(url.hostname, options))
     const result = results?.[0]
 
     if (result == null) {
-      throw new TypeError(`Invalid resource. Cannot resolve DNSLink from domain: ${domain}`)
+      throw new TypeError(`Invalid resource. Cannot resolve DNSLink from domain: ${url.hostname}`)
     }
 
     // dnslink resolved to IPNS name
     if (result.namespace === 'ipns') {
-      return this.resolveIPNSName(domain, result.peerId, parsed, options)
+      return this.resolveIPNSName(url, serverTiming, options)
     }
 
     // dnslink resolved to CID
@@ -103,38 +148,107 @@ export class URLResolver implements URLResolverInterface {
       throw new TypeError(`Invalid resource. Unexpected DNSLink namespace ${result.namespace} from domain: ${domain}`)
     }
 
+    if (result.path != null && url.pathname !== '') {
+      // path conflict?
+    }
+
+    const ipfsUrl = new URL(`ipfs://${result.cid}/${url.pathname}`)
+    const ipfsResult = await this.resolveIPFSPath(ipfsUrl, serverTiming, options)
+
     return {
-      url: parsed.url,
-      cid: result.cid,
-      path: concatPaths(...(result.path ?? '').split('/'), ...(parsed.path ?? [])),
-      fragment: parsed.fragment,
-      // dnslink is mutable so return 'ipns' protocol so we do not include immutable in cache-control header
-      protocol: 'ipns',
-      ttl: result.answer.TTL,
-      query: parsed.query,
-      ipfsPath: `/ipns/${domain}${parsed.url.pathname}`
+      ...ipfsResult,
+      url,
+      ttl: result.answer.TTL
     }
   }
 
-  async resolveIPNSName (resource: string, key: PeerId, parsed: Partial<ParsedURL> & Pick<ParsedURL, 'url'>, options?: AbortOptions): Promise<ResolveURLResult> {
-    const result = await this.components.timing.time('ipns.resolve', `Resolve IPNS name ${key}`, this.components.ipnsResolver.resolve(key, options))
+  private async resolveIPNSName (url: URL, serverTiming: ServerTiming, options?: ResolveURLOptions): Promise<ResolveURLResult> {
+    const peerId = peerIdFromString(url.hostname)
+    const result = await serverTiming.time('ipns.resolve', `Resolve IPNS name ${peerId}`, this.components.ipnsResolver.resolve(peerId, options))
+
+    if (result.path != null && url.pathname !== '') {
+      // path conflict?
+    }
+
+    const ipfsUrl = new URL(`ipfs://${result.cid}/${url.pathname}`)
+    const ipfsResult = await this.resolveIPFSPath(ipfsUrl, serverTiming, options)
 
     return {
-      url: parsed.url,
-      cid: result.cid,
-      path: concatPaths(...(result.path ?? '').split('/'), ...(parsed.path ?? [])),
-      query: parsed.query ?? {},
-      fragment: parsed.fragment ?? '',
-      protocol: 'ipns',
+      ...ipfsResult,
+      url,
       // IPNS ttl is in nanoseconds, convert to seconds
-      ttl: Number((result.record.ttl ?? 0n) / BigInt(1e9)),
-      ipfsPath: `/ipns/${resource}${parsed.url.pathname}`
+      ttl: Number((result.record.ttl ?? 0n) / BigInt(1e9))
+    }
+  }
+
+  private async resolveIPFSPath (url: URL, serverTiming: ServerTiming, options?: ResolveURLOptions): Promise<ResolveURLResult> {
+    const walkPathResult = await serverTiming.time('ipfs.resolve', '', this.walkPath(url, options))
+
+    return {
+      ...walkPathResult,
+      url,
+      ttl: IPFS_CONTENT_TTL,
+      blockstore: walkPathResult.blockstore
+    }
+  }
+
+  private async walkPath (url: URL, options: ResolveURLOptions = {}): Promise<WalkPathResult> {
+    const cid = CID.parse(url.hostname)
+    const blockstore = this.getBlockstore(cid, options)
+
+    if (EXPORTABLE_CODECS.includes(cid.code)) {
+      const ipfsRoots: CID[] = []
+      let terminalElement: UnixFSEntry | undefined
+      const ipfsPath = toIPFSPath(url)
+
+      // @ts-expect-error offline is a helia option
+      for await (const entry of walkPath(ipfsPath, blockstore, {
+        ...options,
+        offline: options.onlyIfCached === true,
+        extended: options.isRawBlockRequest !== true
+      })) {
+        ipfsRoots.push(entry.cid)
+        terminalElement = entry
+      }
+
+      if (terminalElement == null) {
+        throw new DoesNotExistError('No terminal element found')
+      }
+
+      return {
+        ipfsRoots,
+        terminalElement,
+        blockstore
+      }
+    }
+
+    let bytes: Uint8Array
+
+    if (cid.multihash.code === CODEC_IDENTITY) {
+      bytes = cid.multihash.digest
+    } else {
+      bytes = await toBuffer(blockstore.get(cid, options))
+    }
+
+    // entity codecs contain all the bytes for an entity in one block and no
+    // path walking outside of that block is possible
+    if (ENTITY_CODECS.includes(cid.code)) {
+      return {
+        ipfsRoots: [cid],
+        terminalElement: basicEntry('object', cid, bytes),
+        blockstore
+      }
+    }
+
+    // may be an unknown codec
+    return {
+      ipfsRoots: [cid],
+      terminalElement: basicEntry('raw', cid, bytes),
+      blockstore
     }
   }
 }
 
-function concatPaths (...paths: Array<string | undefined>): string[] {
-  // @ts-expect-error undefined is filtered out
-  return paths
-    .filter(p => p != null && p !== '')
+function toIPFSPath (url: URL): string {
+  return `/ipfs/${url.hostname}${decodeURI(url.pathname)}`
 }

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

@@ -39,7 +39,8 @@ export async function contentTypeParser (bytes: Uint8Array, fileName?: string):
     return detectedType
   }
 
-  if (fileName == null) {
+  // no filename or filename has no extension
+  if (fileName == null || fileName.includes('.') === false) {
     // it's likely text... no other way to determine file-type.
     const text = getText(bytes)
 
@@ -59,7 +60,7 @@ export async function contentTypeParser (bytes: Uint8Array, fileName?: string):
     return defaultMimeType
   }
 
-  // no need to include file-types listed at https://github.com/SgtPooki/file-type#supported-file-types
+  // no need to include file-types listed at https://github.com/sindresorhus/file-type#supported-file-types
   switch (fileName.split('.').pop()) {
     case 'css':
       return 'text/css'
@@ -73,7 +74,7 @@ export async function contentTypeParser (bytes: Uint8Array, fileName?: string):
       return 'text/plain'
     case 'woff2':
       return 'font/woff2'
-    // see bottom of https://github.com/SgtPooki/file-type#supported-file-types
+    // see bottom of https://github.com/sindresorhus/file-type#supported-file-types
     case 'svg':
       return 'image/svg+xml'
     case 'csv':