@gjsify/fetch 0.0.4 → 0.1.1

package/lib/esm/index.js

@@ -1,210 +1,169 @@
-import Soup from "@girs/soup-3.0";
-import Request from "./request.js";
-import zlib from "zlib";
-import Stream, { PassThrough, pipeline as pump } from "stream";
-import dataUriToBuffer from "data-uri-to-buffer";
-import { writeToStream, clone } from "./body.js";
+import Stream from "node:stream";
+import { parseDataUri } from "./utils/data-uri.js";
+import { 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
+  File
 } from "./utils/blob-from.js";
-import { URL } from "@gjsify/deno-runtime/ext/url/00_url";
+import { URL } from "@gjsify/url";
 const supportedSchemas = /* @__PURE__ */ new Set(["data:", "http:", "https:"]);
 async function fetch(url, init = {}) {
-  return new Promise(async (resolve, reject) => {
-    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 response2 = new Response(data, { headers: { "Content-Type": data.typeFull } });
-      resolve(response2);
-      return;
-    }
-    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);
-    };
-    if (signal && signal.aborted) {
-      abort();
-      return;
-    }
-    const abortAndFinalize = () => {
-      abort();
-      finalize();
-    };
-    let readable;
-    let cancellable;
-    try {
-      const sendRes = await request._send(options);
-      readable = sendRes.readable;
-      cancellable = sendRes.cancellable;
-    } catch (error) {
-      reject(error);
-    }
+  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 { buffer, typeFull } = parseDataUri(request.url);
+    const response = new Response(Buffer.from(buffer), { headers: { "Content-Type": typeFull } });
+    return response;
+  }
+  const { signal } = request;
+  if (signal && signal.aborted) {
+    throw new AbortError("The operation was aborted.");
+  }
+  let readable;
+  let cancellable;
+  try {
+    const sendRes = await request._send(options);
+    readable = sendRes.readable;
+    cancellable = sendRes.cancellable;
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new FetchError(`request to ${request.url} failed, reason: ${err.message}`, "system", err);
+  }
+  const abortHandler = () => {
+    cancellable.cancel();
+  };
+  if (signal) {
+    signal.addEventListener("abort", abortHandler, { once: true });
+  }
+  const finalize = () => {
     if (signal) {
-      signal.addEventListener("abort", abortAndFinalize);
+      signal.removeEventListener("abort", abortHandler);
     }
-    const cancelledSignalId = cancellable.connect("cancelled", () => {
-      abortAndFinalize();
-    });
-    const finalize = () => {
-      cancellable.cancel();
-      if (signal) {
-        signal.removeEventListener("abort", abortAndFinalize);
+  };
+  cancellable.connect("cancelled", () => {
+    readable.destroy(new AbortError("The operation was aborted."));
+  });
+  readable.on("error", (error) => {
+    finalize();
+  });
+  const message = request._message;
+  const headers = Headers._newFromSoupMessage(message);
+  const statusCode = message.status_code;
+  const statusMessage = message.get_reason_phrase();
+  if (isRedirect(statusCode)) {
+    const location = headers.get("Location");
+    let locationURL = null;
+    try {
+      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");
       }
-      cancellable.disconnect(cancelledSignalId);
-    };
-    const message = request._message;
-    readable.on("error", (error) => {
-      reject(new FetchError(`request to ${request.url} failed, reason: ${error.message}`, "system", error));
-      finalize();
-    });
-    message.connect("finished", (message2) => {
-      const headers = Headers._newFromSoupMessage(request._message, Soup.MessageHeadersType.RESPONSE);
-      const statusCode = message2.status_code;
-      const statusMessage = message2.get_reason_phrase();
-      if (isRedirect(statusCode)) {
-        const location = headers.get("Location");
-        let locationURL = null;
-        try {
-          locationURL = location === null ? null : new URL(location, request.url);
-        } catch {
-          if (request.redirect !== "manual") {
-            reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect"));
-            finalize();
-            return;
-          }
+    }
+    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");
+      case "manual":
+        break;
+      case "follow": {
+        if (locationURL === null) {
+          break;
         }
-        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":
-            break;
-          case "follow": {
-            if (locationURL === null) {
-              break;
-            }
-            if (request.counter >= request.follow) {
-              reject(new FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect"));
-              finalize();
-              return;
-            }
-            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
-            };
-            if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
-              for (const name of ["authorization", "www-authenticate", "cookie", "cookie2"]) {
-                requestOptions.headers.delete(name);
-              }
-            }
-            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;
-            }
-            if (statusCode === 303 || (statusCode === 301 || statusCode === 302) && request.method === "POST") {
-              requestOptions.method = "GET";
-              requestOptions.body = void 0;
-              requestOptions.headers.delete("content-length");
-            }
-            const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
-            if (responseReferrerPolicy) {
-              requestOptions.referrerPolicy = responseReferrerPolicy;
-            }
-            resolve(fetch(new Request(locationURL, requestOptions)));
-            finalize();
-            return;
+        if (request.counter >= request.follow) {
+          finalize();
+          throw new FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect");
+        }
+        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
+        };
+        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`));
         }
-      }
-      let body = pump(response_, new PassThrough(), (error) => {
-        if (error) {
-          reject(error);
+        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");
         }
-      });
-      const responseOptions = {
-        url: request.url,
-        status: statusCode,
-        statusText: statusMessage,
-        headers,
-        size: request.size,
-        counter: request.counter,
-        highWaterMark: request.highWaterMark
-      };
-      const codings = headers.get("Content-Encoding");
-      if (!request.compress || request.method === "HEAD" || codings === null || statusCode === 204 || statusCode === 304) {
-        response = new Response(body, responseOptions);
-        resolve(response);
-        return;
-      }
-      const zlibOptions = {
-        flush: zlib.Z_SYNC_FLUSH,
-        finishFlush: zlib.Z_SYNC_FLUSH
-      };
-      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;
+        if (statusCode === 303 || (statusCode === 301 || statusCode === 302) && request.method === "POST") {
+          requestOptions.method = "GET";
+          requestOptions.body = void 0;
+          requestOptions.headers.delete("content-length");
+        }
+        const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
+        if (responseReferrerPolicy) {
+          requestOptions.referrerPolicy = responseReferrerPolicy;
+        }
+        finalize();
+        return fetch(new Request(locationURL, requestOptions));
       }
-      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`);
+    }
+  }
+  const responseOptions = {
+    url: request.url,
+    status: statusCode,
+    statusText: statusMessage,
+    headers,
+    size: request.size,
+    counter: request.counter,
+    highWaterMark: request.highWaterMark
+  };
+  const codings = headers.get("Content-Encoding");
+  if (!request.compress || request.method === "HEAD" || codings === null || statusCode === 204 || statusCode === 304) {
+    finalize();
+    return new Response(readable, responseOptions);
+  }
+  if (typeof DecompressionStream !== "undefined") {
+    let format = 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));
+        finalize();
+        return new Response(decompressed, responseOptions);
       }
-      response = new Response(body, responseOptions);
-      resolve(response);
-    });
-    writeToStream(inputStream, request).catch(reject);
-  });
+    }
+  }
+  finalize();
+  return new Response(readable, responseOptions);
+}
+const _isGJS = typeof globalThis.imports !== "undefined";
+if (_isGJS) {
+  globalThis.fetch = fetch;
+  globalThis.Headers = Headers;
+  globalThis.Request = Request;
+  globalThis.Response = Response;
 }
 export {
   AbortError,
@@ -215,10 +174,6 @@ export {
   Headers,
   Request,
   Response,
-  blobFrom,
-  blobFromSync,
   fetch as default,
-  fileFrom,
-  fileFromSync,
   isRedirect
 };

package/lib/esm/request.js

@@ -1,10 +1,8 @@
-import "@girs/gjs";
-import "@girs/gio-2.0";
 import GLib from "@girs/glib-2.0";
 import Soup from "@girs/soup-3.0";
 import Gio from "@girs/gio-2.0";
-import * as SoupExt from "@gjsify/soup-3.0";
-import { URL } from "@gjsify/deno-runtime/ext/url/00_url";
+import { soupSendAsync, inputStreamToReadable } from "./utils/soup-helpers.js";
+import { URL } from "@gjsify/url";
 import Headers from "./headers.js";
 import Body, { clone, extractContentType, getTotalBytes } from "./body.js";
 import { isAbortSignal } from "./utils/is.js";
@@ -13,7 +11,7 @@ import {
   determineRequestsReferrer,
   DEFAULT_REFERRER_POLICY
 } from "./utils/referrer.js";
-const INTERNALS = Symbol("Request internals");
+const INTERNALS = /* @__PURE__ */ Symbol("Request internals");
 const isRequest = (obj) => {
   return typeof obj === "object" && typeof obj.url === "string";
 };
@@ -99,43 +97,45 @@ class Request extends Body {
   highWaterMark = 16384;
   insecureHTTPParser = false;
   constructor(input, init) {
+    const inputRL = input;
+    const initRL = init || {};
     let parsedURL;
     let requestObj = {};
     if (isRequest(input)) {
-      parsedURL = new URL(input.url);
-      requestObj = input;
+      parsedURL = new URL(inputRL.url);
+      requestObj = inputRL;
     } else {
       parsedURL = new URL(input);
     }
     if (parsedURL.username !== "" || parsedURL.password !== "") {
       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.body !== null) && (method === "GET" || method === "HEAD")) {
+    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.body !== null ? clone(input) : null;
+    const inputBody = init?.body ? init.body : isRequest(input) && inputRL.body !== null ? clone(input) : null;
     super(inputBody, {
-      size: init.size || init.size || 0
+      size: initRL.size || 0
     });
-    const headers = new Headers(init.headers || input.headers || {});
+    const headers = new Headers(init?.headers || inputRL.headers || {});
     if (inputBody !== null && !headers.has("Content-Type")) {
       const contentType = extractContentType(inputBody, this);
       if (contentType) {
         headers.set("Content-Type", contentType);
       }
     }
-    let signal = isRequest(input) ? input.signal : null;
-    if ("signal" in init) {
+    let signal = isRequest(input) ? inputRL.signal : null;
+    if (init && "signal" in init) {
       signal = init.signal;
     }
     if (signal != null && !isAbortSignal(signal)) {
       throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
     }
-    let referrer = init.referrer == null ? input.referrer : init.referrer;
+    let referrer = init?.referrer == null ? inputRL.referrer : init.referrer;
     if (referrer === "") {
       referrer = "no-referrer";
     } else if (referrer) {
@@ -144,14 +144,19 @@ class Request extends Body {
     } else {
       referrer = void 0;
     }
-    const session = SoupExt.ExtSession.new();
-    const message = new Soup.Message({
-      method,
-      uri: this._uri
-    });
+    const scheme = parsedURL.protocol;
+    let session = null;
+    let message = 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.redirect || "follow",
+      redirect: init?.redirect || inputRL.redirect || "follow",
       headers,
       parsedURL,
       signal,
@@ -160,24 +165,26 @@ class Request extends Body {
       session,
       message
     };
-    this.follow = init.follow === void 0 ? input.follow === void 0 ? 20 : input.follow : init.follow;
-    this.compress = init.compress === void 0 ? input.compress === void 0 ? true : input.compress : init.compress;
-    this.counter = init.counter || input.counter || 0;
-    this.agent = init.agent || input.agent;
-    this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
-    this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;
-    this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || "";
+    this.follow = initRL.follow === void 0 ? inputRL.follow === void 0 ? 20 : inputRL.follow : initRL.follow;
+    this.compress = initRL.compress === void 0 ? inputRL.compress === void 0 ? 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;
+    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) {
-    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].readable = this[INTERNALS].inputStream.toReadable({});
+    this[INTERNALS].inputStream = await soupSendAsync(session, message, GLib.PRIORITY_DEFAULT, cancellable);
+    this[INTERNALS].readable = inputStreamToReadable(this[INTERNALS].inputStream);
     return {
       inputStream: this[INTERNALS].inputStream,
       readable: this[INTERNALS].readable,
@@ -248,7 +255,7 @@ const getSoupRequestOptions = (request) => {
     headers.set("Referer", request.referrer);
   }
   if (!headers.has("User-Agent")) {
-    headers.set("User-Agent", "node-fetch");
+    headers.set("User-Agent", "gjsify-fetch");
   }
   if (request.compress && !headers.has("Accept-Encoding")) {
     headers.set("Accept-Encoding", "gzip, deflate, br");
@@ -261,13 +268,7 @@ const getSoupRequestOptions = (request) => {
     headers.set("Connection", "close");
   }
   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,

package/lib/esm/response.js

@@ -3,8 +3,8 @@ import Gio from "@girs/gio-2.0";
 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";
-const INTERNALS = Symbol("Response internals");
+import { URL } from "@gjsify/url";
+const INTERNALS = /* @__PURE__ */ Symbol("Response internals");
 class Response extends Body {
   [INTERNALS];
   _inputStream = null;
@@ -60,7 +60,6 @@ class Response extends Body {
    *
    * @return  Response
    */
-  // @ts-ignore
   clone() {
     return new Response(clone(this, this.highWaterMark), {
       type: this.type,
@@ -95,6 +94,22 @@ class Response extends Body {
     response[INTERNALS].type = "error";
     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, init) {
+    const body = JSON.stringify(data);
+    const options = { ...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";
   }
@@ -104,7 +119,7 @@ class Response extends Body {
     }
     const outputStream = Gio.MemoryOutputStream.new_resizable();
     await new Promise((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, res) => {
         try {
           resolve(outputStream.splice_finish(res));
         } catch (error) {