Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix(admin): return every user when the list is unpaged (#21723)

CCLUCKYda108133e792
diff --git a/internal/admin/handler.go b/internal/admin/handler.go
index 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 desc
orderBy := 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.go
index 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.go
index 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) * pageSize
status = strings.ToLower(strings.TrimSpace(status))
switch status {
case "":
diff --git a/internal/admin/user_list_test.go b/internal/admin/user_list_test.go
index 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)