Torna al blog

Notifiche push Supabase: una notifica sul telefono per ogni nuova registrazione o ordine

Notifiche push Supabase: una notifica sul telefono per ogni nuova registrazione o ordine

La tua app gira su Supabase, e i momenti che ti interessano sono righe: un nuovo utente in auth.users, un nuovo ordine in orders, un abbonamento che passa a canceled. Li scopri quando apri il Table Editor, che in una bella giornata è la sera e in una giornata piena è la settimana dopo.

Supabase può avvisarti prima. Ogni tabella può chiamare un URL quando una riga viene inserita, aggiornata o eliminata. Punta quella chiamata verso Pocket Alert e ogni evento diventa una notifica push sul tuo telefono, con l'email o il totale dell'ordine nel testo.

Questa guida riguarda l'invio di notifiche a te, il fondatore o l'amministratore. Se vuoi inviare notifiche push agli utenti della tua app, serve FCM, APNs o Expo, e un articolo diverso.

Cosa ti serve

  • Un progetto Supabase che puoi aprire nella dashboard.
  • Un account Pocket Alert e l'app sul tuo iPhone o Android. Il piano gratuito basta per iniziare.

Se hai costruito la tua app con Lovable e collegato un tuo progetto Supabase, tutto quello che segue vale. Su Lovable Cloud (il backend integrato) non c'è la dashboard di Supabase, quindi il Livello 1 non ha dove andare. Il suo SQL editor (Database → Manage → SQL editor) supporta pg_net e Vault, quindi i trigger del Livello 2 sono la strada da provare lì.

Livello 1: un Database Webhook, senza codice

I Database Webhook di Supabase inviano una richiesta HTTP dopo che una riga cambia in una tabella. I webhook di Pocket Alert ricevono JSON e lo trasformano in una notifica push. Collegare i due richiede pochi minuti e nessun codice.

Crea il webhook di Pocket Alert

Apri Webhooks nella console di Pocket Alert e creane uno:

  • Nome: Supabase. Il titolo della notifica è sempre Webhook <name>, quindi questo arriverà come "Webhook Supabase". Usa un nome più specifico, come Supabase signups, se prevedi di averne più d'uno.
  • Messaggio: il template, spiegato più sotto.

Copia l'URL che mostra la console. Ha questa forma: https://p4a.me/wh/abc123xyz. Lo slug finale è l'unico segreto, quindi tratta l'intero URL come una password.

Crea il webhook di Supabase

Nella dashboard di Supabase, apri il tuo progetto e vai su Integrations → Database Webhooks (le guide più vecchie lo chiamano Database → Webhooks). Se l'integrazione non è ancora attiva, attivala prima: crea la funzione trigger che usano i webhook. Poi crea un nuovo webhook:

  1. Dagli un nome, per esempio notify_new_order.
  2. Scegli la tabella, per esempio orders.
  3. Seleziona gli eventi. Per gli avvisi di "nuova riga", seleziona solo Insert.
  4. Scegli HTTP Request come tipo, metodo POST, e incolla l'URL di Pocket Alert.
  5. Lascia l'header Content-Type: application/json così com'è. Pocket Alert accetta solo body JSON.

Salva. Da adesso, ogni inserimento in orders invia una richiesta dopo che la riga è stata scritta. Supabase costruisce queste richieste con l'estensione pg_net, che è asincrona, quindi una chiamata di rete lenta non blocca mai l'inserimento stesso.

Cosa invia Supabase

Il body ha la stessa struttura per ogni tabella:

{
  "type": "INSERT",
  "table": "orders",
  "schema": "public",
  "record": { "id": 1042, "email": "[email protected]", "total": 49, "status": "pending" },
  "old_record": null
}

record è la nuova riga con tutte le sue colonne. Per UPDATE, old_record contiene la riga com'era prima; per DELETE, record è null e viene compilato solo old_record.

Il template del messaggio

Torna nel webhook di Pocket Alert e scrivi il messaggio con i segnaposto %path% che puntano dentro quel JSON:

New %table% row: #%record.id% · %record.email% · $%record.total%

Il prossimo ordine arriva così:

Webhook Supabase
Nuova riga in orders: #1042 · [email protected] · $49

Usa qualsiasi colonna presente nella tua tabella: %record.plan%, %record.country%, %record.status%. Un * al posto del template invia l'intero JSON, utile mentre capisci i nomi delle colonne.

Lo stesso modulo ha un livello predefinito. Imposta high su un webhook degli ordini per farlo passare da Full immersion su iPhone, oppure low su una tabella molto attiva che vuoi solo nella cronologia. Il payload di Supabase non ha un campo level, quindi decide il valore predefinito del webhook.

Registrazioni da auth.users

Supabase salva gli utenti in auth.users, e il selettore di tabelle dei Database Webhook può selezionarla: integrazioni come Loops documentano esattamente questa configurazione. Scegli la tabella degli utenti nello schema auth, seleziona Insert e usa:

New signup: %record.email%

Se le tabelle di auth non compaiono nel selettore, o preferisci tenere la logica in SQL, il trigger della sezione successiva funziona anche su auth.users.

Dove si ferma il Livello 1

Un Database Webhook non ha condizioni. Seleziona Update su orders e ricevi una notifica ogni volta che cambia una colonna qualsiasi: lo stato, l'indirizzo di spedizione, un updated_at toccato da un job in background. Il template non può saltare una richiesta; può solo formattarla. Su una tabella molto attiva è al massimo rumore, e nel peggiore dei casi consuma i 50 messaggi giornalieri del piano gratuito prima di pranzo.

Per "avvisami quando un ordine viene pagato" o "avvisami quando un abbonamento viene annullato" ti serve un filtro, e Postgres ne ha già uno.

Livello 2: un trigger con pg_net e una condizione WHEN

Un Database Webhook è un trigger che chiama pg_net per te. Scrivere il trigger da solo ti dà due cose: una clausola WHEN, così Postgres si attiva solo sulle modifiche che ti interessano, e il controllo completo della richiesta, così puoi chiamare direttamente l'API di Pocket Alert con il tuo titolo, livello e pulsanti.

Salva la chiave API in Vault

Ottieni una chiave API da API Keys e salvala in Supabase Vault dal SQL Editor. Eseguilo una sola volta, fuori dalle tue migrazioni, così la chiave non finisce mai in un file:

select vault.create_secret('YOUR_POCKETALERT_API_KEY', 'pocketalert_key');

Assicurati che pg_net sia attivo in Database → Extensions. I progetti con Database Webhook lo hanno già.

La funzione e il trigger

Questo invia una notifica solo quando lo stato di un ordine passa a paid:

create or replace function public.notify_order_paid()
returns trigger
language plpgsql
security definer
set search_path = ''
as $$
begin
  perform net.http_post(
    url := 'https://api.pocketalert.app/v1/messages',
    headers := jsonb_build_object(
      'Content-Type', 'application/json',
      'Token', (select decrypted_secret from vault.decrypted_secrets where name = 'pocketalert_key')
    ),
    body := jsonb_build_object(
      'title', 'Order paid: $' || new.total,
      'message', '#' || new.id || ' · ' || coalesce(new.email, 'no email'),
      'level', 'high',
      'actions', jsonb_build_array(jsonb_build_object(
        'type', 'view',
        'label', 'Open orders',
        'value', 'https://supabase.com/dashboard/project/YOUR_PROJECT_REF/editor'
      ))
    )
  );
  return new;
end;
$$;

create trigger on_order_paid
after update of status on public.orders
for each row
when (old.status is distinct from new.status and new.status = 'paid')
execute function public.notify_order_paid();

Cosa fa ogni parte:

  • when (...) è il filtro che mancava nel Livello 1. Postgres non chiama nemmeno la funzione a meno che lo stato non sia davvero cambiato e il nuovo valore sia paid. Le modifiche ad altre colonne non costano nulla.
  • security definer permette alla funzione di leggere Vault. I ruoli che scrivono righe dalla tua app, come authenticated, non possono farlo, e senza questa impostazione i loro aggiornamenti fallirebbero con un errore di permessi. È il pattern indicato nella documentazione di Supabase.
  • net.http_post mette in coda la richiesta e ritorna subito; viene inviata dopo il commit della transazione. Se l'aggiornamento viene annullato, nessuna notifica parte.
  • level decide quanto forte arriva: default per gli eventi di routine, high per superare Full immersion, critical per quelli che devono svegliarti. Critical è una funzione a pagamento; con il piano gratuito viene consegnato come high.

Copia la funzione per altri eventi e cambia la condizione: new.status = 'canceled' su subscriptions, new.total > 500 in un trigger di inserimento per gli ordini grandi, new.role = 'admin' su profiles.

Registrazioni tramite trigger su auth.users

Lo stesso schema su auth.users, con il provider di accesso nel testo:

create or replace function public.notify_new_signup()
returns trigger
language plpgsql
security definer
set search_path = ''
as $$
begin
  perform net.http_post(
    url := 'https://api.pocketalert.app/v1/messages',
    headers := jsonb_build_object(
      'Content-Type', 'application/json',
      'Token', (select decrypted_secret from vault.decrypted_secrets where name = 'pocketalert_key')
    ),
    body := jsonb_build_object(
      'title', 'New signup',
      'message', coalesce(new.email, 'no email') || ' via ' || coalesce(new.raw_app_meta_data ->> 'provider', 'unknown')
    )
  );
  return new;
end;
$$;

create trigger on_auth_user_created_notify
after insert on auth.users
for each row execute function public.notify_new_signup();

Supabase avverte che un trigger che fallisce su auth.users può bloccare le registrazioni. Le chiamate coalesce evitano che un valore mancante rompa la stringa, e la richiesta è asincrona, quindi una notifica lenta o fallita non interferisce con la registrazione. Comunque, testalo una volta con un account usa e getta prima di farci affidamento.

Oppure una Edge Function

Se preferisci TypeScript a PL/pgSQL, mantieni il Database Webhook del Livello 1, imposta il suo tipo su Supabase Edge Functions e aggiungi l'header con la chiave segreta che il form propone. La funzione riceve lo stesso payload {type, table, record, old_record} e decide da sola. Il pattern di Supabase per le chiamate con la chiave segreta è il wrapper withSupabase con auth: 'secret', più verify_jwt = false per la funzione in supabase/config.toml:

import { withSupabase } from "npm:@supabase/server@1";

export default {
  fetch: withSupabase({ auth: "secret" }, async (req) => {
    const { type, record, old_record } = await req.json();
    if (type !== "UPDATE" || record.status === old_record.status) {
      return new Response("skipped");
    }

    await fetch("https://api.pocketalert.app/v1/messages", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Token: Deno.env.get("POCKETALERT_API_KEY")!,
      },
      body: JSON.stringify({
        title: `Order #${record.id}: ${record.status}`,
        message: `${record.email} · $${record.total}`,
        level: record.status === "refunded" ? "high" : "default",
      }),
    });
    return new Response("ok");
  }),
};

Imposta la chiave con supabase secrets set POCKETALERT_API_KEY=.... Il compromesso: il webhook si attiva comunque a ogni aggiornamento, e la funzione filtra dopo, quindi paghi un'invocazione per ogni modifica. Il trigger WHEN filtra prima che parta qualsiasi cosa.

Limiti onesti

  • Nessuna verifica della firma. Pocket Alert non verifica da dove arriva una richiesta al webhook; lo slug dell'URL è il segreto. Se conta, usa il trigger del Livello 2, che si autentica con la tua chiave API.
  • La chiave resta brevemente in una tabella di coda. Supabase segnala che pg_net mantiene l'header decifrato in net.http_request_queue finché la richiesta non parte, e qualsiasi ruolo che può accedere al database può leggerlo lì.
  • pg_net è best effort. Le richieste vivono in tabelle non loggate, quindi un crash nel momento sbagliato può perderne una. Va bene per "avvisami", non per la fatturazione.
  • Volume. Un trigger su una tabella che riceve migliaia di scritture all'ora invierà migliaia di notifiche, a meno che la condizione non sia molto stretta. Il piano gratuito consente 50 messaggi al giorno.

Se non arriva nulla

  • Controlla la cronologia del webhook di Pocket Alert. Ogni richiesta all'URL del webhook viene registrata nella console con header, body, messaggio generato e stato. Se la richiesta c'è, Supabase ha fatto la sua parte e il problema è nel template. Se non c'è, guarda Supabase.
  • Controlla cosa ha restituito pg_net. Le risposte vengono conservate per sei ore:
select status_code, content, error_msg, created
from net._http_response
order by created desc
limit 10;

Un 401 significa che la chiave API in Vault è sbagliata; un 400 di solito vuol dire che il body non è JSON valido o che manca un campo.

  • Controlla la condizione del trigger. Esegui a mano un aggiornamento che dovrebbe corrispondere, come update orders set status = 'paid' where id = 1042;, e ricontrolla net._http_response.
  • Controlla l'evento. Un webhook che ascolta solo Insert non si attiva sugli aggiornamenti, e su DELETE i segnaposto %record.*% sono vuoti perché la riga si trova in old_record.

FAQ

È la stessa cosa dell'invio di notifiche push agli utenti della mia app?

No. Questo invia notifiche push al tuo telefono tramite l'app Pocket Alert. Le notifiche ai dispositivi dei tuoi utenti passano per FCM, APNs o un servizio come Expo, che la tua app deve integrare da sola.

Posso ottenere webhook del database Supabase solo per una colonna?

Non con il webhook della dashboard; si attiva su qualsiasi modifica della riga. Un trigger con after update of status e una condizione WHEN, come nel Livello 2, si attiva solo quando quella colonna cambia nel modo che descrivi.

Funziona con il piano gratuito di Supabase?

Database Webhook, trigger, pg_net e Vault fanno tutti parte di un normale progetto Supabase, quindi qui non serve un piano Supabase a pagamento.

Posso inviare tabelle diverse a destinazioni diverse?

Sì. Crea un webhook di Pocket Alert per tabella, ciascuno con il proprio nome, template e livello, oppure mettili in applicazioni separate, così registrazioni e ordini arrivano in canali distinti dentro l'app. Altre idee su avvisi dal database e avvisi di registrazione.

Devo usare il webhook di Supabase?

No. Qualsiasi cosa che può inviare JSON con POST può usare un webhook di Pocket Alert, e qualsiasi cosa che può fare una chiamata HTTP può usare l'API.

Crea un account gratuito, collega una tabella e la prossima registrazione comparirà sulla tua schermata di blocco.

Condividi questo articolo