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() }