@gjsify/fetch 0.0.4 → 0.1.1

package/README.md

@@ -1,9 +1,34 @@
 # @gjsify/fetch
 
-Web and Node.js >= 18 fetch module for Gjs
+GJS implementation of the Web Fetch API using Soup 3.0 and Gio. Provides fetch(), Request, Response, and Headers.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/fetch
+# or
+yarn add @gjsify/fetch
+```
+
+## Usage
+
+```typescript
+import { fetch, Request, Response, Headers } from '@gjsify/fetch';
+
+const response = await fetch('https://example.com');
+const text = await response.text();
+console.log(text);
+```
 
 ## Inspirations and credits
+
 - https://github.com/sonnyp/troll/blob/main/src/std/fetch.js
 - https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node-fetch
 - https://github.com/node-fetch/node-fetch
-- https://github.com/denoland/deno/tree/main/ext/fetch
+- https://github.com/denoland/deno/tree/main/ext/fetch
+
+## License
+
+MIT

package/globals.mjs

@@ -0,0 +1,12 @@
+/**
+ * Re-exports native Web API globals for use in Node.js builds.
+ *
+ * When tests import from the bare 'fetch' specifier, the build system
+ * aliases it to this module on Node.js (where fetch/Headers/Request/
+ * Response/FormData are native globals).
+ */
+export const Headers = globalThis.Headers;
+export const Request = globalThis.Request;
+export const Response = globalThis.Response;
+export const FormData = globalThis.FormData;
+export default globalThis.fetch;

package/lib/body.d.ts

@@ -0,0 +1,69 @@
+import { Blob } from './utils/blob-from.js';
+import { Readable, Writable } from 'node:stream';
+import { Buffer } from 'node:buffer';
+import { FormData } from '@gjsify/formdata';
+import { FetchBaseError } from './errors/base.js';
+import type { Request } from './request.js';
+import type { Response } from './response.js';
+declare const INTERNALS: unique symbol;
+/**
+ * Body mixin
+ *
+ * Ref: https://fetch.spec.whatwg.org/#body
+ *
+ * @param body Readable stream
+ * @param opts Response options
+ */
+export default class Body {
+    [INTERNALS]: {
+        body: null | Buffer | Readable | Blob;
+        stream: Readable | null;
+        boundary: string;
+        disturbed: boolean;
+        error: null | FetchBaseError;
+    };
+    size: number;
+    constructor(body: BodyInit | Readable | Blob | Buffer | null, options?: {
+        size?: number;
+        headers?: unknown;
+    });
+    get body(): ReadableStream<Uint8Array> | null;
+    get _stream(): Readable;
+    get bodyUsed(): boolean;
+    /**
+     * Decode response as ArrayBuffer
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    formData(): Promise<FormData>;
+    /**
+     * Return raw response as Blob
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Decode response as json
+     */
+    json(): Promise<unknown>;
+    /**
+     * Decode response as text
+     */
+    text(): Promise<string>;
+}
+/**
+ * Clone body given Res/Req instance
+ */
+export declare const clone: <T extends Request | Response>(instance: T, highWaterMark?: number) => Blob | Readable | Buffer<ArrayBufferLike>;
+/**
+ * Extract a Content-Type value from a body.
+ */
+export declare const extractContentType: (body: BodyInit | Readable | Blob | Buffer | null, request: Request | Response) => string | null;
+/**
+ * Get total bytes of a body.
+ */
+export declare const getTotalBytes: (request: Request) => number | null;
+/**
+ * Write a Body to a Node.js WritableStream.
+ */
+export declare const writeToStream: (dest: Writable, { body }: {
+    body: Readable | null;
+}) => Promise<void>;
+export {};

package/lib/body.js

@@ -0,0 +1,375 @@
+// 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
+import { URLSearchParams } from '@gjsify/url';
+import { Blob } from './utils/blob-from.js';
+import { PassThrough, pipeline as pipelineCb, Readable, Stream } from 'node:stream';
+import { Buffer } from 'node:buffer';
+import { FormData, formDataToBlob } from '@gjsify/formdata';
+import { FetchError } from './errors/fetch-error.js';
+import { FetchBaseError } from './errors/base.js';
+import { isBlob, isURLSearchParameters } from './utils/is.js';
+const pipeline = (source, dest) => new Promise((resolve, reject) => {
+    pipelineCb(source, dest, (err) => {
+        if (err)
+            reject(err);
+        else
+            resolve();
+    });
+});
+const INTERNALS = Symbol('Body internals');
+function isAnyArrayBuffer(val) {
+    return val instanceof ArrayBuffer ||
+        (typeof SharedArrayBuffer !== 'undefined' && val instanceof SharedArrayBuffer);
+}
+function isBoxedPrimitive(val) {
+    return (val instanceof String ||
+        val instanceof Number ||
+        val instanceof Boolean ||
+        (typeof Symbol !== 'undefined' && val instanceof Symbol) ||
+        (typeof BigInt !== 'undefined' && val instanceof BigInt));
+}
+/**
+ * Body mixin
+ *
+ * Ref: https://fetch.spec.whatwg.org/#body
+ *
+ * @param body Readable stream
+ * @param opts Response options
+ */
+export default class Body {
+    [INTERNALS] = {
+        body: null,
+        stream: null,
+        boundary: '',
+        disturbed: false,
+        error: null,
+    };
+    size = 0;
+    constructor(body, options = { size: 0 }) {
+        this.size = options.size || 0;
+        if (body === null || body === undefined) {
+            // Body is undefined or null
+            this[INTERNALS].body = null;
+        }
+        else if (isURLSearchParameters(body)) {
+            // Body is a URLSearchParams
+            this[INTERNALS].body = Buffer.from(body.toString());
+        }
+        else if (isBlob(body)) {
+            // Body is blob
+            this[INTERNALS].body = body;
+        }
+        else if (Buffer.isBuffer(body)) {
+            // Body is Buffer
+            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 Node.js stream
+            this[INTERNALS].body = body;
+        }
+        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
+            const blob = formDataToBlob(body);
+            this[INTERNALS].body = blob;
+            this[INTERNALS].boundary = blob.type?.split('boundary=')?.[1] ?? '';
+        }
+        else if (typeof body === 'string') {
+            // String body
+            this[INTERNALS].body = Buffer.from(body);
+        }
+        else if (body instanceof URLSearchParams) {
+            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 = Buffer.from(String(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));
+        }
+        else if (b instanceof Readable) {
+            this[INTERNALS].stream = b;
+        }
+        if (b instanceof Stream) {
+            b.on('error', (error_) => {
+                const error = error_ instanceof FetchBaseError
+                    ? error_
+                    : new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, 'system', error_);
+                this[INTERNALS].error = error;
+            });
+        }
+    }
+    get body() {
+        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({
+                start(controller) {
+                    stream.on('data', (chunk) => {
+                        controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+                    });
+                    stream.on('end', () => {
+                        controller.close();
+                    });
+                    stream.on('error', (err) => {
+                        controller.error(err);
+                    });
+                },
+                cancel() {
+                    stream.destroy();
+                }
+            });
+        }
+        return null;
+    }
+    get _stream() {
+        return this[INTERNALS].stream;
+    }
+    get bodyUsed() {
+        return this[INTERNALS].disturbed;
+    }
+    /**
+     * Decode response as ArrayBuffer
+     */
+    async arrayBuffer() {
+        const { buffer, byteOffset, byteLength } = await consumeBody(this);
+        return buffer.slice(byteOffset, byteOffset + byteLength);
+    }
+    async formData() {
+        const ct = this.headers?.get('content-type');
+        if (ct?.startsWith('application/x-www-form-urlencoded')) {
+            const formData = new FormData();
+            const parameters = new URLSearchParams(await this.text());
+            for (const [name, value] of parameters) {
+                formData.append(name, value);
+            }
+            return formData;
+        }
+        const { toFormData } = await import('./utils/multipart-parser.js');
+        return toFormData(this.body, ct);
+    }
+    /**
+     * Return raw response as Blob
+     */
+    async blob() {
+        const ct = (this.headers?.get('content-type')) || (this[INTERNALS].body && this[INTERNALS].body.type) || '';
+        const buf = await this.arrayBuffer();
+        return new Blob([buf], {
+            type: ct
+        });
+    }
+    /**
+     * Decode response as json
+     */
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+    /**
+     * Decode response as text
+     */
+    async text() {
+        const buffer = await consumeBody(this);
+        return new TextDecoder().decode(buffer);
+    }
+}
+// In browsers, all properties are enumerable.
+Object.defineProperties(Body.prototype, {
+    body: { enumerable: true },
+    bodyUsed: { enumerable: true },
+    arrayBuffer: { enumerable: true },
+    blob: { enumerable: true },
+    json: { enumerable: true },
+    text: { enumerable: true },
+});
+/**
+ * Consume and convert an entire Body to a Buffer.
+ */
+async function consumeBody(data) {
+    if (data[INTERNALS].disturbed) {
+        throw new TypeError(`body used already for: ${data.url}`);
+    }
+    data[INTERNALS].disturbed = true;
+    if (data[INTERNALS].error) {
+        throw data[INTERNALS].error;
+    }
+    const { _stream: body } = data;
+    // Body is null
+    if (body === null) {
+        return Buffer.alloc(0);
+    }
+    if (!(body instanceof Stream)) {
+        return Buffer.alloc(0);
+    }
+    // Body is stream — consume it
+    const accum = [];
+    let accumBytes = 0;
+    try {
+        for await (const chunk of body) {
+            if (data.size > 0 && accumBytes + chunk.length > data.size) {
+                const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, 'max-size');
+                body.destroy(error);
+                throw error;
+            }
+            accumBytes += chunk.length;
+            accum.push(chunk);
+        }
+    }
+    catch (error) {
+        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);
+        throw error_;
+    }
+    try {
+        if (accum.every(c => typeof c === 'string')) {
+            return Buffer.from(accum.join(''));
+        }
+        return Buffer.concat(accum, accumBytes);
+    }
+    catch (error) {
+        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);
+    }
+}
+/**
+ * Clone body given Res/Req instance
+ */
+export const clone = (instance, highWaterMark) => {
+    let p1;
+    let p2;
+    let { body } = instance[INTERNALS];
+    if (instance.bodyUsed) {
+        throw new Error('cannot clone body after it is used');
+    }
+    if ((body instanceof Stream) && (typeof body.getBoundary !== 'function')) {
+        p1 = new PassThrough({ highWaterMark });
+        p2 = new PassThrough({ highWaterMark });
+        body.pipe(p1);
+        body.pipe(p2);
+        instance[INTERNALS].stream = p1;
+        body = p2;
+    }
+    return body;
+};
+/**
+ * Extract a Content-Type value from a body.
+ */
+export const extractContentType = (body, request) => {
+    if (body === null) {
+        return null;
+    }
+    if (typeof body === 'string') {
+        return 'text/plain;charset=UTF-8';
+    }
+    if (isURLSearchParameters(body)) {
+        return 'application/x-www-form-urlencoded;charset=UTF-8';
+    }
+    if (isBlob(body)) {
+        return body.type || null;
+    }
+    if (Buffer.isBuffer(body) || isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+        return null;
+    }
+    if (body instanceof FormData) {
+        return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
+    }
+    if (body instanceof Stream) {
+        return null;
+    }
+    return 'text/plain;charset=UTF-8';
+};
+/**
+ * Get total bytes of a body.
+ */
+export const getTotalBytes = (request) => {
+    const { body } = request[INTERNALS];
+    if (body === null) {
+        return 0;
+    }
+    if (isBlob(body)) {
+        return body.size;
+    }
+    if (Buffer.isBuffer(body)) {
+        return body.length;
+    }
+    if (body && typeof body.getLengthSync === 'function') {
+        const streamBody = body;
+        return streamBody.hasKnownLength && streamBody.hasKnownLength() ? streamBody.getLengthSync() : null;
+    }
+    return null;
+};
+/**
+ * Write a Body to a Node.js WritableStream.
+ */
+export const writeToStream = async (dest, { body }) => {
+    if (body === null) {
+        dest.end();
+    }
+    else {
+        await pipeline(body, dest);
+    }
+};
+/**
+ * Convert a Web ReadableStream to a Node.js Readable.
+ */
+function readableStreamToReadable(webStream) {
+    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);
+            }
+        },
+        destroy(_err, callback) {
+            reader.cancel().then(() => callback(null), callback);
+        }
+    });
+}
+/**
+ * Convert a Blob to an async iterable for Readable.from().
+ */
+async function* blobToAsyncIterable(blob) {
+    if (typeof blob.stream === 'function') {
+        const reader = blob.stream().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/lib/errors/abort-error.d.ts

@@ -0,0 +1,7 @@
+import { FetchBaseError } from './base.js';
+/**
+ * AbortError interface for cancelled requests
+ */
+export declare class AbortError extends FetchBaseError {
+    constructor(message: string, type?: string);
+}

package/lib/errors/abort-error.js

@@ -0,0 +1,9 @@
+import { FetchBaseError } from './base.js';
+/**
+ * AbortError interface for cancelled requests
+ */
+export class AbortError extends FetchBaseError {
+    constructor(message, type = 'aborted') {
+        super(message, type);
+    }
+}

package/lib/errors/base.d.ts

@@ -0,0 +1,6 @@
+export declare class FetchBaseError extends Error {
+    type?: 'aborted' | string;
+    constructor(message: string, type?: string);
+    get name(): string;
+    get [Symbol.toStringTag](): string;
+}

package/lib/errors/base.js

@@ -0,0 +1,17 @@
+export class FetchBaseError extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        // Hide custom error implementation details from end-users
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        this.type = type;
+    }
+    get name() {
+        return this.constructor.name;
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+}

package/lib/errors/fetch-error.d.ts

@@ -0,0 +1,16 @@
+import { FetchBaseError } from './base.js';
+import type { SystemError } from '../types/index.js';
+/**
+ * FetchError interface for operational errors
+ */
+export declare class FetchError extends FetchBaseError {
+    code: string;
+    errno: string;
+    erroredSysCall: string;
+    /**
+     * @param message Error message for human
+     * @param type Error type for machine
+     * @param systemError For Node.js system error
+     */
+    constructor(message: string, type?: string, systemError?: SystemError);
+}

package/lib/errors/fetch-error.js

@@ -0,0 +1,23 @@
+import { FetchBaseError } from './base.js';
+/**
+ * FetchError interface for operational errors
+ */
+export class FetchError extends FetchBaseError {
+    code;
+    errno;
+    erroredSysCall;
+    /**
+     * @param message Error message for human
+     * @param type Error type for machine
+     * @param systemError For Node.js system error
+     */
+    constructor(message, type, systemError) {
+        super(message, type);
+        // When err.type is `system`, err.erroredSysCall contains system error and err.code contains system error code
+        if (systemError) {
+            // eslint-disable-next-line no-multi-assign
+            this.code = this.errno = systemError.code;
+            this.erroredSysCall = systemError.syscall;
+        }
+    }
+}