cd /opt
git clone --depth 1 --branch self-hosted/v0.8.2 https://github.com/supabase/supabase supabase-src
mkdir supabase && cp -rf supabase-src/docker/. supabase
cd supabase
cp .env.example .env
printf 'ref=self-hosted/v0.8.2\n' > .supabase-version

# Alle Ports nur auf 127.0.0.1 (Zugriff per SSH-Tunnel).
# Docker umgeht die Firewall: ein Port ohne 127.0.0.1 wäre aus dem Internet erreichbar.
services:
  api-gw:
    ports: !override
      - 127.0.0.1:8000:8000/tcp
  supavisor:
    ports: !override
      - 127.0.0.1:5432:5432
      - 127.0.0.1:6543:6543

sh run.sh config add lokal
sh utils/generate-keys.sh --update-env
sh utils/add-new-auth-keys.sh --update-env
chmod 600 .env
grep -c 'this_password_is_insecure' .env      # muss 0 ergeben

sed -i 's/^ENABLE_EMAIL_AUTOCONFIRM=false/ENABLE_EMAIL_AUTOCONFIRM=true/' .env
docker compose pull
sh run.sh start
docker compose ps

ssh -N -L 8000:127.0.0.1:8000 root@DEIN-SERVER

-- Stufe 5 · Die Tabelle anfragen
-- Im Studio: SQL Editor → New query → einfügen → Run.
-- Setzt voraus, dass die Tabelle produkte aus Stufe 4 existiert.

create table public.anfragen (
  id             bigint generated always as identity primary key,
  erstellt_am    timestamptz not null default now(),
  name           text not null,
  email          text not null,
  anliegen       text not null,
  produkt        text references public.produkte (nummer),
  kategorie      text check (kategorie in ('Angebot', 'Support', 'Beschwerde', 'Sonstiges')),
  status         text not null default 'offen' check (status in ('offen', 'in Arbeit', 'erledigt')),
  bearbeitet_von uuid references auth.users (id)
);

create index anfragen_status_idx on public.anfragen (status);

insert into public.anfragen (name, email, anliegen, produkt, kategorie) values
  ('Jana Weber', 'jana.weber@example.com', 'Was kostet die WB-180 mit Buchenplatte? Wir bräuchten drei Stück.', 'WB-180', 'Angebot'),
  ('Tim Brandt', 'tim.brandt@example.com', 'Die Tür am TS-90 schließt nicht mehr richtig.', 'TS-90', 'Support'),
  ('Eva Lorenz', 'eva.lorenz@example.com', 'Liefert ihr auch nach Österreich?', null, 'Sonstiges');

cd /opt/supabase
P=$(grep ^SUPABASE_PUBLISHABLE_KEY= .env | cut -d= -f2-)
U=http://127.0.0.1:8000

curl -s "$U/rest/v1/produkte?select=nummer,name" -H "apikey: $P"
curl -s "$U/rest/v1/anfragen?select=id,name,status" -H "apikey: $P"

[]
[{"id":1,"name":"Jana Weber","status":"offen"},
 {"id":2,"name":"Tim Brandt","status":"offen"},
 {"id":3,"name":"Eva Lorenz","status":"offen"}]

curl -s -X PATCH "$U/rest/v1/anfragen?id=eq.3" -H "apikey: $P" \
  -H "Content-Type: application/json" -H "Prefer: return=representation" \
  -d '{"status":"erledigt"}'

curl -s -X POST "$U/auth/v1/signup" -H "apikey: $P" -H "Content-Type: application/json" \
  -d '{"email":"nora@nordwerk.example","password":"Werkbank-2026"}'

T=$(curl -s -X POST "$U/auth/v1/token?grant_type=password" -H "apikey: $P" \
  -H "Content-Type: application/json" \
  -d '{"email":"nora@nordwerk.example","password":"Werkbank-2026"}' | python3 -c "import json,sys; print(json.load(sys.stdin)['access_token'])")
echo "$T" | cut -c1-25

-- Stufe 8 · Row Level Security
-- Ohne diese Datei darf jeder mit dem öffentlichen Schlüssel alle Anfragen lesen, ändern und löschen.

alter table public.anfragen enable row level security;

-- Das Kontaktformular (ohne Anmeldung) darf nur neue, offene Anfragen anlegen. Lesen darf es nichts.
create policy "formular legt an" on public.anfragen
  for insert to anon
  with check (status = 'offen' and bearbeitet_von is null);

-- Angemeldete Mitarbeitende sehen alle Anfragen ...
create policy "team liest" on public.anfragen
  for select to authenticated
  using (true);

-- ... übernehmen freie Anfragen und bearbeiten ihre eigenen. Eintragen dürfen sie dabei nur sich selbst.
create policy "team bearbeitet" on public.anfragen
  for update to authenticated
  using (bearbeitet_von is null or bearbeitet_von = (select auth.uid()))
  with check (bearbeitet_von = (select auth.uid()));

-- Die Produktliste ist öffentlich lesbar.
create policy "alle lesen produkte" on public.produkte
  for select to anon, authenticated
  using (true);

# Das Kontaktformular legt eine Anfrage an (ohne Anmeldung)
curl -s -w "%{http_code}\n" -X POST "$U/rest/v1/anfragen" -H "apikey: $P" \
  -H "Content-Type: application/json" -H "Prefer: return=minimal" \
  -d '{"name":"Ali Kaya","email":"ali@example.com","anliegen":"Gibt es die WB-120 auch in Eiche?","produkt":"WB-120"}'

# Nora liest alle Anfragen (Token T aus Stufe 7)
curl -s "$U/rest/v1/anfragen?select=id,name,status" -H "apikey: $P" -H "Authorization: Bearer $T"

-- Stufe 9 · Ein privater Bucket für Anhänge (Fotos zu Reklamationen)
-- Dasselbe geht im Studio unter Storage → New bucket; die Richtlinien stehen dort unter Policies.

insert into storage.buckets (id, name, public)
values ('anhaenge', 'anhaenge', false);

create policy "team lädt hoch" on storage.objects
  for insert to authenticated
  with check (bucket_id = 'anhaenge');

create policy "team liest anhänge" on storage.objects
  for select to authenticated
  using (bucket_id = 'anhaenge');

printf "Foto der Tür am TS-90" > tuer.txt
curl -s -X POST "$U/storage/v1/object/anhaenge/anfrage-2/tuer.txt" -H "apikey: $P" \
  -H "Authorization: Bearer $T" -H "Content-Type: text/plain" --data-binary @tuer.txt

curl -s "$U/storage/v1/object/authenticated/anhaenge/anfrage-2/tuer.txt" -H "apikey: $P" -H "Authorization: Bearer $T"
curl -s -X POST "$U/storage/v1/object/sign/anhaenge/anfrage-2/tuer.txt" -H "apikey: $P" \
  -H "Authorization: Bearer $T" -H "Content-Type: application/json" -d '{"expiresIn":60}'

-- Stufe 10 · Firmenwissen als Vektoren
-- 1024 Werte passen zu bge-m3 (LM Studio: text-embedding-bge-m3). Ein anderes Modell braucht
-- eine andere Zahl, und alte Vektoren müssen neu berechnet werden.

create extension if not exists vector with schema extensions;

create table public.wissen (
  id        bigint generated always as identity primary key,
  quelle    text not null,
  inhalt    text not null,
  embedding extensions.vector(1024) not null
);

create index wissen_embedding_idx on public.wissen
  using hnsw (embedding extensions.vector_cosine_ops);

alter table public.wissen enable row level security;

create policy "team liest wissen" on public.wissen
  for select to authenticated
  using (true);

-- Sucht die Abschnitte, die einer Frage am ähnlichsten sind.
-- aehnlichkeit: 1 = gleiche Bedeutung, 0 = nichts gemeinsam.
create or replace function public.match_wissen (
  frage      extensions.vector(1024),
  anzahl     int   default 3,
  mindestens float default 0.5
)
returns table (id bigint, quelle text, inhalt text, aehnlichkeit float)
language sql stable
set search_path = ''
as $$
  select w.id, w.quelle, w.inhalt,
         1 - (w.embedding operator(extensions.<=>) frage) as aehnlichkeit
  from public.wissen w
  where 1 - (w.embedding operator(extensions.<=>) frage) >= mindestens
  order by w.embedding operator(extensions.<=>) frage
  limit anzahl;
$$;

$env:SUPABASE_URL = "http://localhost:8000"
$env:SUPABASE_SECRET_KEY = "sb_secret_…"          # aus /opt/supabase/.env
$env:EMBED_URL = "http://localhost:1234/v1"       # LM Studio
$env:EMBED_MODEL = "text-embedding-bge-m3"
python wissen_einlesen.py

services:
  n8n:
    # … wie bisher …
    networks: [default, supabase]

networks:
  supabase:
    external: true
    name: supabase_default

#!/bin/sh
# backup.sh — sichert die Supabase-Übungsinstanz in /opt/supabase/backups/<Zeitpunkt>/
#
#   sh backup.sh              # im laufenden Betrieb: Dump Deiner Tabellen (Schema public)
#   sh backup.sh --komplett   # hält Supabase kurz an und sichert alles: Datenbankdateien,
#                             # Storage-Dateien, Funktionen, .env und das Volume db-config
#
# Der Dump reicht, um eine versehentlich gelöschte Tabelle zurückzuholen.
# Vor einem Update braucht es die komplette Sicherung, sonst gibt es keinen Rückweg.
set -eu
cd /opt/supabase
ZIEL="backups/$(date +%Y-%m-%d-%H%M)"
mkdir -p "$ZIEL"

docker exec supabase-db pg_dump -U postgres -d postgres -n public -Fc > "$ZIEL/public.dump"
echo "Dump: $ZIEL/public.dump ($(du -h "$ZIEL/public.dump" | cut -f1))"

if [ "${1:-}" = "--komplett" ]; then
  sh run.sh stop
  tar czf "$ZIEL/volumes.tar.gz" volumes
  docker run --rm -v supabase_db-config:/quelle:ro -v "$PWD/$ZIEL":/ziel alpine \
    tar czf /ziel/db-config.tar.gz -C /quelle .
  cp .env "$ZIEL/env.sicherung"
  sh run.sh start
  echo "Komplett: $ZIEL ($(du -sh "$ZIEL" | cut -f1))"
fi
chmod -R go-rwx backups

D=backups/2026-09-24-1500        # Deine Sicherung
docker exec -i supabase-db pg_restore -U postgres -d postgres --data-only -t wissen < $D/public.dump

cd /opt/supabase
D=backups/2026-09-24-1500
sh run.sh stop
mv volumes volumes.vorher
tar xzf $D/volumes.tar.gz
docker run --rm -v supabase_db-config:/ziel -v "$PWD/$D":/quelle:ro alpine \
  sh -c "rm -rf /ziel/* && tar xzf /quelle/db-config.tar.gz -C /ziel"
sh run.sh start

docker stats --no-stream --format "{{.Name}} {{.MemUsage}}" | grep supabase
docker compose logs --since 24h | grep -i error | tail
du -sh backups/*

cd /opt
git clone --depth 1 --branch self-hosted/v0.8.2 https://github.com/supabase/supabase supabase-src
mkdir supabase && cp -rf supabase-src/docker/. supabase
cd supabase
cp .env.example .env
printf 'ref=self-hosted/v0.8.2\n' > .supabase-version

# Alle Ports nur auf 127.0.0.1 (Zugriff per SSH-Tunnel).
# Docker umgeht die Firewall: ein Port ohne 127.0.0.1 wäre aus dem Internet erreichbar.
services:
  api-gw:
    ports: !override
      - 127.0.0.1:8000:8000/tcp
  supavisor:
    ports: !override
      - 127.0.0.1:5432:5432
      - 127.0.0.1:6543:6543

sh run.sh config add lokal
sh utils/generate-keys.sh --update-env
sh utils/add-new-auth-keys.sh --update-env
chmod 600 .env
grep -c 'this_password_is_insecure' .env      # muss 0 ergeben

sed -i 's/^ENABLE_EMAIL_AUTOCONFIRM=false/ENABLE_EMAIL_AUTOCONFIRM=true/' .env
docker compose pull
sh run.sh start
docker compose ps

ssh -N -L 8000:127.0.0.1:8000 root@DEIN-SERVER

cd /opt/supabase
P=$(grep ^SUPABASE_PUBLISHABLE_KEY= .env | cut -d= -f2-)
U=http://127.0.0.1:8000

services:
  n8n:
    # … wie bisher …
    networks: [default, supabase]

networks:
  supabase:
    external: true
    name: supabase_default

$env:SUPABASE_URL = "http://localhost:8000"
$env:SUPABASE_SECRET_KEY = "sb_secret_…"          # aus /opt/supabase/.env
$env:EMBED_URL = "http://localhost:1234/v1"       # LM Studio
$env:EMBED_MODEL = "text-embedding-bge-m3"
python wissen_einlesen.py

cd /opt/supabase && sh reset.sh