152 lines
5.4 KiB
Go
152 lines
5.4 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
"pageswiki/internal/metadata"
|
|
)
|
|
|
|
var ErrRevisionDomainRequired = errors.New("explicit revision domain is required")
|
|
var ErrDocumentStoreRequired = errors.New("canonical document storage is required")
|
|
|
|
func (s *Store) RestoreRevisionInDomain(ctx context.Context, domain, actor, revision, expected, message string) (*Revision, error) {
|
|
if s.ReadOnly {
|
|
return nil, ErrReadOnly
|
|
}
|
|
if s.sqlBackend == storeSQLite {
|
|
v, err := s.GetRevision(revision)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return s.SaveRevisionContentInDomain(ctx, domain, actor, v.ObjectUUID, []byte(v.Body), message, v.Language, v.ContentType, v.Filename, &expected)
|
|
}
|
|
if s.DocumentRoot == "" {
|
|
return nil, ErrDocumentStoreRequired
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
|
defer cancel()
|
|
repo, err := metadata.NewApplication(s.DB, metadata.PostgreSQL)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
docs, err := s.documentStorage()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
v, err := repo.RestoreDocument(ctx, docs, domain, revision, expected, message, actor)
|
|
if errors.Is(err, metadata.ErrConflict) {
|
|
return nil, ErrRevisionConflict
|
|
}
|
|
if errors.Is(err, metadata.ErrNotFound) {
|
|
return nil, ErrPageNotFound
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Revision{UUID: v.UUID, ObjectUUID: v.ObjectUUID, DocumentHash: v.DocumentHash, Language: v.Language, ContentType: v.ContentType, Filename: v.Filename, Message: v.Message, CreatedAtMS: v.CreatedAtMS, CreatedAt: v.CreatedAtMS / 1000}, nil
|
|
}
|
|
|
|
// SaveRevisionContentInDomain is the domain-aware persistence boundary for
|
|
// HTTP saves. The caller still performs authorization. A nil expected means
|
|
// append without CAS; an empty expected asserts no exact-language head exists.
|
|
// PostgreSQL serving/GC remain gated until all writers and GC pins are ported.
|
|
func (s *Store) SaveRevisionContentInDomain(ctx context.Context, domain, actor, object string, payload []byte, message, lang, contentType, filename string, expected *string) (*Revision, error) {
|
|
if s.ReadOnly {
|
|
return nil, ErrReadOnly
|
|
}
|
|
if strings.TrimSpace(domain) == "" {
|
|
return nil, ErrRevisionDomainRequired
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
|
defer cancel()
|
|
if err := ctx.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
if s.sqlBackend == storeSQLite {
|
|
// Preserve legacy exact-Object grant/create-save-bind behavior. The
|
|
// request layer owns authorization; SQLite's writer port is separate.
|
|
s.revisionWriteMu.Lock()
|
|
defer s.revisionWriteMu.Unlock()
|
|
return s.saveRevisionContentExpected(object, payload, message, lang, contentType, filename, expected)
|
|
}
|
|
if s.DocumentRoot == "" {
|
|
return nil, ErrDocumentStoreRequired
|
|
}
|
|
normalized, err := normalizeRevisionLanguage(lang)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
repo, err := metadata.NewApplication(s.DB, metadata.PostgreSQL)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
documents, err := s.documentStorage()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
v := metadata.Revision{ObjectUUID: object, Language: normalized, ContentType: normalizeRevisionContentType(contentType), Filename: strings.TrimSpace(filename), Message: message}
|
|
var saved metadata.SavedDocument
|
|
if expected == nil {
|
|
saved, err = repo.SaveDocumentUnconditionally(ctx, documents, domain, v, payload, actor)
|
|
} else {
|
|
saved, err = repo.SaveDocument(ctx, documents, domain, v, payload, *expected, actor)
|
|
}
|
|
if errors.Is(err, metadata.ErrConflict) {
|
|
return nil, ErrRevisionConflict
|
|
}
|
|
if errors.Is(err, metadata.ErrNotFound) {
|
|
return nil, ErrPageNotFound
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
v = saved.Revision
|
|
return &Revision{UUID: v.UUID, ObjectUUID: v.ObjectUUID, DocumentHash: v.DocumentHash, Language: v.Language, ContentType: v.ContentType, Filename: v.Filename, Message: v.Message, CreatedAt: v.CreatedAtMS / 1000, CreatedAtMS: v.CreatedAtMS, Body: string(saved.Payload)}, nil
|
|
}
|
|
|
|
// Legacy callers supply only an Object. Never resolve mutable Asset names or
|
|
// deliver change events through an arbitrary Domain when it has aliases across
|
|
// Domains. Such callers must use the explicit-domain API instead.
|
|
func (s *Store) revisionDomain(ctx context.Context, object string) (string, error) {
|
|
rows, err := s.DB.QueryContext(ctx, `SELECT domain_uuid FROM paths WHERE object_uuid=`+s.sqlParam(1)+` UNION SELECT domain_uuid FROM object_origins WHERE object_uuid=`+s.sqlParam(2)+` AND NOT EXISTS(SELECT 1 FROM paths WHERE object_uuid=`+s.sqlParam(3)+`) ORDER BY domain_uuid LIMIT 2`, object, object, object)
|
|
if err != nil {
|
|
return "", s.sqlError("revision domain", err)
|
|
}
|
|
defer rows.Close()
|
|
var domain string
|
|
count := 0
|
|
for rows.Next() {
|
|
count++
|
|
if err = rows.Scan(&domain); err != nil {
|
|
return "", s.sqlError("revision domain", err)
|
|
}
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return "", s.sqlError("revision domain", err)
|
|
}
|
|
if count == 0 {
|
|
return "", ErrPageNotFound
|
|
}
|
|
if count > 1 {
|
|
return "", ErrRevisionDomainRequired
|
|
}
|
|
return domain, nil
|
|
}
|
|
|
|
func (s *Store) legacyRevisionHeadOrder() string {
|
|
tie := "rowid"
|
|
if s.sqlBackend == storePostgreSQL {
|
|
tie = "uuid"
|
|
}
|
|
return "COALESCE(created_at_ms,created_at*1000) DESC," + tie + " DESC"
|
|
}
|
|
|
|
func (s *Store) ObjectHasRevision(ctx context.Context, object string) (bool, error) {
|
|
var found bool
|
|
err := s.DB.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM revisions WHERE object_uuid=`+s.sqlParam(1)+`)`, object).Scan(&found)
|
|
return found, s.sqlError("object revision existence", err)
|
|
}
|