@gjsify/http 0.3.21 → 0.4.3

package/src/index.ts

@@ -1,149 +0,0 @@
-// Node.js http module for GJS
-// Server: Soup.Server, Client: Soup.Session
-// Reference: Node.js lib/http.js
-
-export { STATUS_CODES, METHODS } from './constants.js';
-export { IncomingMessage } from './incoming-message.js';
-export { OutgoingMessage, Server, ServerResponse } from './server.js';
-export { ClientRequest } from './client-request.js';
-export { validateHeaderName, validateHeaderValue } from './validators.js';
-import { validateHeaderName, validateHeaderValue } from './validators.js';
-import { IncomingMessage } from './incoming-message.js';
-import { OutgoingMessage, Server, ServerResponse } from './server.js';
-import { ClientRequest } from './client-request.js';
-import type { ClientRequestOptions } from './client-request.js';
-import { URL } from 'node:url';
-
-export interface AgentOptions {
-  keepAlive?: boolean;
-  keepAliveMsecs?: number;
-  maxSockets?: number;
-  maxTotalSockets?: number;
-  maxFreeSockets?: number;
-  timeout?: number;
-  scheduling?: 'fifo' | 'lifo';
-}
-
-/**
- * Agent class for connection pooling.
- * Soup.Session handles actual TCP connection pooling internally.
- * This class provides the Node.js-compatible API surface for frameworks.
- */
-export class Agent {
-  defaultPort = 80;
-  protocol = 'http:';
-  maxSockets: number;
-  maxTotalSockets: number;
-  maxFreeSockets: number;
-  keepAliveMsecs: number;
-  keepAlive: boolean;
-  scheduling: 'fifo' | 'lifo';
-
-  /** Pending requests per host (compatibility — Soup manages internally). */
-  readonly requests: Record<string, unknown[]> = {};
-  /** Active sockets per host (compatibility — Soup manages internally). */
-  readonly sockets: Record<string, unknown[]> = {};
-  /** Idle sockets per host (compatibility — Soup manages internally). */
-  readonly freeSockets: Record<string, unknown[]> = {};
-
-  constructor(options?: AgentOptions) {
-    this.keepAlive = options?.keepAlive ?? false;
-    this.keepAliveMsecs = options?.keepAliveMsecs ?? 1000;
-    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(): void {
-    // Soup.Session handles cleanup on GC.
-  }
-
-  /** Return a connection pool key for the given options. */
-  getName(options: { host?: string; port?: number; localAddress?: string; family?: number }): string {
-    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;
-  }
-}
-
-export const globalAgent = new Agent();
-
-/**
- * Create an HTTP server.
- */
-export function createServer(options?: Record<string, unknown> | ((req: IncomingMessage, res: ServerResponse) => void), requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server {
-  if (typeof options === 'function') {
-    return new Server(options);
-  }
-  return new Server(requestListener);
-}
-
-/**
- * Make an HTTP request.
- *
- * @param url URL string, URL object, or request options
- * @param options Request options (if url is string/URL)
- * @param callback Response callback
- */
-export function request(url: string | URL | ClientRequestOptions, options?: ClientRequestOptions | ((res: IncomingMessage) => void), callback?: (res: IncomingMessage) => void): ClientRequest {
-  return new ClientRequest(url, options, callback);
-}
-
-/**
- * Make an HTTP GET request (convenience wrapper that calls req.end() automatically).
- */
-export function get(url: string | URL | ClientRequestOptions, options?: ClientRequestOptions | ((res: IncomingMessage) => void), callback?: (res: IncomingMessage) => void): ClientRequest {
-  // Normalize arguments
-  let opts: ClientRequestOptions;
-  let cb: ((res: IncomingMessage) => void) | undefined = 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 as ClientRequestOptions;
-  }
-
-  const req = typeof url === 'string' || url instanceof URL
-    ? new ClientRequest(url, { ...opts, method: 'GET' }, cb)
-    : new ClientRequest({ ...opts, method: 'GET' }, cb);
-  req.end();
-  return req;
-}
-
-/** Max header size in bytes. */
-export const maxHeaderSize = 16384;
-
-/**
- * Set the maximum number of idle HTTP parsers. Soup.Session handles
- * connection pooling internally, so this is a no-op for compatibility.
- * @since v18.8.0
- */
-export function setMaxIdleHTTPParsers(_max: number): void {}
-
-import { STATUS_CODES as _STATUS_CODES, METHODS as _METHODS } from './constants.js';
-
-export default {
-  STATUS_CODES: _STATUS_CODES,
-  METHODS: _METHODS,
-  Server,
-  IncomingMessage,
-  OutgoingMessage,
-  ServerResponse,
-  ClientRequest,
-  Agent,
-  globalAgent,
-  createServer,
-  request,
-  get,
-  validateHeaderName,
-  validateHeaderValue,
-  maxHeaderSize,
-  setMaxIdleHTTPParsers,
-};

package/src/listen-error.spec.ts

@@ -1,73 +0,0 @@
-// Ported from refs/node-test/parallel/test-net-server-listen-handle.js
-// Original: MIT license, Node.js contributors
-// Tests that http.Server emits 'error' with code EADDRINUSE when port is busy.
-
-import { describe, it, expect } from '@gjsify/unit';
-import * as http from 'node:http';
-
-export default async () => {
-
-  await describe('http.Server listen error', async () => {
-
-    await it('should emit error with EADDRINUSE when port is already in use', async () => {
-      // First server binds a random port
-      const server1 = http.createServer();
-      const port = await new Promise<number>((resolve, reject) => {
-        server1.on('error', reject);
-        server1.listen(0, () => {
-          const addr = server1.address() as { port: number };
-          resolve(addr.port);
-        });
-      });
-
-      try {
-        // Second server tries to bind the same port — must emit 'error'
-        const error = await new Promise<any>((resolve, reject) => {
-          const server2 = http.createServer();
-          server2.on('error', resolve);
-          server2.on('listening', () => {
-            server2.close();
-            reject(new Error('Expected EADDRINUSE but server started successfully'));
-          });
-          server2.listen(port);
-        });
-
-        expect(error.code).toBe('EADDRINUSE');
-        expect(error.syscall).toBe('listen');
-        expect(typeof error.port).toBe('number');
-        expect(error.port).toBe(port);
-      } finally {
-        server1.close();
-      }
-    });
-
-    await it('should include address and port in error message', async () => {
-      const server1 = http.createServer();
-      const port = await new Promise<number>((resolve, reject) => {
-        server1.on('error', reject);
-        server1.listen(0, () => {
-          const addr = server1.address() as { port: number };
-          resolve(addr.port);
-        });
-      });
-
-      try {
-        const error = await new Promise<any>((resolve, reject) => {
-          const server2 = http.createServer();
-          server2.on('error', resolve);
-          server2.on('listening', () => {
-            server2.close();
-            reject(new Error('Expected EADDRINUSE'));
-          });
-          server2.listen(port);
-        });
-
-        expect(error.message).toContain('EADDRINUSE');
-        expect(error.message).toContain('listen');
-      } finally {
-        server1.close();
-      }
-    });
-
-  });
-};

package/src/server-request-socket.ts

@@ -1,88 +0,0 @@
-// `req.socket` for our HTTP server.
-//
-// Reference: Node.js lib/net.js Socket interface
-// Reimplemented for GJS — `@gjsify/http-soup-bridge` owns the underlying
-// TCP connection, so a real `Gio.Socket` is not directly accessible from
-// JS. This class satisfies the net.Socket duck-type expected by HTTP
-// consumers (Hono, MCP SDK, engine.io, …) using values copied off the
-// bridge `Request` instance at construction time.
-//
-// Extends Duplex (not EventEmitter) so that `instanceof stream.Duplex`
-// checks and stream API calls (`pipe`, `pause`, `resume`) work. `_read`
-// and `_write` are no-ops because the bridge owns the actual bytes.
-
-import { Duplex } from 'node:stream';
-import type { Response as BridgeResponse } from '@gjsify/http-soup-bridge';
-
-export class ServerRequestSocket extends Duplex {
-  readonly remoteAddress: string;
-  readonly remotePort: number;
-  readonly localAddress: string;
-  readonly localPort: number;
-  readonly remoteFamily = 'IPv4';
-  readonly encrypted: boolean;
-  readonly connecting = false;
-  readonly pending = false;
-  bytesRead = 0;
-  bytesWritten = 0;
-
-  // Bridge response we forward pause/resume to (via super.pause/resume
-  // for now; the bridge will grow explicit pause/unpause hooks later).
-  private readonly _bridgeRes: BridgeResponse;
-  private _bridgePaused = false;
-
-  constructor(
-    remoteAddress: string,
-    remotePort: number,
-    localAddress: string,
-    localPort: number,
-    bridgeRes: BridgeResponse,
-    encrypted = false,
-  ) {
-    super({ allowHalfOpen: true });
-    this.remoteAddress = remoteAddress;
-    this.remotePort = remotePort;
-    this.localAddress = localAddress;
-    this.localPort = localPort;
-    this.encrypted = encrypted;
-    this._bridgeRes = bridgeRes;
-  }
-
-  pause(): this {
-    if (this._bridgePaused) return this;
-    this._bridgePaused = true;
-    return super.pause() as this;
-  }
-
-  resume(): this {
-    if (!this._bridgePaused) return super.resume() as this;
-    this._bridgePaused = false;
-    return super.resume() as this;
-  }
-
-  // The bridge owns the TCP connection — no data flows through this Duplex.
-  _read(_size: number): void {}
-  _write(_chunk: unknown, _encoding: BufferEncoding, cb: (err?: Error | null) => void): void { cb(); }
-
-  destroySoon(): void {
-    if (!this.writableEnded) this.end();
-    if (this.writableFinished)
-      this.destroy();
-    else
-      this.once('finish', () => this.destroy());
-  }
-
-  setTimeout(_timeout: number, cb?: () => void): this {
-    if (cb) this.once('timeout', cb);
-    return this;
-  }
-
-  setNoDelay(_noDelay?: boolean): this { return this; }
-  setKeepAlive(_enable?: boolean, _delay?: number): this { return this; }
-  ref(): this { return this; }
-  unref(): this { return this; }
-
-  address(): { address: string; family: string; port: number } {
-    return { address: this.localAddress, family: 'IPv4', port: this.localPort };
-  }
-}