@gjsify/fetch 0.0.3 → 0.1.0

package/src/request.ts

@@ -1,38 +1,58 @@
-import '@girs/gjs';
-import '@girs/gio-2.0';
+// SPDX-License-Identifier: MIT
+// Adapted from node-fetch (https://github.com/node-fetch/node-fetch/blob/main/src/request.js)
+// Copyright (c) node-fetch contributors. MIT license.
+// Modifications: Rewritten for GJS using Soup.Message and Gio
 
 import GLib from '@girs/glib-2.0';
 import Soup from '@girs/soup-3.0';
 import Gio from '@girs/gio-2.0';
-import * as GioExt from '@gjsify/gio-2.0';
-import * as SoupExt from '@gjsify/soup-3.0';
+import { soupSendAsync, inputStreamToReadable } from './utils/soup-helpers.js';
 
-import { URL } from '@gjsify/deno-runtime/ext/url/00_url';
-import { Blob } from '@gjsify/deno-runtime/ext/web/09_file';
+import { URL } from '@gjsify/url';
+import { Blob } from './utils/blob-from.js';
 
-import { Readable } from 'stream';
+import { Readable } from 'node:stream';
 
 import Headers from './headers.js';
 import Body, {clone, extractContentType, getTotalBytes} from './body.js';
 import {isAbortSignal} from './utils/is.js';
-// import { getSearch } from './utils/get-search.js';
+import type { FormData } from '@gjsify/formdata';
 import {
 	validateReferrerPolicy, determineRequestsReferrer, DEFAULT_REFERRER_POLICY
 } from './utils/referrer.js';
 
 const INTERNALS = Symbol('Request internals');
 
+/** Properties that may exist on a Request-like object (used for safe casting). */
+interface RequestLike {
+  url?: string;
+  method?: string;
+  headers?: Headers | HeadersInit;
+  redirect?: RequestRedirect;
+  signal?: AbortSignal | null;
+  referrer?: string;
+  referrerPolicy?: ReferrerPolicy;
+  body?: BodyInit | null;
+  follow?: number;
+  compress?: boolean;
+  counter?: number;
+  agent?: string | ((url: URL) => string);
+  highWaterMark?: number;
+  insecureHTTPParser?: boolean;
+  size?: number;
+}
+
 /**
  * Check if `obj` is an instance of Request.
  */
- const isRequest = (obj: RequestInfo | URL) => {
+ const isRequest = (obj: RequestInfo | URL | Request): boolean => {
 	return (
 		typeof obj === 'object' &&
-		typeof (obj as Request).url === 'string'
+		typeof (obj as RequestLike).url === 'string'
 	);
 };
 
-// @ts-ignore
+// @ts-expect-error — declaration merging with globalThis.Request for Fetch API compatibility
 export interface Request extends globalThis.Request {}
 
 /** This Fetch API interface represents a resource request. */
@@ -128,9 +148,9 @@ export class Request extends Body {
     referrer: string | URL;
     referrerPolicy: ReferrerPolicy;
     // Gjsify
-    session: SoupExt.ExtSession & Soup.Session;
-    message: Soup.Message;
-    inputStream?: Gio.InputStream & GioExt.ExtInputStream<Gio.InputStream>;
+    session: Soup.Session | null;
+    message: Soup.Message | null;
+    inputStream?: Gio.InputStream;
     readable?: Readable
   };
 
@@ -142,13 +162,16 @@ export class Request extends Body {
   highWaterMark = 16384;
   insecureHTTPParser = false;
 
-  constructor(input: RequestInfo | URL, init?: RequestInit) {
+  constructor(input: RequestInfo | URL | Request, init?: RequestInit) {
+    const inputRL = input as unknown as RequestLike;
+    const initRL = (init || {}) as unknown as RequestLike;
+
     let parsedURL: URL;
-    let requestObj: Partial<Request> = {};
+    let requestObj: RequestLike = {};
 
     if(isRequest(input)) {
-      parsedURL = new URL((input as Request).url);
-      requestObj = input as Request;
+      parsedURL = new URL(inputRL.url);
+      requestObj = inputRL;
     } else {
       parsedURL = new URL(input as string | URL);
     }
@@ -157,23 +180,23 @@ export class Request extends Body {
       throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
     }
 
-    let method = init.method || requestObj.method || 'GET';
+    let method = initRL.method || requestObj.method || 'GET';
     if (/^(delete|get|head|options|post|put)$/i.test(method)) {
       method = method.toUpperCase();
     }
 
-    if ((init.body != null || (isRequest(input) && (input as Request).body !== null)) &&
+    if ((init?.body != null || (isRequest(input) && inputRL.body !== null)) &&
       (method === 'GET' || method === 'HEAD')) {
       throw new TypeError('Request with GET/HEAD method cannot have body');
     }
 
-    const inputBody = init.body ? init.body : (isRequest(input) && (input as Request).body !== null ? clone(input as Request & Body) : null);
+    const inputBody = init?.body ? init.body : (isRequest(input) && inputRL.body !== null ? clone(input as unknown as Request & Body) : null);
 
     super(inputBody, {
-      size: (init as Request).size || (init as any).size || 0
+      size: initRL.size || 0
     });
 
-    const headers = new Headers((init.headers || (input as Request).headers || {}) as HeadersInit);
+    const headers = new Headers((init?.headers || inputRL.headers || {}) as HeadersInit);
 
     if (inputBody !== null && !headers.has('Content-Type')) {
       const contentType = extractContentType(inputBody, this);
@@ -183,9 +206,9 @@ export class Request extends Body {
     }
 
     let signal = isRequest(input) ?
-      (input as Request).signal :
+      inputRL.signal :
       null;
-    if ('signal' in init) {
+    if (init && 'signal' in init) {
       signal = init.signal;
     }
 
@@ -194,7 +217,7 @@ export class Request extends Body {
     }
 
     // §5.4, Request constructor steps, step 15.1
-    let referrer: string | URL = init.referrer == null ? (input as Request).referrer : init.referrer;
+    let referrer: string | URL = init?.referrer == null ? inputRL.referrer : init.referrer;
     if (referrer === '') {
       // §5.4, Request constructor steps, step 15.2
       referrer = 'no-referrer';
@@ -207,15 +230,21 @@ export class Request extends Body {
       referrer = undefined;
     }
 
-    const session = SoupExt.ExtSession.new();
-    const message = new Soup.Message({
-      method,
-      uri: this._uri,
-    });
+    // Only create Soup objects for HTTP/HTTPS — data: URIs etc. don't go through Soup
+    const scheme = parsedURL.protocol;
+    let session: Soup.Session | null = null;
+    let message: Soup.Message | null = null;
+    if (scheme === 'http:' || scheme === 'https:') {
+      session = new Soup.Session();
+      message = new Soup.Message({
+        method,
+        uri: GLib.Uri.parse(parsedURL.toString(), GLib.UriFlags.NONE),
+      });
+    }
 
     this[INTERNALS] = {
       method,
-      redirect: init.redirect || (input as Request).redirect || 'follow',
+      redirect: init?.redirect || inputRL.redirect || 'follow',
       headers,
       parsedURL,
       signal,
@@ -226,32 +255,35 @@ export class Request extends Body {
     };
 
     // Node-fetch-only options
-    this.follow = (init as Request).follow === undefined ? ((input as Request).follow === undefined ? 20 : (input as Request).follow) : (init as Request).follow;
-    this.compress = (init as Request).compress === undefined ? ((input as Request).compress === undefined ? true : (input as Request).compress) : (init as Request).compress;
-    this.counter = (init as Request).counter || (input as Request).counter || 0;
-    this.agent = (init as Request).agent || (input as Request).agent;
-    this.highWaterMark = (init as Request).highWaterMark || (input as Request).highWaterMark || 16384;
-    this.insecureHTTPParser = (init as Request).insecureHTTPParser || (input as Request).insecureHTTPParser || false;
+    this.follow = initRL.follow === undefined ? (inputRL.follow === undefined ? 20 : inputRL.follow) : initRL.follow;
+    this.compress = initRL.compress === undefined ? (inputRL.compress === undefined ? true : inputRL.compress) : initRL.compress;
+    this.counter = initRL.counter || inputRL.counter || 0;
+    this.agent = initRL.agent || inputRL.agent;
+    this.highWaterMark = initRL.highWaterMark || inputRL.highWaterMark || 16384;
+    this.insecureHTTPParser = initRL.insecureHTTPParser || inputRL.insecureHTTPParser || false;
 
     // §5.4, Request constructor steps, step 16.
     // Default is empty string per https://fetch.spec.whatwg.org/#concept-request-referrer-policy
-    this.referrerPolicy = init.referrerPolicy || (input as Request).referrerPolicy || '';
+    this.referrerPolicy = init?.referrerPolicy || inputRL.referrerPolicy || '';
   }
 
   /**
-   * Custom send method using Soup, used in fetch to send the request
-   * @param options 
-   * @returns 
+   * Send the request using Soup.
    */
   async _send(options: { headers: Headers }) {
-    options.headers._appendToSoupMessage(this._message);
+    const { session, message } = this[INTERNALS];
+
+    if (!session || !message) {
+      throw new Error('Cannot send request: no Soup session (non-HTTP URL?)');
+    }
+
+    options.headers._appendToSoupMessage(message);
 
     const cancellable = new Gio.Cancellable();
 
-    this[INTERNALS].inputStream = await this._session.sendAsync(this._message, GLib.PRIORITY_DEFAULT, cancellable);
+    this[INTERNALS].inputStream = await soupSendAsync(session, message, GLib.PRIORITY_DEFAULT, cancellable);
+    this[INTERNALS].readable = inputStreamToReadable(this[INTERNALS].inputStream);
 
-    this[INTERNALS].readable = this[INTERNALS].inputStream.toReadable({});
-    
     return {
       inputStream: this[INTERNALS].inputStream,
       readable: this[INTERNALS].readable,
@@ -263,7 +295,6 @@ export class Request extends Body {
    * Clone this request
    */
   clone(): Request {
-    // @ts-ignores
     return new Request(this);
   }
 
@@ -276,7 +307,7 @@ export class Request extends Body {
   async formData(): Promise<FormData> {
     return super.formData();
   }
-  async json(): Promise<any> {
+  async json(): Promise<unknown> {
     return super.json();
   }
   async text(): Promise<string> {
@@ -298,10 +329,7 @@ Object.defineProperties(Request.prototype, {
 export default Request;
 
 /**
- * Convert a Request to Soup request options.
- *
- * @param request - A Request instance
- * @return The options object to be passed to http.request
+ * @param request
  */
 export const getSoupRequestOptions = (request: Request) => {
 	const { parsedURL } = request[INTERNALS];
@@ -313,14 +341,14 @@ export const getSoupRequestOptions = (request: Request) => {
 	}
 
 	// HTTP-network-or-cache fetch steps 2.4-2.7
-	let contentLengthValue = null;
+	let contentLengthValue: string | null = null;
 	if (request.body === null && /^(post|put)$/i.test(request.method)) {
 		contentLengthValue = '0';
 	}
 
 	if (request.body !== null) {
 		const totalBytes = getTotalBytes(request);
-		// Set Content-Length if totalBytes is a number (that is not NaN)
+		// Set Content-Length if totalBytes is a Number (that is not NaN)
 		if (typeof totalBytes === 'number' && !Number.isNaN(totalBytes)) {
 			contentLengthValue = String(totalBytes);
 		}
@@ -331,15 +359,11 @@ export const getSoupRequestOptions = (request: Request) => {
 	}
 
 	// 4.1. Main fetch, step 2.6
-	// > If request's referrer policy is the empty string, then set request's referrer policy to the
-	// > default referrer policy.
 	if (request.referrerPolicy === '') {
 		request.referrerPolicy = DEFAULT_REFERRER_POLICY;
 	}
 
 	// 4.1. Main fetch, step 2.7
-	// > If request's referrer is not "no-referrer", set request's referrer to the result of invoking
-	// > determine request's referrer.
 	if (request.referrer && request.referrer !== 'no-referrer') {
 		request[INTERNALS].referrer = determineRequestsReferrer(request);
 	} else {
@@ -347,15 +371,13 @@ export const getSoupRequestOptions = (request: Request) => {
 	}
 
 	// 4.5. HTTP-network-or-cache fetch, step 6.9
-	// > If httpRequest's referrer is a URL, then append `Referer`/httpRequest's referrer, serialized
-	// >  and isomorphic encoded, to httpRequest's header list.
 	if (request[INTERNALS].referrer instanceof URL) {
 		headers.set('Referer', request.referrer);
 	}
 
 	// HTTP-network-or-cache fetch step 2.11
 	if (!headers.has('User-Agent')) {
-		headers.set('User-Agent', 'node-fetch');
+		headers.set('User-Agent', 'gjsify-fetch');
 	}
 
 	// HTTP-network-or-cache fetch step 2.15
@@ -372,25 +394,12 @@ export const getSoupRequestOptions = (request: Request) => {
 		headers.set('Connection', 'close');
 	}
 
-	// HTTP-network fetch step 4.2
-	// chunked encoding is handled by Node.js
-
-	// const search = getSearch(parsedURL);
-
-	// Pass the full URL directly to request(), but overwrite the following
-	// options:
 	const options = {
-		// Overwrite search to retain trailing ? (issue #776)
-		// path: parsedURL.pathname + search,
-		// The following options are not expressed in the URL
-		// method: request.method,
 		headers,
-		// insecureHTTPParser: request.insecureHTTPParser,
-		// agent
 	};
 
 	return {
 		parsedURL,
 		options
 	};
-};
+};

package/src/response.ts

@@ -1,8 +1,7 @@
-/**
- * Response.js
- *
- * Response class provides content decoding
- */
+// SPDX-License-Identifier: MIT
+// Adapted from node-fetch (https://github.com/node-fetch/node-fetch/blob/main/src/response.js)
+// Copyright (c) node-fetch contributors. MIT license.
+// Modifications: Rewritten for GJS using Gio streams and GLib
 
 import GLib from '@girs/glib-2.0';
 import Gio from '@girs/gio-2.0';
@@ -11,14 +10,30 @@ import Headers from './headers.js';
 import Body, { clone, extractContentType } from './body.js';
 import { isRedirect } from './utils/is-redirect.js';
 
-import { URL } from '@gjsify/deno-runtime/ext/url/00_url';
-import { Blob } from '@gjsify/deno-runtime/ext/web/09_file';
+import { URL } from '@gjsify/url';
+import { Blob } from './utils/blob-from.js';
 
-import type { Readable } from 'stream';
+import type { Readable } from 'node:stream';
 
 const INTERNALS = Symbol('Response internals');
 
-interface ResponseInit extends globalThis.ResponseInit {
+interface ResponseOptions {
+    status?: number;
+    statusText?: string;
+    headers?: HeadersInit | Headers;
+    url?: string;
+    type?: ResponseType;
+    ok?: boolean;
+    redirected?: boolean;
+    size?: number;
+    counter?: number;
+    highWaterMark?: number;
+}
+
+interface ResponseInit {
+    status?: number;
+    statusText?: string;
+    headers?: HeadersInit | Headers;
     type?: ResponseType;
     url?: string;
     counter?: number;
@@ -36,7 +51,7 @@ interface ResponseInit extends globalThis.ResponseInit {
  * @param body Readable stream
  * @param opts Response options
  */
-export class Response extends Body implements globalThis.Response {
+export class Response extends Body {
 
     [INTERNALS]: {
         type: ResponseType;
@@ -50,7 +65,7 @@ export class Response extends Body implements globalThis.Response {
 
     _inputStream: Gio.InputStream | null = null;
 
-    constructor(body: BodyInit | Readable | Blob | Buffer | null = null, options: ResponseInit = {}) {
+    constructor(body: BodyInit | Readable | Blob | Buffer | null = null, options: ResponseOptions = {}) {
         super(body, options);
 
         // eslint-disable-next-line no-eq-null, eqeqeq, no-negated-condition
@@ -116,7 +131,6 @@ export class Response extends Body implements globalThis.Response {
      *
      * @return  Response
      */
-    // @ts-ignore
     clone() {
         return new Response(clone(this, this.highWaterMark), {
             type: this.type,
@@ -155,6 +169,23 @@ export class Response extends Body implements globalThis.Response {
         return response;
     }
 
+    /**
+     * Create a Response with a JSON body.
+     * @param data The data to serialize as JSON.
+     * @param init Optional response init options.
+     * @returns A Response with the JSON body and appropriate content-type header.
+     */
+    static json(data: unknown, init?: ResponseOptions) {
+        const body = JSON.stringify(data);
+        const options: ResponseOptions = { ...init };
+        const headers = new Headers(options.headers);
+        if (!headers.has('content-type')) {
+            headers.set('content-type', 'application/json');
+        }
+        options.headers = headers;
+        return new Response(body, options);
+    }
+
     get [Symbol.toStringTag]() {
         return 'Response';
     }
@@ -163,11 +194,11 @@ export class Response extends Body implements globalThis.Response {
         if (!this._inputStream) {
           return super.text();
         }
-    
+
         const outputStream = Gio.MemoryOutputStream.new_resizable();
-    
+
         await new Promise<number>((resolve, reject) => {
-          outputStream.splice_async(this._inputStream, Gio.OutputStreamSpliceFlags.CLOSE_TARGET | Gio.OutputStreamSpliceFlags.CLOSE_SOURCE, GLib.PRIORITY_DEFAULT, null, (self, res) => {
+          outputStream.splice_async(this._inputStream, Gio.OutputStreamSpliceFlags.CLOSE_TARGET | Gio.OutputStreamSpliceFlags.CLOSE_SOURCE, GLib.PRIORITY_DEFAULT, null, (_self: Gio.OutputStream, res: Gio.AsyncResult) => {
             try {
               resolve(outputStream.splice_finish(res));
             } catch (error) {
@@ -175,10 +206,9 @@ export class Response extends Body implements globalThis.Response {
             }
           });
         });
-    
-    
+
         const bytes = outputStream.steal_as_bytes();
-    
+
         return new TextDecoder().decode(bytes.toArray());
       }
 }

package/src/test.mts

@@ -1,4 +1,4 @@
-
+import '@gjsify/node-globals';
 import { run } from '@gjsify/unit';
 
 import testSuite from './index.spec.js';

package/src/utils/blob-from.ts

@@ -1,168 +1,8 @@
-import { DOMException } from "@gjsify/deno-runtime/ext/web/01_dom_exception";
-import { Blob, File } from "@gjsify/deno-runtime/ext/web/09_file";
+// Re-export Blob/File from buffer (which provides the polyfill on GJS)
+// Reference: Node.js buffer.Blob (available since v18)
+import { Blob, File } from 'node:buffer';
 
-import {
-    realpathSync,
-    statSync,
-    rmdirSync,
-    createReadStream,
-    promises as fs
-} from 'node:fs'
-import { basename, sep, join } from 'node:path'
-import { tmpdir } from 'node:os'
-import process from 'node:process'
-
-// import Blob from './index.js'
-
-const { stat, mkdtemp } = fs
-let i = 0, tempDir, registry
-
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- */
-const blobFromSync = (path: string, type: string) => fromBlob(statSync(path), path, type)
-
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- * @returns {Promise<Blob>}
- */
-const blobFrom = (path: string, type: string): Promise<Blob> => stat(path).then(stat => fromBlob(stat, path, type))
-
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- * @returns {Promise<File>}
- */
-const fileFrom = (path: string, type: string): Promise<File> => stat(path).then(stat => fromFile(stat, path, type))
-
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- */
-const fileFromSync = (path: string, type: string) => fromFile(statSync(path), path, type)
-
-// @ts-ignore
-const fromBlob = (stat, path, type = '') => new Blob([new BlobDataItem({
-    path,
-    size: stat.size,
-    lastModified: stat.mtimeMs,
-    start: 0
-})], { type })
-
-// @ts-ignore
-const fromFile = (stat, path, type = '') => new File([new BlobDataItem({
-    path,
-    size: stat.size,
-    lastModified: stat.mtimeMs,
-    start: 0
-})], basename(path), { type, lastModified: stat.mtimeMs })
-
-/**
- * Creates a temporary blob backed by the filesystem.
- * NOTE: requires node.js v14 or higher to use FinalizationRegistry
- *
- * @param {*} data Same as fs.writeFile data
- * @param {BlobPropertyBag & {signal?: AbortSignal}} options
- * @param {AbortSignal} [signal] in case you wish to cancel the write operation
- * @returns {Promise<Blob>}
- */
-const createTemporaryBlob = async (data: any, { signal, type }: BlobPropertyBag & { signal?: AbortSignal; } = {}): Promise<Blob> => {
-    registry = registry || new FinalizationRegistry(fs.unlink)
-    tempDir = tempDir || await mkdtemp(realpathSync(tmpdir()) + sep)
-    const id = `${i++}`
-    const destination = join(tempDir, id)
-    if (data instanceof ArrayBuffer) data = new Uint8Array(data)
-    await fs.writeFile(destination, data, { signal })
-    const blob = await blobFrom(destination, type)
-    registry.register(blob, destination)
-    return blob
-}
-
-/**
- * Creates a temporary File backed by the filesystem.
- * Pretty much the same as constructing a new File(data, name, options)
- *
- * NOTE: requires node.js v14 or higher to use FinalizationRegistry
- * @param {*} data
- * @param {string} name
- * @param {FilePropertyBag & {signal?: AbortSignal}} opts
- * @returns {Promise<File>}
- */
-const createTemporaryFile = async (data: any, name: string, opts: FilePropertyBag & { signal?: AbortSignal; }): Promise<File> => {
-    const blob = await createTemporaryBlob(data)
-    return new File([blob], name, opts)
-}
-
-/**
- * This is a blob backed up by a file on the disk
- * with minium requirement. Its wrapped around a Blob as a blobPart
- * so you have no direct access to this.
- *
- * @private
- */
-class BlobDataItem {
-    #path: string;
-    #start: number;
-    size
-    lastModified
-    originalSize
-
-    constructor(options) {
-        this.#path = options.path
-        this.#start = options.start
-        this.size = options.size
-        this.lastModified = options.lastModified
-        this.originalSize = options.originalSize === undefined
-            ? options.size
-            : options.originalSize
-    }
-
-    /**
-     * Slicing arguments is first validated and formatted
-     * to not be out of range by Blob.prototype.slice
-     */
-    slice(start: number, end: number) {
-        return new BlobDataItem({
-            path: this.#path,
-            lastModified: this.lastModified,
-            originalSize: this.originalSize,
-            size: end - start,
-            start: this.#start + start
-        })
-    }
-
-    async * stream() {
-        const { mtimeMs, size } = await stat(this.#path)
-
-        if (mtimeMs > this.lastModified || this.originalSize !== size) {
-            throw new DOMException('The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.', 'NotReadableError')
-        }
-
-        yield* createReadStream(this.#path, {
-            start: this.#start,
-            end: this.#start + this.size - 1
-        })
-    }
-
-    get [Symbol.toStringTag]() {
-        return 'Blob'
-    }
-}
-
-process.once('exit', () => {
-    tempDir && rmdirSync(tempDir, { recursive: true })
-})
-
-export default blobFromSync
 export {
     Blob,
-    blobFrom,
-    blobFromSync,
-    createTemporaryBlob,
     File,
-    fileFrom,
-    fileFromSync,
-    createTemporaryFile
-}
+}

package/src/utils/data-uri.ts

@@ -0,0 +1,29 @@
+/**
+ * Parse a data: URI into its components.
+ * Replaces the `data-uri-to-buffer` npm package.
+ *
+ * Format: data:[<mediatype>][;base64],<data>
+ */
+export function parseDataUri(uri: string): { buffer: Uint8Array; typeFull: string } {
+    const match = uri.match(/^data:([^,]*?)(;base64)?,(.*)$/s);
+    if (!match) {
+        throw new TypeError(`Invalid data URI: ${uri.slice(0, 50)}...`);
+    }
+
+    const typeFull = match[1] || 'text/plain;charset=US-ASCII';
+    const isBase64 = !!match[2];
+    const data = match[3];
+
+    let buffer: Uint8Array;
+    if (isBase64) {
+        const binaryString = atob(data);
+        buffer = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            buffer[i] = binaryString.charCodeAt(i);
+        }
+    } else {
+        buffer = new TextEncoder().encode(decodeURIComponent(data));
+    }
+
+    return { buffer, typeFull };
+}