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 }