Cara Menggunakan Supabase API: Panduan Lengkap

Supabase telah dengan cepat muncul sebagai alternatif sumber terbuka yang kuat untuk Firebase, menyediakan pengembang dengan serangkaian alat yang dibangun di sekitar database PostgreSQL. Di jantungnya, Supabase menawarkan lapisan API real-time instan di atas database Anda, secara signifikan mempercepat pengembangan backend. Panduan ini memberikan gambaran komprehensif tentang cara memanfaatkan API Supabase, dan mencakup segala hal mulai dari pengaturan awal dan operasi dasar hingga keamanan, kustomisasi, dan keamanan tipe.

1. Pendahuluan: Apa itu API Supabase?

Berbeda dengan pengembangan backend tradisional di mana Anda mungkin menghabiskan waktu yang cukup lama membangun endpoint REST atau GraphQL untuk berinteraksi dengan database Anda, Supabase secara otomatis menghasilkan API yang aman dan berkinerja untuk Anda. Ketika Anda membuat tabel di database PostgreSQL Supabase Anda, Supabase menggunakan PostgREST, alat sumber terbuka, untuk mengintrospeksi skema database Anda dan menyediakan endpoint RESTful yang sesuai.

Manfaat Utama:

• Backend Instan: Dapatkan endpoint API fungsional segera setelah Anda mendefinisikan skema database Anda.
• Kemampuan Real-time: Berlangganan perubahan database melalui WebSockets.
• Berdasarkan PostgreSQL: Manfaatkan kekuatan, fleksibilitas, dan kematangan PostgreSQL, termasuk fitur seperti Keamanan Tingkat Baris (RLS).
• Metode Interaksi Ganda: Berinteraksi melalui REST, GraphQL (didukung komunitas), atau pustaka klien Supabase (JavaScript, Python, Dart, dll.).
• Ekstensibilitas: Buat fungsi serverless kustom (Edge Functions) untuk logika atau integrasi yang kompleks.

Panduan ini fokus terutama pada API REST dan interaksinya melalui pustaka klien, serta Fungsi Edge Supabase.

2. Memulai dengan API Supabase

Cara termudah untuk memahami API Supabase adalah langsung terjun. Mari kita anggap Anda telah menyiapkan proyek Supabase (jika belum, kunjungi supabase.com dan buat satu secara gratis) dan telah membuat tabel sederhana, misalnya, profiles:

-- Buat tabel untuk profil publik
create table profiles (
  id uuid references auth.users not null primary key,
  updated_at timestamp with time zone,
  username text unique,
  avatar_url text,
  website text,

  constraint username_length check (char_length(username) >= 3)
);

-- Siapkan Keamanan Tingkat Baris (RLS)
-- Lihat https://supabase.com/docs/guides/auth/row-level-security untuk detail lebih lanjut.
alter table profiles
  enable row level security;

create policy "Profil publik dapat dilihat oleh semua orang." on profiles
  for select using (true);

create policy "Pengguna dapat memasukkan profil mereka sendiri." on profiles
  for insert with check (auth.uid() = id);

create policy "Pengguna dapat memperbarui profil mereka sendiri." on profiles
  for update using (auth.uid() = id);

-- Trigger ini secara otomatis membuat entri profil ketika pengguna baru mendaftar melalui Supabase Auth.
-- Lihat https://supabase.com/docs/guides/auth/managing-user-data#using-triggers untuk detail lebih lanjut.
create function public.handle_new_user()
returns trigger as $$
begin
  insert into public.profiles (id, username)
  values (new.id, new.raw_user_meta_data->>'username');
  return new;
end;
$$ language plpgsql security definer;
create trigger on_auth_user_created
  after insert on auth.users
  for each row execute procedure public.handle_new_user();

(Catatan: Contoh di atas menggunakan profiles, yang sesuai dengan contoh standar Supabase. Konsep ini berlaku sama untuk tabel todos atau tabel lain yang Anda buat.)

Menemukan Kredensial API Anda:

Setiap proyek Supabase dilengkapi dengan kredensial API yang unik:

1. URL Proyek: Endpoint Supabase unik Anda (misalnya, https://<your-project-ref>.supabase.co).
2. Kunci API: Ditemukan di Dasbor Proyek Supabase Anda di bawah Pengaturan Proyek > API.

• anon (kunci publik): Kunci ini aman digunakan dalam aplikasi sisi klien (seperti browser atau aplikasi seluler). Ini bergantung pada Keamanan Tingkat Baris (RLS) untuk mengontrol akses data.
• service_role kunci: Kunci rahasia ini memiliki hak istimewa administratif penuh, melanggar RLS. Jangan pernah mengekspos kunci ini dalam kode sisi klien. Gunakan hanya di lingkungan server yang aman (seperti server backend atau fungsi serverless).

Berinteraksi dengan API (menggunakan Pustaka Klien Supabase JS):

Supabase menyediakan pustaka klien untuk menyederhanakan interaksi API. Berikut cara Anda menggunakan pustaka JavaScript (supabase-js):

// 1. Impor dan inisialisasi klien
import { createClient } from '@supabase/supabase-js'

const supabaseUrl = 'https://<your-project-ref>.supabase.co'
const supabaseAnonKey = '<your-anon-key>'

const supabase = createClient(supabaseUrl, supabaseAnonKey)

// 2. Ambil data (SELECT *)
async function getProfiles() {
  const { data, error } = await supabase
    .from('profiles')
    .select('*')

  if (error) console.error('Error fetching profiles:', error)
  else console.log('Profiles:', data)
}

// 3. Masukkan data (INSERT)
async function createProfile(userId, username) {
  const { data, error } = await supabase
    .from('profiles')
    .insert([
      { id: userId, username: username, updated_at: new Date() },
    ])
    .select() // Mengembalikan data yang dimasukkan

  if (error) console.error('Error creating profile:', error)
  else console.log('Created Profile:', data)
}

// 4. Perbarui data (UPDATE)
async function updateProfileUsername(userId, newUsername) {
  const { data, error } = await supabase
    .from('profiles')
    .update({ username: newUsername, updated_at: new Date() })
    .eq('id', userId) // Hanya perbarui di mana id cocok
    .select()

  if (error) console.error('Error updating profile:', error)
  else console.log('Updated Profile:', data)
}

// 5. Hapus data (DELETE)
async function deleteProfile(userId) {
  const { data, error } = await supabase
    .from('profiles')
    .delete()
    .eq('id', userId) // Hanya hapus di mana id cocok

  if (error) console.error('Error deleting profile:', error)
  // Catatan: Hapus sering mengembalikan data minimal pada keberhasilan kecuali .select() digunakan *sebelum* .delete() pada beberapa versi/pengaturan.
  else console.log('Profile deleted successfully')
}

// Contoh Penggunaan (asumsi Anda memiliki ID pengguna)
// getProfiles();
// createProfile('some-uuid-v4', 'new_user');
// updateProfileUsername('some-uuid-v4', 'updated_username');
// deleteProfile('some-uuid-v4');

Quickstart ini menunjukkan operasi CRUD (Buat, Baca, Perbarui, Hapus) yang mendasar menggunakan pustaka klien, yang secara internal memanggil API REST.

3. API REST Supabase yang Dihasilkan Secara Otomatis

Sementara pustaka klien sangat nyaman, memahami API REST yang mendasarinya yang dihasilkan oleh PostgREST adalah penting.

Struktur Endpoint API:

URL dasar untuk API REST biasanya: https://<your-project-ref>.supabase.co/rest/v1/

Endpoint secara otomatis dibuat untuk tabel Anda:

• GET /rest/v1/nama_tabel_anda: Mengambil baris dari tabel.
• POST /rest/v1/nama_tabel_anda: Memasukkan baris baru ke dalam tabel.
• PATCH /rest/v1/nama_tabel_anda: Memperbarui baris yang ada di tabel.
• DELETE /rest/v1/nama_tabel_anda: Menghapus baris dari tabel.

Otentikasi:

Permintaan API harus menyertakan kunci API Anda di header apikey dan biasanya header Authorization yang berisi Bearer <your-api-key> (sering kali sama dengan kunci anon untuk permintaan sisi klien, atau kunci service_role untuk sisi server).

apikey: <your-anon-or-service-role-key>
Authorization: Bearer <your-anon-or-service-role-key>

Operasi Umum (menggunakan contoh curl):

Mari kita ulang contoh sebelumnya menggunakan curl terhadap API REST secara langsung. Gantilah placeholder sesuai kebutuhan.

Ambil Data (GET):

curl 'https://<ref>.supabase.co/rest/v1/profiles?select=*' \
  -H "apikey: <anon-key>" \
  -H "Authorization: Bearer <anon-key>"

Masukkan Data (POST):

curl 'https://<ref>.supabase.co/rest/v1/profiles' \
  -X POST \
  -H "apikey: <anon-key>" \
  -H "Authorization: Bearer <anon-key>" \
  -H "Content-Type: application/json" \
  -H "Prefer: return=representation" \# Opsional: Mengembalikan baris yang dimasukkan \
  -d '{ "id": "some-uuid", "username": "rest_user" }'

Perbarui Data (PATCH): (Perbarui profil di mana username adalah 'rest_user')

curl 'https://<ref>.supabase.co/rest/v1/profiles?username=eq.rest_user' \
  -X PATCH \
  -H "apikey: <anon-key>" \
  -H "Authorization: Bearer <anon-key>" \
  -H "Content-Type: application/json" \
  -H "Prefer: return=representation" \
  -d '{ "website": "https://example.com" }'

Hapus Data (DELETE): (Hapus profil di mana username adalah 'rest_user')

curl 'https://<ref>.supabase.co/rest/v1/profiles?username=eq.rest_user' \
  -X DELETE \
  -H "apikey: <anon-key>" \
  -H "Authorization: Bearer <anon-key>"

Penyaringan, Pemilihan, Pengurutan, Halaman:

API REST mendukung kueri yang kuat melalui parameter URL:

• Pemilihan Kolom: ?select=kolom1,kolom2
• Penyaringan (Kesetaraan): ?nama_kolom=eq.nilai (misalnya, ?id=eq.some-uuid)
• Penyaringan (Operator Lain): gt (lebih besar dari), lt (kurang dari), gte, lte, neq (tidak sama dengan), like, ilike (seperti tanpa memperhatikan huruf besar/kecil), in (misalnya, ?status=in.(active,pending))
• Pengurutan: ?order=nama_kolom.asc atau ?order=nama_kolom.desc (tambahkan .nullsfirst atau .nullslast jika diperlukan)
• Halaman: ?limit=10&offset=0 (ambil 10 pertama), ?limit=10&offset=10 (ambil 10 berikutnya)

Dokumentasi API yang Dihasilkan Secara Otomatis:

Salah satu fitur paling berguna dari Supabase adalah dokumentasi API yang dihasilkan secara otomatis yang tersedia langsung di dasbor proyek Anda.

1. Navigasikan ke proyek Supabase Anda.
2. Klik ikon API Docs (biasanya terlihat seperti <>) di sidebar kiri.
3. Pilih tabel di bawah "Tabel dan Tampilan".
4. Anda akan melihat dokumentasi terperinci untuk endpoint REST spesifik untuk tabel tersebut, termasuk:

• Permintaan contoh (Bash/curl, JavaScript).
• Filter, pemilih, dan modifikasi yang tersedia.
• Deskripsi kolom dan tipe data.

Dokumentasi interaktif ini sangat berharga untuk memahami cara menyusun panggilan API Anda.

4. Menghasilkan Tipe untuk Pengembangan yang Ditingkatkan Menggunakan API Supabase

Untuk proyek yang menggunakan TypeScript atau bahasa bertipe lainnya, Supabase menyediakan cara untuk menghasilkan definisi tipe langsung dari skema database Anda. Ini membawa manfaat signifikan:

• Kemanan Tipe: Tangkap kesalahan pada waktu kompilasi daripada waktu eksekusi.
• Autocompletion: Dapatkan saran cerdas di editor kode Anda untuk nama tabel, nama kolom, dan parameter fungsi.
• Pemeliharaan yang Lebih Baik: Tipe berfungsi sebagai dokumentasi hidup untuk struktur data Anda.

Menghasilkan Tipe menggunakan Supabase CLI:

1. Instal Supabase CLI: Ikuti petunjuk di https://supabase.com/docs/guides/cli.
2. Masuk: supabase login
3. Hubungkan proyek Anda: supabase link --project-ref <your-project-ref> (Jalankan ini di direktori proyek lokal Anda). Anda mungkin perlu memberikan kata sandi database.
4. Hasilkan tipe:

supabase gen types typescript --linked > src/database.types.ts
# Atau tentukan project-id jika tidak terhubung atau dalam konteks yang berbeda
# supabase gen types typescript --project-id <your-project-ref> > src/database.types.ts

Perintah ini memeriksa skema database proyek Supabase yang terhubung dan mengeluarkan file TypeScript (database.types.ts dalam contoh ini) yang berisi antarmuka untuk tabel, tampilan, dan argumen/tipe pengembalian fungsi Anda.

Menggunakan Tipe yang Dihasilkan:

Anda kemudian dapat mengimpor tipe ini ke dalam kode aplikasi Anda:

import { createClient } from '@supabase/supabase-js'
// Impor tipe yang dihasilkan
import { Database } from './database.types' // Sesuaikan path sesuai kebutuhan

const supabaseUrl = 'https://<your-project-ref>.supabase.co'
const supabaseAnonKey = '<your-anon-key>'

// Berikan tipe Database ke createClient
const supabase = createClient<Database>(supabaseUrl, supabaseAnonKey)

// Sekarang Anda mendapatkan keamanan tipe dan autocompletion!
async function getSpecificUserProfile(username: string) {
  // Autocompletes nama tabel ('profiles')
  const { data, error } = await supabase
    .from('profiles')
    // Autocompletes nama kolom ('id', 'username', 'website')
    .select('id, username, website')
    // Memeriksa tipe nilai terhadap tipe kolom
    .eq('username', username)
    .single() // Mengharapkan hasil tunggal atau null

  if (error) {
    console.error('Error fetching profile:', error)
    return null;
  }

  // 'data' kini diketik dengan benar berdasarkan kueri select Anda
  if (data) {
    console.log(`User ID: ${data.id}, Website: ${data.website}`);
    // console.log(data.non_existent_column); // <-- Kesalahan TypeScript!
  }

  return data;
}

Menghasilkan tipe adalah praktik yang sangat dianjurkan untuk pengembangan aplikasi yang kuat dengan Supabase.

5. Membuat Rute API Supabase Kustom dengan Fungsi Edge

Sementara API REST yang dihasilkan secara otomatis mencakup operasi CRUD standar, Anda sering kali memerlukan logika sisi server kustom untuk:

• Integrasi dengan layanan pihak ketiga (misalnya, Stripe, Twilio).
• Melakukan perhitungan kompleks atau agregasi data.
• Menjalankan logika yang memerlukan hak istimewa tinggi (service_role kunci) tanpa mengekspos kunci ke klien.
• Menegakkan aturan bisnis yang kompleks.

Fungsi Edge Supabase memberikan cara untuk menerapkan fungsi TypeScript berbasis Deno secara global di tepi, dekat dengan pengguna Anda.

Membuat Fungsi Edge:

1. Inisialisasi Fungsi (jika belum dilakukan): supabase functions new hello-world (jalankan di direktori proyek yang terhubung). Ini membuat file supabase/functions/hello-world/index.ts.

Tulis kode fungsi Anda:

// supabase/functions/hello-world/index.ts
import { serve } from 'https://deno.land/std@0.177.0/http/server.ts' // Gunakan versi std yang sesuai

serve(async (req) => {
  // Anda dapat mengakses header permintaan, metode, body, dll. dari 'req'
  console.log(`Permintaan diterima untuk: ${req.url}`);

  // Contoh: Mengakses DB Supabase dari dalam fungsi
  // Catatan: Memerlukan pengaturan klien Supabase *di dalam* fungsi
  // Gunakan variabel lingkungan untuk rahasia!
  // import { createClient } from '@supabase/supabase-js'
  // const supabaseAdmin = createClient(
  //   Deno.env.get('SUPABASE_URL') ?? '',
  //   Deno.env.get('SUPABASE_SERVICE_ROLE_KEY') ?? ''
  // )
  // const { data: users, error } = await supabaseAdmin.from('profiles').select('*').limit(10);

  const data = {
    message: `Hello from the Edge!`,
    // users: users // Contoh jika mengambil data
  }

  return new Response(
    JSON.stringify(data),
    { headers: { 'Content-Type': 'application/json' } },
  )
})

Terapkan fungsi:

supabase functions deploy hello-world --no-verify-jwt
# Gunakan --no-verify-jwt untuk fungsi yang dapat diakses publik
# Hilangkan atau atur --verify-jwt=true untuk meminta JWT Supabase Auth yang valid

Panggil fungsi:
Anda dapat memanggil fungsi yang diterapkan melalui permintaan HTTP POST (atau GET, tergantung pada logika fungsi) ke endpoint unik mereka:
https://<your-project-ref>.supabase.co/functions/v1/hello-world

Menggunakan curl:

curl -X POST 'https://<ref>.supabase.co/functions/v1/hello-world' \
  -H "Authorization: Bearer <user-jwt-if-required>" \
  -H "Content-Type: application/json" \
  -d '{"name": "Functions"}' # Body permintaan opsional

Atau menggunakan klien Supabase JS:

const { data, error } = await supabase.functions.invoke('hello-world', {
  method: 'POST', // atau 'GET', dll.
  body: { name: 'Functions' }
})

Fungsi Edge adalah alat yang kuat untuk memperluas kemampuan backend Supabase Anda di luar operasi database sederhana.

6. Kunci API dan Mengamankan API Supabase Anda

Memahami kunci API dan menerapkan langkah-langkah keamanan yang tepat adalah hal yang tidak dapat ditawar.

Rekap Kunci API:

• anon (kunci publik): Untuk penggunaan sisi klien. Bergantung sepenuhnya pada Keamanan Tingkat Baris (RLS) untuk perlindungan data.
• service_role kunci: Hanya untuk penggunaan sisi server. Mengabaikan RLS, memberikan akses penuh ke database. Jaga kunci ini dengan hati-hati.

Peran Penting Keamanan Tingkat Baris (RLS):

RLS adalah landasan keamanan Supabase ketika menggunakan kunci anon. Ini memungkinkan Anda untuk mendefinisikan kebijakan kontrol akses yang sangat terperinci langsung di dalam database PostgreSQL. Kebijakan pada dasarnya adalah aturan SQL yang menentukan baris mana yang dapat dilihat, dimasukkan, diperbarui, atau dihapus oleh pengguna berdasarkan status otentikasi, ID pengguna, peran, atau kriteria lainnya.

Mengaktifkan RLS:

Secara default, RLS nonaktif pada tabel baru. Anda harus mengaktifkannya untuk tabel mana pun yang akan Anda akses dari sisi klien menggunakan kunci anon.

-- Aktifkan RLS pada tabel 'profiles'
ALTER TABLE profiles ENABLE ROW LEVEL SECURITY;

-- PENTING: Jika tidak ada kebijakan yang ditentukan setelah mengaktifkan RLS,
-- akses secara implisit ditolak untuk semua operasi (kecuali pemilik tabel).

Membuat Kebijakan RLS:

Kebijakan mendefinisikan klausa USING (untuk akses baca seperti SELECT, UPDATE, DELETE) dan klausa WITH CHECK (untuk akses tulis seperti INSERT, UPDATE).

Contoh 1: Izinkan pengguna yang masuk untuk membaca semua profil:

CREATE POLICY "Izinkan akses baca terautentikasi"
ON profiles FOR SELECT
USING ( auth.role() = 'authenticated' );

Contoh 2: Izinkan pengguna untuk melihat hanya profil mereka sendiri:

CREATE POLICY "Izinkan akses baca individu"
ON profiles FOR SELECT
USING ( auth.uid() = id ); -- Mengasumsikan kolom 'id' cocok dengan UUID pengguna dari Supabase Auth

Contoh 3: Izinkan pengguna untuk memperbarui hanya profil mereka sendiri:

CREATE POLICY "Izinkan akses pembaruan individu"
ON profiles FOR UPDATE
USING ( auth.uid() = id ) -- Menentukan baris mana yang dapat ditargetkan untuk pembaruan
WITH CHECK ( auth.uid() = id ); -- Memastikan data *baru* masih memenuhi kondisi

Contoh 4: Izinkan pengguna untuk memasukkan profil mereka sendiri:

CREATE POLICY "Izinkan akses penyisipan individu"
ON profiles FOR INSERT
WITH CHECK ( auth.uid() = id );

Anda dapat melihat, membuat, dan mengelola kebijakan RLS langsung di Dasbor Supabase di bawah Otentikasi > Kebijakan.

Prinsip Keamanan Utama:

1. Selalu aktifkan RLS pada tabel yang diakses melalui kunci anon.
2. Definisikan kebijakan eksplisit untuk SELECT, INSERT, UPDATE, DELETE sesuai kebutuhan. Mulailah dengan kebijakan yang ketat dan buka akses dengan hati-hati.
3. Jangan pernah mengekspos service_role kunci dalam kode sisi klien atau lingkungan yang tidak aman.
4. Gunakan Fungsi Edge untuk operasi yang memerlukan hak istimewa tingkat tinggi atau logika sisi server yang kompleks, melindungi kunci service_role Anda dalam variabel lingkungan aman fungsi.
5. Secara teratur tinjau kebijakan RLS Anda untuk memastikan bahwa kebijakan tersebut memenuhi persyaratan keamanan aplikasi Anda.

7. Memetakan Konsep SQL ke API Supabase (SQL ke API)

Jika Anda akrab dengan SQL, memahami bagaimana operasi SQL umum dipetakan ke API Supabase (baik REST maupun pustaka klien) sangat membantu.

SELECT * FROM my_table;

• REST: GET /rest/v1/my_table?select=*
• JS: supabase.from('my_table').select('*')

SELECT column1, column2 FROM my_table WHERE id = 1;

• REST: GET /rest/v1/my_table?select=column1,column2&id=eq.1
• JS: supabase.from('my_table').select('column1, column2').eq('id', 1)

INSERT INTO my_table (column1, column2) VALUES ('value1', 'value2');

• REST: POST /rest/v1/my_table dengan body JSON {"column1": "value1", "column2": "value2"}
• JS: supabase.from('my_table').insert({ column1: 'value1', column2: 'value2' })

UPDATE my_table SET column1 = 'new_value' WHERE id = 1;

• REST: PATCH /rest/v1/my_table?id=eq.1 dengan body JSON {"column1": "new_value"}
• JS: supabase.from('my_table').update({ column1: 'new_value' }).eq('id', 1)

DELETE FROM my_table WHERE id = 1;

• REST: DELETE /rest/v1/my_table?id=eq.1
• JS: supabase.from('my_table').delete().eq('id', 1)

Gabungan: Meskipun sintaks SQL JOIN langsung tidak digunakan dalam panggilan REST dasar, Anda dapat mengambil data terkait menggunakan:

• Hubungan Kunci Asing: ?select=*,tabel_relatif(*) mengambil data dari tabel terkait yang didefinisikan oleh kunci asing.
• JS: supabase.from('my_table').select('*, tabel_relatif(*)')
• RPC (Panggilan Prosedur Jarak Jauh): Untuk gabungan atau logika yang kompleks, buat fungsi PostgreSQL dan panggil melalui API.

-- Contoh fungsi SQL
CREATE FUNCTION get_user_posts(user_id uuid)
RETURNS TABLE (post_id int, post_content text) AS $$
  SELECT posts.id, posts.content
  FROM posts
  WHERE posts.author_id = user_id;
$$ LANGUAGE sql;

• REST: POST /rest/v1/rpc/get_user_posts dengan body JSON {"user_id": "some-uuid"}
• JS: supabase.rpc('get_user_posts', { user_id: 'some-uuid' })

8. Menggunakan Skema Kustom dengan API Supabase

Secara default, tabel yang Anda buat di Editor SQL Supabase berada di skema public. Untuk organisasi yang lebih baik, penamaan ruang, atau manajemen izin, Anda mungkin ingin menggunakan skema PostgreSQL kustom.

Membuat Skema Kustom:

CREATE SCHEMA private_schema;

Membuat Tabel di Dalam Skema Kustom:

CREATE TABLE private_schema.sensitive_data (
  id serial primary key,
  payload jsonb
);

Mengakses Tabel di Skema Kustom melalui API:

Lapisan PostgREST Supabase secara otomatis mendeteksi tabel di skema lain selain public.

• API REST: Endpoint API tetap sama (/rest/v1/nama_tabel), tetapi PostgREST secara default mengekspos tabel dari skema lain. Anda mungkin perlu mengelola akses melalui peran dan hak di PostgreSQL jika Anda menginginkan kontrol akses tingkat skema yang lebih terperinci di luar RLS standar. Jika ada tabrakan nama (nama tabel yang sama di public dan skema lain), Anda mungkin memerlukan konfigurasi khusus atau menggunakan RPC. Periksa dokumentasi PostgREST untuk menangani visibilitas skema jika diperlukan.
• Pustaka Klien: Pustaka klien bekerja tanpa hambatan. Anda cukup merujuk nama tabel seperti biasa:

// Mengakses tabel di 'private_schema' (mengasumsikan RLS/izin memungkinkan)
const { data, error } = await supabase
  .from('sensitive_data') // Tidak perlu menambahkan prefiks dengan nama skema di sini
  .select('*')
  .eq('id', 1);

Supabase menangani pemetaan nama tabel ke skema yang benar di belakang layar. Pastikan kebijakan RLS Anda merujuk tabel dengan benar jika melibatkan kueri atau fungsi antar skema.

Menggunakan skema kustom adalah praktik PostgreSQL standar yang sepenuhnya didukung oleh Supabase, memungkinkan organisasi database yang lebih terstruktur.

9. Kesimpulan

API Supabase menawarkan cara yang sangat efisien untuk membangun aplikasi dengan menyediakan akses instan, aman, dan skalabel ke database PostgreSQL Anda. Dari endpoint REST yang dihasilkan secara otomatis dan pustaka klien yang berguna hingga keamanan yang kuat yang disediakan oleh Keamanan Tingkat Baris dan ekstensibilitas yang ditawarkan oleh Fungsi Edge, Supabase memberdayakan pengembang untuk fokus pada pembangunan fitur daripada infrastruktur backend yang rumit.

Dengan memahami konsep inti – kunci API, RLS, struktur REST, generasi tipe, dan fungsi kustom – Anda dapat memanfaatkan sepenuhnya kekuatan platform Supabase. Ingat untuk memprioritaskan keamanan.