
## Pre Requirement

This blog will focus on how to use the Google Cloud Function to handler CURD operation with Cloud Firestore. Below is the simple diagram of the process, but before we start you'll need prepare below list to make sure it is ready

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

- have GCP account
- setup GCP project
- setup GCP fireStore collection
- create a service account and add `Cloud Datastore Owner` and download to the local repo folder

## Setup npm repo

Now, let's get started, first we'll need to initialize the npm repo by run the following command on your local. This will create `package.json` file with default setting.

```
npm init -y
```

Next, install the `@google-cloud/functions-framework` so can test the cloud function locally later.

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

To test locally, will need to add following task to the `package.json` as well.

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

Also, will install the following npm package `firebase-admin` so will be able to communicate with `firebase` and `fireStore`.

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

## Adding code to interact with fireStore

Once we have the npm package installed, we can start adding code.
First, let's create a file `index.js`, and will add the following code to start handle CRUD with fireStore.

Here, we'll initialize the fireStore and add service account json, so we can communicate with fireStore from local environment.

```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),
});
```

## Start prepare the CRUD operation

We'll create following operation at this blog, a basic CRUD operation from 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 step, we'll handle the http get for the read operation, here we check http method is `GET`, and has the querystring `docid`.

```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's looks like once we run the `npm run start` to test on my local with postman.
![Cloud Functions to Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img2.png)

## Create Data - [HTTP POST]

For create data, we'll expect the http is `POST` and body has below JSON object structure.

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

Once get the `request.body`, we'll set as showing below, basically using the `fireStore`'s `set` function, which can be using as create or update for the target collection's document.

```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's looks like once we run the `npm run start` to test on my local with postman.
![HTTP Post with fireStore](/images/crud-firestore-with-cloudfunction-nodejs/img3.png)

## Update Data - [HTTP PUT]

Here we'll continue using the `set` function for the update operation.

```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's looks like once we run the `npm run start` to test on my local with postman.
![HTTP Put with fireStore](/images/crud-firestore-with-cloudfunction-nodejs/img4.png)

## Delete Data - [HTTP DELETE]

For the delete we'll just expect the querystring passing the `docid` and use `delete` for remove 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's looks like once we run the `npm run start` to test on my local with postman.
![HTTP Delete with fireStore](/images/crud-firestore-with-cloudfunction-nodejs/img5.png)

## The whole `index.js` file for CRUD operation

This below snippet contains the all the CRUD code we just mentioned earlier.

```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 the `gcloud` to deploy from your local or tight with CI/CD, or deploy from cloud bucket as zip file, but here we'll just deploy from your local folder to the cloud.

below is the sample command that deploy to the google cloud function as name with `my-firestore-function` and other options, once it is done, should be seen a URL from the console or you can find your cloud function, if you browser the URL with the querystring `docid`, now should be seen JSON response from the fireStore database.

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

## Conclusion

Above are few steps that demonstrate how to use cloud function as HTTP(S) request server and communicate with fireStore NoSQL database as back-end server. Both Google cloud function and fireStore are serverless and host in the cloud, so you can focus your business logic and no need to worry about the underneath server.


This blog show how to do CRUD operation with Firestore and Google Cloud Function

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


## About Firestore

Firestore is one of the Firebase's product, provide NoSQL document database let user to store, query data from mobile or web apps at global scale. This blog will demo and shows how to get start with fireStore with node.js.

## GCP Account

First, you'll need GCP account, once you have already should be able to click below Go to console 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 get into the Firebase, follow the navigation and go to the Firestore section and will need to create a new project as well.
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, below example for testing I created data structure as this. As you can see, I have a project as `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 below Node.js sample code to access fireStore will from the local environment to cloud fireStore, to do that we'll need to create service account and has access to fireStore.

- create a new service account at google IAM & Admin section
- go to the `IAM` and add `Cloud Datastore Owner` role to the service account (You should be able to do more specific role here we just use for make it easier.)
- go to `service accounts` section and find the service account and create a new key
- download the json key, once you download the file you should see the JSON file has name as `type`, `project_id`, or `private_key_id`
  Once have the file, we can start to communicate with fireStore from our local environment now.

## Create Node.js to initialize with Firestore

Now, we'll start to do some coding to make this work now, first need to setup a npm if you don't have already.
This command will create `package.json` file.

```
npm init -y
```

Then, we'll install the following npm package for interact with `fireStore`. `firebase-admin` is fireStore official SDK package can interact with Firebase include the fireStore. Base on their document, seems like Node.js language support almost all the feature firebase provided.
![more info about FIrebase admin docs](https://firebase.google.com/docs/admin/setup/)

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

Now, create `index.js` under correct directory with along with `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, should be able to connect to your fireStore. Now, let's try adding some data to our collection.

Below code, will connect to the collection and create a new random document and set the value, or update the existing document if already exist.

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

Below sample code will get all the list from the fireStore for the collection, and you can loop the list and find each documents.

```
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 is for filter by the document id, this will get all the filed by the document id 400.
If the document id not exist then will return null.

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

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

What about if want to filter one of the field array `list` contains particular value? Below code will return any field list has contains value as 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 other filter with other field?
So this will filter the id and return the match find.

```
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 setup fireStore, and how to use Node.js to interact with fireStore with different operations.


Cloud Firestore is cloud-based, NoSQL database, this article shows how to get start wth Node.js

Category fireStore

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

How to Create Firestore database by Node.js