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

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

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

एक्सटेंशन बनाना शुरू करने से पहले, आपको एक बिल्ड सेट अप करना होगा को पूरी सुरक्षा मिलती है.

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

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

    npm install -g firebase-tools

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

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

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

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

    firebase ext:dev:init

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

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

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

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

  1. integration-tests डायरेक्ट्री में बदलें:

    cd functions/integration-tests

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

    firebase emulators:start --project=demo-test

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

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

    आपके ब्राउज़र पर "नमस्ते वर्ल्ड फ़्रॉम ग्रीट-द-वर्ल्ड" का मैसेज दिखता है.

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

    फ़ंक्शन/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. 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 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);
});

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

    वैसे, यह नई फ़ाइल ECMAScript मॉड्यूल सिंटैक्स (import और CommonJS (require) के बजाय export पर दिखाया जाता है. नोड में 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. आपका एक्सटेंशन अब रीयल टाइम डेटाबेस का इस्तेमाल ट्रिगर के तौर पर कर रहा है. इसलिए, आपको इन चीज़ों की ज़रूरत होगी के साथ-साथ RTDB एम्युलेटर चलाने के लिए अपना एम्युलेटर कॉन्फ़िगरेशन अपडेट करें 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 पर काम करता है इंस्टेंस. आने वाले सेक्शन में, आपको कुछ कीवर्ड के साथ इस एक्सटेंशन को बेहतर बनाना होगा अतिरिक्त सुविधाएं. फिर, आपको डिस्ट्रिब्यूट करने के लिए एक्सटेंशन तैयार हो जाएगा और आख़िर में, एक्सटेंशन हब पर अपने एक्सटेंशन को पब्लिश करने का तरीका जानें.

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

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

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

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

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

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

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

    फ़ंक्शन/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

    जब कहा जाए, तब डिफ़ॉल्ट प्रोजेक्ट को सेट अप करने से मना करें. इसके बाद, JavaScript को Cloud 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. लाइफ़साइकल इवेंट हैंडलर जोड़ना

आपने अब तक जो एक्सटेंशन लिखा है वह मैसेज बनने के साथ ही उन्हें प्रोसेस करता है. लेकिन क्या होगा अगर आपके उपयोगकर्ताओं के पास एक्सटेंशन? 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.");
  }
});

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

  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. किसी असली Firebase प्रोजेक्ट में डिप्लॉय करें

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

ऐसा करने के लिए, पहले एक नया प्रोजेक्ट सेट अप करें, जिसमें कुछ सेवाएं चालू हों:

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

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

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

    firebase deploy --only extensions

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

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

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

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

एक्सटेंशन.यामल

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

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

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