Supabase API'sini Nasıl Kullanılır: Eksiksiz Bir Kılavuz

Supabase, PostgreSQL veritabanı etrafında oluşturulmuş bir dizi araç sunarak, geliştiricilere Firebase'e güçlü bir açık kaynak alternatifi olarak hızla ortaya çıktı. Temelinde Supabase, veritabanınızın üzerine anında, gerçek zamanlı bir API katmanı sunarak arka uç geliştirmeyi önemli ölçüde hızlandırır. Bu kılavuz, Supabase API'sinden nasıl yararlanılacağına dair kapsamlı bir genel bakış sunar ve ilk kurulum ve temel işlemlerden güvenliğe, özelleştirmeye ve tür güvenliğine kadar her şeyi kapsar.

💡

Güzel API Dokümantasyonu oluşturan harika bir API Test aracı mı istiyorsunuz?

Geliştirici Ekibinizin maksimum verimlilikle birlikte çalışması için entegre, Hepsi Bir Arada bir platform mu istiyorsunuz?

Apidog tüm taleplerinizi karşılıyor ve Postman'in yerini çok daha uygun bir fiyata alıyor!

button

1. Giriş: Supabase API Nedir?

Veritabanınızla etkileşim kurmak için REST veya GraphQL uç noktaları oluşturmak için önemli zaman harcayabileceğiniz geleneksel arka uç geliştirmesinden farklı olarak, Supabase sizin için otomatik olarak güvenli ve performanslı bir API oluşturur. Supabase PostgreSQL veritabanınızda bir tablo oluşturduğunuzda, Supabase, veritabanı şemanızı incelemek ve ilgili RESTful uç noktaları sağlamak için PostgREST, açık kaynaklı bir araç kullanır.

Temel Faydalar:

Anında Arka Uç: Veritabanı şemanızı tanımlar tanımlamaz işlevsel API uç noktaları edinin.
Gerçek Zamanlı Yetenekler: WebSockets aracılığıyla veritabanı değişikliklerine abone olun.
PostgreSQL Tabanlı: Satır Düzeyi Güvenlik (RLS) gibi özellikler de dahil olmak üzere PostgreSQL'in gücünden, esnekliğinden ve olgunluğundan yararlanın.
Çoklu Etkileşim Yöntemleri: REST, GraphQL (topluluk destekli) veya Supabase'in istemci kitaplıkları (JavaScript, Python, Dart, vb.) aracılığıyla etkileşim kurun.
Genişletilebilirlik: Karmaşık mantık veya entegrasyonlar için özel sunucusuz işlevler (Edge Functions) oluşturun.

Bu kılavuz öncelikle REST API'sine ve istemci kitaplıkları aracılığıyla etkileşimine ve ayrıca Supabase Edge Functions'a odaklanmaktadır.

2. Supabase API'ye Başlarken

Supabase API'sini anlamanın en kolay yolu doğrudan atlamaktır. Bir Supabase projeniz olduğunu (değilse, supabase.com adresini ziyaret edin ve ücretsiz bir tane oluşturun) ve örneğin profiles gibi basit bir tablo oluşturduğunuzu varsayalım:

-- Create a table for public profiles
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)
);

-- Set up Row Level Security (RLS)
-- See https://supabase.com/docs/guides/auth/row-level-security for more details.
alter table profiles
  enable row level security;

create policy "Public profiles are viewable by everyone." on profiles
  for select using (true);

create policy "Users can insert their own profile." on profiles
  for insert with check (auth.uid() = id);

create policy "Users can update own profile." on profiles
  for update using (auth.uid() = id);

-- This trigger automatically creates a profile entry when a new user signs up via Supabase Auth.
-- See https://supabase.com/docs/guides/auth/managing-user-data#using-triggers for more details.
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();

(Not: Yukarıdaki örnek, Supabase'in standart örnekleriyle uyumlu olarak profiles kullanır. Konsept, bir todos tablosu veya oluşturduğunuz başka herhangi bir tablo için eşit olarak geçerlidir.)

API Kimlik Bilgilerinizi Bulma:

Her Supabase projesi benzersiz API kimlik bilgileriyle birlikte gelir:

Proje URL'si: Benzersiz Supabase uç noktanız (örneğin, https://<your-project-ref>.supabase.co).
API Anahtarları: Project Settings > API altında Supabase Proje Panonuzda bulunur.

anon (genel) anahtar: Bu anahtar, istemci tarafı uygulamalarda (tarayıcılar veya mobil uygulamalar gibi) kullanmak güvenlidir. Veri erişimini kontrol etmek için Satır Düzeyi Güvenliğine (RLS) dayanır.
service_role anahtarı: Bu, RLS'yi atlayarak tam yönetim ayrıcalıklarına sahip gizli bir anahtardır. Bu anahtarı asla istemci tarafı kodda ifşa etmeyin. Yalnızca güvenli sunucu ortamlarında (arka uç sunucuları veya sunucusuz işlevler gibi) kullanın.

API ile Etkileşim (Supabase JS İstemci Kitaplığı kullanılarak):

Supabase, API etkileşimlerini basitleştirmek için istemci kitaplıkları sağlar. İşte JavaScript kitaplığını (supabase-js) nasıl kullanacağınız:

// 1. Import and initialize the client
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. Fetch 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. Insert data (INSERT)
async function createProfile(userId, username) {
  const { data, error } = await supabase
    .from('profiles')
    .insert([
      { id: userId, username: username, updated_at: new Date() },
    ])
    .select() // Return the inserted data

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

// 4. Update data (UPDATE)
async function updateProfileUsername(userId, newUsername) {
  const { data, error } = await supabase
    .from('profiles')
    .update({ username: newUsername, updated_at: new Date() })
    .eq('id', userId) // Only update where id matches
    .select()

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

// 5. Delete data (DELETE)
async function deleteProfile(userId) {
  const { data, error } = await supabase
    .from('profiles')
    .delete()
    .eq('id', userId) // Only delete where id matches

  if (error) console.error('Error deleting profile:', error)
  // Note: Delete often returns minimal data on success unless .select() is used *before* .delete() on some versions/setups.
  else console.log('Profile deleted successfully')
}

// Example Usage (assuming you have a user ID)
// getProfiles();
// createProfile('some-uuid-v4', 'new_user');
// updateProfileUsername('some-uuid-v4', 'updated_username');
// deleteProfile('some-uuid-v4');

Bu hızlı başlangıç, dahili olarak REST API'sini çağıran istemci kitaplığını kullanarak temel CRUD (Oluştur, Oku, Güncelle, Sil) işlemlerini gösterir.

3. Otomatik Oluşturulan Supabase REST API'si

İstemci kitaplıkları kullanışlı olsa da, PostgREST tarafından oluşturulan temel REST API'sini anlamak çok önemlidir.

API Uç Noktası Yapısı:

REST API'si için temel URL genellikle şudur: https://<your-project-ref>.supabase.co/rest/v1/

Uç noktalar tablolarınız için otomatik olarak oluşturulur:

GET /rest/v1/your_table_name: Tablodan satırları alır.
POST /rest/v1/your_table_name: Tabloya yeni satırlar ekler.
PATCH /rest/v1/your_table_name: Tablodaki mevcut satırları günceller.
DELETE /rest/v1/your_table_name: Tablodan satırları siler.

Kimlik Doğrulama:

API istekleri, apikey başlığında API anahtarınızı ve genellikle Bearer <your-api-key> içeren bir Authorization başlığı (genellikle istemci tarafı istekler için aynı anon anahtarı veya sunucu tarafı için service_role anahtarı) içermelidir.

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

Yaygın İşlemler (`curl` örnekleri kullanılarak):

Önceki örnekleri doğrudan REST API'sine karşı curl kullanarak çoğaltalım. Yer tutucuları buna göre değiştirin.

Veri Getirme (GET):

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

Veri Ekleme (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" \# Optional: Returns the inserted row(s) \
  -d '{ "id": "some-uuid", "username": "rest_user" }'

Veri Güncelleme (PATCH): (Kullanıcı adı 'rest_user' olan profili güncelle)

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" }'

Veri Silme (DELETE): (Kullanıcı adı 'rest_user' olan profili sil)

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

Filtreleme, Seçme, Sıralama, Sayfalama:

REST API'si, URL parametreleri aracılığıyla güçlü sorgulamayı destekler:

Sütunları Seçme: ?select=column1,column2
Filtreleme (Eşitlik): ?column_name=eq.value (örneğin, ?id=eq.some-uuid)
Filtreleme (Diğer İşleçler): gt (büyüktür), lt (küçüktür), gte, lte, neq (eşit değildir), like, ilike (büyük/küçük harf duyarsız gibi), in (örneğin, ?status=in.(active,pending))
Sıralama: ?order=column_name.asc veya ?order=column_name.desc (gerekirse .nullsfirst veya .nullslast ekleyin)
Sayfalama: ?limit=10&offset=0 (ilk 10'u getir), ?limit=10&offset=10 (sonraki 10'u getir)

Otomatik Oluşturulan API Dokümantasyonu:

Supabase'in en yardımcı özelliklerinden biri, proje panonuzda doğrudan bulunan otomatik oluşturulan API dokümantasyonudur.

Supabase projenize gidin.
Sol kenar çubuğundaki API Belgeleri simgesine (genellikle <> gibi görünür) tıklayın.
"Tablolar ve Görünümler" altında bir tablo seçin.
Şunları içeren, o tabloya özel REST uç noktaları için ayrıntılı dokümantasyon göreceksiniz:

Örnek istekler (Bash/curl, JavaScript).
Kullanılabilir filtreler, seçiciler ve değiştiriciler.
Sütunların ve veri türlerinin açıklamaları.

Bu etkileşimli dokümantasyon, API çağrılarınızı nasıl yapılandıracağınızı anlamak için paha biçilmezdir.

4. Supabase API'sini Kullanarak Gelişmiş Geliştirme İçin Tür Oluşturma

TypeScript veya diğer türü belirlenmiş dilleri kullanan projeler için Supabase, tür tanımlarını doğrudan veritabanı şemanızdan oluşturmanın bir yolunu sağlar. Bu, önemli faydalar sağlar:

Tür Güvenliği: Çalışma zamanı yerine derleme zamanında hataları yakalayın.
Otomatik Tamamlama: Tablo adları, sütun adları ve işlev parametreleri için kod düzenleyicinizde akıllı öneriler alın.
Geliştirilmiş Bakım: Türler, veri yapılarız için canlı dokümantasyon görevi görür.

Supabase CLI Kullanarak Tür Oluşturma:

Supabase CLI'yi Yükleyin: https://supabase.com/docs/guides/cli adresindeki talimatları izleyin.
Oturum açın: supabase login
Projenizi bağlayın: supabase link --project-ref <your-project-ref> (Bunu yerel proje dizininizde çalıştırın). Bir veritabanı parolası sağlamanız gerekebilir.
Türleri oluşturun:

supabase gen types typescript --linked > src/database.types.ts
# Or specify project-id if not linked or in a different context
# supabase gen types typescript --project-id <your-project-ref> > src/database.types.ts

Bu komut, bağlantılı Supabase projenizin veritabanı şemasını inceler ve tablolarınız, görünümleriniz ve işlev bağımsız değişkenleriniz/dönüş türleriniz için arabirimler içeren bir TypeScript dosyası (bu örnekte database.types.ts) çıkarır.

Oluşturulan Türleri Kullanma:

Daha sonra bu türleri uygulama kodunuza aktarabilirsiniz:

import { createClient } from '@supabase/supabase-js'
// Import the generated types
import { Database } from './database.types' // Adjust path as needed

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

// Provide the Database type to createClient
const supabase = createClient<Database>(supabaseUrl, supabaseAnonKey)

// Now you get type safety and autocompletion!
async function getSpecificUserProfile(username: string) {
  // Autocompletes table names ('profiles')
  const { data, error } = await supabase
    .from('profiles')
    // Autocompletes column names ('id', 'username', 'website')
    .select('id, username, website')
    // Type checks the value against the column type
    .eq('username', username)
    .single() // Expects a single result or null

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

  // 'data' is now correctly typed based on your select query
  if (data) {
    console.log(`User ID: ${data.id}, Website: ${data.website}`);
    // console.log(data.non_existent_column); // <-- TypeScript error!
  }

  return data;
}

Tür oluşturma, Supabase ile sağlam uygulama geliştirmesi için şiddetle tavsiye edilen bir uygulamadır.

5. Edge Functions ile Özel Supabase API Rotaları Oluşturma

Otomatik oluşturulan REST API'si standart CRUD işlemlerini kapsarken, genellikle aşağıdakiler için özel sunucu tarafı mantığına ihtiyacınız olacaktır:

Üçüncü taraf hizmetlerle (örneğin, Stripe, Twilio) entegre etme.
Karmaşık hesaplamalar veya veri toplamaları gerçekleştirme.
Anahtarı istemciye ifşa etmeden, ayrıcalıklı ayrıcalıklar (service_role anahtarı) gerektiren mantık çalıştırma.
Karmaşık iş kurallarını uygulama.

Supabase Edge Functions, Deno tabanlı TypeScript işlevlerini kullanıcılarınıza yakın, kenarda küresel olarak dağıtmanın bir yolunu sağlar.

Bir Edge İşlevi Oluşturma:

İşlevleri Başlatın (henüz yapılmadıysa): supabase functions new hello-world (bağlantılı proje dizininizde çalıştırın). Bu, bir supabase/functions/hello-world/index.ts dosyası oluşturur.

İşlev kodunuzu yazın:

// supabase/functions/hello-world/index.ts
import { serve } from 'https://deno.land/std@0.177.0/http/server.ts' // Use appropriate std version

serve(async (req) => {
  // You can access request headers, method, body etc. from 'req'
  console.log(`Request received for: ${req.url}`);

  // Example: Accessing Supabase DB from within the function
  // Note: Requires setting up the Supabase client *inside* the function
  // Use environment variables for secrets!
  // 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 // Example if fetching data
  }

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

İşlevi dağıtın:

supabase functions deploy hello-world --no-verify-jwt
# Use --no-verify-jwt for publicly accessible functions
# Omit it or set --verify-jwt=true to require a valid Supabase Auth JWT

İşlevi çağırın:
Dağıtılan işlevleri, benzersiz uç noktalarına HTTP POST istekleri (veya GET, işlev mantığına bağlı olarak) aracılığıyla çağırabilirsiniz:
https://<your-project-ref>.supabase.co/functions/v1/hello-world

curl kullanma:

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"}' # Optional request body

Veya Supabase JS istemcisini kullanma:

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

Edge Functions, Supabase arka uç yeteneklerinizi basit veritabanı işlemlerinin ötesine genişletmek için güçlü bir araçtır.

6. API Anahtarları ve Supabase API'nizi Güvenli Hale Getirme

API anahtarlarını anlamak ve uygun güvenlik önlemleri uygulamak pazarlık edilemez.

API Anahtarları Özeti:

anon (genel) anahtar: İstemci tarafı kullanımı için. Tamamen Satır Düzeyi Güvenliğine (RLS) dayanır.
service_role anahtarı: YALNIZCA sunucu tarafı kullanımı için. RLS'yi atlar, tam veritabanı erişimi sağlar. Bu anahtarı dikkatlice koruyun.

Satır Düzeyi Güvenliğinin (RLS) Önemli Rolü:

anon anahtarını kullanırken Supabase güvenliğinin temel taşı RLS'dir. PostgreSQL veritabanında doğrudan ayrıntılı erişim kontrolü ilkeleri tanımlamanıza olanak tanır. İlkeler, bir kullanıcının kimlik doğrulama durumuna, kullanıcı kimliğine, rolüne veya diğer ölçütlere göre hangi satırları görüntüleyebileceğini, ekleyebileceğini, güncelleyebileceğini veya silebileceğini belirleyen temel olarak SQL kurallarıdır.

RLS'yi Etkinleştirme:

Varsayılan olarak, RLS yeni tablolarda devre dışıdır. anon anahtarını kullanarak istemci tarafından erişmeyi düşündüğünüz herhangi bir tablo için etkinleştirmeniz gerekir.

-- Enable RLS on the 'profiles' table
ALTER TABLE profiles ENABLE ROW LEVEL SECURITY;

-- IMPORTANT: If no policies are defined after enabling RLS,
-- access is implicitly denied for all operations (except the table owner).

RLS İlkeleri Oluşturma:

İlkeler, USING yan tümcesini (SELECT, UPDATE, DELETE gibi okuma erişimi için) ve WITH CHECK yan tümcesini (INSERT, UPDATE gibi yazma erişimi için) tanımlar.

Örnek 1: Oturum açmış kullanıcıların tüm profilleri okumasına izin verin:

CREATE POLICY "Allow authenticated read access"
ON profiles FOR SELECT
USING ( auth.role() = 'authenticated' );

Örnek 2: Kullanıcıların yalnızca kendi profilini görüntülemesine izin verin:

CREATE POLICY "Allow individual read access"
ON profiles FOR SELECT
USING ( auth.uid() = id ); -- Assumes 'id' column matches the user's UUID from Supabase Auth

Örnek 3: Kullanıcıların yalnızca kendi profilini güncellemesine izin verin:

CREATE POLICY "Allow individual update access"
ON profiles FOR UPDATE
USING ( auth.uid() = id ) -- Specifies which rows can be targeted for update
WITH CHECK ( auth.uid() = id ); -- Ensures any *new* data still matches the condition

Örnek 4: Kullanıcıların kendi profilini eklemesine izin verin:

CREATE POLICY "Allow individual insert access"
ON profiles FOR INSERT
WITH CHECK ( auth.uid() = id );

RLS ilkelerini doğrudan Supabase Panosunda Authentication > Policies altında görüntüleyebilir, oluşturabilir ve yönetebilirsiniz.

Temel Güvenlik İlkeleri:

anon anahtarı aracılığıyla erişilen tablolarda her zaman RLS'yi etkinleştirin.
Gerektiğinde SELECT, INSERT, UPDATE, DELETE için açık ilkeler tanımlayın. Kısıtlayıcı ilkelerle başlayın ve erişimi dikkatlice açın.
İstemci tarafı kodda veya güvensiz ortamlarda asla service_role anahtarını ifşa etmeyin.
Ayrıcalıklı ayrıcalıklar veya karmaşık sunucu tarafı mantığı gerektiren işlemler için Edge Functions kullanın, service_role anahtarınızı işlevin güvenli ortam değişkenleri içinde koruyun.
Uygulamanızın güvenlik gereksinimlerini karşıladıklarından emin olmak için RLS ilkelerinizi düzenli olarak inceleyin.

7. SQL Kavramlarını Supabase API'sine Eşleme (SQL'den API'ye)

SQL'e aşinaysanız, yaygın SQL işlemlerinin Supabase API'sine (hem REST hem de istemci kitaplıkları) nasıl eşlendiğini anlamak faydalıdır.

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: JSON gövdesiyle POST /rest/v1/my_table {"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: JSON gövdesiyle PATCH /rest/v1/my_table?id=eq.1 {"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)

Birleştirmeler: Temel REST çağrılarında doğrudan SQL JOIN sözdizimi kullanılmazken, ilgili verileri şunları kullanarak getirebilirsiniz:

Yabancı Anahtar İlişkileri: ?select=*,related_table(*), yabancı anahtarlar tarafından tanımlanan ilgili tablolardan veri getirir.
JS: supabase.from('my_table').select('*, related_table(*)')
RPC (Uzaktan Prosedür Çağrıları): Karmaşık birleştirmeler veya mantık için, bir PostgreSQL işlevi oluşturun ve API aracılığıyla çağırın.

-- Example SQL function
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: JSON gövdesiyle POST /rest/v1/rpc/get_user_posts {"user_id": "some-uuid"}
JS: supabase.rpc('get_user_posts', { user_id: 'some-uuid' })

8. Supabase API ile Özel Şemalar Kullanma

Varsayılan olarak, Supabase SQL Düzenleyicisi'nde oluşturduğunuz tablolar public şemasında bulunur. Daha iyi organizasyon, ad alanı veya izin yönetimi için, özel PostgreSQL şemaları kullanmak isteyebilirsiniz.

Özel Bir Şema Oluşturma:

CREATE SCHEMA private_schema;

Özel Bir Şemada Tablolar Oluşturma:

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

API aracılığıyla Özel Şemalardaki Tablolara Erişim:

Supabase'in PostgREST katmanı, public dışındaki şemalardaki tabloları otomatik olarak algılar.

REST API: API uç noktaları aynı kalır (/rest/v1/table_name), ancak PostgREST, varsayılan olarak diğer şemalardaki tabloları kullanıma sunar. Standart RLS'nin ötesinde ayrıntılı şema düzeyinde erişim kontrolü istiyorsanız, PostgreSQL'de roller ve yetkiler aracılığıyla erişimi yönetmeniz gerekebilir. Bir ad çakışması varsa (public ve başka bir şemada aynı tablo adı), belirli bir yapılandırmaya veya RPC'ye ihtiyacınız olabilir. Gerekirse şema görünürlüğünü işlemek için PostgREST belgelerine bakın.
İstemci Kitaplıkları: İstemci kitaplıkları sorunsuz çalışır. Tablo adına her zamanki gibi başvurmanız yeterlidir:

// Accessing a table in 'private_schema' (assuming RLS/permissions allow)
const { data, error } = await supabase
  .from('sensitive_data') //