जनरेट किए गए iOS SDK टूल इस्तेमाल करना

Firebase SQL Connect क्लाइंट SDK टूल की मदद से, Firebase ऐप्लिकेशन से सीधे अपने सर्वर-साइड क्वेरी और म्यूटेशन कॉल किए जा सकते हैं. SQL Connect सेवा पर डिप्लॉय किए जाने वाले स्कीमा, क्वेरी, और म्यूटेशन डिज़ाइन करते समय, कस्टम क्लाइंट SDK टूल जनरेट किया जाता है.SQL Connect इसके बाद, इस SDK टूल के तरीकों को अपने क्लाइंट लॉजिक में इंटिग्रेट किया जाता है.

जैसा कि हमने कहीं और बताया है, यह ध्यान रखना ज़रूरी है कि SQL Connect क्वेरी और म्यूटेशन, क्लाइंट कोड से सबमिट नहीं किए जाते. इन्हें सर्वर पर एक्ज़ीक्यूट किया जाता है. इसके बजाय, डिप्लॉय किए जाने पर, SQL Connect ऑपरेशन सर्वर पर Cloud Functions की तरह सेव किए जाते हैं. इसका मतलब है कि आपको मौजूदा उपयोगकर्ताओं के लिए, क्लाइंट-साइड में किए गए बदलावों को डिप्लॉय करना होगा. ऐसा न करने पर, मौजूदा उपयोगकर्ताओं के लिए ऐप्लिकेशन काम नहीं करेगा. उदाहरण के लिए, ऐप्लिकेशन के पुराने वर्शन पर.

इसी वजह से, SQL Connect आपको डेवलपर एनवायरमेंट और टूलिंग उपलब्ध कराता है. इसकी मदद से, सर्वर पर डिप्लॉय किए गए स्कीमा, क्वेरी, और म्यूटेशन का प्रोटोटाइप बनाया जा सकता है. प्रोटोटाइप बनाते समय, यह क्लाइंट-साइड SDK टूल अपने-आप जनरेट करता है.

जब आपकी सेवा और क्लाइंट ऐप्लिकेशन के अपडेट को दोहराया जाता है, तब सर्वर और क्लाइंट-साइड, दोनों के अपडेट डिप्लॉय किए जा सकते हैं.

क्लाइंट डेवलपमेंट का वर्कफ़्लो क्या है?

शुरू करें लेख में, आपको के लिए डेवलपमेंट के पूरे फ़्लो के बारे में बताया गया था.SQL Connect इस गाइड में, आपको अपने स्कीमा से Swift SDK टूल जनरेट करने और क्लाइंट क्वेरी और म्यूटेशन के साथ काम करने के बारे में ज़्यादा जानकारी मिलेगी.

संक्षेप में, अपने क्लाइंट ऐप्लिकेशन में जनरेट किए गए Swift SDK टूल का इस्तेमाल करने के लिए, आपको ये ज़रूरी शर्तें पूरी करनी होंगी:

1. अपने iOS ऐप्लिकेशन में Firebase जोड़ें.

2. जनरेट किए गए SDK टूल का इस्तेमाल करने के लिए, इसे Xcode में डिपेंडेंसी के तौर पर कॉन्फ़िगर करें.

   Xcode के सबसे ऊपर मौजूद नेविगेशन बार में, फ़ाइल > पैकेज डिपेंडेंसी जोड़ें > लोकल जोड़ें को चुनें. इसके बाद, जनरेट किए गए Package.swift वाली फ़ोल्डर को चुनें.

इसके बाद:

1. अपने ऐप्लिकेशन का स्कीमा डेवलप करें.

2. एसडीके जनरेट करने की सुविधा सेट अप करें:

   • SQL Connect VS Code एक्सटेंशन में मौजूद ऐप्लिकेशन में एसडीके जोड़ें बटन की मदद से
   • अपने को अपडेट करके connector.yaml

3. अपने क्लाइंट कोड को शुरू करें और लाइब्रेरी इंपोर्ट करें.

4. क्वेरी और म्यूटेशन के लिए कॉल लागू करें.

5. सेट अप करें और SQL Connect एम्युलेटर का इस्तेमाल करें. साथ ही, इसे दोहराएं.

अपना Swift SDK टूल जनरेट करना

अपने ऐप्लिकेशन में, SQL Connect से जनरेट किए गए SDK टूल सेट अप करने के लिए, Firebase का इस्तेमाल करें. init कमांड को मौजूदा फ़ोल्डर में मौजूद सभी ऐप्लिकेशन का पता लगाना चाहिए. साथ ही, जनरेट किए गए SDK टूल को अपने-आप इंस्टॉल करना चाहिए.

firebase init dataconnect:sdk

प्रोटोटाइप बनाते समय, एसडीके अपडेट करना

अगर आपने SQL Connect VS Code एक्सटेंशन इंस्टॉल किया है, तो यह जनरेट किए गए SDK टूल को हमेशा अप-टू-डेट रखेगा.

अगर SQL Connect VS Code एक्सटेंशन का इस्तेमाल नहीं किया जाता है, तो जनरेट किए गए SDK टूल को अप-टू-डेट रखने के लिए, Firebase CLI का इस्तेमाल किया जा सकता है.

firebase dataconnect:sdk:generate --watch

बिल्ड पाइपलाइन में एसडीके जनरेट करना

CI/CD बिल्ड प्रोसेस में, SQL Connect SDK टूल जनरेट करने के लिए, Firebase CLI का इस्तेमाल किया जा सकता है.

firebase dataconnect:sdk:generate

SQL Connect iOS SDK टूल शुरू करना

अपने SQL Connect इंस्टेंस को शुरू करने के लिए, उस जानकारी का इस्तेमाल करें जिसका इस्तेमाल आपने SQL Connect सेट अप करने के लिए किया था. यह जानकारी, Firebase कंसोल के SQL Connect टैब में उपलब्ध है.

कनेक्टर का इंस्टेंस पाना

आपके कनेक्टर का कोड, SQL Connect एम्युलेटर से जनरेट किया जाएगा. अगर आपके कनेक्टर का नाम movies है और पैकेज movies है, जैसा कि connector.yaml में बताया गया है, तो कनेक्टर ऑब्जेक्ट को इस कॉल से वापस पाएं:

let connector = DataConnect.moviesConnector

क्वेरी और म्यूटेशन लागू करना

कनेक्टर ऑब्जेक्ट की मदद से, GraphQL सोर्स कोड में तय की गई क्वेरी और म्यूटेशन चलाए जा सकते हैं. मान लें कि आपके कनेक्टर में ये ऑपरेशन तय किए गए हैं:

mutation createMovie($title: String!, $releaseYear: Int!, $genre: String!, $rating: Int!) {
  movie_insert(data: {
    title: $title
    releaseYear: $releaseYear
    genre: $genre
    rating: $rating
  })
}

query getMovieByKey($key: Movie_Key!) {
  movie(key: $key) { id title }
}

query listMoviesByGenre($genre: String!) {
  movies(where: {genre: {eq: $genre}}) {
    id
    title
  }
}

इसके बाद, इस तरह से कोई मूवी बनाई जा सकती है:

let mutationResult = try await connector.createMovieMutation.execute(
  title: "Empire Strikes Back",
  releaseYear: 1980,
  genre: "Sci-Fi",
  rating: 5)

print("Movie ID: \(mutationResult.data.movie_insert.id)")

किसी मूवी को वापस पाने के लिए, क्वेरी रेफ़रंस का इस्तेमाल किया जाएगा. क्वेरी रेफ़रंस, Observable पब्लिशर होते हैं. कॉन्फ़िगर किए गए पब्लिशर के आधार पर (देखें connector.yaml), वे या तो @Observable मैक्रो (iOS 17+) के साथ काम करते हैं या ObservableObject प्रोटोकॉल लागू करते हैं. अगर कोई पब्लिशर तय नहीं किया गया है, तो डिफ़ॉल्ट तौर पर, iOS 17+ पर काम करने वाला @Observable मैक्रो इस्तेमाल किया जाता है.

SwiftUI व्यू में, क्वेरी रेफ़रंस के पब्लिश किए गए data वैरिएबल का इस्तेमाल करके, क्वेरी के नतीजों को बाइंड किया जा सकता है. साथ ही, डेटा अपडेट करने के लिए, क्वेरी के execute() तरीके को कॉल किया जा सकता है. data वैरिएबल, आपके GQL क्वेरी की परिभाषा में तय किए गए डेटा के आकार से मेल खाएगा.

वापस पाए गए सभी नतीजे, Decodable प्रोटोकॉल के मुताबिक होते हैं. अगर आपने अपने GQL फ़ेच में ऑब्जेक्ट की प्राइमरी कुंजी शामिल की है, तो ऑब्जेक्ट Identifiable भी होते हैं. इससे, उन्हें इटरेटर में इस्तेमाल किया जा सकता है.

struct ListMovieView: View {
    @StateObject private var queryRef = connector.listMoviesByGenreQuery.ref(genre: "Sci-Fi")
    var body: some View {
        VStack {
            Button {
                Task {
                    do {
                        try await refresh()
                    } catch {
                        print("Failed to refresh: \(error)")
                    }
                }
            } label: {
                Text("Refresh")
            }
                // use the query results in a view
            ForEach(queryRef.data?.movies ?? [], id: \.self.id) { movie in
                    Text(movie.title)
                }
            }
    }
    @MainActor
    func refresh() async throws {
        _ = try await queryRef.execute()
    }
}

क्वेरी को एक बार में भी एक्ज़ीक्यूट किया जा सकता है.

let resultData = try await DataConnect.moviesConnector.listMoviesByGenreQuery.execute(genre: "Sci-Fi")

इन्यूमरेट किए गए फ़ील्ड में किए गए बदलावों को मैनेज करना

किसी ऐप्लिकेशन के स्कीमा में इन्यूमरेशन शामिल हो सकते हैं. इन्हें आपकी GraphQL क्वेरी से ऐक्सेस किया जा सकता है.

ऐप्लिकेशन के डिज़ाइन में बदलाव होने पर, इन्यूमरेट किए गए नए वैल्यू जोड़ी जा सकती हैं. उदाहरण के लिए, मान लें कि ऐप्लिकेशन के लाइफ़साइकल में बाद में, आपने AspectRatio इन्यूमरेट किए गए फ़ील्ड में FULLSCREEN वैल्यू जोड़ने का फ़ैसला लिया.

SQL Connect वर्कफ़्लो में, क्वेरी और SDK टूल अपडेट करने के लिए, लोकल डेवलपमेंट टूलिंग का इस्तेमाल किया जा सकता है.

हालांकि, अपने क्लाइंट का अपडेट किया गया वर्शन रिलीज़ करने से पहले, डिप्लॉय किए गए पुराने क्लाइंट काम करना बंद कर सकते हैं.

लचीले तरीके से लागू करने का उदाहरण

जनरेट किए गए SDK टूल की मदद से, अज्ञात वैल्यू को मैनेज किया जा सकता है. इसकी वजह यह है कि जनरेट किए गए इन्यूमरेट किए गए फ़ील्ड में _UNKNOWN वैल्यू होती है. साथ ही, Swift, स्विच स्टेटमेंट को पूरी तरह से लागू करता है.

do {
    let result = try await DataConnect.moviesConnector.listMovies.execute()
    if let data = result.data {
        for movie in data.movies {
            switch movie.aspectratio {
                case .ACADEMY: print("academy")
                case .WIDESCREEN: print("widescreen")
                case .ANAMORPHIC: print("anamorphic")
                case ._UNKNOWN(let unknownAspect): print(unknownAspect)
            }
        }
    }
} catch {
    // handle error
}

क्लाइंट-साइड कैशिंग की सुविधा चालू करना

SQL Connect में, क्लाइंट-साइड कैशिंग की सुविधा उपलब्ध है. इसे connector.yaml फ़ाइल में बदलाव करके चालू किया जा सकता है. यह सुविधा चालू होने पर, जनरेट किए गए क्लाइंट SDK टूल, क्वेरी के जवाबों को स्थानीय तौर पर कैश करेंगे. इससे, आपके ऐप्लिकेशन के डेटाबेस के अनुरोधों की संख्या कम हो सकती है. साथ ही, नेटवर्क की उपलब्धता में रुकावट आने पर, आपके ऐप्लिकेशन के डेटाबेस पर निर्भर हिस्से काम कर सकते हैं.

क्लाइंट-साइड कैशिंग की सुविधा चालू करने के लिए, अपने कनेक्टर कॉन्फ़िगरेशन में क्लाइंट कैशिंग कॉन्फ़िगरेशन जोड़ें:

generate:
  swiftSdk:
    outputDir: "../ios"
    package: "FirebaseDataConnectGenerated"
    clientCache:
      maxAge: 5s
      storage: persistent

इस कॉन्फ़िगरेशन में दो पैरामीटर होते हैं. दोनों पैरामीटर ज़रूरी नहीं हैं:

• maxAge: कैश किए गए जवाब की ज़्यादा से ज़्यादा उम्र. इसके बाद, क्लाइंट SDK टूल नई वैल्यू फ़ेच करता है. उदाहरण: "0", "30s", "1h30m".

  maxAge की डिफ़ॉल्ट वैल्यू 0 होती है. इसका मतलब है कि जवाब कैश किए जाते हैं, लेकिन क्लाइंट SDK टूल हमेशा नई वैल्यू फ़ेच करेगा. कैश की गई वैल्यू का इस्तेमाल सिर्फ़ तब किया जाएगा, जब execute() के लिए CACHE_ONLY तय किया गया हो.

• storage: क्लाइंट SDK टूल को persistent स्टोरेज या memory में जवाब कैश करने के लिए कॉन्फ़िगर किया जा सकता है. persistent स्टोरेज में कैश किए गए नतीजे, ऐप्लिकेशन को रीस्टार्ट करने पर भी बने रहेंगे. iOS SDK टूल में, डिफ़ॉल्ट तौर पर persistent स्टोरेज इस्तेमाल किया जाता है.

अपने कनेक्टर के कैशिंग कॉन्फ़िगरेशन को अपडेट करने के बाद, अपने क्लाइंट SDK टूल को फिर से जनरेट करें और अपने ऐप्लिकेशन को फिर से बनाएं. ऐसा करने के बाद, execute() जवाबों को कैश करेगा और आपके कॉन्फ़िगर की गई नीति के मुताबिक, कैश की गई वैल्यू का इस्तेमाल करेगा. आम तौर पर, यह प्रोसेस अपने-आप होती है. इसके लिए, आपको कोई और कार्रवाई करने की ज़रूरत नहीं होती. हालांकि, इन बातों का ध्यान रखें:

• execute() का डिफ़ॉल्ट व्यवहार ऊपर बताया गया है: अगर किसी क्वेरी के लिए कोई नतीजा कैश किया जाता है और कैश की गई वैल्यू, maxAge से पुरानी नहीं है, तो कैश की गई वैल्यू का इस्तेमाल करें. इस डिफ़ॉल्ट व्यवहार को PREFER_CACHE नीति कहा जाता है.

  execute() के अलग-अलग कॉल के लिए, यह भी तय किया जा सकता है कि सिर्फ़ कैश की गई वैल्यू (CACHE_ONLY) दिखाई जाएं या सर्वर से बिना किसी शर्त के नई वैल्यू (SERVER_ONLY) फ़ेच की जाएं.

  try await execute(fetchPolicy: .cacheOnly)
  

  try await execute(fetchPolicy: .serverOnly)
  

  अपने iOS ऐप्लिकेशन का प्रोटोटाइप बनाना और उसकी जांच करना

  स्थानीय एम्युलेटर का इस्तेमाल करने के लिए, क्लाइंट को इंस्ट्रूमेंट करना

  आप SQL Connect एम्युलेटर का इस्तेमाल, SQL Connect VS Code एक्सटेंशन या CLI से कर सकते हैं.

  दोनों स्थितियों में, ऐप्लिकेशन को एम्युलेटर से कनेक्ट करने के लिए इंस्ट्रूमेंट करने का तरीका एक ही है.

  let connector = DataConnect.moviesConnector
  // Connect to the emulator on "127.0.0.1:9399"
  connector.useEmulator()
  
  // (alternatively) if you're running your emulator on non-default port:
  connector.useEmulator(port: 9999)
  
  // Make calls from your app
  

  SDK टूल में डेटा के टाइपSQL Connect

  SQL Connect सर्वर, सामान्य और कस्टम GraphQL डेटा टाइप दिखाता है. इन्हें SDK टूल में इस तरह दिखाया जाता है.

  SQL Connect टाइप	Swift
  स्ट्रिंग	स्ट्रिंग
  Int	Int
  फ़्लोट	डबल-साइज़ बेड
  बूलियन	बूल
  यूयूआईडी	यूयूआईडी
  तारीख	FirebaseDataConnect.LocalDate
  टाइमस्टैम्प	FirebaseCore.Timestamp
  Int64	Int64
  कोई भी	FirebaseDataConnect.AnyValue