refactor: Break down middleware to prepare for UCAN Egress (#121)

Should be a pure refactoring, but moves around a lot of code, and adds
some tests.

Author: Peeja

src/bindings.d.ts

@@ -1,10 +1,13 @@
 import { CID } from '@web3-storage/gateway-lib/handlers'
-import { Environment as RateLimiterEnvironment } from './handlers/rate-limiter.types.ts'
-import { Environment as CarBlockEnvironment } from './handlers/car-block.types.ts'
+import { Environment as RateLimiterEnvironment } from './middleware/withRateLimit.types.ts'
+import { Environment as CarBlockEnvironment } from './middleware/withCarBlockHandler.types.ts'
+import { Environment as ContentClaimsDagulaEnvironment } from './middleware/withCarBlockHandler.types.ts'
 
-export interface Environment extends CarBlockEnvironment, RateLimiterEnvironment {
+export interface Environment
+  extends CarBlockEnvironment,
+    RateLimiterEnvironment,
+    ContentClaimsDagulaEnvironment {
   VERSION: string
-  CONTENT_CLAIMS_SERVICE_URL?: string
 }
 
 export interface AccountingService {
@@ -15,4 +18,3 @@ export interface AccountingService {
 export interface Accounting {
   create: ({ serviceURL }: { serviceURL?: string }) => AccountingService
 }
-

src/index.js

@@ -18,35 +18,53 @@ import {
 import {
   withContentClaimsDagula,
   withVersionHeader,
-  withCarBlockHandler
-} from './middleware.js'
-import { withRateLimit } from './handlers/rate-limiter.js'
+  withAuthToken,
+  withCarBlockHandler,
+  withRateLimit,
+  withNotFound,
+  withLocator
+} from './middleware/index.js'
 
 /**
- * @typedef {import('./bindings.js').Environment} Environment
- * @typedef {import('@web3-storage/gateway-lib').IpfsUrlContext} IpfsUrlContext
- * @typedef {import('@web3-storage/gateway-lib').BlockContext} BlockContext
- * @typedef {import('@web3-storage/gateway-lib').DagContext} DagContext
- * @typedef {import('@web3-storage/gateway-lib').UnixfsContext} UnixfsContext
+ * @import {
+ *   Handler,
+ *   Middleware,
+ *   Context,
+ *   IpfsUrlContext,
+ *   BlockContext,
+ *   DagContext,
+ *   UnixfsContext
+ * } from '@web3-storage/gateway-lib'
+ * @import { Environment } from './bindings.js'
  */
 
 export default {
-  /** @type {import('@web3-storage/gateway-lib').Handler<import('@web3-storage/gateway-lib').Context, import('./bindings.js').Environment>} */
+  /** @type {Handler<Context, Environment>} */
   fetch (request, env, ctx) {
     console.log(request.method, request.url)
     const middleware = composeMiddleware(
+      // Prepare the Context
       withCdnCache,
       withContext,
       withCorsHeaders,
       withVersionHeader,
       withErrorHandler,
       withParsedIpfsUrl,
-      withRateLimit,
       createWithHttpMethod('GET', 'HEAD'),
+      withAuthToken,
+      withLocator,
+
+      // Rate-limit requests
+      withRateLimit,
+
+      // Fetch data
       withCarBlockHandler,
+      withNotFound,
       withContentClaimsDagula,
       withFormatRawHandler,
       withFormatCarHandler,
+
+      // Prepare the Response
       withContentDispositionHeader,
       withFixedLengthStream
     )
@@ -55,29 +73,35 @@ export default {
 }
 
 /**
- * @type {import('@web3-storage/gateway-lib').Middleware<BlockContext & UnixfsContext & IpfsUrlContext, BlockContext & UnixfsContext & IpfsUrlContext, Environment>}
+ * @type {Middleware<BlockContext & UnixfsContext & IpfsUrlContext, BlockContext & UnixfsContext & IpfsUrlContext, Environment>}
  */
 export function withFormatRawHandler (handler) {
   return async (request, env, ctx) => {
     const { headers } = request
     const { searchParams } = ctx
     if (!searchParams) throw new Error('missing URL search params')
-    if (searchParams.get('format') === 'raw' || headers.get('Accept')?.includes('application/vnd.ipld.raw')) {
+    if (
+      searchParams.get('format') === 'raw' ||
+      headers.get('Accept')?.includes('application/vnd.ipld.raw')
+    ) {
       return await handleBlock(request, env, ctx)
     }
     return handler(request, env, ctx) // pass to other handlers
   }
 }
 
 /**
- * @type {import('@web3-storage/gateway-lib').Middleware<DagContext & IpfsUrlContext, DagContext & IpfsUrlContext, Environment>}
+ * @type {Middleware<DagContext & IpfsUrlContext, DagContext & IpfsUrlContext, Environment>}
  */
 export function withFormatCarHandler (handler) {
   return async (request, env, ctx) => {
     const { headers } = request
     const { searchParams } = ctx
     if (!searchParams) throw new Error('missing URL search params')
-    if (searchParams.get('format') === 'car' || headers.get('Accept')?.includes('application/vnd.ipld.car')) {
+    if (
+      searchParams.get('format') === 'car' ||
+      headers.get('Accept')?.includes('application/vnd.ipld.car')
+    ) {
       return await handleCar(request, env, ctx)
     }
     return handler(request, env, ctx) // pass to other handlers

src/middleware.js

@@ -0,0 +1,7 @@
+export { withAuthToken } from './withAuthToken.js'
+export { withCarBlockHandler } from './withCarBlockHandler.js'
+export { withContentClaimsDagula } from './withContentClaimsDagula.js'
+export { withRateLimit } from './withRateLimit.js'
+export { withVersionHeader } from './withVersionHeader.js'
+export { withNotFound } from './withNotFound.js'
+export { withLocator } from './withLocator.js'

src/middleware/index.js

@@ -0,0 +1,49 @@
+/**
+ * @import {
+ *   Middleware,
+ *   Context as MiddlewareContext,
+ *  } from '@web3-storage/gateway-lib'
+ * @import {
+ *   Environment,
+ *   InContext,
+ *   OutContext,
+ * } from './withAuthToken.types.js'
+ */
+
+/**
+ * Finds an authentication token in the URL query parameters or the
+ * `Authorization` header and adds it to the context as `authToken`.
+ *
+ * @type {Middleware<OutContext<MiddlewareContext>, InContext, Environment>}
+ */
+export function withAuthToken (handler) {
+  return async (req, env, ctx) => {
+    return handler(req, env, {
+      ...ctx,
+      authToken:
+        getAuthTokenFromQueryParams(req) || getAuthTokenFromHeaders(req)
+    })
+  }
+}
+
+/**
+ * @param {Request} request
+ * @returns {string | null}
+ */
+function getAuthTokenFromQueryParams (request) {
+  return new URL(request.url).searchParams.get('authToken')
+}
+
+const BEARER_PREFIX = 'Bearer '
+
+/**
+ * @param {Request} request
+ * @returns {string | null}
+ */
+function getAuthTokenFromHeaders (request) {
+  const authHeader = request.headers.get('Authorization')
+  if (authHeader && authHeader.startsWith(BEARER_PREFIX)) {
+    return authHeader.substring(BEARER_PREFIX.length)
+  }
+  return null
+}

src/middleware/withAuthToken.js

@@ -0,0 +1,12 @@
+import {
+  Environment as MiddlewareEnvironment,
+  Context as MiddlewareContext,
+} from '@web3-storage/gateway-lib'
+
+export interface Environment extends MiddlewareEnvironment {}
+
+export interface InContext extends MiddlewareContext {}
+
+export type OutContext<IncomingContext> = IncomingContext & {
+  authToken: string | null
+}

src/middleware/withAuthToken.types.ts

@@ -1,19 +1,60 @@
 /* eslint-env browser */
 /* global FixedLengthStream */
+
+import { CAR_CODE } from '../constants.js'
 import { HttpError } from '@web3-storage/gateway-lib/util'
 // @ts-expect-error no types
 import httpRangeParse from 'http-range-parse'
 import { base58btc } from 'multiformats/bases/base58'
-import { CAR_CODE } from '../constants.js'
 
 /**
- * @import { Context, IpfsUrlContext as CarBlockHandlerContext, Handler } from '@web3-storage/gateway-lib'
  * @import { R2Bucket, KVNamespace, RateLimit } from '@cloudflare/workers-types'
- * @import { Environment } from './car-block.types.js'
+ * @import {
+ *   IpfsUrlContext,
+ *   Middleware,
+ *   Context,
+ *   IpfsUrlContext as CarBlockHandlerContext,
+ *   Handler
+ * } from '@web3-storage/gateway-lib'
+ * @import { Environment } from './withCarBlockHandler.types.js'
  */
 
 /** @typedef {{ offset: number, length?: number } | { offset?: number, length: number } | { suffix: number }} Range */
 
+/**
+ * Middleware that will serve CAR files if a CAR codec is found in the path
+ * CID. If the CID is not a CAR CID it delegates to the next middleware.
+ *
+ * @type {Middleware<IpfsUrlContext, IpfsUrlContext, Environment>}
+ */
+
+export function withCarBlockHandler (handler) {
+  return async (request, env, ctx) => {
+    const { dataCid, searchParams } = ctx
+    if (!dataCid) throw new Error('missing data CID')
+
+    // if not CAR codec, or if trusted gateway format has been requested...
+    const formatParam = searchParams.get('format')
+    const acceptHeader = request.headers.get('Accept')
+    if (dataCid.code !== CAR_CODE ||
+      formatParam === 'car' ||
+      acceptHeader === 'application/vnd.ipld.car' ||
+      formatParam === 'raw' ||
+      acceptHeader === 'application/vnd.ipld.raw') {
+      return handler(request, env, ctx) // pass to other handlers
+    }
+
+    try {
+      return await handleCarBlock(request, env, ctx)
+    } catch (err) {
+      if (err instanceof HttpError && err.status === 404) {
+        return handler(request, env, ctx) // use content claims to resolve
+      }
+      throw err
+    }
+  }
+}
+
 /**
  * Handler that serves CAR files directly from R2.
  *