package store import ( "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) { 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 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 } 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) { 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.QueryRow(`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 }