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

343 lines
17 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) {
return (&Store{}).governanceSnapshot(ctx, tx, domain, actor, kind, id)
}
func (s *Store) 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=`+s.sqlParam(1)+` AND m.principal_uuid=`+s.sqlParam(2)+` 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=`+s.sqlParam(1)+` AND g.builtin_key='domain_admin' AND g.state='active' AND gm.membership_uuid=`+s.sqlParam(2)+` 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=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND kind=`+s.sqlParam(3)+` 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=`+s.sqlParam(1)+` AND s.domain_uuid=`+s.sqlParam(2)+` 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=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` 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=`+s.sqlParam(1)+` AND node_kind='quartier' AND node_uuid=`+s.sqlParam(2)+` AND membership_uuid=`+s.sqlParam(3)+`), EXISTS(SELECT 1 FROM city_owner_bindings WHERE domain_uuid=`+s.sqlParam(4)+` AND node_kind=`+s.sqlParam(5)+` AND node_uuid=`+s.sqlParam(6)+` AND membership_uuid=`+s.sqlParam(7)+`)`, 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=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+``, 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=`+s.sqlParam(1)+`),0),COALESCE((SELECT version FROM domain_topology_versions WHERE domain_uuid=`+s.sqlParam(2)+`),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=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+`),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=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+` AND epoch=`+s.sqlParam(4)+` AND topology_version=`+s.sqlParam(5)+` 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' ORDER BY subject,uuid 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=`+s.sqlParam(1)+` AND b.node_kind=`+s.sqlParam(2)+` AND b.node_uuid=`+s.sqlParam(3)+` 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) (result CityGovernance, resultErr error) {
defer func() { resultErr = s.sqlError("City governance read", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return CityGovernance{}, err
}
defer tx.Rollback()
return s.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) (returned []LocalityOwner, resultErr error) {
defer func() { resultErr = s.sqlError("City governance candidates", resultErr) }()
if len(search) > 80 {
return nil, ErrGovernanceInvalid
}
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return nil, err
}
defer tx.Rollback()
g, err := s.governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return nil, err
}
if !g.CanAppoint {
return nil, ErrAccessDenied
}
contains := "instr"
if s.sqlBackend == storePostgreSQL {
contains = "strpos"
}
rows, err := tx.QueryContext(ctx, `SELECT m.uuid,COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' ORDER BY subject,uuid 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=`+s.sqlParam(1)+` AND m.state='active' AND (`+s.sqlParam(2)+`='' OR `+contains+`(lower(p.display_name),`+s.sqlParam(3)+`)>0 OR EXISTS(SELECT 1 FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' AND `+contains+`(lower(i.subject),`+s.sqlParam(4)+`)>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) (result CityGovernance, resultErr error) {
defer func() { resultErr = s.sqlError("City governance update", resultErr) }()
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 = s.lockPolicyWrite(ctx, tx); err != nil {
return CityGovernance{}, err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs(domain_uuid,version) VALUES(`+s.sqlParam(1)+`,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=city_governance_epochs.version`, domain); err != nil {
return CityGovernance{}, err
}
g, err := s.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' ORDER BY subject,uuid 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=`+s.sqlParam(1)+` AND m.domain_uuid=`+s.sqlParam(2)+` 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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`) 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=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+``, domain, kind, id); err != nil {
return g, err
}
for _, member := range *change.Owners {
if _, err = tx.ExecContext(ctx, `INSERT INTO city_owner_bindings VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`)`, 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=`+s.sqlParam(1)+``, domain); err != nil {
return g, err
}
g, err = s.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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`)`, domain, g.Epoch, actor, kind, id, string(before), string(after), now); err != nil {
return g, err
}
return g, tx.Commit()
}