npm package: @nivaldeir/chat-timereal-core
Description: Biblioteca de chat em tempo real baseada em Socket.io
Latest version: 1.0.2

# 📚 Exemplos de Uso

Este diretório contém exemplos práticos de como usar as bibliotecas **Client** e **Server** do Chat em Tempo Real.

## 📋 Índice

- [Cliente (Frontend)](#-cliente-frontend)
- [Servidor (Backend)](#-servidor-backend)
- [Executando os Exemplos](#-executando-os-exemplos)

---

## 🖥️ Cliente (Frontend)

O exemplo `client-usage.ts` demonstra como usar a biblioteca do cliente para se conectar ao servidor e interagir com o chat.

### Funcionalidades Demonstradas

- ✅ Conexão ao servidor Socket.IO
- ✅ Escutar eventos de conexão
- ✅ Enviar mensagens
- ✅ Entrar em salas
- ✅ Buscar mensagens
- ✅ Receber mensagens em tempo real

### Código de Exemplo

```typescript
import { ChatClient } from '../src/client/index';

// Criar instância do cliente
const client = new ChatClient({
  url: 'http://localhost:3001',
  autoConnect: true,
});

// Escutar evento de conexão
client.on('connect', () => {
  console.log('Conectado!');
});

// Escutar novas mensagens
client.on('message', (message) => {
  console.log('Nova mensagem:', message);
});

// Enviar mensagem
client.sendMessage({
  userId: 'user-1',
  username: 'Alice',
  message: 'Olá!',
  roomId: 'room-1',
});

// Entrar em uma sala
client.joinRoom('room-1', 'Alice');

// Buscar mensagens
client.getMessages('room-1', 10);

// Escutar mensagens recebidas
client.on('messages', (messages) => {
  console.log('Mensagens recebidas:', messages);
});
```

### Métodos Disponíveis

| Método | Descrição |
|--------|-----------|
| `connect()` | Conecta ao servidor |
| `disconnect()` | Desconecta do servidor |
| `isConnected()` | Verifica se está conectado |
| `sendMessage(data)` | Envia uma mensagem |
| `joinRoom(roomId, username?)` | Entra em uma sala |
| `leaveRoom(roomId)` | Sai de uma sala |
| `createRoom(roomName, username?)` | Cria uma nova sala |
| `getMessages(roomId?, limit?)` | Busca mensagens |
| `saveMessage(messageId, save)` | Marca mensagem como salva |
| `on(event, callback)` | Escuta eventos |
| `off(event, callback?)` | Remove listener de eventos |

### Eventos Disponíveis

| Evento | Descrição |
|--------|-----------|
| `connect` | Quando conecta ao servidor |
| `disconnect` | Quando desconecta |
| `message` | Nova mensagem recebida |
| `messageSaved` | Confirmação de mensagem salva |
| `messages` | Lista de mensagens retornada |
| `userJoined` | Usuário entrou na sala |
| `userLeft` | Usuário saiu da sala |
| `roomCreated` | Nova sala criada |
| `roomJoined` | Entrou em uma sala |
| `roomLeft` | Saiu de uma sala |
| `messageError` | Erro ao processar mensagem |

---

## 🖥️ Servidor (Backend)

O exemplo `server-usage.ts` demonstra como configurar e inicializar o servidor Socket.IO com todas as funcionalidades.

### Funcionalidades Demonstradas

- ✅ Configuração do servidor Express
- ✅ Inicialização do Socket.IO
- ✅ Middleware de autenticação
- ✅ Configuração do MessageService
- ✅ Setup dos handlers de socket

### Código de Exemplo

```typescript
import express from 'express';
import { createServer } from 'http';
import {
  SocketConfig,
  setupSocketHandlers,
  MessageService,
  InMemoryMessageRepository,
  AuthenticatedSocket,
} from '../src/server/index';

const app = express();
const httpServer = createServer(app);

// Middleware de autenticação
function authenticateMiddleware(socket: any, next: any) {
  const userId = socket.handshake.auth?.userId || `user-${Date.now()}`;
  const username = socket.handshake.auth?.username || `user-${Date.now()}`;

  (socket as AuthenticatedSocket).userId = userId;
  (socket as AuthenticatedSocket).username = username;
  (socket as AuthenticatedSocket).socketId = socket.id;
  (socket as AuthenticatedSocket).joinedAt = Date.now();

  next();
}

// Configurar serviços
const messageRepository = new InMemoryMessageRepository();
const messageService = new MessageService(messageRepository);

// Inicializar Socket.IO
const io = SocketConfig.initialize(httpServer, authenticateMiddleware);
setupSocketHandlers(io, messageService);

// Iniciar servidor
httpServer.listen(3001, () => {
  console.log('Servidor rodando na porta 3001');
});
```

### Componentes Principais

#### SocketConfig
Gerencia a configuração e instância do Socket.IO server.

```typescript
const io = SocketConfig.initialize(httpServer, authenticateMiddleware);
```

#### MessageService
Serviço para gerenciar mensagens (salvar, buscar, deletar).

```typescript
const messageRepository = new InMemoryMessageRepository();
const messageService = new MessageService(messageRepository);
```

#### setupSocketHandlers
Configura todos os handlers de eventos do Socket.IO.

```typescript
setupSocketHandlers(io, messageService);
```

---

## 🚀 Executando os Exemplos

### Pré-requisitos

```bash
npm install
```

### Executar o Servidor

```bash
# Opção 1: Usar o servidor completo com API REST
npm run start

# Opção 2: Executar apenas o exemplo do servidor
npx tsx examples/server-usage.ts
```

### Executar o Cliente

```bash
# Em outro terminal, execute o exemplo do cliente
npx tsx examples/client-usage.ts
```

### Executar Ambos

1. **Terminal 1** - Inicie o servidor:
   ```bash
   npm run start
   ```

2. **Terminal 2** - Execute o cliente:
   ```bash
   npx tsx examples/client-usage.ts
   ```

---

## 📖 Exemplos Adicionais

### Exemplo: Cliente Completo

```typescript
import { ChatClient } from '../src/client/index';

const client = new ChatClient({
  url: 'http://localhost:3001',
  autoConnect: true,
  transports: ['websocket'],
  reconnection: true,
  reconnectionDelay: 1000,
  reconnectionAttempts: 5,
});

// Eventos de conexão
client.on('connect', () => {
  console.log('✅ Conectado!', client.getSocketId());
});

client.on('disconnect', (reason) => {
  console.log('❌ Desconectado:', reason);
});

// Eventos de mensagens
client.on('message', (message) => {
  console.log(`📨 [${message.username}]: ${message.message}`);
});

client.on('messageSaved', (data) => {
  console.log('💾 Mensagem salva:', data.messageId);
});

// Eventos de salas
client.on('userJoined', (user) => {
  console.log(`👤 ${user.username} entrou na sala`);
});

client.on('roomJoined', (data) => {
  console.log(`🚪 Entrou na sala: ${data.roomId}`);
});

// Enviar mensagem
client.sendMessage({
  userId: 'user-1',
  username: 'Alice',
  message: 'Olá, mundo!',
  roomId: 'room-1',
});
```

### Exemplo: Servidor com API REST

Veja o arquivo `server.ts` na raiz do projeto para um exemplo completo de servidor com endpoints REST para testar via Postman.

---

## 🔗 Links Úteis

- [Documentação Socket.IO](https://socket.io/docs/v4/)
- [Collection Postman](./../postman-examples.json) - Importe no Postman para testar a API REST

---

## 💡 Dicas

1. **Desenvolvimento**: Use `npm run dev` para watch mode durante o desenvolvimento
2. **Build**: Execute `npm run build` para gerar os arquivos compilados
3. **Testes**: Use os endpoints REST do `server.ts` para testar via Postman
4. **Tipos**: Todos os tipos estão disponíveis em `src/shared/types.ts`

---

## 📝 Notas

- Os exemplos usam `InMemoryMessageRepository` que armazena mensagens apenas em memória
- Para produção, implemente um repositório com banco de dados
- O middleware de autenticação é básico; implemente autenticação real conforme necessário

---

**Desenvolvido com ❤️ usando Socket.IO**