Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 sysopsandClaude Sonnet 5
|
9d4c2bae4a | ||
|
sysopsandClaude Sonnet 5
|
08d54715d4 |
@@ -1,38 +0,0 @@
|
||||
name: Supply-Chain-Scan (Go)
|
||||
|
||||
on:
|
||||
push:
|
||||
paths:
|
||||
- "**/*.go"
|
||||
- "go.mod"
|
||||
- "go.sum"
|
||||
pull_request: {}
|
||||
|
||||
jobs:
|
||||
govulncheck:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/setup-go@v5
|
||||
with:
|
||||
go-version: "1.22"
|
||||
- name: govulncheck installieren
|
||||
# @latest kann eine govulncheck-Version verlangen, die neuer ist als
|
||||
# die hier verwendete Go-Toolchain (z.B. "requires go >= 1.25.0") —
|
||||
# feste, bekannt kompatible Version statt @latest (siehe
|
||||
# scripts/verify-supply-chain-gate.sh, Fund vom 2026-08-28 auf dem Testhost).
|
||||
run: go install golang.org/x/vuln/cmd/govulncheck@v1.1.3
|
||||
- name: Go-Module auf bekannte Schwachstellen pruefen
|
||||
shell: bash
|
||||
run: |
|
||||
# pipefail ist Pflicht: sonst liefert "govulncheck | tee" den Exit-Code
|
||||
# von tee (immer 0) statt den von govulncheck zurueck — der Gate-Zweck
|
||||
# (Akzeptanzkriterium 3: Fund blockiert den Merge) waere sonst wirkungslos.
|
||||
set -o pipefail
|
||||
govulncheck ./... | tee govulncheck-report.txt
|
||||
- name: Scan-Bericht als Artefakt ablegen
|
||||
if: always()
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: govulncheck-report
|
||||
path: govulncheck-report.txt
|
||||
@@ -1,32 +0,0 @@
|
||||
name: Supply-Chain-Scan (npm)
|
||||
|
||||
on:
|
||||
push:
|
||||
paths:
|
||||
- "web/**/package.json"
|
||||
- "web/**/package-lock.json"
|
||||
pull_request: {}
|
||||
|
||||
jobs:
|
||||
npm-audit:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: "22"
|
||||
- name: Alle Next.js-Frontends auf bekannte Schwachstellen pruefen
|
||||
shell: bash
|
||||
run: |
|
||||
set -o pipefail
|
||||
status=0
|
||||
for pkg in $(find web -maxdepth 2 -name package.json); do
|
||||
dir=$(dirname "$pkg")
|
||||
echo "=== npm audit: $dir ==="
|
||||
(cd "$dir" && npm install --package-lock-only --no-audit --no-fund \
|
||||
&& npm audit --audit-level=high) || status=1
|
||||
done
|
||||
# Erst nach Durchlauf ALLER Frontends fehlschlagen (Akzeptanzkriterium 2/3):
|
||||
# ein einzelner Fund darf nicht verhindern, dass die uebrigen Frontends
|
||||
# ebenfalls geprueft und im Bericht sichtbar werden.
|
||||
exit $status
|
||||
@@ -44,53 +44,3 @@ Keine Commits in dieser Session.
|
||||
Keine Änderungen ermittelbar.
|
||||
|
||||
---
|
||||
## 2026-08-28 23:00 – 23:01 (0m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** nexarch
|
||||
|
||||
### Commits
|
||||
- ab7a033 OPS-06: fix — fixture ruft tatsaechlich verwundbaren symbolpfad auf (ParseAcceptLanguage statt Parse, GO-2022-1059 statt falscher advisory-id)
|
||||
|
||||
### Geänderte Dateien
|
||||
- testdata/vulnfixture-go/go.mod | 8 +++++---
|
||||
- testdata/vulnfixture-go/main.go | 7 +++++--
|
||||
|
||||
---
|
||||
## 2026-08-28 23:02 – 23:03 (0m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** code
|
||||
|
||||
### Commits
|
||||
- 77ecf42 OPS-06: fix — verify-supply-chain-gate.sh unterscheidet jetzt echten Fund von Werkzeugfehler (pruefte vorher nur exit-code, 'command not found' galt faelschlich als bestanden)
|
||||
|
||||
### Geänderte Dateien
|
||||
- DEVLOG.md | 12 ++++++++++++
|
||||
- scripts/verify-supply-chain-gate.sh | 52 +++++++++++++++++++++++++++++++++++++---------------
|
||||
|
||||
---
|
||||
## 2026-08-28 23:04 – 23:05 (0m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** code
|
||||
|
||||
### Commits
|
||||
- 9de84f6 OPS-06: fix — fehlendes fail=1 im govulncheck-unavailable-zweig, govulncheck-version gepinnt statt @latest (Go-Versionskonflikt auf 131 gefunden)
|
||||
|
||||
### Geänderte Dateien
|
||||
- .gitea/workflows/govulncheck.yml | 6 +++++-
|
||||
- DEVLOG.md | 12 ++++++++++++
|
||||
- scripts/verify-supply-chain-gate.sh | 13 +++++++++++--
|
||||
|
||||
---
|
||||
## 2026-08-28 23:05 – 23:05 (0m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** code
|
||||
|
||||
### Commits
|
||||
Keine Commits in dieser Session.
|
||||
|
||||
### Geänderte Dateien
|
||||
- .gitea/workflows/govulncheck.yml | 6 +++++-
|
||||
- DEVLOG.md | 12 ++++++++++++
|
||||
- scripts/verify-supply-chain-gate.sh | 13 +++++++++++--
|
||||
|
||||
---
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
run:
|
||||
timeout: 3m
|
||||
|
||||
linters:
|
||||
disable-all: true
|
||||
enable:
|
||||
- govet
|
||||
- staticcheck
|
||||
- errcheck
|
||||
- unused
|
||||
- ineffassign
|
||||
- gofmt
|
||||
- goimports
|
||||
@@ -0,0 +1,31 @@
|
||||
.PHONY: install run run-app run-worker lint fmt test build
|
||||
|
||||
# Akzeptanzkriterium 1: ein Befehl installiert+startet App und Worker.
|
||||
install: build
|
||||
|
||||
build:
|
||||
go build ./...
|
||||
|
||||
run: build
|
||||
@echo "Starte dms-app und dms-worker (Strg+C zum Beenden beider)"
|
||||
@trap 'kill 0' EXIT; \
|
||||
go run ./cmd/app & \
|
||||
go run ./cmd/worker & \
|
||||
wait
|
||||
|
||||
run-app:
|
||||
go run ./cmd/app
|
||||
|
||||
run-worker:
|
||||
go run ./cmd/worker
|
||||
|
||||
# Akzeptanzkriterium 2: Lint-/Format-Checks laufen lokal durch.
|
||||
lint:
|
||||
golangci-lint run ./...
|
||||
|
||||
fmt:
|
||||
gofmt -l .
|
||||
@test -z "$$(gofmt -l .)" || (echo "gofmt-Verstoesse gefunden, siehe oben" && exit 1)
|
||||
|
||||
test:
|
||||
go test ./... -count=1
|
||||
@@ -0,0 +1,52 @@
|
||||
# NEXARCH DMS
|
||||
|
||||
Dokumentenmanagement-Modul von NEXARCH. Vereint die Stärken von
|
||||
paperless-ngx, Alfresco, Docspell und ecoDMS, vermeidet deren bekannte
|
||||
Schwächen (siehe `known-issues-archivdms.md` im `dms-kanban/`-Ordner).
|
||||
|
||||
Identität, Rechte, Mandantenverwaltung, Authentifizierung, UI-Shell,
|
||||
API-Grundgerüst und Benachrichtigungen kommen aus NEXARCH Core (siehe
|
||||
`../` bzw. `../../core-kanban/`) — dieses Modul implementiert nur die
|
||||
DMS-eigene Logik.
|
||||
|
||||
## Setup
|
||||
|
||||
Voraussetzung: Go 1.22+.
|
||||
|
||||
```bash
|
||||
cd dms
|
||||
make install # baut App und Worker
|
||||
make run # startet beide (Strg+C beendet beide)
|
||||
```
|
||||
|
||||
App läuft danach auf `:8090` (überschreibbar über
|
||||
`NEXARCH_DMS_APP_LISTEN_ADDR`), `GET /healthz` liefert den Status.
|
||||
|
||||
## Struktur
|
||||
|
||||
- `cmd/app` — Anfrage-Dienst (HTTP), blockiert nie durch lange Aufgaben
|
||||
- `cmd/worker` — Hintergrund-Dienst für lange laufende Aufgaben (Indexierung,
|
||||
OCR, Storage-Vorgänge — folgen in FDN-02 ff.)
|
||||
- `internal/shared` — von App und Worker gemeinsam genutzter Code
|
||||
|
||||
## Prüfungen
|
||||
|
||||
```bash
|
||||
make fmt # gofmt-Verstöße brechen ab
|
||||
make lint # golangci-lint
|
||||
make test # go test ./...
|
||||
```
|
||||
|
||||
## Branch- und Commit-Konvention
|
||||
|
||||
Gleiche Konvention wie NEXARCH Core:
|
||||
|
||||
- Branch je Ticket: `feature/<ticket-code>-<kurzbeschreibung>`, z. B.
|
||||
`feature/fdn-02-datenmodell-migrationen`
|
||||
- Commit-Nachricht beginnt mit dem Ticket-Code, z. B.
|
||||
`FDN-02: datenmodell & migrationen`
|
||||
- Ein Ticket = ein Branch. Schrittweise committen, Branch pushen, dann
|
||||
anhalten (kein Merge, kein Deploy durch die bearbeitende Person selbst).
|
||||
- Deutschsprachige Oberflächentexte, englischsprachige Bezeichner im Code.
|
||||
- Keine Zugangsdaten/Schlüssel/Verbindungszeichenfolgen im Code —
|
||||
ausschließlich über Umgebungsvariablen.
|
||||
@@ -0,0 +1,30 @@
|
||||
// app ist der Anfrage-Dienst (Request-Path) des DMS — getrennt vom Worker,
|
||||
// damit lange Hintergrundaufgaben nie eine HTTP-Anfrage blockieren
|
||||
// (Akzeptanzkriterium/Produkt-DNA: paperless-ngx-Trennung Dienst/Worker).
|
||||
package main
|
||||
|
||||
import (
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/dms/internal/shared"
|
||||
)
|
||||
|
||||
func main() {
|
||||
addr := os.Getenv("NEXARCH_DMS_APP_LISTEN_ADDR")
|
||||
if addr == "" {
|
||||
addr = ":8090"
|
||||
}
|
||||
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_, _ = w.Write([]byte(`{"status":"ok","service":"dms-app","version":"` + shared.Version + `"}`))
|
||||
})
|
||||
|
||||
log.Printf("dms-app hoert auf %s (version %s)", addr, shared.Version)
|
||||
if err := http.ListenAndServe(addr, mux); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestHealthz ist der Nachweis, dass der App-Dienst tatsaechlich startet und
|
||||
// antwortet (Akzeptanzkriterium 1: "mit einem Befehl installieren und
|
||||
// starten") — geprueft ueber den Handler direkt statt einen echten Port zu
|
||||
// binden, damit der Test parallel und ohne Portkonflikte laufen kann.
|
||||
func TestHealthz(t *testing.T) {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_, _ = w.Write([]byte(`{"status":"ok","service":"dms-app","version":"test"}`))
|
||||
})
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "/healthz", nil)
|
||||
rec := httptest.NewRecorder()
|
||||
mux.ServeHTTP(rec, req)
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rec.Code, http.StatusOK)
|
||||
}
|
||||
if !strings.Contains(rec.Body.String(), `"status":"ok"`) {
|
||||
t.Fatalf("unerwarteter body: %s", rec.Body.String())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
// worker ist der Hintergrund-Dienst des DMS — verarbeitet lange laufende
|
||||
// Aufgaben (Indexierung, OCR, Storage-Vorgaenge in spaeteren Kacheln),
|
||||
// getrennt vom App-Prozess (siehe cmd/app).
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/dms/internal/shared"
|
||||
)
|
||||
|
||||
func main() {
|
||||
log.Printf("dms-worker gestartet (version %s)", shared.Version)
|
||||
|
||||
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
||||
defer stop()
|
||||
|
||||
ticker := time.NewTicker(30 * time.Second)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
log.Println("dms-worker beendet")
|
||||
return
|
||||
case <-ticker.C:
|
||||
// Platzhalter fuer Job-Verarbeitung (FDN-02 ff.) — Poll-Intervall
|
||||
// folgt der projektweiten Postgres-Jobqueue-Konvention.
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
# FDN-01 – Prüfprotokoll: Repository & Projektgerüst
|
||||
|
||||
Welle 1, keine Vorbedingungen. Verzeichnis `code/dms/` im bestehenden
|
||||
NEXARCH-Repository (Monorepo-Entscheidung, siehe Rückfrage im
|
||||
Session-Verlauf: DMS als Unterordner statt eigenes Gitea-Repo).
|
||||
|
||||
## Struktur
|
||||
|
||||
- `cmd/app` — Anfrage-Dienst (HTTP, Port 8090 per Default)
|
||||
- `cmd/worker` — Hintergrund-Dienst (getrennter Prozess)
|
||||
- `internal/shared` — gemeinsam genutzter Code
|
||||
- `go.mod` — eigenes Modul `gitea.perlbach24.de/scripte/nexarch/dms`,
|
||||
unabhängig vom Core-Modul (kein gemeinsames `go.mod`, um Abhängigkeits-
|
||||
versionen beider Module unabhängig weiterzuentwickeln)
|
||||
|
||||
## Prüfungen
|
||||
|
||||
| # | Prüfung | Zielwert | Ergebnis |
|
||||
|---|---|---|---|
|
||||
| 1 | Frischer Clone baut ohne manuelle Nacharbeit | `make install` läuft ohne Fehler | **bestanden** — `go build ./...` clean auf 192.168.1.131 |
|
||||
| 2 | Lint-Fehler brechen den Build ab | `make lint` liefert Exit-Code ≠ 0 bei echtem Verstoß | **bestanden** — absichtlich eingefügte ungenutzte Variable liefert Exit-Code 2, Fund korrekt lokalisiert (`declared and not used`) |
|
||||
| 3 | README-Setupanleitung von zweiter Person nachvollzogen | — | **nicht durchgeführt** — keine zweite Person in dieser autonomen Sitzung verfügbar (gleiche Methodik-Abweichung wie QA-05 Prüfung 2/QA-09 Bildschirmleser-Durchlauf); ersatzweise die Anleitung selbst Schritt für Schritt auf einer frischen Kopie (`rsync` auf 192.168.1.131) nachvollzogen: `make install` → `make run` → `curl /healthz` → `{"status":"ok",...}`. |
|
||||
|
||||
Zusätzlich (nicht explizit gefordert, aber Teil von Akzeptanzkriterium 1
|
||||
„installieren UND starten"): `make run` startet App und Worker parallel,
|
||||
`GET /healthz` antwortet mit `200 {"status":"ok","service":"dms-app",...}`
|
||||
innerhalb von 2 Sekunden nach Start.
|
||||
|
||||
## Build/Test-Ergebnis (192.168.1.131)
|
||||
|
||||
```
|
||||
make build -> clean
|
||||
make fmt -> clean (keine gofmt-Verstoesse)
|
||||
make lint -> clean (golangci-lint v1.62.2: govet, staticcheck, errcheck, unused, ineffassign, gofmt, goimports)
|
||||
make test -> 1/1 Pakete mit Tests ok (cmd/app), 0 Fehlschlaege
|
||||
```
|
||||
|
||||
## Gesamtergebnis
|
||||
|
||||
**Bestanden**, mit einer dokumentierten Methodik-Abweichung (Prüfung 3,
|
||||
Vier-Augen-Nachvollzug) mangels zweiter Person — durch Selbst-Nachvollzug auf
|
||||
frischer Kopie ersetzt.
|
||||
@@ -0,0 +1,71 @@
|
||||
# FDN-02 – Prüfprotokoll: Datenmodell & Migrationen
|
||||
|
||||
Welle 2. Voraussetzung: FDN-01 (Status "Fertig").
|
||||
|
||||
## Datenmodell
|
||||
|
||||
`migrations/tenant/0001_documents.up.sql` — läuft in der physisch isolierten
|
||||
Tenant-Datenbank (Modell C, siehe Core TEN-01), keine `tenant_id`-Spalte.
|
||||
|
||||
| Entität | Tabelle | Beziehungen |
|
||||
|---|---|---|
|
||||
| Ordner | `folders` | selbstreferenzierend (`parent_folder_id`), `created_by` → `users(id)` |
|
||||
| Dokument | `documents` | `folder_id` → `folders`, `current_revision_id` → `file_revisions`, `created_by` → `users(id)` |
|
||||
| Datei-Revision | `file_revisions` | `document_id` → `documents`, `created_by` → `users(id)`, `UNIQUE(document_id, revision_number)` |
|
||||
| Tag | `tags` | — |
|
||||
| Tag-Zuordnung | `document_tags` | `document_id` → `documents`, `tag_id` → `tags` |
|
||||
| Metadatenfeld | `metadata_fields` | — |
|
||||
| Metadatenwert | `document_metadata_values` | `document_id` → `documents`, `field_id` → `metadata_fields` |
|
||||
|
||||
`created_by`/Benutzerbezug referenziert `users(id)` aus Core IAM-01 (Auth
|
||||
liegt vollständig in Core, siehe "Nicht Bestandteil") — DMS legt `users`
|
||||
nicht selbst an, setzt die Tabelle als bereits vorhanden voraus (dieselbe
|
||||
physische Tenant-Datenbank).
|
||||
|
||||
**Indizes:** `folders(parent_folder_id)`, `documents(folder_id)`,
|
||||
`documents(created_by)`, `file_revisions(document_id)`,
|
||||
`document_tags(tag_id)`, `document_metadata_values(field_id)`.
|
||||
|
||||
## Migrationsmechanik
|
||||
|
||||
`internal/migrate` — eigenständiger, minimaler Runner (kein ORM,
|
||||
`*.up.sql`/`*.down.sql`-Paare), `schema_migrations`-Tabelle als
|
||||
Fortschrittsspeicher (dasselbe Prinzip wie Core, hier eigenständig
|
||||
implementiert, da DMS ein eigenes Go-Modul ist und Cores `internal/`-Pakete
|
||||
nicht importieren kann).
|
||||
|
||||
## Prüfungen
|
||||
|
||||
| # | Prüfung | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Migration auf leerer DB und auf bestehender DB getestet | **bestanden** — `TestUp_OnEmptyAndExistingDB`: erster Lauf legt alle 7 Tabellen an, zweiter Lauf gegen dieselbe (jetzt bestehende) DB wendet 0 neue Migrationen an (über `schema_migrations` erkannt) |
|
||||
| 2 | Rollback stellt Vorzustand wieder her | **bestanden** — `TestDownOne_RestoresPreviousState`: nach `DownOne` existiert keine der 7 Tabellen mehr, zweiter `DownOne`-Aufruf ohne verbleibende Migration liefert korrekt leeren String statt Fehler |
|
||||
| 3 | Fremdschlüssel-Constraints durch Negativtests belegt | **bestanden** — `TestForeignKeyConstraints_RejectInvalidReferences`, 4 Fälle: Dokument mit unbekanntem Ordner, unbekanntem Ersteller, Datei-Revision mit unbekanntem Dokument, Tag-Zuordnung mit unbekanntem Tag — alle vier korrekt abgewiesen |
|
||||
|
||||
Zusätzlich (Akzeptanzkriterium 3, Seed-Datensatz): `migrations/tenant/seed/dev_seed.sql`
|
||||
manuell gegen eine frische Test-DB mit einer `users`-Zeile ausgeführt (siehe
|
||||
Sitzungsprotokoll) — legt Ordner, Dokument mit Revision, Tag und
|
||||
Metadatenfeld+-wert an, per Abfrage bestätigt (`Beispieldokument`,
|
||||
`Beispiel-Tag`, `rechnungsnummer` vorhanden). Schlägt bewusst mit
|
||||
sprechender Fehlermeldung fehl, wenn noch kein Benutzer existiert (DMS legt
|
||||
`users` nicht selbst an).
|
||||
|
||||
## Bekannte Fehler vermeiden (aus Ticket)
|
||||
|
||||
„Fehlende Lock-/Sum-Datei blockiert CI" — `go.sum` ist committet (siehe
|
||||
`git status`/Commit-Diff), `go mod tidy` auf 192.168.1.131 ausgeführt und
|
||||
Ergebnis übernommen.
|
||||
|
||||
## Build/Test-Ergebnis (192.168.1.131)
|
||||
|
||||
```
|
||||
go build ./... -> clean
|
||||
go vet ./... -> clean
|
||||
make lint -> clean (golangci-lint)
|
||||
go test ./... -v -count=1 -> 3/3 Pakete mit Tests ok (cmd/app, internal/migrate), 0 Fehlschläge
|
||||
```
|
||||
|
||||
## Gesamtergebnis
|
||||
|
||||
**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
|
||||
erfüllt und belegt.
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
module gitea.perlbach24.de/scripte/nexarch/dms
|
||||
|
||||
go 1.22
|
||||
|
||||
require github.com/jackc/pgx/v5 v5.6.0
|
||||
|
||||
require (
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
|
||||
github.com/jackc/puddle/v2 v2.2.1 // indirect
|
||||
golang.org/x/crypto v0.17.0 // indirect
|
||||
golang.org/x/sync v0.1.0 // indirect
|
||||
golang.org/x/text v0.14.0 // indirect
|
||||
)
|
||||
@@ -0,0 +1,165 @@
|
||||
// Package migrate implementiert FDN-02s Migrationsmechanik: versionierte,
|
||||
// rueckrollbare SQL-Migrationsdateien (kein ORM), mit einer
|
||||
// schema_migrations-Tabelle als Fortschrittsspeicher — dasselbe Prinzip wie
|
||||
// NEXARCH Core (internal/migrate), hier eigenstaendig implementiert, da DMS
|
||||
// ein eigenes Go-Modul ist und Cores internal/-Pakete nicht importieren
|
||||
// kann.
|
||||
package migrate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// Migration ist eine einzelne versionierte Migrationsdatei.
|
||||
type Migration struct {
|
||||
Version string // Dateiname ohne .up.sql/.down.sql, z.B. "0001_documents"
|
||||
UpSQL string
|
||||
DownSQL string
|
||||
}
|
||||
|
||||
// Load liest alle *.up.sql/*.down.sql-Paare aus dir, sortiert nach
|
||||
// Dateiname (Akzeptanzkriterium: Migrationen sind versioniert).
|
||||
func Load(dir string) ([]Migration, error) {
|
||||
entries, err := os.ReadDir(dir)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("migrationsverzeichnis %q lesen: %w", dir, err)
|
||||
}
|
||||
var versions []string
|
||||
for _, e := range entries {
|
||||
if e.IsDir() || !strings.HasSuffix(e.Name(), ".up.sql") {
|
||||
continue
|
||||
}
|
||||
versions = append(versions, strings.TrimSuffix(e.Name(), ".up.sql"))
|
||||
}
|
||||
sort.Strings(versions)
|
||||
|
||||
migrations := make([]Migration, 0, len(versions))
|
||||
for _, v := range versions {
|
||||
up, err := os.ReadFile(filepath.Join(dir, v+".up.sql"))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("migration %q: up.sql lesen: %w", v, err)
|
||||
}
|
||||
down, err := os.ReadFile(filepath.Join(dir, v+".down.sql"))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("migration %q: down.sql lesen (jede Migration braucht ein Rollback): %w", v, err)
|
||||
}
|
||||
migrations = append(migrations, Migration{Version: v, UpSQL: string(up), DownSQL: string(down)})
|
||||
}
|
||||
return migrations, nil
|
||||
}
|
||||
|
||||
func ensureTrackingTable(ctx context.Context, pool *pgxpool.Pool) error {
|
||||
_, err := pool.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version TEXT PRIMARY KEY,
|
||||
applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
)
|
||||
`)
|
||||
if err != nil {
|
||||
return fmt.Errorf("schema_migrations anlegen: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func appliedVersions(ctx context.Context, pool *pgxpool.Pool) (map[string]bool, error) {
|
||||
rows, err := pool.Query(ctx, `SELECT version FROM schema_migrations`)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("angewendete migrationen lesen: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
applied := map[string]bool{}
|
||||
for rows.Next() {
|
||||
var v string
|
||||
if err := rows.Scan(&v); err != nil {
|
||||
return nil, fmt.Errorf("migrationsversion lesen: %w", err)
|
||||
}
|
||||
applied[v] = true
|
||||
}
|
||||
return applied, rows.Err()
|
||||
}
|
||||
|
||||
// Up wendet alle noch nicht angewendeten Migrationen in Reihenfolge an
|
||||
// (Akzeptanzkriterium 2: vorwaerts ausfuehrbar) — bereits angewendete
|
||||
// werden uebersprungen, damit Up auf einer leeren UND auf einer bestehenden
|
||||
// DB funktioniert (Pruefung 1).
|
||||
func Up(ctx context.Context, pool *pgxpool.Pool, migrations []Migration) (applied []string, err error) {
|
||||
if err := ensureTrackingTable(ctx, pool); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
already, err := appliedVersions(ctx, pool)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
for _, m := range migrations {
|
||||
if already[m.Version] {
|
||||
continue
|
||||
}
|
||||
tx, err := pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return applied, fmt.Errorf("transaktion fuer %q starten: %w", m.Version, err)
|
||||
}
|
||||
if _, err := tx.Exec(ctx, m.UpSQL); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return applied, fmt.Errorf("migration %q anwenden: %w", m.Version, err)
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `INSERT INTO schema_migrations (version) VALUES ($1)`, m.Version); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return applied, fmt.Errorf("migration %q als angewendet markieren: %w", m.Version, err)
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return applied, fmt.Errorf("migration %q committen: %w", m.Version, err)
|
||||
}
|
||||
applied = append(applied, m.Version)
|
||||
}
|
||||
return applied, nil
|
||||
}
|
||||
|
||||
// DownOne macht die zuletzt angewendete Migration rueckgaengig
|
||||
// (Akzeptanzkriterium 2: rueckwaerts ausfuehrbar) und liefert deren Version,
|
||||
// oder "" falls keine Migration angewendet war.
|
||||
func DownOne(ctx context.Context, pool *pgxpool.Pool, migrations []Migration) (version string, err error) {
|
||||
if err := ensureTrackingTable(ctx, pool); err != nil {
|
||||
return "", err
|
||||
}
|
||||
already, err := appliedVersions(ctx, pool)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
var last *Migration
|
||||
for i := len(migrations) - 1; i >= 0; i-- {
|
||||
if already[migrations[i].Version] {
|
||||
last = &migrations[i]
|
||||
break
|
||||
}
|
||||
}
|
||||
if last == nil {
|
||||
return "", nil
|
||||
}
|
||||
|
||||
tx, err := pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("transaktion fuer rollback von %q starten: %w", last.Version, err)
|
||||
}
|
||||
if _, err := tx.Exec(ctx, last.DownSQL); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return "", fmt.Errorf("migration %q zurueckrollen: %w", last.Version, err)
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `DELETE FROM schema_migrations WHERE version = $1`, last.Version); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return "", fmt.Errorf("migration %q aus schema_migrations entfernen: %w", last.Version, err)
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return "", fmt.Errorf("rollback von %q committen: %w", last.Version, err)
|
||||
}
|
||||
return last.Version, nil
|
||||
}
|
||||
@@ -0,0 +1,204 @@
|
||||
package migrate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// usersFixtureSQL spiegelt Core IAM-01s reales Schema
|
||||
// (migrations/tenant/0001_users.up.sql im NEXARCH-Core-Modul) - DMS ist ein
|
||||
// eigenes Go-Modul und kann Cores Migrationsdateien nicht importieren, daher
|
||||
// hier als Testfixture kopiert, NICHT als Produktionsmigration (DMS legt
|
||||
// users nicht selbst an, siehe "Nicht Bestandteil" in FDN-02).
|
||||
const usersFixtureSQL = `
|
||||
CREATE EXTENSION IF NOT EXISTS pgcrypto;
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
email TEXT NOT NULL UNIQUE,
|
||||
name TEXT NOT NULL,
|
||||
status TEXT NOT NULL DEFAULT 'active',
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
`
|
||||
|
||||
func setupTest(t *testing.T) (*pgxpool.Pool, []Migration) {
|
||||
t.Helper()
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
|
||||
pool, err := pgxpool.New(ctx, dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { pool.Close() })
|
||||
|
||||
if _, err := pool.Exec(ctx, usersFixtureSQL); err != nil {
|
||||
t.Fatalf("users-fixture anlegen: %v", err)
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `
|
||||
INSERT INTO users (email, name) VALUES ('seed@example.test', 'Seed-Benutzer')
|
||||
ON CONFLICT (email) DO NOTHING
|
||||
`); err != nil {
|
||||
t.Fatalf("seed-benutzer anlegen: %v", err)
|
||||
}
|
||||
|
||||
migrations, err := Load(migrationsDir(t))
|
||||
if err != nil {
|
||||
t.Fatalf("migrationen laden: %v", err)
|
||||
}
|
||||
return pool, migrations
|
||||
}
|
||||
|
||||
func migrationsDir(t *testing.T) string {
|
||||
t.Helper()
|
||||
wd, err := os.Getwd()
|
||||
if err != nil {
|
||||
t.Fatalf("getwd: %v", err)
|
||||
}
|
||||
return filepath.Join(wd, "..", "..", "migrations", "tenant")
|
||||
}
|
||||
|
||||
func tableExists(t *testing.T, ctx context.Context, pool *pgxpool.Pool, name string) bool {
|
||||
t.Helper()
|
||||
var exists bool
|
||||
if err := pool.QueryRow(ctx, `
|
||||
SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = $1)
|
||||
`, name).Scan(&exists); err != nil {
|
||||
t.Fatalf("tabellenexistenz von %q pruefen: %v", name, err)
|
||||
}
|
||||
return exists
|
||||
}
|
||||
|
||||
// TestUp_OnEmptyAndExistingDB ist Pruefung 1: Migration auf leerer DB und
|
||||
// auf bestehender DB getestet.
|
||||
func TestUp_OnEmptyAndExistingDB(t *testing.T) {
|
||||
pool, migrations := setupTest(t)
|
||||
ctx := context.Background()
|
||||
|
||||
applied, err := Up(ctx, pool, migrations)
|
||||
if err != nil {
|
||||
t.Fatalf("up (leere db): %v", err)
|
||||
}
|
||||
if len(applied) == 0 {
|
||||
t.Fatal("erwartet mindestens 1 angewendete migration auf leerer db")
|
||||
}
|
||||
for _, table := range []string{"folders", "documents", "file_revisions", "tags", "document_tags", "metadata_fields", "document_metadata_values"} {
|
||||
if !tableExists(t, ctx, pool, table) {
|
||||
t.Fatalf("tabelle %q existiert nach Up nicht", table)
|
||||
}
|
||||
}
|
||||
|
||||
// Zweiter Up-Lauf gegen die JETZT BESTEHENDE db - muss ohne Fehler
|
||||
// durchlaufen und darf nichts erneut anwenden (idempotent ueber
|
||||
// schema_migrations).
|
||||
appliedAgain, err := Up(ctx, pool, migrations)
|
||||
if err != nil {
|
||||
t.Fatalf("up (bestehende db, zweiter lauf): %v", err)
|
||||
}
|
||||
if len(appliedAgain) != 0 {
|
||||
t.Fatalf("zweiter Up-Lauf haette 0 neue migrationen anwenden sollen, hat %d", len(appliedAgain))
|
||||
}
|
||||
}
|
||||
|
||||
// TestDownOne_RestoresPreviousState ist Pruefung 2: Rollback stellt den
|
||||
// Vorzustand wieder her.
|
||||
func TestDownOne_RestoresPreviousState(t *testing.T) {
|
||||
pool, migrations := setupTest(t)
|
||||
ctx := context.Background()
|
||||
|
||||
if _, err := Up(ctx, pool, migrations); err != nil {
|
||||
t.Fatalf("up: %v", err)
|
||||
}
|
||||
if !tableExists(t, ctx, pool, "documents") {
|
||||
t.Fatal("voraussetzung nicht erfuellt: documents sollte nach Up existieren")
|
||||
}
|
||||
|
||||
version, err := DownOne(ctx, pool, migrations)
|
||||
if err != nil {
|
||||
t.Fatalf("downone: %v", err)
|
||||
}
|
||||
if version == "" {
|
||||
t.Fatal("erwartet zurueckgerollte version, habe leeren string")
|
||||
}
|
||||
|
||||
for _, table := range []string{"folders", "documents", "file_revisions", "tags", "document_tags", "metadata_fields", "document_metadata_values"} {
|
||||
if tableExists(t, ctx, pool, table) {
|
||||
t.Fatalf("tabelle %q existiert nach Rollback noch - Vorzustand nicht wiederhergestellt", table)
|
||||
}
|
||||
}
|
||||
|
||||
// Erneutes DownOne ohne verbleibende angewendete Migration liefert "".
|
||||
version2, err := DownOne(ctx, pool, migrations)
|
||||
if err != nil {
|
||||
t.Fatalf("downone (nichts mehr anzuwenden): %v", err)
|
||||
}
|
||||
if version2 != "" {
|
||||
t.Fatalf("erwartet leeren string bei leerer schema_migrations, habe %q", version2)
|
||||
}
|
||||
}
|
||||
|
||||
// TestForeignKeyConstraints_RejectInvalidReferences ist Pruefung 3:
|
||||
// Fremdschluessel-Constraints durch Negativtests belegt.
|
||||
func TestForeignKeyConstraints_RejectInvalidReferences(t *testing.T) {
|
||||
pool, migrations := setupTest(t)
|
||||
ctx := context.Background()
|
||||
if _, err := Up(ctx, pool, migrations); err != nil {
|
||||
t.Fatalf("up: %v", err)
|
||||
}
|
||||
|
||||
var userID string
|
||||
if err := pool.QueryRow(ctx, `SELECT id FROM users LIMIT 1`).Scan(&userID); err != nil {
|
||||
t.Fatalf("seed-benutzer lesen: %v", err)
|
||||
}
|
||||
|
||||
t.Run("dokument mit unbekanntem ordner wird abgewiesen", func(t *testing.T) {
|
||||
_, err := pool.Exec(ctx, `
|
||||
INSERT INTO documents (folder_id, title, created_by) VALUES (gen_random_uuid(), 'x', $1)
|
||||
`, userID)
|
||||
if err == nil {
|
||||
t.Fatal("insert mit unbekanntem folder_id haette scheitern muessen")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("dokument mit unbekanntem ersteller wird abgewiesen", func(t *testing.T) {
|
||||
_, err := pool.Exec(ctx, `
|
||||
INSERT INTO documents (title, created_by) VALUES ('x', gen_random_uuid())
|
||||
`)
|
||||
if err == nil {
|
||||
t.Fatal("insert mit unbekanntem created_by haette scheitern muessen")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("datei-revision mit unbekanntem dokument wird abgewiesen", func(t *testing.T) {
|
||||
_, err := pool.Exec(ctx, `
|
||||
INSERT INTO file_revisions (document_id, revision_number, storage_key, checksum_sha256, size_bytes, mime_type, created_by)
|
||||
VALUES (gen_random_uuid(), 1, 'k', repeat('0',64), 1, 'text/plain', $1)
|
||||
`, userID)
|
||||
if err == nil {
|
||||
t.Fatal("insert mit unbekanntem document_id haette scheitern muessen")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("tag-zuordnung mit unbekanntem tag wird abgewiesen", func(t *testing.T) {
|
||||
var docID string
|
||||
if err := pool.QueryRow(ctx, `
|
||||
INSERT INTO documents (title, created_by) VALUES ('fk-test-doc', $1) RETURNING id
|
||||
`, userID).Scan(&docID); err != nil {
|
||||
t.Fatalf("testdokument anlegen: %v", err)
|
||||
}
|
||||
_, err := pool.Exec(ctx, `
|
||||
INSERT INTO document_tags (document_id, tag_id) VALUES ($1, gen_random_uuid())
|
||||
`, docID)
|
||||
if err == nil {
|
||||
t.Fatal("insert mit unbekanntem tag_id haette scheitern muessen")
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
// Package shared enthaelt Code, der von App und Worker gemeinsam genutzt
|
||||
// wird (FDN-01) — Datenmodell, Storage-Zugriff etc. kommen in spaeteren
|
||||
// Kacheln (FDN-02/FDN-03) hierher, dieses Paket ist bewusst noch schlank.
|
||||
package shared
|
||||
|
||||
// Version ist die aktuelle DMS-Version, per -ldflags ueberschreibbar
|
||||
// (siehe Makefile) — Platzhalter fuer echtes Versionsmanagement.
|
||||
var Version = "dev"
|
||||
@@ -0,0 +1,8 @@
|
||||
DROP TABLE IF EXISTS document_metadata_values;
|
||||
DROP TABLE IF EXISTS metadata_fields;
|
||||
DROP TABLE IF EXISTS document_tags;
|
||||
DROP TABLE IF EXISTS tags;
|
||||
ALTER TABLE documents DROP CONSTRAINT IF EXISTS fk_documents_current_revision;
|
||||
DROP TABLE IF EXISTS file_revisions;
|
||||
DROP TABLE IF EXISTS documents;
|
||||
DROP TABLE IF EXISTS folders;
|
||||
@@ -0,0 +1,88 @@
|
||||
-- Kern-Entitaeten des DMS (FDN-02): Dokument, Datei-Revision, Ordner, Tag,
|
||||
-- Metadatenfeld. Laeuft in der DB EINES Mandanten (Modell C, siehe Core
|
||||
-- TEN-01) — keine tenant_id-Spalte, die Tenant-Zugehoerigkeit ist implizit
|
||||
-- durch die Datenbankverbindung gegeben. FK auf users(id) spiegelt das
|
||||
-- Benutzer-Datenmodell aus Core IAM-01 (migrations/tenant/0001_users.up.sql
|
||||
-- im NEXARCH-Core-Modul) — Auth/Benutzerverwaltung liegt vollstaendig in
|
||||
-- Core (siehe "Nicht Bestandteil" in FDN-02), diese Migration dupliziert sie
|
||||
-- NICHT, sondern setzt sie als bereits vorhanden voraus (users-Tabelle wird
|
||||
-- durch Cores eigene Migration in derselben physischen Tenant-Datenbank
|
||||
-- angelegt, bevor DMS-Migrationen laufen).
|
||||
CREATE EXTENSION IF NOT EXISTS pgcrypto;
|
||||
|
||||
CREATE TABLE folders (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
parent_folder_id UUID REFERENCES folders(id) ON DELETE CASCADE,
|
||||
name TEXT NOT NULL,
|
||||
created_by UUID NOT NULL REFERENCES users(id),
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE INDEX idx_folders_parent_folder_id ON folders(parent_folder_id);
|
||||
|
||||
CREATE TABLE documents (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
folder_id UUID REFERENCES folders(id) ON DELETE SET NULL,
|
||||
title TEXT NOT NULL,
|
||||
-- current_revision_id verweist erst NACH der Anlage von file_revisions
|
||||
-- auf eine Zeile (siehe ALTER TABLE unten) — beim INSERT eines Dokuments
|
||||
-- existiert noch keine Revision, daher NULLable und zirkulaer per
|
||||
-- nachtraeglichem FOREIGN KEY statt Inline-Referenz geloest.
|
||||
current_revision_id UUID,
|
||||
created_by UUID NOT NULL REFERENCES users(id),
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
deleted_at TIMESTAMPTZ
|
||||
);
|
||||
CREATE INDEX idx_documents_folder_id ON documents(folder_id);
|
||||
CREATE INDEX idx_documents_created_by ON documents(created_by);
|
||||
|
||||
CREATE TABLE file_revisions (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
document_id UUID NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
|
||||
revision_number INT NOT NULL,
|
||||
-- storage_key ist ein Platzhalter fuer die Objekt-Storage-Abstraktion
|
||||
-- (FDN-03, "Nicht Bestandteil" dieser Kachel) — hier nur die Spalte, die
|
||||
-- spaetere Kachel legt fest, was tatsaechlich dahinter liegt.
|
||||
storage_key TEXT NOT NULL,
|
||||
checksum_sha256 TEXT NOT NULL,
|
||||
size_bytes BIGINT NOT NULL,
|
||||
mime_type TEXT NOT NULL,
|
||||
created_by UUID NOT NULL REFERENCES users(id),
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
UNIQUE (document_id, revision_number)
|
||||
);
|
||||
CREATE INDEX idx_file_revisions_document_id ON file_revisions(document_id);
|
||||
|
||||
ALTER TABLE documents
|
||||
ADD CONSTRAINT fk_documents_current_revision
|
||||
FOREIGN KEY (current_revision_id) REFERENCES file_revisions(id) ON DELETE SET NULL;
|
||||
|
||||
CREATE TABLE tags (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
name TEXT NOT NULL UNIQUE,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE document_tags (
|
||||
document_id UUID NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
|
||||
tag_id UUID NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (document_id, tag_id)
|
||||
);
|
||||
CREATE INDEX idx_document_tags_tag_id ON document_tags(tag_id);
|
||||
|
||||
CREATE TABLE metadata_fields (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
field_key TEXT NOT NULL UNIQUE,
|
||||
label TEXT NOT NULL,
|
||||
field_type TEXT NOT NULL CHECK (field_type IN ('text', 'number', 'date', 'bool', 'select')),
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE document_metadata_values (
|
||||
document_id UUID NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
|
||||
field_id UUID NOT NULL REFERENCES metadata_fields(id) ON DELETE CASCADE,
|
||||
value TEXT NOT NULL,
|
||||
PRIMARY KEY (document_id, field_id)
|
||||
);
|
||||
CREATE INDEX idx_document_metadata_values_field_id ON document_metadata_values(field_id);
|
||||
@@ -0,0 +1,43 @@
|
||||
-- Entwicklungs-Seed (Akzeptanzkriterium 3): legt einen Beispielordner, ein
|
||||
-- Beispieldokument mit einer Revision, ein Tag und ein Metadatenfeld an.
|
||||
-- Setzt voraus, dass mindestens ein Benutzer existiert (Core IAM-01 legt
|
||||
-- users an, DMS tut das nicht selbst - siehe "Nicht Bestandteil" in
|
||||
-- FDN-02) - schlaegt sonst absichtlich mit einer sprechenden Fehlermeldung
|
||||
-- fehl statt einen Platzhalter-Benutzer anzulegen, den DMS gar nicht
|
||||
-- verwalten darf.
|
||||
DO $$
|
||||
DECLARE
|
||||
seed_user_id UUID;
|
||||
seed_folder_id UUID;
|
||||
seed_document_id UUID;
|
||||
BEGIN
|
||||
SELECT id INTO seed_user_id FROM users ORDER BY created_at LIMIT 1;
|
||||
IF seed_user_id IS NULL THEN
|
||||
RAISE EXCEPTION 'dev_seed.sql: keine Zeile in users gefunden - zuerst Core-Seed (IAM-01) ausfuehren';
|
||||
END IF;
|
||||
|
||||
INSERT INTO folders (name, created_by) VALUES ('Beispielordner', seed_user_id)
|
||||
RETURNING id INTO seed_folder_id;
|
||||
|
||||
INSERT INTO documents (folder_id, title, created_by) VALUES (seed_folder_id, 'Beispieldokument', seed_user_id)
|
||||
RETURNING id INTO seed_document_id;
|
||||
|
||||
INSERT INTO file_revisions (document_id, revision_number, storage_key, checksum_sha256, size_bytes, mime_type, created_by)
|
||||
VALUES (seed_document_id, 1, 'dev-seed/beispiel.pdf', repeat('0', 64), 12345, 'application/pdf', seed_user_id);
|
||||
|
||||
UPDATE documents SET current_revision_id = (
|
||||
SELECT id FROM file_revisions WHERE document_id = seed_document_id AND revision_number = 1
|
||||
) WHERE id = seed_document_id;
|
||||
|
||||
INSERT INTO tags (name) VALUES ('Beispiel-Tag')
|
||||
ON CONFLICT (name) DO NOTHING;
|
||||
|
||||
INSERT INTO document_tags (document_id, tag_id)
|
||||
SELECT seed_document_id, id FROM tags WHERE name = 'Beispiel-Tag';
|
||||
|
||||
INSERT INTO metadata_fields (field_key, label, field_type) VALUES ('rechnungsnummer', 'Rechnungsnummer', 'text')
|
||||
ON CONFLICT (field_key) DO NOTHING;
|
||||
|
||||
INSERT INTO document_metadata_values (document_id, field_id, value)
|
||||
SELECT seed_document_id, id, 'RE-2026-0001' FROM metadata_fields WHERE field_key = 'rechnungsnummer';
|
||||
END $$;
|
||||
@@ -1,79 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# OPS-06 Pruefung 1: beweist, dass govulncheck und npm audit eine absichtlich
|
||||
# verwundbare Testabhaengigkeit tatsaechlich ERKENNEN (nicht nur irgendeinen
|
||||
# Fehler werfen) und mit Exit-Code != 0 enden (= wuerden den Merge blockieren).
|
||||
# Laeuft auf dem Testhost (Go/npm noetig), nicht auf der Entwicklungsmaschine.
|
||||
#
|
||||
# Wichtig: ein Exit-Code != 0 allein ist KEIN Beweis — ein fehlendes Tool
|
||||
# ("command not found", exit 127) sieht fuer ein reines Exit-Code-Gate genauso
|
||||
# aus wie ein echter Fund. Deshalb prueft dieses Skript zusaetzlich, dass die
|
||||
# erwartete Advisory-Kennung tatsaechlich in der Ausgabe steht.
|
||||
set -uo pipefail
|
||||
|
||||
# "go install" legt Binaries in $(go env GOPATH)/bin ab — auf frischen Hosts
|
||||
# ist das nicht zwangslaeufig im PATH (gefunden 2026-08-28 auf dem Testhost:
|
||||
# govulncheck installierte erfolgreich, "command -v govulncheck" schlug danach
|
||||
# trotzdem fehl, weil /root/go/bin nicht im PATH stand). Defensiv ergaenzen,
|
||||
# statt stillschweigend als "Werkzeug fehlt" fehlzuschlagen.
|
||||
export PATH="$PATH:$(go env GOPATH 2>/dev/null)/bin"
|
||||
|
||||
fail=0
|
||||
|
||||
echo "=== Go-Fixture: golang.org/x/text v0.3.7, GO-2022-1059 (Symbolpfad language.ParseAcceptLanguage) ==="
|
||||
if ! command -v govulncheck >/dev/null 2>&1; then
|
||||
echo "govulncheck fehlt, installiere..."
|
||||
# @latest kann eine govulncheck-Version verlangen, die neuer ist als die
|
||||
# lokal installierte Go-Toolchain (z. B. "requires go >= 1.25.0"). Feste,
|
||||
# bekannt kompatible Version statt @latest, damit die Installation nicht
|
||||
# von der jeweiligen Go-Version des Hosts abhaengt.
|
||||
if ! go install golang.org/x/vuln/cmd/govulncheck@v1.1.3; then
|
||||
echo "FEHLER: govulncheck konnte nicht installiert werden — Pruefung nicht durchfuehrbar, kein Ersatz-'OK'."
|
||||
fail=1
|
||||
fi
|
||||
fi
|
||||
|
||||
if command -v govulncheck >/dev/null 2>&1; then
|
||||
go_output=$(cd testdata/vulnfixture-go && go mod tidy && govulncheck ./... 2>&1)
|
||||
go_exit=$?
|
||||
echo "$go_output"
|
||||
if [ "$go_exit" -eq 0 ]; then
|
||||
echo "FEHLER: govulncheck hat die bekannte Schwachstelle NICHT erkannt (exit 0 erwartet != 0)"
|
||||
fail=1
|
||||
elif ! grep -q "GO-2022-1059" <<<"$go_output"; then
|
||||
echo "FEHLER: exit code $go_exit ist != 0, aber die erwartete Advisory GO-2022-1059 steht NICHT in der Ausgabe — das ist vermutlich ein Werkzeugfehler (z. B. fehlendes govulncheck, Netzwerkproblem), kein echter Fund. Kein 'OK'."
|
||||
fail=1
|
||||
else
|
||||
echo "OK: govulncheck hat GO-2022-1059 tatsaechlich als Fund gemeldet, exit code $go_exit (!= 0, Gate wuerde blockieren)"
|
||||
fi
|
||||
else
|
||||
# Bug (gefunden 2026-08-28): dieser Zweig druckte vorher nur eine Meldung,
|
||||
# setzte aber "fail" NICHT — das Skript endete trotzdem mit Exit-Code 0 und
|
||||
# "PRUEFUNG 1 BESTANDEN", obwohl der Go-Teil real nicht lief. Exakt derselbe
|
||||
# Fehlerklasse (Werkzeugfehler zaehlt als Erfolg), nur eine Ebene hoeher.
|
||||
echo "FEHLER: govulncheck weiterhin nicht verfuegbar — Go-Teil der Pruefung nicht durchgefuehrt, kein Ersatz-'OK'."
|
||||
fail=1
|
||||
fi
|
||||
|
||||
echo
|
||||
echo "=== npm-Fixture: lodash 4.17.4 (mehrere bekannte kritische CVEs) ==="
|
||||
npm_output=$(cd testdata/vulnfixture-npm && npm install --package-lock-only --no-audit --no-fund 2>&1 \
|
||||
&& npm audit --audit-level=high 2>&1)
|
||||
npm_exit=$?
|
||||
echo "$npm_output"
|
||||
if [ "$npm_exit" -eq 0 ]; then
|
||||
echo "FEHLER: npm audit hat die bekannte Schwachstelle NICHT erkannt (exit 0 erwartet != 0)"
|
||||
fail=1
|
||||
elif ! grep -qiE "severity|vulnerabilit" <<<"$npm_output"; then
|
||||
echo "FEHLER: exit code $npm_exit ist != 0, aber die Ausgabe enthaelt keinen erkennbaren Schwachstellen-Hinweis — vermutlich ein Werkzeugfehler (z. B. fehlendes npm, Netzwerkproblem), kein echter Fund. Kein 'OK'."
|
||||
fail=1
|
||||
else
|
||||
echo "OK: npm audit hat die Schwachstelle tatsaechlich gemeldet, exit code $npm_exit (!= 0, Gate wuerde blockieren)"
|
||||
fi
|
||||
|
||||
echo
|
||||
if [ "$fail" -eq 0 ]; then
|
||||
echo "PRUEFUNG 1 BESTANDEN: beide Gates erkennen eine absichtlich verwundbare Testabhaengigkeit inhaltlich (nicht nur per Exit-Code) und wuerden blockieren."
|
||||
else
|
||||
echo "PRUEFUNG 1 FEHLGESCHLAGEN: siehe FEHLER oben."
|
||||
fi
|
||||
exit $fail
|
||||
Vendored
-14
@@ -1,14 +0,0 @@
|
||||
// Absichtlich verwundbares Fixture-Modul fuer OPS-06 Pruefung 1: beweist, dass
|
||||
// der govulncheck-CI-Schritt eine bekannte Schwachstelle tatsaechlich erkennt
|
||||
// und den Lauf mit Exit-Code != 0 beendet. Eigenes go.mod, damit die
|
||||
// veraltete, verwundbare Abhaengigkeit NICHT im Hauptmodul landet.
|
||||
module gitea.perlbach24.de/scripte/nexarch/testdata/vulnfixture-go
|
||||
|
||||
go 1.22
|
||||
|
||||
// golang.org/x/text v0.3.7: GO-2022-1059 — Denial of Service durch
|
||||
// uebermaessigen Ressourcenverbrauch beim Parsen von Accept-Language-Headern
|
||||
// (language.ParseAcceptLanguage). Bewusst auf dieser verwundbaren Version
|
||||
// gepinnt, siehe scripts/verify-supply-chain-gate.sh — main.go ruft gezielt
|
||||
// den verwundbaren Symbolpfad auf, nicht nur irgendeine Funktion des Pakets.
|
||||
require golang.org/x/text v0.3.7
|
||||
Vendored
-22
@@ -1,22 +0,0 @@
|
||||
// Fixture fuer OPS-06 Pruefung 1 — ruft tatsaechlich in die verwundbare
|
||||
// Funktion hinein, damit govulncheck den Aufrufpfad (nicht nur die
|
||||
// Modul-Abhaengigkeit) als erreichbar erkennt.
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"golang.org/x/text/language"
|
||||
)
|
||||
|
||||
func main() {
|
||||
// ParseAcceptLanguage ist der tatsaechlich verwundbare Aufrufpfad
|
||||
// (GO-2022-1059), im Unterschied zu Parse() — govulncheck bewertet
|
||||
// Erreichbarkeit auf Symbol-, nicht nur Paket-Ebene.
|
||||
tags, _, err := language.ParseAcceptLanguage("de-DE,de;q=0.9,en;q=0.8")
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
return
|
||||
}
|
||||
fmt.Println(tags)
|
||||
}
|
||||
-8
@@ -1,8 +0,0 @@
|
||||
{
|
||||
"name": "nexarch-vulnfixture-npm",
|
||||
"private": true,
|
||||
"description": "Absichtlich verwundbares Fixture-Paket fuer OPS-06 Pruefung 1 — beweist, dass npm audit eine bekannte Schwachstelle erkennt und den Lauf blockiert. Nicht Teil eines echten NEXARCH-Frontends.",
|
||||
"dependencies": {
|
||||
"lodash": "4.17.4"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user