@gjsify/net 0.0.4 → 0.1.1

package/src/index.ts

@@ -1,26 +1,61 @@
+// Node.js net module for GJS
+// Reference: Node.js lib/net.js
+
 import Gio from '@girs/gio-2.0';
 
-export function isIP(input: string): 0 | 4 | 6 {
-  const addr = Gio.InetAddress.new_from_string(input);
+export { Socket, SocketConnectOptions } from './socket.js';
+export { Server, ListenOptions } from './server.js';
+import { Socket, SocketConnectOptions } from './socket.js';
+import { Server, ListenOptions } from './server.js';
 
+/** Check if input is a valid IP address. Returns 0, 4, or 6. */
+export function isIP(input: string): 0 | 4 | 6 {
+  if (typeof input !== 'string') return 0;
+  // Strip IPv6 zone ID (e.g. '%eth0') — Gio.InetAddress doesn't handle it
+  const stripped = input.includes('%') ? input.split('%')[0] : input;
+  const addr = Gio.InetAddress.new_from_string(stripped);
   if (!addr) return 0;
-
   const family = addr.get_family();
-
-  switch(family) {
-    case Gio.SocketFamily.INVALID:
-      return 0;
-    case Gio.SocketFamily.IPV4:
-      return 4;
-    case Gio.SocketFamily.IPV6:
-      return 6;
+  switch (family) {
+    case Gio.SocketFamily.INVALID: return 0;
+    case Gio.SocketFamily.IPV4: return 4;
+    case Gio.SocketFamily.IPV6: return 6;
   }
 }
 
+/** Check if input is a valid IPv4 address. */
 export function isIPv4(input: string): boolean {
   return isIP(input) === 4;
 }
 
+/** Check if input is a valid IPv6 address. */
 export function isIPv6(input: string): boolean {
   return isIP(input) === 6;
-}
+}
+
+/** Create a new TCP connection. */
+export function createConnection(options: SocketConnectOptions | number, host?: string | (() => void), connectionListener?: () => void): Socket {
+  const socket = new Socket();
+  return socket.connect(options as any, host as any, connectionListener);
+}
+
+/** Alias for createConnection. */
+export const connect = createConnection;
+
+/** Create a new TCP server. */
+export function createServer(connectionListener?: (socket: Socket) => void): Server;
+export function createServer(options?: { allowHalfOpen?: boolean }, connectionListener?: (socket: Socket) => void): Server;
+export function createServer(optionsOrListener?: any, connectionListener?: (socket: Socket) => void): Server {
+  return new Server(optionsOrListener, connectionListener);
+}
+
+export default {
+  Socket,
+  Server,
+  isIP,
+  isIPv4,
+  isIPv6,
+  createConnection,
+  connect,
+  createServer,
+};

package/src/server.spec.ts

@@ -0,0 +1,303 @@
+// TCP server/client integration tests — connection lifecycle, data transfer, error handling
+// Reference: refs/node-test/parallel/test-net-*.js
+
+import { describe, it, expect } from '@gjsify/unit';
+import { createServer, createConnection, Socket, Server } from 'node:net';
+import { Buffer } from 'node:buffer';
+
+/** Helper: create server, run test, cleanup */
+function withServer(handler: (server: Server, port: number) => Promise<void>): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(0, '127.0.0.1', () => {
+      const addr = server.address() as { port: number };
+      handler(server, addr.port)
+        .then(() => {
+          server.close();
+          resolve();
+        })
+        .catch((err) => {
+          server.close();
+          reject(err);
+        });
+    });
+  });
+}
+
+export default async () => {
+  // ---- TCP Echo ----
+
+  await describe('net TCP: echo server', async () => {
+    await it('should echo data back to client', async () => {
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => {
+          socket.on('data', (data) => socket.write(data));
+        });
+        const result = await new Promise<string>((resolve, reject) => {
+          const client = createConnection({ port, host: '127.0.0.1' }, () => {
+            client.write('hello echo');
+          });
+          client.setEncoding('utf8');
+          client.on('data', (data) => {
+            client.end();
+            resolve(data);
+          });
+          client.on('error', reject);
+        });
+        expect(result).toBe('hello echo');
+      });
+    });
+
+    await it('should echo a second message after first completes', async () => {
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => {
+          socket.on('data', (data) => socket.write(data));
+        });
+        // Send one message, wait for echo, then send another
+        const result = await new Promise<string>((resolve, reject) => {
+          const client = createConnection({ port, host: '127.0.0.1' }, () => {
+            client.write('first');
+          });
+          client.setEncoding('utf8');
+          let received = '';
+          client.on('data', (data) => {
+            received += data;
+            if (received === 'first') {
+              // Send second message after first echo completes
+              client.write('second');
+            } else if (received.includes('second')) {
+              client.end();
+              resolve(received);
+            }
+          });
+          client.on('error', reject);
+        });
+        expect(result).toBe('firstsecond');
+      });
+    });
+  });
+
+  // ---- Large data transfer ----
+
+  await describe('net TCP: large data transfer', async () => {
+    await it('should transfer 64KB of data', async () => {
+      const size = 64 * 1024;
+      const data = Buffer.alloc(size, 0x41); // 'A'
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => {
+          socket.write(data);
+          socket.end();
+        });
+        const received = await new Promise<Buffer>((resolve, reject) => {
+          const chunks: Buffer[] = [];
+          const client = createConnection({ port, host: '127.0.0.1' });
+          client.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+          client.on('end', () => resolve(Buffer.concat(chunks)));
+          client.on('error', reject);
+        });
+        expect(received.length).toBe(size);
+      });
+    });
+  });
+
+  // ---- Connection events ----
+
+  await describe('net TCP: connection events', async () => {
+    await it('should emit connect event on client', async () => {
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => socket.end());
+        const connected = await new Promise<boolean>((resolve) => {
+          const client = createConnection({ port, host: '127.0.0.1' });
+          client.on('connect', () => {
+            client.end();
+            resolve(true);
+          });
+        });
+        expect(connected).toBe(true);
+      });
+    });
+
+    await it('should emit close event after end', async () => {
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => socket.end('bye'));
+        const closed = await new Promise<boolean>((resolve) => {
+          const client = createConnection({ port, host: '127.0.0.1' });
+          client.on('close', () => resolve(true));
+          client.resume(); // Consume data to allow close
+        });
+        expect(closed).toBe(true);
+      });
+    });
+
+    await it('should emit end event when server closes', async () => {
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => socket.end());
+        const ended = await new Promise<boolean>((resolve) => {
+          const client = createConnection({ port, host: '127.0.0.1' });
+          client.on('end', () => {
+            client.end();
+            resolve(true);
+          });
+        });
+        expect(ended).toBe(true);
+      });
+    });
+
+    await it('should track connection count via server event', async () => {
+      let connectionCount = 0;
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => {
+          connectionCount++;
+          socket.end();
+        });
+        for (let i = 0; i < 3; i++) {
+          await new Promise<void>((resolve) => {
+            const client = createConnection({ port, host: '127.0.0.1' });
+            client.on('close', () => resolve());
+            client.resume();
+          });
+        }
+      });
+      expect(connectionCount).toBe(3);
+    });
+  });
+
+  // ---- Server properties ----
+
+  await describe('net TCP: server properties', async () => {
+    await it('should return address with port and family', async () => {
+      await withServer(async (server, port) => {
+        const addr = server.address() as { port: number; family: string; address: string };
+        expect(addr.port).toBe(port);
+        expect(addr.port).toBeGreaterThan(0);
+        expect(typeof addr.address).toBe('string');
+      });
+    });
+
+    await it('should set listening to true after listen', async () => {
+      await withServer(async (server) => {
+        expect(server.listening).toBe(true);
+      });
+    });
+
+    await it('should allocate random port when 0 specified', async () => {
+      const server = createServer();
+      await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', () => resolve()));
+      const addr = server.address() as { port: number };
+      expect(addr.port).toBeGreaterThan(0);
+      expect(addr.port).toBeLessThan(65536);
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    });
+  });
+
+  // ---- Socket properties ----
+
+  await describe('net TCP: socket properties', async () => {
+    await it('should expose remoteAddress and remotePort after connect', async () => {
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => socket.end());
+        const { remoteAddress, remotePort } = await new Promise<{ remoteAddress: string; remotePort: number }>((resolve) => {
+          const client = createConnection({ port, host: '127.0.0.1' }, () => {
+            resolve({
+              remoteAddress: client.remoteAddress!,
+              remotePort: client.remotePort!,
+            });
+            client.end();
+          });
+        });
+        expect(remoteAddress).toBe('127.0.0.1');
+        expect(remotePort).toBe(port);
+      });
+    });
+
+    await it('should expose localPort after connect', async () => {
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => socket.end());
+        const localPort = await new Promise<number>((resolve) => {
+          const client = createConnection({ port, host: '127.0.0.1' }, () => {
+            resolve(client.localPort!);
+            client.end();
+          });
+        });
+        expect(localPort).toBeGreaterThan(0);
+      });
+    });
+  });
+
+  // ---- Data encoding ----
+
+  await describe('net TCP: data encoding', async () => {
+    await it('should transfer UTF-8 strings', async () => {
+      const testStr = 'Hallo Welt! 你好世界';
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => {
+          socket.write(testStr, 'utf8');
+          socket.end();
+        });
+        const received = await new Promise<string>((resolve, reject) => {
+          const chunks: string[] = [];
+          const client = createConnection({ port, host: '127.0.0.1' });
+          client.setEncoding('utf8');
+          client.on('data', (data) => chunks.push(data));
+          client.on('end', () => resolve(chunks.join('')));
+          client.on('error', reject);
+        });
+        expect(received).toBe(testStr);
+      });
+    });
+
+    await it('should transfer binary data', async () => {
+      const binary = Buffer.from([0x00, 0x01, 0x80, 0xff, 0xfe]);
+      await withServer(async (server, port) => {
+        server.on('connection', (socket) => {
+          socket.write(binary);
+          socket.end();
+        });
+        const received = await new Promise<Buffer>((resolve, reject) => {
+          const chunks: Buffer[] = [];
+          const client = createConnection({ port, host: '127.0.0.1' });
+          client.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+          client.on('end', () => resolve(Buffer.concat(chunks)));
+          client.on('error', reject);
+        });
+        expect(received.length).toBe(5);
+        expect(received[0]).toBe(0x00);
+        expect(received[2]).toBe(0x80);
+        expect(received[4]).toBe(0xfe);
+      });
+    });
+  });
+
+  // ---- Error handling ----
+
+  await describe('net TCP: error handling', async () => {
+    await it('should emit error for connection refused', async () => {
+      const err = await new Promise<Error>((resolve) => {
+        // Port 1 is almost certainly not listening
+        const client = createConnection({ port: 1, host: '127.0.0.1' });
+        client.on('error', (e) => resolve(e));
+      });
+      expect(err).toBeDefined();
+      expect((err as NodeJS.ErrnoException).code).toBeDefined();
+    });
+
+    await it('should handle server close while client connected', async () => {
+      const server = createServer((socket) => {
+        // Close server immediately
+        server.close();
+        socket.end('goodbye');
+      });
+      await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', () => resolve()));
+      const port = (server.address() as { port: number }).port;
+
+      const data = await new Promise<string>((resolve) => {
+        const client = createConnection({ port, host: '127.0.0.1' });
+        client.setEncoding('utf8');
+        const chunks: string[] = [];
+        client.on('data', (chunk) => chunks.push(chunk));
+        client.on('end', () => resolve(chunks.join('')));
+      });
+      expect(data).toBe('goodbye');
+    });
+  });
+};

package/src/server.ts

@@ -0,0 +1,186 @@
+// Reference: Node.js lib/net.js
+// Reimplemented for GJS using Gio.SocketService
+
+import Gio from '@girs/gio-2.0';
+import GLib from '@girs/glib-2.0';
+import { EventEmitter } from 'node:events';
+import { createNodeError, deferEmit, ensureMainLoop } from '@gjsify/utils';
+import type { ErrnoException } from '@gjsify/utils';
+import { Socket } from './socket.js';
+
+export interface ListenOptions {
+  port?: number;
+  host?: string;
+  backlog?: number;
+  exclusive?: boolean;
+}
+
+// GC guard — GJS garbage-collects objects with no JS references.
+// Keep strong references to all listening servers to prevent their
+// Gio.SocketService from being collected while still active.
+const _activeServers = new Set<Server>();
+
+export class Server extends EventEmitter {
+  listening = false;
+  maxConnections?: number;
+  allowHalfOpen: boolean;
+
+  private _service: Gio.SocketService | null = null;
+  private _connections = new Set<Socket>();
+  private _address: { port: number; family: string; address: string } | null = null;
+
+  constructor(connectionListener?: (socket: Socket) => void);
+  constructor(options?: { allowHalfOpen?: boolean }, connectionListener?: (socket: Socket) => void);
+  constructor(
+    optionsOrListener?: { allowHalfOpen?: boolean } | ((socket: Socket) => void),
+    connectionListener?: (socket: Socket) => void,
+  ) {
+    super();
+
+    if (typeof optionsOrListener === 'function') {
+      connectionListener = optionsOrListener;
+      this.allowHalfOpen = false;
+    } else {
+      this.allowHalfOpen = optionsOrListener?.allowHalfOpen ?? false;
+    }
+
+    if (connectionListener) {
+      this.on('connection', connectionListener);
+    }
+  }
+
+  /**
+   * Start listening for connections.
+   */
+  listen(port?: number, host?: string, backlog?: number, callback?: () => void): this;
+  listen(port?: number, host?: string, callback?: () => void): this;
+  listen(port?: number, callback?: () => void): this;
+  listen(options?: ListenOptions, callback?: () => void): this;
+  listen(...args: unknown[]): this {
+    let port = 0;
+    let host = '0.0.0.0';
+    let backlog = 511;
+    let callback: (() => void) | undefined;
+
+    // Parse overloaded arguments
+    if (typeof args[0] === 'object' && args[0] !== null && !Array.isArray(args[0])) {
+      const opts = args[0] as ListenOptions;
+      port = opts.port ?? 0;
+      host = opts.host ?? '0.0.0.0';
+      backlog = opts.backlog ?? 511;
+      callback = args[1] as (() => void) | undefined;
+    } else {
+      if (typeof args[0] === 'number') port = args[0];
+      for (let i = 1; i < args.length; i++) {
+        if (typeof args[i] === 'string') host = args[i] as string;
+        else if (typeof args[i] === 'number') backlog = args[i] as number;
+        else if (typeof args[i] === 'function') callback = args[i] as () => void;
+      }
+    }
+
+    if (callback) {
+      this.once('listening', callback);
+    }
+
+    try {
+      this._service = new Gio.SocketService();
+      this._service.set_backlog(backlog);
+
+      let actualPort: number;
+      if (port === 0) {
+        actualPort = this._service.add_any_inet_port(null);
+      } else {
+        this._service.add_inet_port(port, null);
+        actualPort = port;
+      }
+
+      // Connect the incoming signal
+      this._service.connect('incoming', (_service: Gio.SocketService, connection: Gio.SocketConnection) => {
+        this._handleConnection(connection);
+        return true;
+      });
+
+      this._service.start();
+      ensureMainLoop();
+      this.listening = true;
+      _activeServers.add(this);
+
+      // Determine address info
+      const family = host.includes(':') ? 'IPv6' : 'IPv4';
+      this._address = { port: actualPort, family, address: host };
+
+      // Emit listening asynchronously (matching Node.js behavior)
+      deferEmit(this, 'listening');
+    } catch (err: unknown) {
+      const nodeErr = createNodeError(err, 'listen', { address: host, port });
+      deferEmit(this, 'error', nodeErr);
+    }
+
+    return this;
+  }
+
+  private _handleConnection(connection: Gio.SocketConnection): void {
+    if (this.maxConnections && this._connections.size >= this.maxConnections) {
+      try { connection.close(null); } catch { /* ignore */ }
+      return;
+    }
+
+    // Create a Socket wrapping this connection
+    const socket = new Socket({ allowHalfOpen: this.allowHalfOpen });
+
+    // Inject the connection directly (bypass connect())
+    socket._setConnection(connection);
+    socket._setupConnection({});
+
+    this._connections.add(socket);
+    socket.on('close', () => {
+      this._connections.delete(socket);
+    });
+
+    this.emit('connection', socket);
+  }
+
+  /** Get the address the server is listening on. */
+  address(): { port: number; family: string; address: string } | null {
+    return this._address;
+  }
+
+  /** Close the server, stop accepting new connections. */
+  close(callback?: (err?: Error) => void): this {
+    if (callback) {
+      this.once('close', callback);
+    }
+
+    if (!this._service || !this.listening) {
+      setTimeout(() => {
+        const err = new Error('Server is not running') as ErrnoException;
+        err.code = 'ERR_SERVER_NOT_RUNNING';
+        this.emit('error', err);
+      }, 0);
+      return this;
+    }
+
+    this._service.stop();
+    this._service.close();
+    this._service = null;
+    this.listening = false;
+    _activeServers.delete(this);
+
+    // Close all existing connections
+    for (const socket of this._connections) {
+      socket.destroy();
+    }
+    this._connections.clear();
+
+    deferEmit(this, 'close');
+    return this;
+  }
+
+  /** Get the number of concurrent connections. */
+  getConnections(callback: (err: Error | null, count: number) => void): void {
+    callback(null, this._connections.size);
+  }
+
+  ref(): this { return this; }
+  unref(): this { return this; }
+}