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

परिचय: क्यों Rust और GraphQL एक आदर्श जोड़ी हैं

आधुनिक वेब डेवलपमेंट में उच्च प्रदर्शन और सख्त टाइपिंग की आवश्यकता होती है। Rust, अपनी मेमोरी सुरक्षा और गति के लिए जाना जाता है, बैकएंड बनाने के लिए एक उत्कृष्ट विकल्प बन जाता है। GraphQL, बदले में, डेटा के साथ काम करने का एक लचीला और कुशल तरीका प्रदान करता है। इस ट्यूटोरियल में, हम async-graphql लाइब्रेरी और actix-web फ्रेमवर्क का उपयोग करके Rust पर एक पूर्ण GraphQL API बनाएंगे। आप स्कीमा परिभाषित करना, रिज़ॉल्वर लिखना और क्वेरी प्रोसेस करना सीखेंगे।

लेख के अंत तक, आपके पास एक कार्यशील सर्वर होगा जो वास्तविक प्रोजेक्ट्स में एकीकरण के लिए तैयार है। सभी कोड उदाहरण जांचे गए हैं और चलाने के लिए तैयार हैं।

प्रोजेक्ट सेटअप और निर्भरताएँ स्थापित करना

शुरू करने के लिए, एक नया Rust प्रोजेक्ट बनाएँ। सुनिश्चित करें कि आपके पास Rust स्थापित है (अनुशंसित संस्करण 1.75+)।

cargo new graphql-rust-api\ncd graphql-rust-api

Cargo.toml खोलें और निम्नलिखित निर्भरताएँ जोड़ें:

[dependencies]\nactix-web = "4"\nactix-rt = "2"\nasync-graphql = "7"\nasync-graphql-actix-web = "7"\nserde = { version = "1", features = ["derive"] }\ntokio = { version = "1", features = ["macros"] }

सभी निर्भरताएँ डाउनलोड और कंपाइल करने के लिए cargo build चलाएँ। पहली बार चलाने में कुछ मिनट लग सकते हैं।

प्रोजेक्ट संरचना

निम्नलिखित फ़ोल्डर और फ़ाइल संरचना बनाएँ:

src/\n├── main.rs\n├── schema.rs\n├── models.rs\n└── resolvers.rs

हम धीरे-धीरे प्रत्येक फ़ाइल को भरेंगे।

मॉडल और GraphQL स्कीमा परिभाषित करना

चलिए एक सरल डेटा मॉडल बनाकर शुरू करते हैं। models.rs में, हम User संरचना का वर्णन करेंगे:

use serde::{Deserialize, Serialize};\n\n#[derive(Debug, Clone, Serialize, Deserialize)]\npub struct User {\n    pub id: u32,\n    pub name: String,\n    pub email: String,\n}

अब schema.rs पर चलते हैं। यहाँ हम GraphQL ऑब्जेक्ट और क्वेरी परिभाषित करेंगे:

use async_graphql::{Context, Object, SimpleObject};\nuse crate::models::User;\nuse crate::resolvers::get_all_users;\n\n#[derive(SimpleObject)]\npub struct UserObject {\n    pub id: u32,\n    pub name: String,\n    pub email: String,\n}\n\npub struct QueryRoot;\n\n#[Object]\nimpl QueryRoot {\n    async fn users(&self, ctx: &Context<'_>) -> Vec<UserObject> {\n        let users = get_all_users(ctx).await;\n        users.into_iter().map(|u| UserObject {\n            id: u.id,\n            name: u.name,\n            email: u.email,\n        }).collect()\n    }\n}

#[derive(SimpleObject)] के उपयोग पर ध्यान दें - यह async-graphql का एक मैक्रो है जो स्वचालित रूप से GraphQL प्रकार उत्पन्न करता है।

रिज़ॉल्वर: व्यावसायिक तर्क

resolvers.rs फ़ाइल में, हम डेटा प्राप्त करने का फ़ंक्शन लागू करेंगे। सरलता के लिए, हम एक स्थिर सूची का उपयोग करेंगे:

use async_graphql::Context;\nuse crate::models::User;\n\npub async fn get_all_users(_ctx: &Context<'_>) -> Vec<User> {\n    vec![\n        User { id: 1, name: "Alice".into(), email: "alice@example.com".into() },\n        User { id: 2, name: "Bob".into(), email: "bob@example.com".into() },\n        User { id: 3, name: "Charlie".into(), email: "charlie@example.com".into() },\n    ]\n}

वास्तविक प्रोजेक्ट में, यहाँ डेटाबेस या बाहरी API का कॉल हो सकता है।

Actix-web पर सर्वर बनाना

अब सबसे महत्वपूर्ण बात - main.rs में सब कुछ एक साथ जोड़ना:

use actix_web::{web, App, HttpServer, HttpResponse};\nuse async_graphql::{Schema, EmptyMutation, EmptySubscription};\nuse async_graphql_actix_web::{GraphQLRequest, GraphQLResponse};\nuse crate::schema::QueryRoot;\n\nmod models;\nmod schema;\nmod resolvers;\n\ntype AppSchema = Schema<QueryRoot, EmptyMutation, EmptySubscription>;\n\nasync fn graphql_handler(\n    schema