Cloud Firestore के ट्रिगर

Cloud Functions की मदद से, आप Cloud Firestore के लिए क्लाइंट कोड को अपडेट करने की ज़रूरत नहीं होती. आप दस्तावेज़ स्नैपशॉट इंटरफ़ेस या एडमिन SDK टूल.

सामान्य लाइफ़साइकल में, Cloud Firestore फ़ंक्शन ये काम करता है:

1. किसी खास दस्तावेज़ में बदलाव होने का इंतज़ार किया जाता है.
2. यह तब ट्रिगर होता है, जब कोई इवेंट होता है और अपने टास्क पूरे करते हैं.
3. ऐसा डेटा ऑब्जेक्ट मिलता है जिसमें सेव किए गए डेटा का स्नैपशॉट होता है दिए गए दस्तावेज़ में मौजूद है. इवेंट लिखने या अपडेट करने के लिए, डेटा ऑब्जेक्ट में दो स्नैपशॉट होते हैं, जो पहले की डेटा स्थिति को दिखाते हैं और ट्रिगर करने वाले इवेंट के बाद दिखेगा.

Firestore इंस्टेंस की जगह और जगह के बीच की दूरी फ़ंक्शन के इस्तेमाल से नेटवर्क में लगने वाला समय बढ़ सकता है. परफ़ॉर्मेंस को ऑप्टिमाइज़ करने के लिए, उस फ़ंक्शन की जगह की जानकारी दें जहां लागू.

Cloud Firestore फ़ंक्शन ट्रिगर

'Firebase के लिए Cloud Functions' SDK टूल, functions.firestore को एक्सपोर्ट करता है ऑब्जेक्ट है, जिसकी मदद से आप खास Cloud Firestore इवेंट से जुड़े हैंडलर बना सकते हैं.

अगर आपने अभी तक Cloud Functions for Firebase के लिए कोई प्रोजेक्ट चालू नहीं किया है, तो पढ़ें शुरू करना: अपने पहले फ़ंक्शन लिखें और डिप्लॉय करें Firebase प्रोजेक्ट के लिए अपने Cloud Functions को कॉन्फ़िगर और सेट अप करें.

Cloud Firestore से ट्रिगर होने वाले फ़ंक्शन लिखना

फ़ंक्शन ट्रिगर तय करना

Cloud Firestore ट्रिगर तय करने के लिए, दस्तावेज़ का पाथ और इवेंट टाइप तय करें:

const functions = require('firebase-functions');

exports.myFunction = functions.firestore
  .document('my-collection/{docId}')
  .onWrite((change, context) => { /* ... */ });

दस्तावेज़ के पाथ में किसी खास दस्तावेज़ का रेफ़रंस दिया जा सकता है या वाइल्डकार्ड पैटर्न शामिल हो.

कोई एक दस्तावेज़ तय करें

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

// Listen for any change on document `marie` in collection `users`
exports.myFunctionName = functions.firestore
    .document('users/marie').onWrite((change, context) => {
      // ... Your code here
    });
index.js

वाइल्डकार्ड का इस्तेमाल करके दस्तावेज़ों का एक ग्रुप बनाएं

अगर आपको दस्तावेज़ों के ग्रुप में ट्रिगर अटैच करना है, जैसे कि तो किसी खास कलेक्शन की जगह पर {wildcard} का इस्तेमाल करें दस्तावेज़ आईडी:

// Listen for changes in all documents in the 'users' collection
exports.useWildcard = functions.firestore
    .document('users/{userId}')
    .onWrite((change, context) => {
      // If we set `/users/marie` to {name: "Marie"} then
      // context.params.userId == "marie"
      // ... and ...
      // change.after.data() == {name: "Marie"}
    });
index.js

इस उदाहरण में, जब users में किसी भी दस्तावेज़ पर कोई भी फ़ील्ड बदला जाता है, तो वह मेल खाता है userId नाम का वाइल्डकार्ड.

अगर users के किसी दस्तावेज़ में सब-कलेक्शन हैं और उनमें से किसी एक सब-कलेक्शन में कोई फ़ील्ड है दस्तावेज़ों में बदलाव किया गया है, userId वाइल्डकार्ड ट्रिगर नहीं किया गया है.

वाइल्डकार्ड से मेल खाने वाले नतीजे, दस्तावेज़ के पाथ से हासिल किए जाते हैं और context.params में सेव किए जाते हैं. अश्लील कलेक्शन वाले विकल्प के लिए, जितने चाहें उतने वाइल्डकार्ड तय किए जा सकते हैं दस्तावेज़ आईडी या दस्तावेज़ आईडी:

// Listen for changes in all documents in the 'users' collection and all subcollections
exports.useMultipleWildcards = functions.firestore
    .document('users/{userId}/{messageCollectionId}/{messageId}')
    .onWrite((change, context) => {
      // If we set `/users/marie/incoming_messages/134` to {body: "Hello"} then
      // context.params.userId == "marie";
      // context.params.messageCollectionId == "incoming_messages";
      // context.params.messageId == "134";
      // ... and ...
      // change.after.data() == {body: "Hello"}
    });
index.js

इवेंट ट्रिगर

नया दस्तावेज़ बनाए जाने पर फ़ंक्शन ट्रिगर करें

कलेक्शन में नया दस्तावेज़ बनाए जाने पर, किसी भी फ़ंक्शन को ऐक्टिव करने के लिए ट्रिगर किया जा सकता है वाइल्डकार्ड के साथ onCreate() हैंडलर का इस्तेमाल करके. जब भी उपयोगकर्ता की नई प्रोफ़ाइल जोड़ी जाती है, तब यह उदाहरण फ़ंक्शन createUser को कॉल करता है:

exports.createUser = functions.firestore
    .document('users/{userId}')
    .onCreate((snap, context) => {
      // Get an object representing the document
      // e.g. {'name': 'Marie', 'age': 66}
      const newValue = snap.data();

      // access a particular field as you would any JS property
      const name = newValue.name;

      // perform desired operations ...
    });
index.js

दस्तावेज़ के अपडेट होने पर फ़ंक्शन ट्रिगर करें

जब किसी दस्तावेज़ को सक्रिय करने के लिए वाइल्डकार्ड वाला onUpdate() फ़ंक्शन. इस उदाहरण फ़ंक्शन में updateUser को तब कॉल किया गया है, जब कोई उपयोगकर्ता अपनी प्रोफ़ाइल बदलता है:

exports.updateUser = functions.firestore
    .document('users/{userId}')
    .onUpdate((change, context) => {
      // Get an object representing the document
      // e.g. {'name': 'Marie', 'age': 66}
      const newValue = change.after.data();

      // ...or the previous value before this update
      const previousValue = change.before.data();

      // access a particular field as you would any JS property
      const name = newValue.name;

      // perform desired operations ...
    });
index.js

दस्तावेज़ मिटाए जाने पर फ़ंक्शन ट्रिगर करें

इसका इस्तेमाल करके किसी दस्तावेज़ को मिटाए जाने पर भी फ़ंक्शन को ट्रिगर किया जा सकता है वाइल्डकार्ड वाला onDelete() फ़ंक्शन. यह उदाहरण जब कोई उपयोगकर्ता अपनी उपयोगकर्ता प्रोफ़ाइल हटाता है, तो फ़ंक्शन deleteUser को कॉल करता है:

exports.deleteUser = functions.firestore
    .document('users/{userID}')
    .onDelete((snap, context) => {
      // Get an object representing the document prior to deletion
      // e.g. {'name': 'Marie', 'age': 66}
      const deletedValue = snap.data();

      // perform desired operations ...
    });
index.js

किसी दस्तावेज़ में सभी बदलावों के लिए फ़ंक्शन ट्रिगर करना

अगर आपको ट्रिगर होने वाले इवेंट के बारे में कोई जानकारी नहीं है, तो यहां मौजूद सभी onWrite() फ़ंक्शन का इस्तेमाल करके, Cloud Firestore दस्तावेज़ में बदलाव वाइल्डकार्ड के साथ. इस उदाहरण फ़ंक्शन में modifyUser को कॉल किया गया है अगर कोई उपयोगकर्ता बनाया जाता है, अपडेट किया जाता है या मिटाया जाता है, तो:

exports.modifyUser = functions.firestore
    .document('users/{userID}')
    .onWrite((change, context) => {
      // Get an object with the current document value.
      // If the document does not exist, it has been deleted.
      const document = change.after.exists ? change.after.data() : null;

      // Get an object with the previous document value (for update or delete)
      const oldDocument = change.before.data();

      // perform desired operations ...
    });
index.js

डेटा को पढ़ने और लिखने की सुविधा

जब कोई फ़ंक्शन ट्रिगर किया जाता है, तो यह इवेंट. इस स्नैपशॉट का इस्तेमाल, उस दस्तावेज़ से पढ़ने या उसमें लिखने के लिए किया जा सकता है जिसमें इवेंट ट्रिगर किया है या दूसरे हिस्सों को ऐक्सेस करने के लिए Firebase एडमिन SDK का इस्तेमाल किया जा सकता है आपके डेटाबेस का ऐसा होना चाहिए.

इवेंट का डेटा

पढ़ने से जुड़ा डेटा

जब कोई फ़ंक्शन ट्रिगर होता है, तो हो सकता है कि आप ऐसे दस्तावेज़ से डेटा लेना चाहें जो को अपडेट किया गया हो या अपडेट से पहले का डेटा मिले. पुराना डेटा पाने के लिए, इनका इस्तेमाल करें: change.before.data() में अपडेट से पहले का दस्तावेज़ का स्नैपशॉट होता है. इसी तरह, change.after.data() में दस्तावेज़ के स्नैपशॉट की स्थिति, अपडेट.

exports.updateUser2 = functions.firestore
    .document('users/{userId}')
    .onUpdate((change, context) => {
      // Get an object representing the current document
      const newValue = change.after.data();

      // ...or the previous value before this update
      const previousValue = change.before.data();
    });
index.js

प्रॉपर्टी को उसी तरह ऐक्सेस किया जा सकता है जैसे किसी दूसरे ऑब्जेक्ट में किया जाता है. इसके अलावा, आपके पास कुछ खास फ़ील्ड को ऐक्सेस करने के लिए, get फ़ंक्शन का इस्तेमाल किया जा सकता है:

// Fetch data using standard accessors
const age = snap.data().age;
const name = snap.data()['name'];

// Fetch data using built in accessor
const experience = snap.get('experience');
index.js

डेटा राइट किया जा रहा है

हर फ़ंक्शन को शुरू करने की कार्रवाई, आपके Cloud Firestore डेटाबेस. उस दस्तावेज़ को DocumentReference फ़ंक्शन को शामिल किया गया, स्नैपशॉट की ref प्रॉपर्टी में.

यह DocumentReference Cloud Firestore Node.js SDK टूल इसमें update(), set(), और remove() जैसे तरीके शामिल हैं, ताकि फ़ंक्शन को ट्रिगर करने वाले दस्तावेज़ में बदलाव करें.

// Listen for updates to any `user` document.
exports.countNameChanges = functions.firestore
    .document('users/{userId}')
    .onUpdate((change, context) => {
      // Retrieve the current and previous value
      const data = change.after.data();
      const previousData = change.before.data();

      // We'll only update if the name has changed.
      // This is crucial to prevent infinite loops.
      if (data.name == previousData.name) {
        return null;
      }

      // Retrieve the current count of name changes
      let count = data.name_change_count;
      if (!count) {
        count = 0;
      }

      // Then return a promise of a set operation to update the count
      return change.after.ref.set({
        name_change_count: count + 1
      }, {merge: true});
    });
index.js

ट्रिगर इवेंट से बाहर का डेटा

Cloud Functions, भरोसेमंद जगह पर काम करता है. इसका मतलब है कि वे को आपके प्रोजेक्ट पर सेवा खाते के तौर पर अनुमति मिली हुई हो. पढ़ने और लिखने की सुविधा उपलब्ध है Firebase एडमिन SDK का इस्तेमाल करके:

const admin = require('firebase-admin');
admin.initializeApp();

const db = admin.firestore();

exports.writeToFirestore = functions.firestore
  .document('some/doc')
  .onWrite((change, context) => {
    db.doc('some/otherdoc').set({ ... });
  });

सीमाएं

Cloud Functions के लिए, Cloud Firestore ट्रिगर की इन सीमाओं का ध्यान रखें:

• Cloud Functions (1st gen) के लिए, मौजूदा "(डिफ़ॉल्ट)" का होना ज़रूरी है Firebase के नेटिव मोड में डेटाबेस. इस पर काम नहीं होता Cloud Firestore के नाम वाले डेटाबेस या डेटास्टोर मोड के साथ काम कर सकता है. कृपया Cloud Functions का इस्तेमाल करें (2nd gen) को ऐसे मामलों में इवेंट कॉन्फ़िगर करना होगा.
• ऑर्डर करने की कोई गारंटी नहीं है. तेज़ी से होने वाले बदलावों से, फ़ंक्शन शुरू करने की सुविधा अचानक ऑर्डर हो गया.
• इवेंट कम से कम एक बार डिलीवर किए जाते हैं. हालांकि, किसी एक इवेंट की वजह से कई फ़ंक्शन शुरू करना. इन चीज़ों पर निर्भर रहने से बचें एक बार काम करने वाला मैकेनिक्स, और idemutent फ़ंक्शन का इस्तेमाल करें.
• Datastore मोड में Cloud Firestore इसके लिए Cloud Functions (2nd gen) ज़रूरी है. Cloud Functions (1st gen) यह नहीं करता है डेटास्टोर मोड का समर्थन करता है.
• ट्रिगर एक ही डेटाबेस से जुड़ा होता है. आप ऐसा ट्रिगर नहीं बना सकते जो एक से ज़्यादा डेटाबेस से मेल खाता हो.
• किसी डेटाबेस को मिटाने से, उस डेटाबेस के लिए कोई भी ट्रिगर अपने-आप नहीं मिटता. कॉन्टेंट बनाने ट्रिगर इवेंट डिलीवर करना बंद कर देता है लेकिन जब तक आप ट्रिगर हटा नहीं देते तब तक मौजूद रहता है.
• अगर मेल खाने वाला इवेंट, अनुरोध की संख्या से ज़्यादा हो जाता है, तो ऐसा हो सकता है कि इवेंट, Cloud Functions (1st gen) को डिलीवर न किया गया हो.
  • प्लैटफ़ॉर्म लॉग में, अनुरोध की संख्या की वजह से इवेंट डिलीवर नहीं हो सके और प्रोजेक्ट के लॉग उपयोग में गिना जाता है.
  • आपको ये लॉग, लॉग एक्सप्लोरर में इस मैसेज के साथ मिल सकते हैं: "इवेंट को डिलीवर नहीं किया जा सकता" क्लाउड फ़ंक्शन, 1st gen के लिए तय सीमा से ज़्यादा हो गया है..." error पेज चुने जा सकते हैं गंभीरता. functionName फ़ील्ड में, फ़ंक्शन का नाम देखा जा सकता है. अगर आपने receiveTimestamp फ़ील्ड अभी से एक घंटे के अंदर ही है, तो आप यह अनुमान लगा सकते हैं कि किसी दस्तावेज़ को पढ़ने के बाद, इस स्नैपशॉट से पहले और बाद में एक स्नैपशॉट होना चाहिए.
  • ऐसी गड़बड़ियों से बचने के लिए:
    • Cloud Functions (2nd gen) पर माइग्रेट और अपग्रेड करना
    • दस्तावेज़ का साइज़ छोटा करें
    • जिन Cloud Functions को हटाना है उन्हें मिटाएं
  • शामिल न करने की सेटिंग का इस्तेमाल करके, जानकारी इकट्ठा करने की सुविधा बंद की जा सकती है लेकिन ध्यान रखें कि आपत्तिजनक इवेंट अब भी डिलीवर नहीं किए जाएंगे.