@atproto-labs/fetch 0.0.1

package/dist/util.d.ts

@@ -0,0 +1,24 @@
+export type JsonScalar = string | number | boolean | null;
+export type Json = JsonScalar | Json[] | {
+    [key: string]: undefined | Json;
+};
+export type JsonObject = {
+    [key: string]: Json;
+};
+export type JsonArray = Json[];
+declare global {
+    interface JSON {
+        parse(text: string, reviver?: (key: any, value: any) => any): Json;
+    }
+}
+export declare function isIp(hostname: string): boolean;
+export declare const ifObject: <V>(v?: V) => (V extends symbol | Function | JsonScalar | JsonArray ? never : V extends Json ? V : {
+    [key: string]: unknown;
+}) | undefined;
+export declare const ifArray: <V>(v?: V) => (V & any[]) | undefined;
+export declare const ifScalar: <V>(v?: V) => (V & string) | (V & number) | (V & boolean) | (V & null) | (V extends JsonScalar ? never : undefined);
+export declare const ifBoolean: <V>(v?: V) => (V & boolean) | undefined;
+export declare const ifString: <V>(v?: V) => (V & string) | undefined;
+export declare const ifNumber: <V>(v?: V) => (V & number) | undefined;
+export declare const ifNull: <V>(v?: V) => V | undefined;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;AACzD,MAAM,MAAM,IAAI,GAAG,UAAU,GAAG,IAAI,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAA;CAAE,CAAA;AAC5E,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAA;AAChD,MAAM,MAAM,SAAS,GAAG,IAAI,EAAE,CAAA;AAE9B,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,IAAI;QACZ,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI,CAAA;KACnE;CACF;AAED,wBAAgB,IAAI,CAAC,QAAQ,EAAE,MAAM,WAQpC;AAKD,eAAO,MAAM,QAAQ,UAAW,CAAC;;cAehC,CAAA;AAED,eAAO,MAAM,OAAO,UAAW,CAAC,4BAAuC,CAAA;AACvE,eAAO,MAAM,QAAQ,UAAW,CAAC,0GAUhC,CAAA;AACD,eAAO,MAAM,SAAS,UAAW,CAAC,8BAA6C,CAAA;AAC/E,eAAO,MAAM,QAAQ,UAAW,CAAC,6BAA4C,CAAA;AAC7E,eAAO,MAAM,QAAQ,UAAW,CAAC,6BAA4C,CAAA;AAC7E,eAAO,MAAM,MAAM,UAAW,CAAC,kBAAiC,CAAA"}

package/dist/util.js

@@ -0,0 +1,51 @@
+"use strict";
+// TODO: Move to a shared package ?
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ifNull = exports.ifNumber = exports.ifString = exports.ifBoolean = exports.ifScalar = exports.ifArray = exports.ifObject = exports.isIp = void 0;
+function isIp(hostname) {
+    // IPv4
+    if (hostname.match(/^\d+\.\d+\.\d+\.\d+$/))
+        return true;
+    // IPv6
+    if (hostname.startsWith('[') && hostname.endsWith(']'))
+        return true;
+    return false;
+}
+exports.isIp = isIp;
+// TODO: Move to a shared package ?
+const plainObjectProto = Object.prototype;
+const ifObject = (v) => {
+    if (typeof v === 'object' && v != null && !Array.isArray(v)) {
+        const proto = Object.getPrototypeOf(v);
+        if (proto === null || proto === plainObjectProto) {
+            // eslint-disable-next-line @typescript-eslint/ban-types
+            return v;
+        }
+    }
+    return undefined;
+};
+exports.ifObject = ifObject;
+const ifArray = (v) => (Array.isArray(v) ? v : undefined);
+exports.ifArray = ifArray;
+const ifScalar = (v) => {
+    switch (typeof v) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+            return v;
+        default:
+            if (v === null)
+                return null;
+            return undefined;
+    }
+};
+exports.ifScalar = ifScalar;
+const ifBoolean = (v) => (typeof v === 'boolean' ? v : undefined);
+exports.ifBoolean = ifBoolean;
+const ifString = (v) => (typeof v === 'string' ? v : undefined);
+exports.ifString = ifString;
+const ifNumber = (v) => (typeof v === 'number' ? v : undefined);
+exports.ifNumber = ifNumber;
+const ifNull = (v) => (v === null ? v : undefined);
+exports.ifNull = ifNull;
+//# sourceMappingURL=util.js.map

package/dist/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";AAAA,mCAAmC;;;AAanC,SAAgB,IAAI,CAAC,QAAgB;IACnC,OAAO;IACP,IAAI,QAAQ,CAAC,KAAK,CAAC,sBAAsB,CAAC;QAAE,OAAO,IAAI,CAAA;IAEvD,OAAO;IACP,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAA;IAEnE,OAAO,KAAK,CAAA;AACd,CAAC;AARD,oBAQC;AAED,mCAAmC;AAEnC,MAAM,gBAAgB,GAAG,MAAM,CAAC,SAAS,CAAA;AAClC,MAAM,QAAQ,GAAG,CAAI,CAAK,EAAE,EAAE;IACnC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5D,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAA;QACtC,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,gBAAgB,EAAE,CAAC;YACjD,wDAAwD;YACxD,OAAO,CAKyB,CAAA;QAClC,CAAC;IACH,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC,CAAA;AAfY,QAAA,QAAQ,YAepB;AAEM,MAAM,OAAO,GAAG,CAAI,CAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;AAA1D,QAAA,OAAO,WAAmD;AAChE,MAAM,QAAQ,GAAG,CAAI,CAAK,EAAE,EAAE;IACnC,QAAQ,OAAO,CAAC,EAAE,CAAC;QACjB,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS;YACZ,OAAO,CAAC,CAAA;QACV;YACE,IAAI,CAAC,KAAK,IAAI;gBAAE,OAAO,IAAgB,CAAA;YACvC,OAAO,SAAqD,CAAA;IAChE,CAAC;AACH,CAAC,CAAA;AAVY,QAAA,QAAQ,YAUpB;AACM,MAAM,SAAS,GAAG,CAAI,CAAK,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;AAAlE,QAAA,SAAS,aAAyD;AACxE,MAAM,QAAQ,GAAG,CAAI,CAAK,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;AAAhE,QAAA,QAAQ,YAAwD;AACtE,MAAM,QAAQ,GAAG,CAAI,CAAK,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;AAAhE,QAAA,QAAQ,YAAwD;AACtE,MAAM,MAAM,GAAG,CAAI,CAAK,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;AAAnD,QAAA,MAAM,UAA6C"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@atproto-labs/fetch",
+  "version": "0.0.1",
+  "license": "MIT",
+  "description": "Isomorphic wrapper utilities for fetch API",
+  "keywords": [
+    "atproto",
+    "fetch"
+  ],
+  "homepage": "https://atproto.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluesky-social/atproto",
+    "directory": "packages/fetch"
+  },
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.6.2",
+    "zod": "^3.22.4",
+    "@atproto-labs/transformer": "0.0.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3"
+  },
+  "scripts": {
+    "build": "tsc --build tsconfig.json"
+  }
+}

package/src/fetch-error.ts

@@ -0,0 +1,77 @@
+import { Transformer } from '@atproto-labs/transformer'
+
+export type FetchErrorOptions = {
+  cause?: unknown
+  request?: Request
+  response?: Response
+}
+
+export class FetchError extends Error {
+  public readonly request?: Request
+  public readonly response?: Response
+
+  constructor(
+    public readonly statusCode: number,
+    message?: string,
+    { cause, request, response }: FetchErrorOptions = {},
+  ) {
+    super(message, { cause })
+    this.request = request
+    this.response = response
+  }
+
+  static async from(err: unknown) {
+    const cause = extractCause(err)
+    return new FetchError(...extractInfo(cause), { cause })
+  }
+}
+
+export const fetchFailureHandler: Transformer<unknown, never> = async (
+  err: unknown,
+) => {
+  throw await FetchError.from(err)
+}
+
+function extractCause(err: unknown): unknown {
+  // Unwrap the Network error from undici (i.e. Node's internal fetch() implementation)
+  // https://github.com/nodejs/undici/blob/3274c975947ce11a08508743df026f73598bfead/lib/web/fetch/index.js#L223-L228
+  if (
+    err instanceof TypeError &&
+    err.message === 'fetch failed' &&
+    err.cause instanceof Error
+  ) {
+    return err.cause
+  }
+
+  return err
+}
+
+export function extractInfo(
+  err: unknown,
+): [statusCode: number, message: string] {
+  if (typeof err === 'string' && err.length > 0) {
+    return [502, err]
+  }
+
+  if (!(err instanceof Error)) {
+    return [502, 'Unable to fetch']
+  }
+
+  if ('code' in err && typeof err.code === 'string') {
+    switch (true) {
+      case err.code === 'ENOTFOUND':
+        return [404, 'Invalid hostname']
+      case err.code === 'ECONNREFUSED':
+        return [502, 'Connection refused']
+      case err.code === 'DEPTH_ZERO_SELF_SIGNED_CERT':
+        return [502, 'Self-signed certificate']
+      case err.code.startsWith('ERR_TLS'):
+        return [502, 'TLS error']
+      case err.code.startsWith('ECONN'):
+        return [502, 'Connection error']
+    }
+  }
+
+  // Let's assume that other errors are "bad gateway" errors
+  return [502, err.message]
+}

package/src/fetch-request.ts

@@ -0,0 +1,86 @@
+import { Transformer } from '@atproto-labs/transformer'
+
+import { FetchError } from './fetch-error.js'
+import { isIp } from './util.js'
+
+export type RequestTranformer = Transformer<Request>
+
+export function protocolCheckRequestTransform(
+  protocols: Iterable<string>,
+): RequestTranformer {
+  const allowedProtocols = new Set<string>(protocols)
+
+  return async (request) => {
+    const { protocol } = new URL(request.url)
+
+    if (!allowedProtocols.has(protocol)) {
+      throw new FetchError(400, `${protocol} is not allowed`, { request })
+    }
+
+    return request
+  }
+}
+
+export function requireHostHeaderTranform(): RequestTranformer {
+  return async (request) => {
+    // Note that fetch() will automatically add the Host header from the URL and
+    // discard any Host header manually set in the request.
+
+    const { protocol, hostname } = new URL(request.url)
+
+    // "Host" header only makes sense in the context of an HTTP request
+    if (protocol !== 'http:' && protocol !== 'https') {
+      throw new FetchError(400, `Forbidden protocol ${protocol}`, { request })
+    }
+
+    if (!hostname || isIp(hostname)) {
+      throw new FetchError(400, 'Invalid hostname', { request })
+    }
+
+    return request
+  }
+}
+
+export const DEFAULT_FORBIDDEN_DOMAIN_NAMES = [
+  'example.com',
+  '*.example.com',
+  'example.org',
+  '*.example.org',
+  'example.net',
+  '*.example.net',
+  'googleusercontent.com',
+  '*.googleusercontent.com',
+]
+
+export function forbiddenDomainNameRequestTransform(
+  denyList: Iterable<string> = DEFAULT_FORBIDDEN_DOMAIN_NAMES,
+): RequestTranformer {
+  const denySet = new Set<string>(denyList)
+
+  // Optimization: if no forbidden domain names are provided, we can skip the
+  // check entirely.
+  if (denySet.size === 0) {
+    return async (request) => request
+  }
+
+  return async (request) => {
+    const { hostname } = new URL(request.url)
+
+    // Full domain name check
+    if (denySet.has(hostname)) {
+      throw new FetchError(403, 'Forbidden hostname', { request })
+    }
+
+    // Sub domain name check
+    let curDot = hostname.indexOf('.')
+    while (curDot !== -1) {
+      const subdomain = hostname.slice(curDot + 1)
+      if (denySet.has(`*.${subdomain}`)) {
+        throw new FetchError(403, 'Forbidden hostname', { request })
+      }
+      curDot = hostname.indexOf('.', curDot + 1)
+    }
+
+    return request
+  }
+}

package/src/fetch-response.ts

@@ -0,0 +1,212 @@
+import { Transformer, compose } from '@atproto-labs/transformer'
+import { z } from 'zod'
+
+import { FetchError, FetchErrorOptions } from './fetch-error.js'
+import { Json, ifObject, ifString } from './util.js'
+import { TransformedResponse } from './transformed-response.js'
+
+export type ResponseTranformer = Transformer<Response>
+export type ResponseMessageGetter = Transformer<Response, string | undefined>
+
+const extractResponseMessage: ResponseMessageGetter = async (response) => {
+  if (!response.body) return undefined
+
+  const contentType = response.headers.get('content-type')
+  if (!contentType) return undefined
+
+  const mimeType = contentType.split(';')[0].trim()
+  if (!mimeType) return undefined
+
+  try {
+    if (mimeType === 'text/plain') {
+      return await response.text()
+    } else if (/^application\/(?:[^+]+\+)?json$/i.test(mimeType)) {
+      const json = await response.json()
+
+      if (typeof json === 'string') return json
+
+      const errorDescription = ifString(ifObject(json)?.['error_description'])
+      if (errorDescription) return errorDescription
+
+      const error = ifString(ifObject(json)?.['error'])
+      if (error) return error
+
+      const message = ifString(ifObject(json)?.['message'])
+      if (message) return message
+    }
+  } catch {
+    // noop
+  }
+
+  return undefined
+}
+
+export class FetchResponseError extends FetchError {
+  constructor(
+    response: Response,
+    statusCode: number = response.status,
+    message: string = response.statusText,
+    options?: Omit<FetchErrorOptions, 'response'>,
+  ) {
+    super(statusCode, message, { response, ...options })
+  }
+
+  static async from(
+    response: Response,
+    statusCode = response.status,
+    customMessage: string | ResponseMessageGetter = extractResponseMessage,
+    options?: Omit<FetchErrorOptions, 'response'>,
+  ) {
+    const message =
+      typeof customMessage === 'string'
+        ? customMessage
+        : typeof customMessage === 'function'
+          ? await customMessage(response)
+          : undefined
+
+    // Make sure the body gets consumed as, in some environments (Node 👀), the
+    // response will not automatically be GC'd.
+    if (!response.bodyUsed) await response.body?.cancel()
+
+    return new FetchResponseError(response, statusCode, message, options)
+  }
+}
+
+export function fetchOkProcessor(
+  customMessage?: string | ResponseMessageGetter,
+): ResponseTranformer {
+  return async (response) => {
+    if (response.ok) return response
+    throw await FetchResponseError.from(response, undefined, customMessage)
+  }
+}
+
+export function fetchMaxSizeProcessor(maxBytes: number): ResponseTranformer {
+  if (maxBytes === Infinity) return (response) => response
+  if (!Number.isFinite(maxBytes) || maxBytes < 0) {
+    throw new TypeError('maxBytes must be a non-negative number')
+  }
+  return async (response) => fetchResponseMaxSize(response, maxBytes)
+}
+
+export async function fetchResponseMaxSize(
+  response: Response,
+  maxBytes: number,
+): Promise<Response> {
+  if (maxBytes === Infinity) return response
+  if (!response.body) return response
+
+  const contentLength = response.headers.get('content-length')
+  if (contentLength) {
+    const length = Number(contentLength)
+    if (!(length < maxBytes)) {
+      const err = new FetchResponseError(response, 502, 'Response too large')
+      await response.body.cancel(err)
+      throw err
+    }
+  }
+
+  let bytesRead = 0
+
+  const transform = new TransformStream<Uint8Array, Uint8Array>({
+    transform: (
+      chunk: Uint8Array,
+      ctrl: TransformStreamDefaultController<Uint8Array>,
+    ) => {
+      if ((bytesRead += chunk.length) <= maxBytes) {
+        ctrl.enqueue(chunk)
+      } else {
+        ctrl.error(new FetchResponseError(response, 502, 'Response too large'))
+      }
+    },
+  })
+
+  return new TransformedResponse(response, transform)
+}
+
+export type ContentTypeCheckFn = (contentType: string) => boolean
+export type ContentTypeCheck = string | RegExp | ContentTypeCheckFn
+
+export function fetchTypeProcessor(
+  expectedType: ContentTypeCheck,
+  contentTypeRequired = true,
+): ResponseTranformer {
+  const isExpected: ContentTypeCheckFn =
+    typeof expectedType === 'string'
+      ? (ct) => ct === expectedType
+      : expectedType instanceof RegExp
+        ? (ct) => expectedType.test(ct)
+        : expectedType
+
+  return async (response) => {
+    const contentType = response.headers
+      .get('content-type')
+      ?.split(';')[0]!
+      .trim()
+
+    if (contentType) {
+      if (!isExpected(contentType)) {
+        throw await FetchResponseError.from(
+          response,
+          502,
+          `Unexpected response Content-Type (${contentType})`,
+        )
+      }
+    } else if (contentTypeRequired) {
+      throw await FetchResponseError.from(
+        response,
+        502,
+        'Missing response Content-Type header',
+      )
+    }
+
+    return response
+  }
+}
+
+export type ParsedJsonResponse<T = Json> = {
+  response: Response
+  json: T
+}
+
+export async function jsonTranformer<T = Json>(
+  response: Response,
+): Promise<ParsedJsonResponse<T>> {
+  if (response.body === null) {
+    throw new FetchResponseError(response, 502, 'No response body')
+  }
+
+  if (response.bodyUsed) {
+    throw new FetchResponseError(response, 500, 'Response body already used')
+  }
+
+  try {
+    const json = (await response.json()) as T
+    return { response, json }
+  } catch (cause) {
+    throw new FetchResponseError(
+      response,
+      502,
+      'Unable to parse response as JSON',
+      { cause },
+    )
+  }
+}
+
+export function fetchJsonProcessor<T = Json>(
+  contentType: ContentTypeCheck = /^application\/(?:[^+]+\+)?json$/,
+  contentTypeRequired = true,
+): Transformer<Response, ParsedJsonResponse<T>> {
+  return compose(
+    fetchTypeProcessor(contentType, contentTypeRequired),
+    jsonTranformer<T>,
+  )
+}
+
+export function fetchJsonZodProcessor<S extends z.ZodTypeAny>(
+  schema: S,
+  params?: Partial<z.ParseParams>,
+): Transformer<ParsedJsonResponse, z.infer<S>> {
+  return async (jsonResponse: ParsedJsonResponse): Promise<z.infer<S>> =>
+    schema.parseAsync(jsonResponse.json, params)
+}

package/src/fetch-wrap.ts

@@ -0,0 +1,101 @@
+import { Fetch } from './fetch.js'
+import { TransformedResponse } from './transformed-response.js'
+
+export const loggedFetchWrap = ({
+  fetch = globalThis.fetch as Fetch,
+} = {}): Fetch => {
+  return async function (request) {
+    return fetchLog.call(this, request, fetch)
+  }
+}
+
+async function fetchLog(
+  this: ThisParameterType<Fetch>,
+  request: Request,
+  fetch: Fetch = globalThis.fetch,
+) {
+  console.info(
+    `> ${request.method} ${request.url}\n` +
+      stringifyPayload(request.headers, await request.clone().text()),
+  )
+
+  try {
+    const response = await fetch(request)
+
+    console.info(
+      `< HTTP/1.1 ${response.status} ${response.statusText}\n` +
+        stringifyPayload(response.headers, await response.clone().text()),
+    )
+
+    return response
+  } catch (error) {
+    console.error(`< Error:`, error)
+
+    throw error
+  }
+}
+
+const stringifyPayload = (headers: Headers, body: string) =>
+  [stringifyHeaders(headers), stringifyBody(body)]
+    .filter(Boolean)
+    .join('\n  ') + '\n  '
+
+const stringifyHeaders = (headers: Headers) =>
+  Array.from(headers)
+    .map(([name, value]) => `  ${name}: ${value}\n`)
+    .join('')
+
+const stringifyBody = (body: string) =>
+  body ? `\n  ${body.replace(/\r?\n/g, '\\n')}` : ''
+
+export const timeoutFetchWrap = ({
+  fetch = globalThis.fetch as Fetch,
+  timeout = 60e3,
+} = {}): Fetch => {
+  if (timeout === Infinity) return fetch
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new TypeError('Timeout must be positive')
+  }
+  return async function (request) {
+    return fetchTimeout.call(this, request, timeout, fetch)
+  }
+}
+
+export async function fetchTimeout(
+  this: ThisParameterType<Fetch>,
+  request: Request,
+  timeout = 30e3,
+  fetch: Fetch = globalThis.fetch,
+): Promise<Response> {
+  if (timeout === Infinity) return fetch(request)
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new TypeError('Timeout must be positive')
+  }
+
+  const controller = new AbortController()
+  const signal = controller.signal
+
+  const abort = () => {
+    controller.abort()
+  }
+  const cleanup = () => {
+    clearTimeout(timeoutId)
+    request.signal?.removeEventListener('abort', abort)
+  }
+
+  const timeoutId = setTimeout(abort, timeout).unref()
+  request.signal?.addEventListener('abort', abort)
+
+  signal.addEventListener('abort', cleanup)
+
+  const response = await fetch(new Request(request, { signal }))
+
+  if (!response.body) {
+    cleanup()
+    return response
+  } else {
+    // Cleanup the timer & event listeners when the body stream is closed
+    const transform = new TransformStream({ flush: cleanup })
+    return new TransformedResponse(response, transform)
+  }
+}

package/src/fetch.ts

@@ -0,0 +1,4 @@
+export type Fetch = (
+  this: void | null | typeof globalThis,
+  input: Request,
+) => Promise<Response>

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './fetch-error.js'
+export * from './fetch-request.js'
+export * from './fetch-response.js'
+export * from './fetch-wrap.js'
+export * from './fetch.js'
+export * from './util.js'

package/src/transformed-response.ts

@@ -0,0 +1,33 @@
+export class TransformedResponse extends Response {
+  #response: Response
+
+  constructor(response: Response, transform: TransformStream) {
+    if (response.body && response.bodyUsed) {
+      throw new TypeError('Response body is already used')
+    }
+
+    super(response.body?.pipeThrough(transform) ?? null, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+    })
+
+    this.#response = response
+  }
+
+  /**
+   * Some props can't be set through ResponseInit, so we need to proxy them
+   */
+  get url() {
+    return this.#response.url
+  }
+  get redirected() {
+    return this.#response.redirected
+  }
+  get type() {
+    return this.#response.type
+  }
+  get statusText() {
+    return this.#response.statusText
+  }
+}