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
fix(api): clamp memory list tenant_id filter to joined tenants (#19739)
coderdailyone7ebe0d22b730
diff --git a/internal/service/memory.go b/internal/service/memory.goindex 07932b5cf9..cc03263b74 100644--- a/internal/service/memory.go+++ b/internal/service/memory.go@@ -1563,18 +1563,39 @@ func (s *MemoryService) requireMemoryAccess(ctx context.Context, userID string,//// resp, err := service.ListMemories("user123", []string{}, []string{"semantic"}, "table", "test", 1, 10)func (s *MemoryService) ListMemories(ctx context.Context, userID string, tenantIDs []string, memoryTypes []string, storageType string, keywords string, page int, pageSize int) (*ListMemoryResponse, error) {- // If tenantIDs is empty, get all tenants associated with the user+ // The tenant filter may only name tenants the caller belongs to: Python's+ // list_memory intersects the requested ids with the caller's joined+ // tenants and returns an empty page when nothing survives. Without the+ // clamp a caller could list another tenant's team-shared memories by+ // passing its id in the tenant_id query parameter.+ userTenantService := NewUserTenantService()+ userTenants, err := userTenantService.GetUserTenantRelationByUserIDWithContext(ctx, userID)+ if err != nil {+ return nil, fmt.Errorf("failed to get user tenants: %w", err)+ }+ joinedIDs := make([]string, 0, len(userTenants)+1)+ joinedIDs = append(joinedIDs, userID)+ for _, tenant := range userTenants {+ joinedIDs = append(joinedIDs, tenant.TenantID)+ }+if len(tenantIDs) == 0 {- userTenantService := NewUserTenantService()- userTenants, err := userTenantService.GetUserTenantRelationByUserIDWithContext(ctx, userID)- if err != nil {- return nil, fmt.Errorf("failed to get user tenants: %w", err)+ tenantIDs = joinedIDs+ } else {+ joined := make(map[string]struct{}, len(joinedIDs))+ for _, id := range joinedIDs {+ joined[id] = struct{}{}+ }+ allowed := make([]string, 0, len(tenantIDs))+ for _, id := range tenantIDs {+ if _, ok := joined[id]; ok {+ allowed = append(allowed, id)+ }}- tenantIDs = make([]string, 0, len(userTenants)+1)- tenantIDs = append(tenantIDs, userID)- for _, tenant := range userTenants {- tenantIDs = append(tenantIDs, tenant.TenantID)+ if len(allowed) == 0 {+ return &ListMemoryResponse{MemoryList: []map[string]interface{}{}}, nil}+ tenantIDs = allowed}memories, total, err := s.memoryDAO.GetByFilter(ctx, dao.DB, userID, tenantIDs, memoryTypes, storageType, keywords, page, pageSize)diff --git a/internal/service/memory_message_test.go b/internal/service/memory_message_test.goindex e8b97fa861..8ec361aa33 100644--- a/internal/service/memory_message_test.go+++ b/internal/service/memory_message_test.go@@ -492,6 +492,116 @@ func TestListMemoriesFallsBackToRawModelIDWithoutTenantModelID(t *testing.T) {}}+// A caller may not list memories of a tenant they have not joined, even when+// the target memories carry the team permission. Python list_memory clamps the+// requested tenant_id filter to the caller's joined tenants; the Go port+// passed the requested ids straight through, so ?tenant_id=<foreign> listed+// that tenant's team-shared memories.+func TestListMemoriesRejectsUnjoinedTenantFilter(t *testing.T) {+ setupMemoryMessageTestDB(t)++ for _, u := range []*entity.User{+ {ID: "user-1", Nickname: "Caller"},+ {ID: "tenant-2", Nickname: "Foreign owner"},+ } {+ if err := dao.DB.Create(u).Error; err != nil {+ t.Fatalf("seed user: %v", err)+ }+ }+ if err := dao.DB.Create(&entity.Memory{+ ID: "mem-foreign-team",+ Name: "Foreign team memory",+ TenantID: "tenant-2",+ MemoryType: dao.MemoryTypeRaw,+ StorageType: "table",+ EmbdID: "embd",+ LLMID: "llm",+ Permissions: string(TenantPermissionTeam),+ ForgettingPolicy: string(ForgettingPolicyFIFO),+ }).Error; err != nil {+ t.Fatalf("seed memory: %v", err)+ }++ resp, err := NewMemoryService().ListMemories(t.Context(), "user-1", []string{"tenant-2"}, nil, "", "", 1, 10)+ if err != nil {+ t.Fatalf("ListMemories: %v", err)+ }+ if resp.TotalCount != 0 || len(resp.MemoryList) != 0 {+ t.Fatalf("foreign tenant filter must return no memories, got total=%d list=%v", resp.TotalCount, resp.MemoryList)+ }+}++// A caller who has joined the tenant may still use the tenant_id filter, and a+// mixed filter keeps only the joined ids.+func TestListMemoriesKeepsJoinedTenantFilter(t *testing.T) {+ setupMemoryMessageTestDB(t)++ for _, u := range []*entity.User{+ {ID: "user-1", Nickname: "Caller"},+ {ID: "tenant-2", Nickname: "Joined owner"},+ {ID: "tenant-3", Nickname: "Foreign owner"},+ } {+ if err := dao.DB.Create(u).Error; err != nil {+ t.Fatalf("seed user: %v", err)+ }+ }+ if err := dao.DB.Create(&entity.UserTenant{+ ID: "ut-user-1-tenant-2",+ UserID: "user-1",+ TenantID: "tenant-2",+ Role: "normal",+ Status: sptr("1"),+ }).Error; err != nil {+ t.Fatalf("seed user_tenant: %v", err)+ }+ for _, m := range []*entity.Memory{+ {+ ID: "mem-joined-team",+ Name: "Joined team memory",+ TenantID: "tenant-2",+ MemoryType: dao.MemoryTypeRaw,+ StorageType: "table",+ EmbdID: "embd",+ LLMID: "llm",+ Permissions: string(TenantPermissionTeam),+ ForgettingPolicy: string(ForgettingPolicyFIFO),+ },+ {+ ID: "mem-foreign-team",+ Name: "Foreign team memory",+ TenantID: "tenant-3",+ MemoryType: dao.MemoryTypeRaw,+ StorageType: "table",+ EmbdID: "embd",+ LLMID: "llm",+ Permissions: string(TenantPermissionTeam),+ ForgettingPolicy: string(ForgettingPolicyFIFO),+ },+ } {+ if err := dao.DB.Create(m).Error; err != nil {+ t.Fatalf("seed memory %s: %v", m.ID, err)+ }+ }++ ctx := t.Context()++ resp, err := NewMemoryService().ListMemories(ctx, "user-1", []string{"tenant-2"}, nil, "", "", 1, 10)+ if err != nil {+ t.Fatalf("ListMemories: %v", err)+ }+ if resp.TotalCount != 1 || len(resp.MemoryList) != 1 || resp.MemoryList[0]["id"] != "mem-joined-team" {+ t.Fatalf("joined tenant filter must return its team memory, got total=%d list=%v", resp.TotalCount, resp.MemoryList)+ }++ resp, err = NewMemoryService().ListMemories(ctx, "user-1", []string{"tenant-2", "tenant-3"}, nil, "", "", 1, 10)+ if err != nil {+ t.Fatalf("ListMemories: %v", err)+ }+ if resp.TotalCount != 1 || len(resp.MemoryList) != 1 || resp.MemoryList[0]["id"] != "mem-joined-team" {+ t.Fatalf("mixed filter must drop the unjoined tenant, got total=%d list=%v", resp.TotalCount, resp.MemoryList)+ }+}+func seedMemoryMessages(t *testing.T) {t.Helper()