f3d1210577
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).
165 lines
5.2 KiB
Go
165 lines
5.2 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
|
|
"github.com/Tencent/WeKnora/internal/logger"
|
|
"github.com/Tencent/WeKnora/internal/types"
|
|
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
|
"github.com/Tencent/WeKnora/internal/utils"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
var (
|
|
ErrTenantNotFound = errors.New("tenant not found")
|
|
ErrTenantHasKnowledgeBase = errors.New("tenant has associated knowledge bases")
|
|
)
|
|
|
|
// tenantRepository implements tenant repository interface
|
|
type tenantRepository struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
// NewTenantRepository creates a new tenant repository
|
|
func NewTenantRepository(db *gorm.DB) interfaces.TenantRepository {
|
|
return &tenantRepository{db: db}
|
|
}
|
|
|
|
// CreateTenant creates tenant
|
|
func (r *tenantRepository) CreateTenant(ctx context.Context, tenant *types.Tenant) error {
|
|
return r.db.WithContext(ctx).Create(tenant).Error
|
|
}
|
|
|
|
// GetTenantByID gets tenant by ID
|
|
func (r *tenantRepository) GetTenantByID(ctx context.Context, id uint64) (*types.Tenant, error) {
|
|
var tenant types.Tenant
|
|
if err := r.db.WithContext(ctx).Where("id = ?", id).First(&tenant).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrTenantNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
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
|
|
if err := r.db.WithContext(ctx).Order("created_at DESC").Find(&tenants).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return tenants, nil
|
|
}
|
|
|
|
// SearchTenants searches tenants with pagination and filters
|
|
func (r *tenantRepository) SearchTenants(ctx context.Context, keyword string, tenantID uint64, page, pageSize int) ([]*types.Tenant, int64, error) {
|
|
var tenants []*types.Tenant
|
|
var total int64
|
|
|
|
query := r.db.WithContext(ctx).Model(&types.Tenant{})
|
|
|
|
// Build search conditions
|
|
if tenantID > 0 && keyword != "" {
|
|
escaped := escapeLikeKeyword(keyword)
|
|
query = query.Where("id = ? OR name LIKE ? OR description LIKE ?", tenantID, "%"+escaped+"%", "%"+escaped+"%")
|
|
} else if tenantID > 0 {
|
|
query = query.Where("id = ?", tenantID)
|
|
} else if keyword != "" {
|
|
escaped := escapeLikeKeyword(keyword)
|
|
query = query.Where("name LIKE ? OR description LIKE ?", "%"+escaped+"%", "%"+escaped+"%")
|
|
}
|
|
|
|
// Count total
|
|
if err := query.Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
// Apply pagination
|
|
if page > 0 && pageSize > 0 {
|
|
offset := (page - 1) * pageSize
|
|
query = query.Offset(offset).Limit(pageSize)
|
|
}
|
|
|
|
// Order by created_at DESC
|
|
query = query.Order("created_at DESC")
|
|
|
|
// Execute query
|
|
if err := query.Find(&tenants).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
return tenants, total, nil
|
|
}
|
|
|
|
// UpdateTenant updates tenant.
|
|
// Handles api_key carefully because db.Updates() does not trigger the BeforeSave
|
|
// GORM hook. Without this guard, AfterFind-decrypted plaintext would silently
|
|
// overwrite the encrypted value in the database.
|
|
//
|
|
// Strategy:
|
|
// - enc:v1:… (pre-encrypted by CreateTenant / UpdateAPIKey): write as-is.
|
|
// - plaintext (decrypted by AfterFind): blank it so GORM skips the column.
|
|
// - SYSTEM_AES_KEY not set: write as-is (encryption disabled).
|
|
//
|
|
// The caller's in-memory struct is always restored after the write.
|
|
func (r *tenantRepository) UpdateTenant(ctx context.Context, tenant *types.Tenant) error {
|
|
origAPIKey := tenant.APIKey
|
|
if key := utils.GetAESKey(); key != nil && tenant.APIKey != "" &&
|
|
!strings.HasPrefix(tenant.APIKey, utils.EncPrefix) {
|
|
// Plaintext from AfterFind — do not write back; let the DB keep its
|
|
// existing encrypted value untouched.
|
|
tenant.APIKey = ""
|
|
}
|
|
err := r.db.WithContext(ctx).Model(&types.Tenant{}).Where("id = ?", tenant.ID).Updates(tenant).Error
|
|
tenant.APIKey = origAPIKey
|
|
return err
|
|
}
|
|
|
|
// DeleteTenant deletes tenant
|
|
func (r *tenantRepository) DeleteTenant(ctx context.Context, id uint64) error {
|
|
return r.db.WithContext(ctx).Where("id = ?", id).Delete(&types.Tenant{}).Error
|
|
}
|
|
|
|
func (r *tenantRepository) AdjustStorageUsed(ctx context.Context, tenantID uint64, delta int64) error {
|
|
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
var tenant types.Tenant
|
|
// 使用悲观锁确保并发安全
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&tenant, tenantID).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
tenant.StorageUsed += delta
|
|
// 保存更新并验证业务规则
|
|
if tenant.StorageUsed < 0 {
|
|
logger.Errorf(ctx, "tenant storage used is negative %d: %d", tenant.ID, tenant.StorageUsed)
|
|
tenant.StorageUsed = 0
|
|
}
|
|
|
|
return tx.Save(&tenant).Error
|
|
})
|
|
}
|