
## Table of Contents

1. [Introduction](#introduction)
2. [Prerequisites](#prerequisites)
3. [Setup npm Repository](#setup-npm-repository)
4. [Adding Code to Interact with Firestore](#adding-code-to-interact-with-firestore)
5. [Prepare the CRUD Operations](#prepare-the-crud-operations)
6. [Read Data - HTTP GET](#read-data---http-get)
7. [Create Data - HTTP POST](#create-data---http-post)
8. [Update Data - HTTP PUT](#update-data---http-put)
9. [Delete Data - HTTP DELETE](#delete-data---http-delete)
10. [Complete index.js File](#the-complete-indexjs-file-for-crud-operations)
11. [Deploy to the Cloud](#deploy-nodejs-code-to-the-cloud)
12. [Conclusion](#conclusion)

## Introduction

This blog focuses on how to use Google Cloud Functions to handle CRUD operations with Cloud Firestore. Cloud Functions act as the HTTP server, while Firestore serves as the NoSQL database backend. Both services are serverless and hosted in the cloud, so you can focus on your business logic without worrying about server management.

## Prerequisites

Before we start, you will need to prepare the following:

![Cloud Functions to Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img1.png)

- A GCP (Google Cloud Platform) account
- A GCP project set up
- A Firestore collection configured in your GCP project
- A service account with the `Cloud Datastore Owner` role, with the key file downloaded to your local repository folder

## Setup npm Repository

First, initialize the npm repository by running the following command. This will create a `package.json` file with default settings.

```
npm init -y
```

Next, install `@google-cloud/functions-framework` so you can test the Cloud Function locally.

```
npm install --save-dev @google-cloud/functions-framework
```

To test locally, add the following script to your `package.json`:

```
"start": "npx functions-framework --target=main [--signature-type=http]"
```

Also, install the `firebase-admin` package so you can communicate with Firebase and Firestore.

```
npm install --save firebase-admin
```

## Adding Code to Interact with Firestore

Once the npm packages are installed, we can start adding code. Create a file called `index.js` and add the following code to initialize Firestore with the service account credentials.

```javascript
const { initializeApp, cert } = require("firebase-admin/app");
const { getFirestore } = require("firebase-admin/firestore");

const serviceAccount = require("./service-account-has-fireStore-role.json");
initializeApp({
  credential: cert(serviceAccount),
});
```

## Prepare the CRUD Operations

We will create the following basic CRUD operations from the Cloud Function to the Firestore database:

- **Read Data** - [HTTP GET] - `http://localhost:8080/?docid=800`
- **Create Data** - [HTTP POST] - `http://localhost:8080/`

```json
{
  "docid": "2000",
  "id": "test_10",
  "list": [1, 2, 3]
}
```

- **Update Data** - [HTTP PUT] - `http://localhost:8080/?docid=800`

```json
{
  "id": "test_10",
  "list": [1, 2, 3]
}
```

- **Delete Data** - [HTTP DELETE] - `http://localhost:8080/?docid=800`

## Read Data - HTTP GET

First, we handle the HTTP GET request for the read operation. Here we check that the HTTP method is `GET` and that the `docid` query string parameter is provided.

```javascript
exports.main = (req, res) => {

if (req.method === 'GET') {
    if (!req.query.docid) {
        return res.status(404).send('');
    }

    db.collection('my_collection').doc(req.query.docid.toString()).get()
    .then(doc => {
        return res.status(200).send(doc.data());
    });
}
```

Below is how it looks when we run `npm run start` and test with Postman.
![Cloud Functions to Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img2.png)

## Create Data - HTTP POST

For creating data, we expect the HTTP method to be `POST` and the request body to contain the following JSON structure:

```json
{
  "docid": "200",
  "id": "test_10",
  "list": [10, 20, 30, 40]
}
```

Once we receive the `request.body`, we use Firestore's `set` function to create or update the document in the target collection.

```javascript
exports.main = (req, res) => {

    else if (req.method === 'POST') {

        db.collection('my_collection')
        .doc(req.body.docid)
        .set({
            id: req.body.id,
            list: req.body.list
        })
        .then((doc) => {
            return res.status(200).send(doc);
        });
    }
```

Below is how it looks when we run `npm run start` and test with Postman.
![HTTP Post with Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img3.png)

## Update Data - HTTP PUT

For the update operation, we continue using the `set` function with the document ID passed as a query string parameter.

```javascript
exports.main = (req, res) => {

    else if (req.method === 'PUT') {
        db.collection('my_collection')
        .doc(req.query.docid)
        .set({
            id: req.body.id,
            list: req.body.list
        })
        .then((result) => {
            return res.status(200).send(result);
        });
    }
```

Below is how it looks when we run `npm run start` and test with Postman.
![HTTP Put with Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img4.png)

## Delete Data - HTTP DELETE

For the delete operation, we expect the `docid` to be passed as a query string parameter and use the `delete` method to remove the document from the Firestore database.

```javascript
exports.main = (req, res) => {

    else if (req.method === 'DELETE') {
        db.collection('my_collection')
        .doc(req.query.docid).delete()
        .then((result) => {
            return res.status(200).send(result);
        });
    }
```

Below is how it looks when we run `npm run start` and test with Postman.
![HTTP Delete with Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img5.png)

## The Complete `index.js` File for CRUD Operations

The following snippet contains all the CRUD code mentioned earlier in a single file.

```javascript
const {
  initializeApp,
  applicationDefault,
  cert,
} = require("firebase-admin/app");
const {
  getFirestore,
  Timestamp,
  FieldValue,
} = require("firebase-admin/firestore");

const serviceAccount = require("./none-firebase-admin-firm-champion-365105-f0d88d6192e2.json");

initializeApp({
  credential: cert(serviceAccount),
});

const db = getFirestore();

exports.main = (req, res) => {
  if (req.method === "GET") {
    if (!req.query.docid) {
      return res.status(404).send("");
    }

    db.collection("my_collection")
      .doc(req.query.docid.toString())
      .get()
      .then((doc) => {
        return res.status(200).send(doc.data());
      });
  } else if (req.method === "POST") {
    db.collection("my_collection")
      .doc(req.body.docid)
      .set({
        id: req.body.id,
        list: req.body.list,
      })
      .then((doc) => {
        return res.status(200).send(doc);
      });
  } else if (req.method === "PUT") {
    db.collection("my_collection")
      .doc(req.query.docid)
      .set({
        id: req.body.id,
        list: req.body.list,
      })
      .then((result) => {
        return res.status(200).send(result);
      });
  } else if (req.method === "DELETE") {
    db.collection("my_collection")
      .doc(req.query.docid)
      .delete()
      .then((result) => {
        return res.status(200).send(result);
      });
  }
};
```

## Deploy Node.js Code to the Cloud

For deployment, you can use `gcloud` to deploy from your local machine, integrate with CI/CD, or deploy from a cloud bucket as a zip file. In this example, we will deploy directly from your local folder to the cloud.

Below is the sample command that deploys the function named `my-firestore-function` to Google Cloud Functions:

```
gcloud functions deploy my-firestore-function --trigger-http --region=us-central1 --runtime=nodejs16 --gen2 --allow-unauthenticated --entry-point=main
```

Once the deployment is complete, you should see a URL in the console output. You can also find your Cloud Function URL in the GCP Console. If you browse to the URL with the `docid` query string parameter, you should see a JSON response from the Firestore database.

## Conclusion

This guide demonstrated how to use Google Cloud Functions as an HTTP server to perform CRUD operations with Cloud Firestore as the backend database. Key takeaways:

1. **Cloud Functions** handle HTTP requests (GET, POST, PUT, DELETE) for each CRUD operation
2. **Firestore's `set` method** can be used for both creating and updating documents
3. **Local testing** is possible using the `functions-framework` before deploying to the cloud
4. Both Cloud Functions and Firestore are **serverless**, so you can focus on your business logic without managing servers


This blog shows how to perform CRUD operations with Cloud Firestore using Google Cloud Functions and Node.js.

CRUD with Cloud Firestore and Node.js by Google Cloud Function


## Table of Contents

1. [About Firestore](#about-firestore)
2. [GCP Account](#gcp-account)
3. [Create a New Project at Firebase](#create-a-new-project-at-firebase)
4. [Create a Collection, Document, and Field at Cloud Firestore Console](#create-a-collection-document-and-field-at-cloud-firestore-console)
5. [Create Service Account Key](#create-service-account-key)
6. [Create Node.js to Initialize with Firestore](#create-nodejs-to-initialize-with-firestore)
7. [Add Document to Firestore via Node.js](#add-document-to-firestore-via-nodejs)
8. [Get Document from Firestore via Node.js](#get-document-from-firestore-via-nodejs)
9. [Conclusion](#conclusion)

## About Firestore

Firestore is one of Firebase's products. It provides a NoSQL document database that lets users store and query data from mobile or web apps at global scale. This blog will demonstrate how to get started with Firestore using Node.js.

## GCP Account

First, you'll need a GCP account. Once you have one, you should be able to click "Go to console" below and get into the Firebase portal.
![access to Firebase account](/images/how-to-create-firestore-with-nodejs/img1.png)

## Create a New Project at Firebase

Once you're in Firebase, follow the navigation and go to the Firestore section. You will also need to create a new project.
All Products > Cloud Firestore

## Create a Collection, Document, and Field at Cloud Firestore Console

Here, we start to design our Firestore schema. We'll need to create a collection. In the example below, I created a data structure for testing. As you can see, I have a project called `test-project`, and my first collection name is `my_collection`.
![design firestore schema](/images/how-to-create-firestore-with-nodejs/img2.png)

## Create Service Account Key

The Node.js sample code below accesses Firestore from the local environment to Cloud Firestore. To do that, we'll need to create a service account with access to Firestore.

- Create a new service account in the Google IAM & Admin section
- Go to `IAM` and add the `Cloud Datastore Owner` role to the service account (you can use a more specific role, but we use this here for simplicity)
- Go to the `Service Accounts` section, find the service account, and create a new key
- Download the JSON key. Once you download the file, you should see that the JSON file has fields such as `type`, `project_id`, and `private_key_id`

Once you have the file, we can start communicating with Firestore from our local environment.

## Create Node.js to Initialize with Firestore

Now we'll start coding to make this work. First, set up npm if you don't have it already. This command will create a `package.json` file:

```
npm init -y
```

Then we'll install the following npm package to interact with Firestore. `firebase-admin` is the official Firebase SDK package that can interact with Firebase, including Firestore. Based on their documentation, the Node.js language seems to support almost all the features Firebase provides.
![more info about Firebase admin docs](https://firebase.google.com/docs/admin/setup/)

```
npm install --save firebase-admin
```

Now create `index.js` in the correct directory alongside `package.json`:

```javascript
const { initializeApp, cert } = require('firebase-admin/app');
const { getFirestore } = require('firebase-admin/firestore');

const serviceAccount = require('./{location to your service account JSON file');

initializeApp({
  credential: cert(serviceAccount),
});

const db = getFirestore();
```

## Add Document to Firestore via Node.js

At this point, you should be able to connect to your Firestore. Now let's try adding some data to our collection.

The code below will connect to the collection, create a new random document, and set the value, or update the existing document if it already exists.

```Javascript
function addData() {
    var randomValue = Math.floor(Math.random() * 100).toString();

    const snapshot = db
      .collection('my_collection')
      .doc(randomValue)
      .set({
        id: "test_" + randomValue,
        list: [6,7,9]
      });
}

addData();
```

![collection result](/images/how-to-create-firestore-with-nodejs/img3.png)

## Get Document from Firestore via Node.js

The sample code below will get all the items from the Firestore collection, and you can loop through the list to find each document.

```
async function getData() {
    const list = await db.collection('my_collection').get();
    list.forEach((doc) => {
      console.log(doc.id, '=>', doc.data());
    });
}
getData();
```

Also, this code snippet filters by the document ID. It will get all the fields for the document with ID 400. If the document ID does not exist, it will return null.

```
async function getData() {
  const snapshot = await db.collection('my_collection')
  .doc('400')
  .get();

  console.info('data', snapshot.data());
}
getData();
```

What if you want to filter by one of the field array `list` values that contains a particular value? The code below will return any document whose `list` field contains the value 1.

```
async function getData() {
  const snapshot = await db.collection('my_collection')
  .where('list', 'array-contains', '1')
  .get();

  snapshot.forEach(doc => {
    console.log(doc.id, '=>', doc.data());
  });

}
getData();
```

How about filtering with other fields? The following will filter by `id` and return the matching result:

```
async function getData() {
  const snapshot = await db.collection('my_collection')
  .where('id', '==', 'test_40')
  .get();

  snapshot.forEach(doc => {
    console.log(doc.id, '=>', doc.data());
  });

}
getData();
```

## Conclusion

This blog covered how to set up Firestore and how to use Node.js to interact with Firestore using different operations.


Cloud Firestore is a cloud-based NoSQL database. This article shows how to get started with Node.js.

Firestore

CRUD with Cloud Firestore and Node.js by Google Cloud Function

How to Create Firestore Database by Node.js