@helia/verified-fetch 4.1.1 → 5.0.1

package/src/utils/handle-redirects.ts

@@ -1,109 +0,0 @@
-import { SubdomainNotSupportedError } from '../errors.js'
-import { parseURLString } from './parse-url-string.js'
-import { movedPermanentlyResponse } from './responses.js'
-import type { VerifiedFetchInit, Resource } from '../index.js'
-import type { AbortOptions, ComponentLogger } from '@libp2p/interface'
-import type { CID } from 'multiformats/cid'
-
-interface GetRedirectResponse {
-  cid: CID
-  resource: Resource
-  options?: Omit<VerifiedFetchInit, 'signal'> & AbortOptions
-  logger: ComponentLogger
-
-  /**
-   * Only used in testing.
-   */
-  fetch?: typeof globalThis.fetch
-}
-
-function maybeAddTrailingSlash (path: string): string {
-  // if it has an extension-like ending, don't add a trailing slash
-  if (path.match(/\.[a-zA-Z0-9]{1,4}$/) != null) {
-    return path
-  }
-  return path.endsWith('/') ? path : `${path}/`
-}
-
-// See https://specs.ipfs.tech/http-gateways/path-gateway/#location-response-header
-export async function getRedirectResponse ({ resource, options, logger, cid, fetch = globalThis.fetch }: GetRedirectResponse): Promise<null | Response> {
-  const log = logger.forComponent('helia:verified-fetch:get-redirect-response')
-
-  if (typeof resource !== 'string' || options == null || ['ipfs://', 'ipns://'].some((prefix) => resource.startsWith(prefix))) {
-    return null
-  }
-
-  const headers = new Headers(options?.headers)
-  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
-  try {
-    const urlParts = parseURLString(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 {
-      subdomainUrl.host = `${urlParts.cidOrPeerIdOrDnsLink}.${urlParts.protocol}.${actualHost}`
-    }
-
-    if (headerHost?.includes(urlParts.protocol) === true && subdomainUrl.host.includes(headerHost)) {
-      log.trace('request was for a subdomain already, not setting location header')
-      return null
-    }
-
-    if (headerHost != null && !subdomainUrl.host.includes(headerHost)) {
-      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
-    }
-
-    subdomainUrl.pathname = maybeAddTrailingSlash(reqUrl.pathname.replace(`/${urlParts.cidOrPeerIdOrDnsLink}`, '').replace(`/${urlParts.protocol}`, ''))
-    log.trace('subdomain url %s', subdomainUrl.href)
-    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' })
-      if (subdomainTest.ok) {
-        log('subdomain supported, redirecting to subdomain')
-        return movedPermanentlyResponse(resource.toString(), subdomainUrl.href)
-      } else {
-        log('subdomain not supported, subdomain failed with status %s %s', subdomainTest.status, subdomainTest.statusText)
-        throw new SubdomainNotSupportedError('subdomain not supported')
-      }
-    } catch (err: any) {
-      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)
-    }
-  } catch (e) {
-    // if it's not a full URL, we have nothing left to do.
-    log.error('error setting location header for x-forwarded-host', e)
-  }
-  return null
-}

package/src/utils/is-accept-explicit.ts

@@ -1,38 +0,0 @@
-import { FORMAT_TO_MIME_TYPE } from './select-output-type.js'
-import type { UrlQuery } from '../index.ts'
-
-export interface IsAcceptExplicitOptions {
-  query?: UrlQuery
-  headers: Headers
-}
-
-export function isExplicitAcceptHeader (headers: Headers): boolean {
-  const incomingAcceptHeader = headers.get('accept')
-
-  if (incomingAcceptHeader == null) {
-    return false
-  }
-
-  return Object.values(FORMAT_TO_MIME_TYPE)
-    .some(mimeType => incomingAcceptHeader.includes(mimeType))
-}
-
-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.
- *
- * If either of these are provided, this function returns true.
- */
-export function isExplicitIpldAcceptRequest ({ query, headers }: IsAcceptExplicitOptions): boolean {
-  return isExplicitAcceptHeader(headers) || isExplicitFormatQuery(query)
-}

package/src/utils/request-headers.ts

@@ -1,65 +0,0 @@
-import { InvalidRangeError } from '../errors.js'
-
-export function getHeader (headers: HeadersInit | undefined, header: string): string | undefined {
-  if (headers == null) {
-    return undefined
-  }
-  if (headers instanceof Headers) {
-    return headers.get(header) ?? undefined
-  }
-  if (Array.isArray(headers)) {
-    const entry = headers.find(([key]) => key.toLowerCase() === header.toLowerCase())
-    return entry?.[1]
-  }
-  const key = Object.keys(headers).find(k => k.toLowerCase() === header.toLowerCase())
-  if (key == null) {
-    return undefined
-  }
-
-  return headers[key]
-}
-
-/**
- * Given two ints from a Range header, and potential fileSize, returns:
- * 1. number of bytes the response should contain.
- * 2. the start index of the range. // inclusive
- * 3. the end index of the range. // inclusive
- */
-// eslint-disable-next-line complexity
-export function calculateByteRangeIndexes (start: number | undefined, end: number | undefined, fileSize?: number): { byteSize?: number, start?: number, end?: number } {
-  if ((start ?? 0) > (end ?? Infinity)) {
-    throw new InvalidRangeError('Invalid range: Range-start index is greater than range-end index.')
-  }
-  if (start != null && (end ?? 0) >= (fileSize ?? Infinity)) {
-    throw new InvalidRangeError('Invalid range: Range-end index is greater than or equal to the size of the file.')
-  }
-  if (start == null && (end ?? 0) > (fileSize ?? Infinity)) {
-    throw new InvalidRangeError('Invalid range: Range-end index is greater than the size of the file.')
-  }
-  if (start != null && start < 0) {
-    throw new InvalidRangeError('Invalid range: Range-start index cannot be negative.')
-  }
-
-  if (start != null && end != null) {
-    return { byteSize: end - start + 1, start, end }
-  } else if (start == null && end != null) {
-    // suffix byte range requested
-    if (fileSize == null) {
-      return { end }
-    }
-    if (end === fileSize) {
-      return { byteSize: fileSize, start: 0, end: fileSize - 1 }
-    }
-    return { byteSize: end, start: fileSize - end, end: fileSize - 1 }
-  } else if (start != null && end == null) {
-    if (fileSize == null) {
-      // we only have the start index, and no fileSize, so we can't return a valid range.
-      return { start }
-    }
-    const end = fileSize - 1
-    const byteSize = fileSize - start
-    return { byteSize, start, end }
-  }
-
-  return { byteSize: fileSize, start: 0, end: fileSize != null ? fileSize - 1 : 0 }
-}

package/src/utils/select-output-type.ts

@@ -1,175 +0,0 @@
-import { code as dagCborCode } from '@ipld/dag-cbor'
-import { code as dagJsonCode } from '@ipld/dag-json'
-import { code as dagPbCode } from '@ipld/dag-pb'
-import { code as jsonCode } from 'multiformats/codecs/json'
-import { code as rawCode } from 'multiformats/codecs/raw'
-import { CODEC_CBOR } from '../constants.ts'
-import type { RequestFormatShorthand } from '../index.js'
-import type { CID } from 'multiformats/cid'
-
-/**
- * This maps supported response types for each codec supported by verified-fetch
- */
-const CID_TYPE_MAP: Record<number, string[]> = {
-  [dagCborCode]: [
-    'application/json',
-    'application/vnd.ipld.dag-cbor',
-    'application/cbor',
-    'application/vnd.ipld.dag-json',
-    'application/octet-stream',
-    'application/vnd.ipld.raw',
-    'application/vnd.ipfs.ipns-record',
-    'application/vnd.ipld.car',
-    'text/html'
-  ],
-  [dagJsonCode]: [
-    'application/json',
-    'application/vnd.ipld.dag-cbor',
-    'application/cbor',
-    'application/vnd.ipld.dag-json',
-    'application/octet-stream',
-    'application/vnd.ipld.raw',
-    'application/vnd.ipfs.ipns-record',
-    'application/vnd.ipld.car'
-  ],
-  [jsonCode]: [
-    'application/json',
-    'application/vnd.ipld.dag-cbor',
-    'application/cbor',
-    'application/vnd.ipld.dag-json',
-    'application/octet-stream',
-    'application/vnd.ipld.raw',
-    'application/vnd.ipfs.ipns-record',
-    'application/vnd.ipld.car'
-  ],
-  [dagPbCode]: [
-    'application/octet-stream',
-    'application/json',
-    'application/vnd.ipld.dag-cbor',
-    'application/cbor',
-    'application/vnd.ipld.dag-json',
-    'application/vnd.ipld.raw',
-    'application/vnd.ipfs.ipns-record',
-    'application/vnd.ipld.car',
-    'application/x-tar'
-  ],
-  [rawCode]: [
-    'application/octet-stream',
-    'application/vnd.ipld.raw',
-    'application/vnd.ipfs.ipns-record',
-    'application/vnd.ipld.dag-json',
-    'application/vnd.ipld.car',
-    'application/x-tar'
-  ],
-  [CODEC_CBOR]: [
-    'application/json',
-    'application/vnd.ipld.dag-cbor',
-    'application/cbor',
-    'application/vnd.ipld.dag-json',
-    'application/octet-stream',
-    'application/vnd.ipld.raw',
-    'application/vnd.ipfs.ipns-record',
-    'application/vnd.ipld.car',
-    'text/html'
-  ]
-}
-
-export interface AcceptHeader {
-  mimeType: string
-  options: Record<string, string>
-}
-
-/**
- * Selects an output mime-type based on the CID and a passed `Accept` header
- */
-export function selectOutputType (cid: CID, accept?: string): AcceptHeader | undefined {
-  const cidMimeTypes = CID_TYPE_MAP[cid.code] ?? []
-
-  if (accept != null) {
-    return chooseMimeType(accept, cidMimeTypes)
-  }
-}
-
-function chooseMimeType (accept: string, validMimeTypes: string[]): AcceptHeader | undefined {
-  const requestedMimeTypes = accept
-    .split(',')
-    .map(s => {
-      const parts = s.trim().split(';')
-
-      const options: Record<string, string> = {
-        q: '0'
-      }
-
-      for (let i = 1; i < parts.length; i++) {
-        const [key, value] = parts[i].split('=').map(s => s.trim())
-
-        options[key] = value
-      }
-
-      return {
-        mimeType: `${parts[0]}`.trim(),
-        options
-      }
-    })
-    .sort((a, b) => {
-      if (a.options.q === b.options.q) {
-        return 0
-      }
-
-      if (a.options.q > b.options.q) {
-        return -1
-      }
-
-      return 1
-    })
-
-  for (const headerFormat of requestedMimeTypes) {
-    for (const mimeType of validMimeTypes) {
-      if (headerFormat.mimeType.includes(mimeType)) {
-        return headerFormat
-      }
-
-      if (headerFormat.mimeType === '*/*') {
-        return {
-          mimeType,
-          options: headerFormat.options
-        }
-      }
-
-      if (headerFormat.mimeType.startsWith('*/') && mimeType.split('/')[1] === headerFormat.mimeType.split('/')[1]) {
-        return {
-          mimeType,
-          options: headerFormat.options
-        }
-      }
-
-      if (headerFormat.mimeType.endsWith('/*') && mimeType.split('/')[0] === headerFormat.mimeType.split('/')[0]) {
-        return {
-          mimeType,
-          options: headerFormat.options
-        }
-      }
-    }
-  }
-}
-
-export const FORMAT_TO_MIME_TYPE: Record<RequestFormatShorthand, string> = {
-  raw: 'application/vnd.ipld.raw',
-  car: 'application/vnd.ipld.car',
-  'dag-json': 'application/vnd.ipld.dag-json',
-  'dag-cbor': 'application/vnd.ipld.dag-cbor',
-  json: 'application/json',
-  cbor: 'application/cbor',
-  'ipns-record': 'application/vnd.ipfs.ipns-record',
-  tar: 'application/x-tar'
-}
-
-/**
- * Converts a `format=...` query param to a mime type as would be found in the
- * `Accept` header, if a valid mapping is available
- */
-export function queryFormatToAcceptHeader (format?: RequestFormatShorthand): string | undefined {
-  if (format != null) {
-    return FORMAT_TO_MIME_TYPE[format]
-  }
-}

package/src/utils/tlru.ts

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

package/src/utils/walk-path.ts

@@ -1,69 +0,0 @@
-import { DoesNotExistError } from '@helia/unixfs/errors'
-import { AbortError } from '@libp2p/interface'
-import { walkPath as exporterWalk } from 'ipfs-unixfs-exporter'
-import { badGatewayResponse, notFoundResponse } from './responses.js'
-import type { PluginContext } from '../plugins/types.js'
-import type { Logger } from '@libp2p/interface'
-import type { Blockstore } from 'interface-blockstore'
-import type { ExporterOptions, ReadableStorage, ObjectNode, UnixFSEntry } from 'ipfs-unixfs-exporter'
-import type { CID } from 'multiformats/cid'
-
-export interface PathWalkerOptions extends ExporterOptions {
-
-}
-
-export interface PathWalkerResponse {
-  ipfsRoots: CID[]
-  terminalElement: UnixFSEntry
-}
-
-export interface PathWalkerFn {
-  (blockstore: ReadableStorage, path: string, options?: PathWalkerOptions): Promise<PathWalkerResponse>
-}
-
-async function walkPath (blockstore: ReadableStorage, path: string, options?: PathWalkerOptions): Promise<PathWalkerResponse> {
-  const ipfsRoots: CID[] = []
-  let terminalElement: UnixFSEntry | undefined
-
-  for await (const entry of exporterWalk(path, blockstore, options)) {
-    ipfsRoots.push(entry.cid)
-    terminalElement = entry
-  }
-
-  if (terminalElement == null) {
-    throw new DoesNotExistError('No terminal element found')
-  }
-
-  return {
-    ipfsRoots,
-    terminalElement
-  }
-}
-
-export function isObjectNode (node: UnixFSEntry): node is ObjectNode {
-  return node.type === 'object'
-}
-
-/**
- * Attempts to walk the path in the blockstore, returning ipfsRoots needed to resolve the path, and the terminal element.
- * If the signal is aborted, the function will throw an AbortError
- * If a terminal element is not found, a notFoundResponse is returned
- * If another unknown error occurs, a badGatewayResponse is returned
- *
- */
-export async function handlePathWalking ({ cid, path, resource, options, blockstore, log }: PluginContext & { blockstore: Blockstore, log: Logger }): Promise<PathWalkerResponse | Response> {
-  try {
-    return await walkPath(blockstore, `${cid}/${path.join('/')}`, options)
-  } catch (err: any) {
-    if (options?.signal?.aborted) {
-      throw new AbortError(options?.signal?.reason)
-    }
-
-    if (['ERR_NO_PROP', 'ERR_NO_TERMINAL_ELEMENT', 'ERR_NOT_FOUND'].includes(err.code)) {
-      return notFoundResponse(resource)
-    }
-
-    log.error('error walking path "%s" - %e', path, err)
-    return badGatewayResponse(resource, 'Error walking path')
-  }
-}