DEV Community: Lauren Schaefer

"Sometimes you gotta work a little, so you can ball a lot."

Lauren Schaefer — Mon, 06 Dec 2021 15:26:10 +0000

Tom Haverford once said, "Sometimes you gotta work a little, so you can ball a lot."

That's just what Diego and I did. We worked a little (created a CI/CD pipeline using GitHub Actions for a MongoDB Realm mobile app), so that we can ball a lot (our app development can really fly now that we have an automated pipeline).

My Workflows

We created two workflows for our CI/CD pipeline:

The build workflow contains all of the automation for building and deploying the mobile app
The delete feature branch artifacts upon branch deletion workflow contains cleanup automation that deletes the artifacts that were associated with a given branch

For more details on what is happening in each of these workflows, check out How to Build CI/CD Pipelines for MongoDB Realm Apps Using GitHub Actions.

mongodb-developer / realm-demos

MongoDB Realm demo apps

Submission Category:

Phone Friendly

Yaml File or Link to Code

Additional Resources / Info

Collaborator: Diego Freniche

Article About the Workflows

How to Build CI/CD Pipelines for MongoDB Realm Apps Using GitHub Actions

Video About the Workflows

Slides About the Workflows

How to Use One of the Most Powerful Pieces of MongoDB: The Aggregation Framework

Lauren Schaefer — Wed, 19 Feb 2020 13:00:12 +0000

When you want to analyze data stored in MongoDB, you can use MongoDB’s powerful aggregation framework to do so. Today I’ll give you a high level overview of the aggregation framework and show you how to use it.

If you’re just joining us in this Quick Start with MongoDB and Node.js series, we’re just over halfway through. So far, we’ve covered how to connect to MongoDB and perform each of the CRUD—create, read, update, and delete—operations. The code we write today will use the same structure as the code we built in the first post in the series, so, if you have any questions about how to get started or how the code is structured, head back to that first post.

And, with that, let’s dive into the aggregation framework!

Get started with an M0 cluster on Atlas today. It's free forever, and it’s the easiest way to try out the steps in this blog series.

What is the Aggregation Framework?

The aggregation framework allows you to analyze your data in real time. Using the framework, you can create an aggregation pipeline that consists of one or more stages. Each stage transforms the documents and passes the output to the next stage.

If you’re familiar with the Linux pipe |, you can think of the aggregation pipeline as a very similar concept. Just as output from one command is passed as input to the next command when you use piping, output from one stage is passed as input to the next stage when you use the aggregation pipeline.

The aggregation framework has a variety of stages available for you to use. Today, we’ll discuss the basics of how to use $match, $group, $sort, and $limit. Note that the aggregation framework has many other powerful stages including $count, $geoNear, $graphLookup, $project, $unwind, and others.

How Do You Use the Aggregation Framework?

I’m hoping to visit the beautiful city of Sydney, Australia soon. Sydney is a huge city with many suburbs, and I’m not sure where to start looking for a cheap rental. I want to know which Sydney suburbs have, on average, the cheapest one bedroom Airbnb listings.

I could write a query to pull all of the one bedroom listings in the Sydney area and then write a script to group the listings by suburb and calculate the average price per suburb. Or I could write a single command using the aggregation pipeline. Let’s use the aggregation pipeline.

There are a variety of ways you can create aggregation pipelines. You can write them manually in a code editor or create them visually inside of MongoDB Atlas or MongoDB Compass. In general, I don’t recommend writing pipelines manually as it’s much easier to understand what your pipeline is doing and spot errors when you use a visual editor. Since you’re already setup to use MongoDB Atlas for this blog series, we’ll create our aggregation pipeline in Atlas.

Navigate to the Aggregation Pipeline Builder in Atlas

The first thing we need to do is navigate to the Aggregation Pipeline Builder in Atlas.

Navigate to Atlas and authenticate if you’re not already authenticated.
In the CONTEXT menu in the upper-left corner, select the project you are using for this Quick Start series.
In the right pane for your cluster, click COLLECTIONS.
In the list of databases and collections that appears, select listingsAndReviews.
In the right pane, select the Aggregation view to open the Aggregation Pipeline Builder.

The Aggregation Pipeline Builder provides you with a visual representation of your aggregation pipeline. Each stage is represented by a new row. You can put the code for each stage on the left side of a row, and the Aggregation Pipeline Builder will automatically provide a live sample of results for that stage on the right side of the row.

Build an Aggregation Pipeline

Now we are ready to build an aggregation pipeline.

Add a $match Stage

Let’s begin by narrowing down the documents in our pipeline to one bedroom listings in the Sydney, Australia market where the room type is Entire home/apt. We can do so by using the $match stage.

On the row representing the first stage of the pipeline, choose $match in the Select… box. The Aggregation Pipeline Builder automatically provides sample code for how to use the $match operator in the code box for the stage.
Now we can input a query in the code box. The query syntax for $match is the same as the findOne() syntax that we used in a previous post. Replace the code in the $match stage’s code box with the following:
```
{
  bedrooms: 1,
  "address.country": "Australia",
  "address.market": "Sydney",
  "address.suburb": { $exists: 1, $ne: "" },
  room_type: "Entire home/apt"
}
```
Note that we will be using the address.suburb field later in the pipeline, so we are filtering out documents where address.suburb does not exist or is represented by an empty string.

The Aggregation Pipeline Builder automatically updates the output on the right side of the row to show a sample of 20 documents that will be included in the results after the $match stage is executed.

Add a $group Stage

Now that we have narrowed our documents down to one bedroom listings in the Sydney, Australia market, we are ready to group them by suburb. We can do so by using the $group stage.

Click ADD STAGE. A new stage appears in the pipeline.
On the row representing the new stage of the pipeline, choose $group in the Select… box. The Aggregation Pipeline Builder automatically provides sample code for how to use the $group operator in the code box for the stage.
Now we can input code for the $group stage. We will provide an _id, which is the field that the Aggregation Framework will use to create our groups. In this case, we will use $address.suburb as our _id. Inside of the $group stage, we will also create a new field named averagePrice. We can use the $avg aggregation pipeline operator to calculate the average price for each suburb. Replace the code in the $group stage’s code box with the following:
```
{
  _id: "$address.suburb",
  averagePrice: {
    "$avg": "$price"
  }
}
```

The Aggregation Pipeline Builder automatically updates the output on the right side of the row to show a sample of 20 documents that will be included in the results after the $group stage is executed. Note that the documents have been transformed. Instead of having a document for each listing, we now have a document for each suburb. The suburb documents have only two fields: _id (the name of the suburb) and averagePrice.

Add a $sort Stage

Now that we have the average prices for suburbs in the Sydney, Australia market, we are ready to sort them to discover which are the least expensive. We can do so by using the $sort stage.

Click ADD STAGE. A new stage appears in the pipeline.
On the row representing the new stage of the pipeline, choose $sort in the Select… box. The Aggregation Pipeline Builder automatically provides sample code for how to use the $sort operator in the code box for the stage.
Now we are ready to input code for the $sort stage. We will sort on the $averagePrice field we created in the previous stage. We will indicate we want to sort in ascending order by passing 1. Replace the code in the $sort stage’s code box with the following:
```
{
  "averagePrice": 1
}
```

The Aggregation Pipeline Builder automatically updates the output on the right side of the row to show a sample of 20 documents that will be included in the results after the $sort stage is executed. Note that the documents have the same shape as the documents in the previous stage; the documents are simply sorted from least to most expensive.

Add a $limit Stage

Now we have the average prices for suburbs in the Sydney, Australia market sorted from least to most expensive. We may not want to work with all of the suburb documents in our application. Instead, we may want to limit our results to the ten least expensive suburbs. We can do so by using the $limit stage.

Click ADD STAGE. A new stage appears in the pipeline.
On the row representing the new stage of the pipeline, choose $limit in the Select… box. The Aggregation Pipeline Builder automatically provides sample code for how to use the $limit operator in the code box for the stage.
Now we are ready to input code for the $limit stage. Let’s limit our results to ten documents. Replace the code in the $limit stage’s code box with the following:
```
10
```

The Aggregation Pipeline Builder automatically updates the output on the right side of the row to show a sample of ten documents that will be included in the results after the $limit stage is executed. Note that the documents have the same shape as the documents in the previous stage; we’ve simply limited the number of results to ten.

Execute an Aggregation Pipeline in Node.js

Now that we have built an aggregation pipeline, let’s execute it from inside of a Node.js script.

Get a Copy of the Node.js Template

To make following along with this blog post easier, I’ve created a starter template for a Node.js script that accesses an Atlas cluster.

Download a copy of template.js.
Open template.js in your favorite code editor.
Update the Connection URI to point to your Atlas cluster. If you’re not sure how to do that, refer back to the first post in this series.
Save the file as aggregation.js.

You can run this file by executing node aggregation.js in your shell. At this point, the file simply opens and closes a connection to your Atlas cluster, so no output is expected. If you see DeprecationWarnings, you can ignore them for the purposes of this post.

Create a Function

Let’s create a function whose job it is to print the cheapest suburbs for a given market.

Continuing to work in aggregation.js, create an asynchronous function named printCheapestSuburbs that accepts a connected MongoClient, a country, a market, and the maximum number of results to print as parameters.
```
async function printCheapestSuburbs(client, country, market, maxNumberToPrint) {
}
```

We can execute a pipeline in Node.js by calling Collection’s aggregate(). Paste the following in your new function:


const pipeline = [];

const aggCursor = client.db("sample_airbnb").collection("listingsAndReviews")
                                    .aggregate(pipeline);

aggregate() has one required param: a pipeline of type object. We could manually create the pipeline here. Since we’ve already created a pipeline inside of Atlas, let’s export the pipeline from there. Return to the Aggregation Pipeline Builder in Atlas. Click the Export pipeline code to language button.
The Export Pipeline To Language dialog appears. In the Export Pipleine To selection box, choose NODE.
In the Node pane on the right side of the dialog, click the copy button.

Return to your code editor and paste the pipeline in place of the empty object currently assigned to the pipeline constant.

const pipeline = [
        {
          '$match': {
            'bedrooms': 1, 
            'address.country': 'Australia', 
            'address.market': 'Sydney', 
            'address.suburb': {
              '$exists': 1, 
              '$ne': ''
            }, 
            'room_type': 'Entire home/apt'
          }
        }, {
          '$group': {
            '_id': '$address.suburb', 
            'averagePrice': {
              '$avg': '$price'
            }
          }
        }, {
          '$sort': {
            'averagePrice': 1
          }
        }, {
          '$limit': 10
        }
      ];

This pipeline would work fine as written. However, it is hardcoded to search for ten results in the Sydney, Australia market. We should update this pipeline to be more generic. Make the following replacements in the pipeline definition:
- Replace ’Australia’ with country
- Replace ’Sydney’ with market
- Replace 10 with maxNumberToPrint
aggregate() will return an AggregationCursor, which we are storing in the aggCursor constant. An AggregationCursor allows traversal over the aggregation pipeline results. We can use AggregationCursor’s forEach() to iterate over the results. Paste the following inside printCheapestSuburbs() below the definition of aggCursor.
```
await aggCursor.forEach(airbnbListing => {
        console.log(`${airbnbListing._id}: ${airbnbListing.averagePrice}`);
    });
```

Call the Function

Now we are ready to call our function to print the ten cheapest suburbs in the Sydney, Australia market. Add the following call in the main() function beneath the comment that says Make the appropriate DB calls.

await printCheapestSuburbs(client, "Australia", "Sydney", 10);

Running aggregation.js results in the following output:

Balgowlah: 45.00
Willoughby: 80.00
Marrickville: 94.50
St Peters: 100.00
Redfern: 101.00
Cronulla: 109.00
Bellevue Hill: 109.50
Kingsgrove: 112.00
Coogee: 115.00
Neutral Bay: 119.00

Now I know what suburbs to begin searching as I prepare for my trip to Sydney, Australia.

Wrapping Up

The aggregation framework is an incredibly powerful way to analyze your data. Creating pipelines may seem a little intimidating at first, but it’s worth the investment. The aggregation framework can get results to your end-users faster and save you from a lot of scripting.

Today, we only scratched the surface of the aggregation framework. I highly recommend MongoDB University’s free course specifically on the aggregation framework: M121: The MongoDB Aggregation Framework. The course has a more thorough explanation of how the aggregation framework works and provides detail on how to use the various pipeline stages.

This post included many code snippets that built on code written in the first post of this MongoDB and Node.js Quick Start series. To get a full copy of the code used in today’s post, visit the Node.js Quick Start GitHub Repo.

Be on the lookout for the next post in this series where we’ll discuss change streams.

Series Versions

The examples in this article were created with the following application versions:

Component	Version used
MongoDB	4.0
MongoDB Node.js Driver	3.3.2
Node.js	10.16.3

All posts in the Quick Start: Node.js and MongoDB series:

How to connect to a MongoDB database using Node.js
How to create MongoDB documents using Node.js
How to read MongoDB documents using Node.js
How to update MongoDB documents using Node.js
How to delete MongoDB documents using Node.js
Video: How to perform the CRUD operations using MongoDB & Node.js
How to analyze your data using MongoDB's Aggregation Framework and Node.js (this post)
How to implement transactions using Node.js
How to react to database changes with change streams and triggers

How to Implement Transactions in MongoDB Using Node.js

Lauren Schaefer — Tue, 04 Feb 2020 18:40:12 +0000

Developers who move from relational databases to MongoDB commonly ask, “Does MongoDB support ACID transactions? If so, how do you create a transaction?” The answer to the first question is, “Yes!”

Beginning in 4.0 MongoDB added support for multi-document ACID transactions, and beginning in 4.2 MongoDB added support for distributed ACID transactions. If you’re not familiar with what ACID transactions are or if you should be using them in MongoDB, check out my earlier post on the subject.

For those of you just joining us in this Quick Start with MongoDB and Node.js series, welcome! We began by walking through how to connect to MongoDB and perform each of the CRUD—create, read, update, and delete—operations. Then we jumped into more advanced topics like the aggregation framework.

The code we write today will use the same structure as the code we built in the first post in the series, so, if you have any questions about how to get started or how the code is structured, head back to that first post.

Now let’s dive into that second question developers ask--let’s discover how to create a transaction!

Get started with an M0 cluster on Atlas today. It's free forever, and it’s the easiest way to try out the steps in this blog series. When you want to move beyond the free tier, use code Lauren200 for $200 of Atlas credits.

Creating an Airbnb Reservation

As you may have experienced while working with MongoDB, most use cases do not require you to use multi-document transactions. When you model your data using our rule of thumb Data that is accessed together should be stored together, you’ll find that you rarely need to use a multi-document transaction. In fact, I struggled a bit to think of a use case for the Airbnb dataset that would require a multi-document transaction.

After a bit of brainstorming, I came up with a somewhat plausible example. Let’s say we want to allow users to create reservations in the sample_airbnb database.

We could begin by creating a collection named users. We want users to be able to easily view their reservations when they are looking at their profiles, so we will store the reservations as embedded documents in the users collection. For example, let’s say a user named Leslie creates two reservations. Her document in the users collection would look like the following:

{
  "_id": {"$oid":"5dd589544f549efc1b0320a5"},
  "email": "leslie@example.com",
  "name": "Leslie Yepp",
  "reservations":  [
    {
      "name":"Infinite Views",
      "dates": [
         {"$date": {"$numberLong":"1577750400000"}},
         {"$date": {"$numberLong":"1577836800000"}}
      ],
      "pricePerNight": {"$numberInt":"180"},
      "specialRequests": "Late checkout",
      "breakfastIncluded":true
    },
    {
      "name": "Lovely Loft",
       "dates": [
         {"$date": {"$numberLong": "1585958400000"}}
      ],
      "pricePerNight": {"$numberInt":"210"}
      "breakfastIncluded":false
    }
  ]
}

When browsing Airbnb listings, users need to know if the listing is already booked for their travel dates. As a result we want to store the dates the listing is reserved in the listingsAndReviews collection. For example, the “Infinite Views” listing that Leslie reserved should be updated to list her reservation dates.

{
  "_id": {"$oid":"5dbc20f942073d6d4dabd730"},
  "name":"Infinite Views",
  "summary":"Modern home with infinite views from the infinity pool",
  "property_type": "House",
  "bedrooms": {"$numberInt": "6"},
  "bathrooms":{"$numberDouble":"4.5"},
  "beds":{"$numberInt":"8"},
  "datesReserved": [
    {"$date": {"$numberLong": "1577750400000"}},
    {"$date": {"$numberLong": "1577836800000"}}
  ]
}

Keeping these two records in sync is imperative. If we were to create a reservation in a document in the users collection without updating the associated document in the listingsAndReviews collection, our data would be inconsistent. We can use a multi-document transaction to ensure both updates succeed or fail together.

Set Up

As with all posts in this MongoDB and Node.js Quick Start series, you’ll need to ensure you’ve completed the prerequisite steps outlined in the Set up section of the first post in this series.

We’ll be using the “Infinite Views” Airbnb listing we created in a previous post in this series. Hop back to the post on Creating Documents if your database doesn’t currently have the Infinite Views listing.

The Airbnb sample dataset only has the listingsAndReviews collection by default. To help you quickly create the necessary collection and data, I wrote usersCollection.js. Download a copy of the file, update the uri constant to reflect your Atlas connection info, and run it by executing node usersCollection.js. The script will create three new users in the users collection: Leslie Yepp, April Ludfence, and Tom Haverdodge. If the users collection does not already exist, MongoDB will automatically create it for you when you insert the new users. The script also creates an index on the email field in the users collection. The index requires that every document in the users collection has a unique email.

Create a Transaction in Node.js

Now that we are set up, let’s implement the functionality to store Airbnb reservations.

Get a Copy of the Node.js Template

To make following along with this blog post easier, I’ve created a starter template for a Node.js script that accesses an Atlas cluster.

Download a copy of template.js.
Open template.js in your favorite code editor.
Update the Connection URI to point to your Atlas cluster. If you’re not sure how to do that, refer back to the first post in this series.
Save the file as transaction.js.

You can run this file by executing node transaction.js in your shell. At this point, the file simply opens and closes a connection to your Atlas cluster, so no output is expected. If you see DeprecationWarnings, you can ignore them for the purposes of this post.

Create a Helper Function

Let’s create a helper function. This function will generate a reservation document that we will use later.

Paste the following function in transaction.js:

function createReservationDocument(nameOfListing, reservationDates, reservationDetails) {
      // Create the reservation
      let reservation = {
          name: nameOfListing,
          dates: reservationDates,
      }

      // Add additional properties from reservationDetails to the reservation
      for (let detail in reservationDetails) {
          reservation[detail] = reservationDetails[detail];
      }

      return reservation;
  }

To give you an idea of what this function is doing, let me show you an example. We could call this function from inside of main():

createReservationDocument("Infinite Views",
    [new Date("2019-12-31"), new Date("2020-01-01")],
    { pricePerNight: 180, specialRequests: "Late checkout", breakfastIncluded: true });

The function would return the following:

    { name: 'Infinite Views',
         dates: [ 2019-12-31T00:00:00.000Z, 2020-01-01T00:00:00.000Z ],
         pricePerNight: 180,
         specialRequests: 'Late checkout',
         breakfastIncluded: true }

Create a Function for the Transaction

Let’s create a function whose job is to create the reservation in the database.

Continuing to work in transaction.js, create an asynchronous function named createReservation. The function should accept a MongoClient, the user’s email address, the name of the Airbnb listing, the reservation dates, and any other reservation details as parameters.
```
async function createReservation(client, userEmail, nameOfListing, reservationDates, reservationDetails) {
}
```

Now we need to access the collections we will update in this function. Add the following code to createReservation().

const usersCollection = client.db("sample_airbnb").collection("users");
const listingsAndReviewsCollection = client.db("sample_airbnb").collection("listingsAndReviews");

Let’s create our reservation document by calling the helper function we created in the previous section. Paste the following code in createReservation().
```
const reservation = createReservationDocument(nameOfListing, reservationDates, reservationDetails);
```
Every transaction and its operations must be associated with a session. Beneath the existing code in createReservation(), start a session.
```
const session = client.startSession();
```
We can choose to define options for the transaction. We won’t get into the details of those here. You can learn more about these options in the driver documentation. Paste the following beneath the existing code in createReservation().
```
const transactionOptions = {
       readPreference: 'primary',
       readConcern: { level: 'local' },
       writeConcern: { w: 'majority' }
   };
```
Now we’re ready to start working with our transaction. Beneath the existing code in createReservation(), open a try{} block, follow it with a catch{} block, and finish it with a finally{} block.
```
   try {

   } catch(e){

   } finally {

   }
```
We can use ClientSession’s withTransaction() to start a transaction, execute a callback function, and commit (or abort on error) the transaction. withTransaction() requires us to pass a function that will be run inside the transaction. Add a call to withTransaction() inside of try {}. Let’s begin by passing an anonymous asynchronous function to withTransaction().
```
const transactionResults = await session.withTransaction(async () => {}, transactionOptions);
```

The anonymous callback function we are passing to withTransaction() doesn’t currently do anything. Let’s start to incrementally build the database operations we want to call from inside of that function. We can begin by adding a reservation to the reservations array inside of the appropriate user document. Paste the following inside of the anonymous function that is being passed to withTransaction().

   const usersUpdateResults = await usersCollection.updateOne(
       { email: userEmail },
       { $addToSet: { reservations: reservation } },
       { session });
   console.log(`${usersUpdateResults.matchedCount} document(s) found in the users collection with the email address ${userEmail}.`);
   console.log(`${usersUpdateResults.modifiedCount} document(s) was/were updated to include the reservation.`);

Since we want to make sure that an Airbnb listing is not double-booked for any given date, we should check if the reservation date is already listed in the listing’s datesReserved array. If so, we should abort the transaction. Aborting the transaction will rollback the update to the user document we made in the previous step. Paste the following beneath the existing code in the anonymous function.

const isListingReservedResults = await listingsAndReviewsCollection.findOne(
      { name: nameOfListing, datesReserved: { $in: reservationDates } },
      { session });
if (isListingReservedResults) {
      await session.abortTransaction();
      console.error("This listing is already reserved for at least one of the given dates. The reservation could not be created.");
      console.error("Any operations that already occurred as part of this transaction will be rolled back.");
      return;
   }

The final thing we want to do inside of our transaction is add the reservation dates to the datesReserved array in the listingsAndReviews collection. Paste the following beneath the existing code in the anonymous function.

const listingsAndReviewsUpdateResults = await listingsAndReviewsCollection.updateOne(
      { name: nameOfListing },
      { $addToSet: { datesReserved: { $each: reservationDates } } },
      { session });
 console.log(`${listingsAndReviewsUpdateResults.matchedCount} document(s) found in the listingsAndReviews collection with the name ${nameOfListing}.`);
 console.log(`${listingsAndReviewsUpdateResults.modifiedCount} document(s) was/were updated to include the reservation dates.`);

We’ll want to know if the transaction succeeds. If transactionResults is defined, we know the transaction succeeded. If transactionResults is undefined, we know that we aborted it intentionally in our code. Beneath the definition of the transactionResults constant, paste the following code.
```
if (transactionResults) {
     console.log("The reservation was successfully created.");
} else {
     console.log("The transaction was intentionally aborted.");
}
```
Let’s log any errors that are thrown. Paste the following inside of catch(e){ }:
```
console.log("The transaction was aborted due to an unexpected error: " + e);
```
Regardless of what happens, we need to end our session. Paste the following inside of finally { }:
```
await session.endSession();
```

At this point, your function should look like the following:

async function createReservation(client, userEmail, nameOfListing, reservationDates, reservationDetails) {

    const usersCollection = client.db("sample_airbnb").collection("users");
    const listingsAndReviewsCollection = client.db("sample_airbnb").collection("listingsAndReviews");

    const reservation = createReservationDocument(nameOfListing, reservationDates, reservationDetails);

    const session = client.startSession();

    const transactionOptions = {
        readPreference: 'primary',
        readConcern: { level: 'local' },
        writeConcern: { w: 'majority' }
    };

    try {
        const transactionResults = await session.withTransaction(async () => {

            const usersUpdateResults = await usersCollection.updateOne(
                { email: userEmail },
                { $addToSet: { reservations: reservation } },
                { session });
            console.log(`${usersUpdateResults.matchedCount} document(s) found in the users collection with the email address ${userEmail}.`);
            console.log(`${usersUpdateResults.modifiedCount} document(s) was/were updated to include the reservation.`);


            const isListingReservedResults = await listingsAndReviewsCollection.findOne(
                { name: nameOfListing, datesReserved: { $in: reservationDates } },
                { session });
            if (isListingReservedResults) {
                await session.abortTransaction();
                console.error("This listing is already reserved for at least one of the given dates. The reservation could not be created.");
                console.error("Any operations that already occurred as part of this transaction will be rolled back.");
                return;
            }

            const listingsAndReviewsUpdateResults = await listingsAndReviewsCollection.updateOne(
                { name: nameOfListing },
                { $addToSet: { datesReserved: { $each: reservationDates } } },
                { session });
            console.log(`${listingsAndReviewsUpdateResults.matchedCount} document(s) found in the listingsAndReviews collection with the name ${nameOfListing}.`);
            console.log(`${listingsAndReviewsUpdateResults.modifiedCount} document(s) was/were updated to include the reservation dates.`);

        }, transactionOptions);

        if (transactionResults) {
            console.log("The reservation was successfully created.");
        } else {
            console.log("The transaction was intentionally aborted.");
        }
    } catch(e){
        console.log("The transaction was aborted due to an unexpected error: " + e);
    } finally {
        await session.endSession();
    }

}

Call the Function

Now that we’ve written a function that creates a reservation using a transaction, let’s try it out! Let’s create a reservation for Leslie at the Infinite Views listing for the nights of December 31, 2019 and January 1, 2020.

Inside of main() beneath the comment that says Make the appropriate DB calls, call your createReservation() function:

   await createReservation(client,
     "leslie@example.com",
     "Infinite Views",
     [new Date("2019-12-31"), new Date("2020-01-01")],
     { pricePerNight: 180, specialRequests: "Late checkout", breakfastIncluded: true });

Save your file.
Run your script by executing node transaction.js in your shell.
The following output will be displayed in your shell.

1 document(s) found in the users collection with the email address leslie@example.com.
1 document(s) was/were updated to include the reservation.
1 document(s) found in the listingsAndReviews collection with the name Infinite Views.
1 document(s) was/were updated to include the reservation dates.
The reservation was successfully created.

Leslie’s document in the users collection now contains the reservation.

{
  "_id": {"$oid":"5dd68bd03712fe11bebfab0c"},
  "email":"leslie@example.com",
  "name":"Leslie Yepp",
  "reservations": [
    {
      "name":"Infinite Views", "dates": [
        {"$date": {"$numberLong":"1577750400000"}},
        {"$date": {"$numberLong":"1577836800000"}}
        ],
      "pricePerNight": {"$numberInt":"180"},
      "specialRequests": "Late checkout",
      "breakfastIncluded":true
    }
  ]
}

The “Infinite Views” listing in the listingsAndReviews collection now contains the reservation dates.

{
  "_id": {"$oid": "5dbc20f942073d6d4dabd730"},
  "name": "Infinite Views",
  "summary": "Modern home with infinite views from the infinity pool",
  "property_type": "House",
  "bedrooms": {"$numberInt":"6"},
  "bathrooms": {"$numberDouble":"4.5"},
  "beds": {"$numberInt":"8"},
  "datesReserved": [
    {"$date": {"$numberLong": "1577750400000"}},
    {"$date": {"$numberLong": "1577836800000"}}
  ]
}

Wrapping Up

Today we implemented a multi-document transaction. Transactions are really handy when you need to make changes to more than one document as an all-or-nothing operation.

When you use relational databases, related data is commonly split between different tables in an effort to normalize the data. As a result, transaction usage is fairly common.

When you use MongoDB, data that is accessed together should be stored together. When you model your data this way, you will likely find that you rarely need to use transactions.

Be on the lookout for the next post in this series where we’ll discuss change streams.

Additional Resources

Series Versions

The examples in this article were created with the following application versions:

Component	Version used
MongoDB	4.0
MongoDB Node.js Driver	3.3.2
Node.js	10.16.3