Làm cách nào để cấu trúc các Hàm đám mây cho Firebase để triển khai nhiều chức năng từ nhiều tệp?

Tôi muốn tạo nhiều Hàm đám mây cho Firebase và triển khai tất cả chúng cùng một lúc từ một dự án. Tôi cũng muốn tách từng chức năng thành một tệp riêng biệt. Hiện tại tôi có thể tạo nhiều hàm nếu tôi đặt cả hai trong index.js, chẳng hạn như:

exports.foo = functions.database.ref('/foo').onWrite(event => {
    ...
});

exports.bar = functions.database.ref('/bar').onWrite(event => {
    ...
});

Tuy nhiên tôi muốn đặt foo và bar trong các tệp riêng biệt. Tôi đã thử điều này:

/functions
|--index.js (blank)
|--foo.js
|--bar.js
|--package.json

trong đó foo.js là

exports.foo = functions.database.ref('/foo').onWrite(event => {
    ...
});

và bar.js là

exports.bar = functions.database.ref('/bar').onWrite(event => {
    ...
});

Có cách nào để thực hiện điều này mà không cần đặt tất cả các hàm trong index.js không?

À, Chức năng đám mây cho các mô-đun nút tải Firebase bình thường, vì vậy điều này hoạt động

kết cấu:

/functions
|--index.js
|--foo.js
|--bar.js
|--package.json

index.js:

const functions = require('firebase-functions');
const fooModule = require('./foo');
const barModule = require('./bar');

exports.foo = functions.database.ref('/foo').onWrite(fooModule.handler);
exports.bar = functions.database.ref('/bar').onWrite(barModule.handler);

foo.js:

exports.handler = (event) => {
    ...
};

bar.js:

exports.handler = (event) => {
    ...
};

Câu trả lời của @jasonsirota rất hữu ích. Nhưng nó có thể hữu ích để xem mã chi tiết hơn, đặc biệt là trong trường hợp các hàm được kích hoạt HTTP.

Sử dụng cùng cấu trúc như trong câu trả lời của @ jasonsirota, giả sử bạn muốn có hai hàm kích hoạt HTTP riêng biệt trong hai tệp khác nhau:

Cấu trúc thư mục:

    /functions
       |--index.js
       |--foo.js
       |--bar.js
       |--package.json`

index.js:

'use strict';
const fooFunction = require('./foo');
const barFunction = require('./bar');

// Note do below initialization tasks in index.js and
// NOT in child functions:
const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp(functions.config().firebase); 
const database = admin.database();

// Pass database to child functions so they have access to it
exports.fooFunction = functions.https.onRequest((req, res) => {
    fooFunction.handler(req, res, database);
});
exports.barFunction = functions.https.onRequest((req, res) => {
    barFunction.handler(req, res, database);
});

foo.js:

 exports.handler = function(req, res, database) {
      // Use database to declare databaseRefs:
      usersRef = database.ref('users');
          ...
      res.send('foo ran successfully'); 
   }

bar.js:

exports.handler = function(req, res, database) {
  // Use database to declare databaseRefs:
  usersRef = database.ref('users');
      ...
  res.send('bar ran successfully'); 
}

Cập nhật: Tài liệu này sẽ giúp , câu trả lời của tôi cũ hơn tài liệu này.

Đây là cách tôi cá nhân đã làm nó với bản thảo:

/functions
   |--src
      |--index.ts
      |--http-functions.ts
      |--main.js
      |--db.ts
   |--package.json
   |--tsconfig.json

Hãy để tôi mở đầu điều này bằng cách đưa ra hai cảnh báo để thực hiện công việc này:

2. thứ tự xuất / nhập vấn đề trong index.ts
3. db phải là một tệp riêng biệt

Đối với điểm số 2 tôi không chắc tại sao. Secundo bạn nên tôn trọng chính xác cấu hình của tôi về chỉ mục, chính và db (ít nhất là để dùng thử).

index.ts : giao dịch với xuất khẩu. Tôi thấy nó sạch hơn để cho index.ts đối phó với xuất khẩu.

// main must be before functions
export * from './main';
export * from "./http-functions";

main.ts : Thỏa thuận với khởi tạo.

import { config } from 'firebase-functions';
import { initializeApp } from 'firebase-admin';

initializeApp(config().firebase);
export * from "firebase-functions";

db.ts : chỉ cần xem lại db để tên của nó ngắn hơndatabase()

import { database } from "firebase-admin";

export const db = database();

http-Hàm.ts

// db must be imported like this
import { db } from './db';
// you can now import everything from index. 
import { https } from './index';  
// or (both work)
// import { https } from 'firebase-functions';

export let newComment = https.onRequest(createComment);

export async function createComment(req: any, res: any){
    db.ref('comments').push(req.body.comment);
    res.send(req.body.comment);
}

Với Node 8 LTS hiện có sẵn với Chức năng Cloud / Firebase, bạn có thể thực hiện các thao tác sau với toán tử trải rộng:

/package.json

"engines": {
  "node": "8"
},

/index.js

const functions = require("firebase-functions");
const admin = require("firebase-admin");
admin.initializeApp();

module.exports = {
  ...require("./lib/foo.js"),
  // ...require("./lib/bar.js") // add as many as you like
};

/lib/foo.js

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

exports.fooHandler = functions.database
  .ref("/food/{id}")
  .onCreate((snap, context) => {
    let id = context.params["id"];

    return admin
      .database()
      .ref(`/bar/${id}`)
      .set(true);
  });

Để được đơn giản (nhưng thực hiện công việc), cá nhân tôi đã cấu trúc mã của mình như thế này.

Bố trí

├── /src/                      
│   ├── index.ts               
│   ├── foo.ts           
│   ├── bar.ts
|   ├── db.ts           
└── package.json  

foo.ts

import * as functions from 'firebase-functions';
export const fooFunction = functions.database()......... {
    //do your function.
}

export const someOtherFunction = functions.database().......... {
    // do the thing.
}

thanh.ts

import * as functions from 'firebase-functions';
export const barFunction = functions.database()......... {
    //do your function.
}

export const anotherFunction = functions.database().......... {
    // do the thing.
}

db.ts

import * as admin from 'firebase-admin';
import * as functions from 'firebase-functions';

export const firestore = admin.firestore();
export const realtimeDb = admin.database();

chỉ số

import * as admin from 'firebase-admin';
import * as functions from 'firebase-functions';

admin.initializeApp(functions.config().firebase);
// above codes only needed if you use firebase admin

export * from './foo';
export * from './bar';

Hoạt động cho các thư mục của bất kỳ cấp độ lồng nhau. Chỉ cần làm theo mô hình bên trong các thư mục quá.

tín dụng cho câu trả lời @zaidfazil

Trong trường hợp với Babel / Flow, nó sẽ trông như thế này:

Giao diện thư mục

.
├── /build/                     # Compiled output for Node.js 6.x
├── /src/                       # Application source files
│   ├── db.js                   # Cloud SQL client for Postgres
│   ├── index.js                # Main export(s)
│   ├── someFuncA.js            # Function A
│   ├── someFuncA.test.js       # Function A unit tests
│   ├── someFuncB.js            # Function B
│   ├── someFuncB.test.js       # Function B unit tests
│   └── store.js                # Firebase Firestore client
├── .babelrc                    # Babel configuration
├── firebase.json               # Firebase configuration
└── package.json                # List of project dependencies and NPM scripts

src/index.js - Xuất khẩu chính

export * from './someFuncA.js';
export * from './someFuncB.js';

src/db.js - Ứng dụng khách đám mây SQL cho Postgres

import { Pool } from 'pg';
import { config } from 'firebase-functions';

export default new Pool({
  max: 1,
  user: '<username>',
  database: '<database>',
  password: config().db.password,
  host: `/cloudsql/${process.env.GCP_PROJECT}:<region>:<instance>`,
});

src/store.js - Firebase Firestore Client

import firebase from 'firebase-admin';
import { config } from 'firebase-functions';

firebase.initializeApp(config().firebase);

export default firebase.firestore();

src/someFuncA.js - Chức năng A

import { https } from 'firebase-functions';
import db from './db';

export const someFuncA = https.onRequest(async (req, res) => {
  const { rows: regions } = await db.query(`
    SELECT * FROM regions WHERE country_code = $1
  `, ['US']);
  res.send(regions);
});

src/someFuncB.js - Chức năng B

import { https } from 'firebase-functions';
import store from './store';

export const someFuncB = https.onRequest(async (req, res) => {
  const { docs: regions } = await store
    .collection('regions')
    .where('countryCode', '==', 'US')
    .get();
  res.send(regions);
});

.babelrc

{
  "presets": [["env", { "targets": { "node": "6.11" } }]],
}

firebase.json

{
  "functions": {
    "source": ".",
    "ignore": [
      "**/node_modules/**"
    ]
  }
}

package.json

{
  "name": "functions",
  "verson": "0.0.0",
  "private": true,
  "main": "build/index.js",
  "dependencies": {
    "firebase-admin": "^5.9.0",
    "firebase-functions": "^0.8.1",
    "pg": "^7.4.1"
  },
  "devDependencies": {
    "babel-cli": "^6.26.0",
    "babel-core": "^6.26.0",
    "babel-jest": "^22.2.2",
    "babel-preset-env": "^1.6.1",
    "jest": "^22.2.2"
  },
  "scripts": {
    "test": "jest --env=node",
    "predeploy": "rm -rf ./build && babel --out-dir ./build src",
    "deploy": "firebase deploy --only functions"
  }
}

$ yarn install                  # Install project dependencies
$ yarn test                     # Run unit tests
$ yarn deploy                   # Deploy to Firebase

bigcodenerd.org phác thảo một mẫu kiến ​​trúc đơn giản hơn để có các phương thức được tách thành các tệp khác nhau và được xuất thành một dòng trong index.js .

Kiến trúc cho dự án trong mẫu này là như sau:

dự án

• index.js
• podcast.js
• profile.js

index.js

const admin = require('firebase-admin');
const podcast = require('./podcast');
const profile = require('./profile');
admin.initializeApp();

exports.getPodcast = podcast.getPodcast();
exports.removeProfile = profile.removeProfile();

podcast.js

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

exports.getPodcast = () => functions.https.onCall(async (data, context) => {
      ...
      return { ... }
  });

Mẫu tương tự sẽ được sử dụng cho removeProfilephương thức trong tệp hồ sơ .

Để được đơn giản (nhưng thực hiện công việc), cá nhân tôi đã cấu trúc mã của mình như thế này.

Bố trí

├── /src/                      
│   ├── index.ts               
│   ├── foo.ts           
│   ├── bar.ts           
└── package.json  

foo.ts

export const fooFunction = functions.database()......... {
    //do your function.
}

export const someOtherFunction = functions.database().......... {
    // do the thing.
}

thanh.ts

export const barFunction = functions.database()......... {
    //do your function.
}

export const anotherFunction = functions.database().......... {
    // do the thing.
}

chỉ số

import * as fooFunctions from './foo';
import * as barFunctions from './bar';

module.exports = {
    ...fooFunctions,
    ...barFunctions,
};

Hoạt động cho các thư mục của bất kỳ cấp độ lồng nhau. Chỉ cần làm theo mô hình bên trong các thư mục quá.

Định dạng này cho phép điểm nhập của bạn tự động tìm các tệp chức năng và xuất từng chức năng trong mỗi tệp.

Kịch bản điểm chính

Tìm tất cả các tệp .js bên trong thư mục hàm và xuất từng hàm được xuất từ ​​mỗi tệp.

const fs = require('fs');
const path = require('path');

// Folder where all your individual Cloud Functions files are located.
const FUNCTIONS_FOLDER = './scFunctions';

fs.readdirSync(path.resolve(__dirname, FUNCTIONS_FOLDER)).forEach(file => { // list files in the folder.
  if(file.endsWith('.js')) {
    const fileBaseName = file.slice(0, -3); // Remove the '.js' extension
    const thisFunction = require(`${FUNCTIONS_FOLDER}/${fileBaseName}`);
    for(var i in thisFunction) {
        exports[i] = thisFunction[i];
    }
  }
});

Ví dụ Xuất nhiều hàm từ một tệp

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

const query = functions.https.onRequest((req, res) => {
    let query = req.query.q;

    res.send({
        "You Searched For": query
    });
});

const searchTest = functions.https.onRequest((req, res) => {
    res.send({
        "searchTest": "Hi There!"
    });
});

module.exports = {
    query,
    searchTest
}

http điểm cuối có thể truy cập được đặt tên thích hợp

✔ functions: query: http://localhost:5001/PROJECT-NAME/us-central1/query
✔ functions: helloWorlds: http://localhost:5001/PROJECT-NAME/us-central1/helloWorlds
✔ functions: searchTest: http://localhost:5001/PROJECT-NAME/us-central1/searchTest

Một tập tin

Nếu bạn chỉ có một vài tệp bổ sung (ví dụ: chỉ một), bạn có thể sử dụng:

const your_functions = require('./path_to_your_functions');

for (var i in your_functions) {
  exports[i] = your_functions[i];
}

Vì vậy, tôi có dự án này có chức năng nền và chức năng http. Tôi cũng có bài kiểm tra để kiểm tra đơn vị. CI / CD sẽ giúp cuộc sống của bạn dễ dàng hơn nhiều khi triển khai các chức năng đám mây

Cấu trúc thư mục

|-- package.json
|-- cloudbuild.yaml
|-- functions
    |-- index.js
    |-- background
    |   |-- onCreate
    |       |-- index.js
            |-- create.js
    |
    |-- http
    |   |-- stripe
    |       |-- index.js
    |       |-- payment.js
    |-- utils
        |-- firebaseHelpers.js
    |-- test
        |-- ...
    |-- package.json

Lưu ý: utils/ thư mục dành cho mã chia sẻ giữa các chức năng

Hàm / index.js

Tại đây bạn chỉ có thể nhập tất cả các chức năng bạn cần và khai báo chúng. Không cần phải có logic ở đây. Nó làm cho nó sạch hơn theo ý kiến ​​của tôi.

require('module-alias/register');
const functions = require('firebase-functions');

const onCreate = require('@background/onCreate');
const onDelete = require('@background/onDelete');
const onUpdate = require('@background/onUpdate');

const tours  = require('@http/tours');
const stripe = require('@http/stripe');

const docPath = 'tours/{tourId}';

module.exports.onCreate = functions.firestore.document(docPath).onCreate(onCreate);
module.exports.onDelete = functions.firestore.document(docPath).onDelete(onDelete);
module.exports.onUpdate = functions.firestore.document(docPath).onUpdate(onUpdate);

module.exports.tours  = functions.https.onRequest(tours);
module.exports.stripe = functions.https.onRequest(stripe);

CI / CD

Làm thế nào về việc có liên tục tích hợp và triển khai mỗi khi bạn đẩy các thay đổi của mình lên repo? Bạn có thể có nó bằng cách sử dụng google google cloud build . Nó miễn phí cho đến khi điểm nhất định :) Kiểm tra liên kết này .

./cloudbuild.yaml

steps:
  - name: "gcr.io/cloud-builders/npm"
    args: ["run", "install:functions"]
  - name: "gcr.io/cloud-builders/npm"
    args: ["test"]
  - name: "gcr.io/${PROJECT_ID}/firebase"
    args:
      [
        "deploy",
        "--only",
        "functions",
        "-P",
        "${PROJECT_ID}",
        "--token",
        "${_FIREBASE_TOKEN}"
      ]

substitutions:
    _FIREBASE_TOKEN: nothing

Có một cách khá hay để tổ chức tất cả các chức năng đám mây của bạn trong thời gian dài. Tôi đã làm điều này gần đây và nó đang hoạt động hoàn hảo.

Những gì tôi đã làm là tổ chức từng chức năng đám mây trong các thư mục riêng dựa trên điểm cuối kích hoạt của chúng. Mỗi tên tệp hàm đám mây kết thúc bằng *.f.js. Ví dụ: nếu bạn có onCreatevà onUpdatekích hoạt user/{userId}/document/{documentId}thì tạo hai tệp onCreate.f.jsvà onUpdate.f.jstrong thư mục functions/user/document/và chức năng của bạn sẽ được đặt tên userDocumentOnCreatevàuserDocumentOnUpdate tương ứng. (1)

Đây là một cấu trúc thư mục mẫu:

functions/
|----package.json
|----index.js
/----user/
|-------onCreate.f.js
|-------onWrite.f.js
/-------document/
|------------onCreate.f.js
|------------onUpdate.f.js
/----books/
|-------onCreate.f.js
|-------onUpdate.f.js
|-------onDelete.f.js

Chức năng mẫu

const functions = require('firebase-functions');
const admin = require('firebase-admin');
const db = admin.database();
const documentsOnCreate = functions.database
    .ref('user/{userId}/document/{documentId}')
    .onCreate((snap, context) => {
        // your code goes here
    });
exports = module.exports = documentsOnCreate;

Index.js

const glob = require("glob");
const camelCase = require('camelcase');
const admin = require('firebase-admin');
const serviceAccount = require('./path/to/ServiceAccountKey.json');
try {
    admin.initializeApp({ credential: admin.credential.cert(serviceAccount),
    databaseURL: "Your database URL" });
} catch (e) {
    console.log(e);
}

const files = glob.sync('./**/*.f.js', { cwd: __dirname });
for (let f = 0, fl = files.length; f < fl; f++) {
    const file = files[f];
    const functionName = camelCase(file.slice(0, -5).split('/')); 
    if (!process.env.FUNCTION_NAME || process.env.FUNCTION_NAME === functionName) {
        exports[functionName] = require(file);
      }
}

(1): Bạn có thể sử dụng bất kỳ tên nào bạn muốn. Đối với tôi, onCreate.f.js, onUpdate.f.js, v.v ... có vẻ phù hợp hơn với loại trình kích hoạt.

Tôi sử dụng bộ tải khởi động JS vanilla để tự động bao gồm tất cả các chức năng tôi muốn sử dụng.

├── /functions
│   ├── /test/
│   │   ├── testA.js
│   │   └── testB.js
│   ├── index.js
│   └── package.json

index.js (bộ nạp khởi động)

/**
 * The bootloader reads all directories (single level, NOT recursively)
 * to include all known functions.
 */
const functions = require('firebase-functions');
const fs = require('fs')
const path = require('path')

fs.readdirSync(process.cwd()).forEach(location => {
  if (!location.startsWith('.')) {
    location = path.resolve(location)

    if (fs.statSync(location).isDirectory() && path.dirname(location).toLowerCase() !== 'node_modules') {
      fs.readdirSync(location).forEach(filepath => {
        filepath = path.join(location, filepath)

        if (fs.statSync(filepath).isFile() && path.extname(filepath).toLowerCase() === '.js') {
          Object.assign(exports, require(filepath))
        }
      })
    }
  }
})

Ví dụ này tệp index.js chỉ bao gồm các thư mục tự động trong thư mục gốc. Nó có thể được mở rộng để đi bộ thư mục, Honor .gitignore, vv Điều này là đủ cho tôi mặc dù.

Với tệp chỉ mục tại chỗ, việc thêm các chức năng mới là chuyện nhỏ.

/test/testA.js

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

exports.helloWorld = functions.https.onRequest((request, response) => {
 response.send("Hello from Firebase!");
});

/test/testB.js

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

exports.helloWorld2 = functions.https.onRequest((request, response) => {
 response.send("Hello again, from Firebase!");
});

npm run serve sản lượng:

λ ~/Workspace/Ventures/Author.io/Firebase/functions/ npm run serve

> functions@ serve /Users/cbutler/Workspace/Ventures/Author.io/Firebase/functions
> firebase serve --only functions


=== Serving from '/Users/cbutler/Workspace/Ventures/Author.io/Firebase'...

i  functions: Preparing to emulate functions.
Warning: You're using Node.js v9.3.0 but Google Cloud Functions only supports v6.11.5.
✔  functions: helloWorld: http://localhost:5000/authorio-ecorventures/us-central1/helloWorld
✔  functions: helloWorld2: http://localhost:5000/authorio-ecorventures/us-central1/helloWorld2

Quy trình công việc này khá nhiều chỉ là "ghi và chạy", mà không phải sửa đổi tệp index.js mỗi khi một chức năng / tệp mới được thêm / sửa đổi / loại bỏ.

Đây là một câu trả lời đơn giản nếu bạn đang tạo các hàm đám mây với bản in.

/functions
|--index.ts
|--foo.ts

Gần tất cả hàng nhập thường xuyên của bạn ở đầu chỉ cần xuất tất cả các chức năng từ foo.ts.

export * from './foo';

Tôi đã dành rất nhiều thời gian để tìm kiếm điều tương tự, và có những gì tôi nghĩ là cách tốt nhất để đạt được nó (Tôi đang sử dụng firebase@7.3.0):

https://codeburst.io/organizing-your-firebase-cloud-fifts-67dc17b3b0da

Nhạt toẹt ;)