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

486 lines
12 KiB
Go

package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"errors"
"strings"
"time"
"github.com/google/uuid"
"golang.org/x/text/language"
)
type Revision struct {
UUID string
ObjectUUID string
DocumentHash string
Language string
ContentType string
Filename string
Body string
Message string
CreatedAt int64
CreatedAtMS int64
}
var (
ErrInvalidRevisionLanguage = errors.New("invalid revision language")
ErrPageNotFound = errors.New("page UUID does not exist")
)
func revisionHash(body string) string {
sum := sha256.Sum256([]byte(body))
return hex.EncodeToString(sum[:])
}
func normalizeRevisionLanguage(raw string) (string, error) {
raw = strings.TrimSpace(raw)
if raw == "" {
return "und", nil
}
tag, err := language.Parse(raw)
if err != nil {
return "", ErrInvalidRevisionLanguage
}
return tag.String(), nil
}
func (s *Store) SaveRevision(
objectUUID string,
body string,
message string,
) (string, error) {
revision, err :=
s.SaveRevisionForLanguage(
objectUUID,
body,
message,
"und",
)
if err != nil {
return "", err
}
return revision.UUID, nil
}
func (s *Store) SaveRevisionForLanguage(
objectUUID string,
body string,
message string,
rawLanguage string,
) (*Revision, error) {
return s.SaveRevisionContent(
objectUUID,
[]byte(body),
message,
rawLanguage,
"text/html; charset=utf-8",
"",
)
}
func (s *Store) SaveRevisionContent(
objectUUID string,
payload []byte,
message string,
rawLanguage string,
contentType string,
filename string,
) (*Revision, error) {
if s.sqlBackend == storePostgreSQL {
return s.saveRevisionContentExpected(objectUUID, payload, message, rawLanguage, contentType, filename, nil)
}
s.revisionWriteMu.Lock()
defer s.revisionWriteMu.Unlock()
return s.saveRevisionContentUnlocked(objectUUID, payload, message, rawLanguage, contentType, filename)
}
func (s *Store) saveRevisionContentUnlocked(
objectUUID string,
payload []byte,
message string,
rawLanguage string,
contentType string,
filename string,
) (*Revision, error) {
return s.saveRevisionContentExpected(objectUUID, payload, message, rawLanguage, contentType, filename, nil)
}
// SaveRevisionContentIfHead compares the exact language head and appends within
// one write transaction, including writers outside this Store process.
// An empty expected UUID asserts that this language has no revision yet.
func (s *Store) SaveRevisionContentIfHead(objectUUID string, payload []byte, message, lang, contentType, filename, expected string) (*Revision, error) {
if s.sqlBackend == storePostgreSQL {
return s.saveRevisionContentExpected(objectUUID, payload, message, lang, contentType, filename, &expected)
}
s.revisionWriteMu.Lock()
defer s.revisionWriteMu.Unlock()
return s.saveRevisionContentExpected(objectUUID, payload, message, lang, contentType, filename, &expected)
}
func (s *Store) saveRevisionContentExpected(objectUUID string, payload []byte, message, rawLanguage, contentType, filename string, expected *string) (*Revision, error) {
if s.ReadOnly {
return nil, ErrReadOnly
}
if s.sqlBackend == storePostgreSQL {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
domain, err := s.revisionDomain(ctx, objectUUID)
if err != nil {
return nil, err
}
return s.SaveRevisionContentInDomain(ctx, domain, "", objectUUID, payload, message, rawLanguage, contentType, filename, expected)
}
lang, err :=
normalizeRevisionLanguage(
rawLanguage,
)
if err != nil {
return nil, err
}
var objectCount int
err = s.DB.QueryRow(`
SELECT count(*)
FROM objects
WHERE uuid = ?
`, objectUUID).Scan(&objectCount)
if err != nil {
return nil, err
}
if objectCount == 0 {
return nil, ErrPageNotFound
}
now := time.Now()
contentType = normalizeRevisionContentType(contentType)
filename = strings.TrimSpace(filename)
payload, embeddedHashes, err := s.freezeEmbeddedAssets(objectUUID, payload, contentType)
if err != nil {
return nil, err
}
body := string(payload)
revision := &Revision{
UUID: uuid.NewString(),
ObjectUUID: objectUUID,
DocumentHash: revisionHash(body),
Language: lang,
ContentType: contentType,
Filename: filename,
Body: body,
Message: message,
CreatedAt: now.Unix(),
CreatedAtMS: now.UnixMilli(),
}
if err := s.persistDocument(
revision.DocumentHash,
revision.Body,
); err != nil {
return nil, err
}
tx, err := s.DB.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
if expected != nil {
// Acquire a write lock before reading the head. Avoid a read-to-write
// upgrade race with CLI/another process writing this same database.
if _, err = tx.Exec(`UPDATE objects SET uuid=uuid WHERE uuid=?`, objectUUID); err != nil {
return nil, err
}
var current string
var currentMS int64
err = tx.QueryRow(`SELECT uuid,COALESCE(created_at_ms,created_at*1000) FROM revisions WHERE object_uuid=? AND COALESCE(NULLIF(lang,''),'und')=? ORDER BY COALESCE(created_at_ms,created_at*1000) DESC,rowid DESC LIMIT 1`, objectUUID, lang).Scan(&current, &currentMS)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return nil, err
}
if current != *expected {
return nil, ErrRevisionConflict
}
// Hashing/persisting may wait behind another process. The revision we
// accepted must sort after its base even if the wall clock moved back.
revision.CreatedAtMS = time.Now().UnixMilli()
if revision.CreatedAtMS <= currentMS {
revision.CreatedAtMS = currentMS + 1
}
revision.CreatedAt = revision.CreatedAtMS / 1000
}
if err = insertRevision(tx, revision, embeddedHashes); err != nil {
return nil, err
}
if err = s.appendRevisionActivityOutboxIfAvailable(tx, revision); err != nil {
return nil, err
}
if err = tx.Commit(); err != nil {
return nil, err
}
return revision, nil
}
// GetRevisionForExactLanguage deliberately has no viewer-language fallback.
func (s *Store) GetRevisionForExactLanguage(objectUUID, rawLanguage string) (*Revision, error) {
return s.revisionForExactLanguage(objectUUID, rawLanguage, false)
}
// GetRevisionMetadataForExactLanguage does not read the document file. Polling
// an editor head must not hydrate a potentially large body on every request.
func (s *Store) GetRevisionMetadataForExactLanguage(objectUUID, rawLanguage string) (*Revision, error) {
return s.revisionForExactLanguage(objectUUID, rawLanguage, true)
}
func (s *Store) revisionForExactLanguage(objectUUID, rawLanguage string, metadata bool) (*Revision, error) {
lang, err := normalizeRevisionLanguage(rawLanguage)
if err != nil {
return nil, err
}
var id string
err = s.DB.QueryRow(`SELECT uuid FROM revisions WHERE object_uuid=`+s.sqlParam(1)+` AND COALESCE(NULLIF(lang,''),'und')=`+s.sqlParam(2)+` ORDER BY `+s.legacyRevisionHeadOrder()+` LIMIT 1`, objectUUID, lang).Scan(&id)
if errors.Is(err, sql.ErrNoRows) {
return &Revision{ObjectUUID: objectUUID, Language: lang, ContentType: "text/html; charset=utf-8"}, nil
}
if err != nil {
return nil, err
}
if metadata {
return s.GetRevisionMetadata(id)
}
return s.GetRevision(id)
}
func insertRevision(tx *sql.Tx, revision *Revision, embeddedHashes []string) error {
result, err := tx.Exec(`
INSERT INTO revisions (
uuid,
object_uuid,
body,
document_hash,
lang,
content_type,
filename,
message,
created_at_ms,
created_at
)
SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
WHERE EXISTS(SELECT 1 FROM objects WHERE uuid=?)
`,
revision.UUID,
revision.ObjectUUID,
revision.Body,
revision.DocumentHash,
revision.Language,
revision.ContentType,
revision.Filename,
revision.Message,
revision.CreatedAtMS,
revision.CreatedAt,
revision.ObjectUUID,
)
if err != nil {
return err
}
if n, err := result.RowsAffected(); err != nil {
return err
} else if n != 1 {
return ErrPageNotFound
}
for _, hash := range embeddedHashes {
if _, err = tx.Exec(`INSERT INTO revision_document_refs(revision_uuid,document_hash) VALUES(?,?)`, revision.UUID, hash); err != nil {
return err
}
}
return nil
}
func (s *Store) GetRevision(
revisionUUID string,
) (*Revision, error) {
row := s.DB.QueryRow(`
SELECT
uuid,
object_uuid,
COALESCE(document_hash, ''),
COALESCE(NULLIF(lang, ''), 'und'),
COALESCE(NULLIF(content_type, ''), 'text/html; charset=utf-8'),
COALESCE(filename, ''),
COALESCE(body, ''),
COALESCE(message, ''),
COALESCE(created_at, 0),
COALESCE(created_at_ms, COALESCE(created_at, 0) * 1000)
FROM revisions
WHERE uuid = `+s.sqlParam(1)+`
`, revisionUUID)
revision, err :=
scanRevision(
row,
)
if err != nil {
return nil, err
}
return s.hydrateRevision(
revision,
)
}
func (s *Store) GetLatestRevisionMetadataForLanguages(objectUUID string, rawLanguages []string) (*Revision, error) {
return s.GetLatestRevisionMetadataForLanguagesContext(context.Background(), objectUUID, rawLanguages)
}
func (s *Store) GetLatestRevisionMetadataForLanguagesContext(ctx context.Context, objectUUID string, rawLanguages []string) (*Revision, error) {
candidates := make([]string, 0, len(rawLanguages)+1)
seen := map[string]bool{}
for _, rawLanguage := range rawLanguages {
lang, err := normalizeRevisionLanguage(rawLanguage)
if err == nil && !seen[lang] {
candidates, seen[lang] = append(candidates, lang), true
}
}
if !seen["und"] {
candidates = append(candidates, "und")
}
for _, lang := range candidates {
row := s.DB.QueryRowContext(ctx, `SELECT uuid,object_uuid,COALESCE(document_hash,''),COALESCE(NULLIF(lang,''),'und'),COALESCE(NULLIF(content_type,''),'text/html; charset=utf-8'),COALESCE(filename,''),'',COALESCE(message,''),COALESCE(created_at,0),COALESCE(created_at_ms,COALESCE(created_at,0)*1000) FROM revisions WHERE object_uuid=`+s.sqlParam(1)+` AND COALESCE(NULLIF(lang,''),'und')=`+s.sqlParam(2)+` ORDER BY `+s.legacyRevisionHeadOrder()+` LIMIT 1`, objectUUID, lang)
revision, err := scanRevision(row)
if err == nil {
return revision, nil
}
if !errors.Is(err, sql.ErrNoRows) {
return nil, err
}
}
return &Revision{ObjectUUID: objectUUID, Language: candidates[0], ContentType: "text/html; charset=utf-8"}, nil
}
func (s *Store) ObjectBoundInDomain(domainUUID, objectUUID string) bool {
var exists bool
return s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM paths WHERE domain_uuid=`+s.sqlParam(1)+` AND object_uuid=`+s.sqlParam(2)+`)`, domainUUID, objectUUID).Scan(&exists) == nil && exists
}
func (s *Store) GetLatestRevision(
objectUUID string,
) (*Revision, error) {
return s.GetLatestRevisionForLanguages(
objectUUID,
[]string{"und"},
)
}
func (s *Store) GetLatestRevisionForLanguages(
objectUUID string,
rawLanguages []string,
) (*Revision, error) {
candidates := make([]string, 0, len(rawLanguages)+1)
seen := map[string]bool{}
for _, rawLanguage := range rawLanguages {
lang, err := normalizeRevisionLanguage(rawLanguage)
if err != nil {
continue
}
if !seen[lang] {
candidates = append(candidates, lang)
seen[lang] = true
}
}
if !seen["und"] {
candidates = append(candidates, "und")
}
for _, lang := range candidates {
row := s.DB.QueryRow(`
SELECT
uuid,
object_uuid,
COALESCE(document_hash, ''),
COALESCE(NULLIF(lang, ''), 'und'),
COALESCE(NULLIF(content_type, ''), 'text/html; charset=utf-8'),
COALESCE(filename, ''),
COALESCE(body, ''),
COALESCE(message, ''),
COALESCE(created_at, 0),
COALESCE(created_at_ms, COALESCE(created_at, 0) * 1000)
FROM revisions
WHERE object_uuid = `+s.sqlParam(1)+`
AND COALESCE(NULLIF(lang, ''), 'und') = `+s.sqlParam(2)+`
ORDER BY
`+s.legacyRevisionHeadOrder()+`
LIMIT 1
`, objectUUID, lang)
revision, err := scanRevision(row)
if err == nil {
return s.hydrateRevision(
revision,
)
}
if !errors.Is(err, sql.ErrNoRows) {
return nil, err
}
}
return &Revision{
ObjectUUID: objectUUID,
Language: candidates[0],
ContentType: "text/html; charset=utf-8",
}, nil
}
func scanRevision(row interface {
Scan(dest ...any) error
}) (*Revision, error) {
var revision Revision
err := row.Scan(
&revision.UUID,
&revision.ObjectUUID,
&revision.DocumentHash,
&revision.Language,
&revision.ContentType,
&revision.Filename,
&revision.Body,
&revision.Message,
&revision.CreatedAt,
&revision.CreatedAtMS,
)
if err != nil {
return nil, err
}
return &revision, nil
}
func normalizeRevisionContentType(raw string) string {
raw = strings.TrimSpace(raw)
if raw == "" {
return "text/html; charset=utf-8"
}
if strings.ContainsAny(raw, "\r\n") {
return "application/octet-stream"
}
return raw
}