RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
feat(tenant): add tenant roles and permissions (#21257)
buua43607209543cfc3
diff --git a/internal/admin/service.go b/internal/admin/service.goindex 264c79e7c9..fe4e017265 100644--- a/internal/admin/service.go+++ b/internal/admin/service.go@@ -47,25 +47,26 @@ import (// Service admin service layertype Service struct {- userDAO *dao.UserDAO- licenseDAO *dao.LicenseDAO- timeRecordDAO *dao.TimeRecordDAO- systemSettingsDAO *dao.SystemSettingsDAO- tenantDAO *dao.TenantDAO- userTenantDAO *dao.UserTenantDAO- fileDAO *dao.FileDAO- documentDAO *dao.DocumentDAO- taskDAO *dao.TaskDAO- kbDAO *dao.KnowledgebaseDAO- canvasDAO *dao.UserCanvasDAO- chatDAO *dao.ChatDAO- chatSessionDAO *dao.ChatSessionDAO- apiTokenDAO *dao.APITokenDAO- api4ConvDAO *dao.API4ConversationDAO- llmDAO *dao.LLMDAO- ingestionTaskDAO *dao.IngestionTaskDAO- ingestionTaskLogDao *dao.IngestionTaskLogDAO- ingestionTaskSvc *servicepkg.IngestionTaskService+ userDAO *dao.UserDAO+ licenseDAO *dao.LicenseDAO+ timeRecordDAO *dao.TimeRecordDAO+ systemSettingsDAO *dao.SystemSettingsDAO+ tenantDAO *dao.TenantDAO+ userTenantDAO *dao.UserTenantDAO+ fileDAO *dao.FileDAO+ documentDAO *dao.DocumentDAO+ taskDAO *dao.TaskDAO+ kbDAO *dao.KnowledgebaseDAO+ canvasDAO *dao.UserCanvasDAO+ chatDAO *dao.ChatDAO+ chatSessionDAO *dao.ChatSessionDAO+ apiTokenDAO *dao.APITokenDAO+ api4ConvDAO *dao.API4ConversationDAO+ llmDAO *dao.LLMDAO+ ingestionTaskDAO *dao.IngestionTaskDAO+ ingestionTaskLogDao *dao.IngestionTaskLogDAO+ ingestionTaskSvc *servicepkg.IngestionTaskService+ modelProviderService *servicepkg.ModelProviderServiceBillingProductDAO *dao.BillingProductDAOBillingSubscriptionDAO *dao.BillingSubscriptionDAO@@ -78,25 +79,26 @@ type Service struct {// NewService create admin servicefunc NewService() *Service {return &Service{- userDAO: dao.NewUserDAO(),- licenseDAO: dao.NewLicenseDAO(),- timeRecordDAO: dao.NewTimeRecordDAO(),- systemSettingsDAO: dao.NewSystemSettingsDAO(),- tenantDAO: dao.NewTenantDAO(),- userTenantDAO: dao.NewUserTenantDAO(),- fileDAO: dao.NewFileDAO(),- documentDAO: dao.NewDocumentDAO(),- taskDAO: dao.NewTaskDAO(),- kbDAO: dao.NewKnowledgebaseDAO(),- canvasDAO: dao.NewUserCanvasDAO(),- chatDAO: dao.NewChatDAO(),- chatSessionDAO: dao.NewChatSessionDAO(),- apiTokenDAO: dao.NewAPITokenDAO(),- api4ConvDAO: dao.NewAPI4ConversationDAO(),- llmDAO: dao.NewLLMDAO(),- ingestionTaskDAO: dao.NewIngestionTaskDAO(),- ingestionTaskLogDao: dao.NewIngestionTaskLogDAO(),- ingestionTaskSvc: servicepkg.NewIngestionTaskService(),+ userDAO: dao.NewUserDAO(),+ licenseDAO: dao.NewLicenseDAO(),+ timeRecordDAO: dao.NewTimeRecordDAO(),+ systemSettingsDAO: dao.NewSystemSettingsDAO(),+ tenantDAO: dao.NewTenantDAO(),+ userTenantDAO: dao.NewUserTenantDAO(),+ fileDAO: dao.NewFileDAO(),+ documentDAO: dao.NewDocumentDAO(),+ taskDAO: dao.NewTaskDAO(),+ kbDAO: dao.NewKnowledgebaseDAO(),+ canvasDAO: dao.NewUserCanvasDAO(),+ chatDAO: dao.NewChatDAO(),+ chatSessionDAO: dao.NewChatSessionDAO(),+ apiTokenDAO: dao.NewAPITokenDAO(),+ api4ConvDAO: dao.NewAPI4ConversationDAO(),+ llmDAO: dao.NewLLMDAO(),+ ingestionTaskDAO: dao.NewIngestionTaskDAO(),+ ingestionTaskLogDao: dao.NewIngestionTaskLogDAO(),+ ingestionTaskSvc: servicepkg.NewIngestionTaskService(),+ modelProviderService: servicepkg.NewModelProviderService(),BillingProductDAO: dao.NewBillingProductDAO(),BillingSubscriptionDAO: dao.NewBillingSubscriptionDAO(),@@ -284,7 +286,11 @@ func (s *Service) CreateUser(ctx context.Context, username, password, role strinCredit: 512,Status: &tenantStatus,}- if err = tx.Create(tenant).Error; err != nil {+ if err = dao.ApplyDefaultTenantInviteEnabled(ctx, tx, tenant); err != nil {+ rollbackTx()+ return nil, fmt.Errorf("failed to initialize tenant invitation setting: %w", err)+ }+ if err = dao.NewTenantDAO().Create(ctx, tx, tenant); err != nil {rollbackTx()return nil, fmt.Errorf("failed to create tenant: %w", err)}@@ -1426,8 +1432,11 @@ func (s *Service) addTenantForAdmin(userID, nickname string) error {ID: userID,Name: &tenantName,}+ if err := dao.ApplyDefaultTenantInviteEnabled(context.Background(), dao.DB, tenant); err != nil {+ return fmt.Errorf("failed to initialize tenant invitation setting: %w", err)+ }- if err := dao.DB.Create(tenant).Error; err != nil {+ if err := dao.NewTenantDAO().Create(context.Background(), dao.DB, tenant); err != nil {return err}diff --git a/internal/dao/database.go b/internal/dao/database.goindex 025f03a87b..4432130963 100644--- a/internal/dao/database.go+++ b/internal/dao/database.go@@ -256,6 +256,9 @@ func InitDB(ctx context.Context, migrateDB bool) error {if err = migratePermissions(ctx, DB); err != nil {return fmt.Errorf("failed to migrate permissions: %w", err)}+ if err = migrateTenantModelProviderUserUniqueIndex(ctx, DB); err != nil {+ return fmt.Errorf("failed to migrate tenant model provider unique index: %w", err)+ }common.Info("Database schema migrated successfully")} else {if err = migrateIngestionLogRunIdentity(ctx, DB); err != nil {@@ -268,6 +271,9 @@ func InitDB(ctx context.Context, migrateDB bool) error {return fmt.Errorf("failed to auto-migrate runtime models: %w", err)}}+ if err = initializeSystemSettingsEE(ctx, DB); err != nil {+ return fmt.Errorf("failed to initialize enterprise system settings: %w", err)+ }// Conversation lists filter by dialog and usually order by update time.for _, table := range []string{"conversation", "api_4_conversation"} {indexName := "idx_" + table + "_dialog_updated"diff --git a/internal/dao/database_ee.go b/internal/dao/database_ee.goindex 9d1fb8283c..a6baabe90b 100644--- a/internal/dao/database_ee.go+++ b/internal/dao/database_ee.go@@ -16,7 +16,17 @@package dao-// permissionDataModelsEE returns the entities included in the enterprise schema.+import (+ "context"++ "gorm.io/gorm"+)++// permissionDataModelsEE returns no additional entities in the community edition.func permissionDataModelsEE() []interface{} {return nil}++func initializeSystemSettingsEE(context.Context, *gorm.DB) error {+ return nil+}diff --git a/internal/dao/migration_version.go b/internal/dao/migration_version.goindex e9fdf6761f..098c1aced4 100644--- a/internal/dao/migration_version.go+++ b/internal/dao/migration_version.go@@ -56,6 +56,10 @@ const devPrereleaseIdentifier = "dev"// GetDatabaseMigrationVersion reads the stored migration version. It returns an// empty string when the marker or the system_settings table is absent.func GetDatabaseMigrationVersion(ctx context.Context, db *gorm.DB) (string, error) {+ return getDatabaseMigrationVersion(ctx, db, migrationDBVersionMarker)+}++func getDatabaseMigrationVersion(ctx context.Context, db *gorm.DB, marker string) (string, error) {scoped := db.WithContext(ctx)if !scoped.Migrator().HasTable("system_settings") {common.Info("Table 'system_settings' does not exist, migration version marker is unavailable")@@ -63,7 +67,7 @@ func GetDatabaseMigrationVersion(ctx context.Context, db *gorm.DB) (string, erro}var value string- err := scoped.Raw("SELECT `value` FROM `system_settings` WHERE `name` = ?", migrationDBVersionMarker).Row().Scan(&value)+ err := scoped.Raw("SELECT `value` FROM `system_settings` WHERE `name` = ?", marker).Row().Scan(&value)if err != nil {if errors.Is(err, sql.ErrNoRows) {return "", nil@@ -75,6 +79,10 @@ func GetDatabaseMigrationVersion(ctx context.Context, db *gorm.DB) (string, erro// setDatabaseMigrationVersion upserts the migration version marker.func setDatabaseMigrationVersion(ctx context.Context, db *gorm.DB, version string) error {+ return setDatabaseMigrationVersionForMarker(ctx, db, migrationDBVersionMarker, version)+}++func setDatabaseMigrationVersionForMarker(ctx context.Context, db *gorm.DB, marker, version string) error {scoped := db.WithContext(ctx)if !scoped.Migrator().HasTable("system_settings") {common.Warn("Table 'system_settings' does not exist, migration version marker was not saved")@@ -84,7 +92,7 @@ func setDatabaseMigrationVersion(ctx context.Context, db *gorm.DB, version strinnowMs := time.Now().UnixMilli()now := time.Now()setting := entity.SystemSettings{- Name: migrationDBVersionMarker,+ Name: marker,Source: "migration",DataType: "string",Value: version,diff --git a/internal/dao/permission_migration.go b/internal/dao/permission_migration.goindex ebf06dec15..40ed87aa16 100644--- a/internal/dao/permission_migration.go+++ b/internal/dao/permission_migration.go@@ -26,10 +26,16 @@ import ("gorm.io/gorm")-const permissionMigrationTargetVersion = "v1.0.0-rc3.dev1"+const permissionMigrationTargetVersion = "v1.0.0-rc3.dev3"// migratePermissions applies the permission schema migration and records its version.func migratePermissions(ctx context.Context, db *gorm.DB) error {+ // Enterprise migrations have their own marker. Run this hook before checking+ // the shared marker so a community migration cannot skip enterprise data work.+ if err := migratePermissionDataEE(ctx, db); err != nil {+ return fmt.Errorf("migrate enterprise permission data: %w", err)+ }+version, err := GetDatabaseMigrationVersion(ctx, db)if err != nil {return fmt.Errorf("read database migration version: %w", err)@@ -37,9 +43,6 @@ func migratePermissions(ctx context.Context, db *gorm.DB) error {if shouldSkipMigration(version, permissionMigrationTargetVersion) {return nil}- if err := migratePermissionDataEE(ctx, db); err != nil {- return fmt.Errorf("migrate enterprise permission data: %w", err)- }if err := migrateInvitedByNullable(ctx, db); err != nil {return err}diff --git a/internal/dao/permission_migration_test.go b/internal/dao/permission_migration_test.goindex 460f90dbd3..7ebc9de347 100644--- a/internal/dao/permission_migration_test.go+++ b/internal/dao/permission_migration_test.go@@ -79,7 +79,7 @@ func TestMigratePermissions(t *testing.T) {t.Fatalf("auto-migrate enterprise permission entities: %v", err)}ctx := context.Background()- if err := setDatabaseMigrationVersion(ctx, db, tenantModelMaxTokensTargetVersion); err != nil {+ if err := setDatabaseMigrationVersion(ctx, db, "v1.0.0-rc3.dev2"); err != nil {t.Fatalf("set previous migration version: %v", err)}if err := migratePermissions(ctx, db); err != nil {diff --git a/internal/dao/tenant.go b/internal/dao/tenant.goindex 3d95ffaefe..7561515b7c 100644--- a/internal/dao/tenant.go+++ b/internal/dao/tenant.go@@ -102,7 +102,12 @@ func (dao *TenantDAO) GetByID(ctx context.Context, db *gorm.DB, id string) (*ent// Create creates a new tenantfunc (dao *TenantDAO) Create(ctx context.Context, db *gorm.DB, tenant *entity.Tenant) error {- return db.WithContext(ctx).Create(tenant).Error+ return db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ if err := initializeTenantDefaultRoleEE(ctx, tx, tenant); err != nil {+ return err+ }+ return tx.Create(tenant).Error+ })}// GetAllIDs returns the IDs of all active tenants.diff --git a/internal/dao/tenant_invite_ee.go b/internal/dao/tenant_invite_ee.gonew file mode 100644index 0000000000..7f356d2631--- /dev/null+++ b/internal/dao/tenant_invite_ee.go@@ -0,0 +1,29 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package dao++import (+ "context"++ "ragflow/internal/entity"++ "gorm.io/gorm"+)++func ApplyDefaultTenantInviteEnabled(context.Context, *gorm.DB, *entity.Tenant) error {+ return nil+}diff --git a/internal/dao/tenant_model_provider_migration.go b/internal/dao/tenant_model_provider_migration.gonew file mode 100644index 0000000000..d237c0765c--- /dev/null+++ b/internal/dao/tenant_model_provider_migration.go@@ -0,0 +1,99 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package dao++import (+ "context"+ "fmt"+ "strings"++ "ragflow/internal/entity"++ "gorm.io/gorm"+)++const tenantModelProviderUserUniqueIndex = "idx_tenant_provider_user_unique"++// migrateTenantModelProviderUserUniqueIndex scopes provider names to the+// owning user and tenant. It removes the former (provider_name, tenant_id)+// constraint after the replacement index exists.+func migrateTenantModelProviderUserUniqueIndex(ctx context.Context, db *gorm.DB) error {+ scoped := db.WithContext(ctx)+ model := &entity.TenantModelProvider{}+ migrator := scoped.Migrator()+ if !migrator.HasTable(model) {+ return nil+ }+ if !migrator.HasColumn(model, "UserID") {+ return fmt.Errorf("tenant_model_provider.user_id is missing")+ }++ indexes, err := migrator.GetIndexes(model)+ if err != nil {+ return fmt.Errorf("inspect tenant_model_provider indexes: %w", err)+ }+ var hasUserScopedIndex bool+ for _, index := range indexes {+ if index.Name() == tenantModelProviderUserUniqueIndex && !sameIndexColumns(index.Columns(), []string{"provider_name", "tenant_id", "user_id"}) {+ if err := migrator.DropIndex(model, index.Name()); err != nil {+ return fmt.Errorf("drop malformed index %s: %w", index.Name(), err)+ }+ continue+ }+ unique, known := index.Unique()+ if known && unique && sameIndexColumns(index.Columns(), []string{"provider_name", "tenant_id", "user_id"}) {+ hasUserScopedIndex = true+ }+ }+ if !hasUserScopedIndex {+ if err := migrator.CreateIndex(model, tenantModelProviderUserUniqueIndex); err != nil {+ return fmt.Errorf("create user-scoped provider index: %w", err)+ }+ }++ indexes, err = migrator.GetIndexes(model)+ if err != nil {+ return fmt.Errorf("inspect tenant_model_provider indexes after creating replacement: %w", err)+ }+ for _, index := range indexes {+ unique, known := index.Unique()+ if !known || !unique || index.Name() == tenantModelProviderUserUniqueIndex {+ continue+ }+ if !sameIndexColumns(index.Columns(), []string{"provider_name", "tenant_id"}) {+ continue+ }+ if err := migrator.DropIndex(model, index.Name()); err != nil {+ return fmt.Errorf("drop legacy provider index %s: %w", index.Name(), err)+ }+ }+ return nil+}++func sameIndexColumns(columns, expected []string) bool {+ if len(columns) != len(expected) {+ return false+ }+ columnSet := make(map[string]struct{}, len(expected))+ for _, column := range expected {+ columnSet[strings.ToLower(column)] = struct{}{}+ }+ for _, column := range columns {+ delete(columnSet, strings.ToLower(column))+ }+ return len(columnSet) == 0+}diff --git a/internal/dao/tenant_model_provider_migration_test.go b/internal/dao/tenant_model_provider_migration_test.gonew file mode 100644index 0000000000..4cb74610c5--- /dev/null+++ b/internal/dao/tenant_model_provider_migration_test.go@@ -0,0 +1,88 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package dao++import (+ "context"+ "testing"++ "github.com/glebarez/sqlite"+ "gorm.io/gorm"+ "ragflow/internal/entity"+)++func TestMigrateTenantModelProviderUserUniqueIndex(t *testing.T) {+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{TranslateError: true})+ if err != nil {+ t.Fatalf("open database: %v", err)+ }+ if err = db.Exec(`CREATE TABLE tenant_model_provider (+ id varchar(32) PRIMARY KEY,+ user_id varchar(32),+ provider_name varchar(128) NOT NULL,+ tenant_id varchar(32) NOT NULL+ )`).Error; err != nil {+ t.Fatalf("create legacy provider table: %v", err)+ }+ if err = db.Exec("CREATE UNIQUE INDEX idx_tenant_provider_unique ON tenant_model_provider (provider_name, tenant_id)").Error; err != nil {+ t.Fatalf("create legacy provider index: %v", err)+ }+ if err = db.Exec(`INSERT INTO tenant_model_provider (id, user_id, provider_name, tenant_id)+ VALUES ('provider-1', 'user-1', 'OpenAI', 'tenant-1')`).Error; err != nil {+ t.Fatalf("create existing provider: %v", err)+ }+ if err = db.AutoMigrate(&entity.TenantModelProvider{}); err != nil {+ t.Fatalf("auto-migrate provider table: %v", err)+ }++ ctx := context.Background()+ if err = migrateTenantModelProviderUserUniqueIndex(ctx, db); err != nil {+ t.Fatalf("migrate provider index: %v", err)+ }+ if err = migrateTenantModelProviderUserUniqueIndex(ctx, db); err != nil {+ t.Fatalf("rerun provider index migration: %v", err)+ }++ indexes, err := db.Migrator().GetIndexes(&entity.TenantModelProvider{})+ if err != nil {+ t.Fatalf("inspect provider indexes: %v", err)+ }+ var hasUserScopedIndex, hasLegacyIndex bool+ for _, index := range indexes {+ if index.Name() == tenantModelProviderUserUniqueIndex {+ unique, known := index.Unique()+ hasUserScopedIndex = known && unique && sameIndexColumns(index.Columns(), []string{"provider_name", "tenant_id", "user_id"})+ }+ if sameIndexColumns(index.Columns(), []string{"provider_name", "tenant_id"}) {+ unique, known := index.Unique()+ hasLegacyIndex = known && unique+ }+ }+ if !hasUserScopedIndex {+ t.Fatal("user-scoped unique provider index was not created")+ }+ if hasLegacyIndex {+ t.Fatal("legacy unique provider index was not removed")+ }++ if err = db.Create(&entity.TenantModelProvider{ID: "provider-2", UserID: "user-2", ProviderName: "OpenAI", TenantID: "tenant-1"}).Error; err != nil {+ t.Fatalf("same provider name for another user in the tenant was rejected: %v", err)+ }+ if err = db.Create(&entity.TenantModelProvider{ID: "provider-3", UserID: "user-1", ProviderName: "OpenAI", TenantID: "tenant-1"}).Error; err == nil {+ t.Fatal("duplicate provider name for the same user and tenant was accepted")+ }+}diff --git a/internal/dao/tenant_role_ee.go b/internal/dao/tenant_role_ee.gonew file mode 100644index 0000000000..854bc9cafc--- /dev/null+++ b/internal/dao/tenant_role_ee.go@@ -0,0 +1,29 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package dao++import (+ "context"++ "ragflow/internal/entity"++ "gorm.io/gorm"+)++func initializeTenantDefaultRoleEE(context.Context, *gorm.DB, *entity.Tenant) error {+ return nil+}diff --git a/internal/entity/permission_change_log_ee.go b/internal/entity/permission_change_log_ee.gonew file mode 100644index 0000000000..fc35ea7f18--- /dev/null+++ b/internal/entity/permission_change_log_ee.go@@ -0,0 +1,24 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package entity++// PermissionChangeLog is a test-only placeholder in the community edition.+type PermissionChangeLog struct {+ BaseModel+}++func (PermissionChangeLog) TableName() string { return "permission_change_log" }diff --git a/internal/entity/permission_ee.go b/internal/entity/permission_ee.gonew file mode 100644index 0000000000..868e4c087a--- /dev/null+++ b/internal/entity/permission_ee.go@@ -0,0 +1,23 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package entity++const (+ TenantPermissionManageMembers int32 = 1 << iota+ TenantPermissionManageRoles+ TenantPermissionOwner+)diff --git a/internal/entity/tenant_model_provider.go b/internal/entity/tenant_model_provider.goindex cbb3c170a4..b62b6b9b12 100644--- a/internal/entity/tenant_model_provider.go+++ b/internal/entity/tenant_model_provider.go@@ -19,9 +19,9 @@ package entity// TenantModelProvider tenant model provider tabletype TenantModelProvider struct {ID string `gorm:"column:id;primaryKey;size:32" json:"id"`- UserID string `gorm:"column:user_id;size:32;index" json:"user_id"`- ProviderName string `gorm:"column:provider_name;size:128;not null;index:idx_tenant_provider_unique,unique" json:"provider_name"`- TenantID string `gorm:"column:tenant_id;size:32;not null;index;index:idx_tenant_provider_unique,unique" json:"tenant_id"`+ UserID string `gorm:"column:user_id;size:32;index;index:idx_tenant_provider_user_unique,unique,priority:3" json:"user_id"`+ ProviderName string `gorm:"column:provider_name;size:128;not null;index:idx_tenant_provider_user_unique,unique,priority:1" json:"provider_name"`+ TenantID string `gorm:"column:tenant_id;size:32;not null;index;index:idx_tenant_provider_user_unique,unique,priority:2" json:"tenant_id"`BaseModel}diff --git a/internal/entity/user.go b/internal/entity/user.goindex 4746ff0dac..59ec9a6aa2 100644--- a/internal/entity/user.go+++ b/internal/entity/user.go@@ -35,6 +35,7 @@ type User struct {IsAnonymous string `gorm:"column:is_anonymous;size:1;not null;default:0;index" json:"is_anonymous"`LoginChannel *string `gorm:"column:login_channel;index" json:"login_channel,omitempty"`Status *string `gorm:"column:status;size:1;default:1;index" json:"status"`+ RoleID *int32 `gorm:"column:role_id;index" json:"role_id,omitempty"`IsSuperuser *bool `gorm:"column:is_superuser;index" json:"is_superuser,omitempty"`BaseModel}diff --git a/internal/handler/tenant.go b/internal/handler/tenant.goindex 296846733d..ca093ef236 100644--- a/internal/handler/tenant.go+++ b/internal/handler/tenant.go@@ -345,6 +345,10 @@ func (h *TenantHandler) ListTenantMembers(c *gin.Context) {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")return}+ if !matchesActiveTenant(c, tenantID) {+ common.ErrorWithCode(c, common.CodeForbidden, "Tenant does not match the active token context")+ return+ }ctx := c.Request.Context()members, code, err := h.tenantService.ListMembers(ctx, user.ID, tenantID)@@ -502,6 +506,10 @@ func (h *TenantHandler) AddTenantMember(c *gin.Context) {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")return}+ if !matchesActiveTenant(c, tenantID) {+ common.ErrorWithCode(c, common.CodeForbidden, "Tenant does not match the active token context")+ return+ }var req service.AddMemberRequestif err := c.ShouldBindJSON(&req); err != nil {@@ -552,6 +560,10 @@ func (h *TenantHandler) RemoveTenantMember(c *gin.Context) {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")return}+ if !matchesActiveTenant(c, tenantID) {+ common.ErrorWithCode(c, common.CodeForbidden, "Tenant does not match the active token context")+ return+ }var body struct {UserID string `json:"user_id"`@@ -588,6 +600,10 @@ func (h *TenantHandler) AcceptTenantInvite(c *gin.Context) {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")return}+ if !matchesActiveTenant(c, tenantID) {+ common.ErrorWithCode(c, common.CodeForbidden, "Tenant does not match the active token context")+ return+ }ctx := c.Request.Context()code, err := h.tenantService.AcceptInvite(ctx, user.ID, tenantID)@@ -597,3 +613,8 @@ func (h *TenantHandler) AcceptTenantInvite(c *gin.Context) {}common.SuccessWithData(c, true, "success")}++func matchesActiveTenant(c *gin.Context, tenantID string) bool {+ activeTenantID := strings.TrimSpace(c.GetString("tenant_id"))+ return activeTenantID == "" || activeTenantID == tenantID+}diff --git a/internal/permission/database_source.go b/internal/permission/database_source.goindex 9e45245c8e..96b733931f 100644--- a/internal/permission/database_source.go+++ b/internal/permission/database_source.go@@ -58,15 +58,76 @@ func (s *databaseSource) GetMembership(ctx context.Context, userID, tenantID str}return nil, err}+ role, valid, err := s.resolveMembershipRole(ctx, relation.TenantID, relation.Role)+ if err != nil {+ return nil, err+ }+ if !valid {+ return nil, nil+ }return &Membership{ID: relation.ID,UserID: relation.UserID,TenantID: relation.TenantID,- Role: TenantRole(relation.Role),+ Role: role,Active: relation.Status != nil && *relation.Status == string(entity.StatusValid),}, nil}+func (s *databaseSource) resolveMembershipRole(ctx context.Context, tenantID, roleValue string) (TenantRole, bool, error) {+ role := TenantRole(strings.TrimSpace(roleValue))+ switch role {+ case RoleOwner, RoleAdmin, RoleNormal, RoleInvite:+ return role, true, nil+ }+ valid, err := isTenantRoleID(ctx, s.db, tenantID, string(role))+ if err != nil {+ return "", false, err+ }+ if !valid {+ return "", false, nil+ }+ // Feature roles grant capabilities, while tenant membership still denotes+ // ordinary membership to the shared resource policy.+ return RoleNormal, true, nil+}++func (s *databaseSource) activeTenantIDsForUser(ctx context.Context, userID string) ([]string, error) {+ if s == nil || s.db == nil {+ return nil, ErrSourceUnavailable+ }+ var memberships []entity.UserTenant+ if err := s.db.WithContext(ctx).+ Select("tenant_id", "role").+ Where("user_id = ? AND status = ?", userID, string(entity.StatusValid)).+ Find(&memberships).Error; err != nil {+ return nil, err+ }++ type roleResult struct {+ role TenantRole+ valid bool+ err error+ }+ resolved := make(map[string]roleResult)+ tenantIDs := make([]string, 0, len(memberships))+ for _, membership := range memberships {+ key := membership.TenantID + "\x00" + membership.Role+ result, ok := resolved[key]+ if !ok {+ result.role, result.valid, result.err = s.resolveMembershipRole(ctx, membership.TenantID, membership.Role)+ resolved[key] = result+ }+ if result.err != nil {+ return nil, result.err+ }+ if result.valid && result.role != RoleInvite {+ tenantIDs = append(tenantIDs, membership.TenantID)+ }+ }+ return uniqueStringValues(tenantIDs), nil+}+func (s *databaseSource) GetResources(ctx context.Context, refs []ResourceRef) ([]Resource, error) {if s == nil || s.db == nil {return nil, ErrSourceUnavailable@@ -411,13 +472,8 @@ func (s *databaseSource) ListResourceRefs(ctx context.Context, subject Subject,if parent.ID != "" || parent.Kind != "" {return nil, fmt.Errorf("%w: canvases cannot have a parent scope", ErrInvalidPermission)}- var tenantIDs []string- if err := s.db.WithContext(ctx).Model(&entity.UserTenant{}).- Distinct("tenant_id").- Where("user_id = ? AND status = ? AND role IN ?", subject.UserID, string(entity.StatusValid), []string{- string(RoleOwner), string(RoleAdmin), string(RoleNormal),- }).- Pluck("tenant_id", &tenantIDs).Error; err != nil {+ tenantIDs, err := s.activeTenantIDsForUser(ctx, subject.UserID)+ if err != nil {return nil, err}ownerIDs := append(append(make([]string, 0, len(tenantIDs)+1), tenantIDs...), subject.UserID)diff --git a/internal/permission/database_source_test.go b/internal/permission/database_source_test.goindex 27ab3a88a1..c64225a3dd 100644--- a/internal/permission/database_source_test.go+++ b/internal/permission/database_source_test.go@@ -97,6 +97,69 @@ func TestDatabaseCheckerAuthorizesDatasetFromPersistedRows(t *testing.T) {}}+func TestDatabaseCheckerValidatesTenantRoleIDsAndLegacyMembershipRoles(t *testing.T) {+ db, err := gorm.Open(sqlite.Open("file:"+url.QueryEscape(t.Name())+"?mode=memory&cache=shared"), &gorm.Config{})+ if err != nil {+ t.Fatalf("open sqlite: %v", err)+ }+ if err := db.AutoMigrate(&entity.UserTenant{}); err != nil {+ t.Fatalf("migrate membership table: %v", err)+ }+ if err := db.Exec("CREATE TABLE role (id INTEGER PRIMARY KEY, tenant_id TEXT NOT NULL)").Error; err != nil {+ t.Fatalf("create tenant role table: %v", err)+ }+ if err := db.Exec("INSERT INTO role (id, tenant_id) VALUES (17, 'tenant-1')").Error; err != nil {+ t.Fatalf("create tenant role: %v", err)+ }+ if !tenantRoleMembershipEnabled(db) {+ t.Skip("Tenant feature roles are not enabled")+ }++ valid := string(entity.StatusValid)+ memberships := []entity.UserTenant{+ {ID: "role-member", UserID: "role-user", TenantID: "tenant-1", Role: "17", Status: &valid},+ {ID: "wrong-tenant-role", UserID: "foreign-role-user", TenantID: "tenant-2", Role: "17", Status: &valid},+ {ID: "unknown-role", UserID: "unknown-role-user", TenantID: "tenant-1", Role: "not-a-role", Status: &valid},+ {ID: "admin", UserID: "admin-user", TenantID: "tenant-1", Role: string(RoleAdmin), Status: &valid},+ {ID: "normal", UserID: "normal-user", TenantID: "tenant-1", Role: string(RoleNormal), Status: &valid},+ {ID: "invite", UserID: "invite-user", TenantID: "tenant-1", Role: string(RoleInvite), Status: &valid},+ }+ if err := db.Create(&memberships).Error; err != nil {+ t.Fatalf("create memberships: %v", err)+ }++ checker := NewDatabaseChecker(db)+ if err := checker.CheckTenant(t.Context(), Subject{UserID: "role-user"}, "tenant-1", TenantMember); err != nil {+ t.Fatalf("valid Tenant role ID should be normalized to an ordinary member: %v", err)+ }+ for _, test := range []struct {+ userID string+ tenantID string+ }{+ {userID: "foreign-role-user", tenantID: "tenant-2"},+ {userID: "unknown-role-user", tenantID: "tenant-1"},+ {userID: "invite-user", tenantID: "tenant-1"},+ } {+ if err := checker.CheckTenant(t.Context(), Subject{UserID: test.userID}, test.tenantID, TenantMember); !errors.Is(err, ErrMembershipNotFound) {+ t.Errorf("CheckTenant(%q) error = %v, want %v", test.userID, err, ErrMembershipNotFound)+ }+ }+ if err := checker.CheckTenant(t.Context(), Subject{UserID: "admin-user"}, "tenant-1", TenantNormalMember); !errors.Is(err, ErrMembershipNotFound) {+ t.Errorf("admin CheckTenant(normal member) error = %v, want %v", err, ErrMembershipNotFound)+ }+ if err := checker.CheckTenant(t.Context(), Subject{UserID: "normal-user"}, "tenant-1", TenantNormalMember); err != nil {+ t.Errorf("normal member CheckTenant(normal member) error = %v, want nil", err)+ }++ tenantIDs, err := (&databaseSource{db: db}).activeTenantIDsForUser(t.Context(), "role-user")+ if err != nil {+ t.Fatalf("load member Tenant IDs: %v", err)+ }+ if len(tenantIDs) != 1 || tenantIDs[0] != "tenant-1" {+ t.Fatalf("activeTenantIDsForUser() = %v, want [tenant-1]", tenantIDs)+ }+}+func TestDatabaseCheckerRejectsPrivateDatasetForOtherTenantMember(t *testing.T) {db, err := gorm.Open(sqlite.Open("file:"+url.QueryEscape(t.Name())+"?mode=memory&cache=shared"), &gorm.Config{})if err != nil {diff --git a/internal/permission/model_resources.go b/internal/permission/model_resources.goindex ec8c6499b0..e017eb4999 100644--- a/internal/permission/model_resources.go+++ b/internal/permission/model_resources.go@@ -106,13 +106,7 @@ func (s *databaseSource) loadTenantOwnerIDs(ctx context.Context, tenantIDs []str}func (s *databaseSource) tenantIDsForSubject(ctx context.Context, subject Subject) ([]string, error) {- var tenantIDs []string- err := s.db.WithContext(ctx).Model(&entity.UserTenant{}).- Distinct("tenant_id").- Where("user_id = ? AND status = ? AND role IN ?", subject.UserID, string(entity.StatusValid), []string{- string(RoleOwner), string(RoleAdmin), string(RoleNormal),- }).- Pluck("tenant_id", &tenantIDs).Error+ tenantIDs, err := s.activeTenantIDsForUser(ctx, subject.UserID)if err != nil {return nil, err}diff --git a/internal/permission/policy_ce.go b/internal/permission/policy_ce.goindex 2a43d4fc29..4bb47a3d3c 100644--- a/internal/permission/policy_ce.go+++ b/internal/permission/policy_ce.go@@ -184,6 +184,12 @@ func (p *communityPolicy) QueryScope(ctx context.Context, subject Subject, queryif err := source.validateDatasetTenants(ctx, subject.UserID); err != nil {return QueryScope{}, true, err}+ // Enterprise tenant roles are stored as numeric IDs. The generic SQL fast+ // path cannot resolve those IDs safely, so let the normal resource checks+ // evaluate candidate IDs through databaseSource.GetMembership instead.+ if tenantRoleMembershipEnabled(source.db) {+ return QueryScope{}, false, nil+ }return QueryScope{apply: func(query *gorm.DB) *gorm.DB {db := source.db.WithContext(ctx)diff --git a/internal/permission/tenant_role_ee.go b/internal/permission/tenant_role_ee.gonew file mode 100644index 0000000000..4832542960--- /dev/null+++ b/internal/permission/tenant_role_ee.go@@ -0,0 +1,32 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package permission++import (+ "context"++ "gorm.io/gorm"+)++// Community memberships use the legacy string roles and have no Tenant role table.+func tenantRoleMembershipEnabled(*gorm.DB) bool {+ return false+}++func isTenantRoleID(context.Context, *gorm.DB, string, string) (bool, error) {+ return false, nil+}diff --git a/internal/service/model_service.go b/internal/service/model_service.goindex d7c8475b62..1077e84246 100644--- a/internal/service/model_service.go+++ b/internal/service/model_service.go@@ -595,27 +595,29 @@ func (m *ModelProviderService) addModelToInstance(ctx context.Context, tenantID,extraFields[k] = v}}- extraBytes, err := json.Marshal(extraFields)- if err != nil {- return fmt.Errorf("fail to marshal extra: %w", err)+ if err = m.createModelRecord(ctx, dao.DB, provider.ID, instance.ID, model.ModelName, combinedType, "active", extraFields); err != nil {+ return fmt.Errorf("fail to create model '%s': %w", model.ModelName, err)}- modelID := common.GenerateToken()- tenantModel := &entity.TenantModel{- ID: modelID,- ModelName: model.ModelName,- ModelType: int(combinedType),- ProviderID: provider.ID,- InstanceID: instance.ID,- Status: "active",- Extra: string(extraBytes),- }+ return nil+}- if err = m.modelDAO.Create(ctx, dao.DB, tenantModel); err != nil {- return fmt.Errorf("fail to create model '%s': %w", model.ModelName, err)+func (m *ModelProviderService) createModelRecord(ctx context.Context, db *gorm.DB, providerID, instanceID, modelName string, modelType entity.ModelType, status string, extra map[string]interface{}) error {+ extraBytes, err := json.Marshal(extra)+ if err != nil {+ return fmt.Errorf("fail to marshal model extra: %w", err)}- return nil+ model := &entity.TenantModel{+ ID: common.GenerateToken(),+ ModelName: modelName,+ ModelType: int(modelType),+ ProviderID: providerID,+ InstanceID: instanceID,+ Status: status,+ Extra: string(extraBytes),+ }+ return m.modelDAO.Create(ctx, db, model)}func (m *ModelProviderService) ListProviderInstances(ctx context.Context, providerIDOrName, userID string) ([]map[string]interface{}, common.ErrorCode, error) {diff --git a/internal/service/tenant.go b/internal/service/tenant.goindex 63d91506f7..3ea4af93de 100644--- a/internal/service/tenant.go+++ b/internal/service/tenant.go@@ -18,6 +18,7 @@ package serviceimport ("context"+ "errors""fmt""ragflow/internal/common""ragflow/internal/dao"@@ -26,6 +27,9 @@ import ("ragflow/internal/permission"permissionresponse "ragflow/internal/permission/response""strings"++ "gorm.io/gorm"+ "gorm.io/gorm/clause")// TenantService tenant service@@ -40,6 +44,66 @@ type TenantService struct {docEngine engine.DocEngine}+type tenantInviteRole struct {+ value string+ roleID *int32+ roleName string+}++// tenantMemberPermission keeps community membership policy in shared code and+// lets Enterprise apply its Tenant permission grants through the EE hook.+func tenantMemberPermission(ctx context.Context, db *gorm.DB, userID, tenantID string, required int32) (*entity.UserTenant, int32, error) {+ membership, mask, handled, err := tenantMemberPermissionEE(ctx, db, userID, tenantID, required)+ if err != nil || handled {+ return membership, mask, err+ }++ requirement := permission.TenantMember+ if required != 0 {+ requirement = permission.TenantOwner+ }+ checker := permission.NewDatabaseChecker(db)+ if err := checker.CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, requirement); err != nil {+ return nil, 0, err+ }+ var communityMembership entity.UserTenant+ if err := db.WithContext(ctx).+ Where("user_id = ? AND tenant_id = ? AND status = ?", userID, tenantID, string(entity.StatusValid)).+ Take(&communityMembership).Error; err != nil {+ return nil, 0, err+ }+ return &communityMembership, 0, nil+}++func tenantRoleErrorCode(err error) common.ErrorCode {+ var coded *common.CodedError+ if errors.As(err, &coded) {+ return coded.Code+ }+ code, _ := permissionresponse.Normalize(err)+ return code+}++func recordTenantPermissionChange(tx *gorm.DB, tenantID, actorUserID, eventType, targetType, targetID, resourceType, resourceID, actionType string, beforePermission, afterPermission int32, beforeData, afterData interface{}) error {+ return recordTenantPermissionChangeEE(tx, tenantID, actorUserID, eventType, targetType, targetID, resourceType, resourceID, actionType, beforePermission, afterPermission, beforeData, afterData)+}++func resolveTenantInviteRole(tx *gorm.DB, tenantID string) (tenantInviteRole, error) {+ role, handled, err := resolveTenantInviteRoleEE(tx, tenantID)+ if err != nil || handled {+ return role, err+ }+ return tenantInviteRole{value: TenantRoleNormal}, nil+}++func (s *TenantService) checkTenantInviteEnabled(ctx context.Context, tenantID string) (common.ErrorCode, error) {+ code, handled, err := s.checkTenantInviteEnabledEE(ctx, tenantID)+ if err != nil || handled {+ return code, err+ }+ return common.CodeSuccess, nil+}+// NewTenantService create tenant servicefunc NewTenantService() *TenantService {return &TenantService{@@ -733,9 +797,8 @@ type TenantMemberResponse struct {// ListMembers returns all non-owner members of tenantID.func (s *TenantService) ListMembers(ctx context.Context, userID, tenantID string) ([]*TenantMemberResponse, common.ErrorCode, error) {- if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, permission.TenantOwner); err != nil {- code, permissionErr := permissionresponse.Normalize(err)- return nil, code, permissionErr+ if _, _, err := tenantMemberPermission(ctx, dao.DB.WithContext(ctx), userID, tenantID, entity.TenantPermissionManageMembers); err != nil {+ return nil, tenantRoleErrorCode(err), err}rows, err := s.userTenantDAO.GetMembersByTenantID(ctx, dao.DB, tenantID)if err != nil {@@ -778,13 +841,18 @@ type AddMemberResponse struct {// AddMember invites a user (by email) to the tenant.func (s *TenantService) AddMember(ctx context.Context, userID, tenantID string, req *AddMemberRequest) (*AddMemberResponse, common.ErrorCode, error) {- if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, permission.TenantOwner); err != nil {- code, permissionErr := permissionresponse.Normalize(err)- return nil, code, permissionErr+ if _, _, err := tenantMemberPermission(ctx, dao.DB.WithContext(ctx), userID, tenantID, entity.TenantPermissionManageMembers); err != nil {+ return nil, tenantRoleErrorCode(err), err+ }+ if req == nil {+ return nil, common.CodeArgumentError, fmt.Errorf("request is required")}if strings.TrimSpace(req.Email) == "" {return nil, common.CodeArgumentError, fmt.Errorf("email is required")}+ if code, err := s.checkTenantInviteEnabled(ctx, tenantID); err != nil {+ return nil, code, err+ }invitee, err := s.userDAO.GetByEmail(ctx, dao.DB, req.Email)if err != nil {@@ -798,13 +866,13 @@ func (s *TenantService) AddMember(ctx context.Context, userID, tenantID string,userTenant, err := s.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, invitee.ID, tenantID)if err == nil {if userTenant != nil {- switch userTenant.Role {- case TenantRoleOwner:+ switch {+ case userTenant.Role == TenantRoleOwner:return nil, common.CodeDataError, fmt.Errorf("user is already the tenant owner")- case TenantRoleNormal, TenantRoleAdmin:- return nil, common.CodeDataError, fmt.Errorf("user is already a member")- case TenantRoleInvite:+ case userTenant.Role == TenantRoleInvite:return nil, common.CodeDataError, fmt.Errorf("user already has a pending invitation")+ case strings.TrimSpace(userTenant.Role) != "":+ return nil, common.CodeDataError, fmt.Errorf("user is already a member")}}}@@ -821,8 +889,15 @@ func (s *TenantService) AddMember(ctx context.Context, userID, tenantID string,InvitedBy: userID,Status: &status,}- if err = s.userTenantDAO.Create(ctx, dao.DB, ut); err != nil {- return nil, common.CodeServerError, fmt.Errorf("failed to create invitation: %w", err)+ err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ if err := s.userTenantDAO.Create(ctx, tx, ut); err != nil {+ return fmt.Errorf("failed to create invitation: %w", err)+ }+ return recordTenantPermissionChange(tx, tenantID, userID, "tenant.member.invited", "user", invitee.ID, "tenant_membership", ut.ID, "invite", 0, 0, nil,+ map[string]interface{}{"user_id": invitee.ID, "email": invitee.Email, "role": ut.Role, "invited_by": userID, "status": status})+ })+ if err != nil {+ return nil, tenantRoleErrorCode(err), err}avatar := ""@@ -845,40 +920,72 @@ func (s *TenantService) RemoveMember(ctx context.Context, userID, tenantID, targreturn common.CodeServerError, fmt.Errorf("userTenantDAO not initialized")}if userID != "" && userID == targetUserID {- removed, err := s.userTenantDAO.DeleteByUserAndTenantAndRole(ctx, dao.DB, userID, tenantID, TenantRoleInvite)+ var removed bool+ err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ var invitation entity.UserTenant+ err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).+ Where("user_id = ? AND tenant_id = ? AND role = ? AND status = ?", userID, tenantID, TenantRoleInvite, string(entity.StatusValid)).+ Take(&invitation).Error+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return nil+ }+ if err != nil {+ return fmt.Errorf("load pending tenant invitation: %w", err)+ }+ if err := tx.Unscoped().Where("id = ?", invitation.ID).Delete(&entity.UserTenant{}).Error; err != nil {+ return fmt.Errorf("failed to decline tenant invitation: %w", err)+ }+ removed = true+ return recordTenantPermissionChange(tx, tenantID, userID, "tenant.invitation.declined", "user", userID, "tenant_membership", invitation.ID, "decline", 0, 0,+ map[string]interface{}{"user_id": userID, "role": invitation.Role, "invited_by": invitation.InvitedBy, "status": invitation.Status},+ map[string]interface{}{"declined": true})+ })if err != nil {- return common.CodeServerError, fmt.Errorf("failed to decline tenant invitation: %w", err)+ return tenantRoleErrorCode(err), err}if removed {return common.CodeSuccess, nil}}- requirement := permission.TenantOwnerif userID == targetUserID {- requirement = permission.TenantMember- }- if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, requirement); err != nil {- code, permissionErr := permissionresponse.Normalize(err)- return code, permissionErr- }- targetMembership, err := s.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, targetUserID, tenantID)- if err != nil {- if dao.IsNotFoundErr(err) {- return common.CodeDataError, fmt.Errorf("user is not a tenant member")+ if _, _, err := tenantMemberPermission(ctx, dao.DB.WithContext(ctx), userID, tenantID, 0); err != nil {+ return tenantRoleErrorCode(err), err}- return common.CodeServerError, fmt.Errorf("failed to load tenant member: %w", err)- }- if targetMembership.Role == TenantRoleOwner {- return common.CodeArgumentError, fmt.Errorf("cannot remove the tenant owner")- }- if err := s.userTenantDAO.DeleteByUserAndTenant(ctx, dao.DB, targetUserID, tenantID); err != nil {- return common.CodeServerError, fmt.Errorf("failed to remove member: %w", err)+ } else if _, _, err := tenantMemberPermission(ctx, dao.DB.WithContext(ctx), userID, tenantID, entity.TenantPermissionManageMembers); err != nil {+ return tenantRoleErrorCode(err), err+ }+ err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ var targetMembership entity.UserTenant+ if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).+ Where("user_id = ? AND tenant_id = ? AND status = ?", targetUserID, tenantID, string(entity.StatusValid)).+ Take(&targetMembership).Error; err != nil {+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return common.NewCodedError(common.CodeDataError, "user is not a tenant member")+ }+ return fmt.Errorf("failed to load tenant member: %w", err)+ }+ if targetMembership.Role == TenantRoleOwner {+ return common.NewCodedError(common.CodeArgumentError, "cannot remove the tenant owner")+ }+ if err := tx.Unscoped().Where("id = ?", targetMembership.ID).Delete(&entity.UserTenant{}).Error; err != nil {+ return fmt.Errorf("failed to remove member: %w", err)+ }+ eventType, actionType := "tenant.member.removed", "remove"+ if targetMembership.Role == TenantRoleInvite {+ eventType, actionType = "tenant.invitation.revoked", "revoke"+ }+ return recordTenantPermissionChange(tx, tenantID, userID, eventType, "user", targetUserID, "tenant_membership", targetMembership.ID, actionType, 0, 0,+ map[string]interface{}{"user_id": targetUserID, "role": targetMembership.Role, "invited_by": targetMembership.InvitedBy, "status": targetMembership.Status},+ map[string]interface{}{"removed": true})+ })+ if err != nil {+ return tenantRoleErrorCode(err), err}return common.CodeSuccess, nil}-// AcceptInvite transitions the calling user's role from "invite" → "normal" for the given tenant.+// AcceptInvite assigns the Tenant default role when a pending invitation is accepted.func (s *TenantService) AcceptInvite(ctx context.Context, userID, tenantID string) (common.ErrorCode, error) {if s.userTenantDAO == nil {return common.CodeServerError, fmt.Errorf("userTenantDAO not initialized")@@ -890,8 +997,35 @@ func (s *TenantService) AcceptInvite(ctx context.Context, userID, tenantID strinif existing.Role != TenantRoleInvite {return common.CodeArgumentError, fmt.Errorf("no pending invitation to accept")}- if err := s.userTenantDAO.UpdateRoleByUserAndTenant(ctx, dao.DB, userID, tenantID, TenantRoleNormal); err != nil {- return common.CodeServerError, fmt.Errorf("failed to accept invitation: %w", err)+ err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ var membership entity.UserTenant+ if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).+ Where("id = ? AND user_id = ? AND tenant_id = ? AND role = ? AND status = ?", existing.ID, userID, tenantID, TenantRoleInvite, string(entity.StatusValid)).+ Take(&membership).Error; err != nil {+ return fmt.Errorf("reload pending Tenant invitation: %w", err)+ }+ role, err := resolveTenantInviteRole(tx, tenantID)+ if err != nil {+ return err+ }+ if strings.TrimSpace(role.value) == "" {+ return common.NewCodedError(common.CodeConflict, "Tenant default role is invalid")+ }+ if err := tx.Model(&entity.UserTenant{}).Where("id = ?", membership.ID).Update("role", role.value).Error; err != nil {+ return fmt.Errorf("accept Tenant invitation: %w", err)+ }+ before := map[string]interface{}{"user_id": userID, "role": membership.Role}+ after := map[string]interface{}{"user_id": userID, "role": role.value}+ if role.roleID != nil {+ after["role_id"] = *role.roleID+ }+ if role.roleName != "" {+ after["role_name"] = role.roleName+ }+ return recordTenantPermissionChange(tx, tenantID, userID, "tenant.member.joined", "user", userID, "tenant_membership", membership.ID, "join", 0, 0, before, after)+ })+ if err != nil {+ return tenantRoleErrorCode(err), err}return common.CodeSuccess, nil}diff --git a/internal/service/tenant_invite_ee.go b/internal/service/tenant_invite_ee.gonew file mode 100644index 0000000000..800ebb3794--- /dev/null+++ b/internal/service/tenant_invite_ee.go@@ -0,0 +1,33 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package service++import (+ "context"++ "ragflow/internal/common"++ "gorm.io/gorm"+)++func resolveTenantInviteRoleEE(*gorm.DB, string) (tenantInviteRole, bool, error) {+ return tenantInviteRole{}, false, nil+}++func (*TenantService) checkTenantInviteEnabledEE(context.Context, string) (common.ErrorCode, bool, error) {+ return common.CodeSuccess, false, nil+}diff --git a/internal/service/tenant_role_ee.go b/internal/service/tenant_role_ee.gonew file mode 100644index 0000000000..ab78c144b3--- /dev/null+++ b/internal/service/tenant_role_ee.go@@ -0,0 +1,33 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package service++import (+ "context"++ "ragflow/internal/entity"++ "gorm.io/gorm"+)++func tenantMemberPermissionEE(context.Context, *gorm.DB, string, string, int32) (*entity.UserTenant, int32, bool, error) {+ return nil, 0, false, nil+}++func recordTenantPermissionChangeEE(*gorm.DB, string, string, string, string, string, string, string, string, int32, int32, interface{}, interface{}) error {+ return nil+}diff --git a/internal/service/tenant_test.go b/internal/service/tenant_test.goindex 7ac2bbe41d..b0c9b601a5 100644--- a/internal/service/tenant_test.go+++ b/internal/service/tenant_test.go@@ -38,7 +38,7 @@ func setupTenantPermissionTestDB(t *testing.T) *gorm.DB {if err != nil {t.Fatalf("open sqlite: %v", err)}- if err := db.AutoMigrate(&entity.UserTenant{}); err != nil {+ if err := db.AutoMigrate(&entity.UserTenant{}, &entity.PermissionChangeLog{}); err != nil {t.Fatalf("migrate tenant permission table: %v", err)}originalDB := dao.DBdiff --git a/internal/service/user.go b/internal/service/user.goindex 9ea3fa31f3..3e7d743e08 100644--- a/internal/service/user.go+++ b/internal/service/user.go@@ -235,12 +235,16 @@ func (s *UserService) Register(ctx context.Context, req *RegisterRequest) (*enti}db := dao.GetDB()+ tenantDAO := dao.NewTenantDAO()if err = db.Transaction(func(tx *gorm.DB) error {if err = tx.Create(user).Error; err != nil {return fmt.Errorf("failed to create user: %w", err)}+ if err = dao.ApplyDefaultTenantInviteEnabled(ctx, tx, tenant); err != nil {+ return fmt.Errorf("failed to initialize tenant invitation setting: %w", err)+ }- if err = tx.Create(tenant).Error; err != nil {+ if err = tenantDAO.Create(ctx, tx, tenant); err != nil {return fmt.Errorf("failed to create tenant: %w", err)}