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

197 lines
11 KiB
Go

package store
import (
"context"
"database/sql"
"fmt"
"time"
)
// campusAdminInheritancePrefix is deliberately not a LIKE pattern: underscore
// is a wildcard in SQL LIKE. Derived grants must never become projection roots.
const campusAdminInheritancePrefix = "campus_admin_inherit:"
func (s *Store) ensureCampusAdminInheritanceSchema() error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
for _, statement := range []string{
`CREATE TABLE IF NOT EXISTS campus_admin_grants (
group_uuid TEXT NOT NULL, membership_uuid TEXT NOT NULL,
source TEXT NOT NULL, member_role TEXT NOT NULL,
created_at_ms INTEGER NOT NULL,
PRIMARY KEY(group_uuid,membership_uuid,source))`,
`CREATE INDEX IF NOT EXISTS campus_admin_grants_membership ON campus_admin_grants(membership_uuid)`,
`CREATE TABLE IF NOT EXISTS campus_admin_membership_origins (
membership_uuid TEXT PRIMARY KEY, domain_uuid TEXT NOT NULL,
principal_uuid TEXT NOT NULL, UNIQUE(domain_uuid,principal_uuid))`,
`CREATE TABLE IF NOT EXISTS campus_admin_migrations (key TEXT PRIMARY KEY)`,
} {
if _, err = tx.Exec(statement); err != nil {
return err
}
}
// Only the old direct grants are authoritative. Copying old inherited rows
// would perpetuate cycles from the former insert-only implementation. Do not
// infer ownership of old Domain memberships: their origin was not recorded.
if _, err = tx.Exec(`INSERT OR IGNORE INTO campus_admin_grants
(group_uuid,membership_uuid,source,member_role,created_at_ms)
SELECT gm.group_uuid,gm.membership_uuid,gm.source,gm.member_role,gm.created_at_ms
FROM group_members gm JOIN groups g ON g.uuid=gm.group_uuid
WHERE g.builtin_key='campus_admin' AND substr(gm.source,1,21)!='campus_admin_inherit:'
AND NOT EXISTS(SELECT 1 FROM campus_admin_migrations WHERE key='direct-grants-v1')`); err != nil {
return err
}
if _, err = tx.Exec(`INSERT OR IGNORE INTO campus_admin_migrations(key) VALUES('direct-grants-v1')`); err != nil {
return err
}
return tx.Commit()
}
// seedCampusAdminRoleGrantsContext is the one-time migration of each independent
// Domain administrator binding. A later explicit group removal must not be
// undone by restarting the server or creating another Domain.
func (s *Store) seedCampusAdminRoleGrantsContext(ctx context.Context, tx *sql.Tx, now int64) error {
const candidates = `SELECT DISTINCT g.uuid AS group_uuid,m.uuid AS membership_uuid
FROM groups g JOIN domain_memberships m ON m.domain_uuid=g.domain_uuid
JOIN auth_role_bindings b ON b.membership_uuid=m.uuid
JOIN auth_roles r ON r.uuid=b.role_uuid AND r.domain_uuid=m.domain_uuid
JOIN auth_capability_grants c ON c.role_uuid=r.uuid
AND c.capability='manage' AND c.target_type='domain'
AND (c.target_id=m.domain_uuid OR c.target_id='*')
WHERE g.builtin_key='campus_admin'`
if _, err := tx.ExecContext(ctx, fmt.Sprintf(`INSERT INTO campus_admin_grants
(group_uuid,membership_uuid,source,member_role,created_at_ms)
SELECT group_uuid,membership_uuid,'migration','owner',%s FROM (`+candidates+`) AS candidates
WHERE NOT EXISTS(SELECT 1 FROM campus_admin_migrations
WHERE key='role:'||group_uuid||':'||membership_uuid) ON CONFLICT(group_uuid,membership_uuid,source) DO NOTHING`, s.sqlParam(1)), now); err != nil {
return err
}
_, err := tx.ExecContext(ctx, `INSERT INTO campus_admin_migrations(key)
SELECT 'role:'||group_uuid||':'||membership_uuid FROM (`+candidates+`) AS candidates WHERE 1=1 ON CONFLICT(key) DO NOTHING`)
return err
}
func (s *Store) ProjectCampusAdminMemberships() error {
return s.ProjectCampusAdminMembershipsContext(context.Background())
}
func (s *Store) ProjectCampusAdminMembershipsContext(ctx context.Context) error {
return s.groupWrite(ctx, s.projectCampusAdminMembershipsContext)
}
// projectCampusAdminMembershipsTx materializes effective group membership from
// independent roots, never from its own output. The caller's mutation and this
// reconciliation commit together, so revocation has no observable stale window.
func projectCampusAdminMembershipsTx(tx *sql.Tx) error {
// Compatibility entry point for legacy SQLite-only mutation transactions.
// Native backend writers call the Store method with their request context.
return (&Store{}).projectCampusAdminMembershipsContext(context.Background(), tx)
}
func (s *Store) projectCampusAdminMembershipsContext(ctx context.Context, tx *sql.Tx) error {
if s.sqlBackend == storeSQLite {
var hasDomains int
if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='domains'`).Scan(&hasDomains); err != nil || hasDomains == 0 {
return err
}
}
now := time.Now().UnixMilli()
// These statements also obtain a write lock before reading projection input.
if _, err := tx.ExecContext(ctx, `DELETE FROM campus_admin_grants WHERE substr(source,1,21)='campus_admin_inherit:'`); err != nil {
return err
}
const roots = `SELECT src.uuid AS source_group_uuid,origin.uuid AS source_domain_uuid,
origin.campus_uuid,srcm.principal_uuid,MIN(gr.created_at_ms) AS created_at_ms,
CASE MAX(CASE gr.member_role WHEN 'owner' THEN 3 WHEN 'manager' THEN 2 ELSE 1 END)
WHEN 3 THEN 'owner' WHEN 2 THEN 'manager' ELSE 'member' END AS member_role
FROM campus_admin_grants gr
JOIN groups src ON src.uuid=gr.group_uuid AND src.builtin_key='campus_admin'
AND src.state='active' AND src.inherit_members=1
JOIN domains origin ON origin.uuid=src.domain_uuid AND origin.enabled=1
JOIN domain_memberships srcm ON srcm.uuid=gr.membership_uuid
AND srcm.domain_uuid=src.domain_uuid AND srcm.state='active'
JOIN principals p ON p.uuid=srcm.principal_uuid AND p.state='active'
WHERE substr(gr.source,1,21)!='campus_admin_inherit:'
GROUP BY src.uuid,origin.uuid,origin.campus_uuid,srcm.principal_uuid`
// Record exactly the memberships this projection creates. Existing local
// memberships (including deliberately suspended ones) are never reactivated.
newUUID := `lower(hex(randomblob(4)))||'-'||lower(hex(randomblob(2)))||'-4'||substr(lower(hex(randomblob(2))),2)||'-a'||substr(lower(hex(randomblob(2))),2)||'-'||lower(hex(randomblob(6)))`
if s.sqlBackend == storePostgreSQL {
newUUID = `gen_random_uuid()::text`
}
if _, err := tx.ExecContext(ctx, `INSERT INTO campus_admin_membership_origins
(membership_uuid,domain_uuid,principal_uuid)
SELECT `+newUUID+`,domain_uuid,principal_uuid FROM (
SELECT DISTINCT dst.uuid AS domain_uuid,root.principal_uuid FROM (`+roots+`) root
JOIN domains dst ON dst.campus_uuid=root.campus_uuid AND dst.uuid!=root.source_domain_uuid AND dst.enabled=1
JOIN groups dstg ON dstg.domain_uuid=dst.uuid AND dstg.builtin_key='campus_admin' AND dstg.state='active'
WHERE NOT EXISTS(SELECT 1 FROM domain_memberships m
WHERE m.domain_uuid=dst.uuid AND m.principal_uuid=root.principal_uuid)) AS missing_memberships WHERE 1=1 ON CONFLICT(domain_uuid,principal_uuid) DO NOTHING`); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `INSERT INTO domain_memberships
(uuid,domain_uuid,principal_uuid,state,created_at_ms)
SELECT membership_uuid,domain_uuid,principal_uuid,'active',`+s.sqlParam(1)+`
FROM campus_admin_membership_origins WHERE 1=1 ON CONFLICT(domain_uuid,principal_uuid) DO NOTHING`, now); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `INSERT INTO campus_admin_grants
(group_uuid,membership_uuid,source,member_role,created_at_ms)
SELECT dstg.uuid,dstm.uuid,'campus_admin_inherit:'||root.source_group_uuid,root.member_role,root.created_at_ms
FROM (`+roots+`) root
JOIN domains dst ON dst.campus_uuid=root.campus_uuid AND dst.uuid!=root.source_domain_uuid AND dst.enabled=1
JOIN groups dstg ON dstg.domain_uuid=dst.uuid AND dstg.builtin_key='campus_admin' AND dstg.state='active'
JOIN domain_memberships dstm ON dstm.domain_uuid=dst.uuid AND dstm.principal_uuid=root.principal_uuid
AND dstm.state='active'`); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `DELETE FROM group_members WHERE
group_uuid IN (SELECT uuid FROM groups WHERE builtin_key='campus_admin')
OR substr(source,1,21)='campus_admin_inherit:'`); err != nil {
return err
}
// The strongest remaining grant wins. Prefer the independent local source
// on ties; weaker local grants remain in provenance and reappear on revoke.
if _, err := tx.ExecContext(ctx, `INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms)
SELECT group_uuid,membership_uuid,member_role,source,created_at_ms FROM (
SELECT gr.*,ROW_NUMBER() OVER(PARTITION BY gr.group_uuid,gr.membership_uuid
ORDER BY CASE gr.member_role WHEN 'owner' THEN 3 WHEN 'manager' THEN 2 ELSE 1 END DESC,
CASE WHEN substr(gr.source,1,21)='campus_admin_inherit:' THEN 1 ELSE 0 END,
gr.source) AS rank
FROM campus_admin_grants gr JOIN groups g ON g.uuid=gr.group_uuid
JOIN domains d ON d.uuid=g.domain_uuid
JOIN domain_memberships m ON m.uuid=gr.membership_uuid AND m.domain_uuid=g.domain_uuid
) AS ranked_grants WHERE rank=1`); err != nil {
return err
}
// A newly added independent group/role grant adopts an inherited membership
// as local. Revocation must not delete that membership, binding, or session.
if _, err := tx.ExecContext(ctx, `DELETE FROM campus_admin_membership_origins WHERE
EXISTS(SELECT 1 FROM auth_role_bindings b WHERE b.membership_uuid=campus_admin_membership_origins.membership_uuid)
OR EXISTS(SELECT 1 FROM group_members gm WHERE gm.membership_uuid=campus_admin_membership_origins.membership_uuid
AND substr(gm.source,1,21)!='campus_admin_inherit:')
OR EXISTS(SELECT 1 FROM campus_admin_grants gr WHERE gr.membership_uuid=campus_admin_membership_origins.membership_uuid
AND substr(gr.source,1,21)!='campus_admin_inherit:')`); err != nil {
return err
}
const noGrants = `NOT EXISTS(SELECT 1 FROM group_members gm
WHERE gm.membership_uuid=origin.membership_uuid)
AND NOT EXISTS(SELECT 1 FROM auth_role_bindings b WHERE b.membership_uuid=origin.membership_uuid)`
if _, err := tx.ExecContext(ctx, `UPDATE auth_sessions SET revoked_at_ms=`+s.sqlParam(1)+` WHERE revoked_at_ms=0 AND EXISTS(
SELECT 1 FROM campus_admin_membership_origins origin
WHERE origin.domain_uuid=auth_sessions.domain_uuid AND origin.principal_uuid=auth_sessions.principal_uuid
AND `+noGrants+`)`, now); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `DELETE FROM domain_memberships WHERE uuid IN (
SELECT origin.membership_uuid FROM campus_admin_membership_origins origin WHERE `+noGrants+`)`); err != nil {
return err
}
_, err := tx.ExecContext(ctx, `DELETE FROM campus_admin_membership_origins WHERE
NOT EXISTS(SELECT 1 FROM domain_memberships m WHERE m.uuid=campus_admin_membership_origins.membership_uuid)`)
return err
}