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