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

इस पेज पर, एक सामान्य Firebase एक्सटेंशन बनाने का तरीका बताया गया है. इसे अपने प्रोजेक्ट में इंस्टॉल किया जा सकता है या दूसरों के साथ शेयर किया जा सकता है. Firebase एक्सटेंशन का यह आसान उदाहरण, आपके रीयलटाइम डेटाबेस में मौजूद मैसेज पर नज़र रखेगा और उन्हें बड़े अक्षरों में बदल देगा.

1. अपना एनवायरमेंट सेट अप करना और प्रोजेक्ट शुरू करना

एक्सटेंशन बनाना शुरू करने से पहले, आपको ज़रूरी टूल के साथ एक बिल्ड एनवायरमेंट सेट अप करना होगा.

  1. Node.js 16 या इसके बाद का वर्शन इंस्टॉल करें. Node को इंस्टॉल करने का एक तरीका, nvm (या nvm-windows) का इस्तेमाल करना है.

  2. Firebase CLI का सबसे नया वर्शन इंस्टॉल करें या उस पर अपडेट करें. npm का इस्तेमाल करके इंस्टॉल या अपडेट करने के लिए, यह निर्देश चलाएं:

    npm install -g firebase-tools

अब Firebase CLI का इस्तेमाल करके, नया एक्सटेंशन प्रोजेक्ट शुरू करें:

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

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

  2. Firebase CLI की ext:dev:init कमांड चलाएं:

    firebase ext:dev:init

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

2. एम्युलेटर का इस्तेमाल करके, उदाहरण एक्सटेंशन आज़माएं

Firebase CLI ने नई एक्सटेंशन डायरेक्ट्री को शुरू करते समय, एक सामान्य उदाहरण फ़ंक्शन और एक integration-tests डायरेक्ट्री बनाई. इस डायरेक्ट्री में, Firebase Emulator Suite का इस्तेमाल करके एक्सटेंशन चलाने के लिए ज़रूरी फ़ाइलें होती हैं.

एम्युलेटर में उदाहरण के तौर पर दिए गए एक्सटेंशन को चलाकर देखें:

  1. integration-tests डायरेक्ट्री पर जाएं:

    cd functions/integration-tests

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

    firebase emulators:start --project=demo-test

    एम्युलेटर, एक्सटेंशन को पहले से तय किए गए "डमी" प्रोजेक्ट (demo-test) में लोड करता है. अब तक, एक्सटेंशन में सिर्फ़ एक एचटीटीपी ट्रिगर किया गया फ़ंक्शन, greetTheWorld शामिल है. इसे ऐक्सेस करने पर, यह "hello world" मैसेज दिखाता है.

  3. एम्युलेटर के चालू रहने के दौरान, एक्सटेंशन के greetTheWorld फ़ंक्शन को आज़माएं. इसके लिए, उस यूआरएल पर जाएं जिसे आपने एक्सटेंशन शुरू करते समय प्रिंट किया था.

    आपका ब्राउज़र, "नमस्ते, दुनिया के लोगों!" मैसेज दिखाता है.

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

    functions/index.js

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

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 फ़ंक्शन में थोड़ा बदलाव करके देखें:

    functions/index.js

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

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

3. extension.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 फ़ील्ड में इस्तेमाल किए गए नाम रखने के तरीके पर ध्यान दें: आधिकारिक Firebase एक्सटेंशन के नाम में एक प्रीफ़िक्स होता है. यह प्रीफ़िक्स, उस मुख्य Firebase प्रॉडक्ट के बारे में बताता है जिस पर एक्सटेंशन काम करता है. इसके बाद, एक्सटेंशन के काम करने के तरीके के बारे में जानकारी दी जाती है. आपको अपने एक्सटेंशन में भी इसी कन्वेंशन का इस्तेमाल करना चाहिए.

  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. क्लाउड फ़ंक्शन लिखें और उसे एक्सटेंशन संसाधन के तौर पर घोषित करें

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

  1. अपनी पसंद के एडिटर या आईडीई में, एक्सटेंशन के फ़ंक्शन के सोर्स को खोलें. यह एक्सटेंशन की functions डायरेक्ट्री में मौजूद होता है. इसके कॉन्टेंट को इससे बदलें:

    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);
});

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

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

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

  2. आपके एक्सटेंशन में मौजूद हर फ़ंक्शन को extension.yaml फ़ाइल में एलान किया जाना चाहिए. उदाहरण के तौर पर दिए गए एक्सटेंशन ने greetTheWorld को एक्सटेंशन के सिर्फ़ एक Cloud फ़ंक्शन के तौर पर एलान किया है. अब आपने इसे 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. आपका एक्सटेंशन अब रीयलटाइम डेटाबेस को ट्रिगर के तौर पर इस्तेमाल कर रहा है. इसलिए, आपको अपने एम्युलेटर के कॉन्फ़िगरेशन को अपडेट करना होगा, ताकि आरटीडीबी एम्युलेटर को Cloud Functions एम्युलेटर के साथ चलाया जा सके:

    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 फ़ील्ड का अपरकेस कॉन्टेंट होता है.

अब आपके पास एक पूरा, लेकिन आसान एक्सटेंशन है, जो RTDB इंस्टेंस पर काम करता है. इसके बाद के सेक्शन में, कुछ अतिरिक्त सुविधाओं की मदद से इस एक्सटेंशन को बेहतर बनाया जाएगा. इसके बाद, आपको एक्सटेंशन को दूसरों के साथ शेयर करने का विकल्प मिलेगा. आखिर में, Extensions Hub पर एक्सटेंशन को पब्लिश करने का तरीका जानें.

5. एपीआई और भूमिकाओं का एलान करना

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

किसी प्रॉडक्ट के इवेंट ट्रिगर करने के लिए, भूमिकाओं का एलान करना ज़रूरी नहीं है. हालांकि, इसके साथ इंटरैक्ट करने के लिए, आपको भूमिका का एलान करना होगा. आपने पिछले चरण में जो फ़ंक्शन जोड़ा है वह Realtime Database में लिखता है. इसलिए, आपको extension.yaml में यह एलान जोड़ना होगा:

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

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

6. उपयोगकर्ता के हिसाब से कॉन्फ़िगर किए जा सकने वाले पैरामीटर तय करना

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

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

  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. फ़ंक्शन के कोड से, उपयोगकर्ता के तय किए गए पैरामीटर भी ऐक्सेस किए जा सकते हैं.

    आपने पिछले सेक्शन में लिखे गए फ़ंक्शन में, बदलावों को ट्रैक करने के लिए पाथ को हार्ड-कोड किया है. ट्रिगर की परिभाषा में बदलाव करके, उपयोगकर्ता की तय की गई वैल्यू को रेफ़रंस करें:

    functions/index.js

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

    ध्यान दें कि Firebase एक्सटेंशन में, यह बदलाव सिर्फ़ दस्तावेज़ के लिए किया गया है: जब किसी Cloud फ़ंक्शन को एक्सटेंशन के हिस्से के तौर पर डिप्लॉय किया जाता है, तो यह extension.yaml फ़ाइल से ट्रिगर की परिभाषा का इस्तेमाल करता है. साथ ही, फ़ंक्शन की परिभाषा में तय की गई वैल्यू को अनदेखा करता है. हालांकि, यह बेहतर होगा कि आप अपने कोड में यह जानकारी दें कि यह वैल्यू कहां से मिली है.

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

    functions/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. उपयोगकर्ता के तय किए गए लॉजिक के लिए इवेंट हुक उपलब्ध कराना

एक्सटेंशन के लेखक के तौर पर, आपने पहले ही देख लिया है कि Firebase प्रॉडक्ट, एक्सटेंशन के लॉजिक को कैसे ट्रिगर कर सकता है: रीयलटाइम डेटाबेस में नए रिकॉर्ड बनाने से, आपका makeuppercase फ़ंक्शन ट्रिगर होता है. आपका एक्सटेंशन, उसे इंस्टॉल करने वाले उपयोगकर्ताओं के साथ एक जैसा व्यवहार कर सकता है: आपका एक्सटेंशन, उपयोगकर्ता के तय किए गए लॉजिक को ट्रिगर कर सकता है.

एक्सटेंशन, सिंक्रोनस हुक, एसिंक्रोनस हुक या दोनों उपलब्ध करा सकता है. सिंक्रोनस हुक, उपयोगकर्ताओं को ऐसे टास्क पूरे करने का तरीका देते हैं जो एक्सटेंशन के किसी फ़ंक्शन को पूरा होने से रोकते हैं. यह सुविधा तब काम आ सकती है, जब आपको उपयोगकर्ताओं को यह विकल्प देना हो कि एक्सटेंशन के काम करने से पहले, वे अपनी पसंद के मुताबिक प्रीप्रोसेसिंग कर सकें.

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

एसिंक्रोनस हुक जोड़ने के लिए, यह तरीका अपनाएं:

  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 फ़ंक्शन के आखिर में, कुछ ऐसा कोड जोड़ें जो अभी-अभी आपने जिस तरह का इवेंट तय किया है उसे पब्लिश करे:

    functions/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 तय नहीं किया गया है, तो कोड किसी भी इवेंट को पब्लिश करने की कोशिश नहीं करता.

    Eventarc इवेंट में अतिरिक्त जानकारी अटैच की जा सकती है. ऊपर दिए गए उदाहरण में, इवेंट में एक 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 प्रोजेक्ट शुरू करें:

    firebase init functions

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

  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. लाइफ़साइकल इवेंट हैंडलर जोड़ना

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

Firebase एक्सटेंशन, लाइफ़साइकल इवेंट हैंडलर को चलाने के लिए Cloud Tasks का इस्तेमाल करता है. Cloud Functions का इस्तेमाल करके, इवेंट हैंडलर तय किए जाते हैं. जब भी आपके एक्सटेंशन का कोई इंस्टेंस, लाइफ़साइकल के किसी ऐसे इवेंट पर पहुंचता है जिसे एक्सटेंशन के साथ इस्तेमाल किया जा सकता है, तब अगर आपने कोई हैंडलर तय किया है, तो वह हैंडलर को Cloud Tasks की कतार में जोड़ देगा. इसके बाद, Cloud Tasks हैंडलर को एसिंक्रोनस तरीके से एक्ज़ीक्यूट करेगा. लाइफ़साइकल इवेंट हैंडलर के चालू होने पर, Firebase कंसोल उपयोगकर्ता को यह सूचना देगा कि एक्सटेंशन इंस्टेंस में प्रोसेसिंग टास्क चल रहा है. यह आपके हैंडलर फ़ंक्शन पर निर्भर करता है कि वह उपयोगकर्ता को टास्क पूरा होने और मौजूदा स्थिति के बारे में बताए.

लाइफ़साइकल इवेंट हैंडलर जोड़ने के लिए, यह तरीका अपनाएं. यह हैंडलर, मौजूदा मैसेज को वापस भरता है:

  1. टास्क क्यू इवेंट से ट्रिगर होने वाला नया Cloud फ़ंक्शन तय करें:

    functions/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.");
  }
});

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

  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 lifecycle event के हैंडलर के तौर पर एलान करें:

    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 पैरामीटर की वैल्यू देखें. अगर यह सेट नहीं है, तो फ़ंक्शन से बाहर निकलें:

    functions/index.js

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

ऊपर दिए गए बदलावों के बाद, एक्सटेंशन इंस्टॉल होने पर मौजूदा मैसेज को बड़े अक्षरों में बदल देगा.

अब तक, आपने एक्सटेंशन को डेवलप करने और उसमें किए जा रहे बदलावों को टेस्ट करने के लिए, एक्सटेंशन एम्युलेटर का इस्तेमाल किया है. हालांकि, एक्सटेंशन एम्युलेटर, इंस्टॉलेशन की प्रोसेस को छोड़ देता है. इसलिए, onInstall इवेंट हैंडलर को टेस्ट करने के लिए, आपको एक्सटेंशन को किसी असली प्रोजेक्ट में इंस्टॉल करना होगा. हालांकि, यह भी ठीक है, क्योंकि ऑटोमैटिक बैकफ़िल की सुविधा जोड़ने के बाद, ट्यूटोरियल एक्सटेंशन का कोड अब पूरा हो गया है!

9. किसी असली Firebase प्रोजेक्ट में डिप्लॉय करना

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

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

  1. Firebase कंसोल में, नया प्रोजेक्ट जोड़ें.
  2. अपने प्रोजेक्ट को अपग्रेड करें और इस्तेमाल के हिसाब से पेमेंट करने वाला Blaze प्लान चुनें. Cloud Functions for Firebase के लिए, आपके प्रोजेक्ट में बिलिंग खाता होना ज़रूरी है. इसलिए, एक्सटेंशन इंस्टॉल करने के लिए भी आपके पास बिलिंग खाता होना चाहिए.
  3. अपने नए प्रोजेक्ट में, रीयलटाइम डेटाबेस चालू करें.
  4. आपको यह जांच करनी है कि एक्सटेंशन, इंस्टॉल होने पर मौजूदा डेटा को बैकफ़िल कर सकता है या नहीं. इसलिए, अपने रीयल-टाइम डेटाबेस इंस्टेंस में कुछ सैंपल डेटा इंपोर्ट करें:
    1. कुछ सीड आरटीडीबी डेटा डाउनलोड करें.
    2. Firebase कंसोल के Realtime Database पेज पर, (ज़्यादा) > JSON इंपोर्ट करें पर क्लिक करें. इसके बाद, वह फ़ाइल चुनें जिसे आपने अभी डाउनलोड किया है.

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

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

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

  1. अपने Firebase प्रोजेक्ट के लिए एक नई डायरेक्ट्री बनाएं:

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

  2. वर्किंग डायरेक्ट्री में Firebase प्रोजेक्ट शुरू करें:

    firebase init database

    जब आपसे पूछा जाए, तब वह प्रोजेक्ट चुनें जिसे आपने अभी-अभी बनाया है.

  3. एक्सटेंशन को अपने लोकल Firebase प्रोजेक्ट में इंस्टॉल करें:

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

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

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

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

    firebase deploy --only extensions

अगर सब कुछ ठीक रहा, तो Firebase CLI आपके एक्सटेंशन को आपके प्रोजेक्ट में अपलोड कर देगा और उसे इंस्टॉल कर देगा. इंस्टॉल होने के बाद, बैकफ़िल टास्क चलेगा. कुछ ही मिनटों में, आपका डेटाबेस बड़े अक्षरों वाले मैसेज से अपडेट हो जाएगा. मैसेज के डेटाबेस में कुछ नए नोड जोड़ें. साथ ही, पक्का करें कि एक्सटेंशन नए मैसेज के लिए भी काम कर रहा हो.

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

उपयोगकर्ताओं के साथ अपना एक्सटेंशन शेयर करने से पहले, पक्का करें कि आपने उनके लिए ज़रूरी दस्तावेज़ उपलब्ध कराए हों.

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

extension.yaml

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

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

PREINSTALL.md

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

इस फ़ाइल का टेक्स्ट, उपयोगकर्ता को Extensions Hub में और firebase ext:info कमांड से दिखता है.

यहां PREINSTALL फ़ाइल का एक उदाहरण दिया गया है:

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 का कॉन्टेंट Firebase कंसोल में दिखता है. इस फ़ाइल में उपयोगकर्ता पैरामीटर का रेफ़रंस दिया जा सकता है. इन्हें कॉन्फ़िगर की गई वैल्यू से बदल दिया जाएगा.

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

### 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.

CHANGELOG.md

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

उदाहरण के तौर पर दिए गए एक्सटेंशन को पहले कभी पब्लिश नहीं किया गया है. इसलिए, बदलाव के लॉग में सिर्फ़ एक एंट्री है:

## Version 0.0.1

Initial release of the _Convert messages to upper case_ extension.

README.md

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

इस गाइड के लिए, readme फ़ाइल लिखने की ज़रूरत नहीं है.

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

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

इस गाइड के लिए, ज़्यादा जानकारी वाला दस्तावेज़ लिखने से बचें.

11. Extensions Hub पर पब्लिश करना

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

जब आप Extensions Hub पर अपना काम पब्लिश करने के लिए तैयार हों, तो यहां बताया गया तरीका अपनाएं:

  1. अगर आपको अपना पहला एक्सटेंशन पब्लिश करना है, तो एक्सटेंशन पब्लिशर के तौर पर रजिस्टर करें. एक्सटेंशन पब्लिशर के तौर पर रजिस्टर करने पर, आपको एक पब्लिशर आईडी मिलता है. इससे लोग आपको एक्सटेंशन के लेखक के तौर पर आसानी से पहचान पाते हैं.

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

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

  3. firebase ext:dev:upload कमांड का इस्तेमाल करके, अपने एक्सटेंशन को Extensions Hub पर अपलोड करें.

  4. Firebase कंसोल में अपने पब्लिशर डैशबोर्ड पर जाएं. इसके बाद, अभी-अभी अपलोड किया गया एक्सटेंशन ढूंढें और "Extensions Hub पर पब्लिश करें" पर क्लिक करें. इससे समीक्षा करने वाली हमारी टीम से समीक्षा का अनुरोध किया जाता है. इसमें कुछ दिन लग सकते हैं. मंज़ूरी मिलने पर, एक्सटेंशन को Extensions Hub पर पब्लिश कर दिया जाएगा. अगर अनुरोध अस्वीकार कर दिया जाता है, तो आपको इसकी वजह बताने वाला एक मैसेज मिलेगा. इसके बाद, बताई गई समस्याओं को ठीक करके, समीक्षा के लिए फिर से अनुरोध सबमिट किया जा सकता है.