From 05edcd6b8e0f97dde01ebdb437648c9e0a1bfcb8 Mon Sep 17 00:00:00 2001 From: claude Date: Fri, 20 Nov 2026 17:34:29 +0100 Subject: [PATCH] =?UTF-8?q?Lot=202=20:=20comptes=20partag=C3=A9s=20dans=20?= =?UTF-8?q?le=20catalogue=20PostgreSQL?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - internal/catalog/docs.go : collections de documents JSON (id, data jsonb) modifiées sous verrou consultatif par table, écriture du seul diff, reprise unique d'anciens fichiers (ImportFileOnce), petits blobs. - Migration 002 : tables accounts, tokens, app_settings, app_blobs. - auth.Accounts : UseCatalog ; toutes les modifications passent par une fonction atomique (fichier ou base), la règle du dernier administrateur et le premier administrateur restent vrais entre instances. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB --- internal/auth/accounts.go | 5 + internal/catalog/docs.go | 261 ++++++++++++++++++++++++ internal/catalog/migrations/002_app.sql | 28 +++ 3 files changed, 294 insertions(+) create mode 100644 internal/catalog/docs.go create mode 100644 internal/catalog/migrations/002_app.sql diff --git a/internal/auth/accounts.go b/internal/auth/accounts.go index 075000b..a1ab07e 100644 --- a/internal/auth/accounts.go +++ b/internal/auth/accounts.go @@ -1,6 +1,7 @@ package auth import ( + "context" "crypto/pbkdf2" "crypto/rand" "crypto/sha256" @@ -8,6 +9,7 @@ import ( "encoding/json" "errors" "fmt" + "log/slog" "os" "path/filepath" "regexp" @@ -17,6 +19,9 @@ import ( "sync" "time" "unicode/utf8" + + "github.com/jackc/pgx/v5" + "github.com/vblogio/upandown/internal/catalog" ) // Comptes utilisateurs : comptes locaux (identifiant + mot de passe) et comptes diff --git a/internal/catalog/docs.go b/internal/catalog/docs.go new file mode 100644 index 0000000..0f3056f --- /dev/null +++ b/internal/catalog/docs.go @@ -0,0 +1,261 @@ +package catalog + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "io/fs" + "log/slog" + "os" + "regexp" + + "github.com/jackc/pgx/v5" +) + +// Collections de documents JSON : tables (id text PRIMARY KEY, data jsonb) +// pour les données globales de l'application (comptes, jetons, réglages). +// Chaque modification charge la collection sous un verrou consultatif propre +// à la table, applique la fonction de l'appelant, puis n'écrit que les +// documents ajoutés, modifiés ou supprimés. + +var fieldRe = regexp.MustCompile(`^[A-Za-z][A-Za-z0-9_]*$`) + +func ident(table string) string { return pgx.Identifier{table}.Sanitize() } + +// loadDocs lit toute la collection ; raw reçoit l'encodage Go de chaque +// document (pour détecter ensuite ce qui a changé). +func loadDocs[T any](ctx context.Context, tx pgx.Tx, table string, raw map[string][]byte) (map[string]*T, error) { + rows, err := tx.Query(ctx, "SELECT id, data FROM "+ident(table)) + if err != nil { + return nil, err + } + defer rows.Close() + out := map[string]*T{} + for rows.Next() { + var id string + var b []byte + if err := rows.Scan(&id, &b); err != nil { + return nil, err + } + v := new(T) + if err := json.Unmarshal(b, v); err != nil { + return nil, fmt.Errorf("%s/%s : %w", table, id, err) + } + out[id] = v + if raw != nil { + if raw[id], err = json.Marshal(v); err != nil { + return nil, err + } + } + } + return out, rows.Err() +} + +// AllDocs renvoie toute la collection. +func AllDocs[T any](ctx context.Context, db *DB, table string) (map[string]*T, error) { + var out map[string]*T + err := db.Tx(ctx, func(tx pgx.Tx) error { + var err error + out, err = loadDocs[T](ctx, tx, table, nil) + return err + }) + return out, err +} + +// GetDoc renvoie le document id (nil s'il n'existe pas). +func GetDoc[T any](ctx context.Context, db *DB, table, id string) (*T, error) { + return findDoc[T](ctx, db, "SELECT data FROM "+ident(table)+" WHERE id = $1", id) +} + +// FindDoc renvoie le premier document dont le champ texte field vaut value +// (nil si aucun). field est un nom de champ constant (index sur l'expression). +func FindDoc[T any](ctx context.Context, db *DB, table, field, value string) (*T, error) { + if !fieldRe.MatchString(field) { + return nil, fmt.Errorf("champ %q invalide", field) + } + return findDoc[T](ctx, db, "SELECT data FROM "+ident(table)+" WHERE data->>'"+field+"' = $1 LIMIT 1", value) +} + +func findDoc[T any](ctx context.Context, db *DB, sql, arg string) (*T, error) { + var b []byte + err := db.Tx(ctx, func(tx pgx.Tx) error { + b = nil + err := tx.QueryRow(ctx, sql, arg).Scan(&b) + if errors.Is(err, pgx.ErrNoRows) { + return nil + } + return err + }) + if err != nil || b == nil { + return nil, err + } + v := new(T) + if err := json.Unmarshal(b, v); err != nil { + return nil, err + } + return v, nil +} + +// UpdateDocs modifie la collection : fn reçoit tous les documents (qu'elle +// peut modifier, ajouter ou supprimer) sous le verrou de la table. Une +// erreur de fn annule tout. fn peut être rejouée (voir DB.Tx). +func UpdateDocs[T any](ctx context.Context, db *DB, table string, fn func(map[string]*T) error) error { + return db.Tx(ctx, func(tx pgx.Tx) error { + if err := Lock(ctx, tx, "docs:"+table); err != nil { + return err + } + before := map[string][]byte{} + docs, err := loadDocs[T](ctx, tx, table, before) + if err != nil { + return err + } + if err := fn(docs); err != nil { + return err + } + return writeDocs(ctx, tx, table, before, docs) + }) +} + +func writeDocs[T any](ctx context.Context, tx pgx.Tx, table string, before map[string][]byte, after map[string]*T) error { + for id := range before { + if _, ok := after[id]; !ok { + if _, err := tx.Exec(ctx, "DELETE FROM "+ident(table)+" WHERE id = $1", id); err != nil { + return err + } + } + } + for id, v := range after { + b, err := json.Marshal(v) + if err != nil { + return err + } + if old, ok := before[id]; ok && bytes.Equal(old, b) { + continue + } + if _, err := tx.Exec(ctx, "INSERT INTO "+ident(table)+" (id, data) VALUES ($1, $2) "+ + "ON CONFLICT (id) DO UPDATE SET data = EXCLUDED.data", id, b); err != nil { + return err + } + } + return nil +} + +// ReplaceDoc remplace un document existant sans prendre le verrou de la +// table (mise à jour légère, par exemple une date de dernière utilisation) ; +// un document supprimé entre-temps n'est pas recréé. +func ReplaceDoc(ctx context.Context, db *DB, table, id string, v any) error { + b, err := json.Marshal(v) + if err != nil { + return err + } + return db.Tx(ctx, func(tx pgx.Tx) error { + _, err := tx.Exec(ctx, "UPDATE "+ident(table)+" SET data = $2 WHERE id = $1", id, b) + return err + }) +} + +// ImportFileOnce reprend une seule fois (table imports, clé root + kind) +// l'ancien fichier file : fn reçoit son contenu dans la transaction, puis le +// fichier est renommé en *.imported. Un fichier absent marque simplement la +// reprise comme faite. +func (db *DB) ImportFileOnce(ctx context.Context, root, kind, file string, fn func(context.Context, pgx.Tx, []byte) error) error { + var found bool + err := db.Tx(ctx, func(tx pgx.Tx) error { + found = false + if err := Lock(ctx, tx, "import:"+root+":"+kind); err != nil { + return err + } + var done bool + if err := tx.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM imports WHERE root = $1 AND kind = $2)", + root, kind).Scan(&done); err != nil || done { + return err + } + b, err := os.ReadFile(file) + switch { + case errors.Is(err, fs.ErrNotExist): + case err != nil: + return err + default: + if err := fn(ctx, tx, b); err != nil { + return fmt.Errorf("%s : %w", file, err) + } + found = true + } + _, err = tx.Exec(ctx, "INSERT INTO imports (root, kind) VALUES ($1, $2)", root, kind) + return err + }) + if err != nil || !found { + return err + } + if err := os.Rename(file, file+".imported"); err != nil && !errors.Is(err, fs.ErrNotExist) { + slog.Warn("catalogue : fichier repris non renommé", "fichier", file, "err", err) + } + slog.Info("catalogue : fichier repris en base", "fichier", file) + return nil +} + +// InsertDocs ajoute des documents sans écraser ceux qui existent (reprise). +func InsertDocs[T any](ctx context.Context, tx pgx.Tx, table string, docs map[string]*T) error { + for id, v := range docs { + b, err := json.Marshal(v) + if err != nil { + return err + } + if _, err := tx.Exec(ctx, "INSERT INTO "+ident(table)+" (id, data) VALUES ($1, $2) ON CONFLICT (id) DO NOTHING", id, b); err != nil { + return err + } + } + return nil +} + +// Blobs : petits fichiers binaires partagés (logo). + +// GetBlob renvoie le contenu et la version (horodatage) de key, ou nil. +func (db *DB) GetBlob(ctx context.Context, key string) ([]byte, int64, error) { + var b []byte + var v int64 + err := db.Tx(ctx, func(tx pgx.Tx) error { + b, v = nil, 0 + err := tx.QueryRow(ctx, "SELECT data, (extract(epoch FROM updated) * 1e6)::bigint FROM app_blobs WHERE key = $1", key).Scan(&b, &v) + if errors.Is(err, pgx.ErrNoRows) { + return nil + } + return err + }) + return b, v, err +} + +// BlobVersion renvoie la version de key (0 si absent), sans lire le contenu. +func (db *DB) BlobVersion(ctx context.Context, key string) (int64, error) { + var v int64 + err := db.Tx(ctx, func(tx pgx.Tx) error { + v = 0 + err := tx.QueryRow(ctx, "SELECT (extract(epoch FROM updated) * 1e6)::bigint FROM app_blobs WHERE key = $1", key).Scan(&v) + if errors.Is(err, pgx.ErrNoRows) { + return nil + } + return err + }) + return v, err +} + +// PutBlob enregistre key (data nil : suppression). +func (db *DB) PutBlob(ctx context.Context, key string, data []byte) error { + return db.Tx(ctx, func(tx pgx.Tx) error { + if data == nil { + _, err := tx.Exec(ctx, "DELETE FROM app_blobs WHERE key = $1", key) + return err + } + _, err := tx.Exec(ctx, `INSERT INTO app_blobs (key, data, updated) VALUES ($1, $2, clock_timestamp()) + ON CONFLICT (key) DO UPDATE SET data = EXCLUDED.data, updated = EXCLUDED.updated`, key, data) + return err + }) +} + +// PutBlobTx : PutBlob dans une transaction existante (reprise). +func PutBlobTx(ctx context.Context, tx pgx.Tx, key string, data []byte) error { + _, err := tx.Exec(ctx, `INSERT INTO app_blobs (key, data) VALUES ($1, $2) ON CONFLICT (key) DO NOTHING`, key, data) + return err +} diff --git a/internal/catalog/migrations/002_app.sql b/internal/catalog/migrations/002_app.sql new file mode 100644 index 0000000..f87639d --- /dev/null +++ b/internal/catalog/migrations/002_app.sql @@ -0,0 +1,28 @@ +-- Données globales partagées par toutes les instances ; data reprend le +-- format des anciens fichiers JSON de DATA_DIR. +CREATE TABLE accounts ( + id text PRIMARY KEY, + data jsonb NOT NULL +); +CREATE INDEX accounts_username ON accounts ((data->>'username')); +CREATE INDEX accounts_sub ON accounts ((data->>'sub')); + +-- Jetons d'accès (seul leur hachage est conservé). +CREATE TABLE tokens ( + id text PRIMARY KEY, + data jsonb NOT NULL +); +CREATE UNIQUE INDEX tokens_hash ON tokens ((data->>'hash')); + +-- Réglages d'administration (document "settings", format de .settings.json). +CREATE TABLE app_settings ( + id text PRIMARY KEY, + data jsonb NOT NULL +); + +-- Petits fichiers binaires (logo). +CREATE TABLE app_blobs ( + key text PRIMARY KEY, + data bytea NOT NULL, + updated timestamptz NOT NULL DEFAULT clock_timestamp() +);