Firebase-tools: परिनियोजन में मोनो-रेपो का समर्थन करें

ऐसा लगता है कि यह मेरे सेटअप में काम करता है, यानी deploy रूट से पैकेज उठाता है node_modules , भले ही package.json लिए api/ कार्यक्षेत्र के अंतर्गत स्थित हो ( मैंने functions/ बजाय एक अलग फ़ोल्डर नाम का उपयोग किया है)। क्या यहां कुछ और है जिसे ठीक करने की आवश्यकता है?

संपादित करें: इसके अलावा, मैं package.json को api/dist में deploy द्वारा उपयोग करने के लिए कॉपी करता हूं।

// firebase.json
  ...
  "functions": {
    "source": "api/dist"
  },
  ...

तो, नेस्टिंग के 2 स्तर अभी भी रूट node_modules सफलतापूर्वक हल करते हैं।

@dinvlad क्या आप रेपो साझा कर सकते हैं?

@orouz दुर्भाग्य से अभी तक नहीं, यह अभी के लिए बंद स्रोत है।

क्या कोई इस समस्या से निपटने में कामयाब रहा? सरल उदाहरण परियोजना साझा करना बहुत उपयोगी होगा।

@audkar वर्तमान में मैं सिर्फ lerna.js.org का उपयोग करता run कमांड है:

- service1/
|  - .firebaserc
|  - firebase.json
- service2/
|  - .firebaserc
|  - firebase.json
- app1/
|  - .firebaserc
|  - firebase.json
- app2/
|  - .firebaserc
|  - firebase.json
- firestore/
|  - firestore.rules
|  - firestore.indexes.json
- etc...

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

यहां पहले चर्चा की गई - https://github.com/firebase/firebase-tools/issues/1116

@jthegedus आपके उत्तर के लिए धन्यवाद। लेकिन मुझे लगता है कि इस टिकट का मुद्दा अलग है। मैं यार्न कार्यक्षेत्र का उपयोग करने की कोशिश कर रहा हूँ। और ऐसा लगता है कि फ़ायरबेस टूल फ़ंक्शन अपलोड करते समय सिम्लिंक निर्भरता को पिक नहीं करते हैं

आह काफी है, मैंने खुद उस खरगोश के छेद से परहेज किया है

क्या आप विस्तार से बता सकते हैं कि मामला क्या है? जैसा कि ऊपर उल्लेख किया गया है, मैं केवल api और app कार्यक्षेत्रों के साथ नंगे यार्न का उपयोग करता हूं, और मैं उन्हें yarn workspace api build && yarn workspace app build ( build प्रत्येक के लिए विशिष्ट स्क्रिप्ट के साथ) का उपयोग करके बनाता हूं कार्यक्षेत्र)। निर्माण स्क्रिप्ट
१) TS कोड को outDir app/dist क्रमशः api/dist और app/dist संकलित करें
2) संबंधित package.json फाइलों को dist निर्देशिकाओं में कॉपी करें
3) yarn.lock को _root_ फ़ोल्डर से dist निर्देशिकाओं में कॉपी करें

फिर मैं _root_ फ़ोल्डर से yarn firebase deploy चलाता हूं, और यह बिना किसी हिचकी के api/dist और app/dist दोनों को उठाता है। मेरा firebase.json जैसा दिखता है

  "functions": {
    "source": "api/dist"
  },
  "hosting": {
    "public": "app/dist",

दुर्भाग्य से, मैं अभी भी पूरा कोड साझा नहीं कर सकता, लेकिन यह सेटअप वह सब है जो मायने रखता है, afaik।

साथ ही, मैं गलत हो सकता हूं लेकिन मुझे लगता है कि firebase deploy स्क्रिप्ट वास्तव में आपकी node_modules निर्देशिका का उपयोग नहीं करती है। मुझे लगता है कि यह सिर्फ कोड उठाता है, package.json , और yarn.lock dist निर्देशिकाओं से, और बाकी करता है।

यह सच है। firebase.json में "functions.ignore" का डिफ़ॉल्ट मान है
["नोड_मॉड्यूल्स"] इसलिए इसे अपलोड नहीं किया गया है। मुझे विश्वास है कि आप इसे ओवरराइड कर सकते हैं
हालांकि अगर आप कुछ स्थानीय मॉड्यूल शिप करना चाहते हैं।

सोम को, जून १७, २०१९, ६:५८ अपराह्न डेनिस लोगिनोव नोटिफिकेशन @github.com
लिखा था:

साथ ही, मैं गलत हो सकता हूं लेकिन मुझे लगता है कि फायरबेस तैनाती स्क्रिप्ट नहीं करता है
वास्तव में अपनी नोड_मॉड्यूल निर्देशिका का उपयोग करें। मुझे लगता है कि यह सिर्फ उठाता है
कॉड, पैकेज.जेसन, और यार्न.लॉक डिस्ट निर्देशिका से, और करता है
विश्राम।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने इस थ्रेड की सदस्यता ली है।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/firebase/firebase-tools/issues/653?email_source=notifications&email_token=ACATB2U73VS2KIILUVRFFB3P3A6NPA5CNFSM4EOR24GKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJJ
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ACATB2U3Q2TLVBICRJ3B5OLP3A6NPANCNFSM4EOR24GA
.

@dinvlad हाँ, इसके लिए package.json और जो भी लॉक फ़ाइल आप उपयोग करते हैं, वह क्लाउड पोस्ट परिनियोजन में डिप्स स्थापित करता है।

मेरा मानना ​​​​है कि मूल रूप से दूसरे मुद्दे में उल्लिखित परिदृश्य कार्यक्षेत्र के भीतर एक साझा पैकेज और स्कोप-होस्टिंग के साथ कुछ मुद्दों का उपयोग कर रहा था। चूंकि मैं इस तरह से धागे का उपयोग नहीं कर रहा था, इसलिए मैं केवल वही अनुमान लगा सकता हूं जो मैंने वहां पढ़ा है।

@samtstern @jthegedus धन्यवाद,

ऐसा लगता है कि हम सभी अलग-अलग समस्याओं के बारे में बात करते हैं। मैं yarn workspaces समस्या का वर्णन करने का प्रयास करूंगा।

समस्याग्रस्त परियोजना

परियोजना लेआउट

- utilities/
|  - package.json
- functions/
|  - package.json
- package.json

_./पैकेज.जेसन_

{
  "private": true,
  "workspaces": ["functions", "utilities"]
}

_फ़ंक्शंस/पैकेज.जेसन_

{
  <...>
  "dependencies": {
    "utilities": "1.0.0",
    <...>
  }
}

संकट

फ़ंक्शन परिनियोजन के दौरान त्रुटि:

Deployment error.
Build failed: {"error": {"canonicalCode": "INVALID_ARGUMENT", "errorMessage": "`gen_package_lock` had stderr output:\nnpm WARN deprecated [email protected]: use String.prototype.padStart()\nnpm ERR! code E404\nnpm ERR! 404 Not Found: [email protected]\n\nnpm ERR! A complete log of this run can be found in:\nnpm ERR!     /builder/home/.npm/_logs/2019-06-18T07_10_42_472Z-debug.log\n\nerror: `gen_package_lock` returned code: 1", "errorType": "InternalError", "errorId": "1971BEF9"}}

कार्य एम्यूलेटर पर स्थानीय रूप से ठीक काम करता है।

समाधान की कोशिश की

node_modules अपलोड किया जा रहा है (_firebase.json_ में functions.ignore का उपयोग करके)। परिणाम समान है।

मेरा अनुमान है कि ऐसा इसलिए है क्योंकि utilities _node-modules_ node_modules/utilities -> ../../utilities में syslink के रूप में बनाया गया है

क्या ऐसा हो सकता है कि फायरबेस-टूल्स में अपलोड करते समय सिम्लिंक किए गए मॉड्यूल की सामग्री शामिल न हो (कोई डीरेफेरेंसिंग नहीं)?

क्षमा करें, क्या आप स्पष्ट कर सकते हैं कि आपका firebase.json किस फ़ोल्डर में रहता है (और functions लिए इसका कॉन्फ़िगरेशन अनुभाग दिखाएं)?

_firebase.json_ रूट फोल्डर में था। विन्यास मानक था। इस तरह स्मथ:

  "functions": {
    "predeploy": [
      "yarn --cwd \"$RESOURCE_DIR\" run lint",
      "yarn --cwd \"$RESOURCE_DIR\" run build"
    ],
    "source": "functions",
    "ignore": []
  },
  <...>

सब कुछ अपेक्षित के रूप में तैनात किया गया था (_node_modules_ सहित) node_modules/utilities को छोड़कर जो कि सिम्लिंक है।

मैं कुछ स्क्रिप्ट लिखकर इस मुद्दे को हल करने का प्रबंधन करता हूं:

• प्रत्येक कार्यक्षेत्र के लिए पैकेज बनाएं ( yarn pack )। उदाहरण के लिए यह _utilities.tgz_ बनाता है।
• सभी आउटपुट को कुछ विशिष्ट डीआईआर में ले जाना।
• कार्यक्षेत्र निर्भरता के लिए tgz फ़ाइलों का उपयोग करने के लिए _package.json_ को संशोधित करना। उदाहरण के लिए dependencies { "utilities": "1.0.0" -> dependencies { "utilities": "file:./utilities.tgz"
• उस डीआईआर को फायरबेस पर तैनात करना

अपलोड करने से पहले आउटपुट डीआईआर सामग्री:

- dist
|  - lib
|  | -index.js
|  - utilities.tgz
|  - package.json <---------- This is modified to use *.tgz for workspaces

@audkar आज मैं आपके जैसे ही मुद्दे में फंस गया।

मैं Lerna और Yarn दोनों कार्यक्षेत्रों के लिए नया हूँ। जैसा कि मैं इसे समझता हूं, आप केवल लर्न का उपयोग कर सकते हैं। क्या यह किसी भी तरह से मदद करेगा?

आपका समाधान मेरे लिए थोड़ा जटिल लगता है 🤔

यह भी सोच रहा था कि `--cwd "$RESOURCE_DIR" किसके लिए है?

--cwd अर्थ "वर्तमान कार्यशील निर्देशिका" है और $RESOURCE_DIR स्रोत डीआईआर के लिए मूल्य रखता है (इस मामले में functions )। इस ध्वज को जोड़ने से yarn को रूट के बजाय functions dir में निष्पादित किया जाएगा

@audkar आह मैं देखता हूँ। तो आप yarn workspace functions lint और yarn workspace functions build साथ भी ऐसा ही कर सकते हैं

@dinvlad यह मेरे लिए स्पष्ट नहीं है कि आप dist/index.js इंगित करते हैं तो चीजों को समान काम करना चाहिए? फिर आपको एपीआई/जिला के बजाय स्रोत को एपीआई पर सेट करना चाहिए।

@dinvlad मैंने आपकी टिप्पणियों से yarn workspace कमांड सीखा, लेकिन किसी कारण से यह काम नहीं कर सकता। यहां देखें। कोई विचार?

यहाँ विषय से थोड़ा हटकर जाने के लिए क्षमा करें। शोर को कम करने के लिए शायद SO में टिप्पणी करें।

@ 0x80 मैं package.json से api/dist प्रतिलिपि बनाता हूं और firebase.json से api/dist इंगित करता हूं, इसलिए केवल "निर्मित" फ़ाइलें क्लाउड फ़ंक्शन के अंदर पैक की जाती हैं। मुझे यकीन नहीं है कि अगर मैं firebase.json को api इंगित करता हूं तो क्या होगा - शायद यह अभी भी केवल api/dist ( main पर आधारित) को पैकेज करने के लिए पर्याप्त स्मार्ट होगा package.json )। लेकिन मैंने सोचा कि यह केवल api/dist को इंगित करने के लिए क्लीनर था।

पुन yarn workspace , मैंने SO पर जवाब दिया;)

@dinvlad यह आपके द्वारा इंगित की गई जड़ को बंडल करेगा, लेकिन आप वह सब कुछ डाल सकते हैं जिसे आप firebase.json सूची में शामिल नहीं करना चाहते हैं।

मैंने अब @audkar के समान वर्कअराउंड का उपयोग किया है।

{
  "functions": {
    "source": "packages/cloud-functions",
    "predeploy": ["./scripts/pre-deploy-cloud-functions"],
    "ignore": [
      "src",
      "node_modules"
    ]
  }
}

फिर पूर्व-तैनाती-क्लाउड-फ़ंक्शंस स्क्रिप्ट है:

#!/usr/bin/env bash

set -e

yarn workspace @gemini/common lint
yarn workspace @gemini/common build

cd packages/common
yarn pack --filename gemini-common.tgz
mv gemini-common.tgz ../cloud-functions/
cd -

cp yarn.lock packages/cloud-functions/

yarn workspace @gemini/cloud-functions lint
yarn workspace @gemini/cloud-functions build

और संकुल/क्लाउड-फ़ंक्शंस में एक अतिरिक्त gitignore फ़ाइल है:

yarn.lock
*.tgz

यहाँ मेरे लिए क्या काम किया है

- root/
|  - .firebaserc
|  - firebase.json
- packages/
  | - package1/
  | - functions/
    | - dist/
    | - src/
    | packages.json

और root/firebase.json :
```
{
"फ़ंक्शंस": {
"पूर्व नियोजित": "npm --prefix "$RESOURCE_DIR" रन बिल्ड",
"स्रोत": "पैकेज/फ़ंक्शंस"
}
}
````

@kaminskypavel पैकेज/पैकेज 1 (या कुछ अन्य भाई पैकेज) के आधार पर आपके पैकेज/कार्य हैं?

@0x80 सकारात्मक।

मुझे लगता है कि मोनोरेपो के बारे में मुझे कुछ मौलिक समझ में आया था। मुझे लगता है कि आप एक पैकेज साझा कर सकते हैं और उस पैकेज का उपयोग करके एक ऐप को वास्तव में एनपीएम को साझा पैकेज प्रकाशित किए बिना तैनात कर सकते हैं।

ऐसा लगता है कि यह संभव नहीं है, क्योंकि Firebase या Now.sh जैसे परिनियोजन आमतौर पर कोड अपलोड करेंगे और फिर क्लाउड में इंस्टॉल और बिल्ड करेंगे। क्या मैं सही हूँ?

@kaminskypavel मैंने आपके दृष्टिकोण की कोशिश की और यह काम करता है, लेकिन पहले एनपीएम को अपना पैकेज प्रकाशित करने के बाद ही। क्योंकि मेरे मामले में पैकेज निजी है, मुझे शुरू में "नहीं मिला" त्रुटि मिली, इसलिए मुझे अपनी .npmrc फ़ाइल को क्लाउड फ़ंक्शंस पैकेज की जड़ में भी जोड़ना पड़ा जैसा कि यहाँ वर्णित

@audkar क्या आप अपना सामान्य पैकेज एनपीएम को प्रकाशित कर रहे हैं, या आप मेरे जैसे साझा कोड के साथ तैनात करने की कोशिश कर रहे हैं जो प्रकाशित नहीं हुआ है?

@ 0x80 मैं इस समझ पर आपके साथ हूं - मुझे लगता है कि फायरबेस फ़ंक्शन परिनियोजन केवल (गलती से) यह मानते हुए हैं कि package.json में नामित सभी पैकेज npm पर उपलब्ध होंगे, तैनाती में तेजी लाने के नाम पर।

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

npm कार्यस्थानों के लिए समर्थन जोड़ने के साथ, हमारे पास एक पारिस्थितिकी तंत्र मानक है कि स्थानीय पैकेजों को कैसे काम करना चाहिए।

चूंकि यह समस्या एक वर्ष से अधिक पुरानी है, इसलिए यहां योजनाओं (या योजनाओं की कमी) पर फायरबेस की ओर से कोई अपडेट?

मुझे लगता है कि यह एक बहुत अच्छा अवसर है - फायरबेस की सेवाओं की श्रृंखला एक अच्छे मोनोरेपो सेटअप के लिए भीख माँगती है।

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

यहां बताया गया है कि मैंने इसे इस निर्देशिका संरचना के साथ कैसे किया:
```

• जड़/
  | - .firebaserc
  | - firebase.json
  | -...
• कार्य/
  | - स्रोत/
  | - पैकेज.जेसन
  | - पूर्व-तैनाती.जेएस
  | - पोस्ट-तैनाती.जेएस
  | - ....
• साझा/
  | - स्रोत/
  | - पैकेज.जेसन
  | - ....

content of `pre-deploy.js`

कॉन्स्ट एफएस = आवश्यकता ("एफएस-अतिरिक्त");

कॉन्स्ट पैकेजजसनपाथ = "./package.json";
कॉन्स्ट पैकेजजसन = आवश्यकता (पैकेजजसनपाथ);

(एसिंक () => {
प्रतीक्षा करें fs.remove( ./shared );
प्रतीक्षा fs.copy( ../shared , ./shared );

packageJson.dependencies["@project/shared"] = "file:./shared";

await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));

}) ();

content of `post-deploy.js`

कॉन्स्ट पैकेजजसनपाथ = "./package.json";
कॉन्स्ट पैकेजजसन = आवश्यकता (पैकेजजेसनपाथ);
कॉन्स्ट एफएस = आवश्यकता ("एफएस-अतिरिक्त");

(एसिंक () => {
प्रतीक्षा करें fs.remove ( ./shared );

packageJson.dependencies["@project/shared"] = "file:../shared";

await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));

}) ();

Then update `firebase.json` like this (add the build script if you need, I build before in my pipeline)

"फ़ंक्शंस": {
"स्रोत": "कार्य",
"पूर्व-तैनाती": [
"npm --prefix "$RESOURCE_DIR" पूर्व-तैनाती चलाएं"
],
"तैनाती के बाद": [
"npm --prefix "$RESOURCE_DIR" परिनियोजन के बाद चलाएँ"
]
},
```

यदि आप निर्माण करते हैं, तो dist या lib निर्देशिका के अंदर अब आपके दो भाई-बहन होने चाहिए: कार्य और साझा (यह साझा निर्भरता के कारण हुआ)। तैनाती कार्य करने के लिए lib/functions/src/index.js को इंगित करने के लिए package.json main फ़ंक्शन को अपडेट करना सुनिश्चित करें।

अभी के लिए यह हल हो गया है लेकिन यह एक समाधान है, समाधान नहीं। मुझे लगता है कि फायरबेस टूल्स को वास्तव में सिम्लिंक का समर्थन करना चाहिए

@michelepatrassi आपने मुझे जो याद दिलाया है उससे प्रेरित होकर मैंने इस मामले को प्रबंधित करने के लिए firelink लाइब्रेरी बनाई है। यह पुनरावर्ती फ़ाइलों की प्रतिलिपि बनाने के लिए आंतरिक रूप से rsync का उपयोग करता है।

https://github.com/rxdi/firelink

npm i -g @rxdi/firelink

मूल उपयोग
यह मानते हुए कि आपके पास मोनोरेपो दृष्टिकोण है और आपके पैकेज वर्तमान निर्देशिका से 2 स्तर नीचे स्थित हैं जहां package.json स्थित है।

package.json

  "fireDependencies": {
    "@graphql/database": "../../packages/database",
    "@graphql/shared": "../../packages/shared",
    "@graphql/introspection": "../../packages/introspection"
  },

निष्पादित firelink यह फ़ोल्डरों से संबंधित पैकेजों को कॉपी करेगा फिर स्थानीय मॉड्यूल के साथ मौजूदा पैकेजों को मैप करेगा "@graphql/database": "file:./.packages/database", फिर कमांड firebase निष्पादित करेगा और बाकी तर्कों को firelink से पास करेगा
मूल रूप से firelink के लिए एक स्थानापन्न है firebase CLI के बाद से यह spawns firebase अंत में जब समाप्त अपनी नौकरी को कॉपी packages और संशोधित package.json !

सादर!

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

दोस्तों, इस समस्या का एक सरल समाधान है कि आप अपने क्लाउड-फ़ंक्शंस को बंडल करने के लिए वेबपैक का उपयोग करें और बंडल की गई निर्देशिका से परिनियोजित करें। यहां एक मूल वेबपैक फ़ाइल संलग्न है जिसका मैं उपयोग कर रहा हूं। निर्माण के दौरान, यह सभी फ़ंक्शन कोड को पैक करेगा, जिसमें मोनो-रेपो के भीतर हल की गई निर्भरता को एक टॉपलेवल फ़ोल्डर में शामिल किया जाएगा (इस मामले में इसकी webpack/cloud-functions , यह कुछ भी हो सकता है जिसे आप कॉन्फ़िगर करते हैं)

const path = require('path');

module.exports = {
  target: 'node',
  mode: 'production',
  entry: './src/index.ts',
  module: {
    rules: [
      {
        test: /\.tsx?$/,
        use: 'ts-loader',
        exclude: /node_modules/
      }
    ]
  },
  resolve: {
    extensions: ['.tsx', '.ts', '.js', '.json']
  },
  output: {
    filename: 'index.js',
    path: path.resolve(__dirname, '../../webpack/cloud-functions/dist'),
    libraryTarget: 'commonjs'
  },
  externals: {
    'firebase-admin': 'firebase-admin',
    'firebase-functions': 'firebase-functions'
  }
};

और अंत में अपनी firebase.json फ़ाइल में, परिनियोजन के लिए इस फ़ोल्डर को देखें।

{
  "functions": {
    "source": "webpack/cloud-functions"
  }
}

याद रखें कि package.json फ़ाइल webpack/cloud-functions फ़ोल्डर में भी हो।

{
  "name": "cloud-functions",
  "version": "1.0.0",
  "scripts": {
    "deploy": "firebase deploy --only functions"
  },
  "engines": {
    "node": "10"
  },
  "main": "dist/index.js",
  "dependencies": {
    "firebase-admin": "8.9.1",
    "firebase-functions": "3.3.0"
  },
  "devDependencies": {},
  "private": true
}

यह परीक्षण और काम कर रहा है। मैं Google क्लाउड बिल्ड का उपयोग कर रहा हूं। यदि आवश्यक हो तो अधिक जानकारी के लिए पूछें।

धन्यवाद,

@sowdri साझा करने के लिए धन्यवाद! क्या आप webpack बिल्ड को firebase.json functions.predeploy स्टेप से ट्रिगर करते हैं, या क्या आप फायरबेस डिप्लॉयमेंट को कॉल करने से पहले इसे क्लाउड बिल्ड स्क्रिप्ट से ट्रिगर करते हैं?

@ 0x80 मैं इसे cloud build चरण में बना रहा हूं। तो firebase cli यह केवल JS के साथ निर्मित कार्यों का एक सेट है

@sowdri उदाहरण के लिए धन्यवाद। हमने एडब्ल्यूएस लैम्बडास/सर्वरलेस के लिए पिछले प्रोजेक्ट में उसी दृष्टिकोण का उपयोग करना समाप्त कर दिया है: यार्न मोनोरेपो के साथ काम करने के लिए टूल्स को मजबूर करने की तुलना में एक (वेबपैक) बंडल अपलोड करना आसान था।

मैं भी इसके साथ फंस गया हूं .... सब कुछ ठीक काम करता है (यहां तक ​​​​कि फायरबेस एमुलेटर) जब तक कि मैंने कार्यों को तैनात करने की कोशिश नहीं की (प्रतिक्रिया में वेब ऐप बिल्ड ठीक है)। :(उम्मीद है कि फायरबेस टीम जल्द ही मोनोरेपो के लिए समर्थन जोड़ सकती है।

मैं अपने मोनोरेपो में अन्य पैकेजों के लिए बेबेल का उपयोग करता हूं, इसलिए मैं उसके साथ रहना पसंद करूंगा। अगर और कुछ नहीं तो मैं वेबपैक आज़मा सकता हूँ...ऐसा लगता है कि यह कुछ के लिए काम कर रहा है।

संपादित करें: मैंने इसे GitHub पैकेज रजिस्ट्री का उपयोग करके हल किया है। इसलिए मैं अपने सभी पैकेज वहां प्रकाशित करता हूं और फिर travis और functions सर्वर के लिए मुझे रजिस्ट्री को सेटअप करना होगा और प्रमाणीकरण के लिए टोकन प्रदान करना होगा ( .npmrc माध्यम से किया गया)। ... एक सुरुचिपूर्ण समाधान की तरह लगता है। मुझे यहां इस दृष्टिकोण के लिए विचार मिला: https://medium.com/gdgeurope/how-to-use-firebase-cloud-functions-and-yarn-workspaces-24ca35e941eb

हाँ, इसने भी काट लिया। सब कुछ firebase serve --only functions में पूरी तरह से काम करता है लेकिन जब इसे तैनात किया जाता है, तो यह एक मॉड्यूल का पता नहीं लगा सका।

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

``` "fs" से fs आयात करें;
"child_process" से चाइल्ड_प्रोसेस आयात करें;

कॉन्स्ट इंटरनलपैकेजफुल = नया मैप ();

// पैकेज के लिए सभी विवरण खोजें
const getDepsForPackage = (पैकेजनाम) => {
कॉन्स्ट पैकेजडिर = पैकेजनाम.स्प्लिट ("/") [1]; // इसे आपके लिए बदलने की आवश्यकता हो सकती है
कॉन्स्ट पैकेजस्पेकफाइलनाम = ../${packageDir}/package.json ;
कॉन्स्ट पैकेजस्पेकफाइल = fs.readFileSync (पैकेजस्पेकफाइलनाम);
कॉन्स्ट पैकेजस्पेक = JSON.parse (पैकेजस्पेकफाइल);
कॉन्स्ट पैकेजइंटरनलडिप्स = ऑब्जेक्ट.की (
पैकेजस्पेक.निर्भरता
).filter((key) => key.includes("turing")); // इसे आपके लिए बदलने की आवश्यकता होगी

कॉन्स्ट पैकेजTgzName = ${packageName.replace("@", "").replace("/", "-")}-v${ packageSpec.version }.tgz ;

आंतरिक पैकेजफुल.सेट (पैकेजनाम, {
पैकेजस्पेकफ़ाइलनाम,
पैकेजस्पेक,
पैकेजडीआईआर,
पैकेजइंटरनलडिप्स,
पैकेज टीजीजेडनाम,
});

कॉन्स्ट पैकेजटोप्रोसेस = पैकेजइंटरनलडिप्स.फिल्टर (
(internalDepName) => !internalPackagesFull.has(internalDepName)
);

packageToProcess.forEach((internalPackageName) =>
getDepsForPackage (आंतरिक पैकेज नाम)
);
};

कॉन्स्ट पैकेजनाम = JSON.parse(fs.readFileSync(./package.json")).name;
Child_process.execSync( cp ./package.json ./package.json.org );
getDepsForPackage (पैकेजनाम);

// अद्यतन पैकेज लिखें - सामान्य js का उपयोग करें और संदर्भ स्थानीय tgz फ़ाइलें हैं
[... आंतरिक पैकेजफुल। मान ()]। प्रत्येक के लिए ((आंतरिक डीप) => {
कॉन्स्ट {पैकेजस्पेक, पैकेजस्पेकफाइलनाम, पैकेजइंटरनलडिप्स} = इंटरनलडिप;

// पैकेज प्रकार बदलें
packageSpec.type = "commonjs"; // इसे आपके लिए बदलने की आवश्यकता हो सकती है

// पैकेज की गई ज़िप फ़ाइल होने के लिए डिपो का स्थान निर्दिष्ट करें
packageInternalDeps.forEach((internalDepOfPackage) => {
कॉन्स्ट {पैकेज टीजीजेडनाम} = आंतरिक पैकेजफुल। प्राप्त करें (आंतरिक डीपऑफ पैकेज);
packageSpec.dependencies[internalDepOfPackage] = ./${packageTgzName} ;
});

fs.writeFileSync(
पैकेजस्पेकफ़ाइलनाम,
JSON.stringify (पैकेजस्पेक, नल, "")
);
});

// यार्न बिल्ड और पैक चलाएं
[... आंतरिक पैकेजफुल। मान ()]। प्रत्येक के लिए ((आंतरिक डीप) => {
प्रयत्न {
कंसोल.लॉग ( Buliding ${internalDep.packageDir} );
child_process.execSync("यार्न बिल्ड", {
सीडब्ल्यूडी: ../${internalDep.packageDir} ,
});
कंसोल.लॉग ( Packaging ${internalDep.packageDir} );
child_process.execSync("यार्न पैक", {
सीडब्ल्यूडी: ../${internalDep.packageDir} ,
});

if (packageName !== internalDep.packageSpec.name) {
  console.log(`Move to current directory ${internalDep.packageDir}`);
  child_process.execSync(
    `cp ../${internalDep.packageDir}/${internalDep.packageTgzName} .`,
    {
      cwd: ".",
    }
  );
}

} कैच (ई) {
कंसोल.लॉग (ई);
}
});

// मानक पैकेज संरचना पर वापस जाएं
[... आंतरिक पैकेज पूर्ण। मान ()]
.filter((internalDep) => packageName !== internalDep.packageSpec.name)
प्रत्येक के लिए ((आंतरिक डीप) => {
कास्ट {
पैकेजस्पेक,
पैकेजस्पेकफ़ाइलनाम,
पैकेजइंटरनलडिप्स,
} = आंतरिक डीप;

// change the package type
packageSpec.type = "module"; // THIS MAY NEED TO CHANGE FOR YOU

// specify the location of the dep to be the packaged zip file
packageInternalDeps.forEach((internalDepOfPackage) => {
  packageSpec.dependencies[internalDepOfPackage] = "*";
});

fs.writeFileSync(
  packageSpecFileName,
  JSON.stringify(packageSpec, null, "  ")
);

});
```

मैंने @sowdri द्वारा प्रदान किए गए समाधान का उपयोग किया (इसके लिए धन्यवाद!), एक छोटे से ट्वीक के साथ ताकि मैं माध्यमिक package.json सहित संपूर्ण dist/ निर्देशिका को स्वतंत्र रूप से हटा और पुन: उत्पन्न कर सकूं :

const path = require('path');
const CopyPlugin = require('copy-webpack-plugin');

module.exports = {
  ...,
  plugins: [
    new CopyPlugin({
      patterns: [{ from: 'package.dist.json', to: 'package.json' }],
    }),
  ],
};

और फिर मैं पैकेज रूट में निम्नलिखित package.dist.json रखता हूं:

{
  "name": "@package/name",
  "version": "0.0.1",
  "engines": {
    "node": "10"
  },
  "main": "index.js",
  "dependencies": {
    "firebase-admin": "8.9.1",
    "firebase-functions": "3.3.0"
  },
  "private": true
}

इस फ़ाइल से निर्भरताओं को हटाना संभव हो सकता है और उन्हें भी बंडल करने के लिए वेबपैक पर भरोसा करना संभव हो सकता है (इन निर्भरताओं को आपके मुख्य package.json साथ सिंक में रखने की आवश्यकता को हटाकर), लेकिन मैंने कोशिश नहीं की है।

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

मैं फ़ंक्शन परिनियोजन के लिए मूल package.json से package.json बनाता हूं।

यहाँ copyFiles.js स्क्रिप्ट है:

const cpy = require('cpy');
const fs = require('fs');
const package = require('./package.json');
(async () => {
    await cpy(['./../package.json', './**/*.json', './**/.firebaserc'], '../out/', {
        parents: true,
        cwd: 'src'
    });
    const dirs = fs.readdirSync('./out/');
    const newPkg = {
        main: package.main,
        dependencies: package.dependencies,
        engines: package.engines,
    }
    dirs.forEach(dir => {
        fs.writeFileSync(`./out/${dir}/package.json`, JSON.stringify({ name: dir, ...newPkg }));
    })
    console.log('Files copied!', dirs);
})();

परिनियोजन के लिए ./out/[project-name]/firebase deploy --only=functions या इसके लिए एक स्क्रिप्ट भी लिखें।

मैं इस तरह कुछ वेबपैक चेतावनियों में भाग रहा हूं:

/Users/me/Development/myproject/node_modules/firebase-functions/lib/config.js 61:23-42 में चेतावनी
गंभीर निर्भरता: एक निर्भरता का अनुरोध एक अभिव्यक्ति है

क्या आपको इन्हें हल करने का कोई तरीका मिला, या आप इन्हें अनदेखा/दबा रहे हैं?

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

बंडलिंग मुद्दों के परिणामस्वरूप, मुझे तैनाती के दौरान कुछ गुप्त @grpc त्रुटियों में भी भाग गया। मैं उन्हें संदर्भ के लिए रखना भूल गया।

const path = require("path");
const CopyPlugin = require("copy-webpack-plugin");

module.exports = {
  target: "node",
  mode: "production",
  entry: "./src/index.ts",
  devtool: "inline-source-map",
  module: {
    rules: [
      {
        test: /\.tsx?$/,
        use: "ts-loader",
        exclude: /node_modules/,
      },
    ],
  },
  resolve: {
    extensions: [".tsx", ".ts", ".js", ".json"],
    alias: {
      "~": path.resolve(__dirname, "src"),
    },
  },
  output: {
    filename: "index.js",
    path: path.resolve(__dirname, "dist/bundled"),
    libraryTarget: "commonjs",
  },
  externals: ["express", /^firebase.+$/, /^@google.+$/],
  plugins: [
    new CopyPlugin({
      patterns: [{ from: "package.dist.json", to: "package.json" }],
    }),
  ],
};

यह पता चला है कि एक अलग package.dist.json की कोई आवश्यकता नहीं है। इस फ़ाइल को रखने की कष्टप्रद बात निश्चित रूप से यह है कि आपको हर बार जब आप वहां सूचीबद्ध किसी भी निर्भरता को अपडेट करते हैं तो आपको इसे मैन्युअल रूप से अपडेट करने की आवश्यकता होती है। तो इसे भूलना बहुत आसान है।

इसके बजाय, उन सभी पैकेजों को ले जाएँ जिन्हें आप अपने package.dist.json में सूचीबद्ध नहीं करेंगे, और बस उस फ़ाइल को वेबपैक कॉपी प्लगइन में उपयोग करें। अब आपके पास . से निपटने के लिए केवल एक ही package.json है

साथ ही, मैं नहीं चाहता कि मेरा स्थानीय नोडज संस्करण आवश्यक रूप से नोड संस्करण को तैनात किए गए कार्यों के समान हो। मैंने पाया कि अब आप firebase.json फ़ाइल में functions.runtime निर्दिष्ट कर सकते हैं। इसलिए package.json से engines फ़ील्ड निकालें और इसके बजाय अपने फायरबेस कॉन्फ़िगरेशन में functions.runtime से "10" या "12" सेट करें।

यह मेरे लिए कैसा दिखता है:

{
  "functions": {
    "source": "packages/cloud-functions/dist/bundled",
    "runtime": "12"
  },
  "firestore": {
    "rules": "firestore.rules",
    "indexes": "firestore.indexes.json"
  },
  "emulators": {
    "functions": {
      "port": 5001
    },
    "firestore": {
      "port": 8080
    },
    "pubsub": {
      "port": 8085
    }
  }
}

आप स्रोत मानचित्रों से कैसे निपट रहे हैं? अगर मैं devtool: "inline-source-map" का उपयोग करके वेबपैक के साथ अपने कार्यों को बंडल करता हूं तो यह स्टैकड्राइवर त्रुटि रिपोर्टिंग में नहीं उठाया जाता है। @sowdri

मैं अपने प्रोजेक्ट पर एक ही चीज़ में भाग गया और यह एक बहुत बड़ा बमर था क्योंकि मैं एक साइड प्रोजेक्ट के लिए हर पैकेज को प्रकाशित नहीं करना चाहता। कई package.json फाइलों को रखना या पैकेज के बाहर निर्माण करना कष्टप्रद था। पता चलता है कि यदि आप अपने विभागों को वैकल्पिक के रूप में शामिल करते हैं तो Lerna उन्हें अभी भी उठाएगा और Firebase अपलोड होने पर शिकायत नहीं करेगा।

नीचे दिया गया कॉन्फिगरेशन आपको सिंगल पैकेज के साथ सिम्लिंक्ड डिप सपोर्ट देगा।json!

पैकेज.जेसन

{
  "name": "@your-package-name/functions",
  "version": "0.1.0",
  "scripts": {
    "build": "webpack"
  },
  "engines": {
    "node": "10"
  },
  "main": "dist/index.js",
  "dependencies": {
    "firebase-admin": "^8.10.0",
    "firebase-functions": "^3.6.1"
  },
  "optionalDependencies": {
    "@your-package-name/shared": "^0.1.0",
    "@your-package-name/utils": "^0.1.0"
  }
}

webpack.config.js

const path = require('path')

// The cost of being fancy I suppose
// https://github.com/firebase/firebase-tools/issues/653

module.exports = {
  target: 'node',
  mode: 'production',
  entry: './src/index.ts',
  module: {
    rules: [
      {
        test: /\.tsx?$/,
        loader: 'ts-loader',
        exclude: /node_modules/,
        options: {
          configFile: 'tsconfig.build.json',
        },
      },
    ],
  },
  resolve: {
    extensions: ['.tsx', '.ts', '.js', '.json'],
  },
  output: {
    filename: 'index.js',
    path: path.resolve(__dirname, 'dist'),
    libraryTarget: 'commonjs',
  },
  externals: {
    'firebase-admin': 'firebase-admin',
    'firebase-functions': 'firebase-functions',
  },
}

firebase.json

{
  "firestore": {
    "rules": "firestore.rules",
    "indexes": "firestore.indexes.json"
  },
  "functions": {
    "source": "packages/functions"
  },
  "emulators": {
    "functions": {
      "port": 5476
    },
    "firestore": {
      "port": 4565
    },
    "ui": {
      "enabled": true
    }
  }
}

मैं यार्न वर्कस्पेस का उपयोग कर रहा हूं, लेकिन मुझे अन्य पैकेज.जेसन फाइलों में अपने स्थानीय पैकेज नामों का उल्लेख करने की भी आवश्यकता नहीं है। मैं इसके बिना सफलतापूर्वक फ़ायरबेस और वर्सेल दोनों को तैनात कर रहा हूं।

मुझे यकीन नहीं है कि यह क्या काम करता है। मेरे शीर्ष-स्तरीय पैकेज में बस यह मानक कॉन्फ़िगरेशन है। जेसन:

"workspaces": {
    "packages": [
      "packages/*"
    ]
  },

मुझे प्रत्येक /packages/* फ़ोल्डर में package.json होने से कोई फर्क नहीं पड़ता, क्योंकि yarn upgrade-interactive चलाने से उन सभी को एक ही बार में संभाल लिया जाएगा। कुछ पैकेजों में मुझे विशेष रूप से उस दायरे के लिए स्क्रिप्ट जोड़ने में सक्षम होना उपयोगी लगता है।

---- संपादित करें ----

मैं उल्लेख करना भूल गया कि मैं प्रोजेक्ट संदर्भों के साथ टाइपस्क्रिप्ट का उपयोग कर रहा हूं। उसका इसके साथ कुछ संबंध हो सकता है। वर्सेल के लिए मैं अपने साझा कोड को बंडल में शामिल करने के लिए नेक्स्ट-ट्रांसपाइल-मॉड्यूल का उपयोग कर रहा हूं।

मैं इस काम को करने के लिए @ 0x80 और copy-webpack-plugin का उपयोग कर रहा हूं generate-package-json-webpack-plugin का उपयोग कर रहा हूं। डिस्ट फोल्डर में जेसन। यह मेरी निर्भरता सूची बनाता है जो परिणामी कोड की वास्तव में आवश्यकता होती है, इसलिए यदि यह बंडल या एक देव निर्भरता है तो यह परिणामी पैकेज में शामिल नहीं है। जेसन।

मैंने अपने सिम्लिंक्ड मोनोरेपो पैकेजों को छोड़कर सब कुछ बाहरी बनाने के लिए webpack-node-externals का उपयोग करके अपने बाहरी सेट भी किए हैं, जिन्हें मैं प्रोजेक्ट नाम उपसर्ग से मेल खाने के लिए रेगेक्स का उपयोग कर रहा हूं। मैंने अतिरिक्त बाहरी के रूप में पोस्ट किए गए फ़ायरबेस पैकेज @ 0x80 के लिए रेगेक्स एक्सप्रेशन भी जोड़े हैं।

यह मेरा विन्यास है

/* eslint-disable @typescript-eslint/no-var-requires */
const path = require("path");
const nodeExternals = require("webpack-node-externals");
const GeneratePackageJsonPlugin = require("generate-package-json-webpack-plugin");

const basePackage = {
  name: "@project/functions",
  version: "1.0.0",
  main: "./index.js",
  scripts: {
    start: "yarn run shell"
  },
  engines: {
    node: "12"
  }
};

module.exports = {
  target: "node",
  mode: "production",
  entry: "./src/index.ts",
  devtool: "inline-source-map",
  module: {
    rules: [
      {
        test: /\.tsx?$/,
        use: "ts-loader",
        exclude: /node_modules/
      }
    ]
  },
  resolve: {
    extensions: [".tsx", ".ts", ".js", ".json"],
    alias: {
      "@": path.resolve(__dirname, "src"),
      "@root": path.resolve(__dirname, "./"),
      "@types": path.resolve(__dirname, "src/@types"),
      "@utils": path.resolve(__dirname, "src/utils")
    }
  },
  output: {
    filename: "index.js",
    path: path.resolve(__dirname, "dist"),
    libraryTarget: "commonjs"
  },
  externals: [
    /^firebase.+$/,
    /^@google.+$/,
    nodeExternals({
      allowlist: [/^@project/]
    })
  ],
  plugins: [new GeneratePackageJsonPlugin(basePackage)]
};

कोड को बंडल करने के लिए वेबपैक का उपयोग करने के बारे में दूसरा लाभ यह है कि मैं अंततः मॉड्यूल उपनाम का उपयोग कर सकता हूं :)