@whatwg-node/node-fetch 0.8.0-alpha-20241212160430-140b66f028923f44368e67598b6b66f47f690454 → 0.8.0-alpha-20250917053118-2dc604e028627df01a83e41a3dd6dd3f89ca0b40

package/esm/WritableStream.js

@@ -1,5 +1,7 @@
-import { Writable } from 'stream';
-import { fakePromise } from './utils.js';
+import { once } from 'node:events';
+import { Writable } from 'node:stream';
+import { fakeRejectPromise } from '@whatwg-node/promise-helpers';
+import { endStream, fakePromise, safeWrite } from './utils.js';
 export class PonyfillWritableStream {
     writable;
     constructor(underlyingSink) {
@@ -41,55 +43,15 @@ export class PonyfillWritableStream {
                 },
             });
             this.writable = writable;
-            let onabort;
-            let reason;
+            const abortCtrl = new AbortController();
             const controller = {
-                signal: {
-                    any(signals) {
-                        return AbortSignal.any([...signals]);
-                    },
-                    get reason() {
-                        return reason;
-                    },
-                    get aborted() {
-                        return writable.destroyed;
-                    },
-                    addEventListener: (_event, eventListener) => {
-                        writable.once('error', eventListener);
-                        writable.once('close', eventListener);
-                    },
-                    removeEventListener: (_event, eventListener) => {
-                        writable.off('error', eventListener);
-                        writable.off('close', eventListener);
-                    },
-                    dispatchEvent: (_event) => {
-                        return false;
-                    },
-                    get onabort() {
-                        return onabort;
-                    },
-                    set onabort(value) {
-                        if (onabort) {
-                            this.removeEventListener('abort', onabort);
-                        }
-                        onabort = value;
-                        if (onabort) {
-                            this.addEventListener('abort', onabort, { once: true });
-                        }
-                    },
-                    throwIfAborted() {
-                        if (writable.destroyed) {
-                            throw reason;
-                        }
-                    },
-                },
-                error: e => {
-                    this.writable.destroy(e);
+                signal: abortCtrl.signal,
+                error(e) {
+                    writable.destroy(e);
                 },
             };
-            this.writable.once('error', err => {
-                reason = err;
-            });
+            writable.once('error', err => abortCtrl.abort(err));
+            writable.once('close', () => abortCtrl.abort());
         }
         else {
             this.writable = new Writable();
@@ -98,90 +60,52 @@ export class PonyfillWritableStream {
     getWriter() {
         const writable = this.writable;
         return {
-            closed: new Promise(resolve => {
-                writable.once('close', () => {
-                    resolve(undefined);
-                });
-            }),
+            get closed() {
+                return once(writable, 'close');
+            },
             get desiredSize() {
                 return writable.writableLength;
             },
-            ready: new Promise(resolve => {
-                writable.once('drain', () => {
-                    resolve(undefined);
-                });
-            }),
+            get ready() {
+                return once(writable, 'drain');
+            },
             releaseLock() {
                 // no-op
             },
             write(chunk) {
+                const promise = fakePromise();
                 if (chunk == null) {
-                    return fakePromise(undefined);
+                    return promise;
                 }
-                return new Promise((resolve, reject) => {
-                    writable.write(chunk, (err) => {
-                        if (err) {
-                            reject(err);
-                        }
-                        else {
-                            resolve();
-                        }
-                    });
-                });
+                return promise.then(() => safeWrite(chunk, writable));
             },
             close() {
                 if (!writable.errored && writable.closed) {
-                    return fakePromise(undefined);
+                    return fakePromise();
                 }
-                return new Promise((resolve, reject) => {
-                    if (writable.errored) {
-                        reject(writable.errored);
-                    }
-                    else {
-                        writable.end((err) => {
-                            if (err) {
-                                reject(err);
-                            }
-                            else {
-                                resolve();
-                            }
-                        });
-                    }
-                });
+                if (writable.errored) {
+                    return fakeRejectPromise(writable.errored);
+                }
+                return fakePromise().then(() => endStream(writable));
             },
             abort(reason) {
-                return new Promise(resolve => {
-                    writable.destroy(reason);
-                    writable.once('close', resolve);
-                });
+                writable.destroy(reason);
+                return once(writable, 'close');
             },
         };
     }
     close() {
         if (!this.writable.errored && this.writable.closed) {
-            return fakePromise(undefined);
+            return fakePromise();
         }
-        return new Promise((resolve, reject) => {
-            if (this.writable.errored) {
-                reject(this.writable.errored);
-            }
-            else {
-                this.writable.end((err) => {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-            }
-        });
+        if (this.writable.errored) {
+            return fakeRejectPromise(this.writable.errored);
+        }
+        return fakePromise().then(() => endStream(this.writable));
     }
     abort(reason) {
-        return new Promise(resolve => {
-            this.writable.destroy(reason);
-            this.writable.once('close', resolve);
-        });
+        this.writable.destroy(reason);
+        return once(this.writable, 'close');
     }
     locked = false;
 }

package/esm/fetch.js

@@ -1,5 +1,6 @@
-import { createReadStream } from 'fs';
-import { fileURLToPath } from 'url';
+import { Buffer } from 'node:buffer';
+import { createReadStream, promises as fsPromises } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { fetchCurl } from './fetchCurl.js';
 import { fetchNodeHttp } from './fetchNodeHttp.js';
 import { PonyfillRequest } from './Request.js';
@@ -7,10 +8,38 @@ import { PonyfillResponse } from './Response.js';
 import { PonyfillURL } from './URL.js';
 import { fakePromise } from './utils.js';
 const BASE64_SUFFIX = ';base64';
-function getResponseForFile(url) {
+async function getResponseForFile(url) {
     const path = fileURLToPath(url);
-    const readable = createReadStream(path);
-    return new PonyfillResponse(readable);
+    try {
+        await fsPromises.access(path, fsPromises.constants.R_OK);
+        const stats = await fsPromises.stat(path, {
+            bigint: true,
+        });
+        const readable = createReadStream(path);
+        return new PonyfillResponse(readable, {
+            status: 200,
+            statusText: 'OK',
+            headers: {
+                'content-type': 'application/octet-stream',
+                'last-modified': stats.mtime.toUTCString(),
+            },
+        });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return new PonyfillResponse(null, {
+                status: 404,
+                statusText: 'Not Found',
+            });
+        }
+        else if (err.code === 'EACCES') {
+            return new PonyfillResponse(null, {
+                status: 403,
+                statusText: 'Forbidden',
+            });
+        }
+        throw err;
+    }
 }
 function getResponseForDataUri(url) {
     const [mimeType = 'text/plain', ...datas] = url.substring(5).split(',');
@@ -62,7 +91,7 @@ export function fetchPonyfill(info, init) {
     }
     if (fetchRequest.url.startsWith('file:')) {
         const response = getResponseForFile(fetchRequest.url);
-        return fakePromise(response);
+        return response;
     }
     if (fetchRequest.url.startsWith('blob:')) {
         const response = getResponseForBlob(fetchRequest.url);

package/esm/fetchCurl.js

@@ -1,7 +1,8 @@
-import { PassThrough, Readable, promises as streamPromises } from 'stream';
-import { rootCertificates } from 'tls';
+import { PassThrough, Readable } from 'node:stream';
+import { rootCertificates } from 'node:tls';
+import { createDeferredPromise } from '@whatwg-node/promise-helpers';
 import { PonyfillResponse } from './Response.js';
-import { createDeferredPromise, defaultHeadersSerializer, isNodeReadable } from './utils.js';
+import { defaultHeadersSerializer, isNodeReadable, shouldRedirect } from './utils.js';
 export function fetchCurl(fetchRequest) {
     const { Curl, CurlFeature, CurlPause, CurlProgressFunc } = globalThis['libcurl'];
     const curlHandle = new Curl();
@@ -17,12 +18,15 @@ export function fetchCurl(fetchRequest) {
         curlHandle.setOpt('CAINFO_BLOB', rootCertificates.join('\n'));
     }
     curlHandle.enable(CurlFeature.StreamResponse);
+    let signal;
+    if (fetchRequest._signal === null) {
+        signal = undefined;
+    }
+    else if (fetchRequest._signal) {
+        signal = fetchRequest._signal;
+    }
     curlHandle.setStreamProgressCallback(function () {
-        return fetchRequest['_signal']?.aborted
-            ? process.env.DEBUG
-                ? CurlProgressFunc.Continue
-                : 1
-            : 0;
+        return signal?.aborted ? (process.env.DEBUG ? CurlProgressFunc.Continue : 1) : 0;
     });
     if (fetchRequest['bodyType'] === 'String') {
         curlHandle.setOpt('POSTFIELDS', fetchRequest['bodyInit']);
@@ -59,18 +63,17 @@ export function fetchCurl(fetchRequest) {
     curlHandle.enable(CurlFeature.NoHeaderParsing);
     const deferredPromise = createDeferredPromise();
     let streamResolved;
-    if (fetchRequest['_signal']) {
-        fetchRequest['_signal'].onabort = () => {
-            if (curlHandle.isOpen) {
-                try {
-                    curlHandle.pause(CurlPause.Recv);
-                }
-                catch (e) {
-                    deferredPromise.reject(e);
-                }
+    function onAbort() {
+        if (curlHandle.isOpen) {
+            try {
+                curlHandle.pause(CurlPause.Recv);
+            }
+            catch (e) {
+                deferredPromise.reject(e);
             }
-        };
+        }
     }
+    signal?.addEventListener('abort', onAbort, { once: true });
     curlHandle.once('end', function endListener() {
         try {
             curlHandle.close();
@@ -78,6 +81,7 @@ export function fetchCurl(fetchRequest) {
         catch (e) {
             deferredPromise.reject(e);
         }
+        signal?.removeEventListener('abort', onAbort);
     });
     curlHandle.once('error', function errorListener(error) {
         if (streamResolved && !streamResolved.closed && !streamResolved.destroyed) {
@@ -97,42 +101,17 @@ export function fetchCurl(fetchRequest) {
         }
     });
     curlHandle.once('stream', function streamListener(stream, status, headersBuf) {
-        const outputStream = new PassThrough();
-        streamPromises
-            .pipeline(stream, outputStream, {
+        const outputStream = stream.pipe(new PassThrough(), {
             end: true,
-            signal: fetchRequest['_signal'] ?? undefined,
-        })
-            .then(() => {
-            if (!stream.destroyed) {
-                stream.resume();
-            }
-        })
-            .catch(deferredPromise.reject);
-        if (fetchRequest['_signal']) {
-            outputStream.once('error', () => {
-                if (!fetchRequest['_signal']?.aborted) {
-                    fetchRequest['_signal']?.sendAbort?.();
-                }
-            });
-            outputStream.once('close', () => {
-                if (!fetchRequest['_signal']?.aborted) {
-                    fetchRequest['_signal']?.sendAbort?.();
-                }
-            });
-            outputStream.once('destroy', () => {
-                if (!fetchRequest['_signal']?.aborted) {
-                    fetchRequest['_signal']?.sendAbort?.();
-                }
-            });
-        }
+        });
         const headersFlat = headersBuf
             .toString('utf8')
             .split(/\r?\n|\r/g)
             .filter(headerFilter => {
             if (headerFilter && !headerFilter.startsWith('HTTP/')) {
                 if (fetchRequest.redirect === 'error' &&
-                    (headerFilter.includes('location') || headerFilter.includes('Location'))) {
+                    headerFilter.toLowerCase().includes('location') &&
+                    shouldRedirect(status)) {
                     if (!stream.destroyed) {
                         stream.resume();
                     }
@@ -153,18 +132,8 @@ export function fetchCurl(fetchRequest) {
         deferredPromise.resolve(ponyfillResponse);
         streamResolved = outputStream;
     });
-    let count = 0;
-    try {
-        count = Curl.getCount();
-    }
-    catch { }
-    if (count > 0) {
-        setImmediate(() => {
-            curlHandle.perform();
-        });
-    }
-    else {
+    setImmediate(() => {
         curlHandle.perform();
-    }
+    });
     return deferredPromise.promise;
 }

package/esm/fetchNodeHttp.js

@@ -1,11 +1,12 @@
-import { request as httpRequest } from 'http';
-import { request as httpsRequest } from 'https';
-import { PassThrough, Readable, promises as streamPromises } from 'stream';
-import { createBrotliDecompress, createGunzip, createInflate, createInflateRaw } from 'zlib';
+import { request as httpRequest, STATUS_CODES } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { PassThrough, Readable } from 'node:stream';
+import { createBrotliDecompress, createGunzip, createInflate, createInflateRaw } from 'node:zlib';
+import { handleMaybePromise } from '@whatwg-node/promise-helpers';
 import { PonyfillRequest } from './Request.js';
 import { PonyfillResponse } from './Response.js';
 import { PonyfillURL } from './URL.js';
-import { getHeadersObj, isNodeReadable } from './utils.js';
+import { endStream, getHeadersObj, isNodeReadable, pipeThrough, safeWrite, shouldRedirect, } from './utils.js';
 function getRequestFnForProtocol(url) {
     if (url.startsWith('http:')) {
         return httpRequest;
@@ -19,30 +20,24 @@ export function fetchNodeHttp(fetchRequest) {
     return new Promise((resolve, reject) => {
         try {
             const requestFn = getRequestFnForProtocol(fetchRequest.parsedUrl?.protocol || fetchRequest.url);
-            const nodeReadable = (fetchRequest.body != null
-                ? isNodeReadable(fetchRequest.body)
-                    ? fetchRequest.body
-                    : Readable.from(fetchRequest.body)
-                : null);
             const headersSerializer = fetchRequest.headersSerializer || getHeadersObj;
             const nodeHeaders = headersSerializer(fetchRequest.headers);
-            if (nodeHeaders['accept-encoding'] == null) {
-                nodeHeaders['accept-encoding'] = 'gzip, deflate, br';
+            nodeHeaders['accept-encoding'] ||= 'gzip, deflate, br';
+            nodeHeaders['user-agent'] ||= 'node';
+            let signal;
+            if (fetchRequest._signal == null) {
+                signal = undefined;
+            }
+            else if (fetchRequest._signal) {
+                signal = fetchRequest._signal;
             }
             let nodeRequest;
-            // Skip using parsed URL if it's an IPv6 address (starting with brackets)
-            if (fetchRequest.parsedUrl && !fetchRequest.parsedUrl.hostname?.startsWith('[')) {
-                nodeRequest = requestFn({
-                    auth: fetchRequest.parsedUrl.username
-                        ? `${fetchRequest.parsedUrl.username}:${fetchRequest.parsedUrl.password}`
-                        : undefined,
-                    hostname: fetchRequest.parsedUrl.hostname,
+            // If it is our ponyfilled Request, it should have `parsedUrl` which is a `URL` object
+            if (fetchRequest.parsedUrl) {
+                nodeRequest = requestFn(fetchRequest.parsedUrl, {
                     method: fetchRequest.method,
-                    path: fetchRequest.parsedUrl.pathname + (fetchRequest.parsedUrl.search || ''),
-                    port: fetchRequest.parsedUrl.port,
-                    protocol: fetchRequest.parsedUrl.protocol,
                     headers: nodeHeaders,
-                    signal: fetchRequest['_signal'] ?? undefined,
+                    signal,
                     agent: fetchRequest.agent,
                 });
             }
@@ -50,10 +45,11 @@ export function fetchNodeHttp(fetchRequest) {
                 nodeRequest = requestFn(fetchRequest.url, {
                     method: fetchRequest.method,
                     headers: nodeHeaders,
-                    signal: fetchRequest['_signal'] ?? undefined,
+                    signal,
                     agent: fetchRequest.agent,
                 });
             }
+            nodeRequest.once('error', reject);
             nodeRequest.once('response', nodeResponse => {
                 let outputStream;
                 const contentEncoding = nodeResponse.headers['content-encoding'];
@@ -73,10 +69,8 @@ export function fetchNodeHttp(fetchRequest) {
                     case 'br':
                         outputStream = createBrotliDecompress();
                         break;
-                    default:
-                        outputStream = new PassThrough();
                 }
-                if (nodeResponse.headers.location) {
+                if (nodeResponse.headers.location && shouldRedirect(nodeResponse.statusCode)) {
                     if (fetchRequest.redirect === 'error') {
                         const redirectError = new Error('Redirects are not allowed');
                         reject(redirectError);
@@ -94,48 +88,50 @@ export function fetchNodeHttp(fetchRequest) {
                         return;
                     }
                 }
-                streamPromises
-                    .pipeline(nodeResponse, outputStream, {
-                    signal: fetchRequest['_signal'] ?? undefined,
-                    end: true,
-                })
-                    .then(() => {
-                    if (!nodeResponse.destroyed) {
-                        nodeResponse.resume();
-                    }
-                })
-                    .catch(reject);
-                if (fetchRequest['_signal']) {
-                    outputStream.once('error', () => {
-                        if (!fetchRequest['_signal']?.aborted) {
-                            fetchRequest['_signal']?.sendAbort?.();
-                        }
-                    });
-                    outputStream.once('close', () => {
-                        if (!fetchRequest['_signal']?.aborted) {
-                            fetchRequest['_signal']?.sendAbort?.();
+                outputStream ||= new PassThrough();
+                pipeThrough({
+                    src: nodeResponse,
+                    dest: outputStream,
+                    signal,
+                    onError: e => {
+                        if (!nodeResponse.destroyed) {
+                            nodeResponse.destroy(e);
                         }
-                    });
-                    outputStream.once('destroy', () => {
-                        if (!fetchRequest['_signal']?.aborted) {
-                            fetchRequest['_signal']?.sendAbort?.();
+                        if (!outputStream.destroyed) {
+                            outputStream.destroy(e);
                         }
-                    });
+                        reject(e);
+                    },
+                });
+                const statusCode = nodeResponse.statusCode || 200;
+                let statusText = nodeResponse.statusMessage || STATUS_CODES[statusCode];
+                if (statusText == null) {
+                    statusText = '';
                 }
-                const ponyfillResponse = new PonyfillResponse(outputStream, {
-                    status: nodeResponse.statusCode,
-                    statusText: nodeResponse.statusMessage,
+                const ponyfillResponse = new PonyfillResponse(outputStream || nodeResponse, {
+                    status: statusCode,
+                    statusText,
                     headers: nodeResponse.headers,
                     url: fetchRequest.url,
+                    signal,
                 });
                 resolve(ponyfillResponse);
             });
-            nodeRequest.once('error', reject);
-            if (nodeReadable) {
-                nodeReadable.pipe(nodeRequest);
+            if (fetchRequest['_buffer'] != null) {
+                handleMaybePromise(() => safeWrite(fetchRequest['_buffer'], nodeRequest), () => endStream(nodeRequest), reject);
             }
             else {
-                nodeRequest.end();
+                const nodeReadable = (fetchRequest.body != null
+                    ? isNodeReadable(fetchRequest.body)
+                        ? fetchRequest.body
+                        : Readable.from(fetchRequest.body)
+                    : null);
+                if (nodeReadable) {
+                    nodeReadable.pipe(nodeRequest);
+                }
+                else {
+                    endStream(nodeRequest);
+                }
             }
         }
         catch (e) {

package/esm/index.js

@@ -16,6 +16,3 @@ export { PonyfillCompressionStream as CompressionStream } from './CompressionStr
 export { PonyfillDecompressionStream as DecompressionStream } from './DecompressionStream.js';
 export { PonyfillIteratorObject as IteratorObject } from './IteratorObject.js';
 export { PonyfillTextDecoderStream as TextDecoderStream, PonyfillTextEncoderStream as TextEncoderStream, } from './TextEncoderDecoderStream.js';
-export { PonyfillAbortController as AbortController } from './AbortController.js';
-export { PonyfillAbortSignal as AbortSignal } from './AbortSignal.js';
-export { PonyfillAbortError as AbortError } from './AbortError.js';