@gjsify/http2 0.1.15 → 0.2.0

package/lib/esm/client-session.js

@@ -0,0 +1,280 @@
+import Soup from "@girs/soup-3.0";
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+import { EventEmitter } from "node:events";
+import { Duplex } from "node:stream";
+import { Buffer } from "node:buffer";
+import { readBytesAsync } from "@gjsify/utils";
+import { constants, getDefaultSettings } from "./protocol.js";
+class Http2Session extends EventEmitter {
+  type = constants.NGHTTP2_SESSION_CLIENT;
+  alpnProtocol = void 0;
+  encrypted = false;
+  _closed = false;
+  _destroyed = false;
+  _settings;
+  constructor() {
+    super();
+    this._settings = getDefaultSettings();
+  }
+  get closed() {
+    return this._closed;
+  }
+  get destroyed() {
+    return this._destroyed;
+  }
+  get connecting() {
+    return false;
+  }
+  get pendingSettingsAck() {
+    return false;
+  }
+  get localSettings() {
+    return { ...this._settings };
+  }
+  get remoteSettings() {
+    return getDefaultSettings();
+  }
+  get originSet() {
+    return /* @__PURE__ */ new Set();
+  }
+  settings(settings, callback) {
+    Object.assign(this._settings, settings);
+    if (callback) Promise.resolve().then(callback);
+  }
+  goaway(code, _lastStreamId, _data) {
+    this.emit("goaway", code ?? constants.NGHTTP2_NO_ERROR);
+    this.destroy();
+  }
+  ping(payload, callback) {
+    const buf = payload || new Uint8Array(8);
+    if (callback) Promise.resolve().then(() => callback(null, 0, buf));
+    return true;
+  }
+  close(callback) {
+    if (this._closed) return;
+    this._closed = true;
+    this.emit("close");
+    if (callback) callback();
+  }
+  destroy(error, code) {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    this._closed = true;
+    if (error) this.emit("error", error);
+    if (code !== void 0) this.emit("goaway", code);
+    this.emit("close");
+  }
+  ref() {
+  }
+  unref() {
+  }
+}
+class ClientHttp2Stream extends Duplex {
+  id = 1;
+  pending = false;
+  aborted = false;
+  bufferSize = 0;
+  endAfterHeaders = false;
+  _session;
+  _requestHeaders;
+  _requestChunks = [];
+  _cancellable;
+  _state = constants.NGHTTP2_STREAM_STATE_OPEN;
+  _responseHeaders = {};
+  get state() {
+    return this._state;
+  }
+  get rstCode() {
+    return constants.NGHTTP2_NO_ERROR;
+  }
+  get session() {
+    return this._session;
+  }
+  get sentHeaders() {
+    return this._requestHeaders;
+  }
+  constructor(session, requestHeaders) {
+    super();
+    this._session = session;
+    this._requestHeaders = requestHeaders;
+    this._cancellable = new Gio.Cancellable();
+  }
+  _read(_size) {
+  }
+  _write(chunk, encoding, callback) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+    this._requestChunks.push(buf);
+    callback();
+  }
+  _final(callback) {
+    this._sendRequest().then(() => callback()).catch((err) => callback(err instanceof Error ? err : new Error(String(err))));
+  }
+  async _sendRequest() {
+    const session = this._session._getSoupSession();
+    const authority = this._session._getAuthority();
+    const method = this._requestHeaders[":method"] || "GET";
+    const path = this._requestHeaders[":path"] || "/";
+    const scheme = this._requestHeaders[":scheme"] || (authority.startsWith("https") ? "https" : "http");
+    const host = this._requestHeaders[":authority"] || authority.replace(/^https?:\/\//, "");
+    const url = `${scheme}://${host}${path}`;
+    let uri;
+    try {
+      uri = GLib.Uri.parse(url, GLib.UriFlags.NONE);
+    } catch (err) {
+      throw new Error(`Invalid HTTP/2 request URL: ${url}`);
+    }
+    const message = new Soup.Message({ method, uri });
+    const reqHeaders = message.get_request_headers();
+    for (const [key, value] of Object.entries(this._requestHeaders)) {
+      if (key.startsWith(":")) continue;
+      if (Array.isArray(value)) {
+        for (const v of value) reqHeaders.append(key, v);
+      } else {
+        reqHeaders.replace(key, value);
+      }
+    }
+    const body = Buffer.concat(this._requestChunks);
+    if (body.length > 0) {
+      const contentType = this._requestHeaders["content-type"] || "application/octet-stream";
+      message.set_request_body_from_bytes(contentType, new GLib.Bytes(body));
+    }
+    try {
+      const inputStream = await new Promise((resolve, reject) => {
+        session.send_async(message, GLib.PRIORITY_DEFAULT, this._cancellable, (_self, asyncRes) => {
+          try {
+            resolve(session.send_finish(asyncRes));
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+      const statusCode = message.status_code;
+      const responseHeaders = message.get_response_headers();
+      const headersObj = { ":status": String(statusCode) };
+      responseHeaders.foreach((name, value) => {
+        const lower = name.toLowerCase();
+        if (lower in headersObj) {
+          const existing = headersObj[lower];
+          if (Array.isArray(existing)) {
+            existing.push(value);
+          } else {
+            headersObj[lower] = [existing, value];
+          }
+        } else {
+          headersObj[lower] = value;
+        }
+      });
+      this._responseHeaders = headersObj;
+      this._state = constants.NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL;
+      this.emit("response", headersObj, 0);
+      try {
+        let chunk;
+        while ((chunk = await readBytesAsync(inputStream, 16384, GLib.PRIORITY_DEFAULT, this._cancellable)) !== null) {
+          if (chunk.length > 0) {
+            this.push(Buffer.from(chunk));
+          }
+        }
+      } catch (_readErr) {
+      }
+      this.push(null);
+      this._state = constants.NGHTTP2_STREAM_STATE_CLOSED;
+    } catch (error) {
+      this._state = constants.NGHTTP2_STREAM_STATE_CLOSED;
+      if (!this._cancellable.is_cancelled()) {
+        this.destroy(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+  close(code, callback) {
+    this._cancellable.cancel();
+    this._state = constants.NGHTTP2_STREAM_STATE_CLOSED;
+    this.emit("close", code ?? constants.NGHTTP2_NO_ERROR);
+    if (callback) callback();
+  }
+  priority(_options) {
+  }
+  sendTrailers(_headers) {
+  }
+  setTimeout(_msecs, _callback) {
+    return this;
+  }
+}
+class ClientHttp2Session extends Http2Session {
+  type = constants.NGHTTP2_SESSION_CLIENT;
+  _authority;
+  _soupSession;
+  _streams = /* @__PURE__ */ new Set();
+  constructor(authority, options = {}) {
+    super();
+    this._authority = authority;
+    this.encrypted = authority.startsWith("https:");
+    this._soupSession = new Soup.Session();
+    if (options.rejectUnauthorized === false) {
+      this._soupSession.connect(
+        "accept-certificate",
+        (_msg, _cert, _errors) => {
+          return true;
+        }
+      );
+    }
+    Promise.resolve().then(() => {
+      if (!this.destroyed) {
+        this.alpnProtocol = this.encrypted ? "h2" : void 0;
+        this.emit("connect", this, null);
+      }
+    });
+  }
+  /** @internal Used by ClientHttp2Stream to get the Soup.Session */
+  _getSoupSession() {
+    return this._soupSession;
+  }
+  /** @internal Used by ClientHttp2Stream to build the request URL */
+  _getAuthority() {
+    return this._authority;
+  }
+  request(headers, options) {
+    if (this.destroyed || this.closed) {
+      throw new Error("Session is closed");
+    }
+    const finalHeaders = { ...headers };
+    if (!finalHeaders[":scheme"]) {
+      finalHeaders[":scheme"] = this.encrypted ? "https" : "http";
+    }
+    if (!finalHeaders[":authority"]) {
+      finalHeaders[":authority"] = this._authority.replace(/^https?:\/\//, "");
+    }
+    if (!finalHeaders[":method"]) {
+      finalHeaders[":method"] = "GET";
+    }
+    if (!finalHeaders[":path"]) {
+      finalHeaders[":path"] = "/";
+    }
+    const stream = new ClientHttp2Stream(this, finalHeaders);
+    this._streams.add(stream);
+    stream.once("close", () => this._streams.delete(stream));
+    if (options?.endStream) {
+      stream.end();
+    }
+    return stream;
+  }
+  close(callback) {
+    for (const stream of this._streams) {
+      stream.close();
+    }
+    this._streams.clear();
+    super.close(callback);
+  }
+  destroy(error, code) {
+    for (const stream of this._streams) {
+      stream.close();
+    }
+    this._streams.clear();
+    super.destroy(error, code);
+  }
+}
+export {
+  ClientHttp2Session,
+  ClientHttp2Stream,
+  Http2Session
+};