Cloud Functions की मदद से, डेटा कनेक्ट की सुविधा को बढ़ाना

Cloud Functions for Firebase की मदद से, Firebase Data Connect में इवेंट मैनेज किए जा सकते हैं. Cloud Functions की मदद से, इवेंट के जवाब में सर्वर-साइड कोड चलाया जा सकता है. जैसे, आपकी Data Connect सेवा में म्यूटेशन को लागू करना. इससे, अपने सर्वर को डिप्लॉय किए बिना कस्टम लॉजिक जोड़ा जा सकता है.

इस्तेमाल के सामान्य उदाहरण

  • डेटा सिंक करना: बदलाव होने के बाद, डेटा को अन्य सिस्टम (जैसे कि Cloud Firestore, BigQuery या बाहरी एपीआई) के साथ रेप्लिकेट या सिंक करें.

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

  • उपयोगकर्ता की दिलचस्पी: अपने ऐप्लिकेशन में किसी खास बदलाव वाले इवेंट के बाद, उपयोगकर्ताओं को ईमेल या Cloud Messaging सूचनाएं भेजें. जैसे, खाता बनाने के बाद.

Data Connect म्यूटेशन पर किसी फ़ंक्शन को ट्रिगर करना

Data Connect इवेंट हैंडलर का इस्तेमाल करके, Data Connect म्यूटेशन के लागू होने पर किसी फ़ंक्शन को ट्रिगर किया जा सकता है.onMutationExecuted यह ट्रिगर, म्यूटेशन के लागू होने पर ट्रिगर होता है.

बुनियादी म्यूटेशन इवेंट फ़ंक्शन

यहां दिया गया बुनियादी उदाहरण, एक ऐसा फ़ंक्शन है जो आपकी Data Connect सेवा में किए गए किसी भी बदलाव की जानकारी को लॉग करता है:

Node.js

import { onMutationExecuted } from "firebase-functions/dataconnect";
import { logger } from "firebase-functions";

export const logMutation = onMutationExecuted(
  {
    /* Trigger on all mutations, spanning all services and connectors
       in us-central1 */
  },
  (event) => {
    logger.info("A mutation was executed!", {
      data: event.data,
    });
  }
);

Python

from firebase_functions import dataconnect_fn, logger

@dataconnect_fn.on_mutation_executed()
def log_mutation(event: dataconnect_fn.Event):
  logger.info("A mutation was executed!", event.data)

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

फ़ंक्शन की जगह सेट करना

फ़ंक्शन को ट्रिगर करने के लिए, फ़ंक्शन की जगह, Data Connect सेवा की जगह से मेल खानी चाहिए. डिफ़ॉल्ट रूप से, फ़ंक्शन का क्षेत्र us-central1 होता है.

Node.js

import { onMutationExecuted } from "firebase-functions/dataconnect";

export const onMutationRegionOption = onMutationExecuted(
  {
    region: "europe-west1"  // Set if Data Connect service location is not us-central1
  },
  (event) => { /* ... */ }
);

Python

@dataconnect_fn.on_mutation_executed(
  region="europe-west1"  # Set if Data Connect service location is not us-central1
)
def mutation_executed_handler_region_option(event: dataconnect_fn.Event):
  pass

इवेंट फ़िल्टर करना

onMutationExecuted हैंडलर को कॉन्फ़िगर किया जा सकता है. इसमें कुछ खास एट्रिब्यूट के आधार पर इवेंट फ़िल्टर करने के विकल्प होते हैं. यह तब काम आता है, जब आपको सिर्फ़ कुछ बदलावों के लिए फ़ंक्शन ट्रिगर करना हो.

service, connector, और operation के हिसाब से फ़िल्टर किया जा सकता है:

Node.js

import { onMutationExecuted } from "firebase-functions/dataconnect";
import { logger } from "firebase-functions";

// Trigger this function only for the CreateUser mutation
// in the users connector of the myAppService service.
export const onUserCreate = onMutationExecuted(
  {
    service: "myAppService",
    connector: "users",
    operation: "CreateUser",
  },
  (event) => {
    logger.info("A new user was created!", event.data);
    // Add logic here: for example, sending a welcome email.
  }
);

Python

from firebase_functions import dataconnect_fn, logger

@dataconnect_fn.on_mutation_executed(
  service="myAppService",
  connector="users",
  operation="CreateUser"
):
def on_user_create(event: dataconnect_fn.Event):
  logger.info("A new user was created!", event.data)

वाइल्डकार्ड और कैप्चर ग्रुप

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

उदाहरण:

Node.js

import { onMutationExecuted } from "firebase-functions/dataconnect";

// Trigger on all operations that match the pattern `User*`, on any service and
// connector.
export const onMutationWildcards = onMutationExecuted(
  {
    operation: "User*",
  },
  (event) => {}
);

// Trigger on all operations that match the pattern `User*`, on any service and
// connector. Capture the operation name in the variable `op`.
export const onMutationCaptureWildcards = onMutationExecuted(
  {
    operation: "{op=User*}",
  },
  (event) => {
    // `event.params.op` contains the operation name.
  }
);

// Trigger on all operations on the service `myAppService`. Capture the
// operation name in the variable `operation`.
export const onMutationCaptures = onMutationExecuted(
  {
    service: "myAppService",
    operation: "{operation}",
  },
  (event) => {
    // `event.params.operation` contains the operation name.
  }
);

Python

from firebase_functions import dataconnect_fn

# Trigger on all operations that match the pattern `User*`, on any service and
# connector.
@dataconnect_fn.on_mutation_executed(
  operation="User*"
)
def on_mutation_wildcards(event: dataconnect_fn.Event):
  pass

# Trigger on all operations that match the pattern `User*`, on any service and
# connector. Capture the operation name in the variable `op`.
@dataconnect_fn.on_mutation_executed(
  operation="{op=User*}"
)
def on_mutation_capture_wildcards(event: dataconnect_fn.Event):
  # `event.params["op"]` contains the operation name.
  pass

# Trigger on all operations on the service `myAppService`. Capture the
# operation name in the variable `operation`.
@dataconnect_fn.on_mutation_executed(
  service="myAppService",
  operation="{operation}"
)
def on_mutation_captures(event: dataconnect_fn.Event):
  # `event.params["operation"]` contains the operation name.
  pass

उपयोगकर्ता की पुष्टि करने से जुड़ी जानकारी ऐक्सेस करना

इवेंट को ट्रिगर करने वाले प्रिंसिपल के बारे में, उपयोगकर्ता की पुष्टि करने से जुड़ी जानकारी ऐक्सेस की जा सकती है. प्रमाणीकरण कॉन्टेक्स्ट में उपलब्ध डेटा के बारे में ज़्यादा जानकारी के लिए, Auth Context देखें.

यहां दिए गए उदाहरण में, पुष्टि के लिए जानकारी पाने का तरीका बताया गया है:

Node.js

import { onMutationExecuted } from "firebase-functions/dataconnect";

export const onMutation = onMutationExecuted(
  { operation: "MyMutation" },
  (event) => {
    // mutationExecuted event provides authType and authId:
    // event.authType
    // event.authId
  }
);

Python

from firebase_functions import dataconnect_fn

@dataconnect_fn.on_mutation_executed(operation="MyMutation")
def mutation_executed_handler(event: dataconnect_fn.Event):
  # mutationExecuted event provides auth_type and auth_id, which are accessed as follows
  # event.auth_type
  # event.auth_id
  pass

पुष्टि का टाइप और पुष्टि करने वाला आईडी इस तरह दिखेगा:

म्यूटेशन शुरू करने वाला authtype authid
पुष्टि किया गया असली उपयोगकर्ता app_user Firebase Auth टोकन यूआईडी
ऐसे असली उपयोगकर्ता जिनकी पुष्टि नहीं हुई है unauthenticated खाली
एडमिन एसडीके, असली उपयोगकर्ता के तौर पर काम कर रहा है app_user जिस उपयोगकर्ता की पहचान चुराई गई है उसका Firebase Auth टोकन यूआईडी
Admin SDK, बिना पुष्टि किए गए अनुरोध के तौर पर काम कर रहा है unauthenticated खाली
सभी अनुमतियों वाला Admin SDK admin खाली

इवेंट डेटा ऐक्सेस करना

आपके फ़ंक्शन को पास किया गया CloudEvent ऑब्जेक्ट, उस इवेंट के बारे में जानकारी देता है जिसकी वजह से फ़ंक्शन ट्रिगर हुआ है.

इवेंट के एट्रिब्यूट

एट्रिब्यूट टाइप ब्यौरा
id string यह इवेंट के लिए यूनीक आइडेंटिफ़ायर होता है.
source string वह कनेक्टर संसाधन जिसने इवेंट जनरेट किया है. उदाहरण के लिए, //firebasedataconnect.googleapis.com/projects/*/locations/*/services/*/connectors/*.
specversion string CloudEvents स्पेसिफ़िकेशन का वर्शन (जैसे, "1.0").
type string इवेंट का प्रकार: google.firebase.dataconnect.connector.v1.mutationExecuted.
time string इवेंट के जनरेट होने का टाइमस्टैंप (आईएसओ 8601 फ़ॉर्मैट).
subject string ज़रूरी नहीं. ईवेंट संदर्भ के बारे में अतिरिक्त जानकारी, जैसे ऑपरेशन का नाम.
params object इमेज में, कैप्चर किए गए पाथ पैटर्न का मैप दिखाया गया है.
authType string घटना को ट्रिगर करने वाले प्रिंसिपल के प्रकार को दर्शाने वाला एक enum.
authId string उस प्रिंसिपल का विशिष्ट पहचानकर्ता जिसने घटना को ट्रिगर किया.
data MutationEventData Data Connect इवेंट का पेलोड. अगला सेक्शन देखें.

डेटा पेलोड

MutationEventData ऑब्जेक्ट में, Data Connect इवेंट का पेलोड शामिल होता है:

{
  // ...
  "authType": // ...
  "data": {
    "payload": {
      "variables": {
        "userId": "user123",
        "updateData": {
          "displayName": "New Name"
        }
      },
      "data": {
        "updateUser": {
          "id": "user123",
          "displayName": "New Name",
          "email": "user@example.com"
        }
      },
      "errors": []
    }
  }
}
  • payload.variables: एक ऑब्जेक्ट जिसमें वे वैरिएबल होते हैं जिन्हें म्यूटेशन में पास किया गया था.
  • payload.data: यह एक ऐसा ऑब्जेक्ट होता है जिसमें म्यूटेशन से मिला डेटा होता है.
  • payload.errors: म्यूटेशन के निष्पादन के दौरान हुई किसी भी त्रुटि की एक सरणी. यदि उत्परिवर्तन सफल रहा, तो यह सारणी रिक्त हो जाएगी.

उदाहरण

यहां बताया गया है कि आप उत्परिवर्तन चर और लौटाए गए डेटा तक कैसे पहुंच सकते हैं:

Node.js

import { onMutationExecuted } from "firebase-functions/dataconnect";
import { logger } from "firebase-functions";

export const processNewUserData = onMutationExecuted(
  {
    "service": "myAppService",
    "connector": "users",
    "operation": "CreateUser",
  },
  (event) => {
    // The variables passed to the mutation
    const mutationVariables = event.data.payload.variables;

    // The data returned by the mutation
    const returnedData = event.data.payload.data;

    logger.info("Processing mutation with variables:", mutationVariables);
    logger.info("Mutation returned:", returnedData);

    // ... your custom logic here
  }
);

Python

from firebase_functions import dataconnect_fn, logger

@dataconnect_fn.on_mutation_executed(
  service="myAppService",
  connector="users",
  operation="CreateUser"
):
def process_new_user_data(event: dataconnect_fn.Event):
  # The variables passed to the mutation
  mutation_vars = event.data.payload.variables
  # The data returned by the mutation
  returned_data = event.data.payload.data

  logger.info("Processing mutation with variables:", mutationVariables)
  logger.info("Mutation returned", returnedData)

  # ... your custom logic here

ध्यान दें कि कुछ अन्य डेटाबेस ट्रिगर, जैसे कि Cloud Firestore या Realtime Database के उलट, Data Connect इवेंट डेटा का "before" स्नैपशॉट नहीं देता है. Data Connect, अनुरोधों को डेटाबेस में प्रॉक्सी करता है. इसलिए, डेटा का "पहले" स्नैपशॉट, लेन-देन के तौर पर नहीं पाया जा सकता. इसके बजाय, आपके पास म्यूटेशन को भेजे गए तर्कों और उसके द्वारा लौटाए गए डेटा तक पहुंच होती है.

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