@helia/verified-fetch 2.6.5 → 2.6.7

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

@@ -3,7 +3,7 @@ import toBrowserReadableStream from 'it-to-browser-readablestream'
 import { code as rawCode } from 'multiformats/codecs/raw'
 import { getETag } from '../utils/get-e-tag.js'
 import { tarStream } from '../utils/get-tar-stream.js'
-import { notAcceptableResponse, okResponse } from '../utils/responses.js'
+import { notAcceptableResponse, okRangeResponse } from '../utils/responses.js'
 import { BasePlugin } from './plugin-base.js'
 import type { PluginContext } from './types.js'
 
@@ -13,12 +13,15 @@ import type { PluginContext } from './types.js'
  */
 export class TarPlugin extends BasePlugin {
   readonly codes = []
-  canHandle ({ cid, accept, query }: PluginContext): boolean {
+  canHandle ({ cid, accept, query, byteRangeContext }: PluginContext): boolean {
     this.log('checking if we can handle %c with accept %s', cid, accept)
+    if (byteRangeContext == null) {
+      return false
+    }
     return accept === 'application/x-tar' || query.format === 'tar'
   }
 
-  async handle (context: PluginContext): Promise<Response> {
+  async handle (context: PluginContext & Required<Pick<PluginContext, 'byteRangeContext'>>): Promise<Response> {
     const { cid, path, resource, options, pathDetails } = context
     const { getBlockstore } = this.pluginOptions
 
@@ -34,7 +37,9 @@ export class TarPlugin extends BasePlugin {
     const blockstore = getBlockstore(terminusElement, resource, options?.session, options)
     const stream = toBrowserReadableStream<Uint8Array>(tarStream(`/ipfs/${cid}/${path}`, blockstore, options))
 
-    const response = okResponse(resource, stream)
+    context.byteRangeContext.setBody(stream)
+
+    const response = okRangeResponse(resource, context.byteRangeContext.getBody(), { byteRangeContext: context.byteRangeContext, log: this.log })
     response.headers.set('content-type', 'application/x-tar')
 
     response.headers.set('etag', getETag({ cid: terminusElement, reqFormat: context.reqFormat, weak: true }))

package/src/plugins/types.ts

@@ -1,6 +1,7 @@
 import type { PluginError } from './errors.js'
 import type { VerifiedFetchInit } from '../index.js'
 import type { ContentTypeParser, RequestFormatShorthand } from '../types.js'
+import type { ByteRangeContext } from '../utils/byte-range-context.js'
 import type { ParsedUrlStringResults } from '../utils/parse-url-string.js'
 import type { PathWalkerResponse } from '../utils/walk-path.js'
 import type { AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
@@ -12,7 +13,7 @@ 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.
+ * - 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 {
@@ -47,6 +48,14 @@ export interface PluginContext extends ParsedUrlStringResults {
   errors?: PluginError[]
   reqFormat?: RequestFormatShorthand
   pathDetails?: PathWalkerResponse
+  query: ParsedUrlStringResults['query']
+  /**
+   * 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
   [key: string]: unknown
 }
 

package/src/utils/byte-range-context.ts

@@ -107,6 +107,7 @@ export class ByteRangeContext {
       this.log.trace('returning body with byteStart=%o, byteEnd=%o, byteSize=%o', byteStart, byteEnd, byteSize)
       if (body instanceof ReadableStream) {
         // stream should already be spliced by `unixfs.cat`
+        // TODO: if the content is not unixfs and unixfs.cat was not called, we need to slice the body here.
         return body
       }
       return this.getSlicedBody(body)

package/src/utils/walk-path.ts

@@ -1,5 +1,6 @@
 import { DoesNotExistError } from '@helia/unixfs/errors'
 import { type Logger } from '@libp2p/interface'
+import { abortableSource } from 'abortable-iterator'
 import { type Blockstore } from 'interface-blockstore'
 import { walkPath as exporterWalk, type ExporterOptions, type ReadableStorage, type ObjectNode, type UnixFSEntry } from 'ipfs-unixfs-exporter'
 import { badGatewayResponse, notFoundResponse } from './responses.js'
@@ -22,7 +23,9 @@ async function walkPath (blockstore: ReadableStorage, path: string, options?: Pa
   const ipfsRoots: CID[] = []
   let terminalElement: UnixFSEntry | undefined
 
-  for await (const entry of exporterWalk(path, blockstore, options)) {
+  const iterator = options?.signal != null ? abortableSource(exporterWalk(path, blockstore, options), options.signal) : exporterWalk(path, blockstore, options)
+
+  for await (const entry of iterator) {
     ipfsRoots.push(entry.cid)
     terminalElement = entry
   }

package/src/verified-fetch.ts

@@ -4,6 +4,7 @@ import { prefixLogger } from '@libp2p/logger'
 import { LRUCache } from 'lru-cache'
 import { type CID } from 'multiformats/cid'
 import { CustomProgressEvent } from 'progress-events'
+import { ByteRangeContextPlugin } from './plugins/plugin-handle-byte-range-context.js'
 import { CarPlugin } from './plugins/plugin-handle-car.js'
 import { DagCborPlugin } from './plugins/plugin-handle-dag-cbor.js'
 import { DagPbPlugin } from './plugins/plugin-handle-dag-pb.js'
@@ -90,6 +91,7 @@ export class VerifiedFetch {
 
     const defaultPlugins = [
       new DagWalkPlugin(pluginOptions),
+      new ByteRangeContextPlugin(pluginOptions),
       new IpnsRecordPlugin(pluginOptions),
       new CarPlugin(pluginOptions),
       new RawPlugin(pluginOptions),
@@ -151,13 +153,24 @@ export class VerifiedFetch {
    * Server-Timing header to the response if it has been collected. It should be used for any final processing of the
    * response before it is returned to the user.
    */
-  private handleFinalResponse (response: Response, { query, cid, reqFormat, ttl, protocol, ipfsPath, pathDetails }: Partial<PluginContext> = {}): Response {
+  private handleFinalResponse (response: Response, { query, cid, reqFormat, ttl, protocol, ipfsPath, pathDetails, byteRangeContext }: Partial<PluginContext> = {}): Response {
     if (this.serverTimingHeaders.length > 0) {
       const headerString = this.serverTimingHeaders.join(', ')
       response.headers.set('Server-Timing', headerString)
       this.serverTimingHeaders = []
     }
 
+    // if there are multiple ranges, we should omit the content-length header. see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Transfer-Encoding
+    if (response.headers.get('Transfer-Encoding') !== 'chunked') {
+      if (byteRangeContext != null) {
+        const contentLength = byteRangeContext.length
+        if (contentLength != null) {
+          this.log.trace('Setting Content-Length from byteRangeContext: %d', contentLength)
+          response.headers.set('Content-Length', contentLength.toString())
+        }
+      }
+    }
+
     // set Content-Disposition header
     let contentDisposition: string | undefined