@gjsify/fetch 0.0.4 → 0.1.1

package/src/index.ts

@@ -1,43 +1,32 @@
-import Soup from '@girs/soup-3.0';
-import Gio from '@girs/gio-2.0';
-import Request from './request.js';
+// SPDX-License-Identifier: MIT
+// Adapted from node-fetch (https://github.com/node-fetch/node-fetch) and the Fetch API spec (https://fetch.spec.whatwg.org/)
+// Copyright (c) node-fetch contributors. MIT license.
+// Modifications: Rewritten for GJS using libsoup 3.0 (Soup.Session)
 
-/**
- * Index.js
- *
- * a request API compatible with window.fetch
- *
- * All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
- */
-
-import zlib from 'zlib';
-import Stream, { PassThrough, pipeline as pump } from 'stream';
+import type Gio from '@girs/gio-2.0';
+import Stream from 'node:stream';
 
-import dataUriToBuffer from 'data-uri-to-buffer';
+import { parseDataUri } from './utils/data-uri.js';
 
 import { writeToStream, clone } from './body.js';
 import Response from './response.js';
 import Headers from './headers.js';
-import { getSoupRequestOptions } from './request.js';
+import Request, { getSoupRequestOptions } from './request.js';
 import { FetchError } from './errors/fetch-error.js';
 import { AbortError } from './errors/abort-error.js';
 import { isRedirect } from './utils/is-redirect.js';
-import { FormData } from 'formdata-polyfill/esm.min.js';
+import { FormData } from '@gjsify/formdata';
 import { isDomainOrSubdomain, isSameProtocol } from './utils/is.js';
 import { parseReferrerPolicyFromHeader } from './utils/referrer.js';
 import {
   Blob,
   File,
-  fileFromSync,
-  fileFrom,
-  blobFromSync,
-  blobFrom
 } from './utils/blob-from.js';
 
-import { URL } from '@gjsify/deno-runtime/ext/url/00_url';
+import { URL } from '@gjsify/url';
 
 export { FormData, Headers, Request, Response, FetchError, AbortError, isRedirect };
-export { Blob, File, fileFromSync, fileFrom, blobFromSync, blobFrom };
+export { Blob, File };
 
 import type { SystemError } from './types/index.js';
 
@@ -49,319 +38,217 @@ const supportedSchemas = new Set(['data:', 'http:', 'https:']);
  * @param url Absolute url or Request instance
  * @param init Fetch options
  */
-export default async function fetch(url: RequestInfo | URL, init: RequestInit = {}): Promise<Response> {
-  return new Promise(async (resolve, reject) => {
-    // Build request object
-    const request = new Request(url, init);
-    const { parsedURL, options } = getSoupRequestOptions(request);
-    if (!supportedSchemas.has(parsedURL.protocol)) {
-      throw new TypeError(`@gjsify/fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, '')}" is not supported.`);
-    }
-
-    if (parsedURL.protocol === 'data:') {
-      const data = dataUriToBuffer(request.url);
-      const response = new Response(data, { headers: { 'Content-Type': data.typeFull } });
-      resolve(response);
-      return;
+export default async function fetch(url: RequestInfo | URL | Request, init: RequestInit = {}): Promise<Response> {
+  // Build request object
+  const request = new Request(url, init);
+  const { parsedURL, options } = getSoupRequestOptions(request);
+  if (!supportedSchemas.has(parsedURL.protocol)) {
+    throw new TypeError(`@gjsify/fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, '')}" is not supported.`);
+  }
+
+  // Handle data: URIs
+  if (parsedURL.protocol === 'data:') {
+    const { buffer, typeFull } = parseDataUri(request.url);
+    const response = new Response(Buffer.from(buffer), { headers: { 'Content-Type': typeFull } });
+    return response;
+  }
+
+  const { signal } = request;
+
+  // Check if already aborted
+  if (signal && signal.aborted) {
+    throw new AbortError('The operation was aborted.');
+  }
+
+  // Send HTTP request via Soup
+  let readable: Stream.Readable;
+  let cancellable: Gio.Cancellable;
+
+  try {
+    const sendRes = await request._send(options);
+    readable = sendRes.readable;
+    cancellable = sendRes.cancellable;
+  } catch (error: unknown) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err as unknown as SystemError);
+  }
+
+  // Wire up abort signal to cancellable
+  const abortHandler = () => {
+    cancellable.cancel();
+  };
+
+  if (signal) {
+    signal.addEventListener('abort', abortHandler, { once: true });
+  }
+
+  const finalize = () => {
+    if (signal) {
+      signal.removeEventListener('abort', abortHandler);
     }
+  };
 
-    const { signal } = request;
-    let response = null;
-
-    const abort = () => {
-      const error = new AbortError('The operation was aborted.');
-      reject(error);
-      if (request.body && request.body instanceof Stream.Readable) {
-        request.body.destroy(error);
-      }
-
-      if (!response || !response.body) {
-        return;
-      }
-
-      response.body.emit('error', error);
-    };
+  // Listen for cancellation
+  cancellable.connect('cancelled', () => {
+    readable.destroy(new AbortError('The operation was aborted.'));
+  });
 
-    if (signal && signal.aborted) {
-      abort();
-      return;
-    }
+  // Handle stream errors
+  readable.on('error', (error: SystemError) => {
+    finalize();
+    // Error is consumed by the body when read
+  });
 
-    const abortAndFinalize = () => {
-      abort();
-      finalize();
-    };
+  const message = request._message;
+  const headers = Headers._newFromSoupMessage(message);
+  const statusCode = message.status_code;
+  const statusMessage = message.get_reason_phrase();
 
-    let readable: Stream.Readable;
-    let cancellable: Gio.Cancellable;
+  // HTTP fetch step 5 — handle redirects
+  if (isRedirect(statusCode)) {
+    const location = headers.get('Location');
 
-    // Send request
+    let locationURL: URL | null = null;
     try {
-      const sendRes = await request._send(options);
-      readable = sendRes.readable;
-      cancellable = sendRes.cancellable;
-    } catch (error) {
-      reject(error);
+      locationURL = location === null ? null : new URL(location, request.url);
+    } catch {
+      if (request.redirect !== 'manual') {
+        finalize();
+        throw new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, 'invalid-redirect');
+      }
     }
 
-    if (signal) {
-      signal.addEventListener('abort', abortAndFinalize);
-    }
+    switch (request.redirect) {
+      case 'error':
+        finalize();
+        throw new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect');
 
-    const cancelledSignalId = cancellable.connect('cancelled', () => {
-      abortAndFinalize();
-    });
+      case 'manual':
+        // Nothing to do — return opaque redirect response
+        break;
 
-    const finalize = () => {
-      cancellable.cancel()
-      if (signal) {
-        signal.removeEventListener('abort', abortAndFinalize);
-      }
-      cancellable.disconnect(cancelledSignalId);
-    };
-
-    const message = request._message;
-
-    readable.on('error', (error: SystemError) => {
-      reject(new FetchError(`request to ${request.url} failed, reason: ${error.message}`, 'system', error));
-      finalize();
-    });
-
-    message.connect('finished', (message) => {
-
-      const headers = Headers._newFromSoupMessage( request._message, Soup.MessageHeadersType.RESPONSE);
-      const statusCode = message.status_code;
-      const statusMessage = message.get_reason_phrase() ;
-
-      // HTTP fetch step 5
-      if (isRedirect(statusCode)) {
-        // HTTP fetch step 5.2
-        const location = headers.get('Location');
-
-        // HTTP fetch step 5.3
-        let locationURL = null;
-        try {
-          locationURL = location === null ? null : new URL(location, request.url);
-        } catch {
-          // error here can only be invalid URL in Location: header
-          // do not throw when options.redirect == manual
-          // let the user extract the errorneous redirect URL
-          if (request.redirect !== 'manual') {
-            reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, 'invalid-redirect'));
-            finalize();
-            return;
-          }
+      case 'follow': {
+        if (locationURL === null) {
+          break;
+        }
+
+        if (request.counter >= request.follow) {
+          finalize();
+          throw new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect');
         }
 
-        // HTTP fetch step 5.5
-        switch (request.redirect) {
-          case 'error':
-            reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
-            finalize();
-            return;
-          case 'manual':
-            // Nothing to do
-            break;
-          case 'follow': {
-            // HTTP-redirect fetch step 2
-            if (locationURL === null) {
-              break;
-            }
-
-            // HTTP-redirect fetch step 5
-            if (request.counter >= request.follow) {
-              reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
-              finalize();
-              return;
-            }
-
-            // HTTP-redirect fetch step 6 (counter increment)
-            // Create a new Request object.
-            const requestOptions = {
-              headers: new Headers(request.headers),
-              follow: request.follow,
-              counter: request.counter + 1,
-              agent: request.agent,
-              compress: request.compress,
-              method: request.method,
-              body: clone(request),
-              signal: request.signal,
-              size: request.size,
-              referrer: request.referrer,
-              referrerPolicy: request.referrerPolicy
-            };
-
-            // when forwarding sensitive headers like "Authorization",
-            // "WWW-Authenticate", and "Cookie" to untrusted targets,
-            // headers will be ignored when following a redirect to a domain
-            // that is not a subdomain match or exact match of the initial domain.
-            // For example, a redirect from "foo.com" to either "foo.com" or "sub.foo.com"
-            // will forward the sensitive headers, but a redirect to "bar.com" will not.
-            // headers will also be ignored when following a redirect to a domain using
-            // a different protocol. For example, a redirect from "https://foo.com" to "http://foo.com"
-            // will not forward the sensitive headers
-            if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
-              for (const name of ['authorization', 'www-authenticate', 'cookie', 'cookie2']) {
-                requestOptions.headers.delete(name);
-              }
-            }
-
-            // HTTP-redirect fetch step 9
-            if (statusCode !== 303 && request.body && init.body instanceof Stream.Readable) {
-              reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
-              finalize();
-              return;
-            }
-
-            // HTTP-redirect fetch step 11
-            if (statusCode === 303 || ((statusCode === 301 || statusCode === 302) && request.method === 'POST')) {
-              requestOptions.method = 'GET';
-              requestOptions.body = undefined;
-              requestOptions.headers.delete('content-length');
-            }
-
-            // HTTP-redirect fetch step 14
-            const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
-            if (responseReferrerPolicy) {
-              requestOptions.referrerPolicy = responseReferrerPolicy;
-            }
-
-            // HTTP-redirect fetch step 15
-            resolve(fetch(new Request(locationURL, requestOptions)));
-            finalize();
-            return;
+        const requestOptions: Omit<RequestInit, 'headers'> & {
+          headers: Headers;
+          follow: number;
+          counter: number;
+          agent: string | ((url: URL) => string);
+          compress: boolean;
+          size: number;
+        } = {
+          headers: new Headers(request.headers),
+          follow: request.follow,
+          counter: request.counter + 1,
+          agent: request.agent,
+          compress: request.compress,
+          method: request.method,
+          body: clone(request) as unknown as BodyInit | null,
+          signal: request.signal,
+          size: request.size,
+          referrer: request.referrer,
+          referrerPolicy: request.referrerPolicy
+        };
+
+        // Don't forward sensitive headers to different domains/protocols
+        if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
+          for (const name of ['authorization', 'www-authenticate', 'cookie', 'cookie2']) {
+            requestOptions.headers.delete(name);
           }
+        }
 
-          default:
-            return reject(new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`));
+        // Cannot follow redirect with body being a readable stream
+        if (statusCode !== 303 && request.body && init.body instanceof Stream.Readable) {
+          finalize();
+          throw new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect');
         }
-      }
 
-      // Prepare response
-      // if (signal) {
-      //   response_.once('end', () => {
-      //     signal.removeEventListener('abort', abortAndFinalize);
-      //   });
-      // }
+        // 303 or POST→GET conversion
+        if (statusCode === 303 || ((statusCode === 301 || statusCode === 302) && request.method === 'POST')) {
+          requestOptions.method = 'GET';
+          requestOptions.body = undefined;
+          requestOptions.headers.delete('content-length');
+        }
 
-      let body = pump(response_, new PassThrough(), error => {
-        if (error) {
-          reject(error);
+        // Update referrer policy from response
+        const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
+        if (responseReferrerPolicy) {
+          requestOptions.referrerPolicy = responseReferrerPolicy;
         }
-      });
-      // see https://github.com/nodejs/node/pull/29376
-      /* c8 ignore next 3 */
-      // if (process.version < 'v12.10') {
-      //   response_.on('aborted', abortAndFinalize);
-      // }
-
-      const responseOptions = {
-        url: request.url,
-        status: statusCode,
-        statusText: statusMessage,
-        headers,
-        size: request.size,
-        counter: request.counter,
-        highWaterMark: request.highWaterMark
-      };
-
-      // HTTP-network fetch step 12.1.1.3
-      const codings = headers.get('Content-Encoding');
-
-      // HTTP-network fetch step 12.1.1.4: handle content codings
-
-      // in following scenarios we ignore compression support
-      // 1. compression support is disabled
-      // 2. HEAD request
-      // 3. no Content-Encoding header
-      // 4. no content response (204)
-      // 5. content not modified response (304)
-      if (!request.compress || request.method === 'HEAD' || codings === null || statusCode === 204 || statusCode === 304) {
-        response = new Response(body, responseOptions);
-        resolve(response);
-        return;
-      }
 
-      // For Node v6+
-      // Be less strict when decoding compressed responses, since sometimes
-      // servers send slightly invalid responses that are still accepted
-      // by common browsers.
-      // Always using Z_SYNC_FLUSH is what cURL does.
-      const zlibOptions = {
-        flush: zlib.Z_SYNC_FLUSH,
-        finishFlush: zlib.Z_SYNC_FLUSH
-      };
-
-      // For gzip
-      if (codings === 'gzip' || codings === 'x-gzip') {
-        body = pump(body, zlib.createGunzip(zlibOptions), error => {
-          if (error) {
-            reject(error);
-          }
-        });
-        response = new Response(body, responseOptions);
-        resolve(response);
-        return;
+        finalize();
+        return fetch(new Request(locationURL, requestOptions as unknown as RequestInit));
       }
 
-      // For deflate
-      // if (codings === 'deflate' || codings === 'x-deflate') {
-      //   // Handle the infamous raw deflate response from old servers
-      //   // a hack for old IIS and Apache servers
-      //   const raw = pump(response_, new PassThrough(), error => {
-      //     if (error) {
-      //       reject(error);
-      //     }
-      //   });
-      
-      //   raw.once('data', chunk => {
-      //     // See http://stackoverflow.com/questions/37519828
-      //     if ((chunk[0] & 0x0F) === 0x08) {
-      //       body = pump(body, zlib.createInflate(), error => {
-      //         if (error) {
-      //           reject(error);
-      //         }
-      //       });
-      //     } else {
-      //       body = pump(body, zlib.createInflateRaw(), error => {
-      //         if (error) {
-      //           reject(error);
-      //         }
-      //       });
-      //     }
-
-      //     response = new Response(body, responseOptions);
-      //     resolve(response);
-      //   });
-
-      //   raw.once('end', () => {
-      //     // Some old IIS servers return zero-length OK deflate responses, so
-      //     // 'data' is never emitted. See https://github.com/node-fetch/node-fetch/pull/903
-      //     if (!response) {
-      //       response = new Response(body, responseOptions);
-      //       resolve(response);
-      //     }
-      //   });
-      //   return;
-      // }
-
-      // For br
-      if (codings === 'br') {
-        body = pump(body, zlib.createBrotliDecompress(), error => {
-          if (error) {
-            reject(error);
-          }
-        });
-        response = new Response(body, responseOptions);
-        resolve(response);
-        return;
+      default:
+        throw new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`);
+    }
+  }
+
+  // Build response
+  const responseOptions = {
+    url: request.url,
+    status: statusCode,
+    statusText: statusMessage,
+    headers,
+    size: request.size,
+    counter: request.counter,
+    highWaterMark: request.highWaterMark
+  };
+
+  // Handle content encoding (decompression)
+  const codings = headers.get('Content-Encoding');
+
+  // Skip decompression when:
+  // 1. compression support is disabled
+  // 2. HEAD request
+  // 3. no Content-Encoding header
+  // 4. no content response (204)
+  // 5. content not modified response (304)
+  if (!request.compress || request.method === 'HEAD' || codings === null || statusCode === 204 || statusCode === 304) {
+    finalize();
+    return new Response(readable, responseOptions);
+  }
+
+  // Try to use DecompressionStream Web API (available in modern SpiderMonkey)
+  if (typeof DecompressionStream !== 'undefined') {
+    let format: CompressionFormat | null = null;
+
+    if (codings === 'gzip' || codings === 'x-gzip') {
+      format = 'gzip';
+    } else if (codings === 'deflate' || codings === 'x-deflate') {
+      format = 'deflate';
+    }
+
+    if (format) {
+      const webBody = new Response(readable, responseOptions).body;
+      if (webBody) {
+        const decompressed = webBody.pipeThrough(new DecompressionStream(format) as ReadableWritablePair<Uint8Array, Uint8Array>);
+        finalize();
+        return new Response(decompressed as unknown as ReadableStream, responseOptions);
       }
+    }
+  }
 
-      // Otherwise, use response as-is
-      response = new Response(body, responseOptions);
-      resolve(response);
-    });
+  // Fallback: return the body as-is (no streaming decompression available)
+  finalize();
+  return new Response(readable, responseOptions);
+}
 
-    writeToStream(inputStream, request).catch(reject);
-  });
+// Register Fetch API globals on GJS (pattern: @gjsify/abort-controller, @gjsify/eventsource)
+// On Node.js, native globals are already fully functional — only overwrite on GJS.
+const _isGJS = typeof (globalThis as any).imports !== 'undefined';
+if (_isGJS) {
+  (globalThis as any).fetch = fetch;
+  (globalThis as any).Headers = Headers;
+  (globalThis as any).Request = Request;
+  (globalThis as any).Response = Response;
 }