> ## 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.

# Application d'exemple : envoyer des push depuis votre backend

> Six notifications push envoyées depuis Supabase Edge Functions avec l'API Create message : selon une planification, depuis l'application et depuis un déclencheur de base de données.

Cette page fait partie de [Application d'exemple : une intégration OneSignal complète](https://documentation.onesignal.com/docs/fr/example-full-integration-overview.md), qui suit une application réelle de bout en bout. L'application s'appelle **Clean Beans**, un planning de ménage pour les logements partagés, construite avec Expo (React Native) et un backend Supabase.

La plupart des notifications de Clean Beans sont envoyées par le backend, car elles dépendent d'une planification ou d'une action d'une autre personne. Toutes appellent le même endpoint, [Create message](https://documentation.onesignal.com/reference/create-message.md), et ciblent les personnes par External ID.

| Push | Envoyé quand | Déclencheur |
| - | - | - |
| Résumé quotidien | À l'heure choisie par l'utilisateur, si des tâches sont à faire | Planification horaire |
| Rappel de tâches en retard | Six heures après le résumé, si des tâches sont toujours en retard | Planification horaire |
| Rappel de ménage | Une heure avant le créneau de ménage de l'utilisateur | Planification horaire |
| Session terminée | Un colocataire termine son ménage | Appel depuis l'application |
| Kudos | Un colocataire envoie des kudos | Appel depuis l'application |
| Adhésion approuvée | Un administrateur approuve une demande d'adhésion | Déclencheur de base de données |

![Notifications push de Clean Beans](https://mintcdn.com/onesignal/XdN288-p34EfpfHk/images/tutorials/cleanbeans-push-examples.png?fit=max\&auto=format\&n=XdN288-p34EfpfHk\&q=85\&s=f26bc81be159fba77a9873e119ccb19e)

Un exemple de quelques push envoyés par Clean Beans.

## Des envois planifiés qui respectent les fuseaux horaires \\

Chacun choisit l'heure à laquelle il souhaite recevoir son rappel quotidien. Clean Beans ne planifie pas une tâche par utilisateur. Il exécute une tâche toutes les heures et se demande : « pour qui est-ce l'heure en ce moment ? »

**1. Une planification de la base de données appelle une fonction toutes les heures**

`pg_cron` envoie une requête HTTP à une Supabase Edge Function. La clé de service nécessaire est lue depuis Supabase Vault, elle n'apparaît donc jamais dans le SQL.

**2. La fonction trouve les utilisateurs dont l'heure locale correspond**

Elle charge toutes les personnes qui ont activé ce rappel, convertit l'heure actuelle dans le fuseau horaire de chaque utilisateur et conserve celles dont l'heure choisie est maintenant.

**3. Elle vérifie qu'il y a quelque chose à dire**

Un utilisateur sans tâche à faire ne reçoit aucun push.

**4. Elle appelle OneSignal une fois par utilisateur**

Chaque push a son propre contenu, chacun fait donc l'objet d'une requête distincte.

La planification :

```sql supabase/migrations/006_cron_daily_digest.sql theme={null}
select cron.schedule(
  'send-daily-digest',          -- job name
  '0 * * * *',                  -- every hour at :00
  $$
  select
    net.http_post(
      url := 'https://YOUR_PROJECT_REF.supabase.co/functions/v1/send-daily-digest',
      headers := jsonb_build_object(
        'Content-Type', 'application/json',
        'Authorization', 'Bearer ' || (select decrypted_secret from vault.decrypted_secrets where name = 'service_role_key')
      ),
      body := '{}'::jsonb
    );
  $$
);
```

La correspondance de fuseau horaire :

```typescript supabase/functions/send-daily-digest/index.ts theme={null}
for (const profile of profiles) {
  try {
    // Get current hour in user's timezone
    const localHour = parseInt(
      now.toLocaleString('en-US', {
        timeZone: profile.timezone || 'UTC',
        hour: 'numeric',
        hour12: false,
      }),
      10
    );

    if (localHour === profile.notification_hour) {
      eligibleUsers.push({
        id: profile.id,
        householdId: profile.household_id,
        localDate: localDate(now, profile.timezone || 'UTC'),
      });
    }
  } catch {
    // Invalid timezone — skip this user
    console.warn(`Invalid timezone for user ${profile.id}: ${profile.timezone}`);
  }
}
```

L'envoi :

```typescript supabase/functions/send-daily-digest/index.ts theme={null}
const onesignalPayload = {
  app_id: ONESIGNAL_APP_ID,
  // One digest per user per local day: a retried or duplicated cron
  // run reuses this key and OneSignal will not send it twice.
  idempotency_key: await idempotencyKey('daily_digest', digest.userId, digest.localDate),
  include_aliases: {
    external_id: [digest.userId],
  },
  target_channel: 'push',
  ...DELIVERY.daily_digest,
  headings: { en: heading },
  contents: { en: body },
  url: 'cleaning-rota:///(tabs)/clean',
  // App icon badge = number of tasks due. The OneSignal SDK clears the
  // badge automatically the next time the app is opened.
  ios_badgeType: 'SetTo',
  ios_badgeCount: digest.tasks.length,
  // Action buttons, revealed by expanding the notification
  buttons: TASK_BUTTONS,
  data: { type: 'daily_digest', taskCount: String(digest.tasks.length) },
};

const res = await fetch('https://api.onesignal.com/notifications', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Key ${ONESIGNAL_REST_API_KEY}`,
  },
  body: JSON.stringify(onesignalPayload),
});
```

Les champs `...DELIVERY.daily_digest`, `idempotency_key` et de badge sont expliqués dans [Push fiable et bien maîtrisé](https://documentation.onesignal.com/docs/fr/example-full-integration-reliable-push.md). Le champ `data.type` permet à l'application de savoir quel écran ouvrir lorsque l'utilisateur appuie sur le push. Consultez [Deep links et clics sur les notifications](https://documentation.onesignal.com/docs/fr/example-full-integration-deep-links.md).

Le titre et le corps sont construits à partir des tâches, le push dit donc quelque chose de précis.

```typescript supabase/functions/send-daily-digest/index.ts theme={null}
function buildDigestContent(tasks: TaskRow[]): { heading: string; body: string } {
  const count = tasks.length;
  const heading = count === 1
    ? '1 cleaning task due today'
    : `${count} cleaning tasks due today`;

  // Collect unique room names
  const rooms = [...new Set(tasks.map(t => t.room_name))];

  let body: string;
  if (rooms.length === 1) {
    body = `Your ${rooms[0]} needs some attention!`;
  } else if (rooms.length === 2) {
    body = `Your ${rooms[0]} and ${rooms[1]} need some attention!`;
  } else {
    const last = rooms.pop()!;
    body = `Your ${rooms.join(', ')}, and ${last} need some attention!`;
  }

  return { heading, body };
}
```

## Le rappel de tâches en retard : une seconde relance, différente \\

Le rappel de tâches en retard reprend le même principe avec deux changements. Il se déclenche six heures après l'heure du résumé de l'utilisateur et ne compte que les tâches strictement en retard.

```typescript supabase/functions/send-overdue-reminders/index.ts theme={null}
// Overdue hour wraps around midnight
const overdueHour = (profile.notification_hour + OVERDUE_OFFSET_HOURS) % 24;

if (localHour === overdueHour) {
  eligibleUsers.push({
    id: profile.id,
    householdId: profile.household_id,
    localDate: localDate(now, profile.timezone || 'UTC'),
  });
}
```

Sa tâche s'exécute à la demie, elle n'entre donc jamais en concurrence avec celle du résumé, qui s'exécute à l'heure pile. Le texte est également différent. Un second rappel qui répète le premier est facile à ignorer.

```typescript supabase/functions/send-overdue-reminders/index.ts theme={null}
function buildOverdueContent(tasks: TaskRow[]): { heading: string; body: string } {
  const count = tasks.length;
  const heading = count === 1
    ? '1 overdue task still waiting'
    : `${count} overdue tasks still waiting`;

  const rooms = [...new Set(tasks.map((t) => t.room_name))];

  let body: string;
  if (rooms.length === 1) {
    body = `Your ${rooms[0]} still needs some love today!`;
  } else if (rooms.length === 2) {
    body = `Your ${rooms[0]} and ${rooms[1]} still need some love today!`;
  } else {
    const last = rooms.pop()!;
    body = `Your ${rooms.join(', ')}, and ${last} still need some love today!`;
  }

  return { heading, body };
}
```

## Le rappel de ménage : une requête pour de nombreuses personnes \\

Le rappel de ménage dit la même chose à tout le monde, il n'a donc pas besoin d'une requête par personne. La fonction rassemble tous les ID utilisateur éligibles et les envoie par lots.

```typescript supabase/functions/send-cleaning-reminder/index.ts theme={null}
const batchSize = 2000;
for (let i = 0; i < eligibleUserIds.length; i += batchSize) {
  const batch = eligibleUserIds.slice(i, i + batchSize);

  // One reminder per batch of recipients per hourly cron slot: a retried
  // or duplicated run in the same hour reuses this key and OneSignal
  // will not send it twice.
  const batchKey = await idempotencyKey(
    'upcoming_cleaning',
    utcHourSlot(now),
    [...batch].sort().join(','),
  );

  const onesignalPayload = {
    app_id: ONESIGNAL_APP_ID,
    idempotency_key: batchKey,
    include_aliases: {
      external_id: batch,
    },
    target_channel: 'push',
    ...DELIVERY.upcoming_cleaning,
    headings: { en: 'Cleaning time in 1 hour' },
    contents: {
      en: 'Your cleaning window starts soon. Ready to get things sparkling?',
    },
    url: 'cleaning-rota:///(tabs)/clean',
    data: { type: 'upcoming_cleaning' },
  };
```

> [!TIP]
>
> Envoyez une requête par personne lorsque le contenu diffère. Envoyez une requête pour plusieurs personnes lorsqu'il est identique. Moins de requêtes, c'est moins de points de défaillance et moins de risques de dépasser les limites de débit.

## Session terminée : un push déclenché depuis l'application \\

Lorsqu'une personne termine une session de ménage, le reste du foyer en est informé. L'application ne peut pas envoyer ce push elle-même, car elle ne doit pas détenir de clé API. Elle appelle une fonction backend, et c'est la fonction qui envoie le push.

```typescript src/lib/database.ts theme={null}
const { error } = await supabase.functions.invoke('session-completed', {
  body: {
    householdId,
    roomName: params.roomName,
    tasksCompleted: params.tasksCompleted,
    estimatedMins: params.estimatedMins,
  },
});
```

La requête indique ce qui a été nettoyé, mais pas qui l'a nettoyé. La fonction identifie l'appelant à partir de son jeton de connexion, vérifie qu'il est un membre actif du foyer et récupère son nom et son avatar dans son profil. Consultez [Vérifier qui appelle](#check-who-is-calling).

Elle trouve ensuite les autres membres du foyer et retire ceux qui ont désactivé ce type de push.

```typescript supabase/functions/session-completed/index.ts theme={null}
// ── 1. Look up other active household members ──

const { data: members, error: memberErr } = await supabase
  .from('household_members')
  .select('user_id')
  .eq('household_id', householdId)
  .eq('status', 'active')
  .neq('user_id', userId);

    // ...

const { data: profiles, error: profileErr } = await supabase
  .from('profiles')
  .select('id, notifications_enabled, push_cleaning_done')
  .in('id', recipientIds)
  .eq('notifications_enabled', true)
  .eq('push_cleaning_done', true);
```

Elle envoie un seul push à tous. L'avatar en forme de haricot de l'expéditeur est joint comme image, avec un champ différent pour chaque plateforme.

```typescript supabase/functions/session-completed/index.ts theme={null}
const onesignalPayload: Record<string, unknown> = {
  app_id: ONESIGNAL_APP_ID,
  include_aliases: {
    external_id: enabledIds,
  },
  target_channel: 'push',
  ...DELIVERY.session_completed,
  headings: { en: heading },
  contents: { en: body },
  url: 'cleaning-rota:///activity',
  data: {
    type: 'session_completed',
    roomName,
    userName,
    tasksCompleted: String(tasksCompleted),
    // Who cleaned: lets the "Send kudos" button reply to the right person
    ...(isRealUser ? { cleanerId: userId } : {}),
  },
  // "Send kudos" needs a real person to send to
  ...(isRealUser ? { buttons: SESSION_BUTTONS } : {}),
};

// Attach avatar image for rich push notifications
if (avatarImageUrl) {
  onesignalPayload.big_picture = avatarImageUrl;          // Android
  onesignalPayload.ios_attachments = { avatar: avatarImageUrl }; // iOS
}
```

![Une notification push développée affichant une image d'avatar en forme de haricot](https://mintcdn.com/onesignal/XdN288-p34EfpfHk/images/tutorials/cleanbeans-rich-push.png?fit=max\&auto=format\&n=XdN288-p34EfpfHk\&q=85\&s=07c38920b20cb73093805ca9961841e3)

Un push de session terminée, développé pour afficher l'avatar de l'expéditeur.

## Kudos : d'une personne à une autre \\

Les kudos fonctionnent de la même manière, avec un seul destinataire. Sur l'écran d'activité, un membre appuie sur **Send Kudos** sur la session d'un colocataire, choisit un message, et l'application appelle la fonction `send-kudos`.

![Le panneau inférieur des kudos avec des messages prédéfinis](https://mintcdn.com/onesignal/XdN288-p34EfpfHk/images/tutorials/cleanbeans-kudos.png?fit=max\&auto=format\&n=XdN288-p34EfpfHk\&q=85\&s=83ec608d61e91c74f16bcb65d8757927)

Choisir un message de kudos pour la session de ménage d'un colocataire.

```typescript supabase/functions/send-kudos/index.ts theme={null}
const heading = `Kudos from ${senderName}!`;
const body = message;

    // ...

const onesignalPayload: Record<string, unknown> = {
  app_id: ONESIGNAL_APP_ID,
  include_aliases: {
    external_id: [recipientUserId],
  },
  target_channel: 'push',
  ...DELIVERY.kudos,
  headings: { en: heading },
  contents: { en: body },
  url: 'cleaning-rota:///activity',
  data: {
    type: 'kudos',
    senderName,
    roomName: roomName || '',
  },
};
```

## Adhésion approuvée : un push déclenché par la base de données \\

Une personne qui demande à rejoindre un foyer attend qu'un administrateur l'approuve. À ce moment-là, sa ligne d'adhésion passe de `pending` à `active`. Un déclencheur de base de données sur ce changement appelle une fonction, et la fonction lui annonce qu'elle fait désormais partie du foyer.

Placer le déclencheur dans la base de données signifie que le push est envoyé quelle que soit la façon dont l'approbation a lieu, et que l'application n'a besoin d'aucun code pour cela.

```sql supabase/migrations/027_join_approved_trigger.sql theme={null}
create trigger trg_notify_join_approved
  after update of status on public.household_members
  for each row
  when (old.status = 'pending' and new.status = 'active')
  execute function public.notify_join_approved();
```

La fonction ne se fie pas à ce qu'on lui dit. Elle relit l'adhésion et n'envoie le push que si l'approbation est réelle et récente.

```typescript supabase/functions/join-approved/index.ts theme={null}
// ── 1. Confirm the membership really was approved, and recently ──

const { data: membership, error: memberErr } = await supabase
  .from('household_members')
  .select('status, joined_at, households(name)')
  .eq('user_id', userId)
  .eq('household_id', householdId)
  .maybeSingle();

if (memberErr) throw memberErr;

if (!membership || membership.status !== 'active' || !membership.joined_at) {
  return jsonResponse({ sent: 0, message: 'No active membership found' });
}

const joinedAt = new Date(membership.joined_at).getTime();
if (Date.now() - joinedAt > RECENT_APPROVAL_MS) {
  return jsonResponse({ sent: 0, message: 'Membership was not approved recently' });
}
```

> [!WARNING]
>
> Une fonction qui envoie des messages à la demande est une fonction que d'autres peuvent tenter d'appeler. Vérifiez les faits dans votre propre base de données avant d'envoyer, comme le fait celle-ci, et n'acceptez jamais le contenu d'un message ni des destinataires de la part d'un appelant que vous n'avez pas vérifié.

## Vérifier qui appelle \\

Supabase vérifie qu'une requête vers une edge function porte un jeton valide, mais le jeton d'un utilisateur connecté est tout aussi valide que celui du planificateur. Sans vérification supplémentaire, n'importe quel utilisateur pourrait déclencher le résumé quotidien pour tout le monde ou envoyer un push au nom de quelqu'un d'autre. Chaque fonction décide donc elle-même qui est autorisé à l'appeler.

| Fonctions | Qui peut appeler | Vérification |
| - | - | - |
| Envois planifiés et déclencheur de base de données | Le planificateur uniquement | Le jeton doit être la clé service role |
| Session terminée, kudos | Un utilisateur connecté, en son propre nom | L'expéditeur provient du jeton, jamais du corps de la requête |

Les fonctions planifiées commencent par une ligne :

```typescript supabase/functions/send-daily-digest/index.ts theme={null}
// Only the scheduler (service role) may run this
const denied = requireServiceRole(req);
if (denied) return denied;
```

```typescript supabase/functions/_shared/auth.ts theme={null}
export function isServiceRoleRequest(req: Request): boolean {
  const token = bearerToken(req);
  if (!token) return false;
  if (token === Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')) return true;

  try {
    const part = token.split('.')[1] ?? '';
    const base64 = part.replace(/-/g, '+').replace(/_/g, '/');
    const padded = base64 + '='.repeat((4 - (base64.length % 4)) % 4);
    const claims = JSON.parse(atob(padded));
    return claims?.role === 'service_role';
  } catch {
    return false;
  }
}
```

> [!WARNING]
>
> La vérification du rôle suppose que Supabase a déjà vérifié la signature du jeton. Déployez ces fonctions avec la vérification JWT activée, ce qui est le comportement par défaut. Ne les déployez jamais avec `--no-verify-jwt`.

Les fonctions appelées depuis l'application identifient l'expéditeur à partir du jeton, puis vérifient qu'il est autorisé à joindre le destinataire. Les kudos ne peuvent être envoyés qu'à une personne qui partage un foyer avec l'expéditeur, et le nom affiché dans le push est lu dans le profil de l'expéditeur.

```typescript supabase/functions/send-kudos/index.ts theme={null}
const caller = await authenticateUser(req, supabase);
if (caller instanceof Response) return caller;

// ...

// Sender and recipient must be active members of the same household
const { data: memberships, error: memberErr } = await supabase
  .from('household_members')
  .select('user_id, household_id')
  .in('user_id', [caller.id, recipientUserId])
  .eq('status', 'active');

if (memberErr) throw memberErr;

const callerHouseholds = new Set(
  (memberships ?? []).filter((m) => m.user_id === caller.id).map((m) => m.household_id),
);
const sharesHousehold = (memberships ?? []).some(
  (m) => m.user_id === recipientUserId && callerHouseholds.has(m.household_id),
);

if (!sharesHousehold) {
  return jsonResponse({ error: 'forbidden', message: 'You can only send kudos to members of your household.' }, 403);
}
```

> [card] [API Create message](https://documentation.onesignal.com/reference/create-message.md)
>
> Ciblage, contenu et planification pour tous les canaux.

> [card] [Rich media](https://documentation.onesignal.com/docs/fr/rich-media.md)
>
> Images dans les notifications push sur chaque plateforme.


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