Files
venture 95b4cf79cf 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).
2026-09-26 10:14:07 +02:00

132 lines
4.0 KiB
Go

package repository
import (
"database/sql"
"time"
"github.com/lib/pq"
)
// VersionRow is one frozen byte-generation of a resource.
type VersionRow struct {
ID string
VersionNo int
Size int64
MimeType string
Extension string
StoredPath string
CreatedAt time.Time
}
// MaxVersions caps the per-resource history (V3 P1 : N=3).
const MaxVersions = 3
// NextVersionNo returns 1 + the highest version number (monotonic, never
// reused even after pruning).
func (r *Resources) NextVersionNo(resourceID string) (int, error) {
var next int
err := r.DB.QueryRow(
`SELECT COALESCE(MAX(version_no), 0) + 1 FROM resource_versions WHERE resource_id = $1`,
resourceID,
).Scan(&next)
return next, err
}
// InsertVersion freezes one byte-generation. ID must be NewID() 32-hex.
func (r *Resources) InsertVersion(id, resourceID string, versionNo int, size int64, mimeType, extension *string, storedPath string) error {
_, err := r.DB.Exec(
`INSERT INTO resource_versions (id, resource_id, version_no, size_bytes, mime_type, extension, stored_path)
VALUES ($1, $2, $3, $4, $5, $6, $7)`,
id, resourceID, versionNo, size, mimeType, extension, storedPath,
)
return err
}
// ListVersions returns the history of a resource owned by ownerID
// (ownership checked via the parent row), newest first.
func (r *Resources) ListVersions(ownerID, resourceID string) ([]VersionRow, error) {
if _, err := r.GetFile(ownerID, resourceID); err != nil {
// Folders can be versioned too (metadata only has no bytes — in
// practice only files carry versions, but don't 404 on type).
if _, ferr := r.GetFolder(ownerID, resourceID); ferr != nil {
return nil, err
}
}
rows, err := r.DB.Query(
`SELECT v.id, v.version_no, v.size_bytes, COALESCE(v.mime_type, ''),
COALESCE(v.extension, ''), v.stored_path, v.created_at
FROM resource_versions v
JOIN resources r ON r.resource_id = v.resource_id
WHERE v.resource_id = $1 AND r.user_id = $2 AND r.deleted_at IS NULL
ORDER BY v.version_no DESC`,
resourceID, ownerID,
)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]VersionRow, 0)
for rows.Next() {
var row VersionRow
if err := rows.Scan(&row.ID, &row.VersionNo, &row.Size, &row.MimeType, &row.Extension, &row.StoredPath, &row.CreatedAt); err != nil {
return nil, err
}
out = append(out, row)
}
return out, rows.Err()
}
// GetVersion returns one frozen generation (owner-scoped via parent row).
func (r *Resources) GetVersion(ownerID, resourceID string, versionNo int) (VersionRow, error) {
var row VersionRow
err := r.DB.QueryRow(
`SELECT v.id, v.version_no, v.size_bytes, COALESCE(v.mime_type, ''),
COALESCE(v.extension, ''), v.stored_path, v.created_at
FROM resource_versions v
JOIN resources r ON r.resource_id = v.resource_id
WHERE v.resource_id = $1 AND v.version_no = $2 AND r.user_id = $3 AND r.deleted_at IS NULL`,
resourceID, versionNo, ownerID,
).Scan(&row.ID, &row.VersionNo, &row.Size, &row.MimeType, &row.Extension, &row.StoredPath, &row.CreatedAt)
if err == sql.ErrNoRows {
return VersionRow{}, ErrNotFound
}
return row, err
}
// PruneVersions deletes generations beyond the newest keepN, returning their
// stored paths for physical cleanup (best-effort, caller-side).
func (r *Resources) PruneVersions(resourceID string, keepN int) ([]string, error) {
rows, err := r.DB.Query(
`SELECT stored_path FROM resource_versions
WHERE resource_id = $1
ORDER BY version_no DESC OFFSET $2`,
resourceID, keepN,
)
if err != nil {
return nil, err
}
var paths []string
for rows.Next() {
var p string
if err := rows.Scan(&p); err != nil {
rows.Close()
return nil, err
}
paths = append(paths, p)
}
rows.Close()
if err := rows.Err(); err != nil {
return nil, err
}
if len(paths) == 0 {
return nil, nil
}
if _, err := r.DB.Exec(
`DELETE FROM resource_versions WHERE resource_id = $1 AND stored_path = ANY($2)`,
resourceID, pq.Array(paths),
); err != nil {
return nil, err
}
return paths, nil
}