@gjsify/http 0.0.3 → 0.1.0

package/package.json

@@ -1,32 +1,26 @@
 {
   "name": "@gjsify/http",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "Node.js http module for Gjs",
-  "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/esm/index.js"
-      },
-      "require": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/cjs/index.js"
-      }
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
     }
   },
   "scripts": {
-    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
-    "print:name": "echo '@gjsify/http'",
-    "build": "yarn print:name && yarn build:gjsify",
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
     "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
-    "build:types": "tsc --project tsconfig.types.json || exit 0",
+    "build:types": "tsc",
     "build:test": "yarn build:test:gjs && yarn build:test:node",
     "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
     "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
-    "test": "yarn print:name && yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
     "test:gjs": "gjs -m test.gjs.mjs",
     "test:node": "node test.node.mjs"
   },
@@ -36,8 +30,20 @@
     "http"
   ],
   "devDependencies": {
-    "@gjsify/cli": "^0.0.3",
-    "@gjsify/unit": "^0.0.3",
-    "@types/node": "^20.3.1"
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
+  },
+  "dependencies": {
+    "@girs/gio-2.0": "^2.88.0-4.0.0-beta.42",
+    "@girs/glib-2.0": "^2.88.0-4.0.0-beta.42",
+    "@girs/soup-3.0": "^3.6.6-4.0.0-beta.42",
+    "@gjsify/buffer": "^0.1.0",
+    "@gjsify/events": "^0.1.0",
+    "@gjsify/net": "^0.1.0",
+    "@gjsify/stream": "^0.1.0",
+    "@gjsify/url": "^0.1.0",
+    "@gjsify/utils": "^0.1.0"
   }
 }

package/src/client-request.ts

@@ -0,0 +1,307 @@
+// ClientRequest — Writable stream for outgoing HTTP requests via Soup.Session.
+// Reference: Node.js lib/_http_client.js, lib/_http_outgoing.js
+
+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';
+
+export interface ClientRequestOptions {
+  protocol?: string;
+  hostname?: string;
+  host?: string;
+  port?: number | string;
+  path?: string;
+  method?: string;
+  headers?: Record<string, string | number | string[]>;
+  timeout?: number;
+  agent?: any;
+  setHost?: boolean;
+  /** Basic authentication string in the format 'user:password'. */
+  auth?: string;
+  /** Local address to bind the request from. */
+  localAddress?: string;
+  /** IP address family (4 or 6). */
+  family?: 4 | 6 | 0;
+  /** Signal to abort the request. */
+  signal?: AbortSignal;
+}
+
+/**
+ * ClientRequest — Writable stream representing an outgoing HTTP request.
+ *
+ * Usage:
+ *   const req = http.request(options, (res) => { ... });
+ *   req.write(body);
+ *   req.end();
+ */
+export class ClientRequest extends OutgoingMessage {
+  method: string;
+  path: string;
+  protocol: string;
+  host: string;
+  hostname: string;
+  port: number;
+  aborted = false;
+  reusedSocket = false;
+  maxHeadersCount = 2000;
+
+  private _chunks: Buffer[] = [];
+  private _session: Soup.Session;
+  private _message: Soup.Message;
+  private _cancellable: Gio.Cancellable;
+  private _timeout = 0;
+  private _timeoutTimer: ReturnType<typeof setTimeout> | null = null;
+  private _responseCallback?: (res: IncomingMessage) => void;
+
+  constructor(url: string | URL | ClientRequestOptions, options?: ClientRequestOptions | ((res: IncomingMessage) => void), callback?: (res: IncomingMessage) => void) {
+    super();
+
+    // Parse arguments: request(url, options, cb) or request(options, cb)
+    let opts: ClientRequestOptions;
+
+    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) : undefined,
+        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);
+    }
+
+    // Set default headers
+    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);
+    }
+
+    // Basic authentication: encode user:password as Base64 Authorization header
+    if (opts.auth && !this._headers.has('authorization')) {
+      this.setHeader('Authorization', 'Basic ' + Buffer.from(opts.auth).toString('base64'));
+    }
+
+    // AbortSignal support
+    if (opts.signal) {
+      if (opts.signal.aborted) {
+        this.abort();
+      } else {
+        opts.signal.addEventListener('abort', () => this.abort(), { once: true });
+      }
+    }
+
+    // Create Soup objects
+    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 / 1000);
+      // Start timeout timer immediately for timeout option
+      this._timeoutTimer = setTimeout(() => {
+        this._timeoutTimer = null;
+        this.emit('timeout');
+      }, this._timeout);
+    }
+  }
+
+  private _buildUrl(): string {
+    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(): string[] {
+    return Array.from(this._headers.keys());
+  }
+
+  /** Flush headers — marks headers as sent. */
+  override flushHeaders(): void {
+    if (!this.headersSent) {
+      this._applyHeaders();
+    }
+  }
+
+  /** Set timeout for the request. Emits 'timeout' if no response within msecs. */
+  setTimeout(msecs: number, callback?: () => void): this {
+    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 / 1000);
+      this._timeoutTimer = setTimeout(() => {
+        this._timeoutTimer = null;
+        this.emit('timeout');
+      }, msecs);
+    }
+    return this;
+  }
+
+  /** Abort the request. */
+  abort(): void {
+    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: any, encoding: string, callback: (error?: Error | null) => void): void {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding as BufferEncoding);
+    this._chunks.push(buf);
+    callback();
+  }
+
+  /** Called when the writable stream ends — send the request. */
+  _final(callback: (error?: Error | null) => void): void {
+    this._sendRequest()
+      .then(() => callback())
+      .catch((err) => callback(err));
+  }
+
+  private _applyHeaders(): void {
+    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 as string);
+      }
+    }
+  }
+
+  private async _sendRequest(): Promise<void> {
+    this._applyHeaders();
+
+    // Set request body if we have data
+    const body = Buffer.concat(this._chunks);
+    if (body.length > 0) {
+      const contentType = (this._headers.get('content-type') as string) || 'application/octet-stream';
+      this._message.set_request_body_from_bytes(contentType, new GLib.Bytes(body));
+    }
+
+    try {
+      // Send request asynchronously
+      const inputStream = await new Promise<Gio.InputStream>((resolve, reject) => {
+        this._session.send_async(this._message, GLib.PRIORITY_DEFAULT, this._cancellable, (_self: any, asyncRes: Gio.AsyncResult) => {
+          try {
+            const stream = this._session.send_finish(asyncRes);
+            resolve(stream);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+
+      // Read the entire response body before emitting 'response'.
+      const bodyChunks: Buffer[] = [];
+      try {
+        let chunk: Uint8Array | null;
+        while ((chunk = await readBytesAsync(inputStream, 4096, GLib.PRIORITY_DEFAULT, this._cancellable)) !== null) {
+          bodyChunks.push(Buffer.from(chunk));
+        }
+      } catch (readErr) {
+        // Reading may fail if the connection was reset — still emit response with what we have
+      }
+
+      // Build IncomingMessage from the response
+      const res = new IncomingMessage();
+      res.statusCode = this._message.status_code;
+      res.statusMessage = this._message.get_reason_phrase();
+      res.httpVersion = '1.1';
+
+      // Parse response headers
+      const responseHeaders = this._message.get_response_headers();
+      responseHeaders.foreach((name: string, value: string) => {
+        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 as string, value];
+          }
+        } else {
+          res.headers[lower] = value;
+        }
+      });
+
+      this.finished = true;
+
+      // Clear timeout — response received
+      if (this._timeoutTimer) {
+        clearTimeout(this._timeoutTimer);
+        this._timeoutTimer = null;
+      }
+
+      // Emit 'response' so the user can attach 'data'/'end' listeners
+      this.emit('response', res);
+
+      // Now push the buffered body data into the Readable stream.
+      // Defer to next tick so listeners from the 'response' handler are attached.
+      setTimeout(() => {
+        for (const buf of bodyChunks) {
+          res.push(buf);
+        }
+        res.push(null);
+        res.complete = true;
+      }, 0);
+    } catch (error: any) {
+      if (this.aborted) {
+        this.emit('abort');
+      } else {
+        this.emit('error', error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+}