डेटा वापस लाया जा रहा है

GET अनुरोध के ज़रिए डेटा पढ़ना

हम अपने Firebase डेटाबेस से डेटा पढ़ सकते हैं. इसके लिए, हमें उसके यूआरएल एंडपॉइंट पर GET अनुरोध भेजना होगा. आइए, पिछले सेक्शन में दिए गए ब्लॉग के उदाहरण को आगे बढ़ाते हैं और अपने ब्लॉग पोस्ट का सारा डेटा पढ़ते हैं: 

curl 'https://docs-examples.firebaseio.com/fireblog/posts.json?print=pretty'

अनुरोध पूरा होने पर, 200 OK एचटीटीपी स्टेटस कोड दिखेगा. साथ ही, रिस्पॉन्स में वह डेटा दिखेगा जिसे हम वापस पा रहे हैं.

यूआरआई पैरामीटर जोड़ना

REST API, हमारे Firebase डेटाबेस से डेटा पढ़ते समय, कई क्वेरी पैरामीटर स्वीकार करता है. यहां सबसे ज़्यादा इस्तेमाल किए जाने वाले पैरामीटर दिए गए हैं. पूरी सूची देखने के लिए, REST API का रेफ़रंस देखें.

auth

auth अनुरोध पैरामीटर की मदद से, Firebase Realtime Database Security Rules के सुरक्षा नियमों से सुरक्षित डेटा को ऐक्सेस किया जा सकता है. यह सभी तरह के अनुरोधों के साथ काम करता है. आर्ग्युमेंट के तौर पर, Firebase प्रोजेक्ट में उपयोगकर्ताओं के बारे में बताए गए तरीके से, Firebase ऐप्लिकेशन का सीक्रेट या एक पुष्टि करने वाला टोकन इस्तेमाल किया जा सकता है. यहां दिए गए उदाहरण में, हम GET अनुरोध भेज रहे हैं. इसमें auth पैरामीटर के तौर पर, CREDENTIAL के तौर पर, Firebase ऐप्लिकेशन का सीक्रेट या पुष्टि करने वाला टोकन इस्तेमाल किया गया है: 

curl 'https://docs-examples.firebaseio.com/auth-example.json?auth=CREDENTIAL'

print

print=pretty तय करने पर, डेटा को ऐसे फ़ॉर्मैट में दिखाया जाता है जिसे कोई भी व्यक्ति आसानी से पढ़ सकता है. 

curl 'https://docs-examples.firebaseio.com/fireblog/posts.json?print=pretty'

print=silent तय करने पर, अनुरोध पूरा होने पर 204 No Content दिखता है. 

curl 'https://docs-examples.firebaseio.com/fireblog/posts.json?print=silent'

callback

अलग-अलग डोमेन के वेब ब्राउज़र से REST कॉल करने के लिए, JSONP का इस्तेमाल किया जा सकता है. इससे रिस्पॉन्स को JavaScript कॉलबैक फ़ंक्शन में रैप किया जा सकता है. REST API से, दिखाए गए डेटा को आपके तय किए गए कॉलबैक फ़ंक्शन में रैप कराने के लिए, callback= जोड़ें. उदाहरण के लिए: 

<script>
  function gotData(data) {
    console.log(data);
  }
</script>
<script src="https://docs-examples.firebaseio.com/fireblog/posts.json?callback=gotData">

shallow

यह एक ऐडवांस सुविधा है. इसे बड़े डेटासेट के साथ काम करने में आपकी मदद करने के लिए डिज़ाइन किया गया है. इसके लिए, आपको सारा डेटा डाउनलोड करने की ज़रूरत नहीं होती . इसका इस्तेमाल करने के लिए, shallow=true को पैरामीटर के तौर पर जोड़ें. इससे, दिखाए गए डेटा की डेप्थ सीमित हो जाएगी. अगर उस जगह पर मौजूद डेटा, JSON प्रिमिटिव (स्ट्रिंग, नंबर, या बूलियन) है, तो उसकी वैल्यू सीधे तौर पर दिखाई जाएगी. अगर उस जगह पर मौजूद डेटा स्नैपशॉट, JSON ऑब्जेक्ट है, तो हर कुंजी की वैल्यू को true पर ट्रंकेट कर दिया जाएगा. उदाहरण के लिए, यहां दिए गए डेटा का इस्तेमाल करें: 

{
  "message": {
    "user": {
      "name": "Chris"
    },
    "body": "Hello!"
  }
}

// A request to /message.json?shallow=true
// would return the following:
{
  "user": true,
  "body": true
}

// A request to /message/body.json?shallow=true
// would simply return:
"Hello!"

curl के इस अनुरोध के साथ इसे आज़माएं: 

curl 'https://docs-examples.firebaseio.com/rest/retrieving-data.json?shallow=true&print=pretty'

timeout

इसका इस्तेमाल करके, सर्वर साइड पर डेटा पढ़ने में लगने वाले समय की सीमा तय की जा सकती है. अगर कोई डेटा पढ़ने का अनुरोध, तय समय में पूरा नहीं होता है, तो वह एचटीटीपी 400 गड़बड़ी के साथ खत्म हो जाता है. यह खास तौर पर तब काम आता है, जब आपको डेटा का छोटा ट्रांसफ़र करना हो और आपको संभावित तौर पर बड़े सबट्री को फ़ेच करने के लिए ज़्यादा इंतज़ार न करना पड़े. डेटा पढ़ने में लगने वाला असल समय, डेटा के साइज़ और कैशिंग के आधार पर अलग-अलग हो सकता है.

timeouts को इस फ़ॉर्मैट में तय करें: 3ms, 3s या 3min. इसमें एक नंबर और एक यूनिट होनी चाहिए. अगर इसे तय नहीं किया जाता है, तो ज़्यादा से ज़्यादा timeout का 15min लागू किया जाएगा. अगर timeout पॉज़िटिव नहीं है या यह ज़्यादा से ज़्यादा समय से ज़्यादा है, तो अनुरोध को एचटीटीपी 400 गड़बड़ी के साथ अस्वीकार कर दिया जाएगा. यहां दिए गए उदाहरण में, GET अनुरोध में 10 सेकंड का timeout शामिल है. 

curl 'https://docs-examples.firebaseio.com/rest/retrieving-data.json?timeout=10s'

डेटा फ़िल्टर करना

हम अलग-अलग फ़ैक्टर के आधार पर डेटा फ़िल्टर करने के लिए, क्वेरी बना सकते हैं. शुरू करने के लिए, आपको यह तय करना होगा कि orderBy पैरामीटर का इस्तेमाल करके, डेटा को कैसे फ़िल्टर करना है. इसके बाद, orderBy को इन पांच पैरामीटर में से किसी एक के साथ मिलाएं: limitToFirst, limitToLast, startAt, endAt, और equalTo.

Firebase में हम सभी को डायनासोर बहुत पसंद हैं. इसलिए, हम आपको यह दिखाने के लिए, डायनासोर के बारे में जानकारी वाले सैंपल डेटाबेस का स्निपेट इस्तेमाल करेंगे कि डेटा को कैसे फ़िल्टर किया जा सकता है: 

{
  "lambeosaurus": {
    "height": 2.1,
    "length": 12.5,
    "weight": 5000
  },
  "stegosaurus": {
    "height": 4,
    "length": 9,
    "weight": 2500
  }
}

हम डेटा को तीन तरीकों से फ़िल्टर कर सकते हैं: चाइल्ड की, की या वैल्यू के हिसाब से. कोई क्वेरी, इनमें से किसी एक पैरामीटर से शुरू होती है. इसके बाद, उसे इन पैरामीटर में से एक या ज़्यादा के साथ जोड़ा जाना चाहिए: startAt, endAt, limitToFirst, limitToLast या equalTo.

तय की गई चाइल्ड की के हिसाब से फ़िल्टर करना

हम `orderBy` पैरामीटर में वह की पास करके, नोड को एक जैसी चाइल्ड की के हिसाब से फ़िल्टर कर सकते हैं.orderBy उदाहरण के लिए, तीन मीटर से ज़्यादा ऊंचाई वाले सभी डायनासोर को वापस पाने के लिए, हम यह कर सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"&startAt=3&print=pretty'

जिस नोड में वह चाइल्ड की नहीं है जिसके हिसाब से हम फ़िल्टर कर रहे हैं उसे null वैल्यू के साथ क्रम से लगाया जाएगा. डेटा को क्रम से लगाने के तरीके के बारे में जानने के लिए, डेटा को क्रम से कैसे लगाया जाता है लेख पढ़ें.

Firebase, सिर्फ़ एक लेवल नीचे मौजूद चाइल्ड के बजाय, गहराई से नेस्ट किए गए चाइल्ड के हिसाब से क्रम से लगाई गई क्वेरी भी स्वीकार करता है. यह तब काम आता है, जब आपके पास इस तरह का गहराई से नेस्ट किया गया डेटा हो: 

{
  "lambeosaurus": {
    "dimensions": {
      "height" : 2.1,
      "length" : 12.5,
      "weight": 5000
    }
  },
  "stegosaurus": {
    "dimensions": {
      "height" : 4,
      "length" : 9,
      "weight" : 2500
    }
  }
}

अब ऊंचाई के बारे में क्वेरी करने के लिए, हम एक की के बजाय ऑब्जेक्ट का पूरा पाथ इस्तेमाल करते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="dimensions/height"&startAt=3&print=pretty'

क्वेरी, एक बार में सिर्फ़ एक की के हिसाब से फ़िल्टर की जा सकती हैं. एक ही अनुरोध पर orderBy पैरामीटर का कई बार इस्तेमाल करने पर, गड़बड़ी होती है.

की के हिसाब से फ़िल्टर करना

हम orderBy="$key" पैरामीटर का इस्तेमाल करके, नोड को उनकी की के हिसाब से भी फ़िल्टर कर सकते हैं. यहां दिए गए उदाहरण में, a से m अक्षर से शुरू होने वाले नाम वाले सभी डायनासोर को वापस पाया जाता है: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="$key"&startAt="a"&endAt="m"&print=pretty'

वैल्यू के हिसाब से फ़िल्टर करना

हम नोड को उनकी चाइल्ड की की वैल्यू के हिसाब से फ़िल्टर कर सकते हैं. इसके लिए, हम orderBy="$value" पैरामीटर का इस्तेमाल कर सकते हैं. मान लें कि डायनासोर के बीच, डायनो स्पोर्ट्स की प्रतियोगिता हो रही है और हम उनके स्कोर को इस फ़ॉर्मैट में ट्रैक कर रहे हैं: 

{
  "scores": {
    "bruhathkayosaurus": 55,
    "lambeosaurus": 21,
    "linhenykus": 80,
    "pterodactyl": 93,
    "stegosaurus": 5,
    "triceratops": 22
  }
}

50 से ज़्यादा स्कोर वाले सभी डायनासोर को वापस पाने के लिए, हम यह अनुरोध कर सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/scores.json?orderBy="$value"&startAt=50&print=pretty'

`orderBy="$value"` का इस्तेमाल करने पर, `null`, बूलियन, स्ट्रिंग, और ऑब्जेक्ट वैल्यू को क्रम से कैसे लगाया जाता है, यह जानने के लिए डेटा को क्रम से कैसे लगाया जाता है लेख पढ़ें.

मुश्किल फ़िल्टरिंग

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

सीमा तय करने वाली क्वेरी

limitToFirst और limitToLast पैरामीटर का इस्तेमाल करके, चाइल्ड की ज़्यादा से ज़्यादा संख्या तय की जा सकती है. इसके लिए, डेटा वापस पाया जा सकता है. अगर हम 100 की सीमा तय करते हैं, तो हमें सिर्फ़ 100 मैचिंग चाइल्ड मिलेंगे. अगर हमारे डेटाबेस में 100 से कम मैसेज सेव हैं, तो हमें हर चाइल्ड मिलेगा. हालांकि, अगर हमारे पास 100 से ज़्यादा मैसेज हैं, तो हमें सिर्फ़ 100 मैसेज का डेटा मिलेगा. अगर हम limitToFirst का इस्तेमाल कर रहे हैं, तो क्रम से लगाए गए पहले 100 मैसेज मिलेंगे. वहीं, अगर हम limitToLast का इस्तेमाल कर रहे हैं, तो क्रम से लगाए गए आखिरी 100 मैसेज मिलेंगे.

डायनासोर के बारे में जानकारी वाले डेटाबेस और orderBy का इस्तेमाल करके, हम दो सबसे भारी डायनासोर ढूंढ सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="weight"&limitToLast=2&print=pretty'

इसी तरह, limitToFirst का इस्तेमाल करके, हम दो सबसे छोटे डायनासोर ढूंढ सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"&limitToFirst=2&print=pretty'

हम orderBy="$value" के साथ भी सीमा तय करने वाली क्वेरी कर सकते हैं. अगर हमें डायनो स्पोर्ट्स के सबसे ज़्यादा स्कोर वाले तीन प्रतिस्पर्धियों के साथ लीडरबोर्ड बनाना है, तो हम यह कर सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/scores.json?orderBy="$value"&limitToLast=3&print=pretty'

रेंज क्वेरी

startAt, endAt, और equalTo का इस्तेमाल करके, हम अपनी क्वेरी के लिए शुरुआती और आखिरी पॉइंट तय कर सकते हैं. उदाहरण के लिए, अगर हमें तीन मीटर से ज़्यादा ऊंचाई वाले सभी डायनासोर ढूंढने हैं, तो हम orderBy और startAt को मिला सकते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="height"&startAt=3&print=pretty'

हम endAt का इस्तेमाल करके, उन सभी डायनासोर को ढूंढ सकते हैं जिनके नाम, लेक्सिकोग्राफ़िक तरीके से टेरोडैक्टाइल से पहले आते हैं: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="$key"&endAt="pterodactyl"&print=pretty'

हम startAt और endAt को मिलाकर, अपनी क्वेरी के दोनों एंडपॉइंट की सीमा तय कर सकते हैं. यहां दिए गए उदाहरण में, "b" अक्षर से शुरू होने वाले नाम वाले सभी डायनासोर को ढूंढा जाता है: 

curl 'https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy="$key"&startAt="b"&endAt="b\uf8ff"&print=pretty'

रेंज क्वेरी तब भी काम आती हैं, जब आपको अपने डेटा को पेजिनेट करना हो.

जानकारी को एक जगह इकट्ठा किया जा रहा है

हम इन सभी तकनीकों को मिलाकर, मुश्किल क्वेरी बना सकते हैं. उदाहरण के लिए, हो सकता है कि आपको उन सभी डायनासोर के नाम ढूंढने हों जिनकी ऊंचाई, हमारे पसंदीदा डायनासोर, स्टेगोसॉरस की ऊंचाई से कम या उसके बराबर हो: 

MY_FAV_DINO_HEIGHT=`curl "https://dinosaur-facts.firebaseio.com/dinosaurs/stegosaurus/height.json"`
curl "https://dinosaur-facts.firebaseio.com/dinosaurs.json?orderBy=\"height\"&endAt=${MY_FAV_DINO_HEIGHT}&print=pretty"

डेटा को क्रम से कैसे लगाया जाता है

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

orderBy

चाइल्ड की के नाम के साथ orderBy का इस्तेमाल करने पर, तय की गई चाइल्ड की वाला डेटा इस तरह क्रम से लगाया जाएगा:

  1. तय की गई चाइल्ड की के लिए null वैल्यू वाले चाइल्ड सबसे पहले आते हैं.
  2. तय की गई चाइल्ड की के लिए false वैल्यू वाले चाइल्ड इसके बाद आते हैं. अगर एक से ज़्यादा चाइल्ड की वैल्यू false है, तो उन्हें की के हिसाब से लेक्सिकोग्राफ़िक तरीके से क्रम से लगाया जाता है.
  3. तय की गई चाइल्ड की के लिए true वैल्यू वाले चाइल्ड इसके बाद आते हैं. अगर एक से ज़्यादा चाइल्ड की वैल्यू true है, तो उन्हें की के हिसाब से लेक्सिकोग्राफ़िक तरीके से क्रम से लगाया जाता है.
  4. न्यूमेरिक वैल्यू वाले चाइल्ड इसके बाद आते हैं. इन्हें बढ़ते क्रम में लगाया जाता है. अगर एक से ज़्यादा चाइल्ड की तय की गई चाइल्ड नोड के लिए एक जैसी न्यूमेरिक वैल्यू है, तो उन्हें की के हिसाब से क्रम से लगाया जाता है.
  5. स्ट्रिंग, नंबर के बाद आती हैं. इन्हें लेक्सिकोग्राफ़िक तरीके से बढ़ते क्रम में लगाया जाता है. अगर एक से ज़्यादा चाइल्ड की तय की गई चाइल्ड नोड के लिए एक जैसी वैल्यू है, तो उन्हें की के हिसाब से लेक्सिकोग्राफ़िक तरीके से क्रम से लगाया जाता है.
  6. ऑब्जेक्ट सबसे आखिर में आते हैं. इन्हें की के हिसाब से लेक्सिकोग्राफ़िक तरीके से बढ़ते क्रम में लगाया जाता है.
फ़िल्टर किए गए नतीजे, बिना किसी क्रम के दिखाए जाते हैं. अगर आपके डेटा का क्रम अहम है, तो Firebase से नतीजे मिलने के बाद, आपको अपने ऐप्लिकेशन में उन्हें क्रम से लगाना चाहिए.

orderBy="$key"

अपने डेटा को क्रम से लगाने के लिए, orderBy="$key" पैरामीटर का इस्तेमाल करने पर, डेटा को की के हिसाब से बढ़ते क्रम में दिखाया जाएगा. जैसे: ध्यान रखें कि की सिर्फ़ स्ट्रिंग हो सकती हैं.

  1. जिन चाइल्ड की को 32-बिट इंटिजर के तौर पर पार्स किया जा सकता है वे सबसे पहले आते हैं. इन्हें बढ़ते क्रम में लगाया जाता है.
  2. जिन चाइल्ड की वैल्यू स्ट्रिंग होती है वे इसके बाद आते हैं. इन्हें लेक्सिकोग्राफ़िक तरीके से बढ़ते क्रम में लगाया जाता है.

orderBy="$value"

अपने डेटा को क्रम से लगाने के लिए, orderBy="$value" पैरामीटर का इस्तेमाल करने पर, चाइल्ड को उनकी वैल्यू के हिसाब से क्रम से लगाया जाएगा. क्रम से लगाने के मानदंड, चाइल्ड की के हिसाब से क्रम से लगाए गए डेटा के जैसे ही होते हैं, हालांकि, इसमें तय की गई चाइल्ड की की वैल्यू के बजाय, नोड की वैल्यू का इस्तेमाल किया जाता है.

orderBy="$priority"

अपने डेटा को क्रम से लगाने के लिए, orderBy="$priority" पैरामीटर का इस्तेमाल करने पर, चाइल्ड को उनकी प्राथमिकता और की के हिसाब से क्रम से लगाया जाता है. जैसे: ध्यान रखें कि प्राथमिकता की वैल्यू सिर्फ़ नंबर या स्ट्रिंग हो सकती हैं.

  1. जिन चाइल्ड की कोई प्राथमिकता नहीं होती (डिफ़ॉल्ट), वे सबसे पहले आते हैं.
  2. जिन चाइल्ड की प्राथमिकता नंबर होती है वे इसके बाद आते हैं. इन्हें प्राथमिकता के हिसाब से, छोटे से बड़े क्रम में लगाया जाता है.
  3. जिन चाइल्ड की प्राथमिकता स्ट्रिंग होती है वे सबसे आखिर में आते हैं. इन्हें प्राथमिकता के हिसाब से लेक्सिकोग्राफ़िक तरीके से क्रम से लगाया जाता है.
  4. जब दो चाइल्ड की प्राथमिकता एक जैसी होती है (कोई प्राथमिकता न होने पर भी), तो उन्हें की के हिसाब से क्रम से लगाया जाता है. न्यूमेरिक की सबसे पहले आती हैं (इन्हें न्यूमेरिक तरीके से क्रम से लगाया जाता है). इसके बाद, बाकी की (इन्हें लेक्सिकोग्राफ़िक तरीके से क्रम से लगाया जाता है) .

प्राथमिकताओं के बारे में ज़्यादा जानने के लिए, एपीआई का रेफ़रंस देखें.

REST API से स्ट्रीमिंग करना

Firebase REST एंडपॉइंट, EventSource / Server-Sent Events प्रोटोकॉल के साथ काम करते हैं. इससे हमारे Firebase डेटाबेस में किसी एक जगह पर होने वाले बदलावों को स्ट्रीम करना आसान हो जाता है.

स्ट्रीमिंग शुरू करने के लिए, हमें यह करना होगा:

  1. क्लाइंट के Accept हेडर को text/event-stream पर सेट करना
  2. एचटीटीपी रीडायरेक्ट का पालन करना. खास तौर पर, एचटीटीपी स्टेटस कोड 307
  3. अगर Firebase डेटाबेस की जगह से डेटा पढ़ने के लिए अनुमति की ज़रूरत है, तो auth क्वेरी पैरामीटर शामिल करना

इसके बदले में, सर्वर, अनुरोध किए गए यूआरएल पर मौजूद डेटा की स्थिति में बदलाव होने पर, नाम वाले इवेंट भेजेगा. इन मैसेज का स्ट्रक्चर, EventSource प्रोटोकॉल के मुताबिक होता है: 

event: event name
data: JSON encoded data payload

सर्वर, ये इवेंट भेज सकता है:

put JSON-एन्कोड किया गया डेटा, दो की वाला ऑब्जेक्ट होगा: पाथ और डेटा
पाथ, अनुरोध यूआरएल के मुकाबले किसी जगह की ओर इशारा करता है
क्लाइंट को अपने कैश में मौजूद उस जगह के सभी डेटा को, मैसेज में दिए गए डेटा से बदलना चाहिए
patch JSON-एन्कोड किया गया डेटा, दो की वाला ऑब्जेक्ट होगा: पाथ और डेटा
पाथ, अनुरोध यूआरएल के मुकाबले किसी जगह की ओर इशारा करता है
डेटा में मौजूद हर की के लिए, क्लाइंट को अपने कैश में मौजूद उससे जुड़ी की को, मैसेज में मौजूद उस की के डेटा से बदलना चाहिए
keep-alive इस इवेंट का डेटा, नल होता है. इसके लिए किसी कार्रवाई की ज़रूरत नहीं होती
cancel इस इवेंट का डेटा, नल होता है
यह इवेंट तब भेजा जाएगा, जब Firebase Realtime Database Security Rules की वजह से, अनुरोध की गई जगह से डेटा पढ़ने की अनुमति नहीं होगी
auth_revoked इस इवेंट का डेटा, एक स्ट्रिंग होती है. इससे पता चलता है कि क्रेडेंशियल की समयसीमा खत्म हो गई है
यह इवेंट तब भेजा जाएगा, जब दिया गया auth पैरामीटर मान्य नहीं होगा

यहां इवेंट के सेट का एक उदाहरण दिया गया है. सर्वर, ये इवेंट भेज सकता है: 

// Set your entire cache to {"a": 1, "b": 2}
event: put
data: {"path": "/", "data": {"a": 1, "b": 2}}


// Put the new data in your cache under the key 'c', so that the complete cache now looks like:
// {"a": 1, "b": 2, "c": {"foo": true, "bar": false}}
event: put
data: {"path": "/c", "data": {"foo": true, "bar": false}}


// For each key in the data, update (or add) the corresponding key in your cache at path /c,
// for a final cache of: {"a": 1, "b": 2, "c": {"foo": 3, "bar": false, "baz": 4}}
event: patch
data: {"path": "/c", "data": {"foo": 3, "baz": 4}}

अगर Go का इस्तेमाल किया जा रहा है, तो Firego देखें. यह तीसरे पक्ष का रैपर है जो Firebase REST और स्ट्रीमिंग एपीआई के लिए है.