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,153 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
)
|
||||
|
||||
// FactParam is one generic fact to persist (V3 S2, migration 000019).
|
||||
// ValueNum/ValueDate nil when the type carries no numeric/date value.
|
||||
type FactParam struct {
|
||||
Type string
|
||||
ValueText string
|
||||
ValueNum *float64
|
||||
ValueDate *string // ISO YYYY-MM-DD
|
||||
Confidence float64
|
||||
}
|
||||
|
||||
// FactRow is one persisted fact (auto-extracted or user-corrected).
|
||||
type FactRow struct {
|
||||
ID string
|
||||
Type string
|
||||
ValueText string
|
||||
ValueNum *float64
|
||||
ValueDate *string
|
||||
Confidence float64
|
||||
Origin string
|
||||
}
|
||||
|
||||
// UpsertAutoFacts replaces the origin='auto' facts of a resource with a fresh
|
||||
// extraction. Rows with origin='user' (S3 corrections) are never touched.
|
||||
// An empty params clears stale auto facts (e.g. OCR re-run yielding nothing).
|
||||
func (r *Resources) UpsertAutoFacts(resourceID string, params []FactParam) error {
|
||||
tx, err := r.DB.Begin()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback() //nolint:errcheck — no-op after Commit.
|
||||
if _, err := tx.Exec(
|
||||
`DELETE FROM resource_facts WHERE resource_id = $1 AND origin = 'auto'`,
|
||||
resourceID,
|
||||
); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, p := range params {
|
||||
id, err := NewIDErr()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := tx.Exec(
|
||||
`INSERT INTO resource_facts
|
||||
(id, resource_id, fact_type, value_text, value_num, value_date, confidence, origin)
|
||||
VALUES ($1, $2, $3, NULLIF($4, ''), $5, NULLIF($6, '')::date, $7, 'auto')`,
|
||||
id, resourceID, p.Type, p.ValueText, nullableFloat(p.ValueNum), derefStr(p.ValueDate), clamp01(p.Confidence),
|
||||
); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return tx.Commit()
|
||||
}
|
||||
|
||||
// ListFacts returns the facts of a resource, user-corrected first then auto
|
||||
// (stable order by type). No visibility check — the caller enforces viewer+
|
||||
// (GetFileVisible) like GetFileOcr.
|
||||
func (r *Resources) ListFacts(resourceID string) ([]FactRow, error) {
|
||||
rows, err := r.DB.Query(
|
||||
`SELECT id, fact_type, COALESCE(value_text, ''), value_num,
|
||||
COALESCE(value_date::text, ''), confidence, origin
|
||||
FROM resource_facts WHERE resource_id = $1
|
||||
ORDER BY CASE origin WHEN 'user' THEN 0 ELSE 1 END, fact_type, value_text`,
|
||||
resourceID,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
out := make([]FactRow, 0)
|
||||
for rows.Next() {
|
||||
var row FactRow
|
||||
var num sql.NullFloat64
|
||||
var dat string
|
||||
if err := rows.Scan(&row.ID, &row.Type, &row.ValueText, &num, &dat, &row.Confidence, &row.Origin); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if num.Valid {
|
||||
v := num.Float64
|
||||
row.ValueNum = &v
|
||||
}
|
||||
if dat != "" {
|
||||
d := dat
|
||||
row.ValueDate = &d
|
||||
}
|
||||
out = append(out, row)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// factNeedingExtract is a file with OCR text but no auto facts yet.
|
||||
type factNeedingExtract struct {
|
||||
ResourceID string
|
||||
Text string
|
||||
}
|
||||
|
||||
// ListNeedingExtract returns up to limit files with non-empty ocr_text and no
|
||||
// origin='auto' facts (boot backfill, S2). Live rows only.
|
||||
func (r *Resources) ListNeedingExtract(limit int) ([]factNeedingExtract, error) {
|
||||
rows, err := r.DB.Query(
|
||||
`SELECT resource_id, ocr_text FROM resources
|
||||
WHERE type = 'file' AND deleted_at IS NULL
|
||||
AND ocr_text IS NOT NULL AND ocr_text <> ''
|
||||
AND NOT EXISTS (
|
||||
SELECT 1 FROM resource_facts
|
||||
WHERE resource_facts.resource_id = resources.resource_id
|
||||
AND origin = 'auto')
|
||||
ORDER BY updated_at ASC LIMIT $1`,
|
||||
limit,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var out []factNeedingExtract
|
||||
for rows.Next() {
|
||||
var row factNeedingExtract
|
||||
if err := rows.Scan(&row.ResourceID, &row.Text); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, row)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
func nullableFloat(v *float64) any {
|
||||
if v == nil {
|
||||
return nil
|
||||
}
|
||||
return *v
|
||||
}
|
||||
|
||||
func derefStr(v *string) string {
|
||||
if v == nil {
|
||||
return ""
|
||||
}
|
||||
return *v
|
||||
}
|
||||
|
||||
func clamp01(v float64) float64 {
|
||||
if v < 0 {
|
||||
return 0
|
||||
}
|
||||
if v > 1 {
|
||||
return 1
|
||||
}
|
||||
return v
|
||||
}
|
||||
@@ -569,13 +569,12 @@ func (r *Resources) UpdateOcrText(ownerID, resourceID, text string) error {
|
||||
|
||||
// SyncDelete soft-deletes a resource; absence is NOT an error (idempotent
|
||||
// terminal state for the outbox).
|
||||
//
|
||||
// Deprecated: V3 trash — préférer TrashResource (récursif sur le subtree).
|
||||
// Conservé comme alias pour compatibilité (même effet sur une ressource
|
||||
// sans enfant : TrashResource ne touche que deleted_at IS NULL).
|
||||
func (r *Resources) SyncDelete(ownerID, resourceID string) error {
|
||||
_, err := r.DB.Exec(
|
||||
`UPDATE resources SET deleted_at = NOW(), updated_at = NOW()
|
||||
WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`,
|
||||
resourceID, ownerID,
|
||||
)
|
||||
return err
|
||||
return r.TrashResource(ownerID, resourceID)
|
||||
}
|
||||
|
||||
// ExistsOwner reports whether a non-deleted resource belongs to the device.
|
||||
|
||||
@@ -0,0 +1,191 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"time"
|
||||
)
|
||||
|
||||
// TrashedRow is a trashed resource for GET /trash.
|
||||
type TrashedRow struct {
|
||||
ID string
|
||||
Type string
|
||||
Name string
|
||||
Size int64
|
||||
TrashedAt time.Time
|
||||
UpdatedAt time.Time
|
||||
}
|
||||
|
||||
// subtreeCTE selects a resource and all its descendants (any depth).
|
||||
const subtreeCTE = `
|
||||
subtree(id) AS (
|
||||
SELECT $2::text
|
||||
UNION ALL
|
||||
SELECT r.resource_id FROM resources r JOIN subtree s ON r.parent_id = s.id
|
||||
)`
|
||||
|
||||
// ancestorsCTE selects a resource and all its ancestors up to the root.
|
||||
const ancestorsCTE = `
|
||||
ancestors(id) AS (
|
||||
SELECT $2::text
|
||||
UNION ALL
|
||||
SELECT r.parent_id FROM resources r JOIN ancestors a ON r.resource_id = a.id
|
||||
WHERE r.parent_id IS NOT NULL
|
||||
)`
|
||||
|
||||
// TrashResource soft-deletes a resource and its whole subtree
|
||||
// (`deleted_at = NOW()`), owner-scoped. Already-trashed rows are untouched.
|
||||
// The target must be verified owned beforehand (ExistsOwner / GetResourceOwner)
|
||||
// for the NOT_FOUND halt semantics — this method only applies.
|
||||
func (r *Resources) TrashResource(ownerID, resourceID string) error {
|
||||
_, err := r.DB.Exec(
|
||||
`WITH RECURSIVE `+subtreeCTE+`
|
||||
UPDATE resources SET deleted_at = NOW(), updated_at = NOW()
|
||||
WHERE resource_id IN (SELECT id FROM subtree)
|
||||
AND user_id = $1 AND deleted_at IS NULL`,
|
||||
ownerID, resourceID,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
// RestoreResource clears the trash flag on a resource, its subtree AND its
|
||||
// ancestor chain (a file whose folder is still trashed would stay
|
||||
// unreachable otherwise). Independently-trashed descendants are restored too
|
||||
// — documented V3 behaviour (restoring the folder restores what it contains).
|
||||
func (r *Resources) RestoreResource(ownerID, resourceID string) error {
|
||||
_, err := r.DB.Exec(
|
||||
`WITH RECURSIVE `+subtreeCTE+`, `+ancestorsCTE+`
|
||||
UPDATE resources SET deleted_at = NULL, updated_at = NOW()
|
||||
WHERE (resource_id IN (SELECT id FROM subtree)
|
||||
OR resource_id IN (SELECT id FROM ancestors))
|
||||
AND user_id = $1 AND deleted_at IS NOT NULL`,
|
||||
ownerID, resourceID,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
// ExistsOwnerAny reports ownership regardless of trash state (for purge :
|
||||
// a trashed resource is still owned).
|
||||
func (r *Resources) ExistsOwnerAny(ownerID, resourceID string) (bool, error) {
|
||||
var exists int
|
||||
err := r.DB.QueryRow(
|
||||
`SELECT 1 FROM resources WHERE resource_id = $1 AND user_id = $2`,
|
||||
resourceID, ownerID,
|
||||
).Scan(&exists)
|
||||
if err == sql.ErrNoRows {
|
||||
return false, nil
|
||||
}
|
||||
return err == nil, err
|
||||
}
|
||||
|
||||
// PurgeResource hard-deletes a resource and its subtree (FK CASCADE on
|
||||
// parent_id + resource_versions), returning every purged resource_id so the
|
||||
// caller can remove physical files best-effort. Owner-scoped.
|
||||
func (r *Resources) PurgeResource(ownerID, resourceID string) ([]string, error) {
|
||||
rows, err := r.DB.Query(
|
||||
`WITH RECURSIVE subtree(id) AS (
|
||||
SELECT $1::text
|
||||
UNION ALL
|
||||
SELECT r.resource_id FROM resources r JOIN subtree s ON r.parent_id = s.id
|
||||
)
|
||||
SELECT id FROM subtree`,
|
||||
resourceID,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var ids []string
|
||||
for rows.Next() {
|
||||
var id string
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
rows.Close()
|
||||
return nil, err
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
rows.Close()
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := r.DB.Exec(
|
||||
`DELETE FROM resources WHERE resource_id = $1 AND user_id = $2`,
|
||||
resourceID, ownerID,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return ids, nil
|
||||
}
|
||||
|
||||
// ListTrashed returns the owner's trashed resources, most recently trashed
|
||||
// first, paginated.
|
||||
func (r *Resources) ListTrashed(ownerID string, limit, offset int) ([]TrashedRow, int, error) {
|
||||
var total int
|
||||
if err := r.DB.QueryRow(
|
||||
`SELECT COUNT(*) FROM resources WHERE user_id = $1 AND deleted_at IS NOT NULL`,
|
||||
ownerID,
|
||||
).Scan(&total); err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
rows, err := r.DB.Query(
|
||||
`SELECT resource_id, type, name, COALESCE(size_bytes, 0), deleted_at, updated_at
|
||||
FROM resources WHERE user_id = $1 AND deleted_at IS NOT NULL
|
||||
ORDER BY deleted_at DESC LIMIT $2 OFFSET $3`,
|
||||
ownerID, limit, offset,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
defer rows.Close()
|
||||
out := make([]TrashedRow, 0)
|
||||
for rows.Next() {
|
||||
var row TrashedRow
|
||||
if err := rows.Scan(&row.ID, &row.Type, &row.Name, &row.Size, &row.TrashedAt, &row.UpdatedAt); err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
out = append(out, row)
|
||||
}
|
||||
return out, total, rows.Err()
|
||||
}
|
||||
|
||||
// PurgedResource identifies a row destroyed by the retention pass.
|
||||
type PurgedResource struct {
|
||||
UserID string
|
||||
ResourceID string
|
||||
}
|
||||
|
||||
// PurgeExpiredTrash hard-deletes every resource trashed before cutoff
|
||||
// (corbeille 30j), oldest first, bounded by limit. Returns the destroyed
|
||||
// identities for physical-file cleanup (best-effort, caller-side).
|
||||
func (r *Resources) PurgeExpiredTrash(cutoff time.Time, limit int) ([]PurgedResource, error) {
|
||||
rows, err := r.DB.Query(
|
||||
`SELECT user_id, resource_id FROM resources
|
||||
WHERE deleted_at IS NOT NULL AND deleted_at < $1
|
||||
ORDER BY deleted_at ASC LIMIT $2`,
|
||||
cutoff, limit,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var out []PurgedResource
|
||||
for rows.Next() {
|
||||
var p PurgedResource
|
||||
if err := rows.Scan(&p.UserID, &p.ResourceID); err != nil {
|
||||
rows.Close()
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, p)
|
||||
}
|
||||
rows.Close()
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, p := range out {
|
||||
// Hard delete cascades to children (parent_id FK) and versions.
|
||||
if _, err := r.DB.Exec(
|
||||
`DELETE FROM resources WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NOT NULL AND deleted_at < $3`,
|
||||
p.ResourceID, p.UserID, cutoff,
|
||||
); err != nil {
|
||||
return out, err
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
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
|
||||
}
|
||||
Reference in New Issue
Block a user