Files
pages/internal/store/revision_backend.go
T
2026-11-15 05:47:14 +09:00

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)
}