V3 S1-S2 : corbeille + versions + extract générique
S1 filet (backend + mobile) : corbeille 30j (deleted_at réutilisé, trash/restore récursifs, purge auto serveur), versions N=3 à chaque overwrite, ops outbox trash/restore/purge (delete legacy mappé), Room v19 (trashed_at), Deleters -> trash, écran Corbeille, walk guards. S2 extract (backend) : package extract (règles FR stdlib, corpus testé), resource_facts 000019 (origin auto/user), hook worker OCR + backfill boot, GET /files/:id/facts (viewer+). Contrat docs/api-v1.md étendu, V3.md (vision + plan).
This commit is contained in:
@@ -0,0 +1,108 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"log"
|
||||
|
||||
"github.com/kazier/backend/extract"
|
||||
"github.com/kazier/backend/repository"
|
||||
)
|
||||
|
||||
// Extract derives generic facts from OCR text (V3 S2) — dates, amounts,
|
||||
// issuers, references, suggested doc type. Rules-based (package extract),
|
||||
// no ML, no network : it runs inside the OCR worker right after Tesseract
|
||||
// and stores origin='auto' rows (user corrections, origin='user', survive
|
||||
// every re-run — see UpsertAutoFacts).
|
||||
type Extract struct {
|
||||
Repository *repository.Repository
|
||||
}
|
||||
|
||||
func NewExtract(repo *repository.Repository) *Extract {
|
||||
return &Extract{Repository: repo}
|
||||
}
|
||||
|
||||
// FactDTO serializes one row of GET /files/:id/facts.
|
||||
type FactDTO struct {
|
||||
FactType string `json:"factType"`
|
||||
ValueText string `json:"valueText,omitempty"`
|
||||
ValueNum *float64 `json:"valueNum,omitempty"`
|
||||
ValueDate string `json:"valueDate,omitempty"`
|
||||
Confidence float64 `json:"confidence"`
|
||||
Origin string `json:"origin"`
|
||||
}
|
||||
|
||||
// ProcessText extracts facts from text and replaces the resource's auto
|
||||
// facts. Empty text clears stale auto facts. Never touches user corrections.
|
||||
func (e *Extract) ProcessText(resourceID, text string) error {
|
||||
raw := extract.FromText(text)
|
||||
params := make([]repository.FactParam, 0, len(raw))
|
||||
for _, f := range raw {
|
||||
var num *float64
|
||||
if f.HasNum {
|
||||
n := f.ValueNum
|
||||
num = &n
|
||||
}
|
||||
var dat *string
|
||||
if f.ValueDate != "" {
|
||||
d := f.ValueDate
|
||||
dat = &d
|
||||
}
|
||||
text := f.ValueText
|
||||
// Amounts carry a display string ("1234.56 €") — keep the numeric
|
||||
// column as the machine value, the text as the human one.
|
||||
params = append(params, repository.FactParam{
|
||||
Type: string(f.Type),
|
||||
ValueText: text,
|
||||
ValueNum: num,
|
||||
ValueDate: dat,
|
||||
Confidence: f.Confidence,
|
||||
})
|
||||
}
|
||||
return e.Repository.Resources.UpsertAutoFacts(resourceID, params)
|
||||
}
|
||||
|
||||
// Backfill processes files with OCR text but no auto facts yet (one boot
|
||||
// pass, bounded batches). Returns the number of resources processed.
|
||||
func (e *Extract) Backfill(batch int) (int, error) {
|
||||
total := 0
|
||||
for {
|
||||
pending, err := e.Repository.Resources.ListNeedingExtract(batch)
|
||||
if err != nil {
|
||||
return total, err
|
||||
}
|
||||
if len(pending) == 0 {
|
||||
return total, nil
|
||||
}
|
||||
for _, p := range pending {
|
||||
if err := e.ProcessText(p.ResourceID, p.Text); err != nil {
|
||||
log.Printf("extract: backfill %s: %v", p.ResourceID, err)
|
||||
continue
|
||||
}
|
||||
total++
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// GetFacts returns the facts of a visible resource (viewer+, own or shared —
|
||||
// same scope as GetFileOcr, facts derive from the OCR text). Trashed/absent/
|
||||
// foreign → repository.ErrNotFound.
|
||||
func (s *Resources) GetFacts(userID, resourceID string) ([]FactDTO, error) {
|
||||
if _, err := s.Repo.GetFileVisible(userID, resourceID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rows, err := s.Repository.Resources.ListFacts(resourceID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := make([]FactDTO, 0, len(rows))
|
||||
for _, row := range rows {
|
||||
out = append(out, FactDTO{
|
||||
FactType: row.Type,
|
||||
ValueText: row.ValueText,
|
||||
ValueNum: row.ValueNum,
|
||||
ValueDate: derefString(row.ValueDate),
|
||||
Confidence: row.Confidence,
|
||||
Origin: row.Origin,
|
||||
})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
@@ -0,0 +1,196 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/kazier/backend/repository"
|
||||
)
|
||||
|
||||
func newExtractStore(t *testing.T) (*Resources, *Extract) {
|
||||
t.Helper()
|
||||
s := newServiceStore(t)
|
||||
return s, NewExtract(s.Repository)
|
||||
}
|
||||
|
||||
const extractCorpus = `EDF - SERVICE CLIENTS
|
||||
Facture n° FA-2026-0031 du 12/03/2026
|
||||
Montant total TTC : 84,20 €
|
||||
À payer avant le 12/04/2026
|
||||
`
|
||||
|
||||
func TestProcessTextPersistsAutoFacts(t *testing.T) {
|
||||
s, ex := newExtractStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "extract-auto")
|
||||
fileID := repository.NewID()
|
||||
if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil {
|
||||
t.Fatalf("insert: %v", err)
|
||||
}
|
||||
|
||||
if err := ex.ProcessText(fileID, extractCorpus); err != nil {
|
||||
t.Fatalf("process: %v", err)
|
||||
}
|
||||
facts, err := s.GetFacts(userID, fileID)
|
||||
if err != nil {
|
||||
t.Fatalf("get facts: %v", err)
|
||||
}
|
||||
byType := map[string][]FactDTO{}
|
||||
for _, f := range facts {
|
||||
byType[f.FactType] = append(byType[f.FactType], f)
|
||||
if f.Origin != "auto" {
|
||||
t.Errorf("origine = %q, attendu auto", f.Origin)
|
||||
}
|
||||
}
|
||||
if len(byType["reference"]) == 0 || len(byType["amount"]) == 0 ||
|
||||
len(byType["date"]) == 0 || len(byType["due_date"]) == 0 ||
|
||||
len(byType["doc_type"]) == 0 {
|
||||
t.Fatalf("faits manquants: %+v", byType)
|
||||
}
|
||||
var amount float64
|
||||
for _, f := range byType["amount"] {
|
||||
if f.ValueNum != nil {
|
||||
amount = *f.ValueNum
|
||||
}
|
||||
}
|
||||
if amount != 84.20 {
|
||||
t.Errorf("montant = %v, attendu 84.20", amount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestProcessTextPreservesUserCorrections(t *testing.T) {
|
||||
s, ex := newExtractStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "extract-user")
|
||||
fileID := repository.NewID()
|
||||
if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil {
|
||||
t.Fatalf("insert: %v", err)
|
||||
}
|
||||
|
||||
// Correction manuelle (S3, simulée en SQL) : l'auto ne doit jamais l'écraser.
|
||||
if _, err := s.Repository.Resources.DB.Exec(
|
||||
`INSERT INTO resource_facts (id, resource_id, fact_type, value_text, confidence, origin)
|
||||
VALUES ($1, $2, 'issuer', 'Vrai Fournisseur', 1.0, 'user')`,
|
||||
repository.NewID(), fileID,
|
||||
); err != nil {
|
||||
t.Fatalf("seed user fact: %v", err)
|
||||
}
|
||||
|
||||
if err := ex.ProcessText(fileID, extractCorpus); err != nil {
|
||||
t.Fatalf("process: %v", err)
|
||||
}
|
||||
// Re-passe (idempotence du remplacement auto).
|
||||
if err := ex.ProcessText(fileID, extractCorpus); err != nil {
|
||||
t.Fatalf("re-process: %v", err)
|
||||
}
|
||||
facts, err := s.GetFacts(userID, fileID)
|
||||
if err != nil {
|
||||
t.Fatalf("get facts: %v", err)
|
||||
}
|
||||
issuers := map[string]string{}
|
||||
autoCount := 0
|
||||
for _, f := range facts {
|
||||
if f.FactType == "issuer" {
|
||||
issuers[f.Origin] = f.ValueText
|
||||
}
|
||||
if f.Origin == "auto" {
|
||||
autoCount++
|
||||
}
|
||||
}
|
||||
if issuers["user"] != "Vrai Fournisseur" {
|
||||
t.Errorf("correction user écrasée: %+v", issuers)
|
||||
}
|
||||
if autoCount == 0 {
|
||||
t.Error("aucun fait auto après re-passe")
|
||||
}
|
||||
// Pas de doublons auto après deux passes.
|
||||
seen := map[string]int{}
|
||||
for _, f := range facts {
|
||||
if f.Origin == "auto" {
|
||||
seen[f.FactType+"\x00"+f.ValueText]++
|
||||
}
|
||||
}
|
||||
for k, n := range seen {
|
||||
if n > 1 {
|
||||
t.Errorf("doublon auto %q x%d", k, n)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestProcessTextEmptyClearsStaleAuto(t *testing.T) {
|
||||
s, ex := newExtractStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "extract-clear")
|
||||
fileID := repository.NewID()
|
||||
if err := s.Repository.Resources.InsertFile(userID, fileID, "doc.pdf", "", 0, nil, nil); err != nil {
|
||||
t.Fatalf("insert: %v", err)
|
||||
}
|
||||
if err := ex.ProcessText(fileID, extractCorpus); err != nil {
|
||||
t.Fatalf("process: %v", err)
|
||||
}
|
||||
if err := ex.ProcessText(fileID, ""); err != nil {
|
||||
t.Fatalf("clear: %v", err)
|
||||
}
|
||||
facts, err := s.GetFacts(userID, fileID)
|
||||
if err != nil {
|
||||
t.Fatalf("get facts: %v", err)
|
||||
}
|
||||
if len(facts) != 0 {
|
||||
t.Fatalf("auto périmés non purgés: %+v", facts)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetFactsScope(t *testing.T) {
|
||||
s, ex := newExtractStore(t)
|
||||
owner := mustCreateUser(t, s.Repository, "extract-scope-o")
|
||||
other := mustCreateUser(t, s.Repository, "extract-scope-x")
|
||||
fileID := repository.NewID()
|
||||
if err := s.Repository.Resources.InsertFile(owner, fileID, "doc.pdf", "", 0, nil, nil); err != nil {
|
||||
t.Fatalf("insert: %v", err)
|
||||
}
|
||||
if err := ex.ProcessText(fileID, extractCorpus); err != nil {
|
||||
t.Fatalf("process: %v", err)
|
||||
}
|
||||
|
||||
if _, err := s.GetFacts(other, fileID); err != repository.ErrNotFound {
|
||||
t.Fatalf("étranger : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
if _, err := s.GetFacts(owner, repository.NewID()); err != repository.ErrNotFound {
|
||||
t.Fatalf("inconnu : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
if _, err := s.Trash(owner, fileID); err != nil {
|
||||
t.Fatalf("trash: %v", err)
|
||||
}
|
||||
if _, err := s.GetFacts(owner, fileID); err != repository.ErrNotFound {
|
||||
t.Fatalf("trashé : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBackfill(t *testing.T) {
|
||||
s, ex := newExtractStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "extract-backfill")
|
||||
oldID := repository.NewID()
|
||||
if err := s.Repository.Resources.InsertFile(userID, oldID, "vieux.pdf", "", 0, nil, nil); err != nil {
|
||||
t.Fatalf("insert: %v", err)
|
||||
}
|
||||
// OCR d'avant la V3 : texte présent, aucun fait auto.
|
||||
if err := s.Repository.Resources.UpdateOcrText(userID, oldID, extractCorpus); err != nil {
|
||||
t.Fatalf("ocr text: %v", err)
|
||||
}
|
||||
|
||||
n, err := ex.Backfill(200)
|
||||
if err != nil {
|
||||
t.Fatalf("backfill: %v", err)
|
||||
}
|
||||
if n != 1 {
|
||||
t.Fatalf("backfill = %d, attendu 1", n)
|
||||
}
|
||||
facts, err := s.GetFacts(userID, oldID)
|
||||
if err != nil || len(facts) == 0 {
|
||||
t.Fatalf("faits après backfill: %+v %v", facts, err)
|
||||
}
|
||||
// Deuxième passe : rien à faire (idempotent).
|
||||
n, err = ex.Backfill(200)
|
||||
if err != nil {
|
||||
t.Fatalf("backfill 2: %v", err)
|
||||
}
|
||||
if n != 0 {
|
||||
t.Fatalf("backfill 2 = %d, attendu 0", n)
|
||||
}
|
||||
}
|
||||
+25
-1
@@ -41,6 +41,11 @@ type Ocr struct {
|
||||
Lang string
|
||||
Engine ocr.Engine
|
||||
StaleAfter time.Duration
|
||||
// OnText, quand non-nil, reçoit chaque texte extrait avec succès (V3 S2 :
|
||||
// le service Extract en dérive des faits génériques). Appelé dans le
|
||||
// worker, jamais dans un handler ; une erreur est loggée, pas propagée
|
||||
// (le job OCR reste `done` — l'extract est un enrichissement, pas un gate).
|
||||
OnText func(userID, resourceID, text string)
|
||||
}
|
||||
|
||||
func NewOcr(repo *repository.Repository, uploadDir, lang string, engine ocr.Engine) *Ocr {
|
||||
@@ -166,9 +171,10 @@ func (o *Ocr) process(ctx context.Context, row repository.OcrJobRow) {
|
||||
fail(err.Error())
|
||||
return
|
||||
}
|
||||
trimmed := strings.TrimSpace(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.
|
||||
if trimmed := strings.TrimSpace(text); trimmed != "" {
|
||||
if trimmed != "" {
|
||||
if err := o.Repository.Resources.UpdateOcrText(userID, row.FileID, trimmed); err != nil {
|
||||
if errors.Is(err, repository.ErrNotFound) {
|
||||
fail("file not readable")
|
||||
@@ -178,9 +184,27 @@ func (o *Ocr) process(ctx context.Context, row repository.OcrJobRow) {
|
||||
return
|
||||
}
|
||||
}
|
||||
// V3 S2 : faits génériques (même texte vide — purge les auto périmés).
|
||||
if o.OnText != nil {
|
||||
// userID capturing : le user courant, pas un owner résolu plus tard.
|
||||
if terr := o.safeOnText(userID, row.FileID, trimmed); terr != nil {
|
||||
log.Printf("ocr: extract %s: %v", row.FileID, terr)
|
||||
}
|
||||
}
|
||||
complete(text)
|
||||
}
|
||||
|
||||
// safeOnText isole un hook OnText paniquant (règle défectueuse) du worker.
|
||||
func (o *Ocr) safeOnText(userID, resourceID, text string) (err error) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
err = fmt.Errorf("extract panic: %v", r)
|
||||
}
|
||||
}()
|
||||
o.OnText(userID, resourceID, text)
|
||||
return nil
|
||||
}
|
||||
|
||||
// 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. Durci (A12) :
|
||||
// identifiants 32-hex uniquement (anti `..`), `Lstat` + fichier régulier
|
||||
|
||||
@@ -233,10 +233,6 @@ func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) {
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *Resources) DeleteFile(ownerID, id string) (string, error) {
|
||||
return s.Repo.DeleteFile(ownerID, id)
|
||||
}
|
||||
|
||||
func (s *Resources) ListRootFolders(ownerID string) ([]FolderDTO, error) {
|
||||
rows, err := s.Repo.ListRootFoldersVisible(ownerID)
|
||||
if err != nil {
|
||||
@@ -280,11 +276,17 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID,
|
||||
return FileDTO{}, ErrInvalidUpload
|
||||
}
|
||||
targetExisting := resourceID != ""
|
||||
var cur repository.FileRow
|
||||
if targetExisting {
|
||||
if !idPattern.MatchString(resourceID) {
|
||||
return FileDTO{}, repository.ErrNotFound
|
||||
}
|
||||
if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil {
|
||||
var err error
|
||||
// GetFile ne voit que le live : un upload vers une ressource
|
||||
// trashée/absente/d'autrui → NOT_FOUND (jamais de résurrection
|
||||
// d'octets sur une ligne en corbeille).
|
||||
cur, err = s.Repo.GetFile(ownerID, resourceID)
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
} else {
|
||||
@@ -327,8 +329,27 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID,
|
||||
}
|
||||
}
|
||||
|
||||
// V3 versions : sur upload ciblé, figer l'ancienne génération AVANT
|
||||
// l'écriture (le rename atomique de copyMultipartAtomic détruirait
|
||||
// l'ancien contenu). Staging = copie, jamais move : l'échec reste safe.
|
||||
// Metadata-only (aucun octet live) → rien à versionner.
|
||||
var staged, stagedExt string
|
||||
var stagedSize int64
|
||||
var stagedMime string
|
||||
var hasStaged bool
|
||||
if targetExisting {
|
||||
var ferr error
|
||||
staged, stagedExt, stagedSize, stagedMime, hasStaged, ferr = s.freezeLive(ownerID, resourceID, cur, destDir)
|
||||
if ferr != nil {
|
||||
return FileDTO{}, ferr
|
||||
}
|
||||
}
|
||||
|
||||
written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize)
|
||||
if err != nil {
|
||||
if hasStaged {
|
||||
_ = os.Remove(staged)
|
||||
}
|
||||
return FileDTO{}, err
|
||||
}
|
||||
|
||||
@@ -358,6 +379,9 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID,
|
||||
if !stillOld {
|
||||
_ = os.Remove(destPath)
|
||||
}
|
||||
if hasStaged {
|
||||
_ = os.Remove(staged)
|
||||
}
|
||||
return FileDTO{}, err
|
||||
}
|
||||
// Succès : supprime les anciens suffixes orphelins (stale bytes, cf. #6).
|
||||
@@ -366,6 +390,15 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID,
|
||||
_ = os.Remove(m)
|
||||
}
|
||||
}
|
||||
// Overwrite ciblée : l'ancien live devient une version figée (N=3).
|
||||
// Best-effort après succès des métadonnées : un échec ici ne fait pas
|
||||
// échouer l'upload (loggé, staging nettoyé).
|
||||
if hasStaged {
|
||||
if ferr := s.finalizeVersion(ownerID, resourceID, staged, stagedExt, stagedSize, stagedMime); ferr != nil {
|
||||
log.Printf("upload: finalize version(%s): %v", resourceID, ferr)
|
||||
_ = os.Remove(staged)
|
||||
}
|
||||
}
|
||||
|
||||
row, err := s.Repo.GetFile(ownerID, resourceID)
|
||||
if err != nil {
|
||||
|
||||
@@ -291,12 +291,24 @@ func TestUploadReuploadNewExtensionRemovesStaleFile(t *testing.T) {
|
||||
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())
|
||||
// V3 versions : le re-upload fige l'ancien live (png) en version, le
|
||||
// cleanup des suffixes orphelins ne touche que le live. Attendu : le
|
||||
// live `<id>.jpg` + un dossier `.versions/` contenant le png figé.
|
||||
var live []string
|
||||
for _, e := range entries {
|
||||
if e.Name() == ".versions" {
|
||||
continue
|
||||
}
|
||||
t.Errorf("un seul physique attendu (%s.jpg), got %v", resourceID, names)
|
||||
live = append(live, e.Name())
|
||||
}
|
||||
if len(live) != 1 || live[0] != resourceID+".jpg" {
|
||||
t.Errorf("un seul live attendu (%s.jpg), got %v", resourceID, live)
|
||||
}
|
||||
verFiles, _ := filepath.Glob(filepath.Join(s.UploadDir, userID, ".versions", resourceID+"_v*"))
|
||||
if len(verFiles) != 1 {
|
||||
t.Errorf("une version figée (png) attendue, got %v", verFiles)
|
||||
} else if content, err := os.ReadFile(verFiles[0]); err != nil || string(content) != "PNGDATA" {
|
||||
t.Errorf("version figée = %q, err=%v (attendu PNGDATA)", content, err)
|
||||
}
|
||||
content, err := os.ReadFile(filepath.Join(s.UploadDir, userID, resourceID+".jpg"))
|
||||
if err != nil || string(content) != "JPGDATA!" {
|
||||
|
||||
+61
-7
@@ -25,6 +25,12 @@ const (
|
||||
OpRevokeLink = "revoke_link"
|
||||
// V2 placements : un device signale la présence de ses octets.
|
||||
OpReportBytes = "report_bytes"
|
||||
// V3 corbeille (P1) : trash = soft (restaure via restore), purge = hard.
|
||||
// delete_resource (legacy) est mappé vers trash_resource (même sémantique
|
||||
// d'idempotence, cf. applyTrashOp).
|
||||
OpTrashResource = "trash_resource"
|
||||
OpRestoreResource = "restore_resource"
|
||||
OpPurgeResource = "purge_resource"
|
||||
)
|
||||
|
||||
// SyncOperation is one outbox entry (shadow of mobile PendingOperationRow).
|
||||
@@ -200,7 +206,7 @@ func validateSyncOp(op *SyncOperation) error {
|
||||
switch op.Operation {
|
||||
case OpCreateResource, OpUpdateMetadata, OpMoveResource, OpDeleteResource,
|
||||
OpShare, OpRevokeShare, OpUpdateShare, OpCreateLink, OpRevokeLink,
|
||||
OpReportBytes:
|
||||
OpReportBytes, OpTrashResource, OpRestoreResource, OpPurgeResource:
|
||||
default:
|
||||
return errors.New("unknown operation " + op.Operation)
|
||||
}
|
||||
@@ -311,11 +317,13 @@ func (s *Resources) applySyncOp(ownerID, deviceID string, op *SyncOperation) 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.
|
||||
case OpDeleteResource, OpTrashResource:
|
||||
// V3 : delete_resource (legacy) = trash_resource. A8 : owner-only.
|
||||
// Ligne vivante d'autrui → NOT_FOUND halt (pas de applied
|
||||
// silencieux). Aucune ligne (jamais existé, déjà trashée/purgée par
|
||||
// son owner) → no-op idempotent : l'état terminal est atteint.
|
||||
// Note : une ressource déjà trashée reste trashée (re-trash = no-op
|
||||
// via TrashResource qui ne touche que deleted_at IS NULL).
|
||||
exists, err := s.Repo.ExistsOwner(ownerID, resourceID)
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -329,7 +337,53 @@ func (s *Resources) applySyncOp(ownerID, deviceID string, op *SyncOperation) err
|
||||
}
|
||||
return repository.ErrNotFound
|
||||
}
|
||||
return s.Repo.SyncDelete(ownerID, resourceID)
|
||||
return s.Repo.TrashResource(ownerID, resourceID)
|
||||
|
||||
case OpRestoreResource:
|
||||
// Owner-only (live ou trashé). Absente → no-op (rien à restaurer,
|
||||
// l'état terminal — visible — ne peut pas être atteint autrement,
|
||||
// mais halter casserait la convergence d'un restore rejoué après
|
||||
// purge... non : après purge la ligne n'existe plus, le restore est
|
||||
// sans objet → no-op documenté). Vivante d'autrui → NOT_FOUND halt.
|
||||
owned, err := s.Repo.ExistsOwnerAny(ownerID, resourceID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !owned {
|
||||
if _, err := s.Repo.GetResourceOwner(resourceID); err != nil {
|
||||
if errors.Is(err, repository.ErrNotFound) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
return repository.ErrNotFound
|
||||
}
|
||||
return s.Repo.RestoreResource(ownerID, resourceID)
|
||||
|
||||
case OpPurgeResource:
|
||||
// Owner-only (live ou trashé). Absente → no-op idempotent.
|
||||
// Vivante d'autrui → NOT_FOUND halt. Octets supprimés best-effort.
|
||||
owned, err := s.Repo.ExistsOwnerAny(ownerID, resourceID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !owned {
|
||||
if _, err := s.Repo.GetResourceOwner(resourceID); err != nil {
|
||||
if errors.Is(err, repository.ErrNotFound) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
return repository.ErrNotFound
|
||||
}
|
||||
purged, err := s.Repo.PurgeResource(ownerID, resourceID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, pid := range purged {
|
||||
s.removePhysical(ownerID, pid)
|
||||
}
|
||||
return nil
|
||||
|
||||
case OpShare, OpUpdateShare:
|
||||
return s.applyShareOp(ownerID, resourceID, op)
|
||||
|
||||
@@ -0,0 +1,420 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/kazier/backend/repository"
|
||||
)
|
||||
|
||||
// TrashRetention is the corbeille lifetime (V3 P1 : 30j, cf. V3.md §2).
|
||||
// Après ce délai, la passe de purge détruit définitivement les lignes.
|
||||
const TrashRetention = 30 * 24 * time.Hour
|
||||
|
||||
// TrashDTO serializes one trashed resource for GET /trash.
|
||||
type TrashDTO struct {
|
||||
ID string `json:"id"`
|
||||
Type string `json:"type"`
|
||||
Name string `json:"name"`
|
||||
Size int64 `json:"size"`
|
||||
TrashedAt string `json:"trashedAt"`
|
||||
UpdatedAt string `json:"updatedAt,omitempty"`
|
||||
}
|
||||
|
||||
// VersionDTO serializes one frozen byte-generation for GET /files/:id/versions.
|
||||
type VersionDTO struct {
|
||||
VersionNo int `json:"versionNo"`
|
||||
Size int64 `json:"size"`
|
||||
MimeType string `json:"mimeType,omitempty"`
|
||||
CreatedAt string `json:"createdAt"`
|
||||
}
|
||||
|
||||
// Trash soft-deletes a resource and its subtree (corbeille). Owner-only :
|
||||
// foreign or absent → repository.ErrNotFound (même code, pas d'oracle).
|
||||
// delete_resource (legacy) est mappé vers Trash (cf. applySyncOp).
|
||||
func (s *Resources) Trash(ownerID, id string) (string, error) {
|
||||
owned, err := s.Repo.ExistsOwner(ownerID, id)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if !owned {
|
||||
return "", repository.ErrNotFound
|
||||
}
|
||||
if err := s.Repo.TrashResource(ownerID, id); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// DeleteFile is the legacy owner-only file removal — now a trash (V3 P1).
|
||||
// Purge définitive : Purge. Le handler choisit via ?mode=purge.
|
||||
func (s *Resources) DeleteFile(ownerID, id string) (string, error) {
|
||||
// Restreint aux files comme avant (les dossiers passent par l'outbox).
|
||||
if _, err := s.Repo.GetFile(ownerID, id); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return s.Trash(ownerID, id)
|
||||
}
|
||||
|
||||
// Restore clears the trash flag on a resource, its subtree and its ancestor
|
||||
// chain. Owner-only : absent/foreign → ErrNotFound ; live → no-op succès.
|
||||
func (s *Resources) Restore(ownerID, id string) (string, error) {
|
||||
owned, err := s.Repo.ExistsOwnerAny(ownerID, id)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if !owned {
|
||||
return "", repository.ErrNotFound
|
||||
}
|
||||
if err := s.Repo.RestoreResource(ownerID, id); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// Purge hard-deletes a resource and its subtree (lignes + versions + octets).
|
||||
// Owner-only (trashed ou live) : absent/foreign → ErrNotFound.
|
||||
// Les fichiers physiques sont supprimés best-effort (jamais d'échec sur FS).
|
||||
func (s *Resources) Purge(ownerID, id string) (string, error) {
|
||||
owned, err := s.Repo.ExistsOwnerAny(ownerID, id)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if !owned {
|
||||
return "", repository.ErrNotFound
|
||||
}
|
||||
purged, err := s.Repo.PurgeResource(ownerID, id)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
for _, pid := range purged {
|
||||
s.removePhysical(ownerID, pid)
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// ListTrashed returns the owner's corbeille, most recently trashed first.
|
||||
func (s *Resources) ListTrashed(ownerID string, page, pageSize int) ([]TrashDTO, int, error) {
|
||||
rows, total, err := s.Repo.ListTrashed(ownerID, pageSize, (page-1)*pageSize)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
out := make([]TrashDTO, 0, len(rows))
|
||||
for _, row := range rows {
|
||||
out = append(out, TrashDTO{
|
||||
ID: row.ID,
|
||||
Type: row.Type,
|
||||
Name: row.Name,
|
||||
Size: row.Size,
|
||||
TrashedAt: row.TrashedAt.UTC().Format(time.RFC3339),
|
||||
UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
|
||||
})
|
||||
}
|
||||
return out, total, nil
|
||||
}
|
||||
|
||||
// ListVersions returns the frozen byte-generations of a live owned resource,
|
||||
// newest first. Trashed/absent/foreign → ErrNotFound.
|
||||
func (s *Resources) ListVersions(ownerID, id string) ([]VersionDTO, error) {
|
||||
rows, err := s.Repo.ListVersions(ownerID, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := make([]VersionDTO, 0, len(rows))
|
||||
for _, row := range rows {
|
||||
out = append(out, VersionDTO{
|
||||
VersionNo: row.VersionNo,
|
||||
Size: row.Size,
|
||||
MimeType: row.MimeType,
|
||||
CreatedAt: row.CreatedAt.UTC().Format(time.RFC3339),
|
||||
})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// RestoreVersion recopies la génération n vers l'emplacement live (l'actuel
|
||||
// est à son tour versionné, puis élagué à N=3). Owner-only, parent live.
|
||||
func (s *Resources) RestoreVersion(ownerID, id string, n int) (FileDTO, error) {
|
||||
ver, err := s.Repo.GetVersion(ownerID, id, n)
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
srcAbs := filepath.Join(s.UploadDir, ver.StoredPath)
|
||||
if fi, err := os.Stat(srcAbs); err != nil || !fi.Mode().IsRegular() {
|
||||
return FileDTO{}, repository.ErrNotFound
|
||||
}
|
||||
cur, err := s.Repo.GetFile(ownerID, id)
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
destDir := filepath.Join(s.UploadDir, ownerID)
|
||||
if err := os.MkdirAll(destDir, 0o700); err != nil {
|
||||
return FileDTO{}, fmt.Errorf("create upload dir: %w", err)
|
||||
}
|
||||
if err := os.Chmod(destDir, 0o700); err != nil {
|
||||
return FileDTO{}, fmt.Errorf("chmod upload dir: %w", err)
|
||||
}
|
||||
// 1. Geler l'actuel (staging copy, pas de move — l'échec reste safe).
|
||||
staged, stagedExt, stagedSize, stagedMime, hasLive, err := s.freezeLive(ownerID, id, cur, destDir)
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
if hasLive {
|
||||
defer func() {
|
||||
// Staging orphelin si on sort en erreur avant finalize.
|
||||
if err != nil {
|
||||
_ = os.Remove(staged)
|
||||
}
|
||||
}()
|
||||
}
|
||||
// 2. Recopier la version vers le live (même atomicité que l'upload).
|
||||
destName := id
|
||||
if ver.Extension != "" {
|
||||
destName = id + "." + ver.Extension
|
||||
}
|
||||
if err := copyFileAtomic(srcAbs, destDir, filepath.Join(destDir, destName)); err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
mime := ver.MimeType
|
||||
if mime == "" {
|
||||
mime = "application/octet-stream"
|
||||
}
|
||||
var extPtr *string
|
||||
if ver.Extension != "" {
|
||||
extPtr = &ver.Extension
|
||||
}
|
||||
fi, err := os.Stat(filepath.Join(destDir, destName))
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
if err := s.Repo.UpdatePhysical(ownerID, id, fi.Size(), &mime, extPtr); err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
if err := s.Repo.SetHasContent(ownerID, id, true); err != nil {
|
||||
log.Printf("versions: SetHasContent(%s): %v", id, err)
|
||||
}
|
||||
// 3. Nettoyer les suffixes orphelins + figer l'ancien actuel en version.
|
||||
s.removeStaleSuffixes(destDir, id, destName)
|
||||
if hasLive {
|
||||
if ferr := s.finalizeVersion(ownerID, id, staged, stagedExt, stagedSize, stagedMime); ferr != nil {
|
||||
log.Printf("versions: finalize displaced current(%s): %v", id, ferr)
|
||||
}
|
||||
}
|
||||
row, err := s.Repo.GetFile(ownerID, id)
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
return toFileDTO(row), nil
|
||||
}
|
||||
|
||||
// PurgeExpiredTrash détruit les lignes trashées depuis plus de retention
|
||||
// (corbeille 30j) + leurs octets (best-effort). Boucle par batch jusqu'à vide.
|
||||
// Retourne le nombre de ressources racines purgées. Appelé au boot puis par
|
||||
// ticker (cf. cmd/server/main.go).
|
||||
func (s *Resources) PurgeExpiredTrash(retention time.Duration) (int, error) {
|
||||
cutoff := time.Now().Add(-retention)
|
||||
total := 0
|
||||
for {
|
||||
purged, err := s.Repo.PurgeExpiredTrash(cutoff, 500)
|
||||
if err != nil {
|
||||
return total, err
|
||||
}
|
||||
if len(purged) == 0 {
|
||||
return total, nil
|
||||
}
|
||||
for _, p := range purged {
|
||||
s.removePhysical(p.UserID, p.ResourceID)
|
||||
total++
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// removePhysical supprime tous les octets connus d'une ressource : live
|
||||
// (UPLOAD_DIR/<user>/<resource>.* + nu) et versions (.versions/). Best-effort.
|
||||
func (s *Resources) removePhysical(userID, resourceID string) {
|
||||
if !idPattern.MatchString(userID) || !idPattern.MatchString(resourceID) {
|
||||
return
|
||||
}
|
||||
dir := filepath.Join(s.UploadDir, userID)
|
||||
matches, _ := filepath.Glob(filepath.Join(dir, resourceID+".*"))
|
||||
for _, m := range matches {
|
||||
if strings.HasPrefix(filepath.Base(m), resourceID+".") {
|
||||
_ = os.Remove(m)
|
||||
}
|
||||
}
|
||||
_ = os.Remove(filepath.Join(dir, resourceID))
|
||||
verMatches, _ := filepath.Glob(filepath.Join(dir, ".versions", resourceID+"_v*"))
|
||||
for _, m := range verMatches {
|
||||
_ = os.Remove(m)
|
||||
}
|
||||
}
|
||||
|
||||
// removeStaleSuffixes supprime les anciens suffixes orphelins après écriture
|
||||
// du live (même règle que Upload : tout `<id>.*` sauf le live).
|
||||
func (s *Resources) removeStaleSuffixes(destDir, resourceID, liveName string) {
|
||||
matches, _ := filepath.Glob(filepath.Join(destDir, resourceID+".*"))
|
||||
for _, m := range matches {
|
||||
if filepath.Base(m) != liveName && strings.HasPrefix(filepath.Base(m), resourceID+".") {
|
||||
_ = os.Remove(m)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// livePhysicalFile retourne le chemin live existant d'une ressource (suffixé
|
||||
// ou nu), "" si metadata-only.
|
||||
func livePhysicalFile(uploadDir, ownerID, resourceID string) string {
|
||||
dir := filepath.Join(uploadDir, ownerID)
|
||||
matches, _ := filepath.Glob(filepath.Join(dir, resourceID+".*"))
|
||||
for _, m := range matches {
|
||||
if strings.HasPrefix(filepath.Base(m), resourceID+".") {
|
||||
if fi, err := os.Lstat(m); err == nil && fi.Mode().IsRegular() {
|
||||
return m
|
||||
}
|
||||
}
|
||||
}
|
||||
if bare := filepath.Join(dir, resourceID); bare != "" {
|
||||
if fi, err := os.Lstat(bare); err == nil && fi.Mode().IsRegular() {
|
||||
return bare
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// freezeLive copie les octets live vers un staging temp (jamais de move :
|
||||
// l'original reste en place jusqu'au succès). Retourne le staging + métadonnées.
|
||||
// ok=false quand metadata-only (rien à versionner).
|
||||
func (s *Resources) freezeLive(ownerID, resourceID string, cur repository.FileRow, destDir string) (staging, ext string, size int64, mime string, ok bool, err error) {
|
||||
live := livePhysicalFile(s.UploadDir, ownerID, resourceID)
|
||||
if live == "" {
|
||||
return "", "", 0, "", false, nil
|
||||
}
|
||||
base := filepath.Base(live)
|
||||
ext = ""
|
||||
if strings.HasPrefix(base, resourceID+".") {
|
||||
ext = strings.TrimPrefix(base, resourceID+".")
|
||||
}
|
||||
tmp, err := os.CreateTemp(destDir, ".ver-"+resourceID+".*")
|
||||
if err != nil {
|
||||
return "", "", 0, "", false, fmt.Errorf("stage version: %w", err)
|
||||
}
|
||||
staging = tmp.Name()
|
||||
if err := copyInto(tmp, live); err != nil {
|
||||
tmp.Close()
|
||||
_ = os.Remove(staging)
|
||||
return "", "", 0, "", false, err
|
||||
}
|
||||
if err := tmp.Close(); err != nil {
|
||||
_ = os.Remove(staging)
|
||||
return "", "", 0, "", false, fmt.Errorf("stage version: %w", err)
|
||||
}
|
||||
fi, err := os.Stat(staging)
|
||||
if err != nil {
|
||||
_ = os.Remove(staging)
|
||||
return "", "", 0, "", false, err
|
||||
}
|
||||
mime = cur.MimeType
|
||||
if mime == "" {
|
||||
mime = "application/octet-stream"
|
||||
}
|
||||
return staging, ext, fi.Size(), mime, true, nil
|
||||
}
|
||||
|
||||
// finalizeVersion déplace le staging vers .versions/, insère la ligne et
|
||||
// élague au-delà de MaxVersions (fichiers élagués supprimés best-effort).
|
||||
func (s *Resources) finalizeVersion(ownerID, resourceID, staged, ext string, size int64, mime string) error {
|
||||
no, err := s.Repo.NextVersionNo(resourceID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rel := filepath.Join(ownerID, ".versions", fmt.Sprintf("%s_v%d", resourceID, no))
|
||||
if ext != "" {
|
||||
rel += "." + ext
|
||||
}
|
||||
abs := filepath.Join(s.UploadDir, rel)
|
||||
if err := os.MkdirAll(filepath.Dir(abs), 0o700); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.Rename(staged, abs); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.Chmod(abs, 0o600); err != nil {
|
||||
log.Printf("versions: chmod(%s): %v", rel, err)
|
||||
}
|
||||
var extPtr *string
|
||||
if ext != "" {
|
||||
extPtr = &ext
|
||||
}
|
||||
vid, err := repository.NewIDErr()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := s.Repo.InsertVersion(vid, resourceID, no, size, &mime, extPtr, rel); err != nil {
|
||||
_ = os.Remove(abs)
|
||||
return err
|
||||
}
|
||||
pruned, err := s.Repo.PruneVersions(resourceID, repository.MaxVersions)
|
||||
if err != nil {
|
||||
log.Printf("versions: prune(%s): %v", resourceID, err)
|
||||
return nil
|
||||
}
|
||||
for _, p := range pruned {
|
||||
_ = os.Remove(filepath.Join(s.UploadDir, p))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// copyInto copie src vers le fichier ouvert dst.
|
||||
func copyInto(dst *os.File, src string) error {
|
||||
in, err := os.Open(src)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer in.Close()
|
||||
if _, err := io.Copy(dst, in); err != nil {
|
||||
return fmt.Errorf("copy version bytes: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// copyFileAtomic recopie src vers destPath via temp+rename (0600).
|
||||
func copyFileAtomic(src, destDir, destPath string) error {
|
||||
tmp, err := os.CreateTemp(destDir, ".tmp-"+filepath.Base(destPath)+".*")
|
||||
if err != nil {
|
||||
return fmt.Errorf("create tmp file: %w", err)
|
||||
}
|
||||
tmpName := tmp.Name()
|
||||
success := false
|
||||
defer func() {
|
||||
if !success {
|
||||
_ = os.Remove(tmpName)
|
||||
}
|
||||
}()
|
||||
if err := tmp.Chmod(0o600); err != nil {
|
||||
tmp.Close()
|
||||
return fmt.Errorf("chmod tmp file: %w", err)
|
||||
}
|
||||
if err := copyInto(tmp, src); err != nil {
|
||||
tmp.Close()
|
||||
return err
|
||||
}
|
||||
if err := tmp.Sync(); err != nil {
|
||||
tmp.Close()
|
||||
return fmt.Errorf("fsync: %w", err)
|
||||
}
|
||||
if err := tmp.Close(); err != nil {
|
||||
return fmt.Errorf("close: %w", err)
|
||||
}
|
||||
if err := os.Rename(tmpName, destPath); err != nil {
|
||||
return fmt.Errorf("commit: %w", err)
|
||||
}
|
||||
if err := os.Chmod(destPath, 0o600); err != nil {
|
||||
return fmt.Errorf("chmod: %w", err)
|
||||
}
|
||||
success = true
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,364 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/kazier/backend/repository"
|
||||
)
|
||||
|
||||
func mustInsertFile(t *testing.T, s *Resources, userID, name string) string {
|
||||
t.Helper()
|
||||
id := repository.NewID()
|
||||
if err := s.Repository.Resources.InsertFile(userID, id, name, "", 0, nil, nil); err != nil {
|
||||
t.Fatalf("insert file %q: %v", name, err)
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
func TestTrashRestoreRoundtrip(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "trash-roundtrip")
|
||||
fileID := mustInsertFile(t, s, userID, "acte.pdf")
|
||||
|
||||
if _, err := s.Trash(userID, fileID); err != nil {
|
||||
t.Fatalf("trash: %v", err)
|
||||
}
|
||||
if _, err := s.Repo.GetFile(userID, fileID); !errors.Is(err, repository.ErrNotFound) {
|
||||
t.Fatalf("GetFile après trash : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
items, total, err := s.ListTrashed(userID, 1, 50)
|
||||
if err != nil {
|
||||
t.Fatalf("list trashed: %v", err)
|
||||
}
|
||||
if total != 1 || len(items) != 1 || items[0].ID != fileID {
|
||||
t.Fatalf("corbeille: total=%d items=%+v", total, items)
|
||||
}
|
||||
|
||||
if _, err := s.Restore(userID, fileID); err != nil {
|
||||
t.Fatalf("restore: %v", err)
|
||||
}
|
||||
if _, err := s.Repo.GetFile(userID, fileID); err != nil {
|
||||
t.Fatalf("GetFile après restore: %v", err)
|
||||
}
|
||||
if _, total, err := s.ListTrashed(userID, 1, 50); err != nil || total != 0 {
|
||||
t.Fatalf("corbeille après restore: total=%d err=%v", total, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTrashSubtree(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "trash-subtree")
|
||||
folderID := repository.NewID()
|
||||
if err := s.Repository.Resources.InsertFolder(userID, folderID, "Dossier", ""); err != nil {
|
||||
t.Fatalf("insert folder: %v", err)
|
||||
}
|
||||
childID := repository.NewID()
|
||||
if err := s.Repository.Resources.InsertFile(userID, childID, "enfant.txt", folderID, 0, nil, nil); err != nil {
|
||||
t.Fatalf("insert child: %v", err)
|
||||
}
|
||||
|
||||
if _, err := s.Trash(userID, folderID); err != nil {
|
||||
t.Fatalf("trash folder: %v", err)
|
||||
}
|
||||
if _, err := s.Repo.GetFile(userID, childID); !errors.Is(err, repository.ErrNotFound) {
|
||||
t.Fatalf("enfant après trash dossier : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
if _, total, _ := s.ListTrashed(userID, 1, 50); total != 2 {
|
||||
t.Fatalf("corbeille subtree: total=%d, attendu 2", total)
|
||||
}
|
||||
|
||||
if _, err := s.Restore(userID, folderID); err != nil {
|
||||
t.Fatalf("restore folder: %v", err)
|
||||
}
|
||||
if _, err := s.Repo.GetFile(userID, childID); err != nil {
|
||||
t.Fatalf("enfant après restore dossier: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTrashForeignIsNotFound(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
owner := mustCreateUser(t, s.Repository, "trash-owner")
|
||||
other := mustCreateUser(t, s.Repository, "trash-other")
|
||||
fileID := mustInsertFile(t, s, owner, "secret.pdf")
|
||||
|
||||
if _, err := s.Trash(other, fileID); !errors.Is(err, repository.ErrNotFound) {
|
||||
t.Fatalf("trash autrui : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
if _, err := s.Restore(other, fileID); !errors.Is(err, repository.ErrNotFound) {
|
||||
t.Fatalf("restore autrui : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
if _, err := s.Purge(other, fileID); !errors.Is(err, repository.ErrNotFound) {
|
||||
t.Fatalf("purge autrui : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
if _, err := s.Repo.GetFile(owner, fileID); err != nil {
|
||||
t.Fatalf("fichier owner intact: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeleteLegacyMapsToTrash(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "trash-legacy")
|
||||
device := mustRegisterDevice(t, s.Repository, "b0000000000000000000000000000001")
|
||||
fileID := mustInsertFile(t, s, userID, "legacy.pdf")
|
||||
|
||||
// delete_resource → trash (restaurable, visible en corbeille).
|
||||
res, err := s.ApplyBatch(userID, device, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("apply: %v", err)
|
||||
}
|
||||
if res.Applied != 1 || res.Failed != nil {
|
||||
t.Fatalf("résultat inattendu: %+v", res)
|
||||
}
|
||||
if _, err := s.Repo.GetFile(userID, fileID); !errors.Is(err, repository.ErrNotFound) {
|
||||
t.Fatalf("GetFile après delete legacy : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
if _, total, _ := s.ListTrashed(userID, 1, 50); total != 1 {
|
||||
t.Fatalf("delete legacy doit apparaître en corbeille")
|
||||
}
|
||||
|
||||
// Re-delete (déjà trashé) → no-op idempotent, pas NOT_FOUND.
|
||||
res, err = s.ApplyBatch(userID, device, []SyncOperation{
|
||||
syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("re-apply: %v", err)
|
||||
}
|
||||
if res.Applied != 1 || res.Failed != nil {
|
||||
t.Fatalf("re-delete trashé doit être no-op: %+v", res)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSyncOpsTrashRestorePurge(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "trash-ops")
|
||||
other := mustCreateUser(t, s.Repository, "trash-ops-other")
|
||||
device := mustRegisterDevice(t, s.Repository, "b0000000000000000000000000000002")
|
||||
fileID := mustInsertFile(t, s, userID, "ops.pdf")
|
||||
foreignID := mustInsertFile(t, s, other, "foreign.pdf")
|
||||
|
||||
apply := func(op, resID string) SyncResult {
|
||||
t.Helper()
|
||||
res, err := s.ApplyBatch(userID, device, []SyncOperation{
|
||||
syncOp(repository.NewID(), resID, op, "file", map[string]any{}),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("apply %s: %v", op, err)
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
if res := apply(OpTrashResource, fileID); res.Applied != 1 || res.Failed != nil {
|
||||
t.Fatalf("trash op: %+v", res)
|
||||
}
|
||||
// Trash d'autrui → halt NOT_FOUND.
|
||||
if res := apply(OpTrashResource, foreignID); res.Failed == nil || res.Failed.Code != "NOT_FOUND" {
|
||||
t.Fatalf("trash autrui doit halter NOT_FOUND: %+v", res)
|
||||
}
|
||||
if res := apply(OpRestoreResource, fileID); res.Applied != 1 || res.Failed != nil {
|
||||
t.Fatalf("restore op: %+v", res)
|
||||
}
|
||||
if _, err := s.Repo.GetFile(userID, fileID); err != nil {
|
||||
t.Fatalf("fichier restauré via op: %v", err)
|
||||
}
|
||||
// Restore d'un live → no-op succès.
|
||||
if res := apply(OpRestoreResource, fileID); res.Applied != 1 || res.Failed != nil {
|
||||
t.Fatalf("restore live doit être no-op: %+v", res)
|
||||
}
|
||||
// Restore d'inexistant → no-op (convergence).
|
||||
if res := apply(OpRestoreResource, repository.NewID()); res.Applied != 1 || res.Failed != nil {
|
||||
t.Fatalf("restore inexistant doit être no-op: %+v", res)
|
||||
}
|
||||
// Purge d'un live → détruit.
|
||||
if res := apply(OpPurgeResource, fileID); res.Applied != 1 || res.Failed != nil {
|
||||
t.Fatalf("purge op: %+v", res)
|
||||
}
|
||||
if owned, _ := s.Repo.ExistsOwnerAny(userID, fileID); owned {
|
||||
t.Fatal("purge doit détruire la ligne")
|
||||
}
|
||||
// Purge d'inexistant → no-op.
|
||||
if res := apply(OpPurgeResource, fileID); res.Applied != 1 || res.Failed != nil {
|
||||
t.Fatalf("purge inexistant doit être no-op: %+v", res)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPurgeRemovesPhysicalFiles(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "trash-physical")
|
||||
|
||||
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("hello")), "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload: %v", err)
|
||||
}
|
||||
live := filepath.Join(s.UploadDir, userID, dto.ID+".txt")
|
||||
if _, err := os.Stat(live); err != nil {
|
||||
t.Fatalf("live absent: %v", err)
|
||||
}
|
||||
if _, err := s.Purge(userID, dto.ID); err != nil {
|
||||
t.Fatalf("purge: %v", err)
|
||||
}
|
||||
if _, err := os.Stat(live); !os.IsNotExist(err) {
|
||||
t.Fatalf("octets live doivent être supprimés: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUploadOverwriteCreatesVersionsCappedAt3(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "trash-versions")
|
||||
|
||||
v1, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload v1: %v", err)
|
||||
}
|
||||
// Le premier upload (création) ne crée pas de version.
|
||||
if vers, err := s.ListVersions(userID, v1.ID); err != nil || len(vers) != 0 {
|
||||
t.Fatalf("création ne doit pas versionner: %+v %v", vers, err)
|
||||
}
|
||||
|
||||
contents := []string{"BBBB", "CCCCC", "DDDDDD", "EEEEEEE"}
|
||||
for i, c := range contents {
|
||||
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte(c)), "", v1.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("overwrite %d: %v", i, err)
|
||||
}
|
||||
if dto.Size != int64(len(c)) {
|
||||
t.Fatalf("overwrite %d: taille=%d", i, dto.Size)
|
||||
}
|
||||
}
|
||||
vers, err := s.ListVersions(userID, v1.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("list versions: %v", err)
|
||||
}
|
||||
if len(vers) != 3 {
|
||||
t.Fatalf("versions = %d, attendu 3 (plafond N=3)", len(vers))
|
||||
}
|
||||
// Les 3 conservées sont les plus récentes : AAA a été élaguée.
|
||||
// Ordre décroissant : version_no 4,3,2 → tailles 6,5,4.
|
||||
wantSizes := []int64{6, 5, 4}
|
||||
for i, v := range vers {
|
||||
if v.Size != wantSizes[i] {
|
||||
t.Errorf("version[%d].size = %d, attendu %d", i, v.Size, wantSizes[i])
|
||||
}
|
||||
}
|
||||
// 3 fichiers figés sur disque (AAA élaguée avec sa ligne).
|
||||
verFiles, _ := filepath.Glob(filepath.Join(s.UploadDir, userID, ".versions", v1.ID+"_v*"))
|
||||
if len(verFiles) != 3 {
|
||||
t.Errorf("fichiers versionnés = %d, attendu 3 (%v)", len(verFiles), verFiles)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRestoreVersion(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "trash-restore-ver")
|
||||
|
||||
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload v1: %v", err)
|
||||
}
|
||||
if _, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("BBBB")), "", dto.ID); err != nil {
|
||||
t.Fatalf("overwrite: %v", err)
|
||||
}
|
||||
vers, err := s.ListVersions(userID, dto.ID)
|
||||
if err != nil || len(vers) != 1 {
|
||||
t.Fatalf("versions: %+v %v", vers, err)
|
||||
}
|
||||
|
||||
restored, err := s.RestoreVersion(userID, dto.ID, vers[0].VersionNo)
|
||||
if err != nil {
|
||||
t.Fatalf("restore version: %v", err)
|
||||
}
|
||||
if restored.Size != 3 {
|
||||
t.Fatalf("live restauré taille=%d, attendu 3", restored.Size)
|
||||
}
|
||||
raw, err := os.ReadFile(filepath.Join(s.UploadDir, userID, dto.ID+".txt"))
|
||||
if err != nil {
|
||||
t.Fatalf("read live: %v", err)
|
||||
}
|
||||
if string(raw) != "AAA" {
|
||||
t.Fatalf("contenu live = %q, attendu AAA", raw)
|
||||
}
|
||||
// L'ancien actuel (BBBB) a été à son tour versionné.
|
||||
vers2, err := s.ListVersions(userID, dto.ID)
|
||||
if err != nil || len(vers2) != 2 {
|
||||
t.Fatalf("versions après restore: %+v %v", vers2, err)
|
||||
}
|
||||
if _, err := s.RestoreVersion(userID, dto.ID, 999); !errors.Is(err, repository.ErrNotFound) {
|
||||
t.Fatalf("restore version inconnue : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUploadToTrashedIsNotFound(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "trash-upload-guard")
|
||||
|
||||
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload: %v", err)
|
||||
}
|
||||
if _, err := s.Trash(userID, dto.ID); err != nil {
|
||||
t.Fatalf("trash: %v", err)
|
||||
}
|
||||
if _, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("BBB")), "", dto.ID); !errors.Is(err, repository.ErrNotFound) {
|
||||
t.Fatalf("upload vers trashé : attendu NOT_FOUND, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func backdateTrash(t *testing.T, s *Resources, resourceID string, ago time.Duration) {
|
||||
t.Helper()
|
||||
if _, err := s.Repository.Resources.DB.Exec(
|
||||
`UPDATE resources SET deleted_at = NOW() - ($1 || ' seconds')::interval WHERE resource_id = $2`,
|
||||
int(ago.Seconds()), resourceID,
|
||||
); err != nil {
|
||||
t.Fatalf("backdate: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPurgeExpiredTrash(t *testing.T) {
|
||||
s := newServiceStore(t)
|
||||
userID := mustCreateUser(t, s.Repository, "trash-expire")
|
||||
|
||||
old, err := s.Upload(userID, multipartFileHeader(t, "vieux.txt", []byte("old")), "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload vieux: %v", err)
|
||||
}
|
||||
fresh, err := s.Upload(userID, multipartFileHeader(t, "frais.txt", []byte("new")), "", "")
|
||||
if err != nil {
|
||||
t.Fatalf("upload frais: %v", err)
|
||||
}
|
||||
if _, err := s.Trash(userID, old.ID); err != nil {
|
||||
t.Fatalf("trash vieux: %v", err)
|
||||
}
|
||||
if _, err := s.Trash(userID, fresh.ID); err != nil {
|
||||
t.Fatalf("trash frais: %v", err)
|
||||
}
|
||||
backdateTrash(t, s, old.ID, 31*24*time.Hour)
|
||||
|
||||
n, err := s.PurgeExpiredTrash(TrashRetention)
|
||||
if err != nil {
|
||||
t.Fatalf("purge expired: %v", err)
|
||||
}
|
||||
if n != 1 {
|
||||
t.Fatalf("purgés = %d, attendu 1", n)
|
||||
}
|
||||
if owned, _ := s.Repo.ExistsOwnerAny(userID, old.ID); owned {
|
||||
t.Fatal("vieux doit être détruit")
|
||||
}
|
||||
if _, _, err := s.ListTrashed(userID, 1, 50); err != nil {
|
||||
t.Fatalf("list: %v", err)
|
||||
}
|
||||
if _, err := s.Repo.GetFile(userID, fresh.ID); err == nil {
|
||||
// Frais trashé mais pas expiré : invisible en lecture, présent en corbeille.
|
||||
t.Fatal("frais doit rester trashé (invisible en lecture)")
|
||||
}
|
||||
if _, total, _ := s.ListTrashed(userID, 1, 50); total != 1 {
|
||||
t.Fatalf("corbeille doit garder le frais: total=%d", total)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, old.ID+".txt")); !os.IsNotExist(err) {
|
||||
t.Fatal("octets du purgé doivent être supprimés")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user