ग्राफकॉल और गोलंग

पिछले कुछ वर्षों में ग्राफकॉल तकनीक, कंपनी द्वारा फेसबुक को ओपन-सोर्स की श्रेणी में स्थानांतरित करने के बाद, यह बहुत लोकप्रिय हो गया है। सामग्री का लेखक, जिसका अनुवाद आज हम प्रकाशित करते हैं, का कहना है कि उन्होंने Node.js में ग्राफकॉक के साथ काम करने की कोशिश की और अपने स्वयं के अनुभव से, आश्वस्त थे कि यह तकनीक, इसकी उल्लेखनीय क्षमताओं और सादगी के कारण, गलती से इतना ध्यान नहीं देती है। हाल ही में, एक नए प्रोजेक्ट में लगे रहने के दौरान, उन्होंने Node.js से गोलंग में स्विच किया। तब उन्होंने गोलंग और ग्राफकॉक के सहयोग का परीक्षण करने का फैसला किया।

प्रारंभिक जानकारी

आप आधिकारिक ग्राफ़कॉल परिभाषा से जान सकते हैं कि यह एपीआई के लिए एक क्वेरी भाषा है और मौजूदा डेटा पर ऐसे प्रश्नों को निष्पादित करने के लिए एक रनटाइम है। ग्राफकॉल एक निश्चित एपीआई में डेटा का एक पूर्ण और समझने योग्य विवरण प्रदान करता है, ग्राहकों को ठीक उसी जानकारी का अनुरोध करने की अनुमति देता है, और अधिक कुछ नहीं, समय के साथ एपीआई के विकास को सरल करता है और डेवलपर्स को शक्तिशाली उपकरण देता है।

गोलंग के लिए बहुत से ग्राफ़िकल लाइब्रेरी नहीं हैं। विशेष रूप से, मैंने थंडर , ग्रेफ्ल , ग्रेफ्ल-गो और गक्क्जेन जैसे पुस्तकालयों की कोशिश की। मुझे ध्यान देना चाहिए कि मैंने जो सबसे अच्छा प्रयास किया, वह था गक्लेजेन पुस्तकालय।

Gqlgen पुस्तकालय अभी भी बीटा में है, इस सामग्री को लिखने के समय यह संस्करण 0.7.2 था। पुस्तकालय तेजी से विकसित हो रहा है। यहां आप इसके विकास की योजनाओं के बारे में जान सकते हैं। अब gqlgen का आधिकारिक प्रायोजक 99designs परियोजना है, जिसका अर्थ है कि यह पुस्तकालय, संभवतः, पहले से भी तेजी से विकसित होगा। इस पुस्तकालय के मुख्य विकासकर्ता वीटाह और नीलेंस हैं , जबकि इसके अलावा, नीलेंस, ग्राफ़िकल-गो लाइब्रेरी पर काम करता है।

आइए इस धारणा के आधार पर gqlgen पुस्तकालय के बारे में बात करें कि आपके पास पहले से ही ग्राफ़िकल का बुनियादी ज्ञान है।

Gqlgen सुविधाएँ

Gqlgen विवरण में, आप यह जान सकते हैं कि गोलंग में कड़ाई से टाइप किए गए ग्राफ़क्यूएल सर्वर बनाने के लिए हमारे पास लाइब्रेरी होने से पहले हमारे पास क्या है। यह वाक्यांश मुझे बहुत आशाजनक लगता है, क्योंकि इसका मतलब है कि इस पुस्तकालय के साथ काम करते समय मैं map[string]interface{} जैसी किसी चीज के साथ नहीं map[string]interface{} , क्योंकि सख्त टाइपिंग पर आधारित एक दृष्टिकोण का उपयोग यहां किया जाता है।

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

यह लेख दो भागों में विभाजित है। पहला काम के बुनियादी तरीकों के लिए समर्पित है, और दूसरा उन्नत लोगों के लिए।

काम के मुख्य तरीके: डेटा की स्थापना, सदस्यता और बदलने के लिए अनुरोध करना

हम, एक प्रयोगात्मक अनुप्रयोग के रूप में, एक साइट का उपयोग करेंगे जहां उपयोगकर्ता वीडियो प्रकाशित कर सकते हैं, स्क्रीनशॉट और समीक्षाएं जोड़ सकते हैं, वीडियो खोज सकते हैं और अन्य रिकॉर्ड से जुड़े रिकॉर्ड की सूची देख सकते हैं। आइए इस परियोजना पर काम शुरू करें:

 mkdir -p $GOPATH/src/github.com/ridhamtarpara/go-graphql-demo/ 

प्रोजेक्ट के रूट डायरेक्टरी में निम्न डेटा स्कीमा फ़ाइल ( schema.graphql ) बनाएँ:

 type User {   id: ID!   name: String!   email: String! } type Video {   id: ID!   name: String!   description: String!   user: User!   url: String!   createdAt: Timestamp!   screenshots: [Screenshot]   related(limit: Int = 25, offset: Int = 0): [Video!]! } type Screenshot {   id: ID!   videoId: ID!   url: String! } input NewVideo {   name: String!   description: String!   userId: ID!   url: String! } type Mutation {   createVideo(input: NewVideo!): Video! } type Query {   Videos(limit: Int = 25, offset: Int = 0): [Video!]! } scalar Timestamp 

यहां मूल डेटा मॉडल, एक उत्परिवर्तन ( Mutation , डेटा परिवर्तन के लिए अनुरोध का वर्णन) का वर्णन किया गया है, जिसका उपयोग साइट पर नई वीडियो फ़ाइलों को प्रकाशित करने के लिए किया जाता है, और सभी वीडियो फ़ाइलों की सूची प्राप्त करने के लिए एक क्वेरी ( Query )। यहां ग्राफ़िकल स्कीमा के बारे में और पढ़ें। इसके अलावा, यहां हमने अपने स्वयं के स्केलर डेटा प्रकारों में से एक घोषित किया। हम 5 मानक स्केलर डेटा प्रकारों ( Int , Float , String , Boolean और ID ) से संतुष्ट नहीं हैं, जो ग्राफकॉइन में हैं।

यदि आपको अपने स्वयं के प्रकारों का उपयोग करने की आवश्यकता है, तो आप उन्हें schema.graphql (हमारे मामले में, यह प्रकार Timestamp ) में घोषित कर सकते हैं और कोड में अपनी परिभाषा प्रदान कर सकते हैं। Gqlgen लाइब्रेरी का उपयोग करते समय, आपको अपने सभी स्केलर प्रकारों के लिए मार्शलिंग और अनमर्शिंग के तरीके प्रदान करने और gqlgen.yml का उपयोग करके मैपिंग कॉन्फ़िगर करने की gqlgen.yml ।

यह ध्यान दिया जाना चाहिए कि पुस्तकालय के नवीनतम संस्करण में एक महत्वपूर्ण परिवर्तन था। अर्थात्, संकलित बाइनरी फ़ाइलों पर निर्भरता को इससे हटा दिया गया था। इसलिए, scripts/gqlgen.go फ़ाइल को निम्न सामग्री के scripts/gqlgen.go प्रोजेक्ट में जोड़ा जाना चाहिए:

 // +build ignore package main import "github.com/99designs/gqlgen/cmd" func main() { cmd.Execute() } 

उसके बाद, आपको dep को इनिशियलाइज़ करने की आवश्यकता है:

 dep init 

अब लाइब्रेरी की कोड जनरेशन क्षमताओं का लाभ उठाने का समय आ गया है। वे आपको सभी उबाऊ बॉयलरप्लेट कोड बनाने की अनुमति देते हैं, जो, हालांकि, पूरी तरह से निर्बाध नहीं कहा जा सकता है। स्वचालित कोड पीढ़ी तंत्र शुरू करने के लिए, निम्नलिखित कमांड निष्पादित करें:

 go run scripts/gqlgen.go init 

इसके निष्पादन के परिणामस्वरूप, निम्नलिखित फाइलें बनाई जाएंगी:

• gqlgen.yml : कोड पीढ़ी के प्रबंधन के लिए कॉन्फ़िगरेशन फ़ाइल।
  
• generated.go : उत्पन्न कोड।
  
• models_gen.go : उपलब्ध स्कीमा के सभी मॉडल और डेटा प्रकार।
  
• resolver.go : यहां वह कोड होगा जो प्रोग्रामर बनाता है।
  
• server/server.go : http.Handler पॉइंट सर्वर शुरू करने के लिए http.Handler के साथ एंट्री पॉइंट।
  

Video प्रकार के लिए जनरेट किए गए मॉडल पर एक नज़र डालें (फ़ाइल generated_video.go ):

 type Video struct { ID          string  `json:"id"` Name        string  `json:"name"` User        User  `json:"user"` URL         string  `json:"url"` CreatedAt   string  `json:"createdAt"` Screenshots []*Screenshot `json:"screenshots"` Related     []Video  `json:"related"` } 

यहां आप देख सकते हैं कि ID एक स्ट्रिंग है, CreatedAt भी एक स्ट्रिंग है। अन्य संबंधित मॉडल तदनुसार कॉन्फ़िगर किए गए हैं। हालांकि, वास्तविक अनुप्रयोगों में यह आवश्यक नहीं है। यदि आप किसी भी प्रकार के एसक्यूएल डेटा का उपयोग कर रहे हैं, तो आपको उदाहरण के लिए, ID फ़ील्ड होगा, जो उपयोग किए गए डेटाबेस, एक int या int int64 आधार पर होगा।

उदाहरण के लिए, मैं इस डेमो एप्लिकेशन में PostgreSQL का उपयोग करता हूं, इसलिए निश्चित रूप से मुझे ID फ़ील्ड की आवश्यकता है प्रकार की int और CreatedAt प्रकार CreatedAt । यह इस तथ्य की ओर जाता है कि हमें अपने स्वयं के मॉडल को परिभाषित करने की आवश्यकता है और gqlgen को बताएं कि हमें एक नया निर्माण करने के बजाय अपने मॉडल का उपयोग करने की आवश्यकता है। यहाँ models.go फ़ाइल की सामग्री है:

 type Video struct { ID          int `json:"id"` Name        string `json:"name"` Description string    `json:"description"` User        User `json:"user"` URL         string `json:"url"` CreatedAt   time.Time `json:"createdAt"` Related     []Video } //    int  ID func MarshalID(id int) graphql.Marshaler { return graphql.WriterFunc(func(w io.Writer) {   io.WriteString(w, strconv.Quote(fmt.Sprintf("%d", id))) }) } //        func UnmarshalID(v interface{}) (int, error) { id, ok := v.(string) if !ok {   return 0, fmt.Errorf("ids must be strings") } i, e := strconv.Atoi(id) return int(i), e } func MarshalTimestamp(t time.Time) graphql.Marshaler { timestamp := t.Unix() * 1000 return graphql.WriterFunc(func(w io.Writer) {   io.WriteString(w, strconv.FormatInt(timestamp, 10)) }) } func UnmarshalTimestamp(v interface{}) (time.Time, error) { if tmpStr, ok := v.(int); ok {   return time.Unix(int64(tmpStr), 0), nil } return time.Time{}, errors.TimeStampError } 

हम पुस्तकालय को बताते हैं कि उसे इन मॉडलों ( gqlgen.yml फ़ाइल) का उपयोग करना चाहिए:

 schema: - schema.graphql exec: filename: generated.go model: filename: models_gen.go resolver: filename: resolver.go type: Resolver models: Video:   model: github.com/ridhamtarpara/go-graphql-demo/api.Video ID:   model: github.com/ridhamtarpara/go-graphql-demo/api.ID Timestamp:   model: github.com/ridhamtarpara/go-graphql-demo/api.Timestamp 

इन सबके बीच यह है कि अब हमारे पास ID और Timestamp के लिए मार्शलिंग और gqlgen.yml तरीकों की अपनी परिभाषाएँ हैं और उन्हें gqlgen.yml फ़ाइल में मैप करना है। अब जब उपयोगकर्ता स्ट्रिंग को एक ID रूप में प्रदान करता है, तो UnmarshalID() विधि उस स्ट्रिंग को पूर्णांक में बदल देती है। प्रतिक्रिया भेजते समय, MarshalID() विधि संख्या को एक स्ट्रिंग में परिवर्तित करती है। ऐसा ही कुछ Timestamp साथ या प्रोग्रामर द्वारा घोषित किसी अन्य स्केलर प्रकार के साथ होता है।

अब आवेदन तर्क को लागू करने का समय आ गया है। resolver.go फ़ाइल खोलें और उसमें म्यूटेशन और क्वेरीज़ का विवरण जोड़ें। पहले से ही एक स्वचालित रूप से उत्पन्न बॉयलरप्लेट कोड है जिसे हमें अर्थ के साथ भरने की आवश्यकता है। इस फ़ाइल का कोड इस प्रकार है:

 func (r *mutationResolver) CreateVideo(ctx context.Context, input NewVideo) (api.Video, error) { newVideo := api.Video{   URL:         input.URL,   Name:        input.Name,   CreatedAt:   time.Now().UTC(), } rows, err := dal.LogAndQuery(r.db, "INSERT INTO videos (name, url, user_id, created_at) VALUES($1, $2, $3, $4) RETURNING id",   input.Name, input.URL, input.UserID, newVideo.CreatedAt) defer rows.Close() if err != nil || !rows.Next() {   return api.Video{}, err } if err := rows.Scan(&newVideo.ID); err != nil {   errors.DebugPrintf(err)   if errors.IsForeignKeyError(err) {     return api.Video{}, errors.UserNotExist   }   return api.Video{}, errors.InternalServerError } return newVideo, nil } func (r *queryResolver) Videos(ctx context.Context, limit *int, offset *int) ([]api.Video, error) { var video api.Video var videos []api.Video rows, err := dal.LogAndQuery(r.db, "SELECT id, name, url, created_at, user_id FROM videos ORDER BY created_at desc limit $1 offset $2", limit, offset) defer rows.Close();   if err != nil {   errors.DebugPrintf(err)   return nil, errors.InternalServerError } for rows.Next() {   if err := rows.Scan(&video.ID, &video.Name, &video.URL, &video.CreatedAt, &video.UserID); err != nil {     errors.DebugPrintf(err)     return nil, errors.InternalServerError   }   videos = append(videos, video) } return videos, nil } 

अब म्यूटेशन का परीक्षण करते हैं।

उत्परिवर्तन createVideo

यह काम करता है! लेकिन उपयोगकर्ता जानकारी ( user वस्तु) में कुछ भी क्यों नहीं है? ग्राफकलाइन के साथ काम करते समय, "आलसी" (आलसी) और "लालची" (उत्सुक) लोडिंग के समान अवधारणाएं लागू होती हैं। चूंकि यह प्रणाली एक्स्टेंसिबल है, आपको यह निर्दिष्ट करने की आवश्यकता है कि किन क्षेत्रों को "लालच" से भरने की आवश्यकता है और जो "आलसी" हैं।

मैंने उस संगठन में टीम को सुझाव दिया, जहां मैं निम्नलिखित "सुनहरा नियम" काम करता हूं, जो gqlgen के साथ काम करते समय लागू होता है: "मॉडल में उन क्षेत्रों को शामिल न करें जिन्हें केवल क्लाइंट द्वारा अनुरोध किए जाने पर लोड करने की आवश्यकता होती है।"

हमारे मामले में, मुझे संबंधित वीडियो क्लिप (और यहां तक ​​कि उपयोगकर्ता जानकारी) के बारे में डेटा डाउनलोड करने की आवश्यकता है केवल अगर ग्राहक इन क्षेत्रों का अनुरोध करता है। लेकिन जब से हमने इन क्षेत्रों को मॉडल में शामिल किया, gqlgen मानता है कि हम वीडियो के बारे में जानकारी प्राप्त करके यह डेटा प्रदान करते हैं। नतीजतन, अब हमें खाली संरचनाएं मिलती हैं।

कभी-कभी ऐसा होता है कि हर बार एक निश्चित प्रकार के डेटा की आवश्यकता होती है, इसलिए एक अलग अनुरोध का उपयोग करके इसे डाउनलोड करना अव्यावहारिक है। इसके लिए, प्रदर्शन को बेहतर बनाने के लिए, आप SQL जॉइन जैसे कुछ का उपयोग कर सकते हैं। एक बार (यह, हालांकि, यहां दिए गए उदाहरण पर लागू नहीं होता है), मुझे वीडियो के साथ इसके मेटाडेटा को अपलोड करने की आवश्यकता है। इन संस्थाओं को विभिन्न स्थानों में संग्रहित किया गया था। परिणामस्वरूप, अगर मेरे सिस्टम को वीडियो डाउनलोड करने का अनुरोध मिला, तो मुझे मेटाडेटा प्राप्त करने के लिए एक और अनुरोध करना होगा। लेकिन, जब से मुझे इस आवश्यकता के बारे में पता था (अर्थात, मुझे पता था कि क्लाइंट और वीडियो और उसके मेटाडेटा की हमेशा क्लाइंट की तरफ जरूरत होती है), मैंने प्रदर्शन को बेहतर बनाने के लिए लालची लोडिंग तकनीक का उपयोग करना पसंद किया।

आइए मॉडल को फिर से लिखें और फिर से gqlgen कोड जनरेट करें। कहानी को जटिल नहीं करने के लिए, हम केवल user फ़ील्ड के लिए तरीके लिखते हैं (फ़ाइल models.go ):

 type Video struct { ID          int `json:"id"` Name        string `json:"name"` Description string    `json:"description"` UserID      int `json:"-"` URL         string `json:"url"` CreatedAt   time.Time `json:"createdAt"` } 

हमने एक User जोड़ा और User संरचना को हटा दिया। अब कोड पुन: बनाएँ:

 go run scripts/gqlgen.go -v 

इस आदेश के लिए धन्यवाद, अपरिभाषित संरचनाओं को हल करने के लिए निम्नलिखित इंटरफ़ेस विधियों का निर्माण किया जाएगा। इसके अलावा, आपको रिज़ॉल्वर ( generated.go फ़ाइल) में निम्नलिखित को निर्धारित करना होगा:

 type VideoResolver interface { User(ctx context.Context, obj *api.Video) (api.User, error) Screenshots(ctx context.Context, obj *api.Video) ([]*api.Screenshot, error) Related(ctx context.Context, obj *api.Video, limit *int, offset *int) ([]api.Video, error) } 

यहाँ परिभाषा ( resolver.go फ़ाइल) है:

 func (r *videoResolver) User(ctx context.Context, obj *api.Video) (api.User, error) { rows, _ := dal.LogAndQuery(r.db,"SELECT id, name, email FROM users where id = $1", obj.UserID) defer rows.Close() if !rows.Next() {   return api.User{}, nil } var user api.User if err := rows.Scan(&user.ID, &user.Name, &user.Email); err != nil {   errors.DebugPrintf(err)   return api.User{}, errors.InternalServerError } return user, nil } 

अब, म्यूटेशन टेस्ट के परिणाम नीचे दिखाए गए अनुसार होंगे।


उत्परिवर्तन createVideo

जिस चीज पर हमने चर्चा की है, वह ग्राफक्यूएल की बुनियादी बातों में महारत हासिल है, जिसे आप पहले से ही अपना कुछ लिख सकते हैं। हालांकि, इससे पहले कि आप ग्राफकॉल और गोलंग के प्रयोगों में उतरें, सदस्यता के बारे में बात करना उपयोगी होगा, जो सीधे तौर पर हम यहां क्या कर रहे हैं, से संबंधित हैं।

▍ सदस्यता

GraphQL वास्तविक समय में होने वाले डेटा परिवर्तनों की सदस्यता लेने की क्षमता प्रदान करता है। Gqlgen पुस्तकालय, वास्तविक समय में, वेब सॉकेट्स का उपयोग करके, सब्सक्रिप्शन घटनाओं के साथ काम करने की अनुमति देता है।

सदस्यता को schema.graphql फ़ाइल में वर्णित किया जाना चाहिए। यहाँ वीडियो प्रकाशन घटना के लिए सदस्यता का वर्णन है:

 type Subscription {   videoPublished: Video! } 

अब, स्वचालित कोड पीढ़ी फिर से चलाएँ:

 go run scripts/gqlgen.go -v 

जैसा कि पहले ही उल्लेख किया गया है, generated.go फ़ाइल में कोड के स्वचालित निर्माण के दौरान, एक इंटरफ़ेस बनाया जाता है जिसे पहचानकर्ता में लागू किया जाना चाहिए। हमारे मामले में, यह इस तरह दिखता है ( resolver.go file):

 var videoPublishedChannel map[string]chan api.Video func init() { videoPublishedChannel = map[string]chan api.Video{} } type subscriptionResolver struct{ *Resolver } func (r *subscriptionResolver) VideoPublished(ctx context.Context) (<-chan api.Video, error) { id := randx.String(8) videoEvent := make(chan api.Video, 1) go func() {   <-ctx.Done() }() videoPublishedChannel[id] = videoEvent return videoEvent, nil } func (r *mutationResolver) CreateVideo(ctx context.Context, input NewVideo) (api.Video, error) { //   ... for _, observer := range videoPublishedChannel {   observer <- newVideo } return newVideo, nil } 

अब, एक नया वीडियो बनाते समय, आपको एक ईवेंट ट्रिगर करना होगा। हमारे उदाहरण में, यह for _, observer := range videoPublishedChannel लाइन में किया गया है।

अब आपकी सदस्यता की जांच करने का समय आ गया है।


सदस्यता सत्यापित करें

निश्चित रूप से, ग्राफ़िकल में कुछ मूल्यवान क्षमताएं हैं, लेकिन जैसा कि वे कहते हैं, यह सब नहीं है कि ग्लिटर सोना है। अर्थात्, हम इस तथ्य के बारे में बात कर रहे हैं कि कोई व्यक्ति जो ग्राफ़िकल का उपयोग करता है, उसे प्राधिकरण की देखभाल, अनुरोधों की जटिलता, कैशिंग, एन + 1 अनुरोधों की समस्या, क्वेरी निष्पादन की गति की सीमा और कुछ अन्य चीजों का ध्यान रखना चाहिए। अन्यथा, GraphQL के उपयोग से विकसित एक प्रणाली को प्रदर्शन में एक गंभीर गिरावट का सामना करना पड़ सकता है।

उन्नत तकनीक: प्रमाणीकरण, डेटा लोडर, क्वेरी जटिलता

जब भी मैं इस तरह से मैनुअल पढ़ता हूं, मुझे यह एहसास होता है कि, उन्हें महारत हासिल करने के बाद, मैं वह सब कुछ सीखता हूं, जो मुझे एक निश्चित तकनीक के बारे में जानने की जरूरत है और किसी भी जटिलता की समस्याओं को हल करने की क्षमता प्राप्त करना है।

लेकिन जब मैं अपनी खुद की परियोजनाओं पर काम करना शुरू करता हूं, तो मैं आमतौर पर अप्रत्याशित स्थितियों में आ जाता हूं जो सर्वर त्रुटियों या उन अनुरोधों की तरह दिखती हैं जो उम्र के लिए चल रहे हैं, या कुछ अन्य गतिरोध स्थितियों की तरह हैं। नतीजतन, ऐसा करने के लिए, मुझे बेहतर तरीके से समझाना होगा कि हाल ही में पूरी तरह से समझ में आया था। इसी नियमावली में, मुझे उम्मीद है कि इससे बचा जा सकता है। यही कारण है कि इस खंड में हम ग्राफकॉल के साथ काम करने के लिए कुछ उन्नत तकनीकों को देखेंगे।

Ication प्रमाणीकरण

REST API के साथ काम करते समय, हमारे पास एक प्रमाणीकरण प्रणाली और एक निश्चित समापन बिंदु के साथ काम करते समय मानक प्रमाणीकरण उपकरण होते हैं। लेकिन ग्राफकॉल का उपयोग करते समय, केवल एक समापन बिंदु का उपयोग किया जाता है, इसलिए, स्कीमा निर्देशों का उपयोग करके प्रमाणीकरण कार्यों को हल किया जा सकता है। schema.graphql संपादित करें।

 type Mutation {   createVideo(input: NewVideo!): Video! @isAuthenticated } directive @isAuthenticated on FIELD_DEFINITION 

हमने isAuthenticated निर्देश बनाया और इसे createVideo सदस्यता पर लागू किया। अगले स्वचालित कोड पीढ़ी सत्र के बाद, आपको इस निर्देश के लिए परिभाषा निर्धारित करने की आवश्यकता है। अब निर्देशों को संरचनाओं के तरीकों के रूप में लागू किया जाता है, और इंटरफेस के रूप में नहीं, इसलिए हमें उनका वर्णन करने की आवश्यकता है। मैंने server.go फ़ाइल में स्थित स्वचालित रूप से उत्पन्न कोड को server.go और एक ऐसी विधि बनाई, जो server.go फ़ाइल के लिए ग्राफकॉल कॉन्फ़िगरेशन को server.go है। यहाँ resolver.go फ़ाइल है:

 func NewRootResolvers(db *sql.DB) Config { c := Config{   Resolvers: &Resolver{     db: db,   }, } //   c.Directives.IsAuthenticated = func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error) {   ctxUserID := ctx.Value(UserIDCtxKey)   if ctxUserID != nil {     return next(ctx)   } else {     return nil, errors.UnauthorisedError   } } return c } 

यहाँ server.go फ़ाइल है:

 rootHandler:= dataloaders.DataloaderMiddleware(   db,   handler.GraphQL(     go_graphql_demo.NewExecutableSchema(go_graphql_demo.NewRootResolvers(db)   ) ) http.Handle("/query", auth.AuthMiddleware(rootHandler)) 

हम संदर्भ से उपयोगकर्ता ID पढ़ते हैं। क्या आपको यह अजीब नहीं लगता? यह अर्थ संदर्भ में कैसे आया और यह संदर्भ में भी क्यों प्रकट हुआ? तथ्य यह है कि gqlgen केवल कार्यान्वयन स्तर पर अनुरोध संदर्भ प्रदान करता है, इसलिए हमारे पास किसी भी HTTP अनुरोध डेटा, जैसे हेडर या कुकीज़, पहचानकर्ताओं या निर्देशों में पढ़ने का कोई तरीका नहीं है। नतीजतन, आपको सिस्टम में अपने स्वयं के मध्यवर्ती तंत्र को जोड़ने की जरूरत है, इस डेटा को प्राप्त करें और इसे संदर्भ में डालें।

अब हमें अनुरोध से प्रमाणीकरण डेटा प्राप्त करने और इसे सत्यापित करने के लिए अपने स्वयं के मध्यवर्ती प्रमाणीकरण तंत्र का वर्णन करने की आवश्यकता है।

कोई तर्क यहाँ परिभाषित नहीं है। इसके बजाय, प्रदर्शन उद्देश्यों के लिए प्राधिकरण डेटा के लिए, उपयोगकर्ता ID बस यहां से पारित किया जाता है। यह तंत्र फिर एक नया विन्यास लोड करने की विधि के साथ server.go में संयुक्त है।

अब निर्देश का वर्णन समझ में आता है। हम मिडलवेयर कोड में अनधिकृत उपयोगकर्ता अनुरोधों को संसाधित नहीं करते हैं, क्योंकि ऐसे अनुरोधों को निर्देश द्वारा संसाधित किया जाएगा। यहाँ है कि यह कैसा दिखता है।


एक अनधिकृत उपयोगकर्ता के साथ काम करें


अधिकृत उपयोगकर्ता के साथ काम करें

स्कीमा निर्देशों के साथ काम करते समय, आप तर्क भी पास कर सकते हैं:

 directive @hasRole(role: Role!) on FIELD_DEFINITION enum Role { ADMIN USER } 

▍दत्ता लोडर

यह मुझे लगता है कि यह सब बहुत दिलचस्प लग रहा है। जरूरत पड़ने पर आप डेटा डाउनलोड करते हैं। ग्राहकों के पास डेटा को प्रबंधित करने की क्षमता होती है; लेकिन हर चीज की एक कीमत होती है।

इन अवसरों के लिए भुगतान करने की कीमत क्या है? सभी वीडियो के डाउनलोड लॉग पर एक नज़र डालें। अर्थात्, हम इस तथ्य के बारे में बात कर रहे हैं कि हमारे पास 8 वीडियो और 5 उपयोगकर्ता हैं।

 query{ Videos(limit: 10){   name   user{     name   } } } 

वीडियो डाउनलोड विवरण

 Query: Videos : SELECT id, name, description, url, created_at, user_id FROM videos ORDER BY created_at desc limit $1 offset $2 Resolver: User : SELECT id, name, email FROM users where id = $1 Resolver: User : SELECT id, name, email FROM users where id = $1 Resolver: User : SELECT id, name, email FROM users where id = $1 Resolver: User : SELECT id, name, email FROM users where id = $1 Resolver: User : SELECT id, name, email FROM users where id = $1 Resolver: User : SELECT id, name, email FROM users where id = $1 Resolver: User : SELECT id, name, email FROM users where id = $1 Resolver: User : SELECT id, name, email FROM users where id = $1 

यहाँ क्या हो रहा है? 9 अनुरोध क्यों हैं (1 अनुरोध वीडियो तालिका के साथ जुड़ा हुआ है और 8 - उपयोगकर्ता तालिका के साथ)? यह भयानक लग रहा है। मेरा दिल लगभग रुक गया जब मैंने सोचा कि हमारे मौजूदा एपीआई को इसे बदलना होगा ... सच है, डेटा लोडर पूरी तरह से इस समस्या का सामना कर सकते हैं।

इसे N + 1 समस्या के रूप में जाना जाता है। हम इस तथ्य के बारे में बात कर रहे हैं कि सभी डेटा प्राप्त करने के लिए एक क्वेरी है और डेटा के प्रत्येक टुकड़े (एन) के लिए डेटाबेस के लिए एक और क्वेरी होगी।

जब यह प्रदर्शन और संसाधनों की बात आती है, तो यह एक बहुत ही गंभीर समस्या है: हालांकि ये अनुरोध समानांतर हैं, ये सिस्टम संसाधनों को सूखा देते हैं।

इस समस्या को हल करने के लिए, हम gqlgen लाइब्रेरी के लेखक से dataloaden लाइब्रेरी का उपयोग करेंगे। यह लाइब्रेरी आपको गो कोड जनरेट करने की अनुमति देती है। सबसे पहले, User इकाई के लिए एक डेटा लोडर बनाएँ:

 go get github.com/vektah/dataloaden dataloaden github.com/ridhamtarpara/go-graphql-demo/api.User 

हमारे पास हमारे पास फ़ाइल userloader_gen.go , जिसमें Fetch , LoadAll और Prime जैसी विधियाँ हैं।

अब, सामान्य परिणाम प्राप्त करने के लिए, हमें Fetch विधि ( dataloader.go फ़ाइल) को परिभाषित करने की आवश्यकता है:

 func DataloaderMiddleware(db *sql.DB, next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {   userloader := UserLoader{     wait : 1 * time.Millisecond,     maxBatch: 100,     fetch: func(ids []int) ([]*api.User, []error) {       var sqlQuery string       if len(ids) == 1 {         sqlQuery = "SELECT id, name, email from users WHERE id = ?"       } else {         sqlQuery = "SELECT id, name, email from users WHERE id IN (?)"       }       sqlQuery, arguments, err := sqlx.In(sqlQuery, ids)       if err != nil {         log.Println(err)       }       sqlQuery = sqlx.Rebind(sqlx.DOLLAR, sqlQuery)       rows, err := dal.LogAndQuery(db, sqlQuery, arguments...)       defer rows.Close();       if err != nil {         log.Println(err)       }       userById := map[int]*api.User{}       for rows.Next() {         user:= api.User{}         if err := rows.Scan(&user.ID, &user.Name, &user.Email); err != nil {           errors.DebugPrintf(err)           return nil, []error{errors.InternalServerError}         }         userById[user.ID] = &user       }       users := make([]*api.User, len(ids))       for i, id := range ids {         users[i] = userById[id]         i++       }       return users, nil     },   }   ctx := context.WithValue(r.Context(), CtxKey, &userloader)   r = r.WithContext(ctx)   next.ServeHTTP(w, r) }) } 

यहां हम 1 एमएस की प्रतीक्षा करते हैं। अनुरोध को निष्पादित करने से पहले और 100 अनुरोधों के पैकेज में अनुरोधों को इकट्ठा करें। अब, प्रत्येक उपयोगकर्ता के लिए व्यक्तिगत रूप से एक अनुरोध निष्पादित करने के बजाय, लोडर डेटाबेस तक पहुंचने से पहले निर्दिष्ट समय की प्रतीक्षा करेगा। इसके बाद, आपको डेटा लोडर ( resolver.go फ़ाइल) का उपयोग करने के अनुरोध का उपयोग करके इसे पहचानने वाले तर्क को बदलने की आवश्यकता है:

 func (r *videoResolver) User(ctx context.Context, obj *api.Video) (api.User, error) { user, err := ctx.Value(dataloaders.CtxKey).(*dataloaders.UserLoader).Load(obj.UserID) return *user, err } 

यहां बताया गया है कि ऊपर वर्णित स्थिति के समान ही लॉग कैसे दिखता है:

 Query: Videos : SELECT id, name, description, url, created_at, user_id FROM videos ORDER BY created_at desc limit $1 offset $2 Dataloader: User : SELECT id, name, email from users WHERE id IN ($1, $2, $3, $4, $5) 

केवल दो डेटाबेस प्रश्नों को यहां निष्पादित किया जाता है, परिणामस्वरूप, हर कोई अब खुश है। यह ध्यान रखना दिलचस्प है कि केवल 5 उपयोगकर्ता पहचानकर्ताओं को अनुरोध भेजा जाता है, हालांकि 8 वीडियो के लिए डेटा का अनुरोध किया जाता है। इससे पता चलता है कि डेटा लोडर डुप्लिकेट रिकॉर्ड को हटा देता है।

▍

GraphQL API , . , API DOS-.

, .

Video , . GraphQL Video . . — .

, — :

 { Videos(limit: 10, offset: 0){   name   url   related(limit: 10, offset: 0){     name     url     related(limit: 10, offset: 0){       name       url       related(limit: 100, offset: 0){         name         url       }     }   } } } 

100, . (, , ) , .

gqlgen , . , ( handler.ComplexityLimit(300) ) GraphQL (300 ). , ( server.go ):

 rootHandler:= dataloaders.DataloaderMiddleware( db, handler.GraphQL(   go_graphql_demo.NewExecutableSchema(go_graphql_demo.NewRootResolvers(db)),   handler.ComplexityLimit(300) ), ) 

, , . 12. , , , ( , , , , ). resolver.go :

 func NewRootResolvers(db *sql.DB) Config { c := Config{   Resolvers: &Resolver{     db: db,   }, } //  countComplexity := func(childComplexity int, limit *int, offset *int) int {   return *limit * childComplexity } c.Complexity.Query.Videos = countComplexity c.Complexity.Video.Related = countComplexity //   c.Directives.IsAuthenticated = func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error) {   ctxUserID := ctx.Value(UserIDCtxKey)   if ctxUserID != nil {     return next(ctx)   } else {     return nil, errors.UnauthorisedError   } } return c } 

, , .







, , related . , , , , .

परिणाम

, , GitHub . . , , .

प्रिय पाठकों! GraphQL , Go?