@whatwg-node/node-fetch 0.8.0-alpha-20241212154840-0a0effe808a6614e0a3afd853126a38641485756 → 0.8.0-alpha-20250917012053-36c9ccdc3e94ee8d0961f17398a9053fa55df37b

package/esm/Body.js

@@ -1,5 +1,8 @@
-import { Readable } from 'stream';
-import busboy from 'busboy';
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { Buffer } from 'node:buffer';
+import { addAbortSignal, Readable } from 'node:stream';
+import { Busboy } from '@fastify/busboy';
+import { handleMaybePromise } from '@whatwg-node/promise-helpers';
 import { hasArrayBufferMethod, hasBufferMethod, hasBytesMethod, PonyfillBlob } from './Blob.js';
 import { PonyfillFile } from './File.js';
 import { getStreamFromFormData, PonyfillFormData } from './FormData.js';
@@ -30,11 +33,13 @@ export class PonyfillBody {
         this.contentLength = contentLength;
         this.bodyType = bodyType;
         this._buffer = buffer;
+        this._signal = options.signal;
     }
     bodyType;
     _bodyFactory = () => null;
     _generatedBody = null;
     _buffer;
+    _signal;
     generateBody() {
         if (this._generatedBody?.readable?.destroyed && this._buffer) {
             this._generatedBody.readable = Readable.from(this._buffer);
@@ -97,48 +102,66 @@ export class PonyfillBody {
         return null;
     }
     _chunks = null;
-    _collectChunksFromReadable() {
-        if (this._chunks) {
-            return fakePromise(this._chunks);
-        }
+    _doCollectChunksFromReadableJob() {
         if (this.bodyType === BodyInitType.AsyncIterable) {
-            const iterator = this.bodyInit[Symbol.asyncIterator]();
-            const collectValue = () => {
-                return iterator.next().then(({ value, done }) => {
-                    this._chunks ||= [];
-                    if (value) {
-                        this._chunks.push(value);
-                    }
-                    if (!done) {
-                        return collectValue();
-                    }
+            if (Array.fromAsync) {
+                return handleMaybePromise(() => Array.fromAsync(this.bodyInit), chunks => {
+                    this._chunks = chunks;
                     return this._chunks;
                 });
-            };
+            }
+            const iterator = this.bodyInit[Symbol.asyncIterator]();
+            const chunks = [];
+            const collectValue = () => handleMaybePromise(() => iterator.next(), ({ value, done }) => {
+                if (value) {
+                    chunks.push(value);
+                }
+                if (!done) {
+                    return collectValue();
+                }
+                this._chunks = chunks;
+                return this._chunks;
+            });
             return collectValue();
         }
         const _body = this.generateBody();
         if (!_body) {
-            return fakePromise([]);
+            this._chunks = [];
+            return fakePromise(this._chunks);
         }
-        this._chunks = [];
-        _body.readable.on('data', chunk => {
-            this._chunks.push(chunk);
-        });
+        if (_body.readable.destroyed) {
+            return fakePromise((this._chunks = []));
+        }
+        const chunks = [];
         return new Promise((resolve, reject) => {
-            _body.readable.once('end', () => {
-                resolve(this._chunks);
+            _body.readable.on('data', chunk => {
+                chunks.push(chunk);
             });
-            _body.readable.once('error', e => {
-                reject(e);
+            _body.readable.once('error', reject);
+            _body.readable.once('end', () => {
+                resolve((this._chunks = chunks));
             });
         });
     }
+    _collectChunksFromReadable() {
+        if (this._chunks) {
+            return fakePromise(this._chunks);
+        }
+        this._chunks ||= this._doCollectChunksFromReadableJob();
+        return this._chunks;
+    }
     _blob = null;
     blob() {
         if (this._blob) {
             return fakePromise(this._blob);
         }
+        if (this.bodyType === BodyInitType.String) {
+            this._text = this.bodyInit;
+            this._blob = new PonyfillBlob([this._text], {
+                type: this.contentType || 'text/plain;charset=UTF-8',
+                size: this.contentLength,
+            });
+        }
         if (this.bodyType === BodyInitType.Blob) {
             this._blob = this.bodyInit;
             return fakePromise(this._blob);
@@ -150,13 +173,13 @@ export class PonyfillBody {
             });
             return fakePromise(this._blob);
         }
-        return this._collectChunksFromReadable().then(chunks => {
+        return fakePromise(handleMaybePromise(() => this._collectChunksFromReadable(), chunks => {
             this._blob = new PonyfillBlob(chunks, {
                 type: this.contentType || '',
                 size: this.contentLength,
             });
             return this._blob;
-        });
+        }));
     }
     _formData = null;
     formData(opts) {
@@ -177,61 +200,108 @@ export class PonyfillBody {
             ...opts?.formDataLimits,
         };
         return new Promise((resolve, reject) => {
-            const bb = busboy({
+            const stream = this.body?.readable;
+            if (!stream) {
+                return reject(new Error('No stream available'));
+            }
+            // form data file that is currently being processed, it's
+            // important to keep track of it in case the stream ends early
+            let currFile = null;
+            const bb = new Busboy({
                 headers: {
+                    'content-length': typeof this.contentLength === 'number'
+                        ? this.contentLength.toString()
+                        : this.contentLength || '',
                     'content-type': this.contentType || '',
                 },
                 limits: formDataLimits,
-                defParamCharset: 'utf-8',
+                defCharset: 'utf-8',
             });
-            bb.on('field', (name, value, { nameTruncated, valueTruncated }) => {
-                if (nameTruncated) {
-                    reject(new Error(`Field name size exceeded: ${formDataLimits?.fieldNameSize} bytes`));
+            if (this._signal) {
+                addAbortSignal(this._signal, bb);
+            }
+            let completed = false;
+            const complete = (err) => {
+                if (completed)
+                    return;
+                completed = true;
+                stream.unpipe(bb);
+                bb.destroy();
+                if (currFile) {
+                    currFile.destroy();
+                    currFile = null;
+                }
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    // no error occured, this is a successful end/complete/finish
+                    resolve(this._formData);
+                }
+            };
+            // we dont need to listen to the stream close event because bb will close or error when necessary
+            // stream.on('close', complete);
+            // stream can be aborted, for example
+            stream.on('error', complete);
+            bb.on('field', (name, value, fieldnameTruncated, valueTruncated) => {
+                if (fieldnameTruncated) {
+                    return complete(new Error(`Field name size exceeded: ${formDataLimits?.fieldNameSize} bytes`));
                 }
                 if (valueTruncated) {
-                    reject(new Error(`Field value size exceeded: ${formDataLimits?.fieldSize} bytes`));
+                    return complete(new Error(`Field value size exceeded: ${formDataLimits?.fieldSize} bytes`));
                 }
                 this._formData.set(name, value);
             });
-            bb.on('fieldsLimit', () => {
-                reject(new Error(`Fields limit exceeded: ${formDataLimits?.fields}`));
-            });
-            bb.on('file', (name, fileStream, { filename, mimeType }) => {
+            bb.on('file', (name, fileStream, filename, _transferEncoding, mimeType) => {
+                currFile = fileStream;
                 const chunks = [];
-                fileStream.on('limit', () => {
-                    reject(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
-                });
                 fileStream.on('data', chunk => {
                     chunks.push(chunk);
                 });
+                fileStream.on('error', complete);
+                fileStream.on('limit', () => {
+                    complete(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
+                });
                 fileStream.on('close', () => {
                     if (fileStream.truncated) {
-                        reject(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
+                        complete(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
                     }
+                    currFile = null;
                     const file = new PonyfillFile(chunks, filename, { type: mimeType });
                     this._formData.set(name, file);
                 });
             });
+            bb.on('fieldsLimit', () => {
+                complete(new Error(`Fields limit exceeded: ${formDataLimits?.fields}`));
+            });
             bb.on('filesLimit', () => {
-                reject(new Error(`Files limit exceeded: ${formDataLimits?.files}`));
+                complete(new Error(`Files limit exceeded: ${formDataLimits?.files}`));
             });
             bb.on('partsLimit', () => {
-                reject(new Error(`Parts limit exceeded: ${formDataLimits?.parts}`));
+                complete(new Error(`Parts limit exceeded: ${formDataLimits?.parts}`));
             });
-            bb.on('close', () => {
-                resolve(this._formData);
-            });
-            bb.on('error', (err = 'An error occurred while parsing the form data') => {
-                const errMessage = err.message || err.toString();
-                reject(new TypeError(errMessage, err.cause));
-            });
-            _body?.readable.pipe(bb);
+            bb.on('end', complete);
+            bb.on('finish', complete);
+            bb.on('close', complete);
+            bb.on('error', complete);
+            stream.pipe(bb);
         });
     }
     buffer() {
         if (this._buffer) {
             return fakePromise(this._buffer);
         }
+        if (this._text) {
+            this._buffer = Buffer.from(this._text, 'utf-8');
+            return fakePromise(this._buffer);
+        }
+        if (this.bodyType === BodyInitType.String) {
+            return this.text().then(text => {
+                this._text = text;
+                this._buffer = Buffer.from(text, 'utf-8');
+                return this._buffer;
+            });
+        }
         if (this.bodyType === BodyInitType.Blob) {
             if (hasBufferMethod(this.bodyInit)) {
                 return this.bodyInit.buffer().then(buf => {
@@ -252,20 +322,20 @@ export class PonyfillBody {
                 });
             }
         }
-        return this._collectChunksFromReadable().then(chunks => {
+        return fakePromise(handleMaybePromise(() => this._collectChunksFromReadable(), chunks => {
             if (chunks.length === 1) {
                 this._buffer = chunks[0];
                 return this._buffer;
             }
             this._buffer = Buffer.concat(chunks);
             return this._buffer;
-        });
+        }));
     }
     bytes() {
         return this.buffer();
     }
     arrayBuffer() {
-        // @ts-expect-error - `Buffer` and `ArrayBuffer` are compatible
+        // @ts-ignore - Mismatch between Buffer and ArrayBuffer
         return this.buffer();
     }
     _json = null;
@@ -310,27 +380,26 @@ function processBodyInit(bodyInit) {
         };
     }
     if (typeof bodyInit === 'string') {
-        const buffer = Buffer.from(bodyInit);
-        const contentLength = buffer.byteLength;
+        const contentLength = Buffer.byteLength(bodyInit);
         return {
             bodyType: BodyInitType.String,
             contentType: 'text/plain;charset=UTF-8',
             contentLength,
-            buffer,
             bodyFactory() {
-                const readable = Readable.from(buffer);
+                const readable = Readable.from(Buffer.from(bodyInit, 'utf-8'));
                 return new PonyfillReadableStream(readable);
             },
         };
     }
     if (Buffer.isBuffer(bodyInit)) {
+        const buffer = bodyInit;
         return {
             bodyType: BodyInitType.Buffer,
             contentType: null,
             contentLength: bodyInit.length,
             buffer: bodyInit,
             bodyFactory() {
-                const readable = Readable.from(bodyInit);
+                const readable = Readable.from(buffer);
                 const body = new PonyfillReadableStream(readable);
                 return body;
             },
@@ -351,20 +420,22 @@ function processBodyInit(bodyInit) {
         };
     }
     if (bodyInit instanceof PonyfillReadableStream && bodyInit.readable != null) {
+        const readableStream = bodyInit;
         return {
             bodyType: BodyInitType.ReadableStream,
-            bodyFactory: () => bodyInit,
+            bodyFactory: () => readableStream,
             contentType: null,
             contentLength: null,
         };
     }
     if (isBlob(bodyInit)) {
+        const blob = bodyInit;
         return {
             bodyType: BodyInitType.Blob,
             contentType: bodyInit.type,
             contentLength: bodyInit.size,
             bodyFactory() {
-                return bodyInit.stream();
+                return blob.stream();
             },
         };
     }
@@ -444,7 +515,7 @@ function isFormData(value) {
     return value?.forEach != null;
 }
 function isBlob(value) {
-    return value?.stream != null;
+    return value?.stream != null && typeof value.stream === 'function';
 }
 function isURLSearchParams(value) {
     return value?.sort != null;

package/esm/FormData.js

@@ -1,3 +1,4 @@
+import { Buffer } from 'node:buffer';
 import { PonyfillIteratorObject } from './IteratorObject.js';
 import { PonyfillReadableStream } from './ReadableStream.js';
 export class PonyfillFormData {
@@ -68,54 +69,66 @@ export class PonyfillFormData {
     }
 }
 export function getStreamFromFormData(formData, boundary = '---') {
-    const entries = [];
+    let entriesIterator;
     let sentInitialHeader = false;
-    return new PonyfillReadableStream({
-        start: controller => {
-            formData.forEach((value, key) => {
-                if (!sentInitialHeader) {
-                    controller.enqueue(Buffer.from(`--${boundary}\r\n`));
-                    sentInitialHeader = true;
+    let currentAsyncIterator;
+    let hasBefore = false;
+    function handleNextEntry(controller) {
+        const { done, value } = entriesIterator.next();
+        if (done) {
+            controller.enqueue(Buffer.from(`\r\n--${boundary}--\r\n`));
+            return controller.close();
+        }
+        if (hasBefore) {
+            controller.enqueue(Buffer.from(`\r\n--${boundary}\r\n`));
+        }
+        if (value) {
+            const [key, blobOrString] = value;
+            if (typeof blobOrString === 'string') {
+                controller.enqueue(Buffer.from(`Content-Disposition: form-data; name="${key}"\r\n\r\n`));
+                controller.enqueue(Buffer.from(blobOrString));
+            }
+            else {
+                let filenamePart = '';
+                if (blobOrString.name) {
+                    filenamePart = `; filename="${blobOrString.name}"`;
                 }
-                entries.push([key, value]);
-            });
-            if (!sentInitialHeader) {
-                controller.enqueue(Buffer.from(`--${boundary}--\r\n`));
-                controller.close();
+                controller.enqueue(Buffer.from(`Content-Disposition: form-data; name="${key}"${filenamePart}\r\n`));
+                controller.enqueue(Buffer.from(`Content-Type: ${blobOrString.type || 'application/octet-stream'}\r\n\r\n`));
+                const entryStream = blobOrString.stream();
+                // @ts-expect-error - ReadableStream is async iterable
+                currentAsyncIterator = entryStream[Symbol.asyncIterator]();
             }
+            hasBefore = true;
+        }
+    }
+    return new PonyfillReadableStream({
+        start: () => {
+            entriesIterator = formData.entries();
         },
-        pull: async (controller) => {
-            const entry = entries.shift();
-            if (entry) {
-                const [key, value] = entry;
-                if (typeof value === 'string') {
-                    controller.enqueue(Buffer.from(`Content-Disposition: form-data; name="${key}"\r\n\r\n`));
-                    controller.enqueue(Buffer.from(value));
-                }
-                else {
-                    let filenamePart = '';
-                    if (value.name) {
-                        filenamePart = `; filename="${value.name}"`;
+        pull: controller => {
+            if (!sentInitialHeader) {
+                sentInitialHeader = true;
+                return controller.enqueue(Buffer.from(`--${boundary}\r\n`));
+            }
+            if (currentAsyncIterator) {
+                return currentAsyncIterator.next().then(({ done, value }) => {
+                    if (done) {
+                        currentAsyncIterator = undefined;
                     }
-                    controller.enqueue(Buffer.from(`Content-Disposition: form-data; name="${key}"${filenamePart}\r\n`));
-                    controller.enqueue(Buffer.from(`Content-Type: ${value.type || 'application/octet-stream'}\r\n\r\n`));
-                    const entryStream = value.stream();
-                    for await (const chunk of entryStream) {
-                        controller.enqueue(chunk);
+                    if (value) {
+                        return controller.enqueue(value);
                     }
-                }
-                if (entries.length === 0) {
-                    controller.enqueue(Buffer.from(`\r\n--${boundary}--\r\n`));
-                    controller.close();
-                }
-                else {
-                    controller.enqueue(Buffer.from(`\r\n--${boundary}\r\n`));
-                }
-            }
-            else {
-                controller.enqueue(Buffer.from(`\r\n--${boundary}--\r\n`));
-                controller.close();
+                    else {
+                        return handleNextEntry(controller);
+                    }
+                });
             }
+            return handleNextEntry(controller);
+        },
+        cancel: err => {
+            entriesIterator?.return?.(err);
+            currentAsyncIterator?.return?.(err);
         },
     });
 }

package/esm/Headers.js

@@ -8,14 +8,14 @@ export class PonyfillHeaders {
     _map;
     objectNormalizedKeysOfHeadersInit = [];
     objectOriginalKeysOfHeadersInit = [];
-    _setCookies = [];
+    _setCookies;
     constructor(headersInit) {
         this.headersInit = headersInit;
     }
     // perf: we don't need to build `this.map` for Requests, as we can access the headers directly
     _get(key) {
         const normalized = key.toLowerCase();
-        if (normalized === 'set-cookie') {
+        if (normalized === 'set-cookie' && this._setCookies?.length) {
             return this._setCookies.join(', ');
         }
         // If the map is built, reuse it
@@ -27,7 +27,14 @@ export class PonyfillHeaders {
             return null;
         }
         if (Array.isArray(this.headersInit)) {
-            return this.headersInit.find(header => header[0].toLowerCase() === normalized)?.[1] || null;
+            const found = this.headersInit.filter(([headerKey]) => headerKey.toLowerCase() === normalized);
+            if (found.length === 0) {
+                return null;
+            }
+            if (found.length === 1) {
+                return found[0][1];
+            }
+            return found.map(([, value]) => value).join(', ');
         }
         else if (isHeadersLike(this.headersInit)) {
             return this.headersInit.get(normalized);
@@ -55,22 +62,24 @@ export class PonyfillHeaders {
     // I could do a getter here, but I'm too lazy to type `getter`.
     getMap() {
         if (!this._map) {
+            this._setCookies ||= [];
             if (this.headersInit != null) {
                 if (Array.isArray(this.headersInit)) {
                     this._map = new Map();
-                    this.headersInit.forEach(([key, value]) => {
+                    for (const [key, value] of this.headersInit) {
                         const normalizedKey = key.toLowerCase();
                         if (normalizedKey === 'set-cookie') {
                             this._setCookies.push(value);
-                            return;
+                            continue;
                         }
                         this._map.set(normalizedKey, value);
-                    });
+                    }
                 }
                 else if (isHeadersLike(this.headersInit)) {
                     this._map = new Map();
                     this.headersInit.forEach((value, key) => {
                         if (key === 'set-cookie') {
+                            this._setCookies ||= [];
                             this._setCookies.push(value);
                             return;
                         }
@@ -84,6 +93,7 @@ export class PonyfillHeaders {
                         if (initValue != null) {
                             const normalizedKey = initKey.toLowerCase();
                             if (normalizedKey === 'set-cookie') {
+                                this._setCookies ||= [];
                                 this._setCookies.push(initValue);
                                 continue;
                             }
@@ -101,6 +111,7 @@ export class PonyfillHeaders {
     append(name, value) {
         const key = name.toLowerCase();
         if (key === 'set-cookie') {
+            this._setCookies ||= [];
             this._setCookies.push(value);
             return;
         }
@@ -113,11 +124,12 @@ export class PonyfillHeaders {
         if (value == null) {
             return null;
         }
-        return value;
+        return value.toString();
     }
     has(name) {
-        if (name === 'set-cookie') {
-            return this._setCookies.length > 0;
+        const key = name.toLowerCase();
+        if (key === 'set-cookie') {
+            return !!this._setCookies?.length;
         }
         return !!this._get(name); // we might need to check if header exists and not just check if it's not nullable
     }
@@ -127,6 +139,26 @@ export class PonyfillHeaders {
             this._setCookies = [value];
             return;
         }
+        if (!this._map && this.headersInit != null) {
+            if (Array.isArray(this.headersInit)) {
+                const found = this.headersInit.find(([headerKey]) => headerKey.toLowerCase() === key);
+                if (found) {
+                    found[1] = value;
+                }
+                else {
+                    this.headersInit.push([key, value]);
+                }
+                return;
+            }
+            else if (isHeadersLike(this.headersInit)) {
+                this.headersInit.set(key, value);
+                return;
+            }
+            else {
+                this.headersInit[key] = value;
+                return;
+            }
+        }
         this.getMap().set(key, value);
     }
     delete(name) {
@@ -138,7 +170,7 @@ export class PonyfillHeaders {
         this.getMap().delete(key);
     }
     forEach(callback) {
-        this._setCookies.forEach(setCookie => {
+        this._setCookies?.forEach(setCookie => {
             callback(setCookie, 'set-cookie', this);
         });
         if (!this._map) {
@@ -166,7 +198,7 @@ export class PonyfillHeaders {
         });
     }
     *_keys() {
-        if (this._setCookies.length) {
+        if (this._setCookies?.length) {
             yield 'set-cookie';
         }
         if (!this._map) {
@@ -189,7 +221,9 @@ export class PonyfillHeaders {
         return new PonyfillIteratorObject(this._keys(), 'HeadersIterator');
     }
     *_values() {
-        yield* this._setCookies;
+        if (this._setCookies?.length) {
+            yield* this._setCookies;
+        }
         if (!this._map) {
             if (this.headersInit) {
                 if (Array.isArray(this.headersInit)) {
@@ -210,7 +244,9 @@ export class PonyfillHeaders {
         return new PonyfillIteratorObject(this._values(), 'HeadersIterator');
     }
     *_entries() {
-        yield* this._setCookies.map(cookie => ['set-cookie', cookie]);
+        if (this._setCookies?.length) {
+            yield* this._setCookies.map(cookie => ['set-cookie', cookie]);
+        }
         if (!this._map) {
             if (this.headersInit) {
                 if (Array.isArray(this.headersInit)) {
@@ -231,6 +267,9 @@ export class PonyfillHeaders {
         return new PonyfillIteratorObject(this._entries(), 'HeadersIterator');
     }
     getSetCookie() {
+        if (!this._setCookies) {
+            this.getMap();
+        }
         return this._setCookies;
     }
     [Symbol.iterator]() {
@@ -240,10 +279,10 @@ export class PonyfillHeaders {
         const record = {};
         this.forEach((value, key) => {
             if (key === 'set-cookie') {
-                record['set-cookie'] = this._setCookies;
+                record['set-cookie'] = this._setCookies || [];
             }
             else {
-                record[key] = value.includes(',') ? value.split(',').map(el => el.trim()) : value;
+                record[key] = value?.includes(',') ? value.split(',').map(el => el.trim()) : value;
             }
         });
         return `Headers ${inspect(record)}`;