@whatwg-node/node-fetch 0.5.0-alpha-20230710180612-32e574f → 0.5.0-alpha-20231025080723-49677d8

package/esm/fetchCurl.js

@@ -1,75 +1,102 @@
-/* eslint-disable @typescript-eslint/no-this-alias */
-import { Readable } from 'stream';
-import { PonyfillHeaders } from './Headers.js';
+import { Readable } from 'node:stream';
+import { PonyfillAbortError } from './AbortError.js';
 import { PonyfillResponse } from './Response.js';
-import { defaultHeadersSerializer } from './utils.js';
-export async function fetchCurl(fetchRequest) {
-    const nodeReadable = (fetchRequest.body != null
-        ? 'pipe' in fetchRequest.body
-            ? fetchRequest.body
-            : Readable.from(fetchRequest.body)
-        : null);
+import { defaultHeadersSerializer, isNodeReadable } from './utils.js';
+export function fetchCurl(fetchRequest) {
+    const { Curl, CurlCode, CurlFeature, CurlPause, CurlProgressFunc } = globalThis['libcurl'];
+    const curlHandle = new Curl();
+    curlHandle.enable(CurlFeature.NoDataParsing);
+    curlHandle.setOpt('URL', fetchRequest.url);
+    curlHandle.setOpt('SSL_VERIFYPEER', false);
+    curlHandle.enable(CurlFeature.StreamResponse);
+    curlHandle.setStreamProgressCallback(function () {
+        return fetchRequest['_signal']?.aborted
+            ? process.env.DEBUG
+                ? CurlProgressFunc.Continue
+                : 1
+            : 0;
+    });
+    if (fetchRequest['bodyType'] === 'String') {
+        curlHandle.setOpt('POSTFIELDS', fetchRequest['bodyInit']);
+    }
+    else {
+        const nodeReadable = (fetchRequest.body != null
+            ? isNodeReadable(fetchRequest.body)
+                ? fetchRequest.body
+                : Readable.from(fetchRequest.body)
+            : null);
+        if (nodeReadable) {
+            curlHandle.setOpt('UPLOAD', true);
+            curlHandle.setUploadStream(nodeReadable);
+        }
+    }
+    if (process.env.DEBUG) {
+        curlHandle.setOpt('VERBOSE', true);
+    }
+    curlHandle.setOpt('TRANSFER_ENCODING', false);
+    curlHandle.setOpt('HTTP_TRANSFER_DECODING', true);
+    curlHandle.setOpt('FOLLOWLOCATION', fetchRequest.redirect === 'follow');
+    curlHandle.setOpt('MAXREDIRS', 20);
+    curlHandle.setOpt('ACCEPT_ENCODING', '');
+    curlHandle.setOpt('CUSTOMREQUEST', fetchRequest.method);
     const headersSerializer = fetchRequest.headersSerializer || defaultHeadersSerializer;
     let size;
-    const curlyHeaders = headersSerializer(fetchRequest.headers, value => {
+    const curlHeaders = headersSerializer(fetchRequest.headers, value => {
         size = Number(value);
     });
-    let easyNativeBinding;
-    const curlyOptions = {
-        // we want the unparsed binary response to be returned as a stream to us
-        curlyStreamResponse: true,
-        curlyResponseBodyParser: false,
-        curlyProgressCallback() {
-            if (easyNativeBinding == null) {
-                easyNativeBinding = this;
-            }
-            return fetchRequest.signal.aborted ? 1 : 0;
-        },
-        upload: nodeReadable != null,
-        transferEncoding: false,
-        httpTransferDecoding: true,
-        followLocation: fetchRequest.redirect === 'follow',
-        maxRedirs: 20,
-        acceptEncoding: '',
-        curlyStreamUpload: nodeReadable,
-        // this will just make libcurl use their own progress function (which is pretty neat)
-        // curlyProgressCallback() { return CurlProgressFunc.Continue },
-        // verbose: true,
-        httpHeader: curlyHeaders,
-        customRequest: fetchRequest.method,
-    };
     if (size != null) {
-        curlyOptions.inFileSize = size;
+        curlHandle.setOpt('INFILESIZE', size);
     }
-    const { curly, CurlCode, CurlPause } = globalThis['libcurl'];
-    fetchRequest.signal.onabort = () => {
-        if (easyNativeBinding != null) {
-            easyNativeBinding.pause(CurlPause.Recv);
+    curlHandle.setOpt('HTTPHEADER', curlHeaders);
+    curlHandle.enable(CurlFeature.NoHeaderParsing);
+    return new Promise(function promiseResolver(resolve, reject) {
+        let streamResolved = false;
+        if (fetchRequest['_signal']) {
+            fetchRequest['_signal'].onabort = () => {
+                if (streamResolved) {
+                    curlHandle.pause(CurlPause.Recv);
+                }
+                else {
+                    reject(new PonyfillAbortError());
+                    curlHandle.close();
+                }
+            };
         }
-    };
-    const curlyResult = await curly(fetchRequest.url, curlyOptions);
-    const responseHeaders = new PonyfillHeaders();
-    curlyResult.headers.forEach(headerInfo => {
-        for (const key in headerInfo) {
-            if (key === 'location' || (key === 'Location' && fetchRequest.redirect === 'error')) {
-                throw new Error('redirects are not allowed');
+        curlHandle.once('end', function endListener() {
+            curlHandle.close();
+        });
+        curlHandle.once('error', function errorListener(error) {
+            if (error.isCurlError && error.code === CurlCode.CURLE_ABORTED_BY_CALLBACK) {
+                // this is expected
             }
-            if (key !== 'result') {
-                responseHeaders.append(key, headerInfo[key]);
+            else {
+                // this is unexpected
+                reject(error);
             }
-        }
-    });
-    curlyResult.data.on('error', (err) => {
-        if (err.isCurlError && err.code === CurlCode.CURLE_ABORTED_BY_CALLBACK) {
-            // this is expected
-        }
-        else {
-            throw err;
-        }
-    });
-    return new PonyfillResponse(curlyResult.data, {
-        status: curlyResult.statusCode,
-        headers: responseHeaders,
-        url: fetchRequest.url,
+            curlHandle.close();
+        });
+        curlHandle.once('stream', function streamListener(stream, status, headersBuf) {
+            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'))) {
+                        reject(new Error('redirect is not allowed'));
+                    }
+                    return true;
+                }
+                return false;
+            });
+            const headersInit = headersFlat.map(headerFlat => headerFlat.split(/:\s(.+)/).slice(0, 2));
+            resolve(new PonyfillResponse(stream, {
+                status,
+                headers: headersInit,
+                url: fetchRequest.url,
+            }));
+            streamResolved = true;
+        });
+        curlHandle.perform();
     });
 }

package/esm/fetchNodeHttp.js

@@ -2,11 +2,10 @@ import { request as httpRequest } from 'http';
 import { request as httpsRequest } from 'https';
 import { Readable } from 'stream';
 import { createBrotliDecompress, createGunzip, createInflate } from 'zlib';
-import { PonyfillAbortError } from './AbortError.js';
 import { PonyfillRequest } from './Request.js';
 import { PonyfillResponse } from './Response.js';
 import { PonyfillURL } from './URL.js';
-import { getHeadersObj } from './utils.js';
+import { getHeadersObj, isNodeReadable } from './utils.js';
 function getRequestFnForProtocol(url) {
     if (url.startsWith('http:')) {
         return httpRequest;
@@ -21,7 +20,7 @@ export function fetchNodeHttp(fetchRequest) {
         try {
             const requestFn = getRequestFnForProtocol(fetchRequest.url);
             const nodeReadable = (fetchRequest.body != null
-                ? 'pipe' in fetchRequest.body
+                ? isNodeReadable(fetchRequest.body)
                     ? fetchRequest.body
                     : Readable.from(fetchRequest.body)
                 : null);
@@ -30,19 +29,9 @@ export function fetchNodeHttp(fetchRequest) {
             const nodeRequest = requestFn(fetchRequest.url, {
                 method: fetchRequest.method,
                 headers: nodeHeaders,
-                signal: fetchRequest.signal,
+                signal: fetchRequest['_signal'] ?? undefined,
                 agent: fetchRequest.agent,
             });
-            // TODO: will be removed after v16 reaches EOL
-            fetchRequest.signal?.addEventListener('abort', () => {
-                if (!nodeRequest.aborted) {
-                    nodeRequest.abort();
-                }
-            });
-            // TODO: will be removed after v16 reaches EOL
-            nodeRequest.once('abort', (reason) => {
-                reject(new PonyfillAbortError(reason));
-            });
             nodeRequest.once('response', nodeResponse => {
                 let responseBody = nodeResponse;
                 const contentEncoding = nodeResponse.headers['content-encoding'];

package/esm/utils.js

@@ -1,5 +1,8 @@
+function isHeadersInstance(obj) {
+    return obj?.forEach != null;
+}
 export function getHeadersObj(headers) {
-    if (headers == null || !('forEach' in headers)) {
+    if (headers == null || !isHeadersInstance(headers)) {
         return headers;
     }
     const obj = {};
@@ -8,9 +11,6 @@ export function getHeadersObj(headers) {
     });
     return obj;
 }
-export function uint8ArrayToArrayBuffer(uint8array) {
-    return uint8array.buffer.slice(uint8array.byteOffset, uint8array.byteOffset + uint8array.byteLength);
-}
 export function defaultHeadersSerializer(headers, onContentLength) {
     const headerArray = [];
     headers.forEach((value, key) => {
@@ -21,3 +21,45 @@ export function defaultHeadersSerializer(headers, onContentLength) {
     });
     return headerArray;
 }
+function isPromise(val) {
+    return val?.then != null;
+}
+export function fakePromise(value) {
+    if (isPromise(value)) {
+        return value;
+    }
+    // Write a fake promise to avoid the promise constructor
+    // being called with `new Promise` in the browser.
+    return {
+        then(resolve) {
+            if (resolve) {
+                const callbackResult = resolve(value);
+                if (isPromise(callbackResult)) {
+                    return callbackResult;
+                }
+                return fakePromise(callbackResult);
+            }
+            return this;
+        },
+        catch() {
+            return this;
+        },
+        finally(cb) {
+            if (cb) {
+                const callbackResult = cb();
+                if (isPromise(callbackResult)) {
+                    return callbackResult.then(() => value);
+                }
+                return fakePromise(value);
+            }
+            return this;
+        },
+        [Symbol.toStringTag]: 'Promise',
+    };
+}
+export function isArrayBufferView(obj) {
+    return obj != null && obj.buffer != null && obj.byteLength != null && obj.byteOffset != null;
+}
+export function isNodeReadable(obj) {
+    return obj != null && obj.pipe != null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/node-fetch",
-  "version": "0.5.0-alpha-20230710180612-32e574f",
+  "version": "0.5.0-alpha-20231025080723-49677d8",
   "description": "Fetch API implementation for Node",
   "sideEffects": false,
   "dependencies": {

package/typings/Blob.d.cts

@@ -10,14 +10,18 @@ interface BlobOptions {
      * is performed.
      */
     type?: string | undefined;
+    /**
+     * The size of the Blob object in bytes.
+     */
+    size?: number | null;
 }
 export declare class PonyfillBlob implements Blob {
     private blobParts;
     type: string;
     private encoding;
+    private _size;
     constructor(blobParts: BlobPart[], options?: BlobOptions);
-    buffer(): Promise<Buffer>;
-    arrayBuffer(): Promise<ArrayBuffer>;
+    arrayBuffer(): Promise<Buffer>;
     text(): Promise<string>;
     get size(): number;
     stream(): any;

package/typings/Blob.d.ts

@@ -10,14 +10,18 @@ interface BlobOptions {
      * is performed.
      */
     type?: string | undefined;
+    /**
+     * The size of the Blob object in bytes.
+     */
+    size?: number | null;
 }
 export declare class PonyfillBlob implements Blob {
     private blobParts;
     type: string;
     private encoding;
+    private _size;
     constructor(blobParts: BlobPart[], options?: BlobOptions);
-    buffer(): Promise<Buffer>;
-    arrayBuffer(): Promise<ArrayBuffer>;
+    arrayBuffer(): Promise<Buffer>;
     text(): Promise<string>;
     get size(): number;
     stream(): any;

package/typings/Body.d.cts

@@ -27,15 +27,15 @@ export declare class PonyfillBody<TJSON = any> implements Body {
     private bodyType?;
     private _bodyFactory;
     private _generatedBody;
+    private _buffer?;
     private generateBody;
     get body(): PonyfillReadableStream<Uint8Array> | null;
-    arrayBuffer(): Promise<ArrayBuffer>;
     _collectChunksFromReadable(): Promise<Uint8Array[]>;
     blob(): Promise<PonyfillBlob>;
     formData(opts?: {
         formDataLimits: FormDataLimits;
     }): Promise<PonyfillFormData>;
-    buffer(): Promise<Buffer>;
+    arrayBuffer(): Promise<Buffer>;
     json(): Promise<TJSON>;
     text(): Promise<string>;
 }

package/typings/Body.d.ts

@@ -27,15 +27,15 @@ export declare class PonyfillBody<TJSON = any> implements Body {
     private bodyType?;
     private _bodyFactory;
     private _generatedBody;
+    private _buffer?;
     private generateBody;
     get body(): PonyfillReadableStream<Uint8Array> | null;
-    arrayBuffer(): Promise<ArrayBuffer>;
     _collectChunksFromReadable(): Promise<Uint8Array[]>;
     blob(): Promise<PonyfillBlob>;
     formData(opts?: {
         formDataLimits: FormDataLimits;
     }): Promise<PonyfillFormData>;
-    buffer(): Promise<Buffer>;
+    arrayBuffer(): Promise<Buffer>;
     json(): Promise<TJSON>;
     text(): Promise<string>;
 }

package/typings/FormData.d.cts

@@ -2,12 +2,14 @@ import { PonyfillBlob } from './Blob.cjs';
 import { PonyfillReadableStream } from './ReadableStream.cjs';
 export declare class PonyfillFormData implements FormData {
     private map;
-    append(name: string, value: PonyfillBlob | string, fileName?: string): void;
+    append(name: string, value: string): void;
+    append(name: string, value: PonyfillBlob, fileName?: string): void;
     delete(name: string): void;
     get(name: string): FormDataEntryValue | null;
     getAll(name: string): FormDataEntryValue[];
     has(name: string): boolean;
-    set(name: string, value: PonyfillBlob | string, fileName?: string): void;
+    set(name: string, value: string): void;
+    set(name: string, value: PonyfillBlob, fileName?: string): void;
     [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
     entries(): IterableIterator<[string, FormDataEntryValue]>;
     keys(): IterableIterator<string>;

package/typings/FormData.d.ts

@@ -2,12 +2,14 @@ import { PonyfillBlob } from './Blob.js';
 import { PonyfillReadableStream } from './ReadableStream.js';
 export declare class PonyfillFormData implements FormData {
     private map;
-    append(name: string, value: PonyfillBlob | string, fileName?: string): void;
+    append(name: string, value: string): void;
+    append(name: string, value: PonyfillBlob, fileName?: string): void;
     delete(name: string): void;
     get(name: string): FormDataEntryValue | null;
     getAll(name: string): FormDataEntryValue[];
     has(name: string): boolean;
-    set(name: string, value: PonyfillBlob | string, fileName?: string): void;
+    set(name: string, value: string): void;
+    set(name: string, value: PonyfillBlob, fileName?: string): void;
     [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
     entries(): IterableIterator<[string, FormDataEntryValue]>;
     keys(): IterableIterator<string>;

package/typings/TextEncoderDecoder.d.cts

@@ -9,7 +9,7 @@ export declare class PonyfillTextDecoder implements TextDecoder {
     encoding: BufferEncoding;
     fatal: boolean;
     ignoreBOM: boolean;
-    constructor(encoding: BufferEncoding, options: TextDecoderOptions);
-    decode(input: Uint8Array): string;
+    constructor(encoding?: BufferEncoding, options?: TextDecoderOptions);
+    decode(input: BufferSource): string;
 }
 export declare function PonyfillBtoa(input: string): string;

package/typings/TextEncoderDecoder.d.ts

@@ -9,7 +9,7 @@ export declare class PonyfillTextDecoder implements TextDecoder {
     encoding: BufferEncoding;
     fatal: boolean;
     ignoreBOM: boolean;
-    constructor(encoding: BufferEncoding, options: TextDecoderOptions);
-    decode(input: Uint8Array): string;
+    constructor(encoding?: BufferEncoding, options?: TextDecoderOptions);
+    decode(input: BufferSource): string;
 }
 export declare function PonyfillBtoa(input: string): string;

package/typings/utils.d.cts

@@ -1,3 +1,7 @@
+/// <reference types="node" />
+import { Readable } from 'node:stream';
 export declare function getHeadersObj(headers: Headers): Record<string, string>;
-export declare function uint8ArrayToArrayBuffer(uint8array: Uint8Array): ArrayBuffer;
 export declare function defaultHeadersSerializer(headers: Headers, onContentLength?: (value: string) => void): string[];
+export declare function fakePromise<T>(value: T): Promise<T>;
+export declare function isArrayBufferView(obj: any): obj is ArrayBufferView;
+export declare function isNodeReadable(obj: any): obj is Readable;

package/typings/utils.d.ts

@@ -1,3 +1,7 @@
+/// <reference types="node" />
+import { Readable } from 'node:stream';
 export declare function getHeadersObj(headers: Headers): Record<string, string>;
-export declare function uint8ArrayToArrayBuffer(uint8array: Uint8Array): ArrayBuffer;
 export declare function defaultHeadersSerializer(headers: Headers, onContentLength?: (value: string) => void): string[];
+export declare function fakePromise<T>(value: T): Promise<T>;
+export declare function isArrayBufferView(obj: any): obj is ArrayBufferView;
+export declare function isNodeReadable(obj: any): obj is Readable;