如何在graphql-go中限制查询结果数量，避免全量请求

针对你的需求，graphql-go虽然没有直接的内置“最大limit”校验注解，但可以通过以下两种更优的方式实现，比在Resolve里手动校验更规范、更模块化：

方案一：参数定义时添加校验函数（推荐） #

在字段的参数配置中，直接为limit设置默认值和校验逻辑，这样校验会在Resolve执行前完成，无效请求不会进入数据库查询阶段，同时逻辑和字段定义绑定，更符合GraphQL设计规范。

修改后的代码示例：

import "fmt"

type Book struct {
    ID string `json:"id"`
}

bookType := graphql.NewObject(graphql.ObjectConfig{
    Name:        "Book", // 原名称"Books"不符合单个类型定义，建议修正
    Description: "A single book entry",
    Fields: graphql.Fields{
        "id": &graphql.Field{
            // 原代码中Book.ID是string类型，但字段定义为Int，类型不匹配，这里修正为String
            Type:        graphql.NewNonNull(graphql.String),
            Description: "The unique identifier of the book.",
            Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                if book, ok := p.Source.(*Book); ok {
                    return book.ID, nil
                }
                return nil, nil
            },
        },
    },
})

rootQuery := graphql.NewObject(graphql.ObjectConfig{
    Name: "RootQuery",
    Fields: graphql.Fields{
        "books": &graphql.Field{
            Type:        graphql.NewList(bookType),
            Description: "List of books.",
            // 定义limit参数的规则
            Args: graphql.FieldConfigArgument{
                "limit": &graphql.ArgumentConfig{
                    Type:         graphql.Int,
                    DefaultValue: 100, // 未传入时默认返回100条
                    ValidateFunc: func(value interface{}) error {
                        limit, ok := value.(int)
                        if !ok {
                            return fmt.Errorf("limit must be an integer")
                        }
                        if limit > 100 {
                            return fmt.Errorf("limit cannot exceed 100")
                        }
                        if limit < 1 {
                            return fmt.Errorf("limit must be at least 1") // 可选：防止传入负数或0
                        }
                        return nil
                    },
                },
            },
            Resolve: func(params graphql.ResolveParams) (interface{}, error) {
                // 这里的limit已经通过校验，直接使用即可
                limit := params.Args["limit"].(int)
                rows, err := db.Query("SELECT id FROM books limit $1", limit)
                if err != nil {
                    return nil, err
                }
                defer rows.Close() // 记得关闭结果集，避免资源泄漏
                var books []*Book
                for rows.Next() {
                    book := &Book{}
                    err = rows.Scan(&book.ID)
                    if err != nil {
                        return nil, err
                    }
                    books = append(books, book)
                }
                // 检查遍历结果集后的错误
                if err = rows.Err(); err != nil {
                    return nil, err
                }
                return books, nil
            },
        },
    },
})

方案优势 #

• 校验逻辑前置，无效请求不会触发数据库查询，节省资源
• 默认值直接在参数定义中配置，无需在Resolve里处理默认情况
• 校验规则和字段绑定，代码结构更清晰

方案二：使用中间件统一处理（适合多字段复用） #

如果你的项目中有多个查询字段需要类似的limit限制，可以用中间件统一拦截处理，避免重复代码。

第一步：定义limit中间件 #

import "fmt"

func LimitMiddleware(maxLimit int) graphql.FieldMiddleware {
    return func(next graphql.Resolver) graphql.Resolver {
        return graphql.ResolverFunc(func(params graphql.ResolveParams) (interface{}, error) {
            limitVal, exists := params.Args["limit"]
            var limit int

            if !exists {
                // 未传入limit时设置默认值
                limit = maxLimit
                params.Args["limit"] = limit
            } else {
                limit, ok := limitVal.(int)
                if !ok {
                    return nil, fmt.Errorf("limit must be an integer")
                }
                if limit > maxLimit {
                    return nil, fmt.Errorf("limit cannot exceed %d", maxLimit)
                }
                if limit < 1 {
                    // 可选：将非法的小值修正为1
                    limit = 1
                    params.Args["limit"] = limit
                }
            }

            // 继续执行后续Resolve逻辑
            return next.Resolve(params)
        })
    }
}

第二步：在字段中应用中间件 #

rootQuery := graphql.NewObject(graphql.ObjectConfig{
    Name: "RootQuery",
    Fields: graphql.Fields{
        "books": &graphql.Field{
            Type:        graphql.NewList(bookType),
            Description: "List of books.",
            Args: graphql.FieldConfigArgument{
                "limit": &graphql.ArgumentConfig{
                    Type: graphql.Int,
                },
            },
            // 应用limit中间件，设置最大限制为100
            Middlewares: []graphql.FieldMiddleware{LimitMiddleware(100)},
            Resolve: func(params graphql.ResolveParams) (interface{}, error) {
                limit := params.Args["limit"].(int)
                // 后续数据库查询逻辑同方案一
                rows, err := db.Query("SELECT id FROM books limit $1", limit)
                // ...省略其余代码
            },
        },
    },
})

方案优势 #

• 统一处理多个字段的limit校验，代码复用性高
• 可以灵活调整最大限制，或扩展更多通用校验规则

额外提醒 #

原代码中存在类型不匹配的问题：Book.ID是string类型，但bookType的id字段定义为graphql.Int，这会导致Resolve时返回错误，建议修正为一致的类型（要么把Book.ID改为int，要么把字段类型改为graphql.String）。

内容的提问来源于stack exchange，提问作者Nicole Staline