🚀 PLAN MAESTRO: Crear un Sistema Completo Tipo Slack
📋 ÍNDICE GENERAL DEL PROYECTO
Parte	Contenido
Parte 1	✅ Análisis completo de Slack: Qué es, características, funcionalidades, arquitectura técnica
Parte 2	🏗️ Arquitectura del sistema a construir + Stack tecnológico recomendado
Parte 3	🗄️ Diseño de base de datos y modelo de datos completo
Parte 4	💻 Backend: APIs, servicios, WebSocket, real-time messaging
Parte 5	🎨 Frontend: Web, Desktop, Mobile + UX/UI
Parte 6	🔧 Integraciones, Automatización, IA, Seguridad, Admin
Parte 7	📦 DevOps, Deployment, Escalabilidad, Monetización y Roadmap
📌 PARTE 1: ANÁLISIS COMPLETO DE SLACK
1.1 ¿QUÉ ES SLACK?
Slack es una plataforma de comunicación y colaboración empresarial basada en la nube que reemplaza el email con un sistema de mensajería en tiempo real organizado por canales. No es solo un chat: es un sistema operativo del trabajo que integra personas, herramientas, archivos, automatización e IA en un solo lugar.

Misión de Slack
"Hacer que la vida laboral de las personas sea más simple, más agradable y más productiva."

Datos clave:
700M+ mensajes enviados diariamente
10M+ usuarios activos diarios
4M+ conexiones WebSocket concurrentes en pico
2.3M queries por segundo en la base de datos (pico)
30-40 deploys al día al monolito principal
2,600+ integraciones disponibles
Propiedad de Salesforce desde 2021
1.2 CARACTERÍSTICAS PRINCIPALES (TODAS LAS QUE DEBES REPLICAR)
🔹 A. COMUNICACIÓN Y COLABORACIÓN
Feature	Descripción	Detalle técnico
Canales públicos	Espacios de conversación abiertos,任何人 puede unirse	Organizados por equipo, proyecto o tema
Canales privados	Solo accesibles por invitación	No aparecen en el buscador de canales
Mensajes directos (DMs)	Conversaciones 1-a-1 privadas	Hasta 9 participantes en grupo
Group DMs nombrados	DMs grupales con nombre personalizado	Nuevo feature 2025
Threads (Hilos)	Respuestas dentro de un mensaje	Mantiene conversaciones organizadas
Mentions (@)	Notificar a usuarios específicos	@usuario, @canal, @aquí, @todos
Reactions (Reacciones emoji)	Reaccionar a mensajes con emojis	Custom emojis disponibles
Pinning mensajes	Fijar mensajes importantes en el canal	Visible en el panel del canal
Bookmarks	Marcar canales y enlaces importantes	A nivel canal y personal
Saved items	Guardar mensajes para después	Personal, no visible para otros
Scheduled messages	Programar mensajes para envío futuro	Por fecha y hora
Reminders	Recordatorios personales o de canal	Integrado con Slackbot
Formatting rico	Negrita, cursiva, código, listas, citas	Markdown-like
Code snippets	Bloques de código con syntax highlighting	Lenguajes detectados automáticamente
Link unfurling	Vista previa de enlaces	Procesamiento asíncrono
Custom emojis	Emojis personalizados por workspace	Subidos por admins/users
🔹 B. LLAMADAS Y VIDEO
Feature	Descripción
Huddles	Audio/video llamadas instantáneas dentro de Slack
Screen sharing	Compartir pantalla en huddles
Video llamadas grupales	Hasta 50 participantes (plan Pro)
Audio clips	Grabar y enviar clips de audio
Video clips	Grabar y enviar clips de video
Huddle notes (AI)	Notas automáticas de reuniones con IA
Whiteboard	Pizarra colaborativa en huddles
Transcripción	Transcripción automática de huddles
🔹 C. GESTIÓN DE PROYECTOS
Feature	Descripción
Lists	Listas de tareas estilo Trello/Asana dentro de Slack
Canvases	Documentos colaborativos ricos (texto, tablas, imágenes, video)
Templates	Plantillas para proyectos, onboarding, standups, etc.
Tasks assignment	Asignar tareas a personas con fechas
Kanban board	Vista tipo board para lists
Comments en tasks	Comentarios dentro de cada tarea
Custom views	Vistas filtradas y ordenadas de lists
Alerts en lists	Notificaciones cuando cambia un campo
🔹 D. SLACK CONNECT (COLABORACIÓN EXTERNA)
Feature	Descripción
Shared channels	Canales compartidos entre organizaciones
DMs externos	Mensajes directos con personas externas
Múltiples organizaciones	Conectar con varios partners externos
Control admin	Aprobación de canales compartidos por admins
🔹 E. IA Y INTELIGENCIA (SLACK AI)
Feature	Descripción
Slackbot (AI Agent)	Agente IA personal que conoce tu equipo y contexto
Conversation summaries	Resúmenes automáticos de canales y threads
Huddle notes	Notas automáticas de reuniones con transcript
Daily recaps	Resumen diario de actividad en canales
File summaries	Resúmenes de documentos compartidos
AI Search	Búsqueda con respuestas generadas por IA
Enterprise search	Búsqueda across todas las apps integradas
Translations	Traducción de mensajes con IA
Workflow generation	Generar workflows con un prompt
MCP (Model Context Protocol)	Conectar herramientas externas al Slackbot
Claude integration	Chat con Claude directamente
GitHub Copilot	Revisión de código dentro de Slack
Agentforce	Análisis de datos CRM dentro de Slack
🔹 F. AUTOMATIZACIÓN Y WORKFLOWS
Feature	Descripción
Workflow Builder	Crear automatizaciones sin código (drag & drop)
Custom workflow steps	Pasos personalizados con código
Conditional branching	Lógica if/else en workflows
Triggers	Emisión por emoji, join a canal, schedule, eventos externos
Slack shortcuts	Acciones rápidas via teclado o menú
Slash commands	Comandos personalizados /comando
Incoming webhooks	Recibir datos de servicios externos
Outgoing webhooks	Enviar datos a servicios externos
Bots	Bots automatizados para tareas
🔹 G. INTEGRACIONES Y PLATAFORMA
Feature	Descripción
App Directory	2,600+ apps integrables
API REST	API completa para desarrolladores
RTM API (WebSocket)	API de mensajería en tiempo real
Events API	Webhooks para eventos
Interactive components	Botones, menús, modales interactivos
Block Kit	Framework para UI rica en mensajes
Modals	Ventanas emergentes interactivas
App home	Página de inicio personalizada para cada app
OAuth 2.0	Autenticación para apps
Custom apps	Apps privadas para tu workspace
🔹 H. BÚSQUEDA Y CONOCIMIENTO
Feature	Descripción
Búsqueda global	Buscar en mensajes, archivos, canales y personas
Filtros de búsqueda	Por tipo, fecha, persona, canal
Búsqueda con IA	Preguntas en lenguaje natural con respuestas
Enterprise search	Buscar en apps externas conectadas
Historial completo	Todos los mensajes archivados y buscables
🔹 I. NOTIFICACIONES Y PRESENCIA
Feature	Descripción
Presence (online/offline/away)	Indicador de estado en tiempo real
Custom status	Estado personalizado con emoji y texto
Do Not Disturb	Silenciar notificaciones por horario
Notification preferences	Configuración granular por canal y tipo
Keyword notifications	Notificar cuando se menciona una palabra clave
Push notifications	Notificaciones móviles
Email notifications	Resúmenes por email
Mobile push	Notificaciones push nativas iOS/Android
🔹 J. ARCHIVOS Y COMPARTIR
Feature	Descripción
File sharing	Subir y compartir archivos en canales y DMs
File preview	Vista previa de imágenes, PDFs, documentos
Google Drive integration	Compartir archivos de Google Drive
Drag & drop	Arrastrar archivos al chat
File comments	Comentarios en archivos
Snippets	Bloques de código compartibles
🔹 K. ADMINISTRACIÓN Y GOBIERNO
Feature	Descripción
Workspace management	Gestión del workspace completo
Roles y permisos	Owner, Admin, User, Guest, Multi-channel guest
User groups	Grupos personalizados (@equipo-marketing)
SCIM provisioning	Provisioning automático de usuarios via SSO
Analytics	Métricas de uso y actividad
Audit logs	Registro de acciones administrativas
Data exports	Exportar mensajes y datos
Retention policies	Políticas de retención de mensajes y archivos
Channel management	Archivar, renombrar, convertir canales
Custom roles	Roles personalizados (Enterprise)
Content flagging	Marcar contenido inapropiado
Domain claiming	Reclamar dominios de email
🔹 L. SEGURIDAD Y CUMPLIMIENTO
Feature	Descripción
Data encryption	Cifrado en tránsito y en reposo
2FA	Autenticación de dos factores
SSO (SAML)	Single Sign-On con proveedores externos
Session management	Duración de sesión configurable
Device management	Gestión de dispositivos nativos
Enterprise Key Management	Claves de cifrado propias (Enterprise)
EMM	Enterprise Mobility Management
Information barriers	Barreras de información entre grupos
Legal holds	Retención legal de datos
DLP	Prevención de pérdida de datos
HIPAA compliance	Cumplimiento HIPAA (Enterprise)
GDPR compliance	Cumplimiento GDPR
Data residency	Datos almacenados en regiones específicas
Anomaly detection	Detección de eventos anómalos
🔹 M. PLATFORMS Y CLIENTES
Cliente	Descripción
Web app	Acceso via navegador
Desktop Windows	App nativa Windows
Desktop macOS	App nativa macOS
Desktop Linux	App nativa Linux
iOS app	App nativa iPhone/iPad
Android app	App nativa Android
Apple Watch	App para Apple Watch
1.3 ARQUITECTURA TÉCNICA DE SLACK (CÓMO FUNCIONA POR DENTRO)
Slack tiene una arquitectura fascinante que ha evolucionado en 10+ años. Aquí está el resumen técnico:

Stack Tecnológico de Slack:
Componente	Tecnología
Backend principal (Webapp)	PHP/Hack corriendo en HHVM (monolito de ~1M líneas)
Base de datos	MySQL con Vitess (sharding middleware)
Cache	Memcached con Mcrouter
Mensajería en tiempo real	Java (Channel Servers, Gateway Servers, Admin Servers, Presence Servers)
Load balancer	Envoy (migrado desde HAProxy)
Edge cache	Flannel (cache personalizado a nivel aplicación)
Service discovery	Consul
Event streaming	Kafka → S3 (Parquet via Secor)
Analytics	Presto, Hive, Spark en AWS EMR
Búsqueda	Apache Solr con ML re-ranking (SVM)
Job queue	Redis (9 billón jobs/día)
Control plane	Rotor (xDS personalizado para Envoy)
Infraestructura	AWS (us-east-1 principal, multi-región para data residency)
Servicios de Tiempo Real (Real-Time Messaging):
Slack tiene 4 tipos de servidores para mensajería en tiempo real:

┌─────────────────────────────────────────────────────────┐
│                    CLIENT (Browser/App)                  │
│                   WebSocket Connection                    │
└──────────────────────────┬──────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                  ENVOY LOAD BALANCER                     │
│              (TLS termination, routing)                  │
└──────────────────────────┬──────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│               GATEWAY SERVER (GS)                        │
│  • Stateful, in-memory                                   │
│  • Termina WebSocket connections                         │
│  • Mantiene suscripciones de canales por usuario         │
│  • Desplegado en múltiples regiones geográficas          │
└──────────────────────────┬──────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│               CHANNEL SERVER (CS)                        │
│  • Stateful, in-memory                                   │
│  • ~16M channels por host                                │
│  • Consistent hashing para mapear canales a servidores   │
│  • Pub/sub: recibe mensaje → broadcast a todos los GS   │
└──────────────────────────┬──────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│               ADMIN SERVER (AS)                          │
│  • Stateless                                             │
│  • Interfaz entre Webapp y Channel Servers               │
│  • Routea mensajes al CS correcto via hash ring          │
└──────────────────────────┬──────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│               PRESENCE SERVER (PS)                       │
│  • In-memory                                             │
│  • Trackea qué usuarios están online                     │
│  • Notifica cambios de presencia                         │
└─────────────────────────────────────────────────────────┘
Flujo de un mensaje:
Usuario A escribe mensaje → HTTP POST al Webapp
Webapp persiste el mensaje en MySQL/Vitess
Webapp envía el evento al Admin Server (AS)
AS hashea el channel_id → encuentra el Channel Server (CS) responsable
CS recibe el mensaje → lo broadcastea a todos los Gateway Servers (GS) globales que tienen suscriptores en ese canal
Cada GS empuja el mensaje via WebSocket a los clientes conectados
Latencia objetivo: < 500ms global end-to-end

Arquitectura Celular (Disponibilidad 99.99%):
Slack usa una arquitectura celular donde cada AZ (Availability Zone) opera como una célula independiente:

Servicios dentro de un AZ solo hablan con servicios del mismo AZ
Si un AZ falla, el tráfico se redirige en 5 minutos con granularidad de 1%
Usan Envoy + Rotor (xDS custom) para peso dinámico por AZ
1.4 PLANES Y PRECIOS DE SLACK
Plan	Precio	Features clave
Free	$0	90 días de historial, 10 integraciones, 1:1 huddles
Pro	$7.25-8.75/usuario/mes	Historial ilimitado, huddles grupales, workflows, AI básico
Business+	$12.50-15/usuario/mes	SSO SAML, data exports, compliance, AI avanzado
Enterprise+	Custom	EKM, HIPAA, DLP, information barriers, audit logs
Slack AI	+$10/usuario/mes	Summaries, recaps, AI search, Slackbot
1.5 CÓMO SLACK AYUDA A UNA EMPRESA
Problemas que resuelve:
Problema	Solución Slack
Email excesivo	Reemplaza cadenas de email con canales organizados
Comunicación dispersa	Centraliza todo en un solo lugar
Falta de contexto	Historial completo buscable + IA summaries
Silos de información	Canales públicos transparentes
Trabajo manual repetitivo	Workflow Builder automatiza tareas
Colaboración externa difícil	Slack Connect con partners/clientes
Reuniones innecesarias	Huddles rápidos async
Onboarding lento	Historial de canales + templates + canvases
Búsqueda de información	Enterprise search + AI-powered search
Falta de visibilidad	Canales públicos, lists, analytics
Beneficios medibles:
90% de usuarios dicen que mejora la comunicación
87% dicen que colaboran más eficientemente
86% sienten que mejoró el trabajo remoto
88% se sienten más conectados con su equipo
97 minutos ahorrados por semana con IA
35% más tiempo ahorrado por automatizaciones
✅ RESUMEN DE LA PARTE 1
Hemos cubierto:

✅ Qué es Slack y su propósito
✅ Todas las funcionalidades categorizadas (13 categorías, 100+ features)
✅ Arquitectura técnica completa (stack, servidores, flujo de mensajes)
✅ Planes y precios
✅ Cómo ayuda a una empresa

📌 PARTE 2: ARQUITECTURA DEL SISTEMA + STACK TECNOLÓGICO
2.1 FILOSOFÍA DE DISEÑO
Antes de elegir tecnologías, debemos definir los principios arquitectónicos que guiarán todo el proyecto:

Principio	Descripción
Escalabilidad horizontal	Cada componente debe poder escalar añadiendo más instancias
Tiempo real primero	La mensajería en tiempo real es el core, todo gira alrededor de esto
Multi-tenant	Soportar múltiples workspaces/empresas en una sola instalación
Modular	Cada servicio es independiente pero se comunican vía APIs bien definidas
Seguridad por diseño	Cifrado, RBAC, auditoría desde el día 1
API-first	Todo funciona a través de APIs (web, mobile, integraciones)
Resilencia	Tolerancia a fallos, circuit breakers, retries, dead letter queues
Observabilidad	Logs, métricas, traces en cada servicio desde el inicio
Developer experience	Fácil de desarrollar, testear y desplegar
2.2 STACK TECNOLÓGICO RECOMENDADO
Vamos a comparar lo que usa Slack vs lo que te recomiendo (tecnologías más modernas y accesibles):

🔹 A. BACKEND PRINCIPAL (API + LÓGICA DE NEGOCIO)
Componente	Slack usa	Recomendado	Por qué
Lenguaje principal	PHP/Hack (HHVM)	Node.js + TypeScript	Ecoistema real-time, npm, WebSocket nativo, misma lengua que frontend
Alternativa	-	Go (Golang)	Alta concurrencia, compilado, rápido, ideal para microservicios
Framework	Custom	NestJS (Node) o Gin/Fiber (Go)	Estructura modular, DI, decoradores, scalable
Monolito vs Microservicios	Monolito PHP + servicios	Modular Monolith → Microservicios gradual	Empezar simple, extraer servicios cuando sea necesario
🔹 B. MENSAJERÍA EN TIEMPO REAL
Componente	Slack usa	Recomendado	Por qué
WebSocket Server	Java custom (Gateway Servers)	Socket.io o ws (Node) / gorilla/websocket (Go)	Maduro, battle-tested, simple
Pub/Sub interno	Java custom (Channel Servers)	Redis Pub/Sub o NATS	Pub/sub ultra rápido, simple de operar
Message queue	Redis (Job Queue)	BullMQ (Node) / Asynq (Go) sobre Redis	Queue con retries, delays, priorities
Event bus	Kafka	Redis Streams (inicio) → Kafka (escala)	Empezar simple con Redis, migrar cuando sea necesario
🔹 C. BASE DE DATOS
Componente	Slack usa	Recomendado	Por qué
DB principal (relacional)	MySQL + Vitess	PostgreSQL	Más features, JSON nativo, mejor extensibilidad, full-text search integrado
Cache	Memcached + Mcrouter	Redis (cache + pub/sub + queues)	Un solo componente para múltiples usos
Búsqueda	Apache Solr + ML re-ranking	Elasticsearch o Meilisearch (inicio)	Elasticsearch más potente, Meilisearch más simple para empezar
Almacenamiento de archivos	S3	AWS S3 o MinIO (self-hosted)	S3 estándar de industria, MinIO compatible S3 self-hosted
Time-series / Analytics	Presto/Hive/Spark	ClickHouse o TimescaleDB	ClickHouse ultra rápido para analytics
🔹 D. FRONTEND
Componente	Slack usa	Recomendado	Por qué
Web app	React (custom)	React 18+ con Next.js	SSR, routing, SEO, ecoistema enorme
Estado global	Custom	Zustand o Redux Toolkit	Zustand más simple, Redux más escalable
WebSocket cliente	Custom	Socket.io-client	Auto-reconnect, rooms, fallback a polling
UI Components	Custom (Slack Kit)	shadcn/ui + Tailwind CSS	Componentes hermosos, customizables, accesibles
Editor de texto rico	Custom	TipTap (basado en ProseMirror)	Editor rico extensible, usado por Notion, GitLab
Tabla/Kanban (Lists)	Custom	TanStack Table + custom board	Tablas potentes, sorting, filtering, virtualization
🔹 E. DESKTOP Y MOBILE
Componente	Slack usa	Recomendado	Por qué
Desktop (Win/Mac/Linux)	Electron custom	Tauri o Electron	Tauri: más ligero (Rust + webview), Electron: más maduro
Mobile (iOS/Android)	Nativo Swift/Kotlin	React Native o Flutter	Un solo código para ambas plataformas, más rápido de desarrollar
Notificaciones push	Custom	Firebase Cloud Messaging (FCM) + APNs	Estándar de industria, gratuito
🔹 F. INFRAESTRUCTURA Y DEVOPS
Componente	Slack usa	Recomendado	Por qué
Cloud	AWS	AWS o Google Cloud o DigitalOcean (más económico)	AWS más completo, DO más simple y barato para empezar
Contenedores	Custom	Docker + Kubernetes	Estándar de industria
Orquestación inicial	-	Docker Compose (dev) → Kubernetes (prod)	Empezar simple, escalar cuando sea necesario
CI/CD	Custom (ReleaseBot)	GitHub Actions o GitLab CI	Integrado con Git, gratuito para empezar
Load balancer	Envoy	Nginx (inicio) → Envoy (escala)	Nginx más simple para empezar
Reverse proxy	Envoy	Nginx o Caddy	Caddy: HTTPS automático, config simple
Service discovery	Consul	Kubernetes DNS o Consul	K8s DNS suficiente al inicio
Monitoreo	Custom + Prometheus	Prometheus + Grafana	Estándar open-source
Logs	Custom	Loki o ELK Stack	Loki más ligero, ELK más potente
Tracing	Custom	Jaeger o OpenTelemetry	Distributed tracing estándar
CDN	Custom (Flannel)	Cloudflare o AWS CloudFront	CDN global, cache en edge
🔹 G. IA Y INTELIGENCIA
Componente	Slack usa	Recomendado	Por qué
LLM (Chatbot)	Claude + propios	OpenAI GPT-4 o Anthropic Claude o Llama 3 (self-hosted)	APIs potentes, fácil integración
Vector DB (RAG)	Custom	pgvector (PostgreSQL) o Pinecone o Qdrant	pgvector: integrado en PG, simple
Embeddings	Custom	OpenAI Embeddings o Cohere	Calidad y velocidad
Transcripción audio	Custom	Whisper (OpenAI)	Open-source, self-hostable
Translation	Custom	DeepL API o Google Translate	Calidad de traducción
🔹 H. SEGURIDAD Y AUTENTICACIÓN
Componente	Slack usa	Recomendado	Por qué
Autenticación	Custom + SAML	Auth0, Clerk, o Keycloak (self-hosted)	Auth0/Clerk: managed, Keycloak: open-source completo
SSO	SAML custom	SAML + OAuth2 + OIDC via Keycloak/Auth0	Estándares de industria
Cifrado	AES-256	AES-256 (en reposo) + TLS 1.3 (en tránsito)	Estándar
Secrets management	Custom	HashiCorp Vault o AWS Secrets Manager	Gestión segura de secretos
2.3 ARQUITECTURA DEL SISTEMA COMPLETO
🔹 DIAGRAMA DE ARQUITECTURA GENERAL
                              ┌─────────────────────────────────────────────┐
                              │              CLIENTES                        │
                              │  ┌─────────┐ ┌─────────┐ ┌──────────┐      │
                              │  │  Web    │ │ Desktop │ │  Mobile  │      │
                              │  │(Next.js)│ │(Tauri)  │ │(RN/Flutr)│      │
                              │  └────┬────┘ └────┬────┘ └─────┬────┘      │
                              └───────┼───────────┼────────────┼───────────┘
                                      │           │            │
                                      ▼           ▼            ▼
                              ┌─────────────────────────────────────────────┐
                              │         CDN (Cloudflare)                     │
                              │    Assets estáticos, cache edge              │
                              └──────────────────┬──────────────────────────┘
                                                 │
                                                 ▼
                              ┌─────────────────────────────────────────────┐
                              │       LOAD BALANCER (Nginx/Envoy)           │
                              │   TLS termination, routing, rate limiting   │
                              └─────────┬───────────────────┬───────────────┘
                                        │                   │
                           HTTP/REST    │                   │  WebSocket
                                        ▼                   ▼
              ┌─────────────────────────────┐   ┌──────────────────────────┐
              │     API GATEWAY             │   │   REAL-TIME GATEWAY      │
              │     (NestJS/Go)             │   │   (WebSocket Server)     │
              │                             │   │                          │
              │  • Auth middleware          │   │  • Connection manager    │
              │  • Rate limiting            │   │  • Room subscription     │
              │  • Request routing          │   │  • Event broadcasting    │
              │  • API versioning           │   │  • Presence tracking     │
              │  • Swagger/OpenAPI          │   │  • Typing indicators     │
              └──────────┬──────────────────┘   └───────────┬──────────────┘
                         │                                   │
                         ▼                                   ▼
              ┌──────────────────────────────────────────────────────────────┐
              │                    SERVICIOS BACKEND                          │
              │                                                              │
              │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐    │
              │  │ Message  │  │ Channel  │  │  User    │  │  File    │    │
              │  │ Service  │  │ Service  │  │ Service  │  │ Service  │    │
              │  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘    │
              │       │             │             │             │           │
              │  ┌────┴─────┐  ┌────┴─────┐  ┌────┴─────┐  ┌────┴─────┐   │
              │  │ Search   │  │ Workflow │  │   AI     │  │  Auth    │   │
              │  │ Service  │  │ Service  │  │ Service  │  │ Service  │   │
              │  └────┬─────┘  └────┬─────┘  └────┬─────┘  └──────────┘   │
              │       │             │             │                        │
              │  ┌────┴─────┐  ┌────┴─────┐  ┌────┴─────┐                 │
              │  │ Notif.   │  │ Integr.  │  │ Analytics│                 │
              │  │ Service  │  │ Service  │  │ Service  │                 │
              │  └──────────┘  └──────────┘  └──────────┘                 │
              └──────────────────────────────────────────────────────────────┘
                         │                                              │
                         ▼                                              ▼
              ┌──────────────────────────────────────────────────────────────┐
              │                    DATA LAYER                                │
              │                                                              │
              │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
              │  │PostgreSQL│  │  Redis   │  │Elastic-  │  │   S3/    │   │
              │  │ (Vitess- │  │ (Cache + │  │search    │  │  MinIO   │   │
              │  │  style   │  │ Pub/Sub  │  │ (Search) │  │ (Files)  │   │
              │  │ sharding)│  │ + Queue) │  │          │  │          │   │
              │  └──────────┘  └──────────┘  └──────────┘  └──────────┘   │
              │                                                              │
              │  ┌──────────┐  ┌──────────┐                                 │
              │  │pgvector  │  │ ClickHouse│                                 │
              │  │(Vector DB│  │ (Analytics│                                 │
              │  │ for AI)  │  │  Metrics) │                                 │
              │  └──────────┘  └──────────┘                                 │
              └──────────────────────────────────────────────────────────────┘
2.4 DESGLOSE DE CADA SERVICIO
🔹 1. API Gateway
Responsabilidad: Punto de entrada único para todas las peticiones HTTP/REST

Endpoints principales:
├── /api/v1/auth/*          → Login, register, logout, refresh token
├── /api/v1/users/*         → CRUD usuarios, perfil, status, presence
├── /api/v1/workspaces/*    → CRUD workspaces, settings
├── /api/v1/channels/*      → CRUD canales, miembros, archivar
├── /api/v1/messages/*      → Enviar, editar, borrar, threads, reacciones
├── /api/v1/files/*         → Upload, download, preview, delete
├── /api/v1/search/*        → Búsqueda global con IA
├── /api/v1/dms/*           → Mensajes directos y grupos
├── /api/v1/huddles/*       → Llamadas audio/video
├── /api/v1/lists/*         → Lists, tasks, kanban
├── /api/v1/canvases/*      → Documentos colaborativos
├── /api/v1/workflows/*     → Automatizaciones
├── /api/v1/integrations/*  → Apps externas, webhooks, bots
├── /api/v1/admin/*         → Administración, analytics, audit
├── /api/v1/notifications/* → Preferencias, push tokens
└── /api/v1/ai/*            → Slackbot, summaries, search IA

Características:
├── JWT authentication
├── Rate limiting (por usuario, por IP, por workspace)
├── Request validation (Zod / Joi)
├── API versioning
├── CORS configuration
├── Swagger/OpenAPI docs auto-generadas
├── Request ID tracking (para tracing)
└── Circuit breakers a servicios internos
🔹 2. Real-Time Gateway (WebSocket Server)
Responsabilidad: Mantener conexiones WebSocket persistentes con clientes

Funciones:
├── Conexión WebSocket por usuario
├── Autenticación via token al conectar
├── Suscripción a canales (rooms)
├── Desuscripción de canales
├── Broadcast de mensajes en tiempo real
├── Typing indicators
├── Presence (online/offline/away)
├── Reacciones en tiempo real
├── Notificaciones de canal
├── Actualizaciones de perfil
├── Eventos de sistema (usuario unió/salió de canal)
└── Heartbeat/ping-pong para mantener conexión

Eventos que maneja (similares a Slack RTM):
├── message            → Nuevo mensaje en canal
├── message_changed    → Mensaje editado
├── message_deleted    → Mensaje borrado
├── reaction_added     → Reacción agregada
├── reaction_removed   → Reacción quitada
├── channel_join       → Usuario se unió a canal
├── channel_leave      → Usuario salió de canal
├── channel_created    → Nuevo canal creado
├── channel_archive    → Canal archivado
├── user_typing        → Usuario escribiendo
├── presence_change    → Cambio de presencia
├── user_status_change → Cambio de status
├── file_shared        → Archivo compartido
├── pin_added          → Mensaje fijado
├── pin_removed        → Mensaje desfijado
├── huddle_start       → Huddle iniciado
├── huddle_end         → Huddle terminado
├── list_updated       → Lista/tarea actualizada
├── canvas_updated     → Canvas actualizado
└── bot_message        → Mensaje de bot/app

Escalabilidad:
├── Sticky sessions (usuario → servidor fijo)
├── Redis Pub/Sub para cross-server broadcasting
├── Horizontal scaling (N instancias stateless)
└── Connection draining graceful en deploy
🔹 3. Message Service
Responsabilidad: Lógica de negocio de mensajes

Funciones:
├── Crear mensaje (texto, rico, código, archivo)
├── Editar mensaje (con tracking de edición)
├── Borrar mensaje (soft delete)
├── Threads/hilos (respuestas anidadas)
├── Reacciones emoji
├── Pin messages
├── Scheduled messages
├── Mentions parsing (@user, @channel, @here)
├── Link unfurling (preview de URLs)
├── Message formatting (markdown → HTML)
├── Message search indexing (→ Elasticsearch)
├── Message retention policies
└── Message export

Modelo de mensaje:
├── id: UUID
├── workspace_id: UUID
├── channel_id: UUID
├── user_id: UUID
├── thread_ts: timestamp (si es reply)
├── text: texto plano
├── blocks: array (Block Kit format)
├── attachments: array
├── files: array de file_ids
├── reactions: array de {emoji, users[]}
├── mentions: array de user_ids
├── edited: {ts, user_id}
├── is_pinned: boolean
├── is_scheduled: boolean
├── scheduled_for: timestamp
├── created_at: timestamp
└── updated_at: timestamp
🔹 4. Channel Service
Responsabilidad: Gestión de canales y membresía

Funciones:
├── Crear canal (público/privado)
├── Archivar/desarchivar canal
├── Renombrar canal
├── Set topic y purpose
├── Gestionar miembros (join/leave/invite/kick)
├── Migrar canal (público ↔ privado)
├── Shared channels (Slack Connect)
├── Channel recommendations
├── Default channels (obligatorios)
├── Channel posting permissions
├── Channel notification settings
└── Channel bookmarks/pins

Tipos de canal:
├── public_channel    → Abierto a todos en el workspace
├── private_channel   → Solo por invitación
├── group_dm          → Mensaje grupal privado
├── dm                → Mensaje directo 1:1
├── shared_channel    → Compartido entre workspaces
└── external_dm       → DM con usuario externo
🔹 5. User Service
Responsabilidad: Gestión de usuarios, perfiles y presencia

Funciones:
├── CRUD usuarios
├── Perfil (avatar, nombre, título, bio, teléfono, email)
├── Status custom (emoji + texto + expiración)
├── Presence (online/away/dnd/offline)
├── Timezone
├── Preferencias de notificación
├── User groups (grupos personalizados)
├── Roles y permisos (owner/admin/user/guest)
├── Deactivate/reactivate usuarios
├── Guest accounts (single-channel / multi-channel)
└── Session management

Presencia:
├── Heartbeat cada 30s desde cliente
├── Auto-away después de 5 min inactivo
├── Presence broadcast solo a usuarios relevantes
├── Optimización: no notificar a todos N², solo visibles
└── Presencia persistida en Redis (TTL)
🔹 6. File Service
Responsabilidad: Upload, almacenamiento y distribución de archivos

Funciones:
├── Upload de archivos (drag & drop, paste)
├── Almacenamiento en S3/MinIO
├── Thumbnail generation (imágenes)
├── File preview (imágenes, PDFs, videos, code)
├── File sharing en canales y DMs
├── File comments
├── File deletion (con retention policy)
├── Virus scanning (ClamAV opcional)
├── File size limits configurables
└── File type restrictions

Almacenamiento:
├── S3 bucket por workspace (o prefijo)
├── URLs firmadas (presigned URLs) para download
├── CDN para assets públicos
├── Multipart upload para archivos grandes
└── Image processing (resize, optimize) con Sharp
🔹 7. Search Service
Responsabilidad: Búsqueda en todo el contenido del workspace

Funciones:
├── Indexar mensajes en tiempo real
├── Indexar archivos (nombre, contenido)
├── Indexar canales (nombre, topic, purpose)
├── Indexar usuarios (nombre, email, título)
├── Búsqueda full-text
├── Filtros (tipo, fecha, autor, canal)
├── Búsqueda con IA (preguntas en lenguaje natural)
├── Autocomplete / suggestions
├── Búsqueda en integraciones externas (enterprise search)
└── Re-ranking con ML (opcional, fase avanzada)

Tecnología:
├── Elasticsearch (o Meilisearch para empezar)
├── Index por workspace
├── Sync via event stream (message.created → index)
├── Fuzzy matching
├── Highlighting de resultados
└── Typo tolerance
🔹 8. AI Service
Responsabilidad: Todas las funcionalidades de IA

Funciones:
├── Slackbot (chatbot con contexto del workspace)
├── Conversation summaries (canal, thread, DM)
├── Daily recaps (resumen de actividad)
├── Huddle notes (notas de reunión con transcript)
├── File summaries (resumen de documentos)
├── AI Search (respuestas en lenguaje natural)
├── Translations
├── Workflow generation (crear workflow desde prompt)
├── Code review (integración con GitHub)
└── Sentiment analysis (opcional)

Arquitectura RAG (Retrieval Augmented Generation):
├── Embeddings de mensajes guardados en pgvector
├── Cuando usuario hace pregunta → buscar contexto relevante
├── Construir prompt con contexto + pregunta
├── Enviar a LLM (GPT-4/Claude/Llama)
├── Respuesta con citations/fuentes
└── Fallback: si no hay contexto, respuesta genérica

Seguridad:
├── No compartir datos con proveedores LLM (usar API privada)
├── No usar datos de clientes para entrenar modelos
├── Puedes self-hostear Llama 3 para máxima privacidad
└── Rate limiting en queries IA
🔹 9. Workflow Service
Responsabilidad: Automatización de tareas

Funciones:
├── Workflow Builder visual (drag & drop, no-code)
├── Triggers:
│   ├── Emoji reaction
│   ├── User joins channel
│   ├── Scheduled (cron)
│   ├── Slash command
│   ├── Webhook externo
│   ├── Form submission
│   └── New message in channel
├── Steps:
│   ├── Send message
│   ├── Send DM
│   ├── Create channel
│   ├── Add user to channel
│   ├── Create list item
│   ├── HTTP request (webhook externo)
│   ├── Conditional (if/else branching)
│   ├── Variable assignment
│   ├── Wait/delay
│   └── Custom code step (JavaScript)
├── Workflow templates
├── Workflow analytics (ejecuciones, éxito/fallo)
└── Workflow logs

Ejecución:
├── Workflow engine (state machine)
├── Job queue (BullMQ/Asynq)
├── Timeout y retry policies
├── Variables contextuales (user, channel, message)
└── Webhook signing (HMAC)
🔹 10. Integration Service
Responsabilidad: Integraciones con apps externas

Funciones:
├── App Directory (marketplace de integraciones)
├── OAuth 2.0 flow para apps externas
├── Incoming webhooks (recibir datos de fuera)
├── Outgoing webhooks (enviar datos a fuera)
├── Slash commands custom
├── Bots y bot users
├── Block Kit (UI components en mensajes)
├── Interactive components (botones, menus, modals)
├── App home (página personalizada de la app)
├── Event subscriptions (webhook de eventos)
├── API tokens management
└── Rate limiting por app

Apps esenciales a integrar (fase 1):
├── Google Drive / Docs
├── Google Calendar
├── GitHub / GitLab
├── Jira
├── Zoom / Google Meet
├── Trello / Asana
├── Dropbox / OneDrive
└── Zapier / n8n (conector universal)
🔹 11. Notification Service
Responsabilidad: Entregar notificaciones a través de múltiples canales

Funciones:
├── Notificaciones push (FCM para Android, APNs para iOS)
├── Notificaciones desktop (electron/tauri native)
├── Notificaciones web (Web Push API)
├── Email notifications (digest, mentions, direct)
├── Notification preferences por usuario
├── Notification preferences por canal
├── Do Not Disturb (DND) schedules
├── Keyword notifications
├── Notification queue (rate limited)
├── Notification batching (agregar múltiples en una)
├── Read/unread tracking
└── Badge count (unread counter)

Reglas de notificación:
├── @mention directo → notificación inmediata
├── @channel / @here → notificación (configurable)
├── DM directo → notificación inmediata
├── Mensaje en canal (no mention) → configurable
├── Thread reply → configurable
├── DND activo → silenciar (excepto urgencias)
├── Mobile → push notification
├── Desktop inactivo → push notification
└── Email → digest cada X horas si hay no leídos
🔹 12. Huddle / Call Service
Responsabilidad: Llamadas de audio y video

Funciones:
├── Iniciar huddle desde canal o DM
├── Audio call (Opus codec)
├── Video call (VP8/VP9/H.264)
├── Screen sharing
├── Participants management (join/leave/mute)
├── Huddle chat (mensajes durante la llamada)
├── Huddle notes (IA transcripción + resumen)
├── Recording (opcional)
├── Whiteboard colaborativo
└── Push to talk (opcional)

Tecnología:
├── WebRTC para audio/video P2P
├── SFU server (Selective Forwarding Unit) para grupos
│   ├── Mediasoup (recomendado, Node.js)
│   ├── Jitsi Videobridge (Java, open-source)
│   └── LiveKit (Go, moderno)
├── STUN/TURN servers (coturn)
├── Signaling via WebSocket (canal existente)
└── Grabación → S3 storage
🔹 13. Admin Service
Responsabilidad: Administración y gobierno del workspace

Funciones:
├── Dashboard de analytics
│   ├── Mensajes enviados (día/semana/mes)
│   ├── Usuarios activos (DAU/MAU)
│   ├── Canales activos
│   ├── Huddles realizados
│   ├── Apps más usadas
│   └── Workflows ejecutados
├── User management
│   ├── Invitar usuarios
│   ├── Deactivate/reactivate
│   ├── Cambiar roles
│   ├── Guest accounts
│   └── Bulk import/export
├── Channel management
│   ├── Archivar canales inactivos
│   ├── Channel posting permissions
│   ├── Default channels
│   └── Channel naming conventions
├── Security
│   ├── Session management
│   ├── 2FA enforcement
│   ├── SSO configuration
│   ├── API token management
│   └── Data retention policies
├── Compliance
│   ├── Audit logs
│   ├── Data exports
│   ├── Legal holds
│   ├── Information barriers
│   └── DLP policies
└── Billing (si es SaaS)
    ├── Planes y features
    ├── Usage tracking
    ├── Invoice generation
    └── Payment gateway (Stripe)
2.5 DECISIONES DE DISEÑO CLAVE
🔹 Decisión 1: Modular Monolith → Microservicios
FASE 1 (MVP): Monolito modular
├── Un solo deployable con módulos internos
├── Comunicación via función calls (no network)
├── Shared database con schemas separados
└── Ventaja: Simple de desarrollar y desplegar

FASE 2 (Crecimiento): Extraer servicios críticos
├── Separar Real-Time Gateway (necesita escalar independiente)
├── Separar AI Service (necesita GPU/recursos especiales)
├── Separar File Service (necesita S3 access)
└── El resto permanece en monolito

FASE 3 (Escala): Microservicios completos
├── Cada servicio independiente
├── Comunicación via gRPC o message bus
├── Database por servicio
└── API Gateway para coordinación
🔹 Decisión 2: Sharding Strategy
Como Slack, pero simplificado:

NIVEL 1 (MVP): Single PostgreSQL
├── Una instancia, tablas con workspace_id
├── Índices en workspace_id + channel_id
└── Suficiente para miles de usuarios

NIVEL 2 (Crecimiento): Read replicas + partitioning
├── Partitioning por workspace_id ( declarative partitioning PG)
├── Read replicas para búsquedas
├── Redis cache para hot queries
└── Suficiente para decenas de miles

NIVEL 3 (Escala): Sharding horizontal
├── Sharding por channel_id (como Slack con Vitess)
├── Citus extension para PostgreSQL (sharding nativo)
├── O PgBouncer + sharding manual
└── Suficiente para cientos de miles
🔹 Decisión 3: Real-Time Architecture
NIVEL 1 (MVP): Single Socket.io server
├── Una instancia Socket.io
├── Redis adapter para pub/sub (multiple instancias)
├── Rooms = channels
└── Suficiente para ~10,000 conexiones concurrentes

NIVEL 2 (Crecimiento): Multiple Socket.io + Redis
├── N instancias Socket.io detrás de load balancer
├── Sticky sessions (IP hash o cookie)
├── Redis Pub/Sub para cross-server broadcast
├── Connection counter en Redis
└── Suficiente para ~100,000 conexiones

NIVEL 3 (Escala): Custom WebSocket gateway
├── Gateway Servers (como Slack)
├── Channel Servers (consistent hashing)
├── Presence Servers separados
├── Admin Server para routing
└── Suficiente para millones de conexiones
🔹 Decisión 4: Multi-tenancy
Opción A: Shared database, shared schema (recomendado inicio)
├── Todas las empresas comparten la misma BD
├── workspace_id en cada tabla
├── Row-level security (RLS) en PostgreSQL
├── Más económico, más simple
└── Migración fácil

Opción B: Shared database, separate schemas
├── Cada empresa tiene su schema en PostgreSQL
├── Más aislamiento
├── Más complejo de mantener
└── Para empresas que lo requieran

Opción C: Separate databases (Enterprise)
├── Cada empresa tiene su propia BD
├── Máximo aislamiento
├── Self-hosted o dedicated instances
└── Para compliance extremo
2.6 DIAGRAMA DE DESPLIEGUE (DEV → PROD)
🔹 Entorno de Desarrollo
docker-compose.yml

├── api          → NestJS (hot reload)
├── websocket    → Socket.io server (hot reload)
├── web          → Next.js dev server
├── postgres     → PostgreSQL 16
├── redis        → Redis 7
├── minio        → MinIO (S3 compatible)
├── meilisearch  → Meilisearch (búsqueda)
├── mailhog      → Email testing
└── nginx        → Reverse proxy local

Todo corre en localhost con un comando:
  $ docker-compose up -d
🔹 Entorno de Staging
├── Kubernetes cluster (GKE/EKS/DOKS)
├── 1 pod API, 1 pod WebSocket, 1 pod Web
├── PostgreSQL managed (RDS/CloudSQL)
├── Redis managed (ElastiCache)
├── S3 bucket para archivos
├── Elasticsearch managed (o self-hosted)
├── Cloudflare CDN
├── GitHub Actions CI/CD
└── Secrets en Vault/Secrets Manager
🔹 Entorno de Producción
├── Kubernetes cluster multi-AZ
├── API: 3+ pods (auto-scaling 3-20)
├── WebSocket: 3+ pods (sticky sessions)
├── Web: 2+ pods (CDN fronted)
├── PostgreSQL: primary + 2 read replicas
├── Redis: cluster mode (3 primary + 3 replica)
├── Elasticsearch: 3 node cluster
├── S3 + CloudFront (CDN)
├── Cloudflare (WAF + DDoS protection)
├── Prometheus + Grafana (monitoreo)
├── Loki (logs centralizados)
├── Jaeger (tracing)
├── Vault (secrets)
└── GitHub Actions → ArgoCD (GitOps deploy)
2.7 RESUMEN DEL STACK FINAL RECOMENDADO
┌──────────────────────────────────────────────────────────┐
│                    STACK FINAL                            │
├──────────────────────────────────────────────────────────┤
│ FRONTEND                                                  │
│   Web:       React 18 + Next.js 14 + Tailwind + shadcn   │
│   Desktop:   Tauri (Rust + WebView)                      │
│   Mobile:    React Native (Expo)                         │
│   State:     Zustand + React Query (TanStack)            │
│   Editor:    TipTap (ProseMirror)                        │
│   WebSocket: Socket.io-client                            │
├──────────────────────────────────────────────────────────┤
│ BACKEND                                                   │
│   API:       NestJS (TypeScript) + Prisma ORM            │
│   WebSocket: Socket.io + Redis Adapter                   │
│   Queue:     BullMQ (Redis-based)                        │
│   Real-time: Redis Pub/Sub                               │
├──────────────────────────────────────────────────────────┤
│ DATA                                                      │
│   DB:        PostgreSQL 16 (con pgvector)                │
│   Cache:     Redis 7                                     │
│   Search:    Meilisearch (inicio) → Elasticsearch        │
│   Files:     MinIO (dev) → S3 (prod)                     │
│   Analytics: ClickHouse                                  │
├──────────────────────────────────────────────────────────┤
│ IA                                                        │
│   LLM:       OpenAI GPT-4o o Claude 3.5 o Llama 3        │
│   Embeddings: OpenAI text-embedding-3-small              │
│   Vector:    pgvector (integrado en PostgreSQL)          │
│   Audio:     Whisper (transcripción)                     │
├──────────────────────────────────────────────────────────┤
│ INFRA                                                     │
│   Cloud:     DigitalOcean (inicio) → AWS (escala)        │
│   Container: Docker + Kubernetes                         │
│   CI/CD:     GitHub Actions + ArgoCD                     │
│   CDN:       Cloudflare                                  │
│   Monitor:   Prometheus + Grafana + Loki + Jaeger        │
│   Auth:      Clerk o Keycloak (self-hosted)              │
├──────────────────────────────────────────────────────────┤
│ AUDIO/VIDEO                                               │
│   WebRTC:    Mediasoup (SFU)                             │
│   STUN/TURN: coturn                                       │
├──────────────────────────────────────────────────────────┤
│ SEGURIDAD                                                 │
│   Auth:      Clerk / Keycloak (SSO, SAML, OAuth2)        │
│   Secrets:   HashiCorp Vault                             │
│   WAF:       Cloudflare                                  │
│   Scan:      ClamAV (file scanning)                      │
└──────────────────────────────────────────────────────────┘

📌 PARTE 3: DISEÑO DE BASE DE DATOS Y MODELO DE DATOS COMPLETO
3.1 VISIÓN GENERAL DEL MODELO DE DATOS
El sistema tendrá 6 esquemas principales en PostgreSQL:

postgrez_chat (database)
├── schema: auth        → Usuarios, sesiones, tokens, SSO
├── schema: workspace   → Workspaces, membresía, roles, invitaciones
├── schema: messaging   → Canales, mensajes, threads, reacciones
├── schema: files       → Archivos, thumbnails, compartidos
├── schema: automation  → Workflows, integraciones, bots, webhooks
├── schema: analytics   → Métricas, audit logs, usage tracking
└── schema: ai          → Embeddings, vectores, contexto IA
3.2 ESQUEMA: AUTH (Autenticación y Usuarios)
🔹 Tabla: users
CREATE TABLE auth.users (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email           VARCHAR(255) UNIQUE NOT NULL,
    email_verified  BOOLEAN DEFAULT FALSE,
    phone           VARCHAR(30),
    phone_verified  BOOLEAN DEFAULT FALSE,
    password_hash   VARCHAR(255),          -- NULL si usa SSO únicamente
    display_name    VARCHAR(80) NOT NULL,
    real_name       VARCHAR(80),
    avatar_url      VARCHAR(500),
    title           VARCHAR(120),           -- Job title
    bio             TEXT,
    timezone        VARCHAR(50) DEFAULT 'UTC',
    locale          VARCHAR(10) DEFAULT 'en',
    pronouns        VARCHAR(30),
    status_text     VARCHAR(100),
    status_emoji    VARCHAR(50),
    status_expires  TIMESTAMPTZ,
    presence        VARCHAR(15) DEFAULT 'offline', -- online, away, dnd, offline
    last_active_at  TIMESTAMPTZ,
    is_bot          BOOLEAN DEFAULT FALSE,
    is_deleted      BOOLEAN DEFAULT FALSE,
    deleted_at      TIMESTAMPTZ,
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),
    
    CONSTRAINT chk_presence CHECK (presence IN ('online','away','dnd','offline'))
);

-- Índices
CREATE INDEX idx_users_email ON auth.users(email);
CREATE INDEX idx_users_presence ON auth.users(presence) WHERE is_deleted = FALSE;
CREATE INDEX idx_users_last_active ON auth.users(last_active_at);
🔹 Tabla: user_identities (SSO / OAuth connections)
CREATE TABLE auth.user_identities (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    provider        VARCHAR(50) NOT NULL,      -- google, github, saml, okta, etc.
    provider_user_id VARCHAR(255) NOT NULL,    -- ID en el proveedor
    provider_email  VARCHAR(255),
    provider_data   JSONB,                     -- Datos extra del proveedor
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),
    
    UNIQUE(provider, provider_user_id)
);

CREATE INDEX idx_user_identities_user ON auth.user_identities(user_id);
CREATE INDEX idx_user_identities_provider ON auth.user_identities(provider, provider_user_id);
🔹 Tabla: sessions
CREATE TABLE auth.sessions (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    token_hash      VARCHAR(255) NOT NULL UNIQUE,  -- Hashed refresh token
    device_type     VARCHAR(20),               -- web, desktop, ios, android
    device_name     VARCHAR(120),
    device_id       VARCHAR(255),
    ip_address      INET,
    user_agent      TEXT,
    location        VARCHAR(120),
    expires_at      TIMESTAMPTZ NOT NULL,
    revoked_at      TIMESTAMPTZ,
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    
    CONSTRAINT chk_device_type CHECK (device_type IN ('web','desktop','ios','android','bot'))
);

CREATE INDEX idx_sessions_user ON auth.sessions(user_id) WHERE revoked_at IS NULL;
CREATE INDEX idx_sessions_expires ON auth.sessions(expires_at) WHERE revoked_at IS NULL;
🔹 Tabla: two_factor_auth
CREATE TABLE auth.two_factor_auth (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id         UUID UNIQUE NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    secret          VARCHAR(255) NOT NULL,     -- TOTP secret (encrypted)
    backup_codes    JSONB,                      -- Codigos de respaldo (hashed)
    enabled         BOOLEAN DEFAULT FALSE,
    enabled_at      TIMESTAMPTZ,
    created_at      TIMESTAMPTZ DEFAULT NOW()
);
🔹 Tabla: password_resets
CREATE TABLE auth.password_resets (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    token_hash      VARCHAR(255) NOT NULL UNIQUE,
    expires_at      TIMESTAMPTZ NOT NULL,
    used_at         TIMESTAMPTZ,
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_password_resets_user ON auth.password_resets(user_id) WHERE used_at IS NULL;
3.3 ESQUEMA: WORKSPACE (Espacios de Trabajo)
🔹 Tabla: workspaces
CREATE TABLE workspace.workspaces (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name            VARCHAR(80) NOT NULL,
    domain          VARCHAR(50) UNIQUE NOT NULL,   -- miempresa.chat.com
    logo_url        VARCHAR(500),
    description     TEXT,
    plan            VARCHAR(20) DEFAULT 'free',     -- free, pro, business, enterprise
    plan_expires    TIMESTAMPTZ,
    max_members     INTEGER DEFAULT 100,
    max_file_size   BIGINT DEFAULT 104857600,       -- 100MB default
    message_retention_days INTEGER,                  -- NULL = ilimitado
    file_retention_days INTEGER,
    allow_create_channels BOOLEAN DEFAULT TRUE,
    allow_custom_emoji BOOLEAN DEFAULT TRUE,
    allow_shared_channels BOOLEAN DEFAULT FALSE,
    enforce_2fa     BOOLEAN DEFAULT FALSE,
    sso_required    BOOLEAN DEFAULT FALSE,
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),
    
    CONSTRAINT chk_plan CHECK (plan IN ('free','pro','business','enterprise'))
);

CREATE INDEX idx_workspaces_domain ON workspace.workspaces(domain);
🔹 Tabla: workspace_members
CREATE TABLE workspace.workspace_members (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    role            VARCHAR(20) DEFAULT 'member',   -- owner, admin, member, guest
    guest_type      VARCHAR(20),                     -- single_channel, multi_channel (si es guest)
    display_name    VARCHAR(80),                     -- Override de nombre dentro del workspace
    title           VARCHAR(120),                    -- Override de título
    joined_at       TIMESTAMPTZ DEFAULT NOW(),
    invited_by      UUID REFERENCES auth.users(id),
    deactivated_at  TIMESTAMPTZ,
    deactivated_by  UUID REFERENCES auth.users(id),
    
    UNIQUE(workspace_id, user_id),
    CONSTRAINT chk_role CHECK (role IN ('owner','admin','member','guest')),
    CONSTRAINT chk_guest_type CHECK (guest_type IN ('single_channel','multi_channel') OR role != 'guest')
);

CREATE INDEX idx_workspace_members_workspace ON workspace.workspace_members(workspace_id);
CREATE INDEX idx_workspace_members_user ON workspace.workspace_members(user_id);
CREATE INDEX idx_workspace_members_role ON workspace.workspace_members(workspace_id, role);
🔹 Tabla: workspace_invitations
CREATE TABLE workspace.workspace_invitations (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    email           VARCHAR(255) NOT NULL,
    role            VARCHAR(20) DEFAULT 'member',
    token           VARCHAR(255) NOT NULL UNIQUE,
    invited_by      UUID NOT NULL REFERENCES auth.users(id),
    accepted_at     TIMESTAMPTZ,
    expires_at      TIMESTAMPTZ NOT NULL,
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    
    CONSTRAINT chk_inv_role CHECK (role IN ('owner','admin','member','guest'))
);

CREATE INDEX idx_invitations_workspace ON workspace.workspace_invitations(workspace_id);
CREATE INDEX idx_invitations_email ON workspace.workspace_invitations(email) WHERE accepted_at IS NULL;
🔹 Tabla: user_groups
CREATE TABLE workspace.user_groups (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    name            VARCHAR(80) NOT NULL,         -- @marketing, @engineering
    handle          VARCHAR(50) NOT NULL,          -- marketing, engineering
    description     TEXT,
    is_auto         BOOLEAN DEFAULT FALSE,        -- Auto-generado por dept
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),
    
    UNIQUE(workspace_id, handle)
);

CREATE INDEX idx_user_groups_workspace ON workspace.user_groups(workspace_id);
🔹 Tabla: user_group_members
CREATE TABLE workspace.user_group_members (
    user_group_id   UUID NOT NULL REFERENCES workspace.user_groups(id) ON DELETE CASCADE,
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    added_at        TIMESTAMPTZ DEFAULT NOW(),
    added_by        UUID REFERENCES auth.users(id),
    
    PRIMARY KEY(user_group_id, user_id)
);
🔹 Tabla: custom_emojis
CREATE TABLE workspace.custom_emojis (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    name            VARCHAR(50) NOT NULL,         -- :parrot:
    image_url       VARCHAR(500) NOT NULL,
    aliases         VARCHAR(255)[],               -- Nombres alternativos
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    
    UNIQUE(workspace_id, name)
);

CREATE INDEX idx_custom_emojis_workspace ON workspace.custom_emojis(workspace_id);
🔹 Tabla: workspace_settings
CREATE TABLE workspace.workspace_settings (
    workspace_id    UUID PRIMARY KEY REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    default_channel VARCHAR(80) DEFAULT 'general',
    allowed_file_types VARCHAR(255)[],            -- NULL = todos
    allowed_file_extensions VARCHAR(255)[],
    message_edit_window_minutes INTEGER DEFAULT 0, -- 0 = ilimitado
    allow_message_deletion BOOLEAN DEFAULT TRUE,
    default_retention_days INTEGER,
    require_link_previews BOOLEAN DEFAULT TRUE,
    allowed_auth_domains VARCHAR(255)[],          -- dominios de email permitidos
    sidebar_sections JSONB DEFAULT '[]',
    custom_theme JSONB,
    announcement_channel VARCHAR(80),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW()
);
3.4 ESQUEMA: MESSAGING (Mensajería - EL CORE)
🔹 Tabla: channels
CREATE TABLE messaging.channels (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    name            VARCHAR(80) NOT NULL,
    handle          VARCHAR(80) NOT NULL,          -- Slug: marketing-team
    type            VARCHAR(20) NOT NULL,           -- public, private, group_dm, dm, shared
    topic           TEXT,
    topic_set_by    UUID REFERENCES auth.users(id),
    topic_set_at    TIMESTAMPTZ,
    purpose         TEXT,
    purpose_set_by  UUID REFERENCES auth.users(id),
    purpose_set_at  TIMESTAMPTZ,
    is_archived     BOOLEAN DEFAULT FALSE,
    archived_at     TIMESTAMPTZ,
    archived_by     UUID REFERENCES auth.users(id),
    is_default      BOOLEAN DEFAULT FALSE,
    is_read_only    BOOLEAN DEFAULT FALSE,
    is_shared       BOOLEAN DEFAULT FALSE,         -- Slack Connect
    is_org_wide     BOOLEAN DEFAULT FALSE,
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),
    last_message_at TIMESTAMPTZ,
    member_count    INTEGER DEFAULT 0,
    
    UNIQUE(workspace_id, handle),
    CONSTRAINT chk_channel_type CHECK (type IN ('public','private','group_dm','dm','shared'))
);

-- CRÍTICO: Este índice se usa en casi todas las queries
CREATE INDEX idx_channels_workspace ON messaging.channels(workspace_id, type);
CREATE INDEX idx_channels_workspace_handle ON messaging.channels(workspace_id, handle);
CREATE INDEX idx_channels_archived ON messaging.channels(workspace_id, is_archived);
CREATE INDEX idx_channels_last_message ON messaging.channels(workspace_id, last_message_at DESC);
🔹 Tabla: channel_members
CREATE TABLE messaging.channel_members (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    channel_id      UUID NOT NULL REFERENCES messaging.channels(id) ON DELETE CASCADE,
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    workspace_id    UUID NOT NULL,                  -- Denormalizado para queries rápidas
    role            VARCHAR(20) DEFAULT 'member',   -- owner, admin, member
    notification_pref VARCHAR(20) DEFAULT 'all',    -- all, mentions, nothing
    muted           BOOLEAN DEFAULT FALSE,
    muted_until     TIMESTAMPTZ,
    last_read_ts    TIMESTAMPTZ,                    -- Cursor de lectura
    unread_count    INTEGER DEFAULT 0,
    unread_mention_count INTEGER DEFAULT 0,
    joined_at       TIMESTAMPTZ DEFAULT NOW(),
    invited_by      UUID REFERENCES auth.users(id),
    left_at         TIMESTAMPTZ,
    
    UNIQUE(channel_id, user_id),
    CONSTRAINT chk_notif_pref CHECK (notification_pref IN ('all','mentions','nothing'))
);

-- CRÍTICO: Para listar canales de un usuario
CREATE INDEX idx_channel_members_user ON messaging.channel_members(user_id, workspace_id) WHERE left_at IS NULL;
-- CRÍTICO: Para listar miembros de un canal
CREATE INDEX idx_channel_members_channel ON messaging.channel_members(channel_id) WHERE left_at IS NULL;
-- Para sidebar con unread counts
CREATE INDEX idx_channel_members_unread ON messaging.channel_members(user_id) WHERE unread_count > 0 AND left_at IS NULL;
🔹 Tabla: messages (LA TABLA MÁS IMPORTANTE)
CREATE TABLE messaging.messages (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,                  -- Denormalizado para sharding
    channel_id      UUID NOT NULL REFERENCES messaging.channels(id) ON DELETE CASCADE,
    user_id         UUID REFERENCES auth.users(id), -- NULL si es mensaje del sistema
    bot_id          UUID,                           -- Si fue enviado por un bot
    thread_id       UUID,                           -- Si es reply, ID del mensaje padre
    thread_root_id  UUID,                           -- Siempre apunta al mensaje raíz del thread
    text            TEXT,                           -- Texto plano (fallback)
    blocks          JSONB,                          -- Block Kit: contenido rico
    attachments     JSONB,                          -- Attachments legacy
    mentioned_users UUID[],                         -- IDs de usuarios mencionados
    mentioned_channels UUID[],                      -- Canales mencionados (#canal)
    mentioned_groups UUID[],                        -- Grupos mencionados (@grupo)
    link_previews   JSONB,                          -- Unfurling de URLs
    is_edited       BOOLEAN DEFAULT FALSE,
    edited_at       TIMESTAMPTZ,
    edited_by       UUID REFERENCES auth.users(id),
    is_deleted      BOOLEAN DEFAULT FALSE,
    deleted_at      TIMESTAMPTZ,
    deleted_by      UUID REFERENCES auth.users(id),
    is_pinned       BOOLEAN DEFAULT FALSE,
    is_system       BOOLEAN DEFAULT FALSE,          -- Mensaje del sistema (join, leave)
    system_type     VARCHAR(50),                    -- join, leave, channel_archive, etc.
    is_scheduled    BOOLEAN DEFAULT FALSE,
    scheduled_for   TIMESTAMPTZ,
    reply_count     INTEGER DEFAULT 0,
    reply_users_count INTEGER DEFAULT 0,
    reply_users     UUID[],
    latest_reply_ts TIMESTAMPTZ,
    ts              TIMESTAMPTZ DEFAULT NOW(),      -- Timestamp del mensaje (puede diferir de created_at para scheduled)
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW()
);

-- CRÍTICOS:
-- Sharding por channel_id (fase 2 con Citus)
CREATE INDEX idx_messages_channel_ts ON messaging.messages(channel_id, ts DESC);
CREATE INDEX idx_messages_workspace ON messaging.messages(workspace_id, ts DESC);
CREATE INDEX idx_messages_thread ON messaging.messages(thread_root_id, ts ASC) WHERE thread_root_id IS NOT NULL;
CREATE INDEX idx_messages_user ON messaging.messages(user_id, ts DESC) WHERE is_deleted = FALSE;
CREATE INDEX idx_messages_scheduled ON messaging.messages(is_scheduled, scheduled_for) WHERE is_scheduled = TRUE;
CREATE INDEX idx_messages_mentions ON messaging.messages USING GIN (mentioned_users);
CREATE INDEX idx_messages_blocks ON messaging.messages USING GIN (blocks jsonb_path_ops);

-- PARTICIONAMIENTO (Fase 2): particionar por mes para mantenimiento
-- CREATE TABLE messaging.messages_y2025m01 PARTITION OF messaging.messages
--   FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');
🔹 Tabla: message_reactions
CREATE TABLE messaging.message_reactions (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    message_id      UUID NOT NULL REFERENCES messaging.messages(id) ON DELETE CASCADE,
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    emoji           VARCHAR(50) NOT NULL,           -- :thumbsup: o unicode emoji
    emoji_type      VARCHAR(20) DEFAULT 'unicode',  -- unicode, custom
    custom_emoji_id UUID,                           -- Si es custom emoji
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    
    UNIQUE(message_id, user_id, emoji)
);

CREATE INDEX idx_reactions_message ON messaging.message_reactions(message_id);
CREATE INDEX idx_reactions_user ON messaging.message_reactions(user_id);
🔹 Tabla: message_pins
CREATE TABLE messaging.message_pins (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    channel_id      UUID NOT NULL REFERENCES messaging.channels(id) ON DELETE CASCADE,
    message_id      UUID NOT NULL REFERENCES messaging.messages(id) ON DELETE CASCADE,
    pinned_by       UUID NOT NULL REFERENCES auth.users(id),
    pinned_at       TIMESTAMPTZ DEFAULT NOW(),
    
    UNIQUE(channel_id, message_id)
);
🔹 Tabla: channel_bookmarks
CREATE TABLE messaging.channel_bookmarks (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    channel_id      UUID NOT NULL REFERENCES messaging.channels(id) ON DELETE CASCADE,
    type            VARCHAR(20) NOT NULL,           -- link, channel, message
    title           VARCHAR(120),
    url             VARCHAR(500),                   -- Si es link
    target_channel_id UUID,                         -- Si es channel
    target_message_id UUID,                         -- Si es message
    emoji           VARCHAR(50),
    order_index     INTEGER DEFAULT 0,
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_bookmarks_channel ON messaging.channel_bookmarks(channel_id, order_index);
🔹 Tabla: saved_messages (Items guardados personalmente)
CREATE TABLE messaging.saved_messages (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    message_id      UUID NOT NULL REFERENCES messaging.messages(id) ON DELETE CASCADE,
    saved_at        TIMESTAMPTZ DEFAULT NOW(),
    
    UNIQUE(user_id, message_id)
);

CREATE INDEX idx_saved_messages_user ON messaging.saved_messages(user_id, saved_at DESC);
🔹 Tabla: scheduled_messages
CREATE TABLE messaging.scheduled_messages (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,
    channel_id      UUID NOT NULL REFERENCES messaging.channels(id) ON DELETE CASCADE,
    user_id         UUID NOT NULL REFERENCES auth.users(id),
    text            TEXT,
    blocks          JSONB,
    scheduled_for   TIMESTAMPTZ NOT NULL,
    status          VARCHAR(20) DEFAULT 'pending',  -- pending, sent, cancelled
    sent_message_id UUID,                           -- Referencia al mensaje cuando se envía
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    
    CONSTRAINT chk_sched_status CHECK (status IN ('pending','sent','cancelled'))
);

CREATE INDEX idx_scheduled_pending ON messaging.scheduled_messages(scheduled_for) WHERE status = 'pending';
🔹 Tabla: typing_indicators (Redis - no en PostgreSQL)
NOTA: Los typing indicators se manejan en Redis, NO en PostgreSQL:

Redis key: typing:{channel_id}:{user_id}
TTL: 5 segundos
Value: timestamp

Cada vez que un usuario escribe:
  SET typing:{channel_id}:{user_id} {timestamp} EX 5

Para saber quién está escribiendo en un canal:
  SCAN typing:{channel_id}:*
🔹 Tabla: shared_channels (Slack Connect)
CREATE TABLE messaging.shared_channels (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    channel_id      UUID NOT NULL REFERENCES messaging.channels(id) ON DELETE CASCADE,
    source_workspace_id UUID NOT NULL,              -- Workspace que originó el canal
    target_workspace_id UUID NOT NULL,              -- Workspace con quien se comparte
    target_channel_name VARCHAR(80),                 -- Override de nombre en el workspace destino
    target_channel_topic TEXT,
    target_is_private BOOLEAN DEFAULT FALSE,
    status          VARCHAR(20) DEFAULT 'pending',   -- pending, accepted, rejected, revoked
    accepted_at     TIMESTAMPTZ,
    accepted_by     UUID REFERENCES auth.users(id),
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    
    CONSTRAINT chk_shared_status CHECK (status IN ('pending','accepted','rejected','revoked'))
);

CREATE INDEX idx_shared_channels_source ON messaging.shared_channels(source_workspace_id);
CREATE INDEX idx_shared_channels_target ON messaging.shared_channels(target_workspace_id);
3.5 ESQUEMA: FILES (Archivos)
🔹 Tabla: files
CREATE TABLE files.files (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,
    uploader_id     UUID NOT NULL REFERENCES auth.users(id),
    filename        VARCHAR(255) NOT NULL,
    file_type       VARCHAR(50) NOT NULL,           -- image, pdf, video, audio, code, doc, etc.
    file_extension  VARCHAR(20),
    mime_type       VARCHAR(100) NOT NULL,
    size_bytes      BIGINT NOT NULL,
    storage_key     VARCHAR(500) NOT NULL,          -- Key en S3/MinIO
    storage_bucket  VARCHAR(100) NOT NULL,
    storage_provider VARCHAR(20) DEFAULT 's3',      -- s3, minio, local
    thumbnail_key   VARCHAR(500),                   -- Key del thumbnail en S3
    thumbnail_sizes JSONB,                          -- {"small": "key1", "medium": "key2"}
    image_width     INTEGER,
    image_height    INTEGER,
    duration_seconds FLOAT,                         -- Para audio/video
    page_count      INTEGER,                        -- Para PDFs
    is_public       BOOLEAN DEFAULT FALSE,
    public_url      VARCHAR(500),
    is_deleted      BOOLEAN DEFAULT FALSE,
    deleted_at      TIMESTAMPTZ,
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_files_workspace ON files.files(workspace_id, created_at DESC);
CREATE INDEX idx_files_uploader ON files.files(uploader_id, created_at DESC);
CREATE INDEX idx_files_type ON files.files(workspace_id, file_type);
🔹 Tabla: file_shares
CREATE TABLE files.file_shares (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    file_id         UUID NOT NULL REFERENCES files.files(id) ON DELETE CASCADE,
    channel_id      UUID REFERENCES messaging.channels(id) ON DELETE CASCADE,
    message_id      UUID REFERENCES messaging.messages(id) ON DELETE CASCADE,
    shared_by       UUID NOT NULL REFERENCES auth.users(id),
    shared_at       TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_file_shares_file ON files.file_shares(file_id);
CREATE INDEX idx_file_shares_channel ON files.file_shares(channel_id);
🔹 Tabla: file_comments
CREATE TABLE files.file_comments (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    file_id         UUID NOT NULL REFERENCES files.files(id) ON DELETE CASCADE,
    user_id         UUID NOT NULL REFERENCES auth.users(id),
    text            TEXT NOT NULL,
    blocks          JSONB,
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),
    is_deleted      BOOLEAN DEFAULT FALSE,
    deleted_at      TIMESTAMPTZ
);

CREATE INDEX idx_file_comments_file ON files.file_comments(file_id, created_at DESC);
3.6 ESQUEMA: PROJECTS (Lists, Canvases, Tasks)
🔹 Tabla: lists
CREATE TABLE workspace.lists (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    channel_id      UUID REFERENCES messaging.channels(id) ON DELETE CASCADE,
    name            VARCHAR(120) NOT NULL,
    description     TEXT,
    view_type       VARCHAR(20) DEFAULT 'table',    -- table, board
    group_by_field  VARCHAR(50),                    -- Campo para agrupar en board view
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_lists_workspace ON workspace.lists(workspace_id);
CREATE INDEX idx_lists_channel ON workspace.lists(channel_id);
🔹 Tabla: list_fields (Columnas personalizadas)
CREATE TABLE workspace.list_fields (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    list_id         UUID NOT NULL REFERENCES workspace.lists(id) ON DELETE CASCADE,
    name            VARCHAR(80) NOT NULL,
    field_type      VARCHAR(20) NOT NULL,           -- text, number, checkbox, date, select, people
    options         JSONB,                           -- Para select: opciones
    order_index     INTEGER DEFAULT 0,
    is_required     BOOLEAN DEFAULT FALSE,
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    
    CONSTRAINT chk_field_type CHECK (field_type IN ('text','number','checkbox','date','select','people','multi_select','url','email'))
);

CREATE INDEX idx_list_fields_list ON workspace.list_fields(list_id, order_index);
🔹 Tabla: list_items (Tareas/filas)
CREATE TABLE workspace.list_items (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    list_id         UUID NOT NULL REFERENCES workspace.lists(id) ON DELETE CASCADE,
    name            VARCHAR(255) NOT NULL,
    field_values    JSONB NOT NULL DEFAULT '{}',    -- {"Assignee": "uuid", "Due Date": "2025-01-15", "Status": "Done"}
    order_index     INTEGER DEFAULT 0,
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),
    completed_at    TIMESTAMPTZ
);

CREATE INDEX idx_list_items_list ON workspace.list_items(list_id, order_index);
CREATE INDEX idx_list_items_fields ON workspace.list_items USING GIN (field_values);
🔹 Tabla: list_item_comments
CREATE TABLE workspace.list_item_comments (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    list_item_id    UUID NOT NULL REFERENCES workspace.list_items(id) ON DELETE CASCADE,
    user_id         UUID NOT NULL REFERENCES auth.users(id),
    text            TEXT NOT NULL,
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_list_item_comments_item ON workspace.list_item_comments(list_item_id, created_at DESC);
🔹 Tabla: canvases (Documentos colaborativos)
CREATE TABLE workspace.canvases (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    channel_id      UUID REFERENCES messaging.channels(id) ON DELETE CASCADE,
    title           VARCHAR(200) NOT NULL,
    content         JSONB NOT NULL DEFAULT '{}',    -- TipTap/ProseMirror document JSON
    document_id     UUID NOT NULL,                   -- ID del documento TipTap
    version         INTEGER DEFAULT 1,
    is_template     BOOLEAN DEFAULT FALSE,
    template_category VARCHAR(50),
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),
    last_edited_by  UUID REFERENCES auth.users(id)
);

CREATE INDEX idx_canvases_workspace ON workspace.canvases(workspace_id);
CREATE INDEX idx_canvases_channel ON workspace.canvases(channel_id);
🔹 Tabla: canvas_collaborators
CREATE TABLE workspace.canvas_collaborators (
    canvas_id       UUID NOT NULL REFERENCES workspace.canvases(id) ON DELETE CASCADE,
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    permission      VARCHAR(20) DEFAULT 'edit',     -- edit, view
    added_at        TIMESTAMPTZ DEFAULT NOW(),
    
    PRIMARY KEY(canvas_id, user_id)
);
🔹 Tabla: templates
CREATE TABLE workspace.templates (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID REFERENCES workspace.workspaces(id) ON DELETE CASCADE, -- NULL si es global
    name            VARCHAR(120) NOT NULL,
    description     TEXT,
    category        VARCHAR(50),                    -- onboarding, project, standup, etc.
    content         JSONB NOT NULL,                 -- Estructura del template
    type            VARCHAR(20) NOT NULL,           -- channel_setup, canvas, list, workflow
    created_by      UUID REFERENCES auth.users(id),
    is_custom       BOOLEAN DEFAULT FALSE,
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_templates_workspace ON workspace.templates(workspace_id, category);
3.7 ESQUEMA: AUTOMATION (Workflows, Integraciones, Bots)
🔹 Tabla: workflows
CREATE TABLE automation.workflows (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    name            VARCHAR(120) NOT NULL,
    description     TEXT,
    status          VARCHAR(20) DEFAULT 'draft',    -- draft, active, paused, archived
    trigger_type    VARCHAR(50) NOT NULL,
    trigger_config  JSONB NOT NULL,                 -- Configuración del trigger
    steps           JSONB NOT NULL DEFAULT '[]',    -- Array de pasos
    variables       JSONB DEFAULT '{}',             -- Variables del workflow
    execution_count INTEGER DEFAULT 0,
    failure_count   INTEGER DEFAULT 0,
    last_executed   TIMESTAMPTZ,
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),
    
    CONSTRAINT chk_workflow_status CHECK (status IN ('draft','active','paused','archived'))
);

CREATE INDEX idx_workflows_workspace ON automation.workflows(workspace_id, status);
🔹 Tabla: workflow_executions
CREATE TABLE automation.workflow_executions (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workflow_id     UUID NOT NULL REFERENCES automation.workflows(id) ON DELETE CASCADE,
    trigger_data    JSONB,                          -- Datos que dispararon el workflow
    context         JSONB,                          -- Variables en ejecución
    current_step    INTEGER DEFAULT 0,
    status          VARCHAR(20) DEFAULT 'running',  -- running, completed, failed, cancelled
    error_message   TEXT,
    started_at      TIMESTAMPTZ DEFAULT NOW(),
    completed_at    TIMESTAMPTZ
);

CREATE INDEX idx_workflow_exec_workflow ON automation.workflow_executions(workflow_id, started_at DESC);
CREATE INDEX idx_workflow_exec_status ON automation.workflow_executions(status) WHERE status = 'running';
🔹 Tabla: apps (Integraciones instaladas)
CREATE TABLE automation.apps (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    app_name        VARCHAR(80) NOT NULL,           -- Google Drive, GitHub, etc.
    app_slug        VARCHAR(80) NOT NULL,
    description     TEXT,
    icon_url        VARCHAR(500),
    developer_name  VARCHAR(120),
    is_internal     BOOLEAN DEFAULT FALSE,          -- TRUE si es app custom del workspace
    scopes          TEXT[],                         -- Permisos solicitados
    oauth_token_encrypted TEXT,                     -- Token encriptado
    oauth_refresh_token_encrypted TEXT,
    installed_by    UUID NOT NULL REFERENCES auth.users(id),
    installed_at    TIMESTAMPTZ DEFAULT NOW(),
    is_active       BOOLEAN DEFAULT TRUE,
    config          JSONB DEFAULT '{}',
    
    UNIQUE(workspace_id, app_slug)
);

CREATE INDEX idx_apps_workspace ON automation.apps(workspace_id, is_active);
🔹 Tabla: bot_users
CREATE TABLE automation.bot_users (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    app_id          UUID REFERENCES automation.apps(id) ON DELETE CASCADE,
    name            VARCHAR(80) NOT NULL,
    display_name    VARCHAR(80) NOT NULL,
    avatar_url      VARCHAR(500),
    is_active       BOOLEAN DEFAULT TRUE,
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_bot_users_workspace ON automation.bot_users(workspace_id);
🔹 Tabla: slash_commands
CREATE TABLE automation.slash_commands (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    app_id          UUID REFERENCES automation.apps(id) ON DELETE CASCADE,
    command         VARCHAR(50) NOT NULL,           -- /ticket
    description     TEXT,
    usage_hint      VARCHAR(200),
    url             VARCHAR(500),                   -- Webhook URL
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    
    UNIQUE(workspace_id, command)
);
🔹 Tabla: incoming_webhooks
CREATE TABLE automation.incoming_webhooks (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    app_id          UUID REFERENCES automation.apps(id) ON DELETE CASCADE,
    channel_id      UUID REFERENCES messaging.channels(id),
    webhook_url     VARCHAR(500) UNIQUE NOT NULL,  -- URL única del webhook
    webhook_token   VARCHAR(255) NOT NULL,
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    is_active       BOOLEAN DEFAULT TRUE
);
🔹 Tabla: event_subscriptions
CREATE TABLE automation.event_subscriptions (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    app_id          UUID REFERENCES automation.apps(id) ON DELETE CASCADE,
    callback_url    VARCHAR(500) NOT NULL,
    event_types     TEXT[],                         -- ['message.channels', 'team_join', ...]
    secret          VARCHAR(255) NOT NULL,          -- Para HMAC signing
    is_active       BOOLEAN DEFAULT TRUE,
    created_at      TIMESTAMPTZ DEFAULT NOW()
);
3.8 ESQUEMA: HUDDLES (Llamadas Audio/Video)
🔹 Tabla: huddles
CREATE TABLE workspace.huddles (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,
    channel_id      UUID NOT NULL REFERENCES messaging.channels(id) ON DELETE CASCADE,
    started_by      UUID NOT NULL REFERENCES auth.users(id),
    status          VARCHAR(20) DEFAULT 'active',   -- active, ended
    room_id         VARCHAR(255),                   -- ID del room en Mediasoup/LiveKit
    is_video        BOOLEAN DEFAULT FALSE,
    started_at      TIMESTAMPTZ DEFAULT NOW(),
    ended_at        TIMESTAMPTZ,
    participant_count INTEGER DEFAULT 0,
    max_participants INTEGER DEFAULT 0
);

CREATE INDEX idx_huddles_channel_active ON workspace.huddles(channel_id) WHERE status = 'active';
🔹 Tabla: huddle_participants
CREATE TABLE workspace.huddle_participants (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    huddle_id       UUID NOT NULL REFERENCES workspace.huddles(id) ON DELETE CASCADE,
    user_id         UUID NOT NULL REFERENCES auth.users(id),
    joined_at       TIMESTAMPTZ DEFAULT NOW(),
    left_at         TIMESTAMPTZ,
    had_video       BOOLEAN DEFAULT FALSE,
    had_audio       BOOLEAN DEFAULT TRUE,
    was_screensharing BOOLEAN DEFAULT FALSE,
    
    UNIQUE(huddle_id, user_id)
);

CREATE INDEX idx_huddle_participants_huddle ON workspace.huddle_participants(huddle_id) WHERE left_at IS NULL;
🔹 Tabla: huddle_notes (IA generadas)
CREATE TABLE workspace.huddle_notes (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    huddle_id       UUID NOT NULL REFERENCES workspace.huddles(id) ON DELETE CASCADE,
    transcript      TEXT,                           -- Transcripción completa
    summary         TEXT,                           -- Resumen IA
    action_items    JSONB,                          -- [{item: "...", assignee: "uuid"}]
    key_takeaways   TEXT[],
    generated_at    TIMESTAMPTZ DEFAULT NOW()
);
3.9 ESQUEMA: AI (Inteligencia Artificial)
🔹 Tabla: ai_embeddings (Vector DB para RAG)
-- Requiere extensión pgvector: CREATE EXTENSION vector;

CREATE TABLE ai.message_embeddings (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,
    message_id      UUID NOT NULL REFERENCES messaging.messages(id) ON DELETE CASCADE,
    channel_id      UUID NOT NULL,
    content         TEXT,                           -- Texto que fue embebido
    embedding       vector(1536),                   -- OpenAI text-embedding-3-small = 1536 dims
    model           VARCHAR(50) DEFAULT 'text-embedding-3-small',
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

-- CRÍTICO: Para búsqueda semántica
CREATE INDEX idx_embeddings_vector ON ai.message_embeddings 
    USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
CREATE INDEX idx_embeddings_workspace ON ai.message_embeddings(workspace_id);
CREATE INDEX idx_embeddings_channel ON ai.message_embeddings(channel_id);
🔹 Tabla: ai_summaries (Resúmenes generados)
CREATE TABLE ai.ai_summaries (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,
    type            VARCHAR(30) NOT NULL,           -- channel, thread, dm, huddle, file, recap
    target_id       UUID NOT NULL,                  -- ID del canal/thread/huddle/file
    summary         TEXT NOT NULL,
    key_points      TEXT[],
    action_items    JSONB,
    period_start    TIMESTAMPTZ,
    period_end      TIMESTAMPTZ,
    generated_for   UUID NOT NULL REFERENCES auth.users(id), -- Usuario que solicitó
    model           VARCHAR(50) DEFAULT 'gpt-4o',
    tokens_used     INTEGER,
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_ai_summaries_workspace ON ai.ai_summaries(workspace_id, type, created_at DESC);
CREATE INDEX idx_ai_summaries_target ON ai.ai_summaries(target_id, created_at DESC);
🔹 Tabla: ai_conversations (Chat con Slackbot)
CREATE TABLE ai.ai_conversations (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    messages        JSONB NOT NULL DEFAULT '[]',    -- [{role: "user", content: "..."}, {role: "assistant", content: "..."}]
    context_refs    UUID[],                         -- IDs de mensajes usados como contexto
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_ai_conversations_user ON ai.ai_conversations(user_id, updated_at DESC);
🔹 Tabla: ai_search_cache
CREATE TABLE ai.ai_search_cache (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,
    user_id         UUID NOT NULL,
    query           TEXT NOT NULL,
    answer          TEXT NOT NULL,
    source_message_ids UUID[],                      -- Mensajes usados como fuente
    model           VARCHAR(50),
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_ai_search_workspace ON ai.ai_search_cache(workspace_id, created_at DESC);
3.10 ESQUEMA: NOTIFICATIONS (Notificaciones)
🔹 Tabla: notification_preferences
CREATE TABLE workspace.notification_preferences (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    channel_id      UUID REFERENCES messaging.channels(id) ON DELETE CASCADE, -- NULL = default del workspace
    notify_mentions BOOLEAN DEFAULT TRUE,
    notify_all_messages BOOLEAN DEFAULT FALSE,
    notify_threads  VARCHAR(20) DEFAULT 'all',     -- all, mentions, nothing
    notify_dms      BOOLEAN DEFAULT TRUE,
    notify_huddles  BOOLEAN DEFAULT TRUE,
    push_enabled    BOOLEAN DEFAULT TRUE,
    email_enabled   BOOLEAN DEFAULT TRUE,
    email_frequency VARCHAR(20) DEFAULT 'hourly',  -- immediate, hourly, daily, weekly
    desktop_enabled BOOLEAN DEFAULT TRUE,
    mobile_enabled  BOOLEAN DEFAULT TRUE,
    sound_enabled   BOOLEAN DEFAULT TRUE,
    dnd_enabled     BOOLEAN DEFAULT FALSE,
    dnd_start       TIME,                           -- 22:00
    dnd_end         TIME,                           -- 08:00
    dnd_timezone    VARCHAR(50),
    keywords        TEXT[],                         -- Palabras que disparan notificación
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_notif_prefs_user_workspace ON workspace.notification_preferences(user_id, workspace_id);
CREATE INDEX idx_notif_prefs_channel ON workspace.notification_preferences(channel_id);
🔹 Tabla: push_tokens
CREATE TABLE workspace.push_tokens (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id         UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    platform        VARCHAR(20) NOT NULL,           -- ios, android, web, desktop
    token           VARCHAR(500) NOT NULL,
    device_id       VARCHAR(255),
    app_version     VARCHAR(50),
    is_active       BOOLEAN DEFAULT TRUE,
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),
    
    CONSTRAINT chk_platform CHECK (platform IN ('ios','android','web','desktop'))
);

CREATE INDEX idx_push_tokens_user ON workspace.push_tokens(user_id) WHERE is_active = TRUE;
🔹 Tabla: notification_queue (Redis - no PostgreSQL)
NOTA: La cola de notificaciones se maneja en Redis (BullMQ):

Queue: notifications
Jobs:
├── {user_id, type: 'mention', message_id, channel_id, timestamp}
├── {user_id, type: 'dm', message_id, timestamp}
├── {user_id, type: 'thread_reply', message_id, timestamp}
└── {user_id, type: 'channel_message', message_id, channel_id}

Procesador:
├── Verifica preferencias del usuario
├── Verifica DND
├── Determina canales de entrega (push, email, desktop)
├── Batching: si hay múltiples, agrupa en una
└── Envía via FCM/APNs/Web Push/Email
3.11 ESQUEMA: ANALYTICS Y AUDIT
🔹 Tabla: audit_logs
CREATE TABLE analytics.audit_logs (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,
    actor_id        UUID REFERENCES auth.users(id),
    actor_type      VARCHAR(20) DEFAULT 'user',    -- user, admin, system, app
    action          VARCHAR(80) NOT NULL,           -- user.invite, channel.create, message.delete
    entity_type     VARCHAR(50),                    -- user, channel, message, workspace
    entity_id       UUID,
    details         JSONB,                          -- Detalles específicos del evento
    ip_address      INET,
    user_agent      TEXT,
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_audit_workspace ON analytics.audit_logs(workspace_id, created_at DESC);
CREATE INDEX idx_audit_actor ON analytics.audit_logs(actor_id, created_at DESC);
CREATE INDEX idx_audit_action ON analytics.audit_logs(workspace_id, action);
CREATE INDEX idx_audit_entity ON analytics.audit_logs(entity_type, entity_id);
🔹 Tabla: usage_stats (Agregados diarios)
CREATE TABLE analytics.usage_stats (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,
    stat_date       DATE NOT NULL,
    daily_active_users INTEGER DEFAULT 0,
    weekly_active_users INTEGER DEFAULT 0,
    monthly_active_users INTEGER DEFAULT 0,
    messages_sent   INTEGER DEFAULT 0,
    channels_active INTEGER DEFAULT 0,
    huddles_count   INTEGER DEFAULT 0,
    huddle_minutes  INTEGER DEFAULT 0,
    files_uploaded  INTEGER DEFAULT 0,
    apps_active     INTEGER DEFAULT 0,
    workflows_executed INTEGER DEFAULT 0,
    ai_queries      INTEGER DEFAULT 0,
    
    UNIQUE(workspace_id, stat_date)
);

CREATE INDEX idx_usage_workspace_date ON analytics.usage_stats(workspace_id, stat_date DESC);
🔹 Tabla: message_activity (Tracking por canal - para analytics)
CREATE TABLE analytics.message_activity (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL,
    channel_id      UUID NOT NULL,
    stat_date       DATE NOT NULL,
    messages_count  INTEGER DEFAULT 0,
    unique_posters  INTEGER DEFAULT 0,
    reactions_count INTEGER DEFAULT 0,
    thread_replies  INTEGER DEFAULT 0,
    
    UNIQUE(channel_id, stat_date)
);

CREATE INDEX idx_msg_activity_workspace ON analytics.message_activity(workspace_id, stat_date DESC);
3.12 ESQUEMA: SECURITY (Seguridad y Compliance)
🔹 Tabla: data_retention_policies
CREATE TABLE workspace.data_retention_policies (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    scope           VARCHAR(20) NOT NULL,           -- workspace, channel
    channel_id      UUID REFERENCES messaging.channels(id) ON DELETE CASCADE,
    message_retention_days INTEGER,                  -- NULL = ilimitado
    file_retention_days INTEGER,
    retain_threads  BOOLEAN DEFAULT TRUE,
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW()
);
🔹 Tabla: legal_holds
CREATE TABLE workspace.legal_holds (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    name            VARCHAR(120) NOT NULL,
    description     TEXT,
    user_ids        UUID[],                         -- Usuarios en hold
    channel_ids     UUID[],                         -- Canales en hold
    start_date      TIMESTAMPTZ DEFAULT NOW(),
    end_date        TIMESTAMPTZ,
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW()
);
🔹 Tabla: information_barriers
CREATE TABLE workspace.information_barriers (
    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id    UUID NOT NULL REFERENCES workspace.workspaces(id) ON DELETE CASCADE,
    name            VARCHAR(120) NOT NULL,
    group_a_type    VARCHAR(20) NOT NULL,           -- user_group, channel
    group_a_ids     UUID[] NOT NULL,
    group_b_type    VARCHAR(20) NOT NULL,
    group_b_ids     UUID[] NOT NULL,
    created_by      UUID NOT NULL REFERENCES auth.users(id),
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    is_active       BOOLEAN DEFAULT TRUE
);
3.13 ESTRATEGIA DE ÍNDICES Y OPTIMIZACIÓN
🔹 Índices Críticos (Hot Path)
1. CARGAR SIDEBAR DE CANALES (por usuario):
   Query: SELECT c.*, cm.unread_count, cm.last_read_ts 
           FROM channels c JOIN channel_members cm ON cm.channel_id = c.id
           WHERE cm.user_id = ? AND cm.workspace_id = ? AND cm.left_at IS NULL
           ORDER BY c.last_message_at DESC
   
   Índice: idx_channel_members_user (user_id, workspace_id) WHERE left_at IS NULL ✓
   Índice: idx_channels_last_message (workspace_id, last_message_at DESC) ✓

2. CARGAR MENSAJES DE UN CANAL (paginación):
   Query: SELECT * FROM messages WHERE channel_id = ? AND is_deleted = FALSE
           ORDER BY ts DESC LIMIT 50 OFFSET ?
   
   Índice: idx_messages_channel_ts (channel_id, ts DESC) ✓

3. BUSCAR MENSAJES:
   Query: Via Elasticsearch/Meilisearch (no PostgreSQL)
   
   PostgreSQL fallback: idx_messages_workspace (workspace_id, ts DESC) ✓

4. THREADS:
   Query: SELECT * FROM messages WHERE thread_root_id = ? ORDER BY ts ASC
   
   Índice: idx_messages_thread (thread_root_id, ts ASC) ✓

5. PRESENCIA:
   Redis: presence:{user_id} → TTL 60s
   
6. TYPING:
   Redis: typing:{channel_id}:{user_id} → TTL 5s
🔹 Estrategia de Particionamiento (Fase 2)
-- Particionar messages por mes (para retención y performance)
CREATE TABLE messaging.messages (
    -- ... todos los campos ...
) PARTITION BY RANGE (ts);

-- Particiones mensuales
CREATE TABLE messaging.messages_2025_01 PARTITION OF messaging.messages
    FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');

CREATE TABLE messaging.messages_2025_02 PARTITION OF messaging.messages
    FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');

-- Auto-crear particiones con pg_partman
-- SELECT partman.create_parent('messaging.messages', 'ts', 'native', 'monthly');
🔹 Row Level Security (Multi-tenant)
-- Habilitar RLS en todas las tablas con workspace_id
ALTER TABLE messaging.channels ENABLE ROW LEVEL SECURITY;
ALTER TABLE messaging.messages ENABLE ROW LEVEL SECURITY;
ALTER TABLE messaging.channel_members ENABLE ROW LEVEL SECURITY;
-- ... etc

-- Política: un usuario solo puede ver datos de sus workspaces
CREATE POLICY workspace_isolation ON messaging.channels
    USING (workspace_id IN (
        SELECT workspace_id FROM workspace.workspace_members
        WHERE user_id = current_setting('app.current_user_id')::uuid
        AND deactivated_at IS NULL
    ));
3.14 REDIS: ESTRUCTURAS DE DATOS EN MEMORIA
🔹 Keys principales en Redis:
# PRESENCIA
presence:{user_id}                    → STRING "online" | TTL 60s
presence:workspace:{workspace_id}     → SET de user_ids online
presence:channel:{channel_id}         → SET de user_ids online en canal

# TYPING INDICATORS
typing:{channel_id}:{user_id}         → STRING timestamp | TTL 5s

# UNREAD COUNTS (cache rápido)
unread:{user_id}:{channel_id}         → INTEGER count | TTL 24h

# SESSIONS (active WebSocket connections)
ws:connected:{user_id}                → SET de server_ids donde tiene conexiones
ws:server:{server_id}:channels        → SET de channel_ids suscritos en ese server

# RATE LIMITING
ratelimit:api:{user_id}:{endpoint}    → STRING counter | TTL 60s
ratelimit:ws:{user_id}:messages       → STRING counter | TTL 60s

# PUB/SUB (para broadcasting entre WebSocket servers)
channel:{channel_id}                  → PUBSUB channel (publicar mensajes aquí)
presence:updates                      → PUBSUB channel
user:{user_id}                        → PUBSUB channel (eventos personales)

# JOB QUEUES (BullMQ)
bull:notifications                    → Queue de notificaciones pendientes
bull:workflows                        → Queue de ejecuciones de workflow
bull:embeddings                       → Queue de generación de embeddings
bull:link_unfurling                   → Queue de unfurling de URLs
bull:file_processing                  → Queue de procesamiento de archivos
bull:search_indexing                  → Queue de indexación a Meilisearch/ES
bull:scheduled_messages               → Queue de mensajes programados
bull:email                            → Queue de envío de emails

# CACHE
cache:user:{user_id}                  → HASH con datos del usuario | TTL 5min
cache:channel:{channel_id}            → HASH con datos del canal | TTL 5min
cache:workspace:{workspace_id}        → HASH con datos del workspace | TTL 10min
cache:workspace_members:{workspace_id}→ SET de user_ids | TTL 5min
cache:channel_members:{channel_id}    → SET de user_ids | TTL 5min
cache:user_channels:{user_id}         → SET de channel_ids | TTL 5min

# ONLINE CONNECTIONS COUNTER
stats:online_users:total              → INTEGER (total conexiones globales)
stats:online_users:workspace:{ws_id}  → INTEGER (conexiones por workspace)
3.15 RESUMEN DE TABLAS (TOTAL: 40+ TABLAS)
Esquema	Tablas	Cantidad
auth	users, user_identities, sessions, two_factor_auth, password_resets	5
workspace	workspaces, workspace_members, workspace_invitations, user_groups, user_group_members, custom_emojis, workspace_settings, lists, list_fields, list_items, list_item_comments, canvases, canvas_collaborators, templates, notification_preferences, push_tokens, huddles, huddle_participants, huddle_notes, data_retention_policies, legal_holds, information_barriers	22
messaging	channels, channel_members, messages, message_reactions, message_pins, channel_bookmarks, saved_messages, scheduled_messages, shared_channels	9
files	files, file_shares, file_comments	3
automation	workflows, workflow_executions, apps, bot_users, slash_commands, incoming_webhooks, event_subscriptions	7
analytics	audit_logs, usage_stats, message_activity	3
ai	message_embeddings, ai_summaries, ai_conversations, ai_search_cache	4
TOTAL		53 tablas


📌 PARTE 4: BACKEND COMPLETO — APIs, WEBSOCKET, REAL-TIME Y SERVICIOS
4.1 ARQUITECTURA DEL BACKEND (NestJS)
🔹 Estructura de Proyectos
backend/
├── apps/
│   ├── api/                    → API Gateway + REST endpoints
│   │   ├── src/
│   │   │   ├── modules/
│   │   │   │   ├── auth/           → Login, register, SSO, 2FA
│   │   │   │   ├── users/          → CRUD usuarios, perfil, status
│   │   │   │   ├── workspaces/     → CRUD workspaces, miembros
│   │   │   │   ├── channels/       → CRUD canales, membresía
│   │   │   │   ├── messages/       → Enviar, editar, borrar, threads
│   │   │   │   ├── files/          → Upload, download, preview
│   │   │   │   ├── search/         → Búsqueda global
│   │   │   │   ├── huddles/        → Llamadas audio/video
│   │   │   │   ├── lists/          → Lists, tasks, kanban
│   │   │   │   ├── canvases/       → Documentos colaborativos
│   │   │   │   ├── workflows/      → Automatizaciones
│   │   │   │   ├── integrations/   → Apps, webhooks, bots
│   │   │   │   ├── notifications/  → Preferencias, push
│   │   │   │   ├── admin/          → Analytics, audit, gestión
│   │   │   │   └── ai/             → Slackbot, summaries, search IA
│   │   │   ├── common/
│   │   │   │   ├── decorators/     → @CurrentUser, @Workspace, @Roles
│   │   │   │   ├── guards/         → JwtGuard, WorkspaceGuard, RoleGuard
│   │   │   │   ├── interceptors/   → Logging, Transform, RateLimit
│   │   │   │   ├── filters/        → ExceptionFilter global
│   │   │   │   ├── pipes/          → ValidationPipe custom
│   │   │   │   └── middleware/     → RequestId, WorkspaceContext
│   │   │   ├── config/             → Configuración por env
│   │   │   ├── main.ts
│   │   │   └── app.module.ts
│   │   ├── package.json
│   │   └── tsconfig.json
│   │
│   ├── realtime/               → WebSocket Gateway
│   │   ├── src/
│   │   │   ├── gateways/
│   │   │   │   ├── chat.gateway.ts       → Eventos de mensajería
│   │   │   │   ├── presence.gateway.ts   → Presencia y status
│   │   │   │   └── huddle.gateway.ts     → Señalización WebRTC
│   │   │   ├── services/
│   │   │   │   ├── connection.service.ts → Gestión de conexiones
│   │   │   │   ├── pubsub.service.ts     → Redis Pub/Sub
│   │   │   │   ├── presence.service.ts   → Tracking presencia
│   │   │   │   └── broadcast.service.ts  → Broadcasting
│   │   │   ├── events/                   → Definición de eventos
│   │   │   │   └── events.ts
│   │   │   └── main.ts
│   │   └── package.json
│   │
│   └── workers/                → Background job processors
│       ├── src/
│       │   ├── processors/
│       │   │   ├── notifications.processor.ts
│       │   │   ├── search-indexer.processor.ts
│       │   │   ├── embeddings.processor.ts
│       │   │   ├── link-unfurl.processor.ts
│       │   │   ├── file-processing.processor.ts
│       │   │   ├── scheduled-messages.processor.ts
│       │   │   ├── workflow-executor.processor.ts
│       │   │   └── ai-summaries.processor.ts
│       │   └── main.ts
│       └── package.json
│
├── libs/
│   ├── database/               → Prisma schema, migrations, seeds
│   ├── redis/                  → Redis client, pub/sub, cache helpers
│   ├── types/                  → TypeScript types compartidos
│   ├── utils/                  → Helpers (crypto, date, validation)
│   ├── constants/              → Constantes y enums
│   └── dtos/                   → Data Transfer Objects compartidos
│
├── docker-compose.yml
├── package.json                → Workspace root (monorepo)
└── turbo.json                  → Turborepo config
4.2 SISTEMA DE AUTENTICACIÓN
🔹 JWT + Refresh Token Strategy
Flujo de autenticación:

1. LOGIN:
   POST /api/v1/auth/login
   → { email, password }
   ← { access_token (15min), refresh_token (30d), user }

2. REQUESTS AUTENTICADOS:
   Authorization: Bearer {access_token}
   Header: X-Workspace-Id: {workspace_id}

3. TOKEN REFRESH:
   POST /api/v1/auth/refresh
   → { refresh_token }
   ← { access_token, refresh_token } (rotación)

4. LOGOUT:
   POST /api/v1/auth/logout
   → Revoca refresh token + invalida sesión
🔹 Middleware de Autenticación
// apps/api/src/common/guards/jwt.guard.ts

@Injectable()
export class JwtAuthGuard implements CanActivate {
  constructor(private jwtService: JwtService) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const token = this.extractToken(request);
    
    if (!token) {
      throw new UnauthorizedException('No token provided');
    }

    try {
      const payload = await this.jwtService.verifyAsync(token, {
        secret: process.env.JWT_SECRET,
      });
      request.user = payload; // { userId, email, iat, exp }
    } catch {
      throw new UnauthorizedException('Invalid or expired token');
    }

    return true;
  }

  private extractToken(request: Request): string | undefined {
    const [type, token] = request.headers.authorization?.split(' ') ?? [];
    return type === 'Bearer' ? token : undefined;
  }
}
🔹 Workspace Context Middleware
// apps/api/src/common/middleware/workspace-context.middleware.ts

@Injectable()
export class WorkspaceContextMiddleware implements NestMiddleware {
  constructor(private workspaceMemberService: WorkspaceMemberService) {}

  async use(req: Request, res: Response, next: NextFunction) {
    const workspaceId = req.headers['x-workspace-id'] as string;
    const userId = req.user?.userId;

    if (workspaceId && userId) {
      // Verificar que el usuario es miembro del workspace
      const membership = await this.workspaceMemberService.findByUserAndWorkspace(
        userId,
        workspaceId
      );

      if (!membership || membership.deactivatedAt) {
        throw new ForbiddenException('Not a member of this workspace');
      }

      req.workspace = {
        id: workspaceId,
        role: membership.role,
        membershipId: membership.id,
      };
    }

    next();
  }
}
🔹 Decoradores Personalizados
// apps/api/src/common/decorators/current-user.decorator.ts
export const CurrentUser = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    const user = request.user;
    return data ? user?.[data] : user;
  }
);

// apps/api/src/common/decorators/workspace.decorator.ts
export const Workspace = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    const workspace = request.workspace;
    return data ? workspace?.[data] : workspace;
  }
);

// apps/api/src/common/decorators/roles.decorator.ts
export const Roles = (...roles: string[]) => SetMetadata('roles', roles);

// Uso en controllers:
@Get('channels')
@Roles('owner', 'admin', 'member')
async getChannels(@CurrentUser('userId') userId: string, @Workspace('id') wsId: string) {
  return this.channelService.findAll(userId, wsId);
}
4.3 APIs REST COMPLETAS (TODOS LOS ENDPOINTS)
🔹 A. AUTH MODULE
// ============================================
// POST /api/v1/auth/register
// ============================================
// Request:
{
  "email": "user@company.com",
  "password": "SecurePass123!",
  "display_name": "John Doe",
  "workspace_name": "My Company"    // Opcional: crea workspace también
}
// Response 201:
{
  "user": { "id": "uuid", "email": "...", "display_name": "..." },
  "workspace": { "id": "uuid", "name": "My Company", "domain": "my-company" },
  "access_token": "eyJ...",
  "refresh_token": "eyJ..."
}

// ============================================
// POST /api/v1/auth/login
// ============================================
// Request:
{
  "email": "user@company.com",
  "password": "SecurePass123!"
}
// Response 200:
{
  "user": { "id": "uuid", "email": "...", "display_name": "..." },
  "workspaces": [
    { "id": "uuid", "name": "My Company", "domain": "my-company", "role": "owner" },
    { "id": "uuid", "name": "Client Project", "domain": "client-proj", "role": "member" }
  ],
  "access_token": "eyJ...",
  "refresh_token": "eyJ..."
}

// ============================================
// POST /api/v1/auth/refresh
// ============================================
// Request: { "refresh_token": "eyJ..." }
// Response: { "access_token": "eyJ...", "refresh_token": "eyJ..." }

// ============================================
// POST /api/v1/auth/logout
// ============================================
// Headers: Authorization: Bearer {token}
// Response: 204 No Content

// ============================================
// POST /api/v1/auth/forgot-password
// ============================================
// Request: { "email": "user@company.com" }
// Response: 200 { "message": "If the email exists, a reset link has been sent" }

// ============================================
// POST /api/v1/auth/reset-password
// ============================================
// Request: { "token": "reset-token", "password": "NewPass123!" }
// Response: 200 { "message": "Password updated successfully" }

// ============================================
// POST /api/v1/auth/verify-email
// ============================================
// Request: { "token": "verification-token" }
// Response: 200 { "message": "Email verified" }

// ============================================
// POST /api/v1/auth/2fa/enable
// ============================================
// Response: { "secret": "JBSWY3DPEHPK3PXP", "qr_url": "otpauth://..." }

// ============================================
// POST /api/v1/auth/2fa/verify
// ============================================
// Request: { "code": "123456" }
// Response: { "backup_codes": ["xxxx", "yyyy", ...] }

// ============================================
// POST /api/v1/auth/sso/callback
// ============================================
// Recibe callback de proveedor SSO (Google, SAML, etc.)
// Request: { "provider": "google", "code": "auth_code" }
// Response: { "user", "workspaces", "access_token", "refresh_token" }

// ============================================
// GET /api/v1/auth/sessions
// ============================================
// Lista sesiones activas del usuario
// Response: [{ "id", "device_type", "device_name", "ip", "location", "last_active", "is_current" }]

// ============================================
// DELETE /api/v1/auth/sessions/:id
// ============================================
// Revoca una sesión específica
// Response: 204
🔹 B. USERS MODULE
// ============================================
// GET /api/v1/users
// ============================================
// Lista usuarios del workspace (con paginación)
// Query: ?search=juan&role=member&page=1&limit=50
// Response:
{
  "users": [
    {
      "id": "uuid",
      "display_name": "John Doe",
      "real_name": "John Doe",
      "email": "john@company.com",
      "title": "Software Engineer",
      "avatar_url": "https://...",
      "status_text": "In a meeting",
      "status_emoji": ":spiral_calendar:",
      "presence": "away",
      "is_bot": false,
      "role": "member",
      "timezone": "America/Bogota"
    }
  ],
  "total": 150,
  "page": 1,
  "limit": 50
}

// ============================================
// GET /api/v1/users/:id
// ============================================
// Detalle de un usuario
// Response: { ...user, "profile": { "phone", "bio", "pronouns" }, "joined_at" }

// ============================================
// PATCH /api/v1/users/me
// ============================================
// Actualizar propio perfil
// Request: { "display_name": "New Name", "title": "New Title", "avatar": "file_id" }
// Response: { ...updatedUser }

// ============================================
// PUT /api/v1/users/me/status
// ============================================
// Actualizar status custom
// Request: { "text": "On vacation", "emoji": ":palm_tree:", "expires_at": "2025-01-20T00:00:00Z" }
// Response: { "status_text": "On vacation", "status_emoji": ":palm_tree:", "status_expires": "..." }

// ============================================
// PUT /api/v1/users/me/presence
// ============================================
// Actualizar presencia manual
// Request: { "presence": "away" }  // away, dnd, auto
// Response: { "presence": "away" }

// ============================================
// GET /api/v1/users/me/preferences
// ============================================
// Preferencias del usuario
// Response: { "sidebar_sections": [...], "theme": {...}, "notifications": {...} }

// ============================================
// PATCH /api/v1/users/me/preferences
// ============================================
// Actualizar preferencias
// Request: { "theme": { "colony": "#1264a3" } }

// ============================================
// GET /api/v1/users/:id/conversations
// ============================================
// DMs y canales compartidos con este usuario
🔹 C. WORKSPACES MODULE
// ============================================
// POST /api/v1/workspaces
// ============================================
// Crear nuevo workspace
// Request: { "name": "My Company", "domain": "my-company" }
// Response: { "id": "uuid", "name": "...", "domain": "..." }

// ============================================
// GET /api/v1/workspaces/:id
// ============================================
// Detalle del workspace
// Response: { "id", "name", "domain", "logo_url", "plan", "member_count", "settings" }

// ============================================
// PATCH /api/v1/workspaces/:id
// ============================================
// Actualizar workspace (admin)
// Request: { "name": "Updated Name", "logo_url": "..." }

// ============================================
// GET /api/v1/workspaces/:id/members
// ============================================
// Lista miembros del workspace
// Query: ?role=member&page=1&limit=100
// Response: { "members": [...], "total": 150 }

// ============================================
// POST /api/v1/workspaces/:id/invitations
// ============================================
// Invitar usuarios
// Request: { "emails": ["user1@test.com", "user2@test.com"], "role": "member" }
// Response: { "invitations": [{ "email", "token", "expires_at" }] }

// ============================================
// POST /api/v1/workspaces/:id/invitations/accept
// ============================================
// Aceptar invitación
// Request: { "token": "invitation-token" }

// ============================================
// DELETE /api/v1/workspaces/:id/members/:userId
// ============================================
// Remover usuario del workspace (admin)
// Response: 204

// ============================================
// PATCH /api/v1/workspaces/:id/members/:userId
// ============================================
// Cambiar rol de usuario
// Request: { "role": "admin" }

// ============================================
// GET /api/v1/workspaces/:id/user-groups
// ============================================
// Lista grupos de usuarios
// Response: [{ "id", "name", "handle", "description", "members_count" }]

// ============================================
// POST /api/v1/workspaces/:id/user-groups
// ============================================
// Crear grupo de usuarios
// Request: { "name": "Marketing Team", "handle": "marketing", "user_ids": ["uuid1", "uuid2"] }

// ============================================
// GET /api/v1/workspaces/:id/emojis
// ============================================
// Lista custom emojis
// Response: [{ "id", "name", "image_url", "aliases" }]

// ============================================
// POST /api/v1/workspaces/:id/emojis
// ============================================
// Subir custom emoji
// Request: multipart/form-data { "name": "parrot", "image": File }

// ============================================
// GET /api/v1/workspaces/:id/analytics
// ============================================
// Analytics del workspace (admin)
// Query: ?period=30d
// Response: { "dau": [...], "messages_sent": 50000, "active_channels": 45, ... }
🔹 D. CHANNELS MODULE (EL MÁS IMPORTANTE)
// ============================================
// GET /api/v1/channels
// ============================================
// Lista canales del usuario en el workspace
// Query: ?type=public&archived=false&search=marketing&page=1&limit=100
// Response:
{
  "channels": [
    {
      "id": "uuid",
      "name": "marketing-team",
      "type": "public",
      "topic": "Marketing discussions",
      "purpose": "For all marketing team communication",
      "is_archived": false,
      "member_count": 25,
      "unread_count": 5,
      "unread_mention_count": 2,
      "last_read_ts": "2025-01-15T10:30:00Z",
      "last_message": {
        "text": "Let's discuss the campaign",
        "user": "uuid",
        "ts": "2025-01-15T11:00:00Z"
      },
      "is_muted": false,
      "notification_pref": "all"
    }
  ],
  "total": 45
}

// ============================================
// POST /api/v1/channels
// ============================================
// Crear canal
// Request:
{
  "name": "new-project",
  "type": "public",           // public, private
  "topic": "New project discussion",
  "purpose": "Coordinate the new product launch",
  "user_ids": ["uuid1", "uuid2"]  // Invitar usuarios
}
// Response: { "id": "uuid", "name": "new-project", ... }

// ============================================
// GET /api/v1/channels/:id
// ============================================
// Detalle de un canal
// Response: { ...channel, "members": [...], "pins": [...], "bookmarks": [...] }

// ============================================
// PATCH /api/v1/channels/:id
// ============================================
// Actualizar canal
// Request: { "name": "renamed-channel", "topic": "New topic" }

// ============================================
// POST /api/v1/channels/:id/archive
// ============================================
// Archivar canal
// Response: { "is_archived": true, "archived_at": "..." }

// ============================================
// POST /api/v1/channels/:id/unarchive
// ============================================
// Desarchivar canal

// ============================================
// POST /api/v1/channels/:id/join
// ============================================
// Unirse a canal público
// Response: 204

// ============================================
// POST /api/v1/channels/:id/leave
// ============================================
// Salir de canal
// Response: 204

// ============================================
// POST /api/v1/channels/:id/invite
// ============================================
// Invitar usuarios a canal
// Request: { "user_ids": ["uuid1", "uuid2"] }
// Response: { "invited": ["uuid1", "uuid2"] }

// ============================================
// DELETE /api/v1/channels/:id/members/:userId
// ============================================
// Remover usuario del canal (admin)

// ============================================
// GET /api/v1/channels/:id/members
// ============================================
// Lista miembros del canal
// Query: ?page=1&limit=100
// Response: { "members": [{ "id", "display_name", "avatar_url", "role", "joined_at" }] }

// ============================================
// PATCH /api/v1/channels/:id/members/me
// ============================================
// Actualizar preferencias del canal para el usuario actual
// Request: { "notification_pref": "mentions", "muted": true }

// ============================================
// POST /api/v1/channels/:id/mark-read
// ============================================
// Marcar canal como leído
// Request: { "ts": "2025-01-15T11:00:00Z" }  // Hasta qué timestamp marcar como leído
// Response: 204

// ============================================
// GET /api/v1/channels/:id/bookmarks
// ============================================
// Lista bookmarks del canal
// Response: [{ "id", "type", "title", "url", "emoji", "order_index" }]

// ============================================
// POST /api/v1/channels/:id/bookmarks
// ============================================
// Agregar bookmark
// Request: { "type": "link", "title": "Docs", "url": "https://...", "emoji": ":books:" }

// ============================================
// GET /api/v1/channels/:id/pins
// ============================================
// Lista mensajes fijados
// Response: [{ "message_id", "pinned_by", "pinned_at", "message": {...} }]

// ============================================
// POST /api/v1/channels/:id/pins
// ============================================
// Fijar mensaje
// Request: { "message_id": "uuid" }

// ============================================
// POST /api/v1/channels/:id/convert
// ============================================
// Convertir canal (public ↔ private)
// Request: { "to_type": "private" }

// ============================================
// POST /api/v1/channels/:id/share
// ============================================
// Compartir canal con otro workspace (Slack Connect)
// Request: { "target_workspace_domain": "partner-company" }
// Response: { "shared_channel_id": "uuid", "status": "pending" }
🔹 E. MESSAGES MODULE (EL CORE)
// ============================================
// GET /api/v1/channels/:id/messages
// ============================================
// Lista mensajes de un canal (paginación por cursor)
// Query: ?limit=50&cursor=2025-01-15T10:00:00Z&direction=older
// Response:
{
  "messages": [
    {
      "id": "uuid",
      "user_id": "uuid",
      "display_name": "John Doe",
      "avatar_url": "https://...",
      "text": "Hello team!",
      "blocks": [
        { "type": "section", "text": { "type": "mrkdwn", "text": "Hello *team*!" } }
      ],
      "attachments": [],
      "mentioned_users": ["uuid2"],
      "reactions": [
        { "emoji": ":thumbsup:", "count": 3, "users": ["uuid1", "uuid2", "uuid3"] }
      ],
      "thread_id": null,
      "thread_root_id": null,
      "reply_count": 0,
      "is_edited": false,
      "is_pinned": false,
      "files": [
        { "id": "uuid", "filename": "doc.pdf", "url": "...", "thumbnail_url": "..." }
      ],
      "link_previews": [
        { "url": "https://example.com", "title": "Example", "image": "..." }
      ],
      "ts": "2025-01-15T10:30:00Z",
      "created_at": "2025-01-15T10:30:00Z"
    }
  ],
  "has_more": true,
  "next_cursor": "2025-01-15T09:00:00Z"
}

// ============================================
// POST /api/v1/channels/:id/messages
// ============================================
// Enviar mensaje
// Request:
{
  "text": "Check this out!",                    // Texto plano (fallback)
  "blocks": [                                     // Contenido rico (Block Kit)
    {
      "type": "section",
      "text": { "type": "mrkdwn", "text": "Check *this* out! :tada:" }
    },
    {
      "type": "actions",
      "elements": [
        { "type": "button", "text": { "type": "plain_text", "text": "Approve" }, "action_id": "approve", "value": "yes" }
      ]
    }
  ],
  "thread_root_id": "uuid-of-parent-message",    // Opcional: si es reply
  "file_ids": ["uuid1"],                          // Archivos adjuntos
  "scheduled_for": null,                          // O timestamp para programar
  "unfurl_links": true,                           // Auto preview de URLs
  "unfurl_media": true
}
// Response 201:
{
  "id": "uuid",
  "channel_id": "uuid",
  "user_id": "uuid",
  "text": "Check this out!",
  "blocks": [...],
  "ts": "2025-01-15T10:31:00Z"
}

// ============================================
// PATCH /api/v1/messages/:id
// ============================================
// Editar mensaje
// Request: { "text": "Updated text", "blocks": [...] }
// Response: { ...updatedMessage, "is_edited": true, "edited_at": "..." }

// ============================================
// DELETE /api/v1/messages/:id
// ============================================
// Borrar mensaje (soft delete)
// Response: 204

// ============================================
// GET /api/v1/messages/:id/thread
// ============================================
// Lista replies de un thread
// Query: ?limit=50&cursor=...
// Response: { "messages": [...], "has_more": true }

// ============================================
// POST /api/v1/messages/:id/reactions
// ============================================
// Agregar reacción
// Request: { "emoji": ":thumbsup:" }
// Response: { "emoji": ":thumbsup:", "user_id": "uuid", "created_at": "..." }

// ============================================
// DELETE /api/v1/messages/:id/reactions/:emoji
// ============================================
// Quitar reacción
// Response: 204

// ============================================
// POST /api/v1/messages/:id/schedule
// ============================================
// Programar mensaje
// Request: { "text": "...", "scheduled_for": "2025-01-20T09:00:00Z" }

// ============================================
// GET /api/v1/messages/scheduled
// ============================================
// Lista mensajes programados del usuario
// Response: [{ "id", "channel_id", "text", "scheduled_for", "status" }]

// ============================================
// DELETE /api/v1/messages/scheduled/:id
// ============================================
// Cancelar mensaje programado

// ============================================
// POST /api/v1/messages/:id/save
// ============================================
// Guardar mensaje para después
// Response: 201

// ============================================
// DELETE /api/v1/messages/:id/save
// ============================================
// Quitar de guardados

// ============================================
// GET /api/v1/users/me/saved
// ============================================
// Lista mensajes guardados
// Response: [{ "message": {...}, "saved_at": "..." }]
🔹 F. DMs MODULE
// ============================================
// GET /api/v1/dms
// ============================================
// Lista conversaciones DM
// Response: [{ "id", "type": "dm|group_dm", "name", "members": [...], "last_message": {...}, "unread_count": 3 }]

// ============================================
// POST /api/v1/dms
// ============================================
// Iniciar DM o group DM
// Request: { "user_ids": ["uuid1"], "initial_message": "Hi!" }
//   → Si 1 user: DM. Si 2-9: Group DM
// Response: { "channel_id": "uuid", "type": "dm" }

// ============================================
// PATCH /api/v1/dms/:id
// ============================================
// Renombrar group DM
// Request: { "name": "Project Chat" }
🔹 G. FILES MODULE
// ============================================
// POST /api/v1/files/upload
// ============================================
// Subir archivo (multipart)
// Request: multipart/form-data
//   file: File (binary)
//   channel_id: "uuid" (opcional, compartir al subir)
//   title: "Document title"
//   comment: "Initial comment"
// Response:
{
  "id": "uuid",
  "filename": "document.pdf",
  "file_type": "pdf",
  "mime_type": "application/pdf",
  "size_bytes": 1024000,
  "url": "https://s3.../presigned-url",
  "thumbnail_url": "https://s3.../thumb-url",
  "upload_status": "complete"
}

// ============================================
// GET /api/v1/files/:id
// ============================================
// Detalle de archivo
// Response: { ...file, "shares": [{ "channel_id", "message_id" }], "comments": [...] }

// ============================================
// GET /api/v1/files/:id/download
// ============================================
// Descargar archivo (redirect a presigned URL)
// Response: 302 → S3 presigned URL

// ============================================
// DELETE /api/v1/files/:id
// ============================================
// Borrar archivo
// Response: 204

// ============================================
// POST /api/v1/files/:id/share
// ============================================
// Compartir archivo en canal(es)
// Request: { "channel_ids": ["uuid1", "uuid2"], "comment": "Check this file" }

// ============================================
// POST /api/v1/files/:id/comments
// ============================================
// Comentar archivo
// Request: { "text": "Great document!" }
🔹 H. SEARCH MODULE
// ============================================
// GET /api/v1/search
// ============================================
// Búsqueda global
// Query: ?q=project+launch&type=all&channel_id=uuid&user_id=uuid&from=2025-01-01&to=2025-01-31&page=1&limit=20
// Response:
{
  "query": "project launch",
  "results": {
    "messages": [
      {
        "message": { "id", "text", "channel_id", "channel_name", "user_id", "display_name", "ts" },
        "score": 0.95,
        "highlights": ["<em>project launch</em> is scheduled for..."]
      }
    ],
    "files": [{ "id", "filename", "file_type", "url" }],
    "channels": [{ "id", "name", "topic", "member_count" }],
    "people": [{ "id", "display_name", "title", "avatar_url" }]
  },
  "total": 150,
  "took_ms": 45
}

// ============================================
// POST /api/v1/search/ai
// ============================================
// Búsqueda con IA (pregunta en lenguaje natural)
// Request: { "question": "What's the status of the marketing campaign?" }
// Response:
{
  "answer": "The marketing campaign is currently in the review phase. John mentioned on Jan 15 that the designs are ready for approval...",
  "sources": [
    { "message_id": "uuid", "channel_name": "marketing-team", "user": "John Doe", "ts": "2025-01-15T10:00:00Z", "snippet": "The designs are ready..." }
  ],
  "confidence": 0.89
}
🔹 I. LISTS MODULE
// ============================================
// GET /api/v1/channels/:id/lists
// ============================================
// Listas de un canal
// Response: [{ "id", "name", "view_type", "description", "items_count" }]

// ============================================
// POST /api/v1/channels/:id/lists
// ============================================
// Crear lista
// Request: { "name": "Sprint Tasks", "view_type": "table" }

// ============================================
// GET /api/v1/lists/:id
// ============================================
// Detalle de lista con campos
// Response: { ...list, "fields": [{ "id", "name", "field_type", "options" }] }

// ============================================
// POST /api/v1/lists/:id/fields
// ============================================
// Agregar campo a lista
// Request: { "name": "Status", "field_type": "select", "options": ["Todo", "In Progress", "Done"] }

// ============================================
// GET /api/v1/lists/:id/items
// ============================================
// Items de la lista
// Query: ?view=board&group_by=Status&filter={"Status":"Done"}&page=1
// Response: { "items": [{ "id", "name", "field_values": {...}, "order_index" }] }

// ============================================
// POST /api/v1/lists/:id/items
// ============================================
// Crear item
// Request: { "name": "Design landing page", "field_values": { "Assignee": "uuid", "Due Date": "2025-01-20", "Status": "Todo" } }

// ============================================
// PATCH /api/v1/lists/:id/items/:itemId
// ============================================
// Actualizar item
// Request: { "field_values": { "Status": "Done" } }

// ============================================
// DELETE /api/v1/lists/:id/items/:itemId
// ============================================
// Borrar item

// ============================================
// POST /api/v1/lists/:id/items/:itemId/comments
// ============================================
// Comentar item
// Request: { "text": "This needs revision" }

// ============================================
// POST /api/v1/lists/:id/views
// ============================================
// Guardar vista custom
// Request: { "name": "My Tasks", "filters": {...}, "sort": {...}, "group_by": "Status", "layout": "board" }
🔹 J. CANVASES MODULE
// ============================================
// POST /api/v1/canvases
// ============================================
// Crear canvas
// Request: { "title": "Project Brief", "channel_id": "uuid", "content": {} }
// Response: { "id": "uuid", "title": "...", "document_id": "uuid" }

// ============================================
// GET /api/v1/canvases/:id
// ============================================
// Obtener canvas
// Response: { "id", "title", "content": { TipTap JSON }, "version": 3, "last_edited_by": "uuid" }

// ============================================
// PATCH /api/v1/canvases/:id
// ============================================
// Actualizar canvas (collaborative editing via Yjs/Hocuspocus)
// Request: { "content": { updated TipTap JSON }, "version": 4 }

// ============================================
// POST /api/v1/canvases/:id/collaborators
// ============================================
// Agregar colaborador
// Request: { "user_id": "uuid", "permission": "edit" }

// ============================================
// GET /api/v1/templates
// ============================================
// Lista templates
// Query: ?category=onboarding
// Response: [{ "id", "name", "description", "category", "type" }]

// ============================================
// POST /api/v1/templates/:id/instantiate
// ============================================
// Crear desde template
// Request: { "channel_id": "uuid" }
🔹 K. WORKFLOWS MODULE
// ============================================
// GET /api/v1/workflows
// ============================================
// Lista workflows
// Response: [{ "id", "name", "status", "trigger_type", "execution_count" }]

// ============================================
// POST /api/v1/workflows
// ============================================
// Crear workflow
// Request:
{
  "name": "Welcome new members",
  "description": "Send welcome message when someone joins",
  "trigger_type": "channel_join",
  "trigger_config": { "channel_id": "uuid" },
  "steps": [
    { "type": "send_message", "config": { "channel_id": "${trigger.channel_id}", "text": "Welcome ${trigger.user_name}! 👋" } },
    { "type": "add_to_channel", "config": { "user_id": "${trigger.user_id}", "channel_id": "uuid-introductions" } }
  ]
}

// ============================================
// PATCH /api/v1/workflows/:id
// ============================================
// Actualizar workflow

// ============================================
// POST /api/v1/workflows/:id/activate
// ============================================
// Activar workflow

// ============================================
// POST /api/v1/workflows/:id/pause
// ============================================
// Pausar workflow

// ============================================
// GET /api/v1/workflows/:id/executions
// ============================================
// Historial de ejecuciones
// Response: [{ "id", "status", "started_at", "completed_at", "error_message" }]

// ============================================
// POST /api/v1/workflows/generate
// ============================================
// Generar workflow con IA
// Request: { "prompt": "Create a workflow that sends a daily standup reminder at 9am" }
// Response: { "workflow": { ...generatedWorkflow } }
🔹 L. INTEGRATIONS MODULE
// ============================================
// GET /api/v1/integrations/apps
// ============================================
// App directory
// Query: ?category=productivity&search=github
// Response: [{ "slug", "name", "description", "icon_url", "categories", "installed": false }]

// ============================================
// POST /api/v1/integrations/apps/:slug/install
// ============================================
// Instalar app
// Request: { "scopes": ["channels:read", "chat:write"] }
// Response: { "oauth_url": "https://..." }  → Redirect usuario a OAuth

// ============================================
// DELETE /api/v1/integrations/apps/:slug
// ============================================
// Desinstalar app

// ============================================
// POST /api/v1/integrations/webhooks/incoming
// ============================================
// Crear incoming webhook
// Request: { "channel_id": "uuid", "name": "CI/CD Notifications" }
// Response: { "id": "uuid", "webhook_url": "https://api.chat.com/hooks/xxx" }

// ============================================
// POST /api/v1/integrations/slash-commands
// ============================================
// Crear slash command
// Request: { "command": "/ticket", "url": "https://myapp.com/slack/command", "description": "Create a ticket" }

// ============================================
// POST /api/v1/integrations/webhooks/event-subscriptions
// ============================================
// Suscribirse a eventos
// Request: { "callback_url": "https://myapp.com/events", "event_types": ["message.channels", "team_join"] }

// ============================================
// POST /api/v1/integrations/interactive
// ============================================
// Endpoint para recibir interacciones de Block Kit (botones, menus, modals)
// Request: { "type": "block_actions", "actions": [{ "action_id": "approve", "value": "yes" }], "user": {...}, "channel": {...}, "message": {...} }
// Response: Puede devolver un modal update o un mensaje
🔹 M. AI MODULE
// ============================================
// POST /api/v1/ai/chat
// ============================================
// Chat con Slackbot
// Request: { "message": "What did the team decide about the launch date?" }
// Response:
{
  "answer": "The team decided to launch on February 15th. This was discussed in the #product-launch channel on January 10th...",
  "sources": [{ "message_id", "channel_name", "snippet" }],
  "conversation_id": "uuid"
}

// ============================================
// POST /api/v1/ai/summarize/channel/:channelId
// ============================================
// Resumir conversación de canal
// Request: { "period": "24h" }  // 24h, 7d, 30d, or custom range
// Response:
{
  "summary": "The team discussed three main topics: 1) The Q1 roadmap was finalized...",
  "key_points": ["Q1 roadmap finalized", "Budget approved for $50k", "New hire starting Feb 1"],
  "action_items": [{ "item": "Send budget proposal to CFO", "assignee": "John Doe" }],
  "participants": ["John Doe", "Jane Smith", "Bob Wilson"]
}

// ============================================
// POST /api/v1/ai/summarize/thread/:messageId
// ============================================
// Resumir thread
// Response: { "summary": "...", "key_points": [...], "decisions": [...] }

// ============================================
// POST /api/v1/ai/summarize/huddle/:huddleId
// ============================================
// Notas de huddle (transcripción + resumen)
// Response: { "transcript": "...", "summary": "...", "action_items": [...] }

// ============================================
// POST /api/v1/ai/recaps/setup
// ============================================
// Configurar recaps diarios
// Request: { "channel_ids": ["uuid1", "uuid2"], "time": "09:00", "timezone": "America/Bogota" }

// ============================================
// GET /api/v1/ai/recaps
// ============================================
// Obtener recap de hoy
// Response: { "date": "2025-01-15", "channels": [{ "channel_id", "channel_name", "summary": "..." }] }

// ============================================
// POST /api/v1/ai/translate
// ============================================
// Traducir mensaje
// Request: { "message_id": "uuid", "target_language": "es" }
// Response: { "translated_text": "Hola equipo", "detected_language": "en" }

// ============================================
// POST /api/v1/ai/file-summary/:fileId
// ============================================
// Resumir documento
// Response: { "summary": "...", "key_points": [...], "document_type": "pdf" }
🔹 N. NOTIFICATIONS MODULE
// ============================================
// GET /api/v1/notifications
// ============================================
// Lista notificaciones recientes
// Response: [{ "id", "type", "message_id", "channel_id", "is_read", "created_at" }]

// ============================================
// POST /api/v1/notifications/register-push
// ============================================
// Registrar token de push notification
// Request: { "platform": "ios", "token": "device-token", "device_id": "..." }

// ============================================
// DELETE /api/v1/notifications/push/:tokenId
// ============================================
// Desregistrar token

// ============================================
// PUT /api/v1/notifications/preferences
// ============================================
// Actualizar preferencias globales
// Request: { "push_enabled": true, "email_frequency": "daily", "dnd_enabled": true, "dnd_start": "22:00", "dnd_end": "08:00", "keywords": ["urgent", "deadline"] }

// ============================================
// PUT /api/v1/notifications/preferences/channels/:channelId
// ============================================
// Preferencias por canal
// Request: { "notification_pref": "mentions", "muted": true }

// ============================================
// POST /api/v1/notifications/mark-all-read
// ============================================
// Marcar todas como leídas
🔹 O. HUDDLES MODULE
// ============================================
// POST /api/v1/channels/:id/huddles
// ============================================
// Iniciar huddle
// Request: { "is_video": false }
// Response: { "id": "uuid", "room_id": "mediasoup-room-id", "ws_signaling_url": "..." }

// ============================================
// POST /api/v1/huddles/:id/join
// ============================================
// Unirse a huddle
// Response: { "room_id", "participant_id", "ice_servers": [...] }

// ============================================
// POST /api/v1/huddles/:id/leave
// ============================================
// Salir de huddle

// ============================================
// POST /api/v1/huddles/:id/end
// ============================================
// Terminar huddle

// ============================================
// GET /api/v1/huddles/:id/participants
// ============================================
// Lista participantes
// Response: [{ "user_id", "display_name", "avatar_url", "has_audio", "has_video", "is_screensharing" }]

// ============================================
// POST /api/v1/huddles/:id/notes
// ============================================
// Generar notas de huddle con IA
// Response: { "transcript", "summary", "action_items": [...] }

// ============================================
// POST /api/v1/huddles/:id/screen-share
// ============================================
// Iniciar screen sharing
🔹 P. ADMIN MODULE
// ============================================
// GET /api/v1/admin/dashboard
// ============================================
// Dashboard analytics
// Query: ?period=30d
// Response: { "dau_trend": [...], "messages_sent": 50000, "active_channels": 45, "storage_used": "120GB" }

// ============================================
// GET /api/v1/admin/audit-logs
// ============================================
// Logs de auditoría
// Query: ?action=user.invite&actor_id=uuid&from=2025-01-01&page=1
// Response: { "logs": [{ "id", "action", "actor", "entity", "details", "created_at" }] }

// ============================================
// POST /api/v1/admin/data-export
// ============================================
// Exportar datos del workspace
// Request: { "type": "all|messages|files|channels", "date_range": { "from": "...", "to": "..." } }
// Response: { "export_id": "uuid", "status": "processing" }

// ============================================
// GET /api/v1/admin/retention-policies
// ============================================
// Políticas de retención

// ============================================
// POST /api/v1/admin/retention-policies
// ============================================
// Crear política
// Request: { "scope": "workspace", "message_retention_days": 365 }

// ============================================
// POST /api/v1/admin/legal-holds
// ============================================
// Crear legal hold
// Request: { "name": "Litigation 2025", "user_ids": ["uuid"], "channel_ids": ["uuid"] }
4.4 WEBSOCKET SERVER (REAL-TIME GATEWAY)
🔹 Implementación con Socket.io
// apps/realtime/src/gateways/chat.gateway.ts

@WebSocketGateway({
  cors: { origin: '*' },
  namespace: '/',
  transports: ['websocket'],
  pingInterval: 25000,
  pingTimeout: 10000,
})
export class ChatGateway implements OnGatewayConnection, OnGatewayDisconnect {
  @WebSocketServer()
  server: Server;

  constructor(
    private connectionService: ConnectionService,
    private pubsubService: PubSubService,
    private presenceService: PresenceService,
    private authService: AuthService,
  ) {}

  // ================== CONEXIÓN ==================

  async handleConnection(client: Socket, ...args: any[]) {
    const token = client.handshake.auth?.token;
    const workspaceId = client.handshake.auth?.workspaceId;

    // 1. Autenticar
    let userId: string;
    try {
      const payload = await this.authService.verifyToken(token);
      userId = payload.userId;
    } catch {
      client.emit('error', { message: 'Authentication failed' });
      client.disconnect();
      return;
    }

    // 2. Registrar conexión
    await this.connectionService.addConnection(userId, workspaceId, client.id);

    // 3. Unir a rooms de todos los canales del usuario
    const channels = await this.connectionService.getUserChannels(userId, workspaceId);
    channels.forEach(channelId => {
      client.join(`channel:${channelId}`);
    });

    // Unir a room personal del usuario
    client.join(`user:${userId}`);
    client.join(`workspace:${workspaceId}`);

    // 4. Actualizar presencia a online
    await this.presenceService.setUserOnline(userId, workspaceId);

    // 5. Notificar presencia a otros
    await this.presenceService.broadcastPresence(userId, workspaceId, 'online');

    client.userId = userId;
    client.workspaceId = workspaceId;

    console.log(`✅ User ${userId} connected via ${client.id}`);
  }

  async handleDisconnect(client: Socket) {
    const { userId, workspaceId } = client;

    if (!userId) return;

    // 1. Remover conexión
    await this.connectionService.removeConnection(userId, client.id);

    // 2. Verificar si el usuario sigue conectado en otro dispositivo/server
    const stillConnected = await this.connectionService.isUserConnected(userId);

    if (!stillConnected) {
      // 3. Marcar como offline
      await this.presenceService.setUserOffline(userId, workspaceId);
      await this.presenceService.broadcastPresence(userId, workspaceId, 'offline');
    }

    console.log(`❌ User ${userId} disconnected from ${client.id}`);
  }

  // ================== EVENTOS DEL CLIENTE ==================

  @SubscribeMessage('subscribe_channel')
  async handleSubscribeChannel(
    @ConnectedSocket() client: Socket,
    @MessageBody() data: { channelId: string }
  ) {
    client.join(`channel:${data.channelId}`);
    await this.connectionService.subscribeToChannel(client.userId, data.channelId);
    client.emit('subscribed', { channelId: data.channelId });
  }

  @SubscribeMessage('unsubscribe_channel')
  async handleUnsubscribeChannel(
    @ConnectedSocket() client: Socket,
    @MessageBody() data: { channelId: string }
  ) {
    client.leave(`channel:${data.channelId}`);
    await this.connectionService.unsubscribeFromChannel(client.userId, data.channelId);
  }

  @SubscribeMessage('typing')
  async handleTyping(
    @ConnectedSocket() client: Socket,
    @MessageBody() data: { channelId: string; isTyping: boolean }
  ) {
    if (data.isTyping) {
      // Guardar en Redis con TTL 5s
      await this.presenceService.setTyping(client.userId, data.channelId);
    }
    
    // Broadcast a otros en el canal
    client.to(`channel:${data.channelId}`).emit('user_typing', {
      userId: client.userId,
      channelId: data.channelId,
      isTyping: data.isTyping,
    });
  }

  @SubscribeMessage('presence_request')
  async handlePresenceRequest(
    @ConnectedSocket() client: Socket,
    @MessageBody() data: { userIds: string[] }
  ) {
    const presences = await this.presenceService.getPresences(data.userIds);
    client.emit('presence_update', presences);
  }

  @SubscribeMessage('heartbeat')
  async handleHeartbeat(@ConnectedSocket() client: Socket) {
    await this.presenceService.heartbeat(client.userId);
    client.emit('heartbeat_ack');
  }

  @SubscribeMessage('mark_read')
  async handleMarkRead(
    @ConnectedSocket() client: Socket,
    @MessageBody() data: { channelId: string; ts: string }
  ) {
    await this.connectionService.markChannelRead(client.userId, data.channelId, data.ts);
    client.emit('read_ack', { channelId: data.channelId, ts: data.ts });
  }

  // ================== EVENTOS DEL SERVIDOR (vía Redis Pub/Sub) ==================

  // Estos métodos son llamados cuando se recibe un mensaje de Redis Pub/Sub
  // desde el API server cuando un mensaje es creado

  async onMessageCreated(payload: MessageCreatedEvent) {
    // Broadcast a todos los clientes en el canal
    this.server.to(`channel:${payload.channelId}`).emit('message', {
      id: payload.messageId,
      channel_id: payload.channelId,
      user_id: payload.userId,
      text: payload.text,
      blocks: payload.blocks,
      ts: payload.ts,
    });
  }

  async onMessageEdited(payload: MessageEditedEvent) {
    this.server.to(`channel:${payload.channelId}`).emit('message_changed', {
      id: payload.messageId,
      text: payload.text,
      blocks: payload.blocks,
      edited_at: payload.editedAt,
    });
  }

  async onMessageDeleted(payload: MessageDeletedEvent) {
    this.server.to(`channel:${payload.channelId}`).emit('message_deleted', {
      id: payload.messageId,
      channel_id: payload.channelId,
      deleted_by: payload.deletedBy,
    });
  }

  async onReactionAdded(payload: ReactionAddedEvent) {
    this.server.to(`channel:${payload.channelId}`).emit('reaction_added', {
      message_id: payload.messageId,
      emoji: payload.emoji,
      user_id: payload.userId,
    });
  }

  async onReactionRemoved(payload: ReactionRemovedEvent) {
    this.server.to(`channel:${payload.channelId}`).emit('reaction_removed', {
      message_id: payload.messageId,
      emoji: payload.emoji,
      user_id: payload.userId,
    });
  }

  async onChannelJoined(payload: ChannelJoinedEvent) {
    this.server.to(`channel:${payload.channelId}`).emit('channel_join', {
      user_id: payload.userId,
      channel_id: payload.channelId,
    });
  }

  async onChannelLeft(payload: ChannelLeftEvent) {
    this.server.to(`channel:${payload.channelId}`).emit('channel_leave', {
      user_id: payload.userId,
      channel_id: payload.channelId,
    });
  }

  async onPresenceChange(payload: PresenceChangeEvent) {
    // Notificar a usuarios que tienen este usuario en su vista
    this.server.to(`user:${payload.userId}`).emit('presence_change', {
      user_id: payload.userId,
      presence: payload.presence,
    });
  }

  async onChannelCreated(payload: ChannelCreatedEvent) {
    this.server.to(`workspace:${payload.workspaceId}`).emit('channel_created', {
      id: payload.channelId,
      name: payload.name,
      type: payload.type,
    });
  }

  async onHuddleStarted(payload: HuddleStartedEvent) {
    this.server.to(`channel:${payload.channelId}`).emit('huddle_start', {
      huddle_id: payload.huddleId,
      channel_id: payload.channelId,
      started_by: payload.userId,
    });
  }

  async onHuddleEnded(payload: HuddleEndedEvent) {
    this.server.to(`channel:${payload.channelId}`).emit('huddle_end', {
      huddle_id: payload.huddleId,
    });
  }

  async onListItemUpdated(payload: ListItemUpdatedEvent) {
    this.server.to(`channel:${payload.channelId}`).emit('list_item_updated', {
      list_id: payload.listId,
      item_id: payload.itemId,
      changes: payload.changes,
    });
  }
}
🔹 Redis Pub/Sub Service (Cross-Server Broadcasting)
// apps/realtime/src/services/pubsub.service.ts

@Injectable()
export class PubSubService {
  private pubClient: Redis;
  private subClient: Redis;

  constructor(private eventEmitter: EventEmitter2) {
    this.pubClient = new Redis(process.env.REDIS_URL);
    this.subClient = new Redis(process.env.REDIS_URL);

    this.setupSubscriptions();
  }

  private setupSubscriptions() {
    // Suscribirse a todos los canales de eventos
    this.subClient.subscribe('events:message_created');
    this.subClient.subscribe('events:message_edited');
    this.subClient.subscribe('events:message_deleted');
    this.subClient.subscribe('events:reaction_added');
    this.subClient.subscribe('events:reaction_removed');
    this.subClient.subscribe('events:channel_joined');
    this.subClient.subscribe('events:channel_left');
    this.subClient.subscribe('events:channel_created');
    this.subClient.subscribe('events:presence_change');
    this.subClient.subscribe('events:huddle_started');
    this.subClient.subscribe('events:huddle_ended');
    this.subClient.subscribe('events:list_item_updated');
    this.subClient.subscribe('events:notification');

    this.subClient.on('message', (channel, message) => {
      const payload = JSON.parse(message);
      // Emitir internamente para que el ChatGateway lo maneje
      this.eventEmitter.emit(channel, payload);
    });
  }

  async publish(event: string, payload: any) {
    await this.pubClient.publish(`events:${event}`, JSON.stringify(payload));
  }
}
🔹 Connection Service (Gestión de conexiones)
// apps/realtime/src/services/connection.service.ts

@Injectable()
export class ConnectionService {
  constructor(private redis: Redis) {}

  async addConnection(userId: string, workspaceId: string, socketId: string) {
    // Trackear conexión por usuario
    await this.redis.sadd(`connections:user:${userId}`, socketId);
    await this.redis.sadd(`connections:workspace:${workspaceId}`, userId);
    await this.redis.hset(`connection:${socketId}`, { userId, workspaceId });
    
    // Expirar en 24h por si se pierde la desconexión
    await this.redis.expire(`connections:user:${userId}`, 86400);
  }

  async removeConnection(userId: string, socketId: string) {
    await this.redis.srem(`connections:user:${userId}`, socketId);
    await this.redis.del(`connection:${socketId}`);
  }

  async isUserConnected(userId: string): Promise<boolean> {
    const count = await this.redis.scard(`connections:user:${userId}`);
    return count > 0;
  }

  async getUserChannels(userId: string, workspaceId: string): Promise<string[]> {
    // Query a DB o cache para obtener canales del usuario
    // Esto debería estar cacheado en Redis
    const channels = await this.redis.smembers(`user_channels:${userId}:${workspaceId}`);
    return channels;
  }

  async subscribeToChannel(userId: string, channelId: string) {
    await this.redis.sadd(`user_channels:${userId}:*`, channelId);
  }

  async unsubscribeFromChannel(userId: string, channelId: string) {
    await this.redis.srem(`user_channels:${userId}:*`, channelId);
  }

  async markChannelRead(userId: string, channelId: string, ts: string) {
    // Actualizar en Redis (cache) + DB (persistente)
    await this.redis.hset(`read_state:${userId}`, channelId, ts);
    // También actualizar en DB de forma async
  }
}
🔹 Presence Service
// apps/realtime/src/services/presence.service.ts

@Injectable()
export class PresenceService {
  constructor(
    private redis: Redis,
    private pubsubService: PubSubService,
  ) {}

  async setUserOnline(userId: string, workspaceId: string) {
    await this.redis.set(`presence:${userId}`, 'online', 'EX', 60);
    await this.redis.sadd(`presence:workspace:${workspaceId}`, userId);
  }

  async setUserOffline(userId: string, workspaceId: string) {
    await this.redis.del(`presence:${userId}`);
    await this.redis.srem(`presence:workspace:${workspaceId}`, userId);
  }

  async heartbeat(userId: string) {
    // Renovar TTL de presencia
    const current = await this.redis.get(`presence:${userId}`);
    if (current === 'online') {
      await this.redis.expire(`presence:${userId}`, 60);
    }
  }

  async getPresence(userId: string): Promise<string> {
    const presence = await this.redis.get(`presence:${userId}`);
    return presence || 'offline';
  }

  async getPresences(userIds: string[]): Promise<Record<string, string>> {
    const pipeline = this.redis.pipeline();
    userIds.forEach(id => pipeline.get(`presence:${id}`));
    const results = await pipeline.exec();
    
    const presences: Record<string, string> = {};
    userIds.forEach((id, index) => {
      presences[id] = results[index][1] || 'offline';
    });
    return presences;
  }

  async setTyping(userId: string, channelId: string) {
    await this.redis.set(`typing:${channelId}:${userId}`, Date.now().toString(), 'EX', 5);
  }

  async getTypingUsers(channelId: string): Promise<string[]> {
    const keys = await this.redis.keys(`typing:${channelId}:*`);
    const userIds = keys.map(key => key.split(':')[2]);
    return userIds;
  }

  async broadcastPresence(userId: string, workspaceId: string, presence: string) {
    await this.pubsubService.publish('presence_change', {
      userId,
      workspaceId,
      presence,
    });
  }
}
4.5 FLUJO COMPLETO DE UN MENSAJE (END-TO-END)
🔹 Desde que el usuario presiona "Enviar" hasta que llega a todos los clientes
PASO 1: CLIENTE envía mensaje
┌─────────────────────────────────────────────────────────────┐
│ Usuario presiona "Enviar" en el web/mobile app              │
│                                                              │
│ POST /api/v1/channels/:channelId/messages                    │
│ Authorization: Bearer {token}                               │
│ Body: { text: "Hello team!", blocks: [...] }                │
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
PASO 2: API GATEWAY recibe la petición
┌─────────────────────────────────────────────────────────────┐
│ • JwtAuthGuard verifica el token JWT                         │
│ • WorkspaceContextMiddleware verifica membresía              │
│ • RateLimitInterceptor: ¿Usuario envía太多 mensajes?         │
│ • ValidationPipe: ¿Body válido?                              │
│ → Pasa al MessagesController.sendMessage()                   │
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
PASO 3: MESSAGE SERVICE procesa
┌─────────────────────────────────────────────────────────────┐
│ MessagesService.createMessage()                              │
│                                                              │
│ 3a. Parse mentions (@user, @channel, #channel)               │
│     → Extraer mentioned_users[], mentioned_channels[]        │
│                                                              │
│ 3b. Guardar en PostgreSQL                                    │
│     INSERT INTO messages (...) VALUES (...)                  │
│     → message.id = uuid, message.ts = NOW()                 │
│                                                              │
│ 3c. Actualizar channel.last_message_at                       │
│     UPDATE channels SET last_message_at = NOW()              │
│                                                              │
│ 3d. Incrementar unread_count de otros miembros               │
│     UPDATE channel_members                                   │
│     SET unread_count = unread_count + 1                      │
│     WHERE channel_id = ? AND user_id != sender               │
│                                                              │
│ 3e. Si hay mentions: incrementar unread_mention_count        │
│                                                              │
│ 3f. Publicar evento a Redis Pub/Sub                          │
│     PUBLISH events:message_created {                         │
│       messageId, channelId, userId, text, blocks, ts         │
│     }                                                        │
│                                                              │
│ 3g. Encolar jobs asíncronos:                                 │
│     - notifications.queue.add({ message, mentions })         │
│     - search-indexer.queue.add({ message })                  │
│     - embeddings.queue.add({ message })                      │
│     - link-unfurl.queue.add({ message }) (si tiene URLs)     │
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
PASO 4: REDIS PUB/PROPaga el evento
┌─────────────────────────────────────────────────────────────┐
│ Redis PUBLISH events:message_created                         │
│                                                              │
│ → Todos los WebSocket servers suscritos reciben el evento    │
│ → Cada WS server lo procesa en su ChatGateway.onMessageCreated│
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
PASO 5: WEBSOCKET SERVERS broadcast a clientes
┌─────────────────────────────────────────────────────────────┐
│ ChatGateway.onMessageCreated(payload)                        │
│                                                              │
│ → this.server.to(`channel:${channelId}`).emit('message', {   │
│     id, channel_id, user_id, text, blocks, ts                │
│   })                                                         │
│                                                              │
│ → Socket.io envía el evento a TODOS los clientes             │
│   conectados que están en el room `channel:${channelId}`     │
│   en TODOS los WebSocket servers                             │
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
PASO 6: CLIENTES reciben el mensaje
┌─────────────────────────────────────────────────────────────┐
│ Cada cliente (web, desktop, mobile) recibe:                  │
│                                                              │
│ socket.on('message', (message) => {                          │
│   // Agregar mensaje al store (Zustand/Redux)                │
│   // Actualizar UI: scroll al fondo, incrementar unread      │
│   // Si tiene mention: reproducir sonido, mostrar badge      │
│ })                                                           │
└─────────────────────────────────────────────────────────────┘

PARALELO: Jobs asíncronos se ejecutan en background
┌─────────────────────────────────────────────────────────────┐
│                                                              │
│ JOB 1: Notifications Processor                               │
│   → Determinar quién necesita notificación                   │
│   → Verificar preferencias de cada usuario                   │
│   → Verificar DND                                            │
│   → Enviar push notification (FCM/APNs) si aplica            │
│   → Enviar email si aplica                                   │
│   → Actualizar badge count                                    │
│                                                              │
│ JOB 2: Search Indexer                                        │
│   → Indexar mensaje en Meilisearch/Elasticsearch             │
│   → { id, workspace_id, channel_id, text, user_id, ts }     │
│                                                              │
│ JOB 3: Embeddings Generator                                  │
│   → Generar embedding del texto (OpenAI API)                 │
│   → Guardar en ai.message_embeddings                         │
│   → Para futura búsqueda semántica con IA                    │
│                                                              │
│ JOB 4: Link Unfurler                                         │
│   → Si el mensaje contiene URLs                              │
│   → Fetch URL → extraer title, description, image (OG tags)  │
│   → Actualizar message.link_previews                          │
│   → Publicar events:message_edited para actualizar clientes   │
│                                                              │
└─────────────────────────────────────────────────────────────┘
🔹 Diagrama visual del flujo:
Usuario A                    API Server              Redis Pub/Sub          WS Server 1         WS Server 2         Usuario B
    │                            │                       │                     │                    │                    │
    │──POST /messages───────────▶│                       │                     │                    │                    │
    │                            │──INSERT INTO DB───▶  │                     │                    │                    │
    │                            │                       │                     │                    │                    │
    │                            │──PUBLISH events:msg──▶│                     │                    │                    │
    │                            │                       │──broadcast──────────▶│                    │                    │
    │                            │                       │──broadcast───────────────────────────────▶│                    │
    │◀──201 Created──────────────│                       │                     │                    │                    │
    │                            │                       │                     │──emit('message')──▶│                    │
    │                            │                       │                     │                    │──emit('message')──▶│
    │                            │                       │                     │                    │                    │
    │                            │──enqueue notifications▶ (BullMQ)            │                    │                    │
    │                            │──enqueue search index▶ (BullMQ)             │                    │                    │
    │                            │──enqueue embeddings───▶ (BullMQ)            │                    │                    │
    │                            │──enqueue link unfurl─▶ (BullMQ)             │                    │                    │
    │                            │                       │                     │                    │                    │
    │                            │                       │                     │                    │     Usuario B ve    │
    │                            │                       │                     │                    │──el mensaje al instante
    │                            │                       │                     │                    │                    │
    │                            │                       │                     │                    │      Notificación   │
    │                            │                       │                     │                    │◀──push (FCM/APNs)──│
4.6 WORKER PROCESSORS (BACKGROUND JOBS)
🔹 Notifications Processor
// apps/workers/src/processors/notifications.processor.ts

@Processor('notifications', { concurrency: 50 })
export class NotificationsProcessor extends WorkerHost {
  constructor(
    private pushService: PushNotificationService,
    private emailService: EmailService,
    private preferenceService: NotificationPreferenceService,
  ) {
    super();
  }

  async process(job: Job<NotificationJob>) {
    const { message, channel, mentionedUserIds, senderId } = job.data;

    // 1. Determinar destinatarios
    const recipientIds = await this.getRecipients(channel.id, senderId, mentionedUserIds);

    for (const userId of recipientIds) {
      // 2. Verificar preferencias
      const prefs = await this.preferenceService.get(userId, channel.workspaceId);
      
      const shouldNotify = this.evaluateNotificationRules({
        prefs,
        isMentioned: mentionedUserIds?.includes(userId),
        isDM: channel.type === 'dm',
        channelMuted: await this.isChannelMuted(userId, channel.id),
        isDND: this.isDNDActive(prefs),
      });

      if (!shouldNotify) continue;

      // 3. Determinar canales de entrega
      const channels = this.determineDeliveryChannels(prefs, userId);

      // 4. Enviar notificaciones
      if (channels.push) {
        await this.pushService.send(userId, {
          title: `New message in #${channel.name}`,
          body: this.truncateMessage(message.text),
          data: { channelId: channel.id, messageId: message.id },
        });
      }

      if (channels.email && prefs.emailFrequency === 'immediate') {
        await this.emailService.sendNotification(userId, message, channel);
      }
    }
  }

  private evaluateNotificationRules(params: NotificationRules): boolean {
    if (params.isDND && !params.isMentioned) return false;
    if (params.channelMuted && !params.isMentioned) return false;
    if (params.isMentioned && params.prefs.notifyMentions) return true;
    if (params.isDM && params.prefs.notifyDMs) return true;
    if (params.prefs.notifyAllMessages) return true;
    return false;
  }
}
🔹 Search Indexer Processor
// apps/workers/src/processors/search-indexer.processor.ts

@Processor('search-indexing')
export class SearchIndexerProcessor extends WorkerHost {
  constructor(private searchService: SearchService) {
    super();
  }

  async process(job: Job<{ message: Message }>) {
    const { message } = job.data;

    await this.searchService.indexMessage({
      id: message.id,
      workspace_id: message.workspaceId,
      channel_id: message.channelId,
      channel_name: message.channelName,
      user_id: message.userId,
      user_name: message.userName,
      text: message.text,
      blocks_text: this.extractTextFromBlocks(message.blocks),
      ts: message.ts,
    });
  }
}
🔹 Scheduled Messages Processor
// apps/workers/src/processors/scheduled-messages.processor.ts

@Processor('scheduled-messages', {
  repeat: { pattern: '*/1 * * * *' }, // Cada minuto
})
export class ScheduledMessagesProcessor extends WorkerHost {
  constructor(private messageService: MessageService) {
    super();
  }

  async process() {
    // Buscar mensajes programados que toca enviar
    const dueMessages = await this.messageService.getDueScheduledMessages();

    for (const scheduled of dueMessages) {
      try {
        // Enviar el mensaje
        const message = await this.messageService.createMessage({
          channelId: scheduled.channelId,
          userId: scheduled.userId,
          text: scheduled.text,
          blocks: scheduled.blocks,
        });

        // Marcar como enviado
        await this.messageService.markScheduledAsSent(scheduled.id, message.id);
      } catch (error) {
        console.error(`Failed to send scheduled message ${scheduled.id}:`, error);
      }
    }
  }
}
4.7 DEFINICIÓN COMPLETA DE EVENTOS WEBSOCKET
// apps/realtime/src/events/events.ts

// ============== EVENTOS CLIENTE → SERVIDOR ==============

interface ClientToServerEvents {
  // Suscripción
  'subscribe_channel': (data: { channelId: string }) => void;
  'unsubscribe_channel': (data: { channelId: string }) => void;
  
  // Presencia
  'typing': (data: { channelId: string; isTyping: boolean }) => void;
  'presence_request': (data: { userIds: string[] }) => void;
  'heartbeat': () => void;
  
  // Estado de lectura
  'mark_read': (data: { channelId: string; ts: string }) => void;
  
  // Huddles (señalización WebRTC)
  'huddle_signal': (data: { huddleId: string; signal: any; toUserId: string }) => void;
  'huddle_join': (data: { huddleId: string }) => void;
  'huddle_leave': (data: { huddleId: string }) => void;
  
  // Canvas collaborative editing (Yjs sync)
  'canvas_update': (data: { canvasId: string; update: Uint8Array }) => void;
}

// ============== EVENTOS SERVIDOR → CLIENTE ==============

interface ServerToClientEvents {
  // Mensajes
  'message': (data: MessageEvent) => void;
  'message_changed': (data: MessageChangedEvent) => void;
  'message_deleted': (data: MessageDeletedEvent) => void;
  
  // Reacciones
  'reaction_added': (data: ReactionEvent) => void;
  'reaction_removed': (data: ReactionEvent) => void;
  
  // Canales
  'channel_created': (data: ChannelCreatedEvent) => void;
  'channel_join': (data: ChannelJoinEvent) => void;
  'channel_leave': (data: ChannelLeaveEvent) => void;
  'channel_archive': (data: ChannelArchiveEvent) => void;
  'channel_rename': (data: ChannelRenameEvent) => void;
  'channel_topic': (data: ChannelTopicEvent) => void;
  
  // Presencia y typing
  'user_typing': (data: TypingEvent) => void;
  'presence_change': (data: PresenceEvent) => void;
  'user_status_change': (data: StatusChangeEvent) => void;
  
  // Archivos
  'file_shared': (data: FileSharedEvent) => void;
  
  // Pins y bookmarks
  'pin_added': (data: PinEvent) => void;
  'pin_removed': (data: PinEvent) => void;
  
  // Huddles
  'huddle_start': (data: HuddleStartEvent) => void;
  'huddle_end': (data: HuddleEndEvent) => void;
  'huddle_signal': (data: any) => void;
  'huddle_user_joined': (data: any) => void;
  'huddle_user_left': (data: any) => void;
  
  // Lists
  'list_item_updated': (data: any) => void;
  'list_item_created': (data: any) => void;
  'list_item_deleted': (data: any) => void;
  
  // Canvas
  'canvas_update': (data: any) => void;
  
  // Notificaciones
  'notification': (data: NotificationEvent) => void;
  'badge_update': (data: { count: number }) => void;
  
  // Sistema
  'error': (data: { message: string; code?: string }) => void;
  'subscribed': (data: { channelId: string }) => void;
  'read_ack': (data: { channelId: string; ts: string }) => void;
  'heartbeat_ack': () => void;
  'reconnect': () => void;
}

// ============== TIPOS DE EVENTOS ==============

interface MessageEvent {
  id: string;
  channel_id: string;
  user_id: string;
  display_name: string;
  avatar_url: string;
  text: string;
  blocks: any[];
  thread_root_id: string | null;
  mentioned_users: string[];
  files: any[];
  link_previews: any[];
  ts: string;
}

interface ReactionEvent {
  message_id: string;
  channel_id: string;
  emoji: string;
  user_id: string;
}
4.8 RATE LIMITING Y SEGURIDAD
// apps/api/src/common/interceptors/rate-limit.interceptor.ts

@Injectable()
export class RateLimitInterceptor implements NestInterceptor {
  constructor(private redis: Redis) {}

  async intercept(context: ExecutionContext, next: CallHandler) {
    const request = context.switchToHttp().getRequest();
    const userId = request.user?.userId;
    const endpoint = request.route?.path || request.url;

    // Rate limits por endpoint
    const limits = this.getLimits(endpoint);
    
    for (const { window, max } of limits) {
      const key = `ratelimit:${userId}:${endpoint}:${window}`;
      const current = await this.redis.incr(key);
      
      if (current === 1) {
        await this.redis.expire(key, window);
      }
      
      if (current > max) {
        throw new TooManyRequestsException(
          `Rate limit exceeded. Max ${max} requests per ${window}s`
        );
      }
    }

    return next.handle();
  }

  private getLimits(endpoint: string): Array<{window: number, max: number}> {
    // Endpoints críticos con límites estrictos
    if (endpoint.includes('/messages') && request.method === 'POST') {
      return [{ window: 1, max: 5 }, { window: 60, max: 100 }]; // 5/s, 100/min
    }
    if (endpoint.includes('/files/upload')) {
      return [{ window: 60, max: 20 }]; // 20/min
    }
    if (endpoint.includes('/ai/')) {
      return [{ window: 60, max: 30 }]; // 30/min
    }
    // Default
    return [{ window: 60, max: 300 }]; // 300/min
  }
}
4.9 ERROR HANDLING GLOBAL
// apps/api/src/common/filters/all-exceptions.filter.ts

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();

    let status = 500;
    let message = 'Internal server error';
    let code = 'INTERNAL_ERROR';
    let details: any;

    if (exception instanceof HttpException) {
      status = exception.getStatus();
      const response = exception.getResponse();
      if (typeof response === 'object') {
        message = (response as any).message || message;
        code = (response as any).code || code;
        details = (response as any).details;
      }
    } else if (exception instanceof Prisma.PrismaClientKnownRequestError) {
      status = 400;
      code = `DB_ERROR_${exception.code}`;
      message = 'Database constraint violation';
    }

    // Log del error
    console.error(`[${request.requestId}] ${status} ${code}: ${message}`, exception);

    // Response estandarizada
    response.status(status).json({
      ok: false,
      error: {
        code,
        message,
        details,
      },
      timestamp: new Date().toISOString(),
      path: request.url,
      requestId: request.requestId,
    });
  }
}
4.10 ARQUITECTURA DE RESPUESTA API ESTÁNDAR
// Todas las respuestas siguen este formato:

// ÉXITO:
{
  "ok": true,
  "data": { ... },
  "meta": {
    "page": 1,
    "limit": 50,
    "total": 150,
    "has_more": true
  }
}

// ERROR:
{
  "ok": false,
  "error": {
    "code": "NOT_FOUND",
    "message": "Channel not found",
    "details": { "channel_id": "uuid" }
  },
  "timestamp": "2025-01-15T10:30:00Z",
  "path": "/api/v1/channels/uuid",
  "requestId": "req-uuid"
}


📌 PARTE 5: FRONTEND COMPLETO — WEB, DESKTOP, MOBILE + UX/UI
5.1 ARQUITECTURA DEL FRONTEND
🔹 Estructura Monorepo (Turborepo)
frontend/
├── apps/
│   ├── web/                    → Next.js 14 (App Router)
│   │   ├── src/
│   │   │   ├── app/            → Rutas (App Router)
│   │   │   │   ├── (auth)/
│   │   │   │   │   ├── login/page.tsx
│   │   │   │   │   ├── register/page.tsx
│   │   │   │   │   ├── forgot-password/page.tsx
│   │   │   │   │   └── layout.tsx
│   │   │   │   ├── (workspace)/
│   │   │   │   │   ├── [workspaceDomain]/
│   │   │   │   │   │   ├── layout.tsx          → Layout principal con sidebar
│   │   │   │   │   │   ├── page.tsx            → Redirect a #general
│   │   │   │   │   │   ├── channel/[channelId]/
│   │   │   │   │   │   │   ├── page.tsx        → Vista de canal
│   │   │   │   │   │   │   ├── thread/[messageId]/page.tsx → Thread view
│   │   │   │   │   │   │   ├── canvas/page.tsx → Canvas del canal
│   │   │   │   │   │   │   ├── lists/page.tsx  → Lists del canal
│   │   │   │   │   │   │   └── settings/page.tsx
│   │   │   │   │   │   ├── dm/[dmId]/page.tsx  → Vista de DM
│   │   │   │   │   │   ├── huddle/[huddleId]/page.tsx
│   │   │   │   │   │   ├── activity/page.tsx   → Activity feed
│   │   │   │   │   │   ├── later/page.tsx      → Saved items
│   │   │   │   │   │   ├── threads/page.tsx    → All threads
│   │   │   │   │   │   └── settings/
│   │   │   │   │   │       ├── page.tsx
│   │   │   │   │   │       ├── notifications/page.tsx
│   │   │   │   │   │       └── profile/page.tsx
│   │   │   │   │   └── layout.tsx
│   │   │   │   ├── admin/
│   │   │   │   │   ├── page.tsx                → Dashboard admin
│   │   │   │   │   ├── members/page.tsx
│   │   │   │   │   ├── channels/page.tsx
│   │   │   │   │   ├── analytics/page.tsx
│   │   │   │   │   ├── audit-logs/page.tsx
│   │   │   │   │   ├── integrations/page.tsx
│   │   │   │   │   └── security/page.tsx
│   │   │   │   ├── layout.tsx                  → Root layout
│   │   │   │   └── globals.css
│   │   │   ├── components/
│   │   │   │   ├── layout/
│   │   │   │   │   ├── Sidebar.tsx
│   │   │   │   │   ├── SidebarSection.tsx
│   │   │   │   │   ├── ChannelList.tsx
│   │   │   │   │   ├── DMList.tsx
│   │   │   │   │   ├── TopBar.tsx
│   │   │   │   │   ├── RightPanel.tsx
│   │   │   │   │   └── WorkspaceSwitcher.tsx
│   │   │   │   ├── messaging/
│   │   │   │   │   ├── MessageList.tsx
│   │   │   │   │   ├── MessageItem.tsx
│   │   │   │   │   ├── MessageInput.tsx
│   │   │   │   │   ├── MessageEditor.tsx
│   │   │   │   │   ├── ThreadView.tsx
│   │   │   │   │   ├── MessageReactions.tsx
│   │   │   │   │   ├── MessageActions.tsx
│   │   │   │   │   └── SystemMessage.tsx
│   │   │   │   ├── channels/
│   │   │   │   │   ├── ChannelHeader.tsx
│   │   │   │   │   ├── ChannelInfo.tsx
│   │   │   │   │   ├── ChannelMembers.tsx
│   │   │   │   │   ├── CreateChannelModal.tsx
│   │   │   │   │   ├── ChannelBrowseModal.tsx
│   │   │   │   │   └── InviteMembersModal.tsx
│   │   │   │   ├── block-kit/
│   │   │   │   │   ├── BlockRenderer.tsx
│   │   │   │   │   ├── SectionBlock.tsx
│   │   │   │   │   ├── ActionsBlock.tsx
│   │   │   │   │   ├── DividerBlock.tsx
│   │   │   │   │   ├── ImageBlock.tsx
│   │   │   │   │   ├── ContextBlock.tsx
│   │   │   │   │   ├── HeaderBlock.tsx
│   │   │   │   │   ├── ModalRenderer.tsx
│   │   │   │   │   └── InteractiveElements.tsx
│   │   │   │   ├── files/
│   │   │   │   │   ├── FilePreview.tsx
│   │   │   │   │   ├── FileUploadZone.tsx
│   │   │   │   │   ├── ImagePreview.tsx
│   │   │   │   │   ├── VideoPreview.tsx
│   │   │   │   │   └── FileIcon.tsx
│   │   │   │   ├── huddles/
│   │   │   │   │   ├── HuddleBar.tsx
│   │   │   │   │   ├── HuddlePanel.tsx
│   │   │   │   │   ├── VideoTile.tsx
│   │   │   │   │   ├── AudioIndicator.tsx
│   │   │   │   │   └── ScreenShareView.tsx
│   │   │   │   ├── lists/
│   │   │   │   │   ├── ListTable.tsx
│   │   │   │   │   ├── ListBoard.tsx
│   │   │   │   │   ├── ListItem.tsx
│   │   │   │   │   └── ListItemEditor.tsx
│   │   │   │   ├── canvas/
│   │   │   │   │   ├── CanvasEditor.tsx
│   │   │   │   │   └── CanvasToolbar.tsx
│   │   │   │   ├── search/
│   │   │   │   │   ├── SearchBar.tsx
│   │   │   │   │   ├── SearchResults.tsx
│   │   │   │   │   └── AISearchResults.tsx
│   │   │   │   ├── ai/
│   │   │   │   │   ├── SlackbotPanel.tsx
│   │   │   │   │   ├── SummaryCard.tsx
│   │   │   │   │   └── RecapView.tsx
│   │   │   │   ├── common/
│   │   │   │   │   ├── Avatar.tsx
│   │   │   │   │   ├── PresenceDot.tsx
│   │   │   │   │   ├── EmojiPicker.tsx
│   │   │   │   │   ├── UserMention.tsx
│   │   │   │   │   ├── Tooltip.tsx
│   │   │   │   │   ├── Modal.tsx
│   │   │   │   │   ├── Dropdown.tsx
│   │   │   │   │   ├── Toast.tsx
│   │   │   │   │   ├── CommandPalette.tsx
│   │   │   │   │   └── InfiniteScroll.tsx
│   │   │   │   └── ui/                    → shadcn/ui components
│   │   │   │       ├── button.tsx
│   │   │   │       ├── dialog.tsx
│   │   │   │       ├── input.tsx
│   │   │   │       ├── popover.tsx
│   │   │   │       └── ...
│   │   │   ├── hooks/
│   │   │   │   ├── useSocket.ts           → WebSocket connection
│   │   │   │   ├── useChannel.ts          → Canal actual
│   │   │   │   ├── useMessages.ts         → Mensajes con paginación
│   │   │   │   ├── usePresence.ts         → Presencia de usuarios
│   │   │   │   ├── useTyping.ts           → Typing indicators
│   │   │   │   ├── useNotifications.ts    → Notificaciones
│   │   │   │   ├── useHuddle.ts           → Huddle state
│   │   │   │   ├── useMediaQuery.ts
│   │   │   │   └── useKeyboardShortcuts.ts
│   │   │   ├── stores/                    → Zustand stores
│   │   │   │   ├── workspace.store.ts
│   │   │   │   ├── channels.store.ts
│   │   │   │   ├── messages.store.ts
│   │   │   │   ├── users.store.ts
│   │   │   │   ├── presence.store.ts
│   │   │   │   ├── notifications.store.ts
│   │   │   │   ├── ui.store.ts            → Modals, panels, theme
│   │   │   │   └── huddle.store.ts
│   │   │   ├── lib/
│   │   │   │   ├── api-client.ts          → Axios/fetch wrapper
│   │   │   │   ├── socket-client.ts       → Socket.io client setup
│   │   │   │   ├── block-kit-parser.ts    → Parser de Block Kit
│   │   │   │   ├── message-formatter.ts   → Markdown → HTML
│   │   │   │   ├── mentions-parser.ts     → @mentions parsing
│   │   │   │   └── utils.ts
│   │   │   └── types/
│   │   │       └── index.ts               → Tipos compartidos
│   │   ├── public/
│   │   ├── next.config.js
│   │   ├── tailwind.config.js
│   │   └── package.json
│   │
│   ├── desktop/               → Tauri (Rust + WebView)
│   │   ├── src-tauri/
│   │   │   ├── src/main.rs
│   │   │   ├── Cargo.toml
│   │   │   └── tauri.conf.json
│   │   ├── src/               → Misma app web embebida
│   │   └── package.json
│   │
│   └── mobile/               → React Native (Expo)
│       ├── src/
│       │   ├── screens/
│       │   │   ├── LoginScreen.tsx
│       │   │   ├── HomeScreen.tsx
│       │   │   ├── ChannelScreen.tsx
│       │   │   ├── DMScreen.tsx
│       │   │   ├── ThreadScreen.tsx
│       │   │   ├── HuddleScreen.tsx
│       │   │   └── SettingsScreen.tsx
│       │   ├── components/
│       │   ├── navigation/
│       │   ├── stores/
│       │   ├── hooks/
│       │   └── lib/
│       ├── app.json
│       └── package.json
│
├── packages/
│   ├── ui/                    → Componentes UI compartidos
│   ├── types/                 → Tipos TypeScript compartidos
│   ├── api/                   → API client compartido
│   └── utils/                 → Utils compartidos
│
├── package.json
└── turbo.json
5.2 LAYOUT PRINCIPAL (WEB)
🔹 Estructura visual del layout
┌────────────────────────────────────────────────────────────────────────────────┐
│ TOP BAR: Workspace Name ▼ │ Search Bar │ Help │ Notifications │ Profile │ Dark │
├──────────────┬───────────────────────────────────────────┬─────────────────────┤
│              │ CHANNEL HEADER: #marketing-team            │ RIGHT PANEL         │
│ SIDEBAR      │ Topic: Marketing discussions | Members: 25 │ (Tabs: Info, Files, │
│              ├───────────────────────────────────────────┤ Canvas, Lists, etc) │
│ ▼ Channels   │                                           │                     │
│  # general   │  MESSAGE LIST                              │ Channel Details     │
│  # marketing │  ┌─────────────────────────────────────┐   │                     │
│  # dev-team  │  │ 👤 John Doe  10:30 AM               │   │ Topic:              │
│  # random    │  │ Hello team! Check this out 👋       │   │ Marketing discus... │
│  # support   │  │                                     │   │                     │
│  + Add       │  │ 👤 Jane Smith 10:32 AM              │   │ Created by:         │
│              │  │ Looks great! 👍                     │   │ John Doe            │
│ ▼ DMs        │  │                                     │   │                     │
│  💬 Bob       │  │ 👤 John Doe 10:35 AM                │   │ Members (25):       │
│  💬 Alice     │  │ Here's the document:                │   │ ┌───┐               │
│  + Add       │  │ 📄 Q1-Marketing-Plan.pdf            │   │ │JD │ John Doe      │
│              │  │                                     │   │ ├───┤               │
│ ▼ Apps       │  │ 💬 2 replies (thread)                │   │ │JS │ Jane Smith   │
│  🤖 GitHub   │  │                                     │   │ ├───┤               │
│  🤖 Jira     │  │ 👤 System 10:40 AM                  │   │ │BW │ Bob Wilson   │
│              │  │ Bob Wilson joined #marketing-team   │   │ └───┘               │
│              │  └─────────────────────────────────────┘   │                     │
│              │                                           │ Pinned Messages:    │
│              │  MESSAGE INPUT                            │ 📌 Project deadline  │
│              │  ┌─────────────────────────────────────┐   │ 📌 Meeting notes    │
│              │  │ Write a message...  📎 😊 @ # /sh   │   │                     │
│              │  └─────────────────────────────────────┘   │ Bookmarks:          │
│              │                                           │ 🔗 Marketing Docs   │
│  ● Online    │                                           │ 🔗 Campaign Tracker │
│  John Doe    │                                           │                     │
└──────────────┴───────────────────────────────────────────┴─────────────────────┘
🔹 Root Layout
// apps/web/src/app/layout.tsx

import { Inter } from 'next/font/google';
import { Providers } from '@/components/Providers';
import { Toaster } from '@/components/common/Toast';
import './globals.css';

const inter = Inter({ subsets: ['latin'] });

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en" className="dark">
      <body className={inter.className}>
        <Providers>
          {children}
          <Toaster />
        </Providers>
      </body>
    </html>
  );
}
🔹 Providers (Context & State)
// apps/web/src/components/Providers.tsx

'use client';

import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
import { SocketProvider } from '@/hooks/useSocket';
import { ThemeProvider } from 'next-themes';
import { useState } from 'react';

export function Providers({ children }: { children: React.ReactNode }) {
  const [queryClient] = useState(() => new QueryClient({
    defaultOptions: {
      queries: {
        staleTime: 30_000,        // 30 segundos
        cacheTime: 5 * 60_000,    // 5 minutos
        refetchOnWindowFocus: false,
        retry: 2,
      },
    },
  }));

  return (
    <QueryClientProvider client={queryClient}>
      <ThemeProvider attribute="class" defaultTheme="dark">
        <SocketProvider>
          {children}
        </SocketProvider>
      </ThemeProvider>
      {process.env.NODE_ENV === 'development' && <ReactQueryDevtools />}
    </QueryClientProvider>
  );
}
🔹 Workspace Layout (con Sidebar)
// apps/web/src/app/(workspace)/[workspaceDomain]/layout.tsx

'use client';

import { Sidebar } from '@/components/layout/Sidebar';
import { TopBar } from '@/components/layout/TopBar';
import { useWorkspaceStore } from '@/stores/workspace.store';
import { useEffect } from 'react';
import { useSocket } from '@/hooks/useSocket';

export default function WorkspaceLayout({
  children,
  params,
}: {
  children: React.ReactNode;
  params: { workspaceDomain: string };
}) {
  const { loadWorkspace, currentWorkspace } = useWorkspaceStore();
  const { connect, disconnect } = useSocket();

  useEffect(() => {
    loadWorkspace(params.workspaceDomain);
  }, [params.workspaceDomain]);

  useEffect(() => {
    if (currentWorkspace) {
      connect(currentWorkspace.id);
    }
    return () => disconnect();
  }, [currentWorkspace?.id]);

  return (
    <div className="flex h-screen overflow-hidden bg-slack-dark text-slack-text">
      {/* Sidebar - 260px fijo, colapsable a 60px */}
      <Sidebar />

      {/* Main area */}
      <div className="flex flex-1 flex-col overflow-hidden">
        <TopBar />
        <div className="flex flex-1 overflow-hidden">
          {/* Contenido principal */}
          <main className="flex-1 overflow-hidden">{children}</main>
          {/* Right panel (condicional) */}
          {/* <RightPanel /> */}
        </div>
      </div>
    </div>
  );
}
5.3 SIDEBAR (Componente principal de navegación)
🔹 Sidebar Component
// apps/web/src/components/layout/Sidebar.tsx

'use client';

import { WorkspaceSwitcher } from './WorkspaceSwitcher';
import { SidebarSection } from './SidebarSection';
import { ChannelList } from './ChannelList';
import { DMList } from './DMList';
import { UserPresenceCard } from '@/components/common/UserPresenceCard';
import { useChannelsStore } from '@/stores/channels.store';
import { useUsersStore } from '@/stores/users.store';
import { Search } from 'lucide-react';
import { Button } from '@/components/ui/button';
import { useState } from 'react';

export function Sidebar() {
  const [collapsed, setCollapsed] = useState(false);
  const { channels } = useChannelsStore();
  const { currentUser } = useUsersStore();

  const publicChannels = channels.filter(c => c.type === 'public' && !c.is_archived);
  const privateChannels = channels.filter(c => c.type === 'private' && !c.is_archived);
  const dms = channels.filter(c => c.type === 'dm' || c.type === 'group_dm');

  return (
    <aside
      className={`${
        collapsed ? 'w-[60px]' : 'w-[260px]'
      } flex flex-col border-r border-slack-border bg-slack-sidebar transition-all duration-200`}
    >
      {/* Workspace Switcher */}
      <WorkspaceSwitcher />

      {/* Search Button */}
      {!collapsed && (
        <div className="px-3 py-2">
          <Button
            variant="outline"
            className="w-full justify-start gap-2 text-sm text-slack-text-muted"
            onClick={() => {/* abrir command palette */}}
          >
            <Search className="h-4 w-4" />
            Search {CURRENT_WORKSPACE_NAME}
          </Button>
        </div>
      )}

      {/* Scrollable sections */}
      <nav className="flex-1 overflow-y-auto px-2 py-1 scrollbar-thin">
        {/* Threads shortcut */}
        <SidebarSection
          icon="message"
          label="Threads"
          collapsed={collapsed}
          badge={unreadThreadCount}
          onClick={() => router.push(`/threads`)}
        />

        {/* Activity */}
        <SidebarSection
          icon="activity"
          label="Activity"
          collapsed={collapsed}
          onClick={() => router.push(`/activity`)}
        />

        {/* Later (Saved) */}
        <SidebarSection
          icon="bookmark"
          label="Later"
          collapsed={collapsed}
          badge={savedCount}
          onClick={() => router.push(`/later`)}
        />

 {/* Channels */}
        <ChannelList
          title="Channels"
          channels={publicChannels}
          collapsed={collapsed}
        />

        <ChannelList
          title="Private Channels"
          channels={privateChannels}
          collapsed={collapsed}
          defaultCollapsed
        />

        {/* DMs */}
        <DMList
          dms={dms}
          collapsed={collapsed}
        />

        {/* Apps section */}
        <SidebarSection
          icon="bot"
          label="Apps"
          collapsed={collapsed}
          onClick={() => router.push(`/apps`)}
        />
      </nav>

      {/* Bottom: User presence */}
      <UserPresenceCard user={currentUser} collapsed={collapsed} />
    </aside>
  );
}
🔹 ChannelList Component
// apps/web/src/components/layout/ChannelList.tsx

'use client';

import { useState } from 'react';
import { ChevronDown, ChevronRight, Plus, Hash, Lock } from 'lucide-react';
import { useChannelsStore } from '@/stores/channels.store';
import { useNotificationsStore } from '@/stores/notifications.store';
import { cn } from '@/lib/utils';

interface ChannelListProps {
  title: string;
  channels: Channel[];
  collapsed: boolean;
  defaultCollapsed?: boolean;
}

export function ChannelList({ title, channels, collapsed, defaultCollapsed }: ChannelListProps) {
  const [isOpen, setIsOpen] = useState(!defaultCollapsed);
  const { setActiveChannel } = useChannelsStore();
  const { unreadCounts } = useNotificationsStore();
  const [filter, setFilter] = useState('');
  const [showFilter, setShowFilter] = useState(false);

  const filtered = filter
    ? channels.filter(c => c.name.includes(filter.toLowerCase()))
    : channels;

  if (collapsed) {
    return (
      <div className="py-1">
        <button
          onClick={() => setIsOpen(!isOpen)}
          className="flex w-full items-center justify-center py-1"
        >
          {isOpen ? <ChevronDown className="h-4 w-4" /> : <ChevronRight className="h-4 w-4" />}
        </button>
      </div>
    );
  }

  return (
    <div className="mb-2">
      {/* Section header */}
      <div className="group flex items-center justify-between px-2 py-1">
        <button
          onClick={() => setIsOpen(!isOpen)}
          className="flex items-center gap-1 text-xs font-semibold uppercase text-slack-text-muted hover:text-slack-text"
        >
          {isOpen ? <ChevronDown className="h-3 w-3" /> : <ChevronRight className="h-3 w-3" />}
          {title}
        </button>
        <div className="flex items-center gap-1 opacity-0 group-hover:opacity-100">
          <button
            onClick={() => setShowFilter(!showFilter)}
            className="hover:bg-slack-hover rounded p-0.5"
          >
            <Search className="h-3 w-3" />
          </button>
          <button
            onClick={() => {/* abrir modal crear canal */}}
            className="hover:bg-slack-hover rounded p-0.5"
          >
            <Plus className="h-3 w-3" />
          </button>
        </div>
      </div>

      {/* Filter input */}
      {showFilter && (
        <input
          autoFocus
          value={filter}
          onChange={e => setFilter(e.target.value)}
          placeholder="Filter channels..."
          className="mx-2 mb-1 w-[calc(100%-1rem)] rounded border border-slack-border bg-slack-input px-2 py-1 text-sm"
        />
      )}

      {/* Channel items */}
      {isOpen && (
        <div className="space-y-0.5">
          {filtered.map(channel => (
            <ChannelItem
              key={channel.id}
              channel={channel}
              unread={unreadCounts[channel.id]?.count || 0}
              mentions={unreadCounts[channel.id]?.mentions || 0}
              onClick={() => setActiveChannel(channel.id)}
            />
          ))}
          {filtered.length === 0 && filter && (
            <div className="px-2 py-1 text-xs text-slack-text-muted">
              No channels found
            </div>
          )}
        </div>
      )}
    </div>
  );
}

function ChannelItem({ channel, unread, mentions, onClick }: ChannelItemProps) {
  const { activeChannelId } = useChannelsStore();
  const isActive = activeChannelId === channel.id;
  const isMuted = channel.is_muted;

  return (
    <button
      onClick={onClick}
      className={cn(
        'flex w-full items-center gap-2 rounded px-2 py-1 text-sm transition-colors',
        isActive
          ? 'bg-slack-active text-slack-text'
          : unread > 0
          ? 'text-slack-text hover:bg-slack-hover'
          : 'text-slack-text-muted hover:bg-slack-hover'
      )}
    >
      {/* Channel icon */}
      {channel.type === 'private' ? (
        <Lock className="h-4 w-4 flex-shrink-0 opacity-60" />
      ) : (
        <Hash className="h-4 w-4 flex-shrink-0 opacity-60" />
      )}

      {/* Channel name */}
      <span className={cn('flex-1 truncate text-left', unread > 0 && 'font-bold')}>
        {channel.name}
      </span>

      {/* Badges */}
      <div className="flex items-center gap-1">
        {mentions > 0 && (
          <span className="bg-slack-mention rounded-full px-1.5 py-0.5 text-xs font-bold text-white">
            {mentions}
          </span>
        )}
        {unread > 0 && mentions === 0 && !isMuted && (
          <span className="bg-slack-unread rounded-full px-1.5 py-0.5 text-xs font-bold text-white">
            {unread}
          </span>
        )}
        {isMuted && (
          <span className="text-xs opacity-50">🔕</span>
        )}
      </div>
    </button>
  );
}
5.4 VISTA DE CANAL (Message List + Input)
🔹 Channel Page
// apps/web/src/app/(workspace)/[workspaceDomain]/channel/[channelId]/page.tsx

'use client';

import { ChannelHeader } from '@/components/channels/ChannelHeader';
import { MessageList } from '@/components/messaging/MessageList';
import { MessageInput } from '@/components/messaging/MessageInput';
import { RightPanel } from '@/components/layout/RightPanel';
import { useChannel } from '@/hooks/useChannel';
import { useMessages } from '@/hooks/useMessages';
import { useRightPanelStore } from '@/stores/ui.store';
import { Loader2 } from 'lucide-react';

export default function ChannelPage({ params }: { params: { channelId: string } }) {
  const { channel, isLoading } = useChannel(params.channelId);
  const { rightPanelOpen } = useRightPanelStore();

  if (isLoading) {
    return (
      <div className="flex h-full items-center justify-center">
        <Loader2 className="h-8 w-8 animate-spin text-slack-text-muted" />
      </div>
    );
  }

  if (!channel) {
    return <div className="p-8 text-center text-slack-text-muted">Channel not found</div>;
  }

  return (
    <div className="flex h-full">
      {/* Main column */}
      <div className="flex flex-1 flex-col overflow-hidden">
        <ChannelHeader channel={channel} />
        <MessageList channelId={channel.id} />
        <MessageInput channelId={channel.id} />
      </div>

      {/* Right panel */}
      {rightPanelOpen && <RightPanel channel={channel} />}
    </div>
  );
}
🔹 MessageList (con infinite scroll + virtualization)
// apps/web/src/components/messaging/MessageList.tsx

'use client';

import { useEffect, useRef, useCallback } from 'react';
import { useVirtualizer } from '@tanstack/react-virtual';
import { useMessages } from '@/hooks/useMessages';
import { MessageItem } from './MessageItem';
import { SystemMessage } from './SystemMessage';
import { DateSeparator } from './DateSeparator';
import { useSocket } from '@/hooks/useSocket';
import { Loader2 } from 'lucide-react';

export function MessageList({ channelId }: { channelId: string }) {
  const { messages, isLoading, hasMore, loadMore, isNewest } = useMessages(channelId);
  const { socket } = useSocket();
  const scrollContainerRef = useRef<HTMLDivElement>(null);
  const bottomRef = useRef<HTMLDivElement>(null);
  const prevScrollHeight = useRef(0);

  // Virtualization para performance con miles de mensajes
  const virtualizer = useVirtualizer({
    count: messages.length,
    getScrollElement: () => scrollContainerRef.current,
    estimateSize: () => 80, // Altura estimada por mensaje
    overscan: 10,
    reverse: true, // Mensajes más nuevos arriba (scroll hacia abajo)
  });

  // Auto-scroll al fondo cuando llegan mensajes nuevos
  useEffect(() => {
    if (isNewest) {
      bottomRef.current?.scrollIntoView({ behavior: 'smooth' });
    }
  }, [messages.length, isNewest]);

  // Cargar más mensajes al hacer scroll arriba
  const handleScroll = useCallback(() => {
    const container = scrollContainerRef.current;
    if (!container) return;

    if (container.scrollTop < 100 && hasMore && !isLoading) {
      prevScrollHeight.current = container.scrollHeight;
      loadMore();
    }
  }, [hasMore, isLoading, loadMore]);

  // Mantener scroll position al cargar mensajes antiguos
  useEffect(() => {
    const container = scrollContainerRef.current;
    if (!container || !isLoading) return;

    const newScrollHeight = container.scrollHeight;
    const diff = newScrollHeight - prevScrollHeight.current;
    container.scrollTop += diff;
  }, [isLoading]);

  // Escuchar nuevos mensajes via WebSocket
  useEffect(() => {
    if (!socket) return;

    const handleMessage = (message: MessageEvent) => {
      if (message.channel_id === channelId) {
        // Agregar al store
        useMessagesStore.getState().addMessage(channelId, message);
      }
    };

    socket.on('message', handleMessage);
    return () => socket.off('message', handleMessage);
  }, [socket, channelId]);

  if (isLoading && messages.length === 0) {
    return (
      <div className="flex flex-1 items-center justify-center">
        <Loader2 className="h-8 w-8 animate-spin text-slack-text-muted" />
      </div>
    );
  }

  return (
    <div
      ref={scrollContainerRef}
      onScroll={handleScroll}
      className="flex-1 overflow-y-auto px-4 scrollbar-thin"
    >
      <div className="py-4">
        {/* Channel welcome header */}
        <div className="mb-6 border-b border-slack-border pb-6">
          <div className="flex items-center gap-3">
            <Hash className="h-8 w-8 text-slack-text-muted" />
            <div>
              <h2 className="text-xl font-bold">#{channel.name}</h2>
              <p className="text-sm text-slack-text-muted">
                This is the beginning of the #{channel.name} channel.
              </p>
            </div>
          </div>
        </div>

        {/* Load more indicator */}
        {hasMore && (
          <div className="flex justify-center py-2">
            <Loader2 className="h-4 w-4 animate-spin text-slack-text-muted" />
          </div>
        )}

        {/* Virtualized message list */}
        <div
          style={{ height: `${virtualizer.getTotalSize()}px`, position: 'relative' }}
        >
          {virtualizer.getVirtualItems().map(virtualItem => {
            const message = messages[virtualItem.index];
            const prevMessage = messages[virtualItem.index + 1];

            return (
              <div
                key={virtualItem.key}
                style={{
                  position: 'absolute',
                  top: 0,
                  left: 0,
                  width: '100%',
                  transform: `translateY(${virtualItem.start}px)`,
                }}
              >
                {/* Date separator */}
                {shouldShowDateSeparator(message, prevMessage) && (
                  <DateSeparator date={message.ts} />
                )}

                {/* Message or system message */}
                {message.is_system ? (
                  <SystemMessage message={message} />
                ) : (
                  <MessageItem
                    message={message}
                    showAvatar={shouldShowAvatar(message, prevMessage)}
                  />
                )}
              </div>
            );
          })}
        </div>

        {/* Bottom anchor */}
        <div ref={bottomRef} />
      </div>
    </div>
  );
}

// Helpers para agrupar mensajes
function shouldShowDateSeparator(msg: Message, prev: Message | undefined): boolean {
  if (!prev) return false;
  const msgDate = new Date(msg.ts).toDateString();
  const prevDate = new Date(prev.ts).toDateString();
  return msgDate !== prevDate;
}

function shouldShowAvatar(msg: Message, prev: Message | undefined): boolean {
  if (!prev) return true;
  if (prev.user_id !== msg.user_id) return true;
  const diff = new Date(msg.ts).getTime() - new Date(prev.ts).getTime();
  if (diff > 5 * 60 * 1000) return true; // Más de 5 minutos
  return false;
}
🔹 MessageItem (componente individual de mensaje)
// apps/web/src/components/messaging/MessageItem.tsx

'use client';

import { useState, useRef } from 'react';
import { Avatar, AvatarImage, AvatarFallback } from '@/components/ui/avatar';
import { PresenceDot } from '@/components/common/PresenceDot';
import { MessageReactions } from './MessageReactions';
import { MessageActions } from './MessageActions';
import { BlockRenderer } from '@/components/block-kit/BlockRenderer';
import { FilePreview } from '@/components/files/FilePreview';
import { formatMessageText } from '@/lib/message-formatter';
import { useUsersStore } from '@/stores/users.store';
import { useSocket } from '@/hooks/useSocket';
import { cn } from '@/lib/utils';
import { Edit2, Trash2, Share, Pin, Bookmark, MoreVertical } from 'lucide-react';

interface MessageItemProps {
  message: Message;
  showAvatar: boolean;
}

export function MessageItem({ message, showAvatar }: MessageItemProps) {
  const { getUser } = useUsersStore();
  const { socket } = useSocket();
  const [isHovered, setIsHovered] = useState(false);
  const [isEditing, setIsEditing] = useState(false);
  const [editedText, setEditedText] = useState(message.text);
  const author = getUser(message.user_id);

  const handleEdit = async () => {
    // PATCH /api/v1/messages/:id
    await fetch(`/api/v1/messages/${message.id}`, {
      method: 'PATCH',
      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
      body: JSON.stringify({ text: editedText }),
    });
    setIsEditing(false);
  };

  const handleDelete = async () => {
    if (!confirm('Delete this message?')) return;
    await fetch(`/api/v1/messages/${message.id}`, { method: 'DELETE' });
  };

  const handleSave = async () => {
    await fetch(`/api/v1/messages/${message.id}/save`, { method: 'POST' });
  };

  const handlePin = async () => {
    await fetch(`/api/v1/channels/${message.channel_id}/pins`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ message_id: message.id }),
    });
  };

  return (
    <div
      className={cn(
        'group relative flex gap-3 px-3 py-0.5',
        isHovered && 'bg-slack-hover',
        showAvatar && 'mt-2'
      )}
      onMouseEnter={() => setIsHovered(true)}
      onMouseLeave={() => setIsHovered(false)}
    >
      {/* Avatar */}
      <div className="w-10 flex-shrink-0">
        {showAvatar ? (
          <div className="relative">
            <Avatar className="h-9 w-9 rounded">
              <AvatarImage src={author?.avatar_url} />
              <AvatarFallback>{author?.display_name?.[0]}</AvatarFallback>
            </Avatar>
            <PresenceDot userId={message.user_id} className="absolute -bottom-0.5 -right-0.5" />
          </div>
        ) : (
          <span className="text-[10px] text-slack-text-muted opacity-0 group-hover:opacity-100">
            {formatTime(message.ts)}
          </span>
        )}
      </div>

      {/* Content */}
      <div className="flex-1 min-w-0">
        {/* Header (name + time) */}
        {showAvatar && (
          <div className="flex items-baseline gap-2">
            <span
              className="font-bold text-sm cursor-pointer hover:underline"
              style={{ color: author?.color || 'inherit' }}
              onClick={() => {/* mostrar perfil */}}
            >
              {author?.display_name}
            </span>
            <span className="text-xs text-slack-text-muted">
              {formatTimestamp(message.ts)}
            </span>
            {message.is_edited && (
              <span className="text-xs text-slack-text-muted">(edited)</span>
            )}
          </div>
        )}

        {/* Message body */}
        {isEditing ? (
          <div className="mt-1">
            <textarea
              autoFocus
              value={editedText}
              onChange={e => setEditedText(e.target.value)}
              className="w-full rounded border border-slack-border bg-slack-input px-2 py-1 text-sm"
              rows={3}
            />
            <div className="mt-1 flex gap-2">
              <button onClick={handleEdit} className="text-sm text-slack-primary">Save</button>
              <button onClick={() => setIsEditing(false)} className="text-sm text-slack-text-muted">Cancel</button>
            </div>
          </div>
        ) : (
          <>
            {/* Block Kit content */}
            {message.blocks && message.blocks.length > 0 ? (
              <BlockRenderer blocks={message.blocks} />
            ) : (
              <div
                className="text-sm leading-relaxed"
                dangerouslySetInnerHTML={{ __html: formatMessageText(message.text) }}
              />
            )}

            {/* Files */}
            {message.files?.map(file => (
              <FilePreview key={file.id} file={file} />
            ))}

            {/* Link previews */}
            {message.link_previews?.map((preview, i) => (
              <LinkPreview key={i} preview={preview} />
            ))}

            {/* Thread reply indicator */}
            {message.reply_count > 0 && (
              <button
                className="mt-1 flex items-center gap-2 text-xs text-slack-primary hover:underline"
                onClick={() => {/* abrir thread */}}
              >
                <Avatar className="h-4 w-4 rounded-full">
                  <AvatarImage src={replyUsersAvatars[0]} />
                </Avatar>
                <span>{message.reply_count} {message.reply_count === 1 ? 'reply' : 'replies'}</span>
              </button>
            )}

            {/* Reactions */}
            <MessageReactions
              messageId={message.id}
              reactions={message.reactions}
              channelId={message.channel_id}
            />
          </>
        )}
      </div>

      {/* Hover actions */}
      {isHovered && !isEditing && (
        <MessageActions
          onEdit={() => setIsEditing(true)}
          onDelete={handleDelete}
          onPin={handlePin}
          onSave={handleSave}
          onReply={() => {/* abrir thread */}}
          onReact={() => {/* abrir emoji picker */}}
        />
      )}
    </div>
  );
}
🔹 MessageInput (compositor de mensajes)
// apps/web/src/components/messaging/MessageInput.tsx

'use client';

import { useState, useRef, useEffect } from 'react';
import { useTyping } from '@/hooks/useTyping';
import { EmojiPicker } from '@/components/common/EmojiPicker';
import { FileUploadZone } from '@/components/files/FileUploadZone';
import { MentionSuggestions } from '@/components/common/MentionSuggestions';
import { ChannelSuggestions } from '@/components/common/ChannelSuggestions';
import { SlashCommandMenu } from '@/components/common/SlashCommandMenu';
import { Send, Paperclip, Smile, AtSign, Hash, Bold, Italic, Code } from 'lucide-react';
import { cn } from '@/lib/utils';

export function MessageInput({ channelId }: { channelId: string }) {
  const [text, setText] = useState('');
  const [blocks, setBlocks] = useState<any[]>([]);
  const [files, setFiles] = useState<File[]>([]);
  const [showEmoji, setShowEmoji] = useState(false);
  const [showMentions, setShowMentions] = useState(false);
  const [showChannels, setShowChannels] = useState(false);
  const [showSlash, setShowSlash] = useState(false);
  const [isUploading, setIsUploading] = useState(false);
  const textareaRef = useRef<HTMLTextAreaElement>(null);
  const { startTyping, stopTyping } = useTyping(channelId);

  // Auto-resize textarea
  useEffect(() => {
    const textarea = textareaRef.current;
    if (textarea) {
      textarea.style.height = 'auto';
      textarea.style.height = `${Math.min(textarea.scrollHeight, 300)}px`;
    }
  }, [text]);

  // Detectar @mentions, #channels, /commands en tiempo real
  useEffect(() => {
    const lastWord = text.split(' ').pop() || '';
    if (lastWord.startsWith('@')) setShowMentions(true);
    else if (lastWord.startsWith('#')) setShowChannels(true);
    else if (lastWord.startsWith('/') && text === lastWord) setShowSlash(true);
    else {
      setShowMentions(false);
      setShowChannels(false);
      setShowSlash(false);
    }
  }, [text]);

  // Typing indicator
  useEffect(() => {
    if (text.length > 0) {
      startTyping();
    } else {
      stopTyping();
    }
  }, [text]);

  const handleSend = async () => {
    if (!text.trim() && files.length === 0) return;

    // Upload files si hay
    let fileIds: string[] = [];
    if (files.length > 0) {
      setIsUploading(true);
      fileIds = await uploadFiles(files);
      setIsUploading(false);
    }

    // Enviar mensaje via API
    await fetch(`/api/v1/channels/${channelId}/messages`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
      body: JSON.stringify({
        text: text,
        blocks: blocks.length > 0 ? blocks : undefined,
        file_ids: fileIds.length > 0 ? fileIds : undefined,
      }),
    });

    // Limpiar
    setText('');
    setBlocks([]);
    setFiles([]);
    stopTyping();
  };

  // Keyboard shortcuts
  const handleKeyDown = (e: KeyboardEvent) => {
    // Enter = enviar
    if (e.key === 'Enter' && !e.shiftKey) {
      e.preventDefault();
      handleSend();
    }
    // Cmd/Ctrl + Enter = nueva línea
    // Cmd/Ctrl + K = comando palette
    // Cmd/Ctrl + B = bold
    // Cmd/Ctrl + I = italic
    // Esc = cancelar
  };

  return (
    <div className="border-t border-slack-border px-4 py-3">
      <div className="rounded-lg border border-slack-border bg-slack-input focus-within:border-slack-primary">
        {/* Drag & drop zone */}
        <FileUploadZone onFiles={setFiles} files={files}>
          <textarea
            ref={textareaRef}
            value={text}
            onChange={e => setText(e.target.value)}
            onKeyDown={handleKeyDown}
            placeholder={`Message #${channelName}`}
            className="w-full resize-none bg-transparent px-3 py-2 text-sm outline-none placeholder:text-slack-text-muted"
            rows={1}
          />
        </FileUploadZone>

        {/* Toolbar */}
        <div className="flex items-center justify-between px-2 py-1">
          <div className="flex items-center gap-1">
            {/* Attach file */}
            <button
              onClick={() => fileInputRef.current?.click()}
              className="rounded p-1.5 hover:bg-slack-hover"
            >
              <Paperclip className="h-5 w-5 text-slack-text-muted" />
            </button>

            {/* Emoji picker */}
            <button
              onClick={() => setShowEmoji(!showEmoji)}
              className="rounded p-1.5 hover:bg-slack-hover"
            >
              <Smile className="h-5 w-5 text-slack-text-muted" />
            </button>

            {/* Mention */}
            <button
              onClick={() => { setText(text + ' @'); textareaRef.current?.focus(); }}
              className="rounded p-1.5 hover:bg-slack-hover"
            >
              <AtSign className="h-5 w-5 text-slack-text-muted" />
            </button>

            {/* Channel link */}
            <button
              onClick={() => { setText(text + ' #'); textareaRef.current?.focus(); }}
              className="rounded p-1.5 hover:bg-slack-hover"
            >
              <Hash className="h-5 w-5 text-slack-text-muted" />
            </button>

            {/* Formatting */}
            <div className="mx-1 h-4 w-px bg-slack-border" />
            <button onClick={() => wrapSelection('*')} className="rounded p-1.5 hover:bg-slack-hover">
              <Bold className="h-4 w-4 text-slack-text-muted" />
            </button>
            <button onClick={() => wrapSelection('_')} className="rounded p-1.5 hover:bg-slack-hover">
              <Italic className="h-4 w-4 text-slack-text-muted" />
            </button>
            <button onClick={() => wrapSelection('`')} className="rounded p-1.5 hover:bg-slack-hover">
              <Code className="h-4 w-4 text-slack-text-muted" />
            </button>
          </div>

          {/* Send button */}
          <button
            onClick={handleSend}
            disabled={(!text.trim() && files.length === 0) || isUploading}
            className={cn(
              'rounded-md px-3 py-1 text-sm font-semibold transition-colors',
              text.trim() || files.length > 0
                ? 'bg-slack-primary text-white hover:bg-slack-primary-hover'
                : 'bg-slack-border text-slack-text-muted cursor-not-allowed'
            )}
          >
            {isUploading ? 'Uploading...' : 'Send'}
          </button>
        </div>
      </div>

      {/* Popovers */}
      {showEmoji && <EmojiPicker onSelect={(emoji) => setText(text + emoji)} />}
      {showMentions && <MentionSuggestions query={text.split(' ').pop() || ''} onSelect={insertMention} />}
      {showChannels && <ChannelSuggestions query={text.split(' ').pop() || ''} onSelect={insertChannel} />}
      {showSlash && <SlashCommandMenu onSelect={runCommand} />}

      {/* Helper text */}
      <div className="mt-1 flex justify-between px-2 text-xs text-slack-text-muted">
        <span>
          <kbd className="rounded bg-slack-hover px-1">Enter</kbd> to send ·{' '}
          <kbd className="rounded bg-slack-hover px-1">Shift+Enter</kbd> for new line
        </span>
        <span>{text.length}/40000</span>
      </div>
    </div>
  );
}
5.5 BLOCK KIT RENDERER
🔹 Block Kit: Sistema de contenido rico para mensajes
// apps/web/src/components/block-kit/BlockRenderer.tsx

'use client';

import { SectionBlock } from './SectionBlock';
import { ActionsBlock } from './ActionsBlock';
import { DividerBlock } from './DividerBlock';
import { ImageBlock } from './ImageBlock';
import { ContextBlock } from './ContextBlock';
import { HeaderBlock } from './HeaderBlock';
import { FileBlock } from './FileBlock';
import { InputBlock } from './InputBlock';

interface BlockRendererProps {
  blocks: Block[];
  context?: { channelId: string; messageId: string };
}

export function BlockRenderer({ blocks, context }: BlockRendererProps) {
  return (
    <div className="space-y-1">
      {blocks.map((block, index) => {
        switch (block.type) {
          case 'section':
            return <SectionBlock key={index} block={block} context={context} />;
          case 'divider':
            return <DividerBlock key={index} />;
          case 'image':
            return <ImageBlock key={index} block={block} />;
          case 'actions':
            return <ActionsBlock key={index} block={block} context={context} />;
          case 'context':
            return <ContextBlock key={index} block={block} />;
          case 'header':
            return <HeaderBlock key={index} block={block} />;
          case 'file':
            return <FileBlock key={index} block={block} />;
          case 'input':
            return <InputBlock key={index} block={block} context={context} />;
          default:
            console.warn(`Unknown block type: ${block.type}`);
            return null;
        }
      })}
    </div>
  );
}
🔹 Section Block (el más común)
// apps/web/src/components/block-kit/SectionBlock.tsx

'use client';

import { TextRenderer } from './TextRenderer';
import { ImageBlock } from './ImageBlock';
import { InteractiveElements } from './InteractiveElements';

export function SectionBlock({ block, context }: { block: SectionBlock; context?: any }) {
  return (
    <div className="flex gap-3 py-1">
      {/* Text content */}
      {block.text && (
        <div className="flex-1">
          <TextRenderer text={block.text} />
        </div>
      )}

      {/* Fields (hasta 10 columnas) */}
      {block.fields && (
        <div className="flex-1 grid grid-cols-2 gap-2">
          {block.fields.map((field, i) => (
            <div key={i}>
              <TextRenderer text={field} />
            </div>
          ))}
        </div>
      )}

      {/* Accessory (image, button, select, etc.) */}
      {block.accessory && (
        <div className="flex-shrink-0">
          <InteractiveElements element={block.accessory} context={context} />
        </div>
      )}
    </div>
  );
}
🔹 Actions Block (botones interactivos)
// apps/web/src/components/block-kit/ActionsBlock.tsx

'use client';

import { Button } from '@/components/ui/button';
import { InteractiveElements } from './InteractiveElements';

export function ActionsBlock({ block, context }: { block: ActionsBlock; context?: any }) {
  return (
    <div className="flex flex-wrap gap-2 py-1">
      {block.elements.map((element, index) => (
        <InteractiveElements key={index} element={element} context={context} />
      ))}
    </div>
  );
}

// InteractiveElements maneja: button, select, datepicker, overflow, radio, checkbox, etc.
5.6 STATE MANAGEMENT (Zustand Stores)
🔹 WebSocket Hook (Core)
// apps/web/src/hooks/useSocket.ts

'use client';

import { createContext, useContext, useEffect, useState, ReactNode } from 'react';
import { io, Socket } from 'socket.io-client';
import { useAuthStore } from '@/stores/auth.store';
import { useMessagesStore } from '@/stores/messages.store';
import { usePresenceStore } from '@/stores/presence.store';
import { useChannelsStore } from '@/stores/channels.store';
import { useNotificationsStore } from '@/stores/notifications.store';

interface SocketContextType {
  socket: Socket | null;
  connect: (workspaceId: string) => void;
  disconnect: () => void;
  isConnected: boolean;
}

const SocketContext = createContext<SocketContextType>({} as SocketContextType);

export function SocketProvider({ children }: { children: ReactNode }) {
  const [socket, setSocket] = useState<Socket | null>(null);
  const [isConnected, setIsConnected] = useState(false);
  const { accessToken } = useAuthStore();

  const connect = (workspaceId: string) => {
    if (socket?.connected) return;

    const newSocket = io(process.env.NEXT_PUBLIC_WS_URL || 'http://localhost:3001', {
      transports: ['websocket'],
      auth: { token: accessToken, workspaceId },
      reconnection: true,
      reconnectionAttempts: Infinity,
      reconnectionDelay: 1000,
      reconnectionDelayMax: 5000,
      timeout: 20000,
    });

    // ==================== EVENT HANDLERS ====================

    newSocket.on('connect', () => {
      setIsConnected(true);
      console.log('✅ WebSocket connected');
    });

    newSocket.on('disconnect', (reason) => {
      setIsConnected(false);
      console.log('❌ WebSocket disconnected:', reason);
    });

    newSocket.on('reconnect', (attempt) => {
      console.log(`🔄 Reconnected after ${attempt} attempts`);
    });

    // --- Mensajes ---
    newSocket.on('message', (message: MessageEvent) => {
      useMessagesStore.getState().addMessage(message.channel_id, message);
      // Actualizar last_message en sidebar
      useChannelsStore.getState().updateLastMessage(message.channel_id, message);
      // Incrementar unread si no es el canal activo
      const activeChannel = useChannelsStore.getState().activeChannelId;
      if (message.channel_id !== activeChannel) {
        useNotificationsStore.getState().incrementUnread(message.channel_id, message.mentioned_users);
      }
    });

    newSocket.on('message_changed', (data: MessageChangedEvent) => {
      useMessagesStore.getState().updateMessage(data.channel_id, data);
    });

    newSocket.on('message_deleted', (data: MessageDeletedEvent) => {
      useMessagesStore.getState().deleteMessage(data.channel_id, data.id);
    });

    // --- Reacciones ---
    newSocket.on('reaction_added', (data: ReactionEvent) => {
      useMessagesStore.getState().addReaction(data);
    });

    newSocket.on('reaction_removed', (data: ReactionEvent) => {
      useMessagesStore.getState().removeReaction(data);
    });

    // --- Canales ---
    newSocket.on('channel_join', (data) => {
      useChannelsStore.getState().addMember(data.channel_id, data.user_id);
    });

    newSocket.on('channel_leave', (data) => {
      useChannelsStore.getState().removeMember(data.channel_id, data.user_id);
    });

    newSocket.on('channel_created', (data) => {
      useChannelsStore.getState().addChannel(data);
    });

    // --- Presencia ---
    newSocket.on('presence_change', (data: PresenceEvent) => {
      usePresenceStore.getState().setPresence(data.user_id, data.presence);
    });

    // --- Typing ---
    newSocket.on('user_typing', (data: TypingEvent) => {
      usePresenceStore.getState().setTyping(data.channel_id, data.user_id, data.isTyping);
    });

    // --- Huddles ---
    newSocket.on('huddle_start', (data) => {
      // Mostrar banner de huddle activo
    });

    newSocket.on('huddle_end', (data) => {
      // Quitar banner
    });

    // --- Notificaciones ---
    newSocket.on('notification', (data) => {
      // Mostrar toast + reproducir sonido + badge
    });

    newSocket.on('badge_update', (data) => {
      useNotificationsStore.getState().setTotalUnread(data.count);
    });

    // ==================== HEARTBEAT ====================

    // Heartbeat cada 30s para mantener presencia
    const heartbeatInterval = setInterval(() => {
      if (newSocket.connected) {
        newSocket.emit('heartbeat');
      }
    }, 30000);

    setSocket(newSocket);

    return () => {
      clearInterval(heartbeatInterval);
      newSocket.close();
    };
  };

  const disconnect = () => {
    if (socket) {
      socket.close();
      setSocket(null);
      setIsConnected(false);
    }
  };

  return (
    <SocketContext.Provider value={{ socket, connect, disconnect, isConnected }}>
      {children}
    </SocketContext.Provider>
  );
}

export const useSocket = () => useContext(SocketContext);
🔹 Messages Store (Zustand)
// apps/web/src/stores/messages.store.ts

import { create } from 'zustand';
import { persist } from 'zustand/middleware';

interface MessagesState {
  // messageMap: { [channelId]: Message[] }
  messagesByChannel: Record<string, Message[]>;
  cursorByChannel: Record<string, string | null>; // Para paginación
  hasMoreByChannel: Record<string, boolean>;
  loadingByChannel: Record<string, boolean>;

  // Actions
  setMessages: (channelId: string, messages: Message[], cursor: string | null) => void;
  addMessage: (channelId: string, message: Message) => void;
  prependMessages: (channelId: string, messages: Message[]) => void;
  updateMessage: (channelId: string, data: Partial<Message>) => void;
  deleteMessage: (channelId: string, messageId: string) => void;
  addReaction: (data: ReactionEvent) => void;
  removeReaction: (data: ReactionEvent) => void;
  setLoading: (channelId: string, loading: boolean) => void;
  setHasMore: (channelId: string, hasMore: boolean) => void;
}

export const useMessagesStore = create<MessagesState>()(
  persist(
    (set, get) => ({
      messagesByChannel: {},
      cursorByChannel: {},
      hasMoreByChannel: {},
      loadingByChannel: {},

      setMessages: (channelId, messages, cursor) =>
        set((state) => ({
          messagesByChannel: { ...state.messagesByChannel, [channelId]: messages },
          cursorByChannel: { ...state.cursorByChannel, [channelId]: cursor },
        })),

      addMessage: (channelId, message) =>
        set((state) => ({
          messagesByChannel: {
            ...state.messagesByChannel,
            [channelId]: [...(state.messagesByChannel[channelId] || []), message],
          },
        })),

      prependMessages: (channelId, messages) =>
        set((state) => ({
          messagesByChannel: {
            ...state.messagesByChannel,
            [channelId]: [...messages, ...(state.messagesByChannel[channelId] || [])],
          },
        })),

      updateMessage: (channelId, data) =>
        set((state) => ({
          messagesByChannel: {
            ...state.messagesByChannel,
            [channelId]: (state.messagesByChannel[channelId] || []).map((m) =>
              m.id === data.id ? { ...m, ...data } : m
            ),
          },
        })),

      deleteMessage: (channelId, messageId) =>
        set((state) => ({
          messagesByChannel: {
            ...state.messagesByChannel,
            [channelId]: (state.messagesByChannel[channelId] || []).map((m) =>
              m.id === messageId ? { ...m, is_deleted: true } : m
            ),
          },
        })),

      addReaction: (data) =>
        set((state) => {
          const messages = state.messagesByChannel[data.channel_id] || [];
          return {
            messagesByChannel: {
              ...state.messagesByChannel,
              [data.channel_id]: messages.map((m) => {
                if (m.id !== data.message_id) return m;
                const reactions = m.reactions || [];
                const existing = reactions.find((r) => r.emoji === data.emoji);
                if (existing) {
                  return {
                    ...m,
                    reactions: reactions.map((r) =>
                      r.emoji === data.emoji
                        ? { ...r, count: r.count + 1, users: [...r.users, data.user_id] }
                        : r
                    ),
                  };
                }
                return {
                  ...m,
                  reactions: [...reactions, { emoji: data.emoji, count: 1, users: [data.user_id] }],
                };
              }),
            },
          };
        }),

      removeReaction: (data) =>
        set((state) => {
          const messages = state.messagesByChannel[data.channel_id] || [];
          return {
            messagesByChannel: {
              ...state.messagesByChannel,
              [data.channel_id]: messages.map((m) => {
                if (m.id !== data.message_id) return m;
                return {
                  ...m,
                  reactions: (m.reactions || [])
                    .map((r) =>
                      r.emoji === data.emoji
                        ? { ...r, count: r.count - 1, users: r.users.filter((u) => u !== data.user_id) }
                        : r
                    )
                    .filter((r) => r.count > 0),
                };
              }),
            },
          };
        }),

      setLoading: (channelId, loading) =>
        set((state) => ({
          loadingByChannel: { ...state.loadingByChannel, [channelId]: loading },
        })),

      setHasMore: (channelId, hasMore) =>
        set((state) => ({
          hasMoreByChannel: { ...state.hasMoreByChannel, [channelId]: hasMore },
        })),
    }),
    {
      name: 'messages-store',
      partialize: (state) => ({
        // Solo persistir últimos 50 mensajes por canal (no todo)
        messagesByChannel: Object.fromEntries(
          Object.entries(state.messagesByChannel).map(([k, v]) => [k, v.slice(-50)])
        ),
      }),
    }
  )
);
🔹 Presence Store
// apps/web/src/stores/presence.store.ts

import { create } from 'zustand';

interface PresenceState {
  presences: Record<string, 'online' | 'away' | 'dnd' | 'offline'>;
  typingByChannel: Record<string, Record<string, boolean>>; // { channelId: { userId: true } }

  setPresence: (userId: string, presence: string) => void;
  setPresences: (presences: Record<string, string>) => void;
  setTyping: (channelId: string, userId: string, isTyping: boolean) => void;
  clearTyping: (channelId: string) => void;
}

export const usePresenceStore = create<PresenceState>((set) => ({
  presences: {},
  typingByChannel: {},

  setPresence: (userId, presence) =>
    set((state) => ({
      presences: { ...state.presences, [userId]: presence },
    })),

  setPresences: (presences) =>
    set((state) => ({
      presences: { ...state.presences, ...presences },
    })),

  setTyping: (channelId, userId, isTyping) =>
    set((state) => ({
      typingByChannel: {
        ...state.typingByChannel,
        [channelId]: {
          ...(state.typingByChannel[channelId] || {}),
          [userId]: isTyping,
        },
      },
    })),

  clearTyping: (channelId) =>
    set((state) => ({
      typingByChannel: {
        ...state.typingByChannel,
        [channelId]: {},
      },
    })),
}));
🔹 Channels Store
// apps/web/src/stores/channels.store.ts

import { create } from 'zustand';
import { persist } from 'zustand/middleware';

interface ChannelsState {
  channels: Channel[];
  activeChannelId: string | null;
  isLoading: boolean;

  setChannels: (channels: Channel[]) => void;
  addChannel: (channel: Channel) => void;
  updateChannel: (channelId: string, data: Partial<Channel>) => void;
  removeChannel: (channelId: string) => void;
  setActiveChannel: (channelId: string | null) => void;
  updateLastMessage: (channelId: string, message: MessageEvent) => void;
  addMember: (channelId: string, userId: string) => void;
  removeMember: (channelId: string, userId: string) => void;
}

export const useChannelsStore = create<ChannelsState>()(
  persist(
    (set) => ({
      channels: [],
      activeChannelId: null,
      isLoading: false,

      setChannels: (channels) => set({ channels }),

      addChannel: (channel) =>
        set((state) => ({ channels: [...state.channels, channel] })),

      updateChannel: (channelId, data) =>
        set((state) => ({
          channels: state.channels.map((c) =>
            c.id === channelId ? { ...c, ...data } : c
          ),
        })),

      removeChannel: (channelId) =>
        set((state) => ({
          channels: state.channels.filter((c) => c.id !== channelId),
        })),

      setActiveChannel: (channelId) => set({ activeChannelId: channelId }),

      updateLastMessage: (channelId, message) =>
        set((state) => ({
          channels: state.channels.map((c) =>
            c.id === channelId
              ? {
                  ...c,
                  last_message: {
                    text: message.text,
                    user_id: message.user_id,
                    ts: message.ts,
                  },
                  last_message_at: message.ts,
                }
              : c
          ),
        })),

      addMember: (channelId, userId) =>
        set((state) => ({
          channels: state.channels.map((c) =>
            c.id === channelId ? { ...c, member_count: c.member_count + 1 } : c
          ),
        })),

      removeMember: (channelId, userId) =>
        set((state) => ({
          channels: state.channels.map((c) =>
            c.id === channelId ? { ...c, member_count: c.member_count - 1 } : c
          ),
        })),
    }),
    { name: 'channels-store' }
  )
);
🔹 Notifications Store
// apps/web/src/stores/notifications.store.ts

import { create } from 'zustand';

interface NotificationsState {
  // unreadByChannel: { [channelId]: { count: number, mentions: number } }
  unreadByChannel: Record<string, { count: number; mentions: number }>;
  totalUnread: number;
  totalMentions: number;

  incrementUnread: (channelId: string, mentionedUsers?: string[]) => void;
  clearUnread: (channelId: string) => void;
  setUnread: (channelId: string, count: number, mentions: number) => void;
  setTotalUnread: (count: number) => void;
  decrementTotal: () => void;
}

export const useNotificationsStore = create<NotificationsState>((set) => ({
  unreadByChannel: {},
  totalUnread: 0,
  totalMentions: 0,

  incrementUnread: (channelId, mentionedUsers) =>
    set((state) => {
      const current = state.unreadByChannel[channelId] || { count: 0, mentions: 0 };
      const isMentioned = mentionedUsers?.includes(currentUserId);
      const newChannel = {
        count: current.count + 1,
        mentions: current.mentions + (isMentioned ? 1 : 0),
      };
      return {
        unreadByChannel: { ...state.unreadByChannel, [channelId]: newChannel },
        totalUnread: state.totalUnread + 1,
        totalMentions: state.totalMentions + (isMentioned ? 1 : 0),
      };
    }),

  clearUnread: (channelId) =>
    set((state) => {
      const current = state.unreadByChannel[channelId] || { count: 0, mentions: 0 };
      return {
        unreadByChannel: { ...state.unreadByChannel, [channelId]: { count: 0, mentions: 0 } },
        totalUnread: Math.max(0, state.totalUnread - current.count),
        totalMentions: Math.max(0, state.totalMentions - current.mentions),
      };
    }),

  setUnread: (channelId, count, mentions) =>
    set((state) => ({
      unreadByChannel: { ...state.unreadByChannel, [channelId]: { count, mentions } },
    })),

  setTotalUnread: (count) => set({ totalUnread: count }),
  decrementTotal: () => set((state) => ({ totalUnread: Math.max(0, state.totalUnread - 1) })),
}));
5.7 API CLIENT
// apps/web/src/lib/api-client.ts

import { useAuthStore } from '@/stores/auth.store';

const BASE_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3000/api/v1';

class ApiClient {
  private baseURL: string;

  constructor(baseURL: string) {
    this.baseURL = baseURL;
  }

  private async request<T>(
    endpoint: string,
    options: RequestInit = {}
  ): Promise<T> {
    const token = useAuthStore.getState().accessToken;
    const workspaceId = useAuthStore.getState().currentWorkspaceId;

    const response = await fetch(`${this.baseURL}${endpoint}`, {
      ...options,
      headers: {
        'Content-Type': 'application/json',
        ...(token && { Authorization: `Bearer ${token}` }),
        ...(workspaceId && { 'X-Workspace-Id': workspaceId }),
        ...options.headers,
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({}));
      throw new ApiError(error.error?.message || 'Request failed', error.error?.code, response.status);
    }

    const data = await response.json();
    return data.data || data;
  }

  // ==================== AUTH ====================
  auth = {
    login: (email: string, password: string) =>
      this.request('/auth/login', { method: 'POST', body: JSON.stringify({ email, password }) }),
    register: (data: RegisterDto) =>
      this.request('/auth/register', { method: 'POST', body: JSON.stringify(data) }),
    refresh: (refreshToken: string) =>
      this.request('/auth/refresh', { method: 'POST', body: JSON.stringify({ refresh_token: refreshToken }) }),
    logout: () => this.request('/auth/logout', { method: 'POST' }),
  };

  // ==================== CHANNELS ====================
  channels = {
    list: (params?: { type?: string; archived?: boolean; page?: number }) =>
      this.request(`/channels?${new URLSearchParams(params as any)}`),
    get: (id: string) => this.request(`/channels/${id}`),
    create: (data: CreateChannelDto) =>
      this.request('/channels', { method: 'POST', body: JSON.stringify(data) }),
    update: (id: string, data: Partial<Channel>) =>
      this.request(`/channels/${id}`, { method: 'PATCH', body: JSON.stringify(data) }),
    archive: (id: string) => this.request(`/channels/${id}/archive`, { method: 'POST' }),
    join: (id: string) => this.request(`/channels/${id}/join`, { method: 'POST' }),
    leave: (id: string) => this.request(`/channels/${id}/leave`, { method: 'POST' }),
    invite: (id: string, userIds: string[]) =>
      this.request(`/channels/${id}/invite`, { method: 'POST', body: JSON.stringify({ user_ids: userIds }) }),
    members: (id: string, page?: number) =>
      this.request(`/channels/${id}/members?page=${page || 1}`),
    markRead: (id: string, ts: string) =>
      this.request(`/channels/${id}/mark-read`, { method: 'POST', body: JSON.stringify({ ts }) }),
  };

  // ==================== MESSAGES ====================
  messages = {
    list: (channelId: string, params?: { limit?: number; cursor?: string; direction?: string }) =>
      this.request(`/channels/${channelId}/messages?${new URLSearchParams(params as any)}`),
    send: (channelId: string, data: SendMessageDto) =>
      this.request(`/channels/${channelId}/messages`, { method: 'POST', body: JSON.stringify(data) }),
    edit: (messageId: string, data: { text: string; blocks?: any[] }) =>
      this.request(`/messages/${messageId}`, { method: 'PATCH', body: JSON.stringify(data) }),
    delete: (messageId: string) =>
      this.request(`/messages/${messageId}`, { method: 'DELETE' }),
    thread: (messageId: string, params?: { limit?: number; cursor?: string }) =>
      this.request(`/messages/${messageId}/thread?${new URLSearchParams(params as any)}`),
    addReaction: (messageId: string, emoji: string) =>
      this.request(`/messages/${messageId}/reactions`, { method: 'POST', body: JSON.stringify({ emoji }) }),
    removeReaction: (messageId: string, emoji: string) =>
      this.request(`/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`, { method: 'DELETE' }),
    schedule: (channelId: string, data: { text: string; scheduled_for: string }) =>
      this.request(`/channels/${channelId}/messages/schedule`, { method: 'POST', body: JSON.stringify(data) }),
  };

  // ==================== FILES ====================
  files = {
    upload: (file: File, channelId?: string) => {
      const formData = new FormData();
      formData.append('file', file);
      if (channelId) formData.append('channel_id', channelId);
      return this.request('/files/upload', { method: 'POST', body: formData, headers: {} });
    },
    get: (id: string) => this.request(`/files/${id}`),
    delete: (id: string) => this.request(`/files/${id}`, { method: 'DELETE' }),
    share: (id: string, channelIds: string[], comment?: string) =>
      this.request(`/files/${id}/share`, { method: 'POST', body: JSON.stringify({ channel_ids: channelIds, comment }) }),
  };

  // ==================== SEARCH ====================
  search = {
    query: (q: string, params?: SearchParams) =>
      this.request(`/search?q=${encodeURIComponent(q)}&${new URLSearchParams(params as any)}`),
    ai: (question: string) =>
      this.request('/search/ai', { method: 'POST', body: JSON.stringify({ question }) }),
  };

  // ==================== AI ====================
  ai = {
    chat: (message: string, conversationId?: string) =>
      this.request('/ai/chat', { method: 'POST', body: JSON.stringify({ message, conversation_id: conversationId }) }),
    summarizeChannel: (channelId: string, period: string) =>
      this.request(`/ai/summarize/channel/${channelId}`, { method: 'POST', body: JSON.stringify({ period }) }),
    summarizeThread: (messageId: string) =>
      this.request(`/ai/summarize/thread/${messageId}`, { method: 'POST' }),
    translate: (messageId: string, targetLanguage: string) =>
      this.request('/ai/translate', { method: 'POST', body: JSON.stringify({ message_id: messageId, target_language: targetLanguage }) }),
  };

  // ==================== USERS ====================
  users = {
    list: (params?: { search?: string; page?: number }) =>
      this.request(`/users?${new URLSearchParams(params as any)}`),
    get: (id: string) => this.request(`/users/${id}`),
    updateProfile: (data: Partial<User>) =>
      this.request('/users/me', { method: 'PATCH', body: JSON.stringify(data) }),
    setStatus: (text: string, emoji: string, expiresAt?: string) =>
      this.request('/users/me/status', { method: 'PUT', body: JSON.stringify({ text, emoji, expires_at: expiresAt }) }),
    setPresence: (presence: string) =>
      this.request('/users/me/presence', { method: 'PUT', body: JSON.stringify({ presence }) }),
  };

  // ==================== LISTS ====================
  lists = {
    getByChannel: (channelId: string) => this.request(`/channels/${channelId}/lists`),
    create: (channelId: string, data: { name: string; view_type: string }) =>
      this.request(`/channels/${channelId}/lists`, { method: 'POST', body: JSON.stringify(data) }),
    get: (id: string) => this.request(`/lists/${id}`),
    getItems: (id: string, params?: { view?: string; filter?: any }) =>
      this.request(`/lists/${id}/items?${new URLSearchParams(params as any)}`),
    createItem: (id: string, data: { name: string; field_values: any }) =>
      this.request(`/lists/${id}/items`, { method: 'POST', body: JSON.stringify(data) }),
    updateItem: (listId: string, itemId: string, data: any) =>
      this.request(`/lists/${listId}/items/${itemId}`, { method: 'PATCH', body: JSON.stringify({ field_values: data }) }),
    addField: (id: string, data: { name: string; field_type: string; options?: any[] }) =>
      this.request(`/lists/${id}/fields`, { method: 'POST', body: JSON.stringify(data) }),
  };

  // ==================== WORKFLOWS ====================
  workflows = {
    list: () => this.request('/workflows'),
    create: (data: any) => this.request('/workflows', { method: 'POST', body: JSON.stringify(data) }),
    activate: (id: string) => this.request(`/workflows/${id}/activate`, { method: 'POST' }),
    pause: (id: string) => this.request(`/workflows/${id}/pause`, { method: 'POST' }),
    generate: (prompt: string) =>
      this.request('/workflows/generate', { method: 'POST', body: JSON.stringify({ prompt }) }),
  };

  // ==================== HUDDLES ====================
  huddles = {
    start: (channelId: string, isVideo: boolean) =>
      this.request(`/channels/${channelId}/huddles`, { method: 'POST', body: JSON.stringify({ is_video: isVideo }) }),
    join: (id: string) => this.request(`/huddles/${id}/join`, { method: 'POST' }),
    leave: (id: string) => this.request(`/huddles/${id}/leave`, { method: 'POST' }),
    end: (id: string) => this.request(`/huddles/${id}/end`, { method: 'POST' }),
    participants: (id: string) => this.request(`/huddles/${id}/participants`),
    generateNotes: (id: string) => this.request(`/huddles/${id}/notes`, { method: 'POST' }),
  };

  // ==================== INTEGRATIONS ====================
  integrations = {
    listApps: (params?: { category?: string; search?: string }) =>
      this.request(`/integrations/apps?${new URLSearchParams(params as any)}`),
    install: (slug: string) =>
      this.request(`/integrations/apps/${slug}/install`, { method: 'POST' }),
    uninstall: (slug: string) =>
      this.request(`/integrations/apps/${slug}`, { method: 'DELETE' }),
    createWebhook: (channelId: string, name: string) =>
      this.request('/integrations/webhooks/incoming', { method: 'POST', body: JSON.stringify({ channel_id: channelId, name }) }),
    createSlashCommand: (data: any) =>
      this.request('/integrations/slash-commands', { method: 'POST', body: JSON.stringify(data) }),
  };

  // ==================== NOTIFICATIONS ====================
  notifications = {
    list: () => this.request('/notifications'),
    registerPush: (platform: string, token: string, deviceId: string) =>
      this.request('/notifications/register-push', { method: 'POST', body: JSON.stringify({ platform, token, device_id: deviceId }) }),
    updatePreferences: (prefs: any) =>
      this.request('/notifications/preferences', { method: 'PUT', body: JSON.stringify(prefs) }),
    markAllRead: () => this.request('/notifications/mark-all-read', { method: 'POST' }),
  };
}

export const api = new ApiClient(BASE_URL);

class ApiError extends Error {
  constructor(message: string, public code: string, public status: number) {
    super(message);
  }
}
5.8 COMMAND PALETTE (Quick Switcher)
// apps/web/src/components/common/CommandPalette.tsx

'use client';

import { useState, useEffect, useMemo } from 'react';
import { useChannelsStore } from '@/stores/channels.store';
import { useUsersStore } from '@/stores/users.store';
import { api } from '@/lib/api-client';
import { Search, Hash, Lock, MessageSquare, Bot, FileText, ChevronRight } from 'lucide-react';
import { useRouter } from 'next/navigation';

export function CommandPalette({ open, onClose }: { open: boolean; onClose: () => void }) {
  const [query, setQuery] = useState('');
  const [activeIndex, setActiveIndex] = useState(0);
  const router = useRouter();
  const { channels } = useChannelsStore();
  const { users } = useUsersStore();

  const results = useMemo(() => {
    const q = query.toLowerCase();
    const items: SearchResult[] = [];

    // Canales
    channels.forEach(c => {
      if (c.name.toLowerCase().includes(q)) {
        items.push({
          id: c.id,
          type: 'channel',
          label: c.name,
          icon: c.type === 'private' ? <Lock /> : <Hash />,
          action: () => router.push(`/channel/${c.id}`),
        });
      }
    });

    // Usuarios
    users.forEach(u => {
      if (u.display_name.toLowerCase().includes(q) || u.email.toLowerCase().includes(q)) {
        items.push({
          id: u.id,
          type: 'user',
          label: u.display_name,
          sublabel: u.title,
          icon: <Avatar src={u.avatar_url} />,
          action: () => {/* abrir DM */},
        });
      }
    });

    // Búsqueda de mensajes (si query > 2 chars)
    if (q.length > 2) {
      // Debounced search
      items.push({
        id: 'search',
        type: 'search',
        label: `Search messages for "${query}"`,
        icon: <Search />,
        action: () => router.push(`/search?q=${encodeURIComponent(query)}`),
      });
    }

    return items;
  }, [query, channels, users]);

  // Keyboard navigation
  useEffect(() => {
    const handleKey = (e: KeyboardEvent) => {
      if (!open) return;
      if (e.key === 'ArrowDown') { e.preventDefault(); setActiveIndex(i => Math.min(i + 1, results.length - 1)); }
      if (e.key === 'ArrowUp') { e.preventDefault(); setActiveIndex(i => Math.max(i - 1, 0)); }
      if (e.key === 'Enter' && results[activeIndex]) { results[activeIndex].action(); onClose(); }
      if (e.key === 'Escape') { onClose(); }
    };
    window.addEventListener('keydown', handleKey);
    return () => window.removeEventListener('keydown', handleKey);
  }, [open, results, activeIndex]);

  if (!open) return null;

  return (
    <div className="fixed inset-0 z-50 flex items-start justify-center bg-black/50 pt-24" onClick={onClose}>
      <div
        className="w-full max-w-lg rounded-lg border border-slack-border bg-slack-sidebar shadow-2xl"
        onClick={e => e.stopPropagation()}
      >
        <input
          autoFocus
          value={query}
          onChange={e => { setQuery(e.target.value); setActiveIndex(0); }}
          placeholder="Search channels, people, messages..."
          className="w-full border-b border-slack-border bg-transparent px-4 py-3 text-sm outline-none"
        />
        <div className="max-h-96 overflow-y-auto py-2">
          {results.map((result, index) => (
            <button
              key={`${result.type}-${result.id}`}
              onClick={() => { result.action(); onClose(); }}
              onMouseEnter={() => setActiveIndex(index)}
              className={`flex w-full items-center gap-3 px-4 py-2 text-sm ${
                index === activeIndex ? 'bg-slack-hover' : ''
              }`}
            >
              <span className="text-slack-text-muted">{result.icon}</span>
              <span className="flex-1 text-left">{result.label}</span>
              {result.sublabel && (
                <span className="text-xs text-slack-text-muted">{result.sublabel}</span>
              )}
            </button>
          ))}
          {results.length === 0 && (
            <div className="px-4 py-8 text-center text-sm text-slack-text-muted">
              No results found
            </div>
          )}
        </div>
      </div>
    </div>
  );
}
5.9 DESKTOP APP (Tauri)
🔹 Configuración Tauri
// apps/desktop/src-tauri/src/main.rs

#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

use tauri::{Manager, WindowEvent};
use tauri_plugin_window_state::{WindowExt, StateFlags};

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_window_state::Builder::default().build())
        .plugin(tauri_plugin_deep_link::init())
        .plugin(tauri_plugin_notification::init())
        .plugin(tauri_plugin_autostart::init(
            tauri_plugin_autostart::MacosLauncher::LaunchAgent,
            None,
        ))
        .setup(|app| {
            // Deep link handler: chat://channel/uuid
            app.handle().plugin(
                tauri_plugin_deep_link::init(|app, link| {
                    if link.starts_with("chat://channel/") {
                        let channel_id = link.strip_prefix("chat://channel/").unwrap();
                        // Navegar al canal
                        app.emit_to("main", "deep-link", channel_id).unwrap();
                    }
                })
            )?;

            // Restaurar estado de ventana
            let window = app.get_window("main").unwrap();
            window.restore_state(StateFlags::all())?;

            Ok(())
        })
        .on_window_event(|window, event| {
            // Cerrar al tray en vez de salir
            if let WindowEvent::CloseRequested { api, .. } = event {
                window.hide().unwrap();
                api.prevent_close();
            }
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}
// apps/desktop/src-tauri/tauri.conf.json
{
  "productName": "ChatApp",
  "version": "1.0.0",
  "identifier": "com.chatapp.desktop",
  "build": {
    "frontendDist": "../dist",
    "devUrl": "http://localhost:3000",
    "beforeDevCommand": "npm run dev",
    "beforeBuildCommand": "npm run build"
  },
  "app": {
    "windows": [
      {
        "title": "ChatApp",
        "width": 1200,
        "height": 800,
        "minWidth": 600,
        "minHeight": 400,
        "resizable": true,
        "fullscreen": false,
        "decorations": true
      }
    ],
    "trayIcon": {
      "iconPath": "icons/tray.png",
      "menuOnLeftClick": true
    },
    "security": {
      "csp": "default-src 'self'; connect-src 'self' https://api.chatapp.com wss://ws.chatapp.com"
    }
  },
  "bundle": {
    "active": true,
    "targets": ["deb", "appimage", "msi", "app", "dmg"],
    "icon": ["icons/icon.png"]
  }
}
🔹 Desktop: Features nativos
// apps/desktop/src/components/DesktopFeatures.tsx

'use client';

import { useEffect } from 'react';
import { listen } from '@tauri-apps/api/event';
import { isRegistered, register, unregister } from '@tauri-apps/plugin-autostart';
import { sendNotification, requestPermission } from '@tauri-apps/plugin-notification';
import { api } from '@lib/api-client';
import { useSocket } from '@/hooks/useSocket';

export function DesktopFeatures() {
  const { socket } = useSocket();

  useEffect(() => {
    // 1. Auto-start on boot
    (async () => {
      const registered = await isRegistered();
      if (!registered) await register();
    })();

    // 2. Native notifications
    (async () => {
      const permission = await requestPermission();
      if (permission === 'granted') {
        socket?.on('notification', (data) => {
          sendNotification({
            title: data.title,
            body: data.body,
            icon: data.icon,
          });
        });
      }
    })();

    // 3. Deep links
    const unlisten = listen<string>('deep-link', (event) => {
      const channelId = event.payload;
      window.location.href = `/channel/${channelId}`;
    });

    return () => {
      unlisten.then(fn => fn());
    };
  }, [socket]);

  return null;
}
5.10 MOBILE APP (React Native)
🔹 Navegación principal
// apps/mobile/src/navigation/AppNavigator.tsx

import { NavigationContainer } from '@react-navigation/native';
import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
import { createNativeStackNavigator } from '@react-navigation/native-stack';

const Tab = createBottomTabNavigator();
const Stack = createNativeStackNavigator();

// Bottom tabs
function MainTabs() {
  return (
    <Tab.Navigator screenOptions={{ headerShown: false }}>
      <Tab.Screen
        name="Home"
        component={HomeScreen}
        options={{ tabBarIcon: ({ color }) => <Icon name="message" color={color} />, tabBarBadge: unreadCount }}
      />
      <Tab.Screen
        name="DMs"
        component={DMScreen}
        options={{ tabBarIcon: ({ color }) => <Icon name="mail" color={color} />, tabBarBadge: dmUnread }}
      />
      <Tab.Screen
        name="Activity"
        component={ActivityScreen}
        options={{ tabBarIcon: ({ color }) => <Icon name="activity" color={color} /> }}
      />
      <Tab.Screen
        name="Settings"
        component={SettingsScreen}
        options={{ tabBarIcon: ({ color }) => <Icon name="settings" color={color} /> }}
      />
    </Tab.Navigator>
  );
}

// Stack navigator
export function AppNavigator() {
  return (
    <NavigationContainer>
      <Stack.Navigator screenOptions={{ headerShown: false }}>
        <Stack.Screen name="Main" component={MainTabs} />
        <Stack.Screen name="Channel" component={ChannelScreen} options={{ presentation: 'card' }} />
        <Stack.Screen name="Thread" component={ThreadScreen} options={{ presentation: 'modal' }} />
        <Stack.Screen name="Huddle" component={HuddleScreen} options={{ presentation: 'fullScreenModal' }} />
        <Stack.Screen name="UserProfile" component={UserProfileScreen} options={{ presentation: 'modal' }} />
      </Stack.Navigator>
    </NavigationContainer>
  );
}
🔹 Mobile: Channel Screen
// apps/mobile/src/screens/ChannelScreen.tsx

import React, { useEffect, useRef } from 'react';
import { View, FlatList, TextInput, TouchableOpacity, KeyboardAvoidingView, Platform } from 'react-native';
import { useSocket } from '@/hooks/useSocket';
import { useMessages } from '@/hooks/useMessages';
import { MessageBubble } from '@/components/MessageBubble';
import { ChannelHeader } from '@/components/ChannelHeader';
import { Send, Paperclip, Smile } from 'lucide-react-native';

export function ChannelScreen({ route, navigation }: any) {
  const { channelId } = route.params;
  const { messages, loadMore, send } = useMessages(channelId);
  const [text, setText] = React.useState('');
  const flatListRef = useRef<FlatList>(null);

  // Auto-scroll al fondo
  useEffect(() => {
    if (messages.length > 0) {
      flatListRef.current?.scrollToEnd({ animated: true });
    }
  }, [messages.length]);

  const handleSend = () => {
    if (text.trim()) {
      send(text);
      setText('');
    }
  };

  return (
    <KeyboardAvoidingView
      behavior={Platform.OS === 'ios' ? 'padding' : undefined}
      style={{ flex: 1, backgroundColor: '#1a1a2e' }}
    >
      <ChannelHeader channelId={channelId} navigation={navigation} />

      <FlatList
        ref={flatListRef}
        data={messages}
        keyExtractor={(item) => item.id}
        renderItem={({ item, index }) => (
          <MessageBubble
            message={item}
            showAvatar={shouldShowAvatar(messages[index], messages[index - 1])}
            onReply={() => navigation.navigate('Thread', { messageId: item.id })}
          />
        )}
        onEndReachedThreshold={0.1}
        onEndReached={() => loadMore()}
        contentContainerStyle={{ paddingVertical: 10 }}
      />

      {/* Input bar */}
      <View style={{ flexDirection: 'row', alignItems: 'center', padding: 10, borderTopWidth: 1, borderTopColor: '#2a2a3e' }}>
        <TouchableOpacity onPress={() => {/* attach file */}}>
          <Paperclip size={24} color="#a0a0b0" />
        </TouchableOpacity>
        <TextInput
          value={text}
          onChangeText={setText}
          placeholder={`Message #${channelName}`}
          placeholderTextColor="#666"
          style={{
            flex: 1,
            marginHorizontal: 10,
            paddingVertical: 8,
            paddingHorizontal: 12,
            backgroundColor: '#2a2a3e',
            borderRadius: 8,
            color: '#fff',
          }}
        />
        <TouchableOpacity onPress={handleSend} disabled={!text.trim()}>
          <Send size={24} color={text.trim() ? '#1264a3' : '#666'} />
        </TouchableOpacity>
      </View>
    </KeyboardAvoidingView>
  );
}
🔹 Mobile: Push Notifications
// apps/mobile/src/lib/push-notifications.ts

import * as Notifications from 'expo-notifications';
import * as Device from 'expo-device';
import { Platform } from 'react-native';
import { api } from '@/lib/api-client';

export async function registerForPushNotifications() {
  if (!Device.isDevice) return;

  const { status: existingStatus } = await Notifications.getPermissionsAsync();
  let finalStatus = existingStatus;

  if (existingStatus !== 'granted') {
    const { status } = await Notifications.requestPermissionsAsync();
    finalStatus = status;
  }

  if (finalStatus !== 'granted') return;

  const token = (await Notifications.getExpoPushTokenAsync()).data;
  const platform = Platform.OS;

  // Registrar token en el backend
  await api.notifications.registerPush(platform, token, Device.deviceName || '');

  // Configurar handler de notificaciones
  Notifications.setNotificationHandler({
    handleNotification: async () => ({
      shouldShowAlert: true,
      shouldPlaySound: true,
      shouldSetBadge: true,
    }),
  });

  // Listener para taps en notificación
  Notifications.addNotificationResponseReceivedListener((response) => {
    const { channelId, messageId } = response.notification.request.content.data;
    // Navegar al canal/mensaje
    navigationRef.navigate('Channel', { channelId });
  });
}
5.11 KEYBOARD SHORTCUTS (Web/Desktop)
// apps/web/src/hooks/useKeyboardShortcuts.ts

'use client';

import { useEffect } from 'react';
import { useChannelsStore } from '@/stores/channels.store';
import { useUIStore } from '@/stores/ui.store';

export function useKeyboardShortcuts() {
  const { channels, setActiveChannel } = useChannelsStore();
  const { toggleCommandPalette, toggleRightPanel } = useUIStore();

  useEffect(() => {
    const handleKey = (e: KeyboardEvent) => {
      const isMod = e.metaKey || e.ctrlKey;

      // Cmd/Ctrl + K → Command Palette (Quick Switcher)
      if (isMod && e.key === 'k') {
        e.preventDefault();
        toggleCommandPalette();
      }

      // Cmd/Ctrl + \ → Toggle right panel
      if (isMod && e.key === '\\') {
        e.preventDefault();
        toggleRightPanel();
      }

      // Cmd/Ctrl + / → Show shortcuts help
      if (isMod && e.key === '/') {
        e.preventDefault();
        showShortcutsHelp();
      }

      // ↑ → Edit last message
      if (e.key === 'ArrowUp' && noModifier(e) && isInputFocused()) {
        e.preventDefault();
        editLastMessage();
      }

      // Esc → Close modals/panels
      if (e.key === 'Escape') {
        closeTopmostModal();
      }

      // Alt + ↑/↓ → Navigate channels
      if (e.altKey && e.key === 'ArrowUp') {
        e.preventDefault();
        navigateChannel(-1);
      }
      if (e.altKey && e.key === 'ArrowDown') {
        e.preventDefault();
        navigateChannel(1);
      }

      // Shift + Esc → Mark all as read
      if (e.shiftKey && e.key === 'Escape') {
        e.preventDefault();
        markAllAsRead();
      }
    };

    window.addEventListener('keydown', handleKey);
    return () => window.removeEventListener('keydown', handleKey);
  }, [channels]);

  function navigateChannel(direction: number) {
    const currentIndex = channels.findIndex(c => c.id === activeChannelId);
    const newIndex = currentIndex + direction;
    if (newIndex >= 0 && newIndex < channels.length) {
      setActiveChannel(channels[newIndex].id);
    }
  }
}

// Tabla completa de shortcuts:
const SHORTCUTS = {
  'Cmd/Ctrl + K':     'Quick switcher (buscar canales, personas, mensajes)',
  'Cmd/Ctrl + \\':    'Toggle right panel',
  'Cmd/Ctrl + /':     'Show keyboard shortcuts',
  'Cmd/Ctrl + Z':     'Undo last action',
  'Cmd/Ctrl + Shift + Z': 'Redo',
  'Cmd/Ctrl + B':     'Bold text in input',
  'Cmd/Ctrl + I':     'Italic text in input',
  'Cmd/Ctrl + Shift + X': 'Strikethrough',
  'Cmd/Ctrl + Shift + C': 'Code block',
  'Cmd/Ctrl + Shift + 9': 'Quote',
  'Cmd/Ctrl + U':     'Upload file',
  'Cmd/Ctrl + Shift + L': 'Insert link',
  'Cmd/Ctrl + Shift + M': 'Mention (@user)',
  'Cmd/Ctrl + Shift + H': 'Channel link (#channel)',
  'Enter':            'Send message',
  'Shift + Enter':    'New line',
  '↑ (in input)':     'Edit last message',
  'Esc':              'Close modal/panel/cancel edit',
  'Shift + Esc':      'Mark all as read',
  'Alt + ↑':          'Previous channel',
  'Alt + ↓':          'Next channel',
  'Alt + Shift + ↑':  'Previous unread channel',
  'Alt + Shift + ↓':  'Next unread channel',
  'Cmd/Ctrl + [':     'Previous channel in history',
  'Cmd/Ctrl + ]':     'Next channel in history',
  'Cmd/Ctrl + ,':     'Open preferences',
  'Cmd/Ctrl + .':     'Open channel details (right panel)',
  'Cmd/Ctrl + 0':     'Reset zoom',
  'Cmd/Ctrl + +':     'Zoom in',
  'Cmd/Ctrl + -':     'Zoom out',
};
5.12 THEME SYSTEM (Slack-like dark/light mode)
/* apps/web/src/app/globals.css */

@import 'tailwindcss';
@import '@radix-ui/colors';

/* ============ DARK THEME (default) ============ */
:root, .dark {
  --slack-bg: #1a1a2e;
  --slack-sidebar: #19171d;
  --slack-panel: #1e1d24;
  --slack-input: #2a2a3e;
  --slack-border: #2d2d3f;
  --slack-hover: #2a2a3e;
  --slack-active: #1264a3;
  --slack-text: #d1d1e0;
  --slack-text-muted: #8b8b9e;
  --slack-primary: #1264a3;
  --slack-primary-hover: #0d4f8a;
  --slack-mention: #f85349;
  --slack-unread: #1264a3;
  --slack-online: #2bac76;
  --slack-away: #ecb22a;
  --slack-dnd: #e01e5a;
  --slack-offline: #616061;
}

/* ============ LIGHT THEME ============ */
.light {
  --slack-bg: #ffffff;
  --slack-sidebar: #f8f8f8;
  --slack-panel: #f4f4f4;
  --slack-input: #ffffff;
  --slack-border: #e1e1e1;
  --slack-hover: #f0f0f0;
  --slack-active: #e8f0fe;
  --slack-text: #1d1c1d;
  --slack-text-muted: #616061;
  --slack-primary: #1264a3;
  --slack-primary-hover: #0d4f8a;
  --slack-mention: #e01e5a;
  --slack-unread: #1264a3;
  --slack-online: #2bac76;
  --slack-away: #ecb22a;
  --slack-dnd: #e01e5a;
  --slack-offline: #b9b9b9;
}

/* ============ SLACK FONT ============ */
body {
  font-family: 'Lato', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
  font-size: 15px;
  background-color: var(--slack-bg);
  color: var(--slack-text);
}

/* ============ SCROLLBAR ============ */
.scrollbar-thin::-webkit-scrollbar {
  width: 6px;
  height: 6px;
}
.scrollbar-thin::-webkit-scrollbar-track {
  background: transparent;
}
.scrollbar-thin::-webkit-scrollbar-thumb {
  background: var(--slack-border);
  border-radius: 3px;
}
.scrollbar-thin::-webkit-scrollbar-thumb:hover {
  background: var(--slack-text-muted);
}

/* ============ ANIMATIONS ============ */
@keyframes slide-in-right {
  from { transform: translateX(100%); opacity: 0; }
  to { transform: translateX(0); opacity: 1; }
}
@keyframes fade-in {
  from { opacity: 0; }
  to { opacity: 1; }
}
@keyframes pulse-mention {
  0%, 100% { background-color: var(--slack-mention); }
  50% { background-color: transparent; }
}

.animate-slide-in-right { animation: slide-in-right 0.2s ease-out; }
.animate-fade-in { animation: fade-in 0.15s ease-out; }
5.13 TIPOS COMPARTIDOS (TypeScript)
// packages/types/src/index.ts

export interface User {
  id: string;
  email: string;
  display_name: string;
  real_name?: string;
  avatar_url?: string;
  title?: string;
  bio?: string;
  phone?: string;
  timezone: string;
  locale: string;
  status_text?: string;
  status_emoji?: string;
  status_expires?: string;
  presence: 'online' | 'away' | 'dnd' | 'offline';
  is_bot: boolean;
  color?: string;
}

export interface Workspace {
  id: string;
  name: string;
  domain: string;
  logo_url?: string;
  plan: 'free' | 'pro' | 'business' | 'enterprise';
  member_count: number;
  settings?: WorkspaceSettings;
}

export interface Channel {
  id: string;
  workspace_id: string;
  name: string;
  type: 'public' | 'private' | 'group_dm' | 'dm' | 'shared';
  topic?: string;
  purpose?: string;
  is_archived: boolean;
  is_default: boolean;
  is_read_only: boolean;
  member_count: number;
  unread_count: number;
  unread_mention_count: number;
  is_muted: boolean;
  notification_pref: 'all' | 'mentions' | 'nothing';
  last_message?: {
    text: string;
    user_id: string;
    ts: string;
  };
  last_message_at?: string;
  last_read_ts?: string;
}

export interface Message {
  id: string;
  channel_id: string;
  user_id: string;
  text: string;
  blocks?: Block[];
  attachments?: Attachment[];
  mentioned_users?: string[];
  files?: FileInfo[];
  link_previews?: LinkPreview[];
  reactions?: Reaction[];
  thread_root_id?: string | null;
  reply_count: number;
  reply_users_count: number;
  is_edited: boolean;
  is_deleted: boolean;
  is_pinned: boolean;
  is_system: boolean;
  system_type?: string;
  edited_at?: string;
  edited_by?: string;
  ts: string;
  created_at: string;
}

export interface Reaction {
  emoji: string;
  count: number;
  users: string[];
}

export interface Block {
  type: 'section' | 'divider' | 'image' | 'actions' | 'context' | 'header' | 'file' | 'input';
  text?: TextObject;
  fields?: TextObject[];
  accessory?: InteractiveElement;
  elements?: InteractiveElement[];
  image_url?: string;
  alt_text?: string;
  block_id?: string;
}

export interface TextObject {
  type: 'plain_text' | 'mrkdwn';
  text: string;
  emoji?: boolean;
}

export interface InteractiveElement {
  type: 'button' | 'select' | 'datepicker' | 'overflow' | 'radio' | 'checkbox';
  action_id: string;
  text?: TextObject;
  value?: string;
  style?: 'primary' | 'danger';
  options?: Option[];
}

export interface FileInfo {
  id: string;
  filename: string;
  file_type: string;
  mime_type: string;
  size_bytes: number;
  url: string;
  thumbnail_url?: string;
  image_width?: number;
  image_height?: number;
}

export interface LinkPreview {
  url: string;
  title: string;
  description: string;
  image?: string;
  favicon?: string;
}

// WebSocket Events
export interface MessageEvent {
  id: string;
  channel_id: string;
  user_id: string;
  text: string;
  blocks?: Block[];
  mentioned_users?: string[];
  files?: FileInfo[];
  ts: string;
}

export interface PresenceEvent {
  user_id: string;
  presence: 'online' | 'away' | 'dnd' | 'offline';
}

export interface TypingEvent {
  user_id: string;
  channel_id: string;
  is_typing: boolean;
}

export interface NotificationEvent {
  id: string;
  type: 'mention' | 'dm' | 'thread_reply' | 'channel_message';
  message_id: string;
  channel_id: string;
  text: string;
  user_id: string;
}


📌 PARTE 6: INTEGRACIONES, AUTOMATIZACIÓN, IA, SEGURIDAD Y ADMIN
6.1 SISTEMA DE INTEGRACIONES (APP DIRECTORY)
🔹 Arquitectura de Integraciones
┌─────────────────────────────────────────────────────────────┐
│                    SISTEMA DE INTEGRACIONES                   │
│                                                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │ OAuth    │  │ Incoming │  │ Outgoing │  │ Slash    │   │
│  │ Flow     │  │ Webhooks │  │ Webhooks │  │ Commands │   │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘   │
│                                                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │ Block    │  │ Event    │  │ Bot      │  │ Modal    │   │
│  │ Kit API  │  │ Subscr.  │  │ Users    │  │ Interact.│   │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘   │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐   │
│  │              APP DIRECTORY (Marketplace)              │   │
│  │  2,600+ apps: Google Drive, GitHub, Jira, Zoom, etc  │   │
│  └──────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
🔹 OAuth 2.0 Flow para instalar apps externas
// apps/api/src/modules/integrations/oauth.service.ts

@Injectable()
export class OAuthService {
  constructor(
    private prisma: PrismaService,
    private encryptionService: EncryptionService,
  ) {}

  // Paso 1: Iniciar OAuth flow
  async initiateInstall(workspaceId: string, appSlug: string, userId: string) {
    const app = await this.getAppConfig(appSlug);

    const state = this.generateStateToken({
      workspaceId,
      appSlug,
      userId,
      scopes: app.scopes,
    });

    const authUrl = this.buildAuthUrl(app, state);

    return { oauth_url: authUrl, state };
  }

  // Paso 2: Callback del proveedor externo
  async handleCallback(code: string, state: string) {
    const stateData = this.verifyStateToken(state);
    const app = await this.getAppConfig(stateData.appSlug);

    // Intercambiar code por access_token
    const tokenResponse = await axios.post(app.token_url, {
      grant_type: 'authorization_code',
      code,
      client_id: app.client_id,
      client_secret: app.client_secret,
      redirect_uri: app.redirect_uri,
    });

    const { access_token, refresh_token, expires_in } = tokenResponse.data;

    // Guardar app instalada
    const installedApp = await this.prisma.app.create({
      data: {
        workspace_id: stateData.workspaceId,
        app_name: app.name,
        app_slug: stateData.appSlug,
        icon_url: app.icon_url,
        developer_name: app.developer_name,
        scopes: stateData.scopes,
        oauth_token_encrypted: this.encryptionService.encrypt(access_token),
        oauth_refresh_token_encrypted: refresh_token
          ? this.encryptionService.encrypt(refresh_token)
          : null,
        installed_by: stateData.userId,
        is_active: true,
        config: {},
      },
    });

    // Crear bot user para esta app
    await this.createBotUser(stateData.workspaceId, installedApp.id, app);

    // Publicar evento de instalación
    await this.eventBus.publish('app.installed', {
      workspaceId: stateData.workspaceId,
      appSlug: stateData.appSlug,
      installedBy: stateData.userId,
    });

    return installedApp;
  }

  // Paso 3: Refresh token cuando expira
  async refreshAppToken(appId: string) {
    const app = await this.prisma.app.findUnique({ where: { id: appId } });
    if (!app || !app.oauth_refresh_token_encrypted) return;

    const refreshToken = this.encryptionService.decrypt(app.oauth_refresh_token_encrypted);
    const appConfig = await this.getAppConfig(app.app_slug);

    const tokenResponse = await axios.post(appConfig.token_url, {
      grant_type: 'refresh_token',
      refresh_token: refreshToken,
      client_id: appConfig.client_id,
      client_secret: appConfig.client_secret,
    });

    await this.prisma.app.update({
      where: { id: appId },
      data: {
        oauth_token_encrypted: this.encryptionService.encrypt(tokenResponse.data.access_token),
        oauth_refresh_token_encrypted: tokenResponse.data.refresh_token
          ? this.encryptionService.encrypt(tokenResponse.data.refresh_token)
          : undefined,
      },
    });
  }
}
🔹 Incoming Webhooks (recibir datos de apps externas)
// apps/api/src/modules/integrations/incoming-webhook.controller.ts

@Controller('hooks/:token')
export class IncomingWebhookController {
  constructor(
    private messageService: MessageService,
    private webhookService: WebhookService,
  ) {}

  @Post()
  @HttpCode(200)
  async handleWebhook(
    @Param('token') token: string,
    @Body() body: IncomingWebhookPayload,
  ) {
    // 1. Validar webhook
    const webhook = await this.webhookService.findByToken(token);
    if (!webhook || !webhook.is_active) {
      throw new NotFoundException('Webhook not found');
    }

    // 2. Construir mensaje
    const messageData: CreateMessageDto = {
      text: body.text,
      blocks: body.blocks,
      attachments: body.attachments,
    };

    // 3. Si no se especifica canal, usar el canal del webhook
    const channelId = body.channel || webhook.channel_id;

    // 4. Enviar como bot user
    const message = await this.messageService.createMessage({
      channelId,
      botId: webhook.app?.bot_user_id,
      text: messageData.text,
      blocks: messageData.blocks,
      attachments: messageData.attachments,
    });

    return { ok: true, message_id: message.id };
  }
}

interface IncomingWebhookPayload {
  text?: string;
  blocks?: Block[];
  attachments?: Attachment[];
  channel?: string;  // Override del canal (opcional)
}
🔹 Event Subscriptions (enviar eventos a apps externas)
// apps/api/src/modules/integrations/event-subscriptions.service.ts

@Injectable()
export class EventSubscriptionsService {
  constructor(
    private prisma: PrismaService,
    private httpService: HttpService,
  ) {}

  // Este método se llama cada vez que ocurre un evento en el sistema
  async dispatchEvent(event: SystemEvent) {
    // Buscar todas las suscripciones activas para este evento
    const subscriptions = await this.prisma.eventSubscription.findMany({
      where: {
        workspace_id: event.workspaceId,
        is_active: true,
        event_types: { has: event.type },
      },
      include: { app: true },
    });

    for (const sub of subscriptions) {
      // Enviar webhook con HMAC signing
      const payload = {
        type: 'event_callback',
        event: {
          type: event.type,
          ...event.data,
          ts: event.timestamp,
        },
        workspace_id: event.workspaceId,
      };

      const signature = this.signPayload(JSON.stringify(payload), sub.secret);

      try {
        await this.httpService.post(sub.callback_url, payload, {
          headers: {
            'X-ChatApp-Signature': signature,
            'X-ChatApp-Request-Timestamp': Math.floor(Date.now() / 1000).toString(),
            'Content-Type': 'application/json',
          },
          timeout: 5000, // 5s timeout
        });
      } catch (error) {
        console.error(`Failed to dispatch event to ${sub.callback_url}:`, error);
        // Reintentar con backoff exponencial
        await this.scheduleRetry(sub.id, payload);
      }
    }
  }

  private signPayload(payload: string, secret: string): string {
    const timestamp = Math.floor(Date.now() / 1000);
    const sigBase = `${timestamp}:${payload}`;
    return crypto.createHmac('sha256', secret).update(sigBase).digest('hex');
  }

  // Eventos que se pueden suscribir:
  // message.channels, message.groups, message.im, message.mpim
  // channel_created, channel_archive, channel_unarchive, channel_rename
  // team_join, team_rename, team_domain_change
  // user_change, user_status_change
  // reaction_added, reaction_removed
  // pin_added, pin_removed
  // file_created, file_shared, file_deleted
  // app_mention, app_uninstalled
  // huddle_started, huddle_ended
}
🔹 Interactive Components (procesar clicks en botones, modals)
// apps/api/src/modules/integrations/interactive.controller.ts

@Controller('integrations/interactive')
export class InteractiveController {
  constructor(
    private prisma: PrismaService,
    private httpService: HttpService,
  ) {}

  @Post()
  async handleInteraction(@Body() payload: any) {
    const type = payload.type;

    switch (type) {
      case 'block_actions':
        // Usuario hizo click en un botón/seleccionó una opción
        return this.handleBlockAction(payload);

      case 'view_submission':
        // Usuario envió un modal (form)
        return this.handleViewSubmission(payload);

      case 'view_closed':
        // Usuario cerró un modal
        return this.handleViewClosed(payload);

      case 'shortcut':
        // Usuario usó un shortcut
        return this.handleShortcut(payload);
    }
  }

  private async handleBlockAction(payload: BlockActionPayload) {
    const action = payload.actions[0];
    const appId = payload.api_app_id;

    // Buscar la app
    const app = await this.prisma.app.findFirst({
      where: { app_slug: appId, workspace_id: payload.team.id },
    });

    // Reenviar la interacción a la URL de la app
    await this.httpService.post(app.interactive_callback_url, payload);

    // Si la acción requiere una respuesta inmediata
    if (action.type === 'button') {
      // Puede devolver: actualizar mensaje, abrir modal, o nada
      return {
        response_action: 'update',  // o 'push' (modal), 'clear', 'errors'
        // view: { ...nuevo modal... }
      };
    }

    return { ok: true };
  }
}
🔹 Catálogo de Apps preconfiguradas
// apps/api/src/modules/integrations/app-registry.ts

export const APP_REGISTRY = [
  {
    slug: 'google-drive',
    name: 'Google Drive',
    description: 'Share and collaborate on files from Google Drive',
    icon_url: '/icons/google-drive.png',
    categories: ['productivity', 'file-storage'],
    scopes: ['files:read', 'files:write'],
    oauth_config: {
      auth_url: 'https://accounts.google.com/o/oauth2/auth',
      token_url: 'https://oauth2.googleapis.com/token',
      client_id: process.env.GOOGLE_DRIVE_CLIENT_ID,
      client_secret: process.env.GOOGLE_DRIVE_CLIENT_SECRET,
      redirect_uri: `${process.env.API_URL}/integrations/oauth/google-drive/callback`,
      scopes: ['https://www.googleapis.com/auth/drive.readonly'],
    },
  },
  {
    slug: 'github',
    name: 'GitHub',
    description: 'Track code changes, pull requests, and issues',
    icon_url: '/icons/github.png',
    categories: ['developer', 'productivity'],
    scopes: ['chat:write', 'channels:read'],
    oauth_config: {
      auth_url: 'https://github.com/login/oauth/authorize',
      token_url: 'https://github.com/login/oauth/access_token',
      client_id: process.env.GITHUB_CLIENT_ID,
      client_secret: process.env.GITHUB_CLIENT_SECRET,
      redirect_uri: `${process.env.API_URL}/integrations/oauth/github/callback`,
      scopes: ['repo', 'notifications'],
    },
    slash_commands: ['/github', '/issue', '/pr'],
    event_types: ['pull_request_opened', 'issue_created', 'push'],
  },
  {
    slug: 'jira',
    name: 'Jira',
    description: 'Track issues and sprints from Jira',
    icon_url: '/icons/jira.png',
    categories: ['project-management', 'developer'],
    scopes: ['chat:write', 'commands'],
    oauth_config: {
      auth_url: 'https://auth.atlassian.com/authorize',
      token_url: 'https://auth.atlassian.com/oauth/token',
      client_id: process.env.JIRA_CLIENT_ID,
      client_secret: process.env.JIRA_CLIENT_SECRET,
      redirect_uri: `${process.env.API_URL}/integrations/oauth/jira/callback`,
    },
  },
  {
    slug: 'zoom',
    name: 'Zoom',
    description: 'Start and join Zoom meetings from any channel',
    icon_url: '/icons/zoom.png',
    categories: ['communication', 'video'],
    scopes: ['chat:write', 'commands'],
  },
  {
    slug: 'google-calendar',
    name: 'Google Calendar',
    description: 'Get reminders and update your status based on calendar events',
    icon_url: '/icons/google-calendar.png',
    categories: ['productivity', 'scheduling'],
  },
  {
    slug: 'asana',
    name: 'Asana',
    description: 'Create and assign tasks without leaving the conversation',
    icon_url: '/icons/asana.png',
    categories: ['project-management'],
  },
  {
    slug: 'trello',
    name: 'Trello',
    description: 'Manage Trello cards and boards from Slack',
    icon_url: '/icons/trello.png',
    categories: ['project-management'],
  },
  {
    slug: 'dropbox',
    name: 'Dropbox',
    description: 'Share Dropbox files directly in conversations',
    icon_url: '/icons/dropbox.png',
    categories: ['file-storage'],
  },
  {
    slug: 'salesforce',
    name: 'Salesforce',
    description: 'Bring CRM data into conversations to align teams',
    icon_url: '/icons/salesforce.png',
    categories: ['crm', 'sales'],
  },
  {
    slug: 'zendesk',
    name: 'Zendesk',
    description: 'Manage support tickets from channels',
    icon_url: '/icons/zendesk.png',
    categories: ['customer-support'],
  },
  {
    slug: 'figma',
    name: 'Figma',
    description: 'Share and preview Figma designs in conversations',
    icon_url: '/icons/figma.png',
    categories: ['design'],
  },
  {
    slug: 'notion',
    name: 'Notion',
    description: 'Connect Notion pages and databases',
    icon_url: '/icons/notion.png',
    categories: ['productivity', 'knowledge-base'],
  },
  // ... 2,600+ apps más
];
6.2 WORKFLOW BUILDER (AUTOMATIZACIÓN NO-CODE)
🔹 Arquitectura del Workflow Engine
┌─────────────────────────────────────────────────────────────┐
│                  WORKFLOW ENGINE                             │
│                                                              │
│  TRIGGERS          STEPS (State Machine)         OUTPUTS     │
│  ┌──────────┐      ┌──────────────┐              ┌────────┐│
│  │ Emoji    │─────▶│ Step 1:      │─────────────▶│ Send   ││
│  │ reaction │      │ Send message │              │ msg    ││
│  └──────────┘      └──────────────┘              └────────┘│
│  ┌──────────┐      ┌──────────────┐              ┌────────┐│
│  │ Channel  │─────▶│ Step 2:      │─────────────▶│ Create ││
│  │ join     │      │ HTTP request │              │ task   ││
│  └──────────┘      └──────────────┘              └────────┘│
│  ┌──────────┐      ┌──────────────┐              ┌────────┐│
│  │ Schedule │─────▶│ Step 3:      │─────────────▶│ Update ││
│  │ (cron)   │      │ Condition    │              │ status ││
│  └──────────┘      └──────────────┘              └────────┘│
│  ┌──────────┐      ┌──────────────┐                         │
│  │ Form     │─────▶│ Step 4:      │                         │
│  │ submit   │      │ Create task  │                         │
│  └──────────┘      └──────────────┘                         │
│  ┌──────────┐                                               │
│  │ Webhook  │                                               │
│  │ externo  │                                               │
│  └──────────┘                                               │
└─────────────────────────────────────────────────────────────┘
🔹 Workflow Executor
// apps/workers/src/processors/workflow-executor.processor.ts

import { Processor, WorkerHost, Job } from 'bullmq';
import { Injectable, Logger } from '@nestjs/common';

@Processor('workflows', { concurrency: 20 })
@Injectable()
export class WorkflowExecutorProcessor extends WorkerHost {
  private readonly logger = new Logger(WorkflowExecutorProcessor.name);

  constructor(
    private prisma: PrismaService,
    private messageService: MessageService,
    private channelService: ChannelService,
    private httpService: HttpService,
    private pubsubService: PubSubService,
  ) {
    super();
  }

  async process(job: Job<WorkflowTriggerJob>) {
    const { workflowId, triggerData } = job.data;

    // 1. Cargar workflow
    const workflow = await this.prisma.workflow.findUnique({
      where: { id: workflowId },
    });

    if (!workflow || workflow.status !== 'active') return;

    // 2. Crear registro de ejecución
    const execution = await this.prisma.workflowExecution.create({
      data: {
        workflow_id: workflowId,
        trigger_data: triggerData,
        context: { trigger: triggerData },
        status: 'running',
        started_at: new Date(),
      },
    });

    try {
      // 3. Ejecutar cada paso en orden
      let context = { trigger: triggerData, variables: {} };

      for (let i = 0; i < workflow.steps.length; i++) {
        const step = workflow.steps[i];
        this.logger.log(`Executing step ${i}: ${step.type}`);

        const result = await this.executeStep(step, context, workflow.workspace_id);

        // Merge result into context
        context = { ...context, ...result, stepIndex: i };

        // Actualizar progreso
        await this.prisma.workflowExecution.update({
          where: { id: execution.id },
          data: { current_step: i + 1, context },
        });

        // Si el paso es una condición y no se cumple, salir
        if (step.type === 'condition' && !result.conditionMet) {
          this.logger.log(`Condition not met, stopping workflow`);
          break;
        }
      }

      // 4. Marcar como completado
      await this.prisma.workflowExecution.update({
        where: { id: execution.id },
        data: { status: 'completed', completed_at: new Date() },
      });

      // 5. Incrementar contador
      await this.prisma.workflow.update({
        where: { id: workflowId },
        data: {
          execution_count: { increment: 1 },
          last_executed: new Date(),
        },
      });

    } catch (error) {
      this.logger.error(`Workflow ${workflowId} failed:`, error);

      await this.prisma.workflowExecution.update({
        where: { id: execution.id },
        data: {
          status: 'failed',
          error_message: error.message,
          completed_at: new Date(),
        },
      });

      await this.prisma.workflow.update({
        where: { id: workflowId },
        data: { failure_count: { increment: 1 } },
      });
    }
  }

  private async executeStep(
    step: WorkflowStep,
    context: any,
    workspaceId: string,
  ): Promise<any> {
    const config = this.interpolateVariables(step.config, context);

    switch (step.type) {
      // ==================== MENSAJES ====================
      case 'send_message':
        return this.executeSendMessage(config, workspaceId);

      case 'send_dm':
        return this.executeSendDM(config, workspaceId);

      case 'send_ephemeral':
        return this.executeSendEphemeral(config);

      // ==================== CANALES ====================
      case 'create_channel':
        return this.executeCreateChannel(config, workspaceId);

      case 'add_to_channel':
        return this.executeAddToChannel(config, workspaceId);

      case 'archive_channel':
        return this.executeArchiveChannel(config);

      // ==================== TAREAS / LISTS ====================
      case 'create_list_item':
        return this.executeCreateListItem(config);

      case 'update_list_item':
        return this.executeUpdateListItem(config);

      // ==================== HTTP ====================
      case 'http_request':
        return this.executeHttpRequest(config);

      // ==================== CONTROL DE FLUJO ====================
      case 'condition':
        return this.executeCondition(config, context);

      case 'delay':
        return this.executeDelay(config);

      case 'loop':
        return this.executeLoop(config, context);

      // ==================== VARIABLES ====================
      case 'set_variable':
        return this.executeSetVariable(config, context);

      case 'format_date':
        return this.executeFormatDate(config, context);

      // ==================== ARCHIVOS ====================
      case 'upload_file':
        return this.executeUploadFile(config, workspaceId);

      // ==================== IA ====================
      case 'ai_summarize':
        return this.executeAISummarize(config, workspaceId);

      // ==================== USUARIOS ====================
      case 'update_status':
        return this.executeUpdateStatus(config);

      default:
        throw new Error(`Unknown step type: ${step.type}`);
    }
  }

  // ==================== IMPLEMENTACIONES DE PASOS ====================

  private async executeSendMessage(config: any, workspaceId: string) {
    const message = await this.messageService.createMessage({
      channelId: config.channel_id,
      botId: 'workflow-bot-uuid',
      text: config.text,
      blocks: config.blocks,
    });
    return { last_message_id: message.id };
  }

  private async executeHttpRequest(config: any) {
    const response = await firstValueFrom(
      this.httpService.request({
        method: config.method || 'POST',
        url: config.url,
        headers: config.headers,
        data: config.body,
        timeout: 10000,
      })
    );
    return { http_response: response.data, http_status: response.status };
  }

  private async executeCondition(config: any, context: any) {
    const leftValue = this.resolveValue(config.left, context);
    const rightValue = this.resolveValue(config.right, context);
    const operator = config.operator; // ==, !=, >, <, contains, starts_with, ends_with

    let conditionMet = false;
    switch (operator) {
      case '==': conditionMet = leftValue === rightValue; break;
      case '!=': conditionMet = leftValue !== rightValue; break;
      case '>': conditionMet = leftValue > rightValue; break;
      case '<': conditionMet = leftValue < rightValue; break;
      case 'contains': conditionMet = String(leftValue).includes(String(rightValue)); break;
      case 'starts_with': conditionMet = String(leftValue).startsWith(String(rightValue)); break;
      case 'ends_with': conditionMet = String(leftValue).endsWith(String(rightValue)); break;
      case 'is_empty': conditionMet = !leftValue || leftValue.length === 0; break;
      case 'is_not_empty': conditionMet = leftValue && leftValue.length > 0; break;
    }

    return { conditionMet };
  }

  // Interpolar variables: "Hello ${trigger.user_name}!" → "Hello John!"
  private interpolateVariables(config: any, context: any): any {
    if (typeof config === 'string') {
      return config.replace(/\${([^}]+)}/g, (_, path) => {
        return this.resolvePath(path.trim(), context) ?? '';
      });
    }
    if (Array.isArray(config)) {
      return config.map(item => this.interpolateVariables(item, context));
    }
    if (typeof config === 'object' && config !== null) {
      const result: any = {};
      for (const [key, value] of Object.entries(config)) {
        result[key] = this.interpolateVariables(value, context);
      }
      return result;
    }
    return config;
  }

  private resolvePath(path: string, context: any): any {
    return path.split('.').reduce((obj, key) => obj?.[key], context);
  }
}
🔹 Triggers Dispatcher
// apps/api/src/modules/workflows/trigger-dispatcher.service.ts

@Injectable()
export class TriggerDispatcherService {
  constructor(
    private prisma: PrismaService,
    private queue: Queue,
  ) {}

  // Cuando un usuario reacciona con un emoji específico
  async onEmojiReaction(data: {
    messageId: string;
    channelId: string;
    userId: string;
    emoji: string;
    workspaceId: string;
  }) {
    const workflows = await this.prisma.workflow.findMany({
      where: {
        workspace_id: data.workspaceId,
        status: 'active',
        trigger_type: 'emoji_reaction',
      },
    });

    for (const wf of workflows) {
      const triggerConfig = wf.trigger_config;
      if (triggerConfig.emoji === data.emoji) {
        await this.queue.add('execute', {
          workflowId: wf.id,
          triggerData: {
            user_id: data.userId,
            user_name: await this.getUserName(data.userId),
            channel_id: data.channelId,
            message_id: data.messageId,
            emoji: data.emoji,
            timestamp: new Date().toISOString(),
          },
        });
      }
    }
  }

  // Cuando un usuario se une a un canal
  async onChannelJoin(data: {
    channelId: string;
    userId: string;
    workspaceId: string;
  }) {
    const workflows = await this.prisma.workflow.findMany({
      where: {
        workspace_id: data.workspaceId,
        status: 'active',
        trigger_type: 'channel_join',
      },
    });

    for (const wf of workflows) {
      const config = wf.trigger_config;
      if (!config.channel_id || config.channel_id === data.channelId) {
        await this.queue.add('execute', {
          workflowId: wf.id,
          triggerData: {
            user_id: data.userId,
            user_name: await this.getUserName(data.userId),
            channel_id: data.channelId,
            channel_name: await this.getChannelName(data.channelId),
          },
        });
      }
    }
  }

  // Cuando se envía un formulario
  async onFormSubmission(data: {
    formId: string;
    userId: string;
    responses: Record<string, any>;
    workspaceId: string;
  }) {
    const workflows = await this.prisma.workflow.findMany({
      where: {
        workspace_id: data.workspaceId,
        status: 'active',
        trigger_type: 'form_submission',
        trigger_config: { path: ['form_id'], equals: data.formId },
      },
    });

    for (const wf of workflows) {
      await this.queue.add('execute', {
        workflowId: wf.id,
        triggerData: {
          user_id: data.userId,
          user_name: await this.getUserName(data.userId),
          form_responses: data.responses,
        },
      });
    }
  }

  // Webhook externo
  async onExternalWebhook(data: {
    webhookToken: string;
    payload: any;
  }) {
    const workflows = await this.prisma.workflow.findMany({
      where: {
        status: 'active',
        trigger_type: 'webhook',
        trigger_config: { path: ['token'], equals: data.webhookToken },
      },
    });

    for (const wf of workflows) {
      await this.queue.add('execute', {
        workflowId: wf.id,
        triggerData: { webhook_payload: data.payload },
      });
    }
  }

  // Scheduled (cron) - ejecutado por un scheduler cada minuto
  async onScheduled() {
    const now = new Date();
    const workflows = await this.prisma.workflow.findMany({
      where: { status: 'active', trigger_type: 'schedule' },
    });

    for (const wf of workflows) {
      const config = wf.trigger_config;
      // Verificar si el cron pattern coincide con ahora
      if (this.matchesCron(config.cron, now)) {
        await this.queue.add('execute', {
          workflowId: wf.id,
          triggerData: {
            timestamp: now.toISOString(),
            day: now.toLocaleDateString('en-US', { weekday: 'long' }),
          },
        });
      }
    }
  }

  // Slash command
  async onSlashCommand(data: {
    command: string;
    userId: string;
    channelId: string;
    text: string;
    workspaceId: string;
  }) {
    const workflows = await this.prisma.workflow.findMany({
      where: {
        workspace_id: data.workspaceId,
        status: 'active',
        trigger_type: 'slash_command',
      },
    });

    for (const wf of workflows) {
      const config = wf.trigger_config;
      if (config.command === data.command) {
        await this.queue.add('execute', {
          workflowId: wf.id,
          triggerData: {
            user_id: data.userId,
            user_name: await this.getUserName(data.userId),
            channel_id: data.channelId,
            command_text: data.text,
          },
        });
      }
    }
  }
}
🔹 Workflow Templates predefinidos
// apps/api/src/modules/workflows/workflow-templates.ts

export const WORKFLOW_TEMPLATES = [
  {
    id: 'welcome-new-members',
    name: 'Welcome new members',
    description: 'Send a welcome message when someone joins a channel',
    category: 'onboarding',
    icon: '👋',
    trigger_type: 'channel_join',
    trigger_config: { channel_id: null }, // Se configura al usar
    steps: [
      {
        type: 'send_message',
        config: {
          channel_id: '${trigger.channel_id}',
          text: 'Welcome to the team, ${trigger.user_name}! 🎉 Check out these resources to get started:',
          blocks: [
            {
              type: 'section',
              text: { type: 'mrkdwn', text: 'Welcome *${trigger.user_name}*! 🎉\n\nHere are some resources to get you started:' }
            },
            {
              type: 'context',
              elements: [
                { type: 'mrkdwn', text: '📄 <https://docs.company.com|Company Wiki>' },
                { type: 'mrkdwn', text: '📅 <https://calendar.company.com|Team Calendar>' },
              ]
            }
          ]
        }
      },
      {
        type: 'add_to_channel',
        config: {
          user_id: '${trigger.user_id}',
          channel_id: 'introductions' // Se configura al usar
        }
      }
    ]
  },
  {
    id: 'daily-standup',
    name: 'Daily standup reminder',
    description: 'Send a daily standup reminder at 9 AM',
    category: 'team-routines',
    icon: '☀️',
    trigger_type: 'schedule',
    trigger_config: { cron: '0 9 * * 1-5' }, // 9 AM, Lunes a Viernes
    steps: [
      {
        type: 'send_message',
        config: {
          channel_id: null, // Se configura al usar
          text: '☀️ Good morning team! Time for the daily standup. Please share:',
          blocks: [
            {
              type: 'section',
              text: { type: 'mrkdwn', text: '☀️ *Daily Standup*\n\nPlease share your update:' }
            },
            {
              type: 'context',
              elements: [
                { type: 'mrkdwn', text: '1️⃣ What did you do yesterday?' },
                { type: 'mrkdwn', text: '2️⃣ What will you do today?' },
                { type: 'mrkdwn', text: '3️⃣ Any blockers?' },
              ]
            }
          ]
        }
      }
    ]
  },
  {
    id: 'issue-tracker',
    name: 'Create issue from emoji',
    description: 'When someone reacts with 🎫 on a message, create a task',
    category: 'productivity',
    icon: '🎫',
    trigger_type: 'emoji_reaction',
    trigger_config: { emoji: '🎫' },
    steps: [
      {
        type: 'create_list_item',
        config: {
          list_id: null, // Se configura al usar
          name: 'Issue from ${trigger.user_name}',
          field_values: {
            'Description': 'See message: ${trigger.message_id}',
            'Status': 'Todo',
            'Created by': '${trigger.user_id}',
          }
        }
      },
      {
        type: 'send_message',
        config: {
          channel_id: '${trigger.channel_id}',
          text: '🎫 Issue created from message by ${trigger.user_name}',
        }
      }
    ]
  },
  {
    id: 'approval-workflow',
    name: 'Approval request',
    description: 'Send an approval request with interactive buttons',
    category: 'approvals',
    icon: '✅',
    trigger_type: 'form_submission',
    trigger_config: { form_id: 'approval-request' },
    steps: [
      {
        type: 'send_message',
        config: {
          channel_id: '${trigger.form_responses.approver_channel}',
          text: 'Approval request from ${trigger.user_name}',
          blocks: [
            {
              type: 'section',
              text: { type: 'mrkdwn', text: '*Approval Request*\n\n*From:* ${trigger.user_name}\n*Item:* ${trigger.form_responses.item_name}\n*Amount:* ${trigger.form_responses.amount}' }
            },
            {
              type: 'actions',
              elements: [
                {
                  type: 'button',
                  text: { type: 'plain_text', text: '✅ Approve' },
                  style: 'primary',
                  action_id: 'approve',
                  value: '${trigger.form_responses.request_id}'
                },
                {
                  type: 'button',
                  text: { type: 'plain_text', text: '❌ Reject' },
                  style: 'danger',
                  action_id: 'reject',
                  value: '${trigger.form_responses.request_id}'
                }
              ]
            }
          ]
        }
      }
    ]
  },
  {
    id: 'weekly-digest',
    name: 'Weekly summary with AI',
    description: 'Generate a weekly AI summary and post it',
    category: 'team-routines',
    icon: '📊',
    trigger_type: 'schedule',
    trigger_config: { cron: '0 17 * * 5' }, // Viernes 5 PM
    steps: [
      {
        type: 'ai_summarize',
        config: {
          channel_id: null,
          period: '7d',
        }
      },
      {
        type: 'send_message',
        config: {
          channel_id: null,
          text: '📊 Weekly summary',
          blocks: [
            {
              type: 'section',
              text: { type: 'mrkdwn', text: '*📊 Weekly Summary*\n\n${ai.summary}' }
            }
          ]
        }
      }
    ]
  },
];
6.3 IA: SLACKBOT, SUMMARIES, RAG Y SEARCH
🔹 Arquitectura del sistema de IA
┌─────────────────────────────────────────────────────────────┐
│                    SISTEMA DE IA                             │
│                                                              │
│  ┌──────────┐     ┌──────────────┐     ┌──────────────┐    │
│  │ Usuario  │────▶│  AI Service  │────▶│    LLM       │    │
│  │ pregunta │     │  (Router)    │     │ GPT-4/Claude │    │
│  └──────────┘     └──────┬───────┘     └──────────────┘    │
│                          │                                  │
│                    ┌─────▼─────┐                            │
│                    │ RAG Layer │                            │
│                    │ (Retrieval│                            │
│                    │  Augmented│                            │
│                    │   Gen)    │                            │
│                    └─────┬─────┘                            │
│                          │                                  │
│              ┌───────────┼───────────┐                     │
│              │           │           │                      │
│        ┌─────▼─────┐ ┌───▼───┐ ┌────▼─────┐               │
│        │ pgvector  │ │Search │ │ Channel  │               │
│        │(semantic) │ │Index  │ │ Context  │               │
│        └───────────┘ └───────┘ └──────────┘               │
└─────────────────────────────────────────────────────────────┘
🔹 AI Service (Slackbot + RAG)
// apps/api/src/modules/ai/ai.service.ts

@Injectable()
export class AIService {
  constructor(
    private prisma: PrismaService,
    private openai: OpenAIService,
    private embeddingService: EmbeddingService,
  ) {}

  // ==================== SLACKBOT CHAT ====================

  async chat(userId: string, workspaceId: string, message: string, conversationId?: string) {
    // 1. Obtener o crear conversación
    let conversation;
    if (conversationId) {
      conversation = await this.prisma.aIConversation.findUnique({
        where: { id: conversationId },
      });
    } else {
      conversation = await this.prisma.aIConversation.create({
        data: {
          workspace_id: workspaceId,
          user_id: userId,
          messages: [],
        },
      });
    }

    // 2. RAG: Retrieval - buscar contexto relevante
    const relevantMessages = await this.retrieveRelevantContext(workspaceId, message, userId);

    // 3. Construir prompt con contexto
    const systemPrompt = this.buildSystemPrompt(workspaceId, relevantMessages);
    const conversationHistory = conversation.messages as any[];

    const messages = [
      { role: 'system', content: systemPrompt },
      ...conversationHistory,
      { role: 'user', content: message },
    ];

    // 4. Generar respuesta con LLM
    const response = await this.openai.chatCompletion({
      model: 'gpt-4o',
      messages,
      temperature: 0.7,
      max_tokens: 2000,
    });

    const answer = response.choices[0].message.content;

    // 5. Actualizar conversación
    const updatedMessages = [
      ...conversationHistory,
      { role: 'user', content: message },
      { role: 'assistant', content: answer },
    ];

    await this.prisma.aIConversation.update({
      where: { id: conversation.id },
      data: {
        messages: updatedMessages,
        context_refs: relevantMessages.map(m => m.id),
      },
    });

    // 6. Devolver respuesta con fuentes
    return {
      answer,
      sources: relevantMessages.slice(0, 5).map(m => ({
        message_id: m.id,
        channel_name: m.channel_name,
        user_name: m.user_name,
        snippet: m.text.substring(0, 200) + '...',
        ts: m.ts,
      })),
      conversation_id: conversation.id,
    };
  }

  // ==================== RAG: RETRIEVAL ====================

  private async retrieveRelevantContext(
    workspaceId: string,
    query: string,
    userId: string,
  ): Promise<RelevantMessage[]> {
    // 1. Generar embedding de la query
    const queryEmbedding = await this.embeddingService.embed(query);

    // 2. Búsqueda semántica en pgvector
    const semanticResults = await this.prisma.$queryRaw`
      SELECT 
        m.id, m.text, m.ts, m.channel_id,
        c.name as channel_name,
        u.display_name as user_name,
        e.embedding <=> ${queryEmbedding}::vector as distance
      FROM ai.message_embeddings e
      JOIN messaging.messages m ON m.id = e.message_id
      JOIN messaging.channels c ON c.id = m.channel_id
      JOIN auth.users u ON u.id = m.user_id
      JOIN messaging.channel_members cm ON cm.channel_id = m.channel_id AND cm.user_id = ${userId}
      WHERE e.workspace_id = ${workspaceId}
        AND m.is_deleted = false
      ORDER BY e.embedding <=> ${queryEmbedding}::vector
      LIMIT 10
    `;

    // 3. Búsqueda por palabras clave (Elasticsearch/Meilisearch)
    const keywordResults = await this.searchService.searchMessages({
      workspaceId,
      query,
      userId,
      limit: 10,
    });

    // 4. Combinar y re-rankear resultados
    const combined = this.mergeAndRerank(semanticResults, keywordResults);

    return combined.slice(0, 10);
  }

  // ==================== SUMMARIES ====================

  async summarizeChannel(channelId: string, period: string, userId: string) {
    // 1. Calcular rango de fechas
    const { startDate, endDate } = this.parsePeriod(period);

    // 2. Obtener mensajes del período
    const messages = await this.prisma.message.findMany({
      where: {
        channel_id: channelId,
        ts: { gte: startDate, lte: endDate },
        is_deleted: false,
        is_system: false,
      },
      include: {
        user: { select: { display_name: true } },
      },
      orderBy: { ts: 'asc' },
    });

    if (messages.length === 0) {
      return { summary: 'No messages found in this period.', key_points: [], action_items: [] };
    }

    // 3. Construir texto para resumir
    const conversationText = messages.map(m =>
      `[${m.user.display_name} - ${m.ts}]: ${m.text}`
    ).join('\n\n');

    // 4. Generar resumen con LLM
    const response = await this.openai.chatCompletion({
      model: 'gpt-4o',
      messages: [
        {
          role: 'system',
          content: `You are a helpful assistant that summarizes channel conversations. 
          Provide a concise summary, key points, and action items. 
          Format your response as JSON: { "summary": "...", "key_points": [...], "action_items": [{ "item": "...", "assignee": "..." }] }`
        },
        {
          role: 'user',
          content: `Summarize this conversation:\n\n${conversationText}`
        }
      ],
      temperature: 0.3,
      response_format: { type: 'json_object' },
    });

    const result = JSON.parse(response.choices[0].message.content);

    // 5. Guardar resumen
    await this.prisma.aISummary.create({
      data: {
        workspace_id: messages[0].workspace_id,
        type: 'channel',
        target_id: channelId,
        summary: result.summary,
        key_points: result.key_points,
        action_items: result.action_items,
        period_start: startDate,
        period_end: endDate,
        generated_for: userId,
        tokens_used: response.usage.total_tokens,
      },
    });

    return {
      summary: result.summary,
      key_points: result.key_points,
      action_items: result.action_items,
      participants: [...new Set(messages.map(m => m.user.display_name))],
      message_count: messages.length,
    };
  }

  async summarizeThread(messageId: string, userId: string) {
    // Similar pero obtiene replies del thread
    const rootMessage = await this.prisma.message.findUnique({
      where: { id: messageId },
    });

    const replies = await this.prisma.message.findMany({
      where: { thread_root_id: messageId, is_deleted: false },
      include: { user: { select: { display_name: true } } },
      orderBy: { ts: 'asc' },
    });

    const allMessages = [rootMessage, ...replies];
    const conversationText = allMessages.map(m =>
      `[${m.user.display_name}]: ${m.text}`
    ).join('\n');

    const response = await this.openai.chatCompletion({
      model: 'gpt-4o',
      messages: [
        {
          role: 'system',
          content: 'Summarize this thread conversation. Identify key decisions and action items.'
        },
        { role: 'user', content: conversationText }
      ],
    });

    return {
      summary: response.choices[0].message.content,
      reply_count: replies.length,
      participants: [...new Set(allMessages.map(m => m.user?.display_name).filter(Boolean))],
    };
  }

  // ==================== HUDDLE NOTES ====================

  async generateHuddleNotes(huddleId: string) {
    const huddle = await this.prisma.huddle.findUnique({
      where: { id: huddleId },
      include: {
        participants: { include: { user: { select: { display_name: true } } } },
      },
    });

    // 1. Obtener transcripción (de Whisper o servicio de transcripción)
    const transcript = await this.transcriptionService.getTranscript(huddleId);

    if (!transcript || transcript.length === 0) {
      return { error: 'No transcript available for this huddle.' };
    }

    // 2. Generar resumen con LLM
    const response = await this.openai.chatCompletion({
      model: 'gpt-4o',
      messages: [
        {
          role: 'system',
          content: `You are a meeting notes assistant. From the transcript, generate:
          1. A concise summary
          2. Key takeaways (bullet points)
          3. Action items (with assignees if mentioned)
          4. Decisions made
          Format as JSON: { "summary": "...", "key_takeaways": [...], "action_items": [...], "decisions": [...] }`
        },
        { role: 'user', content: `Transcript:\n\n${transcript}` }
      ],
      response_format: { type: 'json_object' },
    });

    const notes = JSON.parse(response.choices[0].message.content);

    // 3. Guardar notas
    await this.prisma.huddleNote.create({
      data: {
        huddle_id: huddleId,
        transcript,
        summary: notes.summary,
        key_takeaways: notes.key_takeaways,
        action_items: notes.action_items,
      },
    });

    return notes;
  }

  // ==================== AI SEARCH ====================

  async aiSearch(workspaceId: string, question: string, userId: string) {
    // 1. Retrieval (mismo que chat)
    const relevantMessages = await this.retrieveRelevantContext(workspaceId, question, userId);

    if (relevantMessages.length === 0) {
      return {
        answer: "I couldn't find any relevant information. Try rephrasing your question.",
        sources: [],
        confidence: 0,
      };
    }

    // 2. Generar respuesta
    const contextText = relevantMessages.map(m =>
      `[${m.user_name} in #${m.channel_name} on ${m.ts}]: ${m.text}`
    ).join('\n\n');

    const response = await this.openai.chatCompletion({
      model: 'gpt-4o',
      messages: [
        {
          role: 'system',
          content: `Answer the user's question based on the following conversation context. 
          If the context doesn't contain the answer, say so. 
          Always cite which messages you're basing your answer on.
          
          Context:
          ${contextText}`
        },
        { role: 'user', content: question }
      ],
      temperature: 0.3,
    });

    const answer = response.choices[0].message.content;

    // 3. Calcular confianza basada en distancia de embeddings
    const confidence = this.calculateConfidence(relevantMessages);

    // 4. Guardar en cache
    await this.prisma.aISearchCache.create({
      data: {
        workspace_id: workspaceId,
        user_id: userId,
        query: question,
        answer,
        source_message_ids: relevantMessages.slice(0, 5).map(m => m.id),
        model: 'gpt-4o',
      },
    });

    return {
      answer,
      sources: relevantMessages.slice(0, 5).map(m => ({
        message_id: m.id,
        channel_name: m.channel_name,
        user_name: m.user_name,
        snippet: m.text.substring(0, 200),
        ts: m.ts,
      })),
      confidence,
    };
  }

  // ==================== TRANSLATIONS ====================

  async translateMessage(messageId: string, targetLanguage: string) {
    const message = await this.prisma.message.findUnique({
      where: { id: messageId },
    });

    const response = await this.openai.chatCompletion({
      model: 'gpt-4o',
      messages: [
        {
          role: 'system',
          content: `Translate the following text to ${targetLanguage}. Maintain any formatting, mentions, or links. Only return the translation.`
        },
        { role: 'user', content: message.text }
      ],
      temperature: 0.2,
    });

    return {
      translated_text: response.choices[0].message.content,
      detected_language: await this.detectLanguage(message.text),
    };
  }

  // ==================== EMBEDDINGS WORKER ====================

  async generateEmbedding(messageId: string) {
    const message = await this.prisma.message.findUnique({
      where: { id: messageId },
    });

    if (!message || message.is_system || message.is_deleted) return;

    // Extraer texto para embedding (de text + blocks)
    const textForEmbedding = this.extractTextForEmbedding(message);

    if (!textForEmbedding || textForEmbedding.length < 10) return;

    // Generar embedding
    const embedding = await this.embeddingService.embed(textForEmbedding);

    // Guardar en pgvector
    await this.prisma.$executeRaw`
      INSERT INTO ai.message_embeddings (workspace_id, message_id, channel_id, content, embedding)
      VALUES (${message.workspace_id}, ${message.id}, ${message.channel_id}, ${textForEmbedding}, ${embedding}::vector)
      ON CONFLICT (message_id) DO UPDATE SET embedding = EXCLUDED.embedding, content = EXCLUDED.content
    `;
  }

  // ==================== HELPER: SYSTEM PROMPT ====================

  private buildSystemPrompt(workspaceId: string, context: RelevantMessage[]): string {
    return `You are Slackbot, a helpful AI assistant for a team collaboration platform.
You have access to the team's conversation history and can help with:
- Finding information from past conversations
- Summarizing discussions
- Answering questions about projects and decisions
- Suggesting actions

You are talking to a member of the workspace. Be concise, helpful, and friendly.
When you reference information from conversations, mention the channel and person.

Relevant context from recent conversations:
${context.map(m => `[#${m.channel_name} - ${m.user_name}]: ${m.text}`).join('\n')}
`;
  }
}
🔹 Embedding Service
// apps/api/src/modules/ai/embedding.service.ts

@Injectable()
export class EmbeddingService {
  private openai: OpenAI;

  constructor() {
    this.openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
  }

  async embed(text: string): Promise<number[]> {
    const response = await this.openai.embeddings.create({
      model: 'text-embedding-3-small',
      input: this.truncate(text, 8000), // Max tokens para embeddings
    });

    return response.data[0].embedding;
  }

  async embedBatch(texts: string[]): Promise<number[][]> {
    const response = await this.openai.embeddings.create({
      model: 'text-embedding-3-small',
      input: texts.map(t => this.truncate(t, 8000)),
    });

    return response.data.map(d => d.embedding);
  }

  private truncate(text: string, maxTokens: number): string {
    // Aproximación: 1 token ≈ 4 caracteres
    const maxChars = maxTokens * 4;
    return text.length > maxChars ? text.substring(0, maxChars) : text;
  }
}
🔹 Daily Recaps (Resúmenes automáticos diarios)
// apps/workers/src/processors/recaps.processor.ts

@Processor('daily-recaps', {
  repeat: { pattern: '0 8 * * *' }, // Cada día a las 8 AM
})
export class DailyRecapsProcessor extends WorkerHost {
  constructor(
    private prisma: PrismaService,
    private aiService: AIService,
    private messageService: MessageService,
  ) {
    super();
  }

  async process() {
    // 1. Buscar todos los usuarios con recaps activos
    const recapSettings = await this.prisma.recapSettings.findMany({
      where: { is_active: true },
      include: { user: true },
    });

    for (const setting of recapSettings) {
      // 2. Verificar si es hora de enviar (según timezone del usuario)
      const userTime = this.getUserLocalTime(setting.user.timezone);
      if (userTime.getHours() !== setting.time_hour) continue;

      // 3. Generar recap de cada canal seleccionado
      const recaps = [];
      for (const channelId of setting.channel_ids) {
        const summary = await this.aiService.summarizeChannel(
          channelId,
          '24h',
          setting.user_id,
        );
        recaps.push({
          channel_id: channelId,
          channel_name: await this.getChannelName(channelId),
          summary: summary.summary,
          key_points: summary.key_points,
          message_count: summary.message_count,
        });
      }

      // 4. Enviar recap como DM al usuario
      await this.sendRecapDM(setting.user_id, recaps);
    }
  }
}
6.4 SEGURIDAD Y CUMPLIMIENTO
🔹 Arquitectura de Seguridad
┌─────────────────────────────────────────────────────────────┐
│                  CAPAS DE SEGURIDAD                          │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ Capa 1: Network (Cloudflare WAF + DDoS Protection)   │   │
│  │  • Rate limiting global                               │   │
│  │  • DDoS mitigation                                    │   │
│  │  • IP reputation                                      │   │
│  │  • Geo-blocking (opcional)                            │   │
│  └──────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ Capa 2: Application (API Gateway)                     │   │
│  │  • TLS 1.3 obligatorio                                │   │
│  │  • CORS estricto                                      │   │
│  │  • Helmet (security headers)                          │   │
│  │  • Rate limiting por usuario                           │   │
│  │  • Request validation                                  │   │
│  │  • SQL injection prevention (Prisma/parameterized)    │   │
│  │  • XSS prevention (input sanitization)                │   │
│  └──────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ Capa 3: Authentication                                 │   │
│  │  • JWT (access 15min + refresh 30d con rotación)      │   │
│  │  • OAuth 2.0 (Google, GitHub, etc.)                   │   │
│  │  • SAML 2.0 (SSO enterprise)                          │   │
│  │  • 2FA (TOTP + backup codes)                          │   │
│  │  • Session management (revocable)                     │   │
│  │  • Password policy (min 12 chars, complexity)         │   │
│  └──────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ Capa 4: Authorization (RBAC)                          │   │
│  │  • Roles: owner, admin, member, guest                 │   │
│  │  • Permisos granulares por canal                      │   │
│  │  • Information barriers                               │   │
│  │  • Workspace isolation (multi-tenant)                 │   │
│  │  • Row Level Security en PostgreSQL                   │   │
│  └──────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ Capa 5: Data Protection                               │   │
│  │  • Encryption at rest (AES-256)                       │   │
│  │  • Encryption in transit (TLS 1.3)                    │   │
│  │  • Enterprise Key Management (EKM)                    │   │
│  │  • PII data encryption (emails, phones)               │   │
│  │  • OAuth tokens encryption                            │   │
│  │  • File encryption (S3 server-side)                   │   │
│  └──────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ Capa 6: Compliance & Audit                            │   │
│  │  • Audit logs (todas las acciones admin)              │   │
│  │  • Data retention policies                            │   │
│  │  • Legal holds                                        │   │
│  │  • Data exports                                       │   │
│  │  • DLP (Data Loss Prevention)                         │   │
│  │  • GDPR compliance (right to be forgotten)            │   │
│  │  • HIPAA compliance (Enterprise)                      │   │
│  └──────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
🔹 Encryption Service
// apps/api/src/common/services/encryption.service.ts

import * as crypto from 'crypto';

@Injectable()
export class EncryptionService {
  private readonly algorithm = 'aes-256-gcm';
  private readonly key: Buffer;

  constructor() {
    // La clave debe estar en variables de entorno
    this.key = crypto.scryptSync(
      process.env.ENCRYPTION_KEY,
      process.env.ENCRYPTION_SALT || 'salt',
      32
    );
  }

  encrypt(text: string): string {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv(this.algorithm, this.key, iv);
    const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
    const authTag = cipher.getAuthTag();
    // Formato: iv:authTag:encrypted (todos en hex)
    return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted.toString('hex')}`;
  }

  decrypt(encryptedText: string): string {
    const [ivHex, authTagHex, encryptedHex] = encryptedText.split(':');
    const iv = Buffer.from(ivHex, 'hex');
    const authTag = Buffer.from(authTagHex, 'hex');
    const encrypted = Buffer.from(encryptedHex, 'hex');
    const decipher = crypto.createDecipheriv(this.algorithm, this.key, iv);
    decipher.setAuthTag(authTag);
    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
    return decrypted.toString('utf8');
  }

  // Para archivos: hash SHA-256
  hash(data: string): string {
    return crypto.createHash('sha256').update(data).digest('hex');
  }

  // Para contraseñas: bcrypt (en auth service)
  // Para HMAC signing (webhooks): createHmac
}
🔹 2FA (Two-Factor Authentication)
// apps/api/src/modules/auth/two-factor.service.ts

import * as speakeasy from 'speakeasy';
import * as QRCode from 'qrcode';

@Injectable()
export class TwoFactorService {
  constructor(private prisma: PrismaService) {}

  async enable(userId: string) {
    // 1. Generar secreto TOTP
    const secret = speakeasy.generateSecret({
      name: `ChatApp (${userEmail})`,
      issuer: 'ChatApp',
      length: 32,
    });

    // 2. Guardar secreto (encriptado, no habilitado aún)
    await this.prisma.twoFactorAuth.upsert({
      where: { user_id: userId },
      create: {
        user_id: userId,
        secret: this.encrypt(secret.base32),
        enabled: false,
      },
      update: {
        secret: this.encrypt(secret.base32),
        enabled: false,
      },
    });

    // 3. Generar QR code
    const qrUrl = await QRCode.toDataURL(secret.otpauth_url);

    return {
      secret: secret.base32,
      qr_url: qrUrl,
      otpauth_url: secret.otpauth_url,
    };
  }

  async verify(userId: string, token: string) {
    const tfa = await this.prisma.twoFactorAuth.findUnique({
      where: { user_id: userId },
    });

    if (!tfa) throw new NotFoundException('2FA not set up');

    const secret = this.decrypt(tfa.secret);
    const verified = speakeasy.totp.verify({
      secret,
      encoding: 'base32',
      token,
      window: 2, // Permitir 2 pasos de ventana (±60s)
    });

    if (!verified) {
      throw new UnauthorizedException('Invalid 2FA code');
    }

    // Habilitar 2FA y generar backup codes
    const backupCodes = this.generateBackupCodes();

    await this.prisma.twoFactorAuth.update({
      where: { user_id: userId },
      data: {
        enabled: true,
        enabled_at: new Date(),
        backup_codes: this.hashBackupCodes(backupCodes),
      },
    });

    return { backup_codes: backupCodes };
  }

  private generateBackupCodes(): string[] {
    return Array.from({ length: 10 }, () =>
      crypto.randomBytes(5).toString('hex').toUpperCase()
    );
  }
}
🔹 SSO con SAML 2.0
// apps/api/src/modules/auth/saml.service.ts

import { Strategy as SamlStrategy } from 'passport-saml';
import * as saml2 from 'saml2-js';

@Injectable()
export class SamlSSOService {
  constructor(private prisma: PrismaService) {}

  // Configurar SAML para un workspace enterprise
  async configureSAML(workspaceId: string, config: SAMLConfig) {
    await this.prisma.workspaceSettings.update({
      where: { workspace_id: workspaceId },
      data: {
        sso_required: true,
        saml_config: {
          entry_point: config.entryPoint,        // URL del IdP
          issuer: config.issuer,                  // Entity ID
          cert: config.cert,                      // Certificado del IdP
          signature_algorithm: 'sha256',
          accepted_clock_skew_ms: -1,
          want_assertions_signed: true,
          want_assertions_encrypted: false,
        },
      },
    });
  }

  // Metadata del SP (Service Provider) para que el IdP lo configure
  getSPMetadata(workspaceId: string) {
    const config = this.getSAMLConfig(workspaceId);
    const strategy = new SamlStrategy(config, () => {});
    // Generar XML metadata
    return strategy.generateMetadata(callbackURL);
  }

  // Callback del IdP después del login SAML
  async handleSAMLCallback(workspaceId: string, samlResponse: string) {
    // 1. Verificar y parsear la aserción SAML
    const profile = await this.verifySAMLResponse(workspaceId, samlResponse);

    // 2. Buscar o crear usuario basado en el email del SAML
    let user = await this.prisma.user.findUnique({
      where: { email: profile.email },
    });

    if (!user) {
      // Auto-crear usuario si el dominio de email coincide
      const workspace = await this.prisma.workspace.findUnique({
        where: { id: workspaceId },
      });
      const allowedDomains = workspace.settings.allowed_auth_domains || [];
      const emailDomain = profile.email.split('@')[1];

      if (allowedDomains.includes(emailDomain)) {
        user = await this.prisma.user.create({
          data: {
            email: profile.email,
            display_name: profile.displayName || profile.email,
            email_verified: true,
          },
        });
        await this.prisma.workspaceMember.create({
          data: {
            workspace_id: workspaceId,
            user_id: user.id,
            role: 'member',
          },
        });
      } else {
        throw new ForbiddenException('Email domain not allowed');
      }
    }

    // 3. Generar tokens JWT
    return this.generateTokens(user.id, workspaceId);
  }
}
🔹 Audit Log Service
// apps/api/src/modules/admin/audit-log.service.ts

@Injectable()
export class AuditLogService {
  constructor(private prisma: PrismaService) {}

  async log(event: AuditEvent) {
    await this.prisma.auditLog.create({
      data: {
        workspace_id: event.workspaceId,
        actor_id: event.actorId,
        actor_type: event.actorType || 'user',
        action: event.action,           // e.g., 'user.invite'
        entity_type: event.entityType,  // e.g., 'user'
        entity_id: event.entityId,
        details: event.details || {},
        ip_address: event.ipAddress,
        user_agent: event.userAgent,
      },
    });
  }

  // Acciones a auditar:
  // user.invite, user.deactivate, user.reactivate, user.role_change
  // channel.create, channel.archive, channel.unarchive, channel.convert
  // message.delete (admin), message.export
  // workspace.settings_change, workspace.sso_enable
  // app.install, app.uninstall
  // data_export, legal_hold_create, legal_hold_release
  // retention_policy_create, retention_policy_update
  // api_token_create, api_token_revoke
}

// Decorator para auditar automáticamente
export function AuditLog(action: string) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = async function (...args: any[]) {
      const result = await originalMethod.apply(this, args);
      // Extraer workspaceId, userId, etc. de los argumentos
      const req = args[0]; // Asumiendo que el primer arg es el request
      this.auditLogService.log({
        workspaceId: req.workspace.id,
        actorId: req.user.userId,
        action,
        entityType: req.body.entityType,
        entityId: result.id,
        details: req.body,
        ipAddress: req.ip,
        userAgent: req.headers['user-agent'],
      });
      return result;
    };
    return descriptor;
  };
}
🔹 Data Retention (Políticas de retención)
// apps/workers/src/processors/retention.processor.ts

@Processor('data-retention', {
  repeat: { pattern: '0 3 * * *' }, // Cada día a las 3 AM
})
export class DataRetentionProcessor extends WorkerHost {
  constructor(private prisma: PrismaService) {
    super();
  }

  async process() {
    // 1. Obtener todas las políticas de retención activas
    const policies = await this.prisma.dataRetentionPolicy.findMany({
      where: {
        message_retention_days: { not: null },
      },
    });

    for (const policy of policies) {
      const cutoffDate = new Date();
      cutoffDate.setDate(cutoffDate.getDate() - policy.message_retention_days);

      // 2. Verificar que no haya legal holds en estos mensajes
      const legalHoldUserIds = await this.getLegalHoldUserIds(policy.workspace_id);
      const legalHoldChannelIds = await this.getLegalHoldChannelIds(policy.workspace_id);

      // 3. Borrar mensajes antiguos (soft delete) que no estén en legal hold
      await this.prisma.message.updateMany({
        where: {
          workspace_id: policy.workspace_id,
          ts: { lt: cutoffDate },
          is_deleted: false,
          // Excluir mensajes en canales con legal hold
          channel_id: { notIn: legalHoldChannelIds },
          // Excluir mensajes de usuarios con legal hold
          user_id: { notIn: legalHoldUserIds },
          // Si es a nivel canal, solo ese canal
          ...(policy.channel_id ? { channel_id: policy.channel_id } : {}),
        },
        data: {
          is_deleted: true,
          deleted_at: new Date(),
        },
      });

      // 4. Borrar archivos antiguos
      if (policy.file_retention_days) {
        const fileCutoff = new Date();
        fileCutoff.setDate(fileCutoff.getDate() - policy.file_retention_days);

        const oldFiles = await this.prisma.file.findMany({
          where: {
            workspace_id: policy.workspace_id,
            created_at: { lt: fileCutoff },
            is_deleted: false,
          },
        });

        for (const file of oldFiles) {
          // Borrar de S3
          await this.s3Service.deleteObject(file.storage_key);
          // Soft delete en DB
          await this.prisma.file.update({
            where: { id: file.id },
            data: { is_deleted: true, deleted_at: new Date() },
          });
        }
      }
    }
  }
}
🔹 Data Loss Prevention (DLP)
// apps/api/src/modules/security/dlp.service.ts

@Injectable()
export class DLPService {
  constructor(
    private prisma: PrismaService,
    private pubsubService: PubSubService,
  ) {}

  // Ejecutar antes de guardar un mensaje
  async scanMessage(workspaceId: string, text: string): Promise<DLPResult> {
    const policies = await this.getDLPolicies(workspaceId);
    const violations: DLPViolation[] = [];

    for (const policy of policies) {
      const pattern = this.compilePattern(policy.pattern, policy.pattern_type);
      const matches = text.match(pattern);

      if (matches) {
        violations.push({
          policy_id: policy.id,
          policy_name: policy.name,
          matched_content: matches[0],
          action: policy.action, // 'block', 'warn', 'redact'
        });
      }
    }

    if (violations.length === 0) {
      return { allowed: true, text };
    }

    // Si hay violaciones de tipo 'block', bloquear el mensaje
    if (violations.some(v => v.action === 'block')) {
      return {
        allowed: false,
        reason: 'Message blocked by DLP policy',
        violations,
      };
    }

    // Si hay violaciones de tipo 'redact', reemplazar contenido sensible
    let redactedText = text;
    for (const v of violations.filter(v => v.action === 'redact')) {
      redactedText = redactedText.replace(
        this.compilePattern(v.pattern, v.pattern_type),
        '[REDACTED]'
      );
    }

    return {
      allowed: true,
      text: redactedText,
      violations: violations.filter(v => v.action === 'warn'),
    };
  }

  // Patrones predefinidos:
  // - Números de tarjetas de crédito (regex)
  // - SSN (Social Security Number)
  // - Emails externos (dominios no permitidos)
  // - Palabras clave sensibles (configurable)
  // - API keys / tokens (patrones conocidos)
}
6.5 ADMIN DASHBOARD
🔹 Analytics Dashboard
// apps/api/src/modules/admin/admin.service.ts

@Injectable()
export class AdminService {
  constructor(
    private prisma: PrismaService,
    private clickhouse: ClickHouseService,
  ) {}

  async getDashboard(workspaceId: string, period: string) {
    const days = this.parsePeriodDays(period);
    const startDate = new Date();
    startDate.setDate(startDate.getDate() - days);

    const [
      dauTrend,
      messagesSent,
      activeChannels,
      huddleStats,
      storageUsed,
      appUsage,
      workflowStats,
    ] = await Promise.all([
      this.getDAUTrend(workspaceId, startDate),
      this.getMessagesSent(workspaceId, startDate),
      this.getActiveChannels(workspaceId, startDate),
      this.getHuddleStats(workspaceId, startDate),
      this.getStorageUsed(workspaceId),
      this.getAppUsage(workspaceId, startDate),
      this.getWorkflowStats(workspaceId, startDate),
    ]);

    return {
      summary: {
        dau: dauTrend[dauTrend.length - 1]?.value || 0,
        messages_sent: messagesSent,
        active_channels: activeChannels.length,
        huddles_count: huddleStats.count,
        huddle_minutes: huddleStats.totalMinutes,
        storage_used_gb: storageUsed,
        active_apps: appUsage.length,
        workflows_executed: workflowStats.executed,
      },
      charts: {
        dau_trend: dauTrend,
        messages_trend: await this.getMessagesTrend(workspaceId, startDate),
        new_members_trend: await this.getNewMembersTrend(workspaceId, startDate),
      },
      top_channels: await this.getTopChannels(workspaceId, startDate),
      top_apps: appUsage,
      recent_activity: await this.getRecentActivity(workspaceId),
    };
  }

  // ============ Data Export ============

  async exportData(workspaceId: string, options: ExportOptions) {
    const exportJob = await this.prisma.dataExport.create({
      data: {
        workspace_id: workspaceId,
        type: options.type,        // 'all', 'messages', 'files', 'channels'
        date_range_start: options.dateRange.from,
        date_range_end: options.dateRange.to,
        status: 'processing',
        requested_by: options.userId,
      },
    });

    // Encolar job de exportación
    await this.exportQueue.add('export', {
      exportId: exportJob.id,
      workspaceId,
      options,
    });

    return { export_id: exportJob.id, status: 'processing' };
  }
}
// apps/workers/src/processors/data-export.processor.ts

@Processor('data-exports')
export class DataExportProcessor extends WorkerHost {
  async process(job: Job<ExportJob>) {
    const { exportId, workspaceId, options } = job.data;

    // 1. Obtener datos según el tipo
    let data: any = {};
    
    if (options.type === 'all' || options.type === 'channels') {
      data.channels = await this.exportChannels(workspaceId);
    }
    if (options.type === 'all' || options.type === 'messages') {
      data.messages = await this.exportMessages(workspaceId, options.dateRange);
    }
    if (options.type === 'all' || options.type === 'files') {
      data.files = await this.exportFiles(workspaceId, options.dateRange);
    }
    if (options.type === 'all') {
      data.users = await this.exportUsers(workspaceId);
    }

    // 2. Generar archivo ZIP con JSON + archivos
    const zipBuffer = await this.createExportZip(data, workspaceId);

    // 3. Subir a S3 con URL firmada (válida 7 días)
    const key = `exports/${workspaceId}/${exportId}.zip`;
    await this.s3Service.upload(key, zipBuffer);
    const downloadUrl = await this.s3Service.getPresignedUrl(key, 7 * 24 * 3600);

    // 4. Actualizar registro
    await this.prisma.dataExport.update({
      where: { id: exportId },
      data: {
        status: 'completed',
        download_url: downloadUrl,
        completed_at: new Date(),
        file_size: zipBuffer.length,
      },
    });

    // 5. Notificar al usuario
    await this.sendExportCompleteNotification(options.userId, exportId, downloadUrl);
  }
}
6.6 PLATAFORMA DE DESARROLLADORES
🔹 API REST pública (para desarrolladores externos)
// apps/api/src/modules/integrations/public-api.controller.ts

@Controller('api/v2')
@ApiTags('Public API')
@UseGuards(ApiTokenGuard) // Autenticación con token de API (no JWT)
export class PublicApiController {
  constructor(
    private messageService: MessageService,
    private channelService: ChannelService,
  ) {}

  // ==================== MESSAGES ====================

  @Post('chat.postMessage')
  @ApiOperation({ summary: 'Post a message to a channel' })
  async postMessage(@Body() dto: PostMessageDto, @Workspace() ws: any) {
    const message = await this.messageService.createMessage({
      channelId: dto.channel,
      botId: ws.appId, // Se asocia al bot de la app
      text: dto.text,
      blocks: dto.blocks,
      attachments: dto.attachments,
    });
    return { ok: true, channel: dto.channel, ts: message.ts, message: { text: message.text } };
  }

  @Post('chat.update')
  async updateMessage(@Body() dto: UpdateMessageDto) {
    const message = await this.messageService.editMessage(dto.ts, dto.channel, {
      text: dto.text,
      blocks: dto.blocks,
    });
    return { ok: true, channel: dto.channel, ts: message.ts };
  }

  @Post('chat.delete')
  async deleteMessage(@Body() dto: DeleteMessageDto) {
    await this.messageService.deleteMessage(dto.ts, dto.channel);
    return { ok: true };
  }

  @Post('chat.postMessageEphemeral')
  async postEphemeral(@Body() dto: PostEphemeralDto) {
    // Mensaje que solo ve un usuario específico
    const message = await this.messageService.createEphemeralMessage({
      channelId: dto.channel,
      userId: dto.user,
      text: dto.text,
      blocks: dto.blocks,
    });
    return { ok: true };
  }

  // ==================== CHANNELS ====================

  @Get('conversations.list')
  async listChannels(@Workspace() ws: any) {
    const channels = await this.channelService.findAllForApp(ws.workspaceId);
    return { ok: true, channels };
  }

  @Post('conversations.join')
  async joinChannel(@Body() dto: { channel: string }) {
    await this.channelService.joinChannel(dto.channel, this.appBotUserId);
    return { ok: true };
  }

  @Post('conversations.create')
  async createChannel(@Body() dto: CreateChannelDto) {
    const channel = await this.channelService.create({
      name: dto.name,
      type: dto.is_private ? 'private' : 'public',
      workspaceId: this.workspaceId,
    });
    return { ok: true, channel: { id: channel.id, name: channel.name } };
  }

  // ==================== USERS ====================

  @Get('users.list')
  async listUsers(@Workspace() ws: any) {
    const users = await this.userService.findAll(ws.workspaceId);
    return { ok: true, members: users };
  }

  @Get('users.info')
  async userInfo(@Query('user') userId: string) {
    const user = await this.userService.findById(userId);
    return { ok: true, user };
  }

  // ==================== FILES ====================

  @Post('files.upload')
  async uploadFile(@Body() dto: UploadFileDto) {
    const file = await this.fileService.upload({
      filename: dto.filename,
      content: dto.content, // base64 o multipart
      channels: dto.channels,
      workspaceId: this.workspaceId,
    });
    return { ok: true, file: { id: file.id, url: file.url } };
  }

  // ==================== VIEWS (Modals) ====================

  @Post('views.open')
  async openView(@Body() dto: OpenViewDto) {
    // Abrir un modal en el cliente de un usuario específico
    // Se envía via WebSocket al usuario
    await this.pubsubService.publish('open_modal', {
      userId: dto.trigger_id_owner,
      view: dto.view,
    });
    return { ok: true };
  }

  @Post('views.update')
  async updateView(@Body() dto: UpdateViewDto) {
    await this.pubsubService.publish('update_modal', {
      viewId: dto.view_id,
      view: dto.view,
    });
    return { ok: true };
  }

  @Post('views.publish')
  async publishView(@Body() dto: PublishViewDto) {
    // Publicar la App Home de un usuario
    await this.pubsubService.publish('update_app_home', {
      userId: dto.user_id,
      view: dto.view,
    });
    return { ok: true };
  }
}
🔹 SDK para desarrolladores (npm package)
// packages/sdk/src/chatapp-client.ts (npm: @chatapp/sdk)

export class ChatAppClient {
  private token: string;
  private baseURL: string;

  constructor(token: string, options?: { baseURL?: string }) {
    this.token = token;
    this.baseURL = options?.baseURL || 'https://api.chatapp.com/api/v2';
  }

  // Messages
  chat = {
    postMessage: async (params: PostMessageParams) => {
      return this.post('/chat.postMessage', params);
    },
    update: async (params: UpdateMessageParams) => {
      return this.post('/chat.update', params);
    },
    delete: async (channel: string, ts: string) => {
      return this.post('/chat.delete', { channel, ts });
    },
    postEphemeral: async (params: PostEphemeralParams) => {
      return this.post('/chat.postMessageEphemeral', params);
    },
    getPermalink: async (channel: string, ts: string) => {
      return this.get('/chat.getPermalink', { channel, ts });
    },
  };

  // Channels
  conversations = {
    list: async (params?: { types?: string; limit?: number; cursor?: string }) => {
      return this.get('/conversations.list', params);
    },
    join: async (channel: string) => {
      return this.post('/conversations.join', { channel });
    },
    leave: async (channel: string) => {
      return this.post('/conversations.leave', { channel });
    },
    create: async (params: { name: string; is_private?: boolean }) => {
      return this.post('/conversations.create', params);
    },
    info: async (channel: string) => {
      return this.get('/conversations.info', { channel });
    },
    members: async (channel: string) => {
      return this.get('/conversations.members', { channel });
    },
  };

  // Users
  users = {
    list: async (params?: { limit?: number; cursor?: string }) => {
      return this.get('/users.list', params);
    },
    info: async (user: string) => {
      return this.get('/users.info', { user });
    },
  };

  // Views (Modals)
  views = {
    open: async (params: { trigger_id: string; view: View }) => {
      return this.post('/views.open', params);
    },
    update: async (params: { view_id: string; view: View }) => {
      return this.post('/views.update', params);
    },
    publish: async (params: { user_id: string; view: View }) => {
      return this.post('/views.publish', params);
    },
  };

  // Files
  files = {
    upload: async (params: UploadFileParams) => {
      return this.post('/files.upload', params);
    },
    info: async (file: string) => {
      return this.get('/files.info', { file });
    },
  };

  // Reactions
  reactions = {
    add: async (params: { channel: string; ts: string; name: string }) => {
      return this.post('/reactions.add', params);
    },
    remove: async (params: { channel: string; ts: string; name: string }) => {
      return this.post('/reactions.remove', params);
    },
  };

  // Private helpers
  private async post(endpoint: string, body: any) {
    const response = await fetch(`${this.baseURL}${endpoint}`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${this.token}`,
      },
      body: JSON.stringify(body),
    });
    return response.json();
  }

  private async get(endpoint: string, params?: Record<string, string>) {
    const query = params ? `?${new URLSearchParams(params)}` : '';
    const response = await fetch(`${this.baseURL}${endpoint}${query}`, {
      headers: { Authorization: `Bearer ${this.token}` },
    });
    return response.json();
  }
}

// Uso:
// import { ChatAppClient } from '@chatapp/sdk';
// const client = new ChatAppClient('xoxb-your-bot-token');
// await client.chat.postMessage({ channel: 'C123456', text: 'Hello from my app!' });
🔹 Webhook Handler Template (para apps externas)
// Ejemplo de cómo un desarrollador externo crearía una app

import express from 'express';
import { ChatAppClient } from '@chatapp/sdk';

const app = express();
app.use(express.json());

const chatapp = new ChatAppClient(process.env.CHATAPP_BOT_TOKEN);

// Recibir eventos del sistema
app.post('/chatapp/events', (req, res) => {
  const { type, event } = req.body;

  // Verificar URL challenge (primera vez)
  if (type === 'url_verification') {
    return res.json({ challenge: req.body.challenge });
  }

  // Procesar evento
  if (type === 'event_callback') {
    switch (event.type) {
      case 'message.channels':
        // Un mensaje nuevo en un canal público
        if (event.text.includes('help')) {
          chatapp.chat.postMessage({
            channel: event.channel,
            text: 'How can I help you?',
            blocks: [
              {
                type: 'actions',
                elements: [
                  {
                    type: 'button',
                    text: { type: 'plain_text', text: 'Create ticket' },
                    action_id: 'create_ticket',
                    value: event.user,
                  },
                ],
              },
            ],
          });
        }
        break;

      case 'app_mention':
        // Alguien mencionó a nuestro bot
        chatapp.chat.postMessage({
          channel: event.channel,
          text: `Hi <@${event.user}>! I'm here to help.`,
        });
        break;

      case 'team_join':
        // Nuevo miembro del workspace
        chatapp.chat.postMessage({
          channel: 'welcome',
          text: `Welcome <@${event.user}>! 🎉`,
        });
        break;
    }
  }

  // Procesar interacciones (botones, modals)
  if (type === 'block_actions') {
    const action = req.body.actions[0];
    if (action.action_id === 'create_ticket') {
      // Abrir modal para crear ticket
      chatapp.views.open({
        trigger_id: req.body.trigger_id,
        view: {
          type: 'modal',
          title: { type: 'plain_text', text: 'Create Ticket' },
          blocks: [
            {
              type: 'input',
              label: { type: 'plain_text', text: 'Title' },
              element: { type: 'plain_text_input', action_id: 'title' },
            },
            {
              type: 'input',
              label: { type: 'plain_text', text: 'Description' },
              element: { type: 'plain_text_input', multiline: true, action_id: 'description' },
            },
            {
              type: 'input',
              label: { type: 'plain_text', text: 'Priority' },
              element: {
                type: 'static_select',
                action_id: 'priority',
                options: [
                  { text: { type: 'plain_text', text: 'Low' }, value: 'low' },
                  { text: { type: 'plain_text', text: 'Medium' }, value: 'medium' },
                  { text: { type: 'plain_text', text: 'High' }, value: 'high' },
                ],
              },
            },
          ],
          submit: { type: 'plain_text', text: 'Create' },
        },
      });
    }
  }

  // Procesar envío de modal
  if (type === 'view_submission') {
    const values = req.body.view.state.values;
    const title = values.title.title.value;
    const description = values.description.description.value;
    const priority = values.priority.priority.selected_option.value;

    // Crear ticket en tu sistema
    const ticket = await createTicketInYourSystem({ title, description, priority });

    // Confirmar al usuario
    chatapp.chat.postMessage({
      channel: req.body.user.id,
      text: `Ticket created: ${ticket.id}`,
    });
  }

  res.json({ ok: true });
});

app.listen(3000, () => console.log('Bot app listening on port 3000'));
6.7 MATRIX DE FEATURES vs PLANES (MONETIZACIÓN)
┌────────────────────────┬──────────┬──────────┬──────────────┬──────────────┐
│ Feature                │ Free     │ Pro      │ Business+    │ Enterprise+  │
├────────────────────────┼──────────┼──────────┼──────────────┼──────────────┤
│ Mensajes               │ 90 días  │ ∞        │ ∞            │ ∞            │
│ Canales                │ ∞        │ ∞        │ ∞            │ ∞            │
│ Integraciones          │ 10       │ ∞        │ ∞            │ ∞            │
│ Huddles (audio)        │ 1:1      │ Grupo    │ Grupo        │ Grupo        │
│ Huddles (video)        │ 1:1      │ 50 ppl   │ 50 ppl       │ 100 ppl      │
│ File storage           │ 5GB      │ 10GB     │ 20GB         │ 100GB+       │
│ Message history        │ 90 días  │ ∞        │ ∞            │ ∞            │
│ AI Summaries           │ ✗        │ ✓        │ ✓            │ ✓            │
│ AI Search              │ ✗        │ ✗        │ ✓            │ ✓            │
│ AI Recaps              │ ✗        │ ✗        │ ✓            │ ✓            │
│ Slackbot (AI agent)    │ ✗        │ ✗        │ ✓            │ ✓            │
│ Workflow Builder       │ Básico   │ ∞        │ ∞+condicion. │ ∞+condicion. │
│ Canvas                 │ ✗        │ ✓        │ ✓            │ ✓            │
│ Lists                  │ ✓        │ ✓        │ ✓            │ ✓            │
│ Slack Connect          │ 1:1      │ ✓        │ ✓            │ ✓            │
│ SSO (SAML)             │ ✗        │ ✗        │ ✓            │ ✓            │
│ 2FA                    │ ✗        │ ✓        │ ✓            │ ✓ (forced)   │
│ Data exports           │ ✗        │ ✓        │ ✓            │ ✓            │
│ Audit logs             │ ✗        │ ✗        │ ✓            │ ✓            │
│ Data retention         │ ✗        │ ✓        │ ✓            │ ✓            │
│ Enterprise Key Mgmt    │ ✗        │ ✗        │ Add-on       │ ✓            │
│ DLP                    │ ✗        │ ✗        │ ✗            │ ✓            │
│ Information barriers   │ ✗        │ ✗        │ ✗            │ ✓            │
│ Legal holds            │ ✗        │ ✗        │ ✗            │ ✓            │
│ HIPAA compliance       │ ✗        │ ✗        │ ✗            │ ✓            │
│ Data residency         │ ✗        │ ✗        │ ✓            │ ✓            │
│ Custom roles           │ ✗        │ ✗        │ ✗            │ ✓            │
│ Guest accounts         │ ✗        │ ✓        │ ✓            │ ✓            │
│ API access             │ ✗        │ ✓        │ ✓            │ ✓            │
│ Support                │ Community│ 24/7     │ 24/7 prio    │ 24/7 + CSM   │
│ Precio                 │ $0       │ $7.25    │ $12.50       │ Custom       │
│                        │          │ /user/mo │ /user/mo     │ /user/mo     │
└────────────────────────┴──────────┴──────────┴──────────────┴──────────────┘


📌 PARTE 7: DEVOPS, DEPLOYMENT, ESCALABILIDAD, ROADMAP Y COSTOS (PARTE FINAL)
7.1 DOCKER: CONTENERIZACIÓN COMPLETA
🔹 Docker Compose para Desarrollo
# docker-compose.yml (raíz del proyecto)

version: '3.9'

services:
  # ==================== BASE DE DATOS ====================
  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: chatapp
      POSTGRES_USER: chatapp
      POSTGRES_PASSWORD: chatapp_dev_password
    ports:
      - '5432:5432'
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./libs/database/init.sql:/docker-entrypoint-initdb.d/init.sql
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U chatapp']
      interval: 5s
      timeout: 5s
      retries: 5

  # ==================== REDIS ====================
  redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: redis-server --appendonly yes --maxmemory 512mb --maxmemory-policy allkeys-lru
    ports:
      - '6379:6379'
    volumes:
      - redis_data:/data
    healthcheck:
      test: ['CMD', 'redis-cli', 'ping']
      interval: 5s
      timeout: 3s
      retries: 5

  # ==================== BÚSQUEDA ====================
  meilisearch:
    image: getmeili/meilisearch:v1.6
    restart: unless-stopped
    environment:
      MEILI_MASTER_KEY: meili_dev_key
      MEILI_ENV: development
    ports:
      - '7700:7700'
    volumes:
      - meili_data:/meili_data

  # ==================== ARCHIVOS (S3 compatible) ====================
  minio:
    image: minio/minio:latest
    restart: unless-stopped
    command: server /data --console-address ':9001'
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: minioadmin
    ports:
      - '9000:9000'
      - '9001:9001'
    volumes:
      - minio_data:/data

  # ==================== EMAIL (testing) ====================
  mailhog:
    image: mailhog/mailhog:latest
    restart: unless-stopped
    ports:
      - '1025:1025'  # SMTP
      - '8025:8025'  # Web UI

  # ==================== API BACKEND ====================
  api:
    build:
      context: .
      dockerfile: apps/api/Dockerfile
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      NODE_ENV: development
      PORT: 3000
      DATABASE_URL: postgresql://chatapp:chatapp_dev_password@postgres:5432/chatapp
      REDIS_URL: redis://redis:6379
      MEILISEARCH_URL: http://meilisearch:7700
      MEILISEARCH_KEY: meili_dev_key
      S3_ENDPOINT: http://minio:9000
      S3_ACCESS_KEY: minioadmin
      S3_SECRET_KEY: minioadmin
      S3_BUCKET: chatapp-files
      JWT_SECRET: dev_jwt_secret_change_in_prod
      ENCRYPTION_KEY: dev_encryption_key_32_bytes_long!!
      OPENAI_API_KEY: ${OPENAI_API_KEY}
    ports:
      - '3000:3000'
    volumes:
      - ./apps/api/src:/app/apps/api/src
      - ./libs:/app/libs
    command: npm run start:dev --workspace=api

  # ==================== WEBSOCKET SERVER ====================
  websocket:
    build:
      context: .
      dockerfile: apps/realtime/Dockerfile
    restart: unless-stopped
    depends_on:
      redis:
        condition: service_healthy
    environment:
      NODE_ENV: development
      PORT: 3001
      REDIS_URL: redis://redis:6379
      JWT_SECRET: dev_jwt_secret_change_in_prod
    ports:
      - '3001:3001'
    volumes:
      - ./apps/realtime/src:/app/apps/realtime/src
    command: npm run start:dev --workspace=realtime

  # ==================== WORKERS (background jobs) ====================
  workers:
    build:
      context: .
      dockerfile: apps/workers/Dockerfile
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      NODE_ENV: development
      DATABASE_URL: postgresql://chatapp:chatapp_dev_password@postgres:5432/chatapp
      REDIS_URL: redis://redis:6379
      MEILISEARCH_URL: http://meilisearch:7700
      S3_ENDPOINT: http://minio:9000
      S3_ACCESS_KEY: minioadmin
      S3_SECRET_KEY: minioadmin
      OPENAI_API_KEY: ${OPENAI_API_KEY}
    volumes:
      - ./apps/workers/src:/app/apps/workers/src
      - ./libs:/app/libs
    command: npm run start:dev --workspace=workers

  # ==================== WEB FRONTEND ====================
  web:
    build:
      context: .
      dockerfile: apps/web/Dockerfile
    restart: unless-stopped
    depends_on:
      - api
    environment:
      NODE_ENV: development
      NEXT_PUBLIC_API_URL: http://localhost:3000/api/v1
      NEXT_PUBLIC_WS_URL: http://localhost:3001
    ports:
      - '3002:3000'
    volumes:
      - ./apps/web/src:/app/apps/web/src
    command: npm run dev --workspace=web

  # ==================== REVERSE PROXY ====================
  nginx:
    image: nginx:alpine
    restart: unless-stopped
    depends_on:
      - api
      - websocket
      - web
    ports:
      - '80:80'
    volumes:
      - ./nginx/nginx.dev.conf:/etc/nginx/nginx.conf:ro

volumes:
  postgres_data:
  redis_data:
  meili_data:
  minio_data:
🔹 Nginx Config (Desarrollo)
# nginx/nginx.dev.conf

worker_processes auto;

events {
  worker_connections 1024;
}

http {
  upstream api_backend {
    server api:3000;
  }

  upstream ws_backend {
    server websocket:3001;
  }

  upstream web_frontend {
    server web:3000;
  }

  server {
    listen 80;
    server_name localhost;

    # API REST
    location /api/ {
      proxy_pass http://api_backend;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;
    }

    # WebSocket
    location /socket.io/ {
      proxy_pass http://ws_backend;
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_read_timeout 86400;  # 24h para conexiones largas
    }

    # Web frontend (Next.js)
    location / {
      proxy_pass http://web_frontend;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";
    }
  }
}
🔹 Dockerfile del API
# apps/api/Dockerfile

# ============ BUILD STAGE ============
FROM node:20-alpine AS builder

WORKDIR /app

# Copiar package.json y lock files
COPY package.json package-lock.json turbo.json ./
COPY apps/api/package.json ./apps/api/
COPY libs/database/package.json ./libs/database/
COPY libs/redis/package.json ./libs/redis/
COPY libs/types/package.json ./libs/types/
COPY libs/utils/package.json ./libs/utils/

# Instalar dependencias
RUN npm ci

# Copiar código fuente
COPY . .

# Build
RUN npm run build --workspace=api

# ============ PRODUCTION STAGE ============
FROM node:20-alpine AS production

WORKDIR /app

# Copiar solo lo necesario
COPY --from=builder /app/package.json ./
COPY --from=builder /app/package-lock.json ./
COPY --from=builder /app/apps/api/dist ./apps/api/dist
COPY --from=builder /app/apps/api/package.json ./apps/api/
COPY --from=builder /app/libs ./libs
COPY --from=builder /app/node_modules ./node_modules

# Variables de entorno
ENV NODE_ENV=production
ENV PORT=3000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1

EXPOSE 3000

CMD ["node", "apps/api/dist/main.js"]
7.2 KUBERNETES: DEPLOYMENT DE PRODUCCIÓN
🔹 Namespace y ConfigMaps
# k8s/namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: chatapp
  labels:
    name: chatapp

---
# k8s/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: chatapp-config
  namespace: chatapp
data:
  NODE_ENV: "production"
  DATABASE_POOL_SIZE: "20"
  REDIS_PREFIX: "chatapp"
  MEILISEARCH_URL: "http://meilisearch:7700"
  S3_ENDPOINT: "https://s3.us-east-1.amazonaws.com"
  S3_BUCKET: "chatapp-production-files"
  WS_URL: "wss://ws.chatapp.com"
  API_URL: "https://api.chatapp.com"
  WEB_URL: "https://app.chatapp.com"
🔹 API Deployment
# k8s/api-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: chatapp-api
  namespace: chatapp
  labels:
    app: chatapp
    component: api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: chatapp
      component: api
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: chatapp
        component: api
    spec:
      containers:
        - name: api
          image: registry.digitalocean.com/chatapp/api:latest
          ports:
            - containerPort: 3000
          envFrom:
            - configMapRef:
                name: chatapp-config
            - secretRef:
                name: chatapp-secrets
          resources:
            requests:
              cpu: 250m
              memory: 512Mi
            limits:
              cpu: 1000m
              memory: 1Gi
          readinessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 10
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 30
            periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: chatapp-api
  namespace: chatapp
spec:
  selector:
    app: chatapp
    component: api
  ports:
    - port: 80
      targetPort: 3000
  type: ClusterIP

---
# Horizontal Pod Autoscaler
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: chatapp-api-hpa
  namespace: chatapp
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: chatapp-api
  minReplicas: 3
  maxReplicas: 20
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80
🔹 WebSocket Deployment (con sticky sessions)
# k8s/websocket-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: chatapp-websocket
  namespace: chatapp
  labels:
    app: chatapp
    component: websocket
spec:
  replicas: 3
  selector:
    matchLabels:
      app: chatapp
      component: websocket
  template:
    metadata:
      labels:
        app: chatapp
        component: websocket
    spec:
      containers:
        - name: websocket
          image: registry.digitalocean.com/chatapp/websocket:latest
          ports:
            - containerPort: 3001
          envFrom:
            - configMapRef:
                name: chatapp-config
            - secretRef:
                name: chatapp-secrets
          resources:
            requests:
              cpu: 500m
              memory: 1Gi
            limits:
              cpu: 2000m
              memory: 2Gi
          readinessProbe:
            httpGet:
              path: /health
              port: 3001
            initialDelaySeconds: 5
            periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: chatapp-websocket
  namespace: chatapp
  annotations:
    # Sticky sessions para WebSocket
    service.beta.kubernetes.io/do-loadbalancer-sticky-certificate-type: "none"
spec:
  selector:
    app: chatapp
    component: websocket
  ports:
    - port: 80
      targetPort: 3001
  type: ClusterIP
  sessionAffinity: ClientIP
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 3600  # 1 hora de sticky session
🔹 Ingress (con TLS y WebSocket support)
# k8s/ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: chatapp-ingress
  namespace: chatapp
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
    nginx.ingress.kubernetes.io/proxy-body-size: "100m"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "86400"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "86400"
    nginx.ingress.kubernetes.io/websocket-services: "chatapp-websocket"
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - app.chatapp.com
        - api.chatapp.com
        - ws.chatapp.com
      secretName: chatapp-tls
  rules:
    - host: app.chatapp.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: chatapp-web
                port:
                  number: 80
    - host: api.chatapp.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: chatapp-api
                port:
                  number: 80
    - host: ws.chatapp.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: chatapp-websocket
                port:
                  number: 80
🔹 PostgreSQL con replicación
# k8s/postgres-statefulset.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
  namespace: chatapp
spec:
  serviceName: postgres-headless
  replicas: 3  # 1 primary + 2 replicas
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:16-alpine
          ports:
            - containerPort: 5432
          env:
            - name: POSTGRES_DB
              value: chatapp
            - name: POSTGRES_USER
              valueFrom:
                secretKeyRef:
                  name: chatapp-secrets
                  key: postgres_user
            - name: POSTGRES_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: chatapp-secrets
                  key: postgres_password
          resources:
            requests:
              cpu: 1000m
              memory: 2Gi
            limits:
              cpu: 4000m
              memory: 8Gi
          volumeMounts:
            - name: postgres-data
              mountPath: /var/lib/postgresql/data
  volumeClaimTemplates:
    - metadata:
        name: postgres-data
      spec:
        accessModes: ['ReadWriteOnce']
        resources:
          requests:
            storage: 100Gi
        storageClassName: do-block-storage
7.3 CI/CD PIPELINE (GitHub Actions)
🔹 Pipeline completo
# .github/workflows/ci-cd.yml

name: CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

env:
  REGISTRY: registry.digitalocean.com/chatapp

jobs:
  # ==================== 1. LINT & TEST ====================
  lint-and-test:
    name: Lint, Type Check & Test
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16-alpine
        env:
          POSTGRES_DB: chatapp_test
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 5s
          --health-timeout 5s
          --health-retries 5
      redis:
        image: redis:7-alpine
        ports:
          - 6379:6379

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - run: npm ci

      - name: Type check
        run: npm run typecheck

      - name: Lint
        run: npm run lint

      - name: Run database migrations
        env:
          DATABASE_URL: postgresql://test:test@localhost:5432/chatapp_test
        run: npx prisma migrate deploy

      - name: Run tests
        env:
          DATABASE_URL: postgresql://test:test@localhost:5432/chatapp_test
          REDIS_URL: redis://localhost:6379
          JWT_SECRET: test_secret
        run: npm run test -- --coverage

      - name: Upload coverage
        uses: codecov/codecov-action@v3

  # ==================== 2. BUILD & PUSH IMAGES ====================
  build-and-push:
    name: Build & Push Docker Images
    needs: lint-and-test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
    strategy:
      matrix:
        service: [api, websocket, workers, web]

    steps:
      - uses: actions/checkout@v4

      - name: Install doctl
        uses: digitalocean/action-doctl@v2
        with:
          token: ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}

      - name: Log in to DO Container Registry
        run: doctl registry login --expiry-seconds 600

      - name: Build and push ${{ matrix.service }}
        uses: docker/build-push-action@v5
        with:
          context: .
          file: apps/${{ matrix.service }}/Dockerfile
          push: true
          tags: |
            ${{ env.REGISTRY }}/${{ matrix.service }}:${{ github.sha }}
            ${{ env.REGISTRY }}/${{ matrix.service }}:latest
          cache-from: type=registry,ref=${{ env.REGISTRY }}/${{ matrix.service }}:latest
          cache-to: type=inline

  # ==================== 3. DATABASE MIGRATIONS ====================
  migrate-database:
    name: Run Database Migrations
    needs: build-and-push
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    environment: production

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      - run: npm ci

      - name: Run migrations
        env:
          DATABASE_URL: ${{ secrets.PRODUCTION_DATABASE_URL }}
        run: npx prisma migrate deploy

      - name: Generate Prisma client
        run: npx prisma generate

  # ==================== 4. DEPLOY TO KUBERNETES ====================
  deploy:
    name: Deploy to Kubernetes
    needs: [build-and-push, migrate-database]
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    environment: production

    steps:
      - uses: actions/checkout@v4

      - name: Install doctl
        uses: digitalocean/action-doctl@v2
        with:
          token: ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}

      - name: Save kubeconfig
        run: doctl kubernetes cluster kubeconfig save ${{ secrets.K8S_CLUSTER_NAME }}

      - name: Update image tags in manifests
        run: |
          sed -i "s|:latest|:${{ github.sha }}|g" k8s/api-deployment.yaml
          sed -i "s|:latest|:${{ github.sha }}|g" k8s/websocket-deployment.yaml
          sed -i "s|:latest|:${{ github.sha }}|g" k8s/workers-deployment.yaml
          sed -i "s|:latest|:${{ github.sha }}|g" k8s/web-deployment.yaml

      - name: Apply Kubernetes manifests
        run: |
          kubectl apply -f k8s/namespace.yaml
          kubectl apply -f k8s/configmap.yaml
          kubectl apply -f k8s/api-deployment.yaml
          kubectl apply -f k8s/websocket-deployment.yaml
          kubectl apply -f k8s/workers-deployment.yaml
          kubectl apply -f k8s/web-deployment.yaml
          kubectl apply -f k8s/ingress.yaml

      - name: Wait for rollout
        run: |
          kubectl -n chatapp rollout status deployment/chatapp-api --timeout=300s
          kubectl -n chatapp rollout status deployment/chatapp-websocket --timeout=300s
          kubectl -n chatapp rollout status deployment/chatapp-workers --timeout=300s
          kubectl -n chatapp rollout status deployment/chatapp-web --timeout=300s

      - name: Verify deployment
        run: |
          kubectl -n chatapp get pods
          kubectl -n chatapp get services

  # ==================== 5. SMOKE TESTS ====================
  smoke-tests:
    name: Smoke Tests
    needs: deploy
    runs-on: ubuntu-latest

    steps:
      - name: Health check API
        run: |
          response=$(curl -s -o /dev/null -w "%{http_code}" https://api.chatapp.com/health)
          if [ "$response" != "200" ]; then
            echo "API health check failed with status $response"
            exit 1
          fi

      - name: Health check WebSocket
        run: |
          response=$(curl -s -o /dev/null -w "%{http_code}" https://ws.chatapp.com/health)
          if [ "$response" != "200" ]; then
            echo "WebSocket health check failed"
            exit 1
          fi

      - name: Health check Web
        run: |
          response=$(curl -s -o /dev/null -w "%{http_code}" https://app.chatapp.com)
          if [ "$response" != "200" ]; then
            echo "Web health check failed"
            exit 1
          fi

      - name: Notify Slack on success
        if: success()
        run: |
          curl -X POST -H 'Content-type: application/json' \
          --data '{"text":"✅ Deployment successful to production!"}' \
          ${{ secrets.DEPLOY_WEBHOOK_URL }}

      - name: Notify Slack on failure
        if: failure()
        run: |
          curl -X POST -H 'Content-type: application/json' \
          --data '{"text":"❌ Deployment FAILED! Check GitHub Actions."}' \
          ${{ secrets.DEPLOY_WEBHOOK_URL }}
7.4 MONITOREO Y OBSERVABILIDAD
🔹 Stack de observabilidad
┌─────────────────────────────────────────────────────────────┐
│                 OBSERVABILIDAD STACK                         │
│                                                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │Prometheus│  │  Grafana │  │   Loki   │  │  Jaeger  │   │
│  │(métricas)│  │(dashboard)│  │  (logs)  │  │ (traces) │   │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘   │
│                                                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐                  │
│  │ AlertMgr │  │  Sentry  │  │ Uptime   │                  │
│  │(alertas) │  │ (errors) │  │ Kuma     │                  │
│  └──────────┘  └──────────┘  └──────────┘                  │
└─────────────────────────────────────────────────────────────┘
🔹 Métricas clave a monitorear
// apps/api/src/common/interceptors/metrics.interceptor.ts

import { PrometheusService } from '@/common/services/prometheus.service';

// Métricas a registrar:

// 1. HTTP metrics
const httpRequestDuration = new Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status_code'],
  buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
});

const httpRequestsTotal = new Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route', 'status_code'],
});

// 2. WebSocket metrics
const wsConnectionsActive = new Gauge({
  name: 'websocket_connections_active',
  help: 'Number of active WebSocket connections',
});

const wsMessagesSent = new Counter({
  name: 'websocket_messages_sent_total',
  help: 'Total WebSocket messages sent',
  labelNames: ['event_type'],
});

// 3. Business metrics
const messagesCreated = new Counter({
  name: 'messages_created_total',
  help: 'Total messages created',
  labelNames: ['workspace_id', 'channel_type'],
});

const activeUsers = new Gauge({
  name: 'active_users_online',
  help: 'Number of online users',
  labelNames: ['workspace_id'],
});

// 4. Database metrics
const dbQueryDuration = new Histogram({
  name: 'db_query_duration_seconds',
  help: 'Database query duration',
  labelNames: ['operation', 'table'],
  buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1],
});

// 5. Job queue metrics
const jobQueueSize = new Gauge({
  name: 'job_queue_size',
  help: 'Number of jobs in queue',
  labelNames: ['queue_name', 'state'], // active, waiting, delayed, failed
});

const jobProcessingDuration = new Histogram({
  name: 'job_processing_duration_seconds',
  help: 'Job processing time',
  labelNames: ['queue_name', 'job_name'],
});
🔹 Alertas críticas
# monitoring/alerts.yml

groups:
  - name: critical
    rules:
      # API down
      - alert: APIDown
        expr: up{job="chatapp-api"} == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "API is down"
          description: "API has been down for more than 1 minute"

      # WebSocket connections drop
      - alert: WebSocketConnectionsDrop
        expr: websocket_connections_active < 100
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "WebSocket connections dropped below 100"

      # High error rate
      - alert: HighErrorRate
        expr: rate(http_requests_total{status_code=~"5.."}[5m]) / rate(http_requests_total[5m]) > 0.05
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Error rate above 5%"

      # Database connections exhausted
      - alert: DBConnectionsExhausted
        expr: pg_stat_database_numbackends / pg_settings_max_connections > 0.8
        for: 5m
        labels:
          severity: critical

      # High response time
      - alert: HighResponseTime
        expr: histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m])) > 2
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "P99 response time above 2 seconds"

      # Disk space low
      - alert: DiskSpaceLow
        expr: 100 - (node_filesystem_avail_bytes / node_filesystem_size_bytes * 100) > 85
        for: 10m
        labels:
          severity: warning

      # Job queue backed up
      - alert: JobQueueBackedUp
        expr: job_queue_size{state="waiting"} > 1000
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Job queue has more than 1000 waiting jobs"

      # Memory usage high
      - alert: HighMemoryUsage
        expr: container_memory_working_set_bytes / container_spec_memory_limit_bytes > 0.85
        for: 10m
        labels:
          severity: warning
🔹 Grafana Dashboards (queries importantes)
# 1. Active WebSocket connections (tiempo real)
websocket_connections_active

# 2. Messages per second
rate(messages_created_total[1m])

# 3. API response time P50/P95/P99
histogram_quantile(0.50, rate(http_request_duration_seconds_bucket[5m]))
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))
histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m]))

# 4. Online users
active_users_online

# 5. Error rate
rate(http_requests_total{status_code=~"5.."}[5m]) / rate(http_requests_total[5m]) * 100

# 6. Database queries per second
rate(db_query_duration_seconds_count[1m])

# 7. Job queue health
job_queue_size{state="waiting"}
job_queue_size{state="active"}
job_queue_size{state="failed"}

# 8. CPU/Memory por pod
rate(container_cpu_usage_seconds_total[5m]) * 100
container_memory_working_set_bytes / container_spec_memory_limit_bytes * 100
7.5 BACKUP Y DISASTER RECOVERY
🔹 Estrategia de Backup
┌─────────────────────────────────────────────────────────────┐
│                ESTRATEGIA DE BACKUP                          │
│                                                              │
│  PostgreSQL:                                                 │
│  ├── Backup completo: diario a las 3 AM (cron)               │
│  ├── WAL archiving: continuo (Point-in-Time Recovery)        │
│  ├── Retención: 30 días de backups diarios                   │
│  ├── Retención: 12 backups mensuales                         │
│  ├── Almacenamiento: S3 en región diferente                  │
│  └── Restore test: mensual (automated)                       │
│                                                              │
│  Redis:                                                      │
│  ├── Snapshot: cada 6 horas                                  │
│  ├── AOF (Append Only File): habilitado                      │
│  └── Retención: 7 días                                       │
│                                                              │
│  S3 / MinIO (archivos):                                      │
│  ├── Versioning: habilitado                                  │
│  ├── Cross-region replication: a región secundaria           │
│  ├── Lifecycle: mover a Glacier después de 90 días           │
│  └── Retención: configurable por workspace                   │
│                                                              │
│  Configuración Kubernetes:                                   │
│  ├── GitOps: toda la config está en Git (ArgoCD)             │
│  └── Secrets: respaldados en Vault                            │
└─────────────────────────────────────────────────────────────┘
🔹 Script de Backup automatizado
#!/bin/bash
# scripts/backup-postgres.sh

set -euo pipefail

DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="chatapp_pg_backup_${DATE}.sql.gz"
S3_BUCKET="s3://chatapp-backups/postgres"
RETENTION_DAYS=30

echo "📦 Starting PostgreSQL backup..."

# 1. Crear dump comprimido
kubectl -n chatapp exec postgres-0 -- pg_dump -U chatapp -d chatapp --format=custom | gzip > /tmp/${BACKUP_FILE}

# 2. Subir a S3
aws s3 cp /tmp/${BACKUP_FILE} ${S3_BUCKET}/${BACKUP_FILE} --storage-class STANDARD_IA

# 3. Limpiar backups antiguos
echo "🧹 Cleaning backups older than ${RETENTION_DAYS} days..."
aws s3 ls ${S3_BUCKET}/ | awk '{print $4}' | while read file; do
  file_date=$(echo $file | grep -oP '\d{8}')
  if [ $(date -d "${file_date:0:4}-${file_date:4:2}-${file_date:6:2}" +%s 2>/dev/null) ]; then
    age=$(( ($(date +%s) - $(date -d "${file_date:0:4}-${file_date:4:2}-${file_date:6:2}" +%s)) / 86400 ))
    if [ $age -gt $RETENTION_DAYS ]; then
      echo "Deleting old backup: $file"
      aws s3 rm ${S3_BUCKET}/${file}
    fi
  fi
done

# 4. Limpiar archivo local
rm /tmp/${BACKUP_FILE}

# 5. Notificar
echo "✅ Backup completed: ${BACKUP_FILE}"
curl -X POST -H 'Content-type: application/json' \
  --data "{\"text\":\"✅ DB Backup completed: ${BACKUP_FILE}\"}" \
  ${BACKUP_WEBHOOK_URL}
🔹 Plan de Disaster Recovery
RTO (Recovery Time Objective): 1 hora
RPO (Recovery Point Objective): 15 minutos (con WAL archiving)

Escenarios:
├── Falla de un pod → Auto-restart por Kubernetes (segundos)
├── Falla de un nodo K8s → Pods reprogramados en otros nodos (minutos)
├── Falla de AZ → Arquitectura celular, drain de AZ (5 minutos)
├── Falla de región → DNS failover a región secundaria (30-60 min)
│   ├── S3: cross-region replication ya activa
│   ├── PostgreSQL: promote replica en región secundaria
│   ├── Redis: nueva cluster en región secundaria
│   └── K8s: desplegar manifests en región secundaria
└── Corrupción de datos → Point-in-Time Recovery desde backup (30 min)
7.6 ESTRATEGIAS DE ESCALABILIDAD
🔹 Por componente
┌──────────────────┬───────────────────┬──────────────────────────────────┐
│ Componente       │ Escalado          │ Estrategia                        │
├──────────────────┼───────────────────┼──────────────────────────────────┤
│ API Server       │ Horizontal        │ HPA: 3-20 pods, CPU >70%          │
│ WebSocket Server │ Horizontal        │ HPA: 3-15 pods, conexiones/pod    │
│ Workers          │ Horizontal        │ HPA basado en queue size          │
│ Web (Next.js)    │ Horizontal        │ HPA: 2-10 pods                    │
│ PostgreSQL       │ Vertical + Read   │ Read replicas, partitioning       │
│                  │ Replicas          │ Citus sharding (fase 3)           │
│ Redis            │ Cluster mode      │ 3 primary + 3 replica             │
│ Meilisearch/ES   │ Horizontal        │ N nodos, index por workspace      │
│ S3/MinIO         │ Infinito          │ Auto-expanding storage            │
│ CDN              │ Global            │ Cloudflare edge nodes             │
└──────────────────┴───────────────────┴──────────────────────────────────┘
🔹 Estrategias de caching
┌──────────────────────────────────────────────────────────────┐
│                    NIVELES DE CACHE                           │
│                                                               │
│  Nivel 1: CDN (Cloudflare)                                    │
│  ├── Assets estáticos (JS, CSS, imágenes): TTL 1 año         │
│  ├── Páginas SSR (channel list): TTL 60s                     │
│  └── API responses públicas: TTL 5s                          │
│                                                               │
│  Nivel 2: Application Cache (Redis)                           │
│  ├── User profile: TTL 5 min                                 │
│  ├── Channel list per user: TTL 5 min                        │
│  ├── Channel members: TTL 5 min                              │
│  ├── Workspace settings: TTL 10 min                          │
│  ├── Presence: TTL 60s (con heartbeat)                      │
│  └── Rate limit counters: TTL 60s                            │
│                                                               │
│  Nivel 3: Database Cache (PostgreSQL shared buffers)         │
│  ├── Hot data en RAM (~25% de RAM dedicada)                  │
│  └── Connection pooling (PgBouncer)                          │
│                                                               │
│  Nivel 4: Client Cache (browser/device)                      │
│  ├── Zustand persist (últimos 50 mensajes por canal)        │
│  ├── Service Worker (assets offline)                        │
│  └── HTTP cache headers (ETag, Last-Modified)               │
└──────────────────────────────────────────────────────────────┘
7.7 ROADMAP COMPLETO DEL PROYECTO
🔹 Fases de desarrollo con timelines
FASE 0: PLANIFICACIÓN Y SETUP (Semanas 1-2)
├── Definir requisitos finales
├── Setup del monorepo (Turborepo)
├── Configurar Docker Compose dev
├── Setup CI/CD básico (lint, test)
├── Diseño final de base de datos
└── Prisma schema + migraciones iniciales

FASE 1: MVP CORE (Semanas 3-10)
├── Auth: registro, login, JWT, refresh tokens
├── Workspaces: crear, invitar miembros, roles
├── Canales: crear, unirse, salir, archivar
├── Mensajes: enviar, editar, borrar, paginación
├── WebSocket: conexión, broadcast, rooms
├── Presencia: online/offline, heartbeat
├── DMs: mensajes directos 1:1 y grupales
├── Threads: replies anidadas
├── Reacciones: emoji reactions
├── File upload: básico (imágenes, PDFs)
├── Notificaciones: push básico
├── Sidebar: lista de canales, DMs, unread counts
├── Search: básico (Meilisearch)
└── Frontend web completo (React + Next.js)

FASE 2: FEATURES AVANZADAS (Semanas 11-20)
├── Block Kit: renderer completo
├── Mensajes programados
├── Saved items / bookmarks
├── Pin messages
├── Channel bookmarks
├── Custom emojis
├── User groups (@mentions de grupo)
├── Status custom (emoji + texto)
├── Slash commands
├── Link unfurling
├── Typing indicators
├── Keyboard shortcuts
├── Command palette (quick switcher)
├── Desktop app (Tauri)
├── Mobile app (React Native)
├── Push notifications nativas
├── Email notifications
├── DND (Do Not Disturb)
├── Notification preferences granulares
└── Dark/light theme

FASE 3: COLABORACIÓN Y GESTIÓN (Semanas 21-30)
├── Lists (tareas estilo Trello/Asana)
├── Canvas (documentos colaborativos con TipTap)
├── Templates (onboarding, project, etc.)
├── Huddles (audio/video con Mediasoup)
├── Screen sharing
├── Huddle chat
├── Slack Connect (shared channels)
├── DMs externos
├── Guest accounts
├── Admin dashboard (analytics)
├── User management avanzado
├── Channel management admin
├── Audit logs
├── Data export
└── Data retention policies

FASE 4: AUTOMATIZACIÓN E INTEGRACIONES (Semanas 31-40)
├── Workflow Builder (no-code, drag & drop)
├── Workflow templates
├── Conditional branching en workflows
├── Incoming webhooks
├── Outgoing webhooks
├── Event subscriptions
├── Interactive components (botones, modals)
├── Bot users
├── App Directory (marketplace)
├── OAuth 2.0 flow para apps externas
├── Integraciones iniciales: Google Drive, GitHub, Jira
├── Integraciones: Zoom, Google Calendar, Asana
├── Public API (REST)
├── SDK npm (@chatapp/sdk)
└── Developer documentation

FASE 5: IA Y INTELIGENCIA (Semanas 41-50)
├── Embeddings generation (pgvector)
├── AI Search (preguntas en lenguaje natural)
├── Channel summaries (IA)
├── Thread summaries (IA)
├── Huddle notes (transcripción + resumen)
├── Daily recaps automáticos
├── File summaries
├── Translations
├── Slackbot (chatbot con RAG)
├── Workflow generation con IA
├── Sentiment analysis (opcional)
└── MCP (Model Context Protocol) para conectar tools

FASE 6: SEGURIDAD Y ENTERPRISE (Semanas 51-60)
├── 2FA (TOTP + backup codes)
├── SSO (SAML 2.0)
├── SCIM provisioning
├── Enterprise Key Management (EKM)
├── Information barriers
├── Legal holds
├── DLP (Data Loss Prevention)
├── HIPAA compliance
├── Data residency (multi-region)
├── Custom roles
├── Content flagging
├── Anomaly detection
└── Security audit completo

FASE 7: ESCALA Y OPTIMIZACIÓN (Semanas 61-70)
├── PostgreSQL partitioning (messages por mes)
├── Citus sharding (shard por channel_id)
├── Migrar Meilisearch → Elasticsearch
├── Arquitectura celular (AZ isolation)
├── Consistent hashing para WebSocket (Channel Servers)
├── Edge cache (estilo Flannel)
├── Kafka para event streaming
├── ClickHouse para analytics
├── Performance optimization (query tuning)
├── Load testing (k6)
├── Chaos engineering
├── Multi-region deployment
└── 99.99% uptime SLA
🔹 Timeline visual
Mes:  1    2    3    4    5    6    7    8    9    10   11   12   13   14   15   16   17   18
      │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │
      ├────┤    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │
      │F0  │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │
      │ ├──┼────┤    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │ F1 │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │ MVP│    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    ├────┤    │    │    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │ F2 │    │    │    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │ADV │    │    │    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    ├────┤    │    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │ F3 │    │    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │ COL│    │    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    ├────┤    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │ F4 │    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │ AUT│    │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │    ├────┤    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │    │ F5 │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │    │ AI │    │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │    │    ├────┤    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │    │    │ F6 │    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │    │    │ SEC│    │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │    │    │    ├────┤    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │    │    │    │ F7 │    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │    │    │    │ SCA│    │    │    │    │    │    │    │    │    │
      │ │  │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │
      └─┘  └────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

TOTAL: ~18 meses para sistema completo tipo Slack (todas las features)

NOTA: Con un equipo de 5-8 desarrolladores.
      Solo: 24-30 meses (pero MVP usable en 8 semanas).
7.8 ESTIMACIÓN DE COSTOS DE INFRAESTRUCTURA
🔹 Opción A: DigitalOcean (recomendado para empezar)
┌──────────────────────────────┬──────────────┬──────────────────┐
│ Recurso                      │ Cantidad     │ Costo/mes        │
├──────────────────────────────┼──────────────┼──────────────────┤
│ K8s Cluster (DOKS)           │ 1 cluster    │ $48              │
│ Worker Nodes (4 vCPU/8GB)    │ 3 nodos      │ $72 ($24 c/u)    │
│ Managed PostgreSQL           │ 1 (2GB RAM)  │ $60              │
│ Managed Redis                │ 1 (1GB)      │ $30              │
│ Spaces (Object Storage S3)   │ 250GB        │ $5               │
│ Load Balancer                │ 1            │ $12              │
│ Cloudflare (Pro)             │ 1            │ $20              │
│ ──────────────────────────── │ ──────────── │ ──────────────── │
│ TOTAL FASE 1 (MVP)           │              │ ~$247/mes        │
└──────────────────────────────┴──────────────┴──────────────────┘

FASE 3 (crecimiento):
├── Worker Nodes: 6 nodos → +$144/mes
├── PostgreSQL: 4GB → +$40/mes
├── Redis: 2GB → +$30/mes
├── Spaces: 1TB → +$5/mes
└── TOTAL: ~$466/mes

FASE 5 (escala):
├── Worker Nodes: 12 nodos → +$288/mes
├── PostgreSQL: 8GB + 2 replicas → +$200/mes
├── Redis: 4GB cluster → +$100/mes
├── Elasticsearch: 3 nodos → +$100/mes
├── Spaces: 5TB → +$25/mes
├── Bandwidth: 10TB → $50
└── TOTAL: ~$1,100/mes
🔹 Opción B: AWS (para escala enterprise)
┌──────────────────────────────┬──────────────┬──────────────────┐
│ Recurso                      │ Cantidad     │ Costo/mes        │
├──────────────────────────────┼──────────────┼──────────────────┤
│ EKS Cluster                  │ 1            │ $73              │
│ EC2 Nodes (t3.large)         │ 6            │ $180             │
│ RDS PostgreSQL               │ 1 (8GB)      │ $180             │
│ ElastiCache Redis            │ 1 (2GB)      │ $80              │
│ S3 Storage                   │ 1TB          │ $23              │
│ ALB (Load Balancer)          │ 1            │ $25              │
│ CloudFront                   │ 10TB egress  │ $85              │
│ Route 53                     │ 1 zone       │ $5               │
│ OpenAI API (GPT-4o)          │ ~1M tokens   │ $150             │
│ SES (email)                  │ 10K emails   │ $10              │
│ ──────────────────────────── │ ──────────── │ ──────────────── │
│ TOTAL FASE 3                 │              │ ~$811/mes        │
└──────────────────────────────┴──────────────┴──────────────────┘

FASE 5 (escala enterprise):
├── EC2 Nodes: 20 → +$420/mes
├── RDS: 32GB + 3 replicas → +$1,200/mes
├── ElastiCache: 8GB cluster → +$320/mes
├── OpenSearch: 3 nodos → +$350/mes
├── S3: 10TB → +$230/mes
├── CloudFront: 50TB → +$425/mes
├── OpenAI API: 10M tokens → ~$1,500/mes
└── TOTAL: ~$5,000-8,000/mes
🔹 Costos de servicios externos
┌──────────────────────────┬──────────────────────────────────┐
│ Servicio                 │ Costo                             │
├──────────────────────────┼──────────────────────────────────┤
│ OpenAI GPT-4o            │ $5/1M input, $15/1M output       │
│ OpenAI Embeddings        │ $0.02/1M tokens                  │
│ Whisper (transcripción)  │ $0.006/minuto de audio           │
│ FCM (push Android)       │ Gratis                            │
│ APNs (push iOS)          │ Gratis                            │
│ Stripe (pagos)           │ 2.9% + $0.30 por transacción     │
│ Twilio (SMS 2FA)         │ $0.05 por SMS                    │
│ Sentry (error tracking)  │ $26/mes (Team plan)              │
│ Cloudflare Pro           │ $20/mes                           │
│ Domain (chatapp.com)     │ $12/año                           │
└──────────────────────────┴──────────────────────────────────┘
7.9 CHECKLIST FINAL: TODO LO QUE NECESITAS CONSTRUIR
🔹 Checklist organizado por prioridad
┌─────────────────────────────────────────────────────────────────────┐
│  FASE 1 - MVP (Debe tener para ser usable)                         │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  AUTENTICACIÓN                                                      │
│  □ Registro de usuarios con email + password                       │
│  □ Login con JWT + refresh tokens                                 │
│  □ Logout + revocación de sesiones                                │
│  □ Recuperación de contraseña                                     │
│  □ Verificación de email                                          │
│                                                                     │
│  WORKSPACES                                                         │
│  □ Crear workspace                                                 │
│  □ Invitar miembros por email                                     │
│  □ Roles: owner, admin, member                                    │
│  □ Configuración básica del workspace                             │
│                                                                     │
│  CANALES                                                            │
│  □ Crear canal público/privado                                    │
│  □ Unirse/salir de canales                                        │
│  □ Archivar/desarchivar canales                                   │
│  □ Topic y purpose del canal                                      │
│  □ Lista de miembros del canal                                    │
│  □ Invitar usuarios a canal                                       │
│                                                                     │
│  MENSAJES                                                           │
│  □ Enviar mensaje de texto                                        │
│  □ Editar mensaje                                                  │
│  □ Borrar mensaje                                                  │
│  □ Threads (respuestas anidadas)                                  │
│  □ Mentions (@user, @channel, @here)                              │
│  □ Formato básico (bold, italic, code)                            │
│  □ Paginación con cursor (infinite scroll)                        │
│                                                                     │
│  TIEMPO REAL                                                        │
│  □ Conexión WebSocket persistente                                 │
│  □ Broadcast de mensajes en tiempo real                           │
│  □ Presencia (online/offline)                                     │
│  □ Typing indicators                                              │
│  □ Auto-reconnect                                                 │
│                                                                     │
│  DMs                                                                │
│  □ Mensajes directos 1:1                                          │
│  □ Group DMs (hasta 9 personas)                                   │
│                                                                     │
│  REACCIONES                                                         │
│  □ Agregar/quitar reacciones emoji                                │
│                                                                     │
│  ARCHIVOS                                                           │
│  □ Upload de archivos (drag & drop)                               │
│  □ Preview de imágenes                                            │
│  □ Compartir archivos en canales                                  │
│                                                                     │
│  FRONTEND                                                           │
│  □ Sidebar con canales y DMs                                      │
│  □ Vista de canal (messages + input)                              │
│  □ Unread counts en sidebar                                       │
│  □ Búsqueda de mensajes                                           │
│  □ Dark/light theme                                               │
│  □ Responsive (mobile web)                                        │
│                                                                     │
│  INFRAestructura                                                    │
│  □ Docker Compose funcionando                                     │
│  □ Migraciones de BD                                              │
│  □ CI/CD básico (lint + test)                                    │
│  □ Health check endpoints                                         │
│                                                                     │
├─────────────────────────────────────────────────────────────────────┤
│  FASE 2 - FEATURES AVANZADAS (Hacerlo competitivo)                 │
├─────────────────────────────────────────────────────────────────────┤
│  □ Block Kit renderer                                             │
│  □ Mensajes programados                                           │
│  □ Saved items / bookmarks                                        │
│  □ Pin messages                                                   │
│  □ Custom emojis                                                  │
│  □ User groups                                                    │
│  □ Status custom                                                  │
│  □ Slash commands                                                 │
│  □ Link unfurling                                                 │
│  □ Command palette (quick switcher)                              │
│  □ Desktop app (Tauri)                                           │
│  □ Mobile app (React Native)                                     │
│  □ Push notifications (FCM + APNs)                               │
│  □ Email notifications                                            │
│  □ DND schedules                                                  │
│  □ Notification preferences granulares                            │
│  □ Keyboard shortcuts                                             │
├─────────────────────────────────────────────────────────────────────┤
│  FASE 3 - COLABORACIÓN (Hacerlo potente)                          │
├─────────────────────────────────────────────────────────────────────┤
│  □ Lists (tareas estilo Trello/Asana)                             │
│  □ Canvas (documentos colaborativos)                              │
│  □ Templates                                                      │
│  □ Huddles (audio/video con WebRTC)                               │
│  □ Screen sharing                                                 │
│  □ Slack Connect (shared channels)                                │
│  □ Guest accounts                                                 │
│  □ Admin dashboard + analytics                                    │
│  □ Audit logs                                                     │
│  □ Data export                                                    │
│  □ Data retention policies                                        │
├─────────────────────────────────────────────────────────────────────┤
│  FASE 4 - AUTOMATIZACIÓN (Hacerlo inteligente)                    │
├─────────────────────────────────────────────────────────────────────┤
│  □ Workflow Builder (no-code)                                     │
│  □ Workflow templates                                             │
│  □ Conditional branching                                          │
│  □ Incoming/outgoing webhooks                                     │
│  □ Event subscriptions                                            │
│  □ Interactive components (botones, modals)                       │
│  □ Bot users                                                      │
│  □ App Directory                                                  │
│  □ OAuth 2.0 para apps externas                                   │
│  □ Integraciones: Google, GitHub, Jira, Zoom                      │
│  □ Public API + SDK npm                                           │
├─────────────────────────────────────────────────────────────────────┤
│  FASE 5 - IA (Hacerlo revolucionario)                            │
├─────────────────────────────────────────────────────────────────────┤
│  □ Embeddings (pgvector)                                          │
│  □ AI Search (lenguaje natural)                                   │
│  □ Channel summaries                                              │
│  □ Thread summaries                                               │
│  □ Huddle notes (transcripción)                                   │
│  □ Daily recaps                                                   │
│  □ File summaries                                                 │
│  □ Translations                                                   │
│  □ Slackbot (chatbot con RAG)                                     │
│  □ Workflow generation con IA                                     │
├─────────────────────────────────────────────────────────────────────┤
│  FASE 6 - ENTERPRISE (Hacerlo seguro y vendible a grandes corp)   │
├─────────────────────────────────────────────────────────────────────┤
│  □ 2FA (TOTP)                                                     │
│  □ SSO (SAML 2.0)                                                 │
│  □ SCIM provisioning                                              │
│  □ Enterprise Key Management                                      │
│  □ Information barriers                                           │
│  □ Legal holds                                                    │
│  □ DLP (Data Loss Prevention)                                     │
│  □ HIPAA compliance                                               │
│  □ Data residency (multi-region)                                  │
│  □ Custom roles                                                   │
├─────────────────────────────────────────────────────────────────────┤
│  FASE 7 - ESCALA (Hacerlo capaz de millones de usuarios)          │
├─────────────────────────────────────────────────────────────────────┤
│  □ PostgreSQL partitioning                                        │
│  □ Citus sharding                                                 │
│  □ Elasticsearch (migrar de Meilisearch)                         │
│  □ Arquitectura celular (AZ isolation)                           │
│  □ Consistent hashing WebSocket                                   │
│  □ Edge cache (estilo Flannel)                                    │
│  □ Kafka event streaming                                          │
│  □ ClickHouse analytics                                           │
│  □ Multi-region deployment                                        │
│  □ 99.99% uptime SLA                                             │
└─────────────────────────────────────────────────────────────────────┘
7.10 EQUIPO RECOMENDADO
🔹 Composición del equipo por fase
FASE 1 (MVP) - 8 semanas:
├── 1 Backend developer (Node.js/NestJS)
├── 1 Frontend developer (React/Next.js)
├── 1 Full-stack developer
└── 1 DevOps (part-time)

FASE 2-3 - 20 semanas:
├── 2 Backend developers
├── 2 Frontend developers
├── 1 Mobile developer (React Native)
├── 1 DevOps engineer
└── 1 UI/UX designer (part-time)

FASE 4-5 - 20 semanas:
├── 3 Backend developers
├── 2 Frontend developers
├── 1 Mobile developer
├── 1 AI/ML engineer
├── 1 DevOps engineer
├── 1 UI/UX designer
└── 1 Product manager

FASE 6-7 - 20 semanas:
├── 4 Backend developers
├── 2 Frontend developers
├── 1 Mobile developer
├── 1 AI/ML engineer
├── 1 Security engineer
├── 1 DevOps/SRE engineer
├── 1 UI/UX designer
└── 1 Product manager

TOTAL: 8-12 personas en pico
✅ RESUMEN FINAL DE TODAS LAS 7 PARTES
Parte	Contenido	Estado
Parte 1	Análisis completo de Slack: 100+ features, arquitectura técnica	✅
Parte 2	Arquitectura del sistema + Stack tecnológico + 13 servicios	✅
Parte 3	Base de datos: 53 tablas, 7 esquemas, índices, Redis, RLS	✅
Parte 4	Backend: 100+ endpoints API, WebSocket, workers, flujo de mensaje	✅
Parte 5	Frontend: Web (Next.js), Desktop (Tauri), Mobile (RN), stores, Block Kit	✅
Parte 6	Integraciones, Workflows, IA (RAG), Seguridad, Admin, Plataforma dev	✅
Parte 7	DevOps, K8s, CI/CD, monitoreo, backup, escalabilidad, roadmap, costos	✅