# Supabase push notification: kirim push ke HP Anda untuk setiap pendaftaran atau pesanan baru

> Terima push notification di HP saat baris baru masuk ke database Supabase Anda. Database Webhook tanpa kode untuk pendaftaran dan pesanan baru, lalu trigger Postgres dengan pg_net untuk perubahan status, tingkat prioritas, dan tombol yang membuka tabel.

*24.10.2026*

<!-- source: https://pocketalert.app/id/blog/supabase-push-notifications -->

Aplikasi Anda berjalan di Supabase, dan momen yang penting bagi Anda adalah baris data: pengguna baru di `auth.users`, pesanan baru di `orders`, langganan yang berubah menjadi `canceled`. Anda baru tahu tentang semua itu saat membuka Table Editor, yang di hari baik terjadi malam hari dan di hari sibuk baru minggu depan.

Supabase bisa memberi tahu Anda lebih cepat. Setiap tabel bisa memanggil sebuah URL saat baris disisipkan, diperbarui, atau dihapus. Arahkan panggilan itu ke Pocket Alert dan setiap kejadian menjadi push notification di HP Anda, dengan email atau total pesanan langsung di teksnya.

Panduan ini berfokus pada pemberitahuan untuk **Anda**, sang pendiri atau admin. Jika Anda ingin mengirim push notification ke pengguna aplikasi Anda sendiri, itu tugas FCM, APNs, atau Expo, dan dibahas di artikel lain.

## Yang Anda butuhkan

- Proyek Supabase yang bisa Anda buka di dasbor.
- Akun Pocket Alert dan aplikasi di [iPhone atau Android](/get-app) Anda. Paket gratis sudah cukup untuk memulai.

Jika Anda membangun aplikasi dengan Lovable dan menghubungkan proyek Supabase sendiri, semua langkah di bawah berlaku. Di Lovable Cloud (backend bawaan) tidak ada dasbor Supabase, jadi Level 1 tidak bisa dijalankan. Editor SQL-nya (**Database → Manage → SQL editor**) mendukung `pg_net` dan Vault, sehingga trigger Level 2 bisa dicoba di sana.

## Level 1: Database Webhook, tanpa kode

Database Webhook Supabase mengirim permintaan HTTP setelah baris di tabel berubah. Webhook Pocket Alert menerima JSON dan mengubahnya menjadi push. Menghubungkan keduanya memakan beberapa menit dan tanpa kode.

### Buat webhook Pocket Alert

Buka [Webhooks](/webhooks) di konsol Pocket Alert dan buat satu:

- **Name:** `Supabase`. Judul push selalu berbentuk `Webhook <name>`, jadi yang ini akan muncul sebagai "Webhook Supabase". Gunakan nama yang lebih spesifik, seperti `Supabase signups`, jika Anda berencana punya beberapa webhook.
- **Message:** templatenya, dibahas di bawah.

Salin URL yang ditampilkan konsol. Bentuknya seperti `https://p4a.me/wh/abc123xyz`. Slug di ujungnya adalah satu-satunya rahasia, jadi perlakukan seluruh URL seperti kata sandi.

### Buat webhook Supabase

Di dasbor Supabase, buka proyek Anda lalu pilih **Integrations → Database Webhooks** (panduan lama menyebutnya Database → Webhooks). Jika integrasinya belum aktif, aktifkan dulu; ini membuat fungsi trigger yang dipakai webhook. Setelah itu buat webhook baru:

1. Beri nama, misalnya `notify_new_order`.
2. Pilih tabel, misalnya `orders`.
3. Centang event-nya. Untuk notifikasi "baris baru", centang hanya **Insert**.
4. Pilih **HTTP Request** sebagai tipe, metode `POST`, lalu tempel URL Pocket Alert.
5. Biarkan header `Content-Type: application/json` apa adanya. Pocket Alert hanya menerima body JSON.

Simpan. Mulai sekarang, setiap insert ke `orders` akan mengirim permintaan setelah baris itu ditulis. Supabase membuat permintaan ini dengan ekstensi `pg_net`, yang bersifat asinkron, sehingga panggilan jaringan yang lambat tidak menahan proses insert itu sendiri.

### Yang dikirim Supabase

Body-nya memiliki bentuk yang sama untuk setiap tabel:

```json
{
  "type": "INSERT",
  "table": "orders",
  "schema": "public",
  "record": { "id": 1042, "email": "ana@example.com", "total": 49, "status": "pending" },
  "old_record": null
}
```

`record` adalah baris baru dengan semua kolomnya. Untuk `UPDATE`, `old_record` berisi baris sebelum diubah; untuk `DELETE`, `record` bernilai `null` dan hanya `old_record` yang terisi.

### Template pesan

Kembali ke webhook Pocket Alert, tulis pesan dengan placeholder `%path%` yang mengarah ke JSON tersebut:

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

Pesanan berikutnya akan muncul sebagai:

> **Webhook Supabase**
> New orders row: #1042 · ana@example.com · $49

Gunakan kolom apa pun yang dimiliki tabel Anda: `%record.plan%`, `%record.country%`, `%record.status%`. Tanda `*` sebagai pengganti template akan mengirim seluruh JSON, yang membantu saat Anda masih mencari tahu nama kolomnya.

Formulir yang sama juga punya **default level**. Atur `high` pada webhook orders agar lolos dari Fokus di iPhone, atau `low` pada tabel yang sibuk dan hanya ingin Anda lihat di riwayat. Payload Supabase tidak punya field `level`, jadi default webhook yang menentukan.

### Pendaftaran dari auth.users

Supabase menyimpan pengguna di `auth.users`, dan pemilih tabel Database Webhooks bisa memilihnya. Integrasi seperti Loops mendokumentasikan pengaturan persis seperti ini. Pilih tabel users di skema `auth`, centang **Insert**, dan gunakan:

```text
New signup: %record.email%
```

Jika tabel auth tidak muncul di pemilih, atau Anda lebih suka menjaga logikanya di SQL, trigger di bagian berikutnya juga bekerja pada `auth.users`.

## Di mana Level 1 berhenti

Database Webhook tidak punya kondisi. Centang **Update** pada `orders` dan Anda akan mendapat push setiap kali kolom apa pun berubah: statusnya, alamat pengirimannya, atau `updated_at` yang disentuh oleh job latar belakang. Template tidak bisa melewati permintaan; ia hanya memformatnya. Pada tabel yang sibuk, ini paling banter jadi gangguan, dan paling buruk menghabiskan 50 pesan per hari dari paket gratis sebelum makan siang.

Untuk "beri tahu saya saat pesanan dibayar" atau "beri tahu saya saat langganan dibatalkan", Anda membutuhkan filter, dan Postgres sudah punya itu.

## Level 2: trigger dengan pg_net dan kondisi WHEN

Database Webhook pada dasarnya adalah trigger yang memanggil `pg_net` untuk Anda. Menulis trigger sendiri memberi dua keuntungan: klausa `WHEN`, sehingga Postgres hanya berjalan pada perubahan yang Anda pedulikan, dan kendali penuh atas permintaan, sehingga Anda bisa memanggil API Pocket Alert langsung dengan judul, level, dan tombol sendiri.

### Simpan kunci API di Vault

Ambil kunci API dari [API Keys](/account/apikeys) dan simpan di Supabase Vault dari SQL Editor. Jalankan ini sekali, di luar migrasi Anda, supaya kuncinya tidak pernah masuk ke file:

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

Pastikan `pg_net` aktif di **Database → Extensions**. Proyek yang sudah memakai Database Webhooks biasanya sudah memilikinya.

### Fungsi dan trigger

Ini mengirim push hanya ketika status pesanan berubah menjadi `paid`:

```sql
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();
```

Fungsi tiap bagiannya:

- **`when (...)`** adalah filter yang tidak ada di Level 1. Postgres bahkan tidak memanggil fungsi kecuali statusnya benar-benar berubah dan nilai barunya `paid`. Perubahan pada kolom lain tidak berbiaya apa pun.
- **`security definer`** memungkinkan fungsi membaca Vault. Peran yang menulis baris dari aplikasi Anda, seperti `authenticated`, tidak bisa, dan tanpa ini pembaruan mereka akan gagal dengan error izin. Ini pola dari dokumentasi Supabase.
- **`net.http_post`** memasukkan permintaan ke antrean dan langsung kembali; permintaan dikirim setelah transaksi di-commit. Jika pembaruan di-rollback, tidak ada push yang terkirim.
- **`level`** menentukan seberapa keras notifikasinya masuk: `default` untuk kejadian rutin, `high` untuk menembus Fokus, `critical` untuk yang harus membangunkan Anda. Critical adalah fitur berbayar; di paket gratis ia dikirim sebagai `high`.

Salin fungsi ini untuk kejadian lain dan ubah kondisinya: `new.status = 'canceled'` pada `subscriptions`, `new.total > 500` pada trigger insert untuk pesanan besar, `new.role = 'admin'` pada `profiles`.

### Pendaftaran lewat trigger pada auth.users

Pola yang sama pada `auth.users`, dengan penyedia login disertakan di teks:

```sql
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 memperingatkan bahwa trigger yang gagal pada `auth.users` bisa memblokir pendaftaran. Pemanggilan `coalesce` mencegah nilai yang hilang merusak string, dan permintaannya sendiri bersifat asinkron, sehingga push yang lambat atau gagal tidak mengganggu pendaftaran. Meski begitu, uji sekali dengan akun sekali pakai sebelum Anda mengandalkannya.

### Atau Edge Function

Jika Anda lebih suka TypeScript daripada PL/pgSQL, pertahankan Database Webhook dari Level 1, atur tipenya ke **Supabase Edge Functions**, dan tambahkan header kunci rahasia yang disediakan formulir. Fungsi menerima payload `{type, table, record, old_record}` yang sama dan memutuskan sendiri. Pola Supabase untuk panggilan dengan kunci rahasia adalah pembungkus `withSupabase` dengan `auth: 'secret'`, ditambah `verify_jwt = false` untuk fungsi itu di `supabase/config.toml`:

```ts
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");
  }),
};
```

Atur kuncinya dengan `supabase secrets set POCKETALERT_API_KEY=...`. Kompromisnya: webhook tetap menyala pada setiap pembaruan, dan fungsi baru memfilter setelahnya, sehingga Anda membayar satu invokasi untuk setiap perubahan. Trigger `WHEN` memfilter sebelum apa pun berjalan.

## Batasan yang jujur

- **Tidak ada pemeriksaan tanda tangan.** Pocket Alert tidak memverifikasi asal permintaan webhook; slug URL adalah rahasianya. Jika itu penting, gunakan trigger Level 2, yang melakukan autentikasi dengan kunci API Anda.
- **Kunci sempat tersimpan di tabel antrean.** Supabase mencatat bahwa `pg_net` menyimpan header yang sudah didekripsi di `net.http_request_queue` sampai permintaan terkirim, dan peran mana pun yang bisa login ke database dapat membacanya di sana.
- **pg_net bersifat best effort.** Permintaan disimpan di tabel unlogged, sehingga crash pada waktu yang salah bisa menghilangkan satu permintaan. Cukup untuk "beri tahu saya", tidak untuk penagihan.
- **Volume.** Trigger pada tabel yang menerima ribuan tulisan per jam akan mengirim ribuan push kecuali kondisinya ketat. Paket gratis mengizinkan 50 pesan per hari.

## Jika tidak ada yang masuk

- **Periksa riwayat webhook Pocket Alert.** Setiap permintaan ke URL webhook dicatat di konsol beserta header, body, pesan yang sudah dirender, dan statusnya. Jika permintaannya ada, Supabase sudah melakukan bagiannya dan masalahnya ada di template. Jika tidak ada, periksa Supabase.
- **Periksa apa yang diterima pg_net.** Respons disimpan selama enam jam:

```sql
select status_code, content, error_msg, created
from net._http_response
order by created desc
limit 10;
```

`401` berarti kunci API di Vault salah; `400` biasanya berarti body bukan JSON yang valid atau ada field yang hilang.

- **Periksa kondisi trigger.** Jalankan pembaruan manual yang seharusnya cocok, misalnya `update orders set status = 'paid' where id = 1042;`, lalu lihat `net._http_response` lagi.
- **Periksa event-nya.** Webhook yang hanya mendengarkan Insert tidak akan menyala pada pembaruan, dan pada `DELETE` placeholder `%record.*%` kosong karena barisnya ada di `old_record`.

## FAQ

### Apakah ini sama dengan mengirim push notification ke pengguna aplikasi saya?

Tidak. Ini mengirim push ke HP Anda sendiri melalui aplikasi Pocket Alert. Push ke perangkat pengguna Anda melalui FCM, APNs, atau layanan seperti Expo, yang harus diintegrasikan sendiri oleh aplikasi Anda.

### Bisakah saya mendapat database webhook Supabase hanya untuk satu kolom?

Tidak dengan webhook dari dasbor; ia menyala pada perubahan apa pun di baris. Trigger dengan `after update of status` dan kondisi `WHEN`, seperti di Level 2, hanya menyala ketika kolom itu berubah sesuai yang Anda tentukan.

### Apakah ini bisa dipakai di paket gratis Supabase?

Ya. Database Webhooks, trigger, `pg_net`, dan Vault semuanya bagian dari proyek Supabase biasa, jadi tidak ada yang di sini membutuhkan paket Supabase berbayar.

### Bisakah saya mengirim tabel yang berbeda ke tujuan yang berbeda?

Bisa. Buat satu webhook Pocket Alert per tabel, masing-masing dengan nama, template, dan level sendiri, atau letakkan di aplikasi terpisah agar pendaftaran dan pesanan masuk ke saluran berbeda di aplikasi. Lebih banyak ide ada di [notifikasi database](/use-cases/database-alerts) dan [notifikasi pendaftaran](/use-cases/signup-alerts).

### Apakah saya harus memakai webhook milik Supabase?

Tidak. Apa pun yang bisa melakukan POST JSON bisa memakai [webhook Pocket Alert](/tools/webhook), dan apa pun yang bisa melakukan panggilan HTTP bisa memakai API.

[Buat akun gratis](/signup), arahkan satu tabel ke sana, dan pendaftaran berikutnya akan muncul di layar kunci Anda.
