Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

supabase

/supabase

Konfiguruje Supabase dla SaaS w Next.js: Drizzle z poolerem, logowanie wyłącznie przez Google, RLS i optymalizacja kosztów.

Licencja
MIT
Ostatnia zmiana repozytorium
06.09.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
10
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
2
Przestarzałość

Brak sygnałów. Repozytorium zmienione 06.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Konfiguruje Supabase dla SaaS w Next.js: Drizzle z poolerem, logowanie wyłącznie przez Google, RLS i optymalizacja kosztów.

Oryginalny opis (EN)

Configure Supabase for Next.js SaaS: Drizzle + pooler, Google-only Auth, RLS, cost optimization. Use when setting up Supabase, connecting Drizzle, SSR auth, or optimizing costs.

Jak działa

  1. Table of Contents
  2. THE EXACT PROMPT
  3. Architecture
  4. Quick Start
  5. Environment Variables
  6. Workflow Checklist
  7. Critical Gotchas
  8. Security Rules
  9. Quick Commands
  10. AGENTS.md Blurb
Sekcje z nagłówków SKILL.md, w oryginale · 316 linii, 1 299 słów
Podgląd SKILL.md
---
name: supabase
description: >-
  Configure Supabase for Next.js SaaS: Drizzle + pooler, Google-only Auth, RLS,
  cost optimization. Use when setting up Supabase, connecting Drizzle, SSR auth,
  or optimizing costs.
---

# Supabase for Next.js SaaS

> **Core Insight:** Two lanes: user-scoped data via Supabase client (RLS-enforced), server-scoped via Drizzle (privileged). Use `getClaims()` not `getSession()`. Transaction pooler requires `prepare: false`.

## Table of Contents

- [THE EXACT PROMPT](#the-exact-prompt)
- [Architecture](#architecture)
- [Quick Start](#quick-start)
- [Environment Variables](#environment-variables)
- [Workflow Checklist](#workflow-checklist)
- [Critical Gotchas](#critical-gotchas)
- [Quick Commands](#quick-commands)
- [AGENTS.md Blurb](#agentsmd-blurb)
- [References](#references)

---

## THE EXACT PROMPT

```
Set up Supabase for a Next.js SaaS with:
1. Auth: Google OAuth only
2. ORM: Drizzle with Supabase pooler (IPv4)
3. Environment: [Vercel / Cloudflare / local dev]
4. Cost tier: [Free / Pro with Spend Cap / Team]

Follow supabase-guide skill patterns.
```

---

## Architecture

```
┌─────────────────────────────────────────────────────────────────────┐
│                     TWO-LANE DATA ACCESS MODEL                       │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   LANE A: User-scoped (RLS-enforced)                                │
│   ══════════════════════════════════                                │
│   @supabase/ssr → PostgREST Data API                                │
│   • Browser + Server Components                                     │
│   • JWT validated via getClaims()                                   │
│   • Multi-tenant reads/writes obey RLS "naturally"                  │
│                                                                     │
│   LANE B: Server-scoped (privileged)                                │
│   ══════════════════════════════════                                │
│   Drizzle → postgres.js → Supavisor pooler                          │
│   • Migrations, admin tasks, billing webhooks                       │
│   • Transaction mode (port 6543): prepare: false                    │
│   • Session mode (port 5432): migrations only                       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘
```

**Why this split:** Browser access uses Data API with RLS. Server/serverless uses pooler. IPv4-only environments (Vercel/GH Actions) cannot use direct connections (IPv6).

---

## Quick Start

### 1. Drizzle + Pooler (Transaction Mode)

```typescript
// src/db/index.ts
import postgres from "postgres"
import { drizzle } from "drizzle-orm/postgres-js"
import * as schema from "./schema"

const g = globalThis as unknown as { __sql?: ReturnType<typeof postgres> }

export const sql = g.__sql ?? postgres(process.env.DATABASE_URL!, {
  prepare: false,  // REQUIRED for transaction pooler
  max: process.env.NODE_ENV === "production" ? 5 : 1,
})

if (process.env.NODE_ENV !== "production") g.__sql = sql

export const db = drizzle(sql, { schema })
```

### 2. Supabase SSR Clients

```typescript
// src/lib/supabase/client.ts
import { createBrowserClient } from "@supabase/ssr"

export function supabaseBrowser() {
  return createBrowserClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!
  )
}
```

```typescript
// src/lib/supabase/server.ts
import { createServerClient } from "@supabase/ssr"
import { cookies } from "next/headers"

export function supabaseServer() {
  const store = cookies()
  return createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!,
    {
      cookies: {
        getAll: () => store.getAll(),
        setAll: (toSet) => {
          try { toSet.forEach(({ name, value, options }) => store.set(name, value, options)) }
          catch {}
        },
      },
    }
  )
}
```

### 3. Middleware (Token Refresh)

```typescript
// middleware.ts
import { createServerClient } from "@supabase/ssr"
import { NextResponse, type NextRequest } from "next/server"

export async function middleware(request: NextRequest) {
  let response = NextResponse.next({ request: { headers: request.headers } })

  const supabase = createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!,
    {
      cookies: {
        getAll: () => request.cookies.getAll(),
        setAll: (toSet) => {
          toSet.forEach(({ name, value }) => request.cookies.set(name, value))
          response = NextResponse.next({ request: { headers: request.headers } })
          toSet.forEach(({ name, value, options }) => response.cookies.set(name, value, options))
        },
      },
    }
  )

  await supabase.auth.getClaims()  // NOT getSession()
  return response
}

export const config = {
  matcher: ["/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)"],
}
```

---

## Environment Variables

```bash
# Supabase Auth / API
NEXT_PUBLIC_SUPABASE_URL="https://<project_ref>.supabase.co"
NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY="sb_publishable_..."  # or anon key during transition
SUPABASE_SERVICE_ROLE_KEY="..."  # server-only, NEVER ship to client

# Postgres: app runtime (transaction pooler, port 6543)
DATABASE_URL="postgresql://postgres.<project_ref>:<PASSWORD>@aws-0-<region>.pooler.supabase.com:6543/postgres?sslmode=require"

# Postgres: migrations (session pooler, port 5432)
DATABASE_URL_MIGRATIONS="postgresql://postgres.<project_ref>:<PASSWORD>@aws-0-<region>.pooler.supabase.com:5432/postgres?sslmode=require"
```

**Username format:** `postgres.<project_ref>` — the dot is real, copy from Dashboard → Connect button.

---

## Workflow Checklist

### Phase 1: Project Setup
- [ ] Create prod + staging Supabase projects (blast-radius isolation)
- [ ] Copy connection strings from Connect button (not guessed)
- [ ] Set env vars: `NEXT_PUBLIC_SUPABASE_URL`, `NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY`, `DATABASE_URL`, `DATABASE_URL_MIGRATIONS`
- [ ] Enable Spend Cap (Pro plan) — [COST-OPTIMIZATION.md](references/COST-OPTIMIZATION.md)

### Phase 2: Auth (Google-only)
- [ ] Enable Google provider in Dashboard → Auth → Providers
- [ ] Disable email/password, magic links, phone
- [ ] Add redirect URI in Google Cloud Console: `https://<project_ref>.supabase.co/auth/v1/callback`
- [ ] Set up SSR clients + middleware — [AUTH-SSR.md](references/AUTH-SSR.md)
- [ ] Create OAuth callback route — [GOOGLE-OAUTH.md](references/GOOGLE-OAUTH.md)

### Phase 3: Database + Drizzle
- [ ] Install: `bun add drizzle-orm postgres && bun add -d drizzle-kit`
- [ ] Create `src/db/index.ts` with `prepare: false` — [DRIZZLE-SETUP.md](references/DRIZZLE-SETUP.md)
- [ ] Create `drizzle.config.ts` pointing to session pooler for migrations
- [ ] Run `drizzle-kit generate` and `drizzle-kit migrate`

### Phase 4: RLS + Data Model
- [ ] Create `user_profiles` table keyed by `auth.users.id`
- [ ] Enable RLS on ALL tables in `public` schema
- [ ] Create trigger to auto-create profile on signup
- [ ] Index columns used in RLS policies — [RLS-PATTERNS.md](references/RLS-PATTERNS.md)

### Phase 5: Cost Optimization
- [ ] Use transaction pooler for runtime, session for migrations
- [ ] Harden Data API: move sensitive tables to `private` schema
- [ ] Set up cron rollups for event-heavy tables
- [ ] Configure Smart CDN + cache-control for Storage — [COST-OPTIMIZATION.md](references/COST-OPTIMIZATION.md)

---

## Critical Gotchas

| Symptom | Cause | Fix |
|---------|-------|-----|
| `ENETUNREACH` / `network unreachable` | Direct connection is IPv6 | Use pooler connection string |
| `prepared statement does not exist` | Transaction pooler + prepared statements | Set `prepare: false` in postgres.js |
| `Tenant or user not found` | Wrong pooler host or username format | Copy exact string from Connect dialog; include `.project_ref` in username |
| Users randomly logged out | Token not refreshing in middleware | Use `getClaims()` in middleware, not `getSession()` |
| RLS policy not blocking | Table missing `enable row level security` | Run `ALTER TABLE x ENABLE ROW LEVEL SECURITY` |
| Slow queries with RLS | No index on RLS filter columns | Add index on `user_id`, `tenant_id` columns |
| Surprise bills | No Spend Cap, uncached egress | Enable Spend Cap; use Smart CDN + high cache-control |

Full troubleshooting: [TROUBLESHOOTING.md](references/TROUBLESHOOTING.md)

---

## Security Rules

1. **Use `getClaims()`, not `getSession()`** — cookies can be spoofed; `getClaims()` validates JWT signature every time
2. **Never expose `service_role` key** — bypasses RLS, backend-only
3. **Enable RLS on every table in `public`** — tables without RLS are accessible via anon role
4. **Use `app_metadata` not `user_metadata` for tenant_id** — user_metadata is user-modifiable

---

## Quick Commands

```bash
# Supabase CLI
supabase login
supabase link --project-ref $PROJECT_REF
supabase db pull                        # Pull remote schema
supabase migration new <name>           # Create migration
supabase db push                        # Apply migrations

# Drizzle
drizzle-kit generate                    # Generate migrations
drizzle-kit migrate                     # Apply migrations
drizzle-kit studio                      # Visual browser

# Secrets (Edge Functions)
supabase secrets set --env-file .env    # Push secrets
supabase secrets list                   # Verify
```

---

## AGENTS.md Blurb

Copy this to your project's AGENTS.md:

```markdown
### Supabase

Supabase CLI is installed. Project: `<PROJECT_REF>`.

Auth:

\`\`\`bash
supabase login
supabase link --project-ref $PROJECT_REF
\`\`\`

Database:

\`\`\`bash
supabase db pull           # Pull schema to migrations
supabase migration new <name>
supabase db push           # Apply migrations
\`\`\`

Connection strings:
- **Runtime (Drizzle):** Transaction pooler (port 6543), `prepare: false`
- **Migrations:** Session pooler (port 5432)

Copy exact connection string from Dashboard → Connect button.
```

---

## References

| Topic | Reference |
|-------|-----------|
| Copy-paste patterns | [QUICK-REFERENCE.md](references/QUICK-REFERENCE.md) |
| Two-lane architecture + cost model | [ARCHITECTURE.md](references/ARCHITECTURE.md) |
| Drizzle + pooler setup | [DRIZZLE-SETUP.md](references/DRIZZLE-SETUP.md) |
| Next.js SSR auth with getClaims() | [AUTH-SSR.md](references/AUTH-SSR.md) |
| Google OAuth setup | [GOOGLE-OAUTH.md](references/GOOGLE-OAUTH.md) |
| RLS patterns for SaaS | [RLS-PATTERNS.md](references/RLS-PATTERNS.md) |
| Pooler gotchas (IPv4/IPv6, modes) | [POOLER-GOTCHAS.md](references/POOLER-GOTCHAS.md) |
| Cost optimization (Spend Cap, cron) | [COST-OPTIMIZATION.md](references/COST-OPTIMIZATION.md) |
| Troubleshooting guide | [TROUBLESHOOTING.md](references/TROUBLESHOOTING.md) |

---

## Validation

```bash
# After setup, verify:
# 1. Google OAuth flow works (login → callback → dashboard)
# 2. Drizzle can connect: bun run -e "import { db } from './src/db'; console.log('OK')"
# 3. RLS blocks unauthorized access via Data API
# 4. Middleware refreshes tokens (check cookies in DevTools)
```
Pliki w paczce (10)
  • SKILL.md 12 KB
  • references/ARCHITECTURE.md 7 KB
  • references/AUTH-SSR.md 7 KB
  • references/COST-OPTIMIZATION.md 7 KB
  • references/DRIZZLE-SETUP.md 6 KB
  • references/GOOGLE-OAUTH.md 7 KB
  • references/POOLER-GOTCHAS.md 6 KB
  • references/QUICK-REFERENCE.md 8 KB
  • references/RLS-PATTERNS.md 7 KB
  • references/TROUBLESHOOTING.md 6 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · Dicklesworthstone/agent_flywheel_clawdbot_skills_and_integrations100MIT
ericrisco/rsc-harness100MIT
TerminalSkills/skills100Apache-2.0
magnus919/agent-skills100MIT
gianpaj/sexyvoice100Apache-2.0
PracticalSwan/agent-skills100MIT
aAAaqwq/AGI-Super-Team100MIT
tdealer01-crypto/tdealer01-crypto-dsg-control-plane100Apache-2.0
andersonlimahw/lemon-ai-hub100MIT

Migawka bazy z 13.11.2026 · wersja paczki df83770d23e3 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100supabase-auth-ssr
    Konfiguruje Supabase Auth z @supabase/ssr w Next.js 15 App Router: klienty, sesje w cookies, zapytania z RLS, magic link, OAuth, reset hasła i ochrona tras.
  • 100supabase-install-auth
    Instaluje i konfiguruje SDK, CLI i uwierzytelnianie Supabase: @supabase/supabase-js, zmienne środowiskowe i inicjalizacja klienta.
  • 100supabase-install-auth
    Instaluje i konfiguruje SDK oraz CLI Supabase wraz z kluczami API i inicjalizacją w projekcie.
  • 87supabase-test-harness
    Przygotowuje infrastrukturę testową Supabase, czyli lokalne środowisko, konta testowe, testy RLS i migracje.
  • 100supabase-admin
    Obsługuje administrację Supabase: polityki RLS, migracje, projekt schematu oraz strojenie wydajności bazy z integracją uwierzytelniania.
  • 100supabase-admin
    Obsługuje administrację Supabase: polityki RLS, migracje, projekt schematu oraz strojenie wydajności bazy z integracją uwierzytelniania.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.