Cloud Functions for Firebaseを構造化して、複数のファイルから複数の関数をデプロイするにはどうすればよいですか?


164

複数のCloud Functions for Firebaseを作成し、1つのプロジェクトからすべてを同時にデプロイしたいと考えています。また、各機能を個別のファイルに分けたいと思います。現在、次のようなindex.jsに両方を配置すると、複数の関数を作成できます。

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

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

しかし、fooとbarを別々のファイルに入れたいと思います。私はこれを試しました:

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

foo.jsは

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

そしてbar.jsは

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

すべての関数をindex.jsに配置せずにこれを実現する方法はありますか?


1
@JPVentura。本当によくわかりません。説明してください。
HuyLe 2018年

これはv1.0で更新されましたか?問題があります:stackoverflow.com/questions/50089807/…–
tccpg288

2
ちなみに、この公式のFirebase関数の例には、github.com.jsrequire
firebase

これが役に立つかもしれません:stackoverflow.com/questions/43486278/...
ラメシュ-X

回答:


126

ああ、Cloud Functions for Firebaseは通常、ノードモジュールをロードするため、これは機能します

構造:

/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) => {
    ...
};

1
たとえば、fooモジュールにいくつかの関数を含めることはできますか?もしそうなら、それを実装する方が良いですか?
Alexander Khitev

1
私はあなたができると思います、そして異なるハンドラーをfooから異なるエクスポートされた関数に割り当てます:exports.bar = functions.database.ref( '/ foo')。onWrite(fooModule.barHandler); exports.baz = functions.database.ref( '/ bar')。onWrite(fooModule.bazHandler);
jasonsirota 2017年

44
このソリューションは、情報(つまり、データベースパス)をfoo.jsとbar.jsからindex.jsに移動するため、これらの個別のファイルを使用するという点を打ち負かすので、私は好きではありません。
bvs 2017

@bvsに同意します。Cedは良いアプローチだと思います。各モジュールを明示的にエクスポートしてindex.tsを非常に明確にすることで、少し変更します。たとえば、「./ authenticationFunctions」から{newUser}をエクスポートします
Alan

2
私の最初の質問は、index.jsファイルに関数を配置せずに1つのプロジェクトで複数の関数をデプロイすることに関するものだと思います。データベース情報を渡す方法と方法はスコープ外です。私なら、データベースアクセスを制御する別個のモジュールを作成し、それをfoo.jsとbar.jsに個別に要求することになりますが、それはスタイル上の決定です。
jasonsirota 2017年

75

@jasonsirotaの回答は非常に役に立ちました。しかし、特にHTTPでトリガーされる関数の場合は、より詳細なコードを確認すると役立つ場合があります。

@jasonsirotaの回答と同じ構造を使用して、2つの異なるファイルに2つの別々のHTTPトリガー関数を配置したいとします。

ディレクトリ構造:

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

index.jsの現在の構造は、私にはうまく機能しませんでした。最初にFirebaseモジュールをインポートし、次にアプリを初期化してから、他のフォルダーから関数をインポートする必要がありました。そのようにして、私のアプリは最初に何でも初期化し、認証し、その後アプリを事前に初期化する必要がある関数をインポートします。
tonkatata

47

更新:このドキュメントは役に立ちます。私の答えはこのドキュメントよりも古いものです。


これが私が個人的にtypescriptでそれをした方法です:

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

これを機能させるために2つの警告を与えることによってこれを序文にさせてください:

  1. index.tsでのインポート/エクスポートの問題の順序
  2. dbは別のファイルでなければなりません

ポイント2の理由はわかりません。Secundoは、私のインデックス、メイン、データベースの構成を正確に尊重する必要があります(少なくとも試してみてください)。

index.ts:エクスポートを扱います。index.tsでエクスポートを処理する方がきれいだと思います。

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

main.ts:初期化を扱います。

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

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

db.ts:dbを再エクスポートするだけなので、その名前はdatabase()

import { database } from "firebase-admin";

export const db = database();

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

あなたのtsconfigはどのように見えますか?distフォルダーにコンパイルして、gcloud関数に私のindex.jsの場所を知らせるにはどうすればよいですか?あなたのコードはgithubにありますか?:)
bersling '25

@ choopage-JekBaoお久しぶりです。プロジェクトはもうありません。私が正しく思い出せば、firebase configにディレクトリ(デフォルトではpublicです)を与えることができます。1年以上経っているので私は間違っているかもしれません
Ced

ねえ@ced -なぜできないの内容はdb.ts、外出先内部main.ts(管理者のインスタンス化の後?)。それとも、わかりやすく/簡単にするために、このように分割しただけですか?
dsg38

1
@ dsg38これは非常に前に投稿されました。なぜ今答えを見て別のファイルにあるべきなのか本当にわかりません。わかりやすくするためだったと思います
Ced

21

Cloud 8 / Firebase関数でNode 8 LTSが利用できるようになったことで、スプレッドオペレーターで次のことが可能になります。

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

インポートの数が増えると、各関数のコールドスタートが遅くなるのでしょうか、それとも、完全に分離された多くのモジュールが個別に開発される必要があるのでしょうか。
Simon Fakir

2
unexpected token ...index.js内でeslint分割エラーが発生します。
トーマス

おそらく、ノード8を使用していない
ルークピゲッティ

@SimonFakirいい質問です。それについて何か見つけましたか?
atereshkov

@atereshkovはい以下の回答のように、「process.env.FUNCTION_NAME」を使用して、依存関係を含めて要求された関数のみをロードする方法を見つけました。興味がある場合は、レポを参照として共有することもできます。
Simon Fakir

15

簡単にするために(ただし、作業は行います)、私はこのように自分のコードを個人的に構造化しました。

レイアウト

├── /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.
}

bar.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();

index.ts

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';

ネストされたレベルのディレクトリで機能します。ディレクトリ内のパターンにも従ってください。

@zaidfazilの回答へのクレジット


1
これは、Typescriptの最も単純な答えの1つです。たとえば、firebaseデータベースの単一のインスタンス化にどのように対処しますか?admin.initializeApp(functions.config().firestore) const db = admin.firestore();これをどこに置き、fooとbarでそれをどのように参照しますか?
elprl 2018

ねえ-なぜできないの内容はdb.ts、外出先の内部index.ts(管理インスタンス化の後に?)。それとも、わかりやすく/簡単にするために、このように分割しただけですか?
dsg38

@ dsg38では、すべてを組み合わせることができます。これにより、明確になります
Reza

10

Babel / Flowの場合、次のようになります。

ディレクトリのレイアウト

.
├── /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 -主な輸出品

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


src/db.js -Postgres用Cloud SQLクライアント

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クライアント

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

firebase.initializeApp(config().firebase);

export default firebase.firestore();


src/someFuncA.js -機能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 -機能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

9

bigcodenerd.orgアウトラインは、メソッドをさまざまなファイルに分割し、index.jsファイル内の1行にエクスポートするための、より単純なアーキテクチャパターンです。

このサンプルのプロジェクトのアーキテクチャは次のとおりです。

projectDirectory

  • 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 { ... }
  });

プロファイルファイルのremoveProfileメソッドにも同じパターンが使用されます。


7

簡単にするために(ただし、作業は行います)、私はこのように自分のコードを個人的に構造化しました。

レイアウト

├── /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.
}

bar.ts

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

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

index.ts

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

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

ネストされたレベルのディレクトリで機能します。ディレクトリ内のパターンにも従ってください。


Firebaseは現在ES6インポートディレクティブをサポートしていないノード6.11をサポートしているため、これがどのように機能するかわかりませんか?
Aodh

typescriptを使用している場合、問題は発生しません。最近、ほとんどのコードをtypescriptに移植しました。
zaidfazil

2
zaidfazil、あなたはおそらくあなたの答えのすべての前提条件を書き留めるべきです。@ Aodh、Konstantinが回答で概説したのと同じ方法でBabelを使用すれば機能します。stackoverflow.com/questions/43486278/...
PostureOfLearning

1
ありがとうございました。これはtypescriptとノード6で動作しました:)
Ahmad Moussa '23

4
むしろ普及事業者と輸入と再輸出よりも、あなただけ持つことができませんでしたexport * from './fooFunctions';し、export * from './barFunctions';index.tsで?
whatsthatitspat

5

この形式により、エントリポイントで追加の関数ファイルを検索し、各ファイル内の各関数を自動的にエクスポートできます。

メインエントリポイントスクリプト

functionsフォルダー内のすべての.jsファイルを検索し、各ファイルからエクスポートされた各関数をエクスポートします。

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

1つのファイルからの複数の関数のエクスポートの例

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アクセス可能なエンドポイントは適切に名前が付けられます

✔ 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

1つのファイル

いくつかの追加ファイル(例、1つだけ)がある場合は、以下を使用できます。

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

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


これにより、起動するすべての関数インスタンスの起動時に過負荷が発生しませんか?
Ayyappa

4

したがって、私はこのプロジェクトにバックグラウンド関数とhttp関数があります。単体テストのテストもあります。CI / CDは、クラウド機能をデプロイするときにあなたの人生をはるかに簡単にします

フォルダー構造

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

注: utils/フォルダーは関数間でコードを共有するためのものです

functions / index.js

ここでは、必要なすべての関数をインポートして宣言することができます。ここにロジックは必要ありません。それは私の意見ではそれをよりきれいにします。

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

リポジトリに変更をプッシュするたびに、継続的な統合と展開を行うのはどうですか?あなたはグーグルグーグルクラウドビルドを使用してそれを持つことができます。特定の時点まで無料です:)このリンクを確認してください

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

私はあなたが言ったようにエクスポートしましたが、Firebase Deployは最後にあるものを検出します。
OK200

@ OK200あなたはfirebaseコマンドラインで使用しているコマンドは何ですか?あなたを助けるために、私はいくつかのコードを見る必要があります
ajorquera

3

すべてのクラウド機能を長期的に整理するには、かなり良い方法があります。私は最近これをしました、そしてそれは完璧に働いています。

私がしたことは、トリガーのエンドポイントに基づいて、各クラウド機能を別々のフォルダーに整理することでした。すべてのクラウド関数のファイル名はで終わります*.f.js。あなたが持っていた場合たとえば、onCreateonUpdate上のトリガuser/{userId}/document/{documentId}、その後は2つのファイルを作成onCreate.f.jsし、onUpdate.f.jsディレクトリにfunctions/user/document/し、あなたの関数という名前になりますuserDocumentOnCreateuserDocumentOnUpdate、それぞれ。(1)

次に、ディレクトリ構造のサンプルを示します。

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

サンプル関数

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):任意の名前を使用できます。私にとって、onCreate.f.js、onUpdate.f.jsなどは、それらがどのようなトリガーであるかにもっと関連しているように見えます。


1
このアプローチは本当に素晴らしいです。たとえば、異なるAPIバージョン(api v1、api v2など)を分離できるように、関数名にスラッシュを許可するように調整できるかどうか疑問に思いました
Alex Sorokoletov

同じプロジェクトでクラウド関数の異なるバージョンを保持したいのはなぜですか?ディレクトリ構造をわずかに変更することでそれを実行できますが、選択的にデプロイするか、最終的にコードを混乱させることになるindex.jsでif条件を使用しない限り、デフォルトでindex.jsはすべてのクラウド機能をデプロイします
krhitesh

1
すべてをデプロイしても問題はありません。入れた関数(httpトリガーのもの)をバージョン管理したいだけです
Alex Sorokoletov

すべてのhttpトリガーが独自の*.f.jsファイルにあることを期待しています。あなたがすることができる少なくともそれが何かのようにするために接尾辞を付加することで、すべてのバージョンのためのファイルの名前を変更された*.v1.f.jsか、*.v2.f.jsなど(あなたのHTTPトリガーのすべてのすべてのバージョンを想定すると、ライブです)。より良い解決策があるかどうか教えてください。
krhitesh 2018

1

私はバニラJSブートローダーを使用して、使用したいすべての機能を自動インクルードしています。

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

index.js(ブートローダー)

/**
 * 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))
        }
      })
    }
  }
})

この例のindex.jsファイルは、ルート内のディレクトリのみを自動インクルードします。ディレクトリをウォークしたり、.gitignoreを尊重したりするために拡張できます。ただし、これで十分でした。

インデックスファイルを配置すると、新しい関数を追加するのは簡単です。

/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 収量:

λ ~/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

このワークフローはほとんど「書き込みと実行」であり、新しい関数/ファイルが追加/変更/削除されるたびにindex.jsファイルを変更する必要はありません。


これはコールドスタートになるのではないでしょうか。
Ayyappa

1

typescriptを使用してクラウド関数を作成する場合の簡単な答えは次のとおりです。

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

上部にある通常のインポートのほとんどすべてから、すべての関数をエクスポートしfoo.tsます。

export * from './foo';


弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.