446 lines
13 KiB
Go
446 lines
13 KiB
Go
package docs
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
)
|
|
|
|
type Repository struct {
|
|
db *sql.DB
|
|
}
|
|
|
|
type DocumentRecord struct {
|
|
ID string `json:"id"`
|
|
Path string `json:"path"`
|
|
CurrentHash string `json:"currentHash"`
|
|
Title string `json:"title"`
|
|
Tags []string `json:"tags"`
|
|
CreatedAt time.Time `json:"createdAt"`
|
|
UpdatedAt time.Time `json:"updatedAt"`
|
|
ArchivedAt *time.Time `json:"archivedAt,omitempty"`
|
|
}
|
|
|
|
type UserRecord struct {
|
|
ID string `json:"id"`
|
|
Email string `json:"email"`
|
|
DisplayName string `json:"displayName"`
|
|
Role string `json:"role"`
|
|
CreatedAt time.Time `json:"createdAt"`
|
|
LastSeenAt time.Time `json:"lastSeenAt,omitempty"`
|
|
}
|
|
|
|
type AttachmentRecord struct {
|
|
Hash string
|
|
OriginalName string
|
|
ContentType string
|
|
SizeBytes int64
|
|
CreatedAt time.Time
|
|
DocumentPath string
|
|
}
|
|
|
|
type PersistDocumentInput struct {
|
|
ID string
|
|
Path string
|
|
Title string
|
|
Hash string
|
|
PreviousHash string
|
|
Tags []string
|
|
}
|
|
|
|
func NewRepository(db *sql.DB) *Repository {
|
|
return &Repository{db: db}
|
|
}
|
|
|
|
func (r *Repository) PersistDocument(ctx context.Context, input PersistDocumentInput) error {
|
|
now := time.Now().UTC()
|
|
tagsJSON, err := json.Marshal(input.Tags)
|
|
if err != nil {
|
|
return fmt.Errorf("marshal tags: %w", err)
|
|
}
|
|
|
|
existing, err := r.GetDocumentByPath(ctx, input.Path)
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return err
|
|
}
|
|
|
|
documentID := input.ID
|
|
createdAt := now
|
|
if existing != nil {
|
|
documentID = existing.ID
|
|
createdAt = existing.CreatedAt
|
|
}
|
|
|
|
if _, err := r.db.ExecContext(ctx, `
|
|
INSERT INTO documents (id, path, current_hash, title, tags, created_at, updated_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(path) DO UPDATE SET
|
|
current_hash = excluded.current_hash,
|
|
title = excluded.title,
|
|
tags = excluded.tags,
|
|
updated_at = excluded.updated_at
|
|
`, documentID, input.Path, input.Hash, input.Title, string(tagsJSON), createdAt.Format(time.RFC3339), now.Format(time.RFC3339)); err != nil {
|
|
return fmt.Errorf("upsert document %s: %w", input.Path, err)
|
|
}
|
|
|
|
if existing != nil && existing.CurrentHash == input.Hash {
|
|
return nil
|
|
}
|
|
|
|
versionID := documentID + ":" + input.Hash[:12]
|
|
if _, err := r.db.ExecContext(ctx, `
|
|
INSERT OR IGNORE INTO document_versions (id, document_id, hash, previous_hash, created_at, change_summary)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`, versionID, documentID, input.Hash, input.PreviousHash, now.Format(time.RFC3339), "filesystem sync"); err != nil {
|
|
return fmt.Errorf("insert document version %s: %w", input.Path, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (r *Repository) GetDocumentByPath(ctx context.Context, path string) (*DocumentRecord, error) {
|
|
return r.getDocumentByPath(ctx, path, false)
|
|
}
|
|
|
|
func (r *Repository) GetDocumentByPathIncludingArchived(ctx context.Context, path string) (*DocumentRecord, error) {
|
|
return r.getDocumentByPath(ctx, path, true)
|
|
}
|
|
|
|
func (r *Repository) getDocumentByPath(ctx context.Context, path string, includeArchived bool) (*DocumentRecord, error) {
|
|
var (
|
|
record DocumentRecord
|
|
tagsJSON string
|
|
created string
|
|
updated string
|
|
archived sql.NullString
|
|
)
|
|
|
|
query := `
|
|
SELECT id, path, current_hash, title, tags, created_at, updated_at, archived_at
|
|
FROM documents
|
|
WHERE path = ?
|
|
`
|
|
if !includeArchived {
|
|
query += ` AND archived_at IS NULL`
|
|
}
|
|
|
|
err := r.db.QueryRowContext(ctx, query, path).Scan(&record.ID, &record.Path, &record.CurrentHash, &record.Title, &tagsJSON, &created, &updated, &archived)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := parseDocumentTimes(&record, created, updated); err != nil {
|
|
return nil, err
|
|
}
|
|
if archived.Valid && archived.String != "" {
|
|
t, err := time.Parse(time.RFC3339, archived.String)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parse document archived_at: %w", err)
|
|
}
|
|
record.ArchivedAt = &t
|
|
}
|
|
if err := json.Unmarshal([]byte(tagsJSON), &record.Tags); err != nil {
|
|
return nil, fmt.Errorf("unmarshal document tags: %w", err)
|
|
}
|
|
|
|
return &record, nil
|
|
}
|
|
|
|
func (r *Repository) ListDocuments(ctx context.Context) ([]DocumentRecord, error) {
|
|
rows, err := r.db.QueryContext(ctx, `
|
|
SELECT id, path, current_hash, title, tags, created_at, updated_at, archived_at
|
|
FROM documents
|
|
WHERE archived_at IS NULL
|
|
ORDER BY path ASC
|
|
`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list documents: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
return scanDocumentRows(rows)
|
|
}
|
|
|
|
func (r *Repository) ListArchivedDocuments(ctx context.Context) ([]DocumentRecord, error) {
|
|
rows, err := r.db.QueryContext(ctx, `
|
|
SELECT id, path, current_hash, title, tags, created_at, updated_at, archived_at
|
|
FROM documents
|
|
WHERE archived_at IS NOT NULL
|
|
ORDER BY archived_at DESC
|
|
`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list archived documents: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
return scanDocumentRows(rows)
|
|
}
|
|
|
|
func scanDocumentRows(rows *sql.Rows) ([]DocumentRecord, error) {
|
|
var records []DocumentRecord
|
|
for rows.Next() {
|
|
var (
|
|
record DocumentRecord
|
|
tagsJSON string
|
|
created string
|
|
updated string
|
|
archived sql.NullString
|
|
)
|
|
if err := rows.Scan(&record.ID, &record.Path, &record.CurrentHash, &record.Title, &tagsJSON, &created, &updated, &archived); err != nil {
|
|
return nil, fmt.Errorf("scan document: %w", err)
|
|
}
|
|
if err := parseDocumentTimes(&record, created, updated); err != nil {
|
|
return nil, err
|
|
}
|
|
if archived.Valid && archived.String != "" {
|
|
t, err := time.Parse(time.RFC3339, archived.String)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parse document archived_at: %w", err)
|
|
}
|
|
record.ArchivedAt = &t
|
|
}
|
|
if err := json.Unmarshal([]byte(tagsJSON), &record.Tags); err != nil {
|
|
return nil, fmt.Errorf("unmarshal document tags: %w", err)
|
|
}
|
|
records = append(records, record)
|
|
}
|
|
|
|
return records, rows.Err()
|
|
}
|
|
|
|
func (r *Repository) ArchiveDocument(ctx context.Context, path string) error {
|
|
now := time.Now().UTC().Format(time.RFC3339)
|
|
result, err := r.db.ExecContext(ctx, `
|
|
UPDATE documents SET archived_at = ? WHERE path = ? AND archived_at IS NULL
|
|
`, now, path)
|
|
if err != nil {
|
|
return fmt.Errorf("archive document %s: %w", path, err)
|
|
}
|
|
n, err := result.RowsAffected()
|
|
if err != nil {
|
|
return fmt.Errorf("archive document rows affected %s: %w", path, err)
|
|
}
|
|
if n == 0 {
|
|
return sql.ErrNoRows
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *Repository) RestoreDocument(ctx context.Context, path string) error {
|
|
result, err := r.db.ExecContext(ctx, `
|
|
UPDATE documents SET archived_at = NULL WHERE path = ? AND archived_at IS NOT NULL
|
|
`, path)
|
|
if err != nil {
|
|
return fmt.Errorf("restore document %s: %w", path, err)
|
|
}
|
|
n, err := result.RowsAffected()
|
|
if err != nil {
|
|
return fmt.Errorf("restore document rows affected %s: %w", path, err)
|
|
}
|
|
if n == 0 {
|
|
return sql.ErrNoRows
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *Repository) ListUsers(ctx context.Context) ([]UserRecord, error) {
|
|
rows, err := r.db.QueryContext(ctx, `
|
|
SELECT id, email, COALESCE(display_name, ''), COALESCE(role, 'viewer'), created_at, COALESCE(last_seen_at, '')
|
|
FROM users
|
|
ORDER BY created_at DESC
|
|
`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list users: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var users []UserRecord
|
|
for rows.Next() {
|
|
var (
|
|
user UserRecord
|
|
created string
|
|
lastSeen string
|
|
)
|
|
if err := rows.Scan(&user.ID, &user.Email, &user.DisplayName, &user.Role, &created, &lastSeen); err != nil {
|
|
return nil, fmt.Errorf("scan user: %w", err)
|
|
}
|
|
createdAt, err := time.Parse(time.RFC3339, created)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parse user created_at: %w", err)
|
|
}
|
|
user.CreatedAt = createdAt
|
|
if lastSeen != "" {
|
|
parsed, err := time.Parse(time.RFC3339, lastSeen)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parse user last_seen_at: %w", err)
|
|
}
|
|
user.LastSeenAt = parsed
|
|
}
|
|
users = append(users, user)
|
|
}
|
|
|
|
return users, rows.Err()
|
|
}
|
|
|
|
func (r *Repository) UpsertUser(ctx context.Context, user UserRecord) (UserRecord, error) {
|
|
now := time.Now().UTC()
|
|
if user.ID == "" {
|
|
user.ID = "user:" + user.Email
|
|
}
|
|
if user.Role == "" {
|
|
user.Role = "viewer"
|
|
}
|
|
if user.DisplayName == "" {
|
|
user.DisplayName = user.Email
|
|
}
|
|
user.CreatedAt = now
|
|
user.LastSeenAt = now
|
|
|
|
if _, err := r.db.ExecContext(ctx, `
|
|
INSERT INTO users (id, email, display_name, role, created_at, last_seen_at)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(email) DO UPDATE SET
|
|
display_name = excluded.display_name,
|
|
role = excluded.role,
|
|
last_seen_at = excluded.last_seen_at
|
|
`, user.ID, user.Email, user.DisplayName, user.Role, now.Format(time.RFC3339), now.Format(time.RFC3339)); err != nil {
|
|
return UserRecord{}, fmt.Errorf("upsert user %s: %w", user.Email, err)
|
|
}
|
|
|
|
users, err := r.ListUsers(ctx)
|
|
if err != nil {
|
|
return UserRecord{}, err
|
|
}
|
|
for _, candidate := range users {
|
|
if candidate.Email == user.Email {
|
|
return candidate, nil
|
|
}
|
|
}
|
|
return UserRecord{}, sql.ErrNoRows
|
|
}
|
|
|
|
func (r *Repository) SaveAttachment(ctx context.Context, record AttachmentRecord) error {
|
|
if _, err := r.db.ExecContext(ctx, `
|
|
INSERT INTO attachments (hash, original_name, content_type, size_bytes, created_at, document_path)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(hash) DO UPDATE SET
|
|
original_name = excluded.original_name,
|
|
content_type = excluded.content_type,
|
|
size_bytes = excluded.size_bytes,
|
|
document_path = excluded.document_path
|
|
`, record.Hash, record.OriginalName, record.ContentType, record.SizeBytes, record.CreatedAt.Format(time.RFC3339), record.DocumentPath); err != nil {
|
|
return fmt.Errorf("save attachment: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *Repository) GetAttachment(ctx context.Context, hash string) (*AttachmentRecord, error) {
|
|
var (
|
|
record AttachmentRecord
|
|
created string
|
|
)
|
|
err := r.db.QueryRowContext(ctx, `
|
|
SELECT hash, original_name, content_type, size_bytes, created_at, COALESCE(document_path, '')
|
|
FROM attachments
|
|
WHERE hash = ?
|
|
`, hash).Scan(&record.Hash, &record.OriginalName, &record.ContentType, &record.SizeBytes, &created, &record.DocumentPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
parsed, err := time.Parse(time.RFC3339, created)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parse attachment created_at: %w", err)
|
|
}
|
|
record.CreatedAt = parsed
|
|
return &record, nil
|
|
}
|
|
|
|
func (r *Repository) ListAttachments(ctx context.Context) ([]AttachmentRecord, error) {
|
|
rows, err := r.db.QueryContext(ctx, `
|
|
SELECT hash, original_name, content_type, size_bytes, created_at, COALESCE(document_path, '')
|
|
FROM attachments
|
|
ORDER BY created_at DESC
|
|
`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list attachments: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var attachments []AttachmentRecord
|
|
for rows.Next() {
|
|
var record AttachmentRecord
|
|
var created string
|
|
if err := rows.Scan(&record.Hash, &record.OriginalName, &record.ContentType, &record.SizeBytes, &created, &record.DocumentPath); err != nil {
|
|
return nil, fmt.Errorf("scan attachment: %w", err)
|
|
}
|
|
record.CreatedAt, err = time.Parse(time.RFC3339, created)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parse attachment created_at: %w", err)
|
|
}
|
|
attachments = append(attachments, record)
|
|
}
|
|
return attachments, rows.Err()
|
|
}
|
|
|
|
type SearchResult struct {
|
|
Path string `json:"path"`
|
|
Title string `json:"title"`
|
|
}
|
|
|
|
func (r *Repository) SearchDocuments(ctx context.Context, query string) ([]SearchResult, error) {
|
|
rows, err := r.db.QueryContext(ctx, `
|
|
SELECT d.path, d.title
|
|
FROM document_search ds
|
|
JOIN documents d ON d.rowid = ds.rowid
|
|
WHERE document_search MATCH ? AND d.archived_at IS NULL
|
|
ORDER BY rank
|
|
LIMIT 50
|
|
`, query)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("search documents: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var results []SearchResult
|
|
for rows.Next() {
|
|
var result SearchResult
|
|
if err := rows.Scan(&result.Path, &result.Title); err != nil {
|
|
return nil, fmt.Errorf("scan search result: %w", err)
|
|
}
|
|
results = append(results, result)
|
|
}
|
|
|
|
return results, rows.Err()
|
|
}
|
|
|
|
func (r *Repository) UpdateSearchContent(ctx context.Context, path string, content string) error {
|
|
if _, err := r.db.ExecContext(ctx, `
|
|
UPDATE document_search SET content = ?
|
|
WHERE rowid = (SELECT rowid FROM documents WHERE path = ?)
|
|
`, content, path); err != nil {
|
|
return fmt.Errorf("update search content: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *Repository) Ping(ctx context.Context) error {
|
|
return r.db.PingContext(ctx)
|
|
}
|
|
|
|
func parseDocumentTimes(record *DocumentRecord, created string, updated string) error {
|
|
createdAt, err := time.Parse(time.RFC3339, created)
|
|
if err != nil {
|
|
return fmt.Errorf("parse document created_at: %w", err)
|
|
}
|
|
updatedAt, err := time.Parse(time.RFC3339, updated)
|
|
if err != nil {
|
|
return fmt.Errorf("parse document updated_at: %w", err)
|
|
}
|
|
record.CreatedAt = createdAt
|
|
record.UpdatedAt = updatedAt
|
|
return nil
|
|
}
|