[GraphQL] 构建 Rust 异步 GraphQL 服务：基于 tide + async-graphql + mongodb（3）- 重构

2021-03-20 13:43:10+08:00 by - NiQin [blog: 泥芹]

💥 内容涉及著作权，均归属作者本人。若非作者注明，默认欢迎转载：请注明出处，及相关链接。

Summary: 前 2 篇文章中，我们初始化搭建了工程结构，选择了必须的 crate，并成功构建了 GraphQL 查询服务：从 MongoDB 中获取了数据，并通过 GraphQL 查询，输出 json 数据。本篇文章，本应当进行 GraphQL 变更（mutation）服务的开发。但是，虽然代码成功运行，却存在一些问题，如：对于 MongoDB 数据库的连接信息，应当采取配置文件存储；通用公用的代码，应当组织和抽象；诸如此类以便于后续扩展，生产部署等问题。所以，本篇文章中我们暂不进行变更的开发，而是进行第一次简单的重构。以免后续代码扩大，重构工作量繁重。

Topics: rust graphql async-graphql tide mongodb json-web-token jwt

行文开始，先感谢几位指导的老师。根据指导，文章的标题做了更符合撰写目标和使用类库的更改，另外也修改了上篇文章中的笔误。因为笔者是先写 markdown 文件，然后粘贴到 web 页面。尤其是这个博客是笔者“三天打鱼两天晒网”的方式开发的，目前很不完善，所以粘贴时，调整顺序等情形，容易产生张冠李戴的情况。总之，欢迎各位指正。谢谢！

首先，我们通过 shell 命令 cd ./rust-graphql/backend 进入后端工程目录（下文中，将默认在此目录执行操作）。

配置信息的存储和获取

让我们设想正式生产环境的应用场景：

服务器地址和端口的变更可能；
服务功能升级，对用户暴露 API 地址的变更可能。如 rest api，graphql api，以及版本升级；
服务站点密钥定时调整的可能；
服务站点安全调整，jwt、session/cookie 过期时间的变更可能。

显然易见，我们应当避免每次变更调整时，都去重新编译一次源码——并且，大工程中，Rust 的编译速度让开发者注目。更优的方法是，将这些写入到配置文件中。或许上述第 4 点无需写入，但是文件存储到加密保护的物理地址，安全方面也有提升。

当然，实际的应用场景或许有更合适有优的解决方法，但我们先基于此思路来设计。Rust 中，dotenv crate 用来读取环境变量。取得环境变量后，我们将其作为静态或者惰性值来使用，静态或者惰性值相关的 crate 有 lazy_static 和 once_cell 等，都很简单易用。此示例中，我们使用 lazy_static。

创建 `.env`，添加读取相关 crate

增加这 2 个 crate，并且在 backend 目录创建 .env 文件。

cargo add dotenv lazy_static
touch .env

在 .env 文件中，写入如下内容：

# 服务器信息
ADDRESS=127.0.0.1
PORT=8080

# API 服务信息，“gql” 也可以单独提出来定义
GRAPHQL_PATH=v1
GRAPHIQL_PATH=v1i

# 数据库配置
MONGODB_URI=mongodb://mongo:mongo@localhost:27017
MONGODB_BUDSHOME=budshome

# 站点安全相关，此处仅为内容填充，后面的文章中会使用
SITE_KEY=0F4EHz+1/hqVvZjuB8EcooQs1K6QKBvLUxqTHt4tpxE=
CLAIM_EXP=10000000000

Cargo.toml 文件：

[package]
name = "backend"
version = "0.1.0"
authors = ["我是谁？"]
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
futures = "0.3.13"
tide = "0.16.0"
async-std = { version = "1.9.0", features = ["attributes"] }

dotenv = "0.15.0"
lazy_static = "1.4.0"

async-graphql = "2.6.0"
mongodb = { version = "1.2.0", default-features = false, features = ["async-std-runtime"] }
bson = "1.2.0"
serde = { version = "1.0.124", features = ["derive"] }

读取配置文件并使用配置信息

对于配置信息的读取和使用，显然属于公用功能，我们将其归到单独的模块中。所以，需要创建 2 个文件：一个是模块标识文件，一个是将抽象出来共用的常量子模块。

cd ./src
mkdir util
touch ./util/mod.rs ./util/constant.rs

至此，本篇文章的所有文件都已经创建，我们确认一下工程结构。

backend 工程结构

在 util/mod.rs，编写如下代码：

pub mod constant;

读取配置信息

在 util/constant.rs 中，编写如下代码：

use dotenv::dotenv;
use lazy_static::lazy_static;
use std::collections::HashMap;

lazy_static! {
    // CFG variables defined in .env file
    pub static ref CFG: HashMap<&'static str, String> = {
        dotenv().ok();

        let mut map = HashMap::new();

        map.insert(
            "ADDRESS",
            dotenv::var("ADDRESS").expect("Expected ADDRESS to be set in env!"),
        );
        map.insert(
            "PORT",
            dotenv::var("PORT").expect("Expected PORT to be set in env!"),
        );

        map.insert(
            "GRAPHQL_PATH",
            dotenv::var("GRAPHQL_PATH").expect("Expected GRAPHQL_PATH to be set in env!"),
        );
        map.insert(
            "GRAPHIQL_PATH",
            dotenv::var("GRAPHIQL_PATH").expect("Expected GRAPHIQL_PATH to be set in env!"),
        );

        map.insert(
            "MONGODB_URI",
            dotenv::var("MONGODB_URI").expect("Expected MONGODB_URI to be set in env!"),
        );
        map.insert(
            "MONGODB_BUDSHOME",
            dotenv::var("MONGODB_BUDSHOME").expect("Expected MONGODB_BUDSHOME to be set in env!"),
        );

        map.insert(
            "SITE_KEY",
            dotenv::var("SITE_KEY").expect("Expected SITE_KEY to be set in env!"),
        );
        map.insert(
            "CLAIM_EXP",
            dotenv::var("CLAIM_EXP").expect("Expected CLAIM_EXP to be set in env!"),
        );

        map
    };
}

重构代码，使用配置信息，正确提供 GraphQL 服务

首先，src/main.rs 文件中引入 util 模块。并用 use 引入 constant 子模块，读取其惰性配置值。

mod dbs;
mod gql;
mod users;
mod util;

use crate::gql::{build_schema, graphiql, graphql};
use crate::util::constant::CFG;

#[async_std::main]
async fn main() -> Result<(), std::io::Error> {
    // tide logger
    tide::log::start();

    // 初始 Tide 应用程序状态
    let schema = build_schema().await;
    let app_state = State { schema: schema };
    let mut app = tide::with_state(app_state);

    // 路由配置
    app.at(CFG.get("GRAPHQL_PATH").unwrap()).post(graphql);
    app.at(CFG.get("GRAPHIQL_PATH").unwrap()).get(graphiql);

    app.listen(format!(
        "{}:{}",
        CFG.get("ADDRESS").unwrap(),
        CFG.get("PORT").unwrap()
    ))
    .await?;

    Ok(())
}

//  Tide 应用程序作用域状态 state.
#[derive(Clone)]
pub struct State {
    pub schema: async_graphql::Schema<
        gql::queries::QueryRoot,
        async_graphql::EmptyMutation,
        async_graphql::EmptySubscription,
    >,
}

其次，src/gql/mod.rs 文件中，用 use 引入 constant 子模块，读取其惰性配置值。

pub mod mutations;
pub mod queries;

use crate::util::constant::CFG;
use tide::{http::mime, Body, Request, Response, StatusCode};

use async_graphql::{
    http::{playground_source, receive_json, GraphQLPlaygroundConfig},
    EmptyMutation, EmptySubscription, Schema,
};

use crate::State;

use crate::dbs::mongo;

use crate::gql::queries::QueryRoot;

pub async fn build_schema() -> Schema<QueryRoot, EmptyMutation, EmptySubscription> {
    // 获取 mongodb datasource 后，可以将其增加到：
    // 1. 作为 async-graphql 的全局数据；
    // 2. 作为 Tide 的应用状态 State；
    // 3. 使用 lazy-static.rs
    let mongo_ds = mongo::DataSource::init().await;

    // The root object for the query and Mutatio, and use EmptySubscription.
    // Add global mongodb datasource  in the schema object.
    // let mut schema = Schema::new(QueryRoot, MutationRoot, EmptySubscription)
    Schema::build(QueryRoot, EmptyMutation, EmptySubscription)
        .data(mongo_ds)
        .finish()
}

pub async fn graphql(req: Request<State>) -> tide::Result {
    let schema = req.state().schema.clone();
    let gql_resp = schema.execute(receive_json(req).await?).await;

    let mut resp = Response::new(StatusCode::Ok);
    resp.set_body(Body::from_json(&gql_resp)?);

    Ok(resp.into())
}

pub async fn graphiql(_: Request<State>) -> tide::Result {
    let mut resp = Response::new(StatusCode::Ok);
    resp.set_body(playground_source(GraphQLPlaygroundConfig::new(
        CFG.get("GRAPHQL_PATH").unwrap(),
    )));
    resp.set_content_type(mime::HTML);

    Ok(resp.into())
}

最后，不要忘了 src/dbs/mongo.rs 文件中，用 use 引入 constant 子模块，读取其惰性配置值。


use crate::util::constant::CFG;

use mongodb::{Client, options::ClientOptions, Database};

pub struct DataSource {
    client: Client,
    pub db_budshome: Database,
}

#[allow(dead_code)]
impl DataSource {
    pub async fn client(&self) -> Client {
        self.client.clone()
    }

    pub async fn init() -> DataSource {
        // Parse a connection string into an options struct.
        // environment variables defined in .env file
        let mut client_options =
            ClientOptions::parse(CFG.get("MONGODB_URI").unwrap())
                .await
                .expect("Failed to parse options!");
        // Manually set an option.
        client_options.app_name = Some("tide-graphql-mongodb".to_string());

        // Get a handle to the deployment.
        let client = Client::with_options(client_options)
            .expect("Failed to initialize database!");

        // Get a handle to a database.
        let db_budshome = client.database(CFG.get("MONGODB_BUDSHOME").unwrap());

        // return mongodb datasource.
        DataSource { client: client, db_budshome: db_budshome }
    }
}

配置文件读取已经完成，我们测试看看。这次，我们浏览器中要打开的链接为 http://127.0.0.1:8080/v1i。

graphiql ui

执行查询，一切正常。

graphql query

代码简洁性重构，定义公用类型

在上一篇构建 Rust 异步 GraphQL 服务：基于 tide + async-graphql + mongodb（2）- 查询服务文章中，gql/queries.rs 和 users/services.rs 代码中，all_users 函数/方法的返回值为冗长的 std::result::Result<Vec<User>, async_graphql::Error>。显然，这样代码不够易读和简洁。我们简单重构下：定义一个公用的 GqlResult 类型即可。

首先，迭代 util/constant.rs 文件，增加一行：定义 GqlResult 类型别名：

use dotenv::dotenv;
use lazy_static::lazy_static;
use std::collections::HashMap;

pub type GqlResult<T> = std::result::Result<T, async_graphql::Error>;

lazy_static! {
    // CFG variables defined in .env file
    pub static ref CFG: HashMap<&'static str, String> = {
        dotenv().ok();

        let mut map = HashMap::new();

        map.insert(
            "ADDRESS",
            dotenv::var("ADDRESS").expect("Expected ADDRESS to be set in env!"),
        );
        map.insert(
            "PORT",
            dotenv::var("PORT").expect("Expected PORT to be set in env!"),
        );

        map.insert(
            "GRAPHQL_PATH",
            dotenv::var("GRAPHQL_PATH").expect("Expected GRAPHQL_PATH to be set in env!"),
        );
        map.insert(
            "GRAPHIQL_PATH",
            dotenv::var("GRAPHIQL_PATH").expect("Expected GRAPHIQL_PATH to be set in env!"),
        );

        map.insert(
            "MONGODB_URI",
            dotenv::var("MONGODB_URI").expect("Expected MONGODB_URI to be set in env!"),
        );
        map.insert(
            "MONGODB_BUDSHOME",
            dotenv::var("MONGODB_BUDSHOME").expect("Expected MONGODB_BUDSHOME to be set in env!"),
        );

        map.insert(
            "SITE_KEY",
            dotenv::var("SITE_KEY").expect("Expected SITE_KEY to be set in env!"),
        );
        map.insert(
            "CLAIM_EXP",
            dotenv::var("CLAIM_EXP").expect("Expected CLAIM_EXP to be set in env!"),
        );

        map
    };
}

其次，迭代 gql/queries.rs 和 users/services.rs 文件，引入并让函数/方法返回 GqlResult 类型。

gql/queries.rs

use async_graphql::Context;

use crate::dbs::mongo::DataSource;
use crate::users::{self, models::User};
use crate::util::constant::GqlResult;

pub struct QueryRoot;

#[async_graphql::Object]
impl QueryRoot {
    // Get all Users,
    async fn all_users(&self, ctx: &Context<'_>) -> GqlResult<Vec<User>> {
        let db = ctx.data_unchecked::<DataSource>().db_budshome.clone();
        users::services::all_users(db).await
    }
}

users/services.rs

use async_graphql::{Error, ErrorExtensions};
use futures::stream::StreamExt;
use mongodb::Database;

use crate::users::models::User;
use crate::util::constant::GqlResult;

pub async fn all_users(db: Database) -> GqlResult<Vec<User>> {
    let coll = db.collection("users");

    let mut users: Vec<User> = vec![];

    // Query all documents in the collection.
    let mut cursor = coll.find(None, None).await.unwrap();

    // Iterate over the results of the cursor.
    while let Some(result) = cursor.next().await {
        match result {
            Ok(document) => {
                let user = bson::from_bson(bson::Bson::Document(document)).unwrap();
                users.push(user);
            }
            Err(error) => Err(Error::new("6-all-users")
                .extend_with(|_, e| e.set("details", format!("Error to find doc: {}", error))))
            .unwrap(),
        }
    }

    if users.len() > 0 {
        Ok(users)
    } else {
        Err(Error::new("6-all-users").extend_with(|_, e| e.set("details", "No records")))
    }
}

第一次重构，我们就到这个程度。下一篇，我们将进行 GraphQL 变更（mutation）的开发。

谢谢您的阅读。