जनरेट किए गए 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 एक्सटेंशन में मौजूद, ऐप्लिकेशन में SDK जोड़ें बटन की मदद से
    • अपने को अपडेट करके 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 इंस्टेंस को शुरू करें. यह जानकारी, डेटाबेस और स्टोरेज > SQL Connect पेज Firebase कंसोल पर मिलेगी.

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

आपके कनेक्टर का कोड, 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")

बदलावों की सदस्यता लेना

से रीयल-टाइम अपडेट पाना लेख पढ़ें.SQL Connect

गिनती वाले फ़ील्ड में होने वाले बदलावों को मैनेज करना

किसी ऐप्लिकेशन के स्कीमा में गिनती वाले फ़ील्ड हो सकते हैं, जिन्हें आपकी 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