कोड जनरेशन

1. ent टूल की स्थापना

ent कोड जेनरेशन टूल को स्थापित करने के लिए, निम्नलिखित चरणों का पालन करना होगा:

सबसे पहले, सुनिश्चित करें कि आपके सिस्टम में Go भाषा वातानुकूलन स्थापित है। फिर, निम्नलिखित कमांड को चलाकर ent टूल प्राप्त करें:

go get -d entgo.io/ent/cmd/ent

यह कमांड ent टूल के लिए कोड डाउनलोड करेगा, लेकिन इसे कंपाइल और स्थापित नहीं करेगा। यदि आप चाहते हैं कि आप ent को कहीं भी उपयोग कर सकें, तो आपको निम्नलिखित कमांड को भी चलाना होगा जिससे आप ent को $GOPATH/bin निर्देशिका में स्थापित कर सकें:

go install entgo.io/ent/cmd/ent

स्थापना पूरी होने के बाद, आप यह जांच सकते हैं कि क्या ent टूल सही ढंग से स्थापित हुआ है और ent -h चलाकर उपलब्ध कमांड और निर्देश देख सकते हैं।

2. स्कीमा की आरंभिकीकरण

2.1 ent init का उपयोग करके टेम्पलेट का आरंभिकीकरण

नए स्कीमा फ़ाइल बनाना ent कोड जेनरेशन का उपयोग करने का पहला कदम है। आप निम्नलिखित कमांड को चला कर स्कीमा टेम्पलेट का आरंभ कर सकते हैं:

go run -mod=mod entgo.io/ent/cmd/ent new User Pet

यह कमांड दो नई स्कीमा फ़ाइलें बनाएगा: user.go और pet.go, और उन्हें ent/schema निर्देशिका में रखेगा। यदि ent निर्देशिका मौजूद नहीं है, तो यह कमांड स्वचालित रूप से निर्मित करेगा।

उपरोक्त कमांड को प्रोजेक्ट के मूल निर्देशिका में चलाना एक अच्छी प्रथा है, क्योंकि यह प्रोजेक्ट निर्देशिका की संरचना और स्पष्टता को बनाए रखने में मदद करता है।

2.2 स्कीमा फ़ाइल संरचना

ent/schema निर्देशिका में, प्रत्येक स्कीमा एक गो भाषा स्रोत फ़ाइल से मेल खाती है। स्कीमा फ़ाइलें वहाँ हैं जहां आप डेटाबेस मॉडल को, फ़ील्ड और एज़ (संबंध) समेत, परिभाषित करते हैं।

उदाहरण के लिए, user.go फ़ाइल में, आप एक उपयोगकर्ता मॉडल परिभाषित कर सकते हैं, जिसमें उपयोगकर्ता का नाम और आयु जैसी फ़ील्ड्स हो सकती हैं, और उपयोगकर्ताओं और पालतू जानवरों के बीच संबंध को परिभाषित कर सकते हैं। उसी तरह, pet.go फ़ाइल में, आप पालतू जानवर का मॉडल परिभाषित कर सकते हैं और उसके संबंधित फील्ड्स, जैसे जानवर का नाम, प्रकार, और पालतू जानवरों और उपयोगकर्ताओं के बीच संबंध परिभाषित कर सकते हैं।

ये फ़ाइलें अंततः ent टूल द्वारा जनरेट किए गए गो कोड के लिए इस्तेमाल होंगी, जिसमें डेटाबेस के परिचालन और CRUD (सिरजना, पढ़ना, अपडेट, मिटाना) के लिए क्लाइंट कोड शामिल होगा।

// ent/schema/user.go
package schema

import (
    "entgo.io/ent"
    "entgo.io/ent/schema/field"
)

// User उपकरण के लिए यूजर एंटिटी के स्कीमा को परिभाषित करता है।
type User struct {
    ent.Schema
}

// Fields विधि का उपयोग एंटिटी के फ़ील्ड्स को निर्धारित करने के लिए होता है।
func (User) Fields() []ent.Field {
    return []ent.Field{
        field.String("name").Unique(),
        field.Int("age").Positive(),
    }
}

// Edges विधि का उपयोग एंटिटी के संबंधों को निर्धारित करने के लिए होता है।
func (User) Edges() []ent.Edge {
    // संबंधों की विस्तारित जानकारी अगले खंड में समझाई जाएगी।
}

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

3.1 कोड जनरेशन चलाना

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

go generate ./ent

उपरोक्त कमांड को प्रोजेक्ट के मूल निर्देशिका में चलाना चाहिए। go generate कोल करने पर, वह विशिस्ट एनोटेशन्स शामिल कर गो फ़ाइलें खोजेगा और एनोटेशन्स में निर्दिष्ट निर्देश को निष्पादित करेगा। हमारे उदाहरण में, इस कमांड को ent के लिए कोड जेनरेटर को निर्दिष्ट करता है।

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

3.2 उत्पन्न कोड संसाधनों को समझना

उत्पन्न कोड संसाधनों में कई घटक होते हैं, प्रत्येक में विभिन्न कार्य होते हैं:

• **ग्राहक और टीएक्स ऑब्ज

6.2 entc की विस्तृत विन्यासन

entc विकेन्द्रीकरण विकल्पों को उपलब्ध कराता है, जो डेवलपर्स को उत्पन्न कोड को अनुकूलित करने की अनुमति देता है। उदाहरण के रूप में, कस्टम हुक्स को कॉन्फ़िगर/निर्धारित किया जा सकता है ताकि उत्पन्न कोड की जांच या संशोधन किया जा सके, और विदेशी आवश्यकताओं का उपयोग डिपेंडेंसी इंजेक्शन का उपयोग करके किया जा सकता है।

निम्नलिखित उदाहरण में दिखाया गया है कि entc.Generate फ़ंक्शन के लिए कस्टम हुक्स कैसे प्रदान किए जाएं:

func main() {
    err := entc.Generate("./schema", &gen.Config{
        Hooks: []gen.Hook{
            HookFunction,
        },
    })
    if err != nil {
        log.Fatalf("ent कोड और जेनेरेट करना: %v", err)
    }
}

// HookFunction एक कस्टम हुक फ़ंक्शन है
func HookFunction(next gen.Generator) gen.Generator {
    return gen.GenerateFunc(func(g *gen.Graph) error {
        // यहां g द्वारा प्रतिनिधित ग्राफ मोडल को संभाल सकते हैं
        // उदाहरण के लिए, फ़ील्ड की मौजूदगी का सत्यापन करें या संरचना में परिवर्तन करें
        return next.Generate(g)
    })
}

इसके अलावा, entc.Dependency का उपयोग करके विदेशी आवश्यकताएँ जोड़ी जा सकती हैं:

func main() {
    opts := []entc.Option{
        entc.Dependency(
            entc.DependencyType(&http.Client{}),
        ),
        entc.Dependency(
            entc.DependencyName("Writer"),
            entc.DependencyTypeInfo(&field.TypeInfo{
                Ident:   "io.Writer",
                PkgPath: "io",
            }),
        ),
    }
    if err := entc.Generate("./schema", &gen.Config{}, opts...); err != nil {
        log.Fatalf("ent कोड और जेनेट करना: %v", err)
    }
}

इस उदाहरण में, हम http.Client और io.Writer को उत्पन्न किए गए क्लाइंट ऑब्जेक्ट्स में आधारभूत आवश्यकताओं के रूप में इंजेक्ट करते हैं।

7. स्कीमा विवरण का आउटपुट

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

निम्नलिखित कमांड को निष्पादित करने के लिए निम्नलिखित कमांड को आउटपुट द्वारा प्राप्त करें:

go run -mod=mod entgo.io/ent/cmd/ent describe ./ent/schema

उपरोक्त कमांड एक सारणी का आउटपुट करेगा, जिसमें विभिन्न एंटिटियों के क्षेत्र, प्रकार, संबंध आदि की जानकारी दी जा सकती है।

8. कोड जेनरेशन हुक्स

8.1 हुक्स की अवधारणा

हुक्स मिडलवेयर फ़ंक्शन होते हैं जो ent कोड जेनरेशन प्रक्रिया में ज़रिए जा सकते हैं, जो निर्माण करने और उत्पन्न कोड के पहले और बाद में कस्टम तरीके से डाला जा सकता है। हुक्स का उपयोग उत्पन्न कोड की असली वाक्य पृथकरण पेड़ (AST) को मोडिफाई करने, सत्यापन करने या अतिरिक्त कोड स्निपेट्स जोड़ने के लिए किया जा सकता है।

8.2 हुक्स का उपयोग करने का उदाहरण

यहां एक उदाहरण हुक्स का है जिसका उपयोग करने के लिए एक हुक को सुनिश्चित करने के लिए किया जाता है कि सभी फ़ील्ड में किसी निर्दिष्ट संरचना टैग (जैसे json) हो:

func main() {
    err := entc.Generate("./schema", &gen.Config{
        Hooks: []gen.Hook{
            EnsureStructTag("json"),
        },
    })
    if err != nil {
        log.Fatalf("ent कोड और जेनरेट करना: %v", err)
    }
}

// EnsureStructTag सुनिश्चित करता है कि ग्राफ में सभी फ़ील्ड आवश्यक संरचना टैग को शामिल किया गया है
func EnsureStructTag(name string) gen.Hook {
    return func(next gen.Generator) gen.Generator {
        return gen.GenerateFunc(func(g *gen.Graph) error {
            for _, node := range g.Nodes {
                for _, field := range node.Fields {
                    tag := reflect.StructTag(field.StructTag)
                    if _, ok := tag.Lookup(name); !ok {
                        return fmt.Errorf("क्षेत्र %s.%s के लिए स्ट्रक्चर टैग %q अनुपस्थित है", node.Name, field.Name, name)
                    }
                }
            }
            return next.Generate(g)
        })
    }
}

इस उदाहारण में, कोड जेनरेट करने से पहले, EnsureStructTag फ़ंक्शन हर फ़ील्ड के लिए json टैग की जाँच करता है। अगर किसी फ़ील्ड में यह टैग अनुपस्थित है, तो कोड जेनरेशन विफल हो जाएगा और एक त्रुटि लौटाएगा। यह कोड साफ़ई और संरचना को संबोधित करने का एक प्रभावी तरीका है।