🍩 🥔 👩🏽‍🏭 रेखांकन एपीआई (CRUD) गो पर 🆓 👨🏿‍🤝‍👨🏽 🕵🏻

सभी को नमस्कार! ग्राफ पर हेगलाइन के बारे में बहुत सारे लेख हैं, लेकिन उनके माध्यम से चलने पर मैंने पाया कि वे सभी गो जैसी अद्भुत भाषा को दरकिनार करते हैं। आज मैं इस गलतफहमी को दूर करने की कोशिश करूंगा। ऐसा करने के लिए, हम ग्राफक्लाइन का उपयोग करके गो पर एक एपीआई लिखेंगे।

संक्षेप में: ग्राफकॉल एक एपीआई के निर्माण के लिए एक क्वेरी लैंग्वेज है जिसमें डेटा के अनुरोध और वापसी के रूप में वर्णन किया गया है (आधिकारिक संसाधन graphql.imtqy.com पर और हब पर अधिक विस्तृत जानकारी)

आप तर्क दे सकते हैं कि यहां ग्राफकैल या रेस्ट बेहतर है।

हमारे पास ऑनलाइन स्टोर में उत्पादों को जोड़ने, प्राप्त करने, संपादित करने और हटाने के लिए क्लासिक एपीआई: CRUD (क्रिएट, रीड, अपडेट, डिलीट) होगा।
सर्वर की तरफ, हम ग्राफक्यूएल ग्राफकल- गो के तैयार कार्यान्वयन का उपयोग करेंगे

पहले आपको ग्राफकल-गो डाउनलोड करने की आवश्यकता है, यह कमांड के साथ किया जा सकता है

go get github.com/graphql-go/graphql

अगला, हम उत्पाद की संरचना का वर्णन करते हैं (सरलीकृत रूप में)

 type Product struct { ID int64 `json:"id"` Name string `json:"name"` Info string `json:"info,omitempty"` Price float64 `json:"price"` }

ID - विशिष्ट पहचानकर्ता, Name - नाम, Info - उत्पाद जानकारी, Price - मूल्य

पहली बात यह है कि Do विधि को कॉल करें, जो डेटा स्कीम और क्वेरी पैरामीटर को इनपुट मापदंडों के रूप में स्वीकार करता है। और यह परिणामी डेटा हमारे पास लौटा देगा (ग्राहक को और प्रसारण के लिए)

 result := graphql.Do(graphql.Params{ Schema: schema, RequestString: query, })

पूर्ण कोड

 func executeQuery(query string, schema graphql.Schema) *graphql.Result { result := graphql.Do(graphql.Params{ Schema: schema, RequestString: query, }) if len(result.Errors) > 0 { fmt.Printf("errors: %v", result.Errors) } return result } func main() { http.HandleFunc("/product", func(w http.ResponseWriter, r *http.Request) { result := executeQuery(r.URL.Query().Get("query"), schema) json.NewEncoder(w).Encode(result) }) http.ListenAndServe(":8080", nil) }

Schema - डेटा स्कीम, RequestString - हमारे मामले में क्वेरी स्ट्रिंग पैरामीटर का मान, query मान

स्कीमा (योजना)

एक स्कीमा दो रूट डेटा प्रकारों को स्वीकार करता है: Query - अपरिवर्तनीय डेटा, Mutation - उत्परिवर्तनीय डेटा

 var schema, _ = graphql.NewSchema( graphql.SchemaConfig{ Query: queryType, Mutation: mutationType, }, )

क्वेरी ()

Query का उपयोग (और केवल पढ़ने के लिए) डेटा पढ़ने के लिए किया जाता है। Query का उपयोग करते हुए Query हम निर्दिष्ट करते हैं कि सर्वर को किस डेटा पर वापस लौटना चाहिए।
हम Query डेटा प्रकार के कार्यान्वयन को लिखेंगे, हमारे मामले में इसमें एकल उत्पाद (उत्पाद) और माल की सूची (सूची) के बारे में जानकारी होगी।

 var queryType = graphql.NewObject( graphql.ObjectConfig{ Name: "Query", Fields: graphql.Fields{ /*    ID http://localhost:8080/product?query={product(id:1){name,info,price}} */ "product": &graphql.Field{ Type: productType, Description: "Get product by id", //   ,    Args: graphql.FieldConfigArgument{ //       id "id": &graphql.ArgumentConfig{ Type: graphql.Int, }, }, Resolve: func(p graphql.ResolveParams) (interface{}, error) { id, ok := p.Args["id"].(int) if ok { //    ID for _, product := range products { if int(product.ID) == id { return product, nil } } } return nil, nil }, }, /*    http://localhost:8080/product?query={list{id,name,info,price}} */ "list": &graphql.Field{ Type: graphql.NewList(productType), Description: "Get product list", Resolve: func(params graphql.ResolveParams) (interface{}, error) { return products, nil }, }, }, })

क्वेरी टाइप में आवश्यक Name और Fields , साथ ही वैकल्पिक Description (प्रलेखन के लिए उपयोग किया जाता है)
बदले में, Fields फ़ील्ड में आवश्यक Type फ़ील्ड और वैकल्पिक Args , Resolve और Description फ़ील्ड भी शामिल हैं

आर्ग्स (तर्क)

तर्क - क्लाइंट से सर्वर में स्थानांतरित किए गए मापदंडों की एक सूची और लौटे डेटा के परिणाम को प्रभावित करना। तर्क एक विशिष्ट क्षेत्र से जुड़े होते हैं। और तर्क को Query और Mutation दोनों में पारित किया जा सकता है।

 ?query={product(id:1){name,info,price}}

इस स्थिति में, 1 के मान के साथ product फ़ील्ड के लिए id तर्क इंगित करता है कि निर्दिष्ट पहचानकर्ता के साथ उत्पाद को वापस करना आवश्यक है।
list के list तर्कों को छोड़ दिया जाता है, लेकिन एक वास्तविक एप्लिकेशन में यह हो सकता है, उदाहरण के लिए: limit और offset ।

संकल्प (मान्यता)

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

प्रकार (प्रकार प्रणाली)

GraphQL डेटा का वर्णन करने के लिए अपने प्रकार प्रणाली का उपयोग करता है। आप दोनों मूल प्रकारों का उपयोग कर सकते हैं String , Int , Float , Boolean , और अपने स्वयं के (कस्टम) वाले। हमारे उदाहरण के लिए, हमें एक कस्टम प्रकार के Product आवश्यकता होगी, जो Product सभी गुणों का वर्णन करेगा

 var productType = graphql.NewObject( graphql.ObjectConfig{ Name: "Product", Fields: graphql.Fields{ "id": &graphql.Field{ Type: graphql.Int, }, "name": &graphql.Field{ Type: graphql.String, }, "info": &graphql.Field{ Type: graphql.String, }, "price": &graphql.Field{ Type: graphql.Float, }, }, }, )

प्रत्येक क्षेत्र के लिए, बेस प्रकार निर्दिष्ट किया जाता है, इस मामले में graphql.Int , graphql.String , graphql.Float ।
नेस्टेड फ़ील्ड की संख्या सीमित नहीं है, इसलिए आप किसी भी स्तर के ग्राफ सिस्टम को लागू कर सकते हैं।

उत्परिवर्तन (म्यूटेशन)

उत्परिवर्तन ये उत्परिवर्तनीय डेटा हैं, जिनमें शामिल हैं: जोड़, संपादन और विलोपन। अन्यथा, म्यूटेशन बहुत ही नियमित प्रश्नों के समान हैं: वे Args तर्क भी लेते हैं और क्वेरी के जवाब के रूप में Args डेटा वापस करते हैं।

आइए हमारे उत्पादों के लिए म्यूटेशन लिखें।

  var mutationType = graphql.NewObject(graphql.ObjectConfig{ Name: "Mutation", Fields: graphql.Fields{ /*    http://localhost:8080/product?query=mutation+_{create(name:"Tequila",info:"Alcohol",price:99){id,name,info,price}} */ "create": &graphql.Field{ Type: productType, Description: "Create new product", Args: graphql.FieldConfigArgument{ "name": &graphql.ArgumentConfig{ Type: graphql.NewNonNull(graphql.String), //     }, "info": &graphql.ArgumentConfig{ Type: graphql.String, //    }, "price": &graphql.ArgumentConfig{ Type: graphql.NewNonNull(graphql.Float), }, }, Resolve: func(params graphql.ResolveParams) (interface{}, error) { rand.Seed(time.Now().UnixNano()) product := Product{ ID: int64(rand.Intn(100000)), //   ID Name: params.Args["name"].(string), Info: params.Args["info"].(string), Price: params.Args["price"].(float64), } products = append(products, product) return product, nil }, }, /*    id http://localhost:8080/product?query=mutation+_{update(id:1,price:195){id,name,info,price}} */ "update": &graphql.Field{ Type: productType, Description: "Update product by id", Args: graphql.FieldConfigArgument{ "id": &graphql.ArgumentConfig{ Type: graphql.NewNonNull(graphql.Int), }, "name": &graphql.ArgumentConfig{ Type: graphql.String, }, "info": &graphql.ArgumentConfig{ Type: graphql.String, }, "price": &graphql.ArgumentConfig{ Type: graphql.Float, }, }, Resolve: func(params graphql.ResolveParams) (interface{}, error) { id, _ := params.Args["id"].(int) name, nameOk := params.Args["name"].(string) info, infoOk := params.Args["info"].(string) price, priceOk := params.Args["price"].(float64) product := Product{} for i, p := range products { //     if int64(id) == p.ID { if nameOk { products[i].Name = name } if infoOk { products[i].Info = info } if priceOk { products[i].Price = price } product = products[i] break } } return product, nil }, }, /*    id http://localhost:8080/product?query=mutation+_{delete(id:1){id,name,info,price}} */ "delete": &graphql.Field{ Type: productType, Description: "Delete product by id", Args: graphql.FieldConfigArgument{ "id": &graphql.ArgumentConfig{ Type: graphql.NewNonNull(graphql.Int), }, }, Resolve: func(params graphql.ResolveParams) (interface{}, error) { id, _ := params.Args["id"].(int) product := Product{} for i, p := range products { if int64(id) == p.ID { product = products[i] //     products = append(products[:i], products[i+1:]...) } } return product, nil }, }, }, })

सभी queryType । केवल एक छोटी सी विशेषता है, graphql.NewNonNull(graphql.Int) टाइप करें, जो हमें बताता है कि यह क्षेत्र खाली नहीं हो सकता (MySQL में NOT NULL समान NOT NULL )

वह सब है। अब हमारे पास सामानों के साथ काम करने के लिए एक सरल गो CRUD एपीआई है। हमने इस उदाहरण के लिए डेटाबेस का उपयोग नहीं किया, लेकिन हमने देखा कि डेटा मॉडल कैसे बनाया जाए और म्यूटेशन का उपयोग करके उनमें हेरफेर किया जाए।

उदाहरण

यदि आपने स्रोत को डाउनलोड किया है

 go get github.com/graphql-go/graphql

बस एक उदाहरण के साथ निर्देशिका में जाएं

 cd examples/crud

और एप्लिकेशन चलाएँ

 go run main.go

आप निम्नलिखित प्रश्नों का उपयोग कर सकते हैं:
आईडी द्वारा उत्पाद प्राप्त करना
http://localhost:8080/product?query={product(id:1){name,info,price}}

उत्पादों की एक सूची प्राप्त करना
http://localhost:8080/product?query={list{id,name,info,price}}

नया उत्पाद जोड़ें
http://localhost:8080/product?query=mutation+_{create(name:"Tequila",info:"Strong alcoholic beverage",price:999){id,name,info,price}}

उत्पाद संपादन
http://localhost:8080/product?query=mutation+_{update(id:1,price:195){id,name,info,price}}

आईडी द्वारा किसी उत्पाद को निकालना
http://localhost:8080/product?query=mutation+_{delete(id:1){id,name,info,price}}

यदि आप REST का उपयोग करते हैं, तो संभव विकल्प के रूप में GraphQL पर ध्यान दें। हां, पहली नज़र में यह अधिक कठिन लगता है, लेकिन यह शुरू करने लायक है और कुछ दिनों में आप इस तकनीक में महारत हासिल कर लेंगे। कम से कम यह उपयोगी होगा।

रेखांकन एपीआई (CRUD) गो पर