refactor(rbac): address PR 1 review feedback

Tighten correctness, security and observability of the tenant RBAC
foundation introduced in 3c4cdd70 in response to internal review.

Bugfixes
- custom_agents.runnable_by_viewer: drop the GORM `default:true` tag.
  GORM treats a plain bool's zero value as "unspecified" and silently
  rewrites it to the column default on insert, which would prevent
  admins from ever creating an agent with viewer-runtime disabled. The
  column-level DEFAULT TRUE on the database side still backstops rows
  inserted by raw SQL / migrations.
- TenantMemberRepository.HasAnyMembers: replace `Limit(1).Count(&n)`
  with `Take(&probe)`. GORM's Count ignores Limit and scans the whole
  table, which matters because this runs on the auth middleware's
  hot path for users without a cached membership.
- service/user.LoginWithOIDC: include User, Tenant and Memberships in
  the OIDCCallbackResponse so the OIDC flow returns the same shape as
  password login (previously User and friends were left nil).

Security
- middleware/auth.resolveTenantRole: restrict orphan-tenant
  auto-promotion to the caller's home tenant. Cross-tenant superuser
  visits and JWTs minted for foreign tenants no longer trigger silent
  Owner grants. Two regression tests pin the new behaviour.
- service/user.synthFallbackMembership: default the synthesised role
  to Viewer instead of Owner. The login response only feeds UI; the
  backend re-derives the real role from tenant_members on every
  request, so showing a Viewer UI is preferable to a misleading Owner
  UI that would surface admin controls the backend will then 403.
- migrations/versioned/000043_tenant_rbac.down.sql: gate the destructive
  drop behind a `weknora.allow_destructive_migration` GUC so an
  accidental `migrate down` cannot wipe role data in production.
- frontend/src/stores/auth.ts: comment currentTenantRole as
  rendering-only so future PRs cannot mistake the localStorage-backed
  value for an authorisation signal.

API contract
- Memberships in LoginResponse and OIDCCallbackResponse now serialises
  without omitempty, and buildMembershipsForUser / synthFallbackMembership
  always return a non-nil slice — frontend can rely on JSON `[]`.
- handler/auth.GetCurrentUser includes memberships so /auth/me refreshes
  recover currentTenantRole after a page reload.

Performance
- Add TenantService.GetTenantsByIDs (with the matching repo method) and
  use it inside buildMembershipsForUser to batch tenant-name lookups
  instead of issuing one query per membership.

Observability
- Replace the remaining `log.Printf` calls in middleware/auth with
  contextual logger.Warnf / logger.Infof so role resolution events ride
  the standard request-id / Langfuse trace plumbing. The successful
  auto-promote line is tagged `[audit]` for log mining.

Tests
- internal/application/service/tenant_member_test.go: hand-rolled
  fakeTenantMemberRepo plus 11 cases covering AddMember validation,
  EnsureOwner idempotence, "cannot demote/remove the last Owner",
  same-role no-op, ErrInvalidTenantRole / ErrMembershipNotFound, and
  the TenantRole.HasPermission lattice.
- internal/middleware/auth_role_test.go: fakeMemberService plus 8 cases
  pinning every branch of resolveTenantRole, including the two H1
  regressions (cross-tenant superuser must not auto-promote; orphan
  auto-promote requires the home tenant).
This commit is contained in:
wizardchen
2026-05-13 20:24:55 +08:00
committed by lyingbug
parent 7f7a48880f
commit f3d1210577
15 changed files with 792 additions and 46 deletions
+21
View File
@@ -45,6 +45,27 @@ func (r *tenantRepository) GetTenantByID(ctx context.Context, id uint64) (*types
return &tenant, nil
}
// GetTenantsByIDs batches GetTenantByID with a single IN-list query.
// Returns a map keyed by tenant ID; missing rows are simply absent from
// the map (no error). An empty input slice short-circuits to an empty map
// without hitting the database.
func (r *tenantRepository) GetTenantsByIDs(ctx context.Context, ids []uint64) (map[uint64]*types.Tenant, error) {
if len(ids) == 0 {
return map[uint64]*types.Tenant{}, nil
}
var tenants []*types.Tenant
if err := r.db.WithContext(ctx).Where("id IN ?", ids).Find(&tenants).Error; err != nil {
return nil, err
}
out := make(map[uint64]*types.Tenant, len(tenants))
for _, t := range tenants {
if t != nil {
out[t.ID] = t
}
}
return out, nil
}
// ListTenants lists all tenants
func (r *tenantRepository) ListTenants(ctx context.Context) ([]*types.Tenant, error) {
var tenants []*types.Tenant
@@ -115,13 +115,24 @@ func (r *tenantMemberRepository) CountActiveOwners(ctx context.Context, tenantID
}
// HasAnyMembers reports whether the tenant has at least one active
// membership row.
// membership row. Uses a LIMIT 1 SELECT (instead of COUNT(*)) so the query
// short-circuits after the first match — important because this is on the
// auth middleware's hot path for users without a cached membership.
func (r *tenantMemberRepository) HasAnyMembers(ctx context.Context, tenantID uint64) (bool, error) {
var count int64
var probe struct {
ID uint64
}
err := r.db.WithContext(ctx).
Model(&types.TenantMember{}).
Select("id").
Where("tenant_id = ? AND status = ?", tenantID, types.TenantMemberStatusActive).
Limit(1).
Count(&count).Error
return count > 0, err
Take(&probe).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return false, nil
}
return false, err
}
return true, nil
}
+5
View File
@@ -118,6 +118,11 @@ func (s *tenantService) GetTenantByID(ctx context.Context, id uint64) (*types.Te
return tenant, nil
}
// GetTenantsByIDs batches GetTenantByID; returns a map keyed by tenant ID.
func (s *tenantService) GetTenantsByIDs(ctx context.Context, ids []uint64) (map[uint64]*types.Tenant, error) {
return s.repo.GetTenantsByIDs(ctx, ids)
}
// ListTenants retrieves a list of all tenants
func (s *tenantService) ListTenants(ctx context.Context) ([]*types.Tenant, error) {
tenants, err := s.repo.ListTenants(ctx)
@@ -0,0 +1,292 @@
package service
import (
"context"
"errors"
"testing"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
// fakeTenantMemberRepo is an in-memory implementation of
// interfaces.TenantMemberRepository for unit tests. It is intentionally
// not safe for concurrent use; tests should drive it sequentially.
type fakeTenantMemberRepo struct {
rows []*types.TenantMember
// nextID is incremented on Create to populate the surrogate PK.
nextID uint64
// failGet, failHasAny etc. let tests inject transient errors on the
// matching method to exercise error paths.
failGet error
failHasAny error
failCountOwners error
failUpdateRole error
failSoftDelete error
failCreate error
}
func newFakeRepo() *fakeTenantMemberRepo { return &fakeTenantMemberRepo{} }
func (r *fakeTenantMemberRepo) Create(ctx context.Context, m *types.TenantMember) error {
if r.failCreate != nil {
return r.failCreate
}
r.nextID++
m.ID = r.nextID
// Mirror the partial unique index on (user_id, tenant_id) for
// active rows so tests can exercise duplicate-insert behaviour.
for _, e := range r.rows {
if e.UserID == m.UserID && e.TenantID == m.TenantID && e.DeletedAt.Valid == false {
return errors.New("duplicate active membership")
}
}
cp := *m
r.rows = append(r.rows, &cp)
return nil
}
func (r *fakeTenantMemberRepo) Get(ctx context.Context, userID string, tenantID uint64) (*types.TenantMember, error) {
if r.failGet != nil {
return nil, r.failGet
}
for _, e := range r.rows {
if e.UserID == userID && e.TenantID == tenantID && !e.DeletedAt.Valid {
cp := *e
return &cp, nil
}
}
return nil, nil
}
func (r *fakeTenantMemberRepo) ListByUser(ctx context.Context, userID string) ([]*types.TenantMember, error) {
var out []*types.TenantMember
for _, e := range r.rows {
if e.UserID == userID && !e.DeletedAt.Valid {
cp := *e
out = append(out, &cp)
}
}
return out, nil
}
func (r *fakeTenantMemberRepo) ListByTenant(ctx context.Context, tenantID uint64) ([]*types.TenantMember, error) {
var out []*types.TenantMember
for _, e := range r.rows {
if e.TenantID == tenantID && !e.DeletedAt.Valid {
cp := *e
out = append(out, &cp)
}
}
return out, nil
}
func (r *fakeTenantMemberRepo) UpdateRole(ctx context.Context, userID string, tenantID uint64, role types.TenantRole) error {
if r.failUpdateRole != nil {
return r.failUpdateRole
}
for _, e := range r.rows {
if e.UserID == userID && e.TenantID == tenantID && !e.DeletedAt.Valid {
e.Role = role
return nil
}
}
return errors.New("not found")
}
func (r *fakeTenantMemberRepo) SoftDelete(ctx context.Context, userID string, tenantID uint64) error {
if r.failSoftDelete != nil {
return r.failSoftDelete
}
for _, e := range r.rows {
if e.UserID == userID && e.TenantID == tenantID && !e.DeletedAt.Valid {
e.DeletedAt.Valid = true
return nil
}
}
return errors.New("not found")
}
func (r *fakeTenantMemberRepo) CountActiveOwners(ctx context.Context, tenantID uint64) (int64, error) {
if r.failCountOwners != nil {
return 0, r.failCountOwners
}
var n int64
for _, e := range r.rows {
if e.TenantID == tenantID && !e.DeletedAt.Valid &&
e.Role == types.TenantRoleOwner && e.Status == types.TenantMemberStatusActive {
n++
}
}
return n, nil
}
func (r *fakeTenantMemberRepo) HasAnyMembers(ctx context.Context, tenantID uint64) (bool, error) {
if r.failHasAny != nil {
return false, r.failHasAny
}
for _, e := range r.rows {
if e.TenantID == tenantID && !e.DeletedAt.Valid && e.Status == types.TenantMemberStatusActive {
return true, nil
}
}
return false, nil
}
// Compile-time guard so the test stays in sync with the interface.
var _ interfaces.TenantMemberRepository = (*fakeTenantMemberRepo)(nil)
func newServiceWithRepo() (interfaces.TenantMemberService, *fakeTenantMemberRepo) {
r := newFakeRepo()
return NewTenantMemberService(r), r
}
func TestTenantMemberService_AddMember_RejectsInvalidRole(t *testing.T) {
svc, _ := newServiceWithRepo()
_, err := svc.AddMember(context.Background(), "u1", 1, types.TenantRole("nonsense"), nil)
if !errors.Is(err, ErrInvalidTenantRole) {
t.Fatalf("want ErrInvalidTenantRole, got %v", err)
}
}
func TestTenantMemberService_AddMember_RejectsDuplicate(t *testing.T) {
svc, _ := newServiceWithRepo()
ctx := context.Background()
if _, err := svc.AddMember(ctx, "u1", 1, types.TenantRoleContributor, nil); err != nil {
t.Fatalf("first AddMember: %v", err)
}
_, err := svc.AddMember(ctx, "u1", 1, types.TenantRoleContributor, nil)
if !errors.Is(err, ErrMembershipAlreadyExists) {
t.Fatalf("want ErrMembershipAlreadyExists, got %v", err)
}
}
func TestTenantMemberService_EnsureOwner_Idempotent(t *testing.T) {
svc, repo := newServiceWithRepo()
ctx := context.Background()
first, err := svc.EnsureOwner(ctx, "u1", 1)
if err != nil {
t.Fatalf("first EnsureOwner: %v", err)
}
second, err := svc.EnsureOwner(ctx, "u1", 1)
if err != nil {
t.Fatalf("second EnsureOwner: %v", err)
}
if first.ID != second.ID {
t.Fatalf("EnsureOwner not idempotent: %d vs %d", first.ID, second.ID)
}
if len(repo.rows) != 1 {
t.Fatalf("want exactly 1 row after idempotent EnsureOwner, got %d", len(repo.rows))
}
}
func TestTenantMemberService_UpdateRole_BlocksDemotingLastOwner(t *testing.T) {
svc, _ := newServiceWithRepo()
ctx := context.Background()
if _, err := svc.EnsureOwner(ctx, "owner", 1); err != nil {
t.Fatalf("seed: %v", err)
}
err := svc.UpdateRole(ctx, "owner", 1, types.TenantRoleAdmin)
if !errors.Is(err, ErrLastOwner) {
t.Fatalf("want ErrLastOwner when demoting last owner, got %v", err)
}
}
func TestTenantMemberService_UpdateRole_AllowsDemotionWhenOtherOwnerExists(t *testing.T) {
svc, _ := newServiceWithRepo()
ctx := context.Background()
if _, err := svc.EnsureOwner(ctx, "owner1", 1); err != nil {
t.Fatalf("seed1: %v", err)
}
if _, err := svc.AddMember(ctx, "owner2", 1, types.TenantRoleOwner, nil); err != nil {
t.Fatalf("seed2: %v", err)
}
if err := svc.UpdateRole(ctx, "owner1", 1, types.TenantRoleAdmin); err != nil {
t.Fatalf("UpdateRole: %v", err)
}
}
func TestTenantMemberService_UpdateRole_NoopOnSameRole(t *testing.T) {
svc, _ := newServiceWithRepo()
ctx := context.Background()
if _, err := svc.EnsureOwner(ctx, "owner", 1); err != nil {
t.Fatalf("seed: %v", err)
}
// 把"还是 Owner"作为 no-op 处理,必须不触发 ErrLastOwner(同一角色不算降级)。
if err := svc.UpdateRole(ctx, "owner", 1, types.TenantRoleOwner); err != nil {
t.Fatalf("UpdateRole same role should be a no-op, got %v", err)
}
}
func TestTenantMemberService_UpdateRole_RejectsInvalidRole(t *testing.T) {
svc, _ := newServiceWithRepo()
ctx := context.Background()
if _, err := svc.EnsureOwner(ctx, "owner", 1); err != nil {
t.Fatalf("seed: %v", err)
}
if err := svc.UpdateRole(ctx, "owner", 1, types.TenantRole("nope")); !errors.Is(err, ErrInvalidTenantRole) {
t.Fatalf("want ErrInvalidTenantRole, got %v", err)
}
}
func TestTenantMemberService_UpdateRole_ReturnsNotFound(t *testing.T) {
svc, _ := newServiceWithRepo()
if err := svc.UpdateRole(context.Background(), "ghost", 1, types.TenantRoleAdmin); !errors.Is(err, ErrMembershipNotFound) {
t.Fatalf("want ErrMembershipNotFound, got %v", err)
}
}
func TestTenantMemberService_RemoveMember_BlocksLastOwner(t *testing.T) {
svc, _ := newServiceWithRepo()
ctx := context.Background()
if _, err := svc.EnsureOwner(ctx, "owner", 1); err != nil {
t.Fatalf("seed: %v", err)
}
if err := svc.RemoveMember(ctx, "owner", 1); !errors.Is(err, ErrLastOwner) {
t.Fatalf("want ErrLastOwner, got %v", err)
}
}
func TestTenantMemberService_RemoveMember_AllowsContributorRemoval(t *testing.T) {
svc, _ := newServiceWithRepo()
ctx := context.Background()
if _, err := svc.EnsureOwner(ctx, "owner", 1); err != nil {
t.Fatalf("seed owner: %v", err)
}
if _, err := svc.AddMember(ctx, "contrib", 1, types.TenantRoleContributor, nil); err != nil {
t.Fatalf("seed contributor: %v", err)
}
if err := svc.RemoveMember(ctx, "contrib", 1); err != nil {
t.Fatalf("RemoveMember: %v", err)
}
got, _ := svc.GetMembership(ctx, "contrib", 1)
if got != nil {
t.Fatalf("contributor should be soft-deleted, got %+v", got)
}
}
func TestTenantMemberService_RemoveMember_ReturnsNotFound(t *testing.T) {
svc, _ := newServiceWithRepo()
if err := svc.RemoveMember(context.Background(), "ghost", 1); !errors.Is(err, ErrMembershipNotFound) {
t.Fatalf("want ErrMembershipNotFound, got %v", err)
}
}
func TestTenantRole_HasPermission(t *testing.T) {
cases := []struct {
caller types.TenantRole
required types.TenantRole
want bool
}{
{types.TenantRoleOwner, types.TenantRoleAdmin, true},
{types.TenantRoleAdmin, types.TenantRoleOwner, false},
{types.TenantRoleContributor, types.TenantRoleViewer, true},
{types.TenantRoleViewer, types.TenantRoleContributor, false},
{types.TenantRole("bogus"), types.TenantRoleViewer, false},
}
for _, c := range cases {
if got := c.caller.HasPermission(c.required); got != c.want {
t.Errorf("HasPermission(%s, %s) = %v, want %v", c.caller, c.required, got, c.want)
}
}
}
+61 -4
View File
@@ -240,13 +240,21 @@ func (s *userService) Login(ctx context.Context, req *types.LoginRequest) (*type
// part of the dependency graph), this falls back to a single synthesized
// row built from User.TenantID + the active tenant so callers always get
// at least one entry.
func (s *userService) BuildLoginMemberships(
ctx context.Context,
user *types.User,
activeTenant *types.Tenant,
) []types.Membership {
return s.buildMembershipsForUser(ctx, user, activeTenant)
}
func (s *userService) buildMembershipsForUser(
ctx context.Context,
user *types.User,
activeTenant *types.Tenant,
) []types.Membership {
if user == nil {
return nil
return []types.Membership{}
}
if s.memberService == nil {
return synthFallbackMembership(user, activeTenant)
@@ -259,6 +267,27 @@ func (s *userService) buildMembershipsForUser(
if len(rows) == 0 {
return synthFallbackMembership(user, activeTenant)
}
// 收集需要批量查询名称的 tenant id(跳过 activeTenant 因为它已经在手)。
needsLookup := make([]uint64, 0, len(rows))
for _, m := range rows {
if m == nil || m.Status != types.TenantMemberStatusActive {
continue
}
if activeTenant != nil && m.TenantID == activeTenant.ID {
continue
}
needsLookup = append(needsLookup, m.TenantID)
}
tenantByID := map[uint64]*types.Tenant{}
if len(needsLookup) > 0 {
if found, terr := s.tenantService.GetTenantsByIDs(ctx, needsLookup); terr == nil {
tenantByID = found
} else {
logger.Warnf(ctx, "Failed to batch-load tenants for memberships (user=%s): %v",
user.ID, terr)
}
}
out := make([]types.Membership, 0, len(rows))
for _, m := range rows {
if m == nil || m.Status != types.TenantMemberStatusActive {
@@ -267,7 +296,7 @@ func (s *userService) buildMembershipsForUser(
name := ""
if activeTenant != nil && m.TenantID == activeTenant.ID {
name = activeTenant.Name
} else if t, err := s.tenantService.GetTenantByID(ctx, m.TenantID); err == nil && t != nil {
} else if t, ok := tenantByID[m.TenantID]; ok && t != nil {
name = t.Name
}
out = append(out, types.Membership{
@@ -287,9 +316,21 @@ func (s *userService) buildMembershipsForUser(
// populated yet (e.g. during the rollout window where the migration has
// run but the auth middleware's auto-promotion hasn't fired) so the
// response shape stays consistent.
//
// The fallback role is intentionally TenantRoleViewer (least privilege):
// the login response only feeds UI rendering, and the backend re-derives
// the real role from tenant_members on every request. If membership data
// is temporarily unavailable, showing a Viewer UI is preferable to
// granting a misleading Owner UI that would surface admin controls the
// backend will then 403. Once the membership row appears (via the auth
// middleware's home-tenant auto-promotion or an admin invitation) the
// next /auth/me-style refresh will upgrade the UI to the real role.
func synthFallbackMembership(user *types.User, activeTenant *types.Tenant) []types.Membership {
if user == nil || user.TenantID == 0 {
return nil
// Always return a non-nil slice so the login response carries an
// empty array rather than `null`, preserving the documented
// "always populated" contract on LoginResponse.Memberships.
return []types.Membership{}
}
name := ""
if activeTenant != nil && activeTenant.ID == user.TenantID {
@@ -298,7 +339,7 @@ func synthFallbackMembership(user *types.User, activeTenant *types.Tenant) []typ
return []types.Membership{{
TenantID: user.TenantID,
TenantName: name,
Role: types.TenantRoleOwner, // safe default for legacy single-tenant users
Role: types.TenantRoleViewer,
}}
}
@@ -396,9 +437,25 @@ func (s *userService) LoginWithOIDC(ctx context.Context, code, redirectURI strin
return nil, fmt.Errorf("failed to generate local tokens: %w", err)
}
// 拉取 tenant + memberships,让 OIDC 登录的返回结构与本地登录一致,
// 前端无须为 OIDC 单独走一次 /auth/me 才能拿到角色。
var tenant *types.Tenant
if user.TenantID > 0 {
if t, terr := s.tenantService.GetTenantByID(ctx, user.TenantID); terr == nil {
tenant = t
} else {
logger.Warnf(ctx, "OIDC login: failed to load tenant %d for user %s: %v",
user.TenantID, user.ID, terr)
}
}
memberships := s.buildMembershipsForUser(ctx, user, tenant)
return &types.OIDCCallbackResponse{
Success: true,
Message: "登录成功",
User: user,
Tenant: tenant,
Memberships: memberships,
Token: accessToken,
RefreshToken: refreshToken,
IsNewUser: isNewUser,