TablesBroker

TablesBroker es el broker central del SDK Tables. Coordina la comunicación con el servidor de Tables agrupando tres componentes: autenticación (AuthManager), sincronización (SyncManager) y monitoreo de red (NetworkMonitor). La desacople entre componentes se logra con un patrón de suscripción: la red notifica cambios de estado y el broker reacciona reconectando o marcando la conexión como caída.

Nota

El nombre “bus de eventos” aplica a dos mecanismos distintos del SDK: el patrón de listeners de NetworkMonitor que usa TablesBroker, y el ManagerEventBus, que es el bus real entre managers. Esta página cubre ambos; no existen métodos on()/emit() propios sobre TablesBroker.

Responsabilidades

TablesBroker no expone un bus genérico de publish/subscribe. Su rol es orquestar el ciclo de vida de la conexión:

• Autenticación: delega en AuthManager (login, token, reconexión con las últimas credenciales).
• Sincronización: inicializa y dispara SyncManager (auto-sync periódico y forceSynchronization()).
• Red: se suscribe a NetworkMonitor para reaccionar a cambios de conectividad y propagar latencia a la base de datos.

Se instancia una sola vez dentro de TablesCore y queda disponible como tablesCore.broker.

Construcción

new TablesBroker(
  database,        // instancia de Database
  apiUrl,          // URL del proxy/socket
  deviceInfo?,     // Partial<DeviceInfo> (id, name, type, os, ...)
  options?         // { autoReconnectDelay, pingInterval, syncInterval, debug }
);

Valores por defecto de options: autoReconnectDelay 30 000 ms, pingInterval 10 000 ms, syncInterval 300 000 ms, debug false. Si no se entrega deviceInfo.id, el broker genera uno con formato device_<timestamp>_<random> y detecta el sistema operativo del entorno.

API pública

Método	Descripción
connect(credentials?)	Inicia la conexión: autentica (si se entregan credenciales), inicializa SyncManager y arranca el auto-sync. Devuelve Promise<boolean>.
disconnect()	Cancela timers, detiene NetworkMonitor y auto-sync, y hace logout().
forceSynchronization()	Fuerza una sincronización inmediata si hay conexión. Devuelve Promise<boolean>.
isAuthenticated()	true si AuthManager tiene token vigente.
getConnectionStatus()	Estado consolidado: connected, network, lastSyncTime, device, pendingSyncItems.
checkConnection(host)	Hace un GET al host y devuelve si respondió ok.

Además expone públicamente networkMonitor y authManager para que otros componentes accedan a sus listeners y tokens.

Patrón de suscripción interno (red)

El acoplamiento entre red, sincronización y conexión se resuelve con un único listener registrado en el constructor vía setupEventListeners():

1. NetworkMonitor.onStatusChange(listener) registra una función que recibe un NetworkInfo (status, online, latency, lastCheck).

2. En cada cambio, el broker llama database.updateNetworkLatency(status.latency) para ajustar dinámicamente el tamaño de los batches de sync.

3. Si la red vuelve y no hay conexión, programa una reconexión (scheduleReconnect) usando las últimas credenciales guardadas.

4. Si la red se cae estando conectado, marca isConnected = false.

Precaución

La reconexión automática está gateada por RETRY_CONFIG.tableBrokerReconnect. En desarrollo suele estar deshabilitada para evitar spam de errores, por lo que el broker no reintenta solo aunque haya credenciales guardadas.

NetworkStatusListener es el tipo del callback:

type NetworkStatusListener = (status: NetworkInfo) => void;

El bus de eventos entre managers

La comunicación desacoplada entre managers no pasa por TablesBroker, sino por ManagerEventBus, un singleton basado en RxJS. Los managers emiten un ManagerEvent cuando ejecutan mutaciones (create, update, delete, etc.), y otros componentes se suscriben de forma reactiva.

import { managerEventBus } from '../events';

// Identificar el dispositivo origen de los eventos
managerEventBus().setDeviceId('device_123');

// Suscribirse a todos los eventos
managerEventBus().onEvent().subscribe((event) => {
  console.log(event.action, event.documentType, event.documentId);
});

// Filtrar por tipo de documento
managerEventBus().onEventByType('order').subscribe(handleOrderEvent);

Métodos de suscripción y emisión

Método	Rol
emit(event)	Publica un evento; auto-genera eventId, timestamp y sourceDeviceId.
emitCompletion(eventId, action, documentType)	Señala que una acción bloqueante terminó (liberar locks en otros dispositivos).
onEvent()	Observable de todos los eventos.
onEventByType(documentType)	Filtra por tipo de documento (order, table, …).
onEventByAction(action)	Filtra por acción (create, update, delete, …).
onEventByTypeAndAction(type, action)	Filtra por ambos.
onCompletionEvent()	Observable de eventos de finalización.
enable() / disable() / isEnabled()	Habilita o pausa la emisión global.

Forma de un ManagerEvent

interface ManagerEvent<T = unknown> {
  eventId: string;        // único, auto-generado (nanoid)
  action: string;         // método invocado: 'create', 'update', 'addItem', ...
  documentType: string;   // 'order', 'table', 'product', ...
  documentId?: string;    // id del documento afectado
  data?: T;               // payload (según EventConfig.includeData)
  timestamp: string;      // ISO
  sourceDeviceId?: string;// dispositivo origen
  args?: unknown[];       // argumentos del método (debug)
}

Consejo

DEFAULT_EVENT_CONFIG excluye lecturas (getAll, getById, find, observables, métodos de caché). Esto evita que listeners reactivos disparen queries que el server reenvía y amplifican el ciclo entre dispositivos.

Estos eventos son la base de la sincronización en tiempo real: el SDK los reenvía vía WebSocket para que cada dispositivo refleje las mutaciones de los demás. Para el detalle del flujo de datos, ver sincronización.

Relación con otros brokers

Brokers del SDK AuthManager, SyncManager, NetworkMonitor y TablesBroker.