Rust异步GraphQL服务库async-graphql-tide使用指南

简介

async-graphql-tide是一个将async-graphql与Tide框架集成的库，用于构建高性能的异步GraphQL服务。它结合了async-graphql强大的GraphQL实现和Tide轻量级异步HTTP服务器的优势。

主要特性

• 完全异步支持
• 类型安全的GraphQL Schema定义
• 与Tide框架无缝集成
• 高性能请求处理
• 支持GraphQL查询、变更和订阅

完整示例

以下是一个完整的async-graphql-tide示例，包含查询、变更、认证和分页功能：

use async_graphql::{
    connection::{Connection, Edge, EmptyFields},
    Context, EmptyMutation, EmptySubscription, Object, 
    Schema, Upload, FieldResult,
    http::{playground_source, GraphQLPlaygroundConfig},
};
use async_graphql_tide::graphql;
use tide::{Request, Response, StatusCode};

// 定义用户数据结构
struct User {
    id: i32,
    name: String,
    email: String,
}

#[Object]
impl User {
    async fn id(&self) -> i32 {
        self.id
    }
    
    async fn name(&self) -> &str {
        &self.name
    }
    
    async fn email(&self) -> &str {
        &self.email
    }
}

// 定义查询根
struct QueryRoot;

#[Object]
impl QueryRoot {
    // 简单查询示例
    async fn hello(&self) -> String {
        "Hello, Tide and GraphQL!".to_string()
    }
    
    // 认证保护的数据
    async fn protected_data(&self, ctx: &Context<'_>) -> FieldResult<String> {
        if let Some(token) = ctx.data_opt::<String>() {
            Ok(format!("Protected data for token: {}", token))
        } else {
            Err("Unauthorized".into())
        }
    }
    
    // 分页用户查询
    async fn users(
        &self,
        after: Option<String>,
        before: Option<String>,
        first: Option<i32>,
        last: Option<i32>,
    ) -> Connection<usize, User, EmptyFields, EmptyFields> {
        // 模拟数据库中的用户数据
        let users = vec![
            User { id: 1, name: "Alice".into(), email: "alice@example.com".into() },
            User { id: 2, name: "Bob".into(), email: "bob@example.com".into() },
            User { id: 3, name: "Charlie".into(), email: "charlie@example.com".into() },
        ];
        
        async_graphql::connection::query(
            after,
            before,
            first,
            last,
            |after, before, first, last| async move {
                let mut start = after.map(|a| a.parse::<usize>().unwrap() + 1).unwrap_or(0);
                let mut end = before.map(|b| b.parse::<usize>().unwrap()).unwrap_or(users.len());
                
                if let Some(first) = first {
                    end = (start + first as usize).min(end);
                }
                if let Some(last) = last {
                    start = if last as usize >= end - start {
                        start
                    } else {
                        end - last as usize
                    };
                }
                
                let mut connection = Connection::new(start > 0, end < users.len());
                connection.edges.extend(
                    users[start..end]
                        .iter()
                        .enumerate()
                        .map(|(idx, user)| Edge::new((start + idx).to_string(), user.clone())),
                );
                Ok(connection)
            },
        )
        .await
        .unwrap()
    }
}

// 定义变更根
struct MutationRoot;

#[Object]
impl MutationRoot {
    // 创建用户变更
    async fn create_user(&self, name: String, email: String) -> User {
        User {
            id: 100, // 模拟生成的ID
            name,
            email,
        }
    }
    
    // 文件上传示例
    async fn upload_file(&self, ctx: &Context<'_>, file: Upload) -> FieldResult<bool> {
        let file = file.value(ctx)?;
        println!("Uploaded file: {} ({} bytes)", file.filename, file.content.len());
        Ok(true)
    }
}

#[async_std::main]
async fn main() -> tide::Result<()> {
    // 创建Schema并启用并行执行
    let schema = Schema::build(QueryRoot, MutationRoot, EmptySubscription)
        .enable_parallel_execution()
        .finish();
    
    // 创建Tide应用
    let mut app = tide::new();
    
    // 添加中间件 - 添加自定义响应头
    app.with(tide::utils::After(|mut res: Response| async move {
        res.insert_header("X-Custom-Header", "GraphQL-Tide");
        Ok(res)
    }));
    
    // 添加GraphQL端点，支持文件上传和认证
    app.at("/graphql").post(|req: Request<()>| async move {
        let token = req.header("Authorization")
            .map(|h| h.last().as_str().to_string());
        
        let schema = schema.clone();
        async_graphql_tide::graphql(req, schema, move |query| {
            if let Some(token) = token {
                query.data(token);
            }
            query
        }).multipart() // 启用文件上传支持
    });
    
    // 添加GraphQL Playground
    app.at("/").get(|_| async {
        Ok(Response::builder(StatusCode::Ok)
            .body(playground_source(
                GraphQLPlaygroundConfig::new("/graphql")
            ))
            .content_type("text/html; charset=utf-8")
            .build())
    });
    
    // 启动服务器
    println!("Server running at http://localhost:8000");
    app.listen("127.0.0.1:8000").await?;
    
    Ok(())
}

使用说明

1. 将上述代码保存为main.rs
2. 添加Cargo.toml依赖：

[dependencies]
async-graphql = "4.0"
async-graphql-tide = "4.0"
tide = "0.16"
async-std = { version = "1.12", features = ["attributes"] }

1. 运行服务：

cargo run

1. 访问http://localhost:8000使用GraphQL Playground测试API

功能说明

1. 基础查询：hello查询返回简单字符串
2. 认证保护数据：protected_data需要Authorization头
3. 分页查询：users支持分页参数
4. 变更操作：create_user创建新用户
5. 文件上传：upload_file处理文件上传

性能优化建议

1. 使用jemalloc作为全局分配器：

#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;

1. 对于生产环境，考虑使用tide-rustls替代默认的TLS实现