# Ejemplos de Uso - whatsapp-crm-common

## 🚀 Configuración Inicial

### Opción 1: Solo variables de entorno

```typescript
// .env
REDIS_URL=redis://localhost:6379
DATABASE_URL=postgresql://user:pass@localhost:5432/whatsapp_crm
LOG_LEVEL=info
ENABLE_MESSAGE_QUEUE=true

// app.ts
import { RedisClient, logger } from 'whatsapp-crm-common';

const redis = RedisClient.getInstance();
logger.info('Redis conectado automáticamente');
```

### Opción 2: Configuración programática completa

```typescript
import { 
  configureWhatsAppCommon, 
  RedisClient, 
  WhatsAppMessageQueue 
} from 'whatsapp-crm-common';

// Configurar antes de usar cualquier componente
configureWhatsAppCommon({
  redis: {
    host: 'redis.mi-empresa.com',
    port: 6379,
    password: 'mi-super-password',
    db: 2
  },
  database: {
    url: 'postgresql://user:pass@db.mi-empresa.com:5432/crm_prod'
  },
  logging: {
    level: 'debug'
  },
  queue: {
    enabled: true,
    concurrency: 15,
    workerEnabled: true
  }
});

// Usar componentes (ya configurados automáticamente)
const redis = RedisClient.getInstance();
const queue = new WhatsAppMessageQueue(redis);
```

### Opción 3: Configuración mixta (recomendada para producción)

```typescript
import { configureWhatsAppCommon } from 'whatsapp-crm-common';

// Configurar solo lo específico del entorno
configureWhatsAppCommon({
  redis: {
    // Usa configuración específica para Redis
    url: process.env.REDIS_CLUSTER_URL || 'redis://localhost:6379',
    password: process.env.REDIS_PASSWORD
  },
  // El resto se toma de variables de entorno
});
```

## 🔧 Casos de Uso Comunes

### 1. Microservicio API

```typescript
// api-service/src/app.ts
import { 
  configureWhatsAppCommon,
  EventPublisher,
  logger 
} from 'whatsapp-crm-common';

// Configuración específica del API
configureWhatsAppCommon({
  logging: { level: 'info' },
  queue: { enabled: false }, // API solo publica, no procesa
});

const eventPublisher = new EventPublisher();

// En un endpoint
app.post('/webhook/whatsapp', async (req, res) => {
  const { tenantId, agentId, message } = req.body;
  
  await eventPublisher.publishMessageReceived(tenantId, agentId, [message]);
  
  logger.info({
    tenantId,
    agentId,
    messageId: message.id,
    msg: 'Mensaje recibido y encolado'
  });
  
  res.status(200).send('OK');
});
```

### 2. Worker Service

```typescript
// worker-service/src/worker.ts
import { 
  configureWhatsAppCommon,
  WhatsAppMessageQueue,
  RedisClient,
  HybridEventRouter,
  logger 
} from 'whatsapp-crm-common';

// Configuración específica del Worker
configureWhatsAppCommon({
  logging: { level: 'debug' },
  queue: { 
    enabled: true,
    concurrency: 10,
    workerEnabled: true 
  },
});

const redis = RedisClient.getInstance();
const messageQueue = new WhatsAppMessageQueue(redis);
const eventRouter = new HybridEventRouter(redis);

// Procesar mensajes
messageQueue.addWorker('REALTIME', async (job) => {
  const { tenantId, agentId, messages } = job.data;
  
  logger.info({
    tenantId,
    agentId,
    messageCount: messages.length,
    msg: 'Procesando mensajes'
  });
  
  // Procesar mensajes...
  
  // Notificar via Pub/Sub para updates en tiempo real
  await eventRouter.publishToChannel('message-processed', {
    tenantId,
    agentId,
    processedCount: messages.length
  });
});
```

### 3. Aplicación Full-Stack

```typescript
// shared/config.ts
import { configureWhatsAppCommon } from 'whatsapp-crm-common';

export function initializeConfig() {
  configureWhatsAppCommon({
    redis: {
      url: process.env.REDIS_URL,
      password: process.env.REDIS_PASSWORD,
    },
    database: {
      url: process.env.DATABASE_URL,
    },
    logging: {
      level: process.env.NODE_ENV === 'production' ? 'info' : 'debug'
    },
    queue: {
      enabled: process.env.ENABLE_WORKERS === 'true',
      concurrency: parseInt(process.env.WORKER_CONCURRENCY || '5'),
    },
    webhook: {
      url: process.env.WEBHOOK_URL,
    },
    whatsapp: {
      maxSessionsPerProcess: parseInt(process.env.MAX_SESSIONS || '50'),
      syncFullHistory: process.env.SYNC_HISTORY === 'true',
    }
  });
}

// main.ts
import { initializeConfig } from './shared/config';
import { RedisClient, logger } from 'whatsapp-crm-common';

// Inicializar configuración al arrancar la app
initializeConfig();

// Todos los componentes usarán la configuración automáticamente
const redis = RedisClient.getInstance();
logger.info('Aplicación iniciada correctamente');
```

## 🔄 Migración desde versión 0.1.0

### Antes (v0.1.0)

```typescript
import { environment, RedisClient } from 'whatsapp-crm-common';

const redis = RedisClient.getInstance({
  url: environment.redisUrl
});
```

### Después (v0.2.0+)

```typescript
import { RedisClient } from 'whatsapp-crm-common';

// Opción 1: Automático (usa .env del proyecto)
const redis = RedisClient.getInstance();

// Opción 2: Con configuración programática
configureWhatsAppCommon({
  redis: { url: 'redis://mi-servidor:6379' }
});
const redis = RedisClient.getInstance();
```

## 🐛 Debugging y Troubleshooting

### Ver configuración actual

```typescript
import { getConfig } from 'whatsapp-crm-common';

console.log('Configuración actual:', getConfig());
```

### Configuración paso a paso

```typescript
import { 
  configureWhatsAppCommon, 
  getConfig, 
  RedisClient 
} from 'whatsapp-crm-common';

// 1. Ver configuración por defecto
console.log('Config inicial:', getConfig());

// 2. Configurar programáticamente
configureWhatsAppCommon({
  redis: { host: 'mi-redis.com', port: 6380 }
});

// 3. Ver configuración mezclada
console.log('Config después:', getConfig());

// 4. Usar Redis
const redis = RedisClient.getInstance();
```

### Logging detallado

```typescript
configureWhatsAppCommon({
  logging: { level: 'debug' }
});

// Ahora todos los logs serán más detallados
```

## 🧪 Testing

### Configuración para tests

```typescript
// tests/setup.ts
import { configureWhatsAppCommon } from 'whatsapp-crm-common';

configureWhatsAppCommon({
  redis: {
    host: 'localhost',
    port: 6380, // Puerto diferente para tests
    db: 15      // DB diferente para tests
  },
  logging: {
    level: 'silent' // Sin logs en tests
  },
  queue: {
    enabled: false // Deshabilitar colas en tests
  }
});
```

### Test unitario

```typescript
// tests/redis.test.ts
import { RedisClient, configureWhatsAppCommon } from 'whatsapp-crm-common';

describe('RedisClient', () => {
  beforeAll(() => {
    configureWhatsAppCommon({
      redis: { host: 'localhost', port: 6380, db: 15 }
    });
  });

  it('should connect to test Redis', async () => {
    const redis = RedisClient.getInstance();
    await redis.connect();
    expect(redis.isConnected()).toBe(true);
  });
});
```