npm package: @siran/chat-core
Description: Package core du système de chat.
Latest version: 0.1.7

# core

Package core du système de chat.

Ce package contient la logique métier pure (Clean Architecture) pour gérer les conversations et messages, indépendamment de toute technologie.

## Installation

```bash
bun install
```

## ChatEngine

Le `ChatEngine` est le point d'entrée principal pour utiliser le système de chat. Il fournit :

- Une factory pour créer une instance avec les adaptateurs (repositories, event emitter)
- Une configuration des règles métier (longueur max des messages, délais d'édition/suppression, etc.)
- Accès centralisé à tous les use cases

**Important** : Le ChatEngine est **stateless** et ne gère pas les abonnements temps réel. Utilisez le `ChatClient` pour gérer les abonnements et la mise en cache.

### Utilisation

```typescript
import { createChatEngine } from "@packages/chat/core";
import type { ChatEngineDependencies } from "@packages/chat/core";

// Créer les adaptateurs (repositories, event emitter)
const dependencies: ChatEngineDependencies = {
  conversationRepository: myConversationRepository,
  messageRepository: myMessageRepository,
  eventEmitter: myEventEmitter,
};

// Créer le ChatEngine avec configuration personnalisée
const engine = createChatEngine(dependencies, {
  maxMessageLength: 5000,
  messageEditTimeoutMs: 15 * 60 * 1000, // 15 minutes
  messageDeleteTimeoutMs: 30 * 60 * 1000, // 30 minutes
  maxGroupParticipants: 50,
});

// Utiliser les use cases
const result = await engine.sendMessage({
  conversationId: "conv-123",
  senderId: "user-456",
  content: "Hello!",
});

if (result.ok) {
  console.log("Message envoyé:", result.value);
} else {
  console.error("Erreur:", result.error, result.message);
}
```

**Note** : Pour gérer les abonnements aux événements temps réel, utilisez le `ChatClient` séparément :

```typescript
import { createChatClient } from "@packages/chat/client";

const client = createChatClient(eventSubscriber);
client.onMessageReceived((message, conversationId) => {
  console.log("Nouveau message reçu:", message);
});
client.subscribeToConversation("conv-123");
```

### Configuration

La configuration par défaut peut être surchargée :

- `maxMessageLength`: Longueur maximale du contenu d'un message (défaut: 10000)
- `minParticipants`: Nombre minimum de participants (défaut: 2)
- `maxGroupParticipants`: Nombre maximum de participants dans un groupe (défaut: undefined = pas de limite)
- `messageEditTimeoutMs`: Délai pour éditer un message (défaut: undefined = pas de limite)
- `messageDeleteTimeoutMs`: Délai pour supprimer un message (défaut: undefined = pas de limite)

## Architecture

Ce package suit les principes de Clean Architecture :

- **Domain**: Entités et objets de valeur (`Conversation`, `ChatMessage`)
- **Application**: Use cases et ports (interfaces)
- **Infrastructure**: Implémentations des repositories (dans d'autres packages)

## Use Cases Disponibles

- `createConversation`: Créer une nouvelle conversation
- `sendMessage`: Envoyer un message dans une conversation
- `editMessage`: Éditer un message existant
- `deleteMessage`: Supprimer un message (soft delete)
- `markMessageAsRead`: Marquer un message comme lu
- `getConversations`: Récupérer les conversations d'un utilisateur
- `getMessages`: Récupérer les messages d'une conversation

## Architecture

Le ChatEngine fait partie de la couche **core** (logique métier) du système de chat :

```
ChatEngine (core)     →  Logique métier (use cases, validation) - STATELESS
     ↓
ChatClient (client)   →  Abonnements, cache, distribution d'événements - STATEFUL
     ↓
UI Layer              →  Interfaces utilisateur (React, React Native, etc.)
```

Pour gérer les abonnements aux événements temps réel, utilisez le `ChatClient` qui est conçu spécifiquement pour cela. Voir la documentation du `ChatClient` pour plus de détails.