Go के साथ GraphQL API: शुरुआती लोगों के लिए चरण-दर-चरण ट्यूटोरियल

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

आधुनिक वेब डेवलपमेंट में लचीले और उच्च-प्रदर्शन वाले API की आवश्यकता होती है। REST API, अपनी लोकप्रियता के बावजूद, अक्सर डेटा की अधिकता (over-fetching) या कमी (under-fetching) से ग्रस्त रहता है। GraphQL इस समस्या को हल करता है, जिससे क्लाइंट ठीक वही डेटा मांग सकता है जिसकी उसे आवश्यकता है। और Go (Golang) अपनी गति, सरलता और अंतर्निहित कंकरेंसी सपोर्ट के साथ GraphQL सर्वर बनाने के लिए एक आदर्श भाषा बन जाता है।

इस ट्यूटोरियल में हम कदम दर कदम Go पर एक पूर्ण GraphQL API बनाएंगे। आप सीखेंगे कि सर्वर कैसे सेट अप करें, स्कीमा कैसे परिभाषित करें, रिज़ॉल्वर कैसे लिखें, और क्वेरी (queries) और म्यूटेशन (mutations) को कैसे लागू करें। लेख के अंत तक आपके पास एक कार्यशील API होगा, जो किसी भी क्लाइंट के साथ एकीकरण के लिए तैयार है।

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

शुरू करने के लिए, हम एक नया Go मॉड्यूल बनाएंगे और आवश्यक लाइब्रेरीज़ इंस्टॉल करेंगे। हम दो लोकप्रिय GraphQL लाइब्रेरीज़ का उपयोग करेंगे: graphql-go और graphql-go-handler।

1.1. मॉड्यूल इनिशियलाइज़ेशन

go mod init graphql-tutorial

1.2. लाइब्रेरीज़ इंस्टॉल करना

go get github.com/graphql-go/graphqlgo get github.com/graphql-go/handler

ये लाइब्रेरीज़ स्कीमा, टाइप और रिज़ॉल्वर के साथ काम करने के लिए सभी आवश्यक टूल प्रदान करती हैं।

चरण 2: बेसिक GraphQL स्कीमा बनाना

स्कीमा GraphQL API का दिल है। यह परिभाषित करता है कि कौन सा डेटा प्राप्त किया जा सकता है और कौन सी क्रियाएं की जा सकती हैं। चलिए एक सरल "उपयोगकर्ता" मॉडल से शुरू करते हैं।

2.1. User टाइप को परिभाषित करना

import "github.com/graphql-go/graphql"

var userType = graphql.NewObject(graphql.ObjectConfig{    Name: "User",    Fields: graphql.Fields{        "id": &graphql.Field{            Type: graphql.Int,        },        "name": &graphql.Field{            Type: graphql.String,        },        "email": &graphql.Field{            Type: graphql.String,        },    },})

2.2. रूट क्वेरी बनाना

var rootQuery = graphql.NewObject(graphql.ObjectConfig{    Name: "RootQuery",    Fields: graphql.Fields{        "user": &graphql.Field{            Type: userType,            Args: graphql.FieldConfigArgument{                "id": &graphql.ArgumentConfig{                    Type: graphql.Int,                },            },            Resolve: func(p graphql.ResolveParams) (interface{}, error) {                id, _ := p.Args["id"].(int)                // यहाँ डेटाबेस से उपयोगकर्ता प्राप्त करने का लॉजिक होगा                return getUserByID(id), nil            },        },    },})

2.3. स्कीमा में संयोजित करना

var schema, _ = graphql.NewSchema(graphql.SchemaConfig{    Query: rootQuery,})

चरण 3: रिज़ॉल्वर और सर्वर का कार्यान्वयन

अब जब स्कीमा तैयार है, तो हमें रिज़ॉल्वर लिखने होंगे - वे फ़ंक्शन जो वास्तव में डेटा लौटाते हैं। सरलता के लिए, हम in-memory स्टोरेज का उपयोग करेंगे।

3.1. In-memory स्टोरेज

type User struct {    ID    int    `json:"id"`    Name  string `json:"name"`    Email string `json:"email"`}

var users = []User{    {ID: 1, Name: "इवान पेत्रोव", Email: "ivan@example.com"},    {ID: 2, Name: "मारिया सिदोरोवा", Email: "maria@example.com"},}

func getUserByID(id int) *User {    for _, u := range users {        if u.ID == id {            return &u        }    }    return nil}

3.2. HTTP सर्वर चलाना

package main

import (    "fmt"    "log"    "net/http"

    "github.com/graphql-go/handler")

func main() {    h := handler.New(&handler.Config{        Schema:   &schema,        Pretty:   true,        GraphiQL: true, // अंतर्निहित IDE चालू करें    })

    http.Handle("/graphql", h)    fmt.Println("सर्वर चालू है")
```