469 lines
12 KiB
Go
469 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) {
|
|
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
|
|
}
|