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(admin): return every user when the list is unpaged (#21723)
CCLUCKYda108133e792
diff --git a/internal/admin/handler.go b/internal/admin/handler.goindex 0e2cd8523b..dcb703ad30 100644--- a/internal/admin/handler.go+++ b/internal/admin/handler.go@@ -161,10 +161,25 @@ func (h *Handler) ListUsers(c *gin.Context) {role := c.DefaultQuery("role", "")sort := c.DefaultQuery("sort", "") // asc or descorderBy := c.DefaultQuery("order", "") // order by field- pageInt, pageSizeInt, err := common.ParsePagination(c.Request.URL.Query())- if err != nil {- common.RespondError(c, common.CodeBadRequest, err.Error())- return+ // The admin UI and existing admin clients request the user list without+ // pagination and slice it client-side, so omitting both page and page_size+ // returns every user (pageSizeInt=0). When pagination is requested, use+ // the standard pagination parser.+ query := c.Request.URL.Query()+ var (+ pageInt int+ pageSizeInt int+ )+ if query.Has("page") || query.Has("page_size") {+ var err error+ pageInt, pageSizeInt, err = common.ParsePagination(query)+ if err != nil {+ common.RespondError(c, common.CodeBadRequest, err.Error())+ return+ }+ } else {+ pageInt = 1+ pageSizeInt = 0}plan := c.Query("plan") // plan name@@ -222,11 +237,13 @@ func (h *Handler) ListUsers(c *gin.Context) {}func validateAdminUserListPagination(c *gin.Context, page, pageSize, top int) bool {- if page < 1 || pageSize < 1 {+ // pageSize==0 is the "unpaged" sentinel: it only arrives from the omitted+ // page_size default, because an explicit page_size=0 is rejected here.+ query := c.Request.URL.Query()+ if page < 1 || (pageSize < 1 && query.Has("page_size")) {common.RespondError(c, common.CodeBadRequest, "page and page_size must be positive integers")return false}- query := c.Request.URL.Query()if query.Has("top") {if top < 1 {common.RespondError(c, common.CodeBadRequest, "top must be a positive integer")diff --git a/internal/admin/user_detail_test.go b/internal/admin/user_detail_test.goindex ff4605193e..6d88a0fd7b 100644--- a/internal/admin/user_detail_test.go+++ b/internal/admin/user_detail_test.go@@ -184,6 +184,107 @@ func TestListUsersAcceptsSharedClientParameters(t *testing.T) {}}+// The admin UI requests the user list without page/page_size and slices it+// client-side, so an omitted page_size must keep returning every user.+func TestListUsersWithoutPaginationReturnsEveryUser(t *testing.T) {+ handler := setupAdminUserDetailTest(t)+ for i := 0; i < 11; i++ {+ user := entity.User{+ ID: fmt.Sprintf("user-%02d", i),+ Email: fmt.Sprintf("user-%[email protected]", i),+ Nickname: "User",+ IsActive: "1",+ }+ if err := dao.DB.Create(&user).Error; err != nil {+ t.Fatal(err)+ }+ }++ recorder := httptest.NewRecorder()+ ctx, _ := gin.CreateTestContext(recorder)+ ctx.Request = httptest.NewRequest(http.MethodGet, "/api/v1/admin/users", nil)+ handler.ListUsers(ctx)++ var response adminTestResponse+ if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {+ t.Fatal(err)+ }+ var users []map[string]interface{}+ if err := json.Unmarshal(response.Data, &users); err != nil {+ t.Fatal(err)+ }+ if response.Total == nil || *response.Total != 12 || len(users) != 12 {+ t.Fatalf("unpaged list returned %d users (total %v), want 12; body = %s", len(users), response.Total, recorder.Body.String())+ }+}++// When an explicit page is requested without page_size, pagination must be+// preserved using the standard default page size (common.DefaultPageSize).+func TestListUsersWithPageOnlyPreservesPagination(t *testing.T) {+ handler := setupAdminUserDetailTest(t)+ for i := 0; i < 31; i++ {+ user := entity.User{+ ID: fmt.Sprintf("user-%02d", i),+ Email: fmt.Sprintf("user-%[email protected]", i),+ Nickname: "User",+ IsActive: "1",+ }+ if err := dao.DB.Create(&user).Error; err != nil {+ t.Fatal(err)+ }+ }++ recorder := httptest.NewRecorder()+ ctx, _ := gin.CreateTestContext(recorder)+ ctx.Request = httptest.NewRequest(http.MethodGet, "/api/v1/admin/users?page=2", nil)+ handler.ListUsers(ctx)++ var response adminTestResponse+ if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {+ t.Fatal(err)+ }+ var users []map[string]interface{}+ if err := json.Unmarshal(response.Data, &users); err != nil {+ t.Fatal(err)+ }+ if response.Total == nil || *response.Total != 32 || len(users) != 2 {+ t.Fatalf("page=2 without page_size returned %d users (total %v), want 2; body = %s", len(users), response.Total, recorder.Body.String())+ }+}++// When explicit page and page_size are supplied, pagination must be preserved.+func TestListUsersWithExplicitPagination(t *testing.T) {+ handler := setupAdminUserDetailTest(t)+ for i := 0; i < 11; i++ {+ user := entity.User{+ ID: fmt.Sprintf("user-%02d", i),+ Email: fmt.Sprintf("user-%[email protected]", i),+ Nickname: "User",+ IsActive: "1",+ }+ if err := dao.DB.Create(&user).Error; err != nil {+ t.Fatal(err)+ }+ }++ recorder := httptest.NewRecorder()+ ctx, _ := gin.CreateTestContext(recorder)+ ctx.Request = httptest.NewRequest(http.MethodGet, "/api/v1/admin/users?page=2&page_size=10", nil)+ handler.ListUsers(ctx)++ var response adminTestResponse+ if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {+ t.Fatal(err)+ }+ var users []map[string]interface{}+ if err := json.Unmarshal(response.Data, &users); err != nil {+ t.Fatal(err)+ }+ if response.Total == nil || *response.Total != 12 || len(users) != 2 {+ t.Fatalf("page=2&page_size=10 returned %d users (total %v), want 2; body = %s", len(users), response.Total, recorder.Body.String())+ }+}+func setupAdminUserDetailTest(t *testing.T) *Handler {t.Helper()db := testutil.SetupTestDB(t, adminUserDetailTestModels...)diff --git a/internal/admin/user_list.go b/internal/admin/user_list.goindex 485f8349f9..c775f05f43 100644--- a/internal/admin/user_list.go+++ b/internal/admin/user_list.go@@ -54,13 +54,18 @@ func (s *Service) ListUsers(ctx context.Context, pageIndex, pageSize int, name,func parseUserListOptions(page, pageSize int, keyword, status, direction, field string) (dao.UserListOptions, error) {opts := dao.UserListOptions{Keyword: strings.TrimSpace(keyword), Limit: pageSize}- if page < 1 || pageSize < 1 {+ // pageSize==0 means "unpaged": the handler only produces it from the+ // omitted page_size default (an explicit page_size=0 is rejected there),+ // and the DAO leaves the query unlimited when Limit is 0.+ if page < 1 || pageSize < 0 {return opts, fmt.Errorf("%w: page and page_size must be positive integers", errInvalidUserListQuery)}- if page-1 > math.MaxInt/pageSize {- return opts, fmt.Errorf("%w: pagination offset is too large", errInvalidUserListQuery)+ if pageSize > 0 {+ if page-1 > math.MaxInt/pageSize {+ return opts, fmt.Errorf("%w: pagination offset is too large", errInvalidUserListQuery)+ }+ opts.Offset = (page - 1) * pageSize}- opts.Offset = (page - 1) * pageSizestatus = strings.ToLower(strings.TrimSpace(status))switch status {case "":diff --git a/internal/admin/user_list_test.go b/internal/admin/user_list_test.goindex 21f48d411d..af65477af5 100644--- a/internal/admin/user_list_test.go+++ b/internal/admin/user_list_test.go@@ -49,7 +49,6 @@ func TestListUsersRejectsInvalidQueryBeforeDatabaseAccess(t *testing.T) {{name: "index", field: "index", page: 1, pageSize: 10},{name: "zero page", pageSize: 10},{name: "negative page", page: -1, pageSize: 10},- {name: "zero page size", page: 1},{name: "negative page size", page: 1, pageSize: -1},{name: "offset overflow to negative", page: math.MaxInt, pageSize: 10},{name: "offset overflow to zero", page: math.MaxInt/2 + 2, pageSize: 4},@@ -85,6 +84,16 @@ func TestParseUserListOptionsPaginationBounds(t *testing.T) {}}+// pageSize==0 is the "unpaged" request: the handler only produces it from the+// omitted page_size default, and the DAO leaves the query unlimited when+// Limit is 0, so offset must stay 0 and no division by pageSize may run.+func TestParseUserListOptionsUnpagedReturnsEveryUser(t *testing.T) {+ opts, err := parseUserListOptions(1, 0, "", "", "", "")+ if err != nil || opts.Offset != 0 || opts.Limit != 0 {+ t.Fatalf("parseUserListOptions(1, 0) = (%+v, %v), want unpaged options", opts, err)+ }+}+func TestListUsersFiltersAndOrdering(t *testing.T) {handler := setupAdminUserDetailTest(t)created := time.Date(2026, time.September, 17, 12, 0, 0, 0, time.UTC)