Przejdź do treści

Integracja Supabase z Next.js App Router

Maciej Sala

Founder StriveLab

11 min czytaniaAktualizacja

Szybka odpowiedź: jak bezpiecznie zintegrować Supabase z Next.js?

  • Konfiguruj przez @supabase/ssr z osobnymi klientami dla przeglądarki i serwera.
  • Używaj NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY zamiast starego ANON_KEY.
  • proxy.ts odświeża sesję, ale nie zastępuje sprawdzania uprawnień w Server Components, Route Handlers i Server Actions.
  • RLS, polityki Storage i ograniczone subskrypcje Realtime są częścią implementacji od pierwszego dnia.
  • Odpowiedzi z danymi użytkownika nie powinny być cache'owane publicznie.

Czym jest Supabase i dlaczego pasuje do Next.js?

W 2026 roku najważniejsza zmiana w tym stacku jest prosta: nie zaczynaj od starych Auth Helpers. Do integracji z App Routerem używaj @supabase/ssr, cookies, osobnych klientów server/browser i proxy.ts, który odświeża sesję dla .

Druga zasada: Supabase nie zwalnia z myślenia o bezpieczeństwie. Publiczny klient w przeglądarce jest normalną częścią architektury, ale dane chroni baza przez . Jeśli RLS jest źle ustawione, problemu nie naprawi elegancki komponent Reacta.

Warto widzieć ten stack jako kilka warstw kontroli dostępu, a nie jedno SDK wywoływane z Reacta. Proxy dba o świeżą sesję, kod serwerowy sprawdza użytkownika, a baza i polityki Supabase egzekwują dostęp do danych.

Diagram
Warstwy dostępu w aplikacji Next.js + Supabase

Setup projektu Supabase i Next.js

Przykłady zakładają projekt Next.js 16 z App Routerem i TypeScriptem oraz utworzony projekt Supabase. Alias @/ powinien wskazywać katalog zawierający app i lib; jeśli używasz src, umieść tam również proxy.ts. Zod służy do walidacji formularza, a server-only chroni moduł serwerowy przed importem do klienta.

Instalacja pakietów jest krótka:

Code
npm install @supabase/supabase-js @supabase/ssr zod server-only

Pakiet @supabase/ssr jest rekomendowanym następcą Auth Helpers, ale nadal ma status beta. Przed aktualizacją sprawdzaj changelog, bo jego API może jeszcze otrzymywać zmiany niekompatybilne wstecz.

W nowych projektach Supabase promuje publishable keys:

Code
# .env.local
NEXT_PUBLIC_SUPABASE_URL=https://twoj-projekt.supabase.co
NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY=sb_publishable_xxx
NEXT_PUBLIC_SITE_URL=http://localhost:3000

Na produkcji ustaw NEXT_PUBLIC_SITE_URL na właściwy adres HTTPS. W Supabase skonfiguruj Site URL i dozwolone Redirect URLs, w tym /auth/callback dla używanych środowisk. Zmienne NEXT_PUBLIC_* trafiają do bundla podczas budowania, więc po ich zmianie wykonaj nowy build.

Jeśli pracujesz na starszym projekcie, możesz jeszcze spotkać NEXT_PUBLIC_SUPABASE_ANON_KEY. To nadal może działać, ale przy nowym setupie warto przejść na , bo to aktualny kierunek dokumentacji Supabase.

Nigdy nie dodawaj nowego klucza sb_secret_... ani legacy jako zmiennej NEXT_PUBLIC_*. Oba zapewniają podwyższone uprawnienia i omijają RLS, więc mogą istnieć tylko w bezpiecznym kontekście serwerowym, np. w chronionym Route Handlerze, zadaniu administracyjnym albo Edge Function. W nowym projekcie używaj secret key; service_role jest kluczem legacy.

Zwykły klient SSR obsługujący zalogowanego użytkownika nadal używa klucza publishable i jego sesji. Sam fakt działania na serwerze nie uzasadnia użycia secret key.

Klient Supabase dla Next.js App Router

W App Routerze potrzebujesz co najmniej dwóch klientów: jednego do kodu przeglądarkowego i jednego do kodu serwerowego.

Code
// lib/supabase/client.ts
import { createBrowserClient } from '@supabase/ssr'
 
export function createClient() {
  return createBrowserClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!,
  )
}
Code
// lib/supabase/server.ts
import 'server-only'
import { createServerClient } from '@supabase/ssr'
import { cookies } from 'next/headers'
 
export async function createClient() {
  const cookieStore = await cookies()
 
  return createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!,
    {
      cookies: {
        getAll() {
          return cookieStore.getAll()
        },
        setAll(cookiesToSet, _headers) {
          try {
            cookiesToSet.forEach(({ name, value, options }) => {
              cookieStore.set(name, value, options)
            })
          } catch {
            // Server Components nie mogą zapisywać cookies.
            // Odświeżanie sesji obsługuje proxy.ts.
          }
        },
      },
    },
  )
}

Klienta serwerowego twórz osobno dla żądania, nie jako współdzielony singleton z sesją użytkownika.

Po utworzeniu tabel z dalszych przykładów wygeneruj typy bazy. Zaloguj CLI przez npx supabase login, ustaw PROJECT_REF na identyfikator projektu i utwórz katalog docelowy:

Code
mkdir -p src/types
npx supabase gen types typescript --project-id "$PROJECT_REF" > src/types/database.types.ts

Zaimportuj Database z wygenerowanego pliku i przekaż go do createServerClient<Database>(...) oraz createBrowserClient<Database>(...). Ścieżkę dostosuj do projektu bez src, jeśli takiego używasz. Regeneruj typy po migracjach schematu.

Proxy do odświeżania sesji Supabase Auth

Od Next.js 16 konwencja middleware.ts została przemianowana na proxy.ts. W Next.js 15 użyj middleware.ts i eksportu middleware; sam plik proxy.ts nie zostanie tam uruchomiony. W kontekście Supabase mechanizm Proxy jest potrzebny głównie dlatego, że Server Components nie mogą samodzielnie zapisać odświeżonych cookies.

Warto rozdzielić plik konwencji Next.js od logiki Supabase:

Code
// proxy.ts
import { type NextRequest } from 'next/server'
import { updateSession } from '@/lib/supabase/proxy'
 
export async function proxy(request: NextRequest) {
  return await updateSession(request)
}
 
export const config = {
  matcher: [
    '/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)',
  ],
}
Code
// lib/supabase/proxy.ts
import { createServerClient } from '@supabase/ssr'
import { NextResponse, type NextRequest } from 'next/server'
 
export async function updateSession(request: NextRequest) {
  let response = NextResponse.next({ request })
 
  const supabase = createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!,
    {
      cookies: {
        getAll() {
          return request.cookies.getAll()
        },
        setAll(cookiesToSet, headers) {
          cookiesToSet.forEach(({ name, value }) => {
            request.cookies.set(name, value)
          })
 
          response = NextResponse.next({ request })
 
          cookiesToSet.forEach(({ name, value, options }) => {
            response.cookies.set(name, value, options)
          })
 
          Object.entries(headers).forEach(([key, value]) => {
            response.headers.set(key, value)
          })
        },
      },
    },
  )
 
  // Nie dodawaj logiki między createServerClient() i getClaims().
  // To wywołanie weryfikuje JWT i w razie potrzeby odświeża sesję.
  await supabase.auth.getClaims()
 
  return response
}

Drugi argument setAll() zawiera między innymi nagłówki zabezpieczające odpowiedź z odświeżoną sesją przed publicznym cache'owaniem. Trzeba przenieść je na zwracany NextResponse, tak samo jak cookies. Jeśli tworzysz później nową odpowiedź, np. przekierowanie, skopiuj na nią cookies oraz nagłówki Cache-Control, Expires i Pragma. Sam helper server.ts zapisuje cookies, ale nie przenosi _headers na odpowiedź: w Route Handlers ustawiaj ochronę cache jawnie.

Proxy może robić wstępne przekierowania dla /dashboard, ale nie traktuj go jako pełnego systemu autoryzacji. Next.js uruchamia Proxy przed renderowaniem, a ten mechanizm nie powinien stać się miejscem ciężkiej logiki biznesowej.

Uwierzytelnianie Supabase w Server Actions

Logowanie hasłem możesz zrobić w Client Component przez signInWithPassword, ale w App Routerze coraz częściej wygodniejszy jest . Formularz pozostaje prosty, cookies są ustawiane po stronie serwera, a po mutacji możesz odświeżyć cache.

Code
// app/login/actions.ts
'use server'
 
import { createClient } from '@/lib/supabase/server'
import { revalidatePath } from 'next/cache'
import { redirect } from 'next/navigation'
 
export type AuthState = {
  error: string | null
}
 
export async function login(
  _previousState: AuthState,
  formData: FormData,
): Promise<AuthState> {
  const supabase = await createClient()
 
  const email = String(formData.get('email') ?? '')
  const password = String(formData.get('password') ?? '')
 
  const { error } = await supabase.auth.signInWithPassword({
    email,
    password,
  })
 
  if (error) {
    return { error: 'Nie udało się zalogować. Sprawdź adres e-mail i hasło.' }
  }
 
  revalidatePath('/', 'layout')
  redirect('/dashboard')
}
 
export async function signup(
  _previousState: AuthState,
  formData: FormData,
): Promise<AuthState> {
  const supabase = await createClient()
 
  const email = String(formData.get('email') ?? '')
  const password = String(formData.get('password') ?? '')
 
  const { data, error } = await supabase.auth.signUp({
    email,
    password,
    options: {
      emailRedirectTo: `${process.env.NEXT_PUBLIC_SITE_URL}/auth/callback`,
    },
  })
 
  if (error) {
    return { error: 'Nie udało się utworzyć konta.' }
  }
 
  if (data.session) {
    revalidatePath('/', 'layout')
    redirect('/dashboard')
  }
 
  redirect('/check-email')
}
Code
// app/login/login-form.tsx
'use client'
 
import { useActionState } from 'react'
import { login, type AuthState } from './actions'
 
const initialState: AuthState = { error: null }
 
export function LoginForm() {
  const [state, formAction, pending] = useActionState(login, initialState)
 
  return (
    <form action={formAction} className="mx-auto max-w-md space-y-4 p-8">
      <input name="email" type="email" aria-label="Adres e-mail" autoComplete="email" required />
      <input name="password" type="password" aria-label="Hasło" autoComplete="current-password" required />
      <button type="submit" disabled={pending}>
        {pending ? 'Logowanie…' : 'Zaloguj się'}
      </button>
      {state.error ? <p role="alert">{state.error}</p> : null}
    </form>
  )
}
Code
// app/login/page.tsx
import { LoginForm } from './login-form'
 
export default function LoginPage() {
  return <LoginForm />
}

W prawdziwej aplikacji dodaj walidację Zod, limity prób logowania i sensowny dla potwierdzania adresu e-mail. Przykład powyżej pokazuje przepływ i poprawne przekazanie stanu błędu przez useActionState, ale nie kompletny formularz produkcyjny.

Przy włączonym potwierdzaniu e-maila signUp() nie zwraca od razu sesji. Utwórz stronę /check-email z instrukcją dla użytkownika; przy wyłączonym potwierdzaniu przykład kieruje od razu do panelu. Zweryfikuj szablon wiadomości: użyty tutaj callback PKCE musi otrzymać code. Wariant z token_hash wymaga innego endpointu i odpowiednio zmienionego szablonu.

Do wylogowania dodaj Server Action, np. w tym samym actions.ts:

Code
export async function logout() {
  const supabase = await createClient()
  const { error } = await supabase.auth.signOut({ scope: 'local' })
 
  if (error) throw new Error('Nie udało się wylogować. Spróbuj ponownie.')
 
  revalidatePath('/', 'layout')
  redirect('/login')
}

Wywołaj ją przez formularz z przyciskiem wylogowania. local kończy bieżącą sesję; domyślne global unieważnia sesje użytkownika także na innych urządzeniach.

OAuth i callback w Supabase Auth

może zaczynać się po stronie klienta albo serwera. W obu wariantach użytkownik musi zostać przekierowany do dostawcy (providera). Poniżej prosty wariant kliencki:

Code
'use client'
 
import { createClient } from '@/lib/supabase/client'
 
export function GoogleLoginButton() {
  const supabase = createClient()
 
  async function signInWithGoogle() {
    await supabase.auth.signInWithOAuth({
      provider: 'google',
      options: {
        redirectTo: `${window.location.origin}/auth/callback`,
      },
    })
  }
 
  return <button onClick={signInWithGoogle}>Kontynuuj z Google</button>
}

Callback wymienia code na sesję:

Code
// app/auth/callback/route.ts
import { createClient } from '@/lib/supabase/server'
import { NextResponse } from 'next/server'
 
export async function GET(request: Request) {
  const url = new URL(request.url)
  const code = url.searchParams.get('code')
  const next = url.searchParams.get('next') ?? '/dashboard'
  const siteUrl = new URL(process.env.NEXT_PUBLIC_SITE_URL ?? url.origin)
 
  let redirectUrl = new URL('/dashboard', siteUrl)
 
  try {
    const candidate = new URL(next, siteUrl)
 
    if (
      next.startsWith('/') &&
      !next.startsWith('//') &&
      candidate.origin === siteUrl.origin
    ) {
      redirectUrl = candidate
    }
  } catch {
    // Niepoprawny `next` pozostawia bezpieczny adres domyślny.
  }
 
  if (code) {
    const supabase = await createClient()
    const { error } = await supabase.auth.exchangeCodeForSession(code)
 
    if (!error) {
      return NextResponse.redirect(redirectUrl, {
        headers: { 'Cache-Control': 'private, no-store' },
      })
    }
  }
 
  return NextResponse.redirect(new URL('/login?error=auth', siteUrl), {
    headers: { 'Cache-Control': 'private, no-store' },
  })
}

Adres aplikacji użyty w redirectTo musi znajdować się na liście dozwolonych Redirect URLs w Supabase. Sam provider, np. Google, wymaga też skonfigurowania Client ID, Client Secret i callbacku projektu Supabase. Nie przekazuj niesprawdzonego parametru next bezpośrednio do NextResponse.redirect(), bo tworzy to podatność open redirect.

W SSR Supabase korzysta z PKCE. Wymiana code wymaga verifiera zapisanego przy rozpoczęciu flow, dlatego musi odbyć się w tej samej przeglądarce i na tym samym urządzeniu. Dla linków potwierdzających e-mail warto rozważyć osobny endpoint /auth/confirm, który przyjmuje token_hash i wywołuje verifyOtp().

Ochrona stron i danych w Supabase

Nie opieraj ochrony panelu wyłącznie na tym, że użytkownik nie widzi linku w nawigacji. Sprawdzenie musi odbywać się po stronie serwera.

Code
// app/dashboard/page.tsx
import { createClient } from '@/lib/supabase/server'
import { redirect } from 'next/navigation'
 
export default async function DashboardPage() {
  const supabase = await createClient()
  const {
    data: { user },
  } = await supabase.auth.getUser()
 
  if (!user) {
    redirect('/login')
  }
 
  return <div>Panel użytkownika: {user.email}</div>
}

getClaims() weryfikuje podpis i ważność JWT, ale ważny token może przetrwać unieważnienie sesji do czasu wygaśnięcia. getUser() odpytuje serwer Auth; używaj go tam, gdzie istotne jest sprawdzenie aktualnego stanu sesji. Nie podejmuj decyzji o dostępie na podstawie samego getSession() odczytanego z cookies. Żadna z tych metod nie zastępuje sprawdzenia właściciela zasobu lub roli.

W Server Actions powtarzaj ten sam typ kontroli. To, że formularz znajduje się na chronionej stronie, nie oznacza, że wywołanie akcji jest automatycznie bezpieczne.

CRUD z Supabase przez Server Components i Server Actions

Pobieranie danych w Server Component:

Code
// app/dashboard/posts/page.tsx
import { createClient } from '@/lib/supabase/server'
import { redirect } from 'next/navigation'
 
export default async function PostsPage() {
  const supabase = await createClient()
  const {
    data: { user },
  } = await supabase.auth.getUser()
 
  if (!user) {
    redirect('/login')
  }
 
  const { data: posts, error } = await supabase
    .from('posts')
    .select('id, title, published, created_at')
    .eq('author_id', user.id)
    .order('created_at', { ascending: false })
 
  if (error) {
    throw new Error(error.message)
  }
 
  return (
    <ul>
      {posts.map((post) => (
        <li key={post.id}>
          <h2>{post.title}</h2>
          <span>{post.published ? 'Opublikowany' : 'Szkic'}</span>
        </li>
      ))}
    </ul>
  )
}

Mutacja w Server Action:

Code
// app/dashboard/posts/actions.ts
'use server'
 
import { createClient } from '@/lib/supabase/server'
import { revalidatePath } from 'next/cache'
import { z } from 'zod'
 
const createPostSchema = z.object({
  title: z.string().trim().min(3).max(120),
  content: z.string().trim().min(10).max(20000),
})
 
export async function createPost(formData: FormData) {
  const supabase = await createClient()
  const {
    data: { user },
  } = await supabase.auth.getUser()
 
  if (!user) {
    return { error: 'Musisz być zalogowany.' }
  }
 
  const parsed = createPostSchema.safeParse({
    title: formData.get('title'),
    content: formData.get('content'),
  })
 
  if (!parsed.success) {
    return { error: 'Popraw dane formularza.' }
  }
 
  const { error } = await supabase.from('posts').insert({
    ...parsed.data,
    author_id: user.id,
    published: false,
  })
 
  if (error) {
    return { error: 'Nie udało się zapisać wpisu. Spróbuj ponownie.' }
  }
 
  revalidatePath('/dashboard/posts')
  return { success: true }
}

Nawet jeśli w insert() podstawiasz author_id na podstawie sesji, RLS nadal powinno to egzekwować. Kod aplikacji i polityki w bazie mają się wzajemnie uzupełniać.

Row Level Security w Supabase

RLS w Supabase działa jak automatyczny filtr dodawany do zapytań. Po włączeniu RLS zwykłe role anon i authenticated nie odczytają wierszy przez bez odpowiedniej polityki. Uprawnienia SQL (GRANT) i polityki RLS to dwie osobne warstwy — potrzebujesz obu.

Przykłady wymagają tabeli posts. W nowym projekcie uruchom poniższy schemat i polityki jako migrację; w istniejącym dostosuj je do własnych tabel:

Code
create table public.posts (
  id uuid primary key default gen_random_uuid(),
  author_id uuid not null references auth.users(id) on delete cascade,
  title text not null check (char_length(trim(title)) between 3 and 120),
  content text not null check (char_length(trim(content)) between 10 and 20000),
  published boolean not null default false,
  created_at timestamptz not null default now()
);
 
create index posts_author_created_idx on public.posts (author_id, created_at desc);
grant select, insert, update, delete on public.posts to authenticated;
Code
alter table public.posts enable row level security;
 
create policy "Authenticated users can read their own posts"
on public.posts
for select
to authenticated
using ((select auth.uid()) = author_id);
 
create policy "Authenticated users can create their own posts"
on public.posts
for insert
to authenticated
with check ((select auth.uid()) = author_id);
 
create policy "Authenticated users can update their own posts"
on public.posts
for update
to authenticated
using ((select auth.uid()) = author_id)
with check ((select auth.uid()) = author_id);
 
create policy "Authenticated users can delete their own posts"
on public.posts
for delete
to authenticated
using ((select auth.uid()) = author_id);

Dla publicznych wpisów dodaj osobną politykę tylko do odczytu:

Code
grant select on public.posts to anon;
 
create policy "Anyone can read published posts"
on public.posts
for select
to anon, authenticated
using (published = true);

Warto jawnie podawać role przez to authenticated albo to anon, authenticated. Jest to czytelniejsze i często wydajniejsze niż polityki bez określonej roli.

Polityki odczytu powyżej łączą się alternatywą: użytkownik widzi własne wpisy oraz opublikowane wpisy innych autorów. Polityka UPDATE potrzebuje również odpowiedniego SELECT. Autor może tutaj sam zmieniać published; jeśli publikacja wymaga akceptacji administratora, ogranicz zmianę tej kolumny osobno. Walidacja Zod w akcji nie zabezpieczy bezpośredniego wywołania API — dlatego podstawowe ograniczenia są także w schemacie SQL.

Supabase Storage i upload plików w Next.js

Najprostszy wariant dla avatara to upload z klienta do bucketu avatars, z polityką ograniczającą ścieżkę do katalogu użytkownika.

Code
insert into storage.buckets (
  id,
  name,
  public,
  file_size_limit,
  allowed_mime_types
)
values (
  'avatars',
  'avatars',
  true,
  2097152,
  array['image/jpeg', 'image/png', 'image/webp']
)
on conflict (id) do update set
  public = excluded.public,
  file_size_limit = excluded.file_size_limit,
  allowed_mime_types = excluded.allowed_mime_types;
 
create policy "Users can upload their own avatar"
on storage.objects
for insert
to authenticated
with check (
  bucket_id = 'avatars'
  and (select auth.uid())::text = (storage.foldername(name))[1]
);
 
create policy "Users can update their own avatar"
on storage.objects
for update
to authenticated
using (
  bucket_id = 'avatars'
  and (select auth.uid())::text = (storage.foldername(name))[1]
)
with check (
  bucket_id = 'avatars'
  and (select auth.uid())::text = (storage.foldername(name))[1]
);
 
-- Upsert wymaga również SELECT. Ograniczamy je do własnego katalogu.
create policy "Users can select their own avatar"
on storage.objects
for select
to authenticated
using (
  bucket_id = 'avatars'
  and (select auth.uid())::text = (storage.foldername(name))[1]
);

Bucket jest publiczny, więc pobieranie pliku przez publiczny URL nie wymaga polityki SELECT. Szeroka polityka SELECT dla roli anon pozwoliłaby dodatkowo listować obiekty i ujawniałaby ich nazwy. Ograniczona polityka powyżej jest potrzebna zalogowanemu użytkownikowi do upsert.

Komponent uploadu:

Code
// components/avatar-upload.tsx
'use client'
 
import { createClient } from '@/lib/supabase/client'
import { useMemo, useState } from 'react'
 
const MAX_FILE_SIZE = 2 * 1024 * 1024
const ALLOWED_TYPES = ['image/jpeg', 'image/png', 'image/webp']
const EXTENSION_BY_TYPE: Record<string, string> = {
  'image/jpeg': 'jpg',
  'image/png': 'png',
  'image/webp': 'webp',
}
 
export function AvatarUpload({ userId }: { userId: string }) {
  const [uploading, setUploading] = useState(false)
  const [error, setError] = useState<string | null>(null)
  const supabase = useMemo(() => createClient(), [])
 
  async function handleUpload(event: React.ChangeEvent<HTMLInputElement>) {
    const file = event.target.files?.[0]
    if (!file) return
 
    setError(null)
 
    if (!ALLOWED_TYPES.includes(file.type) || file.size > MAX_FILE_SIZE) {
      setError('Wybierz obraz JPG, PNG albo WebP do 2 MB.')
      return
    }
 
    setUploading(true)
 
    const extension = EXTENSION_BY_TYPE[file.type]
    const filePath = `${userId}/avatar.${extension}`
 
    const { error } = await supabase.storage
      .from('avatars')
      .upload(filePath, file, {
        upsert: true,
        contentType: file.type,
        cacheControl: '3600',
      })
 
    setUploading(false)
 
    if (error) {
      setError('Nie udało się przesłać pliku.')
    }
  }
 
  return (
    <label>
      {uploading ? 'Przesyłanie...' : 'Zmień avatar'}
      <input type="file" accept="image/jpeg,image/png,image/webp" disabled={uploading} onChange={handleUpload} />
      {error ? <span>{error}</span> : null}
    </label>
  )
}

Walidacja w komponencie poprawia UX, ale nie jest granicą bezpieczeństwa. Granicą są polityki Storage oraz ustawione na buckecie file_size_limit i allowed_mime_types. Pamiętaj jednak, że deklarowany MIME pochodzi od klienta; jeżeli musisz zweryfikować rzeczywisty format lub przeskanować plik, zrób to po stronie zaufanego backendu. Dla wrażliwych plików użyj prywatnego bucketu. Odczyt może wymagać sesji i polityki SELECT albo odbywać się przez krótkotrwały podpisany URL wydany po sprawdzeniu uprawnień. Sam podpisany URL nie zastępuje autoryzacji przy jego generowaniu.

Nadpisanie avatar.jpg może przez pewien czas pokazywać starszą wersję z CDN. Gdy potrzebujesz natychmiast widocznej zmiany, zapisuj plik pod nową nazwą, aktualizuj ścieżkę w profilu i usuwaj stare obiekty przez Storage API z odpowiednią polityką DELETE. Dla plików większych niż 6 MB Supabase zaleca wznawialny upload TUS; podpisanie URL-a samo w sobie nie zapewnia wznawiania.

Supabase Realtime i subskrypcje na żywo

Supabase udostępnia dwa główne sposoby przesyłania zmian z bazy:

  • Broadcast — rekomendowany dla większej skali i bardziej wymagających systemów; zwykle łączy trigger w Postgresie z prywatnym kanałem,
  • Postgres Changes — prostszy w konfiguracji, dobry dla prototypów i niewielkiej liczby subskrybentów, ale każde zdarzenie musi zostać autoryzowane osobno dla każdego odbiorcy.

Poniższy przykład używa prostszego Postgres Changes. Utwórz tabelę komentarzy, jeśli jeszcze jej nie masz, i dodaj ją do publikacji (tylko raz):

Code
create table public.comments (
  id uuid primary key default gen_random_uuid(),
  post_id uuid not null references public.posts(id) on delete cascade,
  content text not null,
  author_name text not null,
  created_at timestamptz not null default now()
);
 
create index comments_post_created_idx on public.comments (post_id, created_at);
grant select on public.comments to authenticated;
alter publication supabase_realtime add table public.comments;

Tabela nadal powinna mieć RLS:

Code
alter table public.comments enable row level security;
 
create policy "Authors can read comments on their own posts"
on public.comments
for select
to authenticated
using (
  exists (
    select 1
    from public.posts
    where posts.id = comments.post_id
      and posts.author_id = (select auth.uid())
  )
);

To widok komentarzy dla właściciela wpisu, nie publiczny czat. Przykład daje klientowi tylko odczyt; testowy komentarz dodaj przez SQL Editor do istniejącego wpisu. Przy dodawaniu komentarzy przez użytkowników zaprojektuj osobną politykę INSERT i powiąż autora z sesją, zamiast ufać przesłanemu author_name.

Przykład komponentu:

Code
// components/live-comments.tsx
'use client'
 
import { createClient } from '@/lib/supabase/client'
import { postgresChangesFilter } from '@supabase/supabase-js'
import { useEffect, useMemo, useState } from 'react'
 
interface Comment {
  id: string
  post_id: string
  content: string
  author_name: string
  created_at: string
}
 
function mergeComments(current: Comment[], incoming: Comment[]) {
  const byId = new Map(current.map((comment) => [comment.id, comment]))
 
  incoming.forEach((comment) => {
    byId.set(comment.id, comment)
  })
 
  return [...byId.values()].sort((a, b) =>
    a.created_at.localeCompare(b.created_at),
  )
}
 
export function LiveComments({ postId }: { postId: string }) {
  const [comments, setComments] = useState<Comment[]>([])
  const supabase = useMemo(() => createClient(), [])
 
  useEffect(() => {
    let ignore = false
    setComments([])
 
    async function loadComments() {
      const { data } = await supabase
        .from('comments')
        .select('id, post_id, content, author_name, created_at')
        .eq('post_id', postId)
        .order('created_at', { ascending: true })
 
      if (!ignore && data) {
        setComments((current) => mergeComments(current, data))
      }
    }
 
    const channel = supabase
      .channel(`comments:${postId}`)
      .on(
        'postgres_changes',
        {
          event: 'INSERT',
          schema: 'public',
          table: 'comments',
          filter: postgresChangesFilter().eq('post_id', postId),
        },
        (payload) => {
          if (!ignore) {
            setComments((current) =>
              mergeComments(current, [payload.new as Comment]),
            )
          }
        },
      )
      .subscribe((status) => {
        if (!ignore && status === 'SUBSCRIBED') {
          void loadComments()
        }
      })
 
    return () => {
      ignore = true
      void supabase.removeChannel(channel)
    }
  }, [postId, supabase])
 
  return (
    <div>
      {comments.map((comment) => (
        <article key={comment.id}>
          <p>{comment.author_name}</p>
          <p>{comment.content}</p>
        </article>
      ))}
    </div>
  )
}

Początkowe dane są pobierane dopiero po uzyskaniu statusu SUBSCRIBED, a wyniki są scalane po id. Dzięki temu zdarzenie, które nadejdzie w trakcie pierwszego zapytania, nie zostanie pominięte ani dodane dwukrotnie.

Komponent obsługuje tylko INSERT. Nie synchronizuje edycji ani usunięć i nie gwarantuje odtworzenia każdego zdarzenia po rozłączeniu. W produkcji dodaj obsługę błędów zapytania oraz statusów CHANNEL_ERROR i TIMED_OUT, ponowne pobranie aktualnego stanu po reconnect i paginację. Helper postgresChangesFilter() wymaga aktualnej wersji SDK.

Przy Realtime łatwo przesadzić. Nie subskrybuj całych tabel, jeśli potrzebujesz zmian tylko dla jednego dokumentu, projektu albo organizacji. Filtr w subskrypcji zmniejsza ruch, ale nie jest mechanizmem bezpieczeństwa — dostęp do Postgres Changes egzekwują uprawnienia tabeli i RLS. Przy tysiącach subskrybentów tego samego strumienia rozważ Broadcast, bo Postgres Changes wykonuje kontrolę dostępu osobno dla każdego użytkownika.

Cache i prywatne dane w Supabase + Next.js

Supabase Auth z korzysta z cookies, a to oznacza, że odpowiedzi zawierające dane użytkownika nie powinny być traktowane jak statyczne strony ani cache'owane publicznie za -em.

Praktyczne reguły:

  • strony panelu użytkownika trzymaj jako dynamiczne,
  • prywatnych danych nie pobieraj w generateStaticParams,
  • po zapisie odśwież właściwą ścieżkę przez revalidatePath(); dla danych zapisanych w cache z tagiem updateTag() natychmiast wygasza wpis (tylko Server Actions), a revalidateTag(tag, 'max') dopuszcza stary wynik podczas odświeżania w tle,
  • nie mieszaj prywatnych danych użytkownika z publicznym ,
  • w Route Handlers zależnych od sesji ustawiaj Cache-Control: private, no-store i sprawdź, czy CDN go respektuje.

To szczególnie ważne, gdy aplikacja działa za CDN-em lub używa agresywnego cache'owania odpowiedzi HTML.

Co sprawdzić przed wdrożeniem?

  • Izolacja danych: jako użytkownik B spróbuj odczytać i zmienić prywatny wpis użytkownika A oraz wgrać plik do jego katalogu. Testuj przez API z sesją użytkownika; SQL Editor i klucz administracyjny mogą omijać RLS.
  • Sesja: sprawdź odświeżenie strony po wygaśnięciu access tokena, wylogowanie oraz callback OAuth i potwierdzenie e-maila na domenie produkcyjnej.
  • Pusty wynik lub błąd dostępu: skontroluj sesję, GRANT i polityki RLS. Brak dostępu przy odczycie może dać pustą tablicę, a nie błąd.
  • Brak zdarzeń Realtime: sprawdź publikację tabeli, politykę SELECT, filtr i status subskrypcji.
  • Zmiany schematu: przechowuj migracje w repozytorium i odtwarzaj je w środowisku testowym przed produkcją. Same typy TypeScript nie zmieniają bazy.

Kiedy Supabase z Next.js ma sens, a kiedy nie?

Supabase jest bardzo dobry dla:

  • MVP i SaaS z relacyjnym modelem danych,
  • paneli użytkownika, CRM, marketplace'ów i aplikacji B2B,

  • aplikacji, w których Postgres, RLS i szybki są ważniejsze niż własna infrastruktura,

  • produktów, które potrzebują Auth, Storage i Realtime bez składania kilku usług.

Rozważyłbym inne podejście, gdy:

  • masz bardzo specyficzne wymagania infrastrukturalne albo compliance,

  • logika domenowa jest ciężka i wymaga osobnego backendu,
  • Realtime ma obsługiwać bardzo duże wolumeny zdarzeń z własnym protokołem,

  • zespół już ma dojrzały backend w NestJS, Rails, Django, Laravel albo Go.

Supabase nie jest "backendiem bez backendu". To raczej zarządzany Postgres z zestawem usług, które pozwalają przesunąć dużo pracy z warstwy aplikacyjnej do bazy i polityk dostępu.

Raporty, treści i monitoring SEO w n8n, z agentami AI i kontrolą człowieka.
Automatyzacja SEO i marketingu

Często zadawane pytania

Czy Supabase jest dobrym wyborem do Next.js App Router?

Tak, szczególnie gdy potrzebujesz szybko zbudować aplikację z uwierzytelnianiem, relacyjną bazą danych, storage i realtime. Najważniejsze jest używanie aktualnego pakietu @supabase/ssr, cookies zamiast localStorage w SSR oraz Row Level Security jako głównej warstwy ochrony danych.

Czy nadal używać NEXT_PUBLIC_SUPABASE_ANON_KEY?

W nowych projektach lepiej używać NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY. Supabase wspiera jeszcze starsze klucze anon, ale oficjalne materiały kierują nowe projekty w stronę publishable i secret keys. Klucza sb_secret_... ani legacy service_role nigdy nie wolno wysyłać do przeglądarki.

Czy Proxy w Next.js wystarczy do ochrony panelu użytkownika?

Nie jako jedyna warstwa. Mechanizm Proxy jest potrzebny do odświeżania sesji i może robić wstępne redirecty, ale uwierzytelnienie i autoryzację trzeba sprawdzać również w Server Components, Route Handlers i Server Actions. Do ochrony danych po stronie serwera używaj supabase.auth.getClaims(), a getUser() wtedy, gdy potrzebujesz aktualnego rekordu użytkownika lub sprawdzenia sesji w Auth. Samo zweryfikowanie JWT nie sprawdza uprawnień do konkretnego zasobu.

Czy Realtime działa automatycznie dla każdej tabeli?

Nie. Przy Postgres Changes tabelę trzeba dodać do publikacji supabase_realtime, a dostęp nadal zależy od RLS i uprawnień roli użytkownika. Filtry ograniczają przesyłane zdarzenia, ale nie zastępują autoryzacji. Dla większej skali Supabase rekomenduje Broadcast.

Czy upload plików do Supabase Storage powinien iść przez serwer?

Dla prostych avatarów można uploadować z klienta, jeśli bucket ma poprawne polityki Storage RLS i ścieżka pliku jest powiązana z auth.uid(). Prywatny bucket także obsługuje upload z klienta z sesją i RLS. Podpisany URL pozwala czasowo udzielić dostępu, a dla większych plików warto użyć wznawialnego uploadu TUS.

O autorze

Maciej Sala

Maciej Sala — konsultant technologiczny produktów cyfrowych i web developer z bogatym doświadczeniem w marketingu internetowym oraz SEO. Na co dzień pracuje z Reactem, Next.js i TypeScriptem, a ostatnio także z Astro i narzędziami do automatyzacji procesów AI. Sprawnie łączy perspektywę produktową z praktycznym podejściem do kodu. Przez kilka lat był związany z branżą gier wideo jako project manager i game designer. Absolwent historii na Uniwersytecie Jagiellońskim oraz studiów podyplomowych z marketingu internetowego na AGH w Krakowie. Po godzinach trenuje na siłowni, maluje figurki i rozwija własne projekty.

Pomagam przekładać takie tematy na konkretne wdrożenia w frontendzie, SEO, analityce i procesie produktowym.

Skontaktuj się ze mną
LH.pl – Hosting Mango

Biblioteka wiedzy na temat Next.js i React

Czytaj dalej

Zobacz więcej wpisów
Next.js jako backend: architektura aplikacji full-stack

Next.js może obsługiwać interfejs, logikę biznesową i dostęp do bazy w jednym projekcie. Ten przewodnik pokazuje, jak połączyć komponenty serwerowe, Server Actions i Route Handlers z autoryzacją, cache i zadaniami w tle. Na przykładzie panelu zamówień przejdziemy od odczytu danych do zapisu i utrzymania na produkcji, wskazując momenty, w których warto wydzielić osobną usługę.

Maciej Sala

Maciej Sala

Founder StriveLab

Backend dla frontendowca: auth, real-time i integracje

Pierwsza część serii uporządkowała fundamenty: serwer, bazę danych, API i CORS. Teraz przechodzimy do obszarów, które zwykle pojawiają się chwilę później, gdy aplikacja przestaje być prostym CRUD-em: komunikacja w czasie rzeczywistym, webhooki, integracje zewnętrzne oraz autentykacja .

Maciej Sala

Maciej Sala

Founder StriveLab

Backend dla frontendowca: cache, deployment i bezpieczeństwo

To trzecia część mojej małej serii „Backend dla frontendowca” i po fundamentach API oraz tematach real-time, webhooków i uwierzytelniania zostaje warstwa, która decyduje o tym, czy aplikacja wytrzyma prawdziwe użytkowanie: cache , kolejki, pliki, deployment, monitoring i bezpieczeństwo .

Maciej Sala

Maciej Sala

Founder StriveLab

LH.pl – Cloud Server 1C4G