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

406 lines
19 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"github.com/google/uuid"
"path"
"strings"
"time"
"unicode"
)
var ErrPeriodicalInvalid = errors.New("invalid diary/blog entry")
var ErrPeriodicalConflict = errors.New("entry changed")
var ErrPeriodicalDisabled = errors.New("extension is disabled")
func PeriodicalKind(kind string) bool { return kind == "diary" || kind == "blog" }
// Article content remains an ordinary Page. Metadata follows its UUID on rename.
type PeriodicalEntry struct {
PageUUID string `json:"page_uuid"`
Path string `json:"path"`
Title string `json:"title"`
Date string `json:"date"`
Category string `json:"category"`
Timezone string `json:"timezone"`
Owner string `json:"owner_uuid"`
Version int64 `json:"version"`
Remove bool `json:"remove,omitempty"`
}
func (s *Store) EnsurePeriodicalSchema() error {
if s.sqlBackend == storePostgreSQL {
return s.ensurePostgreSQLPeriodicals(context.Background())
}
for _, query := range []string{
`CREATE TABLE IF NOT EXISTS periodical_settings(domain_uuid TEXT NOT NULL,kind TEXT NOT NULL CHECK(kind IN ('diary','blog')),enabled INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(domain_uuid,kind))`,
`CREATE TABLE IF NOT EXISTS periodical_entries(domain_uuid TEXT NOT NULL,kind TEXT NOT NULL CHECK(kind IN ('diary','blog')),page_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,local_date TEXT NOT NULL,title TEXT NOT NULL,category TEXT NOT NULL DEFAULT '',timezone TEXT NOT NULL,version INTEGER NOT NULL DEFAULT 1,PRIMARY KEY(domain_uuid,kind,page_uuid))`,
`CREATE INDEX IF NOT EXISTS idx_periodical_date ON periodical_entries(domain_uuid,kind,local_date DESC,page_uuid)`,
`DROP INDEX IF EXISTS idx_diary_owner_date`,
`CREATE TABLE IF NOT EXISTS periodical_prefixes(domain_uuid TEXT NOT NULL,kind TEXT NOT NULL CHECK(kind IN ('diary','blog')),prefix TEXT NOT NULL,PRIMARY KEY(domain_uuid,kind))`,
`CREATE TABLE IF NOT EXISTS periodical_events(id INTEGER PRIMARY KEY AUTOINCREMENT,domain_uuid TEXT NOT NULL,kind TEXT NOT NULL,page_uuid TEXT NOT NULL,actor_uuid TEXT NOT NULL,operation TEXT NOT NULL,version INTEGER NOT NULL,created_at_ms INTEGER NOT NULL)`,
`CREATE INDEX IF NOT EXISTS idx_periodical_event_page ON periodical_events(domain_uuid,kind,page_uuid,version DESC)`,
`CREATE TABLE IF NOT EXISTS periodical_posts(domain_uuid TEXT NOT NULL,kind TEXT NOT NULL,actor_uuid TEXT NOT NULL,request_id TEXT NOT NULL,digest TEXT NOT NULL,page_uuid TEXT NOT NULL,PRIMARY KEY(domain_uuid,kind,actor_uuid,request_id))`,
`CREATE TABLE IF NOT EXISTS domain_entry_settings(domain_uuid TEXT PRIMARY KEY,settings_json TEXT NOT NULL)`,
`CREATE TABLE IF NOT EXISTS periodical_projections(domain_uuid TEXT NOT NULL,kind TEXT NOT NULL,source_uuid TEXT NOT NULL,prefix TEXT NOT NULL,PRIMARY KEY(domain_uuid,kind))`,
} {
if _, err := s.DB.Exec(query); err != nil {
return err
}
}
return nil
}
func (s *Store) PeriodicalEnabled(ctx context.Context, domain, kind string) (result bool, resultErr error) {
defer func() { resultErr = s.sqlError("periodicals repository", resultErr) }()
var enabled bool
err := s.DB.QueryRowContext(ctx, `SELECT enabled FROM periodical_settings WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2), domain, kind).Scan(&enabled)
if errors.Is(err, sql.ErrNoRows) {
return false, nil
}
return enabled, err
}
// PeriodicalPath is shared by settings validation and the new-article planner.
// It never normalizes traversal or silently replaces a caller's keyword.
func PeriodicalPath(prefix, date, keyword string) (string, error) {
if !strings.HasPrefix(prefix, "/") || path.Clean(prefix) != prefix || len(prefix) > 3500 || strings.ContainsAny(prefix, "\\?#%") || strings.IndexFunc(prefix+keyword, unicode.IsControl) >= 0 {
return "", ErrPeriodicalInvalid
}
for _, reserved := range []string{"/_", "/-", "/v", "/e", "/:"} {
if prefix == reserved || strings.HasPrefix(prefix, reserved+"/") {
return "", ErrPeriodicalInvalid
}
}
d, err := time.Parse("2006-01-02", date)
if err != nil || d.Year() < 1 || d.Year() > 9999 || d.Format("2006-01-02") != date || len(keyword) > 240 || keyword != strings.TrimSpace(keyword) || keyword == "." || keyword == ".." || strings.ContainsAny(keyword, "/\\?#%") {
return "", ErrPeriodicalInvalid
}
return path.Join(prefix, d.Format("2006/01/02"), keyword), nil
}
func (s *Store) PeriodicalPrefix(ctx context.Context, domain, kind string) (result string, resultErr error) {
defer func() { resultErr = s.sqlError("periodicals repository", resultErr) }()
if !PeriodicalKind(kind) {
return "", ErrPeriodicalInvalid
}
var prefix string
err := s.DB.QueryRowContext(ctx, `SELECT prefix FROM periodical_prefixes WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2), domain, kind).Scan(&prefix)
if errors.Is(err, sql.ErrNoRows) {
return "/" + kind, nil
}
return prefix, err
}
func (s *Store) ChangePeriodical(ctx context.Context, domain, actor, kind string, enabled *bool, entry *PeriodicalEntry, prefixes ...string) error {
return s.changePeriodical(ctx, domain, actor, kind, enabled, entry, prefixes, nil)
}
type PeriodicalPost struct {
Title string `json:"title"`
Date string `json:"date"`
Category string `json:"category"`
Keyword string `json:"keyword"`
Body string `json:"body"`
RequestID string `json:"request_id"`
Timezone string `json:"-"`
Path string `json:"-"`
PageUUID string `json:"-"`
}
// Body is canonical HTML produced by the server. The Page, Revision, binding,
// article metadata and retry receipt become visible in one transaction.
func (s *Store) CreatePeriodical(ctx context.Context, domain, actor, kind string, post *PeriodicalPost) error {
if post == nil || len(post.Body) > 256<<10 || strings.TrimSpace(post.Body) == "" {
return ErrPeriodicalInvalid
}
if _, err := uuid.Parse(post.RequestID); err != nil {
return ErrPeriodicalInvalid
}
if strings.TrimSpace(post.Title) == "" || len(post.Title) > 240 || len(post.Category) > 80 || strings.ContainsAny(post.Title+post.Category, "\x00\r\n") {
return ErrPeriodicalInvalid
}
if _, err := time.LoadLocation(post.Timezone); err != nil {
return ErrPeriodicalInvalid
}
s.revisionWriteMu.Lock()
defer s.revisionWriteMu.Unlock()
entry := &PeriodicalEntry{Title: post.Title, Date: post.Date, Category: post.Category, Timezone: post.Timezone}
return s.changePeriodical(ctx, domain, actor, kind, nil, entry, nil, post)
}
func (s *Store) changePeriodical(ctx context.Context, domain, actor, kind string, enabled *bool, entry *PeriodicalEntry, prefixes []string, post *PeriodicalPost) (resultErr error) {
defer func() { resultErr = s.sqlError("periodicals repository", resultErr) }()
if !PeriodicalKind(kind) || (enabled == nil) == (entry == nil) {
return ErrPeriodicalInvalid
}
if len(prefixes) > 1 || (len(prefixes) > 0 && enabled == nil) {
return ErrPeriodicalInvalid
}
if len(prefixes) == 1 {
if _, err := PeriodicalPath(prefixes[0], "2000-01-01", ""); err != nil {
return err
}
}
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if err = s.lockTaskWriter(ctx, tx); err != nil {
return err
}
// Reserve writer before all authorization, configuration and binding checks.
if _, err = tx.ExecContext(ctx, `INSERT INTO periodical_settings(domain_uuid,kind) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`) ON CONFLICT(domain_uuid,kind) DO UPDATE SET enabled=periodical_settings.enabled`, domain, kind); err != nil {
return err
}
var active, admin bool
err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid JOIN domains d ON d.uuid=m.domain_uuid AND d.enabled=1 WHERE p.uuid=`+s.sqlParam(1)+` AND p.state='active' AND m.domain_uuid=`+s.sqlParam(2)+` AND m.state='active')`, actor, domain).Scan(&active)
if err != nil {
return err
}
if !active {
return ErrAccessDenied
}
if s.sqlBackend == storePostgreSQL {
if err = s.taskActor(ctx, tx, domain, actor, true); err != nil {
return err
}
}
err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid WHERE g.domain_uuid=`+s.sqlParam(1)+` AND g.builtin_key='domain_admin' AND g.state='active' AND gm.member_role IN ('owner','manager') AND m.principal_uuid=`+s.sqlParam(2)+` AND m.state='active')`, domain, actor).Scan(&admin)
if err != nil {
return err
}
operation, pageUUID, version := "settings", "", int64(0)
if enabled != nil {
var controlled bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domain_entry_settings WHERE domain_uuid=`+s.sqlParam(1)+`)`, domain).Scan(&controlled); err != nil {
return err
}
if controlled {
return ErrAccessDenied
}
if !admin {
return ErrAccessDenied
}
if _, err = tx.ExecContext(ctx, `UPDATE periodical_settings SET enabled=`+s.sqlParam(1)+` WHERE domain_uuid=`+s.sqlParam(2)+` AND kind=`+s.sqlParam(3), boolToInt(*enabled), domain, kind); err != nil {
return err
}
if len(prefixes) == 1 {
if _, err = tx.ExecContext(ctx, `INSERT INTO periodical_prefixes(domain_uuid,kind,prefix) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`) ON CONFLICT(domain_uuid,kind) DO UPDATE SET prefix=excluded.prefix`, domain, kind, prefixes[0]); err != nil {
return err
}
}
} else {
var projected bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM periodical_projections WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2)+`)`, domain, kind).Scan(&projected); err != nil {
return err
}
if projected {
return ErrAccessDenied
}
var on bool
if err = tx.QueryRowContext(ctx, `SELECT enabled FROM periodical_settings WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2), domain, kind).Scan(&on); err != nil {
return err
}
if !on {
return ErrPeriodicalDisabled
}
e := entry
if post != nil {
var local bool
if err = tx.QueryRowContext(ctx, `SELECT COALESCE(placement,'local')='local' FROM domains WHERE uuid=`+s.sqlParam(1)+` AND enabled=1`, domain).Scan(&local); err != nil {
return err
}
if !local {
return ErrAccessDenied
}
prefix := "/" + kind
err = tx.QueryRowContext(ctx, `SELECT prefix FROM periodical_prefixes WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2), domain, kind).Scan(&prefix)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
e.Path, err = PeriodicalPath(prefix, e.Date, post.Keyword)
if err != nil {
return err
}
post.Path = e.Path
}
if !strings.HasPrefix(e.Path, "/") || path.Clean(e.Path) != e.Path || len(e.Path) > 4096 || strings.ContainsAny(e.Path, "\\\x00\r\n") || e.Version < 0 {
return ErrPeriodicalInvalid
}
if post == nil {
if err = tx.QueryRowContext(ctx, `SELECT p.object_uuid FROM paths p JOIN objects o ON o.uuid=p.object_uuid AND o.kind='page' WHERE p.domain_uuid=`+s.sqlParam(1)+` AND p.path=`+s.sqlParam(2), domain, e.Path).Scan(&pageUUID); err != nil {
return err
}
if (e.Version > 0 && e.PageUUID != pageUUID) || (e.PageUUID != "" && e.PageUUID != pageUUID) {
return ErrPeriodicalConflict
}
}
capabilities := []string{"write"}
if post != nil {
capabilities = append(capabilities, "create")
}
for _, capability := range capabilities {
basis := s.authorizeGrantContext(ctx, tx, AuthorizationRequest{DomainUUID: domain, PrincipalUUID: actor, Capability: capability, TargetType: "path", TargetID: e.Path}, false)
if basis != nil && !errors.Is(basis, ErrAccessDenied) {
return basis
}
// Match the existing semantic editor's own-user Wiki authority; the
// authenticated identity and Locality caps still come from this tx.
if errors.Is(basis, ErrAccessDenied) {
var own bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM principal_identities WHERE principal_uuid=`+s.sqlParam(1)+` AND provider_type='password' AND (`+s.sqlParam(2)+`='/u/'||subject OR substr(`+s.sqlParam(3)+`,1,length('/u/'||subject||'/'))='/u/'||subject||'/'))`, actor, e.Path, e.Path).Scan(&own); err != nil {
return err
}
if own {
basis = nil
}
}
caps, err := s.loadLocalityAccess(tx, domain, actor)
if err != nil {
return err
}
if !caps.Decide(e.Path, capability, basis == nil) {
return ErrAccessDenied
}
}
if post != nil {
encoded, _ := json.Marshal([]string{post.Path, post.Title, post.Date, post.Category, post.Keyword, post.Body})
digest := revisionHash(string(encoded))
var oldDigest, oldPage string
err = tx.QueryRowContext(ctx, `SELECT digest,page_uuid FROM periodical_posts WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2)+` AND actor_uuid=`+s.sqlParam(3)+` AND request_id=`+s.sqlParam(4), domain, kind, actor, post.RequestID).Scan(&oldDigest, &oldPage)
if err == nil {
var live bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM paths p JOIN periodical_entries e ON e.domain_uuid=p.domain_uuid AND e.page_uuid=p.object_uuid AND e.kind=`+s.sqlParam(1)+` WHERE p.domain_uuid=`+s.sqlParam(2)+` AND p.path=`+s.sqlParam(3)+` AND p.object_uuid=`+s.sqlParam(4)+`)`, kind, domain, e.Path, oldPage).Scan(&live); err != nil {
return err
}
if digest != oldDigest || !live {
return ErrPeriodicalConflict
}
post.PageUUID = oldPage
return tx.Commit()
}
if !errors.Is(err, sql.ErrNoRows) {
return err
}
var exists bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM paths WHERE domain_uuid=`+s.sqlParam(1)+` AND path=`+s.sqlParam(2)+`)`, domain, e.Path).Scan(&exists); err != nil {
return err
}
if exists {
return ErrPeriodicalConflict
}
pageUUID = uuid.NewString()
if s.sqlBackend == storePostgreSQL {
if err = s.createPeriodicalPageTx(ctx, tx, domain, actor, pageUUID, e.Path, post.Body); err != nil {
return err
}
} else {
if _, err = tx.ExecContext(ctx, `INSERT INTO objects(uuid,kind,created_at) VALUES(`+s.sqlParam(1)+`,'page',strftime('%s','now'))`, pageUUID); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO object_origins(object_uuid,domain_uuid,created_at) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,strftime('%s','now'))`, pageUUID, domain); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO paths(domain_uuid,path,object_uuid,created_at) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,strftime('%s','now'))`, domain, e.Path, pageUUID); err != nil {
return err
}
body, hashes, err := freezeEmbeddedAssetsFrom(tx, pageUUID, []byte(post.Body), "text/html; charset=utf-8")
if err != nil {
return err
}
now := time.Now()
rev := &Revision{UUID: uuid.NewString(), ObjectUUID: pageUUID, Body: string(body), DocumentHash: revisionHash(string(body)), Language: "und", ContentType: "text/html; charset=utf-8", CreatedAt: now.Unix(), CreatedAtMS: now.UnixMilli()}
if err = s.persistDocument(rev.DocumentHash, rev.Body); err != nil {
return err
}
if err = insertRevision(tx, rev, hashes); err != nil {
return err
}
}
if _, err = tx.ExecContext(ctx, `INSERT INTO periodical_posts(domain_uuid,kind,actor_uuid,request_id,digest,page_uuid) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`)`, domain, kind, actor, post.RequestID, digest, pageUUID); err != nil {
return err
}
post.PageUUID = pageUUID
}
var oldVersion int64
var owner, oldTimezone string
err = tx.QueryRowContext(ctx, `SELECT version,owner_uuid,timezone FROM periodical_entries WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2)+` AND page_uuid=`+s.sqlParam(3), domain, kind, pageUUID).Scan(&oldVersion, &owner, &oldTimezone)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
if oldVersion != e.Version || (e.Remove && oldVersion == 0) {
return ErrPeriodicalConflict
}
version = oldVersion + 1
if oldVersion == 0 {
if err = tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(version),0)+1 FROM periodical_events WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2)+` AND page_uuid=`+s.sqlParam(3), domain, kind, pageUUID).Scan(&version); err != nil {
return err
}
}
if e.Remove {
operation = "removed"
_, err = tx.ExecContext(ctx, `DELETE FROM periodical_entries WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2)+` AND page_uuid=`+s.sqlParam(3), domain, kind, pageUUID)
} else {
operation = "registered"
if oldVersion > 0 {
e.Timezone = oldTimezone
}
e.Title = strings.TrimSpace(e.Title)
e.Category = strings.TrimSpace(e.Category)
date, parseErr := time.Parse("2006-01-02", e.Date)
if parseErr != nil || date.Format("2006-01-02") != e.Date || date.Year() < 1 || date.Year() > 9999 || len(e.Title) == 0 || len(e.Title) > 240 || len(e.Category) > 80 || strings.ContainsAny(e.Title+e.Category, "\x00\r\n") {
return ErrPeriodicalInvalid
}
if _, err = time.LoadLocation(e.Timezone); err != nil {
return ErrPeriodicalInvalid
}
if owner == "" {
owner = actor
}
_, err = tx.ExecContext(ctx, `INSERT INTO periodical_entries(domain_uuid,kind,page_uuid,owner_uuid,local_date,title,category,timezone,version) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`,`+s.sqlParam(9)+`) ON CONFLICT(domain_uuid,kind,page_uuid) DO UPDATE SET local_date=excluded.local_date,title=excluded.title,category=excluded.category,timezone=excluded.timezone,version=excluded.version`, domain, kind, pageUUID, owner, e.Date, e.Title, e.Category, e.Timezone, version)
}
if err != nil {
return err
}
}
if _, err = tx.ExecContext(ctx, `INSERT INTO periodical_events(domain_uuid,kind,page_uuid,actor_uuid,operation,version,created_at_ms) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`)`, domain, kind, pageUUID, actor, operation, version, time.Now().UnixMilli()); err != nil {
return err
}
return tx.Commit()
}
// Bounded metadata-only scan; callers filter permissions before counts/paging.
// All aliases are retained until filtering, so a private alias cannot hide an
// otherwise readable Page. No canonical HTML is loaded to build an index.
func (s *Store) ListPeriodicalEntries(ctx context.Context, domain, kind string) (result []PeriodicalEntry, resultErr error) {
defer func() { resultErr = s.sqlError("periodicals repository", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
rows, err := s.DB.QueryContext(ctx, `SELECT e.page_uuid,p.path,e.title,e.local_date,e.category,e.timezone,e.owner_uuid,e.version FROM periodical_entries e JOIN paths p ON p.object_uuid=e.page_uuid AND p.domain_uuid=e.domain_uuid JOIN objects o ON o.uuid=e.page_uuid AND o.kind='page' WHERE e.domain_uuid=`+s.sqlParam(1)+` AND e.kind=`+s.sqlParam(2)+` ORDER BY e.local_date DESC,e.page_uuid,p.path LIMIT 5001`, domain, kind)
if err != nil {
return nil, err
}
defer rows.Close()
out := []PeriodicalEntry{}
bytes := 0
for rows.Next() {
var e PeriodicalEntry
if err = rows.Scan(&e.PageUUID, &e.Path, &e.Title, &e.Date, &e.Category, &e.Timezone, &e.Owner, &e.Version); err != nil {
return nil, err
}
out = append(out, e)
bytes += len(e.Path) + len(e.Title) + len(e.Category) + len(e.Timezone) + len(e.Owner) + len(e.PageUUID) + len(e.Date)
if len(out) > 5000 || bytes > 4<<20 {
return nil, ErrNavigationBudget
}
}
return out, rows.Err()
}