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 }