Files
pages/internal/store/locality_publication.go
T
Anya Tokugawa d5d21b7841
Build and publish container images / images (push) Successful in 9m34s
Release container images / release (push) Successful in 36s
Refactor architecture into eight components and consolidate reliability work
Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts.

Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation.

Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
2026-11-01 15:23:31 +09:00

370 lines
18 KiB
Go

package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"sort"
"strings"
"time"
"pageswiki/internal/schutzaria"
)
var ErrPublicationImpact = errors.New("city.publication.impact_error")
// Publication is an explicit, bounded approval of current immutable content,
// not a permission to publish future revisions or newly created descendants.
type PublicationEntry struct {
Path string `json:"path"`
Object string `json:"object_uuid"`
Revision string `json:"revision_uuid"`
Hash string `json:"sha256"`
Language string `json:"lang"`
}
type LocalityPublication struct {
PublicationVersion int64 `json:"publication_version"`
Epoch int64 `json:"epoch"`
TopologyVersion int64 `json:"topology_version"`
Enabled bool `json:"enabled"`
Eligible bool `json:"eligible"`
ImpactToken string `json:"impact_token"`
Entries []PublicationEntry `json:"entries"`
Excluded []string `json:"excluded"`
}
type PublicationChange struct {
PublicationVersion int64 `json:"publication_version"`
Epoch int64 `json:"epoch"`
TopologyVersion int64 `json:"topology_version"`
ImpactToken string `json:"impact_token"`
Enabled bool `json:"enabled"`
Confirm bool `json:"confirm"`
}
func (s *Store) ensurePublicationSchema() error {
for _, query := range []string{
`CREATE TABLE IF NOT EXISTS locality_publication_versions(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL,node_uuid TEXT NOT NULL,version INTEGER NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid))`,
`CREATE TABLE IF NOT EXISTS locality_publication_manifests(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL,node_uuid TEXT NOT NULL,epoch INTEGER NOT NULL,topology_version INTEGER NOT NULL,actor_uuid TEXT NOT NULL,created_at_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid))`,
`CREATE TABLE IF NOT EXISTS locality_publication_entries(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL,node_uuid TEXT NOT NULL,path TEXT NOT NULL,object_uuid TEXT NOT NULL,revision_uuid TEXT NOT NULL,document_hash TEXT NOT NULL,lang TEXT NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid,path,lang))`,
`CREATE INDEX IF NOT EXISTS idx_publication_path ON locality_publication_entries(domain_uuid,path)`,
`CREATE INDEX IF NOT EXISTS idx_publication_object ON locality_publication_entries(object_uuid,lang)`,
`CREATE INDEX IF NOT EXISTS idx_publication_revision ON locality_publication_entries(revision_uuid)`,
`CREATE TABLE IF NOT EXISTS locality_auto_publication(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL,node_uuid TEXT NOT NULL,mode TEXT NOT NULL CHECK(mode IN ('inherit','required','automatic')),scope_path TEXT NOT NULL,actor_uuid TEXT NOT NULL,version INTEGER NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid))`,
} {
if _, err := s.DB.Exec(query); err != nil {
return err
}
}
return s.ensureNavigationSchema()
}
func installPublicationGuards(ctx context.Context, tx *sql.Tx) error {
statements := []string{
`CREATE TRIGGER IF NOT EXISTS auto_publication_config_update BEFORE UPDATE ON config WHEN OLD.key='authorization_mode' AND (NEW.key!=OLD.key OR NEW.domain_uuid!=OLD.domain_uuid OR NEW.value!='enforcing') AND EXISTS(SELECT 1 FROM locality_auto_publication WHERE domain_uuid=OLD.domain_uuid AND mode='automatic') BEGIN SELECT RAISE(ABORT,'publication_requires_enforcing'); END`,
`CREATE TRIGGER IF NOT EXISTS auto_publication_config_delete BEFORE DELETE ON config WHEN OLD.key='authorization_mode' AND EXISTS(SELECT 1 FROM locality_auto_publication WHERE domain_uuid=OLD.domain_uuid AND mode='automatic') BEGIN SELECT RAISE(ABORT,'publication_requires_enforcing'); END`,
`CREATE TRIGGER IF NOT EXISTS auto_publication_config_insert BEFORE INSERT ON config WHEN NEW.key='authorization_mode' AND NEW.value!='enforcing' AND EXISTS(SELECT 1 FROM locality_auto_publication WHERE domain_uuid=NEW.domain_uuid AND mode='automatic') BEGIN SELECT RAISE(ABORT,'publication_requires_enforcing'); END`,
`CREATE TRIGGER IF NOT EXISTS publication_revision_insert AFTER INSERT ON revisions BEGIN DELETE FROM locality_publication_entries WHERE object_uuid=NEW.object_uuid AND lang=COALESCE(NULLIF(NEW.lang,''),'und'); END`,
`CREATE TRIGGER IF NOT EXISTS publication_revision_update AFTER UPDATE ON revisions BEGIN DELETE FROM locality_publication_entries WHERE revision_uuid=OLD.uuid; END`,
`CREATE TRIGGER IF NOT EXISTS publication_revision_delete AFTER DELETE ON revisions BEGIN DELETE FROM locality_publication_entries WHERE revision_uuid=OLD.uuid; END`,
`CREATE TRIGGER IF NOT EXISTS publication_path_insert AFTER INSERT ON paths BEGIN DELETE FROM locality_publication_entries WHERE object_uuid=NEW.object_uuid; END`,
`CREATE TRIGGER IF NOT EXISTS publication_path_delete AFTER DELETE ON paths BEGIN DELETE FROM locality_publication_entries WHERE object_uuid=OLD.object_uuid; END`,
`CREATE TRIGGER IF NOT EXISTS publication_path_update AFTER UPDATE ON paths BEGIN DELETE FROM locality_publication_entries WHERE object_uuid IN (OLD.object_uuid,NEW.object_uuid); END`,
`CREATE TRIGGER IF NOT EXISTS publication_config_update BEFORE UPDATE ON config WHEN OLD.key='authorization_mode' AND (NEW.key!=OLD.key OR NEW.domain_uuid!=OLD.domain_uuid OR NEW.value!='enforcing') AND EXISTS(SELECT 1 FROM locality_publication_manifests WHERE domain_uuid=OLD.domain_uuid) BEGIN SELECT RAISE(ABORT,'publication_requires_enforcing'); END`,
`CREATE TRIGGER IF NOT EXISTS publication_config_delete BEFORE DELETE ON config WHEN OLD.key='authorization_mode' AND EXISTS(SELECT 1 FROM locality_publication_manifests WHERE domain_uuid=OLD.domain_uuid) BEGIN SELECT RAISE(ABORT,'publication_requires_enforcing'); END`,
`CREATE TRIGGER IF NOT EXISTS publication_config_insert BEFORE INSERT ON config WHEN NEW.key='authorization_mode' AND NEW.value!='enforcing' AND EXISTS(SELECT 1 FROM locality_publication_manifests WHERE domain_uuid=NEW.domain_uuid) BEGIN SELECT RAISE(ABORT,'publication_requires_enforcing'); END`,
}
for _, table := range []string{"zones", "spots"} {
for _, op := range []string{"INSERT", "UPDATE", "DELETE"} {
ref := "OLD"
if op == "INSERT" {
ref = "NEW"
}
statements = append(statements, `CREATE TRIGGER IF NOT EXISTS publication_`+table+`_`+strings.ToLower(op)+` AFTER `+op+` ON `+table+` BEGIN DELETE FROM locality_publication_manifests WHERE domain_uuid=`+ref+`.domain_uuid; DELETE FROM locality_publication_entries WHERE domain_uuid=`+ref+`.domain_uuid; END`)
}
}
for _, op := range []string{"INSERT", "UPDATE", "DELETE"} {
ref := "OLD"
if op == "INSERT" {
ref = "NEW"
}
statements = append(statements, `CREATE TRIGGER IF NOT EXISTS publication_street_spots_`+strings.ToLower(op)+` AFTER `+op+` ON street_spots BEGIN DELETE FROM locality_publication_manifests WHERE domain_uuid=(SELECT domain_uuid FROM spots WHERE uuid=`+ref+`.spot_uuid); DELETE FROM locality_publication_entries WHERE domain_uuid=(SELECT domain_uuid FROM spots WHERE uuid=`+ref+`.spot_uuid); END`)
}
for _, q := range statements {
if _, err := tx.ExecContext(ctx, q); err != nil {
return err
}
}
return nil
}
func publicationImpact(ctx context.Context, tx *sql.Tx, domain, actor, kind, id string, g CityGovernance) (LocalityPublication, error) {
return publicationImpactBounded(ctx, tx, domain, actor, kind, id, g, 512, "")
}
func publicationImpactBounded(ctx context.Context, tx *sql.Tx, domain, actor, kind, id string, g CityGovernance, limit int, onlyPath string) (LocalityPublication, error) {
p := LocalityPublication{PublicationVersion: g.PublicationVersion, Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Entries: []PublicationEntry{}, Excluded: []string{}}
var mode string
if err := tx.QueryRowContext(ctx, `SELECT value FROM config WHERE domain_uuid=? AND key='authorization_mode'`, domain).Scan(&mode); err != nil {
return p, err
}
if mode != "enforcing" {
return p, ErrAccessDenied
}
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM locality_publication_manifests m WHERE domain_uuid=? AND node_kind=? AND node_uuid=? AND epoch=? AND topology_version=? AND EXISTS(SELECT 1 FROM locality_publication_entries e WHERE e.domain_uuid=m.domain_uuid AND e.node_kind=m.node_kind AND e.node_uuid=m.node_uuid))`, domain, kind, id, g.Epoch, g.TopologyVersion).Scan(&p.Enabled); err != nil {
return p, err
}
// A Domain ceiling is never a publication grant.
if kind == "domain" || !g.DraftEffectivePublic {
return p, nil
}
scope := ""
table := "zones"
if kind == "spot" {
table = "spots"
}
if err := tx.QueryRowContext(ctx, `SELECT path_prefix FROM `+table+` WHERE domain_uuid=? AND uuid=?`, domain, id).Scan(&scope); err != nil {
return p, err
}
policy, err := loadReadPathPolicy(cityReadQuery{ctx, tx}, domain, actor)
if err != nil {
return p, err
}
// Literal segment predicates: '%' and '_' are valid names, never wildcards.
rows, err := tx.QueryContext(ctx, `SELECT p.path,p.object_uuid,
(EXISTS(SELECT 1 FROM locality_access_policies a WHERE a.domain_uuid=p.domain_uuid AND `+cityPathScopeSQL("a.scope_path", "p.path")+`)
OR EXISTS(SELECT 1 FROM locality_publication_policies a JOIN zones z ON z.uuid=a.node_uuid AND z.domain_uuid=a.domain_uuid AND z.state!='archived' WHERE a.domain_uuid=p.domain_uuid AND a.node_kind IN ('quartier','street') AND a.policy='authenticated_acl' AND `+cityPathScopeSQL("z.path_prefix", "p.path")+`)
OR EXISTS(SELECT 1 FROM locality_publication_policies a JOIN spots z ON z.uuid=a.node_uuid AND z.domain_uuid=a.domain_uuid AND z.state!='archived' WHERE a.domain_uuid=p.domain_uuid AND a.node_kind='spot' AND a.policy='authenticated_acl' AND `+cityPathScopeSQL("z.path_prefix", "p.path")+`)
OR EXISTS(SELECT 1 FROM paths other WHERE other.object_uuid=p.object_uuid AND (other.domain_uuid!=p.domain_uuid OR other.path!=p.path)))
FROM paths p CROSS JOIN (SELECT ? AS scope) input WHERE p.domain_uuid=? AND `+cityPathScopeSQL("input.scope", "p.path")+` AND (?='' OR p.path=?) ORDER BY p.path LIMIT ?`, scope, domain, onlyPath, onlyPath, limit+1)
if err != nil {
return p, err
}
type candidate struct {
path, object string
excluded bool
}
candidates := []candidate{}
for rows.Next() {
var c candidate
if err = rows.Scan(&c.path, &c.object, &c.excluded); err != nil {
break
}
candidates = append(candidates, c)
}
if err == nil {
err = rows.Err()
}
rows.Close()
if err != nil {
return p, err
}
if len(candidates) > limit {
return p, ErrPublicationImpact
}
objects := map[string]string{}
args := []any{}
for _, c := range candidates {
if !policy.Allows(c.path) {
return p, ErrAccessDenied
}
if c.excluded || !PublicSemanticPath(c.path) {
p.Excluded = append(p.Excluded, c.path)
continue
}
objects[c.object] = c.path
args = append(args, c.object)
}
if len(args) > 0 {
// Read all scoped language heads in one metadata-only window query,
// rather than repeating an authorization/head query for every Page.
marks := strings.TrimSuffix(strings.Repeat("?,", len(args)), ",")
rows, err = tx.QueryContext(ctx, `SELECT object_uuid,uuid,document_hash,lang FROM (
SELECT object_uuid,uuid,COALESCE(document_hash,'') AS document_hash,COALESCE(NULLIF(lang,''),'und') AS lang,
ROW_NUMBER() OVER(PARTITION BY object_uuid,COALESCE(NULLIF(lang,''),'und') ORDER BY created_at_ms DESC,rowid DESC) AS head
FROM revisions WHERE object_uuid IN (`+marks+`)) WHERE head=1 ORDER BY object_uuid,lang LIMIT `+fmt.Sprint(limit*4+1), args...)
if err != nil {
return p, err
}
counts := map[string]int{}
for rows.Next() {
var e PublicationEntry
if err = rows.Scan(&e.Object, &e.Revision, &e.Hash, &e.Language); err != nil {
break
}
e.Path = objects[e.Object]
counts[e.Object]++
if len(e.Hash) != 64 || counts[e.Object] > 32 || len(p.Entries) >= limit*4 {
err = ErrPublicationImpact
break
}
p.Entries = append(p.Entries, e)
}
if err == nil {
err = rows.Err()
}
rows.Close()
if err != nil {
return p, err
}
}
sort.Slice(p.Entries, func(i, j int) bool {
a, b := p.Entries[i], p.Entries[j]
if a.Path != b.Path {
return a.Path < b.Path
}
return a.Language < b.Language
})
p.Eligible = len(p.Entries) > 0
if limit != 512 {
return p, nil
}
// Include actor/domain/node identity to make approvals non-transferable.
b, _ := json.Marshal(struct {
Domain, Actor, Kind, ID string
Epoch, Topology int64
PublicationVersion int64
Entries []PublicationEntry
Excluded []string
}{domain, actor, kind, id, g.Epoch, g.TopologyVersion, g.PublicationVersion, p.Entries, p.Excluded})
hash := sha256.Sum256(b)
p.ImpactToken = hex.EncodeToString(hash[:])
return p, nil
}
func (s *Store) LocalityPublication(ctx context.Context, domain, actor, kind, id string, change *PublicationChange) (LocalityPublication, error) {
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return LocalityPublication{}, err
}
defer tx.Rollback()
if change != nil {
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs(domain_uuid,version) VALUES(?,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=version`, domain); err != nil {
return LocalityPublication{}, err
}
}
g, err := governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return LocalityPublication{}, err
}
if change != nil && (change.Epoch != g.Epoch || change.TopologyVersion != g.TopologyVersion || change.PublicationVersion != g.PublicationVersion) {
return LocalityPublication{}, ErrGovernanceConflict
}
// Revocation must work even when content is now unreadable or over budget.
p := LocalityPublication{PublicationVersion: g.PublicationVersion, Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Entries: []PublicationEntry{}, Excluded: []string{}}
if change == nil || change.Enabled {
p, err = publicationImpact(ctx, tx, domain, actor, kind, id, g)
if err != nil {
return p, err
}
}
if change == nil {
return p, nil
}
if change.Enabled && (!change.Confirm || !p.Eligible || change.ImpactToken == "" || change.ImpactToken != p.ImpactToken) {
return p, ErrPublicationImpact
}
var old bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM locality_publication_manifests WHERE domain_uuid=? AND node_kind=? AND node_uuid=?)`, domain, kind, id).Scan(&old); err != nil {
return p, err
}
for _, table := range []string{"locality_publication_entries", "locality_publication_manifests"} {
if _, err = tx.ExecContext(ctx, `DELETE FROM `+table+` WHERE domain_uuid=? AND node_kind=? AND node_uuid=?`, domain, kind, id); err != nil {
return p, err
}
}
if change.Enabled {
if err = installPublicationGuards(ctx, tx); err != nil {
return p, err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_publication_manifests VALUES(?,?,?,?,?,?,?)`, domain, kind, id, g.Epoch, g.TopologyVersion, actor, time.Now().UnixMilli()); err != nil {
return p, err
}
for _, e := range p.Entries {
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_publication_entries VALUES(?,?,?,?,?,?,?,?)`, domain, kind, id, e.Path, e.Object, e.Revision, e.Hash, e.Language); err != nil {
return p, err
}
}
}
if !change.Enabled {
if err = requireManualPublication(ctx, tx, domain, actor, kind, id); err != nil {
return p, err
}
}
p.Enabled = change.Enabled
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_publication_versions VALUES(?,?,?,1) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET version=version+1`, domain, kind, id); err != nil {
return p, err
}
p.PublicationVersion++
after, _ := json.Marshal(map[string]any{"publication": change.Enabled, "impact_token": p.ImpactToken, "entries": len(p.Entries)})
before, _ := json.Marshal(map[string]bool{"publication": old})
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_events(domain_uuid,epoch,actor_uuid,node_kind,node_uuid,before_json,after_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, domain, g.Epoch, actor, kind, id, string(before), string(after), time.Now().UnixMilli()); err != nil {
return p, err
}
// Reconfirmation needs a fresh impact token, even if content is unchanged.
p.Eligible = false
p.ImpactToken = ""
return p, tx.Commit()
}
// Explicitly exclude every application/user/group/editor namespace. Public
// projections must never turn an arbitrary reserved handler into a document.
func PublicSemanticPath(path string) bool {
return schutzaria.PublicSemanticPath(path)
}
// Lookup is metadata-only and Path-indexed. The manifest is fenced by current
// governance/topology epochs, live binding, and the current language head.
func (s *Store) AnonymousRevision(ctx context.Context, domain, path string, languages []string) (*Revision, error) {
if !PublicSemanticPath(path) {
return nil, sql.ErrNoRows
}
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
rows, err := s.DB.QueryContext(ctx, `SELECT DISTINCT r.uuid,r.object_uuid,r.document_hash,COALESCE(NULLIF(r.lang,''),'und'),COALESCE(NULLIF(r.content_type,''),'text/html; charset=utf-8'),COALESCE(r.filename,''),r.created_at_ms
`+anonymousRevisionFromSQL+` AND e.path=?
ORDER BY r.created_at_ms DESC,r.uuid LIMIT 33`, domain, path)
if err != nil {
return nil, err
}
items := []*Revision{}
for rows.Next() {
v := &Revision{}
if err = rows.Scan(&v.UUID, &v.ObjectUUID, &v.DocumentHash, &v.Language, &v.ContentType, &v.Filename, &v.CreatedAtMS); err != nil {
rows.Close()
return nil, err
}
items = append(items, v)
}
if err = rows.Err(); err != nil {
rows.Close()
return nil, err
}
rows.Close()
if len(items) == 0 {
pages, e := s.automaticPublicPages(ctx, domain, path)
if e != nil {
return nil, e
}
for i := range pages {
items = append(items, &pages[i].Revision)
}
}
if len(items) == 0 || len(items) > 32 {
return nil, sql.ErrNoRows
}
for _, lang := range languages {
for _, v := range items {
if v.Language == lang {
return v, nil
}
}
}
return items[0], nil
}