Rust के साथ GraphQL API: वेब सेवा बनाने के लिए चरण-दर-चरण ट्यूटोरियल

GraphQL API के साथ Rust: चरण-दर-चरण ट्यूटोरियल

GraphQL एक API के लिए क्वेरी भाषा है जो क्लाइंट को केवल आवश्यक डेटा प्राप्त करने की अनुमति देती है। Rust, अपनी ओर से, प्रदर्शन और मेमोरी सुरक्षा के लिए प्रसिद्ध है। इस ट्यूटोरियल में हम Juniper और Actix-web लाइब्रेरी का उपयोग करके Rust में एक पूर्ण GraphQL API बनाएंगे। आप सीखेंगे कि सर्वर कैसे सेट करें, स्कीमा कैसे परिभाषित करें, क्वेरी और म्यूटेशन कैसे लागू करें, और API का परीक्षण कैसे करें।

यह सामग्री उन डेवलपर्स के लिए उपयोगी होगी जो Rust और वेब डेवलपमेंट की मूल बातों से परिचित हैं। हम अनावश्यक सिद्धांत से बचते हुए व्यावहारिक कार्यान्वयन पर ध्यान केंद्रित करेंगे।

प्रोजेक्ट सेटअप और डिपेंडेंसी इंस्टॉलेशन

पहले एक नया Rust प्रोजेक्ट बनाएं:

cargo new rust-graphql-apicd rust-graphql-api

Cargo.toml फ़ाइल में आवश्यक डिपेंडेंसी जोड़ें:

[dependencies]actix-web = "4"actix-rt = "2"serde = { version = "1", features = ["derive"] }serde_json = "1"juniper = "0.16"juniper_actix = "2"

यहाँ actix-web एक वेब फ्रेमवर्क है, और juniper GraphQL के साथ काम करने के लिए लाइब्रेरी है। juniper_actix इन दोनों के बीच एकीकरण सुनिश्चित करता है।

बेसिक GraphQL स्कीमा बनाना

अब एक सरल डेटा मॉडल और स्कीमा परिभाषित करें। उदाहरण के लिए, हम उपयोगकर्ताओं और पोस्ट के प्रबंधन के लिए एक सिस्टम बनाएंगे।

src/schema.rs फ़ाइल बनाएं:

use juniper::{GraphQLObject, GraphQLInputObject, RootNode};

#[derive(GraphQLObject)]#[graphql(description = "सिस्टम का उपयोगकर्ता")]pub struct User {    pub id: i32,    pub name: String,    pub email: String,}

#[derive(GraphQLInputObject)]#[graphql(description = "उपयोगकर्ता बनाने के लिए इनपुट डेटा")]pub struct NewUser {    pub name: String,    pub email: String,}

#[derive(GraphQLObject)]#[graphql(description = "उपयोगकर्ता का पोस्ट")]pub struct Post {    pub id: i32,    pub title: String,    pub body: String,    pub author_id: i32,}

pub struct QueryRoot;

#[juniper::object]impl QueryRoot {    fn users() -> Vec<User> {        vec![            User { id: 1, name: "एलेक्सी".into(), email: "alex@example.com".into() },            User { id: 2, name: "मारिया".into(), email: "maria@example.com".into() },        ]    }

    fn posts() -> Vec<Post> {        vec![            Post { id: 1, title: "पहली एंट्री".into(), body: "पोस्ट का टेक्स्ट".into(), author_id: 1 },        ]    }}

pub struct MutationRoot;

#[juniper::object]impl MutationRoot {    fn create_user(new_user: NewUser) -> User {        User {            id: 3,            name: new_user.name,            email: new_user.email,        }    }}

pub type Schema = RootNode<'static, QueryRoot, MutationRoot>;

हमने दो रूट ऑब्जेक्ट परिभाषित किए हैं: क्वेरी (डेटा प्राप्त करना) के लिए QueryRoot और म्यूटेशन (डेटा बदलना) के लिए MutationRoot। #[derive(GraphQLObject)] Rust स्ट्रक्चर से स्वचालित रूप से GraphQL प्रकार उत्पन्न करता है।

वेब सर्वर सेटअप और Actix-web के साथ एकीकरण

अब सर्वर चलाने के लिए मुख्य फ़ाइल src/main.rs बनाएं:

mod schema;

use actix_web::{web, App, HttpServer, HttpResponse, middleware};use juniper_actix::{graphql_handler, playground_handler};use std::sync::Arc;

use crate::schema::Schema;

async fn graphql_route(    req: actix_web::HttpRequest,    payload: actix_web::web::Payload,    schema: web::Data<Arc<Schema>>,) -> actix_web::Result<HttpResponse> {    let context = ();    graphql_handler(&schema, &context, req, payload).await}

async fn playground_route() -> actix_web::Result<HttpResponse> {    playground_handler("/graphql", None).await}

#[actix_web::main]async fn main() -> std::io::Result<()> {    let 
```