@helia/verified-fetch 5.0.2 → 5.0.4

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

@@ -53,7 +53,7 @@ export class CarPlugin extends BasePlugin {
   }
 
   async handle (context: PluginContext): Promise<Response> {
-    const { options, url, accept, resource, blockstore, range, ipfsRoots, terminalElement } = context
+    const { options, url, accept, resource, blockstore, range, ipfsRoots, terminalElement, requestedMimeTypes } = context
 
     if (range != null) {
       return badRequestResponse(resource, new Error('Range requests are not supported for CAR files'))
@@ -67,12 +67,12 @@ export class CarPlugin extends BasePlugin {
       return badRequestResponse(resource, new Error('Could not find CAR media type in accept header'))
     }
 
-    const order = acceptCar.options.order === 'dfs' || url.searchParams.get('car-order') === 'dfs' ? 'dfs' : 'unk'
-    const duplicates = acceptCar.options.dups !== 'n' && url.searchParams.get('car-dups') !== 'n'
+    const order = acceptCar.options.order === 'dfs' ? 'dfs' : 'unk'
+    const duplicates = acceptCar.options.dups !== 'n'
 
     // TODO: `@ipld/car` only supports CARv1
     if (acceptCar.options.version === '2' || url.searchParams.get('car-version') === '2') {
-      return notAcceptableResponse(resource, [
+      return notAcceptableResponse(resource, requestedMimeTypes, [
         CONTENT_TYPE_CAR
       ])
     }

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

@@ -43,7 +43,7 @@ export class IpldPlugin extends BasePlugin {
   }
 
   async handle (context: PluginContext): Promise<Response> {
-    const { url, resource, accept, ipfsRoots, terminalElement, blockstore, options } = context
+    const { url, resource, accept, ipfsRoots, terminalElement, blockstore, options, requestedMimeTypes } = context
 
     this.log.trace('fetching %c/%s', terminalElement.cid, url.pathname)
     let block: Uint8Array
@@ -64,7 +64,7 @@ export class IpldPlugin extends BasePlugin {
       contentType = result.contentType
     } catch (err) {
       this.log.error('could not decode object from block - %e', err)
-      return notAcceptableResponse(resource, getContentTypesForCid(terminalElement.cid))
+      return notAcceptableResponse(resource, requestedMimeTypes, getContentTypesForCid(terminalElement.cid))
     }
 
     const headers = {

package/src/utils/error-to-response.ts

@@ -1,5 +1,4 @@
-import { CONTENT_TYPE_OCTET_STREAM, CONTENT_TYPE_RAW } from './content-types.ts'
-import { badGatewayResponse, gatewayTimeoutResponse, internalServerErrorResponse, notAcceptableResponse, notFoundResponse, preconditionFailedResponse } from './responses.js'
+import { badGatewayResponse, gatewayTimeoutResponse, internalServerErrorResponse, notFoundResponse, preconditionFailedResponse } from './responses.js'
 import type { Resource } from '../index.js'
 
 export function errorToResponse (resource: Resource | string, err: any): Response {
@@ -10,15 +9,12 @@ export function errorToResponse (resource: Resource | string, err: any): Respons
 
   // could not reach an upstream server, bad connection or offline
   if (err.code === 'ECONNREFUSED' || err.code === 'ECANCELLED' || err.name === 'DNSQueryFailedError') {
-    return badGatewayResponse(resource.toString(), err)
+    return gatewayTimeoutResponse(resource.toString(), err)
   }
 
   // data was not parseable, user may be able to request raw block
   if (['NotUnixFSError'].includes(err.name)) {
-    return notAcceptableResponse(resource.toString(), [
-      CONTENT_TYPE_RAW,
-      CONTENT_TYPE_OCTET_STREAM
-    ])
+    return badGatewayResponse(resource.toString(), err)
   }
 
   // an upstream server didn't respond in time but inside the signal timeout
@@ -40,8 +36,8 @@ export function errorToResponse (resource: Resource | string, err: any): Respons
     return preconditionFailedResponse(resource.toString())
   }
 
-  if (['RecordNotFoundError'].includes('err.name')) {
-    return badGatewayResponse(resource.toString(), err)
+  if (['RecordNotFoundError', 'LoadBlockFailedError'].includes(err.name)) {
+    return gatewayTimeoutResponse(resource.toString(), err)
   }
 
   // can't tell what went wrong, return a generic error

package/src/utils/responses.ts

@@ -119,11 +119,12 @@ export function notImplementedResponse (url: string, body?: SupportedBodyTypes,
   return response
 }
 
-export function notAcceptableResponse (url: string | URL, acceptable: ContentType[], init?: ResponseInit): Response {
+export function notAcceptableResponse (url: string | URL, requested: Array<Pick<ContentType, 'mediaType'>>, acceptable: Array<Pick<ContentType, 'mediaType'>>, init?: ResponseInit): Response {
   const headers = new Headers(init?.headers)
   headers.set('content-type', 'application/json')
 
   const response = new Response(JSON.stringify({
+    requested: requested.map(contentType => contentType.mediaType),
     acceptable: acceptable.map(contentType => contentType.mediaType)
   }), {
     ...(init ?? {}),

package/src/verified-fetch.ts

@@ -12,7 +12,7 @@ import { TarPlugin } from './plugins/plugin-handle-tar.js'
 import { UnixFSPlugin } from './plugins/plugin-handle-unixfs.js'
 import { URLResolver } from './url-resolver.ts'
 import { contentTypeParser } from './utils/content-type-parser.js'
-import { getContentType, getSupportedContentTypes, CONTENT_TYPE_OCTET_STREAM, CONTENT_TYPE_CAR, MEDIA_TYPE_IPNS_RECORD, MEDIA_TYPE_RAW } from './utils/content-types.ts'
+import { getContentType, getSupportedContentTypes, CONTENT_TYPE_OCTET_STREAM, MEDIA_TYPE_IPNS_RECORD, MEDIA_TYPE_RAW, CONTENT_TYPE_IPNS } from './utils/content-types.ts'
 import { errorToObject } from './utils/error-to-object.ts'
 import { errorToResponse } from './utils/error-to-response.ts'
 import { getETag } from './utils/get-e-tag.js'
@@ -165,20 +165,25 @@ export class VerifiedFetch {
       return this.handleFinalResponse(badRequestResponse(resource.toString(), err))
     }
 
+    const requestedMimeTypes = getRequestedMimeTypes(url, headers.get('accept'))
+
     let parsedResult: ResolveURLResult
 
     // if just an IPNS record has been requested, don't try to load the block
     // the record points to or do any recursive IPNS resolving
     if (isIPNSRecordRequest(headers)) {
       if (url.protocol !== 'ipns:') {
-        return notAcceptableResponse(url, [])
+        return notAcceptableResponse(url, requestedMimeTypes, [
+          CONTENT_TYPE_IPNS
+        ])
       }
 
       // @ts-expect-error ipnsRecordPlugin may not be of type IpnsRecordPlugin
       const ipnsRecordPlugin: IpnsRecordPlugin | undefined = this.plugins.find(plugin => plugin.id === 'ipns-record-plugin')
 
       if (ipnsRecordPlugin == null) {
-        return notAcceptableResponse(url, [])
+        // IPNS record was requested but no IPNS Record plugin is configured?!
+        return notAcceptableResponse(url, requestedMimeTypes, [])
       }
 
       return this.handleFinalResponse(await ipnsRecordPlugin.handle({
@@ -198,6 +203,7 @@ export class VerifiedFetch {
         options?.signal?.throwIfAborted()
 
         this.log.error('error parsing resource %s - %e', resource, err)
+        this.log.error('wat name %s', err.name)
         return this.handleFinalResponse(errorToResponse(resource, err))
       }
     }
@@ -207,7 +213,7 @@ export class VerifiedFetch {
       path: parsedResult.url.pathname
     }))
 
-    const accept = this.getAcceptHeader(parsedResult.url, headers.get('accept'), parsedResult.terminalElement.cid)
+    const accept = this.getAcceptHeader(parsedResult.url, requestedMimeTypes, parsedResult.terminalElement.cid)
 
     if (accept instanceof Response) {
       this.log('allowed media types for requested CID did not contain anything the client can understand')
@@ -224,7 +230,8 @@ export class VerifiedFetch {
       options,
       onProgress: options?.onProgress,
       serverTiming,
-      headers
+      headers,
+      requestedMimeTypes
     }
 
     this.log.trace('finding handler for cid code "0x%s" and response content types %s', parsedResult.terminalElement.cid.code.toString(16), accept.map(header => header.contentType.mediaType).join(', '))
@@ -247,85 +254,9 @@ export class VerifiedFetch {
    * Returns a prioritized list of acceptable content types for the response
    * based on the CID and a passed `Accept` header
    */
-  private getAcceptHeader (url: URL, accept?: string | null, cid?: CID): AcceptHeader[] | Response {
-    if (accept == null || accept === '') {
-      // if the user has specified CAR options but no Accept header, default to
-      // the car content type with the passed options
-      try {
-        const dagScope = url.searchParams.get('dag-scope')
-        const entityBytes = url.searchParams.get('entity-bytes')
-        const dups = url.searchParams.get('car-dups')
-        const order = url.searchParams.get('car-order')
-        const version = url.searchParams.get('car-version')
-
-        if (dagScope != null ||
-          entityBytes != null ||
-          dups != null ||
-          entityBytes != null ||
-          order != null
-        ) {
-          const options: Record<string, string> = {}
-
-          if (dups != null) {
-            options.dups = dups
-          }
-
-          if (order != null) {
-            options.order = order
-          }
-
-          if (version != null) {
-            options.version = version
-          }
-
-          return [{
-            contentType: CONTENT_TYPE_CAR,
-            options
-          }]
-        }
-      } catch {}
-
-      // yolo content-type
-      accept = '*/*'
-      // return []
-    }
-
-    // allow user to choose specific output type
-    const acceptable: AcceptHeader[] = []
-
-    const requestedMimeTypes = accept
-      .split(',')
-      .map(s => {
-        const parts = s.trim().split(';')
-
-        const options: Record<string, string> = {
-          q: '1'
-        }
-
-        for (let i = 1; i < parts.length; i++) {
-          const [key, value] = parts[i].split('=').map(s => s.trim())
-
-          options[key] = value
-        }
-
-        return {
-          mediaType: `${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
-      })
-
+  private getAcceptHeader (url: URL, requestedMimeTypes: RequestedMimeType[], cid?: CID): AcceptHeader[] | Response {
     const supportedContentTypes = getSupportedContentTypes(url.protocol, cid)
+    const acceptable: AcceptHeader[] = []
 
     for (const headerFormat of requestedMimeTypes) {
       const [headerFormatType, headerFormatSubType] = headerFormat.mediaType.split('/')
@@ -367,7 +298,7 @@ export class VerifiedFetch {
       this.log('requested %o', requestedMimeTypes.map(({ mediaType }) => mediaType))
       this.log('supported %o', supportedContentTypes.map(({ mediaType }) => mediaType))
 
-      return notAcceptableResponse(url, supportedContentTypes)
+      return notAcceptableResponse(url, requestedMimeTypes, supportedContentTypes)
     }
 
     return acceptable
@@ -526,3 +457,47 @@ export class VerifiedFetch {
     await this.helia.stop()
   }
 }
+
+export interface RequestedMimeType {
+  mediaType: string
+  options: Record<string, string>
+}
+
+function getRequestedMimeTypes (url: URL, accept?: string | null): RequestedMimeType[] {
+  if (accept == null || accept === '') {
+    // yolo content-type
+    accept = '*/*'
+  }
+
+  return accept
+    .split(',')
+    .map(s => {
+      const parts = s.trim().split(';')
+
+      const options: Record<string, string> = {
+        q: '1'
+      }
+
+      for (let i = 1; i < parts.length; i++) {
+        const [key, value] = parts[i].split('=').map(s => s.trim())
+
+        options[key] = value
+      }
+
+      return {
+        mediaType: `${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
+    })
+}