> ## Documentation Index
> Fetch the complete documentation index at: https://documentation.onesignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# App de ejemplo: bandeja de notificaciones con Event Streams

> Cómo la app de ejemplo Clean Beans crea una bandeja de notificaciones dentro de la app a partir de Event Streams y mantiene las preferencias de email al día con las bajas.

Esta página forma parte de [App de ejemplo: una integración completa de OneSignal](https://documentation.onesignal.com/docs/es/example-full-integration-overview.md), que sigue una app real de principio a fin. La app es **Clean Beans**, un turno de limpieza para hogares compartidos, creada con Expo (React Native) y un backend de Supabase.

Un push que se descarta desaparece. Clean Beans guarda un historial de siete días dentro de la app, con un recuento de no leídos en la cabecera de cada pantalla.

![La bandeja de notificaciones de Clean Beans](https://mintcdn.com/onesignal/XdN288-p34EfpfHk/images/tutorials/cleanbeans-inbox.png?fit=max\&auto=format\&n=XdN288-p34EfpfHk\&q=85\&s=b5e476387dfc0b32a56d71201879c0d0)

La bandeja muestra las notificaciones recientes.

La app no registra las notificaciones por sí misma. Eso dejaría fuera todo lo entregado mientras la app estaba cerrada. OneSignal informa al backend de cada push a través de un **Event Stream**, y el backend guarda el historial.

**1. OneSignal envía un evento por cada push**

Un Event Stream hace una solicitud POST a una función del backend cuando se envía un push y otra vez cuando se pulsa.

**2. La función guarda o actualiza una fila**

Un evento de envío crea una entrada en la bandeja. Un evento de clic la marca como leída.

**3. La app lee la tabla**

La pantalla de la bandeja y la insignia de la cabecera consultan las filas del propio usuario.

## Configurar el Event Stream \\

**Configuración del panel.** En **Datos > Event Streams**, crea un stream con:

* **URL:** la dirección de tu función.
* **Cabecera:** un secreto compartido, por ejemplo `X-Webhook-Secret`.
* **Eventos:** `message.push.sent` y `message.push.clicked`.
* **Cuerpo:** una plantilla Liquid que da forma a la solicitud.

```json Event Stream body theme={null}
{
  "event_kind": "{{ event.kind }}",
  "event_id": "{{ event.id }}",
  "timestamp": {{ event.timestamp }},
  "external_id": "{{ event.external_id }}",
  "message_id": "{{ message.id }}",
  "title": "{{ message.title.en }}",
  "contents": "{{ message.contents.en }}",
  "data": { "type": "{{ message.data.type }}" }
}
```

> [!WARNING]
>
> Haz referencia a cada clave de `data` por su nombre, como arriba. `{{ message.data }}` por sí solo representa todo el objeto como un dict al estilo de Python (`{'type': 'kudos'}`), que no es JSON válido, y la función de abajo rechazaría la solicitud al analizar el cuerpo. El título y el contenido se leen con `.en` por el mismo motivo. La bandeja solo necesita `type`. Añade una línea por cada otra clave que use tu propio webhook.
>
> Un valor que contiene comillas dobles también rompe el JSON. Los push de kudos llevan texto que ha escrito un usuario, así que un mensaje de kudos con un `"` produce un cuerpo que la función no puede analizar, y ese push nunca llega a la bandeja.

> [!NOTE]
>
> Este stream envía un evento por cada push entregado a cada dispositivo, y cada evento cuenta para el volumen de eventos de mensajes de tu plan. Selecciona solo los eventos que uses.

## Recibir los eventos \\

La función comprueba el secreto antes de hacer nada más.

```typescript supabase/functions/inbox-webhook/index.ts theme={null}
const secret = req.headers.get('X-Webhook-Secret') ?? '';
if (!INBOX_WEBHOOK_SECRET || secret !== INBOX_WEBHOOK_SECRET) {
  return new Response('Unauthorized', { status: 401 });
}
```

Un evento de envío se convierte en una fila de la bandeja. El ID de evento de OneSignal es la clave única, así que un evento que se entrega dos veces no crea dos filas.

```typescript supabase/functions/inbox-webhook/index.ts theme={null}
if (event_kind === 'message.push.sent') {
  // ── Create inbox entry ──
  const notifType = (data?.type as string) || 'general';

  // inboxTitle and inboxBody are the title and contents with any Liquid
  // rendered. See "Render Liquid before you store it" below.

  const { error } = await supabase.from('inbox_messages').upsert(
    {
      user_id: profile.id,
      onesignal_event_id: event_id,
      onesignal_message_id: message_id,
      title: inboxTitle || 'Notification',
      body: inboxBody,
      type: notifType,
      data: data || {},
      read: false,
      created_at: payload.timestamp
        ? new Date(payload.timestamp * 1000).toISOString()
        : new Date().toISOString(),
    },
    { onConflict: 'onesignal_event_id' } // dedup
  );
```

Un evento de clic marca como leída la fila correspondiente.

```typescript supabase/functions/inbox-webhook/index.ts theme={null}
const { error, count } = await supabase
  .from('inbox_messages')
  .update({ read: true })
  .eq('onesignal_message_id', message_id)
  .eq('user_id', profile.id);
```

El campo `data.type` que enruta un push tocado se guarda con cada fila, de modo que la bandeja puede mostrar el icono correcto y abrir la pantalla correcta.

## Representar Liquid antes de guardarlo \\

El stream informa de un mensaje tal como se escribió, antes de que OneSignal lo personalice para cada destinatario. Un push enviado por el backend ya tiene su texto final. Un push de Journey no. Uno de los mensajes de Journey de Clean Beans tiene este título:

```text Journey push title theme={null}
{{ journey.first_event.properties.room_name }} cleaned ✅
```

El teléfono muestra "Kitchen cleaned ✅". El webhook recibe la línea de arriba, y la primera versión de la bandeja la mostraba exactamente así.

Ahora la función representa el título y el cuerpo por sí misma antes de guardarlos, con un pequeño renderizador que gestiona las búsquedas de valores y el filtro `default`. Obtiene los valores de dos sitios:

* **Las etiquetas** se leen de la base de datos. La app establece cada etiqueta a partir de un valor que guarda, así que la función lee los mismos valores. Pasar `{{ user.tags.user_name }}` en el cuerpo del stream también funcionaría, pero un nombre que contuviera comillas dobles haría que ese cuerpo fuera JSON no válido.
* **Las propiedades de eventos de Journey** no están disponibles en el stream. La función las reconstruye a partir de la sesión de limpieza que disparó el evento personalizado.

```typescript supabase/functions/inbox-webhook/index.ts theme={null}
if (hasLiquid(inboxTitle) || hasLiquid(inboxBody)) {
  const context = await buildLiquidContext(supabase, payload);
  const renderedTitle = renderLiquid(inboxTitle, context);
  const renderedBody = renderLiquid(inboxBody, context);
  const unresolved = [...renderedTitle.unresolved, ...renderedBody.unresolved];

  if (unresolved.length > 0) {
    // Better no entry than one showing raw template tags
    console.warn(`Inbox: skipped ${message_id} for ${external_id}, unresolved Liquid: ${JSON.stringify(unresolved)}`);
    return jsonResponse({ skipped: true, reason: 'unresolved_liquid', unresolved });
  }

  inboxTitle = renderedTitle.text;
  inboxBody = renderedBody.text;
}
```

> [!WARNING]
>
> Si creas una bandeja o un registro a partir de Event Streams, comprueba qué aspecto tienen tus mensajes de Journey y de plantilla cuando llegan. Cualquier Liquid que contengan sigue siendo Liquid. Represéntalo tú mismo, como aquí, o deja fuera esos mensajes.

## Mostrar la bandeja \\

La seguridad a nivel de fila hace que cada usuario solo pueda leer sus propias filas, así que las consultas de la app no necesitan filtrar por usuario.

```typescript app/inbox.tsx theme={null}
const { data, error } = await supabase
  .from('inbox_messages')
  .select('id, title, body, type, data, read, created_at')
  .order('created_at', { ascending: false })
  .limit(50);
```

```typescript src/components/InboxButton.tsx theme={null}
const fetchCount = async () => {
  const { count, error } = await supabase
    .from('inbox_messages')
    .select('id', { count: 'exact', head: true })
    .eq('read', false);

  if (!cancelled && !error && count !== null) {
    setUnreadCount(count);
  }
};
```

## Mantener al día las preferencias de email \\

El mismo stream resuelve un segundo problema. Cuando alguien toca **Unsubscribe** en un email, OneSignal deja de enviarle emails, pero el interruptor "Weekly Email Summary" de la propia app seguiría activado. La pantalla de ajustes sería incorrecta y el backend seguiría intentando enviar.

Añadir cuatro eventos de email al stream lo soluciona. La función los trata todos igual: OneSignal no volverá a enviar emails a esta persona, así que la preferencia de la app se desactiva para que coincida.

```typescript supabase/functions/inbox-webhook/index.ts theme={null}
const EMAIL_STOP_EVENTS: Record<string, string> = {
  'message.email.unsubscribed': 'unsubscribed',
  'message.email.reported_as_spam': 'reported_as_spam',
  'message.email.bounced': 'bounced',
  'message.email.suppressed': 'suppressed',
};

// ...

const { error: prefErr } = await supabase
  .from('profiles')
  .update({ email_weekly_summary: false })
  .eq('id', profile.id);
```

No es necesario cambiar el cuerpo del stream, porque los campos que ya usa la bandeja (`event_kind`, `event_id`, `external_id`) son suficientes.

> [!NOTE]
>
> Esto mantiene la app al día con OneSignal, no al revés. Si alguien vuelve a activar el email en la app, su suscripción de OneSignal sigue dada de baja. Para volver a suscribirla, tu backend tiene que llamar a la API de suscripciones de OneSignal.

> [!TIP]
>
> El mismo patrón de Event Stream puede mantener tus propios sistemas al día con cualquier cosa que sepa OneSignal: aperturas de email, clics en mensajes in-app, entregas de SMS y más.

> [card] [Event Streams](https://documentation.onesignal.com/docs/es/event-streams.md)
>
> Configura un stream y elige los eventos.

> [card] [Datos de Event Stream](https://documentation.onesignal.com/docs/es/event-streams-data.md)
>
> Todos los campos disponibles en la plantilla del cuerpo.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.