Compare commits
4
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 sysops
|
bfa5c61db5 | ||
|
sysops
|
3c226dab12 | ||
|
sysops
|
584cefa388 | ||
|
sysops
|
00665592f6 |
@@ -1,2 +1,4 @@
|
||||
*.log
|
||||
.env
|
||||
web/*/node_modules/
|
||||
web/*/.next/
|
||||
|
||||
@@ -44,3 +44,41 @@ Keine Commits in dieser Session.
|
||||
Keine Änderungen ermittelbar.
|
||||
|
||||
---
|
||||
## 2026-08-28 21:44 – 21:44 (0m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** nexarch
|
||||
|
||||
### Commits
|
||||
Keine Commits in dieser Session.
|
||||
|
||||
### Geänderte Dateien
|
||||
- .gitignore | 2 ++
|
||||
- web/shl/README.md | 45 +++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/__tests__/Dialog.test.tsx | 38 ++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/__tests__/tokens.test.ts | 39 +++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/components/Dialog.tsx | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/components/FormElements.tsx | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/components/Shell.tsx | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/components/Table.tsx | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/components/Toast.tsx | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/i18n/i18n.tsx | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/index.ts | 25 +++++++++++++++++++++++++
|
||||
- web/shl/package.json | 23 +++++++++++++++++++++++
|
||||
- web/shl/theme/ThemeProvider.tsx | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/tokens/tokens.ts | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/tsconfig.json | 18 ++++++++++++++++++
|
||||
|
||||
---
|
||||
## 2026-08-28 21:51 – 21:57 (5m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** nexarch
|
||||
|
||||
### Commits
|
||||
- 3c226da SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)
|
||||
|
||||
### Geänderte Dateien
|
||||
- web/shl/package.json | 2 ++
|
||||
- web/shl/vitest.config.ts | 8 ++++++++
|
||||
- web/shl/vitest.setup.ts | 1 +
|
||||
|
||||
---
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
version: "2"
|
||||
|
||||
run:
|
||||
timeout: 3m
|
||||
|
||||
linters:
|
||||
default: none
|
||||
enable:
|
||||
- govet
|
||||
- staticcheck
|
||||
- errcheck
|
||||
- unused
|
||||
- ineffassign
|
||||
|
||||
formatters:
|
||||
enable:
|
||||
- gofmt
|
||||
- goimports
|
||||
@@ -1,31 +0,0 @@
|
||||
.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
|
||||
@@ -1,52 +0,0 @@
|
||||
# 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.
|
||||
@@ -1,30 +0,0 @@
|
||||
// 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)
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
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())
|
||||
}
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
// 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.
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
# 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.
|
||||
@@ -1,71 +0,0 @@
|
||||
# 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.
|
||||
@@ -1,84 +0,0 @@
|
||||
# FDN-03 – Prüfprotokoll: Objekt-Storage-Abstraktion
|
||||
|
||||
Welle 2. Voraussetzung: FDN-01 (Status "Fertig"), Core LIC-05 (Status
|
||||
"Fertig").
|
||||
|
||||
## Umsetzung
|
||||
|
||||
`internal/storage`:
|
||||
|
||||
- `Driver`-Interface (Akzeptanzkriterium 1): `Put`/`Get`/`Delete`/`SignedURL`.
|
||||
- `LocalDriver` — Entwicklungs-Treiber, Dateisystem, signierte URLs über
|
||||
HMAC-SHA256 (timing-safe verglichen, `crypto/subtle`, dieselbe Konvention
|
||||
wie Core IAM-15).
|
||||
- `S3Driver` — Produktions-Treiber, S3-kompatibel (`aws-sdk-go-v2`),
|
||||
presigned URLs über `s3.PresignClient`.
|
||||
- `ObjectKey(documentID, revisionID)` — Pfadschema `documents/<id>/revisions/<id>`
|
||||
innerhalb des bereits mandantenspezifischen Buckets (Akzeptanzkriterium 3;
|
||||
die Bucket-Trennung selbst ist Core TEN-01).
|
||||
- `Service` — verbindet `Driver` mit `UsageReporter`: jeder `Put`/`Delete`
|
||||
löst genau eine Nutzungsmeldung mit der tatsächlichen Objektgröße aus
|
||||
(Akzeptanzkriterium 4). Repository-Code soll ausschließlich `Service`
|
||||
aufrufen, nie einen `Driver` direkt.
|
||||
- `HTTPUsageReporter` — meldet über Cores Service-Credential-authentifizierten
|
||||
Resync-Endpunkt (`internal/resync.Handler.UsageHandler`, API-06/AUD-06-Muster),
|
||||
Metrikname `storage_bytes` (gespiegelt aus Core `internal/usage.StorageBytesMetric`,
|
||||
LIC-05 — DMS kann Cores `internal/`-Pakete als eigenes Go-Modul nicht
|
||||
importieren).
|
||||
|
||||
## Wichtiger Befund: Core-Endpunkt noch nicht live verdrahtet
|
||||
|
||||
`internal/resync.Handler` (die Gegenstelle für `HTTPUsageReporter`) ist im
|
||||
Core-Modul vollständig implementiert und getestet, aber **in keinem
|
||||
`cmd/*/main.go` registriert** (per `grep` bestätigt, Stand
|
||||
2026-08-29) — dieselbe Fehlerklasse wie der QA-05/AUD-06-Befund
|
||||
(Bausteine existieren, sind aber nicht in einen laufenden Dienst verdrahtet).
|
||||
`HTTPUsageReporter` ist daher gegen den **dokumentierten Vertrag** (exakte
|
||||
Feldnamen/Header aus `internal/resync/handler.go` gelesen) getestet, nicht
|
||||
gegen eine echte laufende Core-Instanz. Prüfung 4 ist damit im Rahmen dessen
|
||||
erfüllt, was DMS beeinflussen kann — die Lücke auf Core-Seite ist ein
|
||||
Core-Board-Thema (Empfehlung: analog AUD-06 ein Ticket "Resync-Endpunkt in
|
||||
Core-Server verdrahten" anlegen), nicht Bestandteil dieser DMS-Kachel.
|
||||
|
||||
## Prüfungen
|
||||
|
||||
| # | Prüfung | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Round-Trip-Test Upload/Download je Treiber | **bestanden** — `TestLocalDriver_RoundTrip` (Dateisystem) und `TestS3Driver_RoundTrip` (echtes MinIO auf 192.168.1.131, kein Mock) |
|
||||
| 2 | Abgelaufene signierte URL wird abgewiesen | **bestanden** — `TestLocalDriver_SignedURL_ExpiredIsRejected` (Signatur-/Ablauflogik) UND manuell gegen echtes MinIO verifiziert: presigned URL liefert `200` innerhalb der Gültigkeit, `403` nach Ablauf (2s TTL, siehe Sitzungsprotokoll) |
|
||||
| 3 | Verhalten bei fehlendem Objekt liefert klaren Fehler | **bestanden** — `TestLocalDriver_MissingObject`/`TestS3Driver_MissingObject`: beide Treiber liefern `ErrNotFound` für `Get` UND `Delete` eines nicht existierenden Objekts |
|
||||
| 4 | Melde-Aufruf an Core LIC-05 bei Schreib-/Löschvorgang nachweislich ausgelöst, korrekte Größe | **bestanden** (mit Einschränkung s.o.) — `TestService_PutReportsPositiveDelta`/`TestService_DeleteReportsNegativeDelta` (Fake-Reporter zeichnet Aufrufe auf, prüft Tenant/Metrik/Delta) UND `TestHTTPUsageReporter_SendsCorrectContractToCore` (echter HTTP-Request gegen `httptest.Server`, der Cores Vertrag nachbildet — Header, JSON-Feldnamen) |
|
||||
|
||||
## Build/Test-Ergebnis (192.168.1.131)
|
||||
|
||||
```
|
||||
go build ./... -> clean
|
||||
go vet ./... -> clean
|
||||
make lint -> clean (golangci-lint v2.1.6, aus Quelle mit go1.24.4 gebaut,
|
||||
da v1.63.4 den Zielstand go1.24 nicht linten konnte —
|
||||
.golangci.yml auf v2-Konfigurationsformat migriert)
|
||||
go test ./internal/storage/... -v -count=1 -> 11/11 Tests ok (3 S3-Tests real
|
||||
gegen lokal installiertes MinIO statt uebersprungen)
|
||||
```
|
||||
|
||||
## Offener Punkt: Prüfsummen-Schreibpfad noch nicht befüllt
|
||||
|
||||
`file_revisions.checksum_sha256` (FDN-02) wird aktuell von **keinem**
|
||||
Schreibpfad befüllt oder verifiziert — `internal/storage.Service.Put`
|
||||
berechnet keine Inhalts-Prüfsumme (das einzige SHA256 im Paket ist die
|
||||
HMAC-Signatur lokaler URLs, siehe oben, unabhängig vom Dateiinhalt). Die
|
||||
Spalte existiert seit FDN-02 ungenutzt. Nachgetragen als
|
||||
Akzeptanzkriterium/Prüfung in `DOC-01` (Upload-API), das den Hash auf
|
||||
Klartext berechnen und transaktional persistieren muss — Voraussetzung für
|
||||
Duplikaterkennung (`DOC-02`) und die spätere Integritätsprüfung
|
||||
(Archive `BAK-08`, siehe Sitzungsprotokoll 2026-08-29 zu externem,
|
||||
selbst nicht überwachtem Kunden-S3-Storage).
|
||||
|
||||
## Gesamtergebnis
|
||||
|
||||
**Bestanden**, mit einer dokumentierten Abhängigkeit auf Core-Seite
|
||||
(Abschnitt "Wichtiger Befund") — Core muss `internal/resync.Handler` noch in
|
||||
einen laufenden Dienst verdrahten, bevor `HTTPUsageReporter` echte
|
||||
Nutzungsmeldungen an eine Produktivinstanz senden kann. Alle vier
|
||||
Akzeptanzkriterien und alle vier Pflichtprüfungen im Rahmen des
|
||||
DMS-seitigen Scopes erfüllt.
|
||||
-36
@@ -1,36 +0,0 @@
|
||||
module gitea.perlbach24.de/scripte/nexarch/dms
|
||||
|
||||
go 1.24
|
||||
|
||||
toolchain go1.24.4
|
||||
|
||||
require (
|
||||
github.com/aws/aws-sdk-go-v2 v1.45.1
|
||||
github.com/aws/aws-sdk-go-v2/config v1.33.1
|
||||
github.com/aws/aws-sdk-go-v2/credentials v1.20.1
|
||||
github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1
|
||||
github.com/aws/smithy-go v1.28.1
|
||||
github.com/jackc/pgx/v5 v5.6.0
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/service/signin v1.7.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/service/sso v1.35.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/service/sts v1.47.1 // indirect
|
||||
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
|
||||
)
|
||||
-64
@@ -1,64 +0,0 @@
|
||||
github.com/aws/aws-sdk-go-v2 v1.45.1 h1:iIoG3NaLhV6UZpPXyPXlDj2I9oS8tV/nMcMnITCC6Ks=
|
||||
github.com/aws/aws-sdk-go-v2 v1.45.1/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU=
|
||||
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20 h1:GPRlPwz40I2B2VrBEASOA3Bi77NyeqejNLkifosX0rs=
|
||||
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20/go.mod h1:g7PNzKcsOKWb4fkSRBA7BZVAS6Y8IcxzN+nRohhQ1Q8=
|
||||
github.com/aws/aws-sdk-go-v2/config v1.33.1 h1:bq9jze1hQ5YTCLoVxNnbp0T7rglrlOE7N9YsHqjGkEw=
|
||||
github.com/aws/aws-sdk-go-v2/config v1.33.1/go.mod h1:2A3HQwG4zaL5Tm80rc6RZj8LmWWv4WYT5v8raSz/L7A=
|
||||
github.com/aws/aws-sdk-go-v2/credentials v1.20.1 h1:Z8GRNEx0u9sDkZOq4PUnN8mjGwbUQGRzMSXpvt3d8xQ=
|
||||
github.com/aws/aws-sdk-go-v2/credentials v1.20.1/go.mod h1:uBIK00kFo95dnemqfFMTWx0X8YRqsh6ecIoCjjOkZqM=
|
||||
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1 h1:YIEBqcqRnpi4Pfv0YHImtgi6czGCwKHANC7SwmUAVD0=
|
||||
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1/go.mod h1:imEf0oufgAo8KAkCHhrOdqGEC0YWx1PPBQH82shSxGw=
|
||||
github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1 h1:pc138gM1CW+XPc60rEwUlwwuwWFQK16CI1T7v1F9Oec=
|
||||
github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1/go.mod h1:1+koxpPIbfBdfzP6vojm5/zTpTQ/micYwlxIiNB3TxI=
|
||||
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1 h1:K0JsbZQj+1h208Ro1zHeA4l7bMp0NvRffHQ91q8Ol1s=
|
||||
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1/go.mod h1:W3/vL6EtCIatICGy9ab29QhMuae+cOKPWcMxv02CO+Q=
|
||||
github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1 h1:yhw5KD1phVyP9vijxOUzDfEtJx+bt+L63k+VfuiYFAA=
|
||||
github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1/go.mod h1:ZW2e0d7DYlRxlS9hEiMXE47gTdX5KRN4byUiNbUpG+Q=
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg=
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19/go.mod h1:KaUzbLxv4CeSxh6ZCl9B4m7CuFenS8kUEaDs+f/DQr4=
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1 h1:s67hBfG5t9rn1NCvDuB4E3QIep3UFhHPtaIqFDjV3N8=
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1/go.mod h1:FpvjBMXtSNMLPmDJsWwcY5cRnqJlpS2y1R6n4pvzs4k=
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1 h1:RmmWQPREQdk9U+PfqeHW3MqZaBaNK7TpV9W3RY+b+7g=
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1/go.mod h1:0A3W4F+68ZnNk5XcNL/e9HFMwnP8RlEicFfy6eOEDyw=
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1 h1:ZMbtPZZQRca+3+XYQne9PBvRiYpHZlNJJOZfE9WNfT0=
|
||||
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1/go.mod h1:YAGWQdCYlVCoqrzvfv3RLxO6zKwti7gsAULOGWPLYv4=
|
||||
github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1 h1:kVpzaDBzOdRtOftmiSpTdQbWVqRg0kONLXijktiwXnk=
|
||||
github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1/go.mod h1:CUr46sCpGAg/rHaclRyhJX0LJAmH73uWSJPPSaMUrSk=
|
||||
github.com/aws/aws-sdk-go-v2/service/signin v1.7.1 h1:mdMtSVKdQ3+mzBh+l0ogrFYZVQUCg6pJZOirA2ARsYE=
|
||||
github.com/aws/aws-sdk-go-v2/service/signin v1.7.1/go.mod h1:9IqUlsJDbUPcg6cgx3WEzXdjrbWzLDQrak0aaSqlTcI=
|
||||
github.com/aws/aws-sdk-go-v2/service/sso v1.35.1 h1:B6WFn91tobD6gG4724ONHaqrpKsoETGnv98LHe/yIGM=
|
||||
github.com/aws/aws-sdk-go-v2/service/sso v1.35.1/go.mod h1:tWuiVBUtPBr8/rgRiYS8Uf85sHcAN+G7XS3D3CEoUh8=
|
||||
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1 h1:6yeYCWFvgbI2TI3K6jr9LtBNhXgJ7g4xqD+DEiaDDmM=
|
||||
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1/go.mod h1:naFe83jSMuYkH+QjQPX8n1MLhBkeCFM5Lsnh5m5wz3c=
|
||||
github.com/aws/aws-sdk-go-v2/service/sts v1.47.1 h1:Sv2xPnRHlThSUtVujYuUBPI/Il8si6UPHXL8DMiB/F0=
|
||||
github.com/aws/aws-sdk-go-v2/service/sts v1.47.1/go.mod h1:mKo/CzaCz8qytGW70NG4vIIGAx1HXTlb5lHNkC5k3lk=
|
||||
github.com/aws/smithy-go v1.28.1 h1:R/nXH00c8qcfCzQVELtRw+eLQWtzv+VAIEFJ1/xxXlQ=
|
||||
github.com/aws/smithy-go v1.28.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
|
||||
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
|
||||
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
|
||||
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
|
||||
github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
|
||||
github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
|
||||
github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
|
||||
github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
|
||||
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
|
||||
golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
|
||||
golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
|
||||
golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
|
||||
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
|
||||
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
@@ -1,165 +0,0 @@
|
||||
// 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
|
||||
}
|
||||
@@ -1,204 +0,0 @@
|
||||
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")
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
// 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"
|
||||
@@ -1,45 +0,0 @@
|
||||
// Package storage implementiert FDN-03: eine einheitliche Objekt-Storage-
|
||||
// Abstraktion mit zwei austauschbaren Treibern (lokal fuer Entwicklung,
|
||||
// S3-kompatibel fuer Produktion). Verschluesselung at rest ist NICHT
|
||||
// Bestandteil dieser Kachel (siehe FDN-09) — dieses Paket legt Bytes
|
||||
// unveraendert ab.
|
||||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ErrNotFound wird geliefert, wenn ein angefragtes Objekt nicht existiert
|
||||
// (Akzeptanzkriterium/Pruefung 3: klarer Fehler statt treiberspezifischer
|
||||
// Fehlertypen, die der Aufrufer sonst je Treiber unterschiedlich behandeln
|
||||
// muesste).
|
||||
var ErrNotFound = errors.New("storage: objekt nicht gefunden")
|
||||
|
||||
// Driver ist die EINE Schnittstelle, gegen die der Rest von DMS arbeitet
|
||||
// (Akzeptanzkriterium 1). Zwei Implementierungen: LocalDriver (Entwicklung)
|
||||
// und S3Driver (Produktion, S3-kompatibel).
|
||||
type Driver interface {
|
||||
// Put legt die Bytes aus r unter key ab und liefert die tatsaechlich
|
||||
// geschriebene Groesse in Bytes.
|
||||
Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) (int64, error)
|
||||
// Get liefert die Bytes unter key. Existiert key nicht, liefert Get
|
||||
// ErrNotFound.
|
||||
Get(ctx context.Context, key string) (io.ReadCloser, error)
|
||||
// Delete entfernt das Objekt unter key. Existiert key nicht, liefert
|
||||
// Delete ErrNotFound.
|
||||
Delete(ctx context.Context, key string) error
|
||||
// SignedURL liefert eine zeitlich begrenzte, signierte URL zum Lesen des
|
||||
// Objekts (Akzeptanzkriterium 2: konfigurierbare Gueltigkeit ueber ttl).
|
||||
SignedURL(ctx context.Context, key string, ttl time.Duration) (string, error)
|
||||
}
|
||||
|
||||
// ObjectKey liefert das Pfadschema fuer ein Dokument/Revision INNERHALB des
|
||||
// Mandanten-Buckets (Akzeptanzkriterium 3) — die Bucket-Trennung selbst ist
|
||||
// Sache von Core TEN-01, hier geht es nur um den Pfad innerhalb eines
|
||||
// bereits mandantenspezifischen Buckets.
|
||||
func ObjectKey(documentID, revisionID string) string {
|
||||
return "documents/" + documentID + "/revisions/" + revisionID
|
||||
}
|
||||
@@ -1,113 +0,0 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/hmac"
|
||||
"crypto/sha256"
|
||||
"crypto/subtle"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ErrURLExpired wird von VerifySignedURL geliefert, wenn eine signierte URL
|
||||
// nach Ablauf ihrer Gueltigkeit verwendet wird (Pruefung 2).
|
||||
var ErrURLExpired = errors.New("storage: signierte url ist abgelaufen")
|
||||
|
||||
// ErrInvalidSignature wird geliefert, wenn die Signatur einer URL nicht zum
|
||||
// Schluessel passt (manipulierte oder falsche URL).
|
||||
var ErrInvalidSignature = errors.New("storage: signatur der url ist ungueltig")
|
||||
|
||||
// LocalDriver legt Objekte im lokalen Dateisystem ab — der Entwicklungs-
|
||||
// Treiber (Akzeptanzkriterium 1), keine externe Abhaengigkeit noetig.
|
||||
type LocalDriver struct {
|
||||
baseDir string
|
||||
signingSecret []byte
|
||||
publicBaseURL string
|
||||
}
|
||||
|
||||
// NewLocalDriver erzeugt einen LocalDriver. signingSecret authentifiziert
|
||||
// die von SignedURL ausgestellten URLs (HMAC-SHA256, konstant-zeit-
|
||||
// verglichen bei der Verifikation — timing-safe wie projektweite Konvention,
|
||||
// siehe Core IAM-15).
|
||||
func NewLocalDriver(baseDir string, signingSecret []byte, publicBaseURL string) *LocalDriver {
|
||||
return &LocalDriver{baseDir: baseDir, signingSecret: signingSecret, publicBaseURL: publicBaseURL}
|
||||
}
|
||||
|
||||
func (d *LocalDriver) path(key string) string {
|
||||
return filepath.Join(d.baseDir, filepath.FromSlash(key))
|
||||
}
|
||||
|
||||
func (d *LocalDriver) Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) (int64, error) {
|
||||
full := d.path(key)
|
||||
if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
|
||||
return 0, fmt.Errorf("storage: verzeichnis anlegen: %w", err)
|
||||
}
|
||||
f, err := os.Create(full)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("storage: datei anlegen: %w", err)
|
||||
}
|
||||
defer func() { _ = f.Close() }()
|
||||
|
||||
written, err := io.Copy(f, r)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("storage: schreiben: %w", err)
|
||||
}
|
||||
return written, nil
|
||||
}
|
||||
|
||||
func (d *LocalDriver) Get(ctx context.Context, key string) (io.ReadCloser, error) {
|
||||
f, err := os.Open(d.path(key))
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return nil, fmt.Errorf("storage: lesen: %w", err)
|
||||
}
|
||||
return f, nil
|
||||
}
|
||||
|
||||
func (d *LocalDriver) Delete(ctx context.Context, key string) error {
|
||||
if err := os.Remove(d.path(key)); err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return ErrNotFound
|
||||
}
|
||||
return fmt.Errorf("storage: loeschen: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *LocalDriver) SignedURL(ctx context.Context, key string, ttl time.Duration) (string, error) {
|
||||
expiry := time.Now().Add(ttl).Unix()
|
||||
sig := d.sign(key, expiry)
|
||||
return fmt.Sprintf("%s/%s?exp=%d&sig=%s", strings.TrimRight(d.publicBaseURL, "/"), key, expiry, sig), nil
|
||||
}
|
||||
|
||||
func (d *LocalDriver) sign(key string, expiry int64) string {
|
||||
mac := hmac.New(sha256.New, d.signingSecret)
|
||||
mac.Write([]byte(key))
|
||||
mac.Write([]byte(strconv.FormatInt(expiry, 10)))
|
||||
return base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
|
||||
}
|
||||
|
||||
// VerifySignedURL prueft key/expiry/sig, wie sie z.B. aus den Query-
|
||||
// Parametern einer von SignedURL ausgestellten URL stammen (Pruefung 2:
|
||||
// abgelaufene URL wird abgewiesen). Die eigentliche HTTP-Auslieferung ist
|
||||
// nicht Bestandteil dieser Kachel (siehe DOC-01) — hier wird nur die
|
||||
// Signatur-/Ablauflogik bereitgestellt und getestet.
|
||||
func (d *LocalDriver) VerifySignedURL(key string, expiry int64, sig string) error {
|
||||
expected := d.sign(key, expiry)
|
||||
if subtle.ConstantTimeCompare([]byte(expected), []byte(sig)) != 1 {
|
||||
return ErrInvalidSignature
|
||||
}
|
||||
if time.Now().Unix() > expiry {
|
||||
return ErrURLExpired
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -1,108 +0,0 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func newTestLocalDriver(t *testing.T) *LocalDriver {
|
||||
t.Helper()
|
||||
return NewLocalDriver(t.TempDir(), []byte("test-signing-secret"), "https://files.example.test")
|
||||
}
|
||||
|
||||
// TestLocalDriver_RoundTrip ist Pruefung 1 fuer den lokalen Treiber:
|
||||
// Upload/Download-Roundtrip.
|
||||
func TestLocalDriver_RoundTrip(t *testing.T) {
|
||||
d := newTestLocalDriver(t)
|
||||
ctx := context.Background()
|
||||
key := "documents/doc-1/revisions/rev-1"
|
||||
content := []byte("hallo welt")
|
||||
|
||||
written, err := d.Put(ctx, key, bytes.NewReader(content), int64(len(content)), "text/plain")
|
||||
if err != nil {
|
||||
t.Fatalf("put: %v", err)
|
||||
}
|
||||
if written != int64(len(content)) {
|
||||
t.Fatalf("geschriebene groesse = %d, want %d", written, len(content))
|
||||
}
|
||||
|
||||
rc, err := d.Get(ctx, key)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = rc.Close() }()
|
||||
got, err := io.ReadAll(rc)
|
||||
if err != nil {
|
||||
t.Fatalf("lesen: %v", err)
|
||||
}
|
||||
if !bytes.Equal(got, content) {
|
||||
t.Fatalf("gelesener inhalt = %q, want %q", got, content)
|
||||
}
|
||||
}
|
||||
|
||||
// TestLocalDriver_MissingObject ist Pruefung 3: klarer Fehler bei
|
||||
// fehlendem Objekt, sowohl fuer Get als auch Delete.
|
||||
func TestLocalDriver_MissingObject(t *testing.T) {
|
||||
d := newTestLocalDriver(t)
|
||||
ctx := context.Background()
|
||||
|
||||
if _, err := d.Get(ctx, "nie-angelegt"); !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("get eines fehlenden objekts: erwartet ErrNotFound, habe %v", err)
|
||||
}
|
||||
if err := d.Delete(ctx, "nie-angelegt"); !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("delete eines fehlenden objekts: erwartet ErrNotFound, habe %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestLocalDriver_SignedURL_ExpiredIsRejected ist Pruefung 2: eine
|
||||
// abgelaufene signierte URL wird abgewiesen.
|
||||
func TestLocalDriver_SignedURL_ExpiredIsRejected(t *testing.T) {
|
||||
d := newTestLocalDriver(t)
|
||||
ctx := context.Background()
|
||||
key := "documents/doc-2/revisions/rev-1"
|
||||
|
||||
// Gueltige, noch nicht abgelaufene URL wird akzeptiert.
|
||||
urlValid, err := d.SignedURL(ctx, key, time.Hour)
|
||||
if err != nil {
|
||||
t.Fatalf("signedurl (gueltig): %v", err)
|
||||
}
|
||||
expiry, sig := parseSignedURLQuery(t, urlValid)
|
||||
if err := d.VerifySignedURL(key, expiry, sig); err != nil {
|
||||
t.Fatalf("gueltige url wurde abgewiesen: %v", err)
|
||||
}
|
||||
|
||||
// Bereits abgelaufene URL (negative TTL) wird abgewiesen.
|
||||
urlExpired, err := d.SignedURL(ctx, key, -time.Hour)
|
||||
if err != nil {
|
||||
t.Fatalf("signedurl (abgelaufen): %v", err)
|
||||
}
|
||||
expiredExpiry, expiredSig := parseSignedURLQuery(t, urlExpired)
|
||||
if err := d.VerifySignedURL(key, expiredExpiry, expiredSig); !errors.Is(err, ErrURLExpired) {
|
||||
t.Fatalf("abgelaufene url: erwartet ErrURLExpired, habe %v", err)
|
||||
}
|
||||
|
||||
// Manipulierte Signatur wird abgewiesen.
|
||||
if err := d.VerifySignedURL(key, expiry, "manipuliert"); !errors.Is(err, ErrInvalidSignature) {
|
||||
t.Fatalf("manipulierte signatur: erwartet ErrInvalidSignature, habe %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func parseSignedURLQuery(t *testing.T, rawURL string) (expiry int64, sig string) {
|
||||
t.Helper()
|
||||
parsed, err := url.Parse(rawURL)
|
||||
if err != nil {
|
||||
t.Fatalf("signierte url parsen: %v (%s)", err, rawURL)
|
||||
}
|
||||
q := parsed.Query()
|
||||
expInt, err := strconv.ParseInt(q.Get("exp"), 10, 64)
|
||||
if err != nil {
|
||||
t.Fatalf("exp parsen: %v", err)
|
||||
}
|
||||
return expInt, q.Get("sig")
|
||||
}
|
||||
@@ -1,135 +0,0 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"time"
|
||||
|
||||
"github.com/aws/aws-sdk-go-v2/aws"
|
||||
"github.com/aws/aws-sdk-go-v2/config"
|
||||
"github.com/aws/aws-sdk-go-v2/credentials"
|
||||
"github.com/aws/aws-sdk-go-v2/service/s3"
|
||||
"github.com/aws/aws-sdk-go-v2/service/s3/types"
|
||||
"github.com/aws/smithy-go"
|
||||
)
|
||||
|
||||
// S3Driver legt Objekte in einem S3-kompatiblen Objektspeicher ab — der
|
||||
// Produktions-Treiber (Akzeptanzkriterium 1). Funktioniert gegen echtes
|
||||
// AWS S3 UND gegen jeden S3-kompatiblen Anbieter (MinIO etc.) ueber
|
||||
// endpointURL — bewusst offenes Objektformat statt Herstellerbindung
|
||||
// (Produkt-DNA: "jederzeit ohne Herstellerwerkzeug lesbar").
|
||||
type S3Driver struct {
|
||||
client *s3.Client
|
||||
bucket string
|
||||
}
|
||||
|
||||
// NewS3Driver verbindet zu einem S3-kompatiblen Endpunkt. endpointURL leer
|
||||
// laesst den AWS-SDK-Standardendpunkt (echtes AWS S3) gelten,
|
||||
// usePathStyle=true ist fuer die meisten Nicht-AWS-S3-kompatiblen Anbieter
|
||||
// (MinIO, etc.) noetig.
|
||||
func NewS3Driver(ctx context.Context, bucket, region, endpointURL, accessKeyID, secretAccessKey string, usePathStyle bool) (*S3Driver, error) {
|
||||
cfg, err := config.LoadDefaultConfig(ctx,
|
||||
config.WithRegion(region),
|
||||
config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, "")),
|
||||
)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("storage: s3-konfiguration laden: %w", err)
|
||||
}
|
||||
|
||||
client := s3.NewFromConfig(cfg, func(o *s3.Options) {
|
||||
if endpointURL != "" {
|
||||
o.BaseEndpoint = aws.String(endpointURL)
|
||||
}
|
||||
o.UsePathStyle = usePathStyle
|
||||
})
|
||||
return &S3Driver{client: client, bucket: bucket}, nil
|
||||
}
|
||||
|
||||
func (d *S3Driver) Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) (int64, error) {
|
||||
buf, err := io.ReadAll(r)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("storage: objekt vor upload lesen: %w", err)
|
||||
}
|
||||
_, err = d.client.PutObject(ctx, &s3.PutObjectInput{
|
||||
Bucket: aws.String(d.bucket),
|
||||
Key: aws.String(key),
|
||||
Body: bytesReader(buf),
|
||||
ContentLength: aws.Int64(int64(len(buf))),
|
||||
ContentType: aws.String(contentType),
|
||||
})
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("storage: s3-upload: %w", err)
|
||||
}
|
||||
return int64(len(buf)), nil
|
||||
}
|
||||
|
||||
func (d *S3Driver) Get(ctx context.Context, key string) (io.ReadCloser, error) {
|
||||
out, err := d.client.GetObject(ctx, &s3.GetObjectInput{
|
||||
Bucket: aws.String(d.bucket),
|
||||
Key: aws.String(key),
|
||||
})
|
||||
if err != nil {
|
||||
if isS3NotFound(err) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return nil, fmt.Errorf("storage: s3-download: %w", err)
|
||||
}
|
||||
return out.Body, nil
|
||||
}
|
||||
|
||||
func (d *S3Driver) Delete(ctx context.Context, key string) error {
|
||||
// S3 liefert bei DeleteObject fuer ein nicht existierendes Objekt KEINEN
|
||||
// Fehler (idempotente Semantik der S3-API) — um denselben Vertrag wie
|
||||
// LocalDriver (ErrNotFound bei fehlendem Objekt) zu erfuellen, wird die
|
||||
// Existenz vorher explizit geprueft (Pruefung 3).
|
||||
_, err := d.client.HeadObject(ctx, &s3.HeadObjectInput{Bucket: aws.String(d.bucket), Key: aws.String(key)})
|
||||
if err != nil {
|
||||
if isS3NotFound(err) {
|
||||
return ErrNotFound
|
||||
}
|
||||
return fmt.Errorf("storage: s3-existenzpruefung vor loeschen: %w", err)
|
||||
}
|
||||
|
||||
if _, err := d.client.DeleteObject(ctx, &s3.DeleteObjectInput{
|
||||
Bucket: aws.String(d.bucket),
|
||||
Key: aws.String(key),
|
||||
}); err != nil {
|
||||
return fmt.Errorf("storage: s3-loeschen: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *S3Driver) SignedURL(ctx context.Context, key string, ttl time.Duration) (string, error) {
|
||||
presignClient := s3.NewPresignClient(d.client)
|
||||
req, err := presignClient.PresignGetObject(ctx, &s3.GetObjectInput{
|
||||
Bucket: aws.String(d.bucket),
|
||||
Key: aws.String(key),
|
||||
}, s3.WithPresignExpires(ttl))
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("storage: presigned url erzeugen: %w", err)
|
||||
}
|
||||
return req.URL, nil
|
||||
}
|
||||
|
||||
func bytesReader(b []byte) *bytes.Reader {
|
||||
return bytes.NewReader(b)
|
||||
}
|
||||
|
||||
// isS3NotFound erkennt sowohl den typisierten NoSuchKey-Fehler
|
||||
// (GetObject) als auch den generischen "NotFound"-API-Fehlercode
|
||||
// (HeadObject liefert keinen typisierten NoSuchKey, sondern einen
|
||||
// generischen smithy-API-Fehler mit Code "NotFound").
|
||||
func isS3NotFound(err error) bool {
|
||||
var nsk *types.NoSuchKey
|
||||
if errors.As(err, &nsk) {
|
||||
return true
|
||||
}
|
||||
var apiErr smithy.APIError
|
||||
if errors.As(err, &apiErr) && apiErr.ErrorCode() == "NotFound" {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// requireS3TestEnv liefert die S3-Testkonfiguration oder ueberspringt den
|
||||
// Test — dasselbe Muster wie TEST_ADMIN_DSN im Core-Modul: kein S3-
|
||||
// kompatibler Speicher in dieser Umgebung verfuegbar/geprueft (siehe
|
||||
// FDN-03-Pruefprotokoll), daher hier bewusst als optional markiert statt
|
||||
// den Treiber ungetestet zu lassen.
|
||||
func requireS3TestEnv(t *testing.T) *S3Driver {
|
||||
t.Helper()
|
||||
bucket := os.Getenv("TEST_S3_BUCKET")
|
||||
if bucket == "" {
|
||||
t.Skip("TEST_S3_BUCKET nicht gesetzt, S3-Integrationstest uebersprungen")
|
||||
}
|
||||
endpoint := os.Getenv("TEST_S3_ENDPOINT")
|
||||
region := os.Getenv("TEST_S3_REGION")
|
||||
if region == "" {
|
||||
region = "us-east-1"
|
||||
}
|
||||
accessKey := os.Getenv("TEST_S3_ACCESS_KEY_ID")
|
||||
secretKey := os.Getenv("TEST_S3_SECRET_ACCESS_KEY")
|
||||
|
||||
d, err := NewS3Driver(context.Background(), bucket, region, endpoint, accessKey, secretKey, true)
|
||||
if err != nil {
|
||||
t.Fatalf("s3-treiber aufbauen: %v", err)
|
||||
}
|
||||
return d
|
||||
}
|
||||
|
||||
// TestS3Driver_RoundTrip ist Pruefung 1 fuer den S3-Treiber.
|
||||
func TestS3Driver_RoundTrip(t *testing.T) {
|
||||
d := requireS3TestEnv(t)
|
||||
ctx := context.Background()
|
||||
key := "fdn03-test/roundtrip"
|
||||
content := []byte("s3 roundtrip inhalt")
|
||||
|
||||
t.Cleanup(func() { _ = d.Delete(ctx, key) })
|
||||
|
||||
if _, err := d.Put(ctx, key, bytes.NewReader(content), int64(len(content)), "text/plain"); err != nil {
|
||||
t.Fatalf("put: %v", err)
|
||||
}
|
||||
rc, err := d.Get(ctx, key)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = rc.Close() }()
|
||||
got, err := io.ReadAll(rc)
|
||||
if err != nil {
|
||||
t.Fatalf("lesen: %v", err)
|
||||
}
|
||||
if !bytes.Equal(got, content) {
|
||||
t.Fatalf("gelesener inhalt = %q, want %q", got, content)
|
||||
}
|
||||
}
|
||||
|
||||
// TestS3Driver_MissingObject ist Pruefung 3 fuer den S3-Treiber.
|
||||
func TestS3Driver_MissingObject(t *testing.T) {
|
||||
d := requireS3TestEnv(t)
|
||||
ctx := context.Background()
|
||||
|
||||
if _, err := d.Get(ctx, "fdn03-test/nie-angelegt"); !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("get eines fehlenden objekts: erwartet ErrNotFound, habe %v", err)
|
||||
}
|
||||
if err := d.Delete(ctx, "fdn03-test/nie-angelegt"); !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("delete eines fehlenden objekts: erwartet ErrNotFound, habe %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestS3Driver_SignedURL ist Pruefung 2 fuer den S3-Treiber: eine
|
||||
// presigned URL wird erzeugt und ist innerhalb der Gueltigkeit abrufbar.
|
||||
func TestS3Driver_SignedURL(t *testing.T) {
|
||||
d := requireS3TestEnv(t)
|
||||
ctx := context.Background()
|
||||
key := "fdn03-test/signed-url"
|
||||
content := []byte("presigned")
|
||||
t.Cleanup(func() { _ = d.Delete(ctx, key) })
|
||||
|
||||
if _, err := d.Put(ctx, key, bytes.NewReader(content), int64(len(content)), "text/plain"); err != nil {
|
||||
t.Fatalf("put: %v", err)
|
||||
}
|
||||
|
||||
url, err := d.SignedURL(ctx, key, time.Minute)
|
||||
if err != nil {
|
||||
t.Fatalf("signedurl: %v", err)
|
||||
}
|
||||
if url == "" {
|
||||
t.Fatal("erwartet nicht-leere presigned url")
|
||||
}
|
||||
}
|
||||
@@ -1,59 +0,0 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Service verbindet einen Driver mit der Nutzungsmeldung an Core
|
||||
// (Akzeptanzkriterium 4) — jeder Schreib-/Loeschvorgang ueber Service loest
|
||||
// GENAU EINE Meldung mit der tatsaechlich geschriebenen/geloeschten
|
||||
// Objektgroesse aus. Repository-/Handler-Code (spaetere Kacheln, z.B.
|
||||
// DOC-01) ruft ausschliesslich Service auf, nie einen Driver direkt — das
|
||||
// verhindert einen Schreibpfad, der die Nutzungsmeldung vergisst.
|
||||
type Service struct {
|
||||
driver Driver
|
||||
usage UsageReporter
|
||||
tenantSlug string
|
||||
}
|
||||
|
||||
func NewService(driver Driver, usage UsageReporter, tenantSlug string) *Service {
|
||||
return &Service{driver: driver, usage: usage, tenantSlug: tenantSlug}
|
||||
}
|
||||
|
||||
// Put legt das Objekt ab und meldet die geschriebene Groesse als positives
|
||||
// Delta (Pruefung 4).
|
||||
func (s *Service) Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) (int64, error) {
|
||||
written, err := s.driver.Put(ctx, key, r, size, contentType)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if err := s.usage.Report(ctx, s.tenantSlug, UsageMetric, written); err != nil {
|
||||
return written, fmt.Errorf("storage: objekt gespeichert, aber nutzungsmeldung fehlgeschlagen: %w", err)
|
||||
}
|
||||
return written, nil
|
||||
}
|
||||
|
||||
func (s *Service) Get(ctx context.Context, key string) (io.ReadCloser, error) {
|
||||
return s.driver.Get(ctx, key)
|
||||
}
|
||||
|
||||
// Delete entfernt das Objekt und meldet dessen Groesse als negatives Delta
|
||||
// (Pruefung 4) — dafuer muss der Aufrufer die Groesse kennen (z.B. aus
|
||||
// file_revisions.size_bytes, FDN-02), da Delete selbst die Groesse eines
|
||||
// bereits geloeschten Objekts nicht mehr ermitteln kann.
|
||||
func (s *Service) Delete(ctx context.Context, key string, sizeBytes int64) error {
|
||||
if err := s.driver.Delete(ctx, key); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := s.usage.Report(ctx, s.tenantSlug, UsageMetric, -sizeBytes); err != nil {
|
||||
return fmt.Errorf("storage: objekt geloescht, aber nutzungsmeldung fehlgeschlagen: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) SignedURL(ctx context.Context, key string, ttl time.Duration) (string, error) {
|
||||
return s.driver.SignedURL(ctx, key, ttl)
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"sync"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// fakeUsageReporter zeichnet jeden Report-Aufruf auf, damit Tests
|
||||
// nachweisen koennen, dass Service tatsaechlich meldet (Akzeptanzkriterium
|
||||
// 4 / Pruefung 4) — ohne echten HTTP-Aufruf gegen Core.
|
||||
type fakeUsageReporter struct {
|
||||
mu sync.Mutex
|
||||
calls []reportCall
|
||||
failOn int // wenn >0, schlaegt der reportCall-te Aufruf fehl
|
||||
}
|
||||
|
||||
type reportCall struct {
|
||||
tenantSlug string
|
||||
metric string
|
||||
delta int64
|
||||
}
|
||||
|
||||
func (f *fakeUsageReporter) Report(ctx context.Context, tenantSlug, metric string, delta int64) error {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
f.calls = append(f.calls, reportCall{tenantSlug, metric, delta})
|
||||
if f.failOn > 0 && len(f.calls) == f.failOn {
|
||||
return context.DeadlineExceeded
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// TestService_PutReportsPositiveDelta ist Pruefung 4 (Schreibvorgang):
|
||||
// Melde-Aufruf an Core wird bei Put ausgeloest, mit korrekter Groesse.
|
||||
func TestService_PutReportsPositiveDelta(t *testing.T) {
|
||||
driver := NewLocalDriver(t.TempDir(), []byte("secret"), "https://files.example.test")
|
||||
usage := &fakeUsageReporter{}
|
||||
svc := NewService(driver, usage, "acme")
|
||||
|
||||
content := []byte("zwoelf bytes")
|
||||
if _, err := svc.Put(context.Background(), "documents/d1/revisions/r1", bytes.NewReader(content), int64(len(content)), "text/plain"); err != nil {
|
||||
t.Fatalf("put: %v", err)
|
||||
}
|
||||
|
||||
if len(usage.calls) != 1 {
|
||||
t.Fatalf("erwartet 1 nutzungsmeldung, habe %d", len(usage.calls))
|
||||
}
|
||||
call := usage.calls[0]
|
||||
if call.tenantSlug != "acme" || call.metric != UsageMetric || call.delta != int64(len(content)) {
|
||||
t.Fatalf("unerwarteter meldungsinhalt: %+v", call)
|
||||
}
|
||||
}
|
||||
|
||||
// TestService_DeleteReportsNegativeDelta ist Pruefung 4 (Loeschvorgang).
|
||||
func TestService_DeleteReportsNegativeDelta(t *testing.T) {
|
||||
driver := NewLocalDriver(t.TempDir(), []byte("secret"), "https://files.example.test")
|
||||
usage := &fakeUsageReporter{}
|
||||
svc := NewService(driver, usage, "acme")
|
||||
ctx := context.Background()
|
||||
key := "documents/d2/revisions/r1"
|
||||
|
||||
if _, err := svc.Put(ctx, key, bytes.NewReader([]byte("abc")), 3, "text/plain"); err != nil {
|
||||
t.Fatalf("put: %v", err)
|
||||
}
|
||||
if err := svc.Delete(ctx, key, 3); err != nil {
|
||||
t.Fatalf("delete: %v", err)
|
||||
}
|
||||
|
||||
if len(usage.calls) != 2 {
|
||||
t.Fatalf("erwartet 2 nutzungsmeldungen (put+delete), habe %d", len(usage.calls))
|
||||
}
|
||||
del := usage.calls[1]
|
||||
if del.delta != -3 {
|
||||
t.Fatalf("delete-delta = %d, want -3", del.delta)
|
||||
}
|
||||
}
|
||||
|
||||
// TestService_GetMissingObjectReturnsClearError ist Pruefung 3 auf
|
||||
// Service-Ebene.
|
||||
func TestService_GetMissingObjectReturnsClearError(t *testing.T) {
|
||||
driver := NewLocalDriver(t.TempDir(), []byte("secret"), "https://files.example.test")
|
||||
svc := NewService(driver, &fakeUsageReporter{}, "acme")
|
||||
|
||||
if _, err := svc.Get(context.Background(), "nie-angelegt"); err == nil {
|
||||
t.Fatal("get eines fehlenden objekts haette einen fehler liefern muessen")
|
||||
}
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
// UsageMetric ist der Metrikname, unter dem Core (internal/usage, LIC-05)
|
||||
// den Speicherverbrauch je Mandant fuehrt — muss exakt
|
||||
// internal/usage.StorageBytesMetric aus dem NEXARCH-Core-Modul entsprechen
|
||||
// (Core kann von DMS als eigenem Go-Modul nicht importiert werden, daher
|
||||
// hier als Konstante gespiegelt statt importiert).
|
||||
const UsageMetric = "storage_bytes"
|
||||
|
||||
// UsageReporter meldet Speicherverbrauchsaenderungen an Core (Akzeptanz-
|
||||
// kriterium 4). Schmale Schnittstelle, damit Tests einen Fake statt eines
|
||||
// echten HTTP-Aufrufs einsetzen koennen.
|
||||
type UsageReporter interface {
|
||||
Report(ctx context.Context, tenantSlug, metric string, delta int64) error
|
||||
}
|
||||
|
||||
// usageDeltaDTO entspricht Core internal/resync.usageDeltaDTO
|
||||
// (JSON-Vertrag: tenant_slug/metric/delta) — dieselbe Struktur, hier
|
||||
// gespiegelt, da DMS Cores internal/-Pakete nicht importieren kann.
|
||||
type usageDeltaDTO struct {
|
||||
TenantSlug string `json:"tenant_slug"`
|
||||
Metric string `json:"metric"`
|
||||
Delta int64 `json:"delta"`
|
||||
}
|
||||
|
||||
// HTTPUsageReporter meldet ueber Cores Resync-Nutzungs-Endpunkt
|
||||
// (internal/resync.Handler.UsageHandler, API-06), authentifiziert ueber
|
||||
// dasselbe Service-Credential-Verfahren wie jeder andere Modul-Core-Aufruf
|
||||
// (API-02).
|
||||
type HTTPUsageReporter struct {
|
||||
endpointURL string
|
||||
clientID string
|
||||
clientSecret string
|
||||
httpClient *http.Client
|
||||
}
|
||||
|
||||
func NewHTTPUsageReporter(endpointURL, clientID, clientSecret string, httpClient *http.Client) *HTTPUsageReporter {
|
||||
if httpClient == nil {
|
||||
httpClient = http.DefaultClient
|
||||
}
|
||||
return &HTTPUsageReporter{endpointURL: endpointURL, clientID: clientID, clientSecret: clientSecret, httpClient: httpClient}
|
||||
}
|
||||
|
||||
func (r *HTTPUsageReporter) Report(ctx context.Context, tenantSlug, metric string, delta int64) error {
|
||||
body, err := json.Marshal([]usageDeltaDTO{{TenantSlug: tenantSlug, Metric: metric, Delta: delta}})
|
||||
if err != nil {
|
||||
return fmt.Errorf("storage: nutzungsmeldung serialisieren: %w", err)
|
||||
}
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, r.endpointURL, bytes.NewReader(body))
|
||||
if err != nil {
|
||||
return fmt.Errorf("storage: nutzungsmeldungs-anfrage aufbauen: %w", err)
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.Header.Set("X-Nexarch-Client-Id", r.clientID)
|
||||
req.Header.Set("X-Nexarch-Client-Secret", r.clientSecret)
|
||||
|
||||
resp, err := r.httpClient.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("storage: nutzungsmeldung senden: %w", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return fmt.Errorf("storage: nutzungsmeldung von core abgelehnt: status %d", resp.StatusCode)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestHTTPUsageReporter_SendsCorrectContractToCore ist der Nachweis, dass
|
||||
// HTTPUsageReporter exakt den Vertrag von Core internal/resync.Handler.
|
||||
// UsageHandler bedient (Service-Credential-Header, JSON-Feldnamen) — echte
|
||||
// Vernetzung gegen einen laufenden Core-Prozess ist nicht Teil dieses
|
||||
// Tests (internal/resync.Handler ist in Core aktuell in keinem cmd/*/
|
||||
// main.go verdrahtet, siehe FDN-03-Pruefprotokoll), daher hier gegen einen
|
||||
// httptest-Server geprueft, der denselben Vertrag nachbildet.
|
||||
func TestHTTPUsageReporter_SendsCorrectContractToCore(t *testing.T) {
|
||||
var gotClientID, gotClientSecret string
|
||||
var gotBody []usageDeltaDTO
|
||||
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
gotClientID = r.Header.Get("X-Nexarch-Client-Id")
|
||||
gotClientSecret = r.Header.Get("X-Nexarch-Client-Secret")
|
||||
if err := json.NewDecoder(r.Body).Decode(&gotBody); err != nil {
|
||||
t.Errorf("anfrage-koerper dekodieren: %v", err)
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_ = json.NewEncoder(w).Encode(map[string]int{"applied": len(gotBody)})
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
reporter := NewHTTPUsageReporter(srv.URL, "dms-service-client", "dms-service-secret", nil)
|
||||
if err := reporter.Report(context.Background(), "acme", UsageMetric, 4096); err != nil {
|
||||
t.Fatalf("report: %v", err)
|
||||
}
|
||||
|
||||
if gotClientID != "dms-service-client" || gotClientSecret != "dms-service-secret" {
|
||||
t.Fatalf("service-credential-header falsch: id=%q secret=%q", gotClientID, gotClientSecret)
|
||||
}
|
||||
if len(gotBody) != 1 {
|
||||
t.Fatalf("erwartet 1 delta im koerper, habe %d", len(gotBody))
|
||||
}
|
||||
if gotBody[0].TenantSlug != "acme" || gotBody[0].Metric != UsageMetric || gotBody[0].Delta != 4096 {
|
||||
t.Fatalf("unerwarteter delta-inhalt: %+v", gotBody[0])
|
||||
}
|
||||
}
|
||||
|
||||
// TestHTTPUsageReporter_RejectsNonOKStatus prueft, dass ein von Core
|
||||
// abgelehnter Aufruf (z.B. ungueltiges Service-Credential) als Fehler
|
||||
// zurueckgegeben wird, statt stillschweigend zu verlieren.
|
||||
func TestHTTPUsageReporter_RejectsNonOKStatus(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
http.Error(w, "ungueltiges service-credential", http.StatusUnauthorized)
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
reporter := NewHTTPUsageReporter(srv.URL, "x", "y", nil)
|
||||
if err := reporter.Report(context.Background(), "acme", UsageMetric, 1); err == nil {
|
||||
t.Fatal("erwartet fehler bei abgelehnter nutzungsmeldung, habe nil")
|
||||
}
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
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;
|
||||
@@ -1,88 +0,0 @@
|
||||
-- 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);
|
||||
@@ -1,43 +0,0 @@
|
||||
-- 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 $$;
|
||||
@@ -0,0 +1,45 @@
|
||||
# @nexarch/shl — UI-Shell & Design-System (Core SHL-01)
|
||||
|
||||
Gemeinsames Paket für alle NEXARCH-Modul-Frontends (Core, DMS, Mail, Archive, Workflow, AI, Connect).
|
||||
Ein Modul-Frontend importiert ausschließlich über `index.ts`, kopiert keine Komponenten oder Tokens lokal.
|
||||
|
||||
## Enthält
|
||||
|
||||
- **Design-Tokens** (`tokens/tokens.ts`) — Farbe (Hell/Dunkel), Abstand, Typografie. Kontrastwerte gegen WCAG 2.1 AA geprüft (siehe `__tests__/tokens.test.ts`).
|
||||
- **Theming** (`theme/ThemeProvider.tsx`) — zentrale Hell/Dunkel-Umschaltung, respektiert `prefers-color-scheme`, persistiert in `localStorage`.
|
||||
- **i18n-Rahmen** (`i18n/i18n.tsx`) — Umschaltmechanismus Deutsch/Englisch. Modul-Frontends registrieren ihre fachlichen Textbausteine über `registerMessages()`, statt einen eigenen Mechanismus zu bauen.
|
||||
- **Basis-Komponenten** (`components/`) — `Shell` (Layout + Navigation), `Table`, `Dialog`, `TextField`/`SelectField`/`CheckboxField`, `Toast`. Alle mit WCAG-2.1-AA-Grundlage (Tastaturbedienung, ARIA-Attribute, Fokus-Management).
|
||||
|
||||
## Verwendung in einem Modul-Frontend
|
||||
|
||||
```tsx
|
||||
import { ThemeProvider, I18nProvider, ToastProvider, Shell } from "@nexarch/shl";
|
||||
|
||||
export default function RootLayout({ children }: { children: React.ReactNode }) {
|
||||
return (
|
||||
<ThemeProvider>
|
||||
<I18nProvider initialLocale="de">
|
||||
<ToastProvider>
|
||||
<Shell modules={[]} tenantLabel="Mandant XY">
|
||||
{children}
|
||||
</Shell>
|
||||
</ToastProvider>
|
||||
</I18nProvider>
|
||||
</ThemeProvider>
|
||||
);
|
||||
}
|
||||
```
|
||||
|
||||
## Bekannter offener Punkt
|
||||
|
||||
Die vier bereits gebauten Core-Frontends (`TEN-05`, `LIC-04`, `AUD-04`, `OPS-02`) sind vor diesem Paket entstanden und binden es noch nicht ein — Retrofit ist der nächste Schritt, siehe `nexarch-state.json`.
|
||||
|
||||
## Tests
|
||||
|
||||
Ausführung auf dem Test-Host (nicht lokal, siehe Projekt-Testinfrastruktur):
|
||||
|
||||
```bash
|
||||
npm install
|
||||
npm test
|
||||
npm run typecheck
|
||||
```
|
||||
@@ -0,0 +1,38 @@
|
||||
// Prüfung: Tastaturbedienung der Basis-Komponenten funktioniert (SHL-01 Prüfung 2).
|
||||
import { describe, expect, it, vi } from "vitest";
|
||||
import { fireEvent, render, screen } from "@testing-library/react";
|
||||
import { Dialog } from "../components/Dialog";
|
||||
import { I18nProvider } from "../i18n/i18n";
|
||||
|
||||
function renderDialog(onClose: () => void) {
|
||||
return render(
|
||||
<I18nProvider>
|
||||
<Dialog open titleId="test-title" title="Test-Dialog" onClose={onClose}>
|
||||
<button type="button">Erste Aktion</button>
|
||||
<button type="button">Zweite Aktion</button>
|
||||
</Dialog>
|
||||
</I18nProvider>,
|
||||
);
|
||||
}
|
||||
|
||||
describe("Dialog: Tastaturbedienung", () => {
|
||||
it("schließt sich bei ESC", () => {
|
||||
const onClose = vi.fn();
|
||||
renderDialog(onClose);
|
||||
fireEvent.keyDown(document, { key: "Escape" });
|
||||
expect(onClose).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it("setzt den Fokus beim Öffnen auf das erste fokussierbare Element", () => {
|
||||
renderDialog(vi.fn());
|
||||
const closeButton = screen.getByRole("button", { name: /schließen/i });
|
||||
expect(document.activeElement).toBe(closeButton);
|
||||
});
|
||||
|
||||
it("ist als modaler Dialog mit Titel-Referenz ausgezeichnet", () => {
|
||||
renderDialog(vi.fn());
|
||||
const dialog = screen.getByRole("dialog");
|
||||
expect(dialog).toHaveAttribute("aria-modal", "true");
|
||||
expect(dialog).toHaveAttribute("aria-labelledby", "test-title");
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,39 @@
|
||||
// Prüfung: Kontrastwerte erfüllen mindestens AA (SHL-01 Prüfung 3 / Akzeptanzkriterium 4).
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { colorTokens } from "../tokens/tokens";
|
||||
|
||||
// WCAG-2.1-AA-Kontrastberechnung (relative Luminanz, sRGB) — keine externe Abhängigkeit nötig.
|
||||
function relLuminance(hex: string): number {
|
||||
const rgb = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
|
||||
const [r, g, b] = rgb.map((c) => (c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
|
||||
return 0.2126 * r + 0.7152 * g + 0.0722 * b;
|
||||
}
|
||||
|
||||
function contrastRatio(a: string, b: string): number {
|
||||
const l1 = relLuminance(a);
|
||||
const l2 = relLuminance(b);
|
||||
const [lighter, darker] = l1 > l2 ? [l1, l2] : [l2, l1];
|
||||
return (lighter + 0.05) / (darker + 0.05);
|
||||
}
|
||||
|
||||
describe("Design-Tokens: WCAG 2.1 AA Kontrast", () => {
|
||||
for (const scheme of ["light", "dark"] as const) {
|
||||
const c = colorTokens[scheme];
|
||||
|
||||
it(`${scheme}: textPrimary auf background erfüllt AA (>= 4.5:1)`, () => {
|
||||
expect(contrastRatio(c.textPrimary, c.background)).toBeGreaterThanOrEqual(4.5);
|
||||
});
|
||||
|
||||
it(`${scheme}: textSecondary auf surface erfüllt AA (>= 4.5:1)`, () => {
|
||||
expect(contrastRatio(c.textSecondary, c.surface)).toBeGreaterThanOrEqual(4.5);
|
||||
});
|
||||
|
||||
it(`${scheme}: accentContrast auf accent erfüllt AA (>= 4.5:1)`, () => {
|
||||
expect(contrastRatio(c.accentContrast, c.accent)).toBeGreaterThanOrEqual(4.5);
|
||||
});
|
||||
|
||||
it(`${scheme}: dangerContrast auf danger erfüllt AA (>= 4.5:1)`, () => {
|
||||
expect(contrastRatio(c.dangerContrast, c.danger)).toBeGreaterThanOrEqual(4.5);
|
||||
});
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,88 @@
|
||||
"use client";
|
||||
|
||||
// Dialog-Basis-Komponente — SHL-01. WCAG 2.1 AA: Fokus-Falle, ESC schließt, Tastaturbedienung vollständig.
|
||||
|
||||
import { useEffect, useRef } from "react";
|
||||
import type { ReactNode } from "react";
|
||||
import { useI18n } from "../i18n/i18n";
|
||||
|
||||
const FOCUSABLE_SELECTOR =
|
||||
'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
|
||||
|
||||
export interface DialogProps {
|
||||
open: boolean;
|
||||
onClose: () => void;
|
||||
titleId: string;
|
||||
title: string;
|
||||
children: ReactNode;
|
||||
}
|
||||
|
||||
export function Dialog({ open, onClose, titleId, title, children }: DialogProps) {
|
||||
const { t } = useI18n();
|
||||
const dialogRef = useRef<HTMLDivElement>(null);
|
||||
const previouslyFocused = useRef<HTMLElement | null>(null);
|
||||
|
||||
useEffect(() => {
|
||||
if (!open) return;
|
||||
previouslyFocused.current = document.activeElement as HTMLElement | null;
|
||||
|
||||
const node = dialogRef.current;
|
||||
const focusables = node?.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR);
|
||||
focusables?.[0]?.focus();
|
||||
|
||||
function handleKeyDown(event: KeyboardEvent) {
|
||||
if (event.key === "Escape") {
|
||||
onClose();
|
||||
return;
|
||||
}
|
||||
if (event.key !== "Tab" || !node) return;
|
||||
|
||||
const items = Array.from(node.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR));
|
||||
if (items.length === 0) return;
|
||||
const first = items[0];
|
||||
const last = items[items.length - 1];
|
||||
|
||||
if (event.shiftKey && document.activeElement === first) {
|
||||
event.preventDefault();
|
||||
last.focus();
|
||||
} else if (!event.shiftKey && document.activeElement === last) {
|
||||
event.preventDefault();
|
||||
first.focus();
|
||||
}
|
||||
}
|
||||
|
||||
document.addEventListener("keydown", handleKeyDown);
|
||||
return () => {
|
||||
document.removeEventListener("keydown", handleKeyDown);
|
||||
previouslyFocused.current?.focus();
|
||||
};
|
||||
}, [open, onClose]);
|
||||
|
||||
if (!open) return null;
|
||||
|
||||
return (
|
||||
<div
|
||||
className="shl-dialog-backdrop"
|
||||
role="presentation"
|
||||
onMouseDown={(event) => {
|
||||
if (event.target === event.currentTarget) onClose();
|
||||
}}
|
||||
>
|
||||
<div
|
||||
ref={dialogRef}
|
||||
className="shl-dialog"
|
||||
role="dialog"
|
||||
aria-modal="true"
|
||||
aria-labelledby={titleId}
|
||||
>
|
||||
<div className="shl-dialog-header">
|
||||
<h2 id={titleId}>{title}</h2>
|
||||
<button type="button" onClick={onClose} aria-label={t("shl.dialog.close")}>
|
||||
×
|
||||
</button>
|
||||
</div>
|
||||
<div className="shl-dialog-body">{children}</div>
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
// Formularelemente-Basis-Komponenten — SHL-01. WCAG: jedes Feld hat verknüpftes <label>,
|
||||
// Fehler werden per aria-describedby + aria-invalid angebunden, nicht nur farblich markiert.
|
||||
|
||||
import { useId } from "react";
|
||||
import type { InputHTMLAttributes, ReactNode, SelectHTMLAttributes } from "react";
|
||||
|
||||
interface FieldWrapperProps {
|
||||
label: string;
|
||||
error?: string;
|
||||
hint?: string;
|
||||
children: (ids: { inputId: string; describedBy: string | undefined }) => ReactNode;
|
||||
}
|
||||
|
||||
function FieldWrapper({ label, error, hint, children }: FieldWrapperProps) {
|
||||
const inputId = useId();
|
||||
const hintId = hint ? `${inputId}-hint` : undefined;
|
||||
const errorId = error ? `${inputId}-error` : undefined;
|
||||
const describedBy = [hintId, errorId].filter(Boolean).join(" ") || undefined;
|
||||
|
||||
return (
|
||||
<div className="shl-field">
|
||||
<label htmlFor={inputId}>{label}</label>
|
||||
{children({ inputId, describedBy })}
|
||||
{hint && (
|
||||
<p id={hintId} className="shl-field-hint">
|
||||
{hint}
|
||||
</p>
|
||||
)}
|
||||
{error && (
|
||||
<p id={errorId} className="shl-field-error" role="alert">
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
export interface TextFieldProps
|
||||
extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "aria-describedby"> {
|
||||
label: string;
|
||||
error?: string;
|
||||
hint?: string;
|
||||
}
|
||||
|
||||
export function TextField({ label, error, hint, ...inputProps }: TextFieldProps) {
|
||||
return (
|
||||
<FieldWrapper label={label} error={error} hint={hint}>
|
||||
{({ inputId, describedBy }) => (
|
||||
<input
|
||||
id={inputId}
|
||||
aria-describedby={describedBy}
|
||||
aria-invalid={error ? true : undefined}
|
||||
{...inputProps}
|
||||
/>
|
||||
)}
|
||||
</FieldWrapper>
|
||||
);
|
||||
}
|
||||
|
||||
export interface SelectFieldProps
|
||||
extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "id" | "aria-describedby"> {
|
||||
label: string;
|
||||
error?: string;
|
||||
hint?: string;
|
||||
children: ReactNode;
|
||||
}
|
||||
|
||||
export function SelectField({ label, error, hint, children, ...selectProps }: SelectFieldProps) {
|
||||
return (
|
||||
<FieldWrapper label={label} error={error} hint={hint}>
|
||||
{({ inputId, describedBy }) => (
|
||||
<select
|
||||
id={inputId}
|
||||
aria-describedby={describedBy}
|
||||
aria-invalid={error ? true : undefined}
|
||||
{...selectProps}
|
||||
>
|
||||
{children}
|
||||
</select>
|
||||
)}
|
||||
</FieldWrapper>
|
||||
);
|
||||
}
|
||||
|
||||
export interface CheckboxFieldProps
|
||||
extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "type"> {
|
||||
label: string;
|
||||
}
|
||||
|
||||
export function CheckboxField({ label, ...inputProps }: CheckboxFieldProps) {
|
||||
const inputId = useId();
|
||||
return (
|
||||
<div className="shl-field shl-field-checkbox">
|
||||
<input id={inputId} type="checkbox" {...inputProps} />
|
||||
<label htmlFor={inputId}>{label}</label>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
"use client";
|
||||
|
||||
// Layout-Shell mit Navigation — SHL-01 Akzeptanzkriterium 1.
|
||||
// Globale Navigation zeigt nur Module, die Core für Tenant/Benutzer freigibt (Backend entscheidet, UI blendet nur aus).
|
||||
|
||||
import type { ReactNode } from "react";
|
||||
import { useI18n } from "../i18n/i18n";
|
||||
import { useTheme } from "../theme/ThemeProvider";
|
||||
|
||||
export interface ModuleLink {
|
||||
key: string;
|
||||
label: string;
|
||||
href: string;
|
||||
active?: boolean;
|
||||
}
|
||||
|
||||
export interface ShellProps {
|
||||
modules: ModuleLink[];
|
||||
tenantLabel: string;
|
||||
children: ReactNode;
|
||||
}
|
||||
|
||||
export function Shell({ modules, tenantLabel, children }: ShellProps) {
|
||||
const { scheme, toggle } = useTheme();
|
||||
const { t } = useI18n();
|
||||
|
||||
return (
|
||||
<div className="shl-shell">
|
||||
<a className="shl-skip-link" href="#shl-main-content">
|
||||
{t("shl.shell.skipToContent", "Zum Inhalt springen")}
|
||||
</a>
|
||||
<header className="shl-shell-header">
|
||||
<nav aria-label={t("shl.shell.moduleNav", "Modul-Navigation")}>
|
||||
<ul>
|
||||
{modules.map((mod) => (
|
||||
<li key={mod.key}>
|
||||
<a href={mod.href} aria-current={mod.active ? "page" : undefined}>
|
||||
{mod.label}
|
||||
</a>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</nav>
|
||||
<div className="shl-shell-context">
|
||||
<span className="shl-tenant-context">{tenantLabel}</span>
|
||||
<button
|
||||
type="button"
|
||||
onClick={toggle}
|
||||
aria-label={
|
||||
scheme === "light" ? t("shl.theme.toggleToDark") : t("shl.theme.toggleToLight")
|
||||
}
|
||||
>
|
||||
{scheme === "light" ? "🌙" : "☀️"}
|
||||
</button>
|
||||
</div>
|
||||
</header>
|
||||
<main id="shl-main-content" className="shl-shell-content" tabIndex={-1}>
|
||||
{children}
|
||||
</main>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
// Table-Basis-Komponente — SHL-01. WCAG: semantische <table>, scope auf Kopfzellen, sortierbare Spalten per Tastatur.
|
||||
|
||||
import type { ReactNode } from "react";
|
||||
import { useI18n } from "../i18n/i18n";
|
||||
|
||||
export interface TableColumn<Row> {
|
||||
key: string;
|
||||
header: string;
|
||||
render: (row: Row) => ReactNode;
|
||||
sortable?: boolean;
|
||||
}
|
||||
|
||||
export interface TableProps<Row> {
|
||||
columns: TableColumn<Row>[];
|
||||
rows: Row[];
|
||||
rowKey: (row: Row) => string;
|
||||
sortKey?: string;
|
||||
sortDirection?: "asc" | "desc";
|
||||
onSort?: (key: string) => void;
|
||||
caption?: string;
|
||||
}
|
||||
|
||||
export function Table<Row>({
|
||||
columns,
|
||||
rows,
|
||||
rowKey,
|
||||
sortKey,
|
||||
sortDirection,
|
||||
onSort,
|
||||
caption,
|
||||
}: TableProps<Row>) {
|
||||
const { t } = useI18n();
|
||||
|
||||
return (
|
||||
<table className="shl-table">
|
||||
{caption && <caption>{caption}</caption>}
|
||||
<thead>
|
||||
<tr>
|
||||
{columns.map((column) => {
|
||||
const isSorted = column.key === sortKey;
|
||||
const ariaSort = column.sortable
|
||||
? isSorted
|
||||
? sortDirection === "asc"
|
||||
? "ascending"
|
||||
: "descending"
|
||||
: "none"
|
||||
: undefined;
|
||||
return (
|
||||
<th key={column.key} scope="col" aria-sort={ariaSort}>
|
||||
{column.sortable ? (
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => onSort?.(column.key)}
|
||||
className="shl-table-sort-button"
|
||||
>
|
||||
{column.header}
|
||||
</button>
|
||||
) : (
|
||||
column.header
|
||||
)}
|
||||
</th>
|
||||
);
|
||||
})}
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{rows.length === 0 ? (
|
||||
<tr>
|
||||
<td colSpan={columns.length}>{t("shl.table.noRows")}</td>
|
||||
</tr>
|
||||
) : (
|
||||
rows.map((row) => (
|
||||
<tr key={rowKey(row)}>
|
||||
{columns.map((column) => (
|
||||
<td key={column.key}>{column.render(row)}</td>
|
||||
))}
|
||||
</tr>
|
||||
))
|
||||
)}
|
||||
</tbody>
|
||||
</table>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
"use client";
|
||||
|
||||
// Toast-Basis-Komponente — SHL-01. WCAG: aria-live sorgt dafür, dass Screenreader Meldungen ansagen.
|
||||
|
||||
import { createContext, useCallback, useContext, useMemo, useState } from "react";
|
||||
import type { ReactNode } from "react";
|
||||
import { useI18n } from "../i18n/i18n";
|
||||
|
||||
export type ToastVariant = "info" | "success" | "danger" | "warning";
|
||||
|
||||
export interface ToastMessage {
|
||||
id: string;
|
||||
text: string;
|
||||
variant: ToastVariant;
|
||||
}
|
||||
|
||||
interface ToastContextValue {
|
||||
toasts: ToastMessage[];
|
||||
push: (text: string, variant?: ToastVariant) => void;
|
||||
dismiss: (id: string) => void;
|
||||
}
|
||||
|
||||
const ToastContext = createContext<ToastContextValue | null>(null);
|
||||
|
||||
export function ToastProvider({ children }: { children: ReactNode }) {
|
||||
const [toasts, setToasts] = useState<ToastMessage[]>([]);
|
||||
const { t } = useI18n();
|
||||
|
||||
const dismiss = useCallback((id: string) => {
|
||||
setToasts((current) => current.filter((toast) => toast.id !== id));
|
||||
}, []);
|
||||
|
||||
const push = useCallback((text: string, variant: ToastVariant = "info") => {
|
||||
const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
|
||||
setToasts((current) => [...current, { id, text, variant }]);
|
||||
}, []);
|
||||
|
||||
const value = useMemo(() => ({ toasts, push, dismiss }), [toasts, push, dismiss]);
|
||||
|
||||
return (
|
||||
<ToastContext.Provider value={value}>
|
||||
{children}
|
||||
<div className="shl-toast-region" role="status" aria-live="polite" aria-atomic="false">
|
||||
{toasts.map((toast) => (
|
||||
<div key={toast.id} className={`shl-toast shl-toast-${toast.variant}`}>
|
||||
<span>{toast.text}</span>
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => dismiss(toast.id)}
|
||||
aria-label={t("shl.toast.dismiss")}
|
||||
>
|
||||
×
|
||||
</button>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</ToastContext.Provider>
|
||||
);
|
||||
}
|
||||
|
||||
export function useToast(): ToastContextValue {
|
||||
const ctx = useContext(ToastContext);
|
||||
if (!ctx) {
|
||||
throw new Error("useToast muss innerhalb von <ToastProvider> aufgerufen werden");
|
||||
}
|
||||
return ctx;
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
"use client";
|
||||
|
||||
// i18n-Rahmen (mind. Deutsch/Englisch) — SHL-01 Akzeptanzkriterium 5.
|
||||
// Liefert nur den Umschaltmechanismus + Basis-Komponenten-Texte.
|
||||
// Modul-Frontends liefern ihre eigenen fachlichen Textbausteine über registerMessages(),
|
||||
// statt einen eigenen i18n-Mechanismus zu bauen (siehe UI-UX-KONZEPT.md Abschnitt 4).
|
||||
|
||||
import { createContext, useContext, useMemo, useState } from "react";
|
||||
import type { ReactNode } from "react";
|
||||
|
||||
export type Locale = "de" | "en";
|
||||
|
||||
type MessageDict = Record<string, string>;
|
||||
type MessageBundle = Record<Locale, MessageDict>;
|
||||
|
||||
const baseMessages: MessageBundle = {
|
||||
de: {
|
||||
"shl.dialog.close": "Schließen",
|
||||
"shl.toast.dismiss": "Meldung schließen",
|
||||
"shl.table.noRows": "Keine Einträge vorhanden",
|
||||
"shl.theme.toggleToLight": "Helles Erscheinungsbild",
|
||||
"shl.theme.toggleToDark": "Dunkles Erscheinungsbild",
|
||||
},
|
||||
en: {
|
||||
"shl.dialog.close": "Close",
|
||||
"shl.toast.dismiss": "Dismiss message",
|
||||
"shl.table.noRows": "No entries",
|
||||
"shl.theme.toggleToLight": "Switch to light theme",
|
||||
"shl.theme.toggleToDark": "Switch to dark theme",
|
||||
},
|
||||
};
|
||||
|
||||
// Registry, in die Modul-Frontends ihre eigenen Textbausteine einhängen.
|
||||
const registry: MessageBundle = { de: { ...baseMessages.de }, en: { ...baseMessages.en } };
|
||||
|
||||
export function registerMessages(locale: Locale, messages: MessageDict): void {
|
||||
registry[locale] = { ...registry[locale], ...messages };
|
||||
}
|
||||
|
||||
interface I18nContextValue {
|
||||
locale: Locale;
|
||||
setLocale: (locale: Locale) => void;
|
||||
t: (key: string, fallback?: string) => string;
|
||||
}
|
||||
|
||||
const I18nContext = createContext<I18nContextValue | null>(null);
|
||||
|
||||
export function I18nProvider({
|
||||
initialLocale = "de",
|
||||
children,
|
||||
}: {
|
||||
initialLocale?: Locale;
|
||||
children: ReactNode;
|
||||
}) {
|
||||
const [locale, setLocale] = useState<Locale>(initialLocale);
|
||||
|
||||
const value = useMemo<I18nContextValue>(
|
||||
() => ({
|
||||
locale,
|
||||
setLocale,
|
||||
t: (key: string, fallback?: string) => registry[locale][key] ?? fallback ?? key,
|
||||
}),
|
||||
[locale],
|
||||
);
|
||||
|
||||
return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>;
|
||||
}
|
||||
|
||||
export function useI18n(): I18nContextValue {
|
||||
const ctx = useContext(I18nContext);
|
||||
if (!ctx) {
|
||||
throw new Error("useI18n muss innerhalb von <I18nProvider> aufgerufen werden");
|
||||
}
|
||||
return ctx;
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
// Öffentliche Schnittstelle des Pakets @nexarch/shl — Modul-Frontends importieren ausschließlich hierüber,
|
||||
// nicht aus internen Unterpfaden (SHL-01 Akzeptanzkriterium 2: dokumentiert, versioniert, importierbar statt kopiert).
|
||||
|
||||
export { colorTokens, spacing, breakpoints, typography, cssVariables } from "./tokens/tokens";
|
||||
export type { ColorScheme, ColorTokens } from "./tokens/tokens";
|
||||
|
||||
export { ThemeProvider, useTheme, currentColors } from "./theme/ThemeProvider";
|
||||
|
||||
export { I18nProvider, useI18n, registerMessages } from "./i18n/i18n";
|
||||
export type { Locale } from "./i18n/i18n";
|
||||
|
||||
export { Shell } from "./components/Shell";
|
||||
export type { ShellProps, ModuleLink } from "./components/Shell";
|
||||
|
||||
export { Dialog } from "./components/Dialog";
|
||||
export type { DialogProps } from "./components/Dialog";
|
||||
|
||||
export { Table } from "./components/Table";
|
||||
export type { TableProps, TableColumn } from "./components/Table";
|
||||
|
||||
export { TextField, SelectField, CheckboxField } from "./components/FormElements";
|
||||
export type { TextFieldProps, SelectFieldProps, CheckboxFieldProps } from "./components/FormElements";
|
||||
|
||||
export { ToastProvider, useToast } from "./components/Toast";
|
||||
export type { ToastMessage, ToastVariant } from "./components/Toast";
|
||||
@@ -0,0 +1,25 @@
|
||||
{
|
||||
"name": "@nexarch/shl",
|
||||
"version": "0.1.0",
|
||||
"private": true,
|
||||
"description": "NEXARCH UI-Shell & Design-System (Core SHL-01) — gemeinsames Paket für alle Modul-Frontends.",
|
||||
"main": "index.ts",
|
||||
"types": "index.ts",
|
||||
"scripts": {
|
||||
"test": "vitest run",
|
||||
"typecheck": "tsc --noEmit"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"react": "^18.3.1",
|
||||
"react-dom": "^18.3.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@testing-library/jest-dom": "^6.4.8",
|
||||
"@testing-library/react": "^16.0.0",
|
||||
"@types/react": "18.3.3",
|
||||
"@types/react-dom": "18.3.0",
|
||||
"jsdom": "^24.1.1",
|
||||
"typescript": "5.5.3",
|
||||
"vitest": "^2.0.0"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
"use client";
|
||||
|
||||
// Zentrales Theming (Hell/Dunkel) — SHL-01 Akzeptanzkriterium 6.
|
||||
// Einzige Quelle für Hell/Dunkel-Werte; Modul-Frontends schalten nur um, bauen kein eigenes Theming.
|
||||
|
||||
import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
|
||||
import type { ReactNode } from "react";
|
||||
import { colorTokens, cssVariables, type ColorScheme } from "../tokens/tokens";
|
||||
|
||||
const STORAGE_KEY = "nexarch-shl-theme";
|
||||
|
||||
interface ThemeContextValue {
|
||||
scheme: ColorScheme;
|
||||
setScheme: (scheme: ColorScheme) => void;
|
||||
toggle: () => void;
|
||||
}
|
||||
|
||||
const ThemeContext = createContext<ThemeContextValue | null>(null);
|
||||
|
||||
function readStoredScheme(): ColorScheme | null {
|
||||
if (typeof window === "undefined") return null;
|
||||
try {
|
||||
const stored = window.localStorage.getItem(STORAGE_KEY);
|
||||
return stored === "light" || stored === "dark" ? stored : null;
|
||||
} catch {
|
||||
// localStorage kann in privaten Fenstern/eingeschränkten Kontexten fehlschlagen — kein Absturz, nur kein persistierter Zustand.
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function systemPrefersDark(): boolean {
|
||||
if (typeof window === "undefined" || !window.matchMedia) return false;
|
||||
return window.matchMedia("(prefers-color-scheme: dark)").matches;
|
||||
}
|
||||
|
||||
export function ThemeProvider({ children }: { children: ReactNode }) {
|
||||
const [scheme, setSchemeState] = useState<ColorScheme>("light");
|
||||
|
||||
useEffect(() => {
|
||||
const stored = readStoredScheme();
|
||||
setSchemeState(stored ?? (systemPrefersDark() ? "dark" : "light"));
|
||||
}, []);
|
||||
|
||||
const setScheme = useCallback((next: ColorScheme) => {
|
||||
setSchemeState(next);
|
||||
try {
|
||||
window.localStorage.setItem(STORAGE_KEY, next);
|
||||
} catch {
|
||||
// Speichern optional — Umschaltung funktioniert auch ohne Persistenz.
|
||||
}
|
||||
}, []);
|
||||
|
||||
const toggle = useCallback(() => {
|
||||
setScheme(scheme === "light" ? "dark" : "light");
|
||||
}, [scheme, setScheme]);
|
||||
|
||||
useEffect(() => {
|
||||
const vars = cssVariables(scheme);
|
||||
const root = document.documentElement;
|
||||
for (const [key, value] of Object.entries(vars)) {
|
||||
root.style.setProperty(key, value);
|
||||
}
|
||||
root.dataset.shlTheme = scheme;
|
||||
}, [scheme]);
|
||||
|
||||
const value = useMemo(() => ({ scheme, setScheme, toggle }), [scheme, setScheme, toggle]);
|
||||
|
||||
return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
|
||||
}
|
||||
|
||||
export function useTheme(): ThemeContextValue {
|
||||
const ctx = useContext(ThemeContext);
|
||||
if (!ctx) {
|
||||
throw new Error("useTheme muss innerhalb von <ThemeProvider> aufgerufen werden");
|
||||
}
|
||||
return ctx;
|
||||
}
|
||||
|
||||
export function currentColors(scheme: ColorScheme) {
|
||||
return colorTokens[scheme];
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
// Design-Tokens: einzige Quelle für Farbe, Abstand, Typografie im gesamten Frontend-Verbund.
|
||||
// Modul-Frontends importieren diese Tokens, überschreiben sie nicht lokal (SHL-01 Akzeptanzkriterium 3).
|
||||
// Kontrastwerte sind gegen WCAG 2.1 AA geprüft (Akzeptanzkriterium 1/4): mindestens 4.5:1 für Fließtext.
|
||||
|
||||
export type ColorScheme = "light" | "dark";
|
||||
|
||||
export interface ColorTokens {
|
||||
background: string;
|
||||
surface: string;
|
||||
surfaceRaised: string;
|
||||
border: string;
|
||||
textPrimary: string;
|
||||
textSecondary: string;
|
||||
accent: string;
|
||||
accentContrast: string;
|
||||
danger: string;
|
||||
dangerContrast: string;
|
||||
success: string;
|
||||
warning: string;
|
||||
focusRing: string;
|
||||
}
|
||||
|
||||
// Kontrastwerte geprüft: textPrimary auf background/surface >= 7:1, textSecondary >= 4.5:1,
|
||||
// accentContrast auf accent >= 4.5:1 (WCAG AA, siehe SHL-01 Prüfung 3).
|
||||
export const colorTokens: Record<ColorScheme, ColorTokens> = {
|
||||
light: {
|
||||
background: "#FFFFFF",
|
||||
surface: "#F5F6F8",
|
||||
surfaceRaised: "#FFFFFF",
|
||||
border: "#D7DBE0",
|
||||
textPrimary: "#14181F",
|
||||
textSecondary: "#4B5563",
|
||||
accent: "#1D4ED8",
|
||||
accentContrast: "#FFFFFF",
|
||||
danger: "#B91C1C",
|
||||
dangerContrast: "#FFFFFF",
|
||||
success: "#15803D",
|
||||
warning: "#B45309",
|
||||
focusRing: "#1D4ED8",
|
||||
},
|
||||
dark: {
|
||||
background: "#0F1115",
|
||||
surface: "#181B21",
|
||||
surfaceRaised: "#20242C",
|
||||
border: "#333944",
|
||||
textPrimary: "#F2F4F7",
|
||||
textSecondary: "#B4BAC4",
|
||||
accent: "#5B8DEF",
|
||||
accentContrast: "#0F1115",
|
||||
danger: "#F87171",
|
||||
dangerContrast: "#0F1115",
|
||||
success: "#4ADE80",
|
||||
warning: "#FBBF24",
|
||||
focusRing: "#5B8DEF",
|
||||
},
|
||||
};
|
||||
|
||||
export const spacing = {
|
||||
xs: "4px",
|
||||
sm: "8px",
|
||||
md: "16px",
|
||||
lg: "24px",
|
||||
xl: "32px",
|
||||
xxl: "48px",
|
||||
} as const;
|
||||
|
||||
export const breakpoints = {
|
||||
mobile: "0px",
|
||||
tablet: "768px",
|
||||
desktop: "1200px",
|
||||
} as const;
|
||||
|
||||
export const typography = {
|
||||
fontFamily: "'Inter', 'Segoe UI', system-ui, sans-serif",
|
||||
fontFamilyMono: "'JetBrains Mono', ui-monospace, monospace",
|
||||
sizeSm: "13px",
|
||||
sizeMd: "15px",
|
||||
sizeLg: "18px",
|
||||
sizeXl: "24px",
|
||||
lineHeight: 1.5,
|
||||
weightRegular: 400,
|
||||
weightMedium: 500,
|
||||
weightBold: 600,
|
||||
} as const;
|
||||
|
||||
export function cssVariables(scheme: ColorScheme): Record<string, string> {
|
||||
const c = colorTokens[scheme];
|
||||
const vars: Record<string, string> = {};
|
||||
for (const [key, value] of Object.entries(c)) {
|
||||
vars[`--shl-color-${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`] = value;
|
||||
}
|
||||
for (const [key, value] of Object.entries(spacing)) {
|
||||
vars[`--shl-spacing-${key}`] = value;
|
||||
}
|
||||
return vars;
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "ES2020",
|
||||
"lib": ["dom", "dom.iterable", "esnext"],
|
||||
"jsx": "react-jsx",
|
||||
"module": "ESNext",
|
||||
"moduleResolution": "bundler",
|
||||
"strict": true,
|
||||
"declaration": true,
|
||||
"esModuleInterop": true,
|
||||
"skipLibCheck": true,
|
||||
"forceConsistentCasingInFileNames": true,
|
||||
"noUnusedLocals": true,
|
||||
"noUnusedParameters": true
|
||||
},
|
||||
"include": ["**/*.ts", "**/*.tsx"],
|
||||
"exclude": ["node_modules"]
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
import { defineConfig } from "vitest/config";
|
||||
|
||||
export default defineConfig({
|
||||
test: {
|
||||
environment: "jsdom",
|
||||
setupFiles: ["./vitest.setup.ts"],
|
||||
},
|
||||
});
|
||||
@@ -0,0 +1,9 @@
|
||||
import "@testing-library/jest-dom/vitest";
|
||||
import { afterEach } from "vitest";
|
||||
import { cleanup } from "@testing-library/react";
|
||||
|
||||
// Ohne explizites Cleanup bleiben zwischen den it()-Blöcken gerenderte Dialoge im DOM stehen
|
||||
// (mehrere <html>/<body>-Bäume stapeln sich), wodurch getByRole() mehrere Treffer statt einen findet.
|
||||
afterEach(() => {
|
||||
cleanup();
|
||||
});
|
||||
Reference in New Issue
Block a user