unable to split Firebase functions in multiple files

[mInzamamMalik]

I'm working with firebase functions and arrived to hundreds of functions, and now it is very hard to manage it in single index.js file as shown in their lots of examples

I tried to split that functions in multiple files like:

    --firebase.json
    --functions
      --node_modules
      --index.js
      --package.json
      --app
        --groupFunctions.js
        --authFunctions.js
        --storageFunctions.js

in this structure i devide my functions in three categories and put in that three files groupFunctions.js authFunctions.js storageFunctions.js and tried to import that files in index.js but i don't know why it is not working for me

Here is groupFunctions.js

var functions = require('firebase-functions');
module.exports = function(){
    exports.onGroupCreate = functions.database.ref('/groups/{groupId}')
        .onWrite(event => {
            console.log(`A group is created in database named:${event.params.groupId}.`);
            // some logic...
            //...
        })
}

Here is index.js file:

var functions = require('firebase-functions');
module.exports = require("./app/groupFunctions")();

my editor not giving any warning in this code but when i deploy this code with firebase deploy --only functions it does not deploy function (if some functions already exist on firebase console, it remove all functions on deploy)

So I need help regarding this problem,
looking forward to listen from you guise.

question is also asked on stackoverflow

[kibagateaux]

@malikasinger1 I had a similar issue so I had to make a higher order function that takes my firebase objects and returns the cloud function I would like to deploy.

cloudFunction.js

export const cloudFunction = (functions, admin) => {
  return functions.https.onRequest((req, res) => {
    const {userID} = req.body;
    admin.database()
      .ref(`users/${userID}`)
      .update(...storylines)
      .then(snapshot => {
        res.send(snapshot.val());
      });
  });
};

index.js

const functions = require('firebase-functions');
const admin = require('firebase-admin');
const src = require('./src');
admin.initializeApp(functions.config().firebase);
exports.cloudFunctions = src.blah.cloudFunction(functions, admin);

[nicolasgarnier]

Here is my take on it:

You can have an index.js file that will import and list all other Cloud Functions. One trick to improve performance is to use the process.env.FUNCTION_TARGET env variable that will have the name of the Function currently being triggered. During deployment that env variable is null.

Here is an example index.js for 3 functions:

// Sends notifications to users when they get a new follower.
if (!process.env.FUNCTION_TARGET || process.env.FUNCTION_TARGET === 'sendFollowerNotification') {
  exports.sendFollowerNotification = require('./sendFollowerNotification');
}

// Blur offensive images uploaded on Cloud Storage.
if (!process.env.FUNCTION_TARGET || process.env.FUNCTION_TARGET === 'blurOffensiveImages') {
  exports.blurOffensiveImages = require('./blurOffensiveImages');
}

// Renders my server side app template.
if (!process.env.FUNCTION_TARGET || process.env.FUNCTION_TARGET === 'renderTemplate') {
  exports.renderTemplate = require('./renderTemplate');
}

Then for instance, the ./blurOffensiveImages.js would be:

const functions = require('firebase-functions');
const admin = require('firebase-admin');
try {admin.initializeApp(functions.config().firebase);} catch(e) {} // You do that because the admin SDK can only be initialized once.
const mkdirp = require('mkdirp-promise');
// etc... my imports ...

/**
 *  Blur offensive images uploaded on Cloud Storage.
 */
exports = module.exports = functions.storage.object().onChange(event => {
  // Function's code...
});

This will ensure all the 3 functions are deployed if doing a firebase deploy but, at runtime, only one function will be imported. So you won't pollute the functions with each other's imports.

EDIT: Edited to reflect new name of environment variable.

[nicolasgarnier]

Now you could even automate this a bit and register functions based on their file name. For instance with an index.js like this:

**UPDATE, this works:**

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

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

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
    if (!process.env.FUNCTION_TARGET || process.env.FUNCTION_TARGET === fileBaseName) {
      exports[fileBaseName] = require(`${FUNCTIONS_FOLDER}/${fileBaseName}`);
    }
  }
});

Where your file structure is like:

    --firebase.json
    --functions
      --node_modules
      --index.js
      --package.json
      --my_functs
        --sendFollowerNotification.js
        --blurOffensiveImages.js
        --renderTemplate.js

EDIT: Edited to reflect new name of environment variable.

[theprojectsomething]

@nicolasgarnier when attempting to deploy using this method I get the equivalent of
no such file or directory, scandir './my_functs'
assume this is due to the function scanning during deployment (and the fact I'm deploying from the project root, not inside functions). Same goes when attempting to serve from the root.
Is there an obvious way to resolve this? I'm currently checking the dir exists first and if not prepending 'functions/', which works but doesn't seem ideal.

const ENDPOINT_DIR = './endpoints';

fs.readdirSync(fs.existsSync(ENDPOINT_DIR) ? ENDPOINT_DIR : ENDPOINT_DIR.replace('.', './functions')).forEach(file => {
  if(file.endsWith('.js')) {
    const name = file.slice(0, -3);
    const method = name.split(".").reduce(function (method, part) {
      return method ? method + part.charAt(0).toUpperCase() + part.slice(1) : part;
    }, "");
    if (!process.env.FUNCTION_TARGET || process.env.FUNCTION_TARGET === method) {
      exports[method] = require(`${ENDPOINT_DIR}/${name}`);
    }
  }
});

--firebase.json
    --functions
      --node_modules
      --index.js
      --package.json
      --endpoints
        --system.notify.js

EDIT: Edited to reflect new name of environment variable.

[nicolasgarnier]

Ah yes, I actually had a setup where my index.js was at the root (using "functions": {"source": "./","exclude": "public"}, in my firebase.json where this was working fine. You are right that in the example above we need to prepend 'functions'. I think you can also use __dirname like this:

fs.readdirSync(path.resolve(__dirname, FUNCTIONS_FOLDER)).forEach(file => { ...

If you could try that let me know if that works and I'll update my code above :)

[theprojectsomething]

Works perfectly, thanks.

[oodavid]

I've created a slightly modified version of index.js that uses globbing to search for files ending with .function.js. This allows me to organise my directory in any manner.

/** EXPORT ALL FUNCTIONS
 *
 *   Loads all `.function.js` files
 *   Exports a cloud function matching the file name
 * 
 *   Based on this thread:
 *     https://github.com/firebase/functions-samples/issues/170
 */
const glob = require("glob");
const files = glob.sync('./**/*.function.js', { cwd: __dirname });
for(let f=0,fl=files.length; f<fl; f++){
  const file = files[f];
  const functionName = file.split('/').pop().slice(0, -12); // Strip off '.function.js'
  if (!process.env.FUNCTION_TARGET || process.env.FUNCTION_TARGET === functionName) {
    exports[functionName] = require(file);
  }
}

EDIT: Edited to reflect new name of environment variable.

[sonovice]

Thanks for the code snippet, @oodavid . Would it be possible to parse the names of the subfolders as well, e.g. deploy the function in functions/geo/spatial.function.js to https://YOUR_FUNCTIONS_URL/geo/spatial?

[oodavid]

@sonovice you could add a library like camelCase and do something like this to generate your function names, ie:

const functionName = camelCase(file.slice(0, -12).split('/'));

this would set the name of functions/path/to/my/logic.function.js to pathToMyLogic.

(untested logic)

[andrewspy]

@oodavid I have created a simple function at functions/hello/helloWorld.js as follow:-

'use strict';

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

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

But it fails with ! functions[helloWorld]: Deploy Error: Function load error: Error: function load attempt timed out.

Did I missed out anything?

[prescottprue]

@andrewspy Do have a top level exports.helloWorld in functions/index that references the export you showed above?

Something like this:

const helloWorld = require('./hello/helloWorld')
module.exports.helloWorld = helloWorld

Checkout @nicolasgarnier 's comment above (notice how it sets exports.someName to the function).

[andrewspy]

@prescottprue I am actually using @oodavid's code from #170 (comment), which set the reference in index.js in the following code:-

  if (!process.env.FUNCTION_TARGET || process.env.FUNCTION_TARGET === functionName) {
    exports[functionName] = require(file);
  }

I am new to node.js, it'll be great if someone can share a complete working code with index.js and helloWorld.function.js. Thanks!

EDIT: Edited to reflect new name of environment variable.

[oodavid]

@andrewspy with the index.js file I suggested, I'm globbing for files that match './**/*.function.js', so helloWorld.js won't get matched. Rename it to helloWorld.function.js and see if that changes anything.

If not, I'll make an example repo.

[andrewspy]

@oodavid I am actually using functions/hello/helloWorld.function.js, and it's not working... below is the console output for firebase deploy --only functions

i  deploying functions
i  functions: ensuring necessary APIs are enabled...
i  runtimeconfig: ensuring necessary APIs are enabled...
+  runtimeconfig: all necessary APIs are enabled
+  functions: all necessary APIs are enabled
i  functions: preparing functions directory for uploading...
i  functions: packaged functions (3.88 KB) for uploading
+  functions: functions folder uploaded successfully
i  starting release process (may take several minutes)...
i  functions: updating function helloWorld...
!  functions[helloWorld]: Deploy Error: Function load error: Error: function load attempt timed out.

[edTheGuy00]

after trying most of these solutions, only this one worked for me

index.js

'use strict';

//Declare all your child functions here
const fooFunction = require('./foo');
const barFunction = require('./bar');

// Note: these tasks need to be initialized 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();
const messaging = admin.messaging();

exports.fooFunction = functions.database.ref('/users/messages_inbox/{sender_id}/message').onWrite(event => {
// Pass whatever tasks to child functions so they have access to it
  fooFunction.handler(database, messaging, event);
});

exports.barFunction = functions.database.ref('/users').onWrite(event => {
// Pass whatever tasks to child functions so they have access to it
  barFunction.handler(database);
});

foo.js

exports.handler = function(database, messaging, event) {
       // some function
}

bar.js

exports.handler = function(database) {
       // some function
}