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 { 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) (bool, error) { var enabled bool err := s.DB.QueryRowContext(ctx, `SELECT enabled FROM periodical_settings WHERE domain_uuid=? AND kind=?`, 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) (string, error) { if !PeriodicalKind(kind) { return "", ErrPeriodicalInvalid } var prefix string err := s.DB.QueryRowContext(ctx, `SELECT prefix FROM periodical_prefixes WHERE domain_uuid=? AND kind=?`, 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) error { 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() // Reserve writer before all authorization, configuration and binding checks. if _, err = tx.ExecContext(ctx, `INSERT INTO periodical_settings(domain_uuid,kind) VALUES(?,?) ON CONFLICT(domain_uuid,kind) DO UPDATE SET enabled=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=? AND p.state='active' AND m.domain_uuid=? AND m.state='active')`, actor, domain).Scan(&active) if err != nil { return err } if !active { return ErrAccessDenied } 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=? AND g.builtin_key='domain_admin' AND g.state='active' AND gm.member_role IN ('owner','manager') AND m.principal_uuid=? 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=?)`, 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=? WHERE domain_uuid=? AND kind=?`, *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(?,?,?) 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=? AND kind=?)`, 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=? AND kind=?`, 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=? 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=? AND kind=?`, 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=? AND p.path=?`, 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 := authorizeGrantFrom(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=? AND provider_type='password' AND (?='/u/'||subject OR substr(?,1,length('/u/'||subject||'/'))='/u/'||subject||'/'))`, actor, e.Path, e.Path).Scan(&own); err != nil { return err } if own { basis = nil } } caps, err := 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=? AND kind=? AND actor_uuid=? AND request_id=?`, 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=? WHERE p.domain_uuid=? AND p.path=? AND p.object_uuid=?)`, 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=? AND path=?)`, domain, e.Path).Scan(&exists); err != nil { return err } if exists { return ErrPeriodicalConflict } pageUUID = uuid.NewString() if _, err = tx.ExecContext(ctx, `INSERT INTO objects(uuid,kind,created_at) VALUES(?,'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(?,?,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(?,?,?,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(?,?,?,?,?,?)`, 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=? AND kind=? AND page_uuid=?`, 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=? AND kind=? AND page_uuid=?`, 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=? AND kind=? AND page_uuid=?`, 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(?,?,?,?,?,?,?,?,?) 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(?,?,?,?,?,?,?)`, 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) ([]PeriodicalEntry, error) { 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=? AND e.kind=? 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() }