Saltar al contenido

Nivel intermedio · 8 a 10 horas de práctica · Actualizada el

Aplicaciones web que funcionan sin conexión

Cómo diseñar aplicaciones web y móviles que siguen operando sin red y sincronizan los datos al recuperar la conexión: IndexedDB con Dexie.js, service workers, colas de sincronización y resolución de conflictos.

Al terminar podrás

  • Entender el enfoque de diseño «sin conexión primero» y cuándo conviene aplicarlo.
  • Guardar datos estructurados en el navegador con IndexedDB y Dexie.js.
  • Mostrar datos locales que se actualizan solos en una interfaz React.
  • Implementar una cola de sincronización con reintentos.
  • Elegir una estrategia de resolución de conflictos y cachear la aplicación con un service worker.

Conocimientos previos

  • JavaScript moderno, incluidas promesas y async/await.
  • Nociones de React (ver la guía «React desde cero»).
  • Conocimiento básico de API REST.

01 El enfoque «sin conexión primero»

En una aplicación tradicional, cada acción del usuario viaja al servidor y espera la respuesta. Si no hay red, la aplicación deja de funcionar.

En una aplicación diseñada «sin conexión primero» (offline-first), la fuente de verdad inmediata es una base de datos local en el dispositivo. La interfaz lee y escribe siempre ahí, y un proceso en segundo plano sincroniza con el servidor cuando hay conexión.

Cuándo conviene

  • Trabajo de campo en zonas rurales, costeras o de frontera con cobertura móvil intermitente.
  • Formularios que no pueden perderse: inspecciones, relevamientos, registros de actividad.
  • Aplicaciones que deben responder al instante aunque la red sea lenta.

Qué cuesta

  • Los datos existen en varios lugares a la vez, por lo que hay que resolver conflictos.
  • La interfaz debe comunicar con claridad qué está guardado sólo en el dispositivo y qué ya llegó al servidor.
  • Las pruebas deben cubrir cortes de red, reintentos y duplicados.

02 Dónde guardar los datos en el navegador

localStorage sólo guarda texto, tiene poca capacidad y bloquea la ejecución mientras lee o escribe: sirve para preferencias, no para datos de trabajo.

IndexedDB es la base de datos del navegador: guarda objetos estructurados y archivos binarios, admite índices y transacciones, y trabaja de forma asíncrona. Su API nativa es de bajo nivel, por eso suele usarse a través de Dexie.js, una biblioteca que la simplifica con promesas y consultas legibles.

Por defecto, el navegador puede borrar el almacenamiento de un sitio si el dispositivo se queda sin espacio. Para datos importantes conviene solicitar almacenamiento persistente:

if (navigator.storage?.persist) {
  const persistente = await navigator.storage.persist()
  console.log(persistente ? 'Almacenamiento persistente' : 'El navegador puede liberar estos datos')
}

03 Modelar la base local con Dexie.js

npm install dexie dexie-react-hooks
// db.js
import Dexie from 'dexie'

export const db = new Dexie('relevamientos')

db.version(1).stores({
  // Clave primaria primero; luego los campos indexados para consultas.
  registros: 'id, estado, actualizadoEn',
  cola: '++orden, registroId, intentos',
})

Dos decisiones de diseño son importantes desde el principio:

  • Identificadores generados en el dispositivo con crypto.randomUUID(): así un registro creado sin conexión tiene un identificador único antes de llegar al servidor y no hay que renumerarlo.
  • Una marca de tiempo de última modificación (actualizadoEn) y un estado de sincronización (pendiente, sincronizado, error) en cada registro.

Si más adelante cambia la estructura, se declara db.version(2) con el nuevo esquema y una función upgrade que migra los datos existentes.

04 Escribir localmente y encolar

Cada cambio se guarda en la tabla de datos y, en la misma transacción, se agrega a la cola de sincronización. Si una de las dos operaciones falla, ninguna se aplica.

// registros.js
import { db } from './db'

export async function guardarRegistro(datos) {
  const registro = {
    id: datos.id ?? crypto.randomUUID(),
    ...datos,
    actualizadoEn: Date.now(),
    estado: 'pendiente',
  }
  await db.transaction('rw', db.registros, db.cola, async () => {
    await db.registros.put(registro)
    await db.cola.add({ registroId: registro.id, intentos: 0 })
  })
  return registro
}

La interfaz puede mostrar los datos locales con useLiveQuery, que vuelve a renderizar el componente cada vez que la tabla cambia, sin esperar a la red:

import { useLiveQuery } from 'dexie-react-hooks'
import { db } from './db'

export default function ListaRegistros() {
  const registros = useLiveQuery(() => db.registros.orderBy('actualizadoEn').reverse().toArray(), [])
  if (!registros) return <p>Cargando...</p>
  return (
    <ul>
      {registros.map((r) => (
        <li key={r.id}>
          {r.titulo} <span>{r.estado === 'sincronizado' ? 'Enviado' : 'Guardado en el dispositivo'}</span>
        </li>
      ))}
    </ul>
  )
}

05 Detectar la conexión

navigator.onLine y los eventos online y offline indican si el dispositivo tiene una interfaz de red activa, no si el servidor es alcanzable: un celular puede estar conectado a una red Wi-Fi sin salida a Internet. Por eso se usan como señal para intentar sincronizar, y el resultado real lo da la respuesta del servidor.

export function alRecuperarConexion(sincronizar) {
  window.addEventListener('online', sincronizar)
  document.addEventListener('visibilitychange', () => {
    if (document.visibilityState === 'visible' && navigator.onLine) sincronizar()
  })
  const intervalo = setInterval(() => navigator.onLine && sincronizar(), 60_000)
  return () => clearInterval(intervalo)
}

06 La cola de sincronización

El proceso de sincronización recorre la cola en orden, envía cada cambio y lo elimina sólo cuando el servidor confirma la recepción. Si falla, incrementa el contador de intentos y espera cada vez más antes de reintentar (espera exponencial), para no saturar una red débil.

import { db } from './db'

let sincronizando = false

export async function sincronizar() {
  if (sincronizando) return
  sincronizando = true
  try {
    const pendientes = await db.cola.orderBy('orden').toArray()
    for (const item of pendientes) {
      const registro = await db.registros.get(item.registroId)
      if (!registro) {
        await db.cola.delete(item.orden)
        continue
      }
      try {
        const respuesta = await fetch(`/api/registros/${registro.id}`, {
          method: 'PUT',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(registro),
        })
        if (!respuesta.ok) throw new Error(`HTTP ${respuesta.status}`)
        await db.transaction('rw', db.registros, db.cola, async () => {
          await db.cola.delete(item.orden)
          const actual = await db.registros.get(registro.id)
          // Sólo se marca como sincronizado si nadie lo modificó durante el envío.
          if (actual?.actualizadoEn === registro.actualizadoEn) {
            await db.registros.update(registro.id, { estado: 'sincronizado' })
          }
        })
      } catch {
        await db.cola.update(item.orden, { intentos: item.intentos + 1 })
        const espera = Math.min(2 ** item.intentos * 1000, 5 * 60_000)
        setTimeout(sincronizar, espera)
        break
      }
    }
  } finally {
    sincronizando = false
  }
}

Requisitos del servidor

  • Las operaciones deben ser idempotentes: recibir dos veces el mismo cambio (porque se perdió la confirmación) no debe crear duplicados. Usar PUT con el identificador generado en el dispositivo lo garantiza.
  • El servidor registra su propia hora de recepción, además de la hora informada por el dispositivo, porque el reloj de un celular puede estar desajustado.

07 Resolver conflictos

Hay conflicto cuando el mismo registro se modificó en dos lugares antes de sincronizar. Las estrategias más comunes son:

  • Gana la última escritura: se conserva la versión con la marca de tiempo más reciente. Es simple y suficiente cuando cada registro tiene un único responsable.
  • Fusión por campos: se combinan los cambios de campos distintos y sólo se decide entre versiones cuando ambas modificaron el mismo campo.
  • Sólo agregar: los registros nunca se modifican; cada corrección es un registro nuevo que referencia al anterior. Elimina los conflictos y conserva un historial completo, útil cuando los datos deben ser auditables.
  • Resolución manual: se presentan ambas versiones a una persona para que decida.

La elección depende de quién modifica cada dato. En un libro de registro, por ejemplo, el modelo de sólo agregar es el más seguro: nada se pisa y todo queda trazado.

08 Cachear la aplicación con un service worker

Los datos locales no sirven si la aplicación no puede abrirse sin red. Un service worker es un script que el navegador ejecuta aparte de la página y que puede responder las peticiones desde una caché.

En proyectos con Vite, el complemento vite-plugin-pwa genera el service worker y el manifiesto de la aplicación:

npm install -D vite-plugin-pwa
// vite.config.js
import react from '@vitejs/plugin-react'
import { defineConfig } from 'vite'
import { VitePWA } from 'vite-plugin-pwa'

export default defineConfig({
  plugins: [
    react(),
    VitePWA({
      registerType: 'prompt',
      manifest: {
        name: 'Relevamientos',
        short_name: 'Relevamientos',
        display: 'standalone',
        start_url: '/',
        icons: [{ src: '/icono-512.png', sizes: '512x512', type: 'image/png' }],
      },
      workbox: { globPatterns: ['**/*.{js,css,html,png,svg,woff2}'] },
    }),
  ],
})

Con registerType: 'prompt' la aplicación avisa cuando hay una versión nueva y la persona decide cuándo actualizar, en lugar de recargarse en medio de una tarea.

Para mapas u otros recursos pesados, se pueden descargar por adelantado las zonas de trabajo y guardarlas en la caché, con un límite de tamaño para no agotar el espacio del dispositivo.

09 Probar el comportamiento sin red

  • En las herramientas de desarrollo del navegador (pestaña Red), la opción «Sin conexión» simula el corte; la pestaña Aplicación muestra el contenido de IndexedDB, la caché y el service worker.
  • En pruebas automatizadas, la biblioteca fake-indexeddb permite ejecutar el código de Dexie fuera del navegador, por ejemplo con Vitest.
  • Casos que conviene probar: crear sin red y sincronizar al volver; cortar la red en medio de un envío; recibir dos veces la misma confirmación; modificar un registro mientras se envía; cerrar la aplicación con cambios pendientes.

10 Aplicaciones nativas con el mismo código

Una aplicación web sin conexión puede distribuirse además como aplicación nativa sin reescribirla:

  • Capacitor la empaqueta como aplicación de Android o iOS y da acceso a funciones del dispositivo, como la geolocalización en segundo plano o las notificaciones locales.
  • Tauri la empaqueta como aplicación de escritorio liviana para Windows, macOS o Linux.

En ambos casos se mantiene la misma base IndexedDB y la misma cola de sincronización, lo que permite que un equipo de escritorio y varios celulares trabajen sobre los mismos datos.

Fuentes y lecturas recomendadas

  1. API de IndexedDB (abre en una pestaña nueva) — MDN Web Docs
  2. Documentación de Dexie.js (abre en una pestaña nueva) — Dexie.js
  3. API de Service Worker (abre en una pestaña nueva) — MDN Web Docs
  4. Aprende sobre aplicaciones web progresivas (abre en una pestaña nueva) — web.dev
  5. Vite PWA (abre en una pestaña nueva) — Vite PWA
  6. StorageManager.persist() (abre en una pestaña nueva) — MDN Web Docs