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).
132 lines
4.0 KiB
Go
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
|
|
}
|