fix: use explicit binding for Headers re-export for Node 24+ ESM compat

Author: davidgamero

src/fetch-adapter.ts

@@ -0,0 +1,175 @@
+/**
+ * Adapter to wrap undici's fetch to provide node-fetch v2 compatibility.
+ * This allows gradual migration by providing a drop-in replacement.
+ *
+ * Node.js v18+ includes undici's fetch as global, no need to import.
+ * This adapter bridges the gap between undici (Web Streams) and node-fetch v2 (Node streams).
+ */
+
+import { Readable } from 'node:stream';
+
+/**
+ * Custom error classes to match node-fetch v2 behavior
+ */
+export class FetchError extends Error {
+    public readonly type: string;
+    public readonly code?: string;
+    public readonly errno?: string;
+
+    constructor(message: string, type: string, systemError?: any) {
+        super(message);
+        this.name = 'FetchError';
+        this.type = type;
+
+        if (systemError) {
+            this.code = systemError.code;
+            this.errno = systemError.errno;
+        }
+
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+export class AbortError extends Error {
+    public readonly type: string;
+
+    constructor(message: string = 'The operation was aborted') {
+        super(message);
+        this.name = 'AbortError';
+        this.type = 'aborted';
+
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+/**
+ * Compatible response interface that matches node-fetch v2
+ */
+export interface NodeFetchResponse {
+    readonly headers: Headers;
+    readonly ok: boolean;
+    readonly redirected: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly type: string;
+    readonly url: string;
+    readonly body: Readable | null;
+    readonly bodyUsed: boolean;
+
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    formData(): Promise<FormData>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+    buffer(): Promise<Buffer>;
+    clone(): NodeFetchResponse;
+}
+
+/**
+ * Response wrapper that converts Web Streams to Node.js streams
+ */
+class NodeFetchCompatibleResponse implements NodeFetchResponse {
+    private _undiciResponse: Response;
+    private _nodeBody: Readable | null = null;
+
+    constructor(undiciResponse: Response) {
+        this._undiciResponse = undiciResponse;
+    }
+
+    // Delegate all standard Response properties
+    get headers(): Headers {
+        return this._undiciResponse.headers;
+    }
+
+    get ok(): boolean {
+        return this._undiciResponse.ok;
+    }
+
+    get redirected(): boolean {
+        return this._undiciResponse.redirected;
+    }
+
+    get status(): number {
+        return this._undiciResponse.status;
+    }
+
+    get statusText(): string {
+        return this._undiciResponse.statusText;
+    }
+
+    get type(): string {
+        return this._undiciResponse.type;
+    }
+
+    get url(): string {
+        return this._undiciResponse.url;
+    }
+
+    get body(): Readable | null {
+        // Convert Web ReadableStream to Node.js Readable stream
+        // This is the key compatibility shim for watch.ts and log.ts
+        if (!this._nodeBody && this._undiciResponse.body) {
+            this._nodeBody = Readable.fromWeb(this._undiciResponse.body as any);
+        }
+        return this._nodeBody;
+    }
+
+    get bodyUsed(): boolean {
+        return this._undiciResponse.bodyUsed;
+    }
+
+    // Delegate all standard Response methods
+    async arrayBuffer(): Promise<ArrayBuffer> {
+        return this._undiciResponse.arrayBuffer();
+    }
+
+    async blob(): Promise<Blob> {
+        return this._undiciResponse.blob();
+    }
+
+    async formData(): Promise<FormData> {
+        return this._undiciResponse.formData();
+    }
+
+    async json(): Promise<any> {
+        return this._undiciResponse.json();
+    }
+
+    async text(): Promise<string> {
+        return this._undiciResponse.text();
+    }
+
+    clone(): NodeFetchResponse {
+        return new NodeFetchCompatibleResponse(this._undiciResponse.clone());
+    }
+
+    // node-fetch v2 specific method (deprecated in v3, but used in this codebase)
+    async buffer(): Promise<Buffer> {
+        const arrayBuffer = await this._undiciResponse.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+}
+
+/**
+ * Fetch wrapper that provides node-fetch v2 compatibility
+ */
+export default async function fetch(url: string | URL, init?: RequestInit): Promise<NodeFetchResponse> {
+    try {
+        const response = await globalThis.fetch(url, init);
+        return new NodeFetchCompatibleResponse(response);
+    } catch (err: any) {
+        // Convert undici errors to node-fetch compatible errors
+        if (err.name === 'AbortError' || err.code === 'UND_ERR_ABORTED') {
+            throw new AbortError(err.message);
+        }
+
+        // Convert other errors to FetchError
+        throw new FetchError(err.message || 'request failed', err.type || 'system', err);
+    }
+}
+
+// Re-export global Headers (matches what globalThis.fetch returns)
+const _Headers = Headers;
+export { _Headers as Headers };
+
+export type { RequestInit };