# TCP

TCP is the fastest network transport of Deepkit RPC, for communication between servers: microservices, or Node processes that talk to each other. It supports everything WebSocket does (streaming, progress, back controllers, peer-to-peer), without the framing of the WebSocket protocol. Browsers can't open TCP connections, use [WebSocket](https://deepkit.io/en/documentation/rpc/websocket.md) or [HTTP](https://deepkit.io/en/documentation/rpc/http.md) there. To worker threads, Web Workers and child processes of your own application, [IPC](https://deepkit.io/en/documentation/rpc/ipc.md) is faster.

The server and the client are in `@deepkit/rpc-tcp`:

```sh
npm install @deepkit/rpc-tcp
```

## Server

`RpcTcpServer` serves an `RpcKernel` on a host and port:

```typescript
import { RpcKernel, rpc } from '@deepkit/rpc';
import { RpcTcpServer } from '@deepkit/rpc-tcp';

@rpc.controller('user')
class UserController {
    @rpc.action()
    hello(name: string): string {
        return 'Hello ' + name;
    }
}

const kernel = new RpcKernel();
kernel.registerController(UserController, 'user');

const server = new RpcTcpServer(kernel, '0.0.0.0:8811');
await server.start();
```

Instead of a host and port, a path serves on a Unix socket, which is faster between processes on the same machine:

```typescript
const server = new RpcTcpServer(kernel, '/var/run/my-app/rpc.sock');
```

A Unix socket skips the TCP/IP stack of the kernel. On the same machine a small call is about 25% faster than over TCP on localhost (34 µs instead of 45 µs per call to another process on a Linux server), and a result of 100 objects 20% faster. Between threads or to a child process of your own, [IPC](https://deepkit.io/en/documentation/rpc/ipc.md) is faster still.

## Deepkit app

A Deepkit app serves its controllers over WebSocket and, with `httpRpcBasePath`, over HTTP. To serve them over TCP as well, give the `RpcKernel` of the app to an `RpcTcpServer` when the server starts. The controllers, the providers of the app and `RpcKernelSecurity` work the same as over WebSocket:

```typescript
import { App } from '@deepkit/app';
import { FrameworkModule, onServerMainBootstrap, onServerMainShutdown } from '@deepkit/framework';
import { RpcKernel } from '@deepkit/rpc';
import { RpcTcpServer } from '@deepkit/rpc-tcp';

let tcp: RpcTcpServer | undefined;

new App({
    controllers: [UserController],
    imports: [new FrameworkModule()],
})
    .listen(onServerMainBootstrap, async (event, kernel: RpcKernel) => {
        tcp = new RpcTcpServer(kernel, '0.0.0.0:8811');
        await tcp.start();
    })
    .listen(onServerMainShutdown, () => tcp?.close())
    .run();
```

## Client

```typescript
import { RpcClient } from '@deepkit/rpc';
import { RpcTcpClientAdapter } from '@deepkit/rpc-tcp';

const client = new RpcClient(new RpcTcpClientAdapter('localhost:8811'));
const user = client.controller<UserController>('user');

await user.hello('Peter'); // 'Hello Peter'
```

The client connects on the first call and reconnects on the next call after the connection was lost. For a Unix socket, pass its path: `new RpcTcpClientAdapter('/var/run/my-app/rpc.sock')`.

## Authentication

A token set on the client is sent once per connection, and `RpcKernelSecurity.authenticate` turns it into the session of the connection. See [Security](https://deepkit.io/en/documentation/rpc/security.md).

```typescript
client.token.set('my-session-token');
```