Dynamically exporting functions in firebase

Question

I'm having the typical (according to many posts) issue with cold boot times in cloud functions. A solution that seemed promised suggests to import / export only the function actually being executed, as can be seen here:

https://github.com/firebase/functions-samples/issues/170#issuecomment-323375462

if (!process.env.FUNCTION_NAME || process.env.FUNCTION_NAME === 'sendFollowerNotification') {
  exports.sendFollowerNotification = require('./sendFollowerNotification');
}

Which is a Javascript example, but I'm using typescript. I've tried a number of variations, and while some build, in the end I'm always stuck with my function not being exported and deploy warning me that I'm going to delete the existing function.

This is one of the numerous attempts:

if (!process.env.FUNCTION_NAME || process.env.FUNCTION_NAME === 'generateInviteURL') {
  import ('./invite_functions').then ((mod) => { console.log ("mod follows" ); console.log (mod);  exports.generateInviteURL = functions.https.onRequest( mod.generateInviteURL ); } )
  .catch ((err) => {console.log ("Trying to import/export generateInviteURL ", err);}) ;
}

At mentioned, at deploy time what happens is that I get a warning about the function being deleted.

I was able to "avoid" that message with something like this:

console.log ("Function name: ", process.env.FUNCTION_NAME);

function dummy_generateInviteURL (req, res) { ; }
exports.generateInviteURL = functions.https.onRequest( dummy_generateInviteURL );

if (!process.env.FUNCTION_NAME || process.env.FUNCTION_NAME === 'generateInviteURL') {
console.log ("Doing the good import");
import ('./invite_functions').then ((mod) => { console.log ("mod follows" ); console.log (mod);  exports.generateInviteURL = functions.https.onRequest( mod.generateInviteURL ); } )
  .catch ((err) => {console.log ("Trying to import/export generateInviteURL ", err);}) ;
}

console.log ("Exported");
console.log (exports.generateInviteURL);

Which the idea of course that an empty function would be always be exported but would be replaced with the real one if that's the one being called.

In that case logs look like this:

generateInviteURL Function name:  generateInviteURL generateInviteURL  
generateInviteURL Exported generateInviteURL
{ [Function: cloudFunction] __trigger: { httpsTrigger: {} } }

So the first part looks promising (the environment variable is defined), then the import does something (enters the then block, never the catch), but the exported variable is not replaced.

I'm not sure if this is a TypeScript problem, a firebase problem, or a developer problem - probably I'm just missing something obvious.

So the question - how can I avoid importing/exporting anything I don't need for each specific function?

Answer 1

I've been having similar issues, and I wrote a pretty cool solution that worked for me.

I decided to release it as an open-source package - I've never done that before so if anyone can check it out, contribute or give feedback that would be great.

The package is called better-firebase-functions - https://www.npmjs.com/package/better-firebase-functions

All you have to do is import and run it. Two lines. Pretty much everything else is automated.

It will pick up the default exports of all function files in your directory and deploy them as properly named functions. Here is an example:

import { exportFunctions } from 'better-firebase-functions';

exportFunctions({
   __filename,                         // standard node var (leave as is).
   exports,                            // standard node var (leave as is).
   functionDirectoryPath: './myFuncs', // define root functions folder
                                       // relative to this file.
   searchGlob: '**/*.js'               // file search glob pattern.
});

The only other thing you need to do is export your function.http.onRequest()... as a default export from every file that contains a cloud function that you want to deploy. So:

export default functions.http.onRequest()...
/// OR
const func1 = functions.http.onRequest()...
export default func1;

And that's it! UPDATE: Answer edited to reflect newer version of package.

Answer 2

You can stick to the original index.js, with minor changes. I have tried a few times and came with a solution. Am including a sample dir structure and two typescript files (index.ts and another for your custom function). With this you will never have to change the index.ts to modify or add functions.

Directory Structure

+ functions
|
 -- + src
|   |
|    -- index.ts
|   |
|    -- + get
|       |
|        -- status.f.ts
 -- package.json (auto generated)
|
 -- package-lock.json (auto generated)
|
 -- tsconfig.json (auto generated)
|
 -- tslint.json (auto generated)
|
 -- + lib (auto generated)
|
 -- + node_modules (auto generated)

src/index.ts

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

src/get/status.f.ts

import * as functions from 'firebase-functions';

exports = module.exports = functions.https.onRequest((req, res) => {
    res.status(200).json({'status':'OK'})
})

Once you have created the above file install npm packages 'glob' and 'camelcase', then try to deploy the firebase functions

Firebase will deploy a function named 'getStatus'

NOTE that the name of the function is camel case version of folder names and the file name where the function exists, so you can export only one function per .f.ts file

EDIT

I have updated the dir structure. Note that index.ts and all the subsequent files and folders resides within the parent folder 'src'