feat(auth): support tenantless provisioning and gated self-service workspace creation

Allow deployments to register users without auto-creating a personal tenant, expose creation policy via /auth/me, and guide tenantless accounts through a workspace onboarding flow.
This commit is contained in:
wizardchen
2026-07-13 18:04:14 +08:00
committed by lyingbug
parent 50b8c0a72e
commit ecf2c1fb9b
36 changed files with 1543 additions and 89 deletions
+21
View File
@@ -31,6 +31,14 @@ func NewUserRepository(db *gorm.DB) interfaces.UserRepository {
// CreateUser creates a user
func (r *userRepository) CreateUser(ctx context.Context, user *types.User) error {
// users.tenant_id is nullable in both PostgreSQL and SQLite. GORM would
// otherwise serialise the uint64 zero value as 0, which violates the
// PostgreSQL FK and loses the distinction between "not provisioned yet"
// and a real tenant. Omitting the column stores SQL NULL; reads hydrate it
// back as zero, the domain sentinel used by tenantless auth flows.
if user != nil && user.TenantID == 0 {
return r.db.WithContext(ctx).Omit("tenant_id").Create(user).Error
}
return r.db.WithContext(ctx).Create(user).Error
}
@@ -104,6 +112,19 @@ func (r *userRepository) GetUserByTenantID(ctx context.Context, tenantID uint64)
// UpdateUser updates a user
func (r *userRepository) UpdateUser(ctx context.Context, user *types.User) error {
if user != nil && user.TenantID == 0 {
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
// Preserve Save's all-fields behaviour while keeping the nullable
// tenant column out of the struct write, then explicitly store NULL.
// Writing uint64(0) would violate the PostgreSQL tenant FK.
if err := tx.Omit("tenant_id").Save(user).Error; err != nil {
return err
}
return tx.Model(&types.User{}).
Where("id = ?", user.ID).
UpdateColumn("tenant_id", nil).Error
})
}
return r.db.WithContext(ctx).Save(user).Error
}
@@ -0,0 +1,59 @@
package repository
import (
"context"
"testing"
"github.com/Tencent/WeKnora/internal/types"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
)
func TestUserRepositoryTenantlessCreateAndUpdateKeepNullTenantID(t *testing.T) {
db, err := gorm.Open(sqlite.Open("file:user_tenantless?mode=memory&cache=shared"), &gorm.Config{})
if err != nil {
t.Fatalf("open sqlite: %v", err)
}
if err := db.AutoMigrate(&types.Tenant{}, &types.User{}); err != nil {
t.Fatalf("migrate: %v", err)
}
repo := NewUserRepository(db)
user := &types.User{
ID: "tenantless-user",
Username: "before-update",
Email: "tenantless@example.com",
PasswordHash: "hashed",
TenantID: 0,
IsActive: true,
}
if err := repo.CreateUser(context.Background(), user); err != nil {
t.Fatalf("CreateUser: %v", err)
}
assertNullTenantID(t, db, user.ID)
user.Username = "after-update"
if err := repo.UpdateUser(context.Background(), user); err != nil {
t.Fatalf("UpdateUser: %v", err)
}
assertNullTenantID(t, db, user.ID)
var stored types.User
if err := db.First(&stored, "id = ?", user.ID).Error; err != nil {
t.Fatalf("reload user: %v", err)
}
if stored.Username != "after-update" || stored.TenantID != 0 {
t.Fatalf("stored user = %#v", stored)
}
}
func assertNullTenantID(t *testing.T, db *gorm.DB, userID string) {
t.Helper()
var count int64
if err := db.Table("users").Where("id = ? AND tenant_id IS NULL", userID).Count(&count).Error; err != nil {
t.Fatalf("check tenant_id: %v", err)
}
if count != 1 {
t.Fatalf("tenant_id for user %s is not NULL", userID)
}
}
@@ -135,6 +135,15 @@ var registry = map[string]settingSpec{
Description: "自助注册模式。self_serve = 任何人可注册账号;invite_only = 关闭公网注册," +
"仅 Owner/Admin 可邀请。修改后立即生效,但谨慎对待 self_serve(公网会接受 spam)。",
},
"auth.default_tenant_mode": {
Type: "string",
EnvName: "WEKNORA_AUTH_DEFAULT_TENANT_MODE",
Default: "create_personal",
Enum: []string{"create_personal", "tenantless"},
Category: "auth",
Description: "公开注册成功后的默认租户策略。create_personal = 自动创建个人租户并设为 Owner;" +
"tenantless = 仅创建用户,等待接受邀请或主动创建租户。修改后只影响新注册用户。",
},
// tenant.max_owned_per_user caps how many tenants a single non-superuser
// can create (and Own) via self-service POST /tenants. Read on every
// request — UI edits take effect immediately, no restart required. The
@@ -150,6 +159,14 @@ var registry = map[string]settingSpec{
Description: "每个非超管用户通过自助创建可拥有的最大租户数。每次创建租户时实时读取," +
"修改后立即生效。0 表示使用内置默认值 10;负数表示完全关闭限制(不建议在公开部署使用)。",
},
"tenant.self_service_creation_enabled": {
Type: "bool",
EnvName: "WEKNORA_TENANT_SELF_SERVICE_CREATION_ENABLED",
Default: true,
Category: "tenant",
Description: "是否允许非超管用户主动创建租户。关闭后,普通用户只能通过邀请加入已有租户;" +
"跨租户超管仍可创建。修改后立即生效。",
},
// tenant.default_storage_quota_gb is the default storage quota (in GB)
// applied to a newly-created tenant when the caller doesn't specify
// one explicitly. Read at create time only — changing the value does
+100 -22
View File
@@ -103,18 +103,29 @@ func (s *userService) Register(ctx context.Context, req *types.RegisterRequest)
return nil, errors.New("failed to process password")
}
// Create default tenant for the user
// Note: RetrieverEngines is left empty - system will use defaults from RETRIEVE_DRIVER env
tenant := &types.Tenant{
Name: fmt.Sprintf("%s's Workspace", secutils.SanitizeForLog(req.Username)),
Description: "Default workspace",
Status: "active",
provisioning := req.TenantProvisioning
if provisioning == "" {
provisioning = types.TenantProvisioningCreatePersonal
}
if !provisioning.IsValid() {
return nil, fmt.Errorf("invalid tenant provisioning mode %q", provisioning)
}
createdTenant, err := s.tenantService.CreateTenant(ctx, tenant)
if err != nil {
logger.Errorf(ctx, "Failed to create tenant")
return nil, errors.New("failed to create workspace")
var createdTenant *types.Tenant
if provisioning == types.TenantProvisioningCreatePersonal {
// Note: RetrieverEngines is left empty - system will use defaults
// from RETRIEVE_DRIVER env.
tenant := &types.Tenant{
Name: fmt.Sprintf("%s's Workspace", secutils.SanitizeForLog(req.Username)),
Description: "Default workspace",
Status: "active",
}
createdTenant, err = s.tenantService.CreateTenant(ctx, tenant)
if err != nil {
logger.Errorf(ctx, "Failed to create tenant")
return nil, errors.New("failed to create workspace")
}
}
// Create user
@@ -123,15 +134,23 @@ func (s *userService) Register(ctx context.Context, req *types.RegisterRequest)
Username: req.Username,
Email: req.Email,
PasswordHash: string(hashedPassword),
TenantID: createdTenant.ID,
TenantID: 0,
IsActive: true,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
if createdTenant != nil {
user.TenantID = createdTenant.ID
}
err = s.userRepo.CreateUser(ctx, user)
if err != nil {
logger.Errorf(ctx, "Failed to create user: %v", err)
if createdTenant != nil {
if rollbackErr := s.tenantService.DeleteTenant(ctx, createdTenant.ID); rollbackErr != nil {
logger.Errorf(ctx, "Failed to roll back tenant %d after user creation failure: %v", createdTenant.ID, rollbackErr)
}
}
return nil, errors.New("failed to create user")
}
@@ -139,10 +158,13 @@ func (s *userService) Register(ctx context.Context, req *types.RegisterRequest)
// the tenant their account just created. Failure here only logs — the
// user record exists and the auth middleware's orphan-tenant recovery
// path will recreate the membership on next login.
if s.memberService != nil {
if createdTenant != nil && s.memberService != nil {
if _, err := s.memberService.EnsureOwner(ctx, user.ID, createdTenant.ID); err != nil {
logger.Errorf(ctx, "Failed to create owner membership for user %s tenant %d: %v",
user.ID, createdTenant.ID, err)
_ = s.userRepo.DeleteUser(ctx, user.ID)
_ = s.tenantService.DeleteTenant(ctx, createdTenant.ID)
return nil, errors.New("failed to finalise workspace ownership")
}
}
@@ -206,12 +228,16 @@ func (s *userService) Login(ctx context.Context, req *types.LoginRequest) (*type
}
logger.Info(ctx, "Tokens generated successfully")
// Get tenant information
tenant, err := s.tenantService.GetTenantByID(ctx, resolvedTenantID)
if err != nil {
logger.Warn(ctx, "Failed to get tenant info")
} else {
logger.Info(ctx, "Tenant information retrieved successfully")
// Get tenant information. A zero resolved ID is a valid tenantless
// identity, not a failed tenant lookup.
var tenant *types.Tenant
if resolvedTenantID > 0 {
tenant, err = s.tenantService.GetTenantByID(ctx, resolvedTenantID)
if err != nil {
logger.Warn(ctx, "Failed to get tenant info")
} else {
logger.Info(ctx, "Tenant information retrieved successfully")
}
}
memberships := s.buildMembershipsForUser(ctx, user, tenant)
@@ -625,7 +651,9 @@ func (s *userService) GenerateTokens(
// freshly minted access token. The contract:
//
// 1. If the user has no LastActiveTenantID preference set (or it points
// at home), return home — the historical behaviour.
// at home), return home — the historical behaviour. A tenantless user
// with an active membership adopts their earliest membership instead;
// this repairs partial invitation/admin-assignment flows.
// 2. Otherwise validate the preference: the tenant must still exist and
// the user must still have an active membership (or be a cross-tenant
// superuser). Validation failure logs a warning, best-effort clears
@@ -641,6 +669,9 @@ func (s *userService) resolveLoginTenantID(ctx context.Context, user *types.User
}
pref := user.Preferences.LastActiveTenantID
if pref == nil || *pref == 0 || *pref == user.TenantID {
if user.TenantID == 0 {
return s.resolveFirstMembershipTenant(ctx, user)
}
return user.TenantID
}
preferred := *pref
@@ -680,6 +711,46 @@ func (s *userService) resolveLoginTenantID(ctx context.Context, user *types.User
return preferred
}
// resolveFirstMembershipTenant makes a tenantless identity usable when an
// active membership already exists (for example, an invitation was accepted
// but persisting the default tenant failed). ListByUser is stably ordered by
// join time, so the earliest valid membership is deterministic. Persisting it
// as home is best-effort: even if the repair write fails, the freshly issued
// token can still be scoped to the membership and the next login retries.
func (s *userService) resolveFirstMembershipTenant(ctx context.Context, user *types.User) uint64 {
if user == nil || s.memberService == nil {
return 0
}
members, err := s.memberService.ListByUser(ctx, user.ID)
if err != nil {
logger.Warnf(ctx, "resolveLoginTenantID: failed to list memberships for tenantless user %s: %v", user.ID, err)
return 0
}
for _, member := range members {
if member == nil || member.TenantID == 0 || member.Status != types.TenantMemberStatusActive {
continue
}
if s.tenantService != nil {
if _, err := s.tenantService.GetTenantByID(ctx, member.TenantID); err != nil {
logger.Warnf(ctx, "resolveLoginTenantID: tenant %d for tenantless user %s is unavailable: %v",
member.TenantID, user.ID, err)
continue
}
}
user.TenantID = member.TenantID
if s.userRepo != nil {
if err := s.userRepo.UpdateUser(ctx, user); err != nil {
logger.Warnf(ctx, "resolveLoginTenantID: failed to persist tenant %d for tenantless user %s: %v",
member.TenantID, user.ID, err)
user.TenantID = 0
}
}
return member.TenantID
}
return 0
}
// clearLastActiveTenantPreference is the best-effort cleanup half of
// resolveLoginTenantID. Failures here are logged but never propagated:
// the in-memory user already has the preference cleared for this login,
@@ -1261,10 +1332,17 @@ func (s *userService) provisionOIDCUser(ctx context.Context, info *types.OIDCUse
return nil, fmt.Errorf("failed to generate password for OIDC user: %w", err)
}
provisioning := types.TenantProvisioningCreatePersonal
if s.config != nil && s.config.OIDCAuth != nil &&
strings.TrimSpace(s.config.OIDCAuth.DefaultTenantMode) == config.AuthDefaultTenantModeTenantless {
provisioning = types.TenantProvisioningTenantless
}
user, err := s.Register(ctx, &types.RegisterRequest{
Username: username,
Email: info.Email,
Password: randomPassword,
Username: username,
Email: info.Email,
Password: randomPassword,
TenantProvisioning: provisioning,
})
if err != nil {
return nil, fmt.Errorf("failed to auto-provision OIDC user: %w", err)
@@ -0,0 +1,96 @@
package service
import (
"context"
"testing"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
type provisioningUserRepo struct {
interfaces.UserRepository
created *types.User
updatedTenant uint64
}
func (r *provisioningUserRepo) GetUserByEmail(context.Context, string) (*types.User, error) {
return nil, nil
}
func (r *provisioningUserRepo) GetUserByUsername(context.Context, string) (*types.User, error) {
return nil, nil
}
func (r *provisioningUserRepo) CreateUser(_ context.Context, user *types.User) error {
copy := *user
r.created = &copy
return nil
}
func (r *provisioningUserRepo) UpdateUser(_ context.Context, user *types.User) error {
r.updatedTenant = user.TenantID
return nil
}
type provisioningTenantService struct {
interfaces.TenantService
createCalls int
}
func (s *provisioningTenantService) CreateTenant(context.Context, *types.Tenant) (*types.Tenant, error) {
s.createCalls++
return &types.Tenant{ID: 99}, nil
}
func (s *provisioningTenantService) GetTenantByID(_ context.Context, id uint64) (*types.Tenant, error) {
return &types.Tenant{ID: id}, nil
}
type provisioningMemberService struct {
interfaces.TenantMemberService
members []*types.TenantMember
}
func (s *provisioningMemberService) ListByUser(context.Context, string) ([]*types.TenantMember, error) {
return s.members, nil
}
func TestUserServiceRegisterTenantlessSkipsTenantCreation(t *testing.T) {
repo := &provisioningUserRepo{}
tenantSvc := &provisioningTenantService{}
svc := &userService{userRepo: repo, tenantService: tenantSvc}
user, err := svc.Register(context.Background(), &types.RegisterRequest{
Username: "alice",
Email: "alice@example.com",
Password: "supersecret",
TenantProvisioning: types.TenantProvisioningTenantless,
})
if err != nil {
t.Fatalf("Register: %v", err)
}
if tenantSvc.createCalls != 0 {
t.Fatalf("tenant create calls = %d, want 0", tenantSvc.createCalls)
}
if user.TenantID != 0 || repo.created == nil || repo.created.TenantID != 0 {
t.Fatalf("tenantless user persisted with tenant: user=%d created=%v", user.TenantID, repo.created)
}
}
func TestResolveLoginTenantIDRepairsTenantlessUserWithMembership(t *testing.T) {
repo := &provisioningUserRepo{}
tenantSvc := &provisioningTenantService{}
memberSvc := &provisioningMemberService{members: []*types.TenantMember{
{TenantID: 42, Status: types.TenantMemberStatusActive},
}}
svc := &userService{userRepo: repo, tenantService: tenantSvc, memberService: memberSvc}
user := &types.User{ID: "alice", TenantID: 0}
if got := svc.resolveLoginTenantID(context.Background(), user); got != 42 {
t.Fatalf("resolved tenant = %d, want 42", got)
}
if repo.updatedTenant != 42 || user.TenantID != 42 {
t.Fatalf("repair was not persisted: repo=%d user=%d", repo.updatedTenant, user.TenantID)
}
}
+61
View File
@@ -31,6 +31,7 @@ func TestApplyAuthAndTenantDefaults_DisableRegistrationDrivesRegistrationMode(t
// Other tenant env vars must not leak between cases.
t.Setenv("WEKNORA_TENANT_ENABLE_RBAC", "")
t.Setenv("WEKNORA_TENANT_MAX_OWNED_PER_USER", "")
t.Setenv("WEKNORA_TENANT_SELF_SERVICE_CREATION_ENABLED", "")
cfg := &Config{Auth: &AuthConfig{RegistrationMode: tc.cfgMode}}
applyAuthAndTenantDefaults(cfg)
@@ -41,3 +42,63 @@ func TestApplyAuthAndTenantDefaults_DisableRegistrationDrivesRegistrationMode(t
})
}
}
func TestApplyAuthAndTenantDefaults_SelfServiceTenantCreation(t *testing.T) {
t.Run("defaults enabled", func(t *testing.T) {
t.Setenv("WEKNORA_TENANT_SELF_SERVICE_CREATION_ENABLED", "")
cfg := &Config{Tenant: &TenantConfig{}}
applyAuthAndTenantDefaults(cfg)
if !cfg.Tenant.IsSelfServiceCreationEnabled() {
t.Fatal("self-service tenant creation should default to enabled")
}
})
t.Run("environment disables yaml default", func(t *testing.T) {
t.Setenv("WEKNORA_TENANT_SELF_SERVICE_CREATION_ENABLED", "false")
on := true
cfg := &Config{Tenant: &TenantConfig{SelfServiceCreationEnabled: &on}}
applyAuthAndTenantDefaults(cfg)
if cfg.Tenant.IsSelfServiceCreationEnabled() {
t.Fatal("environment override should disable self-service tenant creation")
}
})
}
func TestApplyAuthAndTenantDefaults_DefaultTenantMode(t *testing.T) {
t.Run("historical default creates a personal tenant", func(t *testing.T) {
t.Setenv("WEKNORA_AUTH_DEFAULT_TENANT_MODE", "")
cfg := &Config{Auth: &AuthConfig{}}
applyAuthAndTenantDefaults(cfg)
if cfg.Auth.DefaultTenantMode != AuthDefaultTenantModeCreatePersonal {
t.Fatalf("default_tenant_mode = %q, want %q", cfg.Auth.DefaultTenantMode, AuthDefaultTenantModeCreatePersonal)
}
})
t.Run("environment overrides yaml", func(t *testing.T) {
t.Setenv("WEKNORA_AUTH_DEFAULT_TENANT_MODE", AuthDefaultTenantModeTenantless)
cfg := &Config{Auth: &AuthConfig{DefaultTenantMode: AuthDefaultTenantModeCreatePersonal}}
applyAuthAndTenantDefaults(cfg)
if cfg.Auth.DefaultTenantMode != AuthDefaultTenantModeTenantless {
t.Fatalf("default_tenant_mode = %q, want %q", cfg.Auth.DefaultTenantMode, AuthDefaultTenantModeTenantless)
}
})
t.Run("invalid environment value fails validation", func(t *testing.T) {
t.Setenv("WEKNORA_AUTH_DEFAULT_TENANT_MODE", "create_magic")
cfg := &Config{Auth: &AuthConfig{}}
applyAuthAndTenantDefaults(cfg)
if err := ValidateConfig(cfg); err == nil {
t.Fatal("ValidateConfig unexpectedly accepted an invalid default tenant mode")
}
})
}
+65 -2
View File
@@ -226,6 +226,10 @@ type TenantConfig struct {
// loosen / tighten the quota without a redeploy. See
// applyAuthAndTenantDefaults for the semantics of <0 / 0 / >0.
MaxOwnedPerUser int `yaml:"max_owned_per_user" json:"max_owned_per_user" mapstructure:"max_owned_per_user"`
// SelfServiceCreationEnabled controls whether ordinary authenticated
// users may create a workspace for themselves. Nil preserves the
// historical default (enabled); cross-tenant superusers are exempt.
SelfServiceCreationEnabled *bool `yaml:"self_service_creation_enabled" json:"self_service_creation_enabled" mapstructure:"self_service_creation_enabled"`
}
// IsRBACEnforced reports whether tenant-level role enforcement is
@@ -241,6 +245,12 @@ func (t *TenantConfig) IsRBACEnforced() bool {
return *t.EnableRBAC
}
// IsSelfServiceCreationEnabled reports whether ordinary users may create
// tenants. Nil keeps the historical behaviour enabled.
func (t *TenantConfig) IsSelfServiceCreationEnabled() bool {
return t == nil || t.SelfServiceCreationEnabled == nil || *t.SelfServiceCreationEnabled
}
// AuditConfig governs durable audit log behaviour. Writes happen on
// every member-management mutation and on RBAC denials (when
// EnableRBAC is true); the table grows monotonically unless this
@@ -265,12 +275,19 @@ type AuthConfig struct {
// users only enter through the invitation
// flow added in PR 3.
RegistrationMode string `yaml:"registration_mode" json:"registration_mode"`
// DefaultTenantMode controls public password-registration provisioning.
// create_personal preserves the historical one-user-one-workspace default;
// tenantless creates only the identity and waits for an invitation or an
// explicit self-service tenant creation.
DefaultTenantMode string `yaml:"default_tenant_mode" json:"default_tenant_mode"`
}
// AuthRegistrationMode constants used by handlers and middleware.
const (
AuthRegistrationModeSelfServe = "self_serve"
AuthRegistrationModeInviteOnly = "invite_only"
AuthRegistrationModeSelfServe = "self_serve"
AuthRegistrationModeInviteOnly = "invite_only"
AuthDefaultTenantModeCreatePersonal = "create_personal"
AuthDefaultTenantModeTenantless = "tenantless"
)
// IsInviteOnly returns true when registration is gated behind invitations.
@@ -301,6 +318,9 @@ type OIDCAuthConfig struct {
UserInfoEndpoint string `yaml:"user_info_endpoint" json:"user_info_endpoint"`
Scopes []string `yaml:"scopes" json:"scopes"`
UserInfoMapping *OIDCUserInfoMapping `yaml:"user_info_mapping" json:"user_info_mapping"`
// DefaultTenantMode applies only when OIDC auto-provisions a new local
// user. Existing users keep their current home tenant/memberships.
DefaultTenantMode string `yaml:"default_tenant_mode" json:"default_tenant_mode"`
}
// PromptTemplateI18n holds localized name and description for a prompt template.
@@ -607,6 +627,11 @@ func ValidateConfig(cfg *Config) error {
(strings.TrimSpace(cfg.OIDCAuth.AuthorizationEndpoint) == "" || strings.TrimSpace(cfg.OIDCAuth.TokenEndpoint) == "") {
errs = append(errs, "oidc_auth.discovery_url or both oidc_auth.authorization_endpoint and oidc_auth.token_endpoint are required when OIDC is enabled")
}
tenantMode := strings.TrimSpace(cfg.OIDCAuth.DefaultTenantMode)
if tenantMode != "" && tenantMode != AuthDefaultTenantModeCreatePersonal && tenantMode != AuthDefaultTenantModeTenantless {
errs = append(errs, fmt.Sprintf("oidc_auth.default_tenant_mode must be %q or %q, got %q",
AuthDefaultTenantModeCreatePersonal, AuthDefaultTenantModeTenantless, tenantMode))
}
}
if cfg.Auth != nil {
@@ -615,6 +640,11 @@ func ValidateConfig(cfg *Config) error {
errs = append(errs, fmt.Sprintf("auth.registration_mode must be %q or %q, got %q",
AuthRegistrationModeSelfServe, AuthRegistrationModeInviteOnly, mode))
}
tenantMode := strings.TrimSpace(cfg.Auth.DefaultTenantMode)
if tenantMode != "" && tenantMode != AuthDefaultTenantModeCreatePersonal && tenantMode != AuthDefaultTenantModeTenantless {
errs = append(errs, fmt.Sprintf("auth.default_tenant_mode must be %q or %q, got %q",
AuthDefaultTenantModeCreatePersonal, AuthDefaultTenantModeTenantless, tenantMode))
}
}
if cfg.Audit != nil && cfg.Audit.RetentionDays < 0 {
@@ -699,6 +729,9 @@ func applyOIDCEnvOverrides(cfg *Config) {
if value := strings.TrimSpace(os.Getenv("OIDC_AUTH_SCOPES")); value != "" {
cfg.OIDCAuth.Scopes = strings.Fields(strings.ReplaceAll(value, ",", " "))
}
if value := strings.TrimSpace(os.Getenv("OIDC_AUTH_DEFAULT_TENANT_MODE")); value != "" {
cfg.OIDCAuth.DefaultTenantMode = value
}
if value := strings.TrimSpace(os.Getenv("OIDC_USER_INFO_MAPPING_USER_NAME")); value != "" {
cfg.OIDCAuth.UserInfoMapping.Username = value
}
@@ -709,6 +742,9 @@ func applyOIDCEnvOverrides(cfg *Config) {
if cfg.OIDCAuth.ProviderDisplayName == "" {
cfg.OIDCAuth.ProviderDisplayName = "OIDC"
}
if strings.TrimSpace(cfg.OIDCAuth.DefaultTenantMode) == "" {
cfg.OIDCAuth.DefaultTenantMode = AuthDefaultTenantModeCreatePersonal
}
if len(cfg.OIDCAuth.Scopes) == 0 {
cfg.OIDCAuth.Scopes = []string{"openid", "profile", "email"}
}
@@ -774,11 +810,17 @@ func applyAgentEnvOverrides(cfg *Config) {
//
// Defaults:
// - auth.registration_mode -> "self_serve" (preserves pre-RBAC behaviour)
// - auth.default_tenant_mode -> "create_personal" (preserves the
// historical registration behaviour)
// - tenant.enable_rbac -> true (enforce role checks unless an
// operator explicitly opts into the logging-only rollout window via
// config.yaml `enable_rbac: false` or `WEKNORA_TENANT_ENABLE_RBAC=false`).
// - tenant.self_service_creation_enabled -> true (preserves ordinary
// authenticated users' ability to create workspaces).
//
// Env overrides (when set and non-empty):
// - WEKNORA_AUTH_DEFAULT_TENANT_MODE ("create_personal"/"tenantless")
// - WEKNORA_TENANT_SELF_SERVICE_CREATION_ENABLED (boolean)
// - WEKNORA_TENANT_ENABLE_RBAC ("true"/"false", case-insensitive)
// - WEKNORA_TENANT_MAX_OWNED_PER_USER (integer; <0 disables the cap,
// 0 falls back to the handler default, >0 enforces that exact cap).
@@ -813,6 +855,12 @@ func applyAuthAndTenantDefaults(cfg *Config) {
if strings.TrimSpace(cfg.Auth.RegistrationMode) == "" {
cfg.Auth.RegistrationMode = AuthRegistrationModeSelfServe
}
if value := strings.TrimSpace(os.Getenv("WEKNORA_AUTH_DEFAULT_TENANT_MODE")); value != "" {
cfg.Auth.DefaultTenantMode = value
}
if strings.TrimSpace(cfg.Auth.DefaultTenantMode) == "" {
cfg.Auth.DefaultTenantMode = AuthDefaultTenantModeCreatePersonal
}
if value := strings.TrimSpace(os.Getenv("WEKNORA_TENANT_ENABLE_RBAC")); value != "" {
v := strings.EqualFold(value, "true")
@@ -825,6 +873,21 @@ func applyAuthAndTenantDefaults(cfg *Config) {
cfg.Tenant.EnableRBAC = &on
}
if value := strings.TrimSpace(os.Getenv("WEKNORA_TENANT_SELF_SERVICE_CREATION_ENABLED")); value != "" {
if enabled, err := strconv.ParseBool(value); err == nil {
cfg.Tenant.SelfServiceCreationEnabled = &enabled
} else {
fmt.Printf(
"[config] WEKNORA_TENANT_SELF_SERVICE_CREATION_ENABLED=%q is not a boolean, ignoring\n",
value,
)
}
}
if cfg.Tenant.SelfServiceCreationEnabled == nil {
on := true
cfg.Tenant.SelfServiceCreationEnabled = &on
}
if value := strings.TrimSpace(os.Getenv("WEKNORA_TENANT_MAX_OWNED_PER_USER")); value != "" {
if n, err := strconv.Atoi(value); err == nil {
cfg.Tenant.MaxOwnedPerUser = n
+16 -5
View File
@@ -24,11 +24,12 @@ const (
ErrValidation ErrorCode = 1010
// Tenant related error codes (2000-2099)
ErrTenantNotFound ErrorCode = 2000
ErrTenantAlreadyExists ErrorCode = 2001
ErrTenantInactive ErrorCode = 2002
ErrTenantNameRequired ErrorCode = 2003
ErrTenantInvalidStatus ErrorCode = 2004
ErrTenantNotFound ErrorCode = 2000
ErrTenantAlreadyExists ErrorCode = 2001
ErrTenantInactive ErrorCode = 2002
ErrTenantNameRequired ErrorCode = 2003
ErrTenantInvalidStatus ErrorCode = 2004
ErrTenantCreationDisabled ErrorCode = 2005
// Agent related error codes (2100-2199)
ErrAgentMissingThinkingModel ErrorCode = 2100
@@ -184,6 +185,16 @@ func NewTenantInactiveError() *AppError {
}
}
// NewTenantCreationDisabledError reports a deployment-policy denial for
// ordinary self-service tenant creation.
func NewTenantCreationDisabledError() *AppError {
return &AppError{
Code: ErrTenantCreationDisabled,
Message: "self-service tenant creation is disabled; join a workspace by invitation",
HTTPCode: http.StatusForbidden,
}
}
// Agent related errors
func NewAgentMissingThinkingModelError() *AppError {
return &AppError{
+35 -3
View File
@@ -101,6 +101,31 @@ func (h *AuthHandler) resolveRegistrationMode(ctx context.Context) string {
return h.systemSettingSvc.GetString(ctx, "auth.registration_mode", "", def)
}
// resolveDefaultTenantMode returns the provisioning policy for ordinary
// public password registrations. Invitation registration never uses this
// value: the invitation itself supplies the target tenant.
func (h *AuthHandler) resolveDefaultTenantMode(ctx context.Context) types.TenantProvisioningMode {
def := config.AuthDefaultTenantModeCreatePersonal
if h.configInfo != nil && h.configInfo.Auth != nil {
if mode := strings.TrimSpace(h.configInfo.Auth.DefaultTenantMode); mode != "" {
def = mode
}
}
mode := def
if h.systemSettingSvc != nil {
mode = h.systemSettingSvc.GetString(
ctx,
"auth.default_tenant_mode",
"WEKNORA_AUTH_DEFAULT_TENANT_MODE",
def,
)
}
if mode == config.AuthDefaultTenantModeTenantless {
return types.TenantProvisioningTenantless
}
return types.TenantProvisioningCreatePersonal
}
// Register godoc
// @Summary 用户注册
// @Description 注册新用户账号
@@ -150,6 +175,7 @@ func (h *AuthHandler) Register(c *gin.Context) {
}
req.Username = secutils.SanitizeForLog(req.Username)
req.Email = secutils.SanitizeForLog(req.Email)
req.TenantProvisioning = h.resolveDefaultTenantMode(ctx)
// Call service to register user
user, err := h.userService.Register(ctx, &req)
if err != nil {
@@ -536,12 +562,18 @@ func (h *AuthHandler) GetCurrentUser(c *gin.Context) {
// 同步返回当前用户的 memberships,让前端在页面刷新(仅命中 /auth/me)
// 后也能恢复 currentTenantRole,避免角色信息只在 login 那一刻可用。
memberships := h.userService.BuildLoginMemberships(ctx, user, tenant)
canCreateTenant := user.CanAccessAllTenants ||
resolveTenantSelfServiceCreationEnabled(ctx, h.configInfo, h.systemSettingSvc)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"user": userInfo,
"tenant": dto.NewTenantResponse(ctx, tenant),
"memberships": memberships,
"user": userInfo,
"tenant": dto.NewTenantResponse(ctx, tenant),
"memberships": memberships,
"tenant_required": tenant == nil,
"capabilities": gin.H{
"can_create_tenant": canCreateTenant,
},
},
})
}
+22 -5
View File
@@ -170,9 +170,10 @@ func (h *AuthHandler) RegisterByInvite(c *gin.Context) {
}
user, err := h.userService.Register(ctx, &types.RegisterRequest{
Username: req.Username,
Email: req.Email,
Password: req.Password,
Username: req.Username,
Email: req.Email,
Password: req.Password,
TenantProvisioning: types.TenantProvisioningTenantless,
})
if err != nil {
logger.Errorf(ctx, "register-by-invite: user create failed for %s: %v",
@@ -181,10 +182,26 @@ func (h *AuthHandler) RegisterByInvite(c *gin.Context) {
return
}
// The invited tenant becomes the user's initial/default tenant. No
user.TenantID = inv.TenantID
if err := h.userService.UpdateUser(ctx, user); err != nil {
logger.Errorf(ctx, "register-by-invite: failed to set home tenant for user %s: %v", user.ID, err)
_ = h.userService.DeleteUser(ctx, user.ID)
c.Error(apperrors.NewInternalServerError("failed to finalise invited account").WithDetails(err.Error()))
return
}
if _, err := h.invitationSvc.AcceptByToken(ctx, req.Token, user.ID); err != nil {
// Race: link was revoked between Lookup and Accept. The user
// account is created either way — they can still log in.
// Race: link was revoked between Lookup and Accept. Keep the new
// account, but restore it to tenantless so it does not point at a
// tenant for which no membership was created. If even that repair
// fails, remove the half-provisioned identity.
logger.Errorf(ctx, "register-by-invite: accept failed for user %s: %v", user.ID, err)
user.TenantID = 0
if rollbackErr := h.userService.UpdateUser(ctx, user); rollbackErr != nil {
logger.Errorf(ctx, "register-by-invite: failed to restore tenantless user %s: %v", user.ID, rollbackErr)
_ = h.userService.DeleteUser(ctx, user.ID)
}
c.Error(&apperrors.AppError{
Code: apperrors.ErrNotFound,
Message: "invitation link is no longer valid; please log in to your new account",
@@ -0,0 +1,122 @@
package handler
import (
"bytes"
"context"
"errors"
"net/http"
"net/http/httptest"
"testing"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
type invitedRegistrationUserService struct {
interfaces.UserService
registeredMode types.TenantProvisioningMode
updatedTenant uint64
updateCalls []uint64
}
func (s *invitedRegistrationUserService) GetUserByEmail(context.Context, string) (*types.User, error) {
return nil, nil
}
func (s *invitedRegistrationUserService) Register(_ context.Context, req *types.RegisterRequest) (*types.User, error) {
s.registeredMode = req.TenantProvisioning
return &types.User{ID: "new-user", Username: req.Username, Email: req.Email, IsActive: true}, nil
}
func (s *invitedRegistrationUserService) UpdateUser(_ context.Context, user *types.User) error {
s.updatedTenant = user.TenantID
s.updateCalls = append(s.updateCalls, user.TenantID)
return nil
}
func (s *invitedRegistrationUserService) GenerateTokens(context.Context, *types.User) (string, string, error) {
return "access", "refresh", nil
}
type invitedRegistrationInvitationService struct {
interfaces.TenantInvitationService
acceptErr error
}
func (s *invitedRegistrationInvitationService) LookupByToken(context.Context, string) (*types.TenantInvitation, error) {
return &types.TenantInvitation{TenantID: 42, Role: types.TenantRoleViewer}, nil
}
func (s *invitedRegistrationInvitationService) AcceptByToken(context.Context, string, string) (*types.TenantMember, error) {
if s.acceptErr != nil {
return nil, s.acceptErr
}
return &types.TenantMember{TenantID: 42, Role: types.TenantRoleViewer}, nil
}
type invitedRegistrationTenantService struct {
interfaces.TenantService
}
func TestRegisterByInviteRestoresTenantlessAccountWhenInviteExpiresDuringRegistration(t *testing.T) {
gin.SetMode(gin.TestMode)
users := &invitedRegistrationUserService{}
h := &AuthHandler{
userService: users,
tenantService: &invitedRegistrationTenantService{},
invitationSvc: &invitedRegistrationInvitationService{acceptErr: errors.New("expired")},
}
r := gin.New()
r.Use(errorCapture())
r.POST("/auth/register-by-invite", h.RegisterByInvite)
body := []byte(`{"token":"invite-token","email":"alice@example.com","username":"alice","password":"supersecret"}`)
req := httptest.NewRequest(http.MethodPost, "/auth/register-by-invite", bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
r.ServeHTTP(w, req)
if w.Code != http.StatusGone {
t.Fatalf("status=%d body=%s", w.Code, w.Body.String())
}
if users.updatedTenant != 0 {
t.Fatalf("updated tenant=%d, want tenantless rollback", users.updatedTenant)
}
if len(users.updateCalls) != 2 || users.updateCalls[0] != 42 || users.updateCalls[1] != 0 {
t.Fatalf("update calls=%v, want [42 0]", users.updateCalls)
}
}
func (s *invitedRegistrationTenantService) GetTenantByID(context.Context, uint64) (*types.Tenant, error) {
return &types.Tenant{ID: 42, Name: "Invited Workspace"}, nil
}
func TestRegisterByInviteUsesInvitedTenantWithoutPersonalTenant(t *testing.T) {
gin.SetMode(gin.TestMode)
users := &invitedRegistrationUserService{}
h := &AuthHandler{
userService: users,
tenantService: &invitedRegistrationTenantService{},
invitationSvc: &invitedRegistrationInvitationService{},
}
r := gin.New()
r.Use(errorCapture())
r.POST("/auth/register-by-invite", h.RegisterByInvite)
body := []byte(`{"token":"invite-token","email":"alice@example.com","username":"alice","password":"supersecret"}`)
req := httptest.NewRequest(http.MethodPost, "/auth/register-by-invite", bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
r.ServeHTTP(w, req)
if w.Code != http.StatusCreated {
t.Fatalf("status=%d body=%s", w.Code, w.Body.String())
}
if users.registeredMode != types.TenantProvisioningTenantless {
t.Fatalf("register mode=%q, want tenantless", users.registeredMode)
}
if users.updatedTenant != 42 {
t.Fatalf("updated tenant=%d, want 42", users.updatedTenant)
}
}
@@ -107,8 +107,11 @@ func TestRegister_SelfServeAllowsRegistration(t *testing.T) {
// through by observing the stub being invoked.
called := false
us := &stubRegisterUserService{
register: func(_ context.Context, _ *types.RegisterRequest) (*types.User, error) {
register: func(_ context.Context, req *types.RegisterRequest) (*types.User, error) {
called = true
if req.TenantProvisioning != types.TenantProvisioningCreatePersonal {
t.Fatalf("default provisioning = %q, want create_personal", req.TenantProvisioning)
}
return &types.User{ID: "u1", Email: "alice@example.com"}, nil
},
}
@@ -125,6 +128,28 @@ func TestRegister_SelfServeAllowsRegistration(t *testing.T) {
}
}
func TestRegister_TenantlessProvisioningFromConfig(t *testing.T) {
us := &stubRegisterUserService{
register: func(_ context.Context, req *types.RegisterRequest) (*types.User, error) {
if req.TenantProvisioning != types.TenantProvisioningTenantless {
t.Fatalf("provisioning = %q, want tenantless", req.TenantProvisioning)
}
return &types.User{ID: "u1", Email: "alice@example.com"}, nil
},
}
h := NewAuthHandler(&config.Config{
Auth: &config.AuthConfig{
RegistrationMode: config.AuthRegistrationModeSelfServe,
DefaultTenantMode: config.AuthDefaultTenantModeTenantless,
},
}, us, nil, nil, nil)
w := doRegister(t, newRegisterTestRouter(h), validRegisterBody())
if w.Code != http.StatusCreated {
t.Fatalf("tenantless self-serve registration got %d body=%s", w.Code, w.Body.String())
}
}
func TestRegister_NilAuthConfigDoesNotPanic(t *testing.T) {
// Defensive: a nil Auth section means the operator hasn't set the
// registration mode at all, which must not crash and must keep the
+30 -2
View File
@@ -31,8 +31,8 @@ type TenantHandler struct {
memberService interfaces.TenantMemberService
kbService interfaces.KnowledgeBaseService
config *config.Config
// systemSettingSvc resolves runtime tunables for tenant limits
// (currently `tenant.max_owned_per_user`). Reading goes DB > ENV >
// systemSettingSvc resolves runtime tenant policies and limits.
// Reading goes DB > ENV >
// in-code default, so a SystemAdmin's UI override applies on the
// very next CreateTenant call.
systemSettingSvc interfaces.SystemSettingService
@@ -228,6 +228,17 @@ func (h *TenantHandler) CreateTenant(c *gin.Context) {
return
}
// Deployment-level policy: ordinary users may be restricted to joining
// existing workspaces by invitation. This check is authoritative; the
// frontend capability only improves UX and cannot bypass it. Cross-tenant
// superusers retain the catalog-management create path.
if !caller.CanAccessAllTenants &&
!resolveTenantSelfServiceCreationEnabled(ctx, h.config, h.systemSettingSvc) {
logger.Warnf(ctx, "Self-service tenant creation denied by policy for user %s", caller.ID)
c.Error(errors.NewTenantCreationDisabledError())
return
}
var tenantData types.Tenant
if caller.CanAccessAllTenants {
@@ -402,6 +413,23 @@ func (h *TenantHandler) CreateTenant(c *gin.Context) {
}
}
// When a tenantless user creates their first workspace, make it their
// default login tenant. Roll the just-created resources back if this
// finalisation fails so the user is not left with an unreachable tenant.
if caller.TenantID == 0 {
caller.TenantID = createdTenant.ID
if err := h.userService.UpdateUser(ctx, caller); err != nil {
logger.Errorf(ctx, "Failed to set first tenant %d as default for user %s: %v",
createdTenant.ID, caller.ID, err)
if h.memberService != nil {
_ = h.memberService.RemoveMember(ctx, caller.ID, createdTenant.ID)
}
_ = h.service.DeleteTenant(ctx, createdTenant.ID)
c.Error(errors.NewInternalServerError("Failed to finalise default tenant").WithDetails(err.Error()))
return
}
}
logger.Infof(
ctx,
"Tenant created successfully, ID: %d, name: %s",
+13
View File
@@ -490,6 +490,19 @@ func (h *TenantInvitationHandler) AcceptMyInvitation(c *gin.Context) {
return
}
// A tenantless account adopts the first accepted invitation as its
// default tenant. Membership remains the authorization source; TenantID
// only supplies the login/navigation default.
if user, userErr := h.userService.GetUserByID(ctx, caller); userErr == nil && user != nil && user.TenantID == 0 {
user.TenantID = member.TenantID
if updateErr := h.userService.UpdateUser(ctx, user); updateErr != nil {
logger.Errorf(ctx, "AcceptMyInvitation failed to set default tenant: user=%s tenant=%d err=%v",
caller, member.TenantID, updateErr)
c.Error(apperrors.NewInternalServerError("invitation accepted but default tenant update failed").WithDetails(updateErr.Error()))
return
}
}
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
+37
View File
@@ -0,0 +1,37 @@
package handler
import (
"context"
"github.com/Tencent/WeKnora/internal/config"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
const (
tenantSelfServiceCreationSettingKey = "tenant.self_service_creation_enabled"
tenantSelfServiceCreationEnvName = "WEKNORA_TENANT_SELF_SERVICE_CREATION_ENABLED"
)
// resolveTenantSelfServiceCreationEnabled is the shared policy resolver used
// both by POST /tenants enforcement and /auth/me capability projection. Keeping
// both on one function prevents the UI from advertising a capability that the
// backend would reject.
func resolveTenantSelfServiceCreationEnabled(
ctx context.Context,
cfg *config.Config,
settings interfaces.SystemSettingService,
) bool {
enabled := true
if cfg != nil && cfg.Tenant != nil {
enabled = cfg.Tenant.IsSelfServiceCreationEnabled()
}
if settings == nil {
return enabled
}
return settings.GetBool(
ctx,
tenantSelfServiceCreationSettingKey,
tenantSelfServiceCreationEnvName,
enabled,
)
}
@@ -0,0 +1,146 @@
package handler
import (
"bytes"
"context"
"net/http"
"net/http/httptest"
"strings"
"testing"
"github.com/Tencent/WeKnora/internal/config"
apperrors "github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
func tenantPolicyErrorCapture() gin.HandlerFunc {
return func(c *gin.Context) {
c.Next()
if len(c.Errors) == 0 {
return
}
if appErr, ok := c.Errors.Last().Err.(*apperrors.AppError); ok {
c.JSON(appErr.HTTPCode, gin.H{"error": appErr})
}
}
}
type tenantPolicySettingService struct {
interfaces.SystemSettingService
enabled bool
}
func (s *tenantPolicySettingService) GetBool(context.Context, string, string, bool) bool {
return s.enabled
}
func (s *tenantPolicySettingService) GetInt(_ context.Context, _ string, _ string, def int64) int64 {
return def
}
type tenantPolicyUserService struct {
interfaces.UserService
user *types.User
}
func (s *tenantPolicyUserService) GetCurrentUser(context.Context) (*types.User, error) {
return s.user, nil
}
func (s *tenantPolicyUserService) BuildLoginMemberships(context.Context, *types.User, *types.Tenant) []types.Membership {
return []types.Membership{}
}
type tenantPolicyTenantService struct {
interfaces.TenantService
createCalls int
}
func (s *tenantPolicyTenantService) CreateTenant(_ context.Context, tenant *types.Tenant) (*types.Tenant, error) {
s.createCalls++
tenant.ID = 99
return tenant, nil
}
func TestCreateTenantRejectsRegularUserWhenSelfServiceDisabled(t *testing.T) {
gin.SetMode(gin.TestMode)
tenants := &tenantPolicyTenantService{}
h := &TenantHandler{
service: tenants,
userService: &tenantPolicyUserService{user: &types.User{ID: "regular-user"}},
config: &config.Config{Tenant: &config.TenantConfig{}},
systemSettingSvc: &tenantPolicySettingService{enabled: false},
}
r := gin.New()
r.Use(tenantPolicyErrorCapture())
r.POST("/tenants", h.CreateTenant)
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPost, "/tenants", bytes.NewBufferString(`{"name":"blocked"}`))
req.Header.Set("Content-Type", "application/json")
r.ServeHTTP(w, req)
if w.Code != http.StatusForbidden {
t.Fatalf("status=%d body=%s", w.Code, w.Body.String())
}
if tenants.createCalls != 0 {
t.Fatalf("CreateTenant called %d times, want 0", tenants.createCalls)
}
if !strings.Contains(w.Body.String(), `"code":2005`) {
t.Fatalf("response missing typed disabled code: %s", w.Body.String())
}
}
func TestCreateTenantAllowsCrossTenantSuperuserWhenSelfServiceDisabled(t *testing.T) {
gin.SetMode(gin.TestMode)
tenants := &tenantPolicyTenantService{}
h := &TenantHandler{
service: tenants,
userService: &tenantPolicyUserService{user: &types.User{
ID: "super-user",
TenantID: 1,
CanAccessAllTenants: true,
}},
config: &config.Config{Tenant: &config.TenantConfig{}},
systemSettingSvc: &tenantPolicySettingService{enabled: false},
}
r := gin.New()
r.Use(errorCapture())
r.POST("/tenants", h.CreateTenant)
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPost, "/tenants", bytes.NewBufferString(`{"name":"admin-created"}`))
req.Header.Set("Content-Type", "application/json")
r.ServeHTTP(w, req)
if w.Code != http.StatusCreated {
t.Fatalf("status=%d body=%s", w.Code, w.Body.String())
}
if tenants.createCalls != 1 {
t.Fatalf("CreateTenant called %d times, want 1", tenants.createCalls)
}
}
func TestAuthMeProjectsTenantCreationCapability(t *testing.T) {
gin.SetMode(gin.TestMode)
h := &AuthHandler{
userService: &tenantPolicyUserService{user: &types.User{
ID: "tenantless-user",
Username: "tenantless",
Email: "tenantless@example.com",
}},
configInfo: &config.Config{Tenant: &config.TenantConfig{}},
systemSettingSvc: &tenantPolicySettingService{enabled: false},
}
r := gin.New()
r.GET("/auth/me", h.GetCurrentUser)
w := httptest.NewRecorder()
r.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/auth/me", nil))
if w.Code != http.StatusOK {
t.Fatalf("status=%d body=%s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), `"can_create_tenant":false`) {
t.Fatalf("response missing capability: %s", w.Body.String())
}
}
+89
View File
@@ -77,6 +77,45 @@ func isNoAuthAPI(path string, method string) bool {
return false
}
// isTenantOptionalAPI lists authenticated identity-level operations that are
// meaningful before a user belongs to any tenant. Every other authenticated
// route remains tenant-scoped and returns TENANT_REQUIRED when the JWT and
// request headers do not resolve a tenant.
func isTenantOptionalAPI(path, method string) bool {
switch {
case path == "/api/v1/auth/me" && (method == http.MethodGet || method == http.MethodPut):
return true
case path == "/api/v1/auth/logout" && method == http.MethodPost:
return true
case path == "/api/v1/auth/change-password" && method == http.MethodPost:
return true
case path == "/api/v1/auth/validate" && method == http.MethodGet:
return true
case path == "/api/v1/auth/switch-tenant" && method == http.MethodPost:
return true
case path == "/api/v1/tenants" && method == http.MethodPost:
return true
case strings.HasPrefix(path, "/api/v1/me/invitations"):
return true
default:
return false
}
}
func attachTenantlessUserContext(c *gin.Context, user *types.User) {
principal := types.Principal{Type: types.PrincipalWebUser, ID: user.ID}
c.Set(types.UserContextKey.String(), user)
c.Set(types.UserIDContextKey.String(), user.ID)
c.Set(types.SystemAdminContextKey.String(), user.IsSystemAdmin)
c.Set(types.PrincipalContextKey.String(), principal)
ctx := c.Request.Context()
ctx = context.WithValue(ctx, types.UserContextKey, user)
ctx = context.WithValue(ctx, types.UserIDContextKey, user.ID)
ctx = context.WithValue(ctx, types.SystemAdminContextKey, user.IsSystemAdmin)
ctx = types.WithPrincipal(ctx, principal)
c.Request = c.Request.WithContext(ctx)
}
// Auth 认证中间件
func Auth(
tenantService interfaces.TenantService,
@@ -157,6 +196,25 @@ func Auth(
}
}
if targetTenantID == 0 {
targetTenantID = resolveFirstMembershipTarget(c.Request.Context(), user, memberService, tenantService)
crossTenantSwitch = targetTenantID != user.TenantID
}
if targetTenantID == 0 {
if isTenantOptionalAPI(c.Request.URL.Path, c.Request.Method) {
attachTenantlessUserContext(c, user)
c.Next()
return
}
c.JSON(http.StatusConflict, gin.H{
"error": "Tenant required",
"code": "TENANT_REQUIRED",
})
c.Abort()
return
}
// 获取租户信息(使用目标租户ID)
tenant, err := tenantService.GetTenantByID(c.Request.Context(), targetTenantID)
if err != nil {
@@ -229,6 +287,37 @@ func Auth(
}
}
// resolveFirstMembershipTarget lets a tenantless session immediately become
// usable once an active membership exists (for example after accepting its
// first invitation or being added directly by an administrator). The user
// service persists the same earliest-membership choice on the next token
// issuance; middleware keeps the current JWT usable until then.
func resolveFirstMembershipTarget(
ctx context.Context,
user *types.User,
memberService interfaces.TenantMemberService,
tenantService interfaces.TenantService,
) uint64 {
if user == nil || memberService == nil || tenantService == nil {
return 0
}
members, err := memberService.ListByUser(ctx, user.ID)
if err != nil {
logger.Warnf(ctx, "Failed to list memberships for tenantless user %s: %v", user.ID, err)
return 0
}
for _, member := range members {
if member == nil || member.TenantID == 0 || member.Status != types.TenantMemberStatusActive {
continue
}
tenant, err := tenantService.GetTenantByID(ctx, member.TenantID)
if err == nil && tenant != nil {
return member.TenantID
}
}
return 0
}
func authenticateAPIKeyRequest(
c *gin.Context,
tenantService interfaces.TenantService,
+11 -4
View File
@@ -24,9 +24,9 @@ type fakeMemberService struct {
TenantID uint64
Role types.TenantRole
}
failGet error
failHasAny error
failAdd error
failGet error
failHasAny error
failAdd error
// 阻止 auto-promote 把 hasAny 翻面:默认 AddMember 成功也会写入 members map。
}
@@ -102,7 +102,14 @@ func (f *fakeMemberService) GetMembership(
}
func (f *fakeMemberService) ListByUser(ctx context.Context, userID string) ([]*types.TenantMember, error) {
return nil, nil
var out []*types.TenantMember
for _, member := range f.members {
if member.UserID == userID && member.Status == types.TenantMemberStatusActive {
copy := *member
out = append(out, &copy)
}
}
return out, nil
}
func (f *fakeMemberService) ListByTenant(ctx context.Context, tenantID uint64) ([]*types.TenantMember, error) {
return nil, nil
@@ -0,0 +1,46 @@
package middleware
import (
"context"
"net/http"
"testing"
"github.com/Tencent/WeKnora/internal/types"
)
func TestTenantOptionalAPISurface(t *testing.T) {
tests := []struct {
method string
path string
want bool
}{
{http.MethodGet, "/api/v1/auth/me", true},
{http.MethodPut, "/api/v1/auth/me", true},
{http.MethodPost, "/api/v1/tenants", true},
{http.MethodGet, "/api/v1/me/invitations", true},
{http.MethodPost, "/api/v1/me/invitations/12/accept", true},
{http.MethodGet, "/api/v1/knowledge-bases", false},
{http.MethodGet, "/api/v1/tenants", false},
}
for _, tt := range tests {
if got := isTenantOptionalAPI(tt.path, tt.method); got != tt.want {
t.Errorf("isTenantOptionalAPI(%s %s) = %v, want %v", tt.method, tt.path, got, tt.want)
}
}
}
func TestResolveFirstMembershipTarget(t *testing.T) {
members := newFakeMemberService()
members.seedActive("tenantless-user", 42, types.TenantRoleViewer)
tenants := &fakeTenantService{tenant: &types.Tenant{ID: 42}}
got := resolveFirstMembershipTarget(
context.Background(),
&types.User{ID: "tenantless-user"},
members,
tenants,
)
if got != 42 {
t.Fatalf("resolved tenant = %d, want 42", got)
}
}
+21
View File
@@ -185,6 +185,27 @@ type RegisterRequest struct {
Username string `json:"username" binding:"required,min=2,max=50"`
Email string `json:"email" binding:"required,email"`
Password string `json:"password" binding:"required,min=6"`
// TenantProvisioning is server-controlled registration context. It is
// deliberately excluded from JSON so a public caller cannot choose its
// own tenancy semantics. Empty preserves the historical behaviour and is
// treated as create_personal by UserService.Register.
TenantProvisioning TenantProvisioningMode `json:"-"`
}
// TenantProvisioningMode controls what UserService.Register does after it
// has validated the identity fields. Joining an existing tenant is
// orchestrated by the invitation handler because the invitation token is the
// authority for the target tenant and role.
type TenantProvisioningMode string
const (
TenantProvisioningCreatePersonal TenantProvisioningMode = "create_personal"
TenantProvisioningTenantless TenantProvisioningMode = "tenantless"
)
func (m TenantProvisioningMode) IsValid() bool {
return m == TenantProvisioningCreatePersonal || m == TenantProvisioningTenantless
}
// LoginResponse represents a login response