Skip to content

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

Refactor: restrict page_size max value 100 (#22036)

Wang Qi5fa1879de0e4
diff --git a/docs/references/http_api_reference.md b/docs/references/http_api_reference.md
index b24010e56d..1a88aa4836 100644
--- a/docs/references/http_api_reference.md
+++ b/docs/references/http_api_reference.md
@@ -14,6 +14,11 @@ In the standard response envelope, `message` is always a non-empty string. Succe
`data` is optional. Operation acknowledgments omit it; check `code` for success
and `message` for the result description. Result payloads use objects or arrays.
+Paginated endpoints require a positive integer `page` (default `1`) and a
+`page_size` between `1` and `100`, inclusive. Requests over the limit are rejected with
+an error envelope; values are never silently clamped. Zero and negative sizes
+cannot disable pagination. All paginated endpoints default to `30` items per page.
+
---
## ERROR CODES
@@ -3467,7 +3472,7 @@ curl --request GET \
- `page`: (*Query parameter*), `integer`
Specifies the page on which the sessions will be displayed. Defaults to `1`.
- `page_size`: (*Query parameter*), `integer`
- The number of sessions on each page. Defaults to `30`. If set to `0`, an empty list is returned.
+ The number of sessions on each page. Defaults to `30`. Must be between `1` and `100`.
- `orderby`: (*Query parameter*), `string`
The field by which sessions should be sorted. Available options:
- `create_time` (default)
@@ -5880,7 +5885,7 @@ curl --location 'http://{address}/api/v1/memories?keywords=&page_size=50&page=1&
- `page_size`: `int`, *Optional*
- The number of memories on each page. Defaults to `50`.
+ The number of memories on each page. Defaults to `30`.
#### Response
@@ -6093,7 +6098,7 @@ curl --location 'http://{address}/api/v1/memories/6c8983badede11f083f184ba59bc53
- `page_size`: (*Query parameter*), `int`, *Optional*
- The number of messages on each page. Defaults to `50`.
+ The number of messages on each page. Defaults to `30`.
#### Response
@@ -7037,7 +7042,7 @@ curl --request GET \
- `page`: `integer`
Specifies the page on which the files will be displayed. Defaults to `1`.
- `page_size`: `integer`
- The number of files on each page. Defaults to `15`.
+ The number of files on each page. Defaults to `30`.
- `orderby`: `string`
The field by which files should be sorted. Available options:
- `create_time` (default)
@@ -7610,7 +7615,7 @@ Lists all commits for the specified folder with pagination. Also, available at:
- `'Authorization: Bearer <YOUR_API_KEY>'`
- Query:
- `'page'`: `int` (optional, default: 1)
- - `'page_size'`: `int` (optional, default: 15)
+ - `'page_size'`: `int` (optional, default: 30)
- `'order_by'`: `string` (optional, default: `"create_time"`)
- `'desc'`: `bool` (optional, default: `true`)
@@ -8151,7 +8156,7 @@ curl --request GET \
- `page`: `integer`
Specifies the page number. Defaults to `1`. Values less than `1` fall back to `1`.
- `page_size`: `integer`
- The number of items per page. Defaults to `30`. Values less than `1` fall back to `30`. The maximum value is `100`.
+ The number of items per page. Defaults to `30`. Must be between `1` and `100`.
- `orderby`: `string`
The field to sort by. Defaults to `create_time`.
- `desc`: `boolean`
diff --git a/internal/admin/handler.go b/internal/admin/handler.go
index 0edf5e1f20..0e2cd8523b 100644
--- a/internal/admin/handler.go
+++ b/internal/admin/handler.go
@@ -161,16 +161,12 @@ 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, err := common.ParseRequestIntPositive(c, c.Query("page"), "page", 1)
- if err != nil {
- common.RespondError(c, common.CodeBadRequest, err.Error())
- return
- }
- pageSizeInt, err := common.ParseRequestIntPositive(c, c.Query("page_size"), "page_size", 10)
+ pageInt, pageSizeInt, err := common.ParsePagination(c.Request.URL.Query())
if err != nil {
common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
+
plan := c.Query("plan") // plan name
topInt, err := common.ParseRequestIntPositive(c, c.Query("top"), "top", 0)
if err != nil {
@@ -1143,18 +1139,10 @@ func (h *Handler) Reports(c *gin.Context) {
func (h *Handler) ListAllModels(c *gin.Context) {
- page := 0
- if v := c.Query("page"); v != "" {
- if p, err := strconv.Atoi(v); err == nil && p > 0 {
- page = p
- }
- }
-
- pageSize := 0
- if v := c.Query("page_size"); v != "" {
- if ps, err := strconv.Atoi(v); err == nil && ps > 0 {
- pageSize = ps
- }
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeBadRequest, err.Error())
+ return
}
// List models
diff --git a/internal/admin/pagination_test.go b/internal/admin/pagination_test.go
new file mode 100644
index 0000000000..f404190e16
--- /dev/null
+++ b/internal/admin/pagination_test.go
@@ -0,0 +1,33 @@
+package admin
+
+import (
+ "encoding/json"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/gin-gonic/gin"
+ "ragflow/internal/common"
+)
+
+func TestAdminListHandlersRejectOversizedPagination(t *testing.T) {
+ for name, handle := range map[string]gin.HandlerFunc{
+ "users": (&Handler{}).ListUsers,
+ "models": (&Handler{}).ListAllModels,
+ } {
+ t.Run(name, func(t *testing.T) {
+ rec := httptest.NewRecorder()
+ ctx, _ := gin.CreateTestContext(rec)
+ ctx.Request = httptest.NewRequest("GET", "/?page_size=101", nil)
+ handle(ctx)
+ var response struct {
+ Code common.ErrorCode `json:"code"`
+ }
+ if err := json.Unmarshal(rec.Body.Bytes(), &response); err != nil {
+ t.Fatal(err)
+ }
+ if response.Code != common.CodeBadRequest {
+ t.Fatalf("unexpected response: %s", rec.Body.String())
+ }
+ })
+ }
+}
diff --git a/internal/admin/service.go b/internal/admin/service.go
index ab7133a295..8c5c96103c 100644
--- a/internal/admin/service.go
+++ b/internal/admin/service.go
@@ -1581,10 +1581,14 @@ func (s *Service) ListAllModels(pageIndex, pageSize int) ([]map[string]interface
if err != nil {
return nil, err
}
- if pageSize > 0 && pageIndex >= 0 && pageIndex*pageSize < len(models) {
- return models[pageIndex*pageSize : (pageIndex+1)*pageSize], nil
+ if err := common.ValidatePagination(&pageIndex, &pageSize, nil); err != nil {
+ return nil, err
+ }
+ start := (pageIndex - 1) * pageSize
+ if start >= len(models) {
+ return []map[string]interface{}{}, nil
}
- return models, nil
+ return models[start:min(start+pageSize, len(models))], nil
}
func (s *Service) GetModelByModelName(modelName string) (*modelModule.Model, error) {
diff --git a/internal/admin/user_detail_test.go b/internal/admin/user_detail_test.go
index 20e2c286cd..ff4605193e 100644
--- a/internal/admin/user_detail_test.go
+++ b/internal/admin/user_detail_test.go
@@ -53,6 +53,7 @@ func TestListUsersReturnsTotalForEachPage(t *testing.T) {
query string
want int
}{
+ {"", 12},
{"?page=1&page_size=10", 10},
{"?page=2&page_size=10", 2},
{"?page=3&page_size=10", 0},
diff --git a/internal/common/pagination.go b/internal/common/pagination.go
new file mode 100644
index 0000000000..94724419cf
--- /dev/null
+++ b/internal/common/pagination.go
@@ -0,0 +1,81 @@
+package common
+
+import (
+ "fmt"
+ "math"
+ "net/url"
+ "strconv"
+ "strings"
+)
+
+const (
+ DefaultPage = 1
+ DefaultPageSize = 30
+ MaxPageSize = 100
+)
+
+// ParsePagination parses REST list parameters. Only omitted parameters use defaults.
+func ParsePagination(query url.Values) (int, int, error) {
+ page, err := parsePaginationInt(query, "page", DefaultPage)
+ if err != nil {
+ return 0, 0, err
+ }
+ size, err := parsePaginationInt(query, "page_size", DefaultPageSize)
+ if err != nil {
+ return 0, 0, err
+ }
+ if err := ValidatePagination(&page, &size, nil); err != nil {
+ return 0, 0, err
+ }
+ return page, size, nil
+}
+
+func parsePaginationInt(query url.Values, name string, fallback int) (int, error) {
+ values, ok := query[name]
+ if !ok {
+ return fallback, nil
+ }
+ if len(values) != 1 {
+ return 0, fmt.Errorf("%s must be provided once", name)
+ }
+ value, err := strconv.Atoi(strings.TrimSpace(values[0]))
+ if err != nil {
+ return 0, fmt.Errorf("%s must be an integer", name)
+ }
+ return value, nil
+}
+
+func validatePageSize(size int, name string) error {
+ if size < 1 || size > MaxPageSize {
+ return fmt.Errorf("%s must be between 1 and %d", name, MaxPageSize)
+ }
+ return nil
+}
+
+// ValidatePagination validates JSON pagination, including both size aliases when supplied.
+func ValidatePagination(page, pageSize, size *int) error {
+ p, s := DefaultPage, DefaultPageSize
+ if page != nil {
+ p = *page
+ }
+ if p < 1 {
+ return fmt.Errorf("page must be a positive integer")
+ }
+ if size != nil {
+ if err := validatePageSize(*size, "size"); err != nil {
+ return err
+ }
+ s = *size
+ }
+ if pageSize != nil {
+ if err := validatePageSize(*pageSize, "page_size"); err != nil {
+ return err
+ }
+ s = *pageSize
+ }
+ // Bound the end of the page too, since some stores compute page * size.
+ if p > math.MaxInt/s {
+ return fmt.Errorf("pagination offset is too large")
+ }
+ return nil
+}
diff --git a/internal/common/pagination_test.go b/internal/common/pagination_test.go
new file mode 100644
index 0000000000..a69347b8f9
--- /dev/null
+++ b/internal/common/pagination_test.go
@@ -0,0 +1,79 @@
+package common
+
+import (
+ "fmt"
+ "math"
+ "net/url"
+ "strings"
+ "testing"
+)
+
+func TestParsePagination(t *testing.T) {
+ for _, tt := range []struct {
+ query string
+ page, size int
+ wantErr string
+ }{
+ {"", 1, 30, ""},
+ {"page=2&page_size=100", 2, 100, ""},
+ {"page_size=1", 1, 1, ""},
+ {"page=3", 3, 30, ""},
+ {"page_size=101", 0, 0, "page_size"},
+ {"page_size=0", 0, 0, "page_size"},
+ {"page_size=-1", 0, 0, "page_size"},
+ {"page_size=abc", 0, 0, "page_size"},
+ {"page_size=", 0, 0, "page_size"},
+ {"page_size=1.5", 0, 0, "page_size"},
+ {"page=0", 0, 0, "page"},
+ {"page=-1", 0, 0, "page"},
+ {"page=abc", 0, 0, "page"},
+ {"page=", 0, 0, "page"},
+ {"page=1&page=2", 0, 0, "provided once"},
+ {"page_size=1&page_size=101", 0, 0, "provided once"},
+ {fmt.Sprintf("page=%d&page_size=100", math.MaxInt), 0, 0, "offset"},
+ {"page_size=999999999999999999999999999", 0, 0, "page_size"},
+ } {
+ t.Run(tt.query, func(t *testing.T) {
+ query, err := url.ParseQuery(tt.query)
+ if err != nil {
+ t.Fatal(err)
+ }
+ page, size, err := ParsePagination(query)
+ if tt.wantErr != "" {
+ if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
+ t.Fatalf("error = %v, want %q", err, tt.wantErr)
+ }
+ return
+ }
+ if err != nil || page != tt.page || size != tt.size {
+ t.Fatalf("page/size/error = %d/%d/%v, want %d/%d/nil", page, size, err, tt.page, tt.size)
+ }
+ })
+ }
+}
+
+func TestValidatePaginationAliases(t *testing.T) {
+ for _, tt := range []struct {
+ name string
+ page, pageSize, size *int
+ valid bool
+ }{
+ {"defaults", nil, nil, nil, true},
+ {"max page_size", new(1), new(100), nil, true},
+ {"max size", new(1), nil, new(100), true},
+ {"oversized page_size", nil, new(101), nil, false},
+ {"oversized size", nil, nil, new(101), false},
+ {"ignored alias still validated", nil, new(10), new(101), false},
+ {"zero size", nil, nil, new(0), false},
+ {"negative page_size", nil, new(-1), nil, false},
+ {"zero page", new(0), nil, nil, false},
+ {"overflow with defaults", new(math.MaxInt), nil, nil, false},
+ } {
+ t.Run(tt.name, func(t *testing.T) {
+ err := ValidatePagination(tt.page, tt.pageSize, tt.size)
+ if (err == nil) != tt.valid {
+ t.Fatalf("error = %v, want valid %v", err, tt.valid)
+ }
+ })
+ }
+}
diff --git a/internal/dao/chat_session.go b/internal/dao/chat_session.go
index 4cc5bfaf19..acdb05e7bd 100644
--- a/internal/dao/chat_session.go
+++ b/internal/dao/chat_session.go
@@ -182,7 +182,7 @@ func (dao *ChatSessionDAO) ListByResourceIDs(ctx context.Context, db *gorm.DB, c
query = query.Order(chatSessionOrderClause(terms)).Order("id DESC")
if pageSize > 0 {
if page < 1 {
- page = 1
+ page = common.DefaultPage
}
query = query.Offset((page - 1) * pageSize).Limit(pageSize)
}
@@ -241,10 +241,10 @@ func (dao *ChatSessionDAO) ListAgentSessionNames(ctx context.Context, db *gorm.D
}
if page <= 0 {
- page = 1
+ page = common.DefaultPage
}
if pageSize <= 0 {
- pageSize = 30
+ pageSize = common.DefaultPageSize
}
var rows []map[string]interface{}
@@ -335,12 +335,12 @@ func (dao *ChatSessionDAO) ListAgentSessions(ctx context.Context, db *gorm.DB, p
page := params.Page
if page <= 0 {
- page = 1
+ page = common.DefaultPage
}
pageSize := params.PageSize
if pageSize <= 0 {
- pageSize = 30
+ pageSize = common.DefaultPageSize
}
var sessions []*entity.API4Conversation
diff --git a/internal/handler/agent.go b/internal/handler/agent.go
index e38ca15666..1492e190bd 100644
--- a/internal/handler/agent.go
+++ b/internal/handler/agent.go
@@ -156,8 +156,8 @@ func (h *AgentHandler) WithNewExecutor(f func(taskCtx *task.TaskContext, canvasI
// @Tags agents
// @Produce json
// @Param keywords query string false "Filter by title keyword"
-// @Param page query int false "Page number (0 = no pagination)"
-// @Param page_size query int false "Items per page (0 = no pagination)"
+// @Param page query int false "Page number (default: 1, min: 1)"
+// @Param page_size query int false "Items per page (default: 30, min: 1, max: 100)"
// @Param orderby query string false "Order-by field (default: create_time)"
// @Param sort query string false "Ordered terms, column:direction separated by commas, such as name:asc,create_time:desc. Takes precedence over orderby and desc"
// @Param desc query bool false "Descending order (default: true)"
@@ -170,6 +170,12 @@ func (h *AgentHandler) ListAgents(c *gin.Context) {
// Filter-aggregation mode: the agents page filter bar fetches
// GET /api/v1/agents?type=filter and expects
// {filter: {owner, canvas_category}, total} instead of a canvas list.
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
+ }
+
if c.Query("type") == "filter" {
filters, code, err := h.agentService.ListAgentFilters(c.Request.Context(), strings.TrimSpace(c.Query("canvas_category")))
if err != nil {
@@ -184,20 +190,6 @@ func (h *AgentHandler) ListAgents(c *gin.Context) {
canvasCategory := c.Query("canvas_category")
canvasType := c.Query("canvas_type")
- page := 0
- if v := c.Query("page"); v != "" {
- if p, err := strconv.Atoi(v); err == nil && p > 0 {
- page = p
- }
- }
-
- pageSize := 0
- if v := c.Query("page_size"); v != "" {
- if ps, err := strconv.Atoi(v); err == nil && ps > 0 {
- pageSize = ps
- }
- }
-
orderby := c.Query("orderby")
desc := true
@@ -897,8 +889,12 @@ func (h *AgentHandler) UpdateAgentTags(c *gin.Context) {
// ListAgentSessions GET /api/v1/agents/:canvas_id/sessions
func (h *AgentHandler) ListAgentSessions(c *gin.Context) {
canvasID := c.Param("canvas_id")
- page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
- pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "30"))
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
+ }
+
keywords := c.Query("keywords")
fromDate := c.Query("from_date")
toDate := c.Query("to_date")
diff --git a/internal/handler/chat.go b/internal/handler/chat.go
index 37685129af..7073fc54d5 100644
--- a/internal/handler/chat.go
+++ b/internal/handler/chat.go
@@ -81,18 +81,10 @@ func (h *ChatHandler) ListChats(c *gin.Context) {
keywords = ""
}
- page := 0
- if pageStr := c.Query("page"); pageStr != "" {
- if p, err := strconv.Atoi(pageStr); err == nil && p > 0 {
- page = p
- }
- }
-
- pageSize := 0
- if pageSizeStr := c.Query("page_size"); pageSizeStr != "" {
- if ps, err := strconv.Atoi(pageSizeStr); err == nil && ps > 0 {
- pageSize = ps
- }
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
}
// `sort` supersedes the older pair, so a request it can order is not rejected
diff --git a/internal/handler/chat_session.go b/internal/handler/chat_session.go
index cd92cb9fd0..9b1f18d6f9 100644
--- a/internal/handler/chat_session.go
+++ b/internal/handler/chat_session.go
@@ -79,20 +79,10 @@ func (h *ChatSessionHandler) ListChatSessions(c *gin.Context) {
return
}
- // Mirror Python's list_sessions query handling: invalid/negative page
- // values fall back to the default; page_size 0 yields an empty list and a
- // negative page_size disables pagination.
- page := 1
- if pageStr := c.Query("page"); pageStr != "" {
- if p, err := strconv.Atoi(pageStr); err == nil && p > 0 {
- page = p
- }
- }
- pageSize := 30
- if pageSizeStr := c.Query("page_size"); pageSizeStr != "" {
- if ps, err := strconv.Atoi(pageSizeStr); err == nil {
- pageSize = ps
- }
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
}
// `sort` supersedes the older pair, so a request it can order is not rejected
diff --git a/internal/handler/chunk.go b/internal/handler/chunk.go
index 26894392bc..2a743fbd0d 100644
--- a/internal/handler/chunk.go
+++ b/internal/handler/chunk.go
@@ -23,7 +23,6 @@ import (
"io"
"net/http"
"ragflow/internal/common"
- "strconv"
"strings"
"github.com/gin-gonic/gin"
@@ -131,12 +130,7 @@ func (h *ChunkHandler) ListChunks(c *gin.Context) {
return
}
- page, err := parsePositiveQueryInt(c, "page", 1)
- if err != nil {
- common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
- return
- }
- size, err := parsePositiveQueryInt(c, "page_size", 30)
+ page, size, err := common.ParsePagination(c.Request.URL.Query())
if err != nil {
common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
@@ -195,18 +189,6 @@ func queryStringList(c *gin.Context, name string) []string {
return ids
}
-func parsePositiveQueryInt(c *gin.Context, name string, defaultValue int) (int, error) {
- raw := strings.TrimSpace(c.Query(name))
- if raw == "" {
- return defaultValue, nil
- }
- value, err := strconv.Atoi(raw)
- if err != nil || value <= 0 {
- return 0, fmt.Errorf("%s must be a positive integer", name)
- }
- return value, nil
-}
-
func parseAvailableQuery(raw string) (int, bool, error) {
switch strings.ToLower(strings.TrimSpace(raw)) {
case "":
diff --git a/internal/handler/compilation_template_group.go b/internal/handler/compilation_template_group.go
index dfb7f8f529..3b1629265c 100644
--- a/internal/handler/compilation_template_group.go
+++ b/internal/handler/compilation_template_group.go
@@ -17,8 +17,6 @@
package handler
import (
- "strconv"
-
"ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/permission"
@@ -55,14 +53,12 @@ func NewCompilationTemplateGroupHandler(svc *service.CompilationTemplateGroupSer
// @Success 200 {object} map[string]interface{}
// @Router /v1/compilation-template-groups [get]
func (h *CompilationTemplateGroupHandler) List(c *gin.Context) {
- page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
- pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "30"))
- if page < 1 {
- page = 1
- }
- if pageSize < 1 {
- pageSize = 30
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
}
+
keywords := c.Query("keywords")
scope := c.Query("scope")
tenantID := c.Query("tenant_id")
diff --git a/internal/handler/connector.go b/internal/handler/connector.go
index 1e045ef7b6..85a7b0f989 100644
--- a/internal/handler/connector.go
+++ b/internal/handler/connector.go
@@ -22,7 +22,6 @@ import (
"errors"
"io"
"net/http"
- "strconv"
"strings"
"github.com/gin-gonic/gin"
@@ -192,24 +191,10 @@ func decodeUpdateConnectorRequest(c *gin.Context) (*service.UpdateConnectorReque
// @Router /api/v1/connectors/{connector_id}/logs [get]
func (h *ConnectorHandler) ListLogs(c *gin.Context) {
- page := 1
- if rawPage := strings.TrimSpace(c.DefaultQuery("page", "1")); rawPage != "" {
- parsedPage, err := strconv.Atoi(rawPage)
- if err != nil {
- common.RespondError(c, common.CodeArgumentError, "page must be an integer")
- return
- }
- page = parsedPage
- }
-
- pageSize := 15
- if rawPageSize := strings.TrimSpace(c.DefaultQuery("page_size", "15")); rawPageSize != "" {
- parsedPageSize, err := strconv.Atoi(rawPageSize)
- if err != nil {
- common.RespondError(c, common.CodeArgumentError, "page_size must be an integer")
- return
- }
- pageSize = parsedPageSize
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
}
ctx := c.Request.Context()
@@ -238,23 +223,10 @@ func (h *ConnectorHandler) ListLogs(c *gin.Context) {
// @Router /api/v1/connectors/sync-logs [get]
func (h *ConnectorHandler) ListSyncLogs(c *gin.Context) {
- page := 1
- pageSize := 15
- if rawPage := strings.TrimSpace(c.Query("page")); rawPage != "" {
- parsedPage, err := strconv.Atoi(rawPage)
- if err != nil {
- common.RespondError(c, common.CodeArgumentError, "page must be an integer")
- return
- }
- page = parsedPage
- }
- if rawPageSize := strings.TrimSpace(c.Query("page_size")); rawPageSize != "" {
- parsedPageSize, err := strconv.Atoi(rawPageSize)
- if err != nil {
- common.RespondError(c, common.CodeArgumentError, "page_size must be an integer")
- return
- }
- pageSize = parsedPageSize
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
}
datasetID := strings.TrimSpace(c.Query("dataset_id"))
diff --git a/internal/handler/connector_test.go b/internal/handler/connector_test.go
index 94f0204391..a5488495c2 100644
--- a/internal/handler/connector_test.go
+++ b/internal/handler/connector_test.go
@@ -638,14 +638,14 @@ func TestConnectorHandlerListSyncLogs(t *testing.T) {
query: "",
wantCode: common.CodeSuccess,
wantPage: 1,
- wantPageSize: 15,
+ wantPageSize: 30,
},
{
name: "page only defaults page_size",
query: "?page=3",
wantCode: common.CodeSuccess,
wantPage: 3,
- wantPageSize: 15,
+ wantPageSize: 30,
},
{
name: "page_size only defaults page",
diff --git a/internal/handler/dataset.go b/internal/handler/dataset.go
index eeaa80744e..85d98c4fd8 100644
--- a/internal/handler/dataset.go
+++ b/internal/handler/dataset.go
@@ -76,6 +76,12 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
return
}
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
+ }
+
if c.Query("type") == "filter" {
ctx := c.Request.Context()
data, code, err := h.datasetsService.ListDatasetFilters(ctx, c.Query("canvas_id"))
@@ -95,35 +101,6 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
}
}
- // Mirror the pydantic validation of Python's ListDatasetReq.
- page := 1
- if pageStr := c.Query("page"); pageStr != "" {
- p, err := strconv.Atoi(pageStr)
- if err != nil {
- common.RespondError(c, common.CodeArgumentError, "Input should be a valid integer, unable to parse string as an integer")
- return
- }
- if p < 1 {
- common.RespondError(c, common.CodeArgumentError, "Input should be greater than or equal to 1")
- return
- }
- page = p
- }
-
- pageSize := 30
- if pageSizeStr := c.Query("page_size"); pageSizeStr != "" {
- ps, err := strconv.Atoi(pageSizeStr)
- if err != nil {
- common.RespondError(c, common.CodeArgumentError, "Input should be a valid integer, unable to parse string as an integer")
- return
- }
- if ps < 1 {
- common.RespondError(c, common.CodeArgumentError, "Input should be greater than or equal to 1")
- return
- }
- pageSize = ps
- }
-
// `sort` supersedes the older pair, so a request it can order is not rejected
// for the spelling of an `orderby` or `desc` that will not be read.
sortTerms := sortTermsFromQuery(c)
@@ -636,24 +613,10 @@ func (h *DatasetsHandler) ListIngestionLogs(c *gin.Context) {
datasetID := c.Param("dataset_id")
- page := 0
- if pageStr := c.Query("page"); pageStr != "" {
- p, err := strconv.Atoi(pageStr)
- if err != nil {
- common.RespondError(c, common.CodeArgumentError, "page must be an integer")
- return
- }
- page = p
- }
-
- pageSize := 0
- if pageSizeStr := c.Query("page_size"); pageSizeStr != "" {
- ps, err := strconv.Atoi(pageSizeStr)
- if err != nil {
- common.RespondError(c, common.CodeArgumentError, "page_size must be an integer")
- return
- }
- pageSize = ps
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
}
ctx := c.Request.Context()
@@ -1197,11 +1160,11 @@ func (h *DatasetsHandler) SearchDatasets(c *gin.Context) {
}
if req.Page == nil {
- defaultPage := 1
+ defaultPage := common.DefaultPage
req.Page = &defaultPage
}
if req.PageSize == nil && req.Size == nil {
- defaultSize := 30
+ defaultSize := common.DefaultPageSize
req.PageSize = &defaultSize
}
if req.KNNTopK == nil && req.TopK == nil {
@@ -1343,14 +1306,8 @@ func validateSearchDatasetRequest(req *service.SearchDatasetRequest) error {
}
func validateSearchParams(page, pageSize, size, knnTopK, topK, knnNumCandidates *int, similarityThreshold, vectorSimilarityWeight *float64) error {
- if page != nil && *page < 1 {
- return fmt.Errorf("page must be greater than or equal to 1")
- }
- if pageSize != nil && *pageSize < 1 {
- return fmt.Errorf("page_size must be greater than or equal to 1")
- }
- if size != nil && *size < 1 {
- return fmt.Errorf("size must be greater than or equal to 1")
+ if err := common.ValidatePagination(page, pageSize, size); err != nil {
+ return err
}
effectiveKNNTopK := 1024
knnTopKName := "knn_top_k"
diff --git a/internal/handler/dataset_artifact.go b/internal/handler/dataset_artifact.go
index 56f54a9b94..0a2bcfd816 100644
--- a/internal/handler/dataset_artifact.go
+++ b/internal/handler/dataset_artifact.go
@@ -32,10 +32,6 @@ import (
"go.uber.org/zap"
)
-// maxArtifactPageSize caps the page_size query parameter for artifact list
-// endpoints so a client cannot force an unbounded document-engine search.
-const maxArtifactPageSize = 100
-
// DatasetArtifactHandler exposes the knowledge-compilation artifact REST APIs
// backed by DatasetArtifactService.
type DatasetArtifactHandler struct {
@@ -108,17 +104,12 @@ func (h *DatasetArtifactHandler) ListArtifacts(c *gin.Context) {
pageType := c.Query("page_type")
topic := c.Query("topic")
keywords := strings.TrimSpace(c.Query("keywords"))
- page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
- pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "30"))
- if page < 1 {
- page = 1
- }
- if pageSize < 1 {
- pageSize = 30
- }
- if pageSize > maxArtifactPageSize {
- pageSize = maxArtifactPageSize
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
}
+
items, total, err := h.svc.ListWikiPages(c.Request.Context(), tenantID, datasetID, pageType, topic, keywords, page, pageSize)
if err != nil {
common.RespondError(c, common.CodeDataError, err.Error())
diff --git a/internal/handler/document.go b/internal/handler/document.go
index 4de00178eb..62cdbfa8b2 100644
--- a/internal/handler/document.go
+++ b/internal/handler/document.go
@@ -602,10 +602,11 @@ func (h *DocumentHandler) BatchUpdateDocumentStatus(c *gin.Context) {
func (h *DocumentHandler) ListDocuments(c *gin.Context) {
datasetID := c.Param("dataset_id")
- pageStr := c.Query("page")
- pageSizeStr := c.Query("page_size")
- page, _ := strconv.Atoi(pageStr)
- pageSize, _ := strconv.Atoi(pageSizeStr)
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
+ }
if orderby := c.Query("orderby"); orderby != "" {
switch orderby {
@@ -622,13 +623,6 @@ func (h *DocumentHandler) ListDocuments(c *gin.Context) {
return
}
- if page < 1 {
- page = 1
- }
- if pageSize < 1 || pageSize > 100 {
- pageSize = 10
- }
-
opts, errMsg := parseDocumentListOptions(c, datasetID)
if errMsg != "" {
common.RespondError(c, common.CodeDataError, errMsg)
diff --git a/internal/handler/file.go b/internal/handler/file.go
index 3be0c68186..65fca220b1 100644
--- a/internal/handler/file.go
+++ b/internal/handler/file.go
@@ -24,7 +24,6 @@ import (
permissionresponse "ragflow/internal/permission/response"
"ragflow/internal/storage"
"ragflow/internal/utility"
- "strconv"
"strings"
"time"
@@ -72,7 +71,7 @@ func NewFileHandler(fileService *file.FileService, userService *service.UserServ
// @Param tenant_id query string false "tenant whose files are listed (defaults to the current user)"
// @Param keywords query string false "search keywords (case-insensitive)"
// @Param page query int false "page number (default: 1, min: 1)"
-// @Param page_size query int false "items per page (default: 15, min: 1, max: 100)"
+// @Param page_size query int false "items per page (default: 30, min: 1, max: 100)"
// @Param orderby query string false "order by field (default: create_time)"
// @Param sort query string false "ordered terms, column:direction separated by commas, such as name:asc,create_time:desc. Takes precedence over orderby and desc"
// @Param desc query bool false "descending order (default: true)"
@@ -93,31 +92,10 @@ func (h *FileHandler) ListFiles(c *gin.Context) {
}
keywords := c.Query("keywords")
- page := 1
- if pageStr := c.Query("page"); pageStr != "" {
- if p, err := strconv.Atoi(pageStr); err == nil && p >= 1 {
- page = p
- } else if err != nil {
- common.RespondError(c, common.CodeParamError, "Invalid page parameter: must be a positive integer")
- return
- }
- }
-
- pageSize := 15
- if pageSizeStr := c.Query("page_size"); pageSizeStr != "" {
- if ps, err := strconv.Atoi(pageSizeStr); err == nil {
- if ps < 1 {
- common.RespondError(c, common.CodeParamError, "Invalid page_size parameter: must be at least 1")
- return
- }
- if ps > 100 {
- ps = 100
- }
- pageSize = ps
- } else {
- common.RespondError(c, common.CodeParamError, "Invalid page_size parameter: must be a positive integer")
- return
- }
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeParamError, err.Error())
+ return
}
orderBy := c.DefaultQuery("orderby", "create_time")
diff --git a/internal/handler/file_commit.go b/internal/handler/file_commit.go
index b6e38bf732..79bca92c5e 100644
--- a/internal/handler/file_commit.go
+++ b/internal/handler/file_commit.go
@@ -25,7 +25,6 @@ import (
"ragflow/internal/entity"
"ragflow/internal/permission"
"ragflow/internal/service/file"
- "strconv"
"strings"
"github.com/gin-gonic/gin"
@@ -258,21 +257,10 @@ func (h *FileCommitHandler) ListCommits(c *gin.Context) {
common.RespondError(c, common.CodeNotFound, "Workspace not found")
return
}
- page := 1
- if pageStr := c.Query("page"); pageStr != "" {
- if p, err := strconv.Atoi(pageStr); err == nil && p >= 1 {
- page = p
- }
- }
-
- pageSize := 15
- if psStr := c.Query("page_size"); psStr != "" {
- if ps, err := strconv.Atoi(psStr); err == nil {
- if ps < 1 {
- ps = 15
- }
- pageSize = ps
- }
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeParamError, err.Error())
+ return
}
orderBy := c.DefaultQuery("order_by", "create_time")
diff --git a/internal/handler/mcp.go b/internal/handler/mcp.go
index a391abbdef..a36d0daf17 100644
--- a/internal/handler/mcp.go
+++ b/internal/handler/mcp.go
@@ -19,10 +19,8 @@ package handler
import (
"encoding/json"
"errors"
- "fmt"
"io"
"net/http"
- "strconv"
"strings"
"time"
@@ -35,10 +33,7 @@ import (
)
const (
- defaultMCPServerPage = 0
- defaultMCPServerPageSize = 0
- maxMCPServerPageSize = 100
- mcpServerDateFormat = "2006-01-02T15:04:05"
+ mcpServerDateFormat = "2006-01-02T15:04:05"
)
// MCPHandler handles MCP server requests.
@@ -90,16 +85,12 @@ func (h *MCPHandler) CreateMCPServer(c *gin.Context) {
// ListMCPServers lists MCP servers for an owned tenant or a requested tenant the caller belongs to.
func (h *MCPHandler) ListMCPServers(c *gin.Context) {
- page, err := parseMCPServerPage(c.Query("page"))
- if err != nil {
- common.RespondError(c, common.CodeDataError, err.Error())
- return
- }
- pageSize, err := parseMCPServerPageSize(c.Query("page_size"))
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
if err != nil {
common.RespondError(c, common.CodeDataError, err.Error())
return
}
+
ctx := c.Request.Context()
orderby := c.DefaultQuery("orderby", "create_time")
desc := strings.ToLower(c.DefaultQuery("desc", "true")) != "false"
@@ -383,31 +374,6 @@ func formatMCPServerDate(date *time.Time) string {
return date.Format(mcpServerDateFormat)
}
-func parseMCPServerPage(value string) (int, error) {
- if value == "" {
- return defaultMCPServerPage, nil
- }
- page, err := strconv.Atoi(value)
- if err != nil {
- return 0, fmt.Errorf("page must be an integer")
- }
- return page, nil
-}
-
-func parseMCPServerPageSize(value string) (int, error) {
- if value == "" {
- return defaultMCPServerPageSize, nil
- }
- pageSize, err := strconv.Atoi(value)
- if err != nil {
- return 0, fmt.Errorf("page_size must be an integer")
- }
- if pageSize > maxMCPServerPageSize {
- return 0, fmt.Errorf("page_size must be less than or equal to %d", maxMCPServerPageSize)
- }
- return pageSize, nil
-}
-
func getMCPIDsFromQuery(c *gin.Context) []string {
rawValues := c.QueryArray("mcp_ids")
if len(rawValues) == 0 {
diff --git a/internal/handler/mcp_retrieval.go b/internal/handler/mcp_retrieval.go
index 29f476c82c..5f4b6d9b71 100644
--- a/internal/handler/mcp_retrieval.go
+++ b/internal/handler/mcp_retrieval.go
@@ -25,10 +25,10 @@ const mcpRerankCandidatesCount = 512
// multiplying so a hostile page value cannot overflow page * pageSize.
func validateRetrievalWindow(page, pageSize int) error {
if page <= 0 {
- page = 1
+ page = common.DefaultPage
}
if pageSize <= 0 {
- pageSize = 30
+ pageSize = common.DefaultPageSize
}
if page > mcpRerankCandidatesCount/pageSize {
return fmt.Errorf("page (%d) * page_size (%d) exceeds the fixed rerank candidate window (%d); narrow page or page_size", page, pageSize, mcpRerankCandidatesCount)
@@ -60,14 +60,13 @@ func mcpRetrieval(ctx context.Context, ds mcpDatasetService, req mcp.RetrievalRe
// across all pages (matching Python _fetch_all_datasets behaviour).
datasetIDs := req.DatasetIDs
if len(datasetIDs) == 0 {
- const maxPageSize = 100
ids, err := fetchAllDatasetIDs(func(page, pageSize int) ([]map[string]interface{}, int64, error) {
data, total, _, err := ds.ListDatasets(ctx,
"", "", page, pageSize, []dao.OrderTerm{{Column: "create_time", Desc: true}},
"", nil, "", nil, "",
)
return data, total, err
- }, maxPageSize)
+ }, common.MaxPageSize)
if err != nil {
return "", fmt.Errorf("cannot resolve accessible datasets: %w", err)
}
@@ -234,10 +233,10 @@ func mcpRetrievalResult(req mcp.RetrievalRequest, datasetIDs []string, resp *ser
}
page, size := req.Page, req.PageSize
if page <= 0 {
- page = 1
+ page = common.DefaultPage
}
if size <= 0 {
- size = 30
+ size = common.DefaultPageSize
}
return map[string]any{
"chunks": chunks,
diff --git a/internal/handler/memory.go b/internal/handler/memory.go
index 4a891d041b..d0d4b9f1ad 100644
--- a/internal/handler/memory.go
+++ b/internal/handler/memory.go
@@ -288,7 +288,7 @@ func splitQueryValues(c *gin.Context, key string) []string {
// - storage_type (optional): Storage type filter
// - keywords (optional): Keyword search (fuzzy match on name)
// - page (optional): Page number, default 1
-// - page_size (optional): Items per page, default 50
+// - page_size (optional): Items per page, default 30
//
// Response Format:
// - code: Status code
@@ -296,6 +296,12 @@ func splitQueryValues(c *gin.Context, key string) []string {
// - data.memory_list: Array of Memory objects
// - data.total_count: Total record count
func (h *MemoryHandler) ListMemories(c *gin.Context) {
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
+ }
+
if c.Query("type") == "filter" {
result, err := h.memoryService.ListMemoryFilters(c.Request.Context())
if err != nil {
@@ -309,20 +315,6 @@ func (h *MemoryHandler) ListMemories(c *gin.Context) {
// Parse query parameters
storageType := c.Query("storage_type")
keywords := c.Query("keywords")
- pageStr := c.DefaultQuery("page", "1")
- pageSizeStr := c.DefaultQuery("page_size", "50")
-
- // Convert pagination parameters to integers
- page, _ := strconv.Atoi(pageStr)
- pageSize, _ := strconv.Atoi(pageSizeStr)
-
- // Validate pagination parameters
- if page < 1 {
- page = 1
- }
- if pageSize < 1 {
- pageSize = 50
- }
// Parse memory_type parameter (repeated query keys and comma separation)
memoryTypes := splitQueryValues(c, "memory_type")
@@ -404,7 +396,7 @@ func (h *MemoryHandler) GetMemoryConfig(c *gin.Context) {
// - agent_id (optional): Agent ID filter, supports comma-separated multiple
// - keywords (optional): Keyword search
// - page (optional): Page number, default 1
-// - page_size (optional): Items per page, default 50
+// - page_size (optional): Items per page, default 30
//
// Response Format:
// - code: Status code
@@ -422,18 +414,9 @@ func (h *MemoryHandler) GetMemoryMessages(c *gin.Context) {
agentIDs := splitQueryValues(c, "agent_id")
keywords := strings.TrimSpace(c.DefaultQuery("keywords", ""))
- page, err := strconv.Atoi(c.DefaultQuery("page", "1"))
- if err != nil || page <= 0 {
- common.RespondError(c, common.CodeArgumentError, "page must be a positive integer")
- return
- }
- pageSize, err := strconv.Atoi(c.DefaultQuery("page_size", "50"))
- if err != nil || pageSize <= 0 {
- common.RespondError(c, common.CodeArgumentError, "page_size must be a positive integer")
- return
- }
- if pageSize > 100 {
- common.RespondError(c, common.CodeArgumentError, "page_size must be less than or equal to 100")
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
diff --git a/internal/handler/models.go b/internal/handler/models.go
index 84ab934256..c64b010ccf 100644
--- a/internal/handler/models.go
+++ b/internal/handler/models.go
@@ -19,7 +19,6 @@ package handler
import (
"ragflow/internal/common"
"ragflow/internal/service"
- "strconv"
"github.com/gin-gonic/gin"
)
@@ -38,18 +37,10 @@ func NewModelHandler(modelProviderService *service.ModelProviderService) *ModelH
func (h *ModelHandler) ListAllModels(c *gin.Context) {
- page := 0
- if v := c.Query("page"); v != "" {
- if p, err := strconv.Atoi(v); err == nil && p > 0 {
- page = p
- }
- }
-
- pageSize := 0
- if v := c.Query("page_size"); v != "" {
- if ps, err := strconv.Atoi(v); err == nil && ps > 0 {
- pageSize = ps
- }
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
}
// list tenant models
diff --git a/internal/handler/pagination_test.go b/internal/handler/pagination_test.go
new file mode 100644
index 0000000000..1163b4e2ff
--- /dev/null
+++ b/internal/handler/pagination_test.go
@@ -0,0 +1,163 @@
+package handler
+
+import (
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/gin-gonic/gin"
+
+ "ragflow/internal/common"
+ "ragflow/internal/dao"
+ "ragflow/internal/entity"
+ "ragflow/internal/permission"
+ dataset "ragflow/internal/service/dataset"
+)
+
+func TestListHandlersRejectInvalidPagination(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ for name, handle := range map[string]gin.HandlerFunc{
+ "datasets": (&DatasetsHandler{}).ListDatasets,
+ "ingestion logs": (&DatasetsHandler{}).ListIngestionLogs,
+ "chats": (&ChatHandler{}).ListChats,
+ "chat sessions": (&ChatSessionHandler{}).ListChatSessions,
+ "agents": (&AgentHandler{}).ListAgents,
+ "agent sessions": (&AgentHandler{}).ListAgentSessions,
+ "searches": (&SearchHandler{}).ListSearches,
+ "models": (&ModelHandler{}).ListAllModels,
+ "files": (&FileHandler{}).ListFiles,
+ "documents": (&DocumentHandler{}).ListDocuments,
+ "chunks": (&ChunkHandler{}).ListChunks,
+ "memories": (&MemoryHandler{}).ListMemories,
+ "memory messages": (&MemoryHandler{}).GetMemoryMessages,
+ "connector logs": (&ConnectorHandler{}).ListLogs,
+ "sync logs": (&ConnectorHandler{}).ListSyncLogs,
+ "MCP servers": (&MCPHandler{}).ListMCPServers,
+ "compilation groups": (&CompilationTemplateGroupHandler{}).List,
+ } {
+ for _, query := range []string{"page_size=101", "page_size=0", "page_size=-1", "page_size=invalid", "page_size=1&page_size=101"} {
+ t.Run(name+"/"+query, func(t *testing.T) {
+ rec := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(rec)
+ c.Request = httptest.NewRequest(http.MethodGet, "/?"+query, nil)
+ c.Set("user", &entity.User{ID: "user-1"})
+ c.Params = gin.Params{{Key: "chat_id", Value: "chat-1"}, {Key: "dataset_id", Value: "ds-1"}, {Key: "document_id", Value: "doc-1"}, {Key: "memory_id", Value: "mem-1"}}
+ handle(c)
+ var response struct {
+ Code common.ErrorCode `json:"code"`
+ Message string `json:"message"`
+ }
+ if err := json.Unmarshal(rec.Body.Bytes(), &response); err != nil {
+ t.Fatal(err)
+ }
+ if response.Code == common.CodeSuccess || !strings.Contains(response.Message, "page_size") {
+ t.Fatalf("unexpected response: %s", rec.Body.String())
+ }
+ })
+ }
+ }
+}
+
+func TestSearchHandlersRejectOversizedJSONPagination(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ for name, handle := range map[string]gin.HandlerFunc{
+ "dataset": (&DatasetsHandler{}).SearchDataset,
+ "datasets": (&DatasetsHandler{}).SearchDatasets,
+ } {
+ for _, fields := range []string{`"page_size":101`, `"size":101`, `"page_size":10,"size":101`, `"page_size":0`} {
+ t.Run(name+"/"+fields, func(t *testing.T) {
+ rec := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(rec)
+ c.Request = httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"question":"hello","dataset_ids":["ds-1"],`+fields+`}`))
+ c.Request.Header.Set("Content-Type", "application/json")
+ c.Set("user", &entity.User{ID: "user-1"})
+ c.Params = gin.Params{{Key: "dataset_id", Value: "ds-1"}}
+ handle(c)
+ var response struct {
+ Code common.ErrorCode `json:"code"`
+ Message string `json:"message"`
+ }
+ if err := json.Unmarshal(rec.Body.Bytes(), &response); err != nil {
+ t.Fatal(err)
+ }
+ if response.Code == common.CodeSuccess || !strings.Contains(response.Message, "size must be between 1 and 100") {
+ t.Fatalf("unexpected response: %s", rec.Body.String())
+ }
+ })
+ }
+ }
+}
+
+func TestRetrievalAndSkillSearchRejectOversizedPagination(t *testing.T) {
+ for _, tt := range []struct {
+ name string
+ handle gin.HandlerFunc
+ body string
+ }{
+ {"retrieval", (&SearchBotHandler{}).RetrievalTest, `{"question":"hello","kb_ids":["ds-1"],"size":101}`},
+ {"skills", (&SkillSearchHandler{}).Search, `{"query":"hello","page_size":101}`},
+ } {
+ t.Run(tt.name, func(t *testing.T) {
+ rec := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(rec)
+ c.Request = httptest.NewRequest(http.MethodPost, "/", strings.NewReader(tt.body))
+ c.Request.Header.Set("Content-Type", "application/json")
+ c.Set("user", &entity.User{ID: "user-1"})
+ tt.handle(c)
+ var response struct {
+ Code common.ErrorCode `json:"code"`
+ Message string `json:"message"`
+ }
+ if err := json.Unmarshal(rec.Body.Bytes(), &response); err != nil {
+ t.Fatal(err)
+ }
+ if response.Code == common.CodeSuccess || !strings.Contains(response.Message, "size must be between 1 and 100") {
+ t.Fatalf("unexpected response: %s", rec.Body.String())
+ }
+ })
+ }
+}
+
+func TestCommitsRejectOversizedPagination(t *testing.T) {
+ originalDB := dao.DB
+ t.Cleanup(func() { dao.DB = originalDB })
+ router, _ := setupFileCommitTest("user-1")
+ rec := httptest.NewRecorder()
+ router.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/api/v1/folders/folder-1/commits?page_size=101", nil))
+ var response struct {
+ Code common.ErrorCode `json:"code"`
+ Message string `json:"message"`
+ }
+ if err := json.Unmarshal(rec.Body.Bytes(), &response); err != nil {
+ t.Fatal(err)
+ }
+ if response.Code == common.CodeSuccess || response.Message != "page_size must be between 1 and 100" {
+ t.Fatalf("unexpected response: %s", rec.Body.String())
+ }
+}
+
+func TestArtifactsRejectOversizedPagination(t *testing.T) {
+ const datasetID = "123e4567e89b12d3a456426614174000"
+ db := setupArtifactGraphDB(t)
+ insertArtifactGraphKB(t, db, datasetID, "user-1")
+ h := &DatasetArtifactHandler{datasetSvc: dataset.NewDatasetService()}
+ rec := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(rec)
+ req := httptest.NewRequest(http.MethodGet, "/?page_size=101", nil)
+ c.Request = req.WithContext(permission.WithIdentity(req.Context(), "user-1", "user-1"))
+ c.Set("user", &entity.User{ID: "user-1"})
+ c.Params = gin.Params{{Key: "dataset_id", Value: datasetID}}
+ h.ListArtifacts(c)
+ var response struct {
+ Code common.ErrorCode `json:"code"`
+ Message string `json:"message"`
+ }
+ if err := json.Unmarshal(rec.Body.Bytes(), &response); err != nil {
+ t.Fatal(err)
+ }
+ if response.Code == common.CodeSuccess || response.Message != "page_size must be between 1 and 100" {
+ t.Fatalf("unexpected response: %s", rec.Body.String())
+ }
+}
diff --git a/internal/handler/search.go b/internal/handler/search.go
index 503e9177b8..386fde59b6 100644
--- a/internal/handler/search.go
+++ b/internal/handler/search.go
@@ -22,7 +22,6 @@ import (
"ragflow/internal/common"
"ragflow/internal/permission"
- "strconv"
"strings"
"github.com/gin-gonic/gin"
@@ -91,18 +90,10 @@ func (h *SearchHandler) ListSearches(c *gin.Context) {
// Parse query parameters
keywords := c.Query("keywords")
- page := 0
- if pageStr := c.Query("page"); pageStr != "" {
- if p, err := strconv.Atoi(pageStr); err == nil && p > 0 {
- page = p
- }
- }
-
- pageSize := 0
- if pageSizeStr := c.Query("page_size"); pageSizeStr != "" {
- if ps, err := strconv.Atoi(pageSizeStr); err == nil && ps > 0 {
- pageSize = ps
- }
+ page, pageSize, err := common.ParsePagination(c.Request.URL.Query())
+ if err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
}
orderby := c.DefaultQuery("orderby", "create_time")
diff --git a/internal/handler/searchbot.go b/internal/handler/searchbot.go
index 9d2b91cecd..2475ce00bf 100644
--- a/internal/handler/searchbot.go
+++ b/internal/handler/searchbot.go
@@ -193,6 +193,10 @@ func (h *SearchBotHandler) RetrievalTest(c *gin.Context) {
}
req.VectorSimilarityWeight = vectorSimilarityWeight
+ if err := common.ValidatePagination(req.Page, nil, req.Size); err != nil {
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ return
+ }
applyRetrievalDefaults(&req)
if req.TopK != nil && *req.TopK <= 0 {
@@ -581,11 +585,11 @@ func toRetrievalServiceRequest(h *SearchBotRetrievalTestRequest) *service.Retrie
// search_config, which a default here would hide.
func applyRetrievalDefaults(req *SearchBotRetrievalTestRequest) {
if req.Page == nil {
- v := 1
+ v := common.DefaultPage
req.Page = &v
}
if req.Size == nil {
- v := 30
+ v := common.DefaultPageSize
req.Size = &v
}
if req.UseKG == nil {
diff --git a/internal/handler/skill_search.go b/internal/handler/skill_search.go
index 8de26c59c3..03578c542c 100644
--- a/internal/handler/skill_search.go
+++ b/internal/handler/skill_search.go
@@ -104,12 +104,16 @@ func (h *SkillSearchHandler) UpdateConfig(c *gin.Context) {
// @Success 200 {object} map[string]interface{}
// @Router /v1/skills/search [post]
func (h *SkillSearchHandler) Search(c *gin.Context) {
- var req service.SearchRequest
+ req := service.SearchRequest{Page: common.DefaultPage, PageSize: common.DefaultPageSize}
if err := c.ShouldBindJSON(&req); err != nil {
common.RespondError(c, common.CodeDataError, err.Error())
return
}
+ if err := common.ValidatePagination(&req.Page, &req.PageSize, nil); err != nil {
+ common.RespondError(c, common.CodeArgumentError, err.Error())
+ return
+ }
result, code, err := h.searchService.Search(c.Request.Context(), &req, h.docEngine)
if err != nil {
common.RespondError(c, code, err.Error())
diff --git a/internal/service/chunk/chunk.go b/internal/service/chunk/chunk.go
index 861fe2ab99..70c5a0f387 100644
--- a/internal/service/chunk/chunk.go
+++ b/internal/service/chunk/chunk.go
@@ -412,8 +412,8 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
Question: modifiedQuestion,
KbIDs: []string(req.Datasets),
DocIDs: docIDs,
- Page: common.CoalesceInt(req.Page, 1),
- PageSize: common.CoalesceInt(req.Size, 30),
+ Page: common.CoalesceInt(req.Page, common.DefaultPage),
+ PageSize: common.CoalesceInt(req.Size, common.DefaultPageSize),
RerankCandidatesCount: &rerankCandidatesCount,
KNNTopK: &topK,
SimilarityThreshold: &similarityThreshold,
@@ -836,8 +836,8 @@ func (s *ChunkService) List(ctx context.Context, req *service.ListChunksRequest)
indexName := fmt.Sprintf("ragflow_%s", targetTenantID)
- page := common.CoalesceInt(req.Page, 1)
- size := common.CoalesceInt(req.Size, 30)
+ page := common.CoalesceInt(req.Page, common.DefaultPage)
+ size := common.CoalesceInt(req.Size, common.DefaultPageSize)
keywords := strings.TrimSpace(req.Keywords)
var orderBy *types.OrderByExpr
matchExprs := make([]interface{}, 0, 1)
diff --git a/internal/service/connector.go b/internal/service/connector.go
index 1ba666f76e..9eed9864ed 100644
--- a/internal/service/connector.go
+++ b/internal/service/connector.go
@@ -1321,10 +1321,10 @@ func (s *ConnectorService) ListLog(ctx context.Context, connectorID string, page
}
if page < 1 {
- page = 1
+ page = common.DefaultPage
}
- if pageSize <= 0 || pageSize > 100 {
- pageSize = 15
+ if pageSize <= 0 || pageSize > common.MaxPageSize {
+ pageSize = common.DefaultPageSize
}
offset := (page - 1) * pageSize
@@ -1388,10 +1388,10 @@ func (s *ConnectorService) ListLogs(ctx context.Context, datasetID string, page,
limit = 0
} else {
if page < 1 {
- page = 1
+ page = common.DefaultPage
}
- if pageSize > 100 {
- limit = 15
+ if pageSize > common.MaxPageSize {
+ limit = common.DefaultPageSize
}
offset = (page - 1) * limit
}
diff --git a/internal/service/dataset/crud.go b/internal/service/dataset/crud.go
index 40b51c2967..601808ae52 100644
--- a/internal/service/dataset/crud.go
+++ b/internal/service/dataset/crud.go
@@ -605,10 +605,10 @@ func (d *DatasetService) ListDatasets(ctx context.Context, id, name string, page
name = strings.TrimSpace(name)
if page <= 0 {
- page = 1
+ page = common.DefaultPage
}
if pageSize <= 0 {
- pageSize = 30
+ pageSize = common.DefaultPageSize
}
terms = keepDatasetOrderTerms(terms)
diff --git a/internal/service/dataset/ingestion.go b/internal/service/dataset/ingestion.go
index 00f4070a63..aa70b7cab2 100644
--- a/internal/service/dataset/ingestion.go
+++ b/internal/service/dataset/ingestion.go
@@ -239,10 +239,10 @@ func (d *DatasetService) ListSyncLogs(ctx context.Context, datasetID string, pag
}
if page <= 0 {
- page = 1
+ page = common.DefaultPage
}
if pageSize <= 0 {
- pageSize = 30
+ pageSize = common.DefaultPageSize
}
connectors, err := d.connectorDAO.ListByDatasetID(ctx, dao.DB, datasetID)
@@ -300,10 +300,10 @@ func (d *DatasetService) ListIngestionLogs(ctx context.Context, datasetID string
}
if page <= 0 {
- page = 1
+ page = common.DefaultPage
}
if pageSize <= 0 {
- pageSize = 30
+ pageSize = common.DefaultPageSize
}
var (
diff --git a/internal/service/dataset/search.go b/internal/service/dataset/search.go
index 8f023b2e2a..7a60c8ade7 100644
--- a/internal/service/dataset/search.go
+++ b/internal/service/dataset/search.go
@@ -38,11 +38,11 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
userID := permission.UserIDFromContext(ctx)
common.Info("SearchDatasets started", zap.String("userID", userID), zap.Any("datasets", req.DatasetIDs), zap.String("question", req.Question))
- page := 1
+ page := common.DefaultPage
if req.Page != nil {
page = *req.Page
}
- pageSize := 30
+ pageSize := common.DefaultPageSize
if req.PageSize != nil {
pageSize = *req.PageSize
} else if req.Size != nil {
diff --git a/internal/service/memory.go b/internal/service/memory.go
index 7b6e7352b9..c1d8c58b5e 100644
--- a/internal/service/memory.go
+++ b/internal/service/memory.go
@@ -1899,10 +1899,10 @@ func (s *MemoryService) listMemoryMessages(ctx context.Context, memory *entity.M
return nil, errors.New("message store is not initialized")
}
if page <= 0 {
- page = 1
+ page = common.DefaultPage
}
if pageSize <= 0 {
- pageSize = defaultMessageLimit
+ pageSize = common.DefaultPageSize
} else if pageSize > maxMessageLimit {
pageSize = maxMessageLimit
}
diff --git a/internal/service/model_pagination_test.go b/internal/service/model_pagination_test.go
new file mode 100644
index 0000000000..925fafdafe
--- /dev/null
+++ b/internal/service/model_pagination_test.go
@@ -0,0 +1,35 @@
+package service
+
+import (
+ "testing"
+
+ "ragflow/internal/common"
+ "ragflow/internal/dao"
+)
+
+func TestListAllModelsPagination(t *testing.T) {
+ catalog, err := dao.GetModelProviderManager().ListAllModels()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(catalog) <= common.MaxPageSize {
+ t.Fatalf("catalog has %d models, need more than a page", len(catalog))
+ }
+ svc := &ModelProviderService{}
+ for _, tt := range []struct {
+ name string
+ page, size, want int
+ }{
+ {"first", 1, 100, 100},
+ {"last", (len(catalog) + 99) / 100, 100, (len(catalog)-1)%100 + 1},
+ {"past end", len(catalog) + 1, 100, 0},
+ {"default size", 1, common.DefaultPageSize, common.DefaultPageSize},
+ } {
+ t.Run(tt.name, func(t *testing.T) {
+ models, err := svc.ListAllModels(tt.page, tt.size)
+ if err != nil || len(models) != tt.want {
+ t.Fatalf("count/error = %d/%v, want %d/nil", len(models), err, tt.want)
+ }
+ })
+ }
+}
diff --git a/internal/service/model_service.go b/internal/service/model_service.go
index 48f6ba6511..2be8b56038 100644
--- a/internal/service/model_service.go
+++ b/internal/service/model_service.go
@@ -3110,10 +3110,14 @@ func (m *ModelProviderService) ListAllModels(pageIndex, pageSize int) ([]map[str
if err != nil {
return nil, err
}
- if pageSize > 0 && pageIndex >= 0 && pageIndex*pageSize < len(models) {
- return models[pageIndex*pageSize : (pageIndex+1)*pageSize], nil
+ if err := common.ValidatePagination(&pageIndex, &pageSize, nil); err != nil {
+ return nil, err
+ }
+ start := (pageIndex - 1) * pageSize
+ if start >= len(models) {
+ return []map[string]interface{}{}, nil
}
- return models, nil
+ return models[start:min(start+pageSize, len(models))], nil
}
func (m *ModelProviderService) ShowModel(modelName string) (*modelModule.Model, error) {
diff --git a/internal/service/nlp/retrieval.go b/internal/service/nlp/retrieval.go
index a82279144e..7a4f6164da 100644
--- a/internal/service/nlp/retrieval.go
+++ b/internal/service/nlp/retrieval.go
@@ -741,7 +741,7 @@ func (s *RetrievalService) Search(ctx context.Context, req *RetrievalSearchReque
// Result pagination is independent of the KNN candidate pool size.
pageSize := req.PageSize
if pageSize <= 0 {
- pageSize = 30
+ pageSize = common.DefaultPageSize
}
limit := pageSize
diff --git a/internal/service/skill_search.go b/internal/service/skill_search.go
index 13883c2991..44dde9f090 100644
--- a/internal/service/skill_search.go
+++ b/internal/service/skill_search.go
@@ -233,10 +233,10 @@ func (s *SkillSearchService) Search(ctx context.Context, req *SearchRequest, doc
}
req.TenantID = tenantID
if req.Page <= 0 {
- req.Page = 1
+ req.Page = common.DefaultPage
}
if req.PageSize <= 0 {
- req.PageSize = 10
+ req.PageSize = common.DefaultPageSize
}
// Check if index exists before searching
diff --git a/internal/service/skill_search_test.go b/internal/service/skill_search_test.go
index 23fe2efe0b..d4d1bde295 100644
--- a/internal/service/skill_search_test.go
+++ b/internal/service/skill_search_test.go
@@ -531,22 +531,23 @@ func TestSearchPaginationWindow(t *testing.T) {
}
// TestSearchDefaultsPageAndPageSize verifies that non-positive page and page
-// size default to 1 and 10 respectively.
+// size default to 1 and 30 respectively.
func TestSearchDefaultsPageAndPageSize(t *testing.T) {
setupSkillSearchTenant(t)
service := NewSkillSearchService()
- eng := &skillSearchEngine{
- indexExists: true,
- searchResults: []map[string]interface{}{esStyleChunk("only", 1.0)},
+ results := make([]map[string]interface{}, 35)
+ for i := range results {
+ results[i] = esStyleChunk(fmt.Sprintf("skill-%02d", i), float64(i))
}
+ eng := &skillSearchEngine{indexExists: true, searchResults: results}
- // Page/page_size default to 1/10 when non-positive.
+ // Page/page_size default to 1/30 when non-positive.
resp, code, err := service.Search(skillSearchTestContext(t), &SearchRequest{Query: "", Page: -1, PageSize: -1}, eng)
if err != nil || code != common.CodeSuccess {
t.Fatalf("Search: code=%d err=%v", code, err)
}
- if len(resp.Skills) != 1 {
- t.Fatalf("skills = %d, want 1", len(resp.Skills))
+ if len(resp.Skills) != 30 {
+ t.Fatalf("skills = %d, want 30", len(resp.Skills))
}
}
diff --git a/test/api/chat_api_test.go b/test/api/chat_api_test.go
index f8ef18c1bd..cb41231a26 100644
--- a/test/api/chat_api_test.go
+++ b/test/api/chat_api_test.go
@@ -190,15 +190,9 @@ func TestRESTChatListing(t *testing.T) {
{"page_two", apiObject{"page": 2, "page_size": 2}, 2},
{"page_three", apiObject{"page": "3", "page_size": 2}, 1},
{"beyond_end", apiObject{"page": 99, "page_size": 2}, 0},
- {"page_zero", apiObject{"page": 0, "page_size": 2}, 5},
- {"page_negative", apiObject{"page": -1, "page_size": 2}, 5},
- {"page_alpha", apiObject{"page": "a", "page_size": 2}, 5},
- {"size_without_page", apiObject{"page_size": 1}, 5},
- {"size_string_without_page", apiObject{"page_size": "1"}, 5},
+ {"size_without_page", apiObject{"page_size": 1}, 1},
+ {"size_string_without_page", apiObject{"page_size": "1"}, 1},
{"size_six_without_page", apiObject{"page_size": 6}, 5},
- {"size_zero", apiObject{"page": 1, "page_size": 0}, 5},
- {"size_negative", apiObject{"page": 1, "page_size": -1}, 5},
- {"size_alpha", apiObject{"page": 1, "page_size": "a"}, 5},
} {
t.Run(tc.name, func(t *testing.T) {
data := list(t, tc.query)
@@ -234,7 +228,24 @@ func TestRESTChatListing(t *testing.T) {
second := array(t, list(t, apiObject{"orderby": "name", "desc": false, "page": 2, "page_size": 2})["chats"])
assertChatValue(t, object(t, first[0])["id"], ids[0])
assertChatValue(t, object(t, second[0])["id"], ids[2])
- restCode(t, restCall(t, TestConfig, http.MethodGet, "/chats", nil, apiObject{"orderby": "unknown"}), 200, 101)
+ for _, tc := range []struct {
+ name string
+ query apiObject
+ }{
+ {"page_zero", apiObject{"page": 0, "page_size": 2}},
+ {"page_negative", apiObject{"page": -1, "page_size": 2}},
+ {"page_alpha", apiObject{"page": "a", "page_size": 2}},
+ {"size_zero", apiObject{"page": 1, "page_size": 0}},
+ {"size_negative", apiObject{"page": 1, "page_size": -1}},
+ {"size_alpha", apiObject{"page": 1, "page_size": "a"}},
+ {"invalid_orderby", apiObject{"orderby": "unknown"}},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ query := apiObject{"keywords": prefix}
+ maps.Copy(query, tc.query)
+ restCode(t, restCall(t, TestConfig, http.MethodGet, "/chats", nil, query), 200, 101)
+ })
+ }
assertChatValue(t, list(t, apiObject{"keywords": uniqueName("unmatched")})["chats"], []any{})
assertChatValue(t, list(t, apiObject{"keywords": prefix + "_1"})["total"], float64(1))
// Empty and omitted keywords are equivalent; no assumption about unrelated tenant resources.
diff --git a/test/api/chunk_api_test.go b/test/api/chunk_api_test.go
index 9f02093b3a..a775a754a8 100644
--- a/test/api/chunk_api_test.go
+++ b/test/api/chunk_api_test.go
@@ -270,9 +270,9 @@ func TestChunkListRejectsInvalidQueryValues(t *testing.T) {
message string
}{
{name: "page zero", key: "page", value: "0", message: "page must be a positive integer"},
- {name: "page not numeric", key: "page", value: "first", message: "page must be a positive integer"},
- {name: "page_size zero", key: "page_size", value: "0", message: "page_size must be a positive integer"},
- {name: "page_size not numeric", key: "page_size", value: "many", message: "page_size must be a positive integer"},
+ {name: "page not numeric", key: "page", value: "first", message: "page must be an integer"},
+ {name: "page_size zero", key: "page_size", value: "0", message: "page_size must be between 1 and 100"},
+ {name: "page_size not numeric", key: "page_size", value: "many", message: "page_size must be an integer"},
{name: "available invalid", key: "available", value: "sometimes", message: "available must be one of: true, false, 1, 0"},
}
diff --git a/test/api/document_api_test.go b/test/api/document_api_test.go
index f42bd5e94a..0502fb6e0c 100644
--- a/test/api/document_api_test.go
+++ b/test/api/document_api_test.go
@@ -205,7 +205,6 @@ func TestRESTDocumentListingFiltersPaginationAndReads(t *testing.T) {
{"unstarted", apiObject{"run": "UNSTART"}, ids, 3},
{"future_creation", apiObject{"create_time_from": "9999999999000"}, nil, 3},
{"past_creation", apiObject{"create_time_to": "1"}, nil, 3},
- {"invalid_page_defaults", apiObject{"page": "invalid", "page_size": -1}, ids, 3},
{"unknown_query_ignored", apiObject{"unexpected": "ignored"}, ids, 3},
}
for _, tc := range cases {
@@ -238,6 +237,7 @@ func TestRESTDocumentListingFiltersPaginationAndReads(t *testing.T) {
query apiObject
code int
}{
+ {apiObject{"page": "invalid", "page_size": -1}, 101},
{apiObject{"orderby": "name; DROP TABLE document"}, 101},
{apiObject{"metadata_condition": "{bad"}, 102},
{apiObject{"metadata_condition": "[]"}, 102},
diff --git a/test/testcases/test_sdk_api/test_chat_assistant_management/test_delete_chat_assistants.py b/test/testcases/test_sdk_api/test_chat_assistant_management/test_delete_chat_assistants.py
index e5b1250060..3dcbeec7fa 100644
--- a/test/testcases/test_sdk_api/test_chat_assistant_management/test_delete_chat_assistants.py
+++ b/test/testcases/test_sdk_api/test_chat_assistant_management/test_delete_chat_assistants.py
@@ -97,11 +97,11 @@ class TestChatAssistantsDelete:
chats = [chat_factory() for _ in range(2)]
ids = {chat.id for chat in chats}
# The session preflight verifies an empty dedicated tenant; refuse deletion if it changed.
- response = client.get("/chats", {"page_size": 0}).json()
+ response = client.get("/chats", {"page_size": 100}).json()
assert response["code"] == 0, response
assert response["data"]["total"] == len(ids)
assert {chat["id"] for chat in response["data"]["chats"]} == ids
- assert {chat.id for chat in client.list_chats(page_size=0)} == ids
+ assert {chat.id for chat in client.list_chats(page_size=100)} == ids
if selection == "omitted":
client.delete_chats(delete_all=True)
elif selection == "none":
diff --git a/test/testcases/test_sdk_api/test_chat_assistant_management/test_list_chat_assistants.py b/test/testcases/test_sdk_api/test_chat_assistant_management/test_list_chat_assistants.py
index 87208421d5..98d51b0b61 100644
--- a/test/testcases/test_sdk_api/test_chat_assistant_management/test_list_chat_assistants.py
+++ b/test/testcases/test_sdk_api/test_chat_assistant_management/test_list_chat_assistants.py
@@ -70,10 +70,10 @@ class TestChatAssistantsList:
@pytest.mark.p2
@pytest.mark.parametrize("page", [0, -1])
- def test_nonpositive_page_is_unpaginated(self, client, chats, page):
+ def test_nonpositive_page_is_rejected(self, client, chats, page):
prefix = chats[0].name.rsplit("-", 1)[0]
- listed = client.list_chats(page=page, page_size=2, keywords=prefix)
- assert {chat.id for chat in listed} == {chat.id for chat in chats}
+ with pytest.raises(Exception, match="page must be a positive integer"):
+ client.list_chats(page=page, page_size=2, keywords=prefix)
@pytest.mark.p1
@pytest.mark.parametrize("page_size", [1, 2, 6])
@@ -84,10 +84,10 @@ class TestChatAssistantsList:
@pytest.mark.p2
@pytest.mark.parametrize("page_size", [0, -1])
- def test_nonpositive_page_size_is_unpaginated(self, client, chats, page_size):
+ def test_nonpositive_page_size_is_rejected(self, client, chats, page_size):
prefix = chats[0].name.rsplit("-", 1)[0]
- listed = client.list_chats(page_size=page_size, keywords=prefix)
- assert {chat.id for chat in listed} == {chat.id for chat in chats}
+ with pytest.raises(Exception, match="page_size must be between 1 and 100"):
+ client.list_chats(page_size=page_size, keywords=prefix)
@pytest.mark.p3
@pytest.mark.parametrize("orderby", ["create_time", "update_time", "name"])
diff --git a/test/testcases/test_sdk_api/test_dataset_mangement/test_list_datasets.py b/test/testcases/test_sdk_api/test_dataset_mangement/test_list_datasets.py
index 7b1ce138e7..4286d54b3b 100644
--- a/test/testcases/test_sdk_api/test_dataset_mangement/test_list_datasets.py
+++ b/test/testcases/test_sdk_api/test_dataset_mangement/test_list_datasets.py
@@ -150,7 +150,7 @@ class TestDatasetsList:
@pytest.mark.p2
def test_page_invalid(self, client):
- with pytest.raises(Exception, match="greater than or equal to 1"):
+ with pytest.raises(Exception, match="page must be a positive integer"):
client.list_datasets(page=0)
@pytest.mark.p1
@@ -163,7 +163,7 @@ class TestDatasetsList:
@pytest.mark.p2
def test_page_size_invalid(self, client):
- with pytest.raises(Exception, match="greater than or equal to 1"):
+ with pytest.raises(Exception, match="page_size must be between 1 and 100"):
client.list_datasets(page_size=0)
@pytest.mark.p3
diff --git a/test/testcases/test_sdk_api/test_file_management_within_dataset/test_list_documents.py b/test/testcases/test_sdk_api/test_file_management_within_dataset/test_list_documents.py
index d81fa297d0..d39668c13d 100644
--- a/test/testcases/test_sdk_api/test_file_management_within_dataset/test_list_documents.py
+++ b/test/testcases/test_sdk_api/test_file_management_within_dataset/test_list_documents.py
@@ -42,32 +42,40 @@ class TestDocumentsList:
@pytest.mark.p1
@pytest.mark.parametrize(
- "params, expected_page_ids",
+ "params, expected_page_ids, expected_message",
[
- ({"page": 1, "page_size": 2, "orderby": "name", "desc": False}, slice(0, 2)),
- ({"page": 2, "page_size": 2, "orderby": "name", "desc": False}, slice(2, 4)),
- ({"page": 3, "page_size": 2, "orderby": "name", "desc": False}, slice(4, 6)),
- ({"page": -1, "page_size": 2, "orderby": "name", "desc": False}, slice(0, 2)),
+ ({"page": 1, "page_size": 2, "orderby": "name", "desc": False}, slice(0, 2), ""),
+ ({"page": 2, "page_size": 2, "orderby": "name", "desc": False}, slice(2, 4), ""),
+ ({"page": 3, "page_size": 2, "orderby": "name", "desc": False}, slice(4, 6), ""),
+ ({"page": -1, "page_size": 2, "orderby": "name", "desc": False}, None, "page must be a positive integer"),
],
)
- def test_page(self, add_documents, params, expected_page_ids):
+ def test_page(self, add_documents, params, expected_page_ids, expected_message):
dataset, fixture_documents = add_documents
+ if expected_message:
+ with pytest.raises(Exception, match=expected_message):
+ dataset.list_documents(**params)
+ return
expected = sorted(fixture_documents, key=lambda document: document.name)
documents = dataset.list_documents(**params)
assert [document.id for document in documents] == [document.id for document in expected[expected_page_ids]]
@pytest.mark.p1
@pytest.mark.parametrize(
- "params, expected_size",
+ "params, expected_size, expected_message",
[
- ({"page_size": 2, "orderby": "name", "desc": False}, 2),
- ({"page_size": 1, "orderby": "name", "desc": False}, 1),
- ({"page_size": 6, "orderby": "name", "desc": False}, 5),
- ({"page_size": -1, "orderby": "name", "desc": False}, 5),
+ ({"page_size": 2, "orderby": "name", "desc": False}, 2, ""),
+ ({"page_size": 1, "orderby": "name", "desc": False}, 1, ""),
+ ({"page_size": 6, "orderby": "name", "desc": False}, 5, ""),
+ ({"page_size": -1, "orderby": "name", "desc": False}, None, "page_size must be between 1 and 100"),
],
)
- def test_page_size(self, add_documents, params, expected_size):
+ def test_page_size(self, add_documents, params, expected_size, expected_message):
dataset, fixture_documents = add_documents
+ if expected_message:
+ with pytest.raises(Exception, match=expected_message):
+ dataset.list_documents(**params)
+ return
expected = sorted(fixture_documents, key=lambda document: document.name)
documents = dataset.list_documents(**params)
assert [document.id for document in documents] == [document.id for document in expected[:expected_size]]