Files
pages/internal/store/city_governance.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

329 lines
15 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"strings"
"time"
"pageswiki/internal/schutzaria"
)
var (
ErrGovernanceConflict = errors.New("city.governance.conflict")
ErrGovernanceInvalid = errors.New("city.governance.invalid")
ErrGovernanceCeiling = errors.New("city.governance.ceiling_error")
ErrGovernanceConfirm = errors.New("city.governance.confirm_error")
)
type LocalityPolicy = schutzaria.LocalityPolicy
type LocalityOwner struct {
MembershipUUID string `json:"membership_uuid"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
Active bool `json:"active"`
}
type CityGovernance struct {
PublicationVersion int64 `json:"publication_version"`
Kind string `json:"kind"`
UUID string `json:"uuid"`
Epoch int64 `json:"epoch"`
TopologyVersion int64 `json:"topology_version"`
Policy string `json:"policy"`
Chain []LocalityPolicy `json:"chain"`
Owners []LocalityOwner `json:"owners"`
CanAppoint bool `json:"can_appoint"`
SuperiorAllowsPublic bool `json:"superior_allows_public"`
DraftEffectivePublic bool `json:"draft_effective_public"`
PublicationEnabled bool `json:"publication_enabled"` // This node's separately approved manifest only.
ImpactComplete bool `json:"impact_complete"` // This endpoint does not enumerate Page impact; use /publication.
}
type CityGovernanceChange struct {
Epoch int64 `json:"epoch"`
TopologyVersion int64 `json:"topology_version"`
Policy *string `json:"policy,omitempty"`
Owners *[]string `json:"owners,omitempty"`
ConfirmRelaxation bool `json:"confirm_relaxation"`
}
func (s *Store) ensureCityGovernanceSchema() error {
for _, query := range []string{
`CREATE TABLE IF NOT EXISTS city_governance_epochs(domain_uuid TEXT PRIMARY KEY,version INTEGER NOT NULL DEFAULT 0)`,
`CREATE TABLE IF NOT EXISTS locality_publication_policies(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL CHECK(node_kind IN ('domain','quartier','street','spot')),node_uuid TEXT NOT NULL,policy TEXT NOT NULL CHECK(policy IN ('inherit','public','authenticated_acl')),actor_uuid TEXT NOT NULL,updated_at_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid))`,
`CREATE TABLE IF NOT EXISTS city_owner_bindings(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL CHECK(node_kind IN ('quartier','spot')),node_uuid TEXT NOT NULL,membership_uuid TEXT NOT NULL,actor_uuid TEXT NOT NULL,created_at_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid,membership_uuid))`,
`CREATE INDEX IF NOT EXISTS idx_city_owner_member ON city_owner_bindings(domain_uuid,membership_uuid,node_kind,node_uuid)`,
`CREATE TABLE IF NOT EXISTS city_governance_events(id INTEGER PRIMARY KEY AUTOINCREMENT,domain_uuid TEXT NOT NULL,epoch INTEGER NOT NULL,actor_uuid TEXT NOT NULL,node_kind TEXT NOT NULL,node_uuid TEXT NOT NULL,before_json TEXT NOT NULL,after_json TEXT NOT NULL,created_at_ms INTEGER NOT NULL)`,
`CREATE INDEX IF NOT EXISTS idx_city_governance_events ON city_governance_events(domain_uuid,epoch)`,
} {
if _, err := s.DB.Exec(query); err != nil {
return err
}
}
return s.ensurePublicationSchema()
}
// EvaluateLocalityPublication combines ceilings with intent. A public Domain
// merely allows publication: it never publishes its root or arbitrary Pages.
func EvaluateLocalityPublication(chain []LocalityPolicy) (allows, published bool) {
return schutzaria.EvaluateLocalityPublication(chain)
}
// All authority, parentage and policy reads use this one snapshot. Mutation
// callers acquire SQLite's write reservation before entering this function.
func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id string) (g CityGovernance, err error) {
g = CityGovernance{Kind: kind, UUID: id, Owners: []LocalityOwner{}}
var membership string
err = tx.QueryRowContext(ctx, `SELECT m.uuid FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' JOIN domains d ON d.uuid=m.domain_uuid AND d.enabled=1 WHERE m.domain_uuid=? AND m.principal_uuid=? AND m.state='active'`, domain, actor).Scan(&membership)
if err == sql.ErrNoRows {
return g, ErrAccessDenied
}
if err != nil {
return g, err
}
var admin bool
err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid WHERE g.domain_uuid=? AND g.builtin_key='domain_admin' AND g.state='active' AND gm.membership_uuid=? AND gm.member_role IN ('owner','manager'))`, domain, membership).Scan(&admin)
if err != nil {
return g, err
}
var q, street, parent, nodePath, streetPath, quartierPath string
switch kind {
case "domain":
if id != domain {
return g, sql.ErrNoRows
}
case "quartier", "street":
err = tx.QueryRowContext(ctx, `SELECT COALESCE(parent_uuid,''),path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND kind=? AND state!='archived'`, id, domain, kind).Scan(&parent, &nodePath)
if kind == "quartier" {
q = id
if parent != "" {
return g, ErrGovernanceInvalid
}
} else {
q = parent
street = id
streetPath = nodePath
}
case "spot":
err = tx.QueryRowContext(ctx, `SELECT st.uuid,st.parent_uuid,s.path_prefix,st.path_prefix FROM spots s JOIN street_spots ss ON ss.spot_uuid=s.uuid JOIN zones st ON st.uuid=ss.street_uuid AND st.domain_uuid=s.domain_uuid AND st.kind='street' AND st.state!='archived' WHERE s.uuid=? AND s.domain_uuid=? AND s.state!='archived'`, id, domain).Scan(&street, &q, &nodePath, &streetPath)
default:
return g, ErrGovernanceInvalid
}
if err != nil {
return g, err
}
if q != "" {
if err = tx.QueryRowContext(ctx, `SELECT path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND kind='quartier' AND state!='archived' AND COALESCE(parent_uuid,'')=''`, q, domain).Scan(&quartierPath); err != nil {
return g, err
}
}
if kind != "domain" && (q == "" || quartierPath == "" || nodePath == "" || (street != "" && (streetPath == "" || !cityPathContains(quartierPath, streetPath))) || (kind == "spot" && !cityPathContains(streetPath, nodePath))) {
return g, ErrGovernanceInvalid
}
var qOwner, own bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM city_owner_bindings WHERE domain_uuid=? AND node_kind='quartier' AND node_uuid=? AND membership_uuid=?), EXISTS(SELECT 1 FROM city_owner_bindings WHERE domain_uuid=? AND node_kind=? AND node_uuid=? AND membership_uuid=?)`, domain, q, membership, domain, kind, id, membership).Scan(&qOwner, &own); err != nil {
return g, err
}
if !admin && !qOwner && !(kind == "spot" && own) {
return g, ErrAccessDenied
}
g.CanAppoint = (kind == "quartier" && admin) || (kind == "spot" && (admin || qOwner))
g.Chain = []LocalityPolicy{{Kind: "domain", UUID: domain, Policy: "authenticated_acl"}}
if q != "" {
g.Chain = append(g.Chain, LocalityPolicy{Kind: "quartier", UUID: q, Policy: "inherit"})
}
if street != "" {
g.Chain = append(g.Chain, LocalityPolicy{Kind: "street", UUID: street, Policy: "inherit"})
}
if kind == "spot" {
g.Chain = append(g.Chain, LocalityPolicy{Kind: "spot", UUID: id, Policy: "inherit"})
}
for i := range g.Chain {
p := &g.Chain[i]
err = tx.QueryRowContext(ctx, `SELECT policy FROM locality_publication_policies WHERE domain_uuid=? AND node_kind=? AND node_uuid=?`, domain, p.Kind, p.UUID).Scan(&p.Policy)
if err != nil && err != sql.ErrNoRows {
return g, err
}
if p.Policy != "public" && p.Policy != "authenticated_acl" && p.Policy != "inherit" || p.Kind == "domain" && p.Policy == "inherit" {
return g, ErrGovernanceInvalid
}
}
g.Policy = g.Chain[len(g.Chain)-1].Policy
g.SuperiorAllowsPublic, _ = EvaluateLocalityPublication(g.Chain[:len(g.Chain)-1])
_, g.DraftEffectivePublic = EvaluateLocalityPublication(g.Chain)
if err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT version FROM city_governance_epochs WHERE domain_uuid=?),0),COALESCE((SELECT version FROM domain_topology_versions WHERE domain_uuid=?),1)`, domain, domain).Scan(&g.Epoch, &g.TopologyVersion); err != nil {
return g, err
}
if err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT version FROM locality_publication_versions WHERE domain_uuid=? AND node_kind=? AND node_uuid=?),0)`, domain, kind, id).Scan(&g.PublicationVersion); err != nil {
return g, err
}
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(&g.PublicationEnabled); err != nil {
return g, err
}
rows, err := tx.QueryContext(ctx, `SELECT m.uuid,COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' LIMIT 1),p.uuid),p.display_name,(p.state='active' AND m.state='active') FROM city_owner_bindings b JOIN domain_memberships m ON m.uuid=b.membership_uuid AND m.domain_uuid=b.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE b.domain_uuid=? AND b.node_kind=? AND b.node_uuid=? ORDER BY m.uuid LIMIT 33`, domain, kind, id)
if err != nil {
return g, err
}
defer rows.Close()
for rows.Next() {
var o LocalityOwner
if err = rows.Scan(&o.MembershipUUID, &o.Username, &o.DisplayName, &o.Active); err != nil {
return g, err
}
g.Owners = append(g.Owners, o)
}
if len(g.Owners) > 32 {
return g, ErrGovernanceInvalid
}
return g, rows.Err()
}
func (s *Store) CityGovernance(ctx context.Context, domain, actor, kind, id string) (CityGovernance, error) {
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
if err != nil {
return CityGovernance{}, err
}
defer tx.Rollback()
return governanceSnapshot(ctx, tx, domain, actor, kind, id)
}
// Candidate lookup exposes only active local display identities, never emails,
// credentials or foreign memberships. It is scoped to appointment authority.
func (s *Store) CityGovernanceMembers(ctx context.Context, domain, actor, kind, id, search string) ([]LocalityOwner, error) {
if len(search) > 80 {
return nil, ErrGovernanceInvalid
}
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
if err != nil {
return nil, err
}
defer tx.Rollback()
g, err := governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return nil, err
}
if !g.CanAppoint {
return nil, ErrAccessDenied
}
rows, err := tx.QueryContext(ctx, `SELECT m.uuid,COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' LIMIT 1),p.uuid) username,p.display_name FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' WHERE m.domain_uuid=? AND m.state='active' AND (?='' OR instr(lower(p.display_name),?)>0 OR EXISTS(SELECT 1 FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' AND instr(lower(i.subject),?)>0)) ORDER BY p.display_name,m.uuid LIMIT 30`, domain, search, strings.ToLower(search), strings.ToLower(search))
if err != nil {
return nil, err
}
defer rows.Close()
result := []LocalityOwner{}
for rows.Next() {
o := LocalityOwner{Active: true}
if err = rows.Scan(&o.MembershipUUID, &o.Username, &o.DisplayName); err != nil {
return nil, err
}
result = append(result, o)
}
return result, rows.Err()
}
func (s *Store) ChangeCityGovernance(ctx context.Context, domain, actor, kind, id string, change CityGovernanceChange, preview bool) (CityGovernance, error) {
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return CityGovernance{}, err
}
defer tx.Rollback()
// Reserve the writer before authority reads: revocation cannot commit
// between validation and mutation. Preview rolls back this short reservation.
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 CityGovernance{}, err
}
g, err := governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return g, err
}
if change.Epoch != g.Epoch || change.TopologyVersion != g.TopologyVersion {
return g, ErrGovernanceConflict
}
before, _ := json.Marshal(g)
if change.Policy == nil && change.Owners == nil {
return g, ErrGovernanceInvalid
}
if change.Policy != nil {
p := *change.Policy
if p != "inherit" && p != "public" && p != "authenticated_acl" || (kind == "domain" && p == "inherit") {
return g, ErrGovernanceInvalid
}
if p == "public" && !g.SuperiorAllowsPublic {
return g, ErrGovernanceCeiling
}
if p != g.Policy && (p == "public" || g.Policy == "authenticated_acl") && !change.ConfirmRelaxation && !preview {
return g, ErrGovernanceConfirm
}
g.Policy = p
g.Chain[len(g.Chain)-1].Policy = p
_, g.DraftEffectivePublic = EvaluateLocalityPublication(g.Chain)
}
if change.Owners != nil {
if !g.CanAppoint {
return g, ErrAccessDenied
}
if len(*change.Owners) > 32 {
return g, ErrGovernanceInvalid
}
seen := map[string]bool{}
proposed := []LocalityOwner{}
for _, member := range *change.Owners {
if seen[member] {
return g, ErrGovernanceInvalid
}
seen[member] = true
o := LocalityOwner{MembershipUUID: member, Active: true}
err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' LIMIT 1),p.uuid),p.display_name FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' WHERE m.uuid=? AND m.domain_uuid=? AND m.state='active'`, member, domain).Scan(&o.Username, &o.DisplayName)
if err == sql.ErrNoRows {
return g, ErrGovernanceInvalid
}
if err != nil {
return g, err
}
proposed = append(proposed, o)
}
g.Owners = proposed
}
if preview {
return g, nil
}
now := time.Now().UnixMilli()
if change.Policy != nil {
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_publication_policies(domain_uuid,node_kind,node_uuid,policy,actor_uuid,updated_at_ms) VALUES(?,?,?,?,?,?) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET policy=excluded.policy,actor_uuid=excluded.actor_uuid,updated_at_ms=excluded.updated_at_ms`, domain, kind, id, g.Policy, actor, now); err != nil {
return g, err
}
}
if change.Owners != nil {
if _, err = tx.ExecContext(ctx, `DELETE FROM city_owner_bindings WHERE domain_uuid=? AND node_kind=? AND node_uuid=?`, domain, kind, id); err != nil {
return g, err
}
for _, member := range *change.Owners {
if _, err = tx.ExecContext(ctx, `INSERT INTO city_owner_bindings VALUES(?,?,?,?,?,?)`, domain, kind, id, member, actor, now); err != nil {
return g, err
}
}
}
if _, err = tx.ExecContext(ctx, `UPDATE city_governance_epochs SET version=version+1 WHERE domain_uuid=?`, domain); err != nil {
return g, err
}
g, err = governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return g, err
}
after, _ := json.Marshal(g)
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), now); err != nil {
return g, err
}
return g, tx.Commit()
}