@gjsify/fetch 0.0.4 → 0.1.0

package/src/body.ts

@@ -1,19 +1,15 @@
+// SPDX-License-Identifier: MIT
+// Adapted from node-fetch (https://github.com/node-fetch/node-fetch/blob/main/src/body.js)
+// Copyright (c) node-fetch contributors. MIT license.
+// Modifications: Rewritten for GJS using libsoup 3.0 and @gjsify/url
 
-/**
- * Body.js
- *
- * Body interface provides common methods for Request and Response
- */
-
-import { URLSearchParams } from '@gjsify/deno-runtime/ext/url/00_url';
-import { Blob } from "@gjsify/deno-runtime/ext/web/09_file";
+import { URLSearchParams } from '@gjsify/url';
+import { Blob } from './utils/blob-from.js';
 
-import { PassThrough, pipeline as pipelineCb, Readable, Stream, Writable } from 'stream';
-import { ReadableStream as StreamWebReadableStream } from "stream/web";
-import { types, deprecate, promisify } from 'util';
-import { Buffer } from 'buffer';
+import { PassThrough, pipeline as pipelineCb, Readable, Stream, Writable } from 'node:stream';
+import { Buffer } from 'node:buffer';
 
-import { FormData, formDataToBlob } from 'formdata-polyfill/esm.min.js';
+import { FormData, formDataToBlob } from '@gjsify/formdata';
 
 import { FetchError } from './errors/fetch-error.js';
 import { FetchBaseError } from './errors/base.js';
@@ -21,10 +17,33 @@ import { isBlob, isURLSearchParameters } from './utils/is.js';
 
 import type { Request } from './request.js';
 import type { Response } from './response.js';
+import type { SystemError } from './types/index.js';
+
+const pipeline = (source: Readable, dest: Writable): Promise<void> =>
+    new Promise((resolve, reject) => {
+        pipelineCb(source, dest, (err) => {
+            if (err) reject(err);
+            else resolve();
+        });
+    });
 
-const pipeline = promisify(pipelineCb);
 const INTERNALS = Symbol('Body internals');
- 
+
+function isAnyArrayBuffer(val: unknown): val is ArrayBuffer {
+    return val instanceof ArrayBuffer ||
+        (typeof SharedArrayBuffer !== 'undefined' && val instanceof SharedArrayBuffer);
+}
+
+function isBoxedPrimitive(val: unknown): boolean {
+    return (
+        val instanceof String ||
+        val instanceof Number ||
+        val instanceof Boolean ||
+        (typeof Symbol !== 'undefined' && val instanceof Symbol) ||
+        (typeof BigInt !== 'undefined' && val instanceof (BigInt as unknown as typeof Number))
+    );
+}
+
  /**
   * Body mixin
   *
@@ -33,7 +52,7 @@ const INTERNALS = Symbol('Body internals');
   * @param body Readable stream
   * @param opts Response options
   */
-export default class Body implements globalThis.Body {
+export default class Body {
 
     [INTERNALS]: {
         body: null | Buffer | Readable | Blob;
@@ -51,9 +70,9 @@ export default class Body implements globalThis.Body {
 
     size = 0;
 
-    constructor(body: BodyInit | Readable | Blob | Buffer, options: ResponseInit & { size?: number } = { size: 0 }) {
+    constructor(body: BodyInit | Readable | Blob | Buffer | null, options: { size?: number; headers?: unknown } = { size: 0 }) {
         this.size = options.size || 0;
-        if (body === null) {
+        if (body === null || body === undefined) {
             // Body is undefined or null
             this[INTERNALS].body = null;
         } else if (isURLSearchParameters(body)) {
@@ -61,61 +80,82 @@ export default class Body implements globalThis.Body {
             this[INTERNALS].body = Buffer.from(body.toString())
         } else if (isBlob(body)) {
             // Body is blob
+            this[INTERNALS].body = body as Blob;
         } else if (Buffer.isBuffer(body)) {
             // Body is Buffer
-        } else if (types.isAnyArrayBuffer(body)) {
+            this[INTERNALS].body = body;
+        } else if (isAnyArrayBuffer(body)) {
             // Body is ArrayBuffer
             this[INTERNALS].body = Buffer.from(body);
         } else if (ArrayBuffer.isView(body)) {
             // Body is ArrayBufferView
             this[INTERNALS].body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
         } else if (body instanceof Readable) {
-            // Body is stream
+            // Body is Node.js stream
             this[INTERNALS].body = body;
-        } else if (body instanceof ReadableStream || body instanceof StreamWebReadableStream) {
-            // Body is web stream
-            this[INTERNALS].body = Readable.fromWeb(body as StreamWebReadableStream); // TODO check compatibility between ReadableStream (from lib.dom.d.ts) and StreamWebReadableStream (from stream/web)
+        } else if (typeof ReadableStream !== 'undefined' && body instanceof ReadableStream) {
+            // Body is Web ReadableStream — convert to Node.js Readable
+            this[INTERNALS].body = readableStreamToReadable(body);
         } else if (body instanceof FormData) {
             // Body is FormData
-            this[INTERNALS].body = formDataToBlob(body) as Blob & globalThis.Blob;
-            this[INTERNALS].boundary = this[INTERNALS].body.type.split('=')[1];
+            const blob = formDataToBlob(body) as Blob & globalThis.Blob;
+            this[INTERNALS].body = blob;
+            this[INTERNALS].boundary = blob.type?.split('boundary=')?.[1] ?? '';
         } else if (typeof body === 'string'){
-            // None of the above
-            // coerce to string then buffer
+            // String body
             this[INTERNALS].body = Buffer.from(body);
         } else if (body instanceof URLSearchParams){
-            // None of the above
-            // coerce to string then buffer
             this[INTERNALS].body = Buffer.from(body.toString());
         } else {
             console.warn(`Unknown body type "${typeof body}", try to parse the body to string!`);
-            this[INTERNALS].body = Readable.from(typeof (body as any).toString === 'function' ? (body as any).toString() : body as any); // TODO
+            this[INTERNALS].body = Buffer.from(String(body));
         }
 
-        // ´this[INTERNALS].stream = body;
-
-        if (Buffer.isBuffer(body)) {
-            this[INTERNALS].stream = Readable.from(body);
-        } else if (isBlob(body)) {
-            // @ts-ignore
-            this[INTERNALS].stream = Readable.from(body.stream());
-        } else if (body instanceof Readable) {
-            this[INTERNALS].stream = body;
+        // Set up the internal stream
+        const b = this[INTERNALS].body;
+        if (Buffer.isBuffer(b)) {
+            this[INTERNALS].stream = Readable.from(b);
+        } else if (isBlob(b)) {
+            this[INTERNALS].stream = Readable.from(blobToAsyncIterable(b as Blob));
+        } else if (b instanceof Readable) {
+            this[INTERNALS].stream = b;
         }
 
-        if (body instanceof Stream) {
-            body.on('error', error_ => {
-                const error = error_ instanceof FetchBaseError ?
-                    error_ :
-                    new FetchError(`Invalid response body while trying to fetch ${(this as any).url}: ${error_.message}`, 'system', error_ as any);
+        if (b instanceof Stream) {
+            b.on('error', (error_: Error) => {
+                const error = error_ instanceof FetchBaseError
+                    ? error_
+                    : new FetchError(`Invalid response body while trying to fetch ${(this as unknown as Request).url}: ${error_.message}`, 'system', error_ as unknown as SystemError);
                 this[INTERNALS].error = error;
             });
         }
     }
 
-    get body(): ReadableStream<Uint8Array> {
-        // @ts-ignore
-        return Readable.toWeb(this[INTERNALS].stream);
+    get body(): ReadableStream<Uint8Array> | null {
+        const stream = this[INTERNALS].stream;
+        if (!stream) return null;
+
+        // If ReadableStream is available, wrap the Readable into one
+        if (typeof ReadableStream !== 'undefined') {
+            return new ReadableStream<Uint8Array>({
+                start(controller) {
+                    stream.on('data', (chunk: Buffer | Uint8Array) => {
+                        controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+                    });
+                    stream.on('end', () => {
+                        controller.close();
+                    });
+                    stream.on('error', (err: Error) => {
+                        controller.error(err);
+                    });
+                },
+                cancel() {
+                    stream.destroy();
+                }
+            });
+        }
+
+        return null;
     }
 
     get _stream() {
@@ -128,18 +168,16 @@ export default class Body implements globalThis.Body {
 
     /**
      * Decode response as ArrayBuffer
-     *
-     * @return  Promise
      */
-    async arrayBuffer() {
+    async arrayBuffer(): Promise<ArrayBuffer> {
         const {buffer, byteOffset, byteLength} = await consumeBody(this);
-        return buffer.slice(byteOffset, byteOffset + byteLength);
+        return buffer.slice(byteOffset, byteOffset + byteLength) as ArrayBuffer;
     }
 
-    async formData() {
+    async formData(): Promise<FormData> {
         const ct = (this as unknown as Request).headers?.get('content-type');
 
-        if (ct.startsWith('application/x-www-form-urlencoded')) {
+        if (ct?.startsWith('application/x-www-form-urlencoded')) {
             const formData = new FormData();
             const parameters = new URLSearchParams(await this.text());
 
@@ -156,11 +194,8 @@ export default class Body implements globalThis.Body {
 
     /**
      * Return raw response as Blob
-     *
-     * @return Promise
      */
-    // @ts-ignore
-    async blob() {
+    async blob(): Promise<Blob> {
         const ct = ((this as unknown as Request).headers?.get('content-type')) || (this[INTERNALS].body && (this[INTERNALS].body as Blob).type) || '';
         const buf = await this.arrayBuffer();
 
@@ -171,25 +206,21 @@ export default class Body implements globalThis.Body {
 
     /**
      * Decode response as json
-     *
-     * @return  Promise
      */
-    async json() {
+    async json(): Promise<unknown> {
         const text = await this.text();
         return JSON.parse(text);
     }
 
     /**
      * Decode response as text
-     *
-     * @return  Promise
      */
-    async text() {
+    async text(): Promise<string> {
         const buffer = await consumeBody(this);
         return new TextDecoder().decode(buffer);
     }
 }
-  
+
 // In browsers, all properties are enumerable.
 Object.defineProperties(Body.prototype, {
     body: {enumerable: true},
@@ -198,19 +229,12 @@ Object.defineProperties(Body.prototype, {
     blob: {enumerable: true},
     json: {enumerable: true},
     text: {enumerable: true},
-    data: {get: deprecate(() => {},
-        'data doesn\'t exist, use json(), text(), arrayBuffer(), or body instead',
-        'https://github.com/node-fetch/node-fetch/issues/1000 (response)')}
- });
- 
- /**
-  * Consume and convert an entire Body to a Buffer.
-  *
-  * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
-  *
-  * @return Promise
-  */
-async function consumeBody(data: Body & Partial<Request>) {
+});
+
+/**
+ * Consume and convert an entire Body to a Buffer.
+ */
+async function consumeBody(data: Body & { url?: string }): Promise<Buffer> {
     if (data[INTERNALS].disturbed) {
         throw new TypeError(`body used already for: ${data.url}`);
     }
@@ -228,14 +252,12 @@ async function consumeBody(data: Body & Partial<Request>) {
         return Buffer.alloc(0);
     }
 
-    /* c8 ignore next 3 */
     if (!(body instanceof Stream)) {
         return Buffer.alloc(0);
     }
 
-    // Body is stream
-    // get ready to actually consume the body
-    const accum = [];
+    // Body is stream — consume it
+    const accum: (Buffer | Uint8Array)[] = [];
     let accumBytes = 0;
 
     try {
@@ -249,97 +271,69 @@ async function consumeBody(data: Body & Partial<Request>) {
             accumBytes += chunk.length;
             accum.push(chunk);
         }
-    } catch (error) {
-        const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, 'system', error);
+    } catch (error: unknown) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${err.message}`, 'system', err as unknown as SystemError);
         throw error_;
     }
 
-    if (body.readableEnded === true || (body as any)._readableState.ended === true) {
-        try {
-            if (accum.every(c => typeof c === 'string')) {
-                return Buffer.from(accum.join(''));
-            }
-
-            return Buffer.concat(accum, accumBytes);
-        } catch (error) {
-            throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, 'system', error);
+    try {
+        if (accum.every(c => typeof c === 'string')) {
+            return Buffer.from((accum as unknown as string[]).join(''));
         }
-    } else {
-        throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
+
+        return Buffer.concat(accum as Buffer[], accumBytes);
+    } catch (error: unknown) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${err.message}`, 'system', err as unknown as SystemError);
     }
 }
- 
- /**
-  * Clone body given Res/Req instance
-  *
-  * @param Mixed instance       Response or Request instance
-  * @param highWaterMark highWaterMark for both PassThrough body streams
-  * @return Mixed
-  */
+
+/**
+ * Clone body given Res/Req instance
+ */
 export const clone = <T extends Request | Response>(instance: T, highWaterMark?: number) => {
     let p1: PassThrough;
     let p2: PassThrough;
     let {body} = instance[INTERNALS];
 
-    // Don't allow cloning a used body
     if (instance.bodyUsed) {
         throw new Error('cannot clone body after it is used');
     }
 
-    // Check that body is a stream and not form-data object
-    // note: we can't clone the form-data object without having it as a dependency
-    if ((body instanceof Stream) && (typeof (body as any).getBoundary !== 'function')) {
-        // Tee instance body
+    if ((body instanceof Stream) && (typeof (body as unknown as Record<string, unknown>).getBoundary !== 'function')) {
         p1 = new PassThrough({highWaterMark});
         p2 = new PassThrough({highWaterMark});
         body.pipe(p1);
         body.pipe(p2);
-        // Set instance body to teed body and return the other teed body
         instance[INTERNALS].stream = p1;
         body = p2;
     }
- 
+
     return body;
- };
- 
-// const getNonSpecFormDataBoundary = deprecate(
-//     (body) => body.getBoundary(),
-//     'form-data doesn\'t follow the spec and requires special treatment. Use alternative package',
-//     'https://github.com/node-fetch/node-fetch/issues/1167'
-// );
- 
- /**
-  * Performs the operation "extract a `Content-Type` value from |object|" as
-  * specified in the specification:
-  * https://fetch.spec.whatwg.org/#concept-bodyinit-extract
-  *
-  * This function assumes that instance.body is present.
-  *
-  * @param body Any options.body input
-  */
-export const extractContentType = (body: BodyInit | string | ArrayBuffer | Readable | Blob | ArrayBufferView | Buffer | FormData | globalThis.ReadableStream<any> | null, request: Request | Response): string | null => {
-    // Body is null or undefined
+};
+
+/**
+ * Extract a Content-Type value from a body.
+ */
+export const extractContentType = (body: BodyInit | Readable | Blob | Buffer | null, request: Request | Response): string | null => {
     if (body === null) {
         return null;
     }
 
-    // Body is string
     if (typeof body === 'string') {
         return 'text/plain;charset=UTF-8';
     }
 
-    // Body is a URLSearchParams
     if (isURLSearchParameters(body)) {
         return 'application/x-www-form-urlencoded;charset=UTF-8';
     }
 
-    // Body is blob
     if (isBlob(body)) {
         return (body as Blob & globalThis.Blob).type || null;
     }
 
-    // Body is a Buffer (Buffer, ArrayBuffer or ArrayBufferView)
-    if (Buffer.isBuffer(body) || types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+    if (Buffer.isBuffer(body) || isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
         return null;
     }
 
@@ -347,69 +341,87 @@ export const extractContentType = (body: BodyInit | string | ArrayBuffer | Reada
         return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
     }
 
-    // Detect form data input from form-data module
-    // if (body && typeof body.getBoundary === 'function') {
-    //     return `multipart/form-data;boundary=${getNonSpecFormDataBoundary(body)}`;
-    // }
-
-    // Body is stream - can't really do much about this
     if (body instanceof Stream) {
         return null;
     }
 
-    // Body constructor defaults other things to string
     return 'text/plain;charset=UTF-8';
 };
- 
- /**
-  * The Fetch Standard treats this as if "total bytes" is a property on the body.
-  * For us, we have to explicitly get it with a function.
-  *
-  * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
-  *
-  * @param request Request object with the body property.
-  */
+
+/**
+ * Get total bytes of a body.
+ */
 export const getTotalBytes = (request: Request): number | null => {
     const { body } = request[INTERNALS];
 
-    // Body is null or undefined
     if (body === null) {
         return 0;
     }
 
-    // Body is Blob
     if (isBlob(body)) {
         return (body as Blob).size;
     }
 
-    // Body is Buffer
     if (Buffer.isBuffer(body)) {
         return body.length;
     }
 
-    // Detect form data input from form-data module
-    if (body && typeof (body as any).getLengthSync === 'function') {
-        const anyBody = body as any;
-        return anyBody.hasKnownLength && anyBody.hasKnownLength() ? anyBody.getLengthSync() : null;
+    if (body && typeof (body as unknown as Record<string, unknown>).getLengthSync === 'function') {
+        const streamBody = body as unknown as { getLengthSync(): number; hasKnownLength?(): boolean };
+        return streamBody.hasKnownLength && streamBody.hasKnownLength() ? streamBody.getLengthSync() : null;
     }
 
-    // Body is stream
     return null;
 };
- 
- /**
-  * Write a Body to a Node.js WritableStream (e.g. http.Request) object.
-  *
-  * @param dest The stream to write to.
-  * @param obj.body Body object from the Body instance.
-  */
- export const writeToStream = async (dest: Writable, {body}): Promise<void> => {
+
+/**
+ * Write a Body to a Node.js WritableStream.
+ */
+export const writeToStream = async (dest: Writable, {body}: {body: Readable | null}): Promise<void> => {
     if (body === null) {
-        // Body is null
         dest.end();
     } else {
-        // Body is stream
         await pipeline(body, dest);
     }
- };
- 
+};
+
+/**
+ * Convert a Web ReadableStream to a Node.js Readable.
+ */
+function readableStreamToReadable(webStream: ReadableStream): Readable {
+    const reader = webStream.getReader();
+    return new Readable({
+        async read() {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    this.push(null);
+                } else {
+                    this.push(Buffer.from(value));
+                }
+            } catch (err) {
+                this.destroy(err as Error);
+            }
+        },
+        destroy(_err, callback) {
+            reader.cancel().then(() => callback(null), callback);
+        }
+    });
+}
+
+/**
+ * Convert a Blob to an async iterable for Readable.from().
+ */
+async function* blobToAsyncIterable(blob: Blob): AsyncIterable<Uint8Array> {
+    if (typeof blob.stream === 'function') {
+        const reader = (blob.stream() as unknown as ReadableStream).getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            yield value;
+        }
+    } else {
+        // Fallback: read the entire blob at once
+        yield new Uint8Array(await blob.arrayBuffer());
+    }
+}

package/src/errors/base.ts

@@ -5,7 +5,9 @@ export class FetchBaseError extends Error {
 	constructor(message: string, type?: string) {
 		super(message);
 		// Hide custom error implementation details from end-users
-		Error.captureStackTrace(this, this.constructor);
+		if (typeof Error.captureStackTrace === 'function') {
+			Error.captureStackTrace(this, this.constructor);
+		}
 
 		this.type = type;
 	}