@gjsify/http 0.0.4 → 0.1.1

package/README.md

@@ -1,4 +1,33 @@
 # @gjsify/http
 
-## Inspirations
+GJS partial implementation of the Node.js `http` module using Soup 3.0. Provides Server, IncomingMessage, and ServerResponse.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/http
+# or
+yarn add @gjsify/http
+```
+
+## Usage
+
+```typescript
+import { createServer } from '@gjsify/http';
+
+const server = createServer((req, res) => {
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.end('Hello World');
+});
+server.listen(3000);
+```
+
+## Inspirations and credits
+
 - https://github.com/node-fetch/node-fetch/blob/main/src/headers.js
+
+## License
+
+MIT

package/lib/esm/client-request.js

@@ -0,0 +1,228 @@
+import GLib from "@girs/glib-2.0";
+import Soup from "@girs/soup-3.0";
+import Gio from "@girs/gio-2.0";
+import { Buffer } from "node:buffer";
+import { URL } from "node:url";
+import { readBytesAsync } from "@gjsify/utils";
+import { OutgoingMessage } from "./server.js";
+import { IncomingMessage } from "./incoming-message.js";
+class ClientRequest extends OutgoingMessage {
+  method;
+  path;
+  protocol;
+  host;
+  hostname;
+  port;
+  aborted = false;
+  reusedSocket = false;
+  maxHeadersCount = 2e3;
+  _chunks = [];
+  _session;
+  _message;
+  _cancellable;
+  _timeout = 0;
+  _timeoutTimer = null;
+  _responseCallback;
+  constructor(url, options, callback) {
+    super();
+    let opts;
+    if (typeof url === "string" || url instanceof URL) {
+      const parsed = typeof url === "string" ? new URL(url) : url;
+      opts = {
+        protocol: parsed.protocol,
+        hostname: parsed.hostname,
+        port: parsed.port ? Number(parsed.port) : void 0,
+        path: parsed.pathname + parsed.search,
+        ...typeof options === "object" ? options : {}
+      };
+      if (typeof options === "function") {
+        callback = options;
+      }
+    } else {
+      opts = url;
+      if (typeof options === "function") {
+        callback = options;
+      }
+    }
+    this.method = (opts.method || "GET").toUpperCase();
+    this.protocol = opts.protocol || "http:";
+    this.hostname = opts.hostname || opts.host?.split(":")[0] || "localhost";
+    this.port = Number(opts.port) || (this.protocol === "https:" ? 443 : 80);
+    this.path = opts.path || "/";
+    this.host = opts.host || `${this.hostname}:${this.port}`;
+    this._timeout = opts.timeout || 0;
+    if (callback) {
+      this._responseCallback = callback;
+      this.once("response", callback);
+    }
+    if (opts.headers) {
+      for (const [key, value] of Object.entries(opts.headers)) {
+        this.setHeader(key, value);
+      }
+    }
+    if (opts.setHost !== false && !this._headers.has("host")) {
+      const defaultPort = this.protocol === "https:" ? 443 : 80;
+      const hostHeader = this.port === defaultPort ? this.hostname : `${this.hostname}:${this.port}`;
+      this.setHeader("Host", hostHeader);
+    }
+    if (opts.auth && !this._headers.has("authorization")) {
+      this.setHeader("Authorization", "Basic " + Buffer.from(opts.auth).toString("base64"));
+    }
+    if (opts.signal) {
+      if (opts.signal.aborted) {
+        this.abort();
+      } else {
+        opts.signal.addEventListener("abort", () => this.abort(), { once: true });
+      }
+    }
+    const uri = GLib.Uri.parse(this._buildUrl(), GLib.UriFlags.NONE);
+    this._session = new Soup.Session();
+    this._message = new Soup.Message({ method: this.method, uri });
+    this._cancellable = new Gio.Cancellable();
+    if (this._timeout > 0) {
+      this._session.timeout = Math.ceil(this._timeout / 1e3);
+      this._timeoutTimer = setTimeout(() => {
+        this._timeoutTimer = null;
+        this.emit("timeout");
+      }, this._timeout);
+    }
+  }
+  _buildUrl() {
+    const proto = this.protocol.endsWith(":") ? this.protocol : this.protocol + ":";
+    const defaultPort = proto === "https:" ? 443 : 80;
+    const portStr = this.port === defaultPort ? "" : `:${this.port}`;
+    return `${proto}//${this.hostname}${portStr}${this.path}`;
+  }
+  /** Get raw header names and values as a flat array. */
+  getRawHeaderNames() {
+    return Array.from(this._headers.keys());
+  }
+  /** Flush headers — marks headers as sent. */
+  flushHeaders() {
+    if (!this.headersSent) {
+      this._applyHeaders();
+    }
+  }
+  /** Set timeout for the request. Emits 'timeout' if no response within msecs. */
+  setTimeout(msecs, callback) {
+    this._timeout = msecs;
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+    if (callback) this.once("timeout", callback);
+    if (msecs > 0) {
+      this._session.timeout = Math.ceil(msecs / 1e3);
+      this._timeoutTimer = setTimeout(() => {
+        this._timeoutTimer = null;
+        this.emit("timeout");
+      }, msecs);
+    }
+    return this;
+  }
+  /** Abort the request. */
+  abort() {
+    if (this.aborted) return;
+    this.aborted = true;
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+    this._cancellable.cancel();
+    this.emit("abort");
+    this.destroy();
+  }
+  /** Writable stream _write implementation — collect body chunks. */
+  _write(chunk, encoding, callback) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+    this._chunks.push(buf);
+    callback();
+  }
+  /** Called when the writable stream ends — send the request. */
+  _final(callback) {
+    this._sendRequest().then(() => callback()).catch((err) => callback(err));
+  }
+  _applyHeaders() {
+    if (this.headersSent) return;
+    this.headersSent = true;
+    const requestHeaders = this._message.get_request_headers();
+    for (const [key, value] of this._headers) {
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          requestHeaders.append(key, v);
+        }
+      } else {
+        requestHeaders.replace(key, value);
+      }
+    }
+  }
+  async _sendRequest() {
+    this._applyHeaders();
+    const body = Buffer.concat(this._chunks);
+    if (body.length > 0) {
+      const contentType = this._headers.get("content-type") || "application/octet-stream";
+      this._message.set_request_body_from_bytes(contentType, new GLib.Bytes(body));
+    }
+    try {
+      const inputStream = await new Promise((resolve, reject) => {
+        this._session.send_async(this._message, GLib.PRIORITY_DEFAULT, this._cancellable, (_self, asyncRes) => {
+          try {
+            const stream = this._session.send_finish(asyncRes);
+            resolve(stream);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+      const bodyChunks = [];
+      try {
+        let chunk;
+        while ((chunk = await readBytesAsync(inputStream, 4096, GLib.PRIORITY_DEFAULT, this._cancellable)) !== null) {
+          bodyChunks.push(Buffer.from(chunk));
+        }
+      } catch (readErr) {
+      }
+      const res = new IncomingMessage();
+      res.statusCode = this._message.status_code;
+      res.statusMessage = this._message.get_reason_phrase();
+      res.httpVersion = "1.1";
+      const responseHeaders = this._message.get_response_headers();
+      responseHeaders.foreach((name, value) => {
+        const lower = name.toLowerCase();
+        res.rawHeaders.push(name, value);
+        if (lower in res.headers) {
+          const existing = res.headers[lower];
+          if (Array.isArray(existing)) {
+            existing.push(value);
+          } else {
+            res.headers[lower] = [existing, value];
+          }
+        } else {
+          res.headers[lower] = value;
+        }
+      });
+      this.finished = true;
+      if (this._timeoutTimer) {
+        clearTimeout(this._timeoutTimer);
+        this._timeoutTimer = null;
+      }
+      this.emit("response", res);
+      setTimeout(() => {
+        for (const buf of bodyChunks) {
+          res.push(buf);
+        }
+        res.push(null);
+        res.complete = true;
+      }, 0);
+    } catch (error) {
+      if (this.aborted) {
+        this.emit("abort");
+      } else {
+        this.emit("error", error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+}
+export {
+  ClientRequest
+};

package/lib/esm/constants.js

@@ -0,0 +1,105 @@
+const STATUS_CODES = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  103: "Early Hints",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  207: "Multi-Status",
+  208: "Already Reported",
+  226: "IM Used",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a Teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+const METHODS = [
+  "ACL",
+  "BIND",
+  "CHECKOUT",
+  "CONNECT",
+  "COPY",
+  "DELETE",
+  "GET",
+  "HEAD",
+  "LINK",
+  "LOCK",
+  "M-SEARCH",
+  "MERGE",
+  "MKACTIVITY",
+  "MKCALENDAR",
+  "MKCOL",
+  "MOVE",
+  "NOTIFY",
+  "OPTIONS",
+  "PATCH",
+  "POST",
+  "PRI",
+  "PROPFIND",
+  "PROPPATCH",
+  "PURGE",
+  "PUT",
+  "REBIND",
+  "REPORT",
+  "SEARCH",
+  "SOURCE",
+  "SUBSCRIBE",
+  "TRACE",
+  "UNBIND",
+  "UNLINK",
+  "UNLOCK",
+  "UNSUBSCRIBE"
+];
+export {
+  METHODS,
+  STATUS_CODES
+};

package/lib/esm/incoming-message.js

@@ -0,0 +1,59 @@
+import { Readable } from "node:stream";
+import { Buffer } from "node:buffer";
+class IncomingMessage extends Readable {
+  httpVersion = "1.1";
+  httpVersionMajor = 1;
+  httpVersionMinor = 1;
+  headers = {};
+  rawHeaders = [];
+  method;
+  url;
+  statusCode;
+  statusMessage;
+  complete = false;
+  socket = null;
+  aborted = false;
+  _timeoutTimer = null;
+  constructor() {
+    super();
+  }
+  _read(_size) {
+  }
+  /** Finish the readable stream with the body data (used by server-side handler). */
+  _pushBody(body) {
+    if (body && body.length > 0) {
+      this.push(Buffer.from(body));
+    }
+    this.push(null);
+    this.complete = true;
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+  }
+  setTimeout(msecs, callback) {
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+    if (callback) this.once("timeout", callback);
+    if (msecs > 0) {
+      this._timeoutTimer = setTimeout(() => {
+        this._timeoutTimer = null;
+        this.emit("timeout");
+      }, msecs);
+    }
+    return this;
+  }
+  destroy(error) {
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+    this.aborted = true;
+    return super.destroy(error);
+  }
+}
+export {
+  IncomingMessage
+};

package/lib/esm/index.js

@@ -1,18 +1,128 @@
+import { STATUS_CODES, METHODS } from "./constants.js";
+import { IncomingMessage } from "./incoming-message.js";
+import { OutgoingMessage, Server, ServerResponse } from "./server.js";
+import { ClientRequest } from "./client-request.js";
+import { IncomingMessage as IncomingMessage2 } from "./incoming-message.js";
+import { OutgoingMessage as OutgoingMessage2, Server as Server2, ServerResponse as ServerResponse2 } from "./server.js";
+import { ClientRequest as ClientRequest2 } from "./client-request.js";
+import { URL } from "node:url";
 function validateHeaderName(name) {
-  if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) {
+  if (typeof name !== "string" || !/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) {
     const error = new TypeError(`Header name must be a valid HTTP token ["${name}"]`);
     Object.defineProperty(error, "code", { value: "ERR_INVALID_HTTP_TOKEN" });
     throw error;
   }
 }
 function validateHeaderValue(name, value) {
-  if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
+  if (value === void 0) {
+    const error = new TypeError(`Header "${name}" value must not be undefined`);
+    Object.defineProperty(error, "code", { value: "ERR_HTTP_INVALID_HEADER_VALUE" });
+    throw error;
+  }
+  if (typeof value === "string" && /[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
     const error = new TypeError(`Invalid character in header content ["${name}"]`);
     Object.defineProperty(error, "code", { value: "ERR_INVALID_CHAR" });
     throw error;
   }
 }
+class Agent {
+  defaultPort = 80;
+  protocol = "http:";
+  maxSockets;
+  maxTotalSockets;
+  maxFreeSockets;
+  keepAliveMsecs;
+  keepAlive;
+  scheduling;
+  /** Pending requests per host (compatibility — Soup manages internally). */
+  requests = {};
+  /** Active sockets per host (compatibility — Soup manages internally). */
+  sockets = {};
+  /** Idle sockets per host (compatibility — Soup manages internally). */
+  freeSockets = {};
+  constructor(options) {
+    this.keepAlive = options?.keepAlive ?? false;
+    this.keepAliveMsecs = options?.keepAliveMsecs ?? 1e3;
+    this.maxSockets = options?.maxSockets ?? Infinity;
+    this.maxTotalSockets = options?.maxTotalSockets ?? Infinity;
+    this.maxFreeSockets = options?.maxFreeSockets ?? 256;
+    this.scheduling = options?.scheduling ?? "lifo";
+  }
+  /** Destroy the agent and close idle connections. */
+  destroy() {
+  }
+  /** Return a connection pool key for the given options. */
+  getName(options) {
+    let name = options.host || "localhost";
+    if (options.port) name += ":" + options.port;
+    if (options.localAddress) name += ":" + options.localAddress;
+    if (options.family === 4 || options.family === 6) name += ":" + options.family;
+    return name;
+  }
+}
+const globalAgent = new Agent();
+function createServer(options, requestListener) {
+  if (typeof options === "function") {
+    return new Server2(options);
+  }
+  return new Server2(requestListener);
+}
+function request(url, options, callback) {
+  return new ClientRequest2(url, options, callback);
+}
+function get(url, options, callback) {
+  let opts;
+  let cb = callback;
+  if (typeof url === "string" || url instanceof URL) {
+    opts = typeof options === "object" ? { ...options, method: "GET" } : { method: "GET" };
+    if (typeof options === "function") cb = options;
+  } else {
+    opts = { ...url, method: "GET" };
+    if (typeof options === "function") cb = options;
+    url = opts;
+  }
+  const req = typeof url === "string" || url instanceof URL ? new ClientRequest2(url, { ...opts, method: "GET" }, cb) : new ClientRequest2({ ...opts, method: "GET" }, cb);
+  req.end();
+  return req;
+}
+const maxHeaderSize = 16384;
+function setMaxIdleHTTPParsers(_max) {
+}
+import { STATUS_CODES as _STATUS_CODES, METHODS as _METHODS } from "./constants.js";
+var index_default = {
+  STATUS_CODES: _STATUS_CODES,
+  METHODS: _METHODS,
+  Server: Server2,
+  IncomingMessage: IncomingMessage2,
+  OutgoingMessage: OutgoingMessage2,
+  ServerResponse: ServerResponse2,
+  ClientRequest: ClientRequest2,
+  Agent,
+  globalAgent,
+  createServer,
+  request,
+  get,
+  validateHeaderName,
+  validateHeaderValue,
+  maxHeaderSize,
+  setMaxIdleHTTPParsers
+};
 export {
+  Agent,
+  ClientRequest,
+  IncomingMessage,
+  METHODS,
+  OutgoingMessage,
+  STATUS_CODES,
+  Server,
+  ServerResponse,
+  createServer,
+  index_default as default,
+  get,
+  globalAgent,
+  maxHeaderSize,
+  request,
+  setMaxIdleHTTPParsers,
   validateHeaderName,
   validateHeaderValue
 };