# TcpEvents

**Kind:** Type

**Source:** [`packages/microservices/events/tcp.events.ts`](https://github.com/nestjs/nest/blob/master/packages/microservices/events/tcp.events.ts#L31)

**Part of:** [Microservices](subsystem-packages-microservices)

TCP events map for the net TCP socket.
Key is the event name and value is the corresponding callback function.

`TcpEvents` defines the event-to-callback map used by the microservices TCP transport. It connects Node.js `net.Socket` lifecycle and data events—such as incoming data, connection errors, and socket closure—to the handlers responsible for processing them.

## Definition

```ts
{ error: OnErrorCallback; connect: VoidCallback; end: VoidCallback; close: VoidCallback; timeout: VoidCallback; drain: VoidCallback; lookup: OnLookupCallback; }
```

## Diagram

```mermaid
graph LR
  Socket[net.Socket] -->|data| DataHandler[TcpEvents.data callback]
  Socket -->|error| ErrorHandler[TcpEvents.error callback]
  Socket -->|close| CloseHandler[TcpEvents.close callback]

  DataHandler --> Transport[TCP transport processing]
  ErrorHandler --> Transport
  CloseHandler --> Transport
```

## Usage

```ts
import type { Socket } from 'node:net';
import type { TcpEvents } from './tcp.events';

function registerSocketEvents(socket: Socket, events: TcpEvents): void {
  for (const [eventName, callback] of Object.entries(events)) {
    socket.on(eventName, callback);
  }
}

const events: TcpEvents = {
  data: (chunk: Buffer) => {
    console.log('Received TCP payload:', chunk.toString());
  },
  error: (error: Error) => {
    console.error('TCP socket error:', error);
  },
  close: () => {
    console.log('TCP socket closed');
  },
};

registerSocketEvents(socket, events);
```

## AI Coding Instructions

- Keep event keys aligned with supported Node.js `net.Socket` event names and ensure each callback matches that event's argument signature.
- Always provide an `error` handler when registering TCP socket events to prevent unhandled socket errors.
- Treat `data` payloads as stream chunks; buffer and frame them when application messages may span multiple chunks.
- Remove listeners or release associated connection state after `close` to avoid memory leaks.
- Register `TcpEvents` handlers immediately after creating or accepting a socket, before writing application data.