Firebase Functions: The Complete Guide

Getting Started with Firebase Functions

What is Firebase Functions?

Firebase Functions, a serverless computing service, lets you deploy and run custom backend code in response to events triggered by Firebase services or HTTPS requests. This guide offers an introduction to Firebase Functions, including how to set up and deploy a project.

Prerequisites

Before diving into Firebase Functions, ensure the following are installed on your system:

• Node.js (v14 or newer)
• Firebase CLI

Once installed, use the command firebase login to log in to your Firebase account.

Steps to Create a New Project

Follow these steps to create a new Firebase Functions project:

1. Run firebase init functions to create a new project directory and initiate a functions project within it.
2. Link your functions project with a Firebase project.
3. Choose a language (JavaScript or TypeScript) for your Cloud Functions.

This will create a new directory named functions that contains the necessary files for your project.

How to Write a Basic Cloud Function

Write a simple Cloud Function in the functions/index.js (or functions/index.ts for TypeScript) file as shown below:

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

exports.helloWorld = functions.https.onRequest((request, response) => {
    response.send('Hello, World!');
});

Deploying Your Cloud Function

Use the following command to deploy your Cloud Function:

firebase deploy --only functions

Upon successful deployment, you'll receive a URL for your deployed Cloud Function, which can be accessed via a web browser or called within your application.

Creating and Managing Scheduled Functions with Firebase

What are Scheduled Functions?

Scheduled functions in Firebase Functions allow you to run serverless code at specific intervals, making them ideal for tasks that need to be performed regularly. This section will guide you through creating and managing scheduled functions.

Creating a Scheduled Function

To create a scheduled function, update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code:

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

exports.scheduledFunction = functions.pubsub.schedule('every 5 minutes').onRun((context) => {
  console.log('This function will run every 5 minutes!');
});

In the above example, the scheduled function will run every 5 minutes. You can customize the interval by modifying the `schedule` parameter as per your needs.

Setting Time Zones for Scheduled Functions

By default, scheduled functions use the UTC time zone. If you need to set a specific time zone, update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code:

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

exports.scheduledFunctionWithTimeZone = functions.pubsub.schedule('every day 12:00')
  .timeZone('America/New_York')
  .onRun((context) => {
    console.log('This function will run every day at 12:00 PM in the America/New_York time zone!');
  });

In this example, the scheduled function will run every day at 12:00 PM in the America/New_York time zone.

Deploying Your Scheduled Function

Use the following command to deploy your scheduled function:

firebase deploy --only functions

Once the deployment is finished, your scheduled function will automatically run at the specified intervals.

Firebase Realtime Database Event Triggers

Understanding Event Triggers

Firebase Functions can be used to create event triggers for the Firebase Realtime Database. These triggers allow you to respond to changes in your database by executing custom serverless code. In this section, we'll cover the most common event triggers, such as onCreate, onUpdate, and onDelete.

Creating an onCreate Event Trigger

An onCreate trigger activates when a new node is added to the Realtime Database. Update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code to create an onCreate event trigger:

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

exports.newNodeCreated = functions.database.ref('/path/to/nodes/{nodeId}')
  .onCreate((snapshot, context) => {
    const nodeId = context.params.nodeId;
    const nodeData = snapshot.val();
    console.log(`A new node with ID "${nodeId}" was created with data:`, nodeData);
  });

This function will be executed whenever a new node is created at the specified path.

Creating an onUpdate Event Trigger

An onUpdate trigger activates when data in the Realtime Database is updated. To create an onUpdate event trigger, update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code:

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

exports.nodeUpdated = functions.database.ref('/path/to/nodes/{nodeId}')
  .onUpdate((change, context) => {
    const nodeId = context.params.nodeId;
    const beforeData = change.before.val();
    const afterData = change.after.val();
    console.log(`Node with ID "${nodeId}" was updated from`, beforeData, 'to', afterData);
  });

This function will be executed whenever data at the specified path is updated.

Creating an onDelete Event Trigger

An onDelete trigger activates when data in the Realtime Database is deleted. To create an onDelete event trigger, update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code:

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

exports.nodeDeleted = functions.database.ref('/path/to/nodes/{nodeId}')
  .onDelete((snapshot, context) => {
    const nodeId = context.params.nodeId;
    const deletedData = snapshot.val();
    console.log(`Node with ID "${nodeId}" was deleted with data:`, deletedData);
  });

This function will be executed whenever a node at the specified path is deleted.

Deploying Your Event Triggers

To deploy your event triggers, run the following command:

firebase deploy --only functions

Once deployed, your functions will execute in response to the specified Realtime Database events.

Firebase Firestore Event Triggers

Introduction

In this section, we'll discuss how to use Firebase Functions to create event triggers for Firestore, Firebase's scalable, cloud-hosted NoSQL database. Like the event triggers for the Realtime Database, Firestore event triggers, such as onCreate, onUpdate, and onDelete, allow you to execute custom serverless code in response to changes in your database.

Creating an onCreate Event Trigger for Firestore

An onCreate trigger activates when a new document is added to Firestore. To create an onCreate event trigger, update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code:

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

exports.newDocumentCreated = functions.firestore.document('/path/to/documents/{docId}')
  .onCreate((snapshot, context) => {
    const docId = context.params.docId;
    const docData = snapshot.data();
    console.log(`A new document with ID "${docId}" was created with data:`, docData);
  });

This function will execute whenever a new document is created at the specified path.

Creating an onUpdate Event Trigger for Firestore

An onUpdate trigger activates when data in a Firestore document is updated. To create an onUpdate event trigger, update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code:

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

exports.documentUpdated = functions.firestore.document('/path/to/documents/{docId}')
  .onUpdate((change, context) => {
    const docId = context.params.docId;
    const beforeData = change.before.data();
    const afterData = change.after.data();
    console.log(`Document with ID "${docId}" was updated from`, beforeData, 'to', afterData);
  });

This function will execute whenever data in the specified document path is updated.

Creating an onDelete Event Trigger for Firestore

An onDelete trigger activates when a Firestore document is deleted. To create an onDelete event trigger, update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code:

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

exports.documentDeleted = functions.firestore.document('/path/to/documents/{docId}')
  .onDelete((snapshot, context) => {
    const docId = context.params.docId;
    const deletedData = snapshot.data();
    console.log(`Document with ID "${docId}" was deleted with data:`, deletedData);
  });

This function will execute whenever a document at the specified path is deleted.

Deploying Your Firestore Event Triggers

To deploy your event triggers, run the following command:

firebase deploy --only functions

Once deployed, your functions will execute in response to the specified Firestore events.

Setting Up Firebase Storage Event Triggers

Understanding Firebase Storage Event Triggers

In this section, we'll explore how to create event triggers for Firebase Storage using Firebase Functions. Firebase Storage is the cloud-based file storage solution provided by Firebase. Event triggers allow you to execute custom serverless code in response to changes in your storage buckets, such as file uploads, deletions, or metadata updates. We will cover the most common event triggers, namely the onFinalize, onDelete, and onMetadataUpdate triggers.

Creating an onFinalize Event Trigger for Storage

An onFinalize trigger activates when a new file is uploaded to Firebase Storage. To create an onFinalize event trigger, update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code:

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

exports.fileUploaded = functions.storage.object().onFinalize((object) => {
    const filePath = object.name;
    const fileSize = object.size;
    console.log(`A new file was uploaded to path "${filePath}" with size:`, fileSize);
});

This function will execute whenever a new file is uploaded to your Firebase Storage bucket.

Creating an onDelete Event Trigger for Storage

An onDelete trigger activates when a file in Firebase Storage is deleted. To create an onDelete event trigger, update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code:

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

exports.fileDeleted = functions.storage.object().onDelete((object) => {
    const filePath = object.name;
    console.log(`File at path "${filePath}" was deleted.`);
});

This function will execute whenever a file in your Firebase Storage bucket is deleted.

Creating an onMetadataUpdate Event Trigger for Storage

An onMetadataUpdate trigger activates when the metadata of a file in Firebase Storage is updated. To create an onMetadataUpdate event trigger, update your `functions/index.js` (or `functions/index.ts` for TypeScript) file with the following code:

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

exports.metadataUpdated = functions.storage.object().onMetadataUpdate((object) => {
    const filePath = object.name;
    console.log(`Metadata of file at path "${filePath}" was updated.`);
});

This function will execute whenever the metadata of a file in your Firebase Storage bucket is updated.

Deploying Your Storage Event Triggers

To deploy your event triggers, run the following command:

firebase deploy --only functions

Once deployed, your functions will execute in response to the specified Firebase Storage events.

Summary

Using Firebase Functions to create event triggers can greatly enhance the functionality of your Firebase applications by allowing you to execute custom serverless code in response to changes in your Realtime Database, Firestore, and Storage. This allows you to easily automate tasks, such as sending notifications, updating other parts of your database, or performing complex calculations, whenever your data changes.