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) { 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 SQLite 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) { 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) { 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(¤t, ¤tMS) 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=? AND COALESCE(NULLIF(lang,''),'und')=? ORDER BY COALESCE(created_at_ms,created_at*1000) DESC,rowid DESC 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 = ? `, 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=? AND COALESCE(NULLIF(lang,''),'und')=? ORDER BY COALESCE(created_at_ms,created_at*1000) DESC,rowid DESC 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 int return s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM paths WHERE domain_uuid=? AND object_uuid=?)`, domainUUID, objectUUID).Scan(&exists) == nil && exists != 0 } 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 = ? AND COALESCE(NULLIF(lang, ''), 'und') = ? ORDER BY COALESCE(created_at_ms, created_at * 1000) DESC, rowid DESC 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 }