एक एक्सटेंशन बनाना शुरू करें

यह पृष्ठ आपको एक सरल फायरबेस एक्सटेंशन बनाने के लिए आवश्यक चरणों के बारे में बताता है, जिसे आप अपनी परियोजनाओं में स्थापित कर सकते हैं या दूसरों के साथ साझा कर सकते हैं। फायरबेस एक्सटेंशन का यह सरल उदाहरण आपके रीयलटाइम डेटाबेस को संदेशों के लिए देखेगा और उन्हें अपर केस में बदल देगा।

1. अपना परिवेश सेट करें और एक प्रोजेक्ट प्रारंभ करें

इससे पहले कि आप किसी एक्सटेंशन का निर्माण शुरू कर सकें, आपको आवश्यक उपकरणों के साथ एक बिल्ड वातावरण स्थापित करना होगा।

  1. Node.js 16 या नया स्थापित करें। नोड को स्थापित करने का एक तरीका एनवीएम (या एनवीएम-विंडोज़ ) का उपयोग करना है।

  2. फायरबेस सीएलआई का नवीनतम संस्करण स्थापित करें या अपडेट करें। npm का उपयोग करके इंस्टॉल या अपडेट करने के लिए, यह कमांड चलाएँ:

    npm install -g firebase-tools

अब एक नए एक्सटेंशन प्रोजेक्ट को आरंभ करने के लिए फायरबेस सीएलआई का उपयोग करें:

  1. अपने एक्सटेंशन के लिए एक निर्देशिका बनाएं और उसमें cd :

    mkdir rtdb-uppercase-messages && cd rtdb-uppercase-messages

  2. फायरबेस सीएलआई का ext:dev:init कमांड चलाएँ:

    firebase ext:dev:init

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

2. एम्यूलेटर का उपयोग करके उदाहरण एक्सटेंशन आज़माएं

जब फायरबेस सीएलआई ने नई एक्सटेंशन निर्देशिका को आरंभ किया, तो इसने एक सरल उदाहरण फ़ंक्शन और एक integration-tests निर्देशिका बनाई जिसमें फायरबेस एमुलेटर सूट का उपयोग करके एक्सटेंशन चलाने के लिए आवश्यक फाइलें शामिल थीं।

एम्यूलेटर में उदाहरण एक्सटेंशन चलाने का प्रयास करें:

  1. integration-tests निर्देशिका में बदलें:

    cd functions/integration-tests

  2. डेमो प्रोजेक्ट के साथ एमुलेटर प्रारंभ करें:

    firebase emulators:start --project=demo-test

    एमुलेटर एक्सटेंशन को पूर्वनिर्धारित "डमी" प्रोजेक्ट ( demo-test ) में लोड करता है। अब तक के एक्सटेंशन में एक HTTP-ट्रिगर फ़ंक्शन, greetTheWorld शामिल है, जो एक्सेस करने पर "हैलो वर्ल्ड" संदेश लौटाता है।

  3. एमुलेटर अभी भी चल रहा है, जब आपने इसे शुरू किया था तब प्रिंट किए गए यूआरएल पर जाकर एक्सटेंशन के greetTheWorld फ़ंक्शन को आज़माएं।

    आपका ब्राउज़र "ग्रीट-द-वर्ल्ड की ओर से हैलो वर्ल्ड" संदेश प्रदर्शित करता है।

  4. इस फ़ंक्शन का स्रोत कोड एक्सटेंशन की functions निर्देशिका में है। अपनी पसंद के संपादक या आईडीई में स्रोत खोलें:

    फ़ंक्शन/index.js

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

exports.greetTheWorld = functions.https.onRequest((req, res) => {
  // Here we reference a user-provided parameter
  // (its value is provided by the user during installation)
  const consumerProvidedGreeting = process.env.GREETING;

  // And here we reference an auto-populated parameter
  // (its value is provided by Firebase after installation)
  const instanceId = process.env.EXT_INSTANCE_ID;

  const greeting = `${consumerProvidedGreeting} World from ${instanceId}`;

  res.send(greeting);
});

  5. जब एम्यूलेटर चल रहा हो, तो यह आपके फ़ंक्शंस कोड में किए गए किसी भी बदलाव को स्वचालित रूप से पुनः लोड कर देगा। greetTheWorld फ़ंक्शन में एक छोटा सा परिवर्तन करने का प्रयास करें:

    फ़ंक्शन/index.js

    const greeting = `${consumerProvidedGreeting} everyone, from ${instanceId}`;

    अपने परिवर्तन सहेजें. एमुलेटर आपके कोड को फिर से लोड करेगा, और अब, जब आप फ़ंक्शन यूआरएल पर जाएंगे, तो आपको अपडेट किया गया ग्रीटिंग दिखाई देगा।

3. एक्सटेंशन.yaml में बुनियादी जानकारी जोड़ें

अब जब आपके पास एक विकास परिवेश स्थापित हो गया है और आप एक्सटेंशन एमुलेटर चला रहे हैं, तो आप अपना स्वयं का एक्सटेंशन लिखना शुरू कर सकते हैं।

एक मामूली पहले कदम के रूप में, greet-the-world के बजाय उस एक्सटेंशन को प्रतिबिंबित करने के लिए पूर्वनिर्धारित एक्सटेंशन मेटाडेटा को संपादित करें जिसे आप लिखना चाहते हैं। यह मेटाडेटा extension.yaml फ़ाइल में संग्रहीत है।

  1. अपने संपादक में extension.yaml खोलें, और फ़ाइल की संपूर्ण सामग्री को निम्नलिखित से बदलें:

    name: rtdb-uppercase-messages
version: 0.0.1
specVersion: v1beta  # Firebase Extensions specification version; don't change

# Friendly display name for your extension (~3-5 words)
displayName: Convert messages to upper case

# Brief description of the task your extension performs (~1 sentence)
description: >-
  Converts messages in RTDB to upper case

author:
  authorName: Your Name
  url: https://your-site.example.com

license: Apache-2.0  # Required license

# Public URL for the source code of your extension
sourceUrl: https://github.com/your-name/your-repo

    name फ़ील्ड में प्रयुक्त नामकरण परंपरा पर ध्यान दें: आधिकारिक फ़ायरबेस एक्सटेंशन का नाम एक उपसर्ग के साथ रखा जाता है जो प्राथमिक फ़ायरबेस उत्पाद को इंगित करता है जिस पर एक्सटेंशन संचालित होता है, इसके बाद एक्सटेंशन क्या करता है इसका विवरण दिया जाता है। आपको अपने स्वयं के एक्सटेंशन में उसी परंपरा का उपयोग करना चाहिए।

  2. चूंकि आपने अपने एक्सटेंशन का नाम बदल दिया है, इसलिए आपको अपने एमुलेटर कॉन्फ़िगरेशन को भी नए नाम से अपडेट करना चाहिए:

    1. functions/integration-tests/firebase.json में, greet-the-world rtdb-uppercase-messages में बदलें।
    2. functions/integration-tests/extensions/greet-the-world.env नाम बदलकर functions/integration-tests/extensions/rtdb-uppercase-messages.env कर दें।

आपके एक्सटेंशन कोड में अभी भी greet-the-world एक्सटेंशन के कुछ अवशेष बचे हैं, लेकिन उन्हें अभी छोड़ दें। आप उन्हें अगले कुछ अनुभागों में अपडेट करेंगे।

4. एक क्लाउड फ़ंक्शन लिखें और इसे एक एक्सटेंशन संसाधन के रूप में घोषित करें

अब आप कुछ कोड लिखना शुरू कर सकते हैं। इस चरण में, आप एक क्लाउड फ़ंक्शन लिखेंगे जो आपके एक्सटेंशन का मुख्य कार्य करता है, जो संदेशों के लिए आपके रीयलटाइम डेटाबेस को देखना और उन्हें अपर केस में परिवर्तित करना है।

  1. अपनी पसंद के संपादक या आईडीई में एक्सटेंशन के फ़ंक्शंस (एक्सटेंशन की functions निर्देशिका में) के लिए स्रोत खोलें। इसकी सामग्री को निम्नलिखित से बदलें:

    फ़ंक्शन/index.js

    import { database, logger } from "firebase-functions/v1";

const app = initializeApp();

// Listens for new messages added to /messages/{pushId}/original and creates an
// uppercase version of the message to /messages/{pushId}/uppercase
// for all databases in 'us-central1'
export const makeuppercase = database
  .ref("/messages/{pushId}/uppercase")
  .onCreate(async (snapshot, context) => {
    // Grab the current value of what was written to the Realtime Database.
    const original = snapshot.val();

    // Convert it to upper case.
    logger.log("Uppercasing", context.params.pushId, original);
    const uppercase = original.toUpperCase();

    // Setting an "uppercase" sibling in the Realtime Database.
    const upperRef = snapshot.ref.parent.child("upper");
    await upperRef.set(uppercase);
});

    पुराना फ़ंक्शन, जिसे आपने प्रतिस्थापित किया था, एक HTTP-ट्रिगर फ़ंक्शन था, जो HTTP एंडपॉइंट तक पहुंचने पर चलता था। नया फ़ंक्शन वास्तविक समय डेटाबेस घटनाओं द्वारा ट्रिगर किया जाता है: यह एक विशेष पथ पर नई वस्तुओं पर नज़र रखता है और, जब किसी का पता चलता है, तो यह मूल्य के अपरकेस संस्करण को डेटाबेस में वापस लिखता है।

    वैसे, यह नई फ़ाइल CommonJS ( require ) के बजाय ECMAScript मॉड्यूल सिंटैक्स ( import और export ) का उपयोग करती है। नोड में ईएस मॉड्यूल का उपयोग करने के लिए, functions/package.json में "type": "module" निर्दिष्ट करें:

    {
  "name": "rtdb-uppercase-messages",
  "main": "index.js",
  "type": "module",
  …
}

  2. आपके एक्सटेंशन का प्रत्येक फ़ंक्शन extension.yaml फ़ाइल में घोषित किया जाना चाहिए। उदाहरण एक्सटेंशन ने greetTheWorld एक्सटेंशन का एकमात्र क्लाउड फ़ंक्शन घोषित किया; अब जब आपने इसे makeuppercase से बदल दिया है, तो आपको इसकी घोषणा को भी अद्यतन करने की आवश्यकता है।

    extension.yaml खोलें और एक resources फ़ील्ड जोड़ें:

    resources:
  - name: makeuppercase
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: providers/google.firebase.database/eventTypes/ref.create
        # DATABASE_INSTANCE (project's default instance) is an auto-populated
        # parameter value. You can also specify an instance.
        resource: projects/_/instances/${DATABASE_INSTANCE}/refs/messages/{pushId}/original
      runtime: "nodejs18"

  3. चूंकि आपका एक्सटेंशन अब रीयलटाइम डेटाबेस को ट्रिगर के रूप में उपयोग कर रहा है, इसलिए आपको क्लाउड फ़ंक्शंस एमुलेटर के साथ आरटीडीबी एमुलेटर चलाने के लिए अपने एमुलेटर कॉन्फ़िगरेशन को अपडेट करने की आवश्यकता है:

    1. यदि एमुलेटर अभी भी चल रहा है, तो Ctrl-C दबाकर इसे रोकें।

    2. functions/integration-tests निर्देशिका से, निम्न आदेश चलाएँ:

      firebase init emulators

      पूछे जाने पर, डिफ़ॉल्ट प्रोजेक्ट सेट करना छोड़ दें, फिर फ़ंक्शंस और डेटाबेस एमुलेटर का चयन करें। डिफ़ॉल्ट पोर्ट स्वीकार करें और सेटअप टूल को किसी भी आवश्यक फ़ाइल को डाउनलोड करने की अनुमति दें।

    3. एम्यूलेटर पुनः आरंभ करें:

      firebase emulators:start --project=demo-test

  4. अपना अद्यतन एक्सटेंशन आज़माएँ:

    1. डेटाबेस एमुलेटर यूआई को उस लिंक का उपयोग करके खोलें जिसे एमुलेटर ने शुरू करते समय मुद्रित किया था।

    2. डेटाबेस का रूट नोड संपादित करें:

      • फ़ील्ड: messages
      • प्रकार: json
      • मूल्य: {"11": {"original": "recipe"}}

      यदि सब कुछ सही ढंग से सेट किया गया है, तो जब आप अपना डेटाबेस परिवर्तन सहेजते हैं, तो एक्सटेंशन के makeuppercase फ़ंक्शन को ट्रिगर करना चाहिए और सामग्री "upper": "RECIPE" के साथ संदेश 11 में एक चाइल्ड रिकॉर्ड जोड़ना चाहिए। अपेक्षित परिणामों की पुष्टि करने के लिए एमुलेटर यूआई के लॉग और डेटाबेस टैब पर एक नज़र डालें।

    3. messages नोड में कुछ और बच्चों को जोड़ने का प्रयास करें ( {"original":"any text"} )। जब भी आप कोई नया रिकॉर्ड जोड़ते हैं, तो एक्सटेंशन को एक uppercase फ़ील्ड जोड़ना चाहिए जिसमें original फ़ील्ड की अपरकेस सामग्री शामिल हो।

अब आपके पास एक पूर्ण, हालांकि सरल, एक्सटेंशन है जो आरटीडीबी उदाहरण पर काम करता है। आगे आने वाले अनुभागों में, आप कुछ अतिरिक्त सुविधाओं के साथ इस एक्सटेंशन को परिष्कृत करेंगे। फिर, आप दूसरों को वितरित करने के लिए एक्सटेंशन तैयार कर लेंगे, और अंत में, एक्सटेंशन हब पर अपना एक्सटेंशन प्रकाशित करना सीखेंगे।

5. एपीआई और भूमिकाएँ घोषित करें

फायरबेस स्थापित एक्सटेंशन के प्रत्येक इंस्टेंस को प्रति-इंस्टेंस सेवा खाते का उपयोग करके प्रोजेक्ट और उसके डेटा तक सीमित पहुंच प्रदान करता है। प्रत्येक खाते को संचालित करने के लिए आवश्यक अनुमतियों का न्यूनतम सेट होता है। इस कारण से, आपको अपने एक्सटेंशन के लिए आवश्यक किसी भी IAM भूमिका को स्पष्ट रूप से घोषित करना होगा; जब उपयोगकर्ता आपका एक्सटेंशन इंस्टॉल करते हैं, तो फायरबेस इन भूमिकाओं के साथ एक सेवा खाता बनाता है और एक्सटेंशन को चलाने के लिए इसका उपयोग करता है।

आपको किसी उत्पाद की घटनाओं को ट्रिगर करने के लिए भूमिकाएं घोषित करने की आवश्यकता नहीं है, लेकिन अन्यथा इसके साथ बातचीत करने के लिए आपको एक भूमिका घोषित करने की आवश्यकता है। क्योंकि अंतिम चरण में आपने जो फ़ंक्शन जोड़ा है वह रीयलटाइम डेटाबेस पर लिखता है, आपको extension.yaml में निम्नलिखित घोषणा जोड़ने की आवश्यकता है:

roles:
  - role: firebasedatabase.admin
    reason: Allows the extension to write to RTDB.

इसी तरह, आप Google API की घोषणा करते हैं जिसका उपयोग एक एक्सटेंशन apis फ़ील्ड में करता है। जब उपयोगकर्ता आपका एक्सटेंशन इंस्टॉल करेंगे, तो उनसे पूछा जाएगा कि क्या वे अपने प्रोजेक्ट के लिए इन एपीआई को स्वचालित रूप से सक्षम करना चाहते हैं। यह आमतौर पर केवल गैर-फ़ायरबेस Google API के लिए आवश्यक है, और इस गाइड के लिए इसकी आवश्यकता नहीं है।

6. उपयोगकर्ता-कॉन्फ़िगर करने योग्य पैरामीटर परिभाषित करें

पिछले दो चरणों में आपके द्वारा बनाए गए फ़ंक्शन ने आने वाले संदेशों के लिए एक विशिष्ट आरटीडीबी स्थान देखा। कभी-कभी, किसी विशिष्ट स्थान को देखना वास्तव में वही होता है जो आप चाहते हैं, जैसे कि जब आपका एक्सटेंशन एक डेटाबेस संरचना पर काम करता है जिसे आप विशेष रूप से अपने एक्सटेंशन के लिए उपयोग करते हैं। हालाँकि, अधिकांश समय, आप इन मानों को उन उपयोगकर्ताओं द्वारा कॉन्फ़िगर करने योग्य बनाना चाहेंगे जो आपके एक्सटेंशन को अपने प्रोजेक्ट में इंस्टॉल करते हैं। इस तरह, उपयोगकर्ता अपने मौजूदा डेटाबेस सेटअप के साथ काम करने के लिए आपके एक्सटेंशन का उपयोग कर सकते हैं।

नए संदेशों के लिए एक्सटेंशन जिस पथ को देखता है उसे उपयोगकर्ता-कॉन्फ़िगर करने योग्य बनाएं:

  1. extension.yaml फ़ाइल में, एक params अनुभाग जोड़ें:

    - param: MESSAGE_PATH
  label: Message path
  description: >-
    What is the path at which the original text of a message can be found?
  type: string
  default: /messages/{pushId}/original
  required: true
  immutable: false

    यह एक नए स्ट्रिंग पैरामीटर को परिभाषित करता है जिसे उपयोगकर्ताओं को आपका एक्सटेंशन इंस्टॉल करते समय सेट करने के लिए प्रेरित किया जाएगा।

  2. अभी भी extension.yaml फ़ाइल में, अपने makeuppercase घोषणा पर वापस जाएं और resource फ़ील्ड को निम्नलिखित में बदलें:

    resource: projects/_/instances/${DATABASE_INSTANCE}/refs/${param:MESSAGE_PATH}

    ${param:MESSAGE_PATH} टोकन आपके द्वारा अभी-अभी परिभाषित पैरामीटर का संदर्भ है। जब आपका एक्सटेंशन चलता है, तो इस टोकन को उपयोगकर्ता द्वारा उस पैरामीटर के लिए कॉन्फ़िगर किए गए किसी भी मान से बदल दिया जाएगा, जिसके परिणामस्वरूप makeuppercase फ़ंक्शन उपयोगकर्ता द्वारा निर्दिष्ट पथ को सुनेगा। आप इस सिंटैक्स का उपयोग extension.yaml (और POSTINSTALL.md में - उस पर बाद में और अधिक) में कहीं भी किसी भी उपयोगकर्ता-परिभाषित पैरामीटर को संदर्भित करने के लिए कर सकते हैं।

  3. आप अपने फ़ंक्शन कोड से उपयोगकर्ता-परिभाषित पैरामीटर तक भी पहुंच सकते हैं।

    पिछले अनुभाग में आपके द्वारा लिखे गए फ़ंक्शन में, आपने परिवर्तनों को देखने के लिए पथ को हार्ड-कोड किया था। इसके बजाय उपयोगकर्ता द्वारा परिभाषित मान को संदर्भित करने के लिए ट्रिगर परिभाषा बदलें:

    फ़ंक्शन/index.js

    export const makeuppercase = database.ref(process.env.MESSAGE_PATH).onCreate

    ध्यान दें कि फायरबेस एक्सटेंशन में, यह परिवर्तन पूरी तरह से दस्तावेज़ीकरण के लिए है: जब क्लाउड फ़ंक्शन को एक्सटेंशन के हिस्से के रूप में तैनात किया जाता है, तो यह extension.yaml फ़ाइल से ट्रिगर परिभाषा का उपयोग करता है और फ़ंक्शन परिभाषा में निर्दिष्ट मान को अनदेखा करता है। फिर भी, अपने कोड में यह दर्ज करना एक अच्छा विचार है कि यह मान कहां से आता है।

  4. आपको ऐसा कोड परिवर्तन करना निराशाजनक लग सकता है जिसका कोई रनटाइम प्रभाव नहीं है, लेकिन सीखने योग्य महत्वपूर्ण सबक यह है कि आप अपने फ़ंक्शन कोड में किसी भी उपयोगकर्ता-परिभाषित पैरामीटर तक पहुंच सकते हैं और इसे फ़ंक्शन के तर्क में एक सामान्य मान के रूप में उपयोग कर सकते हैं। इस क्षमता के संकेत के रूप में, यह प्रदर्शित करने के लिए निम्नलिखित लॉग स्टेटमेंट जोड़ें कि आप वास्तव में उपयोगकर्ता द्वारा परिभाषित मूल्य तक पहुंच रहे हैं:

    फ़ंक्शन/index.js

    export const makeuppercase = database.ref(process.env.MESSAGE_PATH).onCreate(
  async (snapshot, context) => {
    logger.log("Found new message at ", snapshot.ref);

    // Grab the current value of what was written to the Realtime Database.
    ...

  5. आम तौर पर, जब उपयोगकर्ता कोई एक्सटेंशन इंस्टॉल करते हैं तो उन्हें पैरामीटर के लिए मान प्रदान करने के लिए कहा जाता है। हालाँकि, जब आप परीक्षण और विकास के लिए एमुलेटर का उपयोग करते हैं, तो आप इंस्टॉलेशन प्रक्रिया को छोड़ देते हैं, इसलिए आप इसके बजाय एक env फ़ाइल का उपयोग करके उपयोगकर्ता-परिभाषित मापदंडों के लिए मान प्रदान करते हैं।

    functions/integration-tests/extensions/rtdb-uppercase-messages.env खोलें और GREETING परिभाषा को निम्नलिखित से बदलें:

    MESSAGE_PATH=/msgs/{pushId}/original

    ध्यान दें कि उपरोक्त पथ डिफ़ॉल्ट पथ और आपके द्वारा पहले परिभाषित पथ से भिन्न है; जब आप अपना अद्यतन एक्सटेंशन आज़माते हैं तो यह केवल स्वयं को साबित करने के लिए होता है कि आपकी परिभाषा प्रभावी हो रही है।

  6. अब, एमुलेटर को पुनरारंभ करें और एक बार फिर डेटाबेस एमुलेटर यूआई पर जाएं।

    आपके द्वारा ऊपर परिभाषित पथ का उपयोग करके डेटाबेस के रूट नोड को संपादित करें:

    • फ़ील्ड: msgs
    • प्रकार: json
    • मूल्य: {"11": {"original": "recipe"}}

    जब आप अपने डेटाबेस में परिवर्तन सहेजते हैं, तो एक्सटेंशन का makeuppercase फ़ंक्शन पहले की तरह ट्रिगर होना चाहिए, लेकिन अब इसे कंसोल लॉग में उपयोगकर्ता-परिभाषित पैरामीटर भी प्रिंट करना चाहिए।

7. उपयोगकर्ता-परिभाषित तर्क के लिए इवेंट हुक प्रदान करें

एक एक्सटेंशन लेखक के रूप में आप पहले ही देख चुके हैं कि कैसे एक फायरबेस उत्पाद आपके एक्सटेंशन-प्रदत्त तर्क को ट्रिगर कर सकता है: रीयलटाइम डेटाबेस में नए रिकॉर्ड का निर्माण आपके makeuppercase फ़ंक्शन को ट्रिगर करता है। आपके एक्सटेंशन का आपके एक्सटेंशन को इंस्टॉल करने वाले उपयोगकर्ताओं के साथ एक समान संबंध हो सकता है: आपका एक्सटेंशन उस तर्क को ट्रिगर कर सकता है जिसे उपयोगकर्ता परिभाषित करता है।

एक एक्सटेंशन सिंक्रोनस हुक , एसिंक्रोनस हुक या दोनों प्रदान कर सकता है। सिंक्रोनस हुक उपयोगकर्ताओं को कार्य करने का एक तरीका देते हैं जो एक्सटेंशन के किसी एक कार्य को पूरा करने से रोकते हैं। यह उपयोगी हो सकता है, उदाहरण के लिए, उपयोगकर्ताओं को किसी एक्सटेंशन के अपना काम करने से पहले कस्टम प्रीप्रोसेसिंग करने का एक तरीका देना।

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

एसिंक्रोनस हुक जोड़ने के लिए इन चरणों का पालन करें:

  1. extension.yaml फ़ाइल में, निम्न अनुभाग जोड़ें, जो एक्सटेंशन द्वारा उत्सर्जित एक ईवेंट प्रकार की घोषणा करता है:

    events:
  - type: test-publisher.rtdb-uppercase-messages.v1.complete
    description: >-
      Occurs when message uppercasing completes. The event subject will contain
      the RTDB URL of the uppercase message.

    ईवेंट प्रकार सार्वभौमिक रूप से अद्वितीय होने चाहिए; विशिष्टता सुनिश्चित करने के लिए, हमेशा अपने ईवेंट को निम्न प्रारूप का उपयोग करके नाम दें: <publisher-id>.<extension-id>.<version>.<description> . (आपके पास अभी तक प्रकाशक आईडी नहीं है, इसलिए अभी के लिए test-publisher उपयोग करें।)

  2. makeuppercase फ़ंक्शन के अंत में, कुछ कोड जोड़ें जो आपके द्वारा अभी घोषित प्रकार की एक घटना प्रकाशित करता है:

    फ़ंक्शन/index.js

    // Import the Eventarc library:
import { initializeApp } from "firebase-admin/app";
import { getEventarc } from "firebase-admin/eventarc";

const app = initializeApp();

// In makeuppercase, after upperRef.set(uppercase), add:

// Set eventChannel to a newly-initialized channel, or `undefined` if events
// aren't enabled.
const eventChannel =
  process.env.EVENTARC_CHANNEL &&
  getEventarc().channel(process.env.EVENTARC_CHANNEL, {
    allowedEventTypes: process.env.EXT_SELECTED_EVENTS,
  });

// If events are enabled, publish a `complete` event to the configured
// channel.
eventChannel &&
  eventChannel.publish({
    type: "test-publisher.rtdb-uppercase-messages.v1.complete",
    subject: upperRef.toString(),
    data: {
      "original": original,
      "uppercase": uppercase,
    },
  });

    यह उदाहरण कोड इस तथ्य का लाभ उठाता है कि EVENTARC_CHANNEL पर्यावरण चर केवल तभी परिभाषित होता है जब उपयोगकर्ता कम से कम एक ईवेंट प्रकार सक्षम करता है। यदि EVENTARC_CHANNEL परिभाषित नहीं है, तो कोड किसी भी ईवेंट को प्रकाशित करने का प्रयास नहीं करता है।

    आप किसी इवेंटआर्क इवेंट में अतिरिक्त जानकारी संलग्न कर सकते हैं। उपरोक्त उदाहरण में, ईवेंट में एक subject फ़ील्ड है जिसमें नव-निर्मित मान का संदर्भ होता है, और एक data पेलोड होता है जिसमें मूल और अपरकेस संदेश होते हैं। इवेंट को ट्रिगर करने वाले उपयोगकर्ता-परिभाषित फ़ंक्शन इस जानकारी का उपयोग कर सकते हैं।

  3. आम तौर पर, EVENTARC_CHANNEL और EXT_SELECTED_EVENTS पर्यावरण चर को इंस्टॉलेशन के दौरान उपयोगकर्ता द्वारा चुने गए विकल्पों के आधार पर परिभाषित किया जाता है। एमुलेटर के साथ परीक्षण के लिए, इन वेरिएबल्स को rtdb-uppercase-messages.env फ़ाइल में मैन्युअल रूप से परिभाषित करें:

    EVENTARC_CHANNEL=locations/us-central1/channels/firebase
EXT_SELECTED_EVENTS=test-publisher.rtdb-uppercase-messages.v1.complete

इस बिंदु पर, आपने अपने एक्सटेंशन में एक एसिंक्रोनस ईवेंट हुक जोड़ने के लिए आवश्यक चरण पूरे कर लिए हैं।

इस नई सुविधा को आज़माने के लिए जिसे आपने अभी लागू किया है, अगले कुछ चरणों में, उस उपयोगकर्ता की भूमिका निभाएं जो एक्सटेंशन इंस्टॉल कर रहा है:

  1. functions/integration-tests निर्देशिका से, एक नया फ़ायरबेस प्रोजेक्ट आरंभ करें:

    firebase init functions

    संकेत मिलने पर, एक डिफ़ॉल्ट प्रोजेक्ट स्थापित करने से इनकार करें, क्लाउड फ़ंक्शंस भाषा के रूप में जावास्क्रिप्ट का चयन करें, और आवश्यक निर्भरताएँ स्थापित करें। यह प्रोजेक्ट एक उपयोगकर्ता के प्रोजेक्ट का प्रतिनिधित्व करता है, जिस पर आपका एक्सटेंशन इंस्टॉल है।

  2. integration-tests/functions/index.js संपादित करें और निम्नलिखित कोड पेस्ट करें:

    import { logger } from "firebase-functions/v1";
import { onCustomEventPublished } from "firebase-functions/v2/eventarc";

import { initializeApp } from "firebase-admin/app";
import { getDatabase } from "firebase-admin/database";

const app = initializeApp();

export const extraemphasis = onCustomEventPublished(
  "test-publisher.rtdb-uppercase-messages.v1.complete",
  async (event) => {
    logger.info("Received makeuppercase completed event", event);

    const refUrl = event.subject;
    const ref = getDatabase().refFromURL(refUrl);
    const upper = (await ref.get()).val();
    return ref.set(`${upper}!!!`);
  }
);

    यह पोस्ट-प्रोसेसिंग फ़ंक्शन का एक उदाहरण है जिसे उपयोगकर्ता लिख ​​सकता है। इस मामले में, फ़ंक्शन एक complete ईवेंट प्रकाशित करने के लिए एक्सटेंशन को सुनता है, और जब ट्रिगर होता है, तो नए बड़े संदेश में तीन विस्मयादिबोधक बिंदु जोड़ता है।

  3. एमुलेटर को पुनरारंभ करें. एम्यूलेटर एक्सटेंशन के फ़ंक्शंस के साथ-साथ "उपयोगकर्ता" द्वारा परिभाषित पोस्ट-प्रोसेसिंग फ़ंक्शन को भी लोड करेगा।

  4. डेटाबेस एमुलेटर यूआई पर जाएं और आपके द्वारा ऊपर परिभाषित पथ का उपयोग करके डेटाबेस के रूट नोड को संपादित करें:

    • फ़ील्ड: msgs
    • प्रकार: json
    • मूल्य: {"11": {"original": "recipe"}}

    जब आप अपने डेटाबेस में परिवर्तन सहेजते हैं, तो एक्सटेंशन का makeuppercase फ़ंक्शन और उपयोगकर्ता का extraemphasis फ़ंक्शन अनुक्रम में ट्रिगर होना चाहिए, जिसके परिणामस्वरूप upper फ़ील्ड को RECIPE!!! .

8. जीवनचक्र ईवेंट हैंडलर जोड़ें

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

फायरबेस एक्सटेंशन आपके जीवनचक्र ईवेंट हैंडलर को चलाने के लिए क्लाउड टास्क का उपयोग करता है। आप क्लाउड फ़ंक्शंस का उपयोग करके ईवेंट हैंडलर को परिभाषित करते हैं; जब भी आपके एक्सटेंशन का कोई उदाहरण समर्थित जीवनचक्र घटनाओं में से एक तक पहुंचता है, यदि आपने एक हैंडलर परिभाषित किया है, तो यह हैंडलर को क्लाउड कार्य कतार में जोड़ देगा। इसके बाद क्लाउड टास्क एसिंक्रोनस रूप से हैंडलर को निष्पादित करेगा। जब एक जीवनचक्र ईवेंट हैंडलर चल रहा होता है, तो फायरबेस कंसोल उपयोगकर्ता को रिपोर्ट करेगा कि एक्सटेंशन इंस्टेंस में एक प्रोसेसिंग कार्य प्रगति पर है। उपयोगकर्ता को चालू स्थिति और कार्य पूरा होने की रिपोर्ट वापस देना आपके हैंडलर फ़ंक्शन पर निर्भर है।

एक जीवनचक्र ईवेंट हैंडलर जोड़ने के लिए जो मौजूदा संदेशों को बैकफ़िल करता है, निम्न कार्य करें:

  1. एक नए क्लाउड फ़ंक्शन को परिभाषित करें जो कार्य कतार घटनाओं द्वारा ट्रिगर होता है:

    फ़ंक्शन/index.js

    import { tasks } from "firebase-functions/v1";

import { getDatabase } from "firebase-admin/database";
import { getExtensions } from "firebase-admin/extensions";
import { getFunctions } from "firebase-admin/functions";

export const backfilldata = tasks.taskQueue().onDispatch(async () => {
  const batch = await getDatabase()
    .ref(process.env.MESSAGE_PATH)
    .parent.parent.orderByChild("upper")
    .limitToFirst(20)
    .get();

  const promises = [];
  for (const key in batch.val()) {
    const msg = batch.child(key);
    if (msg.hasChild("original") && !msg.hasChild("upper")) {
      const upper = msg.child("original").val().toUpperCase();
      promises.push(msg.child("upper").ref.set(upper));
    }
  }
  await Promise.all(promises);

  if (promises.length > 0) {
    const queue = getFunctions().taskQueue(
      "backfilldata",
      process.env.EXT_INSTANCE_ID
    );
    return queue.enqueue({});
  } else {
    return getExtensions()
      .runtime()
      .setProcessingState("PROCESSING_COMPLETE", "Backfill complete.");
  }
});

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

  2. extension.yaml फ़ाइल में, अपने बैकफ़िल फ़ंक्शन को एक एक्सटेंशन संसाधन के रूप में घोषित करें जिसमें taskQueueTrigger संपत्ति है:

    resources:
  - name: makeuppercase
    ...
  - name: backfilldata
    type: firebaseextensions.v1beta.function
    description: >-
      Backfill existing messages with uppercase versions
    properties:
      runtime: "nodejs18"
      taskQueueTrigger: {}

    फिर फ़ंक्शन को onInstall जीवनचक्र ईवेंट के लिए हैंडलर के रूप में घोषित करें:

    lifecycleEvents:
  onInstall:
    function: backfilldata
    processingMessage: Uppercasing existing messages

  3. हालाँकि मौजूदा संदेशों को बैकफिल करना अच्छा है, एक्सटेंशन इसके बिना भी काम कर सकता है। इस तरह की स्थितियों में, आपको जीवनचक्र ईवेंट हैंडलर को चलाना वैकल्पिक बनाना चाहिए।

    ऐसा करने के लिए, extension.yaml में एक नया पैरामीटर जोड़ें:

    - param: DO_BACKFILL
  label: Backfill existing messages
  description: >-
    Generate uppercase versions of existing messages?
  type: select
  required: true
  options:
    - label: Yes
      value: true
    - label: No
      value: false

    फिर बैकफ़िल फ़ंक्शन की शुरुआत में, DO_BACKFILL पैरामीटर का मान जांचें और यदि यह सेट नहीं है तो जल्दी बाहर निकलें:

    फ़ंक्शन/index.js

    if (!process.env.DO_BACKFILL) {
  return getExtensions()
    .runtime()
    .setProcessingState("PROCESSING_COMPLETE", "Backfill skipped.");
}

उपरोक्त परिवर्तनों के साथ, एक्सटेंशन अब इंस्टॉल होने पर मौजूदा संदेशों को अपरकेस में बदल देगा।

इस बिंदु तक, आपने अपना एक्सटेंशन विकसित करने और चल रहे परिवर्तनों का परीक्षण करने के लिए एक्सटेंशन एमुलेटर का उपयोग किया था। हालाँकि, एक्सटेंशन एमुलेटर इंस्टॉलेशन प्रक्रिया को छोड़ देता है, इसलिए अपने onInstall इवेंट हैंडलर का परीक्षण करने के लिए, आपको एक वास्तविक प्रोजेक्ट में एक्सटेंशन इंस्टॉल करना होगा। हालाँकि, यह उतना ही अच्छा है, क्योंकि इस स्वचालित बैकफ़िल सुविधा के जुड़ने से, ट्यूटोरियल एक्सटेंशन अब कोड-पूर्ण हो गया है!

9. एक वास्तविक फायरबेस प्रोजेक्ट में तैनात करें

हालाँकि एक्सटेंशन एमुलेटर विकास के दौरान किसी एक्सटेंशन पर तेजी से पुनरावृत्ति करने के लिए एक बेहतरीन उपकरण है, कुछ बिंदु पर आप इसे एक वास्तविक प्रोजेक्ट में आज़माना चाहेंगे।

ऐसा करने के लिए, पहले कुछ सेवाओं को सक्षम करके एक नया प्रोजेक्ट स्थापित करें:

  1. फायरबेस कंसोल में, एक नया प्रोजेक्ट जोड़ें।
  2. अपने प्रोजेक्ट को पे-एज़-यू-गो ब्लेज़ योजना में अपग्रेड करें । फायरबेस के लिए क्लाउड फ़ंक्शंस के लिए आपके प्रोजेक्ट के लिए एक बिलिंग खाते की आवश्यकता होती है, इसलिए एक्सटेंशन इंस्टॉल करने के लिए आपको एक बिलिंग खाते की भी आवश्यकता होती है।
  3. अपने नए प्रोजेक्ट में, रीयल-टाइम डेटाबेस सक्षम करें ।
  4. चूंकि आप इंस्टॉलेशन पर मौजूदा डेटा को बैकफ़िल करने की अपने एक्सटेंशन की क्षमता का परीक्षण करना चाहते हैं, तो अपने वास्तविक समय डेटाबेस उदाहरण में कुछ नमूना डेटा आयात करें:
    1. कुछ बीज आरटीडीबी डेटा डाउनलोड करें।
    2. फायरबेस कंसोल के रीयल-टाइम डेटाबेस पृष्ठ पर, (अधिक) > JSON आयात करें पर क्लिक करें और आपके द्वारा अभी डाउनलोड की गई फ़ाइल का चयन करें।

  5. orderByChild विधि का उपयोग करने के लिए बैकफ़िल फ़ंक्शन को सक्षम करने के लिए, डेटाबेस को upper मान पर संदेशों को अनुक्रमित करने के लिए कॉन्फ़िगर करें:

    {
  "rules": {
    ".read": false,
    ".write": false,
    "messages": {
      ".indexOn": "upper"
    }
  }
}

अब अपने एक्सटेंशन को स्थानीय स्रोत से नए प्रोजेक्ट में इंस्टॉल करें:

  1. अपने फायरबेस प्रोजेक्ट के लिए एक नई निर्देशिका बनाएं:

    mkdir ~/extensions-live-test && cd ~/extensions-live-test

  2. कार्यशील निर्देशिका में फ़ायरबेस प्रोजेक्ट प्रारंभ करें:

    firebase init database

    संकेत मिलने पर, आपके द्वारा अभी बनाया गया प्रोजेक्ट चुनें।

  3. अपने स्थानीय फायरबेस प्रोजेक्ट में एक्सटेंशन इंस्टॉल करें:

    firebase ext:install /path/to/rtdb-uppercase-messages

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

    आपके द्वारा कॉन्फ़िगरेशन विकल्प चुनने के बाद, फ़ायरबेस सीएलआई आपके कॉन्फ़िगरेशन को extensions निर्देशिका में सहेज लेगा और firebase.json फ़ाइल में एक्सटेंशन स्रोत स्थान रिकॉर्ड करेगा। सामूहिक रूप से, इन दोनों रिकॉर्ड्स को एक्सटेंशन मेनिफेस्ट कहा जाता है। उपयोगकर्ता अपने एक्सटेंशन कॉन्फ़िगरेशन को सहेजने और इसे विभिन्न परियोजनाओं पर तैनात करने के लिए मैनिफ़ेस्ट का उपयोग कर सकते हैं।

  4. अपने एक्सटेंशन कॉन्फ़िगरेशन को अपने लाइव प्रोजेक्ट पर तैनात करें:

    firebase deploy --only extensions

यदि सब कुछ ठीक रहा, तो फायरबेस सीएलआई को आपके एक्सटेंशन को आपके प्रोजेक्ट पर अपलोड करना चाहिए और इसे इंस्टॉल करना चाहिए। इंस्टॉलेशन पूरा होने के बाद, बैकफ़िल कार्य चलेगा और, कुछ ही मिनटों में, आपका डेटाबेस अपरकेस संदेशों के साथ अपडेट हो जाएगा। संदेश डेटाबेस में कुछ नए नोड जोड़ें और सुनिश्चित करें कि एक्सटेंशन नए संदेशों के लिए भी काम कर रहा है।

10. दस्तावेज़ लिखें

इससे पहले कि आप अपना एक्सटेंशन उपयोगकर्ताओं के साथ साझा करें, सुनिश्चित करें कि आप उन्हें सफल होने के लिए पर्याप्त दस्तावेज़ प्रदान कर रहे हैं।

जब आपने एक्सटेंशन प्रोजेक्ट आरंभ किया, तो फायरबेस सीएलआई ने न्यूनतम आवश्यक दस्तावेज़ के स्टब संस्करण बनाए। आपके द्वारा बनाए गए एक्सटेंशन को सटीक रूप से प्रतिबिंबित करने के लिए इन फ़ाइलों को अपडेट करें।

एक्सटेंशन.yaml

आप पहले से ही इस फ़ाइल को अपडेट कर रहे हैं क्योंकि आपने यह एक्सटेंशन विकसित कर लिया है, इसलिए आपको अभी कोई और अपडेट करने की आवश्यकता नहीं है।

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

प्रीइंस्टॉल.md

इस फ़ाइल में, उपयोगकर्ता को आपके एक्सटेंशन को इंस्टॉल करने से पहले आवश्यक जानकारी प्रदान करें: संक्षेप में बताएं कि एक्सटेंशन क्या करता है, किसी भी पूर्वापेक्षा को समझाएं, और उपयोगकर्ता को एक्सटेंशन इंस्टॉल करने के बिलिंग निहितार्थों के बारे में जानकारी दें। यदि आपके पास अतिरिक्त जानकारी वाली कोई वेबसाइट है, तो उसे लिंक करने के लिए यह एक अच्छी जगह है।

इस फ़ाइल का टेक्स्ट उपयोगकर्ता को एक्सटेंशन हब में और firebase ext:info कमांड द्वारा प्रदर्शित किया जाता है।

यहां प्रीइंस्टॉल फ़ाइल का एक उदाहरण दिया गया है:

Use this extension to automatically convert strings to upper case when added to
a specified Realtime Database path.

This extension expects a database layout like the following example:

    "messages": {
      MESSAGE_ID: {
        "original": MESSAGE_TEXT
      },
      MESSAGE_ID: {
        "original": MESSAGE_TEXT
      },
    }

When you create new string records, this extension creates a new sibling record
with upper-cased text:

    MESSAGE_ID: {
      "original": MESSAGE_TEXT,
      "upper": UPPERCASE_MESSAGE_TEXT,
    }

#### Additional setup

Before installing this extension, make sure that you've
[set up Realtime Database](https://firebase.google.com/docs/database/quickstart)
in your Firebase project.

#### Billing

To install an extension, your project must be on the
[Blaze (pay as you go) plan](https://firebase.google.com/pricing).

- This extension uses other Firebase and Google Cloud Platform services, which
  have associated charges if you exceed the service's no-cost tier:
  - Realtime Database
  - Cloud Functions (Node.js 10+ runtime)
    [See FAQs](https://firebase.google.com/support/faq#extensions-pricing)
- If you enable events,
  [Eventarc fees apply](https://cloud.google.com/eventarc/pricing).

POSTINSTALL.md

इस फ़ाइल में आपके एक्सटेंशन को सफलतापूर्वक इंस्टॉल करने के बाद उपयोगकर्ताओं के लिए उपयोगी जानकारी शामिल है: उदाहरण के लिए, अनुवर्ती सेटअप चरण, कार्रवाई में एक्सटेंशन का एक उदाहरण, इत्यादि।

एक्सटेंशन कॉन्फ़िगर और इंस्टॉल होने के बाद POSTINSTALL.md की सामग्री फायरबेस कंसोल में प्रदर्शित होती है। आप इस फ़ाइल में उपयोगकर्ता मापदंडों का संदर्भ दे सकते हैं और उन्हें कॉन्फ़िगर किए गए मानों से बदल दिया जाएगा।

यहां ट्यूटोरियल एक्सटेंशन के लिए पोस्ट-इंस्टॉल फ़ाइल का एक उदाहरण दिया गया है:

### See it in action

You can test out this extension right away!

1.  Go to your
    [Realtime Database dashboard](https://console.firebase.google.com/project/${param:PROJECT_ID}/database/${param:PROJECT_ID}/data) in the Firebase console.

1.  Add a message string to a path that matches the pattern `${param:MESSAGE_PATH}`.

1.  In a few seconds, you'll see a sibling node named `upper` that contains the
    message in upper case.

### Using the extension

We recommend adding data by pushing -- for example,
`firebase.database().ref().push()` -- because pushing assigns an automatically
generated ID to the node in the database. During retrieval, these nodes are
guaranteed to be ordered by the time they were added. Learn more about reading
and writing data for your platform (iOS, Android, or Web) in the
[Realtime Database documentation](https://firebase.google.com/docs/database/).

### Monitoring

As a best practice, you can
[monitor the activity](https://firebase.google.com/docs/extensions/manage-installed-extensions#monitor)
of your installed extension, including checks on its health, usage, and logs.

चेंजलॉग.md

आपको CHANGELOG.md फ़ाइल में किसी एक्सटेंशन के रिलीज़ के बीच किए गए परिवर्तनों का भी दस्तावेज़ीकरण करना चाहिए।

चूँकि उदाहरण एक्सटेंशन पहले कभी प्रकाशित नहीं हुआ है, परिवर्तन लॉग में केवल एक प्रविष्टि है:

## Version 0.0.1

Initial release of the _Convert messages to upper case_ extension.

README.md

अधिकांश एक्सटेंशन एक्सटेंशन के भंडार पर जाने वाले उपयोगकर्ताओं के लाभ के लिए एक रीडमी फ़ाइल भी प्रदान करते हैं। आप इस फ़ाइल को हाथ से लिख सकते हैं या कमांड का उपयोग करके रीड मी जेनरेट कर सकते हैं।

इस गाइड के प्रयोजन के लिए, रीडमी फ़ाइल लिखना छोड़ें।

अतिरिक्त दस्तावेज़ीकरण

ऊपर चर्चा किया गया दस्तावेज़ दस्तावेज़ीकरण का न्यूनतम सेट है जो आपको उपयोगकर्ताओं को प्रदान करना चाहिए। कई एक्सटेंशनों को उपयोगकर्ताओं द्वारा सफलतापूर्वक उपयोग करने के लिए अधिक विस्तृत दस्तावेज़ीकरण की आवश्यकता होती है। जब यह मामला हो, तो आपको अतिरिक्त दस्तावेज़ लिखना चाहिए और इसे किसी ऐसे स्थान पर होस्ट करना चाहिए जहां आप उपयोगकर्ताओं को इंगित कर सकें।

इस गाइड के प्रयोजन के लिए, अधिक व्यापक दस्तावेज़ लिखना छोड़ें।

11. एक्सटेंशन हब पर प्रकाशित करें

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

जब आप एक्सटेंशन हब पर अपना काम प्रकाशित करने के लिए तैयार हों तो आप इसे इस प्रकार करेंगे:

  1. यदि आप अपना पहला एक्सटेंशन प्रकाशित कर रहे हैं, तो एक्सटेंशन प्रकाशक के रूप में पंजीकरण करें । जब आप एक एक्सटेंशन प्रकाशक के रूप में पंजीकरण करते हैं, तो आप एक प्रकाशक आईडी बनाते हैं जो उपयोगकर्ताओं को आपके एक्सटेंशन के लेखक के रूप में तुरंत पहचानने देती है।

  2. अपने एक्सटेंशन के स्रोत कोड को सार्वजनिक रूप से सत्यापन योग्य स्थान पर होस्ट करें। जब आपका कोड सत्यापन योग्य स्रोत से उपलब्ध होता है, तो फायरबेस आपके एक्सटेंशन को सीधे इस स्थान से प्रकाशित कर सकता है। ऐसा करने से यह सुनिश्चित करने में मदद मिलती है कि आप अपने एक्सटेंशन का वर्तमान में जारी संस्करण प्रकाशित कर रहे हैं, और उपयोगकर्ताओं को उनके प्रोजेक्ट में इंस्टॉल किए जा रहे कोड की जांच करने में मदद मिलती है।

    वर्तमान में, इसका अर्थ है आपके एक्सटेंशन को सार्वजनिक GitHub रिपॉजिटरी में उपलब्ध कराना।

  3. firebase ext:dev:upload कमांड का उपयोग करके अपने एक्सटेंशन को एक्सटेंशन हब पर अपलोड करें।

  4. फायरबेस कंसोल में अपने प्रकाशक डैशबोर्ड पर जाएं, आपके द्वारा अभी अपलोड किया गया एक्सटेंशन ढूंढें, और "एक्सटेंशन हब पर प्रकाशित करें" पर क्लिक करें। इसके लिए हमारे समीक्षा स्टाफ से समीक्षा का अनुरोध किया जाता है, जिसमें कुछ दिन लग सकते हैं। यदि स्वीकृत हो जाता है, तो एक्सटेंशन एक्सटेंशन हब पर प्रकाशित किया जाएगा। यदि अस्वीकार कर दिया जाता है, तो आपको कारण बताने वाला एक संदेश मिलेगा; फिर आप रिपोर्ट किए गए मुद्दों का समाधान कर सकते हैं और समीक्षा के लिए पुनः सबमिट कर सकते हैं।