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

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

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

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

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

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

एमुलेटर में सैंपल एक्सटेंशन चलाने की कोशिश करें:

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

    cd functions/integration-tests

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

    firebase emulators:start --project=demo-test

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

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

    आपके ब्राउज़र में "greet-the-world से नमस्ते दुनिया" मैसेज दिखता है.

  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. एमुलेटर के चलने के दौरान, Functions कोड में किए गए सभी बदलाव अपने-आप फिर से लोड हो जाएंगे. greetTheWorld फ़ंक्शन में एक छोटा बदलाव करके देखें:

    functions/index.js

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

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

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

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

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

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

    वैसे, यह नई फ़ाइल 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 को एक्सटेंशन के एकमात्र क्लाउड फ़ंक्शन के तौर पर एलान किया गया था. अब इसे 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 के एमुलेटर के साथ-साथ RTDB एमुलेटर को चलाने के लिए, अपने एमुलेटर कॉन्फ़िगरेशन को अपडेट करना होगा:

    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 फ़ंक्शन ट्रिगर हो जाना चाहिए. साथ ही, मैसेज 11 में "upper": "RECIPE" कॉन्टेंट के साथ एक चाइल्ड रिकॉर्ड जोड़ना चाहिए. उम्मीद के मुताबिक नतीजों की पुष्टि करने के लिए, एमुलेटर यूज़र इंटरफ़ेस (यूआई) के लॉग और डेटाबेस टैब देखें.

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

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

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

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

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

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

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

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

    functions/index.js

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

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

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

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

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

    फ़ंक्शन/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 लाइफ़साइकल इवेंट के लिए हैंडलर के तौर पर घोषित करें:

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

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

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

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

extension.yaml

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

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

PREINSTALL.md

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

इस फ़ाइल का टेक्स्ट, उपयोगकर्ता को एक्सटेंशन हब में और 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

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

इस गाइड के लिए, कोई रीडमी फ़ाइल न लिखें.

अन्य दस्तावेज़

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

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

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

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

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

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

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

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

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

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