fix backend audit findings (auth, upload, sync, data, ocr, contract)
CI / lint-backend (push) Failing after 1m39s
CI / lint-mobile (push) Canceled after 11m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
CI / lint-backend (push) Failing after 1m39s
CI / lint-mobile (push) Canceled after 11m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
This commit is contained in:
@@ -8,6 +8,7 @@ import (
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"sync"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
@@ -41,14 +42,19 @@ func main() {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
|
||||
// Migrations AVANT l'ouverture du pool applicatif : un seul *sql.DB vit à
|
||||
// la fois (MigrateDatabase ouvre/ferme sa propre connexion éphémère).
|
||||
// Inter-lots : pour partager strictement le même pool, db doit exposer
|
||||
// Migrate(conn *sql.DB) — fichier LOT 4 (db/db.go), non édité ici.
|
||||
if err := db.MigrateDatabase(cfg.DatabaseURL); err != nil {
|
||||
log.Fatalf("migrations postgres: %v", err)
|
||||
}
|
||||
|
||||
conn, err := db.Open(cfg.DatabaseURL)
|
||||
if err != nil {
|
||||
log.Fatalf("connexion postgres: %v", err)
|
||||
}
|
||||
|
||||
if err := db.MigrateDatabase(cfg.DatabaseURL); err != nil {
|
||||
log.Fatalf("migrations postgres: %v", err)
|
||||
}
|
||||
defer conn.Close()
|
||||
|
||||
authManager, err := auth.NewManager(cfg.AuthSecret)
|
||||
if err != nil {
|
||||
@@ -59,8 +65,19 @@ func main() {
|
||||
repo := repository.NewRepository(conn)
|
||||
|
||||
// Premier admin (users vide) — refus de démarrer si identifiants absents.
|
||||
// Concurrence au boot (2 instances, users vide) : le perdant de l'INSERT
|
||||
// reçoit ErrNameConflict (UNIQUE username_normalized) → recompte avant de
|
||||
// refuser de démarrer (retry logique, sans toucher bootstrap.go — LOT 4).
|
||||
if err := service.EnsureAdmin(repo, cfg.AdminUsername, cfg.AdminPassword); err != nil {
|
||||
log.Fatalln(err)
|
||||
if errors.Is(err, repository.ErrNameConflict) {
|
||||
if n, cerr := repo.Users.Count(); cerr == nil && n > 0 {
|
||||
log.Println("bootstrap admin: compte créé par une instance concurrente, démarrage poursuivi")
|
||||
} else {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
} else {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
}
|
||||
|
||||
handlers.Store = service.NewResources(
|
||||
@@ -74,7 +91,15 @@ func main() {
|
||||
defer stop()
|
||||
|
||||
// Worker OCR borné (OCR_WORKERS) : file `ocr_jobs`, hors request handlers.
|
||||
go handlers.Ocr.Run(ctx, cfg.OcrWorkers)
|
||||
// WaitGroup + budget d'arrêt partagé (5s, voir shutdown plus bas) : le
|
||||
// worker finit le job en cours ; passé le délai, le process sort et le job
|
||||
// resté `processing` sera requeue au prochain boot (ResetStaleProcessing).
|
||||
var ocrWg sync.WaitGroup
|
||||
ocrWg.Add(1)
|
||||
go func() {
|
||||
defer ocrWg.Done()
|
||||
handlers.Ocr.Run(ctx, cfg.OcrWorkers)
|
||||
}()
|
||||
log.Printf("ocr worker démarré (%d workers)", cfg.OcrWorkers)
|
||||
|
||||
srv := &http.Server{
|
||||
@@ -95,5 +120,19 @@ func main() {
|
||||
if err := srv.Shutdown(shutdownCtx); err != nil {
|
||||
log.Printf("shutdown: %v", err)
|
||||
}
|
||||
// Le worker OCR dispose du même budget de 5s : on attend la fin du job en
|
||||
// cours, passé ce délai le process sort (job resté `processing` → requeue
|
||||
// au prochain boot via ResetStaleProcessing, jamais de job perdu).
|
||||
ocrDone := make(chan struct{})
|
||||
go func() {
|
||||
ocrWg.Wait()
|
||||
close(ocrDone)
|
||||
}()
|
||||
select {
|
||||
case <-ocrDone:
|
||||
log.Println("worker OCR arrêté")
|
||||
case <-shutdownCtx.Done():
|
||||
log.Println("worker OCR: budget 5s écoulé, arrêt forcé (jobs `processing` requeues au prochain boot)")
|
||||
}
|
||||
log.Println("arrêt propre")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -13,11 +13,11 @@ var expectedRoutes = []string{
|
||||
"GET /api/v1/shares/links/:token",
|
||||
|
||||
"GET /api/v1/files",
|
||||
"GET /api/v1/files/search",
|
||||
"GET /api/v1/files/folders",
|
||||
"GET /api/v1/files/:id",
|
||||
"GET /api/v1/files/:id/ocr",
|
||||
"DELETE /api/v1/files/:id",
|
||||
"GET /api/v1/files/search",
|
||||
"GET /api/v1/files/folders",
|
||||
"POST /api/v1/files/upload",
|
||||
|
||||
"GET /api/v1/users/resolve",
|
||||
@@ -44,3 +44,21 @@ func TestRoutesMatchClientContract(t *testing.T) {
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// TestStaticFileRoutesListedBeforeParam (LOT 6 §1) : verrouille que les routes
|
||||
// statiques /files/search et /files/folders restent déclarées avant
|
||||
// /files/:id dans le contrat. Gin priorise déjà le statique sur le paramétré
|
||||
// à l'exécution, mais l'ordre source documente l'intention ("/files/folders
|
||||
// ne doit jamais être avalé par FilesGet avec id="folders"). Le comportement
|
||||
// réel est couvert côté handlers (folders→200, :id="folders"→404).
|
||||
func TestStaticFileRoutesListedBeforeParam(t *testing.T) {
|
||||
index := map[string]int{}
|
||||
for i, r := range expectedRoutes {
|
||||
index[r] = i
|
||||
}
|
||||
for _, static := range []string{"GET /api/v1/files/search", "GET /api/v1/files/folders"} {
|
||||
if index[static] > index["GET /api/v1/files/:id"] {
|
||||
t.Errorf("contrat: %q doit rester listé avant %q (ordre §1)", static, "GET /api/v1/files/:id")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,8 +1,10 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/joho/godotenv"
|
||||
)
|
||||
@@ -19,6 +21,21 @@ type ApplicationConfig struct {
|
||||
AdminPassword string
|
||||
}
|
||||
|
||||
// Sécurité AUTH_SECRET (FEEDBACK #4) :
|
||||
// - valeur par défaut DEV UNIQUEMENT (jamais en production : refusée au boot
|
||||
// si APP_ENV/ENV vaut "prod"/"production") ;
|
||||
// - longueur minimale 32 caractères partout (dev comme prod) : le secret ne
|
||||
// sert qu'à dériver la clé paseto v4-local (SHA256), un secret court ou
|
||||
// deviné = tokens forgeables.
|
||||
//
|
||||
// NOTE inter-lots (LOT 6 « secret-doc ») : aligner backend/.env.example —
|
||||
// documenter « ≥ 32 caractères, ex. `openssl rand -hex 32` » et ne plus
|
||||
// suggérer une valeur copiable telle quelle.
|
||||
const (
|
||||
defaultAuthSecret = "dev-secret-change-me-please-set-in-prod"
|
||||
minAuthSecretLen = 32
|
||||
)
|
||||
|
||||
func LoadApplicationConfig() (*ApplicationConfig, error) {
|
||||
|
||||
// .env optionnel — les défauts suffisent pour le dev local.
|
||||
@@ -28,16 +45,33 @@ func LoadApplicationConfig() (*ApplicationConfig, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if port < 1 || port > 65535 {
|
||||
return nil, fmt.Errorf("PORT hors plage 1-65535: %d", port)
|
||||
}
|
||||
|
||||
maxSize, err := getInt("MAX_FILE_SIZE_MB", 50)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if maxSize < 1 || maxSize > 1024 {
|
||||
return nil, fmt.Errorf("MAX_FILE_SIZE_MB hors plage 1-1024: %d", maxSize)
|
||||
}
|
||||
|
||||
ocrWorkers, err := getInt("OCR_WORKERS", 2)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if ocrWorkers < 1 || ocrWorkers > 16 {
|
||||
return nil, fmt.Errorf("OCR_WORKERS hors plage 1-16: %d", ocrWorkers)
|
||||
}
|
||||
|
||||
authSecret := get("AUTH_SECRET", defaultAuthSecret)
|
||||
if isProduction() && (authSecret == "" || authSecret == defaultAuthSecret) {
|
||||
return nil, fmt.Errorf("AUTH_SECRET doit être défini en production (pas de défaut)")
|
||||
}
|
||||
if len(authSecret) < minAuthSecretLen {
|
||||
return nil, fmt.Errorf("AUTH_SECRET trop court (min %d caractères)", minAuthSecretLen)
|
||||
}
|
||||
|
||||
return &ApplicationConfig{
|
||||
Port: port,
|
||||
@@ -46,13 +80,21 @@ func LoadApplicationConfig() (*ApplicationConfig, error) {
|
||||
MaxFileSizeMB: int64(maxSize),
|
||||
OcrLang: get("OCR_LANG", "fra+eng"),
|
||||
OcrWorkers: ocrWorkers,
|
||||
AuthSecret: get("AUTH_SECRET", "dev-secret-change-me"),
|
||||
AuthSecret: authSecret,
|
||||
AdminUsername: get("ADMIN_USERNAME", ""),
|
||||
AdminPassword: get("ADMIN_PASSWORD", ""),
|
||||
}, nil
|
||||
|
||||
}
|
||||
|
||||
func isProduction() bool {
|
||||
env := strings.ToLower(strings.TrimSpace(os.Getenv("APP_ENV")))
|
||||
if env == "" {
|
||||
env = strings.ToLower(strings.TrimSpace(os.Getenv("ENV")))
|
||||
}
|
||||
return env == "production" || env == "prod"
|
||||
}
|
||||
|
||||
func get(name string, defaultValue string) string {
|
||||
value := os.Getenv(name)
|
||||
if value == "" {
|
||||
|
||||
@@ -10,6 +10,7 @@ func clearEnv(t *testing.T) {
|
||||
for _, name := range []string{
|
||||
"PORT", "DATABASE_URL", "UPLOAD_DIR", "MAX_FILE_SIZE_MB",
|
||||
"OCR_LANG", "OCR_WORKERS", "AUTH_SECRET", "ADMIN_USERNAME", "ADMIN_PASSWORD",
|
||||
"APP_ENV", "ENV",
|
||||
} {
|
||||
t.Setenv(name, "")
|
||||
}
|
||||
@@ -40,9 +41,12 @@ func TestLoadApplicationDefaults(t *testing.T) {
|
||||
if cfg.OcrWorkers != 2 {
|
||||
t.Errorf("OcrWorkers = %d, attendu 2", cfg.OcrWorkers)
|
||||
}
|
||||
if cfg.AuthSecret != "dev-secret-change-me" {
|
||||
if cfg.AuthSecret != defaultAuthSecret {
|
||||
t.Errorf("AuthSecret défaut inattendu: %q", cfg.AuthSecret)
|
||||
}
|
||||
if len(cfg.AuthSecret) < minAuthSecretLen {
|
||||
t.Errorf("AuthSecret défaut trop court pour le minimum %d: %q", minAuthSecretLen, cfg.AuthSecret)
|
||||
}
|
||||
if cfg.AdminUsername != "" || cfg.AdminPassword != "" {
|
||||
t.Errorf("identifiants admin doivent être vides par défaut: %+v", cfg)
|
||||
}
|
||||
@@ -56,7 +60,7 @@ func TestLoadApplicationEnvOverrides(t *testing.T) {
|
||||
t.Setenv("UPLOAD_DIR", "/tmp/up")
|
||||
t.Setenv("OCR_LANG", "eng")
|
||||
t.Setenv("OCR_WORKERS", "4")
|
||||
t.Setenv("AUTH_SECRET", "super-secret")
|
||||
t.Setenv("AUTH_SECRET", "super-secret-0123456789abcdef01234567")
|
||||
t.Setenv("ADMIN_USERNAME", "root")
|
||||
t.Setenv("ADMIN_PASSWORD", "toor")
|
||||
|
||||
@@ -65,12 +69,46 @@ func TestLoadApplicationEnvOverrides(t *testing.T) {
|
||||
t.Fatalf("LoadApplicationConfig: %v", err)
|
||||
}
|
||||
if cfg.Port != 9090 || cfg.MaxFileSizeMB != 120 || cfg.DatabaseURL != "postgres://u:p@host:5433/db?sslmode=disable" ||
|
||||
cfg.UploadDir != "/tmp/up" || cfg.OcrLang != "eng" || cfg.OcrWorkers != 4 || cfg.AuthSecret != "super-secret" ||
|
||||
cfg.UploadDir != "/tmp/up" || cfg.OcrLang != "eng" || cfg.OcrWorkers != 4 || cfg.AuthSecret != "super-secret-0123456789abcdef01234567" ||
|
||||
cfg.AdminUsername != "root" || cfg.AdminPassword != "toor" {
|
||||
t.Errorf("overrides non appliqués: %+v", cfg)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadApplicationRejectsShortSecret(t *testing.T) {
|
||||
clearEnv(t)
|
||||
t.Setenv("AUTH_SECRET", "too-short")
|
||||
if _, err := LoadApplicationConfig(); err == nil {
|
||||
t.Error("AUTH_SECRET court : attendu une erreur (min 32)")
|
||||
}
|
||||
|
||||
// Le défaut dev passe en dev mais est refusé en production.
|
||||
clearEnv(t)
|
||||
if _, err := LoadApplicationConfig(); err != nil {
|
||||
t.Errorf("défaut dev en dev : inattendu %v", err)
|
||||
}
|
||||
for _, env := range []string{"prod", "production", "PROD"} {
|
||||
clearEnv(t)
|
||||
t.Setenv("APP_ENV", env)
|
||||
if _, err := LoadApplicationConfig(); err == nil {
|
||||
t.Errorf("défaut dev avec APP_ENV=%q : attendu une erreur", env)
|
||||
}
|
||||
clearEnv(t)
|
||||
t.Setenv("ENV", env)
|
||||
if _, err := LoadApplicationConfig(); err == nil {
|
||||
t.Errorf("défaut dev avec ENV=%q : attendu une erreur", env)
|
||||
}
|
||||
}
|
||||
|
||||
// Un secret long et explicite passe en production.
|
||||
clearEnv(t)
|
||||
t.Setenv("APP_ENV", "prod")
|
||||
t.Setenv("AUTH_SECRET", "prod-secret-0123456789abcdef01234567")
|
||||
if _, err := LoadApplicationConfig(); err != nil {
|
||||
t.Errorf("secret prod valide : inattendu %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadApplicationRejectsInvalidInt(t *testing.T) {
|
||||
clearEnv(t)
|
||||
|
||||
|
||||
@@ -1,9 +1,21 @@
|
||||
-- Reverse de 000007. Réversible SEULEMENT sur base vide (les ressources sont
|
||||
-- détruites dans les deux sens : sans device associé, il n'y a rien à
|
||||
-- préserver).
|
||||
DELETE FROM resources;
|
||||
-- Reverse de 000007. Chemin TESTS uniquement : ne jamais down en production
|
||||
-- avec des données.
|
||||
-- Les ressources retrouvent leur device d'origine via devices.user_id
|
||||
-- (premier device trouvé en cas de multi-device — mapping non bijectif
|
||||
-- assumé) ; les orphelines (user_id NULL, ou user sans device, ou valeur ne
|
||||
-- correspondant à aucun device) sont détruites car owner_id est NOT NULL
|
||||
-- avec FK vers devices.
|
||||
UPDATE resources r
|
||||
SET user_id = d.device_id
|
||||
FROM devices d
|
||||
WHERE d.user_id = r.user_id;
|
||||
|
||||
DELETE FROM resources
|
||||
WHERE user_id IS NULL
|
||||
OR user_id NOT IN (SELECT device_id FROM devices);
|
||||
|
||||
ALTER TABLE resources DROP CONSTRAINT resources_user_id_fkey;
|
||||
ALTER TABLE resources RENAME COLUMN user_id TO owner_id;
|
||||
ALTER TABLE resources ALTER COLUMN owner_id SET NOT NULL;
|
||||
ALTER TABLE resources ADD CONSTRAINT resources_owner_id_fkey
|
||||
FOREIGN KEY (owner_id) REFERENCES devices(device_id) ON DELETE CASCADE;
|
||||
FOREIGN KEY (owner_id) REFERENCES devices(device_id) ON DELETE CASCADE;
|
||||
|
||||
@@ -1,15 +1,35 @@
|
||||
-- Bascule ownership device → user (étapes 6-10 de la tranche identité).
|
||||
-- Destructif ASSUMÉ : à ce stade aucune release V1, la base de dev est RESET
|
||||
-- (DELETE trivial sur une table vide ; PAS de user marqueur). Le modele
|
||||
-- resources reste parfaitement identique par ailleurs.
|
||||
DELETE FROM resources;
|
||||
-- Migration DOUCE et non destructive (cf. #10) : AUCUNE suppression de
|
||||
-- ressources (l'ancien DELETE FROM resources est supprimé).
|
||||
-- Le device d'origine est résolu vers son dernier utilisateur connu
|
||||
-- (devices.user_id) ; les ressources orphelines (device sans user connu ou
|
||||
-- device inconnu) gardent user_id NULL — visibles par personne mais
|
||||
-- conservées — et user_id reste donc NULLABLE après cette migration.
|
||||
|
||||
ALTER TABLE resources DROP CONSTRAINT resources_owner_id_fkey;
|
||||
ALTER TABLE resources RENAME COLUMN owner_id TO user_id;
|
||||
|
||||
-- La colonne hérite du NOT NULL de owner_id : on l'assouplit AVANT le
|
||||
-- backfill pour accueillir les orphelines.
|
||||
ALTER TABLE resources ALTER COLUMN user_id DROP NOT NULL;
|
||||
|
||||
-- Backfill : device → dernier utilisateur connu.
|
||||
UPDATE resources r
|
||||
SET user_id = d.user_id
|
||||
FROM devices d
|
||||
WHERE r.user_id = d.device_id
|
||||
AND d.user_id IS NOT NULL;
|
||||
|
||||
-- Orphelines : tout ce qui ne référence toujours pas un user existant → NULL.
|
||||
UPDATE resources
|
||||
SET user_id = NULL
|
||||
WHERE user_id IS NOT NULL
|
||||
AND user_id NOT IN (SELECT id FROM users);
|
||||
|
||||
ALTER TABLE resources ADD CONSTRAINT resources_user_id_fkey
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;
|
||||
|
||||
-- Les index créés en 000003 (idx_resources_owner, idx_resources_root_name
|
||||
-- sur owner_id) suivent le renommage Intrinsèquement : ils portent désormais
|
||||
-- sur owner_id) suivent le renommage intrinsèquement : ils portent désormais
|
||||
-- sur user_id. L'unicité racine devient donc « 1 nom par USER » (multi-device
|
||||
-- possible pour le même compte).
|
||||
-- possible pour le même compte).
|
||||
|
||||
@@ -1,4 +1,23 @@
|
||||
-- Down de 000008 : retour operation_id TEXT 32-hex → BIGINT.
|
||||
-- PERTES ASSUMÉES, chemin TESTS uniquement (migrate down complet) : seules
|
||||
-- les valeurs exclusivement numériques sur ≤ 18 chiffres significatifs
|
||||
-- (traces héritées paddées par le up, p.ex. '0000…0042' → 42) survivent ;
|
||||
-- les vrais 32-hex client-generated (contenant a-f, ou > 18 chiffres pour
|
||||
-- éviter tout overflow bigint) ne sont pas convertibles et leurs lignes
|
||||
-- sont supprimées. L'ancien `USING operation_id::bigint` échouait sur ces
|
||||
-- valeurs. Ne jamais down en production avec des données V1 : recréer la
|
||||
-- base plutôt que `migrate down`.
|
||||
ALTER TABLE operations DROP CONSTRAINT operations_operation_id_hex_check;
|
||||
|
||||
ALTER TABLE operations
|
||||
ALTER COLUMN operation_id TYPE BIGINT USING operation_id::bigint;
|
||||
ALTER TABLE operations ADD COLUMN operation_id_bigint BIGINT;
|
||||
|
||||
UPDATE operations
|
||||
SET operation_id_bigint = operation_id::bigint
|
||||
WHERE operation_id ~ '^0*[0-9]{1,18}$';
|
||||
|
||||
DELETE FROM operations WHERE operation_id_bigint IS NULL;
|
||||
|
||||
ALTER TABLE operations DROP COLUMN operation_id;
|
||||
ALTER TABLE operations RENAME COLUMN operation_id_bigint TO operation_id;
|
||||
ALTER TABLE operations ALTER COLUMN operation_id SET NOT NULL;
|
||||
ALTER TABLE operations ADD CONSTRAINT operations_unique_per_device UNIQUE (device_id, operation_id);
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
DROP INDEX IF EXISTS idx_resources_owner_updated_active;
|
||||
@@ -0,0 +1,7 @@
|
||||
-- LOT 4 (DATA ownership) : index snapshot delta — ListOwned filtre
|
||||
-- (user_id, updated_at) WHERE deleted_at IS NULL. Numéro réservé au LOT 4
|
||||
-- par le plan TASKS_PARALLELES.md (LOT 5 = 000012, LOT 3 = 000013) : cette
|
||||
-- migration bouche aussi le trou de version (golang-migrate refuse les gaps
|
||||
-- au `Up` une fois 000012/000013 présentes).
|
||||
CREATE INDEX IF NOT EXISTS idx_resources_owner_updated_active
|
||||
ON resources(user_id, updated_at) WHERE deleted_at IS NULL;
|
||||
@@ -0,0 +1 @@
|
||||
DROP INDEX IF EXISTS idx_ocr_jobs_status_created;
|
||||
@@ -0,0 +1,4 @@
|
||||
-- Index composite pour la file OCR : ClaimNext filtre `status = 'queued'` et
|
||||
-- trie par `created_at, job_id` (FIFO). L'index simple (status) de 000005
|
||||
-- est conservé (LOT 4 reste propriétaire du schéma historique).
|
||||
CREATE INDEX IF NOT EXISTS idx_ocr_jobs_status_created ON ocr_jobs(status, created_at);
|
||||
@@ -0,0 +1,2 @@
|
||||
ALTER TABLE operations DROP CONSTRAINT IF EXISTS operations_payload_hash_hex_check;
|
||||
ALTER TABLE operations DROP COLUMN IF EXISTS payload_hash;
|
||||
@@ -0,0 +1,10 @@
|
||||
-- Trace outbox : hash du payload (A9, LOT 3).
|
||||
-- Au rejeu du même (device_id, operation_id) avec un payload différent, le
|
||||
-- serveur rejette en INVALID_REQUEST au lieu d'un skip silencieux.
|
||||
-- Colonne NULLABLE : les traces héritées (pré-000013) restent valides ; pour
|
||||
-- elles, le hash est recalculé en Go depuis le payload stocké.
|
||||
ALTER TABLE operations ADD COLUMN payload_hash TEXT;
|
||||
|
||||
ALTER TABLE operations
|
||||
ADD CONSTRAINT operations_payload_hash_hex_check
|
||||
CHECK (payload_hash IS NULL OR payload_hash ~ '^[0-9a-f]{64}$');
|
||||
@@ -215,6 +215,33 @@ func TestMigrationsUpDown(t *testing.T) {
|
||||
t.Error("FK resources.user_id → users(id) manquante après 000007")
|
||||
}
|
||||
|
||||
// --- 000007 : migration douce (#10) ----------------------------------
|
||||
// user_id NULLABLE (orphelines conservées, pas de DELETE FROM resources).
|
||||
var userIDNullable string
|
||||
err = conn.QueryRow(`
|
||||
SELECT is_nullable FROM information_schema.columns
|
||||
WHERE table_schema = 'public' AND table_name = 'resources' AND column_name = 'user_id'`).Scan(&userIDNullable)
|
||||
if err != nil {
|
||||
t.Fatalf("resources.user_id nullabilité: %v", err)
|
||||
}
|
||||
if userIDNullable != "YES" {
|
||||
t.Error("resources.user_id doit être NULLABLE après 000007 (migration douce, orphelines)")
|
||||
}
|
||||
|
||||
// --- 000011 : index snapshot delta (LOT 4) -----------------------------
|
||||
var ownerUpdatedIdx int
|
||||
err = conn.QueryRow(`
|
||||
SELECT COUNT(*) FROM pg_index i
|
||||
JOIN pg_class t ON t.oid = i.indrelid
|
||||
WHERE t.relname = 'resources' AND i.indisvalid
|
||||
AND pg_get_indexdef(i.indexrelid) LIKE '%idx_resources_owner_updated_active%'`).Scan(&ownerUpdatedIdx)
|
||||
if err != nil {
|
||||
t.Fatalf("000011 index: %v", err)
|
||||
}
|
||||
if ownerUpdatedIdx == 0 {
|
||||
t.Error("index idx_resources_owner_updated_active manquant après 000011")
|
||||
}
|
||||
|
||||
// operation_id outbox = UUID 32-hex client-generated — cf. docs/api-v1.md §6.1
|
||||
var opType string
|
||||
err = conn.QueryRow(`
|
||||
|
||||
@@ -4,12 +4,12 @@ import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
"github.com/kazier/backend/pkg/api"
|
||||
"github.com/kazier/backend/pkg/auth"
|
||||
"github.com/kazier/backend/pkg/passwd"
|
||||
"github.com/kazier/backend/repository"
|
||||
"github.com/kazier/backend/service"
|
||||
@@ -33,9 +33,55 @@ type LoginResponse struct {
|
||||
User LoginUserDTO `json:"user"`
|
||||
}
|
||||
|
||||
// Anti-bruteforce du login (FEEDBACK #12) : limiteur basique en mémoire,
|
||||
// N tentatives / minute / IP sur POST /auth/login, placé AVANT la vérification
|
||||
// argon2 (coûteuse) pour protéger le CPU. Au-delà → 429 RATE_LIMITED.
|
||||
// TODO(suivi) : rate-limit distribué (ex. Redis) + métriques pour les déploiements
|
||||
// multi-réplicas, et budget global coordonné avec le rate-limit POST /devices
|
||||
// (LOT 6) contre le remplissage de table.
|
||||
var (
|
||||
loginRateLimitPerMinute = 60
|
||||
loginRateWindow = time.Minute
|
||||
loginAttemptsMu sync.Mutex
|
||||
loginAttempts = map[string][]time.Time{}
|
||||
)
|
||||
|
||||
// OnLoginRateLimited est un hook d'observabilité appelé quand le limiteur
|
||||
// rejette une tentative (nil par défaut = no-op). Les tests peuvent l'utiliser
|
||||
// pour asserter le déclenchement sans dépendre du timing.
|
||||
var OnLoginRateLimited func(ip string)
|
||||
|
||||
// ResetLoginRateLimit vide le compteur (tests uniquement).
|
||||
func ResetLoginRateLimit() {
|
||||
loginAttemptsMu.Lock()
|
||||
defer loginAttemptsMu.Unlock()
|
||||
loginAttempts = map[string][]time.Time{}
|
||||
}
|
||||
|
||||
// loginRateLimited enregistre une tentative et retourne true si le quota
|
||||
// IP est dépassé (fenêtre glissante).
|
||||
func loginRateLimited(ip string, now time.Time) bool {
|
||||
loginAttemptsMu.Lock()
|
||||
defer loginAttemptsMu.Unlock()
|
||||
cutoff := now.Add(-loginRateWindow)
|
||||
kept := make([]time.Time, 0, len(loginAttempts[ip])+1)
|
||||
for _, t := range loginAttempts[ip] {
|
||||
if t.After(cutoff) {
|
||||
kept = append(kept, t)
|
||||
}
|
||||
}
|
||||
if len(kept) >= loginRateLimitPerMinute {
|
||||
loginAttempts[ip] = kept
|
||||
return true
|
||||
}
|
||||
loginAttempts[ip] = append(kept, now)
|
||||
return false
|
||||
}
|
||||
|
||||
// AuthLogin est la SEULE porte d'émission de token (V1). L'erreur est
|
||||
// volontairement indistinguable entre « username inconnu » et « mauvais mot de
|
||||
// passe » — même code, même message, délai égalisé via passwd.VerifyTimedEqual.
|
||||
// volontairement indistinguable entre « username inconnu », « mauvais mot de
|
||||
// passe » et « device non enregistré » — même code 401, même message, délai
|
||||
// égalisé via passwd.VerifyTimedEqual (anti-oracle, FEEDBACK #12).
|
||||
func AuthLogin(c *gin.Context) {
|
||||
if Store == nil || Store.Repository == nil || Auth == nil {
|
||||
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
|
||||
@@ -51,12 +97,24 @@ func AuthLogin(c *gin.Context) {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "username, password and device_id are required")
|
||||
return
|
||||
}
|
||||
if !deviceIDPattern.MatchString(req.DeviceID) {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_DEVICE_ID", "device_id must be 32 lowercase hex chars")
|
||||
return
|
||||
}
|
||||
|
||||
if loginRateLimited(c.ClientIP(), time.Now()) {
|
||||
if OnLoginRateLimited != nil {
|
||||
OnLoginRateLimited(c.ClientIP())
|
||||
}
|
||||
api.Error(c, http.StatusTooManyRequests, "RATE_LIMITED", "too many login attempts, retry later")
|
||||
return
|
||||
}
|
||||
|
||||
normalized := service.NormalizeUsername(req.Username)
|
||||
user, userErr := Store.Repository.Users.GetByUsernameNormalized(normalized)
|
||||
|
||||
// Même durée de traitement que le compte existe ou non (username inconnu =>
|
||||
// stored vide → vérification contre dummyHash).
|
||||
// stored vide → vérification contre dummyHash aléatoire par boot).
|
||||
stored := ""
|
||||
if userErr == nil && user != nil {
|
||||
stored = user.PasswordHash
|
||||
@@ -69,6 +127,12 @@ func AuthLogin(c *gin.Context) {
|
||||
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not verify credentials")
|
||||
return
|
||||
}
|
||||
// A1 : ne jamais déréférencer user si inconnu — même si Verify (par
|
||||
// extraordinaire) réussissait, on reste en 401.
|
||||
if userErr != nil || user == nil {
|
||||
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "invalid credentials")
|
||||
return
|
||||
}
|
||||
|
||||
exists, err := Store.Repository.Devices.Exists(req.DeviceID)
|
||||
if err != nil {
|
||||
@@ -76,24 +140,31 @@ func AuthLogin(c *gin.Context) {
|
||||
return
|
||||
}
|
||||
if !exists {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_DEVICE_ID", "device not registered")
|
||||
// Volontairement indistinguable d'un mauvais password (anti-oracle).
|
||||
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "invalid credentials")
|
||||
return
|
||||
}
|
||||
|
||||
if err := Store.Repository.Devices.MarkUser(req.DeviceID, user.ID); err != nil {
|
||||
if errors.Is(err, repository.ErrNotFound) {
|
||||
// Course : device supprimé entre Exists et MarkUser → même 401
|
||||
// indistinguable, jamais de token pour un device fantôme.
|
||||
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "invalid credentials")
|
||||
return
|
||||
}
|
||||
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not update device")
|
||||
return
|
||||
}
|
||||
|
||||
token, err := Auth.Issue(user.ID, req.DeviceID)
|
||||
token, expiresAt, err := Auth.IssueWithExpiry(user.ID, req.DeviceID)
|
||||
if err != nil {
|
||||
api.Error(c, http.StatusInternalServerError, "TOKEN_ERROR", "could not issue token")
|
||||
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not issue token")
|
||||
return
|
||||
}
|
||||
|
||||
api.OK(c, LoginResponse{
|
||||
Token: token,
|
||||
ExpiresAt: time.Now().Add(auth.TokenTTL).UnixMilli(),
|
||||
ExpiresAt: expiresAt.UnixMilli(),
|
||||
User: LoginUserDTO{
|
||||
ID: user.ID,
|
||||
Username: user.Username,
|
||||
|
||||
@@ -42,6 +42,8 @@ func setTestStore(t *testing.T) *repository.Repository {
|
||||
func setTestAuth(t *testing.T) {
|
||||
t.Helper()
|
||||
Auth, _ = auth.NewManager("test-secret")
|
||||
ResetLoginRateLimit()
|
||||
ResetDevicesRateLimit()
|
||||
t.Cleanup(func() { Auth = nil })
|
||||
}
|
||||
|
||||
@@ -202,6 +204,71 @@ func TestAuthLoginWrongCredentials(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// TestAuthLoginUnknownUserRegisteredDevice — régression A1 : un username
|
||||
// inconnu ne doit JAMAIS déréférencer user (panic → 500 via Gin recovery).
|
||||
// Le device est enregistré pour isoler la branche « user inconnu » : on attend
|
||||
// 401 UNAUTHORIZED, corps identique au cas « mauvais mot de passe ».
|
||||
func TestAuthLoginUnknownUserRegisteredDevice(t *testing.T) {
|
||||
setTestAuth(t)
|
||||
repo := setTestStore(t)
|
||||
createAdmin(t, repo, "admin", authTestPassword)
|
||||
r := newTestRouterForAuth()
|
||||
|
||||
doAuth(t, r, http.MethodPost, "/api/v1/devices", "", `{"deviceId":"`+authTestDevice+`"}`)
|
||||
|
||||
badPassword := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", `{"username":"admin","password":"wrong-password","device_id":"`+authTestDevice+`"}`)
|
||||
if badPassword.Code != 401 {
|
||||
t.Fatalf("mauvais mot de passe: status %d body %s", badPassword.Code, badPassword.Body.String())
|
||||
}
|
||||
|
||||
ghost := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", `{"username":"ghost","password":"wrong-password","device_id":"`+authTestDevice+`"}`)
|
||||
if ghost.Code != 401 {
|
||||
t.Fatalf("username inconnu: status %d body %s (attendu 401, jamais 500)", ghost.Code, ghost.Body.String())
|
||||
}
|
||||
if !strings.Contains(ghost.Body.String(), "UNAUTHORIZED") {
|
||||
t.Errorf("code attendu UNAUTHORIZED, got %s", ghost.Body.String())
|
||||
}
|
||||
if ghost.Body.String() != badPassword.Body.String() {
|
||||
t.Errorf("réponses distinguables (sécurité):\n%q\n%q", ghost.Body.String(), badPassword.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthLoginRateLimited(t *testing.T) {
|
||||
setTestAuth(t)
|
||||
repo := setTestStore(t)
|
||||
createAdmin(t, repo, "admin", authTestPassword)
|
||||
r := newTestRouterForAuth()
|
||||
doAuth(t, r, http.MethodPost, "/api/v1/devices", "", `{"deviceId":"`+authTestDevice+`"}`)
|
||||
|
||||
oldLimit := loginRateLimitPerMinute
|
||||
loginRateLimitPerMinute = 2
|
||||
hookCalls := 0
|
||||
oldHook := OnLoginRateLimited
|
||||
OnLoginRateLimited = func(ip string) { hookCalls++ }
|
||||
t.Cleanup(func() {
|
||||
loginRateLimitPerMinute = oldLimit
|
||||
OnLoginRateLimited = oldHook
|
||||
ResetLoginRateLimit()
|
||||
})
|
||||
|
||||
badBody := `{"username":"admin","password":"wrong-password","device_id":"` + authTestDevice + `"}`
|
||||
for i := 0; i < 2; i++ {
|
||||
if rec := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", badBody); rec.Code != 401 {
|
||||
t.Fatalf("tentative %d: status %d, attendu 401", i+1, rec.Code)
|
||||
}
|
||||
}
|
||||
rec := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", badBody)
|
||||
if rec.Code != 429 {
|
||||
t.Fatalf("quota dépassé: status %d body %s, attendu 429", rec.Code, rec.Body.String())
|
||||
}
|
||||
if !strings.Contains(rec.Body.String(), "RATE_LIMITED") {
|
||||
t.Errorf("code attendu RATE_LIMITED, got %s", rec.Body.String())
|
||||
}
|
||||
if hookCalls != 1 {
|
||||
t.Errorf("OnLoginRateLimited appelé %d fois, attendu 1", hookCalls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthLoginUnregisteredDevice(t *testing.T) {
|
||||
setTestAuth(t)
|
||||
repo := setTestStore(t)
|
||||
@@ -209,11 +276,11 @@ func TestAuthLoginUnregisteredDevice(t *testing.T) {
|
||||
r := newTestRouterForAuth()
|
||||
|
||||
rec := doAuth(t, r, http.MethodPost, "/api/v1/auth/login", "", `{"username":"admin","password":"`+authTestPassword+`","device_id":"`+authTestDevice+`"}`)
|
||||
if rec.Code != 400 {
|
||||
if rec.Code != 401 {
|
||||
t.Fatalf("device non enregistré: status %d body %s", rec.Code, rec.Body.String())
|
||||
}
|
||||
if !strings.Contains(rec.Body.String(), "INVALID_DEVICE_ID") {
|
||||
t.Errorf("code attendu INVALID_DEVICE_ID, got %s", rec.Body.String())
|
||||
if !strings.Contains(rec.Body.String(), "UNAUTHORIZED") {
|
||||
t.Errorf("code attendu UNAUTHORIZED (anti-oracle), got %s", rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,7 +1,10 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"regexp"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/kazier/backend/pkg/api"
|
||||
@@ -9,12 +12,65 @@ import (
|
||||
|
||||
var deviceIDPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
|
||||
|
||||
// Anti-remplissage de POST /devices (FEEDBACK §moyenne) : l'endpoint est
|
||||
// public et bon marché (un upsert), donc anonyme et floodable. Limiteur
|
||||
// basique en mémoire, N enregistrements / minute / IP → 429 RATE_LIMITED.
|
||||
// Budget large (300) : les usages légitimes (1 device = 1 appel) sont très
|
||||
// loin du seuil ; la protection vise le flood massif, un WAF frontal fera
|
||||
// le reste en prod multi-réplicas.
|
||||
// TODO(suivi) : rate-limit distribué + budget global coordonné avec le
|
||||
// rate-limit login (cf. handlers/auth.go).
|
||||
var (
|
||||
devicesRateLimitPerMinute = 300
|
||||
devicesRateWindow = time.Minute
|
||||
devicesAttemptsMu sync.Mutex
|
||||
devicesAttempts = map[string][]time.Time{}
|
||||
)
|
||||
|
||||
// OnDevicesRateLimited est un hook d'observabilité (nil = no-op).
|
||||
var OnDevicesRateLimited func(ip string)
|
||||
|
||||
// ResetDevicesRateLimit vide le compteur (tests uniquement).
|
||||
func ResetDevicesRateLimit() {
|
||||
devicesAttemptsMu.Lock()
|
||||
defer devicesAttemptsMu.Unlock()
|
||||
devicesAttempts = map[string][]time.Time{}
|
||||
}
|
||||
|
||||
func devicesRateLimited(ip string, now time.Time) bool {
|
||||
devicesAttemptsMu.Lock()
|
||||
defer devicesAttemptsMu.Unlock()
|
||||
cutoff := now.Add(-devicesRateWindow)
|
||||
kept := make([]time.Time, 0, len(devicesAttempts[ip])+1)
|
||||
for _, t := range devicesAttempts[ip] {
|
||||
if t.After(cutoff) {
|
||||
kept = append(kept, t)
|
||||
}
|
||||
}
|
||||
if len(kept) >= devicesRateLimitPerMinute {
|
||||
devicesAttempts[ip] = kept
|
||||
return true
|
||||
}
|
||||
devicesAttempts[ip] = append(kept, now)
|
||||
return false
|
||||
}
|
||||
|
||||
type DeviceRegisterRequest struct {
|
||||
DeviceID string `json:"deviceId"`
|
||||
}
|
||||
|
||||
func DevicesRegister(c *gin.Context) {
|
||||
|
||||
// POST /devices est PUBLIC (sans token) : le device s'enregistre pour
|
||||
// exister, puis le client appelle POST /auth/login pour obtenir son
|
||||
// token user-first (cf. docs/api-v1.md §2).
|
||||
//
|
||||
// NOTE rate-limit : limiteur en mémoire ci-dessus (300/min/IP, 429
|
||||
// au-delà). Si le budget doit changer, ajuster
|
||||
// devicesRateLimitPerMinute + documenter dans docs/api-v1.md.
|
||||
//
|
||||
// NOTE MarkUser : repository.Devices.MarkUser retourne ErrNotFound quand
|
||||
// RowsAffected == 0 (device supprimé entre Exists et UPDATE) ; le login
|
||||
// mappe ce cas en 401 indistinguable (cf. handlers/auth.go).
|
||||
var req DeviceRegisterRequest
|
||||
if err := c.ShouldBindJSON(&req); err != nil || req.DeviceID == "" {
|
||||
api.Error(c, 400, "INVALID_REQUEST", "missing deviceId")
|
||||
@@ -25,6 +81,14 @@ func DevicesRegister(c *gin.Context) {
|
||||
return
|
||||
}
|
||||
|
||||
if devicesRateLimited(c.ClientIP(), time.Now()) {
|
||||
if OnDevicesRateLimited != nil {
|
||||
OnDevicesRateLimited(c.ClientIP())
|
||||
}
|
||||
api.Error(c, http.StatusTooManyRequests, "RATE_LIMITED", "too many device registrations, retry later")
|
||||
return
|
||||
}
|
||||
|
||||
if Store == nil || Store.Repository == nil {
|
||||
api.Error(c, 503, "SERVICE_UNAVAILABLE", "backend not initialized")
|
||||
return
|
||||
|
||||
@@ -8,6 +8,7 @@ import (
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/kazier/backend/pkg/api"
|
||||
"github.com/kazier/backend/service"
|
||||
)
|
||||
|
||||
func intParam(value string, fallback int) int {
|
||||
@@ -21,18 +22,53 @@ func intParam(value string, fallback int) int {
|
||||
return parsed
|
||||
}
|
||||
|
||||
// parsePageParams valide page/pageSize (400 si garbage, cf. FEEDBACK A7/A16)
|
||||
// au lieu du fallback silencieux. Cap pageSize 200 et offset 100000.
|
||||
func parsePageParams(c *gin.Context) (page, pageSize int, ok bool) {
|
||||
page = 1
|
||||
pageSize = 50
|
||||
if v := c.Query("page"); v != "" {
|
||||
p, err := strconv.Atoi(v)
|
||||
if err != nil || p < 1 {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `page`")
|
||||
return 0, 0, false
|
||||
}
|
||||
page = p
|
||||
}
|
||||
if v := c.Query("pageSize"); v != "" {
|
||||
ps, err := strconv.Atoi(v)
|
||||
if err != nil || ps < 1 {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `pageSize`")
|
||||
return 0, 0, false
|
||||
}
|
||||
pageSize = ps
|
||||
}
|
||||
if pageSize > 200 {
|
||||
pageSize = 200
|
||||
}
|
||||
if (page-1)*pageSize > 100000 {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "page offset too large")
|
||||
return 0, 0, false
|
||||
}
|
||||
return page, pageSize, true
|
||||
}
|
||||
|
||||
func FilesList(c *gin.Context) {
|
||||
if Store == nil {
|
||||
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
|
||||
return
|
||||
}
|
||||
userID := c.GetString(UserIDKey)
|
||||
page := intParam(c.Query("page"), 1)
|
||||
pageSize := intParam(c.Query("pageSize"), 50)
|
||||
if pageSize > 200 {
|
||||
pageSize = 200
|
||||
page, pageSize, ok := parsePageParams(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
files, total, err := Store.ListFiles(userID, c.Query("folderId"), page, pageSize, c.Query("sort"), c.Query("order"))
|
||||
folderID := c.Query("folderId")
|
||||
if folderID != "" && !deviceIDPattern.MatchString(folderID) {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `folderId`")
|
||||
return
|
||||
}
|
||||
files, total, err := Store.ListFiles(userID, folderID, page, pageSize, c.Query("sort"), c.Query("order"))
|
||||
if err != nil {
|
||||
writeError(c, err)
|
||||
return
|
||||
@@ -108,6 +144,10 @@ func FilesUpload(c *gin.Context) {
|
||||
}
|
||||
userID := c.GetString(UserIDKey)
|
||||
folderID := c.PostForm("folderId")
|
||||
if folderID != "" && !deviceIDPattern.MatchString(folderID) {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `folderId`")
|
||||
return
|
||||
}
|
||||
// resourceId optionnel : cible un fichier déjà connu (metadata-only de
|
||||
// l'outbox) pour lui attacher ses octets physiques (ex. OCR serveur).
|
||||
resourceID := c.PostForm("resourceId")
|
||||
@@ -134,6 +174,12 @@ func FilesUpload(c *gin.Context) {
|
||||
|
||||
dto, err := Store.Upload(userID, file, folderID, resourceID)
|
||||
if err != nil {
|
||||
// Nom/extension rejetés côté service (TrimSpace, cap 255,
|
||||
// anti-slash/retour-ligne, cf. FEEDBACK A16) → 400, jamais 500.
|
||||
if errors.Is(err, service.ErrInvalidUpload) {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid file name")
|
||||
return
|
||||
}
|
||||
writeError(c, err)
|
||||
return
|
||||
}
|
||||
@@ -165,10 +211,13 @@ func FilesSearch(c *gin.Context) {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "missing required query param `q`")
|
||||
return
|
||||
}
|
||||
page := intParam(c.Query("page"), 1)
|
||||
pageSize := intParam(c.Query("pageSize"), 50)
|
||||
if pageSize > 200 {
|
||||
pageSize = 200
|
||||
if len(q) > 200 {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "query param `q` too long (max 200)")
|
||||
return
|
||||
}
|
||||
page, pageSize, ok := parsePageParams(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
files, total, err := Store.SearchFiles(userID, q, page, pageSize)
|
||||
if err != nil {
|
||||
|
||||
@@ -73,6 +73,7 @@ func setup(t *testing.T) (*gin.Engine, *service.Resources, *repository.Repositor
|
||||
}
|
||||
handlers.Auth = manager
|
||||
handlers.Store = store
|
||||
handlers.ResetDevicesRateLimit()
|
||||
|
||||
gin.SetMode(gin.TestMode)
|
||||
r := gin.New()
|
||||
@@ -517,12 +518,12 @@ func TestFilesPaginationDefaultsAndClamp(t *testing.T) {
|
||||
t.Errorf("clamp pageSize: %+v", env.Meta)
|
||||
}
|
||||
|
||||
// Paramètres invalides → défauts (page=1, pageSize=50)
|
||||
// Paramètres invalides → 400 (plus de fallback silencieux, cf. A16).
|
||||
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?page=0&pageSize=-5", token, nil, "")
|
||||
env = expectOK(t, rec, "invalid-params")
|
||||
if env.Meta == nil || env.Meta.Page != 1 || env.Meta.PageSize != 50 {
|
||||
t.Errorf("defauts page/pageSize: %+v", env.Meta)
|
||||
}
|
||||
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "negative-params")
|
||||
|
||||
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?page=abc&pageSize=zz", token, nil, "")
|
||||
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "garbage-params")
|
||||
|
||||
// sort/order inconnus → pas d'erreur (défaut created_at desc)
|
||||
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files?sort=zzz&order=up&pageSize=10", token, nil, "")
|
||||
@@ -633,3 +634,55 @@ func TestFilesGetOcrOwnerShareAndScoping(t *testing.T) {
|
||||
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/ocr", ownerToken, nil, "")
|
||||
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "ocr-invalid-id")
|
||||
}
|
||||
|
||||
func TestFilesUploadRejectsBadFilename(t *testing.T) {
|
||||
r, _, repo := setup(t)
|
||||
device := repository.NewID()
|
||||
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "bn"), "badname-test-password", device)
|
||||
|
||||
// Body multipart construit à la main : filename brut, NON neutralisé par
|
||||
// le writer stdlib (qui basename/encode de son côté). Le serveur doit
|
||||
// rejeter en 400, jamais 500 (cf. A16).
|
||||
rawUpload := func(filename string) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
boundary := "testboundary123"
|
||||
body := "--" + boundary + "\r\n" +
|
||||
"Content-Disposition: form-data; name=\"file\"; filename=\"" + filename + "\"\r\n" +
|
||||
"Content-Type: application/octet-stream\r\n\r\n" +
|
||||
"hi\r\n" +
|
||||
"--" + boundary + "--\r\n"
|
||||
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/files/upload", token, []byte(body), "multipart/form-data; boundary="+boundary)
|
||||
return rec
|
||||
}
|
||||
|
||||
rec := rawUpload("../../evil.txt")
|
||||
// La stdlib Go basename déjà côté lecture (défense en profondeur côté
|
||||
// service via sanitizeFileName, testé en unitaire + backslash) : le nom
|
||||
// stocké est "evil.txt" et aucun chemin ne s'échappe (destPath dérivé
|
||||
// uniquement de IDs 32-hex + extension sanitizée).
|
||||
env := expectOK(t, rec, "upload-traversal-name")
|
||||
var uploaded fileDTO
|
||||
if err := json.Unmarshal(env.Data, &uploaded); err != nil {
|
||||
t.Fatalf("upload-traversal-name: unmarshal: %v", err)
|
||||
}
|
||||
if uploaded.Name != "evil.txt" {
|
||||
t.Errorf("nom traversal neutralisé attendu \"evil.txt\", got %q", uploaded.Name)
|
||||
}
|
||||
|
||||
// Backslash : préservé par la stdlib → rejet service 400, jamais 500.
|
||||
rec = rawUpload(`bad\name.txt`)
|
||||
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "upload-backslash-name")
|
||||
}
|
||||
|
||||
func TestSearchQTooLong(t *testing.T) {
|
||||
r, _, repo := setup(t)
|
||||
device := repository.NewID()
|
||||
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "ql"), "search-test-password", device)
|
||||
|
||||
long := make([]byte, 201)
|
||||
for i := range long {
|
||||
long[i] = 'a'
|
||||
}
|
||||
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/search?q="+string(long), token, nil, "")
|
||||
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "search-q-too-long")
|
||||
}
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
package handlers_test
|
||||
|
||||
// Tests contrat LOT 6 : ordre statique/param (§1), validation 32-hex et
|
||||
// curseur `after` stricts (A7), validation POST /devices.
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
"github.com/kazier/backend/handlers"
|
||||
"github.com/kazier/backend/repository"
|
||||
)
|
||||
|
||||
// TestFoldersRouteServesListNotParam (§1) : GET /files/folders via le routeur
|
||||
// atteint FoldersList (200), jamais FilesGet avec id="folders".
|
||||
func TestFoldersRouteServesListNotParam(t *testing.T) {
|
||||
r, _, repo := setup(t)
|
||||
device := repository.NewID()
|
||||
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "l6f"), "lot6-test-password", device)
|
||||
|
||||
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/folders", token, nil, "")
|
||||
expectOK(t, rec, "folders-static-wins")
|
||||
}
|
||||
|
||||
// TestFilesGetRejectsFoldersLiteral (§1) : si le routeur tombait un jour sur
|
||||
// FilesGet avec id="folders", le garde 32-hex répond 404 (jamais 200, jamais
|
||||
// 500). Appel direct du handler pour forcer le cas paramétré.
|
||||
func TestFilesGetRejectsFoldersLiteral(t *testing.T) {
|
||||
setup(t)
|
||||
|
||||
gin.SetMode(gin.TestMode)
|
||||
w := httptest.NewRecorder()
|
||||
c, _ := gin.CreateTestContext(w)
|
||||
c.Request = httptest.NewRequest(http.MethodGet, "/api/v1/files/folders", nil)
|
||||
c.Params = gin.Params{{Key: "id", Value: "folders"}}
|
||||
c.Set(handlers.UserIDKey, "00000000000000000000000000000001")
|
||||
|
||||
handlers.FilesGet(c)
|
||||
|
||||
expectError(t, w, http.StatusNotFound, "NOT_FOUND", "files-get-folders-literal")
|
||||
}
|
||||
|
||||
// TestShareLinkMalformedToken400 (A7) : token non 32-hex → 400
|
||||
// INVALID_REQUEST (pas 404).
|
||||
func TestShareLinkMalformedToken400(t *testing.T) {
|
||||
r, _, _ := setup(t)
|
||||
for _, path := range []string{
|
||||
"/api/v1/shares/links/NOT-HEX",
|
||||
"/api/v1/shares/links/xyz",
|
||||
"/api/v1/shares/links/ABCDEF0123456789ABCDEF0123456789", // majuscules rejetées
|
||||
} {
|
||||
rec, _ := doRequest(t, r, http.MethodGet, path, "", nil, "")
|
||||
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "share-malformed-token")
|
||||
}
|
||||
}
|
||||
|
||||
// TestSyncPermissionsAfterValidation (A7) : garbage/négatif → 400, epoch-ms
|
||||
// 64-bit accepté.
|
||||
func TestSyncPermissionsAfterValidation(t *testing.T) {
|
||||
r, _, repo := setup(t)
|
||||
device := repository.NewID()
|
||||
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "l6a"), "lot6-test-password", device)
|
||||
|
||||
for _, path := range []string{
|
||||
"/api/v1/sync/permissions?after=garbage",
|
||||
"/api/v1/sync/permissions?after=-5",
|
||||
"/api/v1/sync/permissions?after=12.5",
|
||||
"/api/v1/sync/permissions?after=",
|
||||
} {
|
||||
// "?after=" vide = curseur absent → 200 (seul le dernier cas).
|
||||
rec, _ := doRequest(t, r, http.MethodGet, path, token, nil, "")
|
||||
if path == "/api/v1/sync/permissions?after=" {
|
||||
expectOK(t, rec, "after-empty-ok")
|
||||
} else {
|
||||
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "after-invalid:"+path)
|
||||
}
|
||||
}
|
||||
|
||||
// Epoch-ms au-delà de 2^31 (64-bit) → 200, pas de troncation/rejet.
|
||||
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/sync/permissions?after=9999999999999", token, nil, "")
|
||||
expectOK(t, rec, "after-64bit-ok")
|
||||
}
|
||||
|
||||
// TestDevicesRegisterValidation : 32-hex malformé/absent → 400, valide → 200.
|
||||
func TestDevicesRegisterValidation(t *testing.T) {
|
||||
r, _, _ := setup(t)
|
||||
|
||||
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":"NOT-HEX"}`), "application/json")
|
||||
expectError(t, rec, http.StatusBadRequest, "INVALID_DEVICE_ID", "devices-malformed")
|
||||
|
||||
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{}`), "application/json")
|
||||
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "devices-missing")
|
||||
|
||||
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":`+`"`+repository.NewID()+`"}`), "application/json")
|
||||
expectOK(t, rec, "devices-valid")
|
||||
}
|
||||
|
||||
// TestDevicesRegisterRateLimited : flood → 429 RATE_LIMITED (budget 300/min/IP,
|
||||
// cf. handlers/devices.go). Les requêtes invalides ne consomment pas le budget.
|
||||
func TestDevicesRegisterRateLimited(t *testing.T) {
|
||||
r, _, _ := setup(t)
|
||||
|
||||
hookCalls := 0
|
||||
handlers.OnDevicesRateLimited = func(ip string) { hookCalls++ }
|
||||
t.Cleanup(func() { handlers.OnDevicesRateLimited = nil })
|
||||
|
||||
// Les requêtes invalides (avant le compteur) ne doivent pas déclencher.
|
||||
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":"BAD"}`), "application/json")
|
||||
expectError(t, rec, http.StatusBadRequest, "INVALID_DEVICE_ID", "devices-ratelimit-invalid")
|
||||
|
||||
for i := 0; i < 300; i++ {
|
||||
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":`+`"`+repository.NewID()+`"}`), "application/json")
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("enregistrement %d: attendu 200, got %d body=%s", i, rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/devices", "", []byte(`{"deviceId":`+`"`+repository.NewID()+`"}`), "application/json")
|
||||
expectError(t, rec, http.StatusTooManyRequests, "RATE_LIMITED", "devices-ratelimited")
|
||||
if hookCalls != 1 {
|
||||
t.Errorf("OnDevicesRateLimited appelé %d fois, attendu 1", hookCalls)
|
||||
}
|
||||
}
|
||||
@@ -2,6 +2,7 @@ package handlers
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"log"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
@@ -19,6 +20,15 @@ const (
|
||||
// Auth issues/verifies device bearer tokens; set once at startup (cmd/server).
|
||||
var Auth *auth.Manager
|
||||
|
||||
// EnforceDeviceExists durcit RequireAuth (FEEDBACK A15) : quand true, le
|
||||
// device_id porté par le token doit exister en base (POST /devices), sinon la
|
||||
// requête est rejetée en 401 et le rejet est loggé côté serveur.
|
||||
// Défaut false (V1) : le device reste un claim porté NON autorisant —
|
||||
// l'autorisation vient du subject user_id + existence du compte. Passer à true
|
||||
// coûte une lecture DB par requête authentifiée ; ne pas activer sans mesurer
|
||||
// sur les routes à fort trafic (snapshot/sync).
|
||||
var EnforceDeviceExists = false
|
||||
|
||||
// RequireAuth authenticates the bearer paseto token. Le subject (user_id)
|
||||
// autorise — c'est la clé de scoping de toutes les ressources ; device_id est
|
||||
// porté (non autorisant) pour l'idempotence outbox et les jobs OCR. Le compte
|
||||
@@ -26,7 +36,13 @@ var Auth *auth.Manager
|
||||
func RequireAuth(c *gin.Context) {
|
||||
|
||||
header := c.GetHeader("Authorization")
|
||||
token, found := strings.CutPrefix(header, "Bearer ")
|
||||
token := ""
|
||||
found := false
|
||||
// Préfixe Bearer insensible à la casse (cf. FEEDBACK A7).
|
||||
if len(header) > 7 && strings.EqualFold(header[:7], "Bearer ") {
|
||||
token = strings.TrimSpace(header[7:])
|
||||
found = token != ""
|
||||
}
|
||||
|
||||
if Auth == nil || !found || token == "" {
|
||||
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "missing bearer token")
|
||||
@@ -57,6 +73,22 @@ func RequireAuth(c *gin.Context) {
|
||||
}
|
||||
}
|
||||
|
||||
if EnforceDeviceExists && Store != nil && Store.Repository != nil {
|
||||
// Verify garantit déjà le format 32-hex : Exists reçoit une entrée saine.
|
||||
exists, err := Store.Repository.Devices.Exists(identity.DeviceID)
|
||||
if err != nil {
|
||||
api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not check device")
|
||||
c.Abort()
|
||||
return
|
||||
}
|
||||
if !exists {
|
||||
log.Printf("auth: token d'un device inconnu rejeté (user=%s device=%s)", identity.UserID, identity.DeviceID)
|
||||
api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "unknown device")
|
||||
c.Abort()
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
c.Set(UserIDKey, identity.UserID)
|
||||
c.Set(DeviceIDKey, identity.DeviceID)
|
||||
c.Next()
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
const middlewareUnknownDevice = "ffffffffffffffffffffffffffffffff"
|
||||
|
||||
// Par défaut (EnforceDeviceExists=false), un token portant un device inconnu
|
||||
// passe le middleware : le device est un claim non autorisant (V1).
|
||||
func TestRequireAuthUnknownDevicePassesByDefault(t *testing.T) {
|
||||
setTestAuth(t)
|
||||
repo := setTestStore(t)
|
||||
userID := createAdmin(t, repo, "admin", authTestPassword)
|
||||
r := newTestRouterForAuth()
|
||||
|
||||
if EnforceDeviceExists {
|
||||
t.Fatal("EnforceDeviceExists devrait être false par défaut")
|
||||
}
|
||||
|
||||
signed, err := Auth.Issue(userID, middlewareUnknownDevice)
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
rec := doAuth(t, r, http.MethodGet, "/api/v1/files", signed, "")
|
||||
if rec.Code == 401 {
|
||||
t.Fatalf("device inconnu rejeté alors que EnforceDeviceExists=false: %s", rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
// Avec EnforceDeviceExists=true, le device inconnu est rejeté en 401 (et
|
||||
// loggé), le device enregistré passe.
|
||||
func TestRequireAuthEnforceDeviceExists(t *testing.T) {
|
||||
setTestAuth(t)
|
||||
repo := setTestStore(t)
|
||||
userID := createAdmin(t, repo, "admin", authTestPassword)
|
||||
_ = repo.Devices.Upsert(authTestDevice)
|
||||
r := newTestRouterForAuth()
|
||||
|
||||
old := EnforceDeviceExists
|
||||
EnforceDeviceExists = true
|
||||
t.Cleanup(func() { EnforceDeviceExists = old })
|
||||
|
||||
unknown, _ := Auth.Issue(userID, middlewareUnknownDevice)
|
||||
rec := doAuth(t, r, http.MethodGet, "/api/v1/files", unknown, "")
|
||||
if rec.Code != 401 {
|
||||
t.Fatalf("device inconnu: status %d body %s, attendu 401", rec.Code, rec.Body.String())
|
||||
}
|
||||
if !strings.Contains(rec.Body.String(), "UNAUTHORIZED") {
|
||||
t.Errorf("code attendu UNAUTHORIZED, got %s", rec.Body.String())
|
||||
}
|
||||
|
||||
known, _ := Auth.Issue(userID, authTestDevice)
|
||||
rec = doAuth(t, r, http.MethodGet, "/api/v1/files", known, "")
|
||||
if rec.Code == 401 {
|
||||
t.Fatalf("device enregistré rejeté avec EnforceDeviceExists=true: %s", rec.Body.String())
|
||||
}
|
||||
}
|
||||
@@ -40,6 +40,7 @@ func setupOcr(t *testing.T) (*gin.Engine, string, *repository.Repository) {
|
||||
manager, _ := auth.NewManager("test-secret")
|
||||
handlers.Auth = manager
|
||||
handlers.Store = store
|
||||
handlers.ResetDevicesRateLimit()
|
||||
handlers.Ocr = service.NewOcr(repo, uploadDir, "fra+eng", stubEngine{text: "HELLO OCR"})
|
||||
|
||||
// Worker OCR borné — le handler n'enfile plus que le job, le traitement
|
||||
|
||||
@@ -25,11 +25,15 @@ func RegisterRoutes(r *gin.Engine) {
|
||||
protected.Use(RequireAuth)
|
||||
{
|
||||
protected.GET("/files", FilesList)
|
||||
// Verrou LOT 6 §1 : les routes statiques restent déclarées AVANT
|
||||
// /files/:id (Gin priorise déjà le statique sur le paramétré, mais
|
||||
// l'ordre source verrouille l'intention : /files/folders ne doit
|
||||
// jamais être avalé par FilesGet avec id="folders").
|
||||
protected.GET("/files/search", FilesSearch)
|
||||
protected.GET("/files/folders", FoldersList)
|
||||
protected.GET("/files/:id", FilesGet)
|
||||
protected.GET("/files/:id/ocr", FilesGetOcr)
|
||||
protected.DELETE("/files/:id", FilesDelete)
|
||||
protected.GET("/files/folders", FoldersList)
|
||||
protected.POST("/files/upload", FilesUpload)
|
||||
|
||||
protected.GET("/users/resolve", ResolveUser)
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
@@ -18,9 +19,18 @@ func ShareLinkGet(c *gin.Context) {
|
||||
return
|
||||
}
|
||||
token := c.Param("token")
|
||||
// Contrat V1 : les tokens de lien sont du 32-hex (cf. docs/api-v1.md).
|
||||
// Malformé → 400 INVALID_REQUEST (pas 404 : ce n'est pas « introuvable »,
|
||||
// c'est « requête invalide »). deviceIDPattern (devices.go, même package)
|
||||
// exprime exactement ce format.
|
||||
if !deviceIDPattern.MatchString(token) {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "malformed link token")
|
||||
return
|
||||
}
|
||||
link, err := Store.Repository.Shares.GetPublicLink(token)
|
||||
if err != nil {
|
||||
if err == repository.ErrNotFound {
|
||||
// A6 : errors.Is (pas ==) — le repo peut envelopper ErrNotFound.
|
||||
if errors.Is(err, repository.ErrNotFound) {
|
||||
api.Error(c, http.StatusNotFound, "NOT_FOUND", "link not found or revoked")
|
||||
return
|
||||
}
|
||||
|
||||
@@ -2,6 +2,7 @@ package handlers
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"log"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/kazier/backend/pkg/api"
|
||||
@@ -28,6 +29,13 @@ func writeError(c *gin.Context, err error) {
|
||||
case errors.Is(err, service.ErrFileTooLarge):
|
||||
api.Error(c, 413, "FILE_TOO_LARGE", "file exceeds the maximum allowed size")
|
||||
default:
|
||||
api.Error(c, 500, "INTERNAL", err.Error())
|
||||
// Jamais de err.Error() brut au client (fuite SQL/FS/paths, cf.
|
||||
// FEEDBACK #8) : message générique, détail au log serveur.
|
||||
path := ""
|
||||
if c.Request != nil && c.Request.URL != nil {
|
||||
path = c.Request.URL.Path
|
||||
}
|
||||
log.Printf("internal error: path=%s err=%v", path, err)
|
||||
api.Error(c, 500, "INTERNAL", "internal error")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,6 +2,7 @@ package handlers
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strconv"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
@@ -9,10 +10,37 @@ import (
|
||||
"github.com/kazier/backend/service"
|
||||
)
|
||||
|
||||
// parseAfterMs parses the `after` delta cursor of GET /sync/permissions :
|
||||
// epoch-millis, 64-bit (les curseurs dépassent 2^31). Chaîne vide → 0 (sync
|
||||
// complet). Garbage ou négatif → ok=false : le handler répond 400
|
||||
// INVALID_REQUEST, jamais de repli silencieux vers 0 (un curseur malformé
|
||||
// pris pour « sync complet » masquerait une désynchro client).
|
||||
// NOTE : intParam (files.go, LOT 2) garde son repli-défaut historique pour la
|
||||
// pagination ; la validation stricte 400 des pages relève du LOT 2
|
||||
// (inter-lots).
|
||||
func parseAfterMs(raw string) (int64, bool) {
|
||||
if raw == "" {
|
||||
return 0, true
|
||||
}
|
||||
ms, err := strconv.ParseInt(raw, 10, 64)
|
||||
if err != nil || ms < 0 {
|
||||
return 0, false
|
||||
}
|
||||
return ms, true
|
||||
}
|
||||
|
||||
type syncOpsRequest struct {
|
||||
Operations []service.SyncOperation `json:"operations"`
|
||||
}
|
||||
|
||||
// Bornes anti-DoS de POST /sync/ops (FEEDBACK §moyenne) : le client envoie des
|
||||
// batchs de 20 ; au-delà de 100 ops ou 1 MiB de body → rejet explicite, jamais
|
||||
// d'OOM sur batch géant.
|
||||
const (
|
||||
maxSyncOpsBodyBytes = 1 << 20
|
||||
maxSyncOpsPerBatch = 100
|
||||
)
|
||||
|
||||
func SyncOpsPush(c *gin.Context) {
|
||||
if Store == nil {
|
||||
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
|
||||
@@ -20,11 +48,16 @@ func SyncOpsPush(c *gin.Context) {
|
||||
}
|
||||
userID := c.GetString(UserIDKey)
|
||||
|
||||
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, maxSyncOpsBodyBytes)
|
||||
var req syncOpsRequest
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body")
|
||||
return
|
||||
}
|
||||
if len(req.Operations) > maxSyncOpsPerBatch {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "too many operations in batch (max 100)")
|
||||
return
|
||||
}
|
||||
|
||||
result, err := Store.ApplyBatch(userID, c.GetString(DeviceIDKey), req.Operations)
|
||||
if err != nil {
|
||||
@@ -40,10 +73,10 @@ func SyncPermissionsGet(c *gin.Context) {
|
||||
return
|
||||
}
|
||||
userID := c.GetString(UserIDKey)
|
||||
after := c.Query("after")
|
||||
var afterMs int64
|
||||
if after != "" {
|
||||
afterMs = int64(intParam(after, 0))
|
||||
afterMs, ok := parseAfterMs(c.Query("after"))
|
||||
if !ok {
|
||||
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `after` cursor, must be non-negative epoch-millis")
|
||||
return
|
||||
}
|
||||
perms, err := Store.Snapshot(userID, afterMs)
|
||||
if err != nil {
|
||||
|
||||
@@ -254,6 +254,20 @@ func TestSyncOpsLargeBatchAccepted(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestSyncOpsBatchTooLargeRejected(t *testing.T) {
|
||||
r, _, repo := setup(t)
|
||||
device := repository.NewID()
|
||||
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "sx"), "sync-test-password", device)
|
||||
|
||||
ops := make([]map[string]any, 0, 101)
|
||||
for i := 0; i < 101; i++ {
|
||||
ops = append(ops, op(repository.NewID(), repository.NewID(), "create_resource", "file", map[string]any{"name": fmt.Sprintf("g%03d.txt", i)}))
|
||||
}
|
||||
|
||||
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/sync/ops", token, syncOpsBody(ops), "application/json")
|
||||
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "sync-batch-too-large")
|
||||
}
|
||||
|
||||
func TestSyncOpsStopsAtFirstNonIdempotentFailure(t *testing.T) {
|
||||
r, _, repo := setup(t)
|
||||
device := repository.NewID()
|
||||
|
||||
@@ -4,13 +4,42 @@ import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/ledongthuc/pdf"
|
||||
)
|
||||
|
||||
const (
|
||||
// tesseractTimeout : budget max par job (A13) — Tesseract ne doit jamais
|
||||
// bloquer un worker indéfiniment (image pathologique).
|
||||
tesseractTimeout = 120 * time.Second
|
||||
// outputCap : plafond stdout/stderr capturés (A13, 2 Mo) — un document
|
||||
// hostile ne doit pas faire exploser la RAM du worker.
|
||||
outputCap = 2 << 20
|
||||
// maxPDFPages : plafond de pages lues (A13) — au-delà, erreur explicite
|
||||
// (pas de troncature silencieuse).
|
||||
maxPDFPages = 50
|
||||
)
|
||||
|
||||
// validTesseractLang : whitelist `^[a-z+]{2,20}$` (A12, défense en profondeur
|
||||
// — le point d'entrée normal est service.normalizeOcrLang). Évite toute
|
||||
// injection via `tesseract -l` (espaces, `;`, options `--...`).
|
||||
func validTesseractLang(lang string) bool {
|
||||
if len(lang) < 2 || len(lang) > 20 {
|
||||
return false
|
||||
}
|
||||
for _, r := range lang {
|
||||
if (r < 'a' || r > 'z') && r != '+' {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// TesseractEngine runs the `tesseract` binary in a subprocess.
|
||||
// Images are OCR'd directly; PDFs have their text layer extracted first
|
||||
// (scanned PDFs → empty text, no rendering pipeline in V1).
|
||||
@@ -18,20 +47,55 @@ type TesseractEngine struct{}
|
||||
|
||||
func NewTesseract() *TesseractEngine { return &TesseractEngine{} }
|
||||
|
||||
// ExtractText implements Engine.
|
||||
// ExtractText implements Engine. Chaque job est borné par tesseractTimeout
|
||||
// (contexte dérivé, annulé en fin d'appel).
|
||||
func (t *TesseractEngine) ExtractText(ctx context.Context, filePath, lang string) (string, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, tesseractTimeout)
|
||||
defer cancel()
|
||||
if strings.ToLower(filepath.Ext(filePath)) == ".pdf" {
|
||||
return extractPDFText(filePath)
|
||||
return extractPDFText(ctx, filePath)
|
||||
}
|
||||
return runTesseract(ctx, filePath, lang)
|
||||
}
|
||||
|
||||
// cappedBuffer borne un flux capturé à `limit` octets et signale la
|
||||
// troncature (erreur explicite côté appelant, pas de coupe silencieuse).
|
||||
type cappedBuffer struct {
|
||||
buf bytes.Buffer
|
||||
limit int
|
||||
truncated bool
|
||||
}
|
||||
|
||||
func (c *cappedBuffer) Write(p []byte) (int, error) {
|
||||
remaining := c.limit - c.buf.Len()
|
||||
if remaining <= 0 {
|
||||
c.truncated = true
|
||||
return len(p), nil // déverse : le process ne bloque pas sur un pipe plein
|
||||
}
|
||||
if len(p) > remaining {
|
||||
c.truncated = true
|
||||
p = p[:remaining]
|
||||
}
|
||||
return c.buf.Write(p)
|
||||
}
|
||||
|
||||
func (c *cappedBuffer) String() string { return c.buf.String() }
|
||||
|
||||
func runTesseract(ctx context.Context, filePath, lang string) (string, error) {
|
||||
// Défense en profondeur (A12) : même si l'appelant ne passe pas par
|
||||
// service.normalizeOcrLang, `-l` ne reçoit jamais de métacaractères.
|
||||
if !validTesseractLang(lang) {
|
||||
return "", fmt.Errorf("tesseract: langue %q invalide", lang)
|
||||
}
|
||||
cmd := exec.CommandContext(ctx, "tesseract", filePath, "stdout", "-l", lang)
|
||||
var stdout, stderr bytes.Buffer
|
||||
cmd.Stdout = &stdout
|
||||
cmd.Stderr = &stderr
|
||||
stdout := &cappedBuffer{limit: outputCap}
|
||||
stderr := &cappedBuffer{limit: outputCap}
|
||||
cmd.Stdout = stdout
|
||||
cmd.Stderr = stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
if errors.Is(ctx.Err(), context.DeadlineExceeded) {
|
||||
return "", fmt.Errorf("tesseract: délai dépassé (%s): %w", tesseractTimeout, ctx.Err())
|
||||
}
|
||||
if errors.Is(ctx.Err(), context.Canceled) {
|
||||
return "", ctx.Err()
|
||||
}
|
||||
@@ -41,24 +105,37 @@ func runTesseract(ctx context.Context, filePath, lang string) (string, error) {
|
||||
}
|
||||
return "", errors.New("tesseract: " + msg)
|
||||
}
|
||||
if stdout.truncated {
|
||||
return "", fmt.Errorf("tesseract: sortie tronquée (> %d octets)", outputCap)
|
||||
}
|
||||
// stderr tronqué avec un run OK : le texte est complet, mais le diagnostic
|
||||
// est perdu — on l'accepte sans échouer le job.
|
||||
return strings.TrimSpace(stdout.String()), nil
|
||||
}
|
||||
|
||||
func extractPDFText(filePath string) (string, error) {
|
||||
func extractPDFText(ctx context.Context, filePath string) (string, error) {
|
||||
f, r, err := pdf.Open(filePath)
|
||||
if err != nil {
|
||||
return "", errors.New("pdf: " + err.Error())
|
||||
}
|
||||
defer f.Close()
|
||||
if n := r.NumPage(); n > maxPDFPages {
|
||||
return "", fmt.Errorf("pdf: %d pages > plafond %d (tronquer = perdre du texte)", n, maxPDFPages)
|
||||
}
|
||||
var builder strings.Builder
|
||||
for i := 1; i <= r.NumPage(); i++ {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return "", fmt.Errorf("pdf: annulé page %d: %w", i, ctx.Err())
|
||||
default:
|
||||
}
|
||||
p := r.Page(i)
|
||||
if p.V.IsNull() {
|
||||
continue
|
||||
return "", fmt.Errorf("pdf: page %d nulle", i)
|
||||
}
|
||||
plain, err := p.GetPlainText(nil)
|
||||
if err != nil {
|
||||
continue
|
||||
return "", fmt.Errorf("pdf: page %d illisible: %w", i, err)
|
||||
}
|
||||
builder.WriteString(plain)
|
||||
builder.WriteString("\n")
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
package ocr
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestValidTesseractLang(t *testing.T) {
|
||||
valid := []string{"fra", "eng", "fra+eng", "de", "abcdefghijklmnopqrst"} // 20 chars
|
||||
for _, lang := range valid {
|
||||
if !validTesseractLang(lang) {
|
||||
t.Errorf("langue %q : attendue valide", lang)
|
||||
}
|
||||
}
|
||||
invalid := []string{
|
||||
"", "e", "fra;rm -rf", "fra eng", "fra+eng --psm",
|
||||
"FRA", "fra-eng", "fra/eng", "abcdefghijklmnopqrstu", // 21 chars
|
||||
"fra\neng", "-l fra",
|
||||
}
|
||||
for _, lang := range invalid {
|
||||
if validTesseractLang(lang) {
|
||||
t.Errorf("langue %q : attendue invalide (injection -l)", lang)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCappedBufferTruncation(t *testing.T) {
|
||||
c := &cappedBuffer{limit: 8}
|
||||
if _, err := c.Write([]byte("12345678")); err != nil {
|
||||
t.Fatalf("write: %v", err)
|
||||
}
|
||||
if c.truncated {
|
||||
t.Error("8 octets pour limite 8 : ne doit pas être tronqué")
|
||||
}
|
||||
if _, err := c.Write([]byte("9")); err != nil {
|
||||
t.Fatalf("write: %v", err)
|
||||
}
|
||||
if !c.truncated {
|
||||
t.Error("9 octets pour limite 8 : doit être marqué tronqué")
|
||||
}
|
||||
if c.String() != "12345678" {
|
||||
t.Errorf("contenu = %q, attendu %q", c.String(), "12345678")
|
||||
}
|
||||
// Écriture massive d'un coup : bornée, jamais plus que `limit`.
|
||||
big := &cappedBuffer{limit: 4}
|
||||
if _, err := big.Write([]byte(strings.Repeat("x", 1<<20))); err != nil {
|
||||
t.Fatalf("write: %v", err)
|
||||
}
|
||||
if !big.truncated || len(big.String()) != 4 {
|
||||
t.Errorf("écriture 1 Mo limite 4 : tronqué=%v len=%d", big.truncated, len(big.String()))
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,10 @@
|
||||
package api
|
||||
|
||||
import "github.com/gin-gonic/gin"
|
||||
import (
|
||||
"log"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
const NotImplementedCode = "NOT_IMPLEMENTED"
|
||||
|
||||
@@ -22,6 +26,14 @@ func OKList(c *gin.Context, data any, page, pageSize, total int) {
|
||||
}
|
||||
|
||||
func Error(c *gin.Context, status int, code, message string) {
|
||||
// LOT 6 §5 : le client ne reçoit que l'enveloppe générique (code +
|
||||
// message sans détail interne — jamais de err.Error() brut). Le détail
|
||||
// va au log serveur pour le diagnostic.
|
||||
path := ""
|
||||
if c.Request != nil && c.Request.URL != nil {
|
||||
path = c.Request.URL.Path
|
||||
}
|
||||
log.Printf("api error: status=%d code=%s message=%s path=%s", status, code, message, path)
|
||||
c.JSON(status, gin.H{
|
||||
"error": gin.H{"code": code, "message": message},
|
||||
})
|
||||
|
||||
@@ -3,6 +3,7 @@ package auth
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"errors"
|
||||
"regexp"
|
||||
"time"
|
||||
|
||||
"aidanwoods.dev/go-paseto"
|
||||
@@ -14,6 +15,8 @@ const TokenTTL = 7 * 24 * time.Hour
|
||||
|
||||
var ErrInvalidToken = errors.New("invalid token")
|
||||
|
||||
var hex32Pattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
|
||||
|
||||
// Identity est le résultat de Verify : l'utilisateur (sujet du token, autorisant)
|
||||
// et le device (claim secondaire, porté mais NON autorisant seul).
|
||||
type Identity struct {
|
||||
@@ -39,29 +42,40 @@ func NewManager(secret string) (*Manager, error) {
|
||||
|
||||
// Issue émet un token lié à un utilisateur ET à un device.
|
||||
func (m *Manager) Issue(userID, deviceID string) (string, error) {
|
||||
token, _, err := m.IssueWithExpiry(userID, deviceID)
|
||||
return token, err
|
||||
}
|
||||
|
||||
// IssueWithExpiry émet un token et retourne son expiration réelle (le `exp`
|
||||
// embarqué). Les appelants doivent exposer expiresAt, jamais le recalculer
|
||||
// via Now()+TTL (dérive d'horloge, cf. FEEDBACK A7).
|
||||
func (m *Manager) IssueWithExpiry(userID, deviceID string) (string, time.Time, error) {
|
||||
now := time.Now()
|
||||
expiresAt := now.Add(TokenTTL)
|
||||
token := paseto.NewToken()
|
||||
token.SetIssuedAt(now)
|
||||
token.SetNotBefore(now)
|
||||
token.SetExpiration(now.Add(TokenTTL))
|
||||
token.SetExpiration(expiresAt)
|
||||
token.SetSubject(userID)
|
||||
// v1.6.0 : SetString n'expose pas d'erreur (panic si non sérialisable).
|
||||
token.SetString("device_id", deviceID)
|
||||
return token.V4Encrypt(m.key, nil), nil
|
||||
return token.V4Encrypt(m.key, nil), expiresAt, nil
|
||||
}
|
||||
|
||||
// Verify décode et contrôle le token, retourne l'identité (user + device).
|
||||
// Les deux identifiants doivent être 32-hex (cf. docs/api-v1.md) — rejet
|
||||
// sinon pour préserver les invariants UNIQUE(device_id,operation_id)/CHECK.
|
||||
func (m *Manager) Verify(signed string) (Identity, error) {
|
||||
parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil)
|
||||
if err != nil {
|
||||
return Identity{}, ErrInvalidToken
|
||||
}
|
||||
userID, err := parsed.GetSubject()
|
||||
if err != nil || userID == "" {
|
||||
if err != nil || !hex32Pattern.MatchString(userID) {
|
||||
return Identity{}, ErrInvalidToken
|
||||
}
|
||||
deviceID, err := parsed.GetString("device_id")
|
||||
if err != nil || deviceID == "" {
|
||||
if err != nil || !hex32Pattern.MatchString(deviceID) {
|
||||
return Identity{}, ErrInvalidToken
|
||||
}
|
||||
return Identity{UserID: userID, DeviceID: deviceID}, nil
|
||||
|
||||
@@ -96,6 +96,44 @@ func TestVerifyRequiresDeviceClaim(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerifyRejectsNonHex32IDs(t *testing.T) {
|
||||
m, _ := NewManager("test-secret")
|
||||
|
||||
issueWith := func(userID, deviceID string) string {
|
||||
token := paseto.NewToken()
|
||||
now := time.Now()
|
||||
token.SetIssuedAt(now)
|
||||
token.SetNotBefore(now)
|
||||
token.SetExpiration(now.Add(TokenTTL))
|
||||
token.SetSubject(userID)
|
||||
token.SetString("device_id", deviceID)
|
||||
return token.V4Encrypt(m.key, nil)
|
||||
}
|
||||
|
||||
cases := map[string][2]string{
|
||||
"subject vide": {"", testDeviceID},
|
||||
"subject non-hex": {"not-hex-at-all-!!!!!!!!!!!!!!!!", testDeviceID},
|
||||
"subject majuscules": {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", testDeviceID},
|
||||
"subject trop court": {"abc123", testDeviceID},
|
||||
"device vide": {testUserID, ""},
|
||||
"device non-hex": {testUserID, "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"},
|
||||
"device majuscules": {testUserID, "0123456789ABCDEF0123456789ABCDEF"},
|
||||
"device trop long": {testUserID, testDeviceID + "00"},
|
||||
"device avec tirets": {testUserID, "01234567-89ab-cdef-0123-456789abcdef"},
|
||||
}
|
||||
for name, ids := range cases {
|
||||
signed := issueWith(ids[0], ids[1])
|
||||
if _, err := m.Verify(signed); err == nil {
|
||||
t.Errorf("%s: token accepté (user=%q device=%q), attendu rejet", name, ids[0], ids[1])
|
||||
}
|
||||
}
|
||||
|
||||
// Sanity : les IDs 32-hex valides passent toujours.
|
||||
if _, err := m.Verify(issueWith(testUserID, testDeviceID)); err != nil {
|
||||
t.Errorf("IDs valides rejetés: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIssueSetsExpiration(t *testing.T) {
|
||||
m, _ := NewManager("test-secret")
|
||||
before := time.Now()
|
||||
@@ -118,3 +156,25 @@ func TestIssueSetsExpiration(t *testing.T) {
|
||||
t.Errorf("expiration = %v, attendu ≈ now+%v (fenêtre [%v, %v])", exp, TokenTTL, lower, upper)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIssueWithExpiryMatchesTokenExp(t *testing.T) {
|
||||
m, _ := NewManager("test-secret")
|
||||
signed, expiresAt, err := m.IssueWithExpiry(testUserID, testDeviceID)
|
||||
if err != nil {
|
||||
t.Fatalf("IssueWithExpiry: %v", err)
|
||||
}
|
||||
parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("parse: %v", err)
|
||||
}
|
||||
exp, err := parsed.GetExpiration()
|
||||
if err != nil {
|
||||
t.Fatalf("GetExpiration: %v", err)
|
||||
}
|
||||
// L'expiresAt retourné doit être le exp embarqué (pas un Now()+TTL
|
||||
// recalculé — cf. FEEDBACK A7). Comparaison à la seconde : le token
|
||||
// sérialise sans lecture monotonique ni sous-seconde.
|
||||
if exp.Unix() != expiresAt.Unix() {
|
||||
t.Errorf("expiresAt = %v, exp token = %v", expiresAt, exp)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -30,12 +30,17 @@ var (
|
||||
ErrMalformed = errors.New("malformed password hash")
|
||||
)
|
||||
|
||||
// dummyHash est un hash argon2id valide d'un mot de passe aléatoire fixe.
|
||||
// Il sert d'égalisation de timing : quand le username est inconnu, on vérifie
|
||||
// quand même contre ce hash pour que le délai de réponse soit identique à un
|
||||
// « mauvais mot de passe ».
|
||||
// dummyHash est un hash argon2id valide d'un mot de passe aléatoire généré
|
||||
// au boot. Il sert d'égalisation de timing : quand le username est inconnu,
|
||||
// on vérifie quand même contre ce hash pour que le délai de réponse soit
|
||||
// identique à un « mauvais mot de passe ». Aléatoire par boot pour éviter
|
||||
// toute préimage hardcodée (cf. FEEDBACK A1).
|
||||
var dummyHash = func() string {
|
||||
h, err := Hash("kazier-constantime-dummy")
|
||||
raw := make([]byte, 32)
|
||||
if _, err := rand.Read(raw); err != nil {
|
||||
panic(fmt.Sprintf("passwd: entropie dummy indisponible: %v", err))
|
||||
}
|
||||
h, err := Hash(string(raw))
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("passwd: impossible de pré-hacher le dummy: %v", err))
|
||||
}
|
||||
@@ -75,6 +80,18 @@ func Verify(password, stored string) error {
|
||||
if _, err := fmt.Sscanf(fields[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil {
|
||||
return ErrMalformed
|
||||
}
|
||||
// Caps anti-DoS : un hash stocké compromis ne doit pas provoquer un
|
||||
// OOM/CPU arbitraire au prochain login (cf. FEEDBACK §moyenne).
|
||||
const (
|
||||
maxMemory = 256 * 1024 // 256 MiB
|
||||
maxTime = 10
|
||||
maxThreads = 8
|
||||
maxKeyLen = 128
|
||||
maxSaltLen = 128
|
||||
)
|
||||
if memory <= 0 || memory > maxMemory || timeCost <= 0 || timeCost > maxTime || threads <= 0 || threads > maxThreads {
|
||||
return ErrMalformed
|
||||
}
|
||||
|
||||
salt, err := base64.RawStdEncoding.DecodeString(fields[4])
|
||||
if err != nil {
|
||||
@@ -84,6 +101,9 @@ func Verify(password, stored string) error {
|
||||
if err != nil {
|
||||
return ErrMalformed
|
||||
}
|
||||
if len(salt) == 0 || len(salt) > maxSaltLen || len(want) == 0 || len(want) > maxKeyLen {
|
||||
return ErrMalformed
|
||||
}
|
||||
|
||||
got := argon2.IDKey([]byte(password), salt, uint32(timeCost), uint32(memory), uint8(threads), uint32(len(want)))
|
||||
if subtle.ConstantTimeCompare(got, want) != 1 {
|
||||
|
||||
@@ -33,10 +33,22 @@ func (d *Devices) Exists(deviceID string) (bool, error) {
|
||||
|
||||
// MarkUser mémorise le dernier utilisateur connecté sur ce device (INFORMATIF,
|
||||
// jamais autorisant) et rafraîchit last_seen_at. Appelé au login.
|
||||
// Device absent → ErrNotFound (le handler distingue la course
|
||||
// Exists→MarkUser au lieu d'émettre un token pour un device fantôme).
|
||||
func (d *Devices) MarkUser(deviceID, userID string) error {
|
||||
_, err := d.DB.Exec(
|
||||
result, err := d.DB.Exec(
|
||||
`UPDATE devices SET user_id = $2, last_seen_at = NOW() WHERE device_id = $1`,
|
||||
deviceID, userID,
|
||||
)
|
||||
return err
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"github.com/kazier/backend/dbtest"
|
||||
@@ -71,3 +72,12 @@ func TestDevicesMarkUser(t *testing.T) {
|
||||
t.Errorf("user_id mémorisé = %q, attendu %q", storedUser, userID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDevicesMarkUserUnknownDevice(t *testing.T) {
|
||||
d := newTestDevices(t)
|
||||
// Device jamais enregistré → ErrNotFound (pas de UPDATE silencieux à
|
||||
// 0 ligne) : le login mappe ce cas en 401 au lieu d'émettre un token.
|
||||
if err := d.MarkUser(NewID(), NewID()); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("MarkUser device inconnu: attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -22,6 +22,12 @@ var ErrJobNotFound = errors.New("ocr job not found")
|
||||
// ErrNoQueuedJobs marks an OCR queue drained (no job to claim).
|
||||
var ErrNoQueuedJobs = errors.New("no queued ocr jobs")
|
||||
|
||||
// ErrJobStateConflict marks a guarded transition attempted from an
|
||||
// unexpected state (double Complete, Fail of a non-processing job,
|
||||
// TouchProcessing of a non-queued job). Terminal states are sticky:
|
||||
// a second transition never overwrites the first.
|
||||
var ErrJobStateConflict = errors.New("ocr job state conflict")
|
||||
|
||||
type OcrJobs struct{ DB *sql.DB }
|
||||
|
||||
func (o *OcrJobs) Create(jobID, deviceID, fileID string) error {
|
||||
@@ -58,12 +64,22 @@ func (o *OcrJobs) Get(deviceID, jobID string) (OcrJobRow, error) {
|
||||
}
|
||||
|
||||
func (o *OcrJobs) TouchProcessing(deviceID, jobID string) error {
|
||||
_, err := o.DB.Exec(
|
||||
res, err := o.DB.Exec(
|
||||
`UPDATE ocr_jobs SET status = 'processing', started_at = NOW()
|
||||
WHERE job_id = $1 AND device_id = $2 AND status = 'queued'`,
|
||||
jobID, deviceID,
|
||||
)
|
||||
return err
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 0 {
|
||||
return ErrJobStateConflict
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ClaimNext atomically picks the oldest queued job (FIFO) and moves it to
|
||||
@@ -96,12 +112,15 @@ func (o *OcrJobs) ClaimNext() (OcrJobRow, error) {
|
||||
|
||||
// ResetStaleProcessing requeues jobs stuck in `processing` (worker crash /
|
||||
// processus redémarré) et plus vieux que `olderThan`. Retourne le nb de jobs
|
||||
// requeued.
|
||||
// requeued. La comparaison utilise l'horloge DB (NOW(), pas time.Now() du
|
||||
// process) pour rester correcte même si les horloges divergent. Les jobs sans
|
||||
// `started_at` (claim sans timestamp, anomalie) sont aussi requeued.
|
||||
func (o *OcrJobs) ResetStaleProcessing(olderThan time.Duration) (int64, error) {
|
||||
res, err := o.DB.Exec(
|
||||
`UPDATE ocr_jobs SET status = 'queued', started_at = NULL
|
||||
WHERE status = 'processing' AND started_at < $1`,
|
||||
time.Now().Add(-olderThan),
|
||||
WHERE status = 'processing'
|
||||
AND (started_at IS NULL OR started_at < NOW() - ($1::bigint * INTERVAL '1 millisecond'))`,
|
||||
olderThan.Milliseconds(),
|
||||
)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
@@ -110,19 +129,39 @@ func (o *OcrJobs) ResetStaleProcessing(olderThan time.Duration) (int64, error) {
|
||||
}
|
||||
|
||||
func (o *OcrJobs) Complete(deviceID, jobID, text string) error {
|
||||
_, err := o.DB.Exec(
|
||||
res, err := o.DB.Exec(
|
||||
`UPDATE ocr_jobs SET status = 'done', text = NULLIF($3, ''), started_at = COALESCE(started_at, NOW()), completed_at = NOW()
|
||||
WHERE job_id = $1 AND device_id = $2`,
|
||||
WHERE job_id = $1 AND device_id = $2 AND status = 'processing'`,
|
||||
jobID, deviceID, text,
|
||||
)
|
||||
return err
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 0 {
|
||||
return ErrJobStateConflict
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (o *OcrJobs) Fail(deviceID, jobID, message string) error {
|
||||
_, err := o.DB.Exec(
|
||||
res, err := o.DB.Exec(
|
||||
`UPDATE ocr_jobs SET status = 'failed', error = NULLIF($3, ''), started_at = COALESCE(started_at, NOW()), completed_at = NOW()
|
||||
WHERE job_id = $1 AND device_id = $2`,
|
||||
WHERE job_id = $1 AND device_id = $2 AND status = 'processing'`,
|
||||
jobID, deviceID, message,
|
||||
)
|
||||
return err
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 0 {
|
||||
return ErrJobStateConflict
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -67,6 +67,10 @@ func TestOcrJobsFail(t *testing.T) {
|
||||
if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
// Fail n'est valide que depuis `processing` (transition gardée).
|
||||
if err := repo.OcrJobs.TouchProcessing(deviceID, jobID); err != nil {
|
||||
t.Fatalf("touch processing: %v", err)
|
||||
}
|
||||
if err := repo.OcrJobs.Fail(deviceID, jobID, "tesseract exploded"); err != nil {
|
||||
t.Fatalf("fail: %v", err)
|
||||
}
|
||||
@@ -76,6 +80,71 @@ func TestOcrJobsFail(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestOcrJobsGuardedTransitions(t *testing.T) {
|
||||
repo, _, deviceID, fileID := seedOcrJobFixture(t)
|
||||
newJob := func(t *testing.T) string {
|
||||
t.Helper()
|
||||
jobID := NewID()
|
||||
if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
return jobID
|
||||
}
|
||||
|
||||
// Fail depuis `queued` → conflit, le job reste queued.
|
||||
queued := newJob(t)
|
||||
if err := repo.OcrJobs.Fail(deviceID, queued, "boom"); !errors.Is(err, ErrJobStateConflict) {
|
||||
t.Errorf("fail depuis queued : attendu ErrJobStateConflict, got %v", err)
|
||||
}
|
||||
if row, _ := repo.OcrJobs.Get(deviceID, queued); row.Status != "queued" {
|
||||
t.Errorf("fail depuis queued : status = %q, attendu queued", row.Status)
|
||||
}
|
||||
|
||||
// Complete depuis `queued` → conflit.
|
||||
if err := repo.OcrJobs.Complete(deviceID, queued, "x"); !errors.Is(err, ErrJobStateConflict) {
|
||||
t.Errorf("complete depuis queued : attendu ErrJobStateConflict, got %v", err)
|
||||
}
|
||||
|
||||
// Double TouchProcessing → conflit.
|
||||
if err := repo.OcrJobs.TouchProcessing(deviceID, queued); err != nil {
|
||||
t.Fatalf("touch processing: %v", err)
|
||||
}
|
||||
if err := repo.OcrJobs.TouchProcessing(deviceID, queued); !errors.Is(err, ErrJobStateConflict) {
|
||||
t.Errorf("double touch : attendu ErrJobStateConflict, got %v", err)
|
||||
}
|
||||
|
||||
// Double Complete → le premier gagne, le second est un conflit.
|
||||
if err := repo.OcrJobs.Complete(deviceID, queued, "FIRST"); err != nil {
|
||||
t.Fatalf("complete: %v", err)
|
||||
}
|
||||
if err := repo.OcrJobs.Complete(deviceID, queued, "SECOND"); !errors.Is(err, ErrJobStateConflict) {
|
||||
t.Errorf("double complete : attendu ErrJobStateConflict, got %v", err)
|
||||
}
|
||||
if row, _ := repo.OcrJobs.Get(deviceID, queued); row.Text == nil || *row.Text != "FIRST" {
|
||||
t.Errorf("double complete : texte = %+v, attendu FIRST", row.Text)
|
||||
}
|
||||
|
||||
// Fail après Complete → conflit, le statut `done` est collant.
|
||||
if err := repo.OcrJobs.Fail(deviceID, queued, "late"); !errors.Is(err, ErrJobStateConflict) {
|
||||
t.Errorf("fail après done : attendu ErrJobStateConflict, got %v", err)
|
||||
}
|
||||
if row, _ := repo.OcrJobs.Get(deviceID, queued); row.Status != "done" {
|
||||
t.Errorf("fail après done : status = %q, attendu done", row.Status)
|
||||
}
|
||||
|
||||
// Complete après Fail → conflit.
|
||||
failed := newJob(t)
|
||||
if err := repo.OcrJobs.TouchProcessing(deviceID, failed); err != nil {
|
||||
t.Fatalf("touch processing: %v", err)
|
||||
}
|
||||
if err := repo.OcrJobs.Fail(deviceID, failed, "boom"); err != nil {
|
||||
t.Fatalf("fail: %v", err)
|
||||
}
|
||||
if err := repo.OcrJobs.Complete(deviceID, failed, "late"); !errors.Is(err, ErrJobStateConflict) {
|
||||
t.Errorf("complete après failed : attendu ErrJobStateConflict, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOcrJobsGetScopedByDevice(t *testing.T) {
|
||||
repo, _, deviceID, fileID := seedOcrJobFixture(t)
|
||||
jobID := NewID()
|
||||
@@ -179,3 +248,24 @@ func TestOcrJobsResetStaleProcessing(t *testing.T) {
|
||||
t.Errorf("status après reset = %q, attendu queued", row.Status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOcrJobsResetStaleProcessingNullStartedAt(t *testing.T) {
|
||||
repo, _, deviceID, fileID := seedOcrJobFixture(t)
|
||||
jobID := NewID()
|
||||
if err := repo.OcrJobs.Create(jobID, deviceID, fileID); err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
// Job passé en `processing` sans `started_at` (anomalie de claim) → stale.
|
||||
if _, err := repo.OcrJobs.DB.Exec(
|
||||
`UPDATE ocr_jobs SET status = 'processing', started_at = NULL WHERE job_id = $1`, jobID); err != nil {
|
||||
t.Fatalf("forcer processing sans started_at: %v", err)
|
||||
}
|
||||
if n, err := repo.OcrJobs.ResetStaleProcessing(time.Minute); err != nil {
|
||||
t.Fatalf("reset: %v", err)
|
||||
} else if n != 1 {
|
||||
t.Errorf("reset started_at NULL : attendu 1, got %d", n)
|
||||
}
|
||||
if row, _ := repo.OcrJobs.Get(deviceID, jobID); row.Status != "queued" {
|
||||
t.Errorf("status après reset = %q, attendu queued", row.Status)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"database/sql"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"regexp"
|
||||
@@ -16,9 +18,26 @@ type Operations struct {
|
||||
DB *sql.DB
|
||||
}
|
||||
|
||||
// Statuts de la trace outbox (CHECK status IN ('applied','failed'), 000004).
|
||||
// 'failed' = brouillon claimé pas encore confirmé (ou apply en échec) ;
|
||||
// 'applied' = effet durable confirmé.
|
||||
const (
|
||||
OpStatusApplied = "applied"
|
||||
OpStatusFailed = "failed"
|
||||
)
|
||||
|
||||
// ErrInvalidOperationID is returned when operation_id is not 32 lowercase hex.
|
||||
var ErrInvalidOperationID = errors.New("operation_id must be 32 lowercase hex chars")
|
||||
|
||||
// ErrInvalidPayload is returned when the trace payload is not valid JSON.
|
||||
// Le service le mappe en INVALID_REQUEST (faute client, message statique sûr).
|
||||
var ErrInvalidPayload = errors.New("invalid payload JSON")
|
||||
|
||||
// ErrPayloadMismatch is returned when an operation is replayed under the same
|
||||
// (device_id, operation_id) with a different payload (cf. A9). The replay
|
||||
// must halt in INVALID_REQUEST, never skip silently.
|
||||
var ErrPayloadMismatch = errors.New("operation replayed with different payload")
|
||||
|
||||
// Applied reports whether the operation was already processed for this device.
|
||||
func (o *Operations) Applied(deviceID, operationID string) (bool, error) {
|
||||
var exists int
|
||||
@@ -32,20 +51,157 @@ func (o *Operations) Applied(deviceID, operationID string) (bool, error) {
|
||||
return err == nil, err
|
||||
}
|
||||
|
||||
// StoredOp is the persisted trace of an applied operation (replay compare).
|
||||
type StoredOp struct {
|
||||
OpType string
|
||||
ResourceID string
|
||||
Payload []byte
|
||||
Status string
|
||||
PayloadHash string // "" = trace héritée pré-000013 (hash recalculé depuis Payload)
|
||||
}
|
||||
|
||||
// Get returns the stored trace for (device, operation), or sql.ErrNoRows.
|
||||
func (o *Operations) Get(deviceID, operationID string) (StoredOp, error) {
|
||||
var op StoredOp
|
||||
var resourceID sql.NullString
|
||||
var payloadHash sql.NullString
|
||||
var payload []byte
|
||||
err := o.DB.QueryRow(
|
||||
`SELECT op_type, resource_id, COALESCE(payload::text, '{}'), status, payload_hash
|
||||
FROM operations WHERE device_id = $1 AND operation_id = $2`,
|
||||
deviceID, operationID,
|
||||
).Scan(&op.OpType, &resourceID, &payload, &op.Status, &payloadHash)
|
||||
if err != nil {
|
||||
return StoredOp{}, err
|
||||
}
|
||||
if resourceID.Valid {
|
||||
op.ResourceID = resourceID.String
|
||||
}
|
||||
if payloadHash.Valid {
|
||||
op.PayloadHash = payloadHash.String
|
||||
}
|
||||
op.Payload = payload
|
||||
return op, nil
|
||||
}
|
||||
|
||||
// Claim atomically takes ownership of an operation slot for this device
|
||||
// (#7 : sérialisation des batches concurrents sur la contrainte
|
||||
// UNIQUE(device_id, operation_id)). Premier appelant → claimed=true, la ligne
|
||||
// est insérée en status='failed' (brouillon) avec le hash du payload ; le
|
||||
// perdant du conflit (claimed=false) suit le chemin rejeu (comparer via Get).
|
||||
// Après apply réussi, l'appelant promeut la ligne via MarkApplied ; en cas
|
||||
// d'échec d'apply, la ligne reste 'failed' (rejouable à payload identique).
|
||||
func (o *Operations) Claim(deviceID, operationID string, opType, refType string, refID *int64, resourceID string, payload []byte) (bool, error) {
|
||||
if !operationIDPattern.MatchString(operationID) {
|
||||
return false, ErrInvalidOperationID
|
||||
}
|
||||
if len(payload) != 0 && string(payload) != "null" && !json.Valid(payload) {
|
||||
return false, ErrInvalidPayload
|
||||
}
|
||||
var refTypeValue any
|
||||
if refType != "" {
|
||||
refTypeValue = refType
|
||||
}
|
||||
res, err := o.DB.Exec(
|
||||
`INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload, payload_hash, status)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'failed')
|
||||
ON CONFLICT (device_id, operation_id) DO NOTHING`,
|
||||
deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload), CanonicalPayloadHash(payload),
|
||||
)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
affected, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return affected == 1, nil
|
||||
}
|
||||
|
||||
// MarkApplied promotes a claimed ('failed') trace row to 'applied' once the
|
||||
// operation effect is durable. Best-effort : l'échec est remonté pour que le
|
||||
// batch retourne applied:i explicite (rejouable, pas 500 nu).
|
||||
func (o *Operations) MarkApplied(deviceID, operationID string) error {
|
||||
res, err := o.DB.Exec(
|
||||
`UPDATE operations SET status = 'applied'
|
||||
WHERE device_id = $1 AND operation_id = $2 AND status = 'failed'`,
|
||||
deviceID, operationID,
|
||||
)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 0 {
|
||||
// Déjà promue (rejeu concurrent) ou ligne absente : pas d'erreur,
|
||||
// l'idempotence est portée par la contrainte d'unicité.
|
||||
return nil
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// MatchesReplay reports whether an incoming operation matches the stored
|
||||
// trace: same op type, same resource, same canonical payload hash. Legacy
|
||||
// rows (payload_hash NULL, pré-000013) comparent le hash recalculé depuis le
|
||||
// payload stocké. Mismatch → ErrPayloadMismatch (wrappable via errors.Is).
|
||||
func (op StoredOp) MatchesReplay(opType, resourceID string, payload []byte) error {
|
||||
if op.OpType != opType || op.ResourceID != resourceID {
|
||||
return ErrPayloadMismatch
|
||||
}
|
||||
want := CanonicalPayloadHash(payload)
|
||||
got := op.PayloadHash
|
||||
if got == "" {
|
||||
got = CanonicalPayloadHash(op.Payload)
|
||||
}
|
||||
if got != want {
|
||||
return ErrPayloadMismatch
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanonicalPayloadHash is sha256-hex of the canonical payload form: empty /
|
||||
// "null" → {}, sinon round-trip JSON (clés triées, espaces neutralisés) pour
|
||||
// que deux sérialisations du même objet donnent le même hash.
|
||||
func CanonicalPayloadHash(payload []byte) string {
|
||||
sum := sha256.Sum256(canonicalPayloadBytes(payload))
|
||||
return hex.EncodeToString(sum[:])
|
||||
}
|
||||
|
||||
func canonicalPayloadBytes(payload []byte) []byte {
|
||||
if len(payload) == 0 || string(payload) == "null" {
|
||||
return []byte(`{}`)
|
||||
}
|
||||
var v any
|
||||
if err := json.Unmarshal(payload, &v); err != nil {
|
||||
return []byte(`{}`)
|
||||
}
|
||||
out, err := json.Marshal(v)
|
||||
if err != nil {
|
||||
return []byte(`{}`)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// Record stores an applied operation trace (idempotent on replay).
|
||||
// Le hash canonique du payload est persisté (000013, cf. A9) ; status='applied'.
|
||||
func (o *Operations) Record(deviceID, operationID string, opType, refType string, refID *int64, resourceID string, payload []byte) error {
|
||||
if !operationIDPattern.MatchString(operationID) {
|
||||
return ErrInvalidOperationID
|
||||
}
|
||||
if len(payload) != 0 && string(payload) != "null" && !json.Valid(payload) {
|
||||
return ErrInvalidPayload
|
||||
}
|
||||
var refTypeValue any
|
||||
if refType != "" {
|
||||
refTypeValue = refType
|
||||
}
|
||||
_, err := o.DB.Exec(
|
||||
`INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7)
|
||||
`INSERT INTO operations (device_id, operation_id, op_type, ref_type, ref_id, resource_id, payload, payload_hash, status)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'applied')
|
||||
ON CONFLICT (device_id, operation_id) DO NOTHING`,
|
||||
deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload),
|
||||
deviceID, operationID, opType, refTypeValue, refID, nullable(resourceID), jsonBytes(payload), CanonicalPayloadHash(payload),
|
||||
)
|
||||
return err
|
||||
}
|
||||
@@ -62,7 +218,9 @@ func jsonBytes(payload []byte) any {
|
||||
return []byte(`{}`)
|
||||
}
|
||||
if !json.Valid(payload) {
|
||||
return []byte(`{}`)
|
||||
// Trace infidèle refusée (cf. A15) : l'appelant doit rejeter en amont ;
|
||||
// ici on ne normalise plus silencieusement vers {}.
|
||||
return nil
|
||||
}
|
||||
return payload
|
||||
}
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
@@ -66,7 +65,7 @@ func TestOperationsRecordRejectsInvalidOperationID(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestOperationsRecordNormalizesInvalidPayload(t *testing.T) {
|
||||
func TestOperationsRecordRejectsInvalidPayload(t *testing.T) {
|
||||
o, devices := newTestOperations(t)
|
||||
deviceID := NewID()
|
||||
if err := devices.Upsert(deviceID); err != nil {
|
||||
@@ -74,20 +73,128 @@ func TestOperationsRecordNormalizesInvalidPayload(t *testing.T) {
|
||||
}
|
||||
|
||||
opID := NewID()
|
||||
// Un payload non-JSON ne doit pas faire échouer la trace (jsonBytes → {}).
|
||||
if err := o.Record(deviceID, opID, "create_resource", "resource", nil, NewID(), []byte(`not-json`)); err != nil {
|
||||
t.Fatalf("record: %v", err)
|
||||
// Un payload non-JSON est refusé (pas de normalisation silencieuse vers {}) :
|
||||
// l'appelant (service) doit rejeter en amont en INVALID_REQUEST.
|
||||
if err := o.Record(deviceID, opID, "create_resource", "resource", nil, NewID(), []byte(`not-json`)); err == nil {
|
||||
t.Error("payload non-JSON : erreur attendue, got nil")
|
||||
}
|
||||
if applied, _ := o.Applied(deviceID, opID); applied {
|
||||
t.Error("record refusé : l'op ne doit pas être tracée")
|
||||
}
|
||||
}
|
||||
|
||||
func TestOperationsRecordStoresPayloadHash(t *testing.T) {
|
||||
o, devices := newTestOperations(t)
|
||||
deviceID := NewID()
|
||||
if err := devices.Upsert(deviceID); err != nil {
|
||||
t.Fatalf("register device: %v", err)
|
||||
}
|
||||
|
||||
opID := NewID()
|
||||
payload := []byte(`{"name":"x"}`)
|
||||
if err := o.Record(deviceID, opID, "create_resource", "resource", nil, NewID(), payload); err != nil {
|
||||
t.Fatalf("record: %v", err)
|
||||
}
|
||||
stored, err := o.Get(deviceID, opID)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
if stored.Status != OpStatusApplied {
|
||||
t.Errorf("status = %q, attendu %q", stored.Status, OpStatusApplied)
|
||||
}
|
||||
want := CanonicalPayloadHash(payload)
|
||||
if stored.PayloadHash != want {
|
||||
t.Errorf("payload_hash = %q, attendu %q", stored.PayloadHash, want)
|
||||
}
|
||||
if len(stored.PayloadHash) != 64 {
|
||||
t.Errorf("payload_hash attendu 64-hex, got %q", stored.PayloadHash)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOperationsClaimAndMarkApplied(t *testing.T) {
|
||||
o, devices := newTestOperations(t)
|
||||
deviceID := NewID()
|
||||
if err := devices.Upsert(deviceID); err != nil {
|
||||
t.Fatalf("register device: %v", err)
|
||||
}
|
||||
|
||||
var stored string
|
||||
if err := o.DB.QueryRow(`SELECT payload::text FROM operations WHERE device_id = $1 AND operation_id = $2`, deviceID, opID).Scan(&stored); err != nil {
|
||||
t.Fatalf("read payload: %v", err)
|
||||
opID := NewID()
|
||||
payload := []byte(`{"name":"x"}`)
|
||||
// Premier claim → pris.
|
||||
claimed, err := o.Claim(deviceID, opID, "create_resource", "resource", nil, NewID(), payload)
|
||||
if err != nil || !claimed {
|
||||
t.Fatalf("claim 1: claimed=%v err=%v", claimed, err)
|
||||
}
|
||||
// La trace brouillon est en status failed (pas encore confirmée).
|
||||
stored, err := o.Get(deviceID, opID)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
if stored.Status != OpStatusFailed {
|
||||
t.Errorf("status après claim = %q, attendu %q", stored.Status, OpStatusFailed)
|
||||
}
|
||||
// Second claim (batch concurrent) → perdu, chemin rejeu.
|
||||
claimed, err = o.Claim(deviceID, opID, "create_resource", "resource", nil, NewID(), payload)
|
||||
if err != nil || claimed {
|
||||
t.Fatalf("claim 2: claimed=%v err=%v", claimed, err)
|
||||
}
|
||||
// Promotion après apply réussi.
|
||||
if err := o.MarkApplied(deviceID, opID); err != nil {
|
||||
t.Fatalf("mark applied: %v", err)
|
||||
}
|
||||
stored, err = o.Get(deviceID, opID)
|
||||
if err != nil {
|
||||
t.Fatalf("get 2: %v", err)
|
||||
}
|
||||
if stored.Status != OpStatusApplied {
|
||||
t.Errorf("status après promote = %q, attendu %q", stored.Status, OpStatusApplied)
|
||||
}
|
||||
// MarkApplied idempotent (re-promote sans effet).
|
||||
if err := o.MarkApplied(deviceID, opID); err != nil {
|
||||
t.Errorf("re-promote: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStoredOpMatchesReplay(t *testing.T) {
|
||||
o, devices := newTestOperations(t)
|
||||
deviceID := NewID()
|
||||
if err := devices.Upsert(deviceID); err != nil {
|
||||
t.Fatalf("register device: %v", err)
|
||||
}
|
||||
|
||||
opID := NewID()
|
||||
resID := NewID()
|
||||
payload := []byte(`{"name":"x"}`)
|
||||
if err := o.Record(deviceID, opID, "create_resource", "resource", nil, resID, payload); err != nil {
|
||||
t.Fatalf("record: %v", err)
|
||||
}
|
||||
stored, err := o.Get(deviceID, opID)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
// Identique (espaces neutres via hash canonique) → match.
|
||||
if err := stored.MatchesReplay("create_resource", resID, []byte("{ \"name\" : \"x\" }")); err != nil {
|
||||
t.Errorf("rejeu identique: %v", err)
|
||||
}
|
||||
// Payload muté → ErrPayloadMismatch.
|
||||
if err := stored.MatchesReplay("create_resource", resID, []byte(`{"name":"y"}`)); !errors.Is(err, ErrPayloadMismatch) {
|
||||
t.Errorf("payload muté : attendu ErrPayloadMismatch, got %v", err)
|
||||
}
|
||||
// Type muté → ErrPayloadMismatch.
|
||||
if err := stored.MatchesReplay("delete_resource", resID, payload); !errors.Is(err, ErrPayloadMismatch) {
|
||||
t.Errorf("type muté : attendu ErrPayloadMismatch, got %v", err)
|
||||
}
|
||||
// Ressource mutée → ErrPayloadMismatch.
|
||||
if err := stored.MatchesReplay("create_resource", NewID(), payload); !errors.Is(err, ErrPayloadMismatch) {
|
||||
t.Errorf("ressource mutée : attendu ErrPayloadMismatch, got %v", err)
|
||||
}
|
||||
var parsed any
|
||||
if err := json.Unmarshal([]byte(stored), &parsed); err != nil {
|
||||
t.Fatalf("payload stocké invalide: %q", stored)
|
||||
// Ligne héritée sans payload_hash (pré-000013) : hash recalculé depuis
|
||||
// le payload stocké → match quand identique.
|
||||
stored.PayloadHash = ""
|
||||
if err := stored.MatchesReplay("create_resource", resID, payload); err != nil {
|
||||
t.Errorf("ligne héritée identique: %v", err)
|
||||
}
|
||||
if stored != "{}" {
|
||||
t.Errorf("payload normalisé attendu {}, got %q", stored)
|
||||
if err := stored.MatchesReplay("create_resource", resID, []byte(`{"name":"z"}`)); !errors.Is(err, ErrPayloadMismatch) {
|
||||
t.Errorf("ligne héritée mutée : attendu ErrPayloadMismatch, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
+122
-48
@@ -20,12 +20,22 @@ var ErrNameConflict = errors.New("name conflict")
|
||||
|
||||
// NewID returns an opaque lowercase 32-hex identifier (charset ^[0-9a-f]{32}$),
|
||||
// mirroring the mobile's lower(hex(randomblob(16))). Never a UUID.
|
||||
// Panics on entropy failure (legacy) — prefer NewIDErr for new code.
|
||||
func NewID() string {
|
||||
buf := make([]byte, 16)
|
||||
if _, err := rand.Read(buf); err != nil {
|
||||
id, err := NewIDErr()
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("crypto/rand failed: %v", err))
|
||||
}
|
||||
return hex.EncodeToString(buf)
|
||||
return id
|
||||
}
|
||||
|
||||
// NewIDErr is the non-panicking variant (cf. FEEDBACK A5).
|
||||
func NewIDErr() (string, error) {
|
||||
buf := make([]byte, 16)
|
||||
if _, err := rand.Read(buf); err != nil {
|
||||
return "", fmt.Errorf("crypto/rand failed: %w", err)
|
||||
}
|
||||
return hex.EncodeToString(buf), nil
|
||||
}
|
||||
|
||||
func isUniqueViolation(err error) bool {
|
||||
@@ -33,6 +43,14 @@ func isUniqueViolation(err error) bool {
|
||||
return errors.As(err, &pqErr) && pqErr.Code == "23505"
|
||||
}
|
||||
|
||||
// isForeignKeyViolation reports a Postgres FK violation (23503). Une
|
||||
// violation de FK parent (dossier cible disparu en course) est mappée vers
|
||||
// ErrNotFound — cible inexistante — plutôt que de fuir en 500.
|
||||
func isForeignKeyViolation(err error) bool {
|
||||
var pqErr *pq.Error
|
||||
return errors.As(err, &pqErr) && pqErr.Code == "23503"
|
||||
}
|
||||
|
||||
type FileRow struct {
|
||||
ID string
|
||||
Name string
|
||||
@@ -108,42 +126,39 @@ const grantedCTE = `
|
||||
AND r.deleted_at IS NULL AND g.depth < 100
|
||||
)`
|
||||
|
||||
func (r *Resources) folderExists(ownerID, folderID string) (bool, error) {
|
||||
var exists int
|
||||
err := r.DB.QueryRow(
|
||||
`SELECT 1 FROM resources
|
||||
WHERE resource_id = $1 AND user_id = $2 AND type = 'folder' AND deleted_at IS NULL`,
|
||||
folderID, ownerID,
|
||||
).Scan(&exists)
|
||||
if err == sql.ErrNoRows {
|
||||
return false, nil
|
||||
}
|
||||
return err == nil, err
|
||||
}
|
||||
|
||||
// insert persiste une ligne file/folder avec parent-check ATOMIQUE
|
||||
// (single-statement INSERT...SELECT) : le dossier parent (quand non vide)
|
||||
// doit exister, appartenir au même owner, être un folder non supprimé —
|
||||
// sinon ErrNotFound. L'ancien SELECT-then-INSERT (TOCTOU : parent supprimé
|
||||
// entre check et insert → FK 500) est remplacé ; une violation FK résiduelle
|
||||
// (course) est mappée vers ErrNotFound, jamais 500.
|
||||
func (r *Resources) insert(ownerID, id, name, parentResourceID, resourceType string, size int64, mimeType, extension *string) error {
|
||||
if parentResourceID != "" {
|
||||
ok, err := r.folderExists(ownerID, parentResourceID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !ok {
|
||||
return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound)
|
||||
}
|
||||
}
|
||||
var parentID any
|
||||
if parentResourceID != "" {
|
||||
parentID = parentResourceID
|
||||
}
|
||||
_, err := r.DB.Exec(
|
||||
result, err := r.DB.Exec(
|
||||
`INSERT INTO resources (resource_id, type, name, parent_id, user_id, size_bytes, mime_type, extension)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
|
||||
id, resourceType, name, parentID, ownerID, size, mimeType, extension,
|
||||
SELECT $1, $2, $3, NULLIF($4, ''), $5, $6, $7, $8
|
||||
WHERE $4 = '' OR EXISTS (
|
||||
SELECT 1 FROM resources
|
||||
WHERE resource_id = $4 AND user_id = $5 AND type = 'folder' AND deleted_at IS NULL
|
||||
)`,
|
||||
id, resourceType, name, parentResourceID, ownerID, size, mimeType, extension,
|
||||
)
|
||||
if isUniqueViolation(err) {
|
||||
return ErrNameConflict
|
||||
}
|
||||
return err
|
||||
if isForeignKeyViolation(err) {
|
||||
return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 0 {
|
||||
return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// InsertFile persists a file metadata row for the owner device. The parent
|
||||
@@ -270,6 +285,26 @@ func (r *Resources) GetResourceOwner(resourceID string) (string, error) {
|
||||
return ownerID, err
|
||||
}
|
||||
|
||||
// GetParentID returns the parent_id ('""' si racine) d'une ressource non
|
||||
// supprimée. No-rows → ErrNotFound. Sert au check de cycle des moves.
|
||||
func (r *Resources) GetParentID(resourceID string) (string, error) {
|
||||
var parent sql.NullString
|
||||
err := r.DB.QueryRow(
|
||||
`SELECT parent_id FROM resources WHERE resource_id = $1 AND deleted_at IS NULL`,
|
||||
resourceID,
|
||||
).Scan(&parent)
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return "", ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if !parent.Valid {
|
||||
return "", nil
|
||||
}
|
||||
return parent.String, nil
|
||||
}
|
||||
|
||||
// DeleteFile soft-deletes the file (deleted_at), returning its id.
|
||||
func (r *Resources) DeleteFile(ownerID, resourceID string) (string, error) {
|
||||
result, err := r.DB.Exec(
|
||||
@@ -369,26 +404,28 @@ func (r *Resources) GetFolder(ownerID, resourceID string) (FolderRow, error) {
|
||||
return row, err
|
||||
}
|
||||
|
||||
// MoveResource sets parent_id (root when parentResourceID empty). The target
|
||||
// folder must exist and belong to the owner. Absent source is a no-op.
|
||||
// MoveResource sets parent_id (root when parentResourceID empty) avec
|
||||
// parent-check ATOMIQUE (single-statement) : la cible doit exister,
|
||||
// appartenir au même owner, être un folder non supprimé. Source absente /
|
||||
// non-owned OU cible absente → ErrNotFound (même code : le choix A8
|
||||
// move-non-owned → NOT_FOUND est appliqué ici, cf. LOT 3 pour la doc
|
||||
// sync). Violation FK résiduelle (course) → ErrNotFound, jamais 500.
|
||||
func (r *Resources) MoveResource(ownerID, resourceID, parentResourceID string) error {
|
||||
if parentResourceID != "" {
|
||||
if _, err := r.GetFolder(ownerID, parentResourceID); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
var parentID any
|
||||
if parentResourceID != "" {
|
||||
parentID = parentResourceID
|
||||
}
|
||||
result, err := r.DB.Exec(
|
||||
`UPDATE resources SET parent_id = $3, updated_at = NOW()
|
||||
WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`,
|
||||
resourceID, ownerID, parentID,
|
||||
`UPDATE resources SET parent_id = NULLIF($3, ''), updated_at = NOW()
|
||||
WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL
|
||||
AND ($3 = '' OR EXISTS (
|
||||
SELECT 1 FROM resources
|
||||
WHERE resource_id = $3 AND user_id = $2 AND type = 'folder' AND deleted_at IS NULL
|
||||
))`,
|
||||
resourceID, ownerID, parentResourceID,
|
||||
)
|
||||
if err != nil && isUniqueViolation(err) {
|
||||
return ErrNameConflict
|
||||
}
|
||||
if err != nil && isForeignKeyViolation(err) {
|
||||
return fmt.Errorf("folder %s: %w", parentResourceID, ErrNotFound)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -402,7 +439,7 @@ func (r *Resources) MoveResource(ownerID, resourceID, parentResourceID string) e
|
||||
return nil
|
||||
}
|
||||
|
||||
// UpdateName renames a resource. Absent source is a no-op.
|
||||
// UpdateName renames a resource. Absent / not owned → ErrNotFound.
|
||||
func (r *Resources) UpdateName(ownerID, resourceID, name string) error {
|
||||
result, err := r.DB.Exec(
|
||||
`UPDATE resources SET name = $3, updated_at = NOW()
|
||||
@@ -425,8 +462,18 @@ func (r *Resources) UpdateName(ownerID, resourceID, name string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// UpdateNameOwned renames a resource OWNED by ownerID. Absent / not owned →
|
||||
// ErrNotFound, sibling homonyme → ErrNameConflict. Variante scopée
|
||||
// canonique (sémantique identique à UpdateName, nom aligné sur TouchOwned
|
||||
// pour LOT 3).
|
||||
func (r *Resources) UpdateNameOwned(ownerID, resourceID, name string) error {
|
||||
return r.UpdateName(ownerID, resourceID, name)
|
||||
}
|
||||
|
||||
// UpdateNameByID renames a resource without owner scoping — the caller
|
||||
// (service) has already verified the user's effective access (editor+).
|
||||
// Conservée volontairement pour update_metadata : un editor non-owner peut
|
||||
// renommer, UpdateNameOwned rejetterait à tort.
|
||||
func (r *Resources) UpdateNameByID(resourceID, name string) error {
|
||||
result, err := r.DB.Exec(
|
||||
`UPDATE resources SET name = $2, updated_at = NOW()
|
||||
@@ -519,8 +566,35 @@ func (r *Resources) ExistsOwner(ownerID, resourceID string) (bool, error) {
|
||||
return err == nil, err
|
||||
}
|
||||
|
||||
// TouchOwned bumps updated_at on a non-deleted resource OWNED by ownerID so
|
||||
// that the grantee's delta snapshot picks it up after a share is created.
|
||||
// Absent / not owned → ErrNotFound. C'est la variante scopée à utiliser
|
||||
// (LOT 3 : migrer les appelants sync vers TouchOwned).
|
||||
func (r *Resources) TouchOwned(ownerID, resourceID string) error {
|
||||
result, err := r.DB.Exec(
|
||||
`UPDATE resources SET updated_at = NOW()
|
||||
WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`,
|
||||
resourceID, ownerID,
|
||||
)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// TouchResource bumps updated_at on a non-deleted resource so that the
|
||||
// grantee's delta snapshot picks it up after a share is created.
|
||||
//
|
||||
// Deprecated: non scopée (touche n'importe quel owner) — préférer TouchOwned.
|
||||
// Plus aucun appelant sync (migrés vers TouchOwned) ; conservée pour
|
||||
// compatibilité des appelants externes éventuels.
|
||||
func (r *Resources) TouchResource(resourceID string) error {
|
||||
_, err := r.DB.Exec(
|
||||
`UPDATE resources SET updated_at = NOW() WHERE resource_id = $1 AND deleted_at IS NULL`,
|
||||
|
||||
@@ -233,6 +233,156 @@ func TestListOwnedDelta(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsertParentCrossOwnerNotFound(t *testing.T) {
|
||||
repo := newTestResources(t)
|
||||
owner := NewID()
|
||||
other := NewID()
|
||||
mustInsertUser(t, repo, owner)
|
||||
mustInsertUser(t, repo, other)
|
||||
|
||||
ownerFolder := NewID()
|
||||
if err := repo.InsertFolder(owner, ownerFolder, "Docs", ""); err != nil {
|
||||
t.Fatalf("insert folder: %v", err)
|
||||
}
|
||||
|
||||
// Dossier d'un autre owner comme parent → NOT_FOUND (pas de fuite 500).
|
||||
if err := repo.InsertFile(other, NewID(), "x.txt", ownerFolder, 1, nil, nil); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("parent autre owner : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
if err := repo.InsertFolder(other, NewID(), "Sub", ownerFolder); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("parent dossier autre owner : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
|
||||
// Un fichier comme parent → NOT_FOUND (pas un folder).
|
||||
fileID := NewID()
|
||||
if err := repo.InsertFile(owner, fileID, "note.txt", "", 1, nil, nil); err != nil {
|
||||
t.Fatalf("insert file: %v", err)
|
||||
}
|
||||
if err := repo.InsertFile(owner, NewID(), "y.txt", fileID, 1, nil, nil); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("parent fichier : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMoveResourceAtomic(t *testing.T) {
|
||||
repo := newTestResources(t)
|
||||
owner := NewID()
|
||||
other := NewID()
|
||||
mustInsertUser(t, repo, owner)
|
||||
mustInsertUser(t, repo, other)
|
||||
|
||||
folderA := NewID()
|
||||
folderB := NewID()
|
||||
if err := repo.InsertFolder(owner, folderA, "A", ""); err != nil {
|
||||
t.Fatalf("insert A: %v", err)
|
||||
}
|
||||
if err := repo.InsertFolder(owner, folderB, "B", ""); err != nil {
|
||||
t.Fatalf("insert B: %v", err)
|
||||
}
|
||||
otherFolder := NewID()
|
||||
if err := repo.InsertFolder(other, otherFolder, "Other", ""); err != nil {
|
||||
t.Fatalf("insert other: %v", err)
|
||||
}
|
||||
fileID := NewID()
|
||||
if err := repo.InsertFile(owner, fileID, "note.txt", folderA, 1, nil, nil); err != nil {
|
||||
t.Fatalf("insert file: %v", err)
|
||||
}
|
||||
|
||||
// Move OK vers dossier owned.
|
||||
if err := repo.MoveResource(owner, fileID, folderB); err != nil {
|
||||
t.Fatalf("move: %v", err)
|
||||
}
|
||||
got, err := repo.GetFile(owner, fileID)
|
||||
if err != nil || got.FolderID != folderB {
|
||||
t.Errorf("après move : folder=%q err=%v", got.FolderID, err)
|
||||
}
|
||||
|
||||
// Cible d'un autre owner → NOT_FOUND, la source ne bouge pas.
|
||||
if err := repo.MoveResource(owner, fileID, otherFolder); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("cible autre owner : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
got, _ = repo.GetFile(owner, fileID)
|
||||
if got.FolderID != folderB {
|
||||
t.Errorf("move refusé ne doit rien changer, folder=%q", got.FolderID)
|
||||
}
|
||||
|
||||
// Cible inexistante → NOT_FOUND.
|
||||
if err := repo.MoveResource(owner, fileID, NewID()); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("cible inconnue : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
|
||||
// Source inconnue → NOT_FOUND.
|
||||
if err := repo.MoveResource(owner, NewID(), folderB); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("source inconnue : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
|
||||
// Retour à la racine.
|
||||
if err := repo.MoveResource(owner, fileID, ""); err != nil {
|
||||
t.Fatalf("move racine: %v", err)
|
||||
}
|
||||
got, _ = repo.GetFile(owner, fileID)
|
||||
if got.FolderID != "" {
|
||||
t.Errorf("racine attendue, folder=%q", got.FolderID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTouchOwnedAndUpdateNameOwned(t *testing.T) {
|
||||
repo := newTestResources(t)
|
||||
owner := NewID()
|
||||
other := NewID()
|
||||
mustInsertUser(t, repo, owner)
|
||||
mustInsertUser(t, repo, other)
|
||||
|
||||
fileID := NewID()
|
||||
if err := repo.InsertFile(owner, fileID, "note.txt", "", 1, nil, nil); err != nil {
|
||||
t.Fatalf("insert: %v", err)
|
||||
}
|
||||
|
||||
before, err := repo.GetFile(owner, fileID)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
if err := repo.TouchOwned(owner, fileID); err != nil {
|
||||
t.Fatalf("touch owned: %v", err)
|
||||
}
|
||||
after, err := repo.GetFile(owner, fileID)
|
||||
if err != nil {
|
||||
t.Fatalf("get après touch: %v", err)
|
||||
}
|
||||
if !after.UpdatedAt.After(before.UpdatedAt) && !after.UpdatedAt.Equal(before.UpdatedAt) {
|
||||
t.Errorf("touch doit bumperc updated_at : %v → %v", before.UpdatedAt, after.UpdatedAt)
|
||||
}
|
||||
|
||||
// Non-owned / inconnu → ErrNotFound.
|
||||
if err := repo.TouchOwned(other, fileID); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("touch autre owner : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
if err := repo.TouchOwned(owner, NewID()); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("touch inconnu : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
|
||||
if err := repo.UpdateNameOwned(owner, fileID, "renamed.txt"); err != nil {
|
||||
t.Fatalf("rename owned: %v", err)
|
||||
}
|
||||
renamed, err := repo.GetFile(owner, fileID)
|
||||
if err != nil || renamed.Name != "renamed.txt" {
|
||||
t.Errorf("rename : %+v err=%v", renamed, err)
|
||||
}
|
||||
if err := repo.UpdateNameOwned(other, fileID, "volé.txt"); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("rename autre owner : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
if err := repo.UpdateNameOwned(owner, NewID(), "x.txt"); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("rename inconnu : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
|
||||
// Anciennes variantes (deprecated, compat LOT 3) : toujours fonctionnelles.
|
||||
if err := repo.TouchResource(fileID); err != nil {
|
||||
t.Errorf("touch legacy: %v", err)
|
||||
}
|
||||
if err := repo.UpdateNameByID(fileID, "legacy.txt"); err != nil {
|
||||
t.Errorf("rename legacy: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUpdateOcrTextAndReadBack(t *testing.T) {
|
||||
repo := newTestResources(t)
|
||||
owner := NewID()
|
||||
|
||||
@@ -327,17 +327,44 @@ func (s *Shares) ResourceExists(resourceID string) (bool, error) {
|
||||
}
|
||||
|
||||
// CreateLink stores a share link (token = id, client-generated 32-hex).
|
||||
// Idempotent sur rejeu même (token) : ON CONFLICT DO NOTHING puis vérifie
|
||||
// que le lien existant vise la même ressource ET le même owner (created_by) —
|
||||
// sinon ErrNameConflict (réutilisation de token, cf. FEEDBACK #3). Un lien
|
||||
// révoqué identique reste révoqué (pas de résurrection par rejeu : revoke gagne).
|
||||
func (s *Shares) CreateLink(token, resourceID, access string, expiresAt *time.Time, createdBy string) error {
|
||||
var expires any
|
||||
if expiresAt != nil {
|
||||
expires = *expiresAt
|
||||
}
|
||||
_, err := s.DB.Exec(
|
||||
res, err := s.DB.Exec(
|
||||
`INSERT INTO share_links (id, resource_id, access, created_by, expires_at)
|
||||
VALUES ($1, $2, $3, $4, $5)`,
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
ON CONFLICT (id) DO NOTHING`,
|
||||
token, resourceID, access, createdBy, expires,
|
||||
)
|
||||
return err
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 1 {
|
||||
return nil
|
||||
}
|
||||
// Conflit : le token existe déjà — idempotent si même (ressource, owner),
|
||||
// sinon conflit (le token est une clé d'idempotence client).
|
||||
var existing struct {
|
||||
resourceID string
|
||||
createdBy string
|
||||
}
|
||||
if err := s.DB.QueryRow(`SELECT resource_id, created_by FROM share_links WHERE id = $1`, token).Scan(&existing.resourceID, &existing.createdBy); err != nil {
|
||||
return err
|
||||
}
|
||||
if existing.resourceID != resourceID || existing.createdBy != createdBy {
|
||||
return ErrNameConflict
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// RevokeLink soft-revokes a link by token. Returns ErrNotFound if the link
|
||||
|
||||
+42
-15
@@ -20,11 +20,12 @@ type Users struct {
|
||||
DB *sql.DB
|
||||
}
|
||||
|
||||
// Count retourne le nombre d'utilisateurs (y compris supprimés) — sert au
|
||||
// bootstrap admin au démarrage.
|
||||
// Count retourne le nombre d'utilisateurs ACTIFS (deleted_at IS NULL) — sert
|
||||
// au bootstrap admin au démarrage. Une base dont tous les comptes sont
|
||||
// soft-deleted est vue comme vide : EnsureAdmin recréera un admin (#9+A10).
|
||||
func (u *Users) Count() (int, error) {
|
||||
var n int
|
||||
err := u.DB.QueryRow(`SELECT COUNT(*) FROM users`).Scan(&n)
|
||||
err := u.DB.QueryRow(`SELECT COUNT(*) FROM users WHERE deleted_at IS NULL`).Scan(&n)
|
||||
return n, err
|
||||
}
|
||||
|
||||
@@ -67,8 +68,11 @@ func (u *Users) ResolveExact(normalized string) (*UserRow, error) {
|
||||
|
||||
// Create insère un compte avec un id 32-hex généré. Retourne l'id.
|
||||
func (u *Users) Create(username, usernameNormalized, passwordHash string, isAdmin bool) (string, error) {
|
||||
id := NewID()
|
||||
_, err := u.DB.Exec(
|
||||
id, err := NewIDErr()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
_, err = u.DB.Exec(
|
||||
`INSERT INTO users (id, username, username_normalized, password_hash, is_admin, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5, NOW())`,
|
||||
id, username, usernameNormalized, passwordHash, isAdmin,
|
||||
@@ -82,24 +86,47 @@ func (u *Users) Create(username, usernameNormalized, passwordHash string, isAdmi
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// UpdatePassword remplace le hash du compte. Les tokens déjà émis restent
|
||||
// valides 7 jours : limite assumée V1 (pas de liste de révocation).
|
||||
// UpdatePassword remplace le hash du compte actif. Compte absent ou
|
||||
// soft-deleted → ErrNotFound. Les tokens déjà émis restent valides 7 jours :
|
||||
// limite assumée V1 (pas de liste de révocation).
|
||||
func (u *Users) UpdatePassword(id, newHash string) error {
|
||||
_, err := u.DB.Exec(
|
||||
`UPDATE users SET password_hash = $2, updated_at = NOW() WHERE id = $1`,
|
||||
result, err := u.DB.Exec(
|
||||
`UPDATE users SET password_hash = $2, updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`,
|
||||
id, newHash,
|
||||
)
|
||||
return err
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// MarkDeleted soft-delete un compte : les tokens issus sont rejetés par le
|
||||
// middleware (GetByID filtre deleted_at).
|
||||
// MarkDeleted soft-delete un compte actif : les tokens issus sont rejetés par
|
||||
// le middleware (GetByID filtre deleted_at). Compte absent ou déjà supprimé →
|
||||
// ErrNotFound (pas d'idempotence silencieuse : le second delete signale que
|
||||
// la cible n'est plus active).
|
||||
func (u *Users) MarkDeleted(id string) error {
|
||||
_, err := u.DB.Exec(
|
||||
`UPDATE users SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1`,
|
||||
result, err := u.DB.Exec(
|
||||
`UPDATE users SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1 AND deleted_at IS NULL`,
|
||||
id,
|
||||
)
|
||||
return err
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
affected, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if affected == 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func scanUser(scan func(...any) error) (*UserRow, error) {
|
||||
|
||||
@@ -64,6 +64,11 @@ func TestUsersUpdatePassword(t *testing.T) {
|
||||
if err != nil || row.PasswordHash != "hash-2" {
|
||||
t.Errorf("hash après update = %q (err=%v)", row.PasswordHash, err)
|
||||
}
|
||||
|
||||
// Compte inconnu → ErrNotFound (#9+A10).
|
||||
if err := u.UpdatePassword(NewID(), "hash-x"); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("update password inconnu : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUsersMarkDeletedHidesAccount(t *testing.T) {
|
||||
@@ -82,7 +87,22 @@ func TestUsersMarkDeletedHidesAccount(t *testing.T) {
|
||||
if _, err := u.GetByUsernameNormalized("carol"); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("get par username après suppression : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
if n, _ := u.Count(); n != 1 {
|
||||
t.Errorf("count doit compter aussi les supprimés (bootstrap), got %d", n)
|
||||
// Count ne compte que les ACTIFS : carol soft-deleted → 0 (#9+A10). Une
|
||||
// base 100% soft-deleted est vue comme vide par le bootstrap.
|
||||
if n, _ := u.Count(); n != 0 {
|
||||
t.Errorf("count doit exclure les supprimés, got %d", n)
|
||||
}
|
||||
|
||||
// UpdatePassword sur compte supprimé → ErrNotFound.
|
||||
if err := u.UpdatePassword(id, "hash-2"); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("update password après suppression : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
// Second MarkDeleted → ErrNotFound (plus de cible active).
|
||||
if err := u.MarkDeleted(id); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("second mark deleted : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
// MarkDeleted sur inconnu → ErrNotFound.
|
||||
if err := u.MarkDeleted(NewID()); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("mark deleted inconnu : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -21,7 +21,9 @@ func NormalizeUsername(username string) string {
|
||||
}
|
||||
|
||||
// EnsureAdmin crée le compte admin au premier démarrage si la table users est
|
||||
// vide. Idempotent : l'env n'écrase jamais un compte existant.
|
||||
// vide. Idempotent : l'env n'écrase jamais un compte existant. Seuls les
|
||||
// comptes ACTIFS comptent (Users.Count filtre deleted_at, #9+A10) : une base
|
||||
// 100% soft-deleted est vue comme vide et reçoit un nouvel admin.
|
||||
func EnsureAdmin(repo *repository.Repository, username, password string) error {
|
||||
count, err := repo.Users.Count()
|
||||
if err != nil {
|
||||
|
||||
@@ -60,6 +60,32 @@ func TestEnsureAdminRefusesOnEmptyDBWithoutEnv(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestEnsureAdminRecreatesWhenAllSoftDeleted(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
repo := s.Repository
|
||||
|
||||
// Un seul compte, soft-deleted : Count (actifs seuls, #9+A10) voit une
|
||||
// base vide → EnsureAdmin recrée un admin au lieu de refuser.
|
||||
id, err := repo.Users.Create("alice", "alice", "existing-hash", false)
|
||||
if err != nil {
|
||||
t.Fatalf("seed user: %v", err)
|
||||
}
|
||||
if err := repo.Users.MarkDeleted(id); err != nil {
|
||||
t.Fatalf("mark deleted: %v", err)
|
||||
}
|
||||
|
||||
if err := EnsureAdmin(repo, "admin", "admin-secret-123"); err != nil {
|
||||
t.Fatalf("EnsureAdmin sur base 100%% soft-deleted : %v", err)
|
||||
}
|
||||
admin, err := repo.Users.GetByUsernameNormalized("admin")
|
||||
if err != nil {
|
||||
t.Fatalf("admin recréé introuvable: %v", err)
|
||||
}
|
||||
if !admin.IsAdmin {
|
||||
t.Error("le compte recréé doit être admin")
|
||||
}
|
||||
}
|
||||
|
||||
func TestEnsureAdminNeverOverwritesExistingAccounts(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
repo := s.Repository
|
||||
|
||||
@@ -1,14 +0,0 @@
|
||||
package service
|
||||
|
||||
import "github.com/kazier/backend/models"
|
||||
|
||||
func (s *Services) CreateFolder(folderName string, destination *models.Document) (*models.Document, error) {
|
||||
|
||||
directory, err := models.NewDocument(folderName, models.DIRECTORY, 1)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return directory, nil
|
||||
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/kazier/backend/models"
|
||||
)
|
||||
|
||||
func (s *Services) MoveDocumentIntoDocument(from *models.Document, to *models.Document) error {
|
||||
|
||||
if from.UUID == nil {
|
||||
return errors.New(models.ERROR_DOCUMENT_NOT_PERCISTED)
|
||||
}
|
||||
|
||||
if to.Type != models.DIRECTORY {
|
||||
return errors.New("the destination document must be a directory")
|
||||
}
|
||||
|
||||
if canEdit, _ := UserCanEditDocument(s.ConnectedUser, from); !canEdit {
|
||||
return errors.New("you cannot edit this folder")
|
||||
}
|
||||
|
||||
if canEdit, _ := UserCanEditDocument(s.ConnectedUser, to); !canEdit {
|
||||
return errors.New("you cannot edit this folder")
|
||||
}
|
||||
|
||||
// Check if document exist and move the document into document if is directory
|
||||
|
||||
fmt.Println("To implement move to ", to.UUID)
|
||||
|
||||
return nil
|
||||
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/kazier/backend/models"
|
||||
)
|
||||
|
||||
func TestMoveDocument(t *testing.T) {
|
||||
|
||||
userAntoine, err := models.NewUser("antoine")
|
||||
if err != nil {
|
||||
t.Fatalf("creating antoine user: %v", err)
|
||||
}
|
||||
|
||||
fakeUUID := "dsqdsq"
|
||||
document, err := models.NewDocument("test.pdf", models.FILE, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("creating document: %v", err)
|
||||
}
|
||||
document.UUID = &fakeUUID
|
||||
|
||||
folder, err := models.NewDocument("orga", models.DIRECTORY, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("creating folder: %v", err)
|
||||
}
|
||||
folder.UUID = &fakeUUID
|
||||
|
||||
service := New(userAntoine)
|
||||
|
||||
if err := service.MoveDocumentIntoDocument(document, folder); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestMoveDocumentToAFile(t *testing.T) {
|
||||
|
||||
userAntoine, err := models.NewUser("antoine")
|
||||
if err != nil {
|
||||
t.Fatalf("creating antoine user: %v", err)
|
||||
}
|
||||
|
||||
document, err := models.NewDocument("test.pdf", models.FILE, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("creating document: %v", err)
|
||||
}
|
||||
|
||||
notAFolder, err := models.NewDocument("orga", models.FILE, 1)
|
||||
if err != nil {
|
||||
t.Fatalf("creating file: %v", err)
|
||||
}
|
||||
|
||||
service := New(userAntoine)
|
||||
|
||||
err = service.MoveDocumentIntoDocument(document, notAFolder)
|
||||
|
||||
if err == nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
}
|
||||
+80
-12
@@ -3,8 +3,11 @@ package service
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
@@ -41,7 +44,29 @@ type Ocr struct {
|
||||
}
|
||||
|
||||
func NewOcr(repo *repository.Repository, uploadDir, lang string, engine ocr.Engine) *Ocr {
|
||||
return &Ocr{Repository: repo, UploadDir: uploadDir, Lang: lang, Engine: engine, StaleAfter: StaleClaimTimeout}
|
||||
return &Ocr{Repository: repo, UploadDir: uploadDir, Lang: normalizeOcrLang(lang), Engine: engine, StaleAfter: StaleClaimTimeout}
|
||||
}
|
||||
|
||||
var (
|
||||
// ocrLangPattern : whitelist OCR_LANG (A12) — lettres Tesseract + `+`
|
||||
// uniquement (ex. `fra`, `eng`, `fra+eng`). Tout le reste (espaces,
|
||||
// `;`, `-`, options `--...`) est une tentative d'injection `-l`.
|
||||
ocrLangPattern = regexp.MustCompile(`^[a-z+]{2,20}$`)
|
||||
// hexIDPattern : identifiants 32-hex (anti `..` dans physicalPath).
|
||||
hexIDPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
|
||||
)
|
||||
|
||||
// DefaultOcrLang est la langue Tesseract de repli (OCR_LANG, défaut fra+eng).
|
||||
const DefaultOcrLang = "fra+eng"
|
||||
|
||||
// normalizeOcrLang applique la whitelist OCR_LANG : valeur invalide → repli
|
||||
// sur le défaut avec log (jamais d'injection vers `tesseract -l`).
|
||||
func normalizeOcrLang(lang string) string {
|
||||
if ocrLangPattern.MatchString(lang) {
|
||||
return lang
|
||||
}
|
||||
log.Printf("ocr: OCR_LANG %q invalide (whitelist ^[a-z+]{2,20}$), repli sur %q", lang, DefaultOcrLang)
|
||||
return DefaultOcrLang
|
||||
}
|
||||
|
||||
// Create valide la ressource (ownership par user) et l'enfile uniquement
|
||||
@@ -110,44 +135,87 @@ func (o *Ocr) workerLoop(ctx context.Context) {
|
||||
}
|
||||
|
||||
// process exécute l'extraction pour un job déjà réclamé (`processing`).
|
||||
// Ordre A13 : l'écriture `UpdateOcrText` est vérifiée AVANT le `Complete` —
|
||||
// hôte supprimé entre-temps (0 ligne, ErrNotFound) → le job `Fail` au lieu
|
||||
// de rester `done` avec un texte fantôme. Les erreurs `Fail`/`Complete`
|
||||
// (conflit d'état : job requeue et repris par un autre worker) sont loggées,
|
||||
// jamais silencieuses.
|
||||
func (o *Ocr) process(ctx context.Context, row repository.OcrJobRow) {
|
||||
fail := func(message string) {
|
||||
if err := o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, message); err != nil {
|
||||
log.Printf("ocr: fail job %s: %v", row.ID, err)
|
||||
}
|
||||
}
|
||||
complete := func(text string) {
|
||||
if err := o.Repository.OcrJobs.Complete(row.DeviceID, row.ID, text); err != nil {
|
||||
log.Printf("ocr: complete job %s: %v", row.ID, err)
|
||||
}
|
||||
}
|
||||
userID, err := o.Repository.Resources.GetResourceOwner(row.FileID)
|
||||
if err != nil {
|
||||
_ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, "file not readable")
|
||||
fail("file not readable")
|
||||
return
|
||||
}
|
||||
path, err := o.physicalPath(userID, row.FileID)
|
||||
if err != nil {
|
||||
_ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, "file not readable")
|
||||
fail("file not readable")
|
||||
return
|
||||
}
|
||||
text, err := o.Engine.ExtractText(ctx, path, o.Lang)
|
||||
if err != nil {
|
||||
_ = o.Repository.OcrJobs.Fail(row.DeviceID, row.ID, err.Error())
|
||||
fail(err.Error())
|
||||
return
|
||||
}
|
||||
_ = o.Repository.OcrJobs.Complete(row.DeviceID, row.ID, text)
|
||||
// Le texte atterrit sur la ressource (updated_at bumpé) : consultable par
|
||||
// tous les devices du user et les grantees via GET /files/:id/ocr. SILENCIEUX
|
||||
// (hôte déjà supprimé ou lock d'écriture) : le job reste source d'historique.
|
||||
// tous les devices du user et les grantees via GET /files/:id/ocr.
|
||||
if trimmed := strings.TrimSpace(text); trimmed != "" {
|
||||
if err := o.Repository.Resources.UpdateOcrText(userID, row.FileID, trimmed); err != nil {
|
||||
log.Printf("ocr: persiste ocr_text de %s: %v", row.FileID, err)
|
||||
if errors.Is(err, repository.ErrNotFound) {
|
||||
fail("file not readable")
|
||||
} else {
|
||||
fail(err.Error())
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
complete(text)
|
||||
}
|
||||
|
||||
// physicalPath résout UPLOAD_DIR/<user_id>/<resource_id>.<ext> — l'ext est
|
||||
// choisi à l'upload, le fichier réel est retrouvé par préfixe.
|
||||
// choisi à l'upload, le fichier réel est retrouvé par préfixe. Durci (A12) :
|
||||
// identifiants 32-hex uniquement (anti `..`), `Lstat` + fichier régulier
|
||||
// (ni dossier, ni symlink brut), `EvalSymlinks` contenu dans UPLOAD_DIR
|
||||
// (anti évasion par lien symbolique). Candidat rejeté → candidat suivant ;
|
||||
// aucun candidat → ErrNotFound.
|
||||
func (o *Ocr) physicalPath(userID, fileID string) (string, error) {
|
||||
if !hexIDPattern.MatchString(userID) || !hexIDPattern.MatchString(fileID) {
|
||||
return "", fmt.Errorf("physicalPath: identifiant non 32-hex")
|
||||
}
|
||||
base, err := filepath.EvalSymlinks(o.UploadDir)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("physicalPath: upload dir illisible: %w", err)
|
||||
}
|
||||
matches, err := filepath.Glob(filepath.Join(o.UploadDir, userID, fileID+".*"))
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
for _, m := range matches {
|
||||
if strings.HasPrefix(filepath.Base(m), fileID+".") {
|
||||
return m, nil
|
||||
if !strings.HasPrefix(filepath.Base(m), fileID+".") {
|
||||
continue
|
||||
}
|
||||
fi, err := os.Lstat(m)
|
||||
if err != nil || !fi.Mode().IsRegular() {
|
||||
continue
|
||||
}
|
||||
resolved, err := filepath.EvalSymlinks(m)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
rel, err := filepath.Rel(base, resolved)
|
||||
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
|
||||
continue
|
||||
}
|
||||
return resolved, nil
|
||||
}
|
||||
return "", repository.ErrNotFound
|
||||
}
|
||||
@@ -161,4 +229,4 @@ func toOcrJobDTO(row repository.OcrJobRow) OcrJobDTO {
|
||||
dto.Error = *row.Error
|
||||
}
|
||||
return dto
|
||||
}
|
||||
}
|
||||
|
||||
@@ -94,6 +94,76 @@ func TestOcrPhysicalPath(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestOcrPhysicalPathRejectsNonHexIDs(t *testing.T) {
|
||||
o := NewOcr(nil, t.TempDir(), "fra+eng", nil)
|
||||
for _, tc := range [][2]string{
|
||||
{"../evil", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"},
|
||||
{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "../../etc/passwd.png"},
|
||||
{"", ""},
|
||||
} {
|
||||
if _, err := o.physicalPath(tc[0], tc[1]); err == nil {
|
||||
t.Errorf("ids %q/%q : attendu rejet non 32-hex", tc[0], tc[1])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestOcrPhysicalPathRejectsSymlinkEscape(t *testing.T) {
|
||||
uploadDir := t.TempDir()
|
||||
userID := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||||
fileID := "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
|
||||
outside := t.TempDir()
|
||||
|
||||
secret := filepath.Join(outside, "secret.png")
|
||||
if err := os.WriteFile(secret, []byte("secret"), 0o644); err != nil {
|
||||
t.Fatalf("write secret: %v", err)
|
||||
}
|
||||
userDir := filepath.Join(uploadDir, userID)
|
||||
if err := os.MkdirAll(userDir, 0o755); err != nil {
|
||||
t.Fatalf("mkdir: %v", err)
|
||||
}
|
||||
// Lien symbolique <fileID>.png → hors UPLOAD_DIR : doit être ignoré.
|
||||
if err := os.Symlink(secret, filepath.Join(userDir, fileID+".png")); err != nil {
|
||||
t.Fatalf("symlink: %v", err)
|
||||
}
|
||||
|
||||
o := NewOcr(nil, uploadDir, "fra+eng", nil)
|
||||
if _, err := o.physicalPath(userID, fileID); !errors.Is(err, repository.ErrNotFound) {
|
||||
t.Errorf("symlink hors UPLOAD_DIR : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOcrPhysicalPathRejectsDirectory(t *testing.T) {
|
||||
uploadDir := t.TempDir()
|
||||
userID := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||||
fileID := "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
|
||||
userDir := filepath.Join(uploadDir, userID)
|
||||
if err := os.MkdirAll(filepath.Join(userDir, fileID+".png"), 0o755); err != nil {
|
||||
t.Fatalf("mkdir: %v", err)
|
||||
}
|
||||
|
||||
o := NewOcr(nil, uploadDir, "fra+eng", nil)
|
||||
if _, err := o.physicalPath(userID, fileID); !errors.Is(err, repository.ErrNotFound) {
|
||||
t.Errorf("dossier à la place du fichier : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNormalizeOcrLang(t *testing.T) {
|
||||
for _, lang := range []string{"fra", "eng", "fra+eng"} {
|
||||
if got := normalizeOcrLang(lang); got != lang {
|
||||
t.Errorf("langue %q : attendue conservée, got %q", lang, got)
|
||||
}
|
||||
}
|
||||
for _, lang := range []string{"", "e", "fra;id", "fra eng", "FRA", "--psm 6 fra"} {
|
||||
if got := normalizeOcrLang(lang); got != DefaultOcrLang {
|
||||
t.Errorf("langue %q : attendu repli %q, got %q", lang, DefaultOcrLang, got)
|
||||
}
|
||||
}
|
||||
o := NewOcr(nil, t.TempDir(), "fra;evil", nil)
|
||||
if o.Lang != DefaultOcrLang {
|
||||
t.Errorf("NewOcr langue hostile : attendu %q, got %q", DefaultOcrLang, o.Lang)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOcrJobFailsWhenPhysicalFileMissing(t *testing.T) {
|
||||
o, userID, deviceID, _ := newTestOcr(t, t.TempDir(), stubEngine{text: "x"})
|
||||
|
||||
|
||||
+187
-21
@@ -4,9 +4,11 @@ import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"mime/multipart"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
@@ -16,6 +18,10 @@ import (
|
||||
// ErrFileTooLarge signals an upload above MaxFileSize.
|
||||
var ErrFileTooLarge = errors.New("file too large")
|
||||
|
||||
// ErrInvalidUpload signals a rejected upload (display name or path component).
|
||||
// Handlers map it to 400 INVALID_REQUEST (never 500).
|
||||
var ErrInvalidUpload = errors.New("invalid upload name")
|
||||
|
||||
// FileDTO serializes exactly as mobile/api/types.ts FileDto.
|
||||
type FileDTO struct {
|
||||
ID string `json:"id"`
|
||||
@@ -53,6 +59,66 @@ func NewResources(repo *repository.Repository, uploadDir string, maxFileSize int
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
extensionPattern = regexp.MustCompile(`^[a-z0-9]{1,10}$`)
|
||||
idPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
|
||||
)
|
||||
|
||||
// allowedMimeTypes whitelists client-declared Content-Types (parameters
|
||||
// stripped, lowercased) ; anything absent falls back to
|
||||
// application/octet-stream (cf. FEEDBACK A16).
|
||||
var allowedMimeTypes = map[string]struct{}{
|
||||
"application/octet-stream": {},
|
||||
"application/pdf": {},
|
||||
"application/json": {},
|
||||
"application/zip": {},
|
||||
"text/plain": {},
|
||||
"text/csv": {},
|
||||
"text/markdown": {},
|
||||
"image/png": {},
|
||||
"image/jpeg": {},
|
||||
"image/gif": {},
|
||||
"image/webp": {},
|
||||
"audio/mpeg": {},
|
||||
"video/mp4": {},
|
||||
}
|
||||
|
||||
// sanitizeExtension normalise l'extension issue du filename client (cf.
|
||||
// FEEDBACK #5) : lowercase, [a-z0-9]{1,10}, sinon "" (pas de suffixe).
|
||||
func sanitizeExtension(filename string) string {
|
||||
ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(filename), "."))
|
||||
if !extensionPattern.MatchString(ext) {
|
||||
return ""
|
||||
}
|
||||
return ext
|
||||
}
|
||||
|
||||
// sanitizeFileName nettoie le nom stocké (cf. FEEDBACK A16) : TrimSpace,
|
||||
// cap 255, rejet vide / slash / backslash / retour ligne. Le nom n'est
|
||||
// qu'une métadonnée (jamais un composant de chemin), mais on le verrouille
|
||||
// quand même pour casser toute confusion downstream.
|
||||
func sanitizeFileName(name string) (string, error) {
|
||||
n := strings.TrimSpace(name)
|
||||
if n == "" || len(n) > 255 || strings.ContainsAny(n, "/\\\x00\n\r") {
|
||||
return "", ErrInvalidUpload
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
func sanitizeMimeType(mime string) string {
|
||||
m := strings.ToLower(strings.TrimSpace(mime))
|
||||
if i := strings.IndexByte(m, ';'); i >= 0 {
|
||||
m = strings.TrimSpace(m[:i])
|
||||
}
|
||||
if m == "" || len(m) > 128 {
|
||||
return "application/octet-stream"
|
||||
}
|
||||
if _, ok := allowedMimeTypes[m]; !ok {
|
||||
return "application/octet-stream"
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
func (s *Resources) ListFiles(ownerID, folderID string, page, pageSize int, sort, order string) ([]FileDTO, int, error) {
|
||||
rows, total, err := s.Repo.ListFilesVisible(ownerID, folderID, pageSize, (page-1)*pageSize, sort, order)
|
||||
if err != nil {
|
||||
@@ -132,66 +198,166 @@ func (s *Resources) SearchFiles(ownerID, q string, page, pageSize int) ([]FileDT
|
||||
// rename, never a move, never a duplicate row. Unknown / foreign resource →
|
||||
// repo.ErrNotFound.
|
||||
func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, resourceID string) (FileDTO, error) {
|
||||
if file.Size > s.MaxFileSize {
|
||||
return FileDTO{}, ErrFileTooLarge
|
||||
// Garde anti-traversal : seuls des IDs 32-hex (ou générés) deviennent des
|
||||
// composants de chemin. ownerID vient de l'auth mais on ne lui fait pas
|
||||
// confiance aveuglément ; resourceID fourni par le client est déjà
|
||||
// pré-validé côté handler (404), ici on rejete en NotFound/400 pareil.
|
||||
if strings.ContainsAny(ownerID, "/\\\x00\n\r") || strings.Contains(ownerID, "..") {
|
||||
return FileDTO{}, ErrInvalidUpload
|
||||
}
|
||||
|
||||
targetExisting := resourceID != ""
|
||||
if targetExisting {
|
||||
if !idPattern.MatchString(resourceID) {
|
||||
return FileDTO{}, repository.ErrNotFound
|
||||
}
|
||||
if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
} else {
|
||||
resourceID = repository.NewID()
|
||||
var err error
|
||||
resourceID, err = repository.NewIDErr()
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
}
|
||||
|
||||
extension := strings.TrimPrefix(filepath.Ext(file.Filename), ".")
|
||||
name, err := sanitizeFileName(file.Filename)
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
extension := sanitizeExtension(file.Filename)
|
||||
destDir := filepath.Join(s.UploadDir, ownerID)
|
||||
if err := os.MkdirAll(destDir, 0o755); err != nil {
|
||||
if err := os.MkdirAll(destDir, 0o700); err != nil {
|
||||
return FileDTO{}, fmt.Errorf("create upload dir: %w", err)
|
||||
}
|
||||
// MkdirAll respecte umask et ne touche pas aux dirs préexistants : on
|
||||
// enforce 0700 explicitement (cf. FEEDBACK A4).
|
||||
if err := os.Chmod(destDir, 0o700); err != nil {
|
||||
return FileDTO{}, fmt.Errorf("chmod upload dir: %w", err)
|
||||
}
|
||||
|
||||
destPath := filepath.Join(destDir, resourceID+"."+extension)
|
||||
if err := copyMultipart(file, destPath); err != nil {
|
||||
destName := resourceID
|
||||
if extension != "" {
|
||||
destName = resourceID + "." + extension
|
||||
}
|
||||
destPath := filepath.Join(destDir, destName)
|
||||
|
||||
// Mémorise les anciens physiques pour cleanup post-succès (changement d'ext).
|
||||
// Note : Glob(id.*) ne matche pas le fichier sans extension, on traite le
|
||||
// chemin nu séparément (cf. FEEDBACK #6).
|
||||
oldMatches, _ := filepath.Glob(filepath.Join(destDir, resourceID+".*"))
|
||||
barePath := filepath.Join(destDir, resourceID)
|
||||
if barePath != destPath {
|
||||
if _, err := os.Stat(barePath); err == nil {
|
||||
oldMatches = append(oldMatches, barePath)
|
||||
}
|
||||
}
|
||||
|
||||
written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize)
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
|
||||
mimeType := file.Header.Get("Content-Type")
|
||||
var err error
|
||||
mimeType := sanitizeMimeType(file.Header.Get("Content-Type"))
|
||||
var extPtr *string
|
||||
if extension != "" {
|
||||
extPtr = &extension
|
||||
}
|
||||
if targetExisting {
|
||||
err = s.Repo.UpdatePhysical(ownerID, resourceID, file.Size, &mimeType, &extension)
|
||||
err = s.Repo.UpdatePhysical(ownerID, resourceID, written, &mimeType, extPtr)
|
||||
} else {
|
||||
err = s.Repo.InsertFile(ownerID, resourceID, file.Filename, folderID, file.Size, &mimeType, &extension)
|
||||
err = s.Repo.InsertFile(ownerID, resourceID, name, folderID, written, &mimeType, extPtr)
|
||||
}
|
||||
if err != nil {
|
||||
_ = os.Remove(destPath)
|
||||
// Best-effort : supprime le nouveau fichier sauf s'il préexistait à l'identique.
|
||||
stillOld := false
|
||||
for _, m := range oldMatches {
|
||||
if m == destPath {
|
||||
stillOld = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !stillOld {
|
||||
_ = os.Remove(destPath)
|
||||
}
|
||||
return FileDTO{}, err
|
||||
}
|
||||
// Succès : supprime les anciens suffixes orphelins (stale bytes, cf. #6).
|
||||
for _, m := range oldMatches {
|
||||
if m != destPath && strings.HasPrefix(filepath.Base(m), resourceID+".") {
|
||||
_ = os.Remove(m)
|
||||
}
|
||||
}
|
||||
|
||||
row, err := s.Repo.GetFile(ownerID, resourceID)
|
||||
if err != nil {
|
||||
// Lecture post-insert en échec : au moins logguer (cf. FEEDBACK #6).
|
||||
// Sur création on tente en plus de retirer le fichier pour ne pas
|
||||
// laisser d'orphelin (le client retry → NAME_CONFLICT → re-upload
|
||||
// ciblé). Sur re-upload ciblé on ne touche à rien (données existantes).
|
||||
log.Printf("upload: GetFile(%s) failed after persist: %v", resourceID, err)
|
||||
if !targetExisting {
|
||||
_ = os.Remove(destPath)
|
||||
}
|
||||
return FileDTO{}, err
|
||||
}
|
||||
return toFileDTO(row), nil
|
||||
}
|
||||
|
||||
func copyMultipart(file *multipart.FileHeader, destPath string) error {
|
||||
// copyMultipartAtomic écrit vers un temp dans destDir (0600) avec limite
|
||||
// stricte maxSize+1 (header file.Size non fiable, cf. A2), fsync + rename
|
||||
// atomique (cf. A3). Retourne les octets réellement écrits.
|
||||
func copyMultipartAtomic(file *multipart.FileHeader, destDir, destPath string, maxSize int64) (int64, error) {
|
||||
src, err := file.Open()
|
||||
if err != nil {
|
||||
return fmt.Errorf("open multipart file: %w", err)
|
||||
return 0, fmt.Errorf("open multipart file: %w", err)
|
||||
}
|
||||
defer src.Close()
|
||||
|
||||
dst, err := os.Create(destPath)
|
||||
// Temp dans le même répertoire (même filesystem → rename atomique),
|
||||
// pattern .tmp-<base>-* (cf. FEEDBACK A3). Jamais d'overwrite direct.
|
||||
tmp, err := os.CreateTemp(destDir, ".tmp-"+filepath.Base(destPath)+".*")
|
||||
if err != nil {
|
||||
return fmt.Errorf("create file: %w", err)
|
||||
return 0, fmt.Errorf("create tmp file: %w", err)
|
||||
}
|
||||
tmpName := tmp.Name()
|
||||
// En cas d'échec avant rename, nettoyer le temp.
|
||||
success := false
|
||||
defer func() {
|
||||
if !success {
|
||||
_ = os.Remove(tmpName)
|
||||
}
|
||||
}()
|
||||
if err := tmp.Chmod(0o600); err != nil {
|
||||
tmp.Close()
|
||||
return 0, fmt.Errorf("chmod tmp file: %w", err)
|
||||
}
|
||||
defer dst.Close()
|
||||
|
||||
if _, err := io.Copy(dst, src); err != nil {
|
||||
return fmt.Errorf("copy upload: %w", err)
|
||||
limited := io.LimitReader(src, maxSize+1)
|
||||
written, err := io.Copy(tmp, limited)
|
||||
if err != nil {
|
||||
tmp.Close()
|
||||
return 0, fmt.Errorf("copy upload: %w", err)
|
||||
}
|
||||
return nil
|
||||
if written > maxSize {
|
||||
tmp.Close()
|
||||
return 0, ErrFileTooLarge
|
||||
}
|
||||
if err := tmp.Sync(); err != nil {
|
||||
tmp.Close()
|
||||
return 0, fmt.Errorf("fsync upload: %w", err)
|
||||
}
|
||||
if err := tmp.Close(); err != nil {
|
||||
return 0, fmt.Errorf("close upload: %w", err)
|
||||
}
|
||||
if err := os.Rename(tmpName, destPath); err != nil {
|
||||
return 0, fmt.Errorf("commit upload: %w", err)
|
||||
}
|
||||
if err := os.Chmod(destPath, 0o600); err != nil {
|
||||
return 0, fmt.Errorf("chmod upload: %w", err)
|
||||
}
|
||||
success = true
|
||||
return written, nil
|
||||
}
|
||||
|
||||
func toFileDTO(row repository.FileRow) FileDTO {
|
||||
|
||||
@@ -6,6 +6,7 @@ import (
|
||||
"mime/multipart"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/kazier/backend/repository"
|
||||
@@ -162,3 +163,204 @@ func TestUploadTargetUnknownIsNotFound(t *testing.T) {
|
||||
t.Fatalf("upload inconnu : attendu ErrNotFound, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// A2 : le header multipart Size est déclaratif — seul le comptage réel des
|
||||
// octets (LimitReader MaxFileSize+1) fait foi.
|
||||
func TestUploadEnforcesActualSizeDespiteLyingHeader(t *testing.T) {
|
||||
s := newServiceStore(t) // MaxFileSize = 100
|
||||
userID := mustCreateUser(t, s.Repository, "upload-lying")
|
||||
|
||||
fh := multipartFileHeader(t, "big.txt", bytes.Repeat([]byte("x"), 150))
|
||||
fh.Size = 10 // header menteur : annonce 10 alors que 150 arrivent
|
||||
if _, err := s.Upload(userID, fh, "", ""); !errors.Is(err, ErrFileTooLarge) {
|
||||
t.Fatalf("header menteur : attendu ErrFileTooLarge, got %v", err)
|
||||
}
|
||||
// Aucun résidu physique (ni fichier final, ni .tmp-* orphelin).
|
||||
if entries, err := os.ReadDir(filepath.Join(s.UploadDir, userID)); err == nil && len(entries) != 0 {
|
||||
names := make([]string, 0, len(entries))
|
||||
for _, e := range entries {
|
||||
names = append(names, e.Name())
|
||||
}
|
||||
t.Errorf("résidu physique après refus : %v", names)
|
||||
}
|
||||
}
|
||||
|
||||
// #5 : extension sanitizée (lowercase [a-z0-9]{1,10}), pas de "id." si vide.
|
||||
func TestUploadSanitizesExtension(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "upload-ext")
|
||||
|
||||
// Uppercase → lowercase.
|
||||
dto, err := s.Upload(userID, multipartFileHeader(t, "PHOTO.JPG", []byte("data")), "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload uppercase ext: %v", err)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto.ID+".jpg")); err != nil {
|
||||
t.Errorf("fichier .jpg (lowercase) attendu: %v", err)
|
||||
}
|
||||
|
||||
// Pas d'extension → fichier nu, sans trailing dot.
|
||||
dto2, err := s.Upload(userID, multipartFileHeader(t, "README", []byte("data")), "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload sans ext: %v", err)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto2.ID)); err != nil {
|
||||
t.Errorf("fichier sans extension attendu: %v", err)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto2.ID+".")); !os.IsNotExist(err) {
|
||||
t.Errorf("trailing dot interdit (id.) : err=%v", err)
|
||||
}
|
||||
|
||||
// Extension trop longue / non alnum → "" (fichier nu).
|
||||
dto3, err := s.Upload(userID, multipartFileHeader(t, "run.verylongextensiontoolong", []byte("data")), "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload ext invalide: %v", err)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, dto3.ID)); err != nil {
|
||||
t.Errorf("ext invalide → fichier nu attendu: %v", err)
|
||||
}
|
||||
|
||||
// Backslash survit au round-trip multipart stdlib → rejet prouvé de bout
|
||||
// en bout (les autres cas slash/NUL/retour-ligne sont couverts en
|
||||
// unitaire sur sanitizeFileName, la stdlib Go les neutralisant déjà).
|
||||
if _, err := s.Upload(userID, multipartFileHeader(t, `a\b.txt`, []byte("data")), "", ""); !errors.Is(err, ErrInvalidUpload) {
|
||||
t.Errorf(`nom %q : attendu ErrInvalidUpload, got %v`, `a\b.txt`, err)
|
||||
}
|
||||
}
|
||||
|
||||
// #5/A16 : sanitizeurs unitaires — un client non-Go peut envoyer un filename
|
||||
// brut (slash, .., NUL, retour-ligne) que la stdlib Go ne neutraliserait pas
|
||||
// côté lecture serveur.
|
||||
func TestSanitizeFileName(t *testing.T) {
|
||||
for _, bad := range []string{"", " ", "../evil.txt", "a/b.txt", "a\x00b.txt", "bad\nname.txt", "bad\rname.txt", strings.Repeat("a", 256)} {
|
||||
if _, err := sanitizeFileName(bad); !errors.Is(err, ErrInvalidUpload) {
|
||||
t.Errorf("sanitizeFileName(%q) : attendu ErrInvalidUpload, got %v", bad, err)
|
||||
}
|
||||
}
|
||||
for _, good := range []string{"docs.txt", " pad.txt ", "vacances-août.jpg", "a b c.pdf"} {
|
||||
got, err := sanitizeFileName(good)
|
||||
if err != nil {
|
||||
t.Errorf("sanitizeFileName(%q) : rejet inattendu: %v", good, err)
|
||||
} else if got != strings.TrimSpace(good) {
|
||||
t.Errorf("sanitizeFileName(%q) = %q, attendu trim", good, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSanitizeExtension(t *testing.T) {
|
||||
cases := map[string]string{
|
||||
"photo.JPG": "jpg",
|
||||
"archive.tar.gz": "gz",
|
||||
"README": "",
|
||||
"run.verylongextensiontoolong": "",
|
||||
"evil.php/../../x": "",
|
||||
"a.b/c": "",
|
||||
"weird.HTM\nL": "",
|
||||
"dot.": "",
|
||||
}
|
||||
for in, want := range cases {
|
||||
if got := sanitizeExtension(in); got != want {
|
||||
t.Errorf("sanitizeExtension(%q) = %q, attendu %q", in, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// #6 : un re-upload ciblé avec une nouvelle extension ne laisse qu'un seul
|
||||
// fichier physique (l'ancien suffixe est supprimé).
|
||||
func TestUploadReuploadNewExtensionRemovesStaleFile(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "upload-reext")
|
||||
|
||||
resourceID := repository.NewID()
|
||||
png := "png"
|
||||
if err := s.Repository.Resources.InsertFile(userID, resourceID, "scan.png", "", 0, nil, &png); err != nil {
|
||||
t.Fatalf("insert metadata-only: %v", err)
|
||||
}
|
||||
if _, err := s.Upload(userID, multipartFileHeader(t, "scan.png", []byte("PNGDATA")), "", resourceID); err != nil {
|
||||
t.Fatalf("premier upload ciblé: %v", err)
|
||||
}
|
||||
|
||||
dto, err := s.Upload(userID, multipartFileHeader(t, "scan.jpg", []byte("JPGDATA!")), "", resourceID)
|
||||
if err != nil {
|
||||
t.Fatalf("re-upload nouvelle ext: %v", err)
|
||||
}
|
||||
if dto.ID != resourceID {
|
||||
t.Fatalf("id attendu %s, got %s", resourceID, dto.ID)
|
||||
}
|
||||
entries, err := os.ReadDir(filepath.Join(s.UploadDir, userID))
|
||||
if err != nil {
|
||||
t.Fatalf("readdir: %v", err)
|
||||
}
|
||||
if len(entries) != 1 || entries[0].Name() != resourceID+".jpg" {
|
||||
names := make([]string, 0, len(entries))
|
||||
for _, e := range entries {
|
||||
names = append(names, e.Name())
|
||||
}
|
||||
t.Errorf("un seul physique attendu (%s.jpg), got %v", resourceID, names)
|
||||
}
|
||||
content, err := os.ReadFile(filepath.Join(s.UploadDir, userID, resourceID+".jpg"))
|
||||
if err != nil || string(content) != "JPGDATA!" {
|
||||
t.Errorf("contenu = %q, err=%v (attendu JPGDATA!)", content, err)
|
||||
}
|
||||
}
|
||||
|
||||
// A4 : répertoire 0700, fichier 0600 (enforcés malgré umask).
|
||||
func TestUploadFileAndDirPermissions(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "upload-perms")
|
||||
|
||||
dto, err := s.Upload(userID, multipartFileHeader(t, "secret.txt", []byte("data")), "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload: %v", err)
|
||||
}
|
||||
dirInfo, err := os.Stat(filepath.Join(s.UploadDir, userID))
|
||||
if err != nil {
|
||||
t.Fatalf("stat dir: %v", err)
|
||||
}
|
||||
if perm := dirInfo.Mode().Perm(); perm != 0o700 {
|
||||
t.Errorf("perms dossier = %04o, attendu 0700", perm)
|
||||
}
|
||||
fileInfo, err := os.Stat(filepath.Join(s.UploadDir, userID, dto.ID+".txt"))
|
||||
if err != nil {
|
||||
t.Fatalf("stat file: %v", err)
|
||||
}
|
||||
if perm := fileInfo.Mode().Perm(); perm != 0o600 {
|
||||
t.Errorf("perms fichier = %04o, attendu 0600", perm)
|
||||
}
|
||||
}
|
||||
|
||||
// A16 : Content-Type hors whitelist → fallback application/octet-stream.
|
||||
func TestUploadMimeTypeWhitelistFallback(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "upload-mime")
|
||||
|
||||
evil := multipartFileHeader(t, "evil.bin", []byte("data"))
|
||||
evil.Header.Set("Content-Type", "application/x-evil-tool")
|
||||
dto, err := s.Upload(userID, evil, "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload evil mime: %v", err)
|
||||
}
|
||||
if dto.MimeType != "application/octet-stream" {
|
||||
t.Errorf("mime inattendu = %q, attendu fallback application/octet-stream", dto.MimeType)
|
||||
}
|
||||
|
||||
withParams := multipartFileHeader(t, "page.bin", []byte("data"))
|
||||
withParams.Header.Set("Content-Type", "text/html; charset=utf-8")
|
||||
dto, err = s.Upload(userID, withParams, "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload html mime: %v", err)
|
||||
}
|
||||
if dto.MimeType != "application/octet-stream" {
|
||||
t.Errorf("text/html non whitelisté, fallback attendu, got %q", dto.MimeType)
|
||||
}
|
||||
|
||||
allowed := multipartFileHeader(t, "img.bin", []byte("data"))
|
||||
allowed.Header.Set("Content-Type", "image/png")
|
||||
dto, err = s.Upload(userID, allowed, "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload png mime: %v", err)
|
||||
}
|
||||
if dto.MimeType != "image/png" {
|
||||
t.Errorf("mime whitelisté perdu, got %q", dto.MimeType)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,31 +1,6 @@
|
||||
package service
|
||||
|
||||
import "github.com/kazier/backend/models"
|
||||
|
||||
type Services struct {
|
||||
ConnectedUser *models.User
|
||||
}
|
||||
|
||||
func New(connectedUser *models.User) *Services {
|
||||
|
||||
return &Services{
|
||||
ConnectedUser: connectedUser,
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func UserCanReadDocument(connectedUser *models.User, document *models.Document) (bool, string) {
|
||||
return true, ""
|
||||
}
|
||||
|
||||
func UserCanEditDocument(connectedUser *models.User, document *models.Document) (bool, string) {
|
||||
return true, ""
|
||||
}
|
||||
|
||||
func UserCanDeleteDocument(connectedUser *models.User, document *models.Document) (bool, string) {
|
||||
return true, ""
|
||||
}
|
||||
|
||||
func UserCanCreateDocument(connectedUser *models.User, document *models.Document) (bool, string) {
|
||||
return true, ""
|
||||
}
|
||||
// Stubs historiques UserCan* (toujours-true) supprimés — LOT 5 #11.
|
||||
// L'autorisation V1 est portée par le scoping owner (`user_id`) dans
|
||||
// repository.Resources + les grants `shares` (cf. docs/api-v1.md) :
|
||||
// aucune fonction toujours-true ne doit subsister ici.
|
||||
|
||||
+168
-35
@@ -3,6 +3,7 @@ package service
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"log"
|
||||
"regexp"
|
||||
"time"
|
||||
|
||||
@@ -92,33 +93,86 @@ func classifySyncError(err error) (string, string) {
|
||||
return "NOT_FOUND", "target resource or folder not found"
|
||||
case errors.Is(err, repository.ErrGranteeNotFound):
|
||||
return "GRANTEE_NOT_FOUND", "the specified user does not exist"
|
||||
case errors.Is(err, repository.ErrPayloadMismatch):
|
||||
return "INVALID_REQUEST", "operation replayed with different payload"
|
||||
case errors.Is(err, errCycle):
|
||||
return "INVALID_REQUEST", "cannot move a resource into its own subtree"
|
||||
default:
|
||||
return "INVALID_REQUEST", err.Error()
|
||||
// Volontairement générique : ne pas fuir SQL/FS internes (cf. #8).
|
||||
// Le détail reste côté serveur (logs), le client reçoit un code stable.
|
||||
log.Printf("sync: internal apply error: %v", err)
|
||||
return "INVALID_REQUEST", "invalid operation"
|
||||
}
|
||||
}
|
||||
|
||||
var errCycle = errors.New("cannot move a resource into its own subtree")
|
||||
|
||||
// ApplyBatch applique les ops de l'outbox : les mutations de ressources sont
|
||||
// scopées par l'UTILISATEUR (userID), l'idempotence reste par DEVICE
|
||||
// (deviceID) — cf. docs/api-v1.md §6.1.
|
||||
//
|
||||
// Atomicité par op (#7) : chaque op est sérialisée par un claim atomique sur
|
||||
// la trace outbox (INSERT ... ON CONFLICT DO NOTHING portant la contrainte
|
||||
// UNIQUE(device_id, operation_id), cf. Operations.Claim) — deux batches
|
||||
// concurrents ne peuvent pas appliquer deux fois la même op : le perdant
|
||||
// suit le chemin rejeu (comparaison de hash, cf. A9). Le claim est posé en
|
||||
// status='failed' AVANT l'apply puis promu en 'applied' (MarkApplied) une
|
||||
// fois l'effet durable : un crash entre les deux laisse une trace rejouable
|
||||
// (ré-apply à payload identique), jamais un skip silencieux.
|
||||
//
|
||||
// Limite documentée : claim→apply→promote ne sont pas une transaction SQL
|
||||
// unique — apply touche resources/shares via des statements atomiques
|
||||
// (INSERT ... SELECT parent, TouchOwned). Le TOCTOU résiduel (deux owners
|
||||
// créant le même resource_id) dégénère en NAME_CONFLICT explicite, jamais
|
||||
// en double écriture silencieuse. Une atomicité totale exigerait un
|
||||
// transaction manager transverse aux repos (vrai Tx ApplyBatch, reportée —
|
||||
// cf. FEEDBACK risques résiduels).
|
||||
//
|
||||
// Erreurs de persistance (claim/promote) : retournées comme applied:i
|
||||
// explicite avec code INTERNAL, jamais en erreur Go nue (500 nu) — le client
|
||||
// sait exactement où reprendre.
|
||||
func (s *Resources) ApplyBatch(userID, deviceID string, ops []SyncOperation) (SyncResult, error) {
|
||||
for i := range ops {
|
||||
op := &ops[i]
|
||||
if err := validateSyncOp(op); err != nil {
|
||||
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: err.Error()}}, nil
|
||||
}
|
||||
already, err := s.Repository.Operations.Applied(deviceID, op.OperationID)
|
||||
claimed, err := s.Repository.Operations.Claim(deviceID, op.OperationID, op.Operation, derefString(op.RefType), nullableInt64(derefInt64(op.RefID)), derefString(op.ResourceID), op.Payload)
|
||||
if err != nil {
|
||||
return SyncResult{}, err
|
||||
// Faute client (clé ou payload malformé) → INVALID_REQUEST halt,
|
||||
// message statique sûr ; panne persistance → INTERNAL explicite.
|
||||
if errors.Is(err, repository.ErrInvalidOperationID) {
|
||||
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "operation_id must be 32 lowercase hex chars"}}, nil
|
||||
}
|
||||
if errors.Is(err, repository.ErrInvalidPayload) {
|
||||
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "invalid payload JSON"}}, nil
|
||||
}
|
||||
log.Printf("sync: claim device=%s op=%s: %v", deviceID, op.OperationID, err)
|
||||
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "failed to persist operation state"}}, nil
|
||||
}
|
||||
if already {
|
||||
continue
|
||||
if !claimed {
|
||||
// Rejeu : même (device, op) déjà tracé — comparer (A9).
|
||||
stored, err := s.Repository.Operations.Get(deviceID, op.OperationID)
|
||||
if err != nil {
|
||||
log.Printf("sync: replay read device=%s op=%s: %v", deviceID, op.OperationID, err)
|
||||
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "failed to read operation state"}}, nil
|
||||
}
|
||||
if err := stored.MatchesReplay(op.Operation, derefString(op.ResourceID), op.Payload); err != nil {
|
||||
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "operation replayed with different payload"}}, nil
|
||||
}
|
||||
if stored.Status == repository.OpStatusApplied {
|
||||
continue // déjà appliquée à l'identique → skip idempotent
|
||||
}
|
||||
// Trace 'failed' à payload identique : la première tentative est
|
||||
// morte avant MarkApplied (crash) → on ré-applique (recovery).
|
||||
}
|
||||
if err := s.applySyncOp(userID, op); err != nil {
|
||||
code, message := classifySyncError(err)
|
||||
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: code, Message: message}}, nil
|
||||
}
|
||||
if err := s.recordApplied(deviceID, op); err != nil {
|
||||
return SyncResult{}, err
|
||||
if err := s.Repository.Operations.MarkApplied(deviceID, op.OperationID); err != nil {
|
||||
log.Printf("sync: promote device=%s op=%s: %v", deviceID, op.OperationID, err)
|
||||
return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "operation applied but trace update failed; safe to retry"}}, nil
|
||||
}
|
||||
}
|
||||
return SyncResult{Applied: len(ops)}, nil
|
||||
@@ -167,29 +221,47 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
|
||||
// Le parent doit exister et appartenir à l'utilisateur (NOT_FOUND sinon,
|
||||
// cohérent avec move_resource). Ordre du SAF walk : parent avant enfant.
|
||||
if p.ParentResourceID != "" {
|
||||
if !resourceIDPattern.MatchString(p.ParentResourceID) {
|
||||
return errors.New("payload.parentResourceId must be 32 lowercase hex chars")
|
||||
}
|
||||
if _, err := s.Repo.GetFolder(ownerID, p.ParentResourceID); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
var insertErr error
|
||||
if derefString(op.ResourceType) == "folder" {
|
||||
return s.Repo.InsertFolder(ownerID, resourceID, p.Name, p.ParentResourceID)
|
||||
insertErr = s.Repo.InsertFolder(ownerID, resourceID, p.Name, p.ParentResourceID)
|
||||
} else {
|
||||
mime := p.MimeType
|
||||
insertErr = s.Repo.InsertFile(ownerID, resourceID, p.Name, p.ParentResourceID, 0, &mime, nullableString(p.Extension))
|
||||
}
|
||||
mime := p.MimeType
|
||||
return s.Repo.InsertFile(ownerID, resourceID, p.Name, p.ParentResourceID, 0, &mime, nullableString(p.Extension))
|
||||
if insertErr != nil {
|
||||
// Course ExistsOwner→Insert (concurrent ou rejeu croisé) : si la
|
||||
// ressource est désormais owned, l'effet est atteint → idempotent.
|
||||
// Sinon NAME_CONFLICT explicite (sibling ou resource_id d'autrui).
|
||||
// Atomicité totale (INSERT ... SELECT) : inter-lots, LOT 4.
|
||||
if errors.Is(insertErr, repository.ErrNameConflict) {
|
||||
if owned, err := s.Repo.ExistsOwner(ownerID, resourceID); err == nil && owned {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return insertErr
|
||||
}
|
||||
return nil
|
||||
|
||||
case OpUpdateMetadata:
|
||||
// Owner can always rename. A shared resource can be renamed by an
|
||||
// editor+ (docs §6.2 effective_access ranking). Below editor, or on
|
||||
// a resource the caller cannot reach at all, we keep the documented
|
||||
// terminal-state semantics: absent → no-op.
|
||||
// Sémantique uniforme (A8) : toute ressource que l'appelant ne peut
|
||||
// pas renommer — absente, d'autrui, ou partagée sous editor — halte
|
||||
// en NOT_FOUND. Pas de no-op silencieux : un rename qui n'a rien
|
||||
// renommé est un bug client ou une désync, le halt l'expose au lieu
|
||||
// de valider un état qui n'existe pas. Le même code NOT_FOUND dans
|
||||
// tous les cas évite tout oracle d'existence. Owner → rank owner,
|
||||
// editor+ partagé → autorisé (docs §6.2).
|
||||
access, err := s.Repository.Shares.EffectiveAccess(ownerID, resourceID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if access.EffectiveRank < repository.AccessEditor {
|
||||
if !access.Accessible {
|
||||
return nil
|
||||
}
|
||||
return repository.ErrNotFound
|
||||
}
|
||||
var p renamePayload
|
||||
@@ -199,16 +271,17 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
|
||||
if p.Name == "" {
|
||||
return errors.New("payload.name required")
|
||||
}
|
||||
return s.Repo.UpdateNameByID(resourceID, p.Name)
|
||||
// NOTE : UpdateNameByID (non-scopé) est volontaire ici — un editor
|
||||
// non-owner peut renommer (EffectiveAccess vérifié plus haut), donc
|
||||
// UpdateNameOwned(ownerID, ...) rejetterait à tort. La garde
|
||||
// d'autorisation précède immédiatement l'écriture.
|
||||
return s.Repo.UpdateNameByID(resourceID, p.Name)
|
||||
|
||||
case OpMoveResource:
|
||||
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !exists {
|
||||
return nil
|
||||
}
|
||||
// A8 : move owner-only. Source non-owned (absente OU d'autrui) →
|
||||
// NOT_FOUND halt (MoveResource ne touche que les lignes owned).
|
||||
// Pas de applied silencieux : un move qui n'a rien déplacé
|
||||
// désynchroniserait le client.
|
||||
var p movePayload
|
||||
if err := json.Unmarshal(op.Payload, &p); err != nil {
|
||||
return errors.New("invalid payload: " + err.Error())
|
||||
@@ -216,9 +289,36 @@ func (s *Resources) applySyncOp(ownerID string, op *SyncOperation) error {
|
||||
if p.ToFolderResourceID == resourceID {
|
||||
return errors.New("cannot move a resource into itself")
|
||||
}
|
||||
if p.ToFolderResourceID != "" {
|
||||
if !resourceIDPattern.MatchString(p.ToFolderResourceID) {
|
||||
return errors.New("payload.toFolderResourceId must be 32 lowercase hex chars")
|
||||
}
|
||||
// Check de cycle : le dossier cible ne doit pas être la ressource
|
||||
// elle-même ni l'un de ses descendants (cf. FEEDBACK #2).
|
||||
if err := s.checkNoCycle(p.ToFolderResourceID, resourceID); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return s.Repo.MoveResource(ownerID, resourceID, p.ToFolderResourceID)
|
||||
|
||||
case OpDeleteResource:
|
||||
// A8 : delete owner-only. Ligne vivante d'autrui → NOT_FOUND halt
|
||||
// (pas de applied silencieux). Aucune ligne vivante (jamais existé,
|
||||
// ou déjà supprimée par son owner) → no-op idempotent : l'état
|
||||
// terminal (absente) est déjà atteint, le rejeu reste sûr.
|
||||
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !exists {
|
||||
if _, err := s.Repo.GetResourceOwner(resourceID); err != nil {
|
||||
if errors.Is(err, repository.ErrNotFound) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
return repository.ErrNotFound
|
||||
}
|
||||
return s.Repo.SyncDelete(ownerID, resourceID)
|
||||
|
||||
case OpShare, OpUpdateShare:
|
||||
@@ -275,13 +375,18 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation)
|
||||
var expiresAt *time.Time
|
||||
if p.ExpiresAt != nil {
|
||||
t := time.UnixMilli(*p.ExpiresAt)
|
||||
if !t.After(time.Now()) {
|
||||
return errors.New("payload.expiresAt must be in the future")
|
||||
}
|
||||
expiresAt = &t
|
||||
}
|
||||
if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil {
|
||||
return err
|
||||
}
|
||||
// Bump resource updated_at so the grantee's delta snapshot picks it up.
|
||||
return s.Repo.TouchResource(resourceID)
|
||||
// Scopé owner (ExistsOwner vérifié plus haut) : TouchOwned, jamais le
|
||||
// TouchResource non-scopé.
|
||||
return s.Repo.TouchOwned(ownerID, resourceID)
|
||||
}
|
||||
|
||||
// applyRevokeShareOp handles OpRevokeShare: soft-revoke a user-to-user grant.
|
||||
@@ -303,10 +408,13 @@ func (s *Resources) applyRevokeShareOp(ownerID, resourceID string, op *SyncOpera
|
||||
if !resourceIDPattern.MatchString(p.GranteeUserID) {
|
||||
return errors.New("payload.granteeUserId must be 32 lowercase hex chars")
|
||||
}
|
||||
// Revoke is idempotent: no-op if already revoked/missing.
|
||||
_ = s.Repository.Shares.Revoke(resourceID, p.GranteeUserID)
|
||||
// Revoke is idempotent: no-op if already revoked/missing — mais les vraies
|
||||
// pannes DB remontent (cf. FEEDBACK §moyenne).
|
||||
if err := s.Repository.Shares.Revoke(resourceID, p.GranteeUserID); err != nil && !errors.Is(err, repository.ErrNotFound) {
|
||||
return err
|
||||
}
|
||||
// Bump resource updated_at so the grantee's delta snapshot reflects the change.
|
||||
return s.Repo.TouchResource(resourceID)
|
||||
return s.Repo.TouchOwned(ownerID, resourceID)
|
||||
}
|
||||
|
||||
// applyCreateLinkOp handles OpCreateLink: create a public share link.
|
||||
@@ -332,12 +440,15 @@ func (s *Resources) applyCreateLinkOp(ownerID, resourceID string, op *SyncOperat
|
||||
var expiresAt *time.Time
|
||||
if p.ExpiresAt != nil {
|
||||
t := time.UnixMilli(*p.ExpiresAt)
|
||||
if !t.After(time.Now()) {
|
||||
return errors.New("payload.expiresAt must be in the future")
|
||||
}
|
||||
expiresAt = &t
|
||||
}
|
||||
if err := s.Repository.Shares.CreateLink(p.Token, resourceID, p.Access, expiresAt, ownerID); err != nil {
|
||||
return err
|
||||
}
|
||||
return s.Repo.TouchResource(resourceID)
|
||||
return s.Repo.TouchOwned(ownerID, resourceID)
|
||||
}
|
||||
|
||||
// applyRevokeLinkOp handles OpRevokeLink: soft-revoke a public share link.
|
||||
@@ -356,13 +467,35 @@ func (s *Resources) applyRevokeLinkOp(ownerID, resourceID string, op *SyncOperat
|
||||
if !resourceIDPattern.MatchString(p.Token) {
|
||||
return errors.New("payload.token must be 32 lowercase hex chars")
|
||||
}
|
||||
// Revoke is idempotent: no-op if already revoked/missing.
|
||||
_ = s.Repository.Shares.RevokeLink(p.Token)
|
||||
return s.Repo.TouchResource(resourceID)
|
||||
// Revoke is idempotent: no-op if already revoked/missing — mais les vraies
|
||||
// pannes DB remontent.
|
||||
if err := s.Repository.Shares.RevokeLink(p.Token); err != nil && !errors.Is(err, repository.ErrNotFound) {
|
||||
return err
|
||||
}
|
||||
return s.Repo.TouchOwned(ownerID, resourceID)
|
||||
}
|
||||
|
||||
func (s *Resources) recordApplied(deviceID string, op *SyncOperation) error {
|
||||
return s.Repository.Operations.Record(deviceID, op.OperationID, op.Operation, derefString(op.RefType), nullableInt64(derefInt64(op.RefID)), derefString(op.ResourceID), op.Payload)
|
||||
// checkNoCycle remonte la chaîne parentale depuis toFolder : si on rencontre
|
||||
// resourceID, le move créerait un cycle (cf. FEEDBACK #2).
|
||||
func (s *Resources) checkNoCycle(toFolderID, resourceID string) error {
|
||||
cur := toFolderID
|
||||
for i := 0; i < 128; i++ {
|
||||
if cur == "" {
|
||||
return nil
|
||||
}
|
||||
if cur == resourceID {
|
||||
return errCycle
|
||||
}
|
||||
parent, err := s.Repo.GetParentID(cur)
|
||||
if err != nil {
|
||||
if errors.Is(err, repository.ErrNotFound) {
|
||||
return err
|
||||
}
|
||||
return err
|
||||
}
|
||||
cur = parent
|
||||
}
|
||||
return errCycle
|
||||
}
|
||||
|
||||
func derefString(v *string) string {
|
||||
|
||||
@@ -208,6 +208,41 @@ func TestApplyBatchMoveToMissingFolder(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyBatchMoveIntoDescendantRejected(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "sync-move-cycle")
|
||||
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
|
||||
|
||||
parentID := repository.NewID()
|
||||
childID := repository.NewID()
|
||||
if _, err := s.ApplyBatch(userID, deviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), parentID, OpCreateResource, "folder", map[string]any{"name": "parent"}),
|
||||
syncOp(repository.NewID(), childID, OpCreateResource, "folder", map[string]any{"name": "child", "parentResourceId": parentID}),
|
||||
}); err != nil {
|
||||
t.Fatalf("apply create parent+child: %v", err)
|
||||
}
|
||||
|
||||
// Déplacer le parent dans son propre enfant créerait un cycle : halt.
|
||||
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), parentID, OpMoveResource, "folder", map[string]any{"toFolderResourceId": childID}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ApplyBatch: %v", err)
|
||||
}
|
||||
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "INVALID_REQUEST" {
|
||||
t.Fatalf("move parent→enfant: attendu applied=0 INVALID_REQUEST, got %+v", result)
|
||||
}
|
||||
|
||||
// Le parent est toujours à la racine : aucun cycle créé.
|
||||
got, err := s.Repository.Resources.GetParentID(parentID)
|
||||
if err != nil {
|
||||
t.Fatalf("GetParentID: %v", err)
|
||||
}
|
||||
if got != "" {
|
||||
t.Errorf("parent déplacé malgré le rejet: parent=%q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyBatchRejectsInvalidPayloadJSON(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "sync-badpayload")
|
||||
@@ -1146,15 +1181,16 @@ func TestUpdateMetadataRequiresEditor(t *testing.T) {
|
||||
t.Errorf("viewer update: attendu applied=0 NOT_FOUND, got %+v", result)
|
||||
}
|
||||
|
||||
// Stranger (no access) → no-op terminal (absent semantics), no failure.
|
||||
// Stranger (no access) → NOT_FOUND halt (A8 : pas de no-op silencieux ;
|
||||
// un rename qui n'a rien renommé est une désync, le halt l'expose).
|
||||
result, err = s.ApplyBatch(strangerID, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{"name": "sneak.txt"}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("stranger update: %v", err)
|
||||
}
|
||||
if result.Applied != 1 || result.Failed != nil {
|
||||
t.Errorf("stranger update: attendu applied=1 aucun échec, got %+v", result)
|
||||
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
|
||||
t.Errorf("stranger update: attendu applied=0 NOT_FOUND, got %+v", result)
|
||||
}
|
||||
row, err = s.Repo.GetFile(ownerID, fileID)
|
||||
if err != nil || row.Name != "renamed.txt" {
|
||||
@@ -1179,15 +1215,16 @@ func TestMoveAndDeleteOwnerOnly(t *testing.T) {
|
||||
t.Fatalf("create + share: %v", err)
|
||||
}
|
||||
|
||||
// Editor tries to move the shared file → no-op (owner-only), nothing moves.
|
||||
// Editor tries to move the shared file → NOT_FOUND halt (A8 : move
|
||||
// owner-only, pas de applied silencieux).
|
||||
result, err := s.ApplyBatch(granteeID, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileID, OpMoveResource, "file", map[string]any{"toFolderResourceId": targetID}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("grantee move: %v", err)
|
||||
}
|
||||
if result.Applied != 1 || result.Failed != nil {
|
||||
t.Fatalf("grantee move: applied=%d failed=%+v", result.Applied, result.Failed)
|
||||
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
|
||||
t.Fatalf("grantee move: attendu applied=0 NOT_FOUND, got %+v", result)
|
||||
}
|
||||
row, err := s.Repo.GetFile(ownerID, fileID)
|
||||
if err != nil {
|
||||
@@ -1197,17 +1234,254 @@ func TestMoveAndDeleteOwnerOnly(t *testing.T) {
|
||||
t.Errorf("fichier déplacé par un non-owner: folderId=%q, attendu racine", row.FolderID)
|
||||
}
|
||||
|
||||
// Editor tries to delete the shared file → no-op, still present for owner.
|
||||
// Editor tries to delete the shared file → NOT_FOUND halt (A8), still
|
||||
// present for owner.
|
||||
result, err = s.ApplyBatch(granteeID, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("grantee delete: %v", err)
|
||||
}
|
||||
if result.Applied != 1 || result.Failed != nil {
|
||||
t.Fatalf("grantee delete: applied=%d failed=%+v", result.Applied, result.Failed)
|
||||
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
|
||||
t.Fatalf("grantee delete: attendu applied=0 NOT_FOUND, got %+v", result)
|
||||
}
|
||||
if _, err := s.Repo.GetFile(ownerID, fileID); err != nil {
|
||||
t.Errorf("fichier supprimé par un non-owner: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// --- LOT 3 : rejeu, payload_hash, liens idempotents, sémantiques A8 ---
|
||||
|
||||
func TestApplyBatchReplaySameOpIsIdempotent(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "replay-owner")
|
||||
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
|
||||
|
||||
fileID := repository.NewID()
|
||||
opID := repository.NewID()
|
||||
op := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"})
|
||||
|
||||
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{op})
|
||||
if err != nil || result.Applied != 1 || result.Failed != nil {
|
||||
t.Fatalf("apply 1: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
|
||||
}
|
||||
// Rejeu à l'identique (même operation_id, même payload) → skip succès.
|
||||
result, err = s.ApplyBatch(userID, deviceID, []SyncOperation{op})
|
||||
if err != nil || result.Applied != 1 || result.Failed != nil {
|
||||
t.Errorf("rejeu identique: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyBatchReplayMutatedPayloadRejected(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "replay-mut")
|
||||
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
|
||||
|
||||
fileID := repository.NewID()
|
||||
opID := repository.NewID()
|
||||
first := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"})
|
||||
if _, err := s.ApplyBatch(userID, deviceID, []SyncOperation{first}); err != nil {
|
||||
t.Fatalf("apply 1: %v", err)
|
||||
}
|
||||
// Même (device, operation_id), payload muté → INVALID_REQUEST halt (A9),
|
||||
// pas de skip silencieux.
|
||||
mutated := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "y.txt"})
|
||||
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{mutated})
|
||||
if err != nil {
|
||||
t.Fatalf("ApplyBatch: %v", err)
|
||||
}
|
||||
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "INVALID_REQUEST" {
|
||||
t.Errorf("payload muté: attendu applied=0 INVALID_REQUEST, got %+v", result)
|
||||
}
|
||||
// Même opération rejouée sous un autre type → rejet aussi.
|
||||
retyped := syncOp(opID, fileID, OpDeleteResource, "file", map[string]any{})
|
||||
result, err = s.ApplyBatch(userID, deviceID, []SyncOperation{retyped})
|
||||
if err != nil {
|
||||
t.Fatalf("ApplyBatch: %v", err)
|
||||
}
|
||||
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "INVALID_REQUEST" {
|
||||
t.Errorf("type muté: attendu applied=0 INVALID_REQUEST, got %+v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyBatchReplayWhitespaceEquivalentPayload(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "replay-ws")
|
||||
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
|
||||
|
||||
fileID := repository.NewID()
|
||||
opID := repository.NewID()
|
||||
first := syncOp(opID, fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"})
|
||||
if _, err := s.ApplyBatch(userID, deviceID, []SyncOperation{first}); err != nil {
|
||||
t.Fatalf("apply 1: %v", err)
|
||||
}
|
||||
// Même objet, sérialisation différente (espaces) → hash canonique égal → skip.
|
||||
second := SyncOperation{
|
||||
OperationID: opID,
|
||||
ResourceID: strp(fileID),
|
||||
ResourceType: strp("file"),
|
||||
Operation: OpCreateResource,
|
||||
Payload: json.RawMessage(`{ "name" : "x.txt" }`),
|
||||
}
|
||||
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{second})
|
||||
if err != nil || result.Applied != 1 || result.Failed != nil {
|
||||
t.Errorf("rejeu équivalent: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateLinkReplayIdempotent(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
ownerID := mustCreateUser(t, s.Repository, "linkreplay-owner")
|
||||
mustRegisterDevice(t, s.Repository, shareTestDeviceID)
|
||||
|
||||
fileID := repository.NewID()
|
||||
if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"}),
|
||||
}); err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
|
||||
token := repository.NewID()
|
||||
link := func(opID string) SyncOperation {
|
||||
return syncOp(opID, fileID, OpCreateLink, "file", map[string]any{
|
||||
"token": token,
|
||||
"access": "viewer",
|
||||
})
|
||||
}
|
||||
// Premier create_link.
|
||||
if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{link(repository.NewID())}); err != nil {
|
||||
t.Fatalf("create link 1: %v", err)
|
||||
}
|
||||
// Rejeu même token, même ressource, même owner (nouvel operation_id) → succès.
|
||||
result, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{link(repository.NewID())})
|
||||
if err != nil || result.Applied != 1 || result.Failed != nil {
|
||||
t.Errorf("rejeu lien identique: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateLinkTokenReuseConflict(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
ownerID := mustCreateUser(t, s.Repository, "linkconf-owner")
|
||||
mustRegisterDevice(t, s.Repository, shareTestDeviceID)
|
||||
|
||||
fileA := repository.NewID()
|
||||
fileB := repository.NewID()
|
||||
if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileA, OpCreateResource, "file", map[string]any{"name": "a.txt"}),
|
||||
syncOp(repository.NewID(), fileB, OpCreateResource, "file", map[string]any{"name": "b.txt"}),
|
||||
}); err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
|
||||
token := repository.NewID()
|
||||
if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileA, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}),
|
||||
}); err != nil {
|
||||
t.Fatalf("create link: %v", err)
|
||||
}
|
||||
// Même token vers une AUTRE ressource du même owner → NAME_CONFLICT (#3).
|
||||
result, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileB, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ApplyBatch: %v", err)
|
||||
}
|
||||
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NAME_CONFLICT" {
|
||||
t.Errorf("token réutilisé: attendu applied=0 NAME_CONFLICT, got %+v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateLinkTokenOwnerMismatch(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
owner1 := mustCreateUser(t, s.Repository, "linkown-1")
|
||||
owner2 := mustCreateUser(t, s.Repository, "linkown-2")
|
||||
mustRegisterDevice(t, s.Repository, shareTestDeviceID)
|
||||
|
||||
fileA := repository.NewID()
|
||||
fileB := repository.NewID()
|
||||
if _, err := s.ApplyBatch(owner1, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileA, OpCreateResource, "file", map[string]any{"name": "a.txt"}),
|
||||
}); err != nil {
|
||||
t.Fatalf("create A: %v", err)
|
||||
}
|
||||
if _, err := s.ApplyBatch(owner2, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileB, OpCreateResource, "file", map[string]any{"name": "b.txt"}),
|
||||
}); err != nil {
|
||||
t.Fatalf("create B: %v", err)
|
||||
}
|
||||
|
||||
token := repository.NewID()
|
||||
if _, err := s.ApplyBatch(owner1, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileA, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}),
|
||||
}); err != nil {
|
||||
t.Fatalf("create link: %v", err)
|
||||
}
|
||||
// Même token, autre owner → NAME_CONFLICT (#3).
|
||||
result, err := s.ApplyBatch(owner2, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileB, OpCreateLink, "file", map[string]any{"token": token, "access": "viewer"}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ApplyBatch: %v", err)
|
||||
}
|
||||
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NAME_CONFLICT" {
|
||||
t.Errorf("token d'autrui: attendu applied=0 NAME_CONFLICT, got %+v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUpdateMetadataAbsentHalts(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "ren-absent")
|
||||
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
|
||||
|
||||
// update_metadata sur ressource inexistante → NOT_FOUND halt (A8).
|
||||
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), repository.NewID(), OpUpdateMetadata, "file", map[string]any{"name": "ghost.txt"}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ApplyBatch: %v", err)
|
||||
}
|
||||
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
|
||||
t.Errorf("rename absent: attendu applied=0 NOT_FOUND, got %+v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMoveForeignHalts(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
ownerID := mustCreateUser(t, s.Repository, "movef-owner")
|
||||
outsiderID := mustCreateUser(t, s.Repository, "movef-outsider")
|
||||
mustRegisterDevice(t, s.Repository, shareTestDeviceID)
|
||||
|
||||
fileID := repository.NewID()
|
||||
targetID := repository.NewID()
|
||||
if _, err := s.ApplyBatch(ownerID, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "x.txt"}),
|
||||
syncOp(repository.NewID(), targetID, OpCreateResource, "folder", map[string]any{"name": "t"}),
|
||||
}); err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
// Move d'une ressource d'autrui (jamais partagée) → NOT_FOUND halt.
|
||||
result, err := s.ApplyBatch(outsiderID, shareTestDeviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileID, OpMoveResource, "file", map[string]any{"toFolderResourceId": targetID}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("ApplyBatch: %v", err)
|
||||
}
|
||||
if result.Applied != 0 || result.Failed == nil || result.Failed.Code != "NOT_FOUND" {
|
||||
t.Errorf("move étranger: attendu applied=0 NOT_FOUND, got %+v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeleteAbsentIsIdempotentNoop(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "delabsent-owner")
|
||||
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
|
||||
|
||||
// Delete d'une ressource sans ligne vivante → no-op idempotent (état
|
||||
// terminal déjà atteint), pas de halt.
|
||||
result, err := s.ApplyBatch(userID, deviceID, []SyncOperation{
|
||||
syncOp(repository.NewID(), repository.NewID(), OpDeleteResource, "file", map[string]any{}),
|
||||
})
|
||||
if err != nil || result.Applied != 1 || result.Failed != nil {
|
||||
t.Errorf("delete absent: applied=%d failed=%+v err=%v", result.Applied, result.Failed, err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/kazier/backend/models"
|
||||
)
|
||||
|
||||
func (s *Services) UploadDocument(file *string, destination *models.Document) error {
|
||||
|
||||
if canEdit, _ := UserCanEditDocument(s.ConnectedUser, destination); !canEdit {
|
||||
return fmt.Errorf("cannot edit document")
|
||||
}
|
||||
|
||||
models.NewDocument("test", models.FILE, 1)
|
||||
|
||||
return nil
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user