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.
329 lines
15 KiB
Go
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()
|
|
}
|