Server Management

/**
 * Creates an HTTP server exclusively used for Engine.IO connections
 * @param port - Port number to listen on
 * @param options - Server configuration options  
 * @param callback - Optional callback when server starts listening
 * @returns Server instance
 */
function listen(
  port: any, 
  options?: ServerOptions & AttachOptions, 
  callback?: any
): Server;

import { listen } from "engine.io";

const server = listen(3000, {
  pingTimeout: 20000,
  transports: ['polling', 'websocket']
}, () => {
  console.log('Engine.IO server listening on port 3000');
});

server.on('connection', (socket) => {
  console.log('New connection:', socket.id);
});

/**
 * Captures upgrade requests for an HTTP server
 * @param server - HTTP server to attach to
 * @param options - Attachment and server options
 * @returns Server instance
 */
function attach(
  server: any, 
  options?: AttachOptions & ServerOptions
): Server;

import { createServer } from "http";
import { attach } from "engine.io";

const httpServer = createServer().listen(3000);
const server = attach(httpServer, {
  path: '/engine.io',
  cors: {
    origin: "https://example.com",
    credentials: true
  }
});

/**
 * Main Engine.IO server class extending BaseServer
 */
class Server extends BaseServer {
  /**
   * Create a new server instance
   * @param opts - Server configuration options
   */
  constructor(opts?: ServerOptions);
  
  /** Server configuration options */
  readonly opts: ServerOptions;
  
  /** Map of connected clients by socket ID */
  readonly clients: Record<string, Socket>;
  
  /** Number of connected clients */
  readonly clientsCount: number;
  
  /** Attached HTTP server reference */
  httpServer?: HttpServer;
}

/**
 * Attach server to an HTTP server instance
 * @param server - HTTP server to attach to
 * @param options - Attachment options
 */
attach(server: HttpServer, options?: AttachOptions): void;

/**
 * Handle incoming HTTP requests for Engine.IO
 * @param req - Incoming HTTP request
 * @param res - HTTP response object
 */
handleRequest(req: IncomingMessage, res: ServerResponse): void;

/**
 * Handle HTTP upgrade requests for WebSocket connections
 * @param req - Upgrade request
 * @param socket - TCP socket
 * @param head - First packet of upgraded stream
 */
handleUpgrade(req: IncomingMessage, socket: Socket, head: Buffer): void;

/**
 * Generate unique socket identifier
 * @param req - Incoming request
 * @returns Unique socket ID string
 */
generateId(req: IncomingMessage): string | Promise<string>;

/**
 * Get available transport upgrades for a transport
 * @param transport - Current transport name
 * @returns Array of available upgrade transport names
 */
upgrades(transport: string): string[];

/**
 * Close server and all connected clients
 */
close(): void;

/**
 * Add middleware function to server
 * @param fn - Middleware function
 */
use(fn: Middleware): void;

/**
 * Handle WebTransport session connections
 * @param session - WebTransport session
 */
onWebTransportSession(session: any): void;

interface ServerEvents {
  /** Emitted when a new client connects */
  connection: (socket: Socket) => void;
  
  /** Emitted when a connection error occurs */
  connection_error: (error: { req: IncomingMessage; code: number; message: string; context: any }) => void;
  
  /** Emitted before response headers are written */
  initial_headers: (headers: Record<string, string>, req: IncomingMessage) => void;
  
  /** Emitted before response headers are sent */
  headers: (headers: Record<string, string>, req: IncomingMessage) => void;
  
  /** Emitted when socket buffer is being flushed */
  flush: (socket: Socket, buffer: any[]) => void;
  
  /** Emitted when socket buffer is drained */
  drain: (socket: Socket) => void;
}

import { Server } from "engine.io";

const server = new Server({
  pingTimeout: 20000,
  pingInterval: 25000,
  transports: ['polling', 'websocket']
});

// Handle connections
server.on('connection', (socket) => {
  console.log(`Client ${socket.id} connected from ${socket.remoteAddress}`);
  
  socket.on('message', (data) => {
    console.log('Message from', socket.id, ':', data);
    socket.send(`Echo: ${data}`);
  });
});

// Handle connection errors
server.on('connection_error', (error) => {
  console.error('Connection error:', error.message);
});

// Add CORS headers middleware
server.use((req, res, next) => {
  res.setHeader('Access-Control-Allow-Origin', '*');
  next();
});

/**
 * Base server implementation with shared functionality
 */
abstract class BaseServer extends EventEmitter {
  /** Server configuration options */
  readonly opts: ServerOptions;
  
  /** Map of connected clients */
  protected clients: Record<string, Socket>;
  
  /** Number of connected clients */
  readonly clientsCount: number;
  
  /** Registered middleware functions */
  protected middlewares: Middleware[];
  
  /**
   * Create base server instance
   * @param opts - Server options
   */
  constructor(opts?: ServerOptions);
  
  /**
   * Add middleware function
   * @param fn - Middleware function
   */
  use(fn: Middleware): void;
  
  /**
   * Close all clients and cleanup
   */
  close(): void;
}

interface ServerErrors {
  /** Map of error codes to error names */
  errors: {
    UNKNOWN_TRANSPORT: 0;
    UNKNOWN_SID: 1;
    BAD_HANDSHAKE_METHOD: 2;
    BAD_REQUEST: 3;
    FORBIDDEN: 4;
    UNSUPPORTED_PROTOCOL_VERSION: 5;
  };
  
  /** Map of error codes to error messages */
  errorMessages: {
    0: "Transport unknown";
    1: "Session ID unknown";
    2: "Bad handshake method";
    3: "Bad request";
    4: "Forbidden";
    5: "Unsupported protocol version";
  };
}

/**
 * Express-compatible middleware function
 */
type Middleware = (
  req: IncomingMessage,
  res: ServerResponse,
  next: (err?: any) => void
) => void;

// Authentication middleware
server.use((req, res, next) => {
  const token = req.headers.authorization;
  if (!token) {
    res.writeHead(401);
    res.end('Unauthorized');
    return;
  }
  next();
});

// Logging middleware
server.use((req, res, next) => {
  console.log(`${req.method} ${req.url} from ${req.socket.remoteAddress}`);
  next();
});

/**
 * Engine.IO server based on µWebSockets.js package
 */
class uServer extends BaseServer {
  /**
   * Create uServer instance
   * @param opts - Server options
   */
  constructor(opts?: ServerOptions);
  
  /**
   * Attach uServer to µWebSockets.js app
   * @param app - µWebSockets.js TemplatedApp instance
   * @param options - Attachment and µWebSockets.js options
   */
  attach(app: any, options?: AttachOptions & uOptions): void;
}

import { uServer } from "engine.io";
import { App } from "uWebSockets.js";

const app = App();
const server = new uServer({
  pingTimeout: 20000,
  pingInterval: 25000
});

server.attach(app, {
  path: '/engine.io',
  compression: 1, // Enable compression
  idleTimeout: 120,
  maxBackpressure: 1024 * 1024
});

server.on('connection', (socket) => {
  console.log('High-performance connection:', socket.id);
});

app.listen(3000, (token) => {
  if (token) {
    console.log('uServer listening on port 3000');
  } else {
    console.log('Failed to listen on port 3000');
  }
});