Compare commits
30
Commits
+7
-43
@@ -23,13 +23,11 @@ APP_URL="http://localhost:3000"
|
||||
|
||||
# Port innerhalb des Containers bzw. im Standalone-Betrieb
|
||||
PORT="3000"
|
||||
# Host-Port-Mapping fuer den App-Container (--profile full). Nur auf dem
|
||||
# Loopback – nach draussen geht es ueber einen Reverse Proxy. Soll die
|
||||
# Instanz im LAN erreichbar sein, hier "3000" eintragen.
|
||||
APP_PORT="127.0.0.1:3000"
|
||||
# Host-Port-Mapping fuer den App-Container (--profile full)
|
||||
APP_PORT="3000"
|
||||
|
||||
# ── Datenbank ────────────────────────────────────────────────
|
||||
# Standalone-Betrieb: App laeuft lokal, Postgres via "npm run docker:db"
|
||||
# Standalone-Betrieb: App laeuft lokal, Postgres via "docker compose up -d db"
|
||||
# oder als nativ installierter Dienst.
|
||||
DATABASE_URL="postgresql://nebula:nebula@localhost:5432/nebula?schema=public"
|
||||
|
||||
@@ -40,24 +38,10 @@ DATABASE_URL="postgresql://nebula:nebula@localhost:5432/nebula?schema=public"
|
||||
POSTGRES_USER="nebula"
|
||||
POSTGRES_PASSWORD="nebula"
|
||||
POSTGRES_DB="nebula"
|
||||
# Host-Port der Datenbank. Wirkt NUR zusammen mit docker-compose.dev.yml
|
||||
# (npm run docker:db) – die Basisdatei veroeffentlicht keinen DB-Port, weil
|
||||
# die Anwendung im Container "db:5432" anspricht und nichts davon nach
|
||||
# aussen muss. Auf einem Server bleibt dieser Wert also folgenlos.
|
||||
POSTGRES_PORT="127.0.0.1:5432"
|
||||
# Host-Port, unter dem die Datenbank erreichbar ist
|
||||
POSTGRES_PORT="5432"
|
||||
# Host-Port fuer Adminer (--profile tools)
|
||||
ADMINER_PORT="127.0.0.1:8080"
|
||||
|
||||
# ── Betrieb ohne veroeffentlichte Ports ──────────────────────
|
||||
# Liegen mehrere Stacks auf demselben Docker-Host und regelt ein gemeinsamer
|
||||
# Reverse Proxy den Zugang, veroeffentlicht Nebula gar keinen Port. Dann diese
|
||||
# beiden Zeilen aktivieren – danach genuegt ueberall "docker compose up -d":
|
||||
# COMPOSE_FILE="docker-compose.yml:docker-compose.server.yml"
|
||||
# COMPOSE_PROFILES="full"
|
||||
#
|
||||
# Name des geteilten Netzes und der Alias, unter dem der Proxy Nebula findet.
|
||||
# PROXY_NETWORK="proxy"
|
||||
# PROXY_ALIAS="nebula"
|
||||
ADMINER_PORT="8080"
|
||||
|
||||
# ── Sicherheit ───────────────────────────────────────────────
|
||||
# Schluessel zur Verschluesselung der Git-Access-Tokens (AES-256-GCM).
|
||||
@@ -69,29 +53,9 @@ ADMINER_PORT="127.0.0.1:8080"
|
||||
# und Passkeys sind davon nicht betroffen.
|
||||
APP_SECRET="bitte-aendern-mindestens-32-zeichen-langer-zufallswert"
|
||||
|
||||
# Absolute Lebensdauer einer Anmeldung in Tagen – ab dem Anmelden gerechnet
|
||||
# und nicht verlaengerbar.
|
||||
# Lebensdauer einer Anmeldung in Tagen.
|
||||
SESSION_TTL_DAYS="30"
|
||||
|
||||
# Leerlauffrist in Stunden: so lange darf eine Sitzung unbenutzt bleiben.
|
||||
# Wird bei jeder Nutzung neu angestossen. 0 schaltet die Pruefung ab.
|
||||
SESSION_IDLE_HOURS="8"
|
||||
|
||||
# ── Benachrichtigungen ───────────────────────────────────────
|
||||
# ntfy und Webhook brauchen nichts weiter – die Ziele werden in der
|
||||
# Anwendung unter "Mein Konto" eingerichtet.
|
||||
#
|
||||
# E-Mail steht erst zur Verfuegung, wenn SMTP_HOST gesetzt ist:
|
||||
# SMTP_HOST="smtp.example.com"
|
||||
# SMTP_PORT="587"
|
||||
# SMTP_SECURE="false" # true bei Port 465, sonst STARTTLS
|
||||
# SMTP_USER="nebula@example.com"
|
||||
# SMTP_PASSWORD="geheim"
|
||||
# SMTP_FROM="Nebula <nebula@example.com>"
|
||||
|
||||
# Timeout fuer das Zustellen in Millisekunden
|
||||
NOTIFY_TIMEOUT_MS="10000"
|
||||
|
||||
# ── Ausgehende Git-Zugriffe ──────────────────────────────────
|
||||
# Timeout fuer Git-API-Aufrufe in Millisekunden
|
||||
GIT_API_TIMEOUT_MS="15000"
|
||||
|
||||
@@ -1,78 +0,0 @@
|
||||
# Prueft jeden Push und jeden Pull Request.
|
||||
#
|
||||
# Die Datei liegt unter .gitea/workflows und wird von Gitea Actions gelesen.
|
||||
# Die Syntax ist mit GitHub Actions kompatibel – wer das Repo dorthin
|
||||
# spiegelt, kopiert sie nach .github/workflows.
|
||||
#
|
||||
# Voraussetzung: In der Gitea-Instanz muessen Actions aktiviert sein
|
||||
# (app.ini: [actions] ENABLED = true) und mindestens ein Runner registriert.
|
||||
|
||||
name: CI
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
pull_request:
|
||||
|
||||
jobs:
|
||||
pruefen:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:17-alpine
|
||||
env:
|
||||
POSTGRES_USER: nebula
|
||||
POSTGRES_PASSWORD: nebula
|
||||
# Der Name muss "test" enthalten – global-setup.ts leert die
|
||||
# Datenbank und weigert sich bei allem anderen.
|
||||
POSTGRES_DB: nebula_e2e_test
|
||||
ports:
|
||||
- 5432:5432
|
||||
options: >-
|
||||
--health-cmd "pg_isready -U nebula"
|
||||
--health-interval 5s
|
||||
--health-timeout 5s
|
||||
--health-retries 20
|
||||
|
||||
env:
|
||||
DATABASE_URL: postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public
|
||||
E2E_DATABASE_URL: postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public
|
||||
# Nur fuer den Lauf – keine echten Daten im Spiel.
|
||||
APP_SECRET: ci-lauf-schluessel-nur-fuer-die-pipeline-0123456789
|
||||
NEXT_TELEMETRY_DISABLED: "1"
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: 22
|
||||
cache: npm
|
||||
|
||||
- name: Abhaengigkeiten
|
||||
run: npm ci
|
||||
|
||||
- name: Typen pruefen
|
||||
run: npx tsc --noEmit
|
||||
|
||||
- name: Unit-Tests
|
||||
run: npm test
|
||||
|
||||
- name: Browser fuer die Oberflaechentests
|
||||
run: npx playwright install --with-deps chromium
|
||||
|
||||
# Baut zuerst und startet den Server dann selbst (siehe
|
||||
# playwright.config.ts, webServer).
|
||||
- name: Ende-zu-Ende-Tests
|
||||
run: npm run test:e2e
|
||||
|
||||
- name: Bericht bei Fehlschlag sichern
|
||||
if: failure()
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: playwright-bericht
|
||||
path: |
|
||||
playwright-report/
|
||||
test-results/
|
||||
retention-days: 7
|
||||
@@ -43,15 +43,6 @@ yarn-error.log*
|
||||
/data
|
||||
/postgres-data
|
||||
|
||||
# Sicherungen aus scripts/backup.* – enthalten alle Daten der Instanz
|
||||
/backups
|
||||
|
||||
# Playwright
|
||||
/test-results
|
||||
/playwright-report
|
||||
/blob-report
|
||||
/playwright/.cache
|
||||
|
||||
# editors
|
||||
.idea/
|
||||
.vscode/*
|
||||
|
||||
@@ -1,203 +0,0 @@
|
||||
# Nebula – Hinweise für Claude Code
|
||||
|
||||
Dashboard für Vibe-Coding-Projekte. Next.js 15 (App Router), TypeScript,
|
||||
Tailwind 4, Prisma, PostgreSQL. Oberfläche und Texte sind **deutsch**.
|
||||
|
||||
Funktionsumfang: [FEATURES.md](FEATURES.md) · Geplantes: [ROADMAP.md](ROADMAP.md) ·
|
||||
Betrieb: [README.md](README.md) · Server: [DEPLOYMENT.md](DEPLOYMENT.md)
|
||||
|
||||
## Womit man arbeitet
|
||||
|
||||
```bash
|
||||
npm run docker:db # Postgres, muss laufen (mit dem dev-Overlay,
|
||||
# sonst hat die DB keinen Host-Port)
|
||||
npm run dev # Entwicklung
|
||||
npm test # Unit-Tests (Vitest, ohne DB)
|
||||
npx tsc --noEmit # Typprüfung
|
||||
npm run build # Produktionsbau
|
||||
docker compose --profile full up -d --build # alles im Container
|
||||
```
|
||||
|
||||
**Vor dem `npm run build` einen laufenden `npm start`/`npm run dev` beenden.**
|
||||
Sonst hält der Prozess die Prisma-Engine-DLL und der Bau bricht unter Windows
|
||||
mit `EPERM … query_engine-windows.dll.node` ab.
|
||||
|
||||
## Nicht verhandelbar
|
||||
|
||||
**Datentrennung.** Jede Abfrage filtert auf den Besitzer, und zwar an erster
|
||||
Stelle in der `where`-Klausel. Schreiben und Löschen laufen über
|
||||
`updateMany`/`deleteMany` mit `ownerId`, damit fremde Datensätze gar nicht
|
||||
erst getroffen werden. Fremde IDs liefern **404, nicht 403** — die Antwort
|
||||
soll nicht bestätigen, dass es den Datensatz gibt.
|
||||
|
||||
**Jeder Endpunkt prüft selbst.** `requireUserApi()` bzw. `requireUserPage()`
|
||||
sind die Sicherheitsgrenze. Die Middleware schaut nur, ob überhaupt ein
|
||||
Cookie mitkommt — im Edge-Runtime gibt es keine Datenbank.
|
||||
|
||||
**Eingaben validieren.** Zod an jeder API-Grenze, Body über `readJsonBody`
|
||||
(erzwingt `application/json` und begrenzt die Größe).
|
||||
|
||||
**Keine Geheimnisse nach außen.** Git-Tokens verlassen den Server nie;
|
||||
Verbindungen werden über `connectionSafeSelect` geladen. Projekt-Exporte
|
||||
enthalten grundsätzlich keine Tokens.
|
||||
|
||||
**Ausgehende Aufrufe nur über `lib/git/http.ts`** — dort greift der
|
||||
SSRF-Schutz (`lib/security/ssrf.ts`).
|
||||
|
||||
## Fallstricke, die schon zugeschlagen haben
|
||||
|
||||
- **`node:`-Module in Client-Komponenten.** `lib/crypto`, `lib/auth/password`,
|
||||
`lib/git/index` ziehen `node:crypto`/`node:net` nach. Client-Komponenten
|
||||
importieren stattdessen `lib/git/meta` bzw. `lib/auth/constants`.
|
||||
- **`instrumentation.ts` wird auch für Edge übersetzt.** Der dynamische Import
|
||||
muss *innerhalb* von `if (process.env.NEXT_RUNTIME === "nodejs")` stehen,
|
||||
sonst scheitert der Bau an `node:crypto`.
|
||||
- **Eigene CSS-Klassen gehören in `app/components.css`** und dort in
|
||||
`@layer components`. Außerhalb eines Layers gewinnen sie gegen
|
||||
Tailwind-Utilities — dann greift `pl-9` neben `.field` nicht mehr.
|
||||
- **Menüs und Dialoge über Portal.** Karten setzen `overflow-hidden` und
|
||||
`backdrop-filter`; Letzteres erzeugt einen neuen Bezugsrahmen, in dem
|
||||
`position: fixed` und `z-index` nicht mehr wie erwartet wirken. Dafür gibt
|
||||
es `components/ui/Popover.tsx` und `components/ui/Modal.tsx`.
|
||||
- **Overlays brauchen einen deckenden Hintergrund** (`.popover`), nicht
|
||||
`.glass` — dessen 3,5 % Deckkraft lassen alles durchscheinen.
|
||||
- **Datumsangaben** über `lib/utils` formatieren (feste Zeitzone), sonst
|
||||
weichen Server-Render und Hydration voneinander ab. Relative Zeiten
|
||||
bekommen `suppressHydrationWarning`.
|
||||
- **Die feste Zeitzone gilt auch beim *Rechnen*, nicht nur beim Formatieren.**
|
||||
Im Container läuft die Anwendung nach UTC; „welcher Kalendertag" und
|
||||
„welche Woche" kippen dort abends um einen Tag. `lib/tasks` (`dueBucket`)
|
||||
und `lib/review` (`wocheUm`) rechnen deshalb über Berliner Kalendertage.
|
||||
Und eine Woche ist **nicht** „7 × 24 Stunden" — bei einer Zeitumstellung
|
||||
hat sie 167 oder 169.
|
||||
- **`min-width: auto` bei Flex- und Grid-Kindern.** Hat hier zweimal
|
||||
zugeschlagen: ein Kind weigert sich, unter die Inhaltsbreite seines
|
||||
breitesten Kindes zu schrumpfen, und drückt stattdessen die Nachbarn aus
|
||||
dem Bild. Einmal war es ein Sortierfeld mit `min-width`, das „Neues
|
||||
Projekt" hinausschob; einmal die Heatmap, die die ganze Projektseite
|
||||
doppelt so breit machte. Heilmittel ist beide Male `min-w-0` am Kind —
|
||||
ohne das greift auch ein `overflow-x-auto` darin nicht.
|
||||
- **`body { overflow-x: hidden }` versteckt genau diese Fehler.** Es steht in
|
||||
`globals.css` als Notnagel; was es abschneidet, ist auf dem Telefon
|
||||
schlicht nicht mehr erreichbar. Ursachen gehören in die Komponente.
|
||||
- **Dialoge müssen der Bildschirmtastatur ausweichen.** Sie verkleinert nur
|
||||
das *sichtbare* Fenster, nicht das Layoutfenster — `position: fixed` und
|
||||
`100vh` beziehen sich weiter auf das volle. `components/ui/Modal.tsx` hängt
|
||||
dafür an `window.visualViewport`; wer ein eigenes Overlay baut, braucht
|
||||
dasselbe.
|
||||
- **Ein verschluckter Fehler ist schlimmer als ein lauter.** `getJsonSafe` machte aus
|
||||
jedem Fehlschlag eine leere Liste. Damit war ein 403 nicht mehr von „das Repository
|
||||
hat keine Branches" zu unterscheiden: Der Abgleich meldete Erfolg, überschrieb den
|
||||
letzten guten Stand mit Nullen, und die Ursache war von außen nicht zu ermitteln —
|
||||
die Auskunft, die sie benannt hätte, war ja gerade weggeworfen worden. Wo ein
|
||||
Fallback nötig ist, gehört der Grund festgehalten (`Teilabrufe` in `lib/git/http.ts`).
|
||||
- **`Number()` auf einer Umgebungsvariable prüft nichts.** `Number("")` ist `0`,
|
||||
`Number("abc")` ist `NaN`, und `setTimeout` löst bei beidem sofort aus. Eine
|
||||
verrutschte Zeile in der `.env` konnte so den kompletten Abgleich stilllegen, ohne
|
||||
dass irgendwo etwas stand.
|
||||
- **Blättern über Cursor, nicht über `skip`.** Der Aktivitätsverlauf schreibt
|
||||
mehrere Zeilen im selben Augenblick; ein Offset über so eine Grenze hinweg
|
||||
überspringt oder verdoppelt lautlos. Muster in `lib/timeline.ts`:
|
||||
`(createdAt, id)` als Cursor, Sortierung identisch zur Bedingung.
|
||||
|
||||
## Migrationen
|
||||
|
||||
`prisma migrate dev` ist hier nicht benutzbar (interaktiv). Stattdessen:
|
||||
|
||||
```bash
|
||||
docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_shadow"
|
||||
npx prisma migrate diff --from-migrations prisma/migrations \
|
||||
--to-schema-datamodel prisma/schema.prisma \
|
||||
--shadow-database-url postgresql://nebula:nebula@localhost:5432/nebula_shadow \
|
||||
--script --output prisma/migrations/<stempel>_<name>/migration.sql
|
||||
npx prisma migrate deploy
|
||||
```
|
||||
|
||||
**`--from-migrations`, nicht `--from-schema-datasource`.** Letzteres
|
||||
vergleicht mit der *laufenden* Datenbank. Ist eine eben erzeugte Migration
|
||||
dort noch nicht eingespielt, steht ihr Inhalt in der nächsten gleich noch
|
||||
einmal.
|
||||
|
||||
**Das Zielverzeichnis vorher *nicht* anlegen.** Ein leerer Ordner unter
|
||||
`prisma/migrations/` lässt `--from-migrations` mit `P3015` abbrechen
|
||||
(„Could not find the migration file"). Erst die SQL woandershin erzeugen,
|
||||
dann Ordner anlegen und hineinkopieren.
|
||||
|
||||
**Die erzeugte SQL vor dem Anwenden lesen.** Die Volltextindizes
|
||||
`Note_fulltext_idx` und `Task_fulltext_idx` sind Ausdrucksindizes, die Prisma
|
||||
nicht kennt (sie werden bislang in Ruhe gelassen, aber das ist nicht
|
||||
garantiert).
|
||||
|
||||
**Ein Ausdrucksindex greift nur bei Zeichengleichheit.** Weicht der Ausdruck
|
||||
in der Abfrage auch nur in einem `coalesce` vom Index ab, rechnet Postgres
|
||||
`to_tsvector` je Zeile neu — ohne Fehlermeldung. Nachsehen statt annehmen:
|
||||
|
||||
```bash
|
||||
docker exec nebula-db psql -U nebula -d <db> -c "SET enable_seqscan = off;
|
||||
EXPLAIN (COSTS OFF) SELECT …" # muss einen Bitmap Index Scan zeigen
|
||||
```
|
||||
|
||||
**Datenmigrationen von Hand schreiben.** `migrate diff` kennt nur den
|
||||
Zielzustand: Spalten, die woandershin wandern, würde es ersatzlos löschen.
|
||||
Vorgehen wie in `20260726230000_repositories`: neue Tabelle anlegen, Bestand
|
||||
per `INSERT … SELECT` übernehmen, dann erst die alten Spalten entfernen.
|
||||
Danach `migrate diff` erneut laufen lassen — kommt „empty migration“ heraus,
|
||||
stimmt das Ergebnis mit dem Schema überein. Und gegen eine Kopie mit echten
|
||||
Daten prüfen, nicht nur gegen eine leere Datenbank.
|
||||
|
||||
## Prüfen, nicht behaupten
|
||||
|
||||
Vor „fertig": `npx tsc --noEmit`, `npm test`, `npm run build`.
|
||||
|
||||
Bei Änderungen an der Oberfläche **hinsehen**. Chrome ist installiert, ein
|
||||
Skript mit `playwright-core` und `channel: "chrome"` genügt für Screenshots.
|
||||
Mehrere Anzeigefehler dieses Projekts sind ausschließlich so aufgefallen.
|
||||
|
||||
**Seitlichen Überlauf misst man.** `document.documentElement.scrollWidth`
|
||||
gegen `clientWidth` auf 375 px — das findet in Sekunden, was beim Ansehen
|
||||
durchrutscht. Ein Skript, das dabei nur die *obersten* Verursacher meldet
|
||||
(Eltern, die selbst schon überlaufen, herausfiltern), ist deutlich brauchbarer
|
||||
als eine Liste aller betroffenen Knoten.
|
||||
|
||||
**Die Testdaten müssen die Bausteine enthalten, um die es geht.** Eine
|
||||
Messung gegen ein Projekt ohne Repository, ohne Snapshot und ohne README
|
||||
bescheinigte hier einmal „alles in Ordnung", während die echte Projektseite
|
||||
doppelt so breit war wie der Bildschirm. Erst mit vollständigen Daten
|
||||
nachgestellt trat der Fehler zutage.
|
||||
|
||||
**Barrierefreiheit misst man, statt sie zu behaupten.** `axe-core` liegt als
|
||||
Entwicklungsabhängigkeit bereit; ein Skript hängt es per `addScriptTag` in
|
||||
die laufende Seite und ruft `axe.run` mit den WCAG-Tags auf. Jeder
|
||||
Dialogzustand ist eine eigene Prüfung — geschlossene Dialoge stehen nicht im
|
||||
DOM. Der Kontrast gedämpfter Texte ist der Punkt, der hier schon einmal
|
||||
gerissen wurde; die aufgehellten Stufen stehen in `globals.css` im `@theme`.
|
||||
|
||||
Wer den Standalone-Bau von Hand startet (`node .next/standalone/server.js`),
|
||||
muss vorher `.next/static` und `public` danebenkopieren — sonst lädt kein
|
||||
JavaScript, die Seite bleibt serverseitig gerendert, und Formulare senden
|
||||
sich nativ ab. Das sieht aus wie ein Anwendungsfehler, ist aber keiner:
|
||||
|
||||
```bash
|
||||
cp -r .next/static .next/standalone/.next/ && cp -r public .next/standalone/
|
||||
```
|
||||
|
||||
`pkill` gibt es in dieser Git-Bash nicht. Prozesse über PowerShell beenden
|
||||
(`Get-CimInstance Win32_Process … | Stop-Process`) — sonst läuft der alte
|
||||
Server weiter, hält die Prisma-DLL und blockiert den nächsten Bau.
|
||||
|
||||
**Niemals gegen die echte Datenbank testen.** Eine Wegwerf-Datenbank anlegen
|
||||
und danach löschen:
|
||||
|
||||
```bash
|
||||
docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_test"
|
||||
DATABASE_URL=postgresql://nebula:nebula@localhost:5432/nebula_test npx prisma migrate deploy
|
||||
```
|
||||
|
||||
## Sprache
|
||||
|
||||
Code-Kommentare, Commit-Nachrichten und Oberfläche auf Deutsch, **ohne
|
||||
Umlaute in Bezeichnern und Commit-Nachrichten** (bestehende Konvention).
|
||||
In Markdown-Dateien und in der Oberfläche sind Umlaute erwünscht.
|
||||
|
||||
Commits: Conventional Commits, Betreff deutsch, Rumpf erklärt **warum** —
|
||||
nicht was der Diff ohnehin zeigt.
|
||||
-453
@@ -1,453 +0,0 @@
|
||||
# Nebula auf einem Server betreiben
|
||||
|
||||
Schritt für Schritt: von der leeren Maschine bis zur laufenden Instanz hinter
|
||||
TLS — und wie Updates danach ablaufen.
|
||||
|
||||
Für Installation zum Ausprobieren und die Entwicklungsvarianten siehe
|
||||
[README.md](README.md). Hier geht es um den Dauerbetrieb.
|
||||
|
||||
---
|
||||
|
||||
## Was du brauchst
|
||||
|
||||
| | |
|
||||
| --- | --- |
|
||||
| Server | Linux mit Docker Engine ≥ 24 und Compose v2 |
|
||||
| Sonst | `git`, `curl`, eine POSIX-Shell — **kein Node, kein npm** |
|
||||
| Arbeitsspeicher | 1 GB reichen; beim Bauen kurzzeitig ~2 GB |
|
||||
| Plattenplatz | ~2 GB für Abbilder, dazu die Datenbank |
|
||||
| Domain | Eine (Unter-)Domain, die auf den Server zeigt |
|
||||
| TLS | Pflicht, wenn du Passkeys willst — siehe Schritt 6 |
|
||||
|
||||
> **Warum TLS Pflicht ist:** Passkeys verlangen einen sicheren Kontext.
|
||||
> Über `http://` an einer LAN-IP funktionieren sie nicht. Passwort und
|
||||
> Zwei-Faktor gehen auch ohne, aber dann läuft dein Passwort im Klartext
|
||||
> übers Netz — betreibe Nebula nicht ohne TLS.
|
||||
|
||||
---
|
||||
|
||||
## 1 · Docker installieren
|
||||
|
||||
```bash
|
||||
curl -fsSL https://get.docker.com | sh
|
||||
sudo usermod -aG docker "$USER"
|
||||
newgrp docker # oder ab- und wieder anmelden
|
||||
|
||||
docker --version && docker compose version
|
||||
```
|
||||
|
||||
## 2 · Nebula holen
|
||||
|
||||
```bash
|
||||
sudo mkdir -p /opt/nebula && sudo chown "$USER" /opt/nebula
|
||||
git clone https://git.example.com/dein-name/nebula.git /opt/nebula
|
||||
cd /opt/nebula
|
||||
```
|
||||
|
||||
## 3 · Konfigurieren
|
||||
|
||||
```bash
|
||||
./scripts/setup.sh # legt .env an, würfelt ein APP_SECRET, setzt Rechte 600
|
||||
```
|
||||
|
||||
Das Skript ist reines POSIX-Shell und braucht **kein Node** — auf einem
|
||||
reinen Docker-Host ist keins installiert. Es nimmt `openssl`, falls
|
||||
vorhanden, sonst `/dev/urandom`.
|
||||
|
||||
Ganz von Hand geht auch:
|
||||
|
||||
```bash
|
||||
cp .env.example .env
|
||||
chmod 600 .env
|
||||
openssl rand -base64 32 # den Wert als APP_SECRET eintragen
|
||||
```
|
||||
|
||||
Dann die `.env` öffnen und mindestens diese drei Werte anpassen:
|
||||
|
||||
```env
|
||||
# Die Adresse, unter der du Nebula im Browser aufrufst.
|
||||
# Bestimmt die WebAuthn-rpID — passt sie nicht, scheitern Passkeys.
|
||||
APP_URL="https://nebula.deine-domain.de"
|
||||
|
||||
# Verschlüsselt die Git-Tokens. Lang, zufällig, niemals teilen.
|
||||
APP_SECRET="…dein-langer-zufallswert…"
|
||||
|
||||
# Das Datenbankpasswort. Die Voreinstellung „nebula" ist für Entwicklung.
|
||||
POSTGRES_PASSWORD="…noch-ein-langer-zufallswert…"
|
||||
```
|
||||
|
||||
Die Ports müssen nicht angefasst werden: `APP_PORT` steht schon auf
|
||||
`127.0.0.1:3000`, und die Datenbank veröffentlicht gar nichts.
|
||||
|
||||
> **`APP_SECRET` später zu ändern** macht gespeicherte Git-Tokens unlesbar.
|
||||
> Sie müssen dann neu hinterlegt werden. Konten, Passwörter und Passkeys
|
||||
> bleiben unberührt.
|
||||
>
|
||||
> **`APP_URL` später zu ändern** macht bestehende **Passkeys ungültig**, weil
|
||||
> sie an die rpID gebunden sind. Passwörter funktionieren weiter.
|
||||
|
||||
### Welche Ports überhaupt hinausgehen
|
||||
|
||||
Nach einer regulären Installation ist es **genau einer**:
|
||||
|
||||
| Container | Host-Port | Wann |
|
||||
| --- | --- | --- |
|
||||
| `nebula-app` | `APP_PORT`, Vorgabe `127.0.0.1:3000` | `--profile full` |
|
||||
| `nebula-db` | — | **nie** |
|
||||
| `nebula-adminer` | `ADMINER_PORT`, Vorgabe `127.0.0.1:8080` | nur `--profile tools` |
|
||||
|
||||
**Die Datenbank veröffentlicht nichts.** Im Vollbetrieb spricht die Anwendung
|
||||
Postgres über das interne Docker-Netz als `db:5432` an — die `DATABASE_URL`
|
||||
setzt Compose selbst. Auch `scripts/backup.sh` und `restore.sh` gehen über
|
||||
`docker exec`, nicht über den Host. Ein Host-Port wäre nur eine zusätzliche
|
||||
Angriffsfläche und würde mit anderen Postgres-Containern auf demselben Host
|
||||
um den Port streiten.
|
||||
|
||||
Wer die Datenbank beim Entwickeln doch vom Host aus braucht — `npm run dev`
|
||||
läuft ja außerhalb des Containers — nimmt `docker-compose.dev.yml` dazu
|
||||
(`npm run docker:db`). Auf einem Server hat diese Datei nichts zu suchen.
|
||||
|
||||
Auch der Port der Anwendung liegt auf `127.0.0.1`: nach draußen geht es über
|
||||
den Reverse Proxy aus Schritt 6.
|
||||
|
||||
### Variante: gar keinen Port veröffentlichen
|
||||
|
||||
Liegen mehrere Stacks auf demselben Docker-Host und regelt ein gemeinsamer
|
||||
Reverse Proxy den Zugang, braucht Nebula überhaupt keinen Host-Port. Dafür
|
||||
gibt es **`docker-compose.server.yml`**: es nimmt die letzte verbliebene
|
||||
Freigabe zurück und hängt die Anwendung in ein geteiltes Netz.
|
||||
|
||||
```bash
|
||||
docker network create proxy # falls der Proxy-Stack es nicht schon anlegt
|
||||
```
|
||||
|
||||
```env
|
||||
# .env
|
||||
COMPOSE_FILE="docker-compose.yml:docker-compose.server.yml"
|
||||
COMPOSE_PROFILES="full"
|
||||
PROXY_NETWORK="proxy" # so heißt das Netz
|
||||
PROXY_ALIAS="nebula" # so findet der Proxy die Anwendung
|
||||
```
|
||||
|
||||
Compose liest beides aus der `.env`. Danach genügt überall — auch in
|
||||
`scripts/update.sh` — ein schlichtes `docker compose up -d`. Im Proxy zeigt
|
||||
das Ziel dann nicht mehr auf `127.0.0.1:3000`, sondern auf **`nebula:3000`**;
|
||||
Schritt 6 zeigt beide Schreibweisen.
|
||||
|
||||
> Ohne die Datei würde ein Override die Portlisten **zusammenhängen** statt
|
||||
> sie zu ersetzen — Compose führt `ports` anfügend zusammen. Das `!reset`
|
||||
> darin ist genau dafür da und braucht Compose 2.24 oder neuer.
|
||||
>
|
||||
> Das Trennzeichen in `COMPOSE_FILE` ist unter Linux der Doppelpunkt, unter
|
||||
> Windows das Semikolon.
|
||||
|
||||
## 4 · Starten
|
||||
|
||||
```bash
|
||||
docker compose --profile full up -d --build
|
||||
```
|
||||
|
||||
Der erste Bau dauert ein paar Minuten. Der Container spielt beim Start
|
||||
selbst die Migrationen ein und wartet dabei auf die Datenbank.
|
||||
|
||||
```bash
|
||||
docker compose --profile full logs -f app # mitlesen, Strg+C beendet nur das Lesen
|
||||
curl -s localhost:3000/api/health # {"status":"ok","database":"up",…}
|
||||
```
|
||||
|
||||
Ohne veröffentlichten Port geht die Frage an den Container statt an den Host
|
||||
— das Abbild bringt einen `HEALTHCHECK` mit:
|
||||
|
||||
```bash
|
||||
docker inspect --format '{{.State.Health.Status}}' nebula-app # healthy
|
||||
```
|
||||
|
||||
## 5 · Ersten Zugang anlegen
|
||||
|
||||
Ruf `https://nebula.deine-domain.de/setup` auf (nach Schritt 6) oder
|
||||
vorübergehend über einen SSH-Tunnel:
|
||||
|
||||
```bash
|
||||
ssh -L 3000:127.0.0.1:3000 benutzer@server
|
||||
# dann lokal http://localhost:3000/setup öffnen
|
||||
```
|
||||
|
||||
Dort legst du das Administratorkonto an und wählst die Betriebsart.
|
||||
**Danach ist `/setup` dauerhaft gesperrt.**
|
||||
|
||||
Anschließend gleich unter *Mein Konto*:
|
||||
|
||||
1. **Passkey hinzufügen** — geht erst, wenn TLS steht
|
||||
2. **Zwei-Faktor einrichten** und die Wiederherstellungscodes wegschreiben
|
||||
|
||||
## 6 · Reverse Proxy mit TLS
|
||||
|
||||
Nebula bringt keinen eigenen TLS-Abschluss mit. Beispiel mit **Caddy**, das
|
||||
Zertifikate von selbst besorgt und erneuert:
|
||||
|
||||
```caddyfile
|
||||
# /etc/caddy/Caddyfile
|
||||
nebula.deine-domain.de {
|
||||
reverse_proxy 127.0.0.1:3000
|
||||
}
|
||||
```
|
||||
|
||||
```bash
|
||||
sudo systemctl reload caddy
|
||||
```
|
||||
|
||||
Das genügt. Caddy setzt `X-Forwarded-*` von selbst, holt das Zertifikat bei
|
||||
Let's Encrypt und leitet `http` auf `https` um.
|
||||
|
||||
Läuft der Proxy selbst als Container im geteilten Netz (die Variante ohne
|
||||
veröffentlichte Ports), lautet das Ziel stattdessen `nebula:3000` —
|
||||
Docker löst den Alias auf:
|
||||
|
||||
```caddyfile
|
||||
nebula.deine-domain.de {
|
||||
reverse_proxy nebula:3000
|
||||
}
|
||||
```
|
||||
|
||||
<details>
|
||||
<summary>Dasselbe mit nginx</summary>
|
||||
|
||||
```nginx
|
||||
server {
|
||||
listen 443 ssl http2;
|
||||
server_name nebula.deine-domain.de;
|
||||
|
||||
ssl_certificate /etc/letsencrypt/live/nebula.deine-domain.de/fullchain.pem;
|
||||
ssl_certificate_key /etc/letsencrypt/live/nebula.deine-domain.de/privkey.pem;
|
||||
|
||||
location / {
|
||||
proxy_pass http://127.0.0.1:3000;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Real-IP $remote_addr;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header X-Forwarded-Proto $scheme;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Zertifikat mit `certbot --nginx -d nebula.deine-domain.de`.
|
||||
</details>
|
||||
|
||||
> Steht `APP_URL` auf `https://…`, setzt Nebula das `Secure`-Flag auf die
|
||||
> Sitzungscookies. Läuft der Proxy auf `https`, die `APP_URL` aber noch auf
|
||||
> `http`, funktioniert die Anmeldung — nur ohne dieses Flag. Also beides
|
||||
> gleichziehen.
|
||||
|
||||
## 7 · Firewall
|
||||
|
||||
```bash
|
||||
sudo ufw allow 22/tcp
|
||||
sudo ufw allow 80,443/tcp
|
||||
sudo ufw enable
|
||||
```
|
||||
|
||||
Port 3000 bleibt **zu**, 5432 wird ohnehin nie veröffentlicht. Die Firewall
|
||||
ist hier der zweite Riegel, nicht der erste.
|
||||
|
||||
> Docker schreibt seine Portfreigaben direkt in `iptables` und geht dabei an
|
||||
> `ufw` **vorbei**. Eine Freigabe auf `0.0.0.0` steht also im Netz, auch wenn
|
||||
> `ufw` sie zu melden scheint. Genau deshalb wird hier an `127.0.0.1`
|
||||
> gebunden, statt sich auf die Firewall zu verlassen.
|
||||
|
||||
## 8 · Sicherungen automatisieren
|
||||
|
||||
`scripts/backup.sh` legt einen `pg_dump` unter `backups/` ab. Täglich per
|
||||
Cron:
|
||||
|
||||
```bash
|
||||
crontab -e
|
||||
```
|
||||
|
||||
```cron
|
||||
# Jede Nacht um 3:15 sichern, 30 Tage aufheben
|
||||
15 3 * * * cd /opt/nebula && ./scripts/backup.sh >> /var/log/nebula-backup.log 2>&1
|
||||
30 3 * * * find /opt/nebula/backups -name '*.sql.gz' -mtime +30 -delete
|
||||
```
|
||||
|
||||
Zurückspielen:
|
||||
|
||||
```bash
|
||||
./scripts/restore.sh backups/nebula-2026-07-27-03-15-00.sql.gz
|
||||
```
|
||||
|
||||
> Die Sicherungen liegen auf **demselben Server**. Das hilft gegen einen
|
||||
> verpatzten Import, nicht gegen einen Plattenausfall. Zieh sie regelmäßig
|
||||
> woandershin — `rsync`, `restic`, was du ohnehin nutzt.
|
||||
|
||||
---
|
||||
|
||||
## Updates
|
||||
|
||||
Es sind zwei getrennte Orte, und das ist der Punkt, an dem es leicht
|
||||
durcheinandergeht:
|
||||
|
||||
| | Was dort liegt |
|
||||
| --- | --- |
|
||||
| **Das Git-Repository** | Der Quellcode. Dorthin wird entwickelt. |
|
||||
| **Diese Instanz** | Die laufende Anwendung, die du im Browser benutzt. |
|
||||
|
||||
Ein Commit im Git ändert am laufenden Nebula **nichts**. Der Server holt sich
|
||||
von allein nichts ab; er betreibt weiter die Fassung, die dort zuletzt gebaut
|
||||
wurde. Ein Update ist der Schritt dazwischen: holen, bauen, umschalten.
|
||||
|
||||
**Woran du siehst, was gerade läuft:** die Versionsnummer unten in der
|
||||
Fußzeile. Ein Klick darauf öffnet den Änderungsverlauf. Steht dort eine
|
||||
ältere Nummer als im Git, fehlen dir die neueren Funktionen — sie sind
|
||||
geschrieben, aber noch nicht auf diesem Server.
|
||||
|
||||
Dafür gibt es `scripts/update.sh`. Es macht alles in der richtigen
|
||||
Reihenfolge und bricht ab, sobald ein Schritt scheitert:
|
||||
|
||||
```bash
|
||||
cd /opt/nebula
|
||||
./scripts/update.sh
|
||||
```
|
||||
|
||||
Was es tut:
|
||||
|
||||
| Schritt | |
|
||||
| --- | --- |
|
||||
| **1 Prüfen** | docker, compose, `.env` da? Ist `APP_SECRET` gesetzt und nicht mehr der Entwicklungswert? |
|
||||
| | *(alles ohne Node — das Skript liest die Version selbst aus der `package.json`)* |
|
||||
| **2 Holen** | `git pull --ff-only`; zeigt die neuen Commits und fragt nach |
|
||||
| **3 Sichern** | `pg_dump` **vor** jeder Schemaänderung |
|
||||
| **4 Bauen** | Erst bauen, dann umschalten — ein gescheiterter Bau lässt die alte Fassung laufen |
|
||||
| **5 Starten** | Container neu; die Migrationen laufen im Entrypoint |
|
||||
| **6 Prüfen** | Bis zu zwei Minuten warten, bis der Container sich gesund meldet |
|
||||
|
||||
Scheitert die Gesundheitsprüfung, zeigt das Skript die letzten Logzeilen und
|
||||
nennt den Weg zurück.
|
||||
|
||||
```bash
|
||||
./scripts/update.sh --yes # ohne Rückfrage, für Cron
|
||||
./scripts/update.sh --ref v1.9.0 # auf eine bestimmte Fassung
|
||||
./scripts/update.sh --no-pull # nur neu bauen, ohne git pull
|
||||
```
|
||||
|
||||
### Wenn doch etwas schiefgeht
|
||||
|
||||
```bash
|
||||
# Zurück auf den vorigen Stand (die Kennung nennt das Skript beim Abbruch)
|
||||
git checkout <kennung>
|
||||
./scripts/update.sh --no-pull --yes
|
||||
|
||||
# Nur wenn eine Migration die Daten beschädigt hat:
|
||||
./scripts/restore.sh backups/<die-sicherung-von-vorhin>.sql.gz
|
||||
```
|
||||
|
||||
> **Migrationen werden nicht zurückgerollt.** Eine Migration, die eine Spalte
|
||||
> entfernt, ist nicht umkehrbar — deshalb sichert das Skript vorher. Steht
|
||||
> ein Update mit Datenmigration an, lies vorher den Änderungsverlauf
|
||||
> (Versionsnummer in der Fußzeile).
|
||||
|
||||
---
|
||||
|
||||
## Betrieb
|
||||
|
||||
### Zustand ansehen
|
||||
|
||||
```bash
|
||||
docker compose --profile full ps
|
||||
docker compose --profile full logs -f app
|
||||
curl -s localhost:3000/api/health
|
||||
```
|
||||
|
||||
### Neu starten
|
||||
|
||||
```bash
|
||||
docker compose --profile full restart app
|
||||
```
|
||||
|
||||
### Speicher- und Plattenverbrauch
|
||||
|
||||
```bash
|
||||
docker stats --no-stream nebula-app nebula-db
|
||||
docker system df
|
||||
docker image prune -f # alte Abbilder nach mehreren Updates
|
||||
```
|
||||
|
||||
### Webhooks
|
||||
|
||||
Der Abgleich holt den Stand in seinem Takt. Wer ihn **sofort** haben will —
|
||||
ein Push ist durch, ein Issue wurde geschlossen —, trägt im Git-System einen
|
||||
Webhook ein. Nebula erzeugt URL und Geheimnis am Repository (Funksymbol im
|
||||
Git-Bereich der Projektseite), eingetragen wird der Haken von Hand.
|
||||
|
||||
Voraussetzung ist, dass **dein Git-System diese Instanz erreicht**. Hinter
|
||||
dem Reverse Proxy ist das gegeben; in einem abgeschotteten Netz nicht. Der
|
||||
Endpunkt liegt unter `/api/webhooks/<repositoryId>` und ist der einzige ohne
|
||||
Anmeldung — ausgewiesen wird sich über eine Signatur, die gegen das
|
||||
hinterlegte Geheimnis geprüft wird.
|
||||
|
||||
**Ohne Webhook geht nichts verloren.** Der Abgleich prüft den Zustand
|
||||
verknüpfter Issues ohnehin mit und hakt erledigte Aufgaben nach. Der Webhook
|
||||
macht es nur sofort statt beim nächsten Durchlauf.
|
||||
|
||||
### Automatischer Abgleich
|
||||
|
||||
Standardmäßig **aus**. Einzuschalten unter *Admin-Einstellungen →
|
||||
Automatischer Abgleich*: Abstand, Repositories je Durchlauf, ob fertige
|
||||
Projekte ausgelassen werden. Der Zeitgeber läuft im Serverprozess selbst —
|
||||
kein zusätzlicher Container, kein Cron.
|
||||
|
||||
Wer lieber von außen taktet, lässt ihn aus und ruft
|
||||
`POST /api/admin/sync/run` auf.
|
||||
|
||||
---
|
||||
|
||||
## Härtung, die schon eingebaut ist
|
||||
|
||||
Damit du weißt, worum du dich **nicht** kümmern musst:
|
||||
|
||||
- Der Container läuft als **unprivilegierter Benutzer** (`nextjs`, UID 1001),
|
||||
nicht als root.
|
||||
- **Content-Security-Policy** mit Nonce, `strict-dynamic` und ohne
|
||||
`unsafe-inline` für Skripte.
|
||||
- **CSRF-Prüfung** über `Sec-Fetch-Site`/`Origin` bei jedem schreibenden
|
||||
Zugriff.
|
||||
- **SSRF-Schutz** bei allen ausgehenden Aufrufen: jede Adresse wird
|
||||
aufgelöst und gegen Loopback, Link-Local und Metadaten-Endpunkte geprüft,
|
||||
Weiterleitungen eingeschlossen.
|
||||
- **Ratenbegrenzung** auf Anmeldung, ausgehende Abrufe und schreibende
|
||||
Zugriffe; Kontosperre nach acht Fehlversuchen.
|
||||
- **Git-Tokens** liegen AES-256-GCM-verschlüsselt in der Datenbank und
|
||||
verlassen den Server nie — auch nicht im Export.
|
||||
- **Sitzungen** laufen nach 8 Stunden ohne Nutzung ab und spätestens nach
|
||||
30 Tagen (`SESSION_IDLE_HOURS`, `SESSION_TTL_DAYS`). In der Datenbank liegt
|
||||
nur der Hash des Tokens; das Cookie ist `HttpOnly`, `SameSite=Strict` und
|
||||
bei HTTPS zusätzlich mit dem Präfix `__Host-`.
|
||||
- **Passwörter** werden mit scrypt nach der Empfehlung des OWASP Password
|
||||
Storage Cheat Sheet gehasht (N = 2^17). Rechnet mit rund einer halben
|
||||
Sekunde je Anmeldung — das ist gewollt.
|
||||
- Der **Bildoptimierer** von Next ist abgeschaltet: Nebula benutzt ihn nicht,
|
||||
und `/_next/image` wäre sonst eine Angriffsfläche ohne Gegenwert.
|
||||
|
||||
### Was du beisteuern musst
|
||||
|
||||
- **TLS** über den Reverse Proxy
|
||||
- **`APP_SECRET`** lang und zufällig
|
||||
- **Datenbankport** nicht nach außen öffnen
|
||||
- **Sicherungen** wegschaffen
|
||||
- **Systemupdates**: `unattended-upgrades` für das Betriebssystem,
|
||||
`./scripts/update.sh` für Nebula
|
||||
|
||||
---
|
||||
|
||||
## Mehrbenutzerbetrieb
|
||||
|
||||
Nebula kann beides. Im Einzelbetrieb gibt es genau ein Konto und keine
|
||||
Registrierung. Umschalten unter *Admin-Einstellungen*.
|
||||
|
||||
Wichtig zu wissen: **Projekte sind zwischen Konten hart getrennt.** Auch ein
|
||||
Administrator sieht fremde Projekte nicht — er verwaltet Konten, keine
|
||||
Inhalte. Wer gemeinsam an einem Projekt arbeiten will, ist mit Nebula falsch
|
||||
beraten; das ist [bewusst nicht](ROADMAP.md) vorgesehen.
|
||||
|
||||
Die Selbstregistrierung ist standardmäßig aus. Lass sie aus, wenn die
|
||||
Instanz aus dem Internet erreichbar ist und du nicht willst, dass sich
|
||||
Fremde Konten anlegen.
|
||||
+14
-739
@@ -22,30 +22,11 @@ sonst würden Konten ausgesperrt. Nach der Einrichtung ist `/setup` dauerhaft ge
|
||||
|
||||
### 0.2 Anmeldung
|
||||
|
||||
- **Benutzername und Passwort.** Mindestens 10 Zeichen. Abgelehnt werden naheliegende
|
||||
Passwörter, reine Ziffernfolgen, zu wenig verschiedene Zeichen (`abababab`),
|
||||
durchlaufende Folgen (`abcdefgh`) und alles, was den eigenen Benutzernamen enthält.
|
||||
**Keine Zusammensetzungsregeln** — ASVS 2.1.9 rät ausdrücklich davon ab, weil sie zu
|
||||
`Passwort1!` führen statt zu Entropie.
|
||||
- **Hashing mit scrypt**, `N = 2^17, r = 8, p = 1` nach dem OWASP Password Storage Cheat
|
||||
Sheet (rund 0,5 s und 128 MiB je Prüfung). Die Parameter stehen im Hash, ältere bleiben
|
||||
also lesbar — und werden bei der nächsten Anmeldung still auf den aktuellen Stand
|
||||
gehoben. Das ist der einzige Moment, in dem das Klartextpasswort vorliegt.
|
||||
- **Gleiche Antwort für alles Fehlgeschlagene.** Ob ein Konto existiert, gesperrt,
|
||||
deaktiviert oder reines Passkey-Konto ist, sagt die Anmeldung erst, wenn das Passwort
|
||||
stimmt. Davor gibt es genau einen Text und eine vergleichbare Antwortzeit
|
||||
(`fakeVerifyDelay`), damit sich Benutzernamen nicht durchprobieren lassen.
|
||||
- **Benutzername und Passwort.** Mindestens 10 Zeichen, offensichtliche Passwörter werden
|
||||
abgelehnt. Hashing mit scrypt.
|
||||
- **Passkey (WebAuthn).** Fingerabdruck, Gesichtserkennung oder Sicherheitsschlüssel. Die
|
||||
Anmeldung läuft über auffindbare Credentials, ein Benutzername ist also nicht nötig.
|
||||
Mehrere Passkeys pro Konto, benennbar und einzeln entfernbar.
|
||||
- **Zwei-Faktor per TOTP.** Zeitbasiertes Einmalkennwort zusätzlich zum Passwort, für jede
|
||||
gängige Authenticator-App. Einrichtung über QR-Code oder abgetippten Schlüssel; scharf
|
||||
wird er erst nach einem bestätigten Code, damit sich niemand aussperrt, der den Scan
|
||||
nicht hinbekommt. Dazu zehn **Wiederherstellungscodes**, jeder genau einmal gültig —
|
||||
sie werden nur bei der Ausgabe angezeigt. Abschalten und Neuerzeugen verlangen das
|
||||
Passwort, nicht bloß eine offene Sitzung.
|
||||
- Die Passkey-Anmeldung fragt **nicht** nach dem zweiten Faktor: der Passkey ist bereits an
|
||||
ein Gerät gebunden und damit selbst der zweite Faktor.
|
||||
- Ein Konto kann **ausschließlich** per Passkey nutzbar sein. Der letzte Passkey lässt sich
|
||||
dann nicht entfernen, solange kein Passwort gesetzt ist.
|
||||
- Fehlversuche werden gezählt; nach acht sperrt sich das Konto für 15 Minuten.
|
||||
@@ -54,9 +35,9 @@ sonst würden Konten ausgesperrt. Nach der Einrichtung ist `/setup` dauerhaft ge
|
||||
|
||||
### 0.3 Mein Konto
|
||||
|
||||
Anzeigename und E-Mail ändern · Passwort setzen oder wechseln · Zwei-Faktor einrichten und
|
||||
abschalten · Passkeys verwalten · aktive Sitzungen einsehen (Browser, Betriebssystem, IP,
|
||||
letzte Aktivität) · überall abmelden, wobei das eigene Gerät angemeldet bleibt.
|
||||
Anzeigename und E-Mail ändern · Passwort setzen oder wechseln · Passkeys verwalten ·
|
||||
aktive Sitzungen einsehen (Browser, Betriebssystem, IP, letzte Aktivität) · überall
|
||||
abmelden, wobei das eigene Gerät angemeldet bleibt.
|
||||
|
||||
### 0.4 Benutzerverwaltung (Administratoren)
|
||||
|
||||
@@ -120,121 +101,16 @@ Der Status ist **direkt auf der Projektkarte** umschaltbar, ohne den Detailberei
|
||||
|
||||
## 2. Dashboard
|
||||
|
||||
### Schnellerfassung
|
||||
|
||||
Ein Blitzsymbol in der Kopfleiste, auf jeder Seite erreichbar. Ein Feld, Enter, fertig —
|
||||
als **Idee** entsteht ein Projekt im Status `IDEA`, als **Aufgabe** eine Aufgabe im
|
||||
gewählten Projekt (`TODO`). Alles Weitere setzen die Vorgaben des Schemas.
|
||||
|
||||
Der Dialog **bleibt nach dem Anlegen offen** und leert nur das Feld. Wer eine Idee
|
||||
notiert, hat meistens gleich die nächste; ihn jedes Mal neu zu öffnen wäre genau die
|
||||
Hürde, die hier wegsoll. Angelegtes wird darunter mit Link bestätigt. Das zuletzt
|
||||
gewählte Projekt wird gemerkt.
|
||||
|
||||
Der Einstieg sitzt in der Kopfleiste und nicht als schwebender Knopf unten rechts —
|
||||
dort wäre er auf schmalen Anzeigen mit der Auswahlleiste kollidiert.
|
||||
|
||||
### Überblick
|
||||
|
||||
- **Kennzahlen** oben: Anzahl Projekte mit Ø-Fortschritt, offene Ideen, aktive
|
||||
Entwicklungen, fertige Projekte, verknüpfte Repositories. Auf dem Telefon zweispaltig,
|
||||
damit die Projekte nicht erst nach dem zweiten Wischen beginnen.
|
||||
Entwicklungen, fertige Projekte, verknüpfte Repositories.
|
||||
- **Volltextsuche** über Name, Kurzbeschreibung, Beschreibung, Tags und Repo-Pfad.
|
||||
- **Statusfilter** als Chips mit Trefferzähler, mehrere gleichzeitig kombinierbar.
|
||||
- **Sortierung** nach zuletzt geändert, Anlagedatum, Name, Fortschritt oder Priorität —
|
||||
Favoriten bleiben stets oben.
|
||||
- **Vier Ansichten**: freies Raster, **kompakte Liste**, nach Status gruppierte Abschnitte
|
||||
oder **Kanban**.
|
||||
- **Volltextsuche über Notizen und Aufgaben.** Die Suche im Board arbeitet auf den
|
||||
geladenen Projekten (Name, Kurzbeschreibung, Tags, Repo-Pfad). Notizen und Aufgaben
|
||||
liegen dort nicht vor — sie mitzuladen würde die Seite aufblähen. Stattdessen sucht
|
||||
Postgres serverseitig mit seiner deutschen Textsuche, entprellt ab zwei Zeichen.
|
||||
Treffer erscheinen als zwei eigene Listen mit hervorgehobener Fundstelle, die
|
||||
betroffenen Projekte werden zusätzlich eingeblendet. Deutsche Stammformen greifen:
|
||||
„Webhook" findet auch „Webhooks", „Rechnung" auch „Rechnungen".
|
||||
|
||||
Beide Seiten haben je einen **Ausdrucksindex** (`Note_fulltext_idx`,
|
||||
`Task_fulltext_idx`). Der Ausdruck darin muss Zeichen für Zeichen dem in der Abfrage
|
||||
entsprechen, sonst greift er nicht und Postgres rechnet `to_tsvector` je Zeile neu.
|
||||
- **Zwei Ansichten**: freies Raster oder nach Status gruppierte Abschnitte.
|
||||
- **Archiv** ist standardmäßig ausgeblendet und per Schalter einblendbar.
|
||||
- **Leerzustände** mit direktem Einstieg statt einer leeren Fläche.
|
||||
|
||||
### Schnellsuche
|
||||
|
||||
**`Strg+K`** (auf dem Mac `Cmd+K`) öffnet überall eine Palette:
|
||||
|
||||
- **Projekte** nach Name, Kurzbeschreibung und Tags — ohne Eingabe stehen die letzten
|
||||
gleich bereit
|
||||
- **Notizen** über dieselbe Volltextsuche wie im Board, entprellt ab zwei Zeichen
|
||||
- **Bereiche**: Dashboard, Git-Verbindungen, Mein Konto, Admin-Einstellungen
|
||||
|
||||
Bedienung über Tastatur: Pfeile wählen, `Enter` öffnet, `Esc` schließt. Die Projektliste
|
||||
wird beim ersten Öffnen geholt und dann behalten — sie bei jedem Tastendruck neu zu laden
|
||||
wäre Verschwendung.
|
||||
|
||||
### Projektvorlagen
|
||||
|
||||
Ein Projekt, das sich bewährt hat, lässt sich im Projektkopf über **Als Vorlage sichern**
|
||||
festhalten: Status, Priorität, Farbe, Tags, Notizen und offene Aufgaben. Beim Anlegen eines
|
||||
neuen Projekts steht die Vorlage oben im Dialog zur Auswahl.
|
||||
|
||||
Bewusst benutzereigen statt fest eingebaut — welche Tags und welche Startaufgaben sinnvoll
|
||||
sind, weiß nur, wer damit arbeitet. Eine mitgelieferte Liste wäre geraten.
|
||||
|
||||
- **Erledigte Aufgaben kommen nicht mit.** Eine Vorlage beschreibt, was zu tun ist, nicht
|
||||
was einmal getan wurde.
|
||||
- **Repositories gehen nicht mit.** Eine Vorlage, die jedes neue Projekt an dasselbe
|
||||
Repository hängt, wäre eine Falle.
|
||||
- Die Stammdaten füllt der Dialog **sichtbar** in die Felder, damit sie vor dem Speichern
|
||||
noch änderbar sind; bereits Getipptes wird nicht überschrieben. Notizen und Aufgaben legt
|
||||
erst der Server an — im Dialog ließen sie sich nicht darstellen.
|
||||
- Vorlagen überleben das Löschen ihres Ursprungsprojekts.
|
||||
|
||||
### Mehrfachauswahl
|
||||
|
||||
Ein Kästchen auf jeder Karte — es erscheint erst beim Überfahren, damit nicht auf jeder
|
||||
Karte dauerhaft eines steht. Sobald etwas ausgewählt ist, fährt unten eine Leiste ein:
|
||||
**Status setzen**, **Tags ergänzen oder entfernen**, **als Favorit markieren**, **löschen**.
|
||||
|
||||
Was der Filter ausblendet, fällt aus der Auswahl. Sonst träfe eine Massenänderung Projekte,
|
||||
die man gar nicht mehr vor Augen hat. Fremde IDs fallen serverseitig still unter den Tisch.
|
||||
|
||||
### Liste
|
||||
|
||||
Eine Zeile je Projekt, alle gleich aufgebaut: Statusfarbe als Streifen, Name,
|
||||
Fortschrittsbalken mit Prozentwert, danach Aufgaben, Notizen, Branch und Alter des
|
||||
letzten Commits. Der Statuswechsler sitzt rechts, die ganze Zeile ist ein Link.
|
||||
|
||||
Gedacht ist die Ansicht für zwei Fälle:
|
||||
|
||||
- **Auf dem Telefon.** Eine Karte braucht rund 260 px Höhe und steht dort zwangsläufig
|
||||
allein in der Zeile — fünf Projekte füllen zwei Bildschirme, bevor man überhaupt
|
||||
etwas vergleichen kann. Eine Zeile kommt mit einem Viertel davon aus.
|
||||
- **Beim Vergleichen.** Weil alle Zeilen gleich gebaut sind, liegen Name, Fortschritt
|
||||
und Status untereinander. Genau das verliert das Raster, sobald es einspaltig wird.
|
||||
|
||||
Was nicht mehr in die Zeile passt, fällt der Reihe nach weg, statt sie zu sprengen:
|
||||
Notizen ab `sm`, Branch ab `md`, der letzte Commit und die Priorität ab `lg`.
|
||||
|
||||
### Kanban
|
||||
|
||||
Spalten je Status, Karten per Ziehen verschiebbar. Der Wechsel wird sofort angezeigt und
|
||||
erst danach gespeichert; scheitert das Speichern, springt die Karte zurück.
|
||||
|
||||
- Gezogen wird am Griff links, nicht an der ganzen Karte — so bleibt der Titel ein
|
||||
normaler Link.
|
||||
- Das Ziehen startet erst nach ein paar Pixeln Bewegung, damit Klicks weiter funktionieren.
|
||||
Auf Touchgeräten nach kurzem Halten.
|
||||
- **Freie Reihenfolge innerhalb einer Spalte.** Die Position wird am Projekt gespeichert,
|
||||
wie beim Aufgabenbrett. Deshalb ist die Sortierung im Kopf in dieser Ansicht abgeschaltet
|
||||
— sie stehen zu lassen, ohne dass sie wirkt, wäre irreführend.
|
||||
- Reines Umsortieren fasst das Änderungsdatum **nicht** an. Sonst schöbe ein Aufräumen im
|
||||
Brett sämtliche Projekte in der Sortierung „Zuletzt geändert“ nach oben.
|
||||
- Neue, importierte und per Status verschobene Projekte landen am Ende ihrer Spalte.
|
||||
- **Ansicht, Sortierung und Archivschalter überdauern das Neuladen** (im Browser
|
||||
gespeichert, nicht am Konto). Der Suchbegriff bleibt bewusst außen vor — eine Suche von
|
||||
gestern beim Öffnen wiederherzustellen wäre eher verwirrend als hilfreich.
|
||||
|
||||
### Projektkarte auf einen Blick
|
||||
|
||||
Name und Favoritenstern · Kurzbeschreibung · Fortschrittsbalken · Provider-Badge ·
|
||||
@@ -243,181 +119,9 @@ Anzahl Notizen · Warnung bei Sync-Fehler · Tags · Statusauswahl · Priorität
|
||||
|
||||
---
|
||||
|
||||
## 2a. Aufgaben je Projekt
|
||||
|
||||
Jedes Projekt hat ein eigenes Aufgabenbrett mit vier Spalten: **Offen · In Arbeit ·
|
||||
Blockiert · Erledigt**.
|
||||
|
||||
- **Ziehen und Ablegen** zwischen den Spalten **und innerhalb** einer Spalte. Anders als
|
||||
beim Projektbrett ist die Reihenfolge hier bedeutsam, deshalb wird sie gespeichert.
|
||||
- Gezogen wird am Griff links, damit ein Klick auf die Karte weiter den Dialog öffnet.
|
||||
- Eine Aufgabe braucht nur einen Titel. Optional: Beschreibung (Markdown),
|
||||
Fälligkeitsdatum und Labels.
|
||||
- **Fälligkeiten** färben sich mit: überfällig rot, heute gelb, in den nächsten Tagen
|
||||
gedämpft.
|
||||
- **Hängt ein Git-Issue daran**, trägt die Karte dessen Nummer — vorn in der Fußzeile,
|
||||
vor Beschreibung, Wiederholung, Frist und Labels, damit sich eine Spalte danach
|
||||
überfliegen lässt. Bewusst kein Link: der Weg zum Issue führt über den Dialog (4.6),
|
||||
weil ein `<a>` innerhalb der anklickbaren Karte ungültiges Markup wäre.
|
||||
|
||||
#### Wie viele Karten eine Spalte zeigt
|
||||
|
||||
Eine Spalte zeigt höchstens so viele Karten, wie unter *Admin-Einstellungen →
|
||||
Aufgabenbrett* eingestellt ist (Voreinstellung 15, `0` schaltet die Begrenzung ab). Was
|
||||
darüber hinausgeht, steht hinter einem Knopf „*n* weitere anzeigen"; entfaltet wird je
|
||||
Spalte einzeln. Die Zahl neben der Spaltenüberschrift nennt weiterhin den **vollen**
|
||||
Bestand — sonst wäre nicht zu erkennen, dass etwas fehlt.
|
||||
|
||||
**Begrenzt wird nur die Anzeige.** Das Umsortieren schickt je Spalte die vollständige
|
||||
Liste an den Server; würde hier schon gekürzt, fielen die verborgenen Aufgaben beim
|
||||
nächsten Ziehen aus dem Brett. Die Einstellung ist deshalb bewusst eine Sache der
|
||||
Darstellung und keine der Abfrage — geladen wird ohnehin das ganze Projekt.
|
||||
- Erledigtes wird durchgestrichen; der Zeitpunkt wird festgehalten und beim Zurückziehen
|
||||
wieder gelöscht.
|
||||
|
||||
### Wiederkehrende Aufgaben
|
||||
|
||||
Täglich, wöchentlich, alle zwei Wochen oder monatlich. Wandert die Aufgabe nach
|
||||
**Erledigt** — im Dialog oder durch Ziehen —, entsteht die nächste von selbst. Die
|
||||
erledigte bleibt stehen, sonst ginge die Historie verloren.
|
||||
|
||||
- **Gerechnet wird vom Fälligkeitsdatum, nicht vom Abhaken.** Eine wöchentliche Aufgabe
|
||||
bleibt auf ihrem Montag, auch wenn sie einmal erst am Mittwoch erledigt wurde.
|
||||
- Lange Liegengebliebenes rutscht so weit vor, bis der Termin in der Zukunft liegt — eine
|
||||
Aufgabe, die schon bei ihrer Entstehung überfällig ist, hilft niemandem.
|
||||
- Beim Monatsintervall bleibt der Tag im Monat erhalten. Der 31. Januar wird zum
|
||||
28. Februar, nicht zum 3. März.
|
||||
- Nur der **Übergang** nach Erledigt löst aus. Eine bereits erledigte Aufgabe erneut zu
|
||||
speichern erzeugt keine zweite Fassung.
|
||||
- Bewusst grob gehalten: feinere Regeln („jeden zweiten Dienstag im Monat") braucht ein
|
||||
Projektdashboard nicht und wären ohne Kalenderansicht kaum nachvollziehbar.
|
||||
|
||||
### Aus Git-Issues übernehmen
|
||||
|
||||
Im Git-Panel, Reiter *Issues*: ein Klick macht aus den offenen Issues Aufgaben — Titel,
|
||||
Labels und ein Link zurück ins Git-System.
|
||||
|
||||
- Grundlage ist der **zuletzt geholte Stand**, hier wird nichts nachgeladen. Ein Klick
|
||||
soll nicht ungefragt fremde APIs ansprechen; wer den neuesten Stand will, gleicht
|
||||
vorher ab.
|
||||
- Die Issue-Nummer bleibt an der Aufgabe und ist je Projekt eindeutig. Ein zweiter Klick
|
||||
legt deshalb **keine Dubletten** an, auch wenn die Aufgabe inzwischen verschoben oder
|
||||
umbenannt wurde.
|
||||
- Ohne Repo-Stand meldet der Server das mit einem Hinweis statt still nichts zu tun.
|
||||
|
||||
### Fortschritt aus Aufgaben
|
||||
|
||||
Pro Projekt umschaltbar. Ist es an, ergibt sich der Fortschritt aus dem Anteil erledigter
|
||||
Aufgaben und wird bei jeder Änderung neu berechnet — der Regler ist dann gesperrt, statt
|
||||
einen Wert anzubieten, der gleich wieder überschrieben würde.
|
||||
|
||||
Auf der Projektkarte im Dashboard steht das Verhältnis als `3/8`.
|
||||
|
||||
### Wie die Reihenfolge gespeichert wird
|
||||
|
||||
Beim Ablegen schickt die Oberfläche je Spalte die **vollständige Liste** der Aufgaben in
|
||||
ihrer neuen Reihenfolge; der Server vergibt daraus Position und Status. Das ist
|
||||
wiederholbar, kommt ohne Positionsrechnerei im Browser aus, und ein verlorener Aufruf
|
||||
lässt sich einfach erneut senden. IDs, die nicht zum Projekt gehören, werden ignoriert
|
||||
statt verschoben.
|
||||
|
||||
---
|
||||
|
||||
## 2b. Aufgaben über alle Projekte
|
||||
|
||||
Die Seite `/tasks` sammelt jede Aufgabe aus jedem Projekt an einer Stelle. Erreichbar
|
||||
über die Kopfleiste und die Schnellsuche.
|
||||
|
||||
**Geordnet wird nach Fälligkeit, nicht nach Spalte.** Projektübergreifend lautet die
|
||||
Frage „was ist überfällig", nicht „was steht wo im Brett". Die Fächer:
|
||||
|
||||
| Fach | Inhalt |
|
||||
| --- | --- |
|
||||
| **Überfällig** | Termin liegt vor heute |
|
||||
| **Heute** | Termin ist der heutige Kalendertag |
|
||||
| **Diese Woche** | in den nächsten sieben Tagen |
|
||||
| **Später** | alles danach |
|
||||
| **Ohne Termin** | kein Fälligkeitsdatum gesetzt |
|
||||
|
||||
Gerechnet wird auf **Kalendertage in fester Zeitzone** (Europe/Berlin), nicht auf
|
||||
Stunden und nicht nach Serverzeit. Eine heute um 9 Uhr fällige Aufgabe ist um 17 Uhr
|
||||
nicht überfällig, sondern immer noch „heute" — sonst wanderte die halbe Liste im Lauf
|
||||
des Tages nach oben. Und im Container läuft die Anwendung nach UTC; ohne feste Zeitzone
|
||||
kippte die Einteilung abends um einen Tag. Das Fach bestimmt der **Server**, damit
|
||||
Server-Render und Hydration nicht auseinanderlaufen.
|
||||
|
||||
- **Filter** nach Status (mit Zähler) und Projekt; Erledigtes ist ausgeblendet und
|
||||
einzeln zuschaltbar.
|
||||
- **Abhaken direkt aus der Liste.** Der Endpunkt erledigt dabei den Rest: Zeitpunkt,
|
||||
abgeleiteter Projektfortschritt und — bei wiederkehrenden Aufgaben — die nächste
|
||||
Fassung.
|
||||
- Jede Zeile nennt ihr **Projekt** und verlinkt es; ohne das ist eine übergreifende
|
||||
Liste nicht zu lesen. Stammt die Aufgabe aus einem Git-Issue, führt ein Symbol dorthin.
|
||||
|
||||
**Bewusst nicht sortierbar per Ziehen.** Die Position einer Aufgabe gilt innerhalb ihrer
|
||||
Spalte in ihrem Projekt; hier wäre sie ohne Bedeutung. Eine Reihenfolge anzubieten, die
|
||||
nirgends ankommt, wäre ein Versprechen, das die Seite nicht halten kann.
|
||||
|
||||
Die Aufgabe kennt keinen Besitzer — die Trennung läuft über das Projekt
|
||||
(`project: { ownerId }` als einzige und erste Bedingung).
|
||||
|
||||
---
|
||||
|
||||
## 2c. Rückblick und Verlauf
|
||||
|
||||
Zwei Sichten auf denselben Aktivitätsverlauf, über alle Projekte hinweg. Beide teilen
|
||||
sich Zeilendarstellung und Tagesgruppierung (`components/ActivityRow`) — zwei Kopien
|
||||
wären beim nächsten Feinschliff auseinandergelaufen.
|
||||
|
||||
Der Verlauf kennt keinen Besitzer; die Trennung läuft über das Projekt
|
||||
(`project: { ownerId }` als erste Bedingung).
|
||||
|
||||
### Wochenrückblick
|
||||
|
||||
`/rueckblick` beantwortet „was ist diese Woche passiert". Oben Kennzahlen — Vorgänge,
|
||||
berührte Projekte, erledigte und neue Aufgaben —, darunter die Vorgänge nach
|
||||
Kalendertagen gebündelt, neuester Tag zuerst. Über `?woche=-n` geht es bis zu 25 Wochen
|
||||
zurück; weiter lohnt nicht, weil der Verlauf ohnehin nur 200 Einträge je Projekt hält.
|
||||
|
||||
**Gerechnet wird auf Kalendertage in fester Zeitzone** (Europe/Berlin), nicht auf
|
||||
„sieben mal 24 Stunden": liegt eine Zeitumstellung in der Woche, hat sie 167 oder 169
|
||||
Stunden. Und im Container läuft die Anwendung nach UTC — ein Eintrag von Sonntagabend
|
||||
fiele sonst in die falsche Woche. Das Fach bestimmt der **Server**, damit Server-Render
|
||||
und Hydration nicht auseinanderlaufen.
|
||||
|
||||
**„Aufgaben erledigt" wird am `meta`-Feld abgelesen** (`to: "DONE"`), nicht am
|
||||
Anzeigetext. Der Text ist zum Lesen da und ändert sich mit der Formulierung; eine
|
||||
Zählung daran würde beim nächsten umformulierten Einzeiler unbemerkt kippen. Einträge
|
||||
ohne `meta` zählen nicht mit — lieber untertreiben als raten.
|
||||
|
||||
### Globale Zeitleiste
|
||||
|
||||
`/verlauf` zeigt denselben Verlauf **fortlaufend**: ohne Wochengrenze, ohne Fazit, mit
|
||||
„Ältere laden". Die erste Seite kommt serverseitig mit, alles Weitere über
|
||||
`/api/activity`.
|
||||
|
||||
**Geblättert wird per Cursor** über `(createdAt, id)`, nicht per `skip`. Der Verlauf
|
||||
schreibt mehrere Einträge im selben Augenblick — beim Übernehmen von Issues entstehen
|
||||
zehn Zeilen mit identischem Zeitstempel. Ein Offset über eine solche Grenze hinweg
|
||||
überspringt Zeilen oder zeigt sie zweimal, und zwar lautlos. Der zweite Zweig der
|
||||
Bedingung (gleicher Zeitpunkt, kleinere ID) fängt genau das ab.
|
||||
|
||||
Nachgerechnet gegen 144 Einträge mit absichtlichen Blöcken gleicher Zeitstempel: 15
|
||||
Seiten, 144 Zeilen, keine Dublette, streng absteigend.
|
||||
|
||||
Beide Seiten sind über die Schnellsuche erreichbar, der Rückblick zusätzlich über einen
|
||||
Verweis vom Dashboard. Bewusst **kein** weiterer Punkt in der Kopfleiste — die ist auf
|
||||
dem Telefon schon eng.
|
||||
|
||||
---
|
||||
|
||||
## 3. Notizen
|
||||
|
||||
- **Beliebig viele Notizen pro Projekt**, mit optionalem Titel und mehrzeiligem Text.
|
||||
- **Markdown wird dargestellt** — Überschriften, Listen, Tabellen, Codeblöcke, Zitate und
|
||||
Links. Aus `- [ ] Aufgabe` werden echte Checklisten. Gilt auch für die Projekt-
|
||||
beschreibung. Rohes HTML wird beim Rendern entfernt (`rehype-sanitize`) — der Inhalt
|
||||
stammt vom Benutzer und wäre sonst ein XSS-Loch.
|
||||
- **Anpinnen** — angepinnte Notizen stehen oben und sind farblich hervorgehoben.
|
||||
- **Bearbeiten und Löschen** direkt in der Liste; Löschen fragt nach.
|
||||
- **Zeitstempel**: Anlagedatum immer, „bearbeitet vor …" nur bei echter Änderung.
|
||||
@@ -430,54 +134,6 @@ dem Telefon schon eng.
|
||||
|
||||
## 4. Git-Anbindung
|
||||
|
||||
### 4.0 Mehrere Repositories je Projekt
|
||||
|
||||
Ein Vorhaben besteht oft aus mehreren Repositories — Frontend und Backend etwa, oder
|
||||
App und Infrastruktur. Sie gehören trotzdem in **eine** Karte.
|
||||
|
||||
- Im Git-Panel steht eine Leiste mit allen Repositories des Projekts, sobald es mehr als
|
||||
eines gibt. Jedes hat eigene Kennzahlen, Listen, CI und eigenen Abgleich; „Alle" gleicht
|
||||
sie nacheinander ab — nicht gleichzeitig, denn ein Schwung Anfragen an denselben Anbieter
|
||||
ist genau das, worauf Rate-Limits reagieren.
|
||||
- Eine frei wählbare **Bezeichnung** („Frontend") tritt an die Stelle von `owner/name`.
|
||||
- Das erste Repository ist das **führende**. Wo nur eines dargestellt werden kann — auf der
|
||||
Karte im Dashboard, im Kanban —, ist es dieses. Die Karte zeigt daneben `+2 Repos`.
|
||||
Ein Abgleichsfehler an *irgendeinem* Repository erscheint auf der Karte, sonst bliebe er
|
||||
unbemerkt.
|
||||
- **Stillstand** bemisst sich am jüngsten Commit über alle Repositories: an einem Vorhaben
|
||||
wird gearbeitet, sobald an einem seiner Teile gearbeitet wird.
|
||||
- Benachrichtigungen merken sich den gemeldeten Zustand **je Repository**. Sonst verdeckte
|
||||
ein rotes Frontend die rote Pipeline des Backends. Der Betreff nennt das Repository nur,
|
||||
wenn es nicht ohnehin so heißt wie das Projekt.
|
||||
- Übernommene Issues merken sich, aus welchem Repository sie stammen — Frontend und Backend
|
||||
haben beide ein Issue Nummer 5, und das sind zwei Aufgaben.
|
||||
|
||||
Der Projektdialog bearbeitet weiterhin nur das führende Repository; weitere verwaltet das
|
||||
Git-Panel. Beim Anlegen eines Projekts entsteht aus den Git-Feldern das erste.
|
||||
|
||||
### 4.0a README-Vorschau
|
||||
|
||||
Das README des führenden Repositories steht auf der Projektseite — man muss nicht ins Git
|
||||
wechseln, nur um zu sehen, worum ein halbvergessenes Projekt eigentlich ging. Lange
|
||||
READMEs sind eingeklappt, ein Knopf zeigt alles.
|
||||
|
||||
- Geholt wird **höchstens einmal am Tag**, wie die Heatmap. GitHub hat einen eigenen
|
||||
Endpunkt, der jede Schreibweise findet; bei GitLab und Gitea braucht es zwei Aufrufe
|
||||
(Wurzelverzeichnis auflisten, dann die Datei holen).
|
||||
- Erkannt werden `README.md` und die üblichen Varianten, Groß- und Kleinschreibung egal.
|
||||
Markdown hat Vorrang — nur das lässt sich wirklich darstellen.
|
||||
- Bei 60 000 Zeichen wird an einer **Zeilengrenze** abgeschnitten, damit kein halber
|
||||
Codeblock stehen bleibt.
|
||||
- **Relative Links** werden gegen das Verzeichnis der Datei im Repository aufgelöst, sonst
|
||||
liefen sie ins Leere.
|
||||
- **Bilder werden nicht geladen.** Die Content-Security-Policy erlaubt `img-src` nur von
|
||||
der eigenen Instanz; sie dafür zu öffnen hieße, jedem fremden README das Nachladen
|
||||
beliebiger Bilder zu gestatten — also auch Zählpixeln. Für Abzeichen und
|
||||
Bildschirmfotos, die in einer Vorschau ohnehin Beiwerk sind, ist das kein guter Tausch.
|
||||
Stattdessen steht ein anklickbarer Verweis mit dem Alternativtext.
|
||||
- Der Inhalt stammt aus einem fremden Repository und läuft deshalb durch dieselbe
|
||||
Bereinigung wie Notizen (`rehype-sanitize`).
|
||||
|
||||
### 4.1 Unterstützte Systeme
|
||||
|
||||
| System | API | Authentifizierung | Besonderheit |
|
||||
@@ -502,105 +158,18 @@ Firmen-Gitea nebeneinander.
|
||||
Kurzbeschreibung.
|
||||
- **Löschen** trennt nur die Verknüpfung; die Projekte selbst bleiben erhalten.
|
||||
|
||||
#### Nötige Token-Rechte
|
||||
|
||||
Nebula liest fast alles nur. Geschrieben wird an **genau zwei Stellen**: `POST …/issues`
|
||||
beim Anlegen und `PATCH`/`PUT …/issues/{nr}` beim Schließen oder Wiederöffnen (4.6). Wer
|
||||
darauf verzichtet, kommt mit einem rein lesenden Token aus.
|
||||
|
||||
| System | Nur Abgleich | Zusätzlich für die Issue-Anbindung |
|
||||
| --- | --- | --- |
|
||||
| GitHub | *Metadata*, *Contents*, *Issues*, *Pull requests*, *Actions* — je lesend | *Issues: Read and write* |
|
||||
| GitLab | `read_api` | `api` |
|
||||
| Gitea / Forgejo | `read:repository`, `read:issue`, `read:user` | `write:issue` |
|
||||
|
||||
Welcher Aufruf welches Recht verlangt, steht Zeile für Zeile in der
|
||||
[README](README.md#welche-rechte-der-token-braucht) — dort ist jeder ausgehende Aufruf
|
||||
der drei Clients aufgeführt.
|
||||
|
||||
**GitLab kennt keinen schmalen Schreib-Scope.** `api` erlaubt alles, was das Konto darf,
|
||||
Code eingeschlossen. Wem das zu weit geht, bleibt bei `read_api`: der Abgleich läuft
|
||||
vollständig, geschlossene Issues werden weiterhin erkannt — nur schreibt Nebula dann
|
||||
nicht zurück.
|
||||
|
||||
**Nicht verlangt** werden Schreibrechte auf Code, Adminrechte und Rechte zum Anlegen von
|
||||
Webhooks. Der Haken wird von Hand im Git-System eingetragen (4.7); das erspart dem Token
|
||||
genau die Administrationsrechte, die er sonst bräuchte.
|
||||
|
||||
**Kommentare schreibt Nebula nie** — weder beim Anlegen noch beim Schließen. In den
|
||||
Rumpf des angelegten Issues wandert die Aufgabenbeschreibung plus eine Zeile Rückverweis
|
||||
auf das Projekt; danach bleibt der Text unangetastet. Was sonst an Kommentaren und
|
||||
Labels an einem Issue hängt, kommt aus der Weboberfläche oder von einem anderen Werkzeug.
|
||||
|
||||
Ein fehlendes Recht endet in einem `403` mit „Token hat nicht die noetigen Scopes",
|
||||
sichtbar am Repository auf der Projektseite. Klein anfangen und gezielt nachlegen ist
|
||||
deshalb ohne Risiko.
|
||||
|
||||
### 4.3 Was beim Sync geholt wird
|
||||
|
||||
| Bereich | Details |
|
||||
| --- | --- |
|
||||
| Repository | Voller Pfad, Beschreibung, Default-Branch, Sichtbarkeit, Größe, letzte Aktivität |
|
||||
| Kennzahlen | Stars, Forks, offene Issues, offene Pull-/Merge-Requests |
|
||||
| **Pull-/Merge-Requests** | bis zu 50 offene, mit Nummer, Titel, Autor, Alter, Labels, Entwurfskennzeichnung und Link |
|
||||
| **Issues** | bis zu 50 offene, gleiche Angaben. Bei GitHub und Gitea werden PRs herausgefiltert, die dort in derselben Liste stecken |
|
||||
| **CI-Status** | Letzter Lauf auf dem Default-Branch: erfolgreich, fehlgeschlagen, läuft, wartet oder abgebrochen — mit Name und Link |
|
||||
| Branches | bis zu 50, mit SHA, Default-Markierung, Schutzstatus und (wo die API es liefert) letztem Commit |
|
||||
| Tags | bis zu 25, mit SHA, Nachricht und Datum |
|
||||
| Commits | die letzten 15 zur Anzeige; geholt werden 100 für die Aktivitätskurve |
|
||||
| **Commit-Aktivität** | Balkenreihe der letzten Tage, auf Karte und Projektseite |
|
||||
| **Commit-Heatmap** | Ein Feld je Tag über bis zu ein Jahr, auf der Projektseite |
|
||||
| Commits | die letzten 15, mit Kurz-SHA, Nachricht, Autor, Datum und Link |
|
||||
| Releases | bis zu 10, inklusive Pre-Release- und Draft-Kennzeichnung |
|
||||
| Sprachen | Verteilung als Balken mit Prozentwerten |
|
||||
|
||||
#### Wenn ein Teil nicht ankommt
|
||||
|
||||
Diese Listen werden gleichzeitig geholt, und einzelne davon können scheitern, während
|
||||
der Rest durchgeht — ein 403 wegen fehlender Scopes, ein Rate-Limit, eine
|
||||
Zeitüberschreitung.
|
||||
|
||||
**Ein zweiter Versuch, bevor etwas als fehlend gilt.** Zeitüberschreitungen und
|
||||
Verbindungen, die gar nicht zustande kamen, werden einmal nachgeschlagen — einzeln
|
||||
statt im Schwung, weil genau das der beobachtete Fall war: zwei von acht Aufrufen
|
||||
liefen in eine Zeitüberschreitung nach 15 Sekunden, während dieselben Aufrufe einzeln
|
||||
in 80 Millisekunden antworteten. Nachgeschlagen wird höchstens zweimal je Abgleich —
|
||||
acht Zeitüberschreitungen hintereinander wären zwei Minuten. Bei `403`, `404` und `429`
|
||||
gibt es keinen zweiten Versuch: fehlende Rechte werden durch Wiederholen nicht besser,
|
||||
ein Rate-Limit wird schlimmer.
|
||||
|
||||
**Ein gescheiterter Abruf ist keine leere Liste.** Der Unterschied steht am Snapshot: zu
|
||||
jedem Feld, das nicht geholt werden konnte, wird der Grund samt HTTP-Status festgehalten.
|
||||
Daraus folgt dreierlei:
|
||||
|
||||
- Die vorhandenen Daten **bleiben stehen**. Ein Abgleich, der die Tags nicht holen konnte,
|
||||
ersetzt die gespeicherten nicht durch eine leere Liste. Angezeigt wird dann der letzte
|
||||
vollständige Stand, mit Datum.
|
||||
- Die Meldung heißt „Teilweise aktualisiert – nicht geholt: …" statt „Snapshot
|
||||
aktualisiert: 0 Branches, 0 Tags".
|
||||
- Auf der Projektseite steht ein Hinweis am Repository, der jedes fehlende Feld mit
|
||||
seinem Grund nennt.
|
||||
|
||||
Das gilt ausdrücklich **nicht** als Fehlschlag: `syncError` bleibt leer, der Zähler für
|
||||
das Zurückhalten wird nicht erhöht, und der nächste Durchlauf versucht es normal wieder.
|
||||
Der Rest des Standes ist ja frisch.
|
||||
|
||||
> Vor v1.11.0 wurde jeder Fehlschlag in eine leere Liste verwandelt. Ein Repository mit
|
||||
> 65 Commits meldete „Snapshot aktualisiert: 0 Branches, 0 Tags", überschrieb dabei den
|
||||
> letzten guten Stand, und aus der Oberfläche war nicht zu erkennen, dass überhaupt etwas
|
||||
> schiefgegangen war.
|
||||
|
||||
Woher der CI-Status kommt:
|
||||
|
||||
| System | Quelle |
|
||||
| --- | --- |
|
||||
| GitHub | `actions/runs` für den Default-Branch; Lauf-Status und Ergebnis werden zusammengeführt |
|
||||
| GitLab | `pipelines` für den Default-Branch |
|
||||
| Gitea | Kombinierter Commit-Status — deckt Gitea Actions **und** externe Systeme wie Woodpecker ab, anders als ein reiner Actions-Endpunkt, den ältere Instanzen nicht kennen |
|
||||
|
||||
Zur Ehrlichkeit der Aktivitätskurve: geholt wird eine Seite mit 100 Commits. Reicht die
|
||||
nicht über den ganzen Zeitraum, wird die Kurve auf den tatsächlich belegten Ausschnitt
|
||||
gekürzt — eine Null zu zeichnen, wo wir schlicht nichts wissen, wäre falsch.
|
||||
|
||||
- **Snapshot-Prinzip**: Alle Daten werden in der Datenbank abgelegt. Das Dashboard bleibt
|
||||
ohne Netzverbindung oder bei erreichtem Rate-Limit vollständig nutzbar.
|
||||
|
||||
@@ -612,19 +181,9 @@ bewusste Entscheidung sein. Einschalten in den Admin-Einstellungen.
|
||||
| Einstellung | Bedeutung |
|
||||
| --- | --- |
|
||||
| Abstand | 15 Minuten bis täglich |
|
||||
| Repositories je Durchlauf | 1–100, Voreinstellung 25 |
|
||||
| Projekte je Durchlauf | 1–100, Voreinstellung 25 |
|
||||
| Fertige und archivierte auslassen | Dort ändert sich selten noch etwas |
|
||||
|
||||
Gezählt und begrenzt wird je **Repository**, nicht je Projekt: sonst zöge ein Projekt mit
|
||||
fünf Repos fünfmal so viele Anfragen nach sich, wie sein Platz im Kontingent hergibt.
|
||||
|
||||
Die Daten für die **Heatmap** kommen getrennt und höchstens einmal am Tag — an einem
|
||||
Jahresüberblick ändert sich von Stunde zu Stunde nichts Sichtbares. Bei GitHub genügt dafür
|
||||
ein Aufruf der Jahresstatistik; GitLab und Gitea kennen keine, dort werden bis zu fünf
|
||||
Seiten Commits geholt. Reicht das nicht ein Jahr zurück, **beginnt die Heatmap beim
|
||||
ältesten bekannten Commit** und sagt es dazu — leere Felder für Zeiträume zu zeichnen, über
|
||||
die nichts bekannt ist, wäre eine Lüge.
|
||||
|
||||
Wie der Durchlauf arbeitet:
|
||||
|
||||
- Der Zeitgeber läuft im Serverprozess selbst (`instrumentation.ts`), prüft minütlich, ob
|
||||
@@ -654,208 +213,6 @@ Dateneinsicht. Ein Administrator sieht dadurch weiterhin keine fremden Projekte.
|
||||
- **Zeitlimit** pro Aufruf über `GIT_API_TIMEOUT_MS` einstellbar; die Teilabfragen laufen
|
||||
parallel, eine fehlschlagende Liste bricht den restlichen Sync nicht ab.
|
||||
|
||||
### 4.6 Aufgabe ↔ Git-Issue
|
||||
|
||||
Die Verbindung geht in beide Richtungen — mit einer bewussten Grenze.
|
||||
|
||||
**Nebula → Git.** Ein Knopf im Aufgabendialog legt zur Aufgabe ein Issue im
|
||||
verknüpften Repository an. Nummer und Adresse landen an der Aufgabe (`sourceIssue`,
|
||||
`sourceUrl`, `sourceRepositoryId` — dieselben Felder, die die Übernahme aus Issues seit
|
||||
v0.9.0 füllt, samt Eindeutigkeit je Repository gegen Dubletten). In den Rumpf kommt ein
|
||||
Rückverweis auf das Projekt.
|
||||
|
||||
Ausdrücklich **per Knopf und nie nebenbei**: was in ein fremdes System geschrieben wird,
|
||||
soll jemand gewollt haben. Danach wandert der Zustand allerdings mit — erledigt schließt
|
||||
das Issue, ein Zurückziehen öffnet es wieder. Schlägt der Aufruf fehl, zieht die Aufgabe
|
||||
trotzdem um; ein nicht erreichbares Git-System darf das Abhaken nicht verhindern.
|
||||
|
||||
**Git → Nebula** auf zwei Wegen, die sich ergänzen:
|
||||
|
||||
- **Webhook** — sofort, sobald das Issue geschlossen wird. Setzt voraus, dass die Instanz
|
||||
von außen erreichbar ist und der Haken eingetragen wurde (siehe 4.7).
|
||||
- **Beim Abgleich** — verzögert, aber verlässlich. Der Abgleich fragt den Zustand
|
||||
verknüpfter Issues nach und hakt ab, was in Git geschlossen ist. Damit funktioniert der
|
||||
Rückweg auch ohne Webhook, ohne öffentliche Erreichbarkeit und selbst dann, wenn ein
|
||||
Haken einmal ausfällt.
|
||||
|
||||
Gespart wird, wo es geht: Nummern, die der gerade geholte Snapshot als offen führt,
|
||||
werden nicht einzeln nachgefragt. Umgekehrt gilt das nicht — die Liste der offenen
|
||||
Issues ist gedeckelt, aus dem Fehlen einer Nummer folgt also nichts. Pro Durchgang
|
||||
fragt der Abgleich höchstens 25 Issues nach.
|
||||
|
||||
**Der Abgleich hakt nur ab, er nimmt nie zurück.** Er sieht Zustände, keine Ereignisse:
|
||||
ein offenes Issue kann auch bedeuten, dass das Schließen von Nebula aus fehlgeschlagen
|
||||
ist. Ein symmetrischer Abgleich würde dann eine bewusst erledigte Aufgabe wieder
|
||||
aufmachen. Das Zurücknehmen bleibt dem Webhook vorbehalten, der ein echtes „reopened“
|
||||
sieht.
|
||||
|
||||
Ein gelöschtes Issue ist kein erledigtes — die Aufgabe bleibt stehen.
|
||||
|
||||
In beiden Fällen bewirkt ein geschlossenes Issue dasselbe wie ein Haken in der
|
||||
Oberfläche: bei einer wiederkehrenden Aufgabe entsteht die nächste Fassung, und der
|
||||
Vorgang landet im Projektverlauf (ohne Benutzer — das hat nicht jemand in Nebula getan,
|
||||
sondern das Git-System gemeldet).
|
||||
|
||||
**Die Zustände passen nicht aufeinander, und das bleibt so.** Nebula kennt
|
||||
`Offen · In Arbeit · Blockiert · Erledigt`, ein Issue nur offen oder geschlossen. Nach
|
||||
außen geht deshalb nur die Grenze um „erledigt“; ein Rundlauf verliert *In Arbeit* und
|
||||
*Blockiert*. Labels wie `nebula:doing` wären die Alternative, würden aber den
|
||||
Issue-Tracker mit Zuständen füllen, die dort niemand pflegt. Die feine Abstufung bleibt
|
||||
in Nebula.
|
||||
|
||||
Eine echte beidseitige Synchronisation mit Konfliktauflösung gibt es **nicht** — das ist
|
||||
der klassische Ort für stillen Datenverlust.
|
||||
|
||||
**Kein Widerspruch zu „keine eigenen Git-Operationen“:** Issues laufen über die HTTP-API
|
||||
der Provider, dieselbe Schicht wie alles andere (`lib/git/http.ts`, SSRF-Schutz
|
||||
inklusive). Kein Klon, kein Arbeitsverzeichnis. Schreibende Aufrufe folgen dabei
|
||||
**keinen Umleitungen** — ein 307 auf eine interne Adresse nähme den Rumpf und den Token
|
||||
im Header mit.
|
||||
|
||||
### 4.7 Webhooks
|
||||
|
||||
Ein Push aktualisiert den Stand sofort, statt bis zum nächsten Durchlauf des Zeitgebers
|
||||
zu warten; ein geschlossenes Issue hakt seine Aufgabe ab. Der Zeitplan bleibt als
|
||||
Rückfalllösung bestehen.
|
||||
|
||||
Einzurichten am Repository (Funksymbol im Git-Bereich): Nebula erzeugt URL und
|
||||
Geheimnis, eingetragen wird der Haken im Git-System von Hand. Über die API anzulegen
|
||||
wäre machbar, verlangte aber Administrationsrechte am Repository — deutlich mehr, als
|
||||
Nebula sonst braucht.
|
||||
|
||||
Das Geheimnis ist **genau einmal** zu sehen; danach liegt es verschlüsselt in der
|
||||
Datenbank, wie die Zugangstoken, und verlässt den Server nicht mehr.
|
||||
|
||||
| System | Ausweis | Kopfzeile |
|
||||
| --- | --- | --- |
|
||||
| GitHub | HMAC-SHA256 über den Rumpf | `X-Hub-Signature-256: sha256=…` |
|
||||
| Gitea | dieselbe Rechnung, ohne Präfix | `X-Gitea-Signature` (ältere: `X-Hub-Signature-256`) |
|
||||
| GitLab | das Geheimnis im Klartext | `X-Gitlab-Token` |
|
||||
|
||||
GitLabs Verfahren ist schwächer: es beweist nur, dass der Absender das Geheimnis kennt,
|
||||
nicht dass der Rumpf unverändert ist. Mehr gibt die Plattform nicht her; verglichen wird
|
||||
trotzdem zeitkonstant.
|
||||
|
||||
Geprüft wird gegen den **rohen** Rumpf — durch `JSON.parse` und `JSON.stringify` gedreht
|
||||
käme eine andere Zeichenfolge heraus und die Signatur passte nie.
|
||||
|
||||
Was der Endpunkt bewusst **nicht** tut: den Rumpf als Quelle für Inhalte benutzen. Titel,
|
||||
Beschreibung und Zustand kommen weiter aus Nebula beziehungsweise beim nächsten Abgleich
|
||||
aus der API. Wer das Geheimnis kennt, kann also höchstens eine Aufgabe auf- oder zumachen
|
||||
und einen Abgleich auslösen — keine beliebigen Daten einschleusen.
|
||||
|
||||
Unbekannte Ereignisse werden angenommen und liegen gelassen. Ein Fehler brächte das
|
||||
Git-System zum Wiederholen und irgendwann zum Abschalten des Hakens.
|
||||
|
||||
Der Endpunkt ist der einzige ohne Anmeldung, der schreibt. Deshalb: Ratenbegrenzung je
|
||||
Repository (60/Minute), Deckel auf die Rumpfgröße, und ein unbekanntes Repository
|
||||
antwortet wie ein nicht eingerichtetes — mit 404, damit die ID nicht bestätigt wird.
|
||||
|
||||
---
|
||||
|
||||
## 4a. Export, Import und Sicherung
|
||||
|
||||
### Projekte mitnehmen
|
||||
|
||||
- **JSON-Export** einzeln oder für alle Projekte: Stammdaten, Notizen, Tags,
|
||||
Repo-Verknüpfung. **Ohne Access Tokens** — die Verbindung wird nur beschrieben, das
|
||||
Token muss beim Import neu hinterlegt werden. Auch ohne Snapshots (reproduzierbar) und
|
||||
ohne Datenbank-IDs (gelten nur in der Quellinstanz).
|
||||
- **Markdown-Export** eines Projekts: Beschreibung, Kennzahlen, Notizen und der letzte
|
||||
bekannte Git-Stand als lesbare Datei.
|
||||
- **Import mit Vorschau.** Die Datei wird streng geprüft, bevor irgendetwas passiert.
|
||||
Abgeglichen wird über den Slug; bei Treffern stehen drei Strategien bereit:
|
||||
|
||||
| Strategie | Wirkung |
|
||||
| --- | --- |
|
||||
| Überspringen | Vorhandene bleiben unverändert |
|
||||
| Zusätzlich anlegen | Kopie mit freiem Slug (`nebula` → `nebula-2`) |
|
||||
| Ersetzen | Stammdaten überschreiben, Notizen austauschen |
|
||||
|
||||
Die Vorschau zeigt je Projekt, was geschähe, und weist auf fehlende Git-Verbindungen
|
||||
hin. Erst ein zweiter Klick schreibt.
|
||||
|
||||
### Sicherung
|
||||
|
||||
- **JSON-Sicherung** im Adminbereich: Einstellungen, Konten, Verbindungen, Projekte und
|
||||
Notizen in einer Datei. Passwörter als scrypt-Hash, Git-Tokens als Chiffrat — ohne
|
||||
dasselbe `APP_SECRET` wertlos. Sitzungen und Passkeys bleiben draußen: erstere sind
|
||||
kurzlebig, letztere hängen an Gerät und rpID.
|
||||
- **Datenbank-Sicherung** über `scripts/backup.*`: `pg_dump` im Container, mit
|
||||
`--clean --if-exists`, also für sich allein einspielbar. Gegenstück ist
|
||||
`scripts/restore.*`, das vor dem Überschreiben nachfragt und sich über einen Parameter
|
||||
auf eine Wegwerf-Datenbank umlenken lässt — damit sich eine Sicherung prüfen lässt,
|
||||
ohne die echte anzufassen.
|
||||
|
||||
---
|
||||
|
||||
## 4b. Benachrichtigungen
|
||||
|
||||
Einzurichten unter *Mein Konto → Benachrichtigungen*, pro Konto und beliebig viele Ziele.
|
||||
|
||||
### Anlässe
|
||||
|
||||
| Anlass | Wann |
|
||||
| --- | --- |
|
||||
| ⚠️ **Abgleich fehlgeschlagen** | Das Git-System war nicht erreichbar oder hat abgelehnt |
|
||||
| 🔴 **CI rot** | Der letzte Lauf auf dem Default-Branch ist fehlgeschlagen |
|
||||
| 🏷️ **Neues Release** | Ein neuer Tag oder ein neues Release ist aufgetaucht |
|
||||
| 🕸️ **Projekt steht still** | Seit längerem kein Commit — Schwelle einstellbar, Vorgabe 60 Tage |
|
||||
|
||||
### Nur bei Änderung
|
||||
|
||||
Der entscheidende Punkt: Gemeldet wird **ausschließlich, wenn sich etwas ändert**
|
||||
gegenüber dem, worüber zuletzt benachrichtigt wurde. Ein Repository mit abgelaufenem
|
||||
Token meldet sich also **einmal**, nicht bei jedem stündlichen Durchlauf. Wird der Fehler
|
||||
ein anderer, kommt eine neue Meldung; ist er behoben und tritt später erneut auf, ebenso.
|
||||
|
||||
Zwei Feinheiten:
|
||||
|
||||
- **Beim allerersten Abgleich** eines Repositories wird kein Release gemeldet — sonst
|
||||
wäre jede bereits vorhandene Version eine „Neuigkeit".
|
||||
- Der Merkstand wird auch dann fortgeschrieben, wenn **kein** Ziel eingerichtet ist. Sonst
|
||||
käme beim ersten eingerichteten Ziel die ganze Vergangenheit hinterher.
|
||||
|
||||
### Stillstand
|
||||
|
||||
Der einzige Anlass, der an keinem Ereignis hängt — es passiert ja gerade nichts. Deshalb
|
||||
ein eigener Durchlauf, **höchstens einmal am Tag**, unabhängig vom automatischen Abgleich.
|
||||
Hört niemand auf diesen Anlass, läuft die Prüfung gar nicht erst.
|
||||
|
||||
Maßstab ist ausschließlich der **letzte Commit** im verknüpften Repository. Das
|
||||
Änderungsdatum des Projekts taugt nicht: jeder Abgleich fasst es an und würde den
|
||||
Stillstand immer wieder zurücksetzen. Projekte **ohne Repository** bleiben deshalb außen
|
||||
vor, ebenso fertige und archivierte.
|
||||
|
||||
Gemeldet wird je Projekt einmal. Erneut erst, wenn danach wieder ein Commit kam und es
|
||||
seitdem wieder still geworden ist — ein Projekt, das aufwacht und wieder einschläft, meldet
|
||||
sich also ein zweites Mal.
|
||||
|
||||
Die Schwelle setzt ein Administrator unter *Admin-Einstellungen → Stillstand* (14 Tage bis
|
||||
ein Jahr). Eine Änderung wirkt sofort, nicht erst nach 24 Stunden.
|
||||
|
||||
### Zustellwege
|
||||
|
||||
| Weg | Details |
|
||||
| --- | --- |
|
||||
| **ntfy** | Vollständige Themen-URL. Titel, Priorität und Symbol als Kopfzeilen; optionales Bearer-Token für geschützte Themen. Läuft auch gegen ein selbst gehostetes ntfy im eigenen Netz. |
|
||||
| **Webhook** | JSON per POST mit Anlass, Titel, Text, Projektbezug und Tieflink. Mit hinterlegtem Geheimnis wird der Rumpf per HMAC-SHA256 signiert (`X-Nebula-Signature`), damit der Empfänger die Herkunft prüfen kann. |
|
||||
| **E-Mail** | Über SMTP. Steht erst zur Verfügung, wenn `SMTP_HOST` in der `.env` gesetzt ist — sonst ist die Auswahl in der Oberfläche gesperrt und erklärt, warum. |
|
||||
|
||||
Jedes Ziel lässt sich einzeln **testen** und **pausieren**; Ergebnis und Zeitpunkt der
|
||||
letzten Zustellung stehen an der Karte.
|
||||
|
||||
### Absicherung
|
||||
|
||||
- Zieladressen sind Benutzereingaben, die der Server abruft — sie laufen deshalb durch
|
||||
denselben **SSRF-Schutz** wie die Git-Verbindungen. Ein ntfy im eigenen Netz bleibt
|
||||
erlaubt, Loopback und Cloud-Metadaten nicht.
|
||||
- Redirects werden **nicht verfolgt**: ein Umleitungsziel wäre nicht geprüft.
|
||||
- Geheimnisse liegen AES-256-GCM-verschlüsselt und verlassen den Server nie; die
|
||||
Oberfläche zeigt nur einen Hinweis wie `test…mnis`.
|
||||
- Eine fehlgeschlagene Zustellung lässt den Abgleich nicht scheitern — der Fehler landet
|
||||
am Ziel, nicht im Sync.
|
||||
|
||||
---
|
||||
|
||||
## 5. Oberfläche
|
||||
@@ -865,24 +222,10 @@ letzten Zustellung stehen an der Karte.
|
||||
- **Animationen**: gestaffelt einblendende Karten, Hover-Lift mit Farbverlaufsrand,
|
||||
animierte Fortschrittsbalken.
|
||||
- **Responsiv** von Handy bis Ultrawide (bis zu vier Kartenspalten).
|
||||
- **Barrierefrei nach WCAG 2.1 AA**, und zwar geprüft statt behauptet: axe-core läuft über
|
||||
zehn Seitenzustände einschließlich der Dialoge und meldet keine Verstöße. Durchgehende
|
||||
ARIA-Labels, Escape schließt Dialoge, sichtbarer Fokusring, `prefers-reduced-motion`
|
||||
schaltet Animationen ab.
|
||||
Bei der ersten Durchsicht fielen 26 Kontrastverstöße auf: gedämpfter Text erreichte auf
|
||||
dem sehr dunklen Untergrund nur 3,8 statt 4,5 zu 1. Statt an hundert Stellen die Klasse
|
||||
zu tauschen, sind die beiden gedämpften Stufen im Theme aufgehellt — der Abstand
|
||||
zwischen ihnen bleibt sichtbar.
|
||||
- **Barrierearm**: durchgehende ARIA-Labels, Escape schließt Dialoge, sichtbarer
|
||||
Fokusring, `prefers-reduced-motion` schaltet Animationen ab.
|
||||
- **Deutschsprachig**, Datums- und Zahlenformate in `de-DE` mit fester Zeitzone
|
||||
Europe/Berlin, damit Server- und Browser-Darstellung übereinstimmen.
|
||||
- **Als App installierbar.** Ein Web-Manifest mit eigenen Symbolen — auf dem Handy
|
||||
„Zum Startbildschirm hinzufügen“, danach läuft Nebula ohne Adressleiste. Die
|
||||
maskierbare Fassung hat mehr Rand, weil Android Symbole je nach Gerät rund, eckig
|
||||
oder als Tropfen zuschneidet.
|
||||
- **Änderungsverlauf** hinter der Versionsnummer in der Fußzeile: was neu ist, was besser
|
||||
wurde und welche Fehler behoben sind. Die Liste steht in `src/lib/changelog.ts` und ist
|
||||
die einzige Quelle — ein Test hält sie und `package.json` zusammen, weil genau diese
|
||||
beiden Angaben hier schon einmal auseinandergelaufen sind.
|
||||
|
||||
---
|
||||
|
||||
@@ -896,18 +239,11 @@ letzten Zustellung stehen an der Karte.
|
||||
| `Session` | Serverseitige Sitzungen (nur der Token-Hash) |
|
||||
| `Credential` | Passkeys inkl. öffentlichem Schlüssel und Signaturzähler |
|
||||
| `WebAuthnChallenge` | Kurzlebige, einmalig verwendbare Challenges |
|
||||
| `RecoveryCode` | Wiederherstellungscodes für die Zwei-Faktor-Anmeldung (nur der Hash) |
|
||||
| `PendingLogin` | Zwischenzustand zwischen Passwort und zweitem Faktor, fünf Minuten gültig |
|
||||
| `AppSettings` | Betriebsart und Registrierung (eine Zeile) |
|
||||
| `Project` | Projektstammdaten, Status, Fortschritt, Besitzer |
|
||||
| `Repository` | Repositories eines Projekts inkl. Abgleichstand (n:1 zu Projekt) |
|
||||
| `Task` | Aufgaben mit Spalte, Position, Fälligkeit, Labels, Wiederholung und Issue-Herkunft |
|
||||
| `ProjectTemplate` | Vorlagen je Konto: Stammdaten, Tags, Notizen und Aufgaben |
|
||||
| `Activity` | Verlauf je Projekt, neueste zuerst, auf 200 Einträge begrenzt |
|
||||
| `NotificationTarget` | Zustellwege je Konto, mit verschlüsseltem Geheimnis |
|
||||
| `Project` | Projektstammdaten, Status, Fortschritt, Repo-Verknüpfung, Besitzer |
|
||||
| `Note` | Notizen (n:1 zu Projekt, Cascade-Delete) |
|
||||
| `GitConnection` | Git-Systeme inkl. verschlüsseltem Token, Besitzer |
|
||||
| `RepoSnapshot` | Zwischengespeicherter Repo-Stand (1:1 zu Repository) |
|
||||
| `RepoSnapshot` | Zwischengespeicherter Repo-Stand (1:1 zu Projekt) |
|
||||
|
||||
`Project.ownerId` und `GitConnection.ownerId` sind bewusst optional: so überleben Daten aus
|
||||
der Zeit vor der Benutzerverwaltung die Migration und werden beim Anlegen des ersten Kontos
|
||||
@@ -936,16 +272,6 @@ nicht verloren gehen. Indizes auf Status, Verbindung und Änderungsdatum.
|
||||
`GIT_BLOCK_PRIVATE` und `GIT_ALLOWED_HOSTS`.
|
||||
- **Rate-Limiting** für Anmeldung (je IP und je Konto), ausgehende Git-Aufrufe und
|
||||
WebAuthn-Optionen.
|
||||
- **Sitzungen**: Zufallstoken mit 256 Bit, in der Datenbank nur als SHA-256-Hash — wer die
|
||||
Datenbank liest, kann keine Sitzung übernehmen. Geprüft wird bei jeder Anfrage, Abmelden
|
||||
und Sperren wirken also sofort. Zwei Fristen nach ASVS 3.3.2: **absolut** 30 Tage ab
|
||||
Anmeldung (`SESSION_TTL_DAYS`) und **im Leerlauf** 8 Stunden (`SESSION_IDLE_HOURS`).
|
||||
Ein Passwortwechsel entwertet alle Sitzungen und stellt für das eigene Gerät eine neue
|
||||
aus.
|
||||
- **Cookies**: `HttpOnly`, `SameSite=Strict`, `Secure` sobald die App über HTTPS läuft, und
|
||||
dann zusätzlich mit dem Präfix `__Host-`. Der Präfix lässt den Browser selbst erzwingen,
|
||||
dass kein `Domain` gesetzt ist — eine andere Subdomain kann den Cookie damit nicht
|
||||
überschreiben und keine Sitzung unterschieben.
|
||||
- Access Tokens verschlüsselt mit **AES-256-GCM**, Schlüssel per **scrypt** aus
|
||||
`APP_SECRET` abgeleitet, Chiffrat versioniert (`v1.<iv>.<tag>.<data>`).
|
||||
- Tokens werden nie an den Browser gesendet — alle API-Antworten nutzen eine Feldauswahl
|
||||
@@ -966,58 +292,7 @@ nicht verloren gehen. Indizes auf Status, Verbindung und Änderungsdatum.
|
||||
- **Setup-Skript** erzeugt die `.env` samt zufälligem `APP_SECRET`.
|
||||
- **Seed-Daten** auf Wunsch, idempotent — mehrfaches Ausführen legt nichts doppelt an.
|
||||
|
||||
### 6.4 Tests
|
||||
|
||||
Zwei Ebenen. `npm run test:all` führt beide aus.
|
||||
|
||||
**`npm test` — Unit-Tests** (Vitest, 56 Stück, unter einer Sekunde, ohne DOM und ohne
|
||||
Datenbank):
|
||||
|
||||
| Bereich | Was geprüft wird |
|
||||
| --- | --- |
|
||||
| `utils` | Slug-Erzeugung inklusive Umlauten und Längenbegrenzung, Tag-Aufbereitung, Kürzen, Zahlenformat |
|
||||
| `git/parse` | URL-Zerlegung für https, SSH, verschachtelte GitLab-Gruppen und Oberflächenpfade; Provider-Erkennung; Bildung der Aktivitätskurve |
|
||||
| `security/ssrf` | Sperrlisten für Loopback, Link-Local, Metadaten-Endpunkt, CGNAT und Multicast; Formprüfung; die drei Umgebungsschalter |
|
||||
| `auth/password` | scrypt-Rundlauf, unterschiedliches Salz, Ablageformat, Verhalten bei kaputten Hashes, Passwortregeln |
|
||||
| `tasks` | Berechnung des abgeleiteten Fortschritts, Spaltenreihenfolge |
|
||||
| `notify/pending` | Wann eine Benachrichtigung fällig ist: neuer Fehler ja, gleicher Fehler nein; CI-Wechsel nach rot; Release erst ab dem zweiten Abgleich |
|
||||
| `notify/stale` | Stillstandsschwelle, keine Zweitmeldung, aber erneute Meldung nach zwischenzeitlicher Aktivität |
|
||||
| `validation` | Dass jeder Anlass, den die Oberfläche anbietet, auch vom Schema akzeptiert wird — entstanden aus genau diesem Fehler |
|
||||
|
||||
**`npm run test:e2e` — Ende-zu-Ende** (Playwright, 13 Stück, rund 20 Sekunden). Läuft
|
||||
gegen die gebaute Anwendung mit eigener Datenbank auf Port 3111 — also durch Middleware,
|
||||
Authentifizierung, Validierung und Datenbank hindurch:
|
||||
|
||||
| Datei | Was geprüft wird |
|
||||
| --- | --- |
|
||||
| `e2e/api.spec.ts` | Einrichtung sperrt sich nach dem ersten Konto · kein Zugriff ohne Anmeldung · fremdes Origin und falscher Content-Type abgewiesen · SSRF geblockt · **Datentrennung zwischen zwei Konten** · Aufgaben-Reihenfolge, abgeleiteter Fortschritt und untergeschobene IDs · Export ohne Geheimnisse, Import je Strategie |
|
||||
| `e2e/ui.spec.ts` | Anmelden · Projekt anlegen · Aufgaben anlegen und **per Ziehen verschieben** (inklusive Prüfung nach dem Neuladen) · Volltextsuche · Abmelden sperrt geschützte Seiten wieder |
|
||||
|
||||
Zwei Dinge sind bewusst so gebaut:
|
||||
|
||||
- **Die Testdatenbank kann nicht die echte sein.** `e2e/global-setup.ts` bricht ab, wenn
|
||||
der Datenbankname nicht `test` enthält — vor dem `TRUNCATE`. Der teuerste denkbare
|
||||
Fehler wäre eine Testreihe, die die Produktivdaten leert.
|
||||
- **Playwright startet den Server selbst** (`webServer` in `playwright.config.ts`) mit
|
||||
eigener `DATABASE_URL` und eigenem Port. Eine laufende Instanz auf 3000 stört nicht.
|
||||
|
||||
Einmalig vorbereiten:
|
||||
|
||||
```bash
|
||||
docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_e2e_test"
|
||||
```
|
||||
|
||||
### 6.5 Fortlaufende Prüfung
|
||||
|
||||
`.gitea/workflows/ci.yml` prüft jeden Push und jeden Pull Request: Typen, Unit-Tests,
|
||||
Bau und Ende-zu-Ende-Tests gegen einen frischen PostgreSQL-Dienst. Schlägt etwas fehl,
|
||||
wird der Playwright-Bericht als Artefakt abgelegt.
|
||||
|
||||
Dafür müssen in der Gitea-Instanz Actions aktiviert sein (`app.ini`: `[actions] ENABLED
|
||||
= true`) und ein Runner registriert. Die Syntax ist GitHub-kompatibel — für GitHub die
|
||||
Datei nach `.github/workflows/` kopieren.
|
||||
|
||||
### 6.6 API
|
||||
### 6.4 API
|
||||
|
||||
Zehn REST-Endpunkte für Projekte, Notizen, Verbindungen, Sync, Repo-Listen und Health.
|
||||
Alles, was die Oberfläche kann, ist damit auch scriptbar. Übersicht in der
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
|
||||
|
||||
<div align="center">
|
||||
|
||||
# ✦ Nebula
|
||||
|
||||
**Das Kontrollzentrum für deine Vibe-Coding Projekte.**
|
||||
|
||||
Ideen festhalten · Status pflegen · Notizen sammeln · Git-Repos live im Blick
|
||||
|
||||
<sub>Next.js 15 · TypeScript · Tailwind CSS 4 · Prisma · PostgreSQL · Docker</sub>
|
||||
|
||||
</div>
|
||||
@@ -22,12 +22,6 @@ Jedes Projekt bekommt einen **Status** (von der rohen Idee bis „Fertig"), beli
|
||||
Branches, Tags, Commits, Releases und offene Issues/PRs — egal ob **GitHub**, **GitLab**
|
||||
oder eine selbst gehostete **Gitea**-Instanz.
|
||||
|
||||
Neben dem Projektbrett gibt es **Aufgaben über alle Projekte hinweg** (nach Fälligkeit
|
||||
geordnet), einen **Wochenrückblick** und eine **fortlaufende Zeitleiste** aus dem
|
||||
Aktivitätsverlauf. Aufgaben lassen sich als **Git-Issue** anlegen; wird das Issue
|
||||
geschlossen, hakt Nebula die Aufgabe ab — sofort per **Webhook** oder verzögert beim
|
||||
nächsten Abgleich.
|
||||
|
||||
Die Anmeldung läuft über **Benutzername und Passwort oder Passkey** (WebAuthn). Nebula
|
||||
kennt zwei Betriebsarten: **Einzelbetrieb** für ein Konto oder **Mehrbenutzerbetrieb**, in
|
||||
dem jede Person ihren eigenen, streng getrennten Bereich hat. Umschalten geht jederzeit in
|
||||
@@ -37,8 +31,7 @@ Alle Daten liegen in **deiner lokalen PostgreSQL**. Es gibt keinen Cloud-Dienst
|
||||
Access Tokens werden verschlüsselt abgelegt.
|
||||
|
||||
Eine vollständige Auflistung aller Funktionen steht in **[FEATURES.md](FEATURES.md)**,
|
||||
geplante Erweiterungen in **[ROADMAP.md](ROADMAP.md)**. Für den Dauerbetrieb auf einem
|
||||
Server — TLS, Firewall, Sicherungen und Updates — gibt es **[DEPLOYMENT.md](DEPLOYMENT.md)**.
|
||||
geplante Erweiterungen in **[ROADMAP.md](ROADMAP.md)**.
|
||||
|
||||
---
|
||||
|
||||
@@ -58,7 +51,7 @@ node scripts/setup.mjs # legt .env an und erzeugt ein zufälliges APP_SECRE
|
||||
Die App läuft nativ auf dem Rechner, nur PostgreSQL kommt aus dem Container:
|
||||
|
||||
```bash
|
||||
npm run docker:db # Postgres 17 auf 127.0.0.1:5432
|
||||
docker compose up -d db # Postgres 17 auf localhost:5432
|
||||
npm install
|
||||
npm run db:migrate # Schema anlegen
|
||||
npm run db:seed # optional: drei Beispielprojekte
|
||||
@@ -124,19 +117,16 @@ Alle Variablen sind in [`.env.example`](.env.example) dokumentiert.
|
||||
| `APP_URL` | Öffentliche Adresse — bestimmt die WebAuthn-RP-ID | `http://localhost:3000` |
|
||||
| `DATABASE_URL` | PostgreSQL-Verbindung (Prisma) | `postgresql://nebula:nebula@localhost:5432/nebula` |
|
||||
| `APP_SECRET` | Schlüssel für die Token-Verschlüsselung (AES-256-GCM) | — **unbedingt setzen** |
|
||||
| `SESSION_TTL_DAYS` | Absolute Lebensdauer einer Anmeldung in Tagen | `30` |
|
||||
| `SESSION_IDLE_HOURS` | Nach so vielen Stunden ohne Nutzung läuft die Sitzung ab (`0` = aus) | `8` |
|
||||
| `SESSION_TTL_DAYS` | Lebensdauer einer Anmeldung in Tagen | `30` |
|
||||
| `PORT` | Port der Anwendung | `3000` |
|
||||
| `APP_PORT` | Host-Port-Mapping des App-Containers | `127.0.0.1:3000` |
|
||||
| `APP_PORT` | Host-Port-Mapping des App-Containers | `3000` |
|
||||
| `POSTGRES_USER` / `POSTGRES_PASSWORD` / `POSTGRES_DB` | Zugangsdaten des DB-Containers | `nebula` |
|
||||
| `POSTGRES_PORT` | Host-Port der Datenbank — wirkt nur mit `docker-compose.dev.yml`, sonst hat die DB keinen | `127.0.0.1:5432` |
|
||||
| `ADMINER_PORT` | Host-Port von Adminer (`--profile tools`) | `127.0.0.1:8080` |
|
||||
| `GIT_API_TIMEOUT_MS` | Timeout für Git-API-Aufrufe, in Millisekunden. Alles unter 1000 oder Unlesbares wird verworfen (mit Warnung im Log) — sonst bräche jeder Aufruf sofort ab | `15000` |
|
||||
| `POSTGRES_PORT` | Host-Port der Datenbank | `5432` |
|
||||
| `ADMINER_PORT` | Host-Port von Adminer (`--profile tools`) | `8080` |
|
||||
| `GIT_API_TIMEOUT_MS` | Timeout für Git-API-Aufrufe | `15000` |
|
||||
| `GIT_ALLOW_LOOPBACK` | Git-Instanz auf demselben Rechner erlauben | `false` |
|
||||
| `GIT_BLOCK_PRIVATE` | Zugriff ins private LAN sperren | `false` |
|
||||
| `GIT_ALLOWED_HOSTS` | Strengster Modus: nur diese Hosts erlauben | leer |
|
||||
| `NOTIFY_TIMEOUT_MS` | Timeout beim Zustellen von Benachrichtigungen | `10000` |
|
||||
| `SMTP_HOST` … `SMTP_FROM` | SMTP-Zugang; ohne `SMTP_HOST` steht der Weg „E-Mail" nicht zur Verfügung | leer |
|
||||
|
||||
`APP_NAME`, `APP_TAGLINE` und `APP_URL` werden **zur Laufzeit** gelesen. Dasselbe
|
||||
Docker-Image lässt sich also ohne Neubau umbenennen oder unter einer anderen Adresse
|
||||
@@ -173,8 +163,14 @@ Nebula auffindbare Credentials nutzt.
|
||||
|
||||
## Git-Verbindung einrichten
|
||||
|
||||
1. Im Git-System einen **Personal Access Token** erzeugen — mit den Rechten aus dem
|
||||
Abschnitt [Welche Rechte der Token braucht](#welche-rechte-der-token-braucht).
|
||||
1. Im Git-System einen **Personal Access Token** mit Leserechten erzeugen:
|
||||
|
||||
| System | Scopes |
|
||||
| --- | --- |
|
||||
| GitHub | Fine-grained Token: *Contents: Read*, *Metadata: Read*, *Issues: Read*, *Pull requests: Read* |
|
||||
| GitLab | `read_api` (alternativ `read_repository`) |
|
||||
| Gitea / Forgejo | `repository:read`, `issue:read`, `user:read` |
|
||||
|
||||
2. In Nebula unter **Git-Verbindungen → Verbindung hinzufügen** eintragen:
|
||||
System wählen, Basis-URL (z. B. `https://git.meine-firma.de`, ohne `/api`) und Token.
|
||||
3. Mit **Testen** prüfen — Nebula meldet den erkannten Benutzer zurück.
|
||||
@@ -186,132 +182,6 @@ Nebula auffindbare Credentials nutzt.
|
||||
Der Snapshot bleibt in der Datenbank, das Dashboard funktioniert also auch offline.
|
||||
Ohne Token gehen nur öffentliche Repositories, mit strengem Rate-Limit.
|
||||
|
||||
### Welche Rechte der Token braucht
|
||||
|
||||
Nebula liest fast alles nur. Geschrieben wird an **genau zwei Stellen**: wenn du eine
|
||||
Aufgabe als Issue anlegst, und wenn eine Aufgabe auf `DONE` wandert und Nebula das
|
||||
verknüpfte Issue schließt. Alles andere sind `GET`-Aufrufe. Deshalb lohnt es, zwei Fälle
|
||||
zu unterscheiden:
|
||||
|
||||
**Fall A — nur Abgleich.** Branches, Tags, Commits, Releases, CI-Zustand, README,
|
||||
Heatmap, offene Issues und PRs anzeigen. Rein lesend.
|
||||
|
||||
**Fall B — zusätzlich die Issue-Anbindung.** Eine Aufgabe als Issue anlegen; wird das
|
||||
Issue geschlossen, hakt Nebula die Aufgabe ab und schließt sie umgekehrt mit.
|
||||
|
||||
| System | Fall A (nur lesen) | Fall B zusätzlich |
|
||||
| --- | --- | --- |
|
||||
| **GitHub** | Fine-grained Token: *Metadata: Read*, *Contents: Read*, *Issues: Read*, *Pull requests: Read*, *Actions: Read* | *Issues: **Read and write*** |
|
||||
| **GitLab** | `read_api` | `api` — **es gibt nichts dazwischen** |
|
||||
| **Gitea / Forgejo** | `read:repository`, `read:issue`, `read:user` | `write:issue` |
|
||||
|
||||
#### Jeder Aufruf einzeln
|
||||
|
||||
Die folgenden Tabellen sind vollständig: mehr als das ruft Nebula nicht nach draußen.
|
||||
Sie sind aus `src/lib/git/github.ts`, `gitlab.ts` und `gitea.ts` erhoben — wer prüfen
|
||||
will, ob hier etwas fehlt, greppt dort nach `getJson`, `getJsonSafe` und `sendJson`.
|
||||
|
||||
**GitHub** — `https://api.github.com`, Header `Authorization: Bearer …`
|
||||
|
||||
| Aufruf | Wofür | Benötigtes Recht |
|
||||
| --- | --- | --- |
|
||||
| `GET /rate_limit` | Verbindungstest | keins |
|
||||
| `GET /user` | Kontoname beim Testen zurückmelden | keins |
|
||||
| `GET /user/repos` | Auswahlliste hinter **Repos laden** | Metadata: Read |
|
||||
| `GET /repos/{o}/{r}` | Stammdaten, Default-Branch, Sichtbarkeit | Metadata: Read |
|
||||
| `GET …/languages` | Sprachverteilung | Metadata: Read |
|
||||
| `GET …/tags` | Tags | Metadata: Read |
|
||||
| `GET …/stats/commit_activity` | Commit-Heatmap über ein Jahr | Metadata: Read |
|
||||
| `GET …/branches` | Branch-Liste | Contents: Read |
|
||||
| `GET …/commits` | die letzten 100 Commits | Contents: Read |
|
||||
| `GET …/releases` | Releases | Contents: Read |
|
||||
| `GET …/readme` | README-Vorschau | Contents: Read |
|
||||
| `GET …/pulls?state=open` | offene Pull Requests | Pull requests: Read |
|
||||
| `GET …/issues?state=open` | offene Issues | Issues: Read |
|
||||
| `GET …/issues/{nr}` | Abgleich: ist das verknüpfte Issue noch offen? | Issues: Read |
|
||||
| `GET …/actions/runs` | CI-Zustand des Default-Branch | Actions: Read |
|
||||
| `POST …/issues` | **Aufgabe als Issue anlegen** | Issues: Read and write |
|
||||
| `PATCH …/issues/{nr}` | **Issue schließen oder wieder öffnen** | Issues: Read and write |
|
||||
|
||||
Dass `/tags` und `/stats/commit_activity` unter *Metadata* fallen und nicht unter
|
||||
*Contents*, ist nicht zu erraten — es steht so in
|
||||
[GitHubs Berechtigungsübersicht](https://docs.github.com/en/rest/authentication/permissions-required-for-fine-grained-personal-access-tokens).
|
||||
|
||||
**GitLab** — `{Basis-URL}/api/v4`, Header `PRIVATE-TOKEN: …`
|
||||
|
||||
| Aufruf | Wofür | Benötigtes Recht |
|
||||
| --- | --- | --- |
|
||||
| `GET /projects?per_page=1` | Verbindungstest | `read_api` |
|
||||
| `GET /user` | Kontoname beim Testen zurückmelden | `read_user` (in `read_api` enthalten) |
|
||||
| `GET /projects?membership=true` | Auswahlliste hinter **Repos laden** | `read_api` |
|
||||
| `GET /projects/{id}?statistics=true` | Stammdaten, Default-Branch, Sichtbarkeit | `read_api` |
|
||||
| `GET …/repository/branches` · `/tags` · `/commits` | Snapshot und Heatmap | `read_api` |
|
||||
| `GET …/repository/tree` · `/repository/files/{datei}` | README (zwei Aufrufe, GitLab hat keinen README-Endpunkt) | `read_api` |
|
||||
| `GET …/releases` · `/languages` | Releases, Sprachverteilung | `read_api` |
|
||||
| `GET …/merge_requests?state=opened` | offene Merge Requests | `read_api` |
|
||||
| `GET …/issues?state=opened` | offene Issues | `read_api` |
|
||||
| `GET …/issues/{nr}` | Abgleich: ist das verknüpfte Issue noch offen? | `read_api` |
|
||||
| `GET …/pipelines` | CI-Zustand des Default-Branch | `read_api` |
|
||||
| `POST …/issues` | **Aufgabe als Issue anlegen** | `api` |
|
||||
| `PUT …/issues/{nr}` (`state_event`) | **Issue schließen oder wieder öffnen** | `api` |
|
||||
|
||||
**Gitea / Forgejo** — `{Basis-URL}/api/v1`, Header `Authorization: token …`
|
||||
|
||||
| Aufruf | Wofür | Benötigtes Recht |
|
||||
| --- | --- | --- |
|
||||
| `GET /version` | Verbindungstest | keins — der Aufruf darf fehlschlagen, Nebula wertet ihn nur ergänzend aus |
|
||||
| `GET /user` | Kontoname beim Testen zurückmelden | `read:user` |
|
||||
| `GET /user/repos` bzw. `GET /repos/search` | Auswahlliste hinter **Repos laden** | `read:repository` |
|
||||
| `GET /repos/{o}/{r}` | Stammdaten, Default-Branch, Sichtbarkeit | `read:repository` |
|
||||
| `GET …/branches` · `/tags` · `/commits` · `/releases` · `/languages` | Snapshot und Heatmap | `read:repository` |
|
||||
| `GET …/contents` · `/contents/{datei}` | README (zwei Aufrufe, wie bei GitLab) | `read:repository` |
|
||||
| `GET …/commits/{branch}/status` | CI-Zustand des Default-Branch | `read:repository` |
|
||||
| `GET …/pulls?state=open` | offene Pull Requests | `read:repository` — Gitea zählt PRs zum Repository-Scope, nicht zu den Issues |
|
||||
| `GET …/issues?state=open&type=issues` | offene Issues | `read:issue` |
|
||||
| `GET …/issues/{nr}` | Abgleich: ist das verknüpfte Issue noch offen? | `read:issue` |
|
||||
| `POST …/issues` | **Aufgabe als Issue anlegen** | `write:issue` |
|
||||
| `PATCH …/issues/{nr}` | **Issue schließen oder wieder öffnen** | `write:issue` |
|
||||
|
||||
`write:issue` schließt `read:issue` mit ein — Gitea versteht `write:` als „lesen und
|
||||
schreiben". Beide anzuhaken schadet nicht, nötig ist es nicht.
|
||||
|
||||
#### Was Nebula nicht tut
|
||||
|
||||
- **Keine Kommentare.** Nebula schreibt nie einen Issue-Kommentar, weder beim Anlegen
|
||||
noch beim Schließen. Was im Rumpf des angelegten Issues steht, ist die
|
||||
Aufgabenbeschreibung plus eine Zeile Rückverweis — danach fasst Nebula den Text
|
||||
nicht mehr an.
|
||||
- **Kein Code.** Nichts wird committet, gepusht, gemergt oder getaggt. Nebula ist eine
|
||||
Übersicht, keine Entwicklungsumgebung.
|
||||
- **Keine Webhooks anlegen.** Den Haken trägst du selbst im Git-System ein — genau
|
||||
deshalb verlangt Nebula dafür keine Administrationsrechte.
|
||||
- **Keine Labels, keine Meilensteine, keine Zuweisungen.**
|
||||
- **Keine Adminrechte**, keine Organisations- oder Benutzerverwaltung.
|
||||
|
||||
Kommentare und Labels, die an einem Issue hängen, stammen also entweder aus der
|
||||
Weboberfläche deines Git-Systems oder von einem anderen Werkzeug mit eigenem Token —
|
||||
nicht von Nebula.
|
||||
|
||||
#### Der GitLab-Sonderfall
|
||||
|
||||
GitLab kennt keinen schmalen Schreib-Scope für Issues. Laut
|
||||
[Access token scopes](https://docs.gitlab.com/security/tokens/access_token_scopes/)
|
||||
gibt es nur `api` — „complete read and write access to the API" — und darunter direkt
|
||||
`read_api`. Wer bei GitLab Aufgaben als Issue anlegen will, vergibt damit ein Token, das
|
||||
auch Code ändern darf.
|
||||
|
||||
Wenn dir das zu weit geht: bleib bei `read_api` und verzichte auf die Issue-Anbindung.
|
||||
Der Abgleich läuft vollständig, und geschlossene Issues werden weiterhin erkannt und
|
||||
haken ihre Aufgabe ab — nur der Rückweg von Nebula ins Issue fällt weg. Ein eigenes
|
||||
Dienstkonto, das nur Zugriff auf die betroffenen Projekte hat, ist der andere Ausweg.
|
||||
|
||||
#### Im Zweifel klein anfangen
|
||||
|
||||
Ein fehlendes Recht führt zu einem `403` mit dem Hinweis „Token hat nicht die noetigen
|
||||
Scopes"; die Meldung steht am Repository auf der Projektseite. Fang mit Fall A an und
|
||||
leg gezielt nach, wenn du die Issue-Anbindung wirklich benutzt — statt vorsorglich
|
||||
alles zu vergeben.
|
||||
|
||||
### Automatisch statt auf Knopfdruck
|
||||
|
||||
Unter **Admin-Einstellungen → Automatischer Abgleich** lässt sich der Sync in den
|
||||
@@ -329,68 +199,10 @@ Wer lieber von außen taktet, lässt den Automatismus aus und ruft
|
||||
|
||||
---
|
||||
|
||||
## Export, Import und Sicherung
|
||||
|
||||
### Projekte mitnehmen
|
||||
|
||||
| Weg | Wo | Inhalt |
|
||||
| --- | --- | --- |
|
||||
| **Alle Projekte als JSON** | Dashboard → Datenbank-Symbol | Stammdaten, Notizen, Repo-Verknüpfung |
|
||||
| **Ein Projekt als JSON** | Projektseite → Download-Symbol | dasselbe, für ein Projekt |
|
||||
| **Ein Projekt als Markdown** | Projektseite → Download-Symbol | lesbar, inklusive letztem Git-Stand |
|
||||
| **Import** | Dashboard → Datenbank-Symbol | JSON einlesen, mit Vorschau |
|
||||
|
||||
**Access Tokens sind nie enthalten.** Die Git-Verbindung wird nur beschrieben (Name,
|
||||
System, Basis-URL); nach dem Import muss das Token neu hinterlegt werden. Verweist eine
|
||||
importierte Datei auf eine hier unbekannte Verbindung, wird das Projekt ohne Verknüpfung
|
||||
angelegt und in der Vorschau angezeigt.
|
||||
|
||||
Beim Import wird über den Slug abgeglichen. Für Treffer gibt es drei Strategien:
|
||||
|
||||
- **Überspringen** — Vorhandene bleiben unverändert
|
||||
- **Zusätzlich anlegen** — Kopie mit freiem Slug (`nebula` → `nebula-2`)
|
||||
- **Ersetzen** — Stammdaten überschreiben, Notizen austauschen
|
||||
|
||||
Vor dem Schreiben zeigt eine Vorschau, was passieren würde. Erst dann wird geschrieben.
|
||||
|
||||
### Sicherung
|
||||
|
||||
Zwei Wege, mit unterschiedlichem Zweck:
|
||||
|
||||
**JSON-Sicherung** (Admin-Einstellungen → Sicherung) enthält Einstellungen, Konten,
|
||||
Verbindungen, Projekte und Notizen. Gut zum Umziehen. Passwörter liegen als scrypt-Hash
|
||||
vor, Git-Tokens als Chiffrat — ohne dasselbe `APP_SECRET` sind sie wertlos. Trotzdem
|
||||
vertraulich behandeln.
|
||||
|
||||
**Datenbank-Sicherung** über `pg_dump` — das, was man zum Wiederherstellen einer kaputten
|
||||
Instanz braucht:
|
||||
|
||||
```powershell
|
||||
.\scripts\backup.ps1 # → .\backups\nebula-<datum>.sql
|
||||
.\scripts\restore.ps1 -File .\backups\nebula-....sql
|
||||
```
|
||||
|
||||
```bash
|
||||
./scripts/backup.sh # → ./backups/nebula-<datum>.sql
|
||||
./scripts/restore.sh backups/nebula-....sql
|
||||
```
|
||||
|
||||
Die Skripte lesen Benutzer und Datenbankname aus der `.env` und führen `pg_dump` im
|
||||
Container aus — auf dem Rechner selbst muss nichts installiert sein.
|
||||
|
||||
> Eine Sicherung ist erst dann eine Sicherung, wenn du sie einmal zurückgespielt hast.
|
||||
> Das geht ohne Risiko in eine Wegwerf-Datenbank:
|
||||
>
|
||||
> ```powershell
|
||||
> docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_test"
|
||||
> .\scripts\restore.ps1 -File .\backups\nebula-....sql -Database nebula_test -Force
|
||||
> ```
|
||||
|
||||
## Projektstruktur
|
||||
|
||||
```
|
||||
nebula/
|
||||
├── docs/banner.png Titelbild dieser Datei
|
||||
├── docker/entrypoint.sh Migrationen + Serverstart im Container
|
||||
├── docker-compose.yml db (immer) · app (--profile full) · adminer (--profile tools)
|
||||
├── Dockerfile Multi-Stage-Build auf Basis des Next-Standalone-Outputs
|
||||
@@ -402,25 +214,15 @@ nebula/
|
||||
└── src/
|
||||
├── app/
|
||||
│ ├── page.tsx Dashboard (Board, Filter, Kennzahlen)
|
||||
│ ├── projects/[id]/ Projektdetail: Beschreibung, Notizen, Aufgaben, Git
|
||||
│ ├── tasks/ Aufgaben über alle Projekte, nach Fälligkeit
|
||||
│ ├── rueckblick/ Wochenrückblick
|
||||
│ ├── verlauf/ Fortlaufende Zeitleiste
|
||||
│ ├── projects/[id]/ Projektdetail: Beschreibung, Notizen, Git
|
||||
│ ├── connections/ Verwaltung der Git-Verbindungen
|
||||
│ ├── account/ admin/ Eigenes Konto · Adminbereich
|
||||
│ └── api/ REST-Endpunkte (siehe Abschnitt „API")
|
||||
│ └── api/ REST-Endpunkte (Projekte, Notizen, Verbindungen, Sync)
|
||||
├── components/ UI-Komponenten (Board, Karten, Panels, Dialoge)
|
||||
├── lib/
|
||||
│ ├── auth/ Sitzungen, Passwörter, TOTP, WebAuthn, Zugriffsschutz
|
||||
│ ├── crypto.ts AES-256-GCM für Access Tokens
|
||||
│ ├── db.ts Prisma-Client
|
||||
│ ├── git/ Provider-Adapter: github.ts · gitlab.ts · gitea.ts
|
||||
│ ├── sync/ Repo-Snapshot holen, speichern, Zeitgeber
|
||||
│ ├── tasks/ Aufgabenlogik, Brücke zu Git-Issues
|
||||
│ ├── webhooks/ Signaturprüfung eingehender Webhooks
|
||||
│ ├── review.ts Wochengrenzen und Kennzahlen
|
||||
│ ├── timeline.ts Cursor-Blättern für den Verlauf
|
||||
│ ├── security/ SSRF-Schutz, Ratenbegrenzung, Body-Prüfung
|
||||
│ ├── sync.ts Repo-Snapshot holen und speichern
|
||||
│ └── validation.ts Zod-Schemas für alle Eingaben
|
||||
└── types/ gemeinsame Typen für Server und Client
|
||||
```
|
||||
@@ -439,13 +241,8 @@ nebula/
|
||||
| `npm run db:seed` | Beispielprojekte anlegen |
|
||||
| `npm run db:studio` | Prisma Studio öffnen |
|
||||
| `npm run db:reset` | Datenbank zurücksetzen (**löscht alles**) |
|
||||
| `npm test` | Unit-Tests (Vitest), unter einer Sekunde |
|
||||
| `npm run test:watch` | Tests im Beobachtungsmodus |
|
||||
| `npm run typecheck` | TypeScript prüfen |
|
||||
| `npm test` | Unit-Tests (Vitest, ohne Datenbank) |
|
||||
| `npm run test:e2e` | Ende-zu-Ende-Tests (Playwright, baut vorher) |
|
||||
| `npm run test:all` | Beides nacheinander |
|
||||
| `npm run docker:db` | Nur die Datenbank starten, mit Host-Port für `npm run dev` |
|
||||
| `npm run docker:db` | Nur die Datenbank starten |
|
||||
| `npm run docker:up` / `docker:down` | Kompletten Stack starten / stoppen |
|
||||
| `npm run docker:tools` | Adminer auf `http://localhost:8080` |
|
||||
|
||||
@@ -463,47 +260,19 @@ ausschließlich Daten des angemeldeten Kontos.
|
||||
| `GET` | `/api/health` | Status inkl. Datenbankverbindung (Docker-Healthcheck) |
|
||||
| `POST` | `/api/auth/setup` | Administratorkonto anlegen (nur beim ersten Mal) |
|
||||
| `POST` | `/api/auth/login` `/api/auth/logout` `/api/auth/register` | Anmeldung |
|
||||
| `POST` | `/api/auth/mfa` | Zweiter Faktor: Einmalkennwort oder Wiederherstellungscode |
|
||||
| `GET` | `/api/auth/session` | Aktuelle Sitzung und Instanzzustand |
|
||||
| `POST` | `/api/auth/passkey/{login,register}/{options,verify}` | WebAuthn |
|
||||
| `PATCH` | `/api/account/profile` | Eigenes Profil |
|
||||
| `POST` | `/api/account/password` | Eigenes Passwort setzen |
|
||||
| `GET` `DELETE` | `/api/account/sessions` | Eigene Sitzungen / überall abmelden |
|
||||
| `PATCH` `DELETE` | `/api/account/passkeys/:id` | Passkey umbenennen / entfernen |
|
||||
| `GET` `POST` `PUT` `DELETE` | `/api/account/totp` | Zwei-Faktor: Zustand, einrichten, aktivieren, abschalten |
|
||||
| `POST` | `/api/account/totp/recovery` | Neue Wiederherstellungscodes |
|
||||
| `GET` `PATCH` | `/api/admin/settings` | Betriebsart, Registrierung, Abgleich (Admin) |
|
||||
| `POST` | `/api/admin/sync/run` | Abgleich sofort anstoßen (Admin) |
|
||||
| `GET` `POST` | `/api/admin/users` | Konten auflisten / anlegen (Admin) |
|
||||
| `PATCH` `DELETE` | `/api/admin/users/:id` | Konto ändern / löschen (Admin) |
|
||||
| `GET` `POST` | `/api/projects` | Projekte auflisten / anlegen |
|
||||
| `GET` | `/api/projects/export` | Alle eigenen Projekte als JSON |
|
||||
| `GET` | `/api/projects/:id/export` | Ein Projekt (`?format=md` für Markdown) |
|
||||
| `POST` | `/api/projects/import` | Import, mit `dryRun` für die Vorschau |
|
||||
| `GET` `POST` | `/api/templates` | Projektvorlagen auflisten / anlegen |
|
||||
| `PATCH` `DELETE` | `/api/templates/:id` | Vorlage ändern / löschen |
|
||||
| `POST` | `/api/templates/from-project` | Aus einem Projekt eine Vorlage machen |
|
||||
| `GET` | `/api/admin/backup` | Vollständige Sicherung als JSON (Admin) |
|
||||
| `GET` | `/api/search?q=` | Volltextsuche über eigene Notizen **und Aufgaben** |
|
||||
| `GET` | `/api/activity` | Verlauf über alle Projekte, per Cursor (`?vor=&id=&limit=`) |
|
||||
| `GET` `POST` | `/api/notifications` | Benachrichtigungsziele |
|
||||
| `PATCH` `DELETE` | `/api/notifications/:id` | Ziel ändern / entfernen |
|
||||
| `POST` | `/api/notifications/:id/test` | Testnachricht senden |
|
||||
| `GET` `PATCH` `DELETE` | `/api/projects/:id` | Projekt lesen / ändern / löschen |
|
||||
| `POST` | `/api/projects/:id/sync` | Alle Repositories des Projekts abgleichen |
|
||||
| `PATCH` | `/api/projects/reorder` | Neue Reihenfolge im Brett |
|
||||
| `POST` | `/api/projects/bulk` | Status, Tags oder Löschen für mehrere |
|
||||
| `GET` | `/api/projects/:id/activity` | Verlauf des Projekts (`?limit=`) |
|
||||
| `GET` `POST` | `/api/projects/:id/repositories` | Repositories des Projekts |
|
||||
| `PATCH` `DELETE` | `/api/repositories/:id` | Repository ändern / vom Projekt lösen |
|
||||
| `POST` | `/api/repositories/:id/sync` | Ein einzelnes Repository abgleichen |
|
||||
| `POST` `DELETE` | `/api/repositories/:id/webhook` | Webhook einrichten / zurücknehmen |
|
||||
| `POST` | `/api/webhooks/:repositoryId` | **Eingehend** von GitHub/GitLab/Gitea, per Signatur geprüft |
|
||||
| `GET` `POST` | `/api/projects/:id/tasks` | Aufgaben des Projekts |
|
||||
| `PATCH` | `/api/projects/:id/tasks/reorder` | Neue Reihenfolge nach dem Ziehen |
|
||||
| `POST` | `/api/projects/:id/tasks/from-issues` | Offene Issues als Aufgaben übernehmen |
|
||||
| `PATCH` `DELETE` | `/api/tasks/:id` | Aufgabe ändern / löschen |
|
||||
| `POST` | `/api/tasks/:id/issue` | Aufgabe als Issue im verknüpften Repository anlegen |
|
||||
| `POST` | `/api/projects/:id/sync` | Repo-Daten vom Git-System holen |
|
||||
| `GET` `POST` | `/api/projects/:id/notes` | Notizen des Projekts |
|
||||
| `PATCH` `DELETE` | `/api/notes/:id` | Notiz ändern / löschen |
|
||||
| `GET` `POST` | `/api/connections` | Git-Verbindungen |
|
||||
@@ -558,7 +327,7 @@ Grenzen, die du kennen solltest:
|
||||
|
||||
| Symptom | Ursache / Lösung |
|
||||
| --- | --- |
|
||||
| `Can't reach database server` | Läuft `npm run docker:db`? Ein blosses `docker compose up -d db` startet die DB **ohne Host-Port** — dann ist sie von `npm run dev` aus nicht erreichbar. Stimmt `DATABASE_URL`? |
|
||||
| `Can't reach database server` | Läuft `docker compose up -d db`? Stimmt `DATABASE_URL`? |
|
||||
| `The table ... does not exist` | Migrationen fehlen: `npm run db:migrate` |
|
||||
| Sync meldet `401` | Token abgelaufen oder falsche Scopes — unter Git-Verbindungen neu setzen |
|
||||
| Sync meldet `404` | Owner/Repo prüfen; bei GitLab gehört die volle Gruppenkette in „Owner" |
|
||||
@@ -575,21 +344,17 @@ Grenzen, die du kennen solltest:
|
||||
|
||||
## Getestet mit
|
||||
|
||||
Am 25.07.2026 gegen echte Systeme verifiziert — beide Betriebsarten, alle drei
|
||||
Git-Adapter (GitHub, GitLab und Gitea jeweils gegen die öffentliche Instanz). Seitdem
|
||||
laufen die Ende-zu-Ende-Tests bei jeder Änderung mit; live nach draußen geht davon nur
|
||||
ein Test gegen die GitHub-API.
|
||||
|
||||
Werkzeugstand vom 18.08.2026:
|
||||
Stand 25.07.2026 gegen echte Systeme verifiziert — beide Betriebsarten, alle drei
|
||||
Git-Adapter (GitHub, GitLab und Gitea jeweils gegen die öffentliche Instanz).
|
||||
|
||||
| | Version |
|
||||
| --- | --- |
|
||||
| Node.js | 24.19.0 |
|
||||
| Node.js | 26.5.0 |
|
||||
| npm | 11.17.0 |
|
||||
| Next.js | 15.5.21 |
|
||||
| Prisma | 6.19.3 |
|
||||
| PostgreSQL | 17.11 (Alpine) |
|
||||
| Docker | 29.7.2 |
|
||||
| PostgreSQL | 17 (Alpine) |
|
||||
| Docker / Compose | 29.6.2 / v5.3.1 |
|
||||
|
||||
---
|
||||
|
||||
|
||||
+108
-117
@@ -7,120 +7,145 @@ Stück für Stück abarbeiten. Reihenfolge ist ein Vorschlag, keine Festlegung.
|
||||
|
||||
Was bereits steht, listet [FEATURES.md](FEATURES.md).
|
||||
|
||||
**Stand:** v1.11.0. Alle Issues aus dem Dashboard sind abgearbeitet.
|
||||
|
||||
---
|
||||
|
||||
## 1 · Als Nächstes empfohlen
|
||||
|
||||
### 1.1 Persönliche API-Token `M`
|
||||
### 1.1 Export und Import `M`
|
||||
|
||||
Der letzte offene Teil aus v1.6.0 („unterwegs erfassen"). Derzeit geht die
|
||||
API nur mit Sitzungscookie. Ein Token je Konto würde `curl`-Aufrufe und
|
||||
Handy-Shortcuts erlauben — eine Idee aus dem Terminal anlegen, ohne den
|
||||
Browser zu öffnen. Nur der Hash in der Datenbank, wie bei den Sitzungen.
|
||||
Dein Vorschlag, in vier Stufen — jede für sich nutzbar:
|
||||
|
||||
Bewusst noch nicht angefasst, weil sicherheitsrelevant: Geltungsbereich,
|
||||
Widerruf und Ablauf wollen entschieden sein, nicht nebenbei gebaut.
|
||||
| Stufe | Inhalt |
|
||||
| --- | --- |
|
||||
| **Projekt-Export** | Ein Projekt oder alle als JSON: Stammdaten, Notizen, Repo-Verknüpfung. Ein Klick auf der Projektseite, einer im Dashboard für alles. |
|
||||
| **Projekt-Import** | JSON hochladen, Vorschau, dann übernehmen. Konfliktstrategie wählbar: überspringen · umbenennen · überschreiben. |
|
||||
| **Markdown-Export** | Ein Projekt als lesbares `.md` — Beschreibung, Notizen, aktueller Git-Stand. Gut zum Archivieren oder für ein README. |
|
||||
| **Voll-Backup** | `pg_dump` aus dem Container heraus, per Knopf im Adminbereich als Datei. Plus dokumentierter Rückweg. |
|
||||
|
||||
### 1.2 Läuft es noch? `M`
|
||||
**Offene Fragen, die wir klären sollten:**
|
||||
- **Git-Tokens mitexportieren?** Mein Vorschlag: **nein**. Die Verbindung wird
|
||||
mitexportiert (Name, System, Basis-URL), das Token muss beim Import neu
|
||||
hinterlegt werden. Ein Export-JSON landet sonst schnell irgendwo, wo es
|
||||
nicht hingehört.
|
||||
- **Reichweite:** Export der eigenen Daten für jeden — Voll-Backup nur für
|
||||
Administratoren?
|
||||
- **Snapshots mitnehmen?** Ich würde sie weglassen: sie sind reproduzierbar
|
||||
und blähen die Datei auf. Ein Sync nach dem Import holt sie zurück.
|
||||
|
||||
Eine Health-Check-URL je Projekt, die der Zeitgeber regelmäßig anpingt.
|
||||
Nebula wüsste dann, ob ein Projekt nicht nur existiert, sondern auch läuft.
|
||||
Nutzt Zeitgeber und Benachrichtigungen, die es schon gibt. Der SSRF-Schutz
|
||||
greift dabei wie bei den Git-Aufrufen.
|
||||
### 1.2 Markdown in Beschreibung und Notizen `S`
|
||||
|
||||
### 1.3 Aufgaben ↔ Issues: der Rest `S`
|
||||
Heute wird alles als reiner Text dargestellt. Mit Markdown werden aus
|
||||
`- [ ] Aufgabe` echte Checklisten, Codeblöcke bekommen Hervorhebung, Links
|
||||
werden klickbar.
|
||||
|
||||
Beide Richtungen stehen — „als Issue anlegen" seit v1.7.0, der Rückweg über
|
||||
Webhook (v1.7.0) und zusätzlich über den Abgleich (v1.9.0). Offen ist
|
||||
Kleinkram:
|
||||
Zu beachten: HTML muss beim Rendern entfernt werden, sonst reißt es ein
|
||||
XSS-Loch. Mit `react-markdown` plus `rehype-sanitize` ist das sauber lösbar.
|
||||
|
||||
- **Mehrere Repositories.** Der Knopf nimmt immer das führende. Bei einem
|
||||
Projekt aus Frontend und Backend fehlt die Wahl.
|
||||
- **Webhook beim Verknüpfen anbieten.** Er ist getrennt einzurichten, und
|
||||
wer das nicht tut, merkt nur an der Verzögerung, dass etwas fehlt. Ein
|
||||
Hinweis an der richtigen Stelle würde reichen.
|
||||
### 1.3 Volltextsuche über Notizen `S`
|
||||
|
||||
Was **nicht** kommt, bleibt wie besprochen: eine echte beidseitige
|
||||
Synchronisation mit Konfliktauflösung. Die Zustände passen ohnehin nicht
|
||||
aufeinander — ein Issue kennt nur offen und geschlossen, `DOING` und
|
||||
`BLOCKED` gehen im Rundlauf verloren. Das ist hingenommen, statt den
|
||||
Issue-Tracker mit Labels zu füllen, die dort niemand pflegt.
|
||||
Die Suche im Board deckt Namen, Kurzbeschreibung und Tags ab — Notizen nicht.
|
||||
Postgres kann das nativ (`tsvector` mit deutscher Konfiguration), also ohne
|
||||
zusätzlichen Dienst.
|
||||
|
||||
### 1.4 Kanban-Board mit Drag & Drop `M`
|
||||
|
||||
Die gruppierte Ansicht gibt es schon, aber Statuswechsel geht nur über das
|
||||
Menü. Spalten mit Ziehen und Ablegen wären der natürlichere Weg.
|
||||
|
||||
Bibliothek: `@dnd-kit` — leichtgewichtig, tastaturbedienbar. Auf Mobilgeräten
|
||||
bleibt die Listenansicht.
|
||||
|
||||
---
|
||||
|
||||
## 2 · Größere Brocken
|
||||
## 2 · Danach
|
||||
|
||||
### 2.1 Passwort-Zurücksetzen per E-Mail `M`
|
||||
### 2.1 Offene Pull Requests und Issues als Liste `S`
|
||||
|
||||
Aktuell werden sie nur gezählt. Titel, Autor, Alter und Link wären deutlich
|
||||
nützlicher — die Daten holen wir ohnehin schon ab.
|
||||
|
||||
### 2.2 CI-Status je Branch `M`
|
||||
|
||||
Grün oder rot direkt an der Projektkarte, gespeist aus GitHub Actions,
|
||||
GitLab Pipelines und Gitea Actions. Erfordert je Provider einen weiteren
|
||||
Endpunkt und einen zusätzlichen Token-Scope.
|
||||
|
||||
### 2.3 Webhooks statt Polling `M`
|
||||
|
||||
Ein Push aktualisiert den Snapshot sofort, statt bis zum nächsten Durchlauf
|
||||
zu warten. Braucht einen öffentlich erreichbaren Endpunkt mit
|
||||
Signaturprüfung je Provider — sinnvoll erst, wenn die Instanz von außen
|
||||
erreichbar ist. Der Zeitplan bleibt als Rückfalllösung.
|
||||
|
||||
### 2.4 Commit-Aktivität als Verlauf `S`
|
||||
|
||||
Kleine Sparkline auf der Karte, Heatmap auf der Projektseite. Datenbasis ist
|
||||
da, es fehlt nur die Darstellung.
|
||||
|
||||
### 2.5 Aufgaben und Checklisten `M`
|
||||
|
||||
Eigene Entität statt Freitext-Notiz, mit Häkchen und automatisch
|
||||
berechnetem Fortschritt. Ersetzt das manuelle Schieben des Reglers.
|
||||
|
||||
### 2.6 Benachrichtigungen `M`
|
||||
|
||||
Bei Sync-Fehlern, neuen Releases oder Projekten, die lange stillstehen.
|
||||
Kanäle: E-Mail (SMTP), ntfy, generischer Webhook. Zusammen mit dem
|
||||
automatischen Abgleich ergibt das ein brauchbares Frühwarnsystem.
|
||||
|
||||
---
|
||||
|
||||
## 3 · Größere Brocken
|
||||
|
||||
### 3.1 Automatisierte Tests und CI `L`
|
||||
|
||||
Aktuell prüfe ich jede Änderung von Hand — Typecheck, Build, API-Durchläufe,
|
||||
Browser-Screenshots. Das gehört in eine Pipeline:
|
||||
|
||||
- **Vitest** für die Logik: URL-Parsing, SSRF-Regeln, Passwort-Hashing,
|
||||
Backoff-Berechnung
|
||||
- **Playwright** für die Wege durch die App: Einrichtung, Anmeldung,
|
||||
Datentrennung
|
||||
- **GitHub Actions** oder Gitea Actions, je nachdem wohin du das Repo legst
|
||||
|
||||
Aus meiner Sicht der wertvollste Punkt der ganzen Liste, sobald das Projekt
|
||||
länger lebt: er macht alles Weitere billiger und sicherer.
|
||||
|
||||
### 3.2 Mehrere Repositories je Projekt `M`
|
||||
|
||||
Frontend und Backend getrennt, aber ein Projekt. Erfordert eine Zwischentabelle
|
||||
und Anpassungen in der Anzeige.
|
||||
|
||||
### 3.3 Zwei-Faktor per TOTP `M`
|
||||
|
||||
Als Alternative zum Passkey — nützlich, wenn die Instanz aus dem Internet
|
||||
erreichbar ist und nicht jedes Gerät Passkeys kann.
|
||||
|
||||
### 3.4 Passwort-Zurücksetzen per E-Mail `M`
|
||||
|
||||
Heute setzt ein Administrator das Passwort neu. Selbstbedienung braucht SMTP
|
||||
und damit eine weitere Konfiguration — lohnt erst im Mehrbenutzerbetrieb.
|
||||
|
||||
### 2.2 Mehrsprachigkeit `L`
|
||||
### 3.5 Mehrsprachigkeit `L`
|
||||
|
||||
Die Oberfläche ist durchgängig deutsch verdrahtet. Englisch dazu wäre eine
|
||||
Voraussetzung, falls du das Projekt veröffentlichen willst.
|
||||
|
||||
---
|
||||
|
||||
## 3 · Aufgefallen beim Bauen
|
||||
|
||||
Beobachtungen aus der Arbeit an v1.6.0 bis v1.11.0 — festgehalten, damit sie
|
||||
nicht verloren gehen. Nichts davon ist dringend.
|
||||
|
||||
### 3.1 Anwendungsname bricht in der Kopfleiste ab `S`
|
||||
|
||||
Zwischen 320 und 375 px wird aus „Nebula" ein „Neb…". Gemessen über fünf
|
||||
Breiten und zwei Seiten: betrifft alle Seiten gleichermaßen. Seit die
|
||||
Aufgaben als dritter Punkt danebenstehen, ist es enger geworden.
|
||||
|
||||
### 3.2 Indizes für die projektübergreifenden Seiten `S`
|
||||
|
||||
Weder `Task` noch `Activity` haben einen Besitzer — die Trennung läuft über
|
||||
`project: { ownerId }`. Die vorhandenen Indizes
|
||||
(`[projectId, status, position]` bzw. `[projectId, createdAt]`) greifen für
|
||||
Abfragen über alle Projekte deshalb nicht.
|
||||
|
||||
Betroffen sind inzwischen vier Seiten: Aufgabenübersicht, Wochenrückblick,
|
||||
Zeitleiste und die Volltextsuche. Bei einigen hundert Datensätzen fällt das
|
||||
nicht auf. Wird eine der Seiten träge, sind Indizes auf `Task.dueDate` und
|
||||
`Activity.createdAt` der erste Griff — und dann eine Migration wert.
|
||||
|
||||
### 3.3 Projektfilter auf der Zeitleiste `S`
|
||||
|
||||
Über alle Projekte wird die Liste schnell lang. Der Wochenrückblick hat
|
||||
Wochengrenzen als natürliche Bremse, die Zeitleiste nicht. Bewusst
|
||||
weggelassen, weil das Issue nur „derselbe Verlauf, projektübergreifend"
|
||||
verlangte.
|
||||
|
||||
### 3.4 Abgleich gegen geleakte Passwörter `M`
|
||||
|
||||
ASVS 2.1.7 verlangt es; umgesetzt ist bisher nur eine lokale Sperrliste plus
|
||||
Mustererkennung (Wiederholungen, Zeichenfolgen, Benutzername im Passwort).
|
||||
Have-I-Been-Pwned scheidet aus — Nebula ruft grundsätzlich nichts von außen,
|
||||
und ein Passwort-Präfix nach draußen zu geben widerspräche dem erst recht.
|
||||
Eine lokale Top-10000-Liste als Datei wäre der Kompromiss.
|
||||
|
||||
### 3.5 v0.2.0 und v0.3.0 ohne Release `S`
|
||||
|
||||
Beide stehen im Änderungsverlauf, existierten aber nie in der
|
||||
`package.json` — dort springt die Historie von 0.1.0 auf 0.4.0. Nachgetragen
|
||||
wurden sie in dem Commit, der den Verlauf einführte, und der liegt *nach*
|
||||
0.4.0. Es gibt also keinen ehrlichen Commit, an dem ein Tag hängen könnte.
|
||||
Die übrigen 20 Fassungen haben seit dem 18.08.2026 ein Release in Gitea.
|
||||
|
||||
---
|
||||
|
||||
## 4 · Kleinigkeiten
|
||||
|
||||
| Idee | Aufwand | Nutzen |
|
||||
| --- | --- | --- |
|
||||
| Suchtreffer in Notizen hervorheben | `S` | In der Notiz selbst, nicht nur in der Trefferliste |
|
||||
| Aufgabe ↔ Commit verknüpfen | `M` | Enthält ein Commit `#5`, wird die übernommene Aufgabe verlinkt — fällt weitgehend mit 1.3 ab |
|
||||
| Tastaturkürzel-Übersicht mit `?` | `S` | Es gibt inzwischen genug davon |
|
||||
| Schnellsuche per `Strg+K` | `S` | Springt direkt zu Projekt oder Aktion |
|
||||
| Mehrfachauswahl im Board | `S` | Status oder Tags für mehrere auf einmal |
|
||||
| Aktivitätsverlauf je Projekt | `S` | Wer hat wann was geändert |
|
||||
| Projektvorlagen | `S` | Neues Projekt mit vorgefüllten Tags und Notizen |
|
||||
| Hell/Dunkel umschaltbar | `M` | Aktuell nur dunkel |
|
||||
| Eigenes Logo und Farbe | `S` | Ergänzt `APP_NAME` |
|
||||
| PWA-Manifest | `S` | Auf dem Handy als App installierbar |
|
||||
| Barrierefreiheits-Durchsicht | `M` | Fokusreihenfolge, Screenreader, Kontraste |
|
||||
| `prisma.config.ts` | `S` | Beseitigt die Deprecation-Warnung vor Prisma 7 |
|
||||
| Audit-Log für Adminaktionen | `M` | Nachvollziehbar, wer Konten geändert hat |
|
||||
|
||||
---
|
||||
@@ -132,16 +157,8 @@ Damit klar ist, was **nicht** kommt und warum:
|
||||
- **Geteilte Projekte zwischen Konten.** Die Trennung ist derzeit hart und
|
||||
einfach zu prüfen. Freigaben bringen eine Rechteverwaltung mit sich — nur
|
||||
sinnvoll, wenn wirklich mehrere Leute zusammenarbeiten.
|
||||
- **Veraltete Abhängigkeiten prüfen.** Klingt verlockend, aber Renovate und
|
||||
Dependabot machen das besser, und es wären viele Aufrufe an fremde
|
||||
Registries — für eine Zahl, die im Repo selbst schon steht.
|
||||
- **Anhänge an Notizen.** Bräuchte Dateispeicher und damit eine zweite Sorge
|
||||
bei jeder Sicherung. Ein Link ins Git tut es auch.
|
||||
- **Eigene Git-Operationen** (klonen, committen, pushen). Nebula ist eine
|
||||
Übersicht, keine Entwicklungsumgebung. Issues über die HTTP-API der
|
||||
Provider sind davon nicht berührt — die gibt es seit v1.7.0.
|
||||
- **Beidseitige Synchronisation von Aufgaben und Issues** mit
|
||||
Konfliktauflösung — siehe 1.3.
|
||||
Übersicht, keine Entwicklungsumgebung.
|
||||
- **Zeiterfassung, Rechnungen, Kundenverwaltung.** Andere Baustelle.
|
||||
- **Cloud-Synchronisation.** Die Daten bleiben in deiner Datenbank; das ist
|
||||
der Punkt.
|
||||
@@ -159,29 +176,3 @@ Damit klar ist, was **nicht** kommt und warum:
|
||||
| Härtung: CSRF, CSP, SSRF, Ratenbegrenzung, Datentrennung | ✓ |
|
||||
| Docker- und Standalone-Betrieb | ✓ |
|
||||
| Automatischer Abgleich mit Zeitplan | ✓ |
|
||||
| Export, Import und Sicherung | ✓ |
|
||||
| **v0.3.0** Markdown, Volltextsuche über Notizen, PR- und Issue-Listen, Testfundament | ✓ |
|
||||
| **v0.4.0** Kanban mit Drag & Drop, CI-Status je Branch, Commit-Aktivität | ✓ |
|
||||
| **v0.5.0** Aufgabenbrett je Projekt mit sortierbaren Spalten, Fortschritt aus Aufgaben | ✓ |
|
||||
| **v0.6.0** Ende-zu-Ende-Tests mit Playwright, CI-Pipeline für Gitea Actions | ✓ |
|
||||
| **v0.7.0** Benachrichtigungen über ntfy, Webhook und E-Mail | ✓ |
|
||||
| **v0.8.0** Stillstehende Projekte melden, Schwelle im Adminbereich | ✓ |
|
||||
| **v0.9.0** Schnellsuche per `Strg+K`, Aufgaben aus Git-Issues | ✓ |
|
||||
| **v1.0.0** Aktivitätsverlauf je Projekt, Zwei-Faktor per TOTP, mehrere Repositories je Projekt | ✓ |
|
||||
| **v1.1.0** Freie Reihenfolge im Brett, Mehrfachauswahl, installierbar als App, Änderungsverlauf | ✓ |
|
||||
| **v1.2.0** Commit-Heatmap über ein Jahr, Projektvorlagen | ✓ |
|
||||
| **v1.3.0** Wiederkehrende Aufgaben, Barrierefreiheit nach WCAG 2.1 AA | ✓ |
|
||||
| **v1.4.0** README-Vorschau auf der Projektseite | ✓ |
|
||||
| **v1.5.0** Sicherheitsdurchsicht, Server-Anleitung und Update-Skript | ✓ |
|
||||
| **v1.6.0** Mobile Ansicht, Listenansicht, Schnellerfassung, Aufgaben über alle Projekte | ✓ |
|
||||
| **v1.7.0** Aufgabe als Git-Issue anlegen, Webhooks für Push und Issues | ✓ |
|
||||
| **v1.8.0** Anmeldung und Sitzungen nach OWASP: scrypt-Aufwand, Aufzählbarkeit, Leerlauffrist, Cookie-Härtung | ✓ |
|
||||
| **v1.9.0** Geschlossene Issues haken ihre Aufgabe auch ohne Webhook ab | ✓ |
|
||||
| **v1.10.0** Wochenrückblick, globale Zeitleiste, Suche über Aufgaben | ✓ |
|
||||
| **v1.10.1** Issue-Kennzeichen auf der Aufgabenkarte, Token-Rechte Aufruf für Aufruf belegt | ✓ |
|
||||
| **v1.11.0** Karten je Spalte begrenzen; der Abgleich verschluckt keine Fehler mehr und verliert dabei nichts | ✓ |
|
||||
|
||||
Zur Entscheidung beim Export: Git-Tokens gehen **nicht** mit. Die Verbindung wird nur
|
||||
beschrieben, das Token ist nach dem Import neu zu hinterlegen. Snapshots bleiben
|
||||
ebenfalls draußen — sie sind reproduzierbar. Der Projekt-Export steht jedem Konto für
|
||||
seine eigenen Daten offen, die Voll-Sicherung nur Administratoren.
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
# Overlay fuer die Entwicklung: macht die Datenbank auf dem Host erreichbar.
|
||||
#
|
||||
# Gebraucht wird das nur, wenn die Anwendung ausserhalb des Containers
|
||||
# laeuft – "npm run dev" verbindet sich dann ueber localhost:5432. Im
|
||||
# Vollbetrieb spricht die Anwendung "db:5432" im Docker-Netz an und braucht
|
||||
# diese Datei nicht.
|
||||
#
|
||||
# Aufruf:
|
||||
# docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d db
|
||||
# npm run dev
|
||||
#
|
||||
# Kuerzer: npm run docker:db
|
||||
#
|
||||
# Gebunden wird auf 127.0.0.1, nicht auf 0.0.0.0. Docker traegt Freigaben
|
||||
# direkt in iptables ein und umgeht dabei ufw – eine offene Bindung stuende
|
||||
# also auch bei aktiver Firewall im Netz.
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
|
||||
services:
|
||||
db:
|
||||
ports:
|
||||
- "${POSTGRES_PORT:-127.0.0.1:5432}:5432"
|
||||
@@ -1,46 +0,0 @@
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
# Overlay fuer den Serverbetrieb: kein einziger Port geht zum Host.
|
||||
#
|
||||
# Gedacht fuer einen Docker-Host, auf dem mehrere Stacks liegen und ein
|
||||
# gemeinsamer Reverse Proxy die einzige Tuer nach draussen ist. Die
|
||||
# Datenbank veroeffentlicht ohnehin nichts; diese Datei nimmt zusaetzlich
|
||||
# die Freigabe der Anwendung zurueck und haengt sie in ein geteiltes Netz,
|
||||
# ueber das der Proxy sie erreicht.
|
||||
#
|
||||
# Aufruf:
|
||||
# docker compose -f docker-compose.yml -f docker-compose.server.yml \
|
||||
# --profile full up -d --build
|
||||
#
|
||||
# Bequemer ist, das dauerhaft in die .env zu schreiben:
|
||||
# COMPOSE_FILE=docker-compose.yml:docker-compose.server.yml
|
||||
# COMPOSE_PROFILES=full
|
||||
# Danach genuegt ueberall "docker compose up -d" – auch in update.sh.
|
||||
# (Trennzeichen: Doppelpunkt unter Linux, Semikolon unter Windows.)
|
||||
#
|
||||
# Das Netz muss es vorher geben (der Proxy-Stack legt es ueblicherweise an):
|
||||
# docker network create proxy
|
||||
#
|
||||
# Im Proxy zeigt das Ziel dann auf http://nebula:3000 bzw. nebula-app:3000.
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
|
||||
services:
|
||||
app:
|
||||
# !reset loescht die Portfreigabe aus der Basisdatei. Ohne dieses Tag
|
||||
# wuerden die Listen zusammengefuegt statt ersetzt – Compose behandelt
|
||||
# "ports" beim Zusammenfuehren als anzuhaengende Liste. Braucht
|
||||
# Compose 2.24 oder neuer.
|
||||
ports: !reset []
|
||||
networks:
|
||||
# Das stackeigene Netz: darueber spricht die Anwendung mit der Datenbank.
|
||||
default:
|
||||
# Das geteilte Netz zum Reverse Proxy. Der Alias ist der Name, unter dem
|
||||
# der Proxy Nebula anspricht – kurz und eindeutig, denn "app" hiessen in
|
||||
# einem geteilten Netz schnell mehrere Container.
|
||||
proxy:
|
||||
aliases:
|
||||
- ${PROXY_ALIAS:-nebula}
|
||||
|
||||
networks:
|
||||
proxy:
|
||||
external: true
|
||||
name: ${PROXY_NETWORK:-proxy}
|
||||
+9
-28
@@ -1,20 +1,14 @@
|
||||
name: nebula
|
||||
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
# Diese Datei veroeffentlicht nur einen einzigen Port, und den auf dem
|
||||
# Loopback: den der Anwendung. Die Datenbank bleibt im Docker-Netz.
|
||||
# Zwei Betriebsarten aus einer Datei:
|
||||
#
|
||||
# 1) Alles im Container (Server wie Entwicklung):
|
||||
# docker compose --profile full up -d --build
|
||||
#
|
||||
# 2) Standalone-Entwicklung – Datenbank im Container, App auf dem Host.
|
||||
# Dafuer muss Postgres auf dem Host erreichbar sein, also mit dem
|
||||
# Entwicklungs-Overlay (oder kurz: npm run docker:db):
|
||||
# docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d db
|
||||
# 1) Standalone-Entwicklung – nur die Datenbank im Container:
|
||||
# docker compose up -d db
|
||||
# npm run dev
|
||||
#
|
||||
# 3) Server ohne jede Portfreigabe, hinter einem Reverse Proxy im
|
||||
# gemeinsamen Docker-Netz: siehe docker-compose.server.yml
|
||||
# 2) Alles im Container:
|
||||
# docker compose --profile full up -d --build
|
||||
#
|
||||
# Optionales DB-Webinterface:
|
||||
# docker compose --profile tools up -d adminer → http://localhost:8080
|
||||
@@ -31,10 +25,8 @@ services:
|
||||
POSTGRES_DB: ${POSTGRES_DB:-nebula}
|
||||
# Deterministische Sortierung unabhaengig vom Host-Locale
|
||||
POSTGRES_INITDB_ARGS: "--encoding=UTF8"
|
||||
# Absichtlich keine Portfreigabe: die Anwendung erreicht die Datenbank im
|
||||
# Container ueber "db:5432", und backup.sh geht ueber "docker exec". Nach
|
||||
# aussen muss hier nichts. Wer die Datenbank vom Host aus braucht – fuer
|
||||
# "npm run dev" oder psql – nimmt docker-compose.dev.yml dazu.
|
||||
ports:
|
||||
- "${POSTGRES_PORT:-5432}:5432"
|
||||
volumes:
|
||||
- nebula-db-data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
@@ -67,13 +59,6 @@ services:
|
||||
APP_URL: ${APP_URL:-http://localhost:3000}
|
||||
SESSION_TTL_DAYS: ${SESSION_TTL_DAYS:-30}
|
||||
GIT_API_TIMEOUT_MS: ${GIT_API_TIMEOUT_MS:-15000}
|
||||
NOTIFY_TIMEOUT_MS: ${NOTIFY_TIMEOUT_MS:-10000}
|
||||
SMTP_HOST: ${SMTP_HOST:-}
|
||||
SMTP_PORT: ${SMTP_PORT:-587}
|
||||
SMTP_SECURE: ${SMTP_SECURE:-}
|
||||
SMTP_USER: ${SMTP_USER:-}
|
||||
SMTP_PASSWORD: ${SMTP_PASSWORD:-}
|
||||
SMTP_FROM: ${SMTP_FROM:-}
|
||||
GIT_ALLOW_LOOPBACK: ${GIT_ALLOW_LOOPBACK:-false}
|
||||
GIT_BLOCK_PRIVATE: ${GIT_BLOCK_PRIVATE:-false}
|
||||
GIT_ALLOWED_HOSTS: ${GIT_ALLOWED_HOSTS:-}
|
||||
@@ -81,11 +66,7 @@ services:
|
||||
PORT: 3000
|
||||
HOSTNAME: 0.0.0.0
|
||||
ports:
|
||||
# Nur auf dem Loopback: nach draussen kommt man ueber den Reverse Proxy.
|
||||
# Docker schreibt seine Freigaben an ufw vorbei direkt in iptables – eine
|
||||
# Bindung auf 0.0.0.0 stuende also im Netz, auch bei aktiver Firewall.
|
||||
# Ganz ohne Host-Port: docker-compose.server.yml.
|
||||
- "${APP_PORT:-127.0.0.1:3000}:3000"
|
||||
- "${APP_PORT:-3000}:3000"
|
||||
|
||||
adminer:
|
||||
profiles: ["tools"]
|
||||
@@ -99,7 +80,7 @@ services:
|
||||
ADMINER_DEFAULT_SERVER: db
|
||||
ADMINER_DESIGN: dracula
|
||||
ports:
|
||||
- "${ADMINER_PORT:-127.0.0.1:8080}:8080"
|
||||
- "${ADMINER_PORT:-8080}:8080"
|
||||
|
||||
volumes:
|
||||
nebula-db-data:
|
||||
|
||||
Executable → Regular
Binary file not shown.
|
Before Width: | Height: | Size: 503 KiB |
-964
@@ -1,964 +0,0 @@
|
||||
import { expect, test, type APIRequestContext } from "@playwright/test";
|
||||
import { PrismaClient } from "@prisma/client";
|
||||
|
||||
/**
|
||||
* Dieselbe Datenbank wie global-setup.ts. Gebraucht fuer den einen Fall, in
|
||||
* dem ein Zustand herzustellen ist, den die API bewusst nicht anbietet.
|
||||
*/
|
||||
const DATABASE_URL =
|
||||
process.env.E2E_DATABASE_URL ??
|
||||
"postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public";
|
||||
|
||||
/**
|
||||
* Tests ueber HTTP gegen die laufende Anwendung – also durch Middleware,
|
||||
* Authentifizierung, Validierung und Datenbank hindurch. Genau die Dinge,
|
||||
* die Unit-Tests nicht erreichen.
|
||||
*
|
||||
* Die Tests bauen aufeinander auf und laufen in dieser Reihenfolge, weil sie
|
||||
* sich eine Datenbank teilen (siehe playwright.config.ts, workers: 1).
|
||||
*/
|
||||
|
||||
const ADMIN = { username: "chefin", password: "ein-langes-testpasswort" };
|
||||
const ZWEITER = { username: "zweiter", password: "noch-ein-langes-passwort" };
|
||||
|
||||
async function login(request: APIRequestContext, user: { username: string; password: string }) {
|
||||
const response = await request.post("/api/auth/login", { data: user });
|
||||
expect(response.ok(), `Anmeldung als ${user.username}`).toBeTruthy();
|
||||
}
|
||||
|
||||
test.describe.configure({ mode: "serial" });
|
||||
|
||||
test("Einrichtung legt das erste Konto an und sperrt sich danach", async ({ request }) => {
|
||||
const response = await request.post("/api/auth/setup", {
|
||||
data: { ...ADMIN, mode: "MULTI_USER" },
|
||||
});
|
||||
expect(response.status()).toBe(200);
|
||||
expect((await response.json()).user.role).toBe("ADMIN");
|
||||
|
||||
// Ein zweiter Aufruf darf kein weiteres Adminkonto erzeugen.
|
||||
const wieder = await request.post("/api/auth/setup", {
|
||||
data: { username: "eindringling", password: "ein-langes-testpasswort" },
|
||||
});
|
||||
expect(wieder.status()).toBe(409);
|
||||
});
|
||||
|
||||
test("ohne Anmeldung ist nichts zu holen", async ({ playwright }) => {
|
||||
const anonym = await playwright.request.newContext({ baseURL: test.info().project.use.baseURL });
|
||||
for (const pfad of ["/api/projects", "/api/connections", "/api/admin/users"]) {
|
||||
expect((await anonym.get(pfad)).status(), pfad).toBe(401);
|
||||
}
|
||||
await anonym.dispose();
|
||||
});
|
||||
|
||||
test("Fremdes Origin wird abgewiesen", async ({ request }) => {
|
||||
await login(request, ADMIN);
|
||||
const response = await request.post("/api/projects", {
|
||||
data: { name: "Von woanders" },
|
||||
headers: { Origin: "https://boese.example" },
|
||||
});
|
||||
expect(response.status()).toBe(403);
|
||||
});
|
||||
|
||||
test("Content-Type wird erzwungen", async ({ request }) => {
|
||||
await login(request, ADMIN);
|
||||
const response = await request.post("/api/projects", {
|
||||
headers: { "Content-Type": "text/plain" },
|
||||
data: JSON.stringify({ name: "Umgehung" }),
|
||||
});
|
||||
expect(response.status()).toBe(415);
|
||||
});
|
||||
|
||||
test("SSRF: interne Adressen werden geblockt", async ({ request }) => {
|
||||
await login(request, ADMIN);
|
||||
for (const ziel of ["http://127.0.0.1:5432", "http://169.254.169.254", "http://0.0.0.0"]) {
|
||||
const response = await request.post("/api/connections", {
|
||||
data: { name: `ssrf-${ziel}`, provider: "GITEA", baseUrl: ziel },
|
||||
});
|
||||
expect(response.status(), ziel).toBe(422);
|
||||
}
|
||||
});
|
||||
|
||||
test("Datentrennung zwischen zwei Konten", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
const angelegt = await request.post("/api/projects", {
|
||||
data: { name: "Geheimprojekt", status: "IN_DEVELOPMENT" },
|
||||
});
|
||||
expect(angelegt.status()).toBe(201);
|
||||
const projektId = (await angelegt.json()).project.id;
|
||||
|
||||
const aufgabe = await request.post(`/api/projects/${projektId}/tasks`, {
|
||||
data: { title: "Nicht fuer fremde Augen" },
|
||||
});
|
||||
expect(aufgabe.status()).toBe(201);
|
||||
const aufgabenId = (await aufgabe.json()).task.id;
|
||||
|
||||
// Zweites Konto anlegen und in einem eigenen Kontext anmelden.
|
||||
const neu = await request.post("/api/admin/users", {
|
||||
data: { ...ZWEITER, role: "USER" },
|
||||
});
|
||||
expect(neu.status()).toBe(201);
|
||||
|
||||
const fremd = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
await login(fremd, ZWEITER);
|
||||
|
||||
expect((await (await fremd.get("/api/projects")).json()).projects).toHaveLength(0);
|
||||
|
||||
// Fremde IDs muessen 404 liefern, nicht 403 – sonst waere die Existenz
|
||||
// des Datensatzes bestaetigt.
|
||||
expect((await fremd.get(`/api/projects/${projektId}`)).status()).toBe(404);
|
||||
expect(
|
||||
(await fremd.patch(`/api/projects/${projektId}`, { data: { name: "uebernommen" } })).status(),
|
||||
).toBe(404);
|
||||
expect((await fremd.delete(`/api/projects/${projektId}`)).status()).toBe(404);
|
||||
expect((await fremd.get(`/api/projects/${projektId}/tasks`)).status()).toBe(404);
|
||||
expect((await fremd.patch(`/api/tasks/${aufgabenId}`, { data: { title: "x" } })).status()).toBe(
|
||||
404,
|
||||
);
|
||||
|
||||
// Adminwege bleiben zu.
|
||||
expect((await fremd.get("/api/admin/users")).status()).toBe(403);
|
||||
expect(
|
||||
(await fremd.patch("/api/admin/settings", { data: { mode: "SINGLE_USER" } })).status(),
|
||||
).toBe(403);
|
||||
|
||||
// Und das Original ist unveraendert.
|
||||
const danach = await (await request.get(`/api/projects/${projektId}`)).json();
|
||||
expect(danach.project.name).toBe("Geheimprojekt");
|
||||
expect(danach.project.tasks).toHaveLength(1);
|
||||
|
||||
await fremd.dispose();
|
||||
});
|
||||
|
||||
test("Aufgaben: Reihenfolge, abgeleiteter Fortschritt, fremde IDs", async ({ request }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
const projekt = (
|
||||
await (await request.post("/api/projects", { data: { name: "Aufgabenprojekt" } })).json()
|
||||
).project;
|
||||
|
||||
const titel = ["eins", "zwei", "drei"];
|
||||
const ids: string[] = [];
|
||||
for (const title of titel) {
|
||||
const response = await request.post(`/api/projects/${projekt.id}/tasks`, {
|
||||
data: { title, status: "TODO" },
|
||||
});
|
||||
ids.push((await response.json()).task.id);
|
||||
}
|
||||
|
||||
// Neue Aufgaben haengen sich hinten an.
|
||||
const angelegt = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
|
||||
expect(angelegt.map((task: { position: number }) => task.position)).toEqual([0, 1, 2]);
|
||||
|
||||
// Umdrehen.
|
||||
const gedreht = [...ids].reverse();
|
||||
const reorder = await request.patch(`/api/projects/${projekt.id}/tasks/reorder`, {
|
||||
data: { columns: { TODO: gedreht } },
|
||||
});
|
||||
expect(reorder.ok()).toBeTruthy();
|
||||
const nachher = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
|
||||
expect(nachher.map((task: { title: string }) => task.title)).toEqual(["drei", "zwei", "eins"]);
|
||||
|
||||
// Eine nach DONE – Fortschritt folgt, sobald eingeschaltet.
|
||||
await request.patch(`/api/projects/${projekt.id}`, { data: { progressFromTasks: true } });
|
||||
await request.patch(`/api/tasks/${ids[0]}`, { data: { status: "DONE" } });
|
||||
|
||||
const mitFortschritt = (
|
||||
await (await request.get(`/api/projects/${projekt.id}`)).json()
|
||||
).project;
|
||||
expect(mitFortschritt.progress).toBe(33);
|
||||
|
||||
// Eine ID aus einem anderen Projekt darf nicht verschoben werden.
|
||||
const anderes = (
|
||||
await (await request.post("/api/projects", { data: { name: "Anderes" } })).json()
|
||||
).project;
|
||||
const fremdeAufgabe = (
|
||||
await (
|
||||
await request.post(`/api/projects/${anderes.id}/tasks`, { data: { title: "fremd" } })
|
||||
).json()
|
||||
).task;
|
||||
|
||||
const untergeschoben = await request.patch(`/api/projects/${projekt.id}/tasks/reorder`, {
|
||||
data: { columns: { DOING: [fremdeAufgabe.id] } },
|
||||
});
|
||||
const ergebnis = await untergeschoben.json();
|
||||
expect(ergebnis.updated).toBe(0);
|
||||
expect(ergebnis.ignored).toBe(1);
|
||||
|
||||
const unveraendert = (
|
||||
await (await request.get(`/api/projects/${anderes.id}/tasks`)).json()
|
||||
).tasks[0];
|
||||
expect(unveraendert.status).toBe("TODO");
|
||||
});
|
||||
|
||||
test("Issues als Aufgaben uebernehmen, ohne Dubletten", async ({ request }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
const projekt = (
|
||||
await (await request.post("/api/projects", { data: { name: "Issue-Projekt" } })).json()
|
||||
).project;
|
||||
|
||||
// Ohne verknuepftes Repository gibt es nichts zu uebernehmen.
|
||||
const ohneRepo = await request.post(`/api/projects/${projekt.id}/tasks/from-issues`, {
|
||||
data: {},
|
||||
});
|
||||
expect(ohneRepo.status()).toBe(409);
|
||||
|
||||
// Mit Repository, aber ohne geholten Stand ebenfalls nicht – der Server
|
||||
// laedt hier bewusst nichts nach.
|
||||
await request.patch(`/api/projects/${projekt.id}`, {
|
||||
data: { repoUrl: "https://github.com/vercel/swr" },
|
||||
});
|
||||
const ohneStand = await request.post(`/api/projects/${projekt.id}/tasks/from-issues`, {
|
||||
data: {},
|
||||
});
|
||||
expect(ohneStand.status()).toBe(409);
|
||||
|
||||
// Nach einem bestimmten, das es nicht gibt, ist dagegen 404 richtig.
|
||||
const fremdesRepo = await request.post(`/api/projects/${projekt.id}/tasks/from-issues`, {
|
||||
data: { repositoryId: "gibt-es-nicht" },
|
||||
});
|
||||
expect(fremdesRepo.status()).toBe(404);
|
||||
});
|
||||
|
||||
test("Mehrere Repositories je Projekt", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
// Beim Anlegen setzen die Git-Felder das fuehrende Repository.
|
||||
const projekt = (
|
||||
await (
|
||||
await request.post("/api/projects", {
|
||||
data: { name: "Zwei Teile", repoUrl: "https://github.com/vercel/swr" },
|
||||
})
|
||||
).json()
|
||||
).project;
|
||||
|
||||
expect(projekt.repositories).toHaveLength(1);
|
||||
expect(projekt.repositories[0].repoOwner).toBe("vercel");
|
||||
expect(projekt.repositories[0].repoName).toBe("swr");
|
||||
|
||||
// Ein zweites dazu.
|
||||
const zweites = await request.post(`/api/projects/${projekt.id}/repositories`, {
|
||||
data: { label: "Backend", repoUrl: "https://github.com/vercel/next.js" },
|
||||
});
|
||||
expect(zweites.status()).toBe(201);
|
||||
const backendId = (await zweites.json()).repository.id;
|
||||
|
||||
// Dasselbe Repo zweimal ist immer ein Versehen.
|
||||
const doppelt = await request.post(`/api/projects/${projekt.id}/repositories`, {
|
||||
data: { repoUrl: "https://github.com/vercel/next.js" },
|
||||
});
|
||||
expect(doppelt.status()).toBe(409);
|
||||
|
||||
// Halbe Angaben ergeben kein Repository.
|
||||
const leer = await request.post(`/api/projects/${projekt.id}/repositories`, {
|
||||
data: { label: "Nur ein Name" },
|
||||
});
|
||||
expect(leer.status()).toBe(422);
|
||||
|
||||
const geladen = (await (await request.get(`/api/projects/${projekt.id}`)).json()).project;
|
||||
expect(geladen.repositories).toHaveLength(2);
|
||||
// Das fuehrende steht vorn.
|
||||
expect(geladen.repositories[0].repoName).toBe("swr");
|
||||
expect(geladen.repositories[1].label).toBe("Backend");
|
||||
|
||||
// Der Projekt-PATCH bearbeitet weiterhin nur das fuehrende.
|
||||
await request.patch(`/api/projects/${projekt.id}`, { data: { autoSync: false } });
|
||||
const danach = (await (await request.get(`/api/projects/${projekt.id}`)).json()).project;
|
||||
expect(danach.repositories[0].autoSync).toBe(false);
|
||||
expect(danach.repositories[1].autoSync).toBe(true);
|
||||
|
||||
// Fremde Konten kommen an kein Repository.
|
||||
const fremd = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
await login(fremd, ZWEITER);
|
||||
expect((await fremd.get(`/api/projects/${projekt.id}/repositories`)).status()).toBe(404);
|
||||
expect((await fremd.patch(`/api/repositories/${backendId}`, { data: {} })).status()).toBe(404);
|
||||
expect((await fremd.delete(`/api/repositories/${backendId}`)).status()).toBe(404);
|
||||
expect((await fremd.post(`/api/repositories/${backendId}/sync`)).status()).toBe(404);
|
||||
await fremd.dispose();
|
||||
|
||||
// Entfernen laesst das andere stehen.
|
||||
expect((await request.delete(`/api/repositories/${backendId}`)).ok()).toBeTruthy();
|
||||
const zumSchluss = (await (await request.get(`/api/projects/${projekt.id}`)).json()).project;
|
||||
expect(zumSchluss.repositories).toHaveLength(1);
|
||||
expect(zumSchluss.repositories[0].repoName).toBe("swr");
|
||||
});
|
||||
|
||||
test("Die Anmeldung verraet nicht, welche Konten es gibt", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
// Ein Konto anlegen und stilllegen.
|
||||
const angelegt = await request.post("/api/admin/users", {
|
||||
data: {
|
||||
username: "stillgelegt",
|
||||
password: "ein-ausreichend-langes-passwort",
|
||||
role: "USER",
|
||||
},
|
||||
});
|
||||
expect(angelegt.status()).toBe(201);
|
||||
const id = (await angelegt.json()).user.id;
|
||||
expect((await request.patch(`/api/admin/users/${id}`, { data: { isActive: false } })).ok())
|
||||
.toBeTruthy();
|
||||
|
||||
const anonym = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
|
||||
// Falsches Passwort auf dem stillgelegten Konto ...
|
||||
const stillgelegt = await anonym.post("/api/auth/login", {
|
||||
data: { username: "stillgelegt", password: "falsches-passwort-hier" },
|
||||
});
|
||||
// ... und auf einem Konto, das es gar nicht gibt.
|
||||
const erfunden = await anonym.post("/api/auth/login", {
|
||||
data: { username: "gibtesnicht", password: "falsches-passwort-hier" },
|
||||
});
|
||||
|
||||
// Beides muss ununterscheidbar sein – sonst laesst sich durchprobieren,
|
||||
// welche Benutzernamen vergeben sind. Frueher kam hier 403 gegen 401.
|
||||
expect(stillgelegt.status()).toBe(erfunden.status());
|
||||
expect(stillgelegt.status()).toBe(401);
|
||||
expect(await stillgelegt.json()).toEqual(await erfunden.json());
|
||||
|
||||
// Mit dem richtigen Passwort darf die Anwendung dann Klartext reden.
|
||||
const mitPasswort = await anonym.post("/api/auth/login", {
|
||||
data: { username: "stillgelegt", password: "ein-ausreichend-langes-passwort" },
|
||||
});
|
||||
expect(mitPasswort.status()).toBe(403);
|
||||
expect((await mitPasswort.json()).error).toMatch(/deaktiviert/);
|
||||
|
||||
await anonym.dispose();
|
||||
await request.delete(`/api/admin/users/${id}`);
|
||||
});
|
||||
|
||||
test("Abgleich hakt Aufgaben ab, deren Issue geschlossen wurde", async ({ request }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
// Ein oeffentliches Repository mit sicher geschlossenen Issues. Der
|
||||
// Abgleich laeuft anonym gegen die GitHub-API – kein Token noetig.
|
||||
const projekt = (
|
||||
await (
|
||||
await request.post("/api/projects", {
|
||||
data: { name: "Rueckweg", repoUrl: "https://github.com/vercel/swr" },
|
||||
})
|
||||
).json()
|
||||
).project;
|
||||
const repoId = projekt.repositories[0].id;
|
||||
|
||||
const angelegt = await request.post(`/api/projects/${projekt.id}/tasks`, {
|
||||
data: { title: "Haengt an einem geschlossenen Issue" },
|
||||
});
|
||||
const taskId = (await angelegt.json()).task.id;
|
||||
|
||||
/**
|
||||
* Die Verknuepfung direkt in der Datenbank setzen.
|
||||
*
|
||||
* Ueber die API gibt es dafuer keinen Weg, und das ist richtig so: "als
|
||||
* Issue anlegen" wuerde ein neues Issue in einem fremden Repository
|
||||
* erzeugen. Ein Endpunkt nur fuer Tests waere eine Hintertuer im
|
||||
* Produktionscode – dafuer greift der Test lieber selbst zur Datenbank.
|
||||
*
|
||||
* Issue 1 von vercel/swr ist seit Jahren geschlossen.
|
||||
*/
|
||||
const prisma = new PrismaClient({
|
||||
datasources: { db: { url: DATABASE_URL } },
|
||||
});
|
||||
try {
|
||||
await prisma.task.update({
|
||||
where: { id: taskId },
|
||||
data: { sourceRepositoryId: repoId, sourceIssue: 1 },
|
||||
});
|
||||
} finally {
|
||||
await prisma.$disconnect();
|
||||
}
|
||||
|
||||
const vorher = await (await request.get(`/api/projects/${projekt.id}`)).json();
|
||||
const alsAngelegt = vorher.project.tasks.find(
|
||||
(t: { id: string }) => t.id === taskId,
|
||||
);
|
||||
expect(alsAngelegt.sourceIssue).toBe(1);
|
||||
expect(alsAngelegt.status).toBe("TODO");
|
||||
|
||||
// Abgleich anstossen – er fragt den Zustand des Issues nach.
|
||||
const sync = await request.post(`/api/repositories/${repoId}/sync`);
|
||||
const syncBody = await sync.json();
|
||||
|
||||
/**
|
||||
* Dieser Test greift als einziger wirklich nach draussen. Ist GitHub nicht
|
||||
* erreichbar oder das anonyme Rate-Limit ausgeschoepft, sagt er das statt
|
||||
* rot zu werden – ein fremder Dienst darf die Testreihe nicht bestimmen.
|
||||
*/
|
||||
if (!sync.ok()) {
|
||||
test.skip(true, `GitHub nicht erreichbar: ${syncBody.message ?? sync.status()}`);
|
||||
return;
|
||||
}
|
||||
|
||||
const nachher = await (await request.get(`/api/projects/${projekt.id}`)).json();
|
||||
const abgehakt = nachher.project.tasks.find((t: { id: string }) => t.id === taskId);
|
||||
expect(abgehakt.status).toBe("DONE");
|
||||
expect(abgehakt.doneAt).not.toBeNull();
|
||||
|
||||
// Und ein zweiter Lauf aendert nichts mehr – abgehakt bleibt abgehakt,
|
||||
// ohne dass erneut nachgefragt wird.
|
||||
const nochmal = await request.post(`/api/repositories/${repoId}/sync`);
|
||||
expect((await nochmal.json()).message ?? "").not.toMatch(/abgehakt/);
|
||||
});
|
||||
|
||||
test("Webhook: Signatur entscheidet, sonst passiert nichts", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
const projekt = (
|
||||
await (
|
||||
await request.post("/api/projects", {
|
||||
data: { name: "Hakenprojekt", repoUrl: "https://github.com/vercel/swr" },
|
||||
})
|
||||
).json()
|
||||
).project;
|
||||
const repoId = projekt.repositories[0].id;
|
||||
|
||||
// Ohne eingerichteten Webhook ist der Endpunkt stumm – und zwar mit 404,
|
||||
// damit die ID nicht bestaetigt wird.
|
||||
const ohne = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: { "Content-Type": "application/json" },
|
||||
data: { action: "closed", issue: { number: 1 } },
|
||||
});
|
||||
expect(ohne.status()).toBe(404);
|
||||
|
||||
// Einrichten liefert das Geheimnis genau einmal zurueck.
|
||||
const eingerichtet = await request.post(`/api/repositories/${repoId}/webhook`);
|
||||
expect(eingerichtet.status()).toBe(200);
|
||||
const { secret, url } = await eingerichtet.json();
|
||||
expect(typeof secret).toBe("string");
|
||||
expect(secret.length).toBeGreaterThanOrEqual(64);
|
||||
expect(url).toContain(`/api/webhooks/${repoId}`);
|
||||
|
||||
// Und danach nirgends mehr: weder im Projekt noch am Repository.
|
||||
const geladen = await (await request.get(`/api/projects/${projekt.id}`)).json();
|
||||
expect(JSON.stringify(geladen)).not.toContain(secret);
|
||||
expect(geladen.project.repositories[0].webhookSecret).toBeUndefined();
|
||||
|
||||
// Eine Aufgabe, die an einem Issue haengt – von Hand gesetzt gibt es
|
||||
// nicht, also ueber die Uebernahme aus dem Snapshot. Stattdessen prueft
|
||||
// dieser Test die Grenze selbst: ohne gueltige Signatur passiert nichts.
|
||||
const rumpf = JSON.stringify({ action: "closed", issue: { number: 4242 } });
|
||||
|
||||
const falsch = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
"X-GitHub-Event": "issues",
|
||||
"X-Hub-Signature-256": "sha256=00",
|
||||
},
|
||||
data: rumpf,
|
||||
});
|
||||
expect(falsch.status()).toBe(401);
|
||||
|
||||
const gar_keine = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: { "Content-Type": "application/json", "X-GitHub-Event": "issues" },
|
||||
data: rumpf,
|
||||
});
|
||||
expect(gar_keine.status()).toBe(401);
|
||||
|
||||
// Mit richtiger Signatur wird der Aufruf angenommen. Zu Issue 4242 gibt
|
||||
// es keine Aufgabe – erwartet ist also "angenommen, nichts zugeordnet".
|
||||
const { createHmac } = await import("node:crypto");
|
||||
const signatur = createHmac("sha256", secret).update(rumpf, "utf8").digest("hex");
|
||||
const richtig = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
"X-GitHub-Event": "issues",
|
||||
"X-Hub-Signature-256": `sha256=${signatur}`,
|
||||
},
|
||||
data: rumpf,
|
||||
});
|
||||
expect(richtig.status()).toBe(200);
|
||||
const antwort = await richtig.json();
|
||||
expect(antwort).toMatchObject({ ok: true, handled: "issue", matched: false });
|
||||
|
||||
// Dieselbe Signatur zu einem anderen Rumpf gilt nicht.
|
||||
const veraendert = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
"X-GitHub-Event": "issues",
|
||||
"X-Hub-Signature-256": `sha256=${signatur}`,
|
||||
},
|
||||
data: JSON.stringify({ action: "closed", issue: { number: 9999 } }),
|
||||
});
|
||||
expect(veraendert.status()).toBe(401);
|
||||
|
||||
// Fremde Konten koennen den Haken weder einrichten noch zuruecknehmen.
|
||||
const fremd = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
await login(fremd, ZWEITER);
|
||||
expect((await fremd.post(`/api/repositories/${repoId}/webhook`)).status()).toBe(404);
|
||||
expect((await fremd.delete(`/api/repositories/${repoId}/webhook`)).status()).toBe(404);
|
||||
await fremd.dispose();
|
||||
|
||||
// Zuruecknehmen schliesst den Endpunkt wieder.
|
||||
expect((await request.delete(`/api/repositories/${repoId}/webhook`)).ok()).toBeTruthy();
|
||||
const danach = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
"X-GitHub-Event": "issues",
|
||||
"X-Hub-Signature-256": `sha256=${signatur}`,
|
||||
},
|
||||
data: rumpf,
|
||||
});
|
||||
expect(danach.status()).toBe(404);
|
||||
});
|
||||
|
||||
test("Brett: Reihenfolge und Mehrfachauswahl", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
const angelegt = [];
|
||||
for (const name of ["Brett A", "Brett B", "Brett C"]) {
|
||||
const response = await request.post("/api/projects", { data: { name, status: "IDEA" } });
|
||||
angelegt.push((await response.json()).project);
|
||||
}
|
||||
// Neue Projekte haengen sich hinten an ihre Spalte an – fortlaufend, nicht
|
||||
// alle auf denselben Platz. Absolut zaehlen laesst sich nicht: in der
|
||||
// Spalte stehen schon Projekte aus frueheren Tests.
|
||||
const [a, b, c] = angelegt.map((p) => p.position);
|
||||
expect([b, c]).toEqual([a + 1, a + 2]);
|
||||
|
||||
const ids = angelegt.map((p) => p.id);
|
||||
const vorher = angelegt[0].updatedAt;
|
||||
|
||||
// Umdrehen und dabei eines in eine andere Spalte schieben.
|
||||
const gedreht = [ids[2], ids[1]];
|
||||
const reorder = await request.patch("/api/projects/reorder", {
|
||||
data: { columns: { IDEA: gedreht, IN_DEVELOPMENT: [ids[0]] } },
|
||||
});
|
||||
expect(reorder.ok()).toBeTruthy();
|
||||
|
||||
const alle = (await (await request.get("/api/projects")).json()).projects;
|
||||
const finde = (id: string) => alle.find((p: { id: string }) => p.id === id);
|
||||
expect(finde(ids[2]).position).toBe(0);
|
||||
expect(finde(ids[1]).position).toBe(1);
|
||||
expect(finde(ids[0]).status).toBe("IN_DEVELOPMENT");
|
||||
|
||||
// Reines Umsortieren darf das Aenderungsdatum nicht anfassen – sonst
|
||||
// schoebe ein Aufraeumen im Brett alles in "Zuletzt geaendert" nach oben.
|
||||
expect(new Date(finde(ids[1]).updatedAt).getTime()).toBe(
|
||||
new Date(angelegt[1].updatedAt).getTime(),
|
||||
);
|
||||
// Das verschobene dagegen hat sich wirklich geaendert.
|
||||
expect(new Date(finde(ids[0]).updatedAt).getTime()).toBeGreaterThan(
|
||||
new Date(vorher).getTime(),
|
||||
);
|
||||
|
||||
// Mehrfachauswahl: Tags ergaenzen und wieder entfernen.
|
||||
const ergaenzt = await request.post("/api/projects/bulk", {
|
||||
data: { ids, action: "tags", tags: ["Sammel", "test"], tagMode: "add" },
|
||||
});
|
||||
expect((await ergaenzt.json()).changed).toBe(3);
|
||||
const mitTags = (await (await request.get("/api/projects")).json()).projects;
|
||||
// Kleingeschrieben abgelegt, wie ueberall.
|
||||
expect(mitTags.find((p: { id: string }) => p.id === ids[0]).tags).toContain("sammel");
|
||||
|
||||
const entfernt = await request.post("/api/projects/bulk", {
|
||||
data: { ids, action: "tags", tags: ["sammel"], tagMode: "remove" },
|
||||
});
|
||||
expect((await entfernt.json()).changed).toBe(3);
|
||||
|
||||
// Status fuer mehrere: die Verschobenen landen hintereinander, nicht
|
||||
// uebereinander auf derselben Position.
|
||||
const verschoben = await request.post("/api/projects/bulk", {
|
||||
data: { ids, action: "status", status: "PLANNING" },
|
||||
});
|
||||
expect((await verschoben.json()).changed).toBe(3);
|
||||
const geplant = (await (await request.get("/api/projects?status=PLANNING")).json()).projects;
|
||||
const positionen = geplant.map((p: { position: number }) => p.position).sort();
|
||||
expect(new Set(positionen).size).toBe(positionen.length);
|
||||
|
||||
// Wer schon so steht, wird nicht noch einmal angefasst.
|
||||
const nochmal = await request.post("/api/projects/bulk", {
|
||||
data: { ids, action: "status", status: "PLANNING" },
|
||||
});
|
||||
expect((await nochmal.json()).changed).toBe(0);
|
||||
|
||||
// Fremde IDs fallen still unter den Tisch, statt etwas anzurichten.
|
||||
const fremd = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
await login(fremd, ZWEITER);
|
||||
const untergeschoben = await fremd.post("/api/projects/bulk", {
|
||||
data: { ids, action: "delete" },
|
||||
});
|
||||
expect((await untergeschoben.json()).changed).toBe(0);
|
||||
const uebrig = (await (await request.get("/api/projects")).json()).projects;
|
||||
expect(uebrig.filter((p: { id: string }) => ids.includes(p.id))).toHaveLength(3);
|
||||
|
||||
const fremdSortieren = await fremd.patch("/api/projects/reorder", {
|
||||
data: { columns: { DONE: ids } },
|
||||
});
|
||||
expect((await fremdSortieren.json()).updated).toBe(0);
|
||||
await fremd.dispose();
|
||||
|
||||
// Und zum Schluss die eigenen wirklich loeschen.
|
||||
const geloescht = await request.post("/api/projects/bulk", {
|
||||
data: { ids, action: "delete" },
|
||||
});
|
||||
expect((await geloescht.json()).changed).toBe(3);
|
||||
});
|
||||
|
||||
test("Wiederkehrende Aufgaben legen die naechste Fassung an", async ({ request }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
const projekt = (
|
||||
await (await request.post("/api/projects", { data: { name: "Wiederkehrend" } })).json()
|
||||
).project;
|
||||
|
||||
const woechentlich = (
|
||||
await (
|
||||
await request.post(`/api/projects/${projekt.id}/tasks`, {
|
||||
data: {
|
||||
title: "Abhaengigkeiten pruefen",
|
||||
dueDate: "2026-07-06T12:00:00",
|
||||
recurrence: "WEEKLY",
|
||||
labels: ["wartung"],
|
||||
},
|
||||
})
|
||||
).json()
|
||||
).task;
|
||||
|
||||
// Ein Zwischenschritt loest noch nichts aus.
|
||||
await request.patch(`/api/tasks/${woechentlich.id}`, { data: { status: "DOING" } });
|
||||
let alle = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
|
||||
expect(alle).toHaveLength(1);
|
||||
|
||||
// Erst der Uebergang nach ERLEDIGT.
|
||||
const erledigt = await request.patch(`/api/tasks/${woechentlich.id}`, {
|
||||
data: { status: "DONE" },
|
||||
});
|
||||
expect((await erledigt.json()).next).not.toBeNull();
|
||||
|
||||
alle = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
|
||||
expect(alle).toHaveLength(2);
|
||||
|
||||
const folge = alle.find((task: { id: string }) => task.id !== woechentlich.id);
|
||||
expect(folge.status).toBe("TODO");
|
||||
expect(folge.title).toBe("Abhaengigkeiten pruefen");
|
||||
expect(folge.labels).toEqual(["wartung"]);
|
||||
expect(folge.recurrence).toBe("WEEKLY");
|
||||
expect(folge.recurredFrom).toBe(woechentlich.id);
|
||||
// Der Termin liegt in der Zukunft und auf demselben Wochentag.
|
||||
expect(new Date(folge.dueDate).getTime()).toBeGreaterThan(Date.now());
|
||||
expect(new Date(folge.dueDate).getUTCDay()).toBe(1);
|
||||
|
||||
// Erneut speichern erzeugt keine dritte.
|
||||
await request.patch(`/api/tasks/${woechentlich.id}`, { data: { title: "Umbenannt" } });
|
||||
alle = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
|
||||
expect(alle).toHaveLength(2);
|
||||
|
||||
// Der zweite Weg: durch Ziehen in die Spalte ERLEDIGT.
|
||||
const gezogen = await request.patch(`/api/projects/${projekt.id}/tasks/reorder`, {
|
||||
data: { columns: { DONE: [folge.id] } },
|
||||
});
|
||||
expect(gezogen.ok()).toBeTruthy();
|
||||
|
||||
alle = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
|
||||
expect(alle).toHaveLength(3);
|
||||
expect(alle.filter((task: { status: string }) => task.status === "TODO")).toHaveLength(1);
|
||||
|
||||
// Eine einmalige Aufgabe bleibt einmalig.
|
||||
const einmalig = (
|
||||
await (
|
||||
await request.post(`/api/projects/${projekt.id}/tasks`, { data: { title: "Nur einmal" } })
|
||||
).json()
|
||||
).task;
|
||||
await request.patch(`/api/tasks/${einmalig.id}`, { data: { status: "DONE" } });
|
||||
alle = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
|
||||
expect(alle).toHaveLength(4);
|
||||
});
|
||||
|
||||
test("Projektvorlagen: aus Projekt sichern und anwenden", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
// Ein Projekt herrichten, das als Vorlage taugt.
|
||||
const quelle = (
|
||||
await (
|
||||
await request.post("/api/projects", {
|
||||
data: { name: "Vorlagenquelle", status: "PLANNING", priority: 3, tags: ["web", "docker"] },
|
||||
})
|
||||
).json()
|
||||
).project;
|
||||
|
||||
await request.post(`/api/projects/${quelle.id}/notes`, {
|
||||
data: { content: "Checkliste vor dem Start." },
|
||||
});
|
||||
const erledigt = (
|
||||
await (
|
||||
await request.post(`/api/projects/${quelle.id}/tasks`, { data: { title: "Schon fertig" } })
|
||||
).json()
|
||||
).task;
|
||||
await request.patch(`/api/tasks/${erledigt.id}`, { data: { status: "DONE" } });
|
||||
await request.post(`/api/projects/${quelle.id}/tasks`, { data: { title: "Repo anlegen" } });
|
||||
await request.post(`/api/projects/${quelle.id}/tasks`, { data: { title: "CI einrichten" } });
|
||||
|
||||
const gesichert = await request.post("/api/templates/from-project", {
|
||||
data: { projectId: quelle.id, name: "Web-App", description: "Mit Docker und CI" },
|
||||
});
|
||||
expect(gesichert.status()).toBe(201);
|
||||
const vorlage = (await gesichert.json()).template;
|
||||
|
||||
expect(vorlage.tags).toEqual(["web", "docker"]);
|
||||
expect(vorlage.status).toBe("PLANNING");
|
||||
expect(vorlage.notes).toHaveLength(1);
|
||||
// Erledigte Aufgaben kommen nicht mit: eine Vorlage beschreibt, was zu tun ist.
|
||||
expect(vorlage.tasks).toHaveLength(2);
|
||||
expect(vorlage.tasks.map((task: { title: string }) => task.title)).not.toContain("Schon fertig");
|
||||
|
||||
// Derselbe Name ein zweites Mal wird abgewiesen.
|
||||
const doppelt = await request.post("/api/templates/from-project", {
|
||||
data: { projectId: quelle.id, name: "Web-App" },
|
||||
});
|
||||
expect(doppelt.status()).toBe(409);
|
||||
|
||||
// Anwenden: Notizen und Aufgaben entstehen mit dem Projekt.
|
||||
const neu = (
|
||||
await (
|
||||
await request.post("/api/projects", {
|
||||
data: { name: "Aus Vorlage", status: "IDEA", templateId: vorlage.id },
|
||||
})
|
||||
).json()
|
||||
).project;
|
||||
|
||||
const geladen = (await (await request.get(`/api/projects/${neu.id}`)).json()).project;
|
||||
expect(geladen.notes).toHaveLength(1);
|
||||
expect(geladen.tasks).toHaveLength(2);
|
||||
// Die Reihenfolge der Vorlage bleibt erhalten.
|
||||
expect(geladen.tasks.map((task: { title: string }) => task.title)).toEqual([
|
||||
"Repo anlegen",
|
||||
"CI einrichten",
|
||||
]);
|
||||
// Der ausdrueckliche Status gewinnt gegen den der Vorlage.
|
||||
expect(geladen.status).toBe("IDEA");
|
||||
|
||||
// Der Verlauf haelt die Herkunft fest.
|
||||
const verlauf = (await (await request.get(`/api/projects/${neu.id}/activity`)).json()).activities;
|
||||
expect(verlauf.some((entry: { summary: string }) => entry.summary.includes("Web-App"))).toBe(true);
|
||||
|
||||
// Eine fremde Vorlage laesst sich nicht unterschieben.
|
||||
const fremd = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
await login(fremd, ZWEITER);
|
||||
expect((await (await fremd.get("/api/templates")).json()).templates).toHaveLength(0);
|
||||
const untergeschoben = await fremd.post("/api/projects", {
|
||||
data: { name: "Klau", templateId: vorlage.id },
|
||||
});
|
||||
expect(untergeschoben.status()).toBe(404);
|
||||
expect((await fremd.delete(`/api/templates/${vorlage.id}`)).status()).toBe(404);
|
||||
await fremd.dispose();
|
||||
|
||||
// Und die Vorlage ueberlebt das Loeschen ihres Ursprungsprojekts.
|
||||
await request.delete(`/api/projects/${quelle.id}`);
|
||||
const nochDa = (await (await request.get("/api/templates")).json()).templates;
|
||||
expect(nochDa).toHaveLength(1);
|
||||
|
||||
expect((await request.delete(`/api/templates/${vorlage.id}`)).ok()).toBeTruthy();
|
||||
});
|
||||
|
||||
test("Verlauf blaettert per Cursor, ohne Zeilen zu verlieren", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
// Die bisherigen Tests haben reichlich Verlauf erzeugt. Erst alles auf
|
||||
// einmal holen, dann in kleinen Seiten – beides muss dieselbe Menge sein.
|
||||
const alles = await (await request.get("/api/activity?limit=100")).json();
|
||||
expect(alles.activities.length).toBeGreaterThan(5);
|
||||
|
||||
const ids: string[] = [];
|
||||
let cursor: { vor: string; id: string } | null = null;
|
||||
for (let seite = 0; seite < 60; seite += 1) {
|
||||
const query = cursor
|
||||
? `?limit=3&vor=${encodeURIComponent(cursor.vor)}&id=${encodeURIComponent(cursor.id)}`
|
||||
: "?limit=3";
|
||||
const antwort = await request.get(`/api/activity${query}`);
|
||||
expect(antwort.ok()).toBeTruthy();
|
||||
const seiteBody = await antwort.json();
|
||||
ids.push(...seiteBody.activities.map((eintrag: { id: string }) => eintrag.id));
|
||||
if (!seiteBody.weitere) break;
|
||||
cursor = seiteBody.naechster;
|
||||
expect(cursor).not.toBeNull();
|
||||
}
|
||||
|
||||
// Der eigentliche Punkt: keine Dubletten und keine Luecken, auch wenn
|
||||
// mehrere Eintraege denselben Zeitstempel tragen.
|
||||
expect(new Set(ids).size).toBe(ids.length);
|
||||
expect(ids.length).toBe(alles.activities.length);
|
||||
|
||||
// Absteigend sortiert.
|
||||
const zeiten: number[] = alles.activities.map((eintrag: { createdAt: string }) =>
|
||||
Date.parse(eintrag.createdAt),
|
||||
);
|
||||
for (let i = 1; i < zeiten.length; i += 1) {
|
||||
expect(zeiten[i]).toBeLessThanOrEqual(zeiten[i - 1]);
|
||||
}
|
||||
|
||||
// Unbrauchbare Cursor fangen von vorn an, statt zu scheitern.
|
||||
const kaputt = await request.get("/api/activity?vor=keindatum&id=x");
|
||||
expect(kaputt.ok()).toBeTruthy();
|
||||
expect((await kaputt.json()).activities.length).toBeGreaterThan(0);
|
||||
|
||||
// Und ein fremdes Konto sieht ausschliesslich seinen eigenen Verlauf.
|
||||
const fremd = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
await login(fremd, ZWEITER);
|
||||
const fremderVerlauf = await (await fremd.get("/api/activity")).json();
|
||||
const eigeneIds = new Set(ids);
|
||||
for (const eintrag of fremderVerlauf.activities) {
|
||||
expect(eigeneIds.has(eintrag.id)).toBe(false);
|
||||
}
|
||||
await fremd.dispose();
|
||||
});
|
||||
|
||||
test("Volltextsuche findet auch Aufgaben", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
const projekt = (
|
||||
await (await request.post("/api/projects", { data: { name: "Suchprojekt" } })).json()
|
||||
).project;
|
||||
|
||||
for (const task of [
|
||||
{
|
||||
title: "Dockerfile aufraeumen",
|
||||
description: "Die Schichten im Container neu ordnen, damit der Bau schneller wird.",
|
||||
},
|
||||
{ title: "Rechnungen exportieren", description: "Monatlicher Export als CSV." },
|
||||
{ title: "Erledigtes mit Container", description: "Auch das soll gefunden werden.", status: "DONE" },
|
||||
{ title: "Ohne Bezug", description: "Voellig anderer Inhalt." },
|
||||
]) {
|
||||
expect((await request.post(`/api/projects/${projekt.id}/tasks`, { data: task })).status()).toBe(
|
||||
201,
|
||||
);
|
||||
}
|
||||
|
||||
// Titel und Beschreibung werden durchsucht.
|
||||
const container = await (await request.get("/api/search?q=Container")).json();
|
||||
const titel = container.tasks.map((treffer: { title: string }) => treffer.title);
|
||||
expect(titel).toContain("Dockerfile aufraeumen");
|
||||
// Erledigtes bleibt drin – wer sucht, sucht oft gerade das Abgehakte.
|
||||
expect(titel).toContain("Erledigtes mit Container");
|
||||
expect(titel).not.toContain("Ohne Bezug");
|
||||
|
||||
// Deutsche Stammformen: "Rechnung" findet "Rechnungen".
|
||||
const rechnung = await (await request.get("/api/search?q=Rechnung")).json();
|
||||
expect(rechnung.tasks.map((t: { title: string }) => t.title)).toContain(
|
||||
"Rechnungen exportieren",
|
||||
);
|
||||
|
||||
// Das Projekt taucht in projectIds auf, damit das Brett es einblendet.
|
||||
expect(container.projectIds).toContain(projekt.id);
|
||||
|
||||
// Zu kurze Eingaben liefern leere Listen statt Unsinn.
|
||||
const kurz = await (await request.get("/api/search?q=a")).json();
|
||||
expect(kurz.tasks).toEqual([]);
|
||||
expect(kurz.hits).toEqual([]);
|
||||
|
||||
// Und ein fremdes Konto findet nichts davon.
|
||||
const fremd = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
await login(fremd, ZWEITER);
|
||||
expect((await (await fremd.get("/api/search?q=Container")).json()).tasks).toHaveLength(0);
|
||||
await fremd.dispose();
|
||||
});
|
||||
|
||||
test("Der Bildoptimierer ist zu", async ({ playwright }) => {
|
||||
// /_next/image reicht jedes Bild durch sharp und damit durch libvips, fuer
|
||||
// das es regelmaessig Schwachstellen gibt. Nebula benutzt next/image
|
||||
// nirgends – der Endpunkt darf ohne Anmeldung nicht antworten.
|
||||
const anonym = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
maxRedirects: 0,
|
||||
});
|
||||
const antwort = await anonym.get("/_next/image?url=%2Ficon-192.png&w=64&q=75");
|
||||
expect(antwort.status(), "kein 200 ohne Anmeldung").not.toBe(200);
|
||||
await anonym.dispose();
|
||||
});
|
||||
|
||||
test("Export enthaelt keine Geheimnisse, Import beachtet die Strategie", async ({ request }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
await request.post("/api/connections", {
|
||||
data: {
|
||||
name: "Mit Token",
|
||||
provider: "GITEA",
|
||||
baseUrl: "https://gitea.example.com",
|
||||
token: "streng-geheimes-token",
|
||||
},
|
||||
});
|
||||
|
||||
const roh = await (await request.get("/api/projects/export")).text();
|
||||
expect(roh).not.toContain("streng-geheimes-token");
|
||||
expect(roh).not.toContain("tokenCipher");
|
||||
expect(roh).not.toContain("ownerId");
|
||||
|
||||
const datei = JSON.parse(roh);
|
||||
const vorher = datei.projects.length;
|
||||
|
||||
// Version 2: die Repositories stehen als Liste in der Datei.
|
||||
expect(datei.version).toBe(2);
|
||||
const mitRepo = datei.projects.find((entry: { name: string }) => entry.name === "Zwei Teile");
|
||||
expect(mitRepo.repositories).toHaveLength(1);
|
||||
expect(mitRepo.repositories[0].repoName).toBe("swr");
|
||||
|
||||
// Ueberspringen aendert nichts.
|
||||
const uebersprungen = await request.post("/api/projects/import", {
|
||||
data: { data: datei, strategy: "skip", dryRun: false },
|
||||
});
|
||||
expect((await uebersprungen.json()).summary.skipped).toBe(vorher);
|
||||
|
||||
// Zusaetzlich anlegen verdoppelt.
|
||||
const zusaetzlich = await request.post("/api/projects/import", {
|
||||
data: { data: datei, strategy: "rename", dryRun: false },
|
||||
});
|
||||
expect((await zusaetzlich.json()).summary.renamed).toBe(vorher);
|
||||
|
||||
const jetzt = (await (await request.get("/api/projects")).json()).projects;
|
||||
expect(jetzt).toHaveLength(vorher * 2);
|
||||
|
||||
// Muell wird abgewiesen.
|
||||
const muell = await request.post("/api/projects/import", {
|
||||
data: { data: { irgendwas: true }, strategy: "skip", dryRun: true },
|
||||
});
|
||||
expect(muell.status()).toBe(422);
|
||||
});
|
||||
|
||||
test("Dateien der Version 1 bleiben lesbar", async ({ request }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
// Damals stand genau ein Repository flach am Projekt. Wer eine solche
|
||||
// Sicherung liegen hat, soll sie weiterhin einspielen koennen.
|
||||
const alt = {
|
||||
kind: "nebula.projects",
|
||||
version: 1,
|
||||
projects: [
|
||||
{
|
||||
name: "Aus Version eins",
|
||||
repoUrl: "https://github.com/vercel/swr",
|
||||
repoOwner: "vercel",
|
||||
repoName: "swr",
|
||||
autoSync: false,
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
const gelesen = await request.post("/api/projects/import", {
|
||||
data: { data: alt, strategy: "rename", dryRun: false },
|
||||
});
|
||||
expect(gelesen.ok()).toBeTruthy();
|
||||
|
||||
const projekte = (await (await request.get("/api/projects")).json()).projects;
|
||||
const uebernommen = projekte.find(
|
||||
(entry: { name: string }) => entry.name === "Aus Version eins",
|
||||
);
|
||||
expect(uebernommen.repositories).toHaveLength(1);
|
||||
expect(uebernommen.repositories[0].repoOwner).toBe("vercel");
|
||||
expect(uebernommen.repositories[0].autoSync).toBe(false);
|
||||
});
|
||||
@@ -1,62 +0,0 @@
|
||||
import { execFileSync } from "node:child_process";
|
||||
import { PrismaClient } from "@prisma/client";
|
||||
|
||||
/**
|
||||
* Bereitet die Testdatenbank vor: Schema einspielen und leeren.
|
||||
*
|
||||
* Die Datenbank muss vorher existieren. Anlegen ist bewusst nicht Teil des
|
||||
* Setups – in CI erzeugt sie der Postgres-Dienst, oertlich einmalig:
|
||||
*
|
||||
* docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_e2e_test"
|
||||
*/
|
||||
|
||||
const DATABASE_URL =
|
||||
process.env.E2E_DATABASE_URL ??
|
||||
"postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public";
|
||||
|
||||
/**
|
||||
* Reihenfolge egal, weil CASCADE – aber vollstaendig muss sie sein, sonst
|
||||
* schleppen Laeufe Reste mit.
|
||||
*/
|
||||
const TABLES = [
|
||||
"Task",
|
||||
"Note",
|
||||
"RepoSnapshot",
|
||||
"Project",
|
||||
"Credential",
|
||||
"Session",
|
||||
"WebAuthnChallenge",
|
||||
"GitConnection",
|
||||
"User",
|
||||
"AppSettings",
|
||||
];
|
||||
|
||||
export default async function globalSetup() {
|
||||
const name = new URL(DATABASE_URL).pathname.replace(/^\//, "");
|
||||
|
||||
// Schutz vor dem teuersten aller Fehler: eine Testreihe, die die echte
|
||||
// Datenbank leert. Der Name muss "test" enthalten, sonst passiert nichts.
|
||||
if (!name.includes("test")) {
|
||||
throw new Error(
|
||||
`Die Testdatenbank heisst "${name}" und enthaelt nicht "test". ` +
|
||||
"Aus Sicherheitsgruenden abgebrochen – E2E_DATABASE_URL pruefen.",
|
||||
);
|
||||
}
|
||||
|
||||
console.log(`[e2e] Datenbank: ${name}`);
|
||||
|
||||
execFileSync("npx", ["prisma", "migrate", "deploy"], {
|
||||
env: { ...process.env, DATABASE_URL },
|
||||
stdio: "pipe",
|
||||
shell: process.platform === "win32",
|
||||
});
|
||||
|
||||
const prisma = new PrismaClient({ datasources: { db: { url: DATABASE_URL } } });
|
||||
try {
|
||||
const list = TABLES.map((table) => `"${table}"`).join(", ");
|
||||
await prisma.$executeRawUnsafe(`TRUNCATE TABLE ${list} RESTART IDENTITY CASCADE`);
|
||||
console.log("[e2e] Datenbank geleert.");
|
||||
} finally {
|
||||
await prisma.$disconnect();
|
||||
}
|
||||
}
|
||||
-391
@@ -1,391 +0,0 @@
|
||||
import { expect, test } from "@playwright/test";
|
||||
|
||||
/**
|
||||
* Ein Weg durch die Oberflaeche, wie ihn ein Mensch geht: anmelden, Projekt
|
||||
* anlegen, Aufgaben verwalten. Keine Vollabdeckung – die Wege, die kaputt
|
||||
* gehen duerfen, ohne dass es jemand merkt.
|
||||
*
|
||||
* Setzt voraus, dass api.spec.ts das Konto bereits angelegt hat; laeuft
|
||||
* alphabetisch danach.
|
||||
*/
|
||||
|
||||
const KONTO = { username: "chefin", password: "ein-langes-testpasswort" };
|
||||
|
||||
test.describe.configure({ mode: "serial" });
|
||||
|
||||
test.beforeEach(async ({ page }) => {
|
||||
await page.goto("/login");
|
||||
await page.fill("#login-username", KONTO.username);
|
||||
await page.fill("#login-password", KONTO.password);
|
||||
await page.click('button[type="submit"]');
|
||||
await expect(page.getByText("Vibe Coding Kontrollzentrum")).toBeVisible();
|
||||
});
|
||||
|
||||
test("Dashboard zeigt Kennzahlen und Projekte", async ({ page }) => {
|
||||
await expect(page.getByRole("heading", { name: /Deine Projekte/ })).toBeVisible();
|
||||
await expect(page.getByText("Projekte", { exact: false }).first()).toBeVisible();
|
||||
// Keine unbeabsichtigten Fehler in der Konsole.
|
||||
expect(page.url()).toContain("/");
|
||||
});
|
||||
|
||||
test("Projekt anlegen und wiederfinden", async ({ page }) => {
|
||||
await page.getByRole("button", { name: /Neues Projekt/ }).click();
|
||||
await expect(page.getByRole("dialog")).toBeVisible();
|
||||
|
||||
await page.fill("#project-name", "Oberflaechentest");
|
||||
await page.fill("#project-summary", "Von Playwright angelegt.");
|
||||
await page.getByRole("button", { name: "Projekt anlegen" }).click();
|
||||
|
||||
await expect(page.getByRole("dialog")).toBeHidden();
|
||||
await expect(page.getByText("Oberflaechentest")).toBeVisible();
|
||||
});
|
||||
|
||||
test("Aufgaben anlegen und per Ziehen verschieben", async ({ page }) => {
|
||||
await page.getByRole("link", { name: /Projekt Oberflaechentest/ }).click();
|
||||
await expect(page.getByRole("heading", { name: "Oberflaechentest" })).toBeVisible();
|
||||
|
||||
// Zwei Aufgaben ueber den Dialog anlegen.
|
||||
for (const titel of ["Erste Aufgabe", "Zweite Aufgabe"]) {
|
||||
await page.getByRole("button", { name: "Aufgabe", exact: true }).click();
|
||||
await expect(page.getByRole("dialog")).toBeVisible();
|
||||
await page.fill("#task-title", titel);
|
||||
await page.getByRole("button", { name: "Anlegen" }).click();
|
||||
await expect(page.getByRole("dialog")).toBeHidden();
|
||||
}
|
||||
|
||||
const offen = page.locator('[data-task-column="TODO"]');
|
||||
const inArbeit = page.locator('[data-task-column="DOING"]');
|
||||
await expect(offen.getByText("Erste Aufgabe")).toBeVisible();
|
||||
await expect(offen.getByText("Zweite Aufgabe")).toBeVisible();
|
||||
|
||||
// Erste Aufgabe nach "In Arbeit" ziehen.
|
||||
const griff = offen.locator('button[aria-label$="verschieben"]').first();
|
||||
const von = await griff.boundingBox();
|
||||
const nach = await inArbeit.boundingBox();
|
||||
expect(von && nach).toBeTruthy();
|
||||
|
||||
await page.mouse.move(von!.x + von!.width / 2, von!.y + von!.height / 2);
|
||||
await page.mouse.down();
|
||||
// Erst ueber die Aktivierungsschwelle des Sensors (5 Pixel) hinaus.
|
||||
await page.mouse.move(von!.x + 30, von!.y + 10, { steps: 6 });
|
||||
await page.mouse.move(nach!.x + nach!.width / 2, nach!.y + 60, { steps: 20 });
|
||||
// dnd-kit wertet die Bewegung in einem eigenen Frame aus. Ohne diese
|
||||
// Pause faende das Loslassen noch kein Ziel und die Karte spraenge zurueck.
|
||||
await page.waitForTimeout(250);
|
||||
|
||||
// Auf die Antwort warten, bevor neu geladen wird. Sonst bricht das Neuladen
|
||||
// den noch laufenden Aufruf ab, und der Test schlaegt gelegentlich fehl,
|
||||
// obwohl die Anwendung in Ordnung ist – genau so ist es passiert.
|
||||
const gespeichert = page.waitForResponse(
|
||||
(response) => response.url().includes("/tasks/reorder") && response.request().method() === "PATCH",
|
||||
);
|
||||
await page.mouse.up();
|
||||
|
||||
await expect(inArbeit.getByText("Erste Aufgabe")).toBeVisible();
|
||||
expect((await gespeichert).ok()).toBeTruthy();
|
||||
|
||||
// Und der Server hat es auch so gespeichert.
|
||||
await page.reload();
|
||||
await expect(
|
||||
page.locator('[data-task-column="DOING"]').getByText("Erste Aufgabe"),
|
||||
).toBeVisible();
|
||||
});
|
||||
|
||||
test("Volltextsuche findet Notizen", async ({ page }) => {
|
||||
await page.getByRole("link", { name: /Projekt Oberflaechentest/ }).click();
|
||||
await page.getByRole("button", { name: "Notiz", exact: true }).click();
|
||||
|
||||
await page.getByPlaceholder(/Gedanken/).fill("Suchbegriff Zaunkoenig steht hier.");
|
||||
await page.getByRole("button", { name: "Speichern" }).click();
|
||||
await expect(page.getByText("Zaunkoenig", { exact: false })).toBeVisible();
|
||||
|
||||
// exact, sonst trifft es auch "Zurueck zum Dashboard".
|
||||
await page.getByRole("link", { name: "Dashboard", exact: true }).click();
|
||||
await page.getByPlaceholder(/durchsuchen/).fill("Zaunkoenig");
|
||||
|
||||
await expect(page.getByText("Treffer in Notizen")).toBeVisible();
|
||||
});
|
||||
|
||||
test("Listenansicht auf Telefonbreite ohne seitliches Scrollen", async ({ page }) => {
|
||||
await page.setViewportSize({ width: 375, height: 667 });
|
||||
|
||||
await page.getByRole("button", { name: "Liste" }).click();
|
||||
await expect(page.getByRole("link", { name: /Projekt Oberflaechentest/ })).toBeVisible();
|
||||
|
||||
// Der eigentliche Punkt der Ansicht: sie passt in die Breite. Frueher schob
|
||||
// die Steuerleiste den Knopf "Neues Projekt" aus dem Bild und die ganze
|
||||
// Seite liess sich seitwaerts schieben.
|
||||
const masse = await page.evaluate(() => ({
|
||||
scrollWidth: document.documentElement.scrollWidth,
|
||||
clientWidth: document.documentElement.clientWidth,
|
||||
}));
|
||||
expect(masse.scrollWidth).toBeLessThanOrEqual(masse.clientWidth + 1);
|
||||
|
||||
// Auch der Knopf muss erreichbar bleiben – auf dieser Breite traegt er nur
|
||||
// noch das Pluszeichen und lebt von seinem aria-label. Geprueft wird die
|
||||
// rechte Kante: genau die lag vorher ausserhalb des Bildschirms.
|
||||
const knopf = page.getByRole("button", { name: "Neues Projekt" });
|
||||
await expect(knopf).toBeVisible();
|
||||
const kasten = await knopf.boundingBox();
|
||||
expect(kasten).not.toBeNull();
|
||||
expect(kasten!.x + kasten!.width).toBeLessThanOrEqual(masse.clientWidth);
|
||||
});
|
||||
|
||||
test("Schnellerfassung legt Idee und Aufgabe mit einem Feld an", async ({ page }) => {
|
||||
await page.setViewportSize({ width: 375, height: 667 });
|
||||
|
||||
await page.getByRole("button", { name: "Schnell erfassen" }).click();
|
||||
const dialog = page.getByRole("dialog");
|
||||
await expect(dialog).toBeVisible();
|
||||
|
||||
// Idee: nur der Name, alles andere kommt aus den Vorgaben des Schemas.
|
||||
await page.fill("#quick-title", "Aus der Bahn notiert");
|
||||
await dialog.getByRole("button", { name: "Anlegen" }).click();
|
||||
|
||||
// Der Dialog bleibt offen und bestaetigt – das ist der Punkt der
|
||||
// Schnellerfassung: die naechste Idee soll ohne Umweg hineingehen.
|
||||
await expect(dialog.getByText("Angelegt")).toBeVisible();
|
||||
await expect(dialog.getByRole("link", { name: "Aus der Bahn notiert" })).toBeVisible();
|
||||
await expect(page.locator("#quick-title")).toHaveValue("");
|
||||
|
||||
// Aufgabe: derselbe Dialog, ein Feld mehr.
|
||||
await dialog.getByRole("button", { name: "Aufgabe", exact: true }).click();
|
||||
await page.fill("#quick-title", "Unterwegs eingefallen");
|
||||
await expect(page.locator("#quick-project")).toBeVisible();
|
||||
await dialog.getByRole("button", { name: "Anlegen" }).click();
|
||||
await expect(dialog.getByRole("link", { name: "Unterwegs eingefallen" })).toBeVisible();
|
||||
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
|
||||
// Die Idee steht als Projekt im Dashboard.
|
||||
await page.goto("/");
|
||||
await expect(page.getByText("Aus der Bahn notiert")).toBeVisible();
|
||||
});
|
||||
|
||||
test("Dialoge weichen der Bildschirmtastatur aus", async ({ page }) => {
|
||||
await page.setViewportSize({ width: 375, height: 667 });
|
||||
await page.getByRole("button", { name: "Schnell erfassen" }).click();
|
||||
await expect(page.getByRole("dialog")).toBeVisible();
|
||||
|
||||
const TASTATUR = 336;
|
||||
|
||||
/**
|
||||
* Eine echte Tastatur laesst sich nicht einblenden. Stattdessen meldet
|
||||
* visualViewport eine kleinere Hoehe – genau die Schnittstelle, an der
|
||||
* der Dialog haengt. Ueberschrieben wird am echten Objekt: der Dialog
|
||||
* merkt sich beim Oeffnen eine Referenz darauf.
|
||||
*/
|
||||
await page.evaluate((tastatur) => {
|
||||
const fenster = window.visualViewport;
|
||||
if (!fenster) throw new Error("visualViewport fehlt");
|
||||
const hoehe = window.innerHeight - tastatur;
|
||||
Object.defineProperty(fenster, "height", { get: () => hoehe, configurable: true });
|
||||
Object.defineProperty(fenster, "offsetTop", { get: () => 0, configurable: true });
|
||||
fenster.dispatchEvent(new Event("resize"));
|
||||
}, TASTATUR);
|
||||
|
||||
await page.waitForTimeout(300);
|
||||
|
||||
// Eingabefeld und Absendeknopf muessen oberhalb der Tastatur liegen.
|
||||
// Vorher stand der Dialog mittig im vollen Fenster – und damit zur
|
||||
// Haelfte darunter.
|
||||
const frei = 667 - TASTATUR;
|
||||
for (const ziel of [
|
||||
page.locator("#quick-title"),
|
||||
page.getByRole("dialog").getByRole("button", { name: "Anlegen" }),
|
||||
]) {
|
||||
const kasten = await ziel.boundingBox();
|
||||
expect(kasten).not.toBeNull();
|
||||
expect(kasten!.y + kasten!.height).toBeLessThanOrEqual(frei);
|
||||
}
|
||||
|
||||
await page.keyboard.press("Escape");
|
||||
});
|
||||
|
||||
test("Aufgabenuebersicht sammelt ueber alle Projekte und hakt ab", async ({ page }) => {
|
||||
await page.getByRole("link", { name: "Aufgaben", exact: true }).click();
|
||||
await expect(page.getByRole("heading", { name: "Aufgaben", level: 1 })).toBeVisible();
|
||||
|
||||
// Die zuvor per Schnellerfassung angelegte Aufgabe taucht hier auf,
|
||||
// obwohl sie in einem anderen Projekt haengt.
|
||||
const zeile = page.getByRole("listitem").filter({ hasText: "Unterwegs eingefallen" });
|
||||
await expect(zeile).toBeVisible();
|
||||
|
||||
// Abhaken aus der Uebersicht heraus.
|
||||
await zeile.getByRole("button", { name: /abhaken/ }).click();
|
||||
// Ohne "Erledigte einblenden" verschwindet sie damit aus der Liste.
|
||||
await expect(zeile).toBeHidden();
|
||||
|
||||
await page.getByLabel("Erledigte einblenden").check();
|
||||
await expect(
|
||||
page.getByRole("listitem").filter({ hasText: "Unterwegs eingefallen" }),
|
||||
).toBeVisible();
|
||||
});
|
||||
|
||||
test("Wochenrueckblick zeigt, was diese Woche passiert ist", async ({ page }) => {
|
||||
// Erreichbar vom Dashboard aus, ohne vierten Punkt in der Kopfleiste.
|
||||
await page.getByRole("link", { name: /Wochenrückblick/ }).click();
|
||||
await expect(page).toHaveURL(/\/rueckblick$/);
|
||||
await expect(page.getByRole("heading", { name: "Diese Woche", level: 1 })).toBeVisible();
|
||||
|
||||
// Die Vorgaenge der bisherigen Tests liegen in dieser Woche, es muss also
|
||||
// etwas dastehen – und das Projekt gehoert an jede Zeile.
|
||||
await expect(page.getByRole("link", { name: "Oberflaechentest" }).first()).toBeVisible();
|
||||
|
||||
// Blättern: zurück und wieder her.
|
||||
await page.getByRole("link", { name: "Eine Woche zurück" }).click();
|
||||
await expect(page).toHaveURL(/woche=-1/);
|
||||
await expect(page.getByRole("heading", { name: "Vorige Woche", level: 1 })).toBeVisible();
|
||||
|
||||
await page.getByRole("link", { name: "Diese Woche", exact: true }).click();
|
||||
await expect(page).toHaveURL(/\/rueckblick$/);
|
||||
|
||||
// Auch ueber die Schnellsuche erreichbar.
|
||||
await page.goto("/");
|
||||
await page.keyboard.press("Control+k");
|
||||
await page.getByPlaceholder(/^Projekt, /).fill("Rückblick");
|
||||
await page.keyboard.press("Enter");
|
||||
await expect(page).toHaveURL(/\/rueckblick/);
|
||||
});
|
||||
|
||||
test("Globale Zeitleiste zeigt den Verlauf ueber alle Projekte", async ({ page }) => {
|
||||
// Vom Wochenrueckblick aus verlinkt.
|
||||
await page.goto("/rueckblick");
|
||||
await page.getByRole("link", { name: /Ganzer Verlauf/ }).click();
|
||||
await expect(page).toHaveURL(/\/verlauf$/);
|
||||
await expect(page.getByRole("heading", { name: "Verlauf", level: 1 })).toBeVisible();
|
||||
|
||||
// Eintraege mit Projektbezug – ohne den ist eine uebergreifende Liste
|
||||
// nicht zu lesen.
|
||||
await expect(page.getByRole("link", { name: "Oberflaechentest" }).first()).toBeVisible();
|
||||
await expect(page.getByText(/Vorgänge geladen|Vorgang geladen/)).toBeVisible();
|
||||
|
||||
// Auch ueber die Schnellsuche erreichbar.
|
||||
await page.goto("/");
|
||||
await page.keyboard.press("Control+k");
|
||||
await page.getByPlaceholder(/^Projekt, /).fill("Verlauf");
|
||||
await page.keyboard.press("Enter");
|
||||
await expect(page).toHaveURL(/\/verlauf/);
|
||||
});
|
||||
|
||||
test("Aufgabendashboard laesst sich durchsuchen", async ({ page }) => {
|
||||
await page.getByRole("link", { name: "Aufgaben", exact: true }).click();
|
||||
await expect(page.getByRole("heading", { name: "Aufgaben", level: 1 })).toBeVisible();
|
||||
|
||||
const suchfeld = page.getByLabel("Aufgaben durchsuchen");
|
||||
await expect(suchfeld).toBeVisible();
|
||||
|
||||
// Aus den frueheren Tests gibt es "Erste Aufgabe" und "Zweite Aufgabe".
|
||||
await suchfeld.fill("Erste");
|
||||
await expect(page.getByRole("listitem").filter({ hasText: "Erste Aufgabe" })).toBeVisible();
|
||||
await expect(page.getByRole("listitem").filter({ hasText: "Zweite Aufgabe" })).toBeHidden();
|
||||
|
||||
// Ohne Treffer erklaert der Leerzustand, worin gesucht wurde.
|
||||
await suchfeld.fill("gibtesnichtxyz");
|
||||
await expect(page.getByText("Keine Treffer")).toBeVisible();
|
||||
await expect(page.getByText(/Titel, Beschreibung, Labels und Projektname/)).toBeVisible();
|
||||
|
||||
// Zuruecksetzen bringt alles wieder.
|
||||
await page.getByRole("button", { name: "Suche zuruecksetzen" }).click();
|
||||
await expect(suchfeld).toHaveValue("");
|
||||
await expect(page.getByRole("listitem").filter({ hasText: "Erste Aufgabe" })).toBeVisible();
|
||||
});
|
||||
|
||||
test("Schnellsuche findet Projekt und Notiz", async ({ page }) => {
|
||||
await page.keyboard.press("Control+k");
|
||||
await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeVisible();
|
||||
|
||||
// Ohne Eingabe stehen Projekte und Bereiche bereit.
|
||||
await expect(page.getByRole("dialog").getByText("Oberflaechentest")).toBeVisible();
|
||||
|
||||
await page.getByPlaceholder(/^Projekt, /).fill("Zaunkoenig");
|
||||
await expect(page.getByRole("dialog").getByText(/in Oberflaechentest/)).toBeVisible();
|
||||
|
||||
// Enter springt zum ersten Treffer.
|
||||
await page.keyboard.press("Enter");
|
||||
await expect(page.getByRole("heading", { name: "Oberflaechentest" })).toBeVisible();
|
||||
|
||||
// Escape schliesst wieder.
|
||||
await page.keyboard.press("Control+k");
|
||||
await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeHidden();
|
||||
});
|
||||
|
||||
test("Mehrfachauswahl aendert mehrere Projekte auf einmal", async ({ page }) => {
|
||||
const kaestchen = page.locator('input[aria-label$="auswaehlen"]');
|
||||
const anzahl = await kaestchen.count();
|
||||
expect(anzahl).toBeGreaterThan(0);
|
||||
|
||||
// Ohne Auswahl gibt es keine Leiste – sie soll nicht dauerhaft im Weg sein.
|
||||
await expect(page.getByText(/ausgewählt/)).toBeHidden();
|
||||
|
||||
await kaestchen.first().check();
|
||||
await expect(page.getByText("1 ausgewählt")).toBeVisible();
|
||||
|
||||
await page.getByRole("button", { name: "Tags", exact: true }).click();
|
||||
await page.fill("#bulk-tags", "sammeltest");
|
||||
await page.getByRole("button", { name: "Hinzufügen" }).click();
|
||||
|
||||
await expect(page.getByText("#sammeltest").first()).toBeVisible();
|
||||
// Nach getaner Arbeit ist die Auswahl aufgehoben.
|
||||
await expect(page.getByText(/ausgewählt/)).toBeHidden();
|
||||
});
|
||||
|
||||
test("Die Versionsnummer oeffnet den Aenderungsverlauf", async ({ page }) => {
|
||||
await page.getByRole("button", { name: /^v\d+\.\d+\.\d+$/ }).click();
|
||||
|
||||
// Ueber die Rolle, nicht ueber den Text: das Wort steht auch in einem der
|
||||
// Eintraege, und ein blosser Textvergleich waere mehrdeutig.
|
||||
const dialog = page.getByRole("dialog", { name: "Änderungsverlauf" });
|
||||
await expect(dialog).toBeVisible();
|
||||
// Die laufende Fassung ist als solche gekennzeichnet.
|
||||
await expect(dialog.getByText("installiert")).toBeVisible();
|
||||
// Und es steht wirklich etwas drin.
|
||||
await expect(dialog.getByRole("heading", { level: 3 }).first()).toBeVisible();
|
||||
await expect(dialog.getByText("Neu").first()).toBeVisible();
|
||||
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
|
||||
test("Das Manifest liegt bereit, auch ohne Anmeldung", async ({ page, playwright }) => {
|
||||
const anonym = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
|
||||
// Ohne diesen Weg an der Zugangsschranke vorbei liesse sich die Anwendung
|
||||
// nicht installieren: der Browser holt das Manifest, bevor jemand angemeldet ist.
|
||||
const antwort = await anonym.get("/manifest.webmanifest");
|
||||
expect(antwort.ok()).toBeTruthy();
|
||||
|
||||
const manifest = await antwort.json();
|
||||
expect(manifest.name).toContain("Nebula");
|
||||
expect(manifest.display).toBe("standalone");
|
||||
expect(manifest.icons.some((icon: { purpose: string }) => icon.purpose === "maskable")).toBe(true);
|
||||
|
||||
for (const icon of manifest.icons) {
|
||||
const bild = await anonym.get(icon.src);
|
||||
expect(bild.ok(), icon.src).toBeTruthy();
|
||||
expect(bild.headers()["content-type"]).toContain("image/png");
|
||||
}
|
||||
|
||||
await anonym.dispose();
|
||||
|
||||
// Die Seite muss ein Symbol verweisen. Fehlt es, sucht der Browser
|
||||
// /favicon.ico – das es hier nicht gibt, und die Konsole fuellt sich mit
|
||||
// 404ern. Genau das ist beim Ergaenzen des Apple-Symbols passiert.
|
||||
await page.goto("/");
|
||||
await expect(page.locator('link[rel="icon"]').first()).toHaveAttribute("href", /icon/);
|
||||
});
|
||||
|
||||
test("Abmelden fuehrt zurueck zur Anmeldung", async ({ page }) => {
|
||||
await page.getByRole("button", { name: /Benutzermenue/ }).click();
|
||||
await page.getByRole("menuitem", { name: "Abmelden" }).click();
|
||||
await expect(page).toHaveURL(/\/login/);
|
||||
|
||||
// Und die geschuetzte Seite ist wieder zu.
|
||||
await page.goto("/");
|
||||
await expect(page).toHaveURL(/\/login/);
|
||||
});
|
||||
@@ -9,21 +9,6 @@ const nextConfig: NextConfig = {
|
||||
poweredByHeader: false,
|
||||
// Prisma darf nicht gebundlet werden, sonst findet der Client seine Engine nicht.
|
||||
serverExternalPackages: ["@prisma/client", "prisma"],
|
||||
images: {
|
||||
/**
|
||||
* Der Bildoptimierer ist abgeschaltet.
|
||||
*
|
||||
* Nebula benutzt next/image nirgends – die paar Symbole sind SVG und
|
||||
* PNG in fester Groesse. Der Endpunkt /_next/image waere aber trotzdem
|
||||
* da, und zwar ohne Anmeldung: die Middleware nimmt ihn aus, weil dort
|
||||
* sonst nur Rechenzeit verbraucht wuerde.
|
||||
*
|
||||
* Er reicht jedes Bild durch sharp und damit durch libvips, fuer das es
|
||||
* regelmaessig Schwachstellen gibt (aktuell CVE-2026-33327 und drei
|
||||
* weitere). Eine Angriffsflaeche ohne Gegenwert – also weg damit.
|
||||
*/
|
||||
unoptimized: true,
|
||||
},
|
||||
};
|
||||
|
||||
export default nextConfig;
|
||||
|
||||
Generated
+9
-2892
File diff suppressed because it is too large
Load Diff
+7
-23
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "nebula",
|
||||
"version": "1.11.0",
|
||||
"version": "0.1.0",
|
||||
"private": true,
|
||||
"description": "Nebula – Dashboard fuer Vibe-Coding Projekte mit Git-Anbindung (GitHub, GitLab, Gitea)",
|
||||
"scripts": {
|
||||
@@ -16,53 +16,37 @@
|
||||
"db:studio": "prisma studio",
|
||||
"db:seed": "prisma db seed",
|
||||
"db:reset": "prisma migrate reset",
|
||||
"docker:db": "docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d db",
|
||||
"docker:db": "docker compose up -d db",
|
||||
"docker:db:down": "docker compose stop db",
|
||||
"docker:up": "docker compose --profile full up -d --build",
|
||||
"docker:down": "docker compose --profile full down",
|
||||
"docker:logs": "docker compose --profile full logs -f app",
|
||||
"docker:tools": "docker compose --profile tools up -d",
|
||||
"setup": "node scripts/setup.mjs",
|
||||
"postinstall": "prisma generate",
|
||||
"test": "vitest run",
|
||||
"test:watch": "vitest",
|
||||
"test:e2e": "npm run build && playwright test",
|
||||
"test:e2e:ui": "playwright test --ui",
|
||||
"test:all": "npm test && npm run test:e2e"
|
||||
"postinstall": "prisma generate"
|
||||
},
|
||||
"prisma": {
|
||||
"seed": "tsx prisma/seed.ts"
|
||||
},
|
||||
"dependencies": {
|
||||
"@dnd-kit/core": "^6.3.1",
|
||||
"@dnd-kit/modifiers": "^9.0.0",
|
||||
"@dnd-kit/sortable": "^10.0.0",
|
||||
"@prisma/client": "^6.8.2",
|
||||
"@simplewebauthn/browser": "^13.3.0",
|
||||
"@simplewebauthn/server": "^13.3.2",
|
||||
"lucide-react": "^0.511.0",
|
||||
"next": "^15.3.3",
|
||||
"nodemailer": "^9.0.3",
|
||||
"qrcode": "^1.5.4",
|
||||
"react": "^19.1.0",
|
||||
"react-dom": "^19.1.0",
|
||||
"react-markdown": "^10.1.0",
|
||||
"rehype-sanitize": "^6.0.0",
|
||||
"remark-gfm": "^4.0.1",
|
||||
"zod": "^3.25.28"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@playwright/test": "^1.62.0",
|
||||
"@tailwindcss/postcss": "^4.1.7",
|
||||
"@types/node": "^22.15.21",
|
||||
"@types/nodemailer": "^8.0.1",
|
||||
"@types/qrcode": "^1.5.6",
|
||||
"@types/react": "^19.1.5",
|
||||
"@types/react-dom": "^19.1.5",
|
||||
"axe-core": "^4.12.1",
|
||||
"dotenv": "^17.4.2",
|
||||
"prisma": "^6.8.2",
|
||||
"tailwindcss": "^4.1.7",
|
||||
"tsx": "^4.19.4",
|
||||
"typescript": "^5.8.3",
|
||||
"vitest": "^4.1.10"
|
||||
"typescript": "^5.8.3"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=20.11"
|
||||
|
||||
@@ -1,63 +0,0 @@
|
||||
import { defineConfig } from "@playwright/test";
|
||||
|
||||
/**
|
||||
* Ende-zu-Ende-Tests gegen die echte Anwendung.
|
||||
*
|
||||
* Playwright startet den Produktionsserver selbst und richtet ihn auf eine
|
||||
* eigene Datenbank. Der Port ist bewusst ein anderer als 3000 und 3100,
|
||||
* damit eine laufende Instanz nicht stoert.
|
||||
*
|
||||
* Voraussetzung: ein Bau (`npm run build`) und eine leere Datenbank, deren
|
||||
* Name "test" enthaelt – siehe global-setup.ts. Beides erledigt
|
||||
* `npm run test:e2e`.
|
||||
*/
|
||||
|
||||
const PORT = Number(process.env.E2E_PORT ?? 3111);
|
||||
const BASE_URL = `http://localhost:${PORT}`;
|
||||
|
||||
const DATABASE_URL =
|
||||
process.env.E2E_DATABASE_URL ??
|
||||
"postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public";
|
||||
|
||||
export default defineConfig({
|
||||
testDir: "./e2e",
|
||||
// Die Tests teilen sich eine Datenbank, deshalb nacheinander.
|
||||
fullyParallel: false,
|
||||
workers: 1,
|
||||
forbidOnly: Boolean(process.env.CI),
|
||||
retries: process.env.CI ? 1 : 0,
|
||||
reporter: process.env.CI ? [["list"], ["html", { open: "never" }]] : [["list"]],
|
||||
timeout: 60_000,
|
||||
expect: { timeout: 10_000 },
|
||||
|
||||
globalSetup: "./e2e/global-setup.ts",
|
||||
|
||||
use: {
|
||||
baseURL: BASE_URL,
|
||||
locale: "de-DE",
|
||||
timezoneId: "Europe/Berlin",
|
||||
trace: "retain-on-failure",
|
||||
screenshot: "only-on-failure",
|
||||
// Oertlich der installierte Chrome, damit kein Browser geladen werden
|
||||
// muss. In CI gibt es keinen – dort das mitgelieferte Chromium
|
||||
// (siehe "playwright install chromium" im Arbeitsablauf).
|
||||
...(process.env.CI ? {} : { channel: "chrome" as const }),
|
||||
},
|
||||
|
||||
webServer: {
|
||||
command: "npm start",
|
||||
url: `${BASE_URL}/api/health`,
|
||||
reuseExistingServer: false,
|
||||
timeout: 120_000,
|
||||
stdout: "pipe",
|
||||
stderr: "pipe",
|
||||
env: {
|
||||
DATABASE_URL,
|
||||
PORT: String(PORT),
|
||||
APP_URL: BASE_URL,
|
||||
NODE_ENV: "production",
|
||||
// Fester Schluessel, damit Laeufe vergleichbar bleiben.
|
||||
APP_SECRET: "e2e-test-secret-nur-fuer-die-testlaeufe-1234567890",
|
||||
},
|
||||
},
|
||||
});
|
||||
@@ -1,24 +0,0 @@
|
||||
import { config as loadEnv } from "dotenv";
|
||||
import { defineConfig } from "prisma/config";
|
||||
|
||||
/**
|
||||
* Konfiguration der Prisma-CLI.
|
||||
*
|
||||
* Loest den Abschnitt `prisma` in der package.json ab, der mit Prisma 7
|
||||
* wegfaellt.
|
||||
*
|
||||
* **Der Aufruf von dotenv ist nicht optional.** Sobald diese Datei
|
||||
* existiert, liest Prisma die .env nicht mehr von selbst ein – ohne die
|
||||
* folgenden Zeilen stuende `migrate deploy` plotzlich ohne DATABASE_URL da,
|
||||
* und zwar mit einer Fehlermeldung, die nicht darauf hindeutet. Erst .env,
|
||||
* dann .env.local: eine oertliche Abweichung soll gewinnen.
|
||||
*/
|
||||
loadEnv({ path: ".env", quiet: true });
|
||||
loadEnv({ path: ".env.local", override: true, quiet: true });
|
||||
|
||||
export default defineConfig({
|
||||
schema: "prisma/schema.prisma",
|
||||
migrations: {
|
||||
seed: "tsx prisma/seed.ts",
|
||||
},
|
||||
});
|
||||
@@ -1,16 +0,0 @@
|
||||
-- Volltextsuche ueber Notizen.
|
||||
--
|
||||
-- Dies ist ein Ausdrucksindex. Prisma kann so etwas im Schema nicht abbilden
|
||||
-- und kennt ihn deshalb nicht. Nachgeprueft: "prisma migrate diff" laesst ihn
|
||||
-- in Ruhe und schlaegt kein DROP vor - Ausdrucksindizes werden schlicht
|
||||
-- ignoriert. Trotzdem beim Erzeugen kuenftiger Migrationen kurz hinsehen.
|
||||
--
|
||||
-- Faellt er doch einmal weg, funktioniert die Suche weiter, nur langsamer:
|
||||
-- Postgres berechnet to_tsvector dann je Zeile.
|
||||
--
|
||||
-- Der Ausdruck muss mit dem in src/app/api/search/route.ts uebereinstimmen,
|
||||
-- sonst greift der Index nicht. Die zweistellige Form von to_tsvector mit
|
||||
-- fester Konfiguration ist IMMUTABLE und damit indizierbar.
|
||||
|
||||
CREATE INDEX "Note_fulltext_idx" ON "Note"
|
||||
USING GIN (to_tsvector('german', coalesce("title", '') || ' ' || "content"));
|
||||
@@ -1,9 +0,0 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "RepoSnapshot" ADD COLUMN "ciBranch" TEXT,
|
||||
ADD COLUMN "ciFinishedAt" TIMESTAMP(3),
|
||||
ADD COLUMN "ciName" TEXT,
|
||||
ADD COLUMN "ciState" TEXT,
|
||||
ADD COLUMN "ciUrl" TEXT,
|
||||
ADD COLUMN "commitActivity" JSONB NOT NULL DEFAULT '[]',
|
||||
ADD COLUMN "issues" JSONB NOT NULL DEFAULT '[]',
|
||||
ADD COLUMN "pullRequests" JSONB NOT NULL DEFAULT '[]';
|
||||
@@ -1,28 +0,0 @@
|
||||
-- CreateEnum
|
||||
CREATE TYPE "TaskStatus" AS ENUM ('TODO', 'DOING', 'BLOCKED', 'DONE');
|
||||
|
||||
-- AlterTable
|
||||
ALTER TABLE "Project" ADD COLUMN "progressFromTasks" BOOLEAN NOT NULL DEFAULT false;
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE "Task" (
|
||||
"id" TEXT NOT NULL,
|
||||
"projectId" TEXT NOT NULL,
|
||||
"title" TEXT NOT NULL,
|
||||
"description" TEXT,
|
||||
"status" "TaskStatus" NOT NULL DEFAULT 'TODO',
|
||||
"position" INTEGER NOT NULL DEFAULT 0,
|
||||
"dueDate" TIMESTAMP(3),
|
||||
"labels" TEXT[] DEFAULT ARRAY[]::TEXT[],
|
||||
"doneAt" TIMESTAMP(3),
|
||||
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"updatedAt" TIMESTAMP(3) NOT NULL,
|
||||
|
||||
CONSTRAINT "Task_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "Task_projectId_status_position_idx" ON "Task"("projectId", "status", "position");
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "Task" ADD CONSTRAINT "Task_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
@@ -1,39 +0,0 @@
|
||||
-- CreateEnum
|
||||
CREATE TYPE "NotificationChannel" AS ENUM ('WEBHOOK', 'NTFY', 'EMAIL');
|
||||
|
||||
-- CreateEnum
|
||||
CREATE TYPE "NotificationEvent" AS ENUM ('SYNC_FAILED', 'CI_FAILED', 'NEW_RELEASE');
|
||||
|
||||
-- AlterTable
|
||||
ALTER TABLE "Project" ADD COLUMN "notifiedCiState" TEXT,
|
||||
ADD COLUMN "notifiedRelease" TEXT,
|
||||
ADD COLUMN "notifiedSyncError" TEXT;
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE "NotificationTarget" (
|
||||
"id" TEXT NOT NULL,
|
||||
"userId" TEXT NOT NULL,
|
||||
"name" TEXT NOT NULL,
|
||||
"channel" "NotificationChannel" NOT NULL,
|
||||
"target" TEXT NOT NULL,
|
||||
"secretCipher" TEXT,
|
||||
"secretHint" TEXT,
|
||||
"events" "NotificationEvent"[] DEFAULT ARRAY[]::"NotificationEvent"[],
|
||||
"isActive" BOOLEAN NOT NULL DEFAULT true,
|
||||
"lastSentAt" TIMESTAMP(3),
|
||||
"lastOk" BOOLEAN,
|
||||
"lastMessage" TEXT,
|
||||
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"updatedAt" TIMESTAMP(3) NOT NULL,
|
||||
|
||||
CONSTRAINT "NotificationTarget_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "NotificationTarget_userId_idx" ON "NotificationTarget"("userId");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "NotificationTarget_userId_name_key" ON "NotificationTarget"("userId", "name");
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "NotificationTarget" ADD CONSTRAINT "NotificationTarget_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
@@ -1,9 +0,0 @@
|
||||
-- AlterEnum
|
||||
ALTER TYPE "NotificationEvent" ADD VALUE 'PROJECT_STALE';
|
||||
|
||||
-- AlterTable
|
||||
ALTER TABLE "AppSettings" ADD COLUMN "lastStaleCheckAt" TIMESTAMP(3),
|
||||
ADD COLUMN "staleAfterDays" INTEGER NOT NULL DEFAULT 60;
|
||||
|
||||
-- AlterTable
|
||||
ALTER TABLE "Project" ADD COLUMN "notifiedStaleAt" TIMESTAMP(3);
|
||||
@@ -1,6 +0,0 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "Task" ADD COLUMN "sourceIssue" INTEGER,
|
||||
ADD COLUMN "sourceUrl" TEXT;
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "Task_projectId_sourceIssue_key" ON "Task"("projectId", "sourceIssue");
|
||||
@@ -1,24 +0,0 @@
|
||||
-- CreateEnum
|
||||
CREATE TYPE "ActivityKind" AS ENUM ('PROJECT_CREATED', 'PROJECT_UPDATED', 'STATUS_CHANGED', 'NOTE_ADDED', 'NOTE_UPDATED', 'NOTE_DELETED', 'TASK_ADDED', 'TASK_MOVED', 'TASK_DELETED', 'TASKS_IMPORTED', 'REPO_LINKED', 'REPO_COMMITS', 'SYNC_FAILED');
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE "Activity" (
|
||||
"id" TEXT NOT NULL,
|
||||
"projectId" TEXT NOT NULL,
|
||||
"userId" TEXT,
|
||||
"kind" "ActivityKind" NOT NULL,
|
||||
"summary" TEXT NOT NULL,
|
||||
"meta" JSONB,
|
||||
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
|
||||
CONSTRAINT "Activity_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "Activity_projectId_createdAt_idx" ON "Activity"("projectId", "createdAt");
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "Activity" ADD CONSTRAINT "Activity_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "Activity" ADD CONSTRAINT "Activity_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
|
||||
@@ -1,47 +0,0 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "User" ADD COLUMN "totpEnabledAt" TIMESTAMP(3),
|
||||
ADD COLUMN "totpSecretCipher" TEXT;
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE "RecoveryCode" (
|
||||
"id" TEXT NOT NULL,
|
||||
"userId" TEXT NOT NULL,
|
||||
"codeHash" TEXT NOT NULL,
|
||||
"usedAt" TIMESTAMP(3),
|
||||
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
|
||||
CONSTRAINT "RecoveryCode_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE "PendingLogin" (
|
||||
"id" TEXT NOT NULL,
|
||||
"userId" TEXT NOT NULL,
|
||||
"tokenHash" TEXT NOT NULL,
|
||||
"attempts" INTEGER NOT NULL DEFAULT 0,
|
||||
"expiresAt" TIMESTAMP(3) NOT NULL,
|
||||
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
|
||||
CONSTRAINT "PendingLogin_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "RecoveryCode_codeHash_key" ON "RecoveryCode"("codeHash");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "RecoveryCode_userId_idx" ON "RecoveryCode"("userId");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "PendingLogin_tokenHash_key" ON "PendingLogin"("tokenHash");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "PendingLogin_userId_idx" ON "PendingLogin"("userId");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "PendingLogin_expiresAt_idx" ON "PendingLogin"("expiresAt");
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "RecoveryCode" ADD CONSTRAINT "RecoveryCode_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "PendingLogin" ADD CONSTRAINT "PendingLogin_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
@@ -1,113 +0,0 @@
|
||||
-- Mehrere Repositories je Projekt.
|
||||
--
|
||||
-- Die Git-Felder wandern vom Projekt in eine eigene Tabelle. Bestehende
|
||||
-- Projekte bekommen daraus genau ein Repository, damit nichts verlorengeht;
|
||||
-- der Snapshot haengt danach am Repository statt am Projekt.
|
||||
--
|
||||
-- Von Hand geschrieben: prisma migrate diff wuerde die Spalten am Projekt
|
||||
-- ersatzlos loeschen und die Snapshots gleich mit.
|
||||
|
||||
-- ── 1. Neue Tabelle ─────────────────────────────────────────
|
||||
CREATE TABLE "Repository" (
|
||||
"id" TEXT NOT NULL,
|
||||
"projectId" TEXT NOT NULL,
|
||||
"label" TEXT,
|
||||
"repoUrl" TEXT,
|
||||
"repoOwner" TEXT,
|
||||
"repoName" TEXT,
|
||||
"defaultBranch" TEXT,
|
||||
"connectionId" TEXT,
|
||||
"position" INTEGER NOT NULL DEFAULT 0,
|
||||
"lastSyncedAt" TIMESTAMP(3),
|
||||
"syncError" TEXT,
|
||||
"autoSync" BOOLEAN NOT NULL DEFAULT true,
|
||||
"syncFailureCount" INTEGER NOT NULL DEFAULT 0,
|
||||
"notifiedSyncError" TEXT,
|
||||
"notifiedCiState" TEXT,
|
||||
"notifiedRelease" TEXT,
|
||||
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"updatedAt" TIMESTAMP(3) NOT NULL,
|
||||
|
||||
CONSTRAINT "Repository_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
CREATE INDEX "Repository_projectId_position_idx" ON "Repository"("projectId", "position");
|
||||
CREATE INDEX "Repository_connectionId_idx" ON "Repository"("connectionId");
|
||||
|
||||
ALTER TABLE "Repository" ADD CONSTRAINT "Repository_projectId_fkey"
|
||||
FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
ALTER TABLE "Repository" ADD CONSTRAINT "Repository_connectionId_fkey"
|
||||
FOREIGN KEY ("connectionId") REFERENCES "GitConnection"("id") ON DELETE SET NULL ON UPDATE CASCADE;
|
||||
|
||||
-- ── 2. Bestand uebernehmen ──────────────────────────────────
|
||||
-- Nur Projekte, an denen wirklich etwas haengt. Ein Projekt, das bloss eine
|
||||
-- Verbindung ausgewaehlt hatte, ohne je ein Repo zu nennen, braucht keine
|
||||
-- leere Zeile.
|
||||
INSERT INTO "Repository" (
|
||||
"id", "projectId", "repoUrl", "repoOwner", "repoName", "defaultBranch",
|
||||
"connectionId", "position", "lastSyncedAt", "syncError", "autoSync",
|
||||
"syncFailureCount", "notifiedSyncError", "notifiedCiState", "notifiedRelease",
|
||||
"createdAt", "updatedAt"
|
||||
)
|
||||
SELECT
|
||||
gen_random_uuid()::text, "id", "repoUrl", "repoOwner", "repoName", "defaultBranch",
|
||||
"connectionId", 0, "lastSyncedAt", "syncError", "autoSync",
|
||||
"syncFailureCount", "notifiedSyncError", "notifiedCiState", "notifiedRelease",
|
||||
"createdAt", CURRENT_TIMESTAMP
|
||||
FROM "Project"
|
||||
WHERE "repoUrl" IS NOT NULL
|
||||
OR ("repoOwner" IS NOT NULL AND "repoName" IS NOT NULL);
|
||||
|
||||
-- ── 3. Snapshots umhaengen ──────────────────────────────────
|
||||
ALTER TABLE "RepoSnapshot" ADD COLUMN "repositoryId" TEXT;
|
||||
|
||||
UPDATE "RepoSnapshot" AS s
|
||||
SET "repositoryId" = r."id"
|
||||
FROM "Repository" AS r
|
||||
WHERE r."projectId" = s."projectId";
|
||||
|
||||
-- Ein Snapshot ohne zugehoeriges Repository kann nur entstanden sein, wenn
|
||||
-- jemand die Repo-Angaben nachtraeglich geleert hat. Er ist ohnehin nicht
|
||||
-- mehr zuzuordnen und beim naechsten Abgleich neu geholt.
|
||||
DELETE FROM "RepoSnapshot" WHERE "repositoryId" IS NULL;
|
||||
|
||||
ALTER TABLE "RepoSnapshot" ALTER COLUMN "repositoryId" SET NOT NULL;
|
||||
ALTER TABLE "RepoSnapshot" DROP CONSTRAINT "RepoSnapshot_projectId_fkey";
|
||||
DROP INDEX "RepoSnapshot_projectId_key";
|
||||
ALTER TABLE "RepoSnapshot" DROP COLUMN "projectId";
|
||||
|
||||
CREATE UNIQUE INDEX "RepoSnapshot_repositoryId_key" ON "RepoSnapshot"("repositoryId");
|
||||
ALTER TABLE "RepoSnapshot" ADD CONSTRAINT "RepoSnapshot_repositoryId_fkey"
|
||||
FOREIGN KEY ("repositoryId") REFERENCES "Repository"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
|
||||
-- ── 4. Herkunft uebernommener Aufgaben ──────────────────────
|
||||
-- Bisher war die Issue-Nummer je Projekt eindeutig. Mit mehreren Repos
|
||||
-- reicht das nicht mehr: Frontend und Backend haben beide ein Issue 5.
|
||||
ALTER TABLE "Task" ADD COLUMN "sourceRepositoryId" TEXT;
|
||||
|
||||
UPDATE "Task" AS t
|
||||
SET "sourceRepositoryId" = r."id"
|
||||
FROM "Repository" AS r
|
||||
WHERE r."projectId" = t."projectId" AND t."sourceIssue" IS NOT NULL;
|
||||
|
||||
DROP INDEX "Task_projectId_sourceIssue_key";
|
||||
CREATE UNIQUE INDEX "Task_projectId_sourceRepositoryId_sourceIssue_key"
|
||||
ON "Task"("projectId", "sourceRepositoryId", "sourceIssue");
|
||||
|
||||
-- ── 5. Projekt aufraeumen ───────────────────────────────────
|
||||
ALTER TABLE "Project" DROP CONSTRAINT "Project_connectionId_fkey";
|
||||
DROP INDEX "Project_connectionId_idx";
|
||||
|
||||
ALTER TABLE "Project"
|
||||
DROP COLUMN "repoUrl",
|
||||
DROP COLUMN "repoOwner",
|
||||
DROP COLUMN "repoName",
|
||||
DROP COLUMN "defaultBranch",
|
||||
DROP COLUMN "connectionId",
|
||||
DROP COLUMN "lastSyncedAt",
|
||||
DROP COLUMN "syncError",
|
||||
DROP COLUMN "autoSync",
|
||||
DROP COLUMN "syncFailureCount",
|
||||
DROP COLUMN "notifiedSyncError",
|
||||
DROP COLUMN "notifiedCiState",
|
||||
DROP COLUMN "notifiedRelease";
|
||||
@@ -1,20 +0,0 @@
|
||||
-- Freie Reihenfolge im Projektbrett.
|
||||
--
|
||||
-- Der Bestand bekommt seine Position aus der bisherigen Anzeige: je Konto und
|
||||
-- Spalte nach Aenderungsdatum absteigend. Ohne diesen Schritt staenden alle
|
||||
-- auf 0 und das Brett zeigte eine willkuerliche Reihenfolge, die sich bei
|
||||
-- jedem Laden anders ergeben koennte.
|
||||
|
||||
ALTER TABLE "Project" ADD COLUMN "position" INTEGER NOT NULL DEFAULT 0;
|
||||
|
||||
UPDATE "Project" AS p
|
||||
SET "position" = nummeriert.rang - 1
|
||||
FROM (
|
||||
SELECT "id", ROW_NUMBER() OVER (
|
||||
PARTITION BY "ownerId", "status" ORDER BY "updatedAt" DESC, "id"
|
||||
) AS rang
|
||||
FROM "Project"
|
||||
) AS nummeriert
|
||||
WHERE nummeriert."id" = p."id";
|
||||
|
||||
CREATE INDEX "Project_ownerId_status_position_idx" ON "Project"("ownerId", "status", "position");
|
||||
@@ -1,3 +0,0 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "RepoSnapshot" ADD COLUMN "commitCalendar" JSONB NOT NULL DEFAULT '{}',
|
||||
ADD COLUMN "commitCalendarAt" TIMESTAMP(3);
|
||||
@@ -1,29 +0,0 @@
|
||||
-- CreateTable
|
||||
CREATE TABLE "ProjectTemplate" (
|
||||
"id" TEXT NOT NULL,
|
||||
"ownerId" TEXT NOT NULL,
|
||||
"name" TEXT NOT NULL,
|
||||
"description" TEXT,
|
||||
"summary" TEXT,
|
||||
"projectDescription" TEXT,
|
||||
"status" "ProjectStatus" NOT NULL DEFAULT 'IDEA',
|
||||
"priority" INTEGER NOT NULL DEFAULT 2,
|
||||
"accent" TEXT NOT NULL DEFAULT 'violet',
|
||||
"tags" TEXT[] DEFAULT ARRAY[]::TEXT[],
|
||||
"progressFromTasks" BOOLEAN NOT NULL DEFAULT false,
|
||||
"notes" JSONB NOT NULL DEFAULT '[]',
|
||||
"tasks" JSONB NOT NULL DEFAULT '[]',
|
||||
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"updatedAt" TIMESTAMP(3) NOT NULL,
|
||||
|
||||
CONSTRAINT "ProjectTemplate_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "ProjectTemplate_ownerId_idx" ON "ProjectTemplate"("ownerId");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "ProjectTemplate_ownerId_name_key" ON "ProjectTemplate"("ownerId", "name");
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "ProjectTemplate" ADD CONSTRAINT "ProjectTemplate_ownerId_fkey" FOREIGN KEY ("ownerId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
@@ -1,6 +0,0 @@
|
||||
-- CreateEnum
|
||||
CREATE TYPE "Recurrence" AS ENUM ('DAILY', 'WEEKLY', 'BIWEEKLY', 'MONTHLY');
|
||||
|
||||
-- AlterTable
|
||||
ALTER TABLE "Task" ADD COLUMN "recurredFrom" TEXT,
|
||||
ADD COLUMN "recurrence" "Recurrence";
|
||||
@@ -1,5 +0,0 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "RepoSnapshot" ADD COLUMN "readme" TEXT,
|
||||
ADD COLUMN "readmeAt" TIMESTAMP(3),
|
||||
ADD COLUMN "readmeBaseUrl" TEXT,
|
||||
ADD COLUMN "readmePath" TEXT;
|
||||
@@ -1,2 +0,0 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "User" ADD COLUMN "totpLastCounter" INTEGER;
|
||||
@@ -1,3 +0,0 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "Repository" ADD COLUMN "webhookLastAt" TIMESTAMP(3),
|
||||
ADD COLUMN "webhookSecret" TEXT;
|
||||
@@ -1,20 +0,0 @@
|
||||
-- Volltextsuche ueber Aufgaben.
|
||||
--
|
||||
-- Wie Note_fulltext_idx ein Ausdrucksindex: Prisma kann so etwas im Schema
|
||||
-- nicht abbilden und kennt ihn deshalb nicht. Nachgeprueft mit
|
||||
-- "prisma migrate diff" gegen das Schema - es kommt "empty migration"
|
||||
-- heraus, der Index wird also weder angelegt noch geloescht. Trotzdem beim
|
||||
-- Erzeugen kuenftiger Migrationen kurz hinsehen.
|
||||
--
|
||||
-- Faellt er doch einmal weg, funktioniert die Suche weiter, nur langsamer:
|
||||
-- Postgres berechnet to_tsvector dann je Zeile.
|
||||
--
|
||||
-- Der Ausdruck muss Zeichen fuer Zeichen dem in src/app/api/search/route.ts
|
||||
-- entsprechen, sonst greift der Index nicht. Die zweistellige Form von
|
||||
-- to_tsvector mit fester Konfiguration ist IMMUTABLE und damit indizierbar.
|
||||
--
|
||||
-- Anders als bei der Notiz ist auch die Beschreibung optional, deshalb steht
|
||||
-- coalesce um beide Spalten.
|
||||
|
||||
CREATE INDEX "Task_fulltext_idx" ON "Task"
|
||||
USING GIN (to_tsvector('german', coalesce("title", '') || ' ' || coalesce("description", '')));
|
||||
@@ -1,2 +0,0 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "AppSettings" ADD COLUMN "taskColumnLimit" INTEGER NOT NULL DEFAULT 15;
|
||||
@@ -1,3 +0,0 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "RepoSnapshot" ADD COLUMN "completeAt" TIMESTAMP(3),
|
||||
ADD COLUMN "missing" JSONB NOT NULL DEFAULT '{}';
|
||||
+32
-390
@@ -33,62 +33,6 @@ enum GitProvider {
|
||||
GITEA
|
||||
}
|
||||
|
||||
/// Zustellwege fuer Benachrichtigungen.
|
||||
enum NotificationChannel {
|
||||
WEBHOOK
|
||||
NTFY
|
||||
EMAIL
|
||||
}
|
||||
|
||||
/// Anlaesse, ueber die benachrichtigt werden kann.
|
||||
enum NotificationEvent {
|
||||
/// Ein Abgleich mit dem Git-System ist fehlgeschlagen.
|
||||
SYNC_FAILED
|
||||
/// Der letzte CI-Lauf auf dem Default-Branch ist rot.
|
||||
CI_FAILED
|
||||
/// Im Repository ist ein neuer Tag oder ein neues Release aufgetaucht.
|
||||
NEW_RELEASE
|
||||
/// Seit laengerem kein Commit mehr – der sanfte Stups.
|
||||
PROJECT_STALE
|
||||
}
|
||||
|
||||
/// Was im Verlauf eines Projekts festgehalten wird. Bewusst grob: der
|
||||
/// Verlauf soll erzaehlen, was passiert ist, und nicht jede Feldaenderung
|
||||
/// mitschreiben.
|
||||
enum ActivityKind {
|
||||
PROJECT_CREATED
|
||||
PROJECT_UPDATED
|
||||
STATUS_CHANGED
|
||||
NOTE_ADDED
|
||||
NOTE_UPDATED
|
||||
NOTE_DELETED
|
||||
TASK_ADDED
|
||||
TASK_MOVED
|
||||
TASK_DELETED
|
||||
TASKS_IMPORTED
|
||||
REPO_LINKED
|
||||
REPO_COMMITS
|
||||
SYNC_FAILED
|
||||
}
|
||||
|
||||
/// Wie oft sich eine Aufgabe wiederholt. Bewusst grob: feinere Regeln
|
||||
/// (jeden zweiten Dienstag im Monat) braucht ein Projektdashboard nicht,
|
||||
/// und sie waeren ohne Kalenderansicht kaum nachvollziehbar.
|
||||
enum Recurrence {
|
||||
DAILY
|
||||
WEEKLY
|
||||
BIWEEKLY
|
||||
MONTHLY
|
||||
}
|
||||
|
||||
/// Spalten des Aufgabenbretts innerhalb eines Projekts.
|
||||
enum TaskStatus {
|
||||
TODO
|
||||
DOING
|
||||
BLOCKED
|
||||
DONE
|
||||
}
|
||||
|
||||
/// ADMIN darf Benutzer und Einstellungen verwalten. Auf fremde Projekte hat
|
||||
/// auch ein Admin keinen Zugriff – die Trennung ist bewusst hart.
|
||||
enum UserRole {
|
||||
@@ -122,26 +66,10 @@ model User {
|
||||
failedLoginCount Int @default(0)
|
||||
lockedUntil DateTime?
|
||||
|
||||
/// TOTP-Schluessel, AES-256-GCM-verschluesselt (siehe src/lib/crypto.ts).
|
||||
/// Hinterlegt heisst noch nicht scharf: erst ein bestaetigter Code setzt
|
||||
/// totpEnabledAt. Bis dahin darf die Anmeldung nicht danach fragen, sonst
|
||||
/// sperrt sich aus, wer die Einrichtung abbricht.
|
||||
totpSecretCipher String?
|
||||
totpEnabledAt DateTime?
|
||||
/// Zuletzt eingeloestes Zeitfenster. RFC 6238 verlangt, denselben Code
|
||||
/// kein zweites Mal anzunehmen – ohne diesen Merker liesse sich ein
|
||||
/// abgefangener Code die restliche Gueltigkeit ueber wiederverwenden.
|
||||
totpLastCounter Int?
|
||||
|
||||
sessions Session[]
|
||||
credentials Credential[]
|
||||
projects Project[]
|
||||
connections GitConnection[]
|
||||
notificationTargets NotificationTarget[]
|
||||
activities Activity[]
|
||||
recoveryCodes RecoveryCode[]
|
||||
pendingLogins PendingLogin[]
|
||||
templates ProjectTemplate[]
|
||||
|
||||
createdAt DateTime @default(now())
|
||||
updatedAt DateTime @updatedAt
|
||||
@@ -186,45 +114,6 @@ model Credential {
|
||||
@@index([userId])
|
||||
}
|
||||
|
||||
/// Ein Wiederherstellungscode fuer den Fall, dass der Authenticator weg ist.
|
||||
/// Jeder Code gilt genau einmal.
|
||||
model RecoveryCode {
|
||||
id String @id @default(cuid())
|
||||
userId String
|
||||
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
|
||||
|
||||
/// SHA-256 des Codes. Kein langsames Verfahren wie bei Passwoertern: die
|
||||
/// Codes sind zufaellig erzeugt und lang genug, dass Raten aussichtslos
|
||||
/// ist – und bei einer Anmeldung waeren sonst zehn teure Vergleiche noetig.
|
||||
codeHash String @unique
|
||||
|
||||
usedAt DateTime?
|
||||
createdAt DateTime @default(now())
|
||||
|
||||
@@index([userId])
|
||||
}
|
||||
|
||||
/// Zwischenzustand einer Anmeldung: Passwort stimmt, der zweite Faktor fehlt
|
||||
/// noch. Bewusst eine eigene Zeile und keine halbfertige Sitzung – so kann
|
||||
/// aus diesem Zustand nichts entstehen, was einer Anmeldung aehnelt.
|
||||
model PendingLogin {
|
||||
id String @id @default(cuid())
|
||||
userId String
|
||||
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
|
||||
|
||||
/// Wie bei der Sitzung liegt nur der SHA-256-Hash des Cookie-Tokens hier.
|
||||
tokenHash String @unique
|
||||
/// Fehlversuche. Nach zu vielen wird der Vorgang verworfen, damit die
|
||||
/// sechs Stellen nicht in Ruhe durchprobiert werden koennen.
|
||||
attempts Int @default(0)
|
||||
|
||||
expiresAt DateTime
|
||||
createdAt DateTime @default(now())
|
||||
|
||||
@@index([userId])
|
||||
@@index([expiresAt])
|
||||
}
|
||||
|
||||
/// Kurzlebige WebAuthn-Challenge. Wird nach Gebrauch geloescht, damit sie
|
||||
/// kein zweites Mal verwendet werden kann.
|
||||
model WebAuthnChallenge {
|
||||
@@ -266,17 +155,6 @@ model AppSettings {
|
||||
/// Kurzbericht des letzten Durchlaufs: { synced, failed, skipped, ms }
|
||||
lastAutoSyncReport Json?
|
||||
|
||||
// ── Aufgabenbrett ──────────────────────────────────────────
|
||||
/// Hoechstzahl Karten je Spalte. Was darueber hinausgeht, kommt hinter
|
||||
/// einen Knopf – verborgen wird nichts. 0 schaltet die Begrenzung ab.
|
||||
taskColumnLimit Int @default(15)
|
||||
|
||||
// ── Stillstand ─────────────────────────────────────────────
|
||||
/// Ab wie vielen Tagen ohne Commit ein Projekt als stillstehend gilt.
|
||||
staleAfterDays Int @default(60)
|
||||
/// Die Pruefung laeuft hoechstens einmal am Tag.
|
||||
lastStaleCheckAt DateTime?
|
||||
|
||||
updatedAt DateTime @updatedAt
|
||||
}
|
||||
|
||||
@@ -306,7 +184,7 @@ model GitConnection {
|
||||
ownerId String?
|
||||
owner User? @relation(fields: [ownerId], references: [id], onDelete: Cascade)
|
||||
|
||||
repositories Repository[]
|
||||
projects Project[]
|
||||
|
||||
createdAt DateTime @default(now())
|
||||
updatedAt DateTime @updatedAt
|
||||
@@ -335,235 +213,41 @@ model Project {
|
||||
accent String @default("violet")
|
||||
tags String[] @default([])
|
||||
favorite Boolean @default(false)
|
||||
/// Rang innerhalb der Statusspalte im Brett. Nur dort wirksam – die
|
||||
/// uebrigen Ansichten folgen der gewaehlten Sortierung.
|
||||
position Int @default(0)
|
||||
|
||||
// ── Git-Anbindung ──────────────────────────────────────────
|
||||
repoUrl String?
|
||||
/// Owner bzw. Namespace/Gruppe (bei GitLab auch verschachtelt: "gruppe/subgruppe")
|
||||
repoOwner String?
|
||||
repoName String?
|
||||
defaultBranch String?
|
||||
connectionId String?
|
||||
connection GitConnection? @relation(fields: [connectionId], references: [id], onDelete: SetNull)
|
||||
|
||||
lastSyncedAt DateTime?
|
||||
syncError String?
|
||||
/// Am automatischen Abgleich teilnehmen. Einzeln abschaltbar, etwa bei
|
||||
/// einem Repo, dessen Token staendig Fehler wirft.
|
||||
autoSync Boolean @default(true)
|
||||
/// Aufeinanderfolgende Fehlversuche. Steuert das Zurueckhalten: nach
|
||||
/// jedem Fehlschlag wird der naechste Versuch weiter hinausgezoegert.
|
||||
syncFailureCount Int @default(0)
|
||||
|
||||
/// Besitzer. Nullable wie bei GitConnection, damit Bestandsdaten beim
|
||||
/// Einrichten des ersten Kontos uebernommen werden koennen.
|
||||
ownerId String?
|
||||
owner User? @relation(fields: [ownerId], references: [id], onDelete: Cascade)
|
||||
|
||||
/// Fortschritt aus dem Verhaeltnis erledigter Aufgaben berechnen statt
|
||||
/// von Hand zu schieben. Nur sinnvoll, wenn es ueberhaupt Aufgaben gibt.
|
||||
progressFromTasks Boolean @default(false)
|
||||
|
||||
/// Wann zuletzt wegen Stillstands gemeldet wurde. Erneut gemeldet wird
|
||||
/// erst, wenn danach wieder ein Commit kam und es dann wieder still wurde.
|
||||
/// Bleibt am Projekt: Stillstand ist eine Aussage ueber das Vorhaben, nicht
|
||||
/// ueber ein einzelnes Repository.
|
||||
notifiedStaleAt DateTime?
|
||||
|
||||
notes Note[]
|
||||
tasks Task[]
|
||||
activities Activity[]
|
||||
repositories Repository[]
|
||||
notes Note[]
|
||||
snapshot RepoSnapshot?
|
||||
|
||||
createdAt DateTime @default(now())
|
||||
updatedAt DateTime @updatedAt
|
||||
|
||||
@@unique([ownerId, slug])
|
||||
@@index([status])
|
||||
@@index([connectionId])
|
||||
@@index([updatedAt])
|
||||
@@index([ownerId])
|
||||
@@index([ownerId, status, position])
|
||||
}
|
||||
|
||||
/// Ein Repository eines Projekts. Ein Vorhaben besteht oft aus mehreren –
|
||||
/// Frontend und Backend etwa –, gehoert aber in eine Karte.
|
||||
///
|
||||
/// Das erste Repository (position 0) ist das fuehrende: seine Kennzahlen
|
||||
/// stehen auf der Projektkarte, wo fuer mehrere kein Platz ist.
|
||||
model Repository {
|
||||
id String @id @default(cuid())
|
||||
projectId String
|
||||
project Project @relation(fields: [projectId], references: [id], onDelete: Cascade)
|
||||
|
||||
/// Frei waehlbare Bezeichnung wie "Frontend". Leer heisst: der Repo-Name
|
||||
/// steht fuer sich.
|
||||
label String?
|
||||
|
||||
repoUrl String?
|
||||
/// Owner bzw. Namespace/Gruppe (bei GitLab auch verschachtelt: "gruppe/subgruppe")
|
||||
repoOwner String?
|
||||
repoName String?
|
||||
defaultBranch String?
|
||||
|
||||
connectionId String?
|
||||
connection GitConnection? @relation(fields: [connectionId], references: [id], onDelete: SetNull)
|
||||
|
||||
/// Reihenfolge in der Anzeige.
|
||||
position Int @default(0)
|
||||
|
||||
lastSyncedAt DateTime?
|
||||
syncError String?
|
||||
/// Am automatischen Abgleich teilnehmen. Einzeln abschaltbar, etwa bei
|
||||
/// einem Repo, dessen Token staendig Fehler wirft.
|
||||
autoSync Boolean @default(true)
|
||||
/// Aufeinanderfolgende Fehlversuche. Steuert das Zurueckhalten: nach
|
||||
/// jedem Fehlschlag wird der naechste Versuch weiter hinausgezoegert.
|
||||
syncFailureCount Int @default(0)
|
||||
|
||||
/// Woruber zuletzt benachrichtigt wurde. Gemeldet wird nur bei einer
|
||||
/// Aenderung – sonst kaeme bei einem dauerhaft kaputten Repo mit jedem
|
||||
/// Abgleich dieselbe Nachricht. Je Repository, nicht je Projekt: sonst
|
||||
/// verdeckt ein rotes Frontend die rote Pipeline des Backends.
|
||||
notifiedSyncError String?
|
||||
notifiedCiState String?
|
||||
notifiedRelease String?
|
||||
|
||||
/// Gemeinsames Geheimnis fuer eingehende Webhooks, verschluesselt wie die
|
||||
/// Zugangstoken. Je Repository, weil der Haken im Git-System dort
|
||||
/// eingetragen wird und sich einzeln zuruecknehmen laesst.
|
||||
/// NULL heisst: fuer dieses Repository ist kein Webhook eingerichtet, und
|
||||
/// eingehende Aufrufe werden abgewiesen.
|
||||
webhookSecret String?
|
||||
/// Wann zuletzt ein gueltiger Webhook ankam – die einzige Rueckmeldung
|
||||
/// darueber, ob der Haken im Git-System wirklich funktioniert.
|
||||
webhookLastAt DateTime?
|
||||
|
||||
snapshot RepoSnapshot?
|
||||
|
||||
createdAt DateTime @default(now())
|
||||
updatedAt DateTime @updatedAt
|
||||
|
||||
@@index([projectId, position])
|
||||
@@index([connectionId])
|
||||
}
|
||||
|
||||
/// Ein Zustellweg fuer Benachrichtigungen, gehoert genau einem Konto.
|
||||
model NotificationTarget {
|
||||
id String @id @default(cuid())
|
||||
userId String
|
||||
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
|
||||
name String
|
||||
channel NotificationChannel
|
||||
|
||||
/// Webhook-URL, ntfy-Themen-URL oder E-Mail-Adresse.
|
||||
target String
|
||||
/// Optionales Geheimnis, AES-256-GCM verschluesselt: Bearer-Token fuer
|
||||
/// ntfy oder ein Signaturschluessel fuer den Webhook.
|
||||
secretCipher String?
|
||||
secretHint String?
|
||||
|
||||
/// Worueber dieses Ziel benachrichtigt werden will.
|
||||
events NotificationEvent[] @default([])
|
||||
isActive Boolean @default(true)
|
||||
|
||||
lastSentAt DateTime?
|
||||
lastOk Boolean?
|
||||
lastMessage String?
|
||||
|
||||
createdAt DateTime @default(now())
|
||||
updatedAt DateTime @updatedAt
|
||||
|
||||
@@unique([userId, name])
|
||||
@@index([userId])
|
||||
}
|
||||
|
||||
/// Eine Aufgabe innerhalb eines Projekts – die Karten des Aufgabenbretts.
|
||||
model Task {
|
||||
id String @id @default(cuid())
|
||||
projectId String
|
||||
project Project @relation(fields: [projectId], references: [id], onDelete: Cascade)
|
||||
title String
|
||||
/// Optionale Notiz zur Aufgabe, Markdown wird dargestellt.
|
||||
description String?
|
||||
status TaskStatus @default(TODO)
|
||||
/// Rang innerhalb der Spalte. Anders als beim Projektbrett braucht es ihn
|
||||
/// hier wirklich: Aufgaben haben eine Reihenfolge, die der Benutzer setzt.
|
||||
/// Beim Umsortieren werden die Positionen einer Spalte neu durchnummeriert.
|
||||
position Int @default(0)
|
||||
dueDate DateTime?
|
||||
labels String[] @default([])
|
||||
/// Zeitpunkt, zu dem die Aufgabe nach DONE gewandert ist.
|
||||
doneAt DateTime?
|
||||
|
||||
/// Wiederholt sich die Aufgabe? Wandert sie nach ERLEDIGT, entsteht die
|
||||
/// naechste Fassung mit fortgeschriebenem Faelligkeitsdatum. Die erledigte
|
||||
/// bleibt stehen – sonst ginge die Historie verloren.
|
||||
recurrence Recurrence?
|
||||
/// Aus welcher Aufgabe diese hervorgegangen ist. Nur zur Nachvollziehbarkeit;
|
||||
/// bewusst ohne Fremdschluessel, damit das Loeschen der Vorgaengerin die
|
||||
/// Nachfolgerin nicht mitnimmt.
|
||||
recurredFrom String?
|
||||
|
||||
/// Stammt die Aufgabe aus einem Git-Issue? Nummer, Repository und Link
|
||||
/// merken, damit dasselbe Issue nicht zweimal uebernommen wird.
|
||||
sourceIssue Int?
|
||||
sourceUrl String?
|
||||
/// Aus welchem Repository. Muss mit in die Eindeutigkeit: Frontend und
|
||||
/// Backend haben beide ein Issue Nummer 5, und das sind zwei Aufgaben.
|
||||
sourceRepositoryId String?
|
||||
|
||||
createdAt DateTime @default(now())
|
||||
updatedAt DateTime @updatedAt
|
||||
|
||||
/// Verhindert Dubletten beim erneuten Uebernehmen. Mehrere Aufgaben ohne
|
||||
/// Herkunft sind erlaubt: NULL gilt in Postgres als verschieden.
|
||||
@@unique([projectId, sourceRepositoryId, sourceIssue])
|
||||
@@index([projectId, status, position])
|
||||
}
|
||||
|
||||
/// Eine Vorlage fuer neue Projekte: Stammdaten, Tags, Notizen und Aufgaben.
|
||||
///
|
||||
/// Bewusst benutzereigen und nicht fest eingebaut. Welche Tags und welche
|
||||
/// Startaufgaben sinnvoll sind, weiss nur, wer damit arbeitet – eine
|
||||
/// mitgelieferte Liste waere geraten.
|
||||
model ProjectTemplate {
|
||||
id String @id @default(cuid())
|
||||
ownerId String
|
||||
owner User @relation(fields: [ownerId], references: [id], onDelete: Cascade)
|
||||
|
||||
name String
|
||||
/// Wozu die Vorlage gut ist – erscheint in der Auswahl.
|
||||
description String?
|
||||
|
||||
// ── Was die Vorlage in das neue Projekt schreibt ───────────
|
||||
summary String?
|
||||
projectDescription String?
|
||||
status ProjectStatus @default(IDEA)
|
||||
priority Int @default(2)
|
||||
accent String @default("violet")
|
||||
tags String[] @default([])
|
||||
progressFromTasks Boolean @default(false)
|
||||
|
||||
/// [{ title, content, pinned }]
|
||||
notes Json @default("[]")
|
||||
/// [{ title, description, status, labels }]
|
||||
tasks Json @default("[]")
|
||||
|
||||
createdAt DateTime @default(now())
|
||||
updatedAt DateTime @updatedAt
|
||||
|
||||
@@unique([ownerId, name])
|
||||
@@index([ownerId])
|
||||
}
|
||||
|
||||
/// Ein Eintrag im Verlauf eines Projekts: was ist wann passiert.
|
||||
model Activity {
|
||||
id String @id @default(cuid())
|
||||
projectId String
|
||||
project Project @relation(fields: [projectId], references: [id], onDelete: Cascade)
|
||||
|
||||
/// Wer. null bedeutet: die Anwendung selbst, also der Zeitgeber beim
|
||||
/// automatischen Abgleich.
|
||||
userId String?
|
||||
user User? @relation(fields: [userId], references: [id], onDelete: SetNull)
|
||||
|
||||
kind ActivityKind
|
||||
/// Fertig formulierter Einzeiler. Die Formulierung beim Schreiben
|
||||
/// festzuhalten spart der Anzeige das Nachschlagen von Namen, die es
|
||||
/// spaeter womoeglich nicht mehr gibt – etwa den einer geloeschten Notiz.
|
||||
summary String
|
||||
/// Zusatzangaben wie { from: "IDEA", to: "DONE" }. Fuer die Anzeige nicht
|
||||
/// noetig, aber nuetzlich, falls spaeter ausgewertet werden soll.
|
||||
meta Json?
|
||||
|
||||
createdAt DateTime @default(now())
|
||||
|
||||
/// Absteigend gelesen, immer je Projekt.
|
||||
@@index([projectId, createdAt])
|
||||
}
|
||||
|
||||
/// Freie Notizen zu einem Projekt.
|
||||
@@ -581,12 +265,12 @@ model Note {
|
||||
@@index([pinned])
|
||||
}
|
||||
|
||||
/// Zwischengespeicherter Stand eines Repositories. Wird beim Sync
|
||||
/// ueberschrieben, damit das Dashboard auch ohne Netz Daten zeigt.
|
||||
/// Zwischengespeicherter Stand des verknuepften Repositories. Wird beim
|
||||
/// Sync ueberschrieben, damit das Dashboard auch ohne Netz Daten zeigt.
|
||||
model RepoSnapshot {
|
||||
id String @id @default(cuid())
|
||||
repositoryId String @unique
|
||||
repository Repository @relation(fields: [repositoryId], references: [id], onDelete: Cascade)
|
||||
id String @id @default(cuid())
|
||||
projectId String @unique
|
||||
project Project @relation(fields: [projectId], references: [id], onDelete: Cascade)
|
||||
|
||||
fullName String?
|
||||
description String?
|
||||
@@ -614,54 +298,12 @@ model RepoSnapshot {
|
||||
|
||||
/// Rohdaten der Listen – bewusst als JSON, damit providerspezifische
|
||||
/// Zusatzfelder nicht verloren gehen.
|
||||
branches Json @default("[]")
|
||||
tags Json @default("[]")
|
||||
commits Json @default("[]")
|
||||
releases Json @default("[]")
|
||||
languages Json @default("{}")
|
||||
pullRequests Json @default("[]")
|
||||
issues Json @default("[]")
|
||||
/// Commits je Tag der letzten 30 Tage, aeltester zuerst.
|
||||
commitActivity Json @default("[]")
|
||||
|
||||
/// Commits je Tag ueber bis zu ein Jahr – die Heatmap.
|
||||
/// { from, to, days: { "2026-07-26": 3 }, source, truncated }
|
||||
/// Getrennt vom uebrigen Stand, weil das Holen zusaetzliche Aufrufe kostet
|
||||
/// und deshalb hoechstens einmal am Tag geschieht.
|
||||
commitCalendar Json @default("{}")
|
||||
commitCalendarAt DateTime?
|
||||
|
||||
/// Das README des Repositories, roh als Markdown. Wie der Kalender
|
||||
/// hoechstens einmal am Tag geholt – es aendert sich selten, und der
|
||||
/// Abgleich laeuft im Zweifel stuendlich.
|
||||
readme String?
|
||||
/// Dateiname, wie er im Repository steht ("README.md", "readme.rst" …).
|
||||
readmePath String?
|
||||
/// Wogegen relative Links im README aufzuloesen sind.
|
||||
readmeBaseUrl String?
|
||||
readmeAt DateTime?
|
||||
|
||||
// ── Letzter CI-Lauf auf dem Default-Branch ─────────────────
|
||||
/// success | failure | running | pending | cancelled
|
||||
ciState String?
|
||||
ciName String?
|
||||
ciBranch String?
|
||||
ciUrl String?
|
||||
ciFinishedAt DateTime?
|
||||
|
||||
/// Teil-Abrufe, die beim letzten Abgleich nicht geklappt haben:
|
||||
/// { "branches": "HTTP 403: Zugriff verweigert …" }. Leeres Objekt heisst,
|
||||
/// dass alle Listen wirklich geholt wurden.
|
||||
///
|
||||
/// Ohne diese Angabe ist eine leere Liste zweideutig – "nicht geholt" sieht
|
||||
/// aus wie "nichts vorhanden". Genau daran ist eine Fehlersuche einmal
|
||||
/// haengen geblieben.
|
||||
missing Json @default("{}")
|
||||
branches Json @default("[]")
|
||||
tags Json @default("[]")
|
||||
commits Json @default("[]")
|
||||
releases Json @default("[]")
|
||||
languages Json @default("{}")
|
||||
|
||||
pushedAt DateTime?
|
||||
fetchedAt DateTime @default(now())
|
||||
/// Wann zuletzt ein Abgleich lief, bei dem alle Teile ankamen. Steht der
|
||||
/// weiter zurueck als fetchedAt, ist ein Teil der Anzeige aelter als sie
|
||||
/// vorgibt.
|
||||
completeAt DateTime?
|
||||
}
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 7.5 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 8.1 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 34 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB |
@@ -1,64 +0,0 @@
|
||||
<#
|
||||
.SYNOPSIS
|
||||
Byteweise Sicherung der Nebula-Datenbank mit pg_dump.
|
||||
|
||||
.DESCRIPTION
|
||||
Ergaenzt den JSON-Export im Adminbereich um eine vollstaendige
|
||||
Datenbanksicherung: Schema, Daten, Sequenzen, Indizes. Genau das, was
|
||||
man zum Wiederherstellen einer kaputten Instanz braucht.
|
||||
|
||||
Laeuft die Datenbank im mitgelieferten Container, wird pg_dump dort
|
||||
ausgefuehrt - auf dem Rechner selbst muss dann nichts installiert sein.
|
||||
|
||||
.PARAMETER OutDir
|
||||
Zielverzeichnis. Vorgabe: .\backups
|
||||
|
||||
.PARAMETER Container
|
||||
Name des Postgres-Containers. Vorgabe: nebula-db
|
||||
|
||||
.EXAMPLE
|
||||
.\scripts\backup.ps1
|
||||
.\scripts\backup.ps1 -OutDir D:\Sicherungen
|
||||
#>
|
||||
[CmdletBinding()]
|
||||
param(
|
||||
[string]$OutDir = (Join-Path $PSScriptRoot "..\backups"),
|
||||
[string]$Container = "nebula-db"
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
|
||||
# .env einlesen, damit Benutzer und Datenbankname nicht doppelt gepflegt werden.
|
||||
$envFile = Join-Path $PSScriptRoot "..\.env"
|
||||
$settings = @{ POSTGRES_USER = "nebula"; POSTGRES_DB = "nebula" }
|
||||
if (Test-Path $envFile) {
|
||||
foreach ($line in Get-Content $envFile) {
|
||||
if ($line -match '^\s*([A-Z_]+)\s*=\s*"?([^"#]*)"?\s*$') {
|
||||
$settings[$Matches[1]] = $Matches[2].Trim()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$user = $settings["POSTGRES_USER"]
|
||||
$database = $settings["POSTGRES_DB"]
|
||||
|
||||
if (-not (Test-Path $OutDir)) { New-Item -ItemType Directory -Path $OutDir | Out-Null }
|
||||
|
||||
$stamp = Get-Date -Format "yyyy-MM-dd-HHmmss"
|
||||
$target = Join-Path $OutDir "nebula-$stamp.sql"
|
||||
|
||||
$running = docker ps --filter "name=$Container" --format "{{.Names}}"
|
||||
if ($running -notcontains $Container) {
|
||||
Write-Error "Container '$Container' laeuft nicht. Zuerst 'docker compose up -d db' ausfuehren."
|
||||
}
|
||||
|
||||
Write-Host "Sichere Datenbank '$database' aus Container '$Container'..."
|
||||
|
||||
# --clean --if-exists macht die Datei fuer sich allein einspielbar.
|
||||
docker exec $Container pg_dump -U $user -d $database --clean --if-exists | Out-File -Encoding utf8 $target
|
||||
|
||||
if ($LASTEXITCODE -ne 0) { Write-Error "pg_dump ist fehlgeschlagen." }
|
||||
|
||||
$size = [math]::Round((Get-Item $target).Length / 1KB, 1)
|
||||
Write-Host "Fertig: $target ($size KB)" -ForegroundColor Green
|
||||
Write-Host "Wiederherstellen mit: .\scripts\restore.ps1 -File `"$target`""
|
||||
@@ -1,43 +0,0 @@
|
||||
#!/bin/sh
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
# Byteweise Sicherung der Nebula-Datenbank mit pg_dump.
|
||||
#
|
||||
# Ergaenzt den JSON-Export im Adminbereich um eine vollstaendige
|
||||
# Datenbanksicherung: Schema, Daten, Sequenzen, Indizes.
|
||||
#
|
||||
# Aufruf: ./scripts/backup.sh [Zielverzeichnis]
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
set -eu
|
||||
|
||||
root="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
out_dir="${1:-$root/backups}"
|
||||
container="${NEBULA_DB_CONTAINER:-nebula-db}"
|
||||
|
||||
user="nebula"
|
||||
database="nebula"
|
||||
if [ -f "$root/.env" ]; then
|
||||
# Nur die beiden benoetigten Werte lesen, ohne die Datei auszufuehren.
|
||||
value_of() {
|
||||
sed -n "s/^[[:space:]]*$1[[:space:]]*=[[:space:]]*\"\{0,1\}\([^\"#]*\)\"\{0,1\}[[:space:]]*$/\1/p" \
|
||||
"$root/.env" | tail -n 1
|
||||
}
|
||||
[ -n "$(value_of POSTGRES_USER)" ] && user="$(value_of POSTGRES_USER)"
|
||||
[ -n "$(value_of POSTGRES_DB)" ] && database="$(value_of POSTGRES_DB)"
|
||||
fi
|
||||
|
||||
if ! docker ps --filter "name=$container" --format '{{.Names}}' | grep -qx "$container"; then
|
||||
echo "Container '$container' laeuft nicht. Zuerst 'docker compose up -d db' ausfuehren." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
mkdir -p "$out_dir"
|
||||
stamp="$(date +%Y-%m-%d-%H%M%S)"
|
||||
target="$out_dir/nebula-$stamp.sql"
|
||||
|
||||
echo "Sichere Datenbank '$database' aus Container '$container'..."
|
||||
# --clean --if-exists macht die Datei fuer sich allein einspielbar.
|
||||
docker exec "$container" pg_dump -U "$user" -d "$database" --clean --if-exists > "$target"
|
||||
|
||||
size="$(du -h "$target" | cut -f1)"
|
||||
echo "Fertig: $target ($size)"
|
||||
echo "Wiederherstellen mit: ./scripts/restore.sh \"$target\""
|
||||
@@ -1,62 +0,0 @@
|
||||
<#
|
||||
.SYNOPSIS
|
||||
Spielt eine mit backup.ps1 erzeugte Sicherung zurueck.
|
||||
|
||||
.DESCRIPTION
|
||||
ACHTUNG: Der aktuelle Inhalt der Datenbank wird dabei ersetzt. Das Skript
|
||||
fragt vorher nach, es sei denn, -Force ist gesetzt.
|
||||
|
||||
.PARAMETER Database
|
||||
Zieldatenbank. Vorgabe: der Wert aus der .env.
|
||||
|
||||
Tipp: Eine Sicherung laesst sich pruefen, ohne die echte Datenbank
|
||||
anzufassen - in eine leere Testdatenbank einspielen und nachsehen:
|
||||
|
||||
docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_test"
|
||||
.\scripts\restore.ps1 -File .\backups\... -Database nebula_test -Force
|
||||
|
||||
.EXAMPLE
|
||||
.\scripts\restore.ps1 -File .\backups\nebula-2026-07-26-101500.sql
|
||||
#>
|
||||
[CmdletBinding()]
|
||||
param(
|
||||
[Parameter(Mandatory = $true)][string]$File,
|
||||
[string]$Database,
|
||||
[string]$Container = "nebula-db",
|
||||
[switch]$Force
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
|
||||
if (-not (Test-Path $File)) { Write-Error "Datei nicht gefunden: $File" }
|
||||
|
||||
$envFile = Join-Path $PSScriptRoot "..\.env"
|
||||
$settings = @{ POSTGRES_USER = "nebula"; POSTGRES_DB = "nebula" }
|
||||
if (Test-Path $envFile) {
|
||||
foreach ($line in Get-Content $envFile) {
|
||||
if ($line -match '^\s*([A-Z_]+)\s*=\s*"?([^"#]*)"?\s*$') {
|
||||
$settings[$Matches[1]] = $Matches[2].Trim()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$user = $settings["POSTGRES_USER"]
|
||||
$database = if ($Database) { $Database } else { $settings["POSTGRES_DB"] }
|
||||
|
||||
if (-not $Force) {
|
||||
Write-Host "Der gesamte Inhalt der Datenbank '$database' wird ersetzt." -ForegroundColor Yellow
|
||||
$answer = Read-Host "Wirklich fortfahren? (ja/nein)"
|
||||
if ($answer -ne "ja") { Write-Host "Abgebrochen."; exit 0 }
|
||||
}
|
||||
|
||||
$running = docker ps --filter "name=$Container" --format "{{.Names}}"
|
||||
if ($running -notcontains $Container) {
|
||||
Write-Error "Container '$Container' laeuft nicht."
|
||||
}
|
||||
|
||||
Write-Host "Spiele '$File' ein..."
|
||||
Get-Content $File -Raw | docker exec -i $Container psql -U $user -d $database -v ON_ERROR_STOP=1
|
||||
|
||||
if ($LASTEXITCODE -ne 0) { Write-Error "Das Einspielen ist fehlgeschlagen." }
|
||||
|
||||
Write-Host "Fertig. Anwendung neu starten, damit sie eine frische Verbindung aufbaut." -ForegroundColor Green
|
||||
@@ -1,57 +0,0 @@
|
||||
#!/bin/sh
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
# Spielt eine mit backup.sh erzeugte Sicherung zurueck.
|
||||
#
|
||||
# ACHTUNG: Der aktuelle Inhalt der Datenbank wird ersetzt.
|
||||
#
|
||||
# Aufruf: ./scripts/restore.sh <datei.sql> [--force]
|
||||
#
|
||||
# Zieldatenbank ueberschreiben mit NEBULA_DB_NAME. Damit laesst sich eine
|
||||
# Sicherung pruefen, ohne die echte Datenbank anzufassen:
|
||||
#
|
||||
# docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_test"
|
||||
# NEBULA_DB_NAME=nebula_test ./scripts/restore.sh backups/... --force
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
set -eu
|
||||
|
||||
root="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
file="${1:-}"
|
||||
force="${2:-}"
|
||||
container="${NEBULA_DB_CONTAINER:-nebula-db}"
|
||||
|
||||
if [ -z "$file" ]; then
|
||||
echo "Aufruf: ./scripts/restore.sh <datei.sql> [--force]" >&2
|
||||
exit 1
|
||||
fi
|
||||
if [ ! -f "$file" ]; then
|
||||
echo "Datei nicht gefunden: $file" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
user="nebula"
|
||||
database="nebula"
|
||||
if [ -f "$root/.env" ]; then
|
||||
value_of() {
|
||||
sed -n "s/^[[:space:]]*$1[[:space:]]*=[[:space:]]*\"\{0,1\}\([^\"#]*\)\"\{0,1\}[[:space:]]*$/\1/p" \
|
||||
"$root/.env" | tail -n 1
|
||||
}
|
||||
[ -n "$(value_of POSTGRES_USER)" ] && user="$(value_of POSTGRES_USER)"
|
||||
[ -n "$(value_of POSTGRES_DB)" ] && database="$(value_of POSTGRES_DB)"
|
||||
fi
|
||||
database="${NEBULA_DB_NAME:-$database}"
|
||||
|
||||
if [ "$force" != "--force" ]; then
|
||||
printf "Der gesamte Inhalt der Datenbank '%s' wird ersetzt.\nWirklich fortfahren? (ja/nein) " "$database"
|
||||
read -r answer
|
||||
[ "$answer" = "ja" ] || { echo "Abgebrochen."; exit 0; }
|
||||
fi
|
||||
|
||||
if ! docker ps --filter "name=$container" --format '{{.Names}}' | grep -qx "$container"; then
|
||||
echo "Container '$container' laeuft nicht." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "Spiele '$file' ein..."
|
||||
docker exec -i "$container" psql -U "$user" -d "$database" -v ON_ERROR_STOP=1 < "$file"
|
||||
|
||||
echo "Fertig. Anwendung neu starten, damit sie eine frische Verbindung aufbaut."
|
||||
@@ -1,79 +0,0 @@
|
||||
#!/bin/sh
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
# Legt die .env an und wuerfelt ein APP_SECRET.
|
||||
#
|
||||
# Dasselbe wie scripts/setup.mjs, aber ohne Node: auf einem reinen
|
||||
# Docker-Host ist keins installiert, und nur zum Erzeugen einer Textdatei
|
||||
# eines zu verlangen waere albern. Braucht nichts ausser einer POSIX-Shell.
|
||||
#
|
||||
# Aufruf: ./scripts/setup.sh
|
||||
# ./scripts/setup.sh --force (vorhandene .env ueberschreiben)
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
set -eu
|
||||
|
||||
root="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
env_datei="$root/.env"
|
||||
vorlage="$root/.env.example"
|
||||
force=0
|
||||
|
||||
[ "${1:-}" = "--force" ] && force=1
|
||||
|
||||
if [ -t 1 ]; then
|
||||
gruen=$'\033[32m'; gelb=$'\033[33m'; cyan=$'\033[36m'; dim=$'\033[2m'; aus=$'\033[0m'
|
||||
else
|
||||
gruen=""; gelb=""; cyan=""; dim=""; aus=""
|
||||
fi
|
||||
|
||||
[ -f "$vorlage" ] || { echo "${gelb}.env.example nicht gefunden – abgebrochen.${aus}" >&2; exit 1; }
|
||||
|
||||
# ── Zufall ───────────────────────────────────────────────────
|
||||
# openssl ist auf den meisten Systemen da, aber nicht auf allen. /dev/urandom
|
||||
# gibt es ueberall, wo diese Shell laeuft – und base64 ebenso.
|
||||
zufall() {
|
||||
if command -v openssl >/dev/null 2>&1; then
|
||||
openssl rand -base64 32
|
||||
else
|
||||
head -c 32 /dev/urandom | base64
|
||||
fi | tr -d '\n'
|
||||
}
|
||||
|
||||
if [ -f "$env_datei" ] && [ "$force" -eq 0 ]; then
|
||||
echo "${gelb}·${aus} .env existiert bereits – sie wird nicht ueberschrieben."
|
||||
echo " ${dim}Mit --force neu anlegen (die alte wird gesichert).${aus}"
|
||||
else
|
||||
if [ -f "$env_datei" ]; then
|
||||
sicherung="$env_datei.$(date +%Y%m%d%H%M%S).bak"
|
||||
cp "$env_datei" "$sicherung"
|
||||
echo "${gelb}·${aus} Alte .env gesichert: $(basename "$sicherung")"
|
||||
fi
|
||||
|
||||
secret="$(zufall)"
|
||||
# Das Geheimnis kann / und + enthalten; als sed-Ersetzung waeren das
|
||||
# Sonderzeichen. Deshalb zeilenweise ersetzen statt mit einem Ausdruck.
|
||||
: > "$env_datei"
|
||||
while IFS= read -r zeile || [ -n "$zeile" ]; do
|
||||
case "$zeile" in
|
||||
APP_SECRET=*) printf 'APP_SECRET="%s"\n' "$secret" >> "$env_datei" ;;
|
||||
*) printf '%s\n' "$zeile" >> "$env_datei" ;;
|
||||
esac
|
||||
done < "$vorlage"
|
||||
|
||||
chmod 600 "$env_datei"
|
||||
echo "${gruen}✓${aus} .env angelegt, APP_SECRET zufaellig erzeugt, Rechte auf 600."
|
||||
fi
|
||||
|
||||
echo
|
||||
echo "${cyan}Noch anzupassen${aus}"
|
||||
echo "${dim}─────────────────────────────────────────────${aus}"
|
||||
echo " APP_URL die Adresse, unter der du Nebula aufrufst"
|
||||
echo " ${dim}bestimmt die WebAuthn-rpID – passt sie nicht, scheitern Passkeys${aus}"
|
||||
echo " POSTGRES_PASSWORD die Voreinstellung ist fuer Entwicklung gedacht"
|
||||
echo " APP_PORT auf einem Server: 127.0.0.1:3000 hinter den Reverse Proxy"
|
||||
echo
|
||||
echo "${cyan}Danach${aus}"
|
||||
echo "${dim}─────────────────────────────────────────────${aus}"
|
||||
echo " docker compose --profile full up -d --build"
|
||||
echo " ${dim}Der Container spielt die Migrationen beim Start selbst ein.${aus}"
|
||||
echo
|
||||
echo " Ausfuehrlich: DEPLOYMENT.md"
|
||||
echo
|
||||
@@ -1,194 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
# Nebula auf einem Server aktualisieren.
|
||||
#
|
||||
# Holt den neuen Stand, sichert die Datenbank, baut das Abbild, spielt die
|
||||
# Migrationen ein und startet neu. Bricht ab, sobald ein Schritt scheitert –
|
||||
# und sagt dann, wie zurueckzukommen ist.
|
||||
#
|
||||
# Aufruf: ./scripts/update.sh
|
||||
# ./scripts/update.sh --no-pull (nur neu bauen und starten)
|
||||
# ./scripts/update.sh --ref v1.4.0 (auf einen Stand festlegen)
|
||||
# ./scripts/update.sh --yes (ohne Rueckfrage)
|
||||
#
|
||||
# Rueckgabe 0 heisst: die neue Fassung laeuft und antwortet gesund.
|
||||
# ─────────────────────────────────────────────────────────────
|
||||
set -euo pipefail
|
||||
|
||||
root="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
cd "$root"
|
||||
|
||||
pull=1
|
||||
ref=""
|
||||
zusage=0
|
||||
|
||||
while [ $# -gt 0 ]; do
|
||||
case "$1" in
|
||||
--no-pull) pull=0 ;;
|
||||
--ref) ref="${2:-}"; shift ;;
|
||||
--yes|-y) zusage=1 ;;
|
||||
-h|--help) sed -n '3,15p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
|
||||
*) echo "Unbekannte Option: $1" >&2; exit 2 ;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
|
||||
# ── Farben, aber nur wenn ein Terminal zusieht ───────────────
|
||||
if [ -t 1 ]; then
|
||||
rot=$'\033[31m'; gruen=$'\033[32m'; gelb=$'\033[33m'; fett=$'\033[1m'; aus=$'\033[0m'
|
||||
else
|
||||
rot=""; gruen=""; gelb=""; fett=""; aus=""
|
||||
fi
|
||||
|
||||
# Die Version aus der package.json lesen – ohne Node. Auf einem reinen
|
||||
# Docker-Host ist keins installiert, und dieses Skript soll dort laufen.
|
||||
paket_version() {
|
||||
sed -n 's/.*"version"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$root/package.json" \
|
||||
| head -n 1
|
||||
}
|
||||
|
||||
schritt() { printf '\n%s▸ %s%s\n' "$fett" "$1" "$aus"; }
|
||||
ok() { printf ' %s✓%s %s\n' "$gruen" "$aus" "$1"; }
|
||||
warnung() { printf ' %s!%s %s\n' "$gelb" "$aus" "$1"; }
|
||||
abbruch() { printf '\n%s✗ %s%s\n' "$rot" "$1" "$aus" >&2; exit 1; }
|
||||
|
||||
# ── Voraussetzungen ──────────────────────────────────────────
|
||||
schritt "Voraussetzungen"
|
||||
|
||||
command -v docker >/dev/null || abbruch "docker nicht gefunden."
|
||||
docker compose version >/dev/null 2>&1 || abbruch "docker compose (v2) nicht gefunden."
|
||||
[ -f "$root/.env" ] || abbruch "Keine .env in $root. Zuerst './scripts/setup.sh' ausfuehren."
|
||||
[ -f "$root/docker-compose.yml" ] || abbruch "Kein docker-compose.yml in $root."
|
||||
ok "docker, compose und .env vorhanden"
|
||||
|
||||
# APP_SECRET muss gesetzt sein – sonst liegen die Git-Tokens faktisch offen.
|
||||
if grep -qE '^\s*APP_SECRET\s*=\s*("?)(nebula-dev-secret[^"]*|)\1\s*$' "$root/.env"; then
|
||||
abbruch "APP_SECRET ist leer oder noch der Entwicklungswert. Bitte in der .env setzen."
|
||||
fi
|
||||
ok "APP_SECRET gesetzt"
|
||||
|
||||
vorher="$(git rev-parse --short HEAD 2>/dev/null || echo "unbekannt")"
|
||||
version_vorher="$(paket_version)"
|
||||
printf ' Aktuell: v%s (%s)\n' "$version_vorher" "$vorher"
|
||||
|
||||
# ── Neuen Stand holen ────────────────────────────────────────
|
||||
if [ "$pull" -eq 1 ]; then
|
||||
schritt "Neuen Stand holen"
|
||||
|
||||
schmutz="$(git status --porcelain)"
|
||||
if [ -n "$schmutz" ]; then
|
||||
# Nicht nur meckern, sondern zeigen, worum es geht – sonst muss man
|
||||
# raten, was man da eigentlich verwerfen soll.
|
||||
printf '\n%sGeaendert gegenueber dem Stand im Git:%s\n' "$fett" "$aus"
|
||||
printf '%s\n' "$schmutz" | sed 's/^/ /'
|
||||
printf '\n Verwerfen: git checkout -- .\n'
|
||||
printf ' Behalten: git stash\n'
|
||||
abbruch "Das Arbeitsverzeichnis ist nicht sauber."
|
||||
fi
|
||||
|
||||
git fetch --all --tags --quiet
|
||||
if [ -n "$ref" ]; then
|
||||
git checkout --quiet "$ref"
|
||||
ok "Auf $ref gewechselt"
|
||||
else
|
||||
zweig="$(git rev-parse --abbrev-ref HEAD)"
|
||||
git pull --ff-only --quiet origin "$zweig"
|
||||
ok "$zweig aktualisiert"
|
||||
fi
|
||||
|
||||
nachher="$(git rev-parse --short HEAD)"
|
||||
version_nachher="$(paket_version)"
|
||||
|
||||
if [ "$vorher" = "$nachher" ]; then
|
||||
warnung "Kein neuer Stand – es wird trotzdem neu gebaut."
|
||||
else
|
||||
printf ' Neu: v%s (%s)\n' "$version_nachher" "$nachher"
|
||||
printf '\n Was dazukam:\n'
|
||||
git --no-pager log --oneline --no-decorate "$vorher..$nachher" 2>/dev/null | sed 's/^/ /' || true
|
||||
fi
|
||||
else
|
||||
warnung "Ohne --pull: der vorhandene Stand wird neu gebaut."
|
||||
fi
|
||||
|
||||
# ── Rueckfrage ───────────────────────────────────────────────
|
||||
if [ "$zusage" -eq 0 ] && [ -t 0 ]; then
|
||||
printf '\n%sWeiter? Die Datenbank wird vorher gesichert. [j/N] %s' "$fett" "$aus"
|
||||
read -r antwort
|
||||
case "$antwort" in [jJyY]*) ;; *) abbruch "Abgebrochen." ;; esac
|
||||
fi
|
||||
|
||||
# ── Datenbank sichern ────────────────────────────────────────
|
||||
schritt "Datenbank sichern"
|
||||
|
||||
# Die Datenbank muss laufen, sonst gibt es nichts zu sichern.
|
||||
docker compose up -d db >/dev/null
|
||||
sicherung=""
|
||||
if [ -x "$root/scripts/backup.sh" ]; then
|
||||
ausgabe="$("$root/scripts/backup.sh" 2>&1)" || abbruch "Sicherung fehlgeschlagen:\n$ausgabe"
|
||||
# backup.sh setzt den Pfad in Anfuehrungszeichen – die gehoeren nicht in
|
||||
# den Namen, sonst laesst sich der Vorschlag am Ende nicht kopieren.
|
||||
sicherung="$(printf '%s' "$ausgabe" | grep -oE '[^ "]*backups/[^ "]*\.sql[^ "]*' | tail -n 1 || true)"
|
||||
ok "Gesichert${sicherung:+: $sicherung}"
|
||||
else
|
||||
warnung "scripts/backup.sh fehlt – es wird ohne Sicherung fortgefahren."
|
||||
fi
|
||||
|
||||
# ── Bauen ────────────────────────────────────────────────────
|
||||
schritt "Abbild bauen"
|
||||
# Erst bauen, dann umschalten: ein Fehlschlag laesst die alte Fassung laufen.
|
||||
docker compose --profile full build app || abbruch "Der Bau ist gescheitert. Die laufende Fassung ist unveraendert."
|
||||
ok "Abbild gebaut"
|
||||
|
||||
# ── Starten ──────────────────────────────────────────────────
|
||||
schritt "Starten"
|
||||
# Die Migrationen laufen im entrypoint.sh, bevor der Server hochkommt.
|
||||
docker compose --profile full up -d || abbruch "Der Start ist gescheitert."
|
||||
ok "Container gestartet"
|
||||
|
||||
# ── Gesundheitspruefung ──────────────────────────────────────
|
||||
schritt "Gesundheitspruefung"
|
||||
|
||||
# Gefragt wird der Container selbst, nicht der Host. Das Abbild bringt einen
|
||||
# HEALTHCHECK mit, und so ist es einerlei, ob APP_PORT nur eine Nummer ist
|
||||
# oder wie auf einem Server "127.0.0.1:3000" – und curl braucht es auch nicht.
|
||||
gesund=0
|
||||
for _ in $(seq 1 40); do
|
||||
zustand="$(docker inspect --format '{{.State.Health.Status}}' nebula-app 2>/dev/null || echo "weg")"
|
||||
case "$zustand" in
|
||||
healthy) gesund=1; break ;;
|
||||
unhealthy) break ;;
|
||||
esac
|
||||
sleep 3
|
||||
done
|
||||
|
||||
if [ "$gesund" -ne 1 ]; then
|
||||
printf '\n%sLetzte Zeilen aus dem Log:%s\n' "$fett" "$aus"
|
||||
docker compose --profile full logs --tail 40 app || true
|
||||
printf '\n%sZurueck zur vorigen Fassung:%s\n' "$fett" "$aus"
|
||||
printf ' git checkout %s && ./scripts/update.sh --no-pull --yes\n' "$vorher"
|
||||
[ -n "$sicherung" ] && printf ' Datenbank notfalls: ./scripts/restore.sh %s\n' "$sicherung"
|
||||
abbruch "Der Container meldet sich nach zwei Minuten nicht gesund (Zustand: ${zustand})."
|
||||
fi
|
||||
ok "Container meldet sich gesund"
|
||||
|
||||
# Die Anzeige der Adresse. Nicht die .env raten, sondern Docker fragen: mit
|
||||
# docker-compose.server.yml veroeffentlicht der Container gar keinen Port und
|
||||
# haengt nur im Netz des Reverse Proxy. Dann gibt "port" nichts zurueck.
|
||||
adresse="$(docker compose --profile full port app 3000 2>/dev/null | tail -n 1 || true)"
|
||||
|
||||
if [ -n "$adresse" ]; then
|
||||
port="${adresse##*:}"
|
||||
if command -v curl >/dev/null 2>&1; then
|
||||
antwort_json="$(curl -fsS "http://127.0.0.1:${port}/api/health" 2>/dev/null || true)"
|
||||
[ -n "$antwort_json" ] && ok "Antwort: $antwort_json"
|
||||
fi
|
||||
wo="$adresse"
|
||||
else
|
||||
wo="im Docker-Netz (kein Host-Port veroeffentlicht)"
|
||||
fi
|
||||
|
||||
# ── Fertig ───────────────────────────────────────────────────
|
||||
version_jetzt="$(paket_version)"
|
||||
printf '\n%s%s✓ Nebula v%s laeuft auf %s%s\n' "$gruen" "$fett" "$version_jetzt" "$wo" "$aus"
|
||||
[ -n "$sicherung" ] && printf ' Sicherung vor dem Update: %s\n' "$sicherung"
|
||||
printf ' Log mitlesen: docker compose --profile full logs -f app\n\n'
|
||||
@@ -1,10 +1,5 @@
|
||||
import type { Metadata } from "next";
|
||||
import { AccountManager, type AccountData } from "@/components/account/AccountManager";
|
||||
import {
|
||||
NotificationSection,
|
||||
type NotificationTargetEntry,
|
||||
} from "@/components/account/NotificationSection";
|
||||
import { emailAvailable } from "@/lib/notify";
|
||||
import { requireUserPage } from "@/lib/auth/guard";
|
||||
import { WEBAUTHN_AVAILABLE } from "@/lib/config";
|
||||
import { prisma } from "@/lib/db";
|
||||
@@ -18,7 +13,7 @@ export async function generateMetadata(): Promise<Metadata> {
|
||||
export default async function AccountPage() {
|
||||
const user = await requireUserPage();
|
||||
|
||||
const [passkeys, sessions, targets, konto, offeneCodes] = await Promise.all([
|
||||
const [passkeys, sessions] = await Promise.all([
|
||||
prisma.credential.findMany({
|
||||
where: { userId: user.id },
|
||||
select: {
|
||||
@@ -42,27 +37,6 @@ export default async function AccountPage() {
|
||||
},
|
||||
orderBy: { lastSeenAt: "desc" },
|
||||
}),
|
||||
prisma.notificationTarget.findMany({
|
||||
where: { userId: user.id },
|
||||
select: {
|
||||
id: true,
|
||||
name: true,
|
||||
channel: true,
|
||||
target: true,
|
||||
secretHint: true,
|
||||
events: true,
|
||||
isActive: true,
|
||||
lastSentAt: true,
|
||||
lastOk: true,
|
||||
lastMessage: true,
|
||||
},
|
||||
orderBy: { name: "asc" },
|
||||
}),
|
||||
prisma.user.findUniqueOrThrow({
|
||||
where: { id: user.id },
|
||||
select: { totpEnabledAt: true },
|
||||
}),
|
||||
prisma.recoveryCode.count({ where: { userId: user.id, usedAt: null } }),
|
||||
]);
|
||||
|
||||
const data: AccountData = {
|
||||
@@ -74,11 +48,6 @@ export default async function AccountPage() {
|
||||
passkeys,
|
||||
sessions,
|
||||
passkeysAvailable: WEBAUTHN_AVAILABLE,
|
||||
totp: {
|
||||
enabled: Boolean(konto.totpEnabledAt),
|
||||
enabledAt: konto.totpEnabledAt,
|
||||
recoveryCodesLeft: offeneCodes,
|
||||
},
|
||||
};
|
||||
|
||||
return (
|
||||
@@ -91,11 +60,6 @@ export default async function AccountPage() {
|
||||
</header>
|
||||
|
||||
<AccountManager data={data} />
|
||||
|
||||
<NotificationSection
|
||||
targets={targets as unknown as NotificationTargetEntry[]}
|
||||
emailAvailable={emailAvailable()}
|
||||
/>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
+2
-28
@@ -19,7 +19,7 @@ export async function generateMetadata(): Promise<Metadata> {
|
||||
export default async function AdminPage() {
|
||||
const admin = await requireAdminPage();
|
||||
|
||||
const [settings, users, eligible, staleListeners, laengsteSpalte] = await Promise.all([
|
||||
const [settings, users, eligible] = await Promise.all([
|
||||
getAppSettings(),
|
||||
prisma.user.findMany({
|
||||
select: userSafeSelect,
|
||||
@@ -27,9 +27,7 @@ export default async function AdminPage() {
|
||||
}),
|
||||
// Bewusst ueber alle Konten: der Abgleich ist ein Serverauftrag, keine
|
||||
// Dateneinsicht. Gezaehlt wird nur, nicht gelesen.
|
||||
// Gezaehlt werden Repositories, nicht Projekte: sie sind die Einheit, in
|
||||
// der abgeglichen und begrenzt wird.
|
||||
prisma.repository.count({
|
||||
prisma.project.count({
|
||||
where: {
|
||||
autoSync: true,
|
||||
OR: [
|
||||
@@ -38,21 +36,6 @@ export default async function AdminPage() {
|
||||
],
|
||||
},
|
||||
}),
|
||||
prisma.notificationTarget.count({
|
||||
where: { isActive: true, events: { has: "PROJECT_STALE" } },
|
||||
}),
|
||||
// Laengste Spalte ueber alle Projekte. Ohne diese Zahl steht die
|
||||
// Einstellung im Leeren: eine Grenze von 15 sagt nichts, wenn die
|
||||
// groesste Spalte im Bestand aus drei Karten besteht.
|
||||
//
|
||||
// Wie beim Abgleich bewusst ueber alle Konten – gezaehlt wird nur, es
|
||||
// wird nichts gelesen und nichts zugeordnet.
|
||||
prisma.task.groupBy({
|
||||
by: ["projectId", "status"],
|
||||
_count: { _all: true },
|
||||
orderBy: { _count: { projectId: "desc" } },
|
||||
take: 1,
|
||||
}),
|
||||
]);
|
||||
|
||||
const data: AdminData = {
|
||||
@@ -71,15 +54,6 @@ export default async function AdminPage() {
|
||||
lastReport: (settings.lastAutoSyncReport as AutoSyncReport | null) ?? null,
|
||||
eligible,
|
||||
},
|
||||
stale: {
|
||||
afterDays: settings.staleAfterDays,
|
||||
lastCheckAt: settings.lastStaleCheckAt,
|
||||
listeners: staleListeners,
|
||||
},
|
||||
tasks: {
|
||||
columnLimit: settings.taskColumnLimit,
|
||||
laengsteSpalte: laengsteSpalte[0]?._count._all ?? 0,
|
||||
},
|
||||
};
|
||||
|
||||
return (
|
||||
|
||||
@@ -47,7 +47,7 @@ export async function POST(request: Request) {
|
||||
}
|
||||
}
|
||||
|
||||
const weak = validatePasswordStrength(parsed.data.newPassword, user.username);
|
||||
const weak = validatePasswordStrength(parsed.data.newPassword);
|
||||
if (weak) {
|
||||
return NextResponse.json({ error: weak, fields: { newPassword: weak } }, { status: 422 });
|
||||
}
|
||||
|
||||
@@ -1,43 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { z } from "zod";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { verifyPassword } from "@/lib/auth/password";
|
||||
import { issueRecoveryCodes } from "@/lib/auth/recovery";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
const schema = z.object({ password: z.string().min(1).max(200) });
|
||||
|
||||
/**
|
||||
* Neue Wiederherstellungscodes. Die alten verfallen dabei – sonst waeren
|
||||
* Zettel im Umlauf, von denen niemand mehr weiss, welche noch gelten.
|
||||
*
|
||||
* Verlangt das Passwort, wie das Abschalten auch: die Codes sind gleichwertig
|
||||
* zum zweiten Faktor.
|
||||
*/
|
||||
export async function POST(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = schema.safeParse(body.data);
|
||||
if (!parsed.success) return jsonError("Bitte das Passwort angeben.", 422);
|
||||
|
||||
const user = await prisma.user.findUniqueOrThrow({
|
||||
where: { id: auth.user.id },
|
||||
select: { passwordHash: true, totpEnabledAt: true },
|
||||
});
|
||||
|
||||
if (!user.totpEnabledAt) {
|
||||
return jsonError("Die Zwei-Faktor-Anmeldung ist nicht aktiv.", 409);
|
||||
}
|
||||
if (!(await verifyPassword(parsed.data.password, user.passwordHash))) {
|
||||
return jsonError("Das Passwort stimmt nicht.", 401);
|
||||
}
|
||||
|
||||
return NextResponse.json({ recoveryCodes: await issueRecoveryCodes(auth.user.id) });
|
||||
}
|
||||
@@ -1,170 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import QRCode from "qrcode";
|
||||
import { z } from "zod";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { verifyPassword } from "@/lib/auth/password";
|
||||
import { countUnusedRecoveryCodes, issueRecoveryCodes } from "@/lib/auth/recovery";
|
||||
import { generateTotpSecret, groupSecret, matchTotp, otpauthUri } from "@/lib/auth/totp";
|
||||
import { APP_NAME } from "@/lib/config";
|
||||
import { encryptSecret, tryDecryptSecret } from "@/lib/crypto";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { formatZodError } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
/**
|
||||
* Zwei-Faktor-Anmeldung per Einmalkennwort.
|
||||
*
|
||||
* Die Einrichtung laeuft in zwei Schritten: POST legt einen Schluessel an und
|
||||
* zeigt ihn als QR-Code, PUT schaltet ihn nach einem bestaetigten Code scharf.
|
||||
* Erst dann fragt die Anmeldung danach. Wer die Einrichtung abbricht oder den
|
||||
* QR-Code nie scannt, sperrt sich so nicht aus.
|
||||
*/
|
||||
|
||||
/** Zustand fuer die Anzeige. */
|
||||
export async function GET() {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const user = await prisma.user.findUniqueOrThrow({
|
||||
where: { id: auth.user.id },
|
||||
select: { totpEnabledAt: true },
|
||||
});
|
||||
|
||||
return NextResponse.json({
|
||||
enabled: Boolean(user.totpEnabledAt),
|
||||
enabledAt: user.totpEnabledAt,
|
||||
recoveryCodesLeft: user.totpEnabledAt
|
||||
? await countUnusedRecoveryCodes(auth.user.id)
|
||||
: 0,
|
||||
});
|
||||
}
|
||||
|
||||
/** Schritt 1: Schluessel erzeugen und als QR-Code zurueckgeben. */
|
||||
export async function POST() {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const user = await prisma.user.findUniqueOrThrow({
|
||||
where: { id: auth.user.id },
|
||||
select: { totpEnabledAt: true, username: true },
|
||||
});
|
||||
|
||||
if (user.totpEnabledAt) {
|
||||
return jsonError(
|
||||
"Die Zwei-Faktor-Anmeldung ist bereits aktiv. Bitte zuerst abschalten.",
|
||||
409,
|
||||
);
|
||||
}
|
||||
|
||||
// Bei jedem Anlauf ein frischer Schluessel: ein halb eingerichteter aus
|
||||
// einem frueheren Versuch koennte in einer Authenticator-App liegen, ohne
|
||||
// dass hier bekannt waere, in welcher.
|
||||
const secret = generateTotpSecret();
|
||||
await prisma.user.update({
|
||||
where: { id: auth.user.id },
|
||||
data: { totpSecretCipher: encryptSecret(secret) },
|
||||
});
|
||||
|
||||
const uri = otpauthUri({ secret, account: user.username, issuer: APP_NAME });
|
||||
|
||||
return NextResponse.json({
|
||||
// Das Bild als data:-URI, damit die Content-Security-Policy nichts
|
||||
// nachladen muss. img-src erlaubt data: bereits.
|
||||
qr: await QRCode.toDataURL(uri, { margin: 1, width: 320 }),
|
||||
uri,
|
||||
/** Zum Abtippen, falls die Kamera nicht mitspielt. */
|
||||
secret: groupSecret(secret),
|
||||
});
|
||||
}
|
||||
|
||||
const enableSchema = z.object({ code: z.string().min(6).max(10) });
|
||||
|
||||
/** Schritt 2: Code bestaetigen, scharfschalten, Wiederherstellungscodes ausgeben. */
|
||||
export async function PUT(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = enableSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const user = await prisma.user.findUniqueOrThrow({
|
||||
where: { id: auth.user.id },
|
||||
select: { totpSecretCipher: true, totpEnabledAt: true },
|
||||
});
|
||||
|
||||
if (user.totpEnabledAt) return jsonError("Die Zwei-Faktor-Anmeldung ist bereits aktiv.", 409);
|
||||
|
||||
const secret = tryDecryptSecret(user.totpSecretCipher);
|
||||
if (!secret) {
|
||||
return jsonError("Es liegt kein Schluessel vor. Bitte die Einrichtung neu starten.", 409);
|
||||
}
|
||||
|
||||
const fenster = matchTotp(secret, parsed.data.code);
|
||||
if (fenster === null) {
|
||||
return jsonError(
|
||||
"Der Code stimmt nicht. Geht die Uhr des Geraets richtig?",
|
||||
401,
|
||||
);
|
||||
}
|
||||
|
||||
await prisma.user.update({
|
||||
where: { id: auth.user.id },
|
||||
// Das Fenster gleich mitverbrennen: der Code, der eben aktiviert hat,
|
||||
// soll nicht Sekunden spaeter noch zum Anmelden taugen.
|
||||
data: { totpEnabledAt: new Date(), totpLastCounter: fenster },
|
||||
});
|
||||
|
||||
return NextResponse.json({
|
||||
ok: true,
|
||||
// Einmalige Ausgabe: gespeichert wird nur ihr Hash.
|
||||
recoveryCodes: await issueRecoveryCodes(auth.user.id),
|
||||
});
|
||||
}
|
||||
|
||||
const disableSchema = z.object({ password: z.string().min(1).max(200) });
|
||||
|
||||
/** Abschalten. Verlangt das Passwort, nicht nur eine offene Sitzung. */
|
||||
export async function DELETE(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = disableSchema.safeParse(body.data);
|
||||
if (!parsed.success) return jsonError("Bitte das Passwort angeben.", 422);
|
||||
|
||||
const user = await prisma.user.findUniqueOrThrow({
|
||||
where: { id: auth.user.id },
|
||||
select: { passwordHash: true, totpEnabledAt: true },
|
||||
});
|
||||
|
||||
if (!user.totpEnabledAt) return jsonError("Die Zwei-Faktor-Anmeldung ist nicht aktiv.", 409);
|
||||
|
||||
// Ein unbeaufsichtigter Rechner mit offener Sitzung soll den zweiten Faktor
|
||||
// nicht im Vorbeigehen entfernen koennen.
|
||||
if (!(await verifyPassword(parsed.data.password, user.passwordHash))) {
|
||||
return jsonError("Das Passwort stimmt nicht.", 401);
|
||||
}
|
||||
|
||||
await prisma.$transaction([
|
||||
prisma.user.update({
|
||||
where: { id: auth.user.id },
|
||||
data: { totpSecretCipher: null, totpEnabledAt: null, totpLastCounter: null },
|
||||
}),
|
||||
prisma.recoveryCode.deleteMany({ where: { userId: auth.user.id } }),
|
||||
prisma.pendingLogin.deleteMany({ where: { userId: auth.user.id } }),
|
||||
]);
|
||||
|
||||
return NextResponse.json({ ok: true });
|
||||
}
|
||||
@@ -1,58 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import {
|
||||
SEITEN_ORDNUNG,
|
||||
cursorAus,
|
||||
seitenBedingung,
|
||||
seitenGroesse,
|
||||
} from "@/lib/timeline";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
/**
|
||||
* Der Verlauf ueber alle Projekte, neueste Eintraege zuerst.
|
||||
*
|
||||
* Geblaettert wird per Cursor (`vor` = Zeitpunkt, `id` = Eintrag), nicht per
|
||||
* Offset – siehe lib/timeline. Zurueck kommt der Cursor fuer die naechste
|
||||
* Seite gleich mit, damit der Aufrufer ihn nicht selbst zusammensetzen muss.
|
||||
*/
|
||||
export async function GET(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const params = new URL(request.url).searchParams;
|
||||
const cursor = cursorAus(params.get("vor"), params.get("id"));
|
||||
const take = seitenGroesse(params.get("limit"));
|
||||
|
||||
/**
|
||||
* Einen mehr holen als angefragt: daran laesst sich ablesen, ob es
|
||||
* weitergeht, ohne dafuer zaehlen zu muessen.
|
||||
*/
|
||||
const gefunden = await prisma.activity.findMany({
|
||||
where: seitenBedingung(auth.user.id, cursor),
|
||||
orderBy: SEITEN_ORDNUNG,
|
||||
take: take + 1,
|
||||
select: {
|
||||
id: true,
|
||||
kind: true,
|
||||
summary: true,
|
||||
createdAt: true,
|
||||
project: { select: { id: true, name: true, accent: true } },
|
||||
user: { select: { username: true, displayName: true } },
|
||||
},
|
||||
});
|
||||
|
||||
const weitere = gefunden.length > take;
|
||||
const activities = weitere ? gefunden.slice(0, take) : gefunden;
|
||||
const letzter = activities[activities.length - 1];
|
||||
|
||||
return NextResponse.json({
|
||||
activities: activities.map((eintrag) => ({
|
||||
...eintrag,
|
||||
createdAt: eintrag.createdAt.toISOString(),
|
||||
})),
|
||||
weitere,
|
||||
naechster: weitere && letzter ? { vor: letzter.createdAt.toISOString(), id: letzter.id } : null,
|
||||
});
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
import { requireAdminApi } from "@/lib/auth/guard";
|
||||
import { APP_NAME } from "@/lib/config";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { exportFileName } from "@/lib/export/format";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
/**
|
||||
* Vollstaendige Sicherung der Instanz als JSON.
|
||||
*
|
||||
* Anders als der Projekt-Export ist das eine echte Sicherung und enthaelt
|
||||
* deshalb auch Konten und Verbindungen. Was drinsteht:
|
||||
*
|
||||
* - Passwoerter nur als scrypt-Hash, nicht im Klartext
|
||||
* - Git-Tokens nur als Chiffrat; ohne dasselbe APP_SECRET sind sie wertlos
|
||||
* - Sitzungen und Passkeys bewusst nicht: Sitzungen sind kurzlebig, und
|
||||
* Passkeys haengen ohnehin am Geraet und an der rpID
|
||||
*
|
||||
* Die Datei ist damit vertraulich zu behandeln. Fuer eine byteweise Sicherung
|
||||
* der Datenbank siehe scripts/backup.* mit pg_dump.
|
||||
*/
|
||||
export async function GET() {
|
||||
const auth = await requireAdminApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const [settings, users, connections, projects] = await Promise.all([
|
||||
prisma.appSettings.findUnique({ where: { id: "singleton" } }),
|
||||
prisma.user.findMany({
|
||||
select: {
|
||||
id: true,
|
||||
username: true,
|
||||
displayName: true,
|
||||
email: true,
|
||||
passwordHash: true,
|
||||
role: true,
|
||||
isActive: true,
|
||||
createdAt: true,
|
||||
lastLoginAt: true,
|
||||
},
|
||||
orderBy: { username: "asc" },
|
||||
}),
|
||||
prisma.gitConnection.findMany({
|
||||
select: {
|
||||
id: true,
|
||||
ownerId: true,
|
||||
name: true,
|
||||
provider: true,
|
||||
baseUrl: true,
|
||||
username: true,
|
||||
tokenCipher: true,
|
||||
tokenHint: true,
|
||||
createdAt: true,
|
||||
},
|
||||
orderBy: { name: "asc" },
|
||||
}),
|
||||
prisma.project.findMany({
|
||||
include: {
|
||||
notes: { orderBy: { createdAt: "asc" } },
|
||||
tasks: { orderBy: [{ status: "asc" }, { position: "asc" }] },
|
||||
// Snapshots bleiben draussen: reproduzierbar und gross.
|
||||
},
|
||||
orderBy: { name: "asc" },
|
||||
}),
|
||||
]);
|
||||
|
||||
const payload = {
|
||||
kind: "nebula.backup",
|
||||
version: 1,
|
||||
exportedAt: new Date().toISOString(),
|
||||
app: APP_NAME,
|
||||
note:
|
||||
"Enthaelt Passwort-Hashes und verschluesselte Git-Tokens. " +
|
||||
"Die Tokens sind nur mit demselben APP_SECRET wieder lesbar. Vertraulich behandeln.",
|
||||
settings,
|
||||
users,
|
||||
connections,
|
||||
projects,
|
||||
};
|
||||
|
||||
const filename = exportFileName(`${APP_NAME}-sicherung`, new Date(), "json");
|
||||
|
||||
return new Response(JSON.stringify(payload, null, 2), {
|
||||
headers: {
|
||||
"Content-Type": "application/json; charset=utf-8",
|
||||
"Content-Disposition": `attachment; filename="${filename}"`,
|
||||
"Cache-Control": "no-store",
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -37,8 +37,6 @@ export async function PATCH(request: Request) {
|
||||
autoSyncIntervalMinutes,
|
||||
autoSyncActiveOnly,
|
||||
autoSyncBatchSize,
|
||||
staleAfterDays,
|
||||
taskColumnLimit,
|
||||
} = parsed.data;
|
||||
|
||||
// Der Wechsel in den Einzelbetrieb wuerde weitere Konten aussperren –
|
||||
@@ -59,12 +57,6 @@ export async function PATCH(request: Request) {
|
||||
...(autoSyncIntervalMinutes !== undefined ? { autoSyncIntervalMinutes } : {}),
|
||||
...(autoSyncActiveOnly !== undefined ? { autoSyncActiveOnly } : {}),
|
||||
...(autoSyncBatchSize !== undefined ? { autoSyncBatchSize } : {}),
|
||||
// Neue Schwelle: die Pruefung soll beim naechsten Tick greifen, nicht
|
||||
// erst in 24 Stunden.
|
||||
...(staleAfterDays !== undefined
|
||||
? { staleAfterDays, lastStaleCheckAt: null }
|
||||
: {}),
|
||||
...(taskColumnLimit !== undefined ? { taskColumnLimit } : {}),
|
||||
};
|
||||
|
||||
const settings = await prisma.appSettings.upsert({
|
||||
|
||||
@@ -69,7 +69,7 @@ export async function PATCH(request: Request, { params }: Params) {
|
||||
}
|
||||
|
||||
if (password) {
|
||||
const weak = validatePasswordStrength(password, target.username);
|
||||
const weak = validatePasswordStrength(password);
|
||||
if (weak) {
|
||||
return NextResponse.json({ error: weak, fields: { password: weak } }, { status: 422 });
|
||||
}
|
||||
|
||||
@@ -47,7 +47,7 @@ export async function POST(request: Request) {
|
||||
|
||||
const { username, displayName, email, password, role } = parsed.data;
|
||||
|
||||
const weak = validatePasswordStrength(password, username);
|
||||
const weak = validatePasswordStrength(password);
|
||||
if (weak) {
|
||||
return NextResponse.json({ error: weak, fields: { password: weak } }, { status: 422 });
|
||||
}
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { createPendingLogin, setMfaCookie } from "@/lib/auth/mfa";
|
||||
import { fakeVerifyDelay, hashPassword, needsRehash, verifyPassword } from "@/lib/auth/password";
|
||||
import { fakeVerifyDelay, verifyPassword } from "@/lib/auth/password";
|
||||
import { createSession, setSessionCookie } from "@/lib/auth/session";
|
||||
import { lockRemainingSeconds, noteFailedLogin, noteSuccessfulLogin } from "@/lib/auth/users";
|
||||
import { prisma } from "@/lib/db";
|
||||
@@ -42,30 +41,6 @@ export async function POST(request: Request) {
|
||||
return jsonError(GENERIC, 401);
|
||||
}
|
||||
|
||||
/**
|
||||
* Erst das Passwort pruefen, dann ueber den Kontozustand reden.
|
||||
*
|
||||
* Frueher standen die Abfragen auf gesperrt, deaktiviert und
|
||||
* "kein Passwort hinterlegt" **vor** der Pruefung und beantworteten sich
|
||||
* damit ohne jede Kenntnis des Passworts. Wer einen Benutzernamen riet,
|
||||
* bekam an der Antwort gesagt, ob es ihn gibt – genau die Aufzaehlbarkeit,
|
||||
* die der einheitliche Text GENERIC sonst verhindert.
|
||||
*
|
||||
* Jetzt gilt: falsches Passwort → immer dieselbe Antwort. Die
|
||||
* hilfreichere Auskunft bekommt nur, wer das Passwort kennt.
|
||||
*/
|
||||
const valid = user.passwordHash
|
||||
? await verifyPassword(password, user.passwordHash)
|
||||
: // Kein Passwort hinterlegt (reines Passkey-Konto): trotzdem Zeit
|
||||
// verbrennen, damit sich der Fall nicht an der Antwortdauer zeigt.
|
||||
await fakeVerifyDelay().then(() => false);
|
||||
|
||||
if (!valid) {
|
||||
// Fehlversuche nur zaehlen, wo es ein Passwort zu erraten gibt.
|
||||
if (user.passwordHash) await noteFailedLogin(user.id);
|
||||
return jsonError(GENERIC, 401);
|
||||
}
|
||||
|
||||
const locked = lockRemainingSeconds(user.lockedUntil);
|
||||
if (locked > 0) {
|
||||
return jsonError(
|
||||
@@ -75,32 +50,22 @@ export async function POST(request: Request) {
|
||||
}
|
||||
|
||||
if (!user.isActive) {
|
||||
await fakeVerifyDelay();
|
||||
return jsonError("Dieses Konto ist deaktiviert.", 403);
|
||||
}
|
||||
|
||||
/**
|
||||
* Der Aufwand beim Hashen ist gestiegen. Wer sich mit einem Passwort
|
||||
* anmeldet, dessen Hash noch nach den alten Vorgaben erzeugt wurde,
|
||||
* bekommt hier still einen neuen – es ist der einzige Moment, in dem das
|
||||
* Klartextpasswort vorliegt. Nebenlaeufig, damit die Anmeldung nicht auf
|
||||
* die halbe Sekunde wartet.
|
||||
*/
|
||||
if (needsRehash(user.passwordHash)) {
|
||||
void hashPassword(password)
|
||||
.then((neu) => prisma.user.update({ where: { id: user.id }, data: { passwordHash: neu } }))
|
||||
.catch(() => undefined);
|
||||
if (!user.passwordHash) {
|
||||
await fakeVerifyDelay();
|
||||
return jsonError(
|
||||
"Fuer dieses Konto ist kein Passwort hinterlegt – bitte mit Passkey anmelden.",
|
||||
401,
|
||||
);
|
||||
}
|
||||
|
||||
// Das Passwort stimmt. Ist ein zweiter Faktor eingerichtet, entsteht hier
|
||||
// noch keine Sitzung, sondern nur ein Vorgang mit kurzer Frist.
|
||||
if (user.totpEnabledAt) {
|
||||
// Die Zaehler bleiben stehen, bis die Anmeldung wirklich durch ist:
|
||||
// sonst liesse sich ueber wiederholte Passworteingaben die Sperre
|
||||
// umgehen, die falsche Passwoerter aufbaut.
|
||||
const token = await createPendingLogin(user.id);
|
||||
const response = NextResponse.json({ ok: false, mfaRequired: true });
|
||||
setMfaCookie(response, token);
|
||||
return response;
|
||||
const valid = await verifyPassword(password, user.passwordHash);
|
||||
if (!valid) {
|
||||
await noteFailedLogin(user.id);
|
||||
return jsonError(GENERIC, 401);
|
||||
}
|
||||
|
||||
await noteSuccessfulLogin(user.id);
|
||||
|
||||
@@ -1,117 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { z } from "zod";
|
||||
import {
|
||||
clearMfaCookie,
|
||||
discardPendingLogin,
|
||||
noteMfaFailure,
|
||||
readPendingLogin,
|
||||
} from "@/lib/auth/mfa";
|
||||
import { redeemRecoveryCode } from "@/lib/auth/recovery";
|
||||
import { createSession, setSessionCookie } from "@/lib/auth/session";
|
||||
import { matchTotp } from "@/lib/auth/totp";
|
||||
import { noteSuccessfulLogin } from "@/lib/auth/users";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
|
||||
import { clientIp, jsonError, readJsonBody, tooManyRequests } from "@/lib/security/request";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
/**
|
||||
* Der zweite Schritt der Anmeldung: Einmalkennwort oder
|
||||
* Wiederherstellungscode.
|
||||
*
|
||||
* Der Vorgang steckt im kurzlebigen Cookie aus Schritt eins. Wer hier ohne
|
||||
* diesen Cookie ankommt, hat kein Passwort vorgezeigt und bekommt nichts.
|
||||
*/
|
||||
|
||||
const schema = z.object({
|
||||
code: z.string().min(1).max(40),
|
||||
});
|
||||
|
||||
const GENERIC = "Der Code stimmt nicht.";
|
||||
|
||||
export async function POST(request: Request) {
|
||||
const ip = clientIp(request);
|
||||
const limited = rateLimit(`mfa:${ip}`, LIMITS.login.limit, LIMITS.login.windowMs);
|
||||
if (!limited.ok) return tooManyRequests(limited.retryAfter);
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = schema.safeParse(body.data);
|
||||
if (!parsed.success) return jsonError(GENERIC, 401);
|
||||
|
||||
const pending = await readPendingLogin();
|
||||
if (!pending) {
|
||||
const response = jsonError(
|
||||
"Die Anmeldung ist abgelaufen. Bitte melde dich neu an.",
|
||||
401,
|
||||
);
|
||||
clearMfaCookie(response);
|
||||
return response;
|
||||
}
|
||||
|
||||
if (!pending.user.isActive) {
|
||||
await discardPendingLogin(pending.id);
|
||||
const response = jsonError("Dieses Konto ist deaktiviert.", 403);
|
||||
clearMfaCookie(response);
|
||||
return response;
|
||||
}
|
||||
|
||||
const eingabe = parsed.data.code.trim();
|
||||
|
||||
// Sechs Ziffern sind ein Einmalkennwort, alles andere ein
|
||||
// Wiederherstellungscode. Beide Wege zu probieren waere unnoetig – die
|
||||
// Formate ueberschneiden sich nicht.
|
||||
const istZiffern = /^[\d\s]+$/.test(eingabe);
|
||||
|
||||
// Bei den Ziffern zaehlt zusaetzlich, dass das Zeitfenster neuer ist als
|
||||
// das zuletzt eingeloeste. Sonst liesse sich ein abgefangener Code die
|
||||
// restliche Gueltigkeitsdauer ueber wiederverwenden – RFC 6238, 5.2.
|
||||
const fenster =
|
||||
istZiffern && pending.user.totpSecret
|
||||
? matchTotp(pending.user.totpSecret, eingabe)
|
||||
: null;
|
||||
const frisch =
|
||||
fenster !== null &&
|
||||
(pending.user.totpLastCounter === null || fenster > pending.user.totpLastCounter);
|
||||
|
||||
const erfolg = istZiffern ? frisch : await redeemRecoveryCode(pending.user.id, eingabe);
|
||||
|
||||
if (!erfolg) {
|
||||
const weiterMoeglich = await noteMfaFailure(pending.id);
|
||||
if (!weiterMoeglich) {
|
||||
const response = jsonError(
|
||||
"Zu viele Fehlversuche. Bitte melde dich neu an.",
|
||||
429,
|
||||
);
|
||||
clearMfaCookie(response);
|
||||
return response;
|
||||
}
|
||||
return jsonError(GENERIC, 401);
|
||||
}
|
||||
|
||||
await discardPendingLogin(pending.id);
|
||||
await noteSuccessfulLogin(pending.user.id);
|
||||
|
||||
// Das eingeloeste Fenster merken, damit derselbe Code verbrannt ist.
|
||||
if (fenster !== null) {
|
||||
await prisma.user.update({
|
||||
where: { id: pending.user.id },
|
||||
data: { totpLastCounter: fenster },
|
||||
});
|
||||
}
|
||||
|
||||
const session = await createSession(pending.user.id, {
|
||||
userAgent: request.headers.get("user-agent"),
|
||||
ip,
|
||||
});
|
||||
|
||||
const response = NextResponse.json({
|
||||
ok: true,
|
||||
user: { id: pending.user.id, username: pending.user.username, role: pending.user.role },
|
||||
});
|
||||
setSessionCookie(response, session.token, session.expiresAt);
|
||||
clearMfaCookie(response);
|
||||
return response;
|
||||
}
|
||||
@@ -39,7 +39,7 @@ export async function POST(request: Request) {
|
||||
|
||||
const { username, displayName, email, password } = parsed.data;
|
||||
|
||||
const weak = validatePasswordStrength(password, username);
|
||||
const weak = validatePasswordStrength(password);
|
||||
if (weak) {
|
||||
return NextResponse.json({ error: weak, fields: { password: weak } }, { status: 422 });
|
||||
}
|
||||
|
||||
@@ -34,7 +34,7 @@ export async function POST(request: Request) {
|
||||
|
||||
const { username, displayName, email, password, mode } = parsed.data;
|
||||
|
||||
const weak = validatePasswordStrength(password, username);
|
||||
const weak = validatePasswordStrength(password);
|
||||
if (weak) {
|
||||
return NextResponse.json(
|
||||
{ error: weak, fields: { password: weak } },
|
||||
|
||||
@@ -14,7 +14,7 @@ type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
const safeSelect = {
|
||||
...connectionSafeSelect,
|
||||
_count: { select: { repositories: true } },
|
||||
_count: { select: { projects: true } },
|
||||
};
|
||||
|
||||
export async function PATCH(request: Request, { params }: Params) {
|
||||
|
||||
@@ -14,7 +14,7 @@ export const dynamic = "force-dynamic";
|
||||
/** Verbindungen ohne Token-Chiffrat – das verlaesst den Server nie. */
|
||||
const safeSelect = {
|
||||
...connectionSafeSelect,
|
||||
_count: { select: { repositories: true } },
|
||||
_count: { select: { projects: true } },
|
||||
};
|
||||
|
||||
export async function GET() {
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { recordActivity, shorten } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
@@ -45,18 +44,6 @@ export async function PATCH(request: Request, { params }: Params) {
|
||||
},
|
||||
});
|
||||
|
||||
// Nur Anheften ist keine inhaltliche Aenderung und kommt nicht in den
|
||||
// Verlauf – sonst steht dort dreimal dieselbe Notiz, weil jemand unschluessig war.
|
||||
if (parsed.data.title !== undefined || parsed.data.content !== undefined) {
|
||||
await recordActivity({
|
||||
projectId: note.projectId,
|
||||
userId: auth.user.id,
|
||||
kind: "NOTE_UPDATED",
|
||||
summary: `Notiz bearbeitet: ${shorten(updated.title || updated.content)}`,
|
||||
meta: { noteId: id },
|
||||
});
|
||||
}
|
||||
|
||||
return NextResponse.json({ note: updated });
|
||||
}
|
||||
|
||||
@@ -66,25 +53,10 @@ export async function DELETE(_request: Request, { params }: Params) {
|
||||
|
||||
const { id } = await params;
|
||||
|
||||
// Vor dem Loeschen lesen: danach ist nicht mehr feststellbar, worum es ging.
|
||||
const vorher = await prisma.note.findFirst({
|
||||
where: { id, project: { ownerId: auth.user.id } },
|
||||
select: { projectId: true, title: true, content: true },
|
||||
});
|
||||
|
||||
const result = await prisma.note.deleteMany({
|
||||
where: { id, project: { ownerId: auth.user.id } },
|
||||
});
|
||||
if (result.count === 0) return jsonError("Notiz nicht gefunden", 404);
|
||||
|
||||
if (vorher) {
|
||||
await recordActivity({
|
||||
projectId: vorher.projectId,
|
||||
userId: auth.user.id,
|
||||
kind: "NOTE_DELETED",
|
||||
summary: `Notiz gelöscht: ${shorten(vorher.title || vorher.content)}`,
|
||||
});
|
||||
}
|
||||
|
||||
return NextResponse.json({ ok: true });
|
||||
}
|
||||
|
||||
@@ -1,93 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { encryptSecret, tokenHint } from "@/lib/crypto";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { BlockedHostError, assertAllowedUrl } from "@/lib/security/ssrf";
|
||||
import { targetSafeSelect } from "@/lib/notify/types";
|
||||
import { formatZodError, notificationTargetUpdateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
export async function PATCH(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const existing = await prisma.notificationTarget.findFirst({
|
||||
where: { id, userId: auth.user.id },
|
||||
});
|
||||
if (!existing) return jsonError("Ziel nicht gefunden", 404);
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = notificationTargetUpdateSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const data = parsed.data;
|
||||
const update: Record<string, unknown> = {};
|
||||
|
||||
if (data.name !== undefined) update.name = data.name;
|
||||
if (data.events !== undefined) update.events = data.events;
|
||||
if (data.isActive !== undefined) update.isActive = data.isActive;
|
||||
|
||||
if (data.target !== undefined) {
|
||||
if (existing.channel !== "EMAIL") {
|
||||
try {
|
||||
await assertAllowedUrl(data.target);
|
||||
} catch (error) {
|
||||
if (error instanceof BlockedHostError) {
|
||||
return NextResponse.json(
|
||||
{ error: error.message, fields: { target: error.message } },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
update.target = data.target;
|
||||
}
|
||||
|
||||
// Leeres Feld heisst "unveraendert", null heisst "entfernen".
|
||||
if (data.secret !== undefined) {
|
||||
if (data.secret) {
|
||||
update.secretCipher = encryptSecret(data.secret);
|
||||
update.secretHint = tokenHint(data.secret);
|
||||
} else {
|
||||
update.secretCipher = null;
|
||||
update.secretHint = null;
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
const target = await prisma.notificationTarget.update({
|
||||
where: { id },
|
||||
data: update,
|
||||
select: targetSafeSelect,
|
||||
});
|
||||
return NextResponse.json({ target });
|
||||
} catch {
|
||||
return jsonError("Name bereits vergeben.", 409);
|
||||
}
|
||||
}
|
||||
|
||||
export async function DELETE(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const result = await prisma.notificationTarget.deleteMany({
|
||||
where: { id, userId: auth.user.id },
|
||||
});
|
||||
if (result.count === 0) return jsonError("Ziel nicht gefunden", 404);
|
||||
|
||||
return NextResponse.json({ ok: true });
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { deliver } from "@/lib/notify/channels";
|
||||
import { testMessage } from "@/lib/notify";
|
||||
import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
|
||||
import { clientIp, jsonError, tooManyRequests } from "@/lib/security/request";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
/** Schickt eine Testnachricht an genau dieses Ziel. */
|
||||
export async function POST(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
// Loest einen ausgehenden Aufruf aus – entsprechend begrenzt.
|
||||
const limited = rateLimit(
|
||||
`notify-test:${auth.user.id}:${clientIp(request)}`,
|
||||
LIMITS.outbound.limit,
|
||||
LIMITS.outbound.windowMs,
|
||||
);
|
||||
if (!limited.ok) return tooManyRequests(limited.retryAfter);
|
||||
|
||||
const { id } = await params;
|
||||
const target = await prisma.notificationTarget.findFirst({
|
||||
where: { id, userId: auth.user.id },
|
||||
});
|
||||
if (!target) return jsonError("Ziel nicht gefunden", 404);
|
||||
|
||||
const result = await deliver(target, testMessage());
|
||||
|
||||
await prisma.notificationTarget.update({
|
||||
where: { id },
|
||||
data: { lastSentAt: new Date(), lastOk: result.ok, lastMessage: result.message },
|
||||
});
|
||||
|
||||
return NextResponse.json(result, { status: result.ok ? 200 : 502 });
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { encryptSecret, tokenHint } from "@/lib/crypto";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { readJsonBody } from "@/lib/security/request";
|
||||
import { targetSafeSelect } from "@/lib/notify/types";
|
||||
import { BlockedHostError, assertAllowedUrl } from "@/lib/security/ssrf";
|
||||
import { formatZodError, notificationTargetCreateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
export async function GET() {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const targets = await prisma.notificationTarget.findMany({
|
||||
where: { userId: auth.user.id },
|
||||
select: targetSafeSelect,
|
||||
orderBy: { name: "asc" },
|
||||
});
|
||||
return NextResponse.json({ targets });
|
||||
}
|
||||
|
||||
export async function POST(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = notificationTargetCreateSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const { name, channel, target, secret, events, isActive } = parsed.data;
|
||||
|
||||
// Webhook und ntfy ruft der Server spaeter selbst auf – gleiche Pruefung
|
||||
// wie bei den Git-Verbindungen.
|
||||
if (channel !== "EMAIL") {
|
||||
try {
|
||||
await assertAllowedUrl(target);
|
||||
} catch (error) {
|
||||
if (error instanceof BlockedHostError) {
|
||||
return NextResponse.json(
|
||||
{ error: error.message, fields: { target: error.message } },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
const duplicate = await prisma.notificationTarget.findFirst({
|
||||
where: { userId: auth.user.id, name },
|
||||
select: { id: true },
|
||||
});
|
||||
if (duplicate) {
|
||||
return NextResponse.json(
|
||||
{ error: "Name bereits vergeben.", fields: { name: "Name bereits vergeben" } },
|
||||
{ status: 409 },
|
||||
);
|
||||
}
|
||||
|
||||
const created = await prisma.notificationTarget.create({
|
||||
data: {
|
||||
userId: auth.user.id,
|
||||
name,
|
||||
channel,
|
||||
target,
|
||||
secretCipher: secret ? encryptSecret(secret) : null,
|
||||
secretHint: secret ? tokenHint(secret) : null,
|
||||
events,
|
||||
isActive,
|
||||
},
|
||||
select: targetSafeSelect,
|
||||
});
|
||||
|
||||
return NextResponse.json({ target: created }, { status: 201 });
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { ACTIVITY_LIMIT } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError } from "@/lib/security/request";
|
||||
import { ownedProject } from "@/lib/tasks";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
/** Der Verlauf eines Projekts, neueste Eintraege zuerst. */
|
||||
export async function GET(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
if (!(await ownedProject(id, auth.user.id))) {
|
||||
return jsonError("Projekt nicht gefunden", 404);
|
||||
}
|
||||
|
||||
// Number(null) waere 0 und damit endlich – ohne die Pruefung auf den
|
||||
// fehlenden Parameter kaeme genau ein Eintrag zurueck.
|
||||
const roh = new URL(request.url).searchParams.get("limit");
|
||||
const angefragt = roh === null ? Number.NaN : Number(roh);
|
||||
const take = Number.isFinite(angefragt)
|
||||
? Math.min(Math.max(angefragt, 1), ACTIVITY_LIMIT)
|
||||
: 30;
|
||||
|
||||
const activities = await prisma.activity.findMany({
|
||||
where: { projectId: id },
|
||||
orderBy: { createdAt: "desc" },
|
||||
take,
|
||||
select: {
|
||||
id: true,
|
||||
kind: true,
|
||||
summary: true,
|
||||
createdAt: true,
|
||||
user: { select: { username: true, displayName: true } },
|
||||
},
|
||||
});
|
||||
|
||||
return NextResponse.json({ activities });
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { exportFileName } from "@/lib/export/format";
|
||||
import { buildExportFile, exportInclude, toMarkdown } from "@/lib/export/project";
|
||||
import { jsonError } from "@/lib/security/request";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
/**
|
||||
* Ein einzelnes Projekt exportieren.
|
||||
*
|
||||
* ?format=json (Vorgabe) – zum Wiedereinlesen
|
||||
* ?format=md – lesbar, zum Archivieren
|
||||
*/
|
||||
export async function GET(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const format = new URL(request.url).searchParams.get("format") ?? "json";
|
||||
|
||||
const project = await prisma.project.findFirst({
|
||||
where: { id, ownerId: auth.user.id },
|
||||
include: {
|
||||
...exportInclude,
|
||||
// Fuer die Markdown-Fassung zusaetzlich der gespeicherte Stand, damit
|
||||
// die Datei auch ohne Netz vollstaendig ist.
|
||||
repositories: {
|
||||
include: {
|
||||
connection: { select: { name: true, provider: true, baseUrl: true } },
|
||||
snapshot: true,
|
||||
},
|
||||
orderBy: [{ position: "asc" }, { createdAt: "asc" }],
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
if (!project) return jsonError("Projekt nicht gefunden", 404);
|
||||
|
||||
if (format === "md" || format === "markdown") {
|
||||
const filename = exportFileName(project.slug, new Date(), "md");
|
||||
return new Response(toMarkdown(project), {
|
||||
headers: {
|
||||
"Content-Type": "text/markdown; charset=utf-8",
|
||||
"Content-Disposition": `attachment; filename="${filename}"`,
|
||||
"Cache-Control": "no-store",
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
const payload = buildExportFile([project]);
|
||||
const filename = exportFileName(project.slug, new Date(), "json");
|
||||
|
||||
return new Response(JSON.stringify(payload, null, 2), {
|
||||
headers: {
|
||||
"Content-Type": "application/json; charset=utf-8",
|
||||
"Content-Disposition": `attachment; filename="${filename}"`,
|
||||
"Cache-Control": "no-store",
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -1,5 +1,4 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { recordActivity, shorten } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
@@ -65,13 +64,5 @@ export async function POST(request: Request, { params }: Params) {
|
||||
// Projekt "anfassen", damit die Sortierung nach Aktivitaet stimmt.
|
||||
await prisma.project.update({ where: { id }, data: { updatedAt: new Date() } });
|
||||
|
||||
await recordActivity({
|
||||
projectId: id,
|
||||
userId: auth.user.id,
|
||||
kind: "NOTE_ADDED",
|
||||
summary: `Notiz angelegt: ${shorten(note.title || note.content)}`,
|
||||
meta: { noteId: note.id },
|
||||
});
|
||||
|
||||
return NextResponse.json({ note }, { status: 201 });
|
||||
}
|
||||
|
||||
@@ -1,122 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { recordActivity, shorten } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { connectionSafeSelect } from "@/lib/projects";
|
||||
import {
|
||||
completeRepoInput,
|
||||
namesRepository,
|
||||
nextRepoPosition,
|
||||
repoTitle,
|
||||
} from "@/lib/repositories";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { ownedProject } from "@/lib/tasks";
|
||||
import { formatZodError, repositoryCreateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
/** Hoechstzahl je Projekt. Wer mehr braucht, hat mehrere Vorhaben. */
|
||||
const MAX_REPOS = 20;
|
||||
|
||||
const include = {
|
||||
connection: { select: connectionSafeSelect },
|
||||
snapshot: true,
|
||||
} as const;
|
||||
|
||||
export async function GET(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
if (!(await ownedProject(id, auth.user.id))) {
|
||||
return jsonError("Projekt nicht gefunden", 404);
|
||||
}
|
||||
|
||||
const repositories = await prisma.repository.findMany({
|
||||
where: { projectId: id },
|
||||
include,
|
||||
orderBy: [{ position: "asc" }, { createdAt: "asc" }],
|
||||
});
|
||||
|
||||
return NextResponse.json({ repositories });
|
||||
}
|
||||
|
||||
export async function POST(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
if (!(await ownedProject(id, auth.user.id))) {
|
||||
return jsonError("Projekt nicht gefunden", 404);
|
||||
}
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = repositoryCreateSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const eingabe = completeRepoInput(parsed.data);
|
||||
if (!namesRepository(eingabe)) {
|
||||
return jsonError("Bitte eine Repo-URL oder Owner und Name angeben.", 422);
|
||||
}
|
||||
|
||||
// Eine fremde Verbindung darf nicht untergeschoben werden.
|
||||
if (eingabe.connectionId) {
|
||||
const connection = await prisma.gitConnection.findFirst({
|
||||
where: { id: eingabe.connectionId, ownerId: auth.user.id },
|
||||
select: { id: true },
|
||||
});
|
||||
if (!connection) return jsonError("Git-Verbindung nicht gefunden.", 404);
|
||||
}
|
||||
|
||||
const vorhanden = await prisma.repository.count({ where: { projectId: id } });
|
||||
if (vorhanden >= MAX_REPOS) {
|
||||
return jsonError(`Mehr als ${MAX_REPOS} Repositories je Projekt sind nicht vorgesehen.`, 409);
|
||||
}
|
||||
|
||||
// Dasselbe Repo zweimal am selben Projekt ist immer ein Versehen.
|
||||
if (eingabe.repoOwner && eingabe.repoName) {
|
||||
const doppelt = await prisma.repository.findFirst({
|
||||
where: { projectId: id, repoOwner: eingabe.repoOwner, repoName: eingabe.repoName },
|
||||
select: { id: true },
|
||||
});
|
||||
if (doppelt) {
|
||||
return jsonError(
|
||||
`${eingabe.repoOwner}/${eingabe.repoName} ist mit diesem Projekt bereits verknuepft.`,
|
||||
409,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
const repository = await prisma.repository.create({
|
||||
data: {
|
||||
projectId: id,
|
||||
label: eingabe.label ?? null,
|
||||
repoUrl: eingabe.repoUrl ?? null,
|
||||
repoOwner: eingabe.repoOwner ?? null,
|
||||
repoName: eingabe.repoName ?? null,
|
||||
connectionId: eingabe.connectionId ?? null,
|
||||
autoSync: eingabe.autoSync ?? true,
|
||||
position: await nextRepoPosition(id),
|
||||
},
|
||||
include,
|
||||
});
|
||||
|
||||
await recordActivity({
|
||||
projectId: id,
|
||||
userId: auth.user.id,
|
||||
kind: "REPO_LINKED",
|
||||
summary: `Repository verknüpft: ${shorten(repoTitle(repository))}`,
|
||||
meta: { repositoryId: repository.id },
|
||||
});
|
||||
|
||||
return NextResponse.json({ repository }, { status: 201 });
|
||||
}
|
||||
@@ -1,17 +1,9 @@
|
||||
import type { ProjectStatus } from "@prisma/client";
|
||||
import { NextResponse } from "next/server";
|
||||
import { describeFields, describeStatus, recordActivities, shorten } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import {
|
||||
nextProjectPosition,
|
||||
projectDetailInclude,
|
||||
projectListInclude,
|
||||
uniqueSlug,
|
||||
} from "@/lib/projects";
|
||||
import { applyLeadingRepo, type RepoInput } from "@/lib/repositories";
|
||||
import { parseRepoUrl } from "@/lib/git";
|
||||
import { projectDetailInclude, projectListInclude, uniqueSlug } from "@/lib/projects";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { refreshDerivedProgress } from "@/lib/tasks";
|
||||
import { formatZodError, projectUpdateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
@@ -82,104 +74,35 @@ export async function PATCH(request: Request, { params }: Params) {
|
||||
"accent",
|
||||
"tags",
|
||||
"favorite",
|
||||
"progressFromTasks",
|
||||
"autoSync",
|
||||
"connectionId",
|
||||
] as const) {
|
||||
if (data[key] !== undefined) update[key] = data[key];
|
||||
}
|
||||
|
||||
// Beim Statuswechsel ans Ende der neuen Spalte – sonst behielte das Projekt
|
||||
// seinen alten Rang und saesse mitten in einer Spalte, in der es eben erst
|
||||
// angekommen ist.
|
||||
if (data.status !== undefined && data.status !== existing.status) {
|
||||
update.position = await nextProjectPosition(auth.user.id, data.status);
|
||||
if (data.repoUrl !== undefined) {
|
||||
update.repoUrl = data.repoUrl;
|
||||
const parsedUrl = data.repoUrl ? parseRepoUrl(data.repoUrl) : null;
|
||||
if (parsedUrl) {
|
||||
update.repoOwner = data.repoOwner ?? parsedUrl.owner;
|
||||
update.repoName = data.repoName ?? parsedUrl.name;
|
||||
} else if (!data.repoUrl) {
|
||||
update.repoOwner = null;
|
||||
update.repoName = null;
|
||||
}
|
||||
}
|
||||
if (data.repoOwner !== undefined) update.repoOwner = data.repoOwner;
|
||||
if (data.repoName !== undefined) update.repoName = data.repoName;
|
||||
|
||||
await prisma.project.update({ where: { id }, data: update });
|
||||
|
||||
// Die Git-Felder gehen an das fuehrende Repository. Sie hier weiterhin
|
||||
// anzunehmen erspart der Oberflaeche zwei Aufrufe fuer einen Speichervorgang.
|
||||
const repoFelder = {
|
||||
repoUrl: data.repoUrl,
|
||||
repoOwner: data.repoOwner,
|
||||
repoName: data.repoName,
|
||||
connectionId: data.connectionId,
|
||||
autoSync: data.autoSync,
|
||||
};
|
||||
const repoBeruehrt = Object.values(repoFelder).some((value) => value !== undefined);
|
||||
if (repoBeruehrt) await applyLeadingRepo(id, repoFelder);
|
||||
|
||||
await noteChanges(id, auth.user.id, existing, update, repoBeruehrt ? repoFelder : null);
|
||||
|
||||
// Wird die Ableitung eingeschaltet, soll der Wert sofort stimmen und nicht
|
||||
// erst beim naechsten Aufgabenwechsel.
|
||||
if (data.progressFromTasks === true) {
|
||||
await refreshDerivedProgress(id);
|
||||
}
|
||||
|
||||
const project = await prisma.project.findUniqueOrThrow({
|
||||
const project = await prisma.project.update({
|
||||
where: { id },
|
||||
data: update,
|
||||
include: projectListInclude,
|
||||
});
|
||||
|
||||
return NextResponse.json({ project });
|
||||
}
|
||||
|
||||
/**
|
||||
* Haelt fest, was sich geaendert hat. Status und Repo-Verknuepfung bekommen
|
||||
* einen eigenen Eintrag – sie sind die Vorgaenge, die man spaeter sucht. Alles
|
||||
* uebrige fasst ein Eintrag zusammen, sonst ertraenkt eine Feinjustage der
|
||||
* Farbe den Verlauf.
|
||||
*/
|
||||
async function noteChanges(
|
||||
projectId: string,
|
||||
userId: string,
|
||||
before: { status: ProjectStatus },
|
||||
update: Record<string, unknown>,
|
||||
repo: RepoInput | null,
|
||||
) {
|
||||
const rest = Object.keys(update).filter((key) => key !== "status" && key !== "slug");
|
||||
const entries: Parameters<typeof recordActivities>[0] = [];
|
||||
|
||||
if (update.status !== undefined && update.status !== before.status) {
|
||||
const to = update.status as ProjectStatus;
|
||||
entries.push({
|
||||
projectId,
|
||||
userId,
|
||||
kind: "STATUS_CHANGED",
|
||||
summary: describeStatus(before.status, to),
|
||||
meta: { from: before.status, to },
|
||||
});
|
||||
}
|
||||
|
||||
// Nur die Verknuepfung selbst ist eine Nachricht wert. Ob der automatische
|
||||
// Abgleich an oder aus ist, gehoert zu den uebrigen Feldern.
|
||||
if (repo && (repo.repoUrl !== undefined || repo.repoName !== undefined)) {
|
||||
const ziel = repo.repoUrl ?? (repo.repoOwner ? `${repo.repoOwner}/${repo.repoName}` : null);
|
||||
entries.push({
|
||||
projectId,
|
||||
userId,
|
||||
kind: "REPO_LINKED",
|
||||
summary: ziel ? `Repository verknüpft: ${shorten(ziel)}` : "Repository-Angaben geleert",
|
||||
meta: { repoUrl: repo.repoUrl ?? null },
|
||||
});
|
||||
}
|
||||
if (repo?.autoSync !== undefined) rest.push("autoSync");
|
||||
if (repo?.connectionId !== undefined) rest.push("connectionId");
|
||||
|
||||
const felder = describeFields(rest);
|
||||
if (felder) {
|
||||
entries.push({
|
||||
projectId,
|
||||
userId,
|
||||
kind: "PROJECT_UPDATED",
|
||||
summary: felder,
|
||||
meta: { fields: rest },
|
||||
});
|
||||
}
|
||||
|
||||
await recordActivities(entries);
|
||||
}
|
||||
|
||||
export async function DELETE(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
@@ -1,147 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { z } from "zod";
|
||||
import { recordActivity } from "@/lib/activity";
|
||||
import { repoTitle } from "@/lib/repositories";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { nextPosition, ownedProject, refreshDerivedProgress } from "@/lib/tasks";
|
||||
import { asArray, type TicketInfo } from "@/types";
|
||||
import { formatZodError } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
const schema = z.object({
|
||||
/** Leer heisst: alle offenen Issues aus dem Snapshot. */
|
||||
numbers: z.array(z.number().int()).max(200).optional(),
|
||||
/** Aus welchem Repository. Leer heisst: dem fuehrenden. */
|
||||
repositoryId: z.string().optional(),
|
||||
});
|
||||
|
||||
/**
|
||||
* Uebernimmt offene Issues des verknuepften Repositories als Aufgaben.
|
||||
*
|
||||
* Grundlage ist der zuletzt geholte Snapshot – hier wird nichts nachgeladen,
|
||||
* damit ein Klick nicht ungefragt fremde APIs anspricht. Wer den neuesten
|
||||
* Stand will, gleicht vorher ab.
|
||||
*
|
||||
* Bereits uebernommene Issues werden uebersprungen: die Nummer steht an der
|
||||
* Aufgabe und ist je Projekt eindeutig. Ein zweiter Aufruf legt also keine
|
||||
* Dubletten an, auch wenn die Aufgabe inzwischen verschoben oder umbenannt
|
||||
* wurde.
|
||||
*/
|
||||
export async function POST(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
if (!(await ownedProject(id, auth.user.id))) {
|
||||
return jsonError("Projekt nicht gefunden", 404);
|
||||
}
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = schema.safeParse(body.data ?? {});
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
// Die Besitzerbedingung laeuft ueber das Projekt, dessen Besitz eben
|
||||
// geprueft wurde – eine fremde Repository-ID trifft hier also nichts.
|
||||
const repository = await prisma.repository.findFirst({
|
||||
where: { projectId: id, ...(parsed.data.repositoryId ? { id: parsed.data.repositoryId } : {}) },
|
||||
orderBy: [{ position: "asc" }, { createdAt: "asc" }],
|
||||
include: { snapshot: true },
|
||||
});
|
||||
|
||||
if (!repository) {
|
||||
// 404 nur, wenn nach einem bestimmten gefragt wurde. Wer nichts angibt,
|
||||
// hat schlicht noch keines verknuepft – und das ist kein "nicht gefunden".
|
||||
return parsed.data.repositoryId
|
||||
? jsonError("Repository nicht gefunden", 404)
|
||||
: jsonError("Kein Repository verknuepft. Bitte zuerst eines hinterlegen.", 409);
|
||||
}
|
||||
|
||||
const snapshot = repository.snapshot;
|
||||
if (!snapshot) {
|
||||
return jsonError(
|
||||
"Noch kein Repo-Stand vorhanden. Bitte zuerst synchronisieren.",
|
||||
409,
|
||||
);
|
||||
}
|
||||
|
||||
const alle = asArray<TicketInfo>(snapshot.issues);
|
||||
const gewuenscht = parsed.data.numbers;
|
||||
const auswahl = gewuenscht?.length
|
||||
? alle.filter((issue) => gewuenscht.includes(issue.number))
|
||||
: alle;
|
||||
|
||||
if (auswahl.length === 0) {
|
||||
return NextResponse.json({ created: 0, skipped: 0, tasks: [] });
|
||||
}
|
||||
|
||||
const vorhanden = await prisma.task.findMany({
|
||||
where: {
|
||||
projectId: id,
|
||||
sourceRepositoryId: repository.id,
|
||||
sourceIssue: { in: auswahl.map((issue) => issue.number) },
|
||||
},
|
||||
select: { sourceIssue: true },
|
||||
});
|
||||
const bekannt = new Set(vorhanden.map((task) => task.sourceIssue));
|
||||
|
||||
const neu = auswahl.filter((issue) => !bekannt.has(issue.number));
|
||||
let position = await nextPosition(id, "TODO");
|
||||
|
||||
const angelegt = [];
|
||||
for (const issue of neu) {
|
||||
angelegt.push(
|
||||
await prisma.task.create({
|
||||
data: {
|
||||
projectId: id,
|
||||
title: issue.title.slice(0, 200),
|
||||
// Der Link ist das Wichtigste – der Text steht im Git-System.
|
||||
description: issue.url ? `[Issue #${issue.number}](${issue.url})` : null,
|
||||
status: "TODO",
|
||||
position: position++,
|
||||
labels: issue.labels.slice(0, 8),
|
||||
sourceIssue: issue.number,
|
||||
sourceUrl: issue.url,
|
||||
sourceRepositoryId: repository.id,
|
||||
},
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
if (angelegt.length > 0) {
|
||||
await refreshDerivedProgress(id);
|
||||
await prisma.project.update({ where: { id }, data: { updatedAt: new Date() } });
|
||||
// Ein Eintrag fuer den Vorgang, nicht einer je Aufgabe: sonst besteht der
|
||||
// Verlauf nach einer Uebernahme aus nichts anderem mehr.
|
||||
await recordActivity({
|
||||
projectId: id,
|
||||
userId: auth.user.id,
|
||||
kind: "TASKS_IMPORTED",
|
||||
summary:
|
||||
angelegt.length === 1
|
||||
? `1 Issue aus ${repoTitle(repository)} als Aufgabe übernommen`
|
||||
: `${angelegt.length} Issues aus ${repoTitle(repository)} als Aufgaben übernommen`,
|
||||
meta: {
|
||||
repositoryId: repository.id,
|
||||
numbers: angelegt.map((task) => task.sourceIssue),
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
return NextResponse.json({
|
||||
created: angelegt.length,
|
||||
skipped: auswahl.length - angelegt.length,
|
||||
tasks: angelegt,
|
||||
});
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import type { Prisma, TaskStatus } from "@prisma/client";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { ownedProject, refreshDerivedProgress, spawnRecurrence } from "@/lib/tasks";
|
||||
import { formatZodError, taskReorderSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
/**
|
||||
* Neue Reihenfolge nach dem Ziehen.
|
||||
*
|
||||
* Uebergeben wird je betroffener Spalte die vollstaendige Liste der Aufgaben
|
||||
* in ihrer neuen Reihenfolge. Daraus ergeben sich Status und Position
|
||||
* eindeutig – der Aufruf ist damit wiederholbar, ohne Schaden anzurichten,
|
||||
* und ein verlorener Aufruf laesst sich einfach erneut senden.
|
||||
*/
|
||||
export async function PATCH(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
if (!(await ownedProject(id, auth.user.id))) {
|
||||
return jsonError("Projekt nicht gefunden", 404);
|
||||
}
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = taskReorderSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const columns = parsed.data.columns as Partial<Record<TaskStatus, string[]>>;
|
||||
const requestedIds = Object.values(columns).flat();
|
||||
|
||||
// Nur Aufgaben anfassen, die wirklich zu diesem Projekt gehoeren – sonst
|
||||
// liessen sich fremde Aufgaben ueber untergeschobene IDs verschieben.
|
||||
const owned = await prisma.task.findMany({
|
||||
where: { projectId: id, id: { in: requestedIds } },
|
||||
select: { id: true, status: true },
|
||||
});
|
||||
const ownedIds = new Set(owned.map((task) => task.id));
|
||||
const previousStatus = new Map(owned.map((task) => [task.id, task.status]));
|
||||
|
||||
const now = new Date();
|
||||
const updates: Prisma.PrismaPromise<unknown>[] = [];
|
||||
/** Wer eben erst nach ERLEDIGT gewandert ist – nicht, wer dort schon lag. */
|
||||
const frischErledigt: string[] = [];
|
||||
|
||||
for (const [status, ids] of Object.entries(columns) as Array<[TaskStatus, string[]]>) {
|
||||
ids.forEach((taskId, index) => {
|
||||
if (!ownedIds.has(taskId)) return;
|
||||
const before = previousStatus.get(taskId);
|
||||
if (status === "DONE" && before !== "DONE") frischErledigt.push(taskId);
|
||||
updates.push(
|
||||
prisma.task.update({
|
||||
where: { id: taskId },
|
||||
data: {
|
||||
status,
|
||||
position: index,
|
||||
// doneAt nur beim tatsaechlichen Wechsel setzen oder loeschen,
|
||||
// damit ein Umsortieren innerhalb von "Erledigt" das Datum nicht
|
||||
// immer wieder erneuert.
|
||||
...(before !== status
|
||||
? { doneAt: status === "DONE" ? now : null }
|
||||
: {}),
|
||||
},
|
||||
}),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
if (updates.length > 0) {
|
||||
await prisma.$transaction(updates);
|
||||
|
||||
// Wiederkehrende Aufgaben, die eben nach ERLEDIGT gezogen wurden,
|
||||
// bekommen ihre naechste Fassung. Erst nach der Transaktion: vorher
|
||||
// stuende doneAt noch nicht, aus dem der Folgetermin gerechnet wird.
|
||||
for (const taskId of frischErledigt) {
|
||||
await spawnRecurrence(taskId);
|
||||
}
|
||||
|
||||
await refreshDerivedProgress(id);
|
||||
}
|
||||
|
||||
const tasks = await prisma.task.findMany({
|
||||
where: { projectId: id },
|
||||
orderBy: [{ status: "asc" }, { position: "asc" }],
|
||||
});
|
||||
|
||||
return NextResponse.json({
|
||||
tasks,
|
||||
updated: updates.length,
|
||||
ignored: requestedIds.length - updates.length,
|
||||
});
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { recordActivity, shorten } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { nextPosition, ownedProject, refreshDerivedProgress } from "@/lib/tasks";
|
||||
import { formatZodError, taskCreateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
export async function GET(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
if (!(await ownedProject(id, auth.user.id))) {
|
||||
return jsonError("Projekt nicht gefunden", 404);
|
||||
}
|
||||
|
||||
const tasks = await prisma.task.findMany({
|
||||
where: { projectId: id },
|
||||
orderBy: [{ status: "asc" }, { position: "asc" }],
|
||||
});
|
||||
return NextResponse.json({ tasks });
|
||||
}
|
||||
|
||||
export async function POST(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
if (!(await ownedProject(id, auth.user.id))) {
|
||||
return jsonError("Projekt nicht gefunden", 404);
|
||||
}
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = taskCreateSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const { title, description, status, dueDate, labels, recurrence } = parsed.data;
|
||||
|
||||
const task = await prisma.task.create({
|
||||
data: {
|
||||
projectId: id,
|
||||
title,
|
||||
description: description ?? null,
|
||||
status,
|
||||
// Neue Aufgaben landen unten in ihrer Spalte.
|
||||
position: await nextPosition(id, status),
|
||||
dueDate: dueDate ? new Date(dueDate) : null,
|
||||
labels,
|
||||
recurrence: recurrence ?? null,
|
||||
doneAt: status === "DONE" ? new Date() : null,
|
||||
},
|
||||
});
|
||||
|
||||
await refreshDerivedProgress(id);
|
||||
// Damit die Sortierung nach Aktivitaet stimmt.
|
||||
await prisma.project.update({ where: { id }, data: { updatedAt: new Date() } });
|
||||
|
||||
await recordActivity({
|
||||
projectId: id,
|
||||
userId: auth.user.id,
|
||||
kind: "TASK_ADDED",
|
||||
summary: `Aufgabe angelegt: ${shorten(task.title, 50)}`,
|
||||
meta: { taskId: task.id },
|
||||
});
|
||||
|
||||
return NextResponse.json({ task }, { status: 201 });
|
||||
}
|
||||
@@ -1,150 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import type { Prisma, ProjectStatus } from "@prisma/client";
|
||||
import { describeStatus, recordActivities } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
|
||||
import { clientIp, readJsonBody, tooManyRequests } from "@/lib/security/request";
|
||||
import { formatZodError, projectBulkSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
/**
|
||||
* Dieselbe Aenderung fuer mehrere Projekte auf einmal.
|
||||
*
|
||||
* Der Weg ueber einen eigenen Endpunkt statt vieler einzelner PATCHes hat
|
||||
* zwei Gruende: es ist eine Transaktion statt zwanzig Rundgaengen, und der
|
||||
* Verlauf bekommt je Projekt genau einen Eintrag statt eines Schwalls.
|
||||
*/
|
||||
export async function POST(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const limited = rateLimit(
|
||||
`mutate:${clientIp(request)}`,
|
||||
LIMITS.mutation.limit,
|
||||
LIMITS.mutation.windowMs,
|
||||
);
|
||||
if (!limited.ok) return tooManyRequests(limited.retryAfter);
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = projectBulkSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const { ids, action } = parsed.data;
|
||||
|
||||
// Die Besitzerbedingung steht zuerst: fremde IDs werden hier gar nicht
|
||||
// erst eingesammelt und fallen damit still unter den Tisch.
|
||||
const owned = await prisma.project.findMany({
|
||||
where: { ownerId: auth.user.id, id: { in: ids } },
|
||||
select: { id: true, status: true, tags: true, favorite: true, updatedAt: true },
|
||||
});
|
||||
|
||||
if (owned.length === 0) {
|
||||
return NextResponse.json({ changed: 0, ignored: ids.length });
|
||||
}
|
||||
|
||||
const eigene = owned.map((project) => project.id);
|
||||
const entries: Parameters<typeof recordActivities>[0] = [];
|
||||
|
||||
if (action === "delete") {
|
||||
const result = await prisma.project.deleteMany({
|
||||
where: { ownerId: auth.user.id, id: { in: eigene } },
|
||||
});
|
||||
return NextResponse.json({ changed: result.count, ignored: ids.length - result.count });
|
||||
}
|
||||
|
||||
const updates: Prisma.PrismaPromise<unknown>[] = [];
|
||||
|
||||
// Einmal vorab bestimmen und hochzaehlen. Je Projekt neu abzufragen ergaebe
|
||||
// immer dieselbe Zahl – die Transaktion ist ja noch nicht geschrieben, und
|
||||
// alle Verschobenen landeten uebereinander auf derselben Position.
|
||||
let position =
|
||||
action === "status" ? await nextPosition(auth.user.id, parsed.data.status!) : 0;
|
||||
|
||||
for (const project of owned) {
|
||||
if (action === "status") {
|
||||
const ziel = parsed.data.status!;
|
||||
if (project.status === ziel) continue;
|
||||
updates.push(
|
||||
prisma.project.update({
|
||||
where: { id: project.id },
|
||||
// Ans Ende der Zielspalte, wie beim einzelnen Verschieben auch.
|
||||
data: { status: ziel, position: position++ },
|
||||
}),
|
||||
);
|
||||
entries.push({
|
||||
projectId: project.id,
|
||||
userId: auth.user.id,
|
||||
kind: "STATUS_CHANGED",
|
||||
summary: describeStatus(project.status, ziel),
|
||||
meta: { from: project.status, to: ziel, bulk: true },
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
if (action === "favorite") {
|
||||
const ziel = parsed.data.favorite!;
|
||||
if (project.favorite === ziel) continue;
|
||||
updates.push(
|
||||
prisma.project.update({
|
||||
where: { id: project.id },
|
||||
// Ein Stern ist keine inhaltliche Aenderung.
|
||||
data: { favorite: ziel, updatedAt: project.updatedAt },
|
||||
}),
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
// action === "tags"
|
||||
const gewuenscht = parsed.data.tags!.map((tag) => tag.toLowerCase());
|
||||
const naechste =
|
||||
parsed.data.tagMode === "add"
|
||||
? Array.from(new Set([...project.tags, ...gewuenscht])).slice(0, 12)
|
||||
: project.tags.filter((tag) => !gewuenscht.includes(tag));
|
||||
|
||||
if (naechste.length === project.tags.length &&
|
||||
naechste.every((tag, index) => tag === project.tags[index])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
updates.push(
|
||||
prisma.project.update({ where: { id: project.id }, data: { tags: naechste } }),
|
||||
);
|
||||
entries.push({
|
||||
projectId: project.id,
|
||||
userId: auth.user.id,
|
||||
kind: "PROJECT_UPDATED",
|
||||
summary: "Tags geändert",
|
||||
meta: { tags: naechste, bulk: true },
|
||||
});
|
||||
}
|
||||
|
||||
if (updates.length > 0) {
|
||||
await prisma.$transaction(updates);
|
||||
await recordActivities(entries);
|
||||
}
|
||||
|
||||
return NextResponse.json({
|
||||
changed: updates.length,
|
||||
// Nicht geaendert, weil schon so, oder weil die ID nicht dem Konto gehoert.
|
||||
ignored: ids.length - updates.length,
|
||||
});
|
||||
}
|
||||
|
||||
/** Naechste freie Position am Ende einer Statusspalte. */
|
||||
async function nextPosition(ownerId: string, status: ProjectStatus) {
|
||||
const last = await prisma.project.findFirst({
|
||||
where: { ownerId, status },
|
||||
orderBy: { position: "desc" },
|
||||
select: { position: true },
|
||||
});
|
||||
return (last?.position ?? -1) + 1;
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { APP_NAME } from "@/lib/config";
|
||||
import { exportFileName } from "@/lib/export/format";
|
||||
import { buildExportFile, loadProjectsForExport } from "@/lib/export/project";
|
||||
import { jsonError } from "@/lib/security/request";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
/** Alle eigenen Projekte als JSON zum Herunterladen. */
|
||||
export async function GET() {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const projects = await loadProjectsForExport(auth.user.id);
|
||||
if (projects.length === 0) {
|
||||
return jsonError("Es gibt noch keine Projekte zum Exportieren.", 404);
|
||||
}
|
||||
|
||||
const payload = buildExportFile(projects);
|
||||
const filename = exportFileName(`${APP_NAME}-projekte`, new Date(), "json");
|
||||
|
||||
return new Response(JSON.stringify(payload, null, 2), {
|
||||
headers: {
|
||||
"Content-Type": "application/json; charset=utf-8",
|
||||
"Content-Disposition": `attachment; filename="${filename}"`,
|
||||
"Cache-Control": "no-store",
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -1,276 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { z } from "zod";
|
||||
import { recordActivity } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import {
|
||||
exportFileSchema,
|
||||
repositoriesOf,
|
||||
type ExportedRepository,
|
||||
} from "@/lib/export/format";
|
||||
import { nextProjectPosition, uniqueSlug } from "@/lib/projects";
|
||||
import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
|
||||
import {
|
||||
IMPORT_MAX_BODY_BYTES,
|
||||
clientIp,
|
||||
jsonError,
|
||||
readJsonBody,
|
||||
tooManyRequests,
|
||||
} from "@/lib/security/request";
|
||||
import { slugify } from "@/lib/utils";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
const requestSchema = z.object({
|
||||
data: z.unknown(),
|
||||
/**
|
||||
* skip – vorhandene Projekte unveraendert lassen
|
||||
* rename – zusaetzlich anlegen, mit freiem Slug
|
||||
* overwrite – vorhandenes Projekt ersetzen (Notizen werden ausgetauscht)
|
||||
*/
|
||||
strategy: z.enum(["skip", "rename", "overwrite"]).default("skip"),
|
||||
/** Nur pruefen und berichten, nichts schreiben. */
|
||||
dryRun: z.boolean().default(true),
|
||||
});
|
||||
|
||||
type Action = "create" | "rename" | "overwrite" | "skip" | "error";
|
||||
|
||||
interface ItemResult {
|
||||
name: string;
|
||||
slug: string;
|
||||
action: Action;
|
||||
/** Bei "rename" der tatsaechlich vergebene Slug. */
|
||||
newSlug?: string;
|
||||
notes: number;
|
||||
/** matched: Verbindung gefunden · missing: beschrieben, aber nicht vorhanden */
|
||||
connection: "matched" | "missing" | "none";
|
||||
connectionName?: string;
|
||||
message?: string;
|
||||
}
|
||||
|
||||
export async function POST(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const limited = rateLimit(
|
||||
`import:${clientIp(request)}`,
|
||||
LIMITS.mutation.limit,
|
||||
LIMITS.mutation.windowMs,
|
||||
);
|
||||
if (!limited.ok) return tooManyRequests(limited.retryAfter);
|
||||
|
||||
const body = await readJsonBody(request, IMPORT_MAX_BODY_BYTES);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const outer = requestSchema.safeParse(body.data);
|
||||
if (!outer.success) return jsonError("Ungueltige Anfrage.", 422);
|
||||
|
||||
// Die hochgeladene Datei ist Fremdinhalt – strikt pruefen, bevor irgendetwas
|
||||
// damit passiert.
|
||||
const parsed = exportFileSchema.safeParse(outer.data.data);
|
||||
if (!parsed.success) {
|
||||
const first = parsed.error.issues[0];
|
||||
return NextResponse.json(
|
||||
{
|
||||
error:
|
||||
"Die Datei passt nicht zum erwarteten Format. " +
|
||||
(first ? `${first.path.join(".") || "Datei"}: ${first.message}` : ""),
|
||||
},
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const { strategy, dryRun } = outer.data;
|
||||
const file = parsed.data;
|
||||
|
||||
// Verbindungen des Kontos einmal laden, um sie den Projekten zuzuordnen.
|
||||
const connections = await prisma.gitConnection.findMany({
|
||||
where: { ownerId: auth.user.id },
|
||||
select: { id: true, name: true, provider: true, baseUrl: true },
|
||||
});
|
||||
|
||||
function matchConnection(described: ExportedRepository["connection"]) {
|
||||
if (!described) return null;
|
||||
const byName = connections.find(
|
||||
(candidate) => candidate.name.toLowerCase() === described.name.toLowerCase(),
|
||||
);
|
||||
if (byName) return byName;
|
||||
return (
|
||||
connections.find(
|
||||
(candidate) =>
|
||||
candidate.provider === described.provider &&
|
||||
candidate.baseUrl.replace(/\/+$/, "").toLowerCase() ===
|
||||
described.baseUrl.replace(/\/+$/, "").toLowerCase(),
|
||||
) ?? null
|
||||
);
|
||||
}
|
||||
|
||||
const results: ItemResult[] = [];
|
||||
|
||||
for (const incoming of file.projects) {
|
||||
const slug = incoming.slug || slugify(incoming.name) || "projekt";
|
||||
|
||||
// Version 1 kannte ein Repository je Projekt und schrieb es flach; seit
|
||||
// Version 2 steht eine Liste da. repositoriesOf glaettet den Unterschied.
|
||||
const eingehendeRepos = repositoriesOf(incoming);
|
||||
const repos = eingehendeRepos.map((repo, index) => ({
|
||||
label: repo.label ?? null,
|
||||
repoUrl: repo.repoUrl ?? null,
|
||||
repoOwner: repo.repoOwner ?? null,
|
||||
repoName: repo.repoName ?? null,
|
||||
autoSync: repo.autoSync ?? true,
|
||||
connectionId: matchConnection(repo.connection ?? null)?.id ?? null,
|
||||
position: index,
|
||||
}));
|
||||
|
||||
// Fuer die Rueckmeldung genuegt, ob ueberhaupt eine beschriebene
|
||||
// Verbindung fehlt – welche, steht in der Datei.
|
||||
const beschrieben = eingehendeRepos.filter((repo) => repo.connection);
|
||||
const fehlend = beschrieben.filter((repo) => !matchConnection(repo.connection ?? null));
|
||||
const connectionState: ItemResult["connection"] =
|
||||
beschrieben.length === 0 ? "none" : fehlend.length > 0 ? "missing" : "matched";
|
||||
|
||||
const existing = await prisma.project.findFirst({
|
||||
where: { slug, ownerId: auth.user.id },
|
||||
select: { id: true },
|
||||
});
|
||||
|
||||
const base: ItemResult = {
|
||||
name: incoming.name,
|
||||
slug,
|
||||
action: "create",
|
||||
notes: incoming.notes.length,
|
||||
connection: connectionState,
|
||||
connectionName: (fehlend[0] ?? beschrieben[0])?.connection?.name,
|
||||
};
|
||||
|
||||
if (existing && strategy === "skip") {
|
||||
results.push({ ...base, action: "skip", message: "Slug bereits vergeben." });
|
||||
continue;
|
||||
}
|
||||
|
||||
const action: Action = !existing ? "create" : strategy === "rename" ? "rename" : "overwrite";
|
||||
|
||||
if (dryRun) {
|
||||
results.push({
|
||||
...base,
|
||||
action,
|
||||
...(action === "rename" ? { newSlug: `${slug}-…` } : {}),
|
||||
...(action === "overwrite"
|
||||
? { message: "Ersetzt Stammdaten und tauscht die Notizen aus." }
|
||||
: {}),
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
const data = {
|
||||
// Hinten an die Statusspalte des Bretts, in der Reihenfolge der Datei.
|
||||
position: await nextProjectPosition(auth.user.id, incoming.status),
|
||||
name: incoming.name,
|
||||
summary: incoming.summary ?? null,
|
||||
description: incoming.description ?? null,
|
||||
status: incoming.status,
|
||||
priority: incoming.priority,
|
||||
progress: incoming.progress,
|
||||
accent: incoming.accent,
|
||||
tags: incoming.tags,
|
||||
favorite: incoming.favorite,
|
||||
progressFromTasks: incoming.progressFromTasks,
|
||||
};
|
||||
|
||||
const tasks = incoming.tasks.map((task, index) => ({
|
||||
title: task.title,
|
||||
description: task.description ?? null,
|
||||
status: task.status,
|
||||
// Position aus der Datei uebernehmen, notfalls die Reihenfolge in ihr.
|
||||
position: task.position ?? index,
|
||||
dueDate: task.dueDate && !Number.isNaN(Date.parse(task.dueDate))
|
||||
? new Date(task.dueDate)
|
||||
: null,
|
||||
labels: task.labels,
|
||||
doneAt: task.status === "DONE" ? new Date() : null,
|
||||
...(task.createdAt && !Number.isNaN(Date.parse(task.createdAt))
|
||||
? { createdAt: new Date(task.createdAt) }
|
||||
: {}),
|
||||
}));
|
||||
|
||||
const notes = incoming.notes.map((note) => ({
|
||||
title: note.title ?? null,
|
||||
content: note.content,
|
||||
pinned: note.pinned ?? false,
|
||||
...(note.createdAt && !Number.isNaN(Date.parse(note.createdAt))
|
||||
? { createdAt: new Date(note.createdAt) }
|
||||
: {}),
|
||||
}));
|
||||
|
||||
try {
|
||||
if (existing && action === "overwrite") {
|
||||
// Notizen austauschen statt zusammenfuehren: vorhersagbar, und ein
|
||||
// erneuter Import erzeugt keine Dubletten.
|
||||
await prisma.$transaction([
|
||||
prisma.note.deleteMany({ where: { projectId: existing.id } }),
|
||||
prisma.task.deleteMany({ where: { projectId: existing.id } }),
|
||||
// Wie Notizen und Aufgaben: austauschen statt zusammenfuehren. Der
|
||||
// gesammelte Repo-Stand geht dabei mit, ist aber beim naechsten
|
||||
// Abgleich zurueck.
|
||||
prisma.repository.deleteMany({ where: { projectId: existing.id } }),
|
||||
prisma.project.update({
|
||||
where: { id: existing.id },
|
||||
data: {
|
||||
...data,
|
||||
slug,
|
||||
notes: { create: notes },
|
||||
tasks: { create: tasks },
|
||||
repositories: { create: repos },
|
||||
},
|
||||
}),
|
||||
]);
|
||||
results.push({ ...base, action: "overwrite" });
|
||||
} else {
|
||||
const finalSlug = existing ? await uniqueSlug(incoming.name, auth.user.id) : slug;
|
||||
const angelegt = await prisma.project.create({
|
||||
data: {
|
||||
...data,
|
||||
ownerId: auth.user.id,
|
||||
slug: finalSlug,
|
||||
notes: { create: notes },
|
||||
tasks: { create: tasks },
|
||||
repositories: { create: repos },
|
||||
},
|
||||
});
|
||||
// Der Verlauf wird nicht mitexportiert – der erste Eintrag hier haelt
|
||||
// wenigstens fest, woher das Projekt stammt.
|
||||
await recordActivity({
|
||||
projectId: angelegt.id,
|
||||
userId: auth.user.id,
|
||||
kind: "PROJECT_CREATED",
|
||||
summary: "Aus einer Exportdatei importiert",
|
||||
meta: { notes: notes.length, tasks: tasks.length },
|
||||
});
|
||||
results.push({
|
||||
...base,
|
||||
action: existing ? "rename" : "create",
|
||||
...(existing ? { newSlug: finalSlug } : {}),
|
||||
});
|
||||
}
|
||||
} catch (error) {
|
||||
results.push({
|
||||
...base,
|
||||
action: "error",
|
||||
message: error instanceof Error ? error.message : String(error),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const summary = {
|
||||
total: results.length,
|
||||
created: results.filter((entry) => entry.action === "create").length,
|
||||
renamed: results.filter((entry) => entry.action === "rename").length,
|
||||
overwritten: results.filter((entry) => entry.action === "overwrite").length,
|
||||
skipped: results.filter((entry) => entry.action === "skip").length,
|
||||
errors: results.filter((entry) => entry.action === "error").length,
|
||||
missingConnections: results.filter((entry) => entry.connection === "missing").length,
|
||||
};
|
||||
|
||||
return NextResponse.json({ dryRun, strategy, summary, results });
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import type { Prisma, ProjectStatus } from "@prisma/client";
|
||||
import { describeStatus, recordActivities } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
|
||||
import { clientIp, readJsonBody, tooManyRequests } from "@/lib/security/request";
|
||||
import { formatZodError, projectReorderSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
/**
|
||||
* Neue Reihenfolge im Brett nach dem Ziehen.
|
||||
*
|
||||
* Wie beim Aufgabenbrett wird je betroffener Spalte die vollstaendige Liste
|
||||
* uebergeben. Status und Position ergeben sich daraus eindeutig; ein
|
||||
* verlorener Aufruf laesst sich einfach erneut senden, ohne Schaden
|
||||
* anzurichten.
|
||||
*/
|
||||
export async function PATCH(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const limited = rateLimit(
|
||||
`mutate:${clientIp(request)}`,
|
||||
LIMITS.mutation.limit,
|
||||
LIMITS.mutation.windowMs,
|
||||
);
|
||||
if (!limited.ok) return tooManyRequests(limited.retryAfter);
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = projectReorderSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const columns = parsed.data.columns as Partial<Record<ProjectStatus, string[]>>;
|
||||
const requestedIds = Object.values(columns).flat();
|
||||
|
||||
// Nur eigene Projekte anfassen – sonst liessen sich fremde ueber
|
||||
// untergeschobene IDs verschieben.
|
||||
const owned = await prisma.project.findMany({
|
||||
where: { ownerId: auth.user.id, id: { in: requestedIds } },
|
||||
select: { id: true, status: true, updatedAt: true },
|
||||
});
|
||||
const ownedIds = new Set(owned.map((project) => project.id));
|
||||
const vorher = new Map(owned.map((project) => [project.id, project]));
|
||||
|
||||
const updates: Prisma.PrismaPromise<unknown>[] = [];
|
||||
const entries: Parameters<typeof recordActivities>[0] = [];
|
||||
|
||||
for (const [status, ids] of Object.entries(columns) as Array<[ProjectStatus, string[]]>) {
|
||||
ids.forEach((projectId, index) => {
|
||||
const before = vorher.get(projectId);
|
||||
if (!ownedIds.has(projectId) || !before) return;
|
||||
|
||||
const gewandert = before.status !== status;
|
||||
|
||||
updates.push(
|
||||
prisma.project.update({
|
||||
where: { id: projectId },
|
||||
data: {
|
||||
status,
|
||||
position: index,
|
||||
// Beim reinen Umsortieren das Aenderungsdatum festhalten. Sonst
|
||||
// schoebe ein Aufraeumen im Brett saemtliche Projekte in der
|
||||
// Sortierung "Zuletzt geaendert" nach oben – das Brett wuerde die
|
||||
// Liste umsortieren, ohne dass sich inhaltlich etwas geaendert hat.
|
||||
...(gewandert ? {} : { updatedAt: before.updatedAt }),
|
||||
},
|
||||
}),
|
||||
);
|
||||
|
||||
// Ein Statuswechsel gehoert in den Verlauf, ein blosses Umsortieren
|
||||
// nicht – sonst besteht er bald nur noch aus Rangaenderungen.
|
||||
if (gewandert) {
|
||||
entries.push({
|
||||
projectId,
|
||||
userId: auth.user.id,
|
||||
kind: "STATUS_CHANGED",
|
||||
summary: describeStatus(before.status, status),
|
||||
meta: { from: before.status, to: status },
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (updates.length > 0) {
|
||||
await prisma.$transaction(updates);
|
||||
await recordActivities(entries);
|
||||
}
|
||||
|
||||
return NextResponse.json({
|
||||
updated: updates.length,
|
||||
ignored: requestedIds.length - updates.length,
|
||||
});
|
||||
}
|
||||
@@ -1,12 +1,10 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { recordActivity } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { nextProjectPosition, projectListInclude, uniqueSlug } from "@/lib/projects";
|
||||
import { applyLeadingRepo } from "@/lib/repositories";
|
||||
import { parseRepoUrl } from "@/lib/git";
|
||||
import { projectListInclude, uniqueSlug } from "@/lib/projects";
|
||||
import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
|
||||
import { clientIp, jsonError, readJsonBody, tooManyRequests } from "@/lib/security/request";
|
||||
import { statusOf } from "@/lib/status";
|
||||
import { formatZodError, projectCreateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
@@ -74,21 +72,18 @@ export async function POST(request: Request) {
|
||||
if (!connection) return jsonError("Git-Verbindung nicht gefunden.", 404);
|
||||
}
|
||||
|
||||
// Aus der Vorlage kommen nur Notizen und Aufgaben. Die Stammdaten hat die
|
||||
// Oberflaeche schon in die Felder uebernommen, damit man sie vor dem
|
||||
// Speichern noch sieht und aendern kann.
|
||||
const vorlage = data.templateId
|
||||
? await prisma.projectTemplate.findFirst({
|
||||
where: { id: data.templateId, ownerId: auth.user.id },
|
||||
select: { name: true, notes: true, tasks: true },
|
||||
})
|
||||
: null;
|
||||
if (data.templateId && !vorlage) return jsonError("Vorlage nicht gefunden.", 404);
|
||||
// Owner/Name aus der URL ableiten, falls nicht explizit angegeben.
|
||||
let repoOwner = data.repoOwner ?? null;
|
||||
let repoName = data.repoName ?? null;
|
||||
if (data.repoUrl && (!repoOwner || !repoName)) {
|
||||
const parsedUrl = parseRepoUrl(data.repoUrl);
|
||||
if (parsedUrl) {
|
||||
repoOwner = repoOwner ?? parsedUrl.owner;
|
||||
repoName = repoName ?? parsedUrl.name;
|
||||
}
|
||||
}
|
||||
|
||||
const notes = templateNotes(vorlage?.notes);
|
||||
const tasks = templateTasks(vorlage?.tasks);
|
||||
|
||||
const angelegt = await prisma.project.create({
|
||||
const project = await prisma.project.create({
|
||||
data: {
|
||||
ownerId: auth.user.id,
|
||||
name: data.name,
|
||||
@@ -101,83 +96,14 @@ export async function POST(request: Request) {
|
||||
accent: data.accent,
|
||||
tags: data.tags,
|
||||
favorite: data.favorite,
|
||||
progressFromTasks: data.progressFromTasks,
|
||||
// Hinten an die Statusspalte des Bretts.
|
||||
position: await nextProjectPosition(auth.user.id, data.status),
|
||||
notes: { create: notes },
|
||||
tasks: { create: tasks },
|
||||
autoSync: data.autoSync,
|
||||
repoUrl: data.repoUrl ?? null,
|
||||
repoOwner,
|
||||
repoName,
|
||||
connectionId: data.connectionId ?? null,
|
||||
},
|
||||
select: { id: true },
|
||||
});
|
||||
|
||||
// Die Git-Angaben werden zum fuehrenden Repository – falls welche kamen.
|
||||
await applyLeadingRepo(angelegt.id, {
|
||||
repoUrl: data.repoUrl,
|
||||
repoOwner: data.repoOwner,
|
||||
repoName: data.repoName,
|
||||
connectionId: data.connectionId,
|
||||
autoSync: data.autoSync,
|
||||
});
|
||||
|
||||
const project = await prisma.project.findUniqueOrThrow({
|
||||
where: { id: angelegt.id },
|
||||
include: projectListInclude,
|
||||
});
|
||||
|
||||
await recordActivity({
|
||||
projectId: project.id,
|
||||
userId: auth.user.id,
|
||||
kind: "PROJECT_CREATED",
|
||||
summary: vorlage
|
||||
? `Aus Vorlage „${vorlage.name}“ angelegt`
|
||||
: data.status === "IDEA"
|
||||
? "Als Idee angelegt"
|
||||
: `Angelegt mit Status „${statusOf(data.status).label}“`,
|
||||
meta: {
|
||||
status: data.status,
|
||||
...(vorlage ? { template: vorlage.name, notes: notes.length, tasks: tasks.length } : {}),
|
||||
},
|
||||
});
|
||||
|
||||
return NextResponse.json({ project }, { status: 201 });
|
||||
}
|
||||
|
||||
/**
|
||||
* Die Vorlage kommt als JSON aus der Datenbank und ist damit fuer TypeScript
|
||||
* unbekannt. Hier wird sie auf das Noetige zurechtgeschnitten – lieber einen
|
||||
* Eintrag auslassen als am Anlegen scheitern.
|
||||
*/
|
||||
function templateNotes(value: unknown) {
|
||||
if (!Array.isArray(value)) return [];
|
||||
return value
|
||||
.filter((entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === "object")
|
||||
.filter((entry) => typeof entry.content === "string" && entry.content.trim().length > 0)
|
||||
.slice(0, 50)
|
||||
.map((entry) => ({
|
||||
title: typeof entry.title === "string" ? entry.title : null,
|
||||
content: entry.content as string,
|
||||
pinned: entry.pinned === true,
|
||||
}));
|
||||
}
|
||||
|
||||
function templateTasks(value: unknown) {
|
||||
if (!Array.isArray(value)) return [];
|
||||
return value
|
||||
.filter((entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === "object")
|
||||
.filter((entry) => typeof entry.title === "string" && entry.title.trim().length > 0)
|
||||
.slice(0, 100)
|
||||
.map((entry, index) => ({
|
||||
title: entry.title as string,
|
||||
description: typeof entry.description === "string" ? entry.description : null,
|
||||
status: (["TODO", "DOING", "BLOCKED"] as const).includes(
|
||||
entry.status as "TODO" | "DOING" | "BLOCKED",
|
||||
)
|
||||
? (entry.status as "TODO" | "DOING" | "BLOCKED")
|
||||
: ("TODO" as const),
|
||||
// Reihenfolge wie in der Vorlage.
|
||||
position: index,
|
||||
labels: Array.isArray(entry.labels)
|
||||
? entry.labels.filter((label): label is string => typeof label === "string").slice(0, 8)
|
||||
: [],
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -1,93 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { recordActivity, shorten } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { connectionSafeSelect } from "@/lib/projects";
|
||||
import { completeRepoInput, ownedRepository, repoTitle } from "@/lib/repositories";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { formatZodError, repositoryUpdateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
export async function PATCH(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const existing = await ownedRepository(id, auth.user.id);
|
||||
if (!existing) return jsonError("Repository nicht gefunden", 404);
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = repositoryUpdateSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const eingabe = completeRepoInput(parsed.data);
|
||||
|
||||
if (eingabe.connectionId) {
|
||||
const connection = await prisma.gitConnection.findFirst({
|
||||
where: { id: eingabe.connectionId, ownerId: auth.user.id },
|
||||
select: { id: true },
|
||||
});
|
||||
if (!connection) return jsonError("Git-Verbindung nicht gefunden.", 404);
|
||||
}
|
||||
|
||||
const data: Record<string, unknown> = {};
|
||||
for (const key of ["label", "repoUrl", "repoOwner", "repoName", "connectionId", "autoSync"] as const) {
|
||||
if (eingabe[key] !== undefined) data[key] = eingabe[key];
|
||||
}
|
||||
if (parsed.data.position !== undefined) data.position = parsed.data.position;
|
||||
|
||||
// Zeigt das Repo woandershin, taugt der gesammelte Stand nicht mehr. Ihn
|
||||
// stehen zu lassen waere schlimmer als ihn zu verlieren: er saehe echt aus.
|
||||
const zieltWoandershin =
|
||||
(eingabe.repoOwner !== undefined && eingabe.repoOwner !== existing.repoOwner) ||
|
||||
(eingabe.repoName !== undefined && eingabe.repoName !== existing.repoName);
|
||||
if (zieltWoandershin) {
|
||||
data.lastSyncedAt = null;
|
||||
data.syncError = null;
|
||||
data.syncFailureCount = 0;
|
||||
data.notifiedSyncError = null;
|
||||
data.notifiedCiState = null;
|
||||
data.notifiedRelease = null;
|
||||
await prisma.repoSnapshot.deleteMany({ where: { repositoryId: id } });
|
||||
}
|
||||
|
||||
const repository = await prisma.repository.update({
|
||||
where: { id },
|
||||
data,
|
||||
include: { connection: { select: connectionSafeSelect }, snapshot: true },
|
||||
});
|
||||
|
||||
return NextResponse.json({ repository });
|
||||
}
|
||||
|
||||
export async function DELETE(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
|
||||
// Vor dem Loeschen lesen: danach ist nicht mehr feststellbar, worum es ging.
|
||||
const vorher = await ownedRepository(id, auth.user.id);
|
||||
if (!vorher) return jsonError("Repository nicht gefunden", 404);
|
||||
|
||||
await prisma.repository.delete({ where: { id } });
|
||||
|
||||
await recordActivity({
|
||||
projectId: vorher.projectId,
|
||||
userId: auth.user.id,
|
||||
kind: "REPO_LINKED",
|
||||
summary: `Repository entfernt: ${shorten(repoTitle(vorher))}`,
|
||||
});
|
||||
|
||||
return NextResponse.json({ ok: true });
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { connectionSafeSelect } from "@/lib/projects";
|
||||
import { ownedRepository } from "@/lib/repositories";
|
||||
import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
|
||||
import { clientIp, jsonError, tooManyRequests } from "@/lib/security/request";
|
||||
import { syncRepository } from "@/lib/sync";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
/** Gleicht ein einzelnes Repository ab. */
|
||||
export async function POST(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
// Dieser Endpunkt loest ausgehende Verbindungen aus – hier wird enger
|
||||
// begrenzt als bei reinen Datenbankzugriffen.
|
||||
const limited = rateLimit(
|
||||
`outbound:${auth.user.id}:${clientIp(request)}`,
|
||||
LIMITS.outbound.limit,
|
||||
LIMITS.outbound.windowMs,
|
||||
);
|
||||
if (!limited.ok) return tooManyRequests(limited.retryAfter);
|
||||
|
||||
const { id } = await params;
|
||||
if (!(await ownedRepository(id, auth.user.id))) {
|
||||
return jsonError("Repository nicht gefunden", 404);
|
||||
}
|
||||
|
||||
const result = await syncRepository(id);
|
||||
|
||||
const repository = await prisma.repository.findUnique({
|
||||
where: { id },
|
||||
include: { connection: { select: connectionSafeSelect }, snapshot: true },
|
||||
});
|
||||
|
||||
return NextResponse.json({ ...result, repository }, { status: result.ok ? 200 : 502 });
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
import { randomBytes } from "node:crypto";
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { APP_URL } from "@/lib/config";
|
||||
import { encryptSecret } from "@/lib/crypto";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { ownedRepository } from "@/lib/repositories";
|
||||
import { jsonError } from "@/lib/security/request";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
/**
|
||||
* Richtet den Webhook eines Repositories ein oder nimmt ihn zurueck.
|
||||
*
|
||||
* Das Geheimnis wird hier erzeugt und **genau einmal** im Klartext
|
||||
* zurueckgegeben – danach liegt es nur noch verschluesselt in der Datenbank,
|
||||
* wie die Zugangstoken. Wer es verliert, erzeugt ein neues; das alte gilt
|
||||
* dann nicht mehr.
|
||||
*
|
||||
* Eingetragen wird der Haken im Git-System von Hand. Ihn ueber die API
|
||||
* anzulegen waere machbar, verlangte aber Administrationsrechte am
|
||||
* Repository – deutlich mehr, als Nebula sonst braucht.
|
||||
*/
|
||||
export async function POST(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const repository = await ownedRepository(id, auth.user.id);
|
||||
if (!repository) return jsonError("Repository nicht gefunden", 404);
|
||||
|
||||
// 32 Byte, hexadezimal. Lang genug, dass Raten aussichtslos ist, und
|
||||
// ohne Sonderzeichen, die in Formularfeldern Aerger machen.
|
||||
const secret = randomBytes(32).toString("hex");
|
||||
|
||||
await prisma.repository.update({
|
||||
where: { id: repository.id },
|
||||
data: { webhookSecret: encryptSecret(secret), webhookLastAt: null },
|
||||
});
|
||||
|
||||
return NextResponse.json({
|
||||
secret,
|
||||
url: `${APP_URL}/api/webhooks/${repository.id}`,
|
||||
});
|
||||
}
|
||||
|
||||
export async function DELETE(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const repository = await ownedRepository(id, auth.user.id);
|
||||
if (!repository) return jsonError("Repository nicht gefunden", 404);
|
||||
|
||||
await prisma.repository.update({
|
||||
where: { id: repository.id },
|
||||
data: { webhookSecret: null, webhookLastAt: null },
|
||||
});
|
||||
|
||||
return NextResponse.json({ ok: true });
|
||||
}
|
||||
@@ -1,118 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
interface Hit {
|
||||
projectId: string;
|
||||
noteId: string;
|
||||
title: string | null;
|
||||
/** Textausschnitt mit hervorgehobener Fundstelle. */
|
||||
snippet: string;
|
||||
}
|
||||
|
||||
interface TaskHit {
|
||||
projectId: string;
|
||||
taskId: string;
|
||||
title: string;
|
||||
status: string;
|
||||
/** Ausschnitt aus der Beschreibung; leer, wenn nur der Titel passte. */
|
||||
snippet: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Volltextsuche ueber Notizen und Aufgaben.
|
||||
*
|
||||
* Die Suche im Board arbeitet auf den bereits geladenen Projekten und deckt
|
||||
* Name, Kurzbeschreibung und Tags ab. Notizen und Aufgaben liegen dort nicht
|
||||
* vor – die mitzuladen wuerde die Seite unnoetig aufblaehen. Deshalb dieser
|
||||
* Endpunkt: Postgres sucht mit seiner deutschen Textsuche direkt in der
|
||||
* Datenbank.
|
||||
*
|
||||
* ts_headline liefert gleich den passenden Ausschnitt mit; die Hervorhebung
|
||||
* kommt als [[…]] zurueck, damit die Oberflaeche kein HTML einbetten muss.
|
||||
*
|
||||
* Das Feld heisst weiterhin "hits" und meint die Notizen – umbenennen haette
|
||||
* nur Aufrufer gebrochen, ohne etwas zu verbessern. Aufgaben kommen als
|
||||
* eigenes Feld dazu.
|
||||
*/
|
||||
export async function GET(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const query = (new URL(request.url).searchParams.get("q") ?? "").trim();
|
||||
if (query.length < 2) {
|
||||
return NextResponse.json({ query, hits: [], tasks: [], projectIds: [] });
|
||||
}
|
||||
|
||||
// websearch_to_tsquery versteht Eingaben wie "docker -compose" oder
|
||||
// Anfuehrungszeichen und wirft bei Unsinn keinen Fehler.
|
||||
const hits = await prisma.$queryRaw<Hit[]>`
|
||||
SELECT
|
||||
n."projectId" AS "projectId",
|
||||
n."id" AS "noteId",
|
||||
n."title" AS "title",
|
||||
ts_headline(
|
||||
'german',
|
||||
n."content",
|
||||
websearch_to_tsquery('german', ${query}),
|
||||
'StartSel=[[, StopSel=]], MaxWords=18, MinWords=6, ShortWord=2, MaxFragments=1'
|
||||
) AS "snippet"
|
||||
FROM "Note" n
|
||||
JOIN "Project" p ON p."id" = n."projectId"
|
||||
WHERE p."ownerId" = ${auth.user.id}
|
||||
AND to_tsvector('german', coalesce(n."title", '') || ' ' || n."content")
|
||||
@@ websearch_to_tsquery('german', ${query})
|
||||
ORDER BY ts_rank(
|
||||
to_tsvector('german', coalesce(n."title", '') || ' ' || n."content"),
|
||||
websearch_to_tsquery('german', ${query})
|
||||
) DESC
|
||||
LIMIT 50
|
||||
`;
|
||||
|
||||
/**
|
||||
* Dieselbe Rechnung fuer Aufgaben.
|
||||
*
|
||||
* Der Ausdruck in to_tsvector muss Zeichen fuer Zeichen dem in der
|
||||
* Migration entsprechen (Task_fulltext_idx), sonst greift der Index nicht
|
||||
* und Postgres rechnet ihn je Zeile neu.
|
||||
*
|
||||
* Erledigtes bleibt drin: wer sucht, sucht oft gerade das, was er letzte
|
||||
* Woche abgehakt hat.
|
||||
*/
|
||||
const tasks = await prisma.$queryRaw<TaskHit[]>`
|
||||
SELECT
|
||||
t."projectId" AS "projectId",
|
||||
t."id" AS "taskId",
|
||||
t."title" AS "title",
|
||||
t."status"::text AS "status",
|
||||
ts_headline(
|
||||
'german',
|
||||
coalesce(t."description", ''),
|
||||
websearch_to_tsquery('german', ${query}),
|
||||
'StartSel=[[, StopSel=]], MaxWords=18, MinWords=6, ShortWord=2, MaxFragments=1'
|
||||
) AS "snippet"
|
||||
FROM "Task" t
|
||||
JOIN "Project" p ON p."id" = t."projectId"
|
||||
WHERE p."ownerId" = ${auth.user.id}
|
||||
AND to_tsvector('german', coalesce(t."title", '') || ' ' || coalesce(t."description", ''))
|
||||
@@ websearch_to_tsquery('german', ${query})
|
||||
ORDER BY ts_rank(
|
||||
to_tsvector('german', coalesce(t."title", '') || ' ' || coalesce(t."description", '')),
|
||||
websearch_to_tsquery('german', ${query})
|
||||
) DESC
|
||||
LIMIT 50
|
||||
`;
|
||||
|
||||
return NextResponse.json({
|
||||
query,
|
||||
hits,
|
||||
tasks,
|
||||
// Die Oberflaeche braucht vor allem die betroffenen Projekte, um sie im
|
||||
// Board einzublenden – jetzt aus beiden Quellen.
|
||||
projectIds: Array.from(
|
||||
new Set([...hits.map((hit) => hit.projectId), ...tasks.map((hit) => hit.projectId)]),
|
||||
),
|
||||
});
|
||||
}
|
||||
@@ -1,141 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { z } from "zod";
|
||||
import { recordActivity, shorten } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { APP_URL } from "@/lib/config";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { GitApiError, clientForConnection } from "@/lib/git";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { formatZodError } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
const schema = z.object({
|
||||
/** Aus welchem Repository. Leer heisst: dem fuehrenden. */
|
||||
repositoryId: z.string().optional(),
|
||||
});
|
||||
|
||||
/**
|
||||
* Legt zu einer Aufgabe ein Issue im verknuepften Repository an.
|
||||
*
|
||||
* Der einzige Weg, auf dem Nebula von sich aus etwas in ein fremdes System
|
||||
* schreibt – deshalb ausdruecklich angestossen und nie nebenbei. Umgekehrt
|
||||
* gibt es die Uebernahme von Issues als Aufgaben schon laenger
|
||||
* (tasks/from-issues); die Felder sourceIssue, sourceUrl und
|
||||
* sourceRepositoryId sind dieselben, und die Eindeutigkeit je Repository
|
||||
* verhindert, dass beide Wege dasselbe doppelt anlegen.
|
||||
*/
|
||||
export async function POST(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
|
||||
// Besitz haengt am Projekt – die Aufgabe selbst kennt keinen Besitzer.
|
||||
const task = await prisma.task.findFirst({
|
||||
where: { id, project: { ownerId: auth.user.id } },
|
||||
select: {
|
||||
id: true,
|
||||
title: true,
|
||||
description: true,
|
||||
projectId: true,
|
||||
sourceIssue: true,
|
||||
sourceUrl: true,
|
||||
project: { select: { name: true } },
|
||||
},
|
||||
});
|
||||
if (!task) return jsonError("Aufgabe nicht gefunden", 404);
|
||||
|
||||
// Schon verknuepft: nicht noch einmal anlegen. Ein zweites Issue zur
|
||||
// selben Aufgabe waere genau die Dublette, die from-issues vermeidet.
|
||||
if (task.sourceIssue !== null) {
|
||||
return NextResponse.json(
|
||||
{
|
||||
error: "Diese Aufgabe haengt bereits an einem Issue.",
|
||||
issue: { number: task.sourceIssue, url: task.sourceUrl },
|
||||
},
|
||||
{ status: 409 },
|
||||
);
|
||||
}
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = schema.safeParse(body.data ?? {});
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
// Die Besitzerbedingung laeuft ueber das Projekt, dessen Besitz eben
|
||||
// geprueft wurde – eine fremde Repository-ID trifft hier also nichts.
|
||||
const repository = await prisma.repository.findFirst({
|
||||
where: {
|
||||
projectId: task.projectId,
|
||||
...(parsed.data.repositoryId ? { id: parsed.data.repositoryId } : {}),
|
||||
},
|
||||
orderBy: [{ position: "asc" }, { createdAt: "asc" }],
|
||||
include: { connection: true },
|
||||
});
|
||||
|
||||
if (!repository) {
|
||||
return jsonError("Das Projekt hat kein verknuepftes Repository.", 422);
|
||||
}
|
||||
if (!repository.connection) {
|
||||
return jsonError(
|
||||
"Das Repository haengt an keiner Git-Verbindung – ohne Token laesst sich nichts anlegen.",
|
||||
422,
|
||||
);
|
||||
}
|
||||
if (!repository.repoOwner || !repository.repoName) {
|
||||
return jsonError("Am Repository fehlen Owner oder Name.", 422);
|
||||
}
|
||||
|
||||
const client = clientForConnection(repository.connection);
|
||||
|
||||
// Rueckverweis in den Rumpf: wer das Issue im Git-System liest, soll
|
||||
// wissen, wo es herkommt und wo der Rest der Notizen liegt.
|
||||
const rumpf = [
|
||||
task.description?.trim() || null,
|
||||
`_Angelegt aus [${task.project.name}](${APP_URL}/projects/${task.projectId}) in Nebula._`,
|
||||
]
|
||||
.filter(Boolean)
|
||||
.join("\n\n");
|
||||
|
||||
try {
|
||||
const issue = await client.createIssue(
|
||||
{ owner: repository.repoOwner, name: repository.repoName },
|
||||
{ title: task.title, body: rumpf },
|
||||
);
|
||||
|
||||
const aktualisiert = await prisma.task.update({
|
||||
where: { id: task.id },
|
||||
data: {
|
||||
sourceIssue: issue.number,
|
||||
sourceUrl: issue.url,
|
||||
sourceRepositoryId: repository.id,
|
||||
},
|
||||
});
|
||||
|
||||
await recordActivity({
|
||||
projectId: task.projectId,
|
||||
userId: auth.user.id,
|
||||
kind: "TASK_ADDED",
|
||||
summary: `Issue #${issue.number} angelegt zu: ${shorten(task.title, 50)}`,
|
||||
meta: { taskId: task.id, issue: issue.number, url: issue.url },
|
||||
});
|
||||
|
||||
return NextResponse.json({ task: aktualisiert, issue }, { status: 201 });
|
||||
} catch (error) {
|
||||
// Der Aufruf ging nach draussen; die Meldung des Git-Systems ist
|
||||
// hilfreicher als ein pauschales "hat nicht geklappt".
|
||||
if (error instanceof GitApiError) {
|
||||
return jsonError(`Issue konnte nicht angelegt werden: ${error.message}`, 502);
|
||||
}
|
||||
return jsonError("Issue konnte nicht angelegt werden.", 502);
|
||||
}
|
||||
}
|
||||
@@ -1,133 +0,0 @@
|
||||
import type { TaskStatus } from "@prisma/client";
|
||||
import { NextResponse } from "next/server";
|
||||
import { recordActivity, shorten } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import {
|
||||
TASK_STATUS_META,
|
||||
nextPosition,
|
||||
refreshDerivedProgress,
|
||||
spawnRecurrence,
|
||||
} from "@/lib/tasks";
|
||||
import { issueShouldBeOpen, mirrorStatusToIssue } from "@/lib/tasks/issues";
|
||||
import { formatZodError, taskUpdateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
/** Eine Aufgabe gehoert dem, dem das zugehoerige Projekt gehoert. */
|
||||
async function ownedTask(taskId: string, ownerId: string) {
|
||||
return prisma.task.findFirst({
|
||||
where: { id: taskId, project: { ownerId } },
|
||||
select: { id: true, projectId: true, status: true, title: true },
|
||||
});
|
||||
}
|
||||
|
||||
export async function PATCH(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const existing = await ownedTask(id, auth.user.id);
|
||||
if (!existing) return jsonError("Aufgabe nicht gefunden", 404);
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = taskUpdateSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const data = parsed.data;
|
||||
const update: Record<string, unknown> = {};
|
||||
|
||||
if (data.title !== undefined) update.title = data.title;
|
||||
if (data.description !== undefined) update.description = data.description;
|
||||
if (data.labels !== undefined) update.labels = data.labels;
|
||||
if (data.recurrence !== undefined) update.recurrence = data.recurrence;
|
||||
if (data.dueDate !== undefined) {
|
||||
update.dueDate = data.dueDate ? new Date(data.dueDate) : null;
|
||||
}
|
||||
|
||||
if (data.status !== undefined && data.status !== existing.status) {
|
||||
update.status = data.status;
|
||||
// Beim Spaltenwechsel ans Ende der neuen Spalte.
|
||||
update.position = await nextPosition(existing.projectId, data.status);
|
||||
// doneAt nur setzen, wenn die Aufgabe wirklich nach DONE wandert.
|
||||
update.doneAt = data.status === "DONE" ? new Date() : null;
|
||||
}
|
||||
|
||||
const task = await prisma.task.update({ where: { id }, data: update });
|
||||
|
||||
// Genau beim Uebergang nach ERLEDIGT entsteht die naechste Fassung. Ein
|
||||
// erneutes Speichern einer schon erledigten Aufgabe darf keine zweite
|
||||
// erzeugen – deshalb haengt es an update.status und nicht an data.status.
|
||||
const folge =
|
||||
update.status === "DONE" && existing.status !== "DONE"
|
||||
? await spawnRecurrence(id)
|
||||
: null;
|
||||
|
||||
await refreshDerivedProgress(existing.projectId);
|
||||
|
||||
/**
|
||||
* Haengt die Aufgabe an einem Issue, wandert der Zustand mit: erledigt
|
||||
* schliesst es, ein Zurueckziehen oeffnet es wieder. Nur die Grenze um
|
||||
* ERLEDIGT geht nach draussen – mehr kennt ein Issue nicht.
|
||||
*
|
||||
* Fehlertolerant und ohne den Aufrufer warten zu lassen, was schiefgehen
|
||||
* kann: ein nicht erreichbares Git-System darf das Abhaken nicht
|
||||
* verhindern. Beim naechsten Wechsel wird es erneut versucht.
|
||||
*/
|
||||
if (update.status !== undefined) {
|
||||
const vorher = issueShouldBeOpen(existing.status);
|
||||
const nachher = issueShouldBeOpen(update.status as TaskStatus);
|
||||
if (vorher !== nachher) {
|
||||
await mirrorStatusToIssue(id, update.status as TaskStatus);
|
||||
}
|
||||
}
|
||||
|
||||
// Nur der Spaltenwechsel kommt in den Verlauf. Ein umbenannter Titel oder
|
||||
// ein neues Label sind zu kleinteilig, um die Geschichte des Projekts zu
|
||||
// erzaehlen – und beim Ziehen im Brett ist der Wechsel die eigentliche Tat.
|
||||
if (update.status !== undefined) {
|
||||
const nach = update.status as TaskStatus;
|
||||
await recordActivity({
|
||||
projectId: existing.projectId,
|
||||
userId: auth.user.id,
|
||||
kind: "TASK_MOVED",
|
||||
summary: folge
|
||||
? `Aufgabe „${shorten(task.title, 40)}“ erledigt, nächste angelegt`
|
||||
: `Aufgabe „${shorten(task.title, 50)}“ → ${TASK_STATUS_META[nach].label}`,
|
||||
meta: { taskId: id, from: existing.status, to: nach, ...(folge ? { next: folge.id } : {}) },
|
||||
});
|
||||
}
|
||||
|
||||
return NextResponse.json({ task, next: folge });
|
||||
}
|
||||
|
||||
export async function DELETE(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const existing = await ownedTask(id, auth.user.id);
|
||||
if (!existing) return jsonError("Aufgabe nicht gefunden", 404);
|
||||
|
||||
await prisma.task.delete({ where: { id } });
|
||||
await refreshDerivedProgress(existing.projectId);
|
||||
|
||||
await recordActivity({
|
||||
projectId: existing.projectId,
|
||||
userId: auth.user.id,
|
||||
kind: "TASK_DELETED",
|
||||
summary: `Aufgabe gelöscht: ${shorten(existing.title, 50)}`,
|
||||
});
|
||||
|
||||
return NextResponse.json({ ok: true });
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { formatZodError, templateUpdateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
export async function PATCH(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const existing = await prisma.projectTemplate.findFirst({
|
||||
where: { id, ownerId: auth.user.id },
|
||||
select: { id: true },
|
||||
});
|
||||
if (!existing) return jsonError("Vorlage nicht gefunden", 404);
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = templateUpdateSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const data = parsed.data;
|
||||
|
||||
if (data.name) {
|
||||
const doppelt = await prisma.projectTemplate.findFirst({
|
||||
where: { ownerId: auth.user.id, name: data.name, id: { not: id } },
|
||||
select: { id: true },
|
||||
});
|
||||
if (doppelt) return jsonError(`Eine Vorlage „${data.name}“ gibt es bereits.`, 409);
|
||||
}
|
||||
|
||||
const template = await prisma.projectTemplate.update({ where: { id }, data });
|
||||
return NextResponse.json({ template });
|
||||
}
|
||||
|
||||
export async function DELETE(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
|
||||
// deleteMany mit Besitzerbedingung: trifft fremde Vorlagen gar nicht erst.
|
||||
const result = await prisma.projectTemplate.deleteMany({
|
||||
where: { id, ownerId: auth.user.id },
|
||||
});
|
||||
if (result.count === 0) return jsonError("Vorlage nicht gefunden", 404);
|
||||
|
||||
return NextResponse.json({ ok: true });
|
||||
}
|
||||
@@ -1,95 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
|
||||
import { clientIp, jsonError, readJsonBody, tooManyRequests } from "@/lib/security/request";
|
||||
import { formatZodError, templateFromProjectSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
/**
|
||||
* Aus einem vorhandenen Projekt eine Vorlage machen.
|
||||
*
|
||||
* Das ist der Weg, auf dem Vorlagen ueblicherweise entstehen: man richtet ein
|
||||
* Projekt so ein, wie es passt, und haelt das dann fest. Eine Vorlage von
|
||||
* Grund auf zu tippen kann man auch – ueber POST /api/templates.
|
||||
*
|
||||
* Nicht mitgenommen wird alles Projektbezogene: Name, Slug, Fortschritt,
|
||||
* Favorit und vor allem die Repositories. Eine Vorlage, die jedes neue
|
||||
* Projekt an dasselbe Repository haengt, waere eine Falle.
|
||||
*/
|
||||
export async function POST(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const limited = rateLimit(
|
||||
`mutate:${clientIp(request)}`,
|
||||
LIMITS.mutation.limit,
|
||||
LIMITS.mutation.windowMs,
|
||||
);
|
||||
if (!limited.ok) return tooManyRequests(limited.retryAfter);
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = templateFromProjectSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const { projectId, name, description, withNotes, withTasks } = parsed.data;
|
||||
|
||||
const project = await prisma.project.findFirst({
|
||||
where: { id: projectId, ownerId: auth.user.id },
|
||||
include: {
|
||||
notes: { orderBy: [{ pinned: "desc" }, { createdAt: "asc" }] },
|
||||
tasks: { orderBy: [{ status: "asc" }, { position: "asc" }] },
|
||||
},
|
||||
});
|
||||
if (!project) return jsonError("Projekt nicht gefunden", 404);
|
||||
|
||||
const doppelt = await prisma.projectTemplate.findFirst({
|
||||
where: { ownerId: auth.user.id, name },
|
||||
select: { id: true },
|
||||
});
|
||||
if (doppelt) return jsonError(`Eine Vorlage „${name}“ gibt es bereits.`, 409);
|
||||
|
||||
const template = await prisma.projectTemplate.create({
|
||||
data: {
|
||||
ownerId: auth.user.id,
|
||||
name,
|
||||
description: description ?? null,
|
||||
summary: project.summary,
|
||||
projectDescription: project.description,
|
||||
status: project.status,
|
||||
priority: project.priority,
|
||||
accent: project.accent,
|
||||
tags: project.tags,
|
||||
progressFromTasks: project.progressFromTasks,
|
||||
notes: withNotes
|
||||
? project.notes.map((note) => ({
|
||||
title: note.title,
|
||||
content: note.content,
|
||||
pinned: note.pinned,
|
||||
}))
|
||||
: [],
|
||||
// Erledigte Aufgaben kommen nicht mit: eine Vorlage beschreibt, was zu
|
||||
// tun ist, nicht was einmal getan wurde.
|
||||
tasks: withTasks
|
||||
? project.tasks
|
||||
.filter((task) => task.status !== "DONE")
|
||||
.map((task) => ({
|
||||
title: task.title,
|
||||
description: task.description,
|
||||
status: task.status,
|
||||
labels: task.labels,
|
||||
}))
|
||||
: [],
|
||||
},
|
||||
});
|
||||
|
||||
return NextResponse.json({ template }, { status: 201 });
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
|
||||
import { clientIp, jsonError, readJsonBody, tooManyRequests } from "@/lib/security/request";
|
||||
import { formatZodError, templateCreateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
/** Hoechstzahl je Konto. Wer mehr braucht, hat keine Vorlagen mehr, sondern Projekte. */
|
||||
const MAX_TEMPLATES = 30;
|
||||
|
||||
export async function GET() {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const templates = await prisma.projectTemplate.findMany({
|
||||
where: { ownerId: auth.user.id },
|
||||
orderBy: { name: "asc" },
|
||||
});
|
||||
|
||||
return NextResponse.json({ templates });
|
||||
}
|
||||
|
||||
export async function POST(request: Request) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const limited = rateLimit(
|
||||
`mutate:${clientIp(request)}`,
|
||||
LIMITS.mutation.limit,
|
||||
LIMITS.mutation.windowMs,
|
||||
);
|
||||
if (!limited.ok) return tooManyRequests(limited.retryAfter);
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = templateCreateSchema.safeParse(body.data);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
const vorhanden = await prisma.projectTemplate.count({ where: { ownerId: auth.user.id } });
|
||||
if (vorhanden >= MAX_TEMPLATES) {
|
||||
return jsonError(`Mehr als ${MAX_TEMPLATES} Vorlagen sind nicht vorgesehen.`, 409);
|
||||
}
|
||||
|
||||
const data = parsed.data;
|
||||
|
||||
// Der Name ist je Konto eindeutig; ein Duplikat soll eine verstaendliche
|
||||
// Meldung geben statt eines Datenbankfehlers.
|
||||
const doppelt = await prisma.projectTemplate.findFirst({
|
||||
where: { ownerId: auth.user.id, name: data.name },
|
||||
select: { id: true },
|
||||
});
|
||||
if (doppelt) return jsonError(`Eine Vorlage „${data.name}“ gibt es bereits.`, 409);
|
||||
|
||||
const template = await prisma.projectTemplate.create({
|
||||
data: {
|
||||
ownerId: auth.user.id,
|
||||
name: data.name,
|
||||
description: data.description ?? null,
|
||||
summary: data.summary ?? null,
|
||||
projectDescription: data.projectDescription ?? null,
|
||||
status: data.status,
|
||||
priority: data.priority,
|
||||
accent: data.accent,
|
||||
tags: data.tags,
|
||||
progressFromTasks: data.progressFromTasks,
|
||||
notes: data.notes,
|
||||
tasks: data.tasks,
|
||||
},
|
||||
});
|
||||
|
||||
return NextResponse.json({ template }, { status: 201 });
|
||||
}
|
||||
@@ -1,142 +0,0 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { tryDecryptSecret } from "@/lib/crypto";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { rateLimit } from "@/lib/security/rateLimit";
|
||||
import { syncRepository } from "@/lib/sync";
|
||||
import { completeTaskFromIssue, statusForIssueState } from "@/lib/tasks/issues";
|
||||
import { refreshDerivedProgress } from "@/lib/tasks";
|
||||
import { parseEvent, verifySignature } from "@/lib/webhooks/verify";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ repositoryId: string }> };
|
||||
|
||||
/** Groesse des Rumpfes deckeln – ein Push-Ereignis ist nie ein Megabyte. */
|
||||
const MAX_BODY = 512 * 1024;
|
||||
|
||||
/**
|
||||
* Eingehende Webhooks von GitHub, GitLab und Gitea.
|
||||
*
|
||||
* Der einzige Endpunkt ohne Anmeldung, der etwas schreibt. Ausgewiesen wird
|
||||
* sich mit einer Signatur ueber den Rumpf, geprueft gegen das Geheimnis, das
|
||||
* beim Einrichten am Repository hinterlegt wurde.
|
||||
*
|
||||
* Absichtlich sparsam in dem, was er tut:
|
||||
*
|
||||
* push – stoesst denselben Abgleich an wie der Zeitgeber
|
||||
* issues – geschlossen oder wieder geoeffnet wandert an die Aufgabe
|
||||
*
|
||||
* Alles andere wird angenommen und liegen gelassen. Ein Webhook, der mit
|
||||
* einem Fehler antwortet, wird von den Systemen wiederholt und irgendwann
|
||||
* abgeschaltet – deshalb ist "verstanden, nichts zu tun" die richtige
|
||||
* Antwort auf ein unbekanntes Ereignis.
|
||||
*
|
||||
* Was hier NICHT passiert: der Rumpf wird nie als Quelle fuer Inhalte
|
||||
* benutzt. Titel, Beschreibung und Zustand einer Aufgabe kommen weiter aus
|
||||
* Nebula beziehungsweise beim naechsten Abgleich aus der API. Wer das
|
||||
* Geheimnis kennt, kann also hoechstens eine Aufgabe auf- oder zumachen und
|
||||
* einen Abgleich ausloesen – nicht beliebige Daten einschleusen.
|
||||
*/
|
||||
export async function POST(request: Request, { params }: Params) {
|
||||
const { repositoryId } = await params;
|
||||
|
||||
// Die ID steht in der URL und ist damit halboeffentlich. Ein Deckel
|
||||
// dagegen, sie als Orakel zu benutzen oder den Abgleich zu verheizen.
|
||||
const limit = rateLimit(`webhook:${repositoryId}`, 60, 60_000);
|
||||
if (!limit.ok) {
|
||||
return NextResponse.json(
|
||||
{ error: "Zu viele Aufrufe." },
|
||||
{ status: 429, headers: { "Retry-After": String(limit.retryAfter) } },
|
||||
);
|
||||
}
|
||||
|
||||
const repository = await prisma.repository.findUnique({
|
||||
where: { id: repositoryId },
|
||||
include: { connection: true },
|
||||
});
|
||||
|
||||
// Unbekanntes Repository und fehlendes Geheimnis sind dieselbe Antwort:
|
||||
// ob es die ID gibt, geht den Anrufer nichts an.
|
||||
const secret = repository?.webhookSecret
|
||||
? tryDecryptSecret(repository.webhookSecret)
|
||||
: null;
|
||||
if (!repository || !secret) {
|
||||
return NextResponse.json({ error: "Unbekannt." }, { status: 404 });
|
||||
}
|
||||
|
||||
const roh = await request.text();
|
||||
if (roh.length > MAX_BODY) {
|
||||
return NextResponse.json({ error: "Rumpf zu gross." }, { status: 413 });
|
||||
}
|
||||
|
||||
/**
|
||||
* Der **rohe** Rumpf geht in die Pruefung, nicht das geparste Objekt:
|
||||
* durch JSON.parse und JSON.stringify gedreht kaeme eine andere Zeichen-
|
||||
* folge heraus und die Signatur passte nie.
|
||||
*/
|
||||
const provider = repository.connection?.provider ?? "GITEA";
|
||||
const geprueft = verifySignature(provider, secret, roh, request.headers);
|
||||
if (!geprueft.ok) {
|
||||
return NextResponse.json({ error: "Signatur ungueltig." }, { status: 401 });
|
||||
}
|
||||
|
||||
let payload: unknown = null;
|
||||
try {
|
||||
payload = JSON.parse(roh);
|
||||
} catch {
|
||||
return NextResponse.json({ error: "Kein gueltiges JSON." }, { status: 400 });
|
||||
}
|
||||
|
||||
const eventName =
|
||||
request.headers.get("x-github-event") ??
|
||||
request.headers.get("x-gitea-event") ??
|
||||
request.headers.get("x-gitlab-event");
|
||||
|
||||
const ereignis = parseEvent(provider, eventName, payload);
|
||||
|
||||
// Ab hier gilt der Aufruf als echt – das ist die Rueckmeldung darueber,
|
||||
// ob der Haken im Git-System ueberhaupt funktioniert.
|
||||
await prisma.repository.update({
|
||||
where: { id: repository.id },
|
||||
data: { webhookLastAt: new Date() },
|
||||
});
|
||||
|
||||
if (ereignis.kind === "push") {
|
||||
// Derselbe Weg wie beim Zeitgeber – nur eben sofort statt beim
|
||||
// naechsten Durchlauf.
|
||||
await syncRepository(repository.id).catch(() => undefined);
|
||||
return NextResponse.json({ ok: true, handled: "push" });
|
||||
}
|
||||
|
||||
if (ereignis.kind === "issue") {
|
||||
const task = await prisma.task.findFirst({
|
||||
where: { sourceRepositoryId: repository.id, sourceIssue: ereignis.number },
|
||||
select: { id: true, status: true, projectId: true },
|
||||
});
|
||||
if (!task) {
|
||||
return NextResponse.json({ ok: true, handled: "issue", matched: false });
|
||||
}
|
||||
|
||||
const ziel = statusForIssueState(ereignis.open, task.status);
|
||||
|
||||
if (ziel === "DONE" && task.status !== "DONE") {
|
||||
// Ueber die gemeinsame Funktion, damit ein geschlossenes Issue
|
||||
// dasselbe bewirkt wie ein Haken in der Oberflaeche: naechste Fassung
|
||||
// einer wiederkehrenden Aufgabe und ein Eintrag im Verlauf.
|
||||
await completeTaskFromIssue(task.id, "webhook");
|
||||
} else if (ziel !== task.status) {
|
||||
// Wieder geoeffnet. Das darf nur der Webhook, weil hier ein echtes
|
||||
// "reopened" vorliegt – der Abgleich sieht nur Zustaende und wuerde
|
||||
// sonst eine bewusst erledigte Aufgabe aufmachen.
|
||||
await prisma.task.update({
|
||||
where: { id: task.id },
|
||||
data: { status: ziel, doneAt: null },
|
||||
});
|
||||
await refreshDerivedProgress(task.projectId);
|
||||
}
|
||||
|
||||
return NextResponse.json({ ok: true, handled: "issue", matched: true, status: ziel });
|
||||
}
|
||||
|
||||
return NextResponse.json({ ok: true, handled: "ignored", event: ereignis.name });
|
||||
}
|
||||
@@ -89,155 +89,6 @@
|
||||
0 28px 70px -24px rgba(0, 0, 0, 0.95);
|
||||
}
|
||||
|
||||
/**
|
||||
* Markdown-Inhalte. Tailwind setzt in seinem Preflight alle Abstaende und
|
||||
* Schriftgroessen zurueck, also muessen Ueberschriften, Listen und
|
||||
* Codebloecke hier wieder Form bekommen.
|
||||
*/
|
||||
.md {
|
||||
font-size: 0.875rem;
|
||||
line-height: 1.65;
|
||||
color: #cbd5e1;
|
||||
overflow-wrap: break-word;
|
||||
}
|
||||
|
||||
.md > *:first-child { margin-top: 0; }
|
||||
.md > *:last-child { margin-bottom: 0; }
|
||||
|
||||
.md h1, .md h2, .md h3, .md h4 {
|
||||
color: #f1f5f9;
|
||||
font-weight: 600;
|
||||
line-height: 1.3;
|
||||
margin: 1.4em 0 0.5em;
|
||||
}
|
||||
.md h1 { font-size: 1.3rem; }
|
||||
.md h2 { font-size: 1.15rem; }
|
||||
.md h3 { font-size: 1rem; }
|
||||
.md h4 { font-size: 0.9rem; }
|
||||
|
||||
.md p { margin: 0.75em 0; }
|
||||
|
||||
.md a {
|
||||
color: #c4b5fd;
|
||||
text-decoration: underline;
|
||||
text-underline-offset: 2px;
|
||||
}
|
||||
.md a:hover { color: #ddd6fe; }
|
||||
|
||||
/* Bilder werden nicht geladen, sondern als Marke gezeigt – siehe die
|
||||
Begruendung in Markdown.tsx. Damit sie nicht wie Fliesstext aussieht,
|
||||
bekommt sie einen Rahmen und ein Symbol davor. */
|
||||
.md .md-image {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 0.3em;
|
||||
border: 1px dashed rgba(255, 255, 255, 0.16);
|
||||
border-radius: 0.4rem;
|
||||
padding: 0.05em 0.45em;
|
||||
font-size: 0.85em;
|
||||
color: #8a98b0;
|
||||
text-decoration: none;
|
||||
vertical-align: baseline;
|
||||
}
|
||||
.md .md-image::before {
|
||||
content: "▣";
|
||||
opacity: 0.6;
|
||||
}
|
||||
.md a.md-image:hover {
|
||||
color: #c4b5fd;
|
||||
border-color: rgba(196, 181, 253, 0.4);
|
||||
}
|
||||
|
||||
.md strong { color: #f1f5f9; font-weight: 600; }
|
||||
|
||||
.md ul, .md ol { margin: 0.75em 0; padding-left: 1.35em; }
|
||||
.md ul { list-style: disc; }
|
||||
.md ol { list-style: decimal; }
|
||||
.md li { margin: 0.3em 0; }
|
||||
.md li::marker { color: #64748b; }
|
||||
|
||||
/* Aufgabenlisten aus "- [ ] …" */
|
||||
.md li:has(> input[type="checkbox"]) {
|
||||
list-style: none;
|
||||
margin-left: -1.35em;
|
||||
display: flex;
|
||||
align-items: flex-start;
|
||||
gap: 0.5rem;
|
||||
}
|
||||
.md input[type="checkbox"] {
|
||||
margin-top: 0.35em;
|
||||
accent-color: #8b5cf6;
|
||||
width: 0.9rem;
|
||||
height: 0.9rem;
|
||||
flex-shrink: 0;
|
||||
}
|
||||
|
||||
.md code {
|
||||
background: rgba(255, 255, 255, 0.07);
|
||||
border: 1px solid rgba(255, 255, 255, 0.07);
|
||||
border-radius: 0.35rem;
|
||||
padding: 0.1em 0.35em;
|
||||
font-family: var(--font-mono);
|
||||
font-size: 0.85em;
|
||||
color: #e9d5ff;
|
||||
}
|
||||
|
||||
.md pre {
|
||||
background: rgba(4, 6, 16, 0.75);
|
||||
border: 1px solid rgba(255, 255, 255, 0.08);
|
||||
border-radius: 0.75rem;
|
||||
padding: 0.85rem 1rem;
|
||||
margin: 0.9em 0;
|
||||
overflow-x: auto;
|
||||
}
|
||||
.md pre code {
|
||||
background: none;
|
||||
border: none;
|
||||
padding: 0;
|
||||
color: #cbd5e1;
|
||||
font-size: 0.8rem;
|
||||
line-height: 1.6;
|
||||
}
|
||||
|
||||
.md blockquote {
|
||||
border-left: 2px solid rgba(167, 139, 250, 0.5);
|
||||
padding-left: 0.9rem;
|
||||
margin: 0.9em 0;
|
||||
color: #94a3b8;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.md hr {
|
||||
border: 0;
|
||||
border-top: 1px solid rgba(255, 255, 255, 0.09);
|
||||
margin: 1.4em 0;
|
||||
}
|
||||
|
||||
.md table {
|
||||
width: 100%;
|
||||
margin: 0.9em 0;
|
||||
border-collapse: collapse;
|
||||
font-size: 0.8rem;
|
||||
display: block;
|
||||
overflow-x: auto;
|
||||
}
|
||||
.md th, .md td {
|
||||
border: 1px solid rgba(255, 255, 255, 0.09);
|
||||
padding: 0.4rem 0.6rem;
|
||||
text-align: left;
|
||||
}
|
||||
.md th {
|
||||
background: rgba(255, 255, 255, 0.04);
|
||||
color: #e2e8f0;
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
.md img {
|
||||
max-width: 100%;
|
||||
height: auto;
|
||||
border-radius: 0.5rem;
|
||||
}
|
||||
|
||||
/* ── Text & Akzente ───────────────────────────────────────── */
|
||||
|
||||
.text-gradient {
|
||||
@@ -277,21 +128,6 @@
|
||||
border: 1px solid transparent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Auf Zeigergeraeten reichen die 36px, die sich aus Schriftgroesse und
|
||||
* Innenabstand ergeben. Ein Finger trifft das nicht zuverlaessig – dort
|
||||
* gilt die uebliche Untergrenze von 44px.
|
||||
*
|
||||
* Ueber "pointer: coarse" statt einer Breitenabfrage: entscheidend ist das
|
||||
* Eingabegeraet, nicht die Fenstergroesse. Ein Tablet im Querformat ist
|
||||
* breit und wird trotzdem mit dem Finger bedient.
|
||||
*/
|
||||
@media (pointer: coarse) {
|
||||
.btn {
|
||||
min-height: 2.75rem;
|
||||
}
|
||||
}
|
||||
|
||||
.btn:disabled {
|
||||
opacity: 0.5;
|
||||
cursor: not-allowed;
|
||||
@@ -350,19 +186,6 @@
|
||||
box-shadow 0.2s ease;
|
||||
}
|
||||
|
||||
/**
|
||||
* Unter 16px zoomt iOS Safari beim Hineintippen die ganze Seite heran und
|
||||
* kehrt danach nicht von selbst zurueck – aus einem Formular wird so eine
|
||||
* Schiebepartie. Deshalb auf Beruehrungsgeraeten volle 16px, unabhaengig
|
||||
* von der Fensterbreite.
|
||||
*/
|
||||
@media (pointer: coarse) {
|
||||
.field {
|
||||
font-size: 1rem;
|
||||
padding: 0.65rem 0.85rem;
|
||||
}
|
||||
}
|
||||
|
||||
.field::placeholder {
|
||||
color: rgba(148, 163, 184, 0.6);
|
||||
}
|
||||
@@ -444,22 +267,4 @@
|
||||
.range::-moz-range-track {
|
||||
background: transparent;
|
||||
}
|
||||
|
||||
/* Ein 16px-Griff ist mit dem Finger kaum zu fassen. Die Spur bleibt
|
||||
schmal, damit der Regler nicht ploetzlich klobig wirkt. */
|
||||
@media (pointer: coarse) {
|
||||
.range {
|
||||
height: 10px;
|
||||
}
|
||||
|
||||
.range::-webkit-slider-thumb {
|
||||
height: 24px;
|
||||
width: 24px;
|
||||
}
|
||||
|
||||
.range::-moz-range-thumb {
|
||||
height: 22px;
|
||||
width: 22px;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -17,7 +17,7 @@ export default async function ConnectionsPage() {
|
||||
|
||||
const connections = await prisma.gitConnection.findMany({
|
||||
where: { ownerId: user.id },
|
||||
select: { ...connectionSafeSelect, _count: { select: { repositories: true } } },
|
||||
select: { ...connectionSafeSelect, _count: { select: { projects: true } } },
|
||||
orderBy: { name: "asc" },
|
||||
});
|
||||
|
||||
|
||||
@@ -16,35 +16,12 @@
|
||||
--color-void-soft: #0a0c1a;
|
||||
--color-haze: #12142b;
|
||||
|
||||
/* ── Gedaempfte Textfarben ──────────────────────────────────
|
||||
Tailwinds slate-500 und slate-600 kommen auf diesem sehr dunklen
|
||||
Untergrund nur auf 3,8 bzw. 2,5 zu 1. WCAG AA verlangt 4,5 fuer
|
||||
normalen Text, und beide werden hier reichlich fuer Hinweise und
|
||||
Nebenangaben benutzt – axe-core hat das an 26 Stellen beanstandet.
|
||||
|
||||
Statt an hundert Stellen die Klasse zu tauschen, werden die beiden
|
||||
Stufen hier aufgehellt. Der Abstand zwischen ihnen bleibt sichtbar,
|
||||
der Rest des Entwurfs unangetastet.
|
||||
|
||||
Geprueft gegen die drei vorkommenden Untergruende #0b0d1c (Seite),
|
||||
#0e0f17 (.glass) und #14141d (.popover) – der schlechteste Wert
|
||||
zaehlt. */
|
||||
--color-slate-500: #8a98b0; /* 6,3 : 1 */
|
||||
--color-slate-600: #78879f; /* 5,0 : 1 */
|
||||
|
||||
--font-sans: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto,
|
||||
"Helvetica Neue", Arial, "Noto Sans", sans-serif;
|
||||
--font-mono: ui-monospace, "Cascadia Code", "Source Code Pro", Menlo,
|
||||
Consolas, "DejaVu Sans Mono", monospace;
|
||||
|
||||
--radius-card: 1.25rem;
|
||||
|
||||
/* Eine Stufe unterhalb von Tailwinds "sm" (40rem). Zwischen 320px und
|
||||
640px liegt der gesamte Telefonbereich, und dort ist der Unterschied
|
||||
zwischen "Beschriftung passt noch" und "passt nicht mehr" oft nur ein
|
||||
Zentimeter breit. 22rem trennt die wirklich schmalen Geraete (iPhone SE
|
||||
der ersten Reihe, 320px) vom Rest, der bei 360px und mehr anfaengt. */
|
||||
--breakpoint-xs: 22rem;
|
||||
}
|
||||
|
||||
:root {
|
||||
@@ -70,14 +47,7 @@
|
||||
font-family: var(--font-sans);
|
||||
-webkit-font-smoothing: antialiased;
|
||||
text-rendering: optimizeLegibility;
|
||||
/* Ein Notnagel gegen seitliches Scrollen, kein Ersatz fuer richtiges
|
||||
Umbrechen: was hier abgeschnitten wird, ist auf dem Telefon einfach
|
||||
nicht mehr erreichbar. Die Ursachen gehoeren in die Komponenten. */
|
||||
overflow-x: hidden;
|
||||
/* Mit viewportFit: "cover" reicht die Seite bis in die Ecken; ohne diese
|
||||
Einrueckung stuende der Inhalt im Querformat unter der Kameraleiste. */
|
||||
padding-left: env(safe-area-inset-left);
|
||||
padding-right: env(safe-area-inset-right);
|
||||
}
|
||||
|
||||
::selection {
|
||||
|
||||
+2
-26
@@ -1,9 +1,7 @@
|
||||
import type { Metadata, Viewport } from "next";
|
||||
import { ChangelogButton } from "@/components/ChangelogButton";
|
||||
import { CommandPalette } from "@/components/CommandPalette";
|
||||
import { TopNav } from "@/components/TopNav";
|
||||
import { getSessionUser } from "@/lib/auth/session";
|
||||
import { APP_NAME, APP_TAGLINE, APP_VERSION } from "@/lib/config";
|
||||
import { APP_NAME, APP_TAGLINE } from "@/lib/config";
|
||||
import "./globals.css";
|
||||
|
||||
/**
|
||||
@@ -21,20 +19,6 @@ export async function generateMetadata(): Promise<Metadata> {
|
||||
"Uebersicht ueber alle Vibe-Coding Projekte: Status, Notizen und Live-Daten aus GitHub, GitLab und Gitea.",
|
||||
applicationName: APP_NAME,
|
||||
robots: { index: false, follow: false },
|
||||
manifest: "/manifest.webmanifest",
|
||||
// iOS liest das Manifest nicht; dort braucht es diese Angaben einzeln.
|
||||
appleWebApp: { capable: true, title: APP_NAME, statusBarStyle: "black-translucent" },
|
||||
// Beide Eintraege ausdruecklich: sobald hier etwas steht, ersetzt es den
|
||||
// Verweis, den Next aus app/icon.svg von selbst erzeugt. Ohne die erste
|
||||
// Zeile haette die Seite gar kein Symbol mehr und der Browser fiele auf
|
||||
// /favicon.ico zurueck – das es hier nicht gibt.
|
||||
icons: {
|
||||
icon: [
|
||||
{ url: "/icon.svg", type: "image/svg+xml" },
|
||||
{ url: "/icon-192.png", sizes: "192x192", type: "image/png" },
|
||||
],
|
||||
apple: "/apple-touch-icon.png",
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
@@ -42,11 +26,6 @@ export const viewport: Viewport = {
|
||||
themeColor: "#05060f",
|
||||
width: "device-width",
|
||||
initialScale: 1,
|
||||
// Die Seite reicht bis unter Statusleiste und Home-Anzeige; das ist noetig,
|
||||
// damit der Hintergrund im installierten Betrieb nicht an einem weissen
|
||||
// Balken endet. Was dadurch verdeckt wuerde, holen die env(safe-area-*)
|
||||
// in globals.css wieder heraus.
|
||||
viewportFit: "cover",
|
||||
};
|
||||
|
||||
export default async function RootLayout({
|
||||
@@ -66,9 +45,6 @@ export default async function RootLayout({
|
||||
|
||||
<TopNav user={user} appName={APP_NAME} tagline={APP_TAGLINE} />
|
||||
|
||||
{/* Nur fuer Angemeldete – auf der Anmeldeseite gibt es nichts zu suchen. */}
|
||||
{user ? <CommandPalette isAdmin={user.role === "ADMIN"} /> : null}
|
||||
|
||||
<main className="mx-auto w-full max-w-[1400px] px-4 pb-24 pt-6 sm:px-6 lg:px-8">
|
||||
{children}
|
||||
</main>
|
||||
@@ -76,7 +52,7 @@ export default async function RootLayout({
|
||||
<footer className="mx-auto w-full max-w-[1400px] px-4 pb-10 text-xs text-slate-500 sm:px-6 lg:px-8">
|
||||
<div className="flex flex-wrap items-center justify-between gap-2 border-t border-white/5 pt-6">
|
||||
<span>{APP_NAME} · lokal betrieben, Daten bleiben in deiner PostgreSQL.</span>
|
||||
<ChangelogButton version={APP_VERSION} />
|
||||
<span className="font-mono text-slate-600">v0.2.0</span>
|
||||
</div>
|
||||
</footer>
|
||||
</body>
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
import type { MetadataRoute } from "next";
|
||||
import { APP_NAME, APP_TAGLINE } from "@/lib/config";
|
||||
|
||||
/**
|
||||
* Web-App-Manifest: macht Nebula auf dem Handy installierbar.
|
||||
*
|
||||
* Als Funktion und nicht als Konstante, aus demselben Grund wie bei
|
||||
* generateMetadata: nur so wird APP_NAME zur Laufzeit gelesen. Ein
|
||||
* konstanter Export waere beim Build eingefroren und liesse sich im
|
||||
* fertigen Docker-Image nicht mehr aendern.
|
||||
*/
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
export default function manifest(): MetadataRoute.Manifest {
|
||||
return {
|
||||
name: `${APP_NAME} – ${APP_TAGLINE} Dashboard`,
|
||||
short_name: APP_NAME,
|
||||
description:
|
||||
"Uebersicht ueber alle Vibe-Coding-Projekte: Status, Notizen und Live-Daten aus GitHub, GitLab und Gitea.",
|
||||
// Ohne Adressleiste, aber mit den Systemleisten – die Anwendung braucht
|
||||
// keinen Vollbildmodus, wohl aber die Uhrzeit und den Akkustand.
|
||||
display: "standalone",
|
||||
start_url: "/",
|
||||
scope: "/",
|
||||
background_color: "#05060f",
|
||||
theme_color: "#05060f",
|
||||
lang: "de",
|
||||
orientation: "any",
|
||||
icons: [
|
||||
{ src: "/icon-192.png", sizes: "192x192", type: "image/png", purpose: "any" },
|
||||
{ src: "/icon-512.png", sizes: "512x512", type: "image/png", purpose: "any" },
|
||||
// Getrennte Fassung mit mehr Rand: Android schneidet maskierbare
|
||||
// Symbole je nach Geraet rund, eckig oder als Tropfen zu.
|
||||
{ src: "/icon-maskable-512.png", sizes: "512x512", type: "image/png", purpose: "maskable" },
|
||||
],
|
||||
shortcuts: [
|
||||
{ name: "Dashboard", url: "/" },
|
||||
{ name: "Mein Konto", url: "/account" },
|
||||
],
|
||||
};
|
||||
}
|
||||
+3
-17
@@ -1,5 +1,4 @@
|
||||
import Link from "next/link";
|
||||
import { CalendarRange, CircleDot, GitBranch, Lightbulb, Rocket, Trophy } from "lucide-react";
|
||||
import { CircleDot, GitBranch, Lightbulb, Rocket, Trophy } from "lucide-react";
|
||||
import { ProjectBoard } from "@/components/ProjectBoard";
|
||||
import { StatCard } from "@/components/StatCard";
|
||||
import { requireUserPage } from "@/lib/auth/guard";
|
||||
@@ -30,7 +29,7 @@ export default async function DashboardPage() {
|
||||
const ideas = active.filter((project) => project.status === "IDEA").length;
|
||||
const inDev = active.filter((project) => project.status === "IN_DEVELOPMENT").length;
|
||||
const done = active.filter((project) => project.status === "DONE").length;
|
||||
const linked = active.filter((project) => project.repositories.length > 0).length;
|
||||
const linked = active.filter((project) => Boolean(project.repoOwner && project.repoName)).length;
|
||||
|
||||
const averageProgress =
|
||||
active.length > 0
|
||||
@@ -51,28 +50,15 @@ export default async function DashboardPage() {
|
||||
Ideen festhalten, Status pflegen, Notizen sammeln – und live sehen, was in den
|
||||
verknuepften Repositories bei GitHub, GitLab und Gitea passiert.
|
||||
</p>
|
||||
{/* Kein weiterer Punkt in der Kopfleiste – die ist auf dem Telefon
|
||||
schon eng. Der Rueckblick haengt dort, wo man ohnehin hinsieht. */}
|
||||
<Link
|
||||
href="/rueckblick"
|
||||
className="mt-3 inline-flex items-center gap-1.5 text-sm text-violet-300 underline-offset-2 hover:underline"
|
||||
>
|
||||
<CalendarRange className="h-4 w-4" />
|
||||
Wochenrückblick ansehen
|
||||
</Link>
|
||||
</header>
|
||||
|
||||
{/* Zwei Spalten schon auf dem Telefon: einspaltig fuellten die fuenf
|
||||
Kacheln dort den ganzen ersten Bildschirm, und die Projekte – der
|
||||
eigentliche Inhalt – begannen erst nach dem zweiten Wischen. */}
|
||||
<div className="grid grid-cols-2 gap-3 sm:gap-4 lg:grid-cols-5">
|
||||
<div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-5">
|
||||
<StatCard
|
||||
label="Projekte"
|
||||
value={active.length}
|
||||
hint={`Ø Fortschritt ${averageProgress}%`}
|
||||
icon={CircleDot}
|
||||
color="#a78bfa"
|
||||
className="col-span-2 lg:col-span-1"
|
||||
/>
|
||||
<StatCard
|
||||
label="Ideen"
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user