Jesse Hall

Did you know that Prisma now supports MongoDB? In this article, we'll take a look at how to use Prisma to connect to MongoDB.


## What is Prisma?

Prisma is an open source ORM (Object Relational Mapper) for Node.js. It supports both JavaScript and TypeScript. It really shines when using TypeScript, helping you to write code that is both readable and type-safe.

> If you want to hear from Nikolas Burk and Matthew Meuller of Prisma, check out this episode of the MongoDB Podcast.
> 
> <iframe src="https://open.spotify.com/embed/episode/7CebX3Vq4qNMa9067rUBXU" width="100%" height="232" frameBorder="0" allowtransparency="true" allow="encrypted-media"></iframe>


## Why Prisma?

Schemas help developers avoid data inconsistency issues over time. While you can define a schema at the database level within MongoDB, Prisma lets you define a schema at the application level. When using the Prisma Client, a developer gets the aid of auto-completing queries, since the Prisma Client is aware of the schema.


## Data modeling

Generally, [data that is accessed together should be stored together](https://www.mongodb.com/developer/article/schema-design-anti-pattern-separating-data/) in a MongoDB database. Prisma supports using embedded documents to keep data together.

However, there may be use cases where you'll need to store related data in separate collections. To do that in MongoDB, you can include one document’s `_id` field in another document. In this instance, Prisma can assist you in organizing this related data and maintaining referential integrity of the data.


## Prisma & MongoDB in action

We are going to take an existing example project from Prisma’s `prisma-examples` repository.

One of the examples is a blog content management platform. This example uses a SQLite database. We'll convert it to use MongoDB and then seed some dummy data.

If you want to see the final code, you can find it in [the dedicated Github repository](https://github.com/mongodb-developer/prisma-mongodb-nextjs-example).


### MongoDB Atlas configuration

In this article, we’ll use a MongoDB Atlas cluster. To create a free account and your first forever-free cluster, follow the [Get Started with Atlas guide](https://www.mongodb.com/docs/atlas/getting-started/).


### Prisma configuration

We'll first need to set up our environment variable to connect to our MongoDB Atlas database. I'll add my MongoDB Atlas connection string to a `.env` file.

Example:


```js
DATABASE_URL="mongodb+srv://<username>:<password>@<cluster>.mongodb.net/prisma?retryWrites=true&w=majority"
```


> You can get your connection string from the Atlas dashboard.

Now, let's edit the `schema.prisma` file.

> If you are using Visual Studio Code, be sure to install the official [Prisma VS Code extension](https://marketplace.visualstudio.com/items?itemName=Prisma.prisma) to help with formatting and auto-completion.
> 
> While you’re in VS Code, also install the official [MongoDB VS Code extension](https://marketplace.visualstudio.com/items?itemName=mongodb.mongodb-vscode) to monitor your database right inside VS Code!

In the `datasource db` object, we'll set the provider to "mongodb" and the url to our environment variable `DATABASE_URL`.

For the `User` model, we'll need to update the `id`. Instead of an `Int`, we'll use `String`. We'll set the default to `auto()`. Since MongoDB names the `id` field `_id`, we'll map the `id` field to `_id`. Lastly, we'll tell Prisma to use the data type of `ObjectId` for the `id` field.

We'll do the same for the `Post` model `id` field. We'll also change the `authorId` field to `String` and set the data type to `ObjectId`.


```js
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mongodb"
  url      = env("DATABASE_URL")
}

model User {
  id    String  @id @default(auto()) @map("_id") @db.ObjectId
  email String  @unique
  name  String?
  posts Post[]
}

model Post {
  id        String   @id @default(auto()) @map("_id") @db.ObjectId
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  title     String
  content   String?
  published Boolean  @default(false)
  viewCount Int      @default(0)
  author    User     @relation(fields: [authorId], references: [id])
  authorId  String   @db.ObjectId
}
```


This schema will result in a separate `User` and `Post` collection in MongoDB. Each post will have a reference to a user.

Now that we have our schema set up, let's install our dependencies and generate our schema.


```bash
npm install
npx prisma generate
```


> If you make any changes later to the schema, you'll need to run `npx prisma generate` again.


### Create and seed the MongoDB database

Next, we need to seed our database. The repo comes with a `prisma/seed.ts` file with some dummy data.

So, let's run the following command to seed our database:


```bash
npx prisma db seed
```


This also creates the `User` and `Post` collections that are defined in `prisma/schema.prisma`.


### Other updates to the example code

Because we made some changes to the `id` data type, we'll need to update some of the example code to reflect these changes.

The updates are in the [`pages/api/post/[id].ts`](https://github.com/mongodb-developer/prisma-mongodb-nextjs-example/blob/main/pages/api/post/%5Bid%5D.ts) and [`pages/api/publish/[id].ts`](https://github.com/mongodb-developer/prisma-mongodb-nextjs-example/blob/main/pages/api/publish/%5Bid%5D.ts) files.

Here's one example. We need to remove the `Number()` call from the reference to the `id` field since it is now a `String`.


```js
// BEFORE
async function handleGET(postId, res) {
  const post = await prisma.post.findUnique({
    where: { id: Number(postId) },
    include: { author: true },
  })
  res.json(post)
}

// AFTER
async function handleGET(postId, res) {
  const post = await prisma.post.findUnique({
    where: { id: postId },
    include: { author: true },
  })
  res.json(post)
}
```



### Awesome auto complete & IntelliSense

![Example GIF showing VS Code autocomplete and IntelliSense capabilities](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Animation2_4b8500072b.gif)

Notice in this file, when hovering over the `post` variable, VS Code knows that it is of type `Post`. If we just wanted a specific field from this, VS Code automatically knows which fields are included. No guessing!

### Run the app

Those are all of the updates needed. We can now run the app and we should see the seed data show up.

```bash
npm run dev
```

We can open the app in the browser at `http://localhost:3000/`.

![Screencapture of the resulting application pages in the browser](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Animation_4b18f809df.gif)

From the main page, you can click on a post to see it. From there, you can delete the post.

We can go to the Drafts page to see any unpublished posts. When we click on any unpublished post, we can publish it or delete it.

The "Signup" button will allow us to add a new user to the database.

And, lastly, we can create a new post by clicking the "Create draft" button.

All of these actions are performed by the Prisma client using the API routes defined in our application.

Check out the [`pages/api`](https://github.com/mongodb-developer/prisma-mongodb-nextjs-example/tree/main/pages/api) folder to dive deeper into the API routes.


## Conclusion

Prisma makes dealing with schemas in MongoDB a breeze. It especially shines when using TypeScript by making your code readable and type-safe. It also helps to manage multiple collection relationships by aiding with referential integrity.

I can see the benefit of defining your schema at the application level and will be using Prisma to connect to MongoDB in the future.

Let me know what you think in the [MongoDB community](https://community.mongodb.com/).

In this article, we’ll explore Prisma, an Object Relational Mapper (ODM) for MongoDB. Prisma helps developers to write code that is both readable and type-safe.

Type Safety with Prisma & MongoDB

So your business needs have changed and there’s additional data that needs to be stored within an existing dataset. Fear not! With MongoDB, this is no sweat.

> In this article, I’ll show you how to quickly add and populate additional fields into an existing database collection.

## The Scenario

Let’s say you have a “Netflix” type application and you want to allow users to see which movies they have watched. We’ll use the sample\_mflix database from the [sample datasets](https://docs.atlas.mongodb.com/sample-data/) available in a MongoDB Atlas cluster.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/I_Veb_N_Rm3_Ab3xi_F5c_Phpa3n_3zzf5pvv_I_Fsgnu3_X_6m_U_Knyev_Mrkvy_ZCTUF_5y_LM_Sv_WN_8_E11nbqzv3v_Mo95_C7_WYFGR_3l_OK_4_N2b_Rr9_Z4_Bu_U4_K_Cheipu_V_Rcvcq3_N_Wh_Zd3bu_J_Yafd_V_69c906938e)

Here is the existing schema for the user collection in the sample\_mflix database:

``` js
{
    _id: ObjectId(),
    name: <string>,
    email: <string>,
    password: <string>
}
```

## The Solution

There are a few ways we could go about this. Since MongoDB has a flexible data model, we can just add our new data into existing documents.

In this example, we are going to assume that we know the user ID. We’ll use [`updateOne`](https://docs.mongodb.com/manual/reference/method/db.collection.updateOne/#mongodb-method-db.collection.updateOne) and the [`$addToSet`](https://docs.mongodb.com/manual/reference/operator/update/addToSet/) operator to add our new data.

``` js
const { db } = await connectToDatabase();
const collection = await db.collection(“users”).updateOne(
    { _id: ObjectID(“59b99db9cfa9a34dcd7885bf”) },
    {
        $addToSet: {
            moviesWatched: {
                <movieId>,
                <title>,
                <poster>
            }
        }
    }
);
```

The `$addToSet` operator adds a value to an array avoiding duplicates. If the field referenced is not present in the document, `$addToSet` will create the array field and enter the specified value. If the value is already present in the field, `$addToSet` will do nothing.

Using `$addToSet` will prevent us from duplicating movies when they are watched multiple times.

## The Result

Now, when a user goes to their profile, they will see their watched movies.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/d_I_Tvq_WAL_4_Ap_Z_j_GN_Qx_Vu_Vxw6_3_Dt3_Krn_O_Fl_L9_OI_3be_DD_1_Q58dk_J39f7s0_Vn3p_Ptgcs_P_Ss3_XT_0_B_Kjcqh_H_Erw_J6if2_Ueeb_GA_Gc20_Fmfgt8j9g_H_Tm_Vow_Kk2_Hgb_Kbj_Eg9f_Xg_ACZ_Be_A_bb92f06e85)

But what if the user has not watched any movies? The user will simply not have that field in their document.

I’m using Next.js for this application. I simply need to check to see if a user has watched any movies and display the appropriate information accordingly.

``` js
{ moviesWatched
    ? "Movies I've Watched"
    : "I have not watched any movies yet :("
}
```

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/78ye_Oz_Njq_O_Rd2_Ngt_YQ_0ab_X_Fm_Vn_Eriu9_F_Bh_K8_Zx9_FD_Ls_ST_Uk_IR_Ee8_B_Iz_H_Tw_WI_Or_KB_Kzp_Ve_H_Eti_O66_fyb_MA_Eu_Yxa3gf2iq_Lg_Mska_O1w_W_Jc_Gk1_C7_Uk_F_Mud28_Sx_U4yse_0_Tb3_S9_F_e0d789b4bf)

## Conclusion

Because of MongoDB’s flexible data model, we can have multiple schemas in one collection. This allows you to easily update data and fields in existing schemas.

If you would like to learn more about schema validation, take a look at the [Schema Validation](https://docs.mongodb.com/manual/core/schema-validation/) documentation.

I’d love to hear your feedback or questions. Let’s chat in the [MongoDB Community](https://developer.mongodb.com/community/forums/).

So your business needs have changed and there’s additional data that needs to be stored within an existing dataset. Fear not! With MongoDB, this is no sweat. In this article, I’ll show you how to quickly add and populate additional fields into an existing database collection.

Document Enrichment and Schema Updates

MongoDB Atlas serverless instances are now GA (generally available)!

What is a serverless instance you might ask? In short, *it’s an on-demand serverless database*. In this article, we'll deploy a MongoDB Atlas serverless instance and perform some basic CRUD operations. You’ll need a MongoDB Atlas account. If you already have one [sign-in](https://account.mongodb.com/account/login), or [register now](https://www.mongodb.com/cloud/atlas/register).

## Demand Planning

When you deploy a MongoDB Atlas cluster, you need to understand what compute and storage resources your application will require so that you pick the correct tier to accommodate its needs.

As your storage needs grow, you will need to adjust your cluster’s tier accordingly. You can also enable auto-scaling between a minimum and maximum tier.

## Ongoing Management

Once you’ve set your tiering scale, what happens when your app explodes and gets tons of traffic and exceeds your estimated maximum tier? It’s going to be slow and unresponsive because there aren’t enough resources.

Or, maybe you’ve over-anticipated how much traffic your application would get but you’re not getting any traffic. You still have to pay for the resources even if they aren’t being utilized.

As your application scales, you are limited to these tiered increments but nothing in between.

These tiers tightly couple compute and storage with each other. You may not need 3TB of storage but you do need a lot of compute. So you’re forced into a tier that isn’t balanced to the needs of your application.

## The Solve

MongoDB Atlas serverless instances solve all of these issues:

-   Deployment friction
-   Management overhead
-   Performance consequences
-   Paying for unused resources
-   Rigid data models

With MongoDB Atlas serverless instances, you will get seamless deployment and scaling, a reliable backend infrastructure, and an intuitive pricing model.

It’s even easier to deploy a serverless instance than it is to deploy a free cluster on MongoDB Atlas. All you have to do is choose a cloud provider and region. Once created, your serverless instance will seamlessly scale up and down as your application demand fluctuates.

The best part is you only pay for the compute and storage resources you use, leaving the operations to MongoDB’s best-in-class automation, including end-to-end security, continuous uptime, and regular backups.

## Create Your First Serverless Instance

Let’s see how it works…

If you haven’t already signed up for a [MongoDB Atlas account](https://www.mongodb.com/cloud/atlas/register), go ahead and do that first, then select "Build a Database".

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screen_Shot_2021_07_16_at_3_52_21_PM_25c61de281.png)

Next, choose the Serverless deployment option.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screen_Shot_2021_07_16_at_3_52_50_PM_203c12265e.png)

Now, select a cloud provider and region, and then optionally modify your instance name. Create your new deployment and you’re ready to start using your serverless instance!

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screen_Shot_2021_07_16_at_3_55_23_PM_2ec017a847.png)

Your serverless instance will be up and running in just a few minutes. Alternatively, you can also use the [Atlas CLI](https://www.mongodb.com/docs/atlas/cli/stable/) to create and deploy a new serverless instance.

While we wait for that, let’s set up a quick Node.js application to test out the CRUD operations.

## Node.js CRUD Example

Prerequisite: You will need [Node.js](https://nodejs.org/) installed on your computer.

Connecting to the serverless instance is just as easy as a tiered instance.

1.  Click “Connect.”

    ![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/EXTERNAL_Cluster_Card_Close_Up_2x_38c2a5e381.png)

3.  Set your IP address and database user the same as you would a tiered instance.
4.  Choose a connection method.
	-   You can choose between mongo shell, Compass, or “Connect your application” using MongoDB drivers.
    
    ![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/EXTERNAL_Connect_to_Cluster_2x_eccf2b8761.png)
    
We are going to “Connect your application” and choose Node.js as our driver. This will give us a connection string we can use in our Node.js application. Check the “Include full driver code example” box and copy the example to your clipboard.

To set up our application, open VS Code (or your editor of choice) in a blank folder. From the terminal, let’s initiate a project:

`npm init -y`

Now we’ll install MongoDB in our project:

`npm i mongodb`

### Create

We’ll create a `server.js` file in the root and paste the code example we just copied.

```js
const  MongoClient  =  require('mongodb').MongoClient;
const  uri  =  "mongodb+srv://mongo:<password>@serverlessinstance0.xsel4.mongodb.net/myFirstDatabase?retryWrites=true&w=majority";
const  client  =  new  MongoClient(uri, { useNewUrlParser:  true, useUnifiedTopology:  true });

client.connect(err  => {
    const  collection  =  client.db("test").collection("devices");
    
    // perform actions on the collection object
    
    client.close();
});
```

We’ll need to replace `<password>` with our actual user password and `myFirstDatabase` with the database name we’ll be connecting to.

Let’s modify the `client.connect` method to create a database, collection, and insert a new document.

Now we’ll run this from our terminal using `node server`.

```js
client.connect((err) => {
    const  collection  =  client.db("store").collection("products");
    collection
        .insertOne(
        {
            name:  "JavaScript T-Shirt",
            category:  "T-Shirts",
        })
        .then(() => {
            client.close();
        });
});
```

When we use the `.db` and `.collection` methods, if the database and/or collection does not exist, it will be created. We also have to move the `client.close` method into a `.then()` after the `.insertOne()` promise has been returned. Alternatively, we could wrap this in an async function.

We can also insert multiple documents at the same time using `.insertMany()`.

```js
collection
    .insertMany([
    {
        name:  "React T-Shirt",
        category:  "T-Shirts",
    },
    {
        name:  "Vue T-Shirt",
        category:  "T-Shirts",
    }
    ])
    .then(() => {
        client.close();
    });
```

Make the changes and run `node server` again.

### Read

Let’s see what’s in the database now. There should be three documents. The `find()` method will return all documents in the collection.

```js
client.connect((err) => {
    const  collection  =  client.db("store").collection("products");
    collection.find().toArray((err, result) =>  console.log(result))
    .then(() => {
        client.close();
    });
});
```

When you run `node server` now, you should see all of the documents created in the console.

If we wanted to find a specific document, we could pass an object to the `find()` method, giving it something to look for.

```js
client.connect((err) => {
    const  collection  =  client.db("store").collection("products");
    collection.find({name: “React T-Shirt”}).toArray((err, result) =>  console.log(result))
    .then(() => {
        client.close();
    });
});
```

### Update

To update a document, we can use the `updateOne()` method, passing it an object with the search parameters and information to update.

```js
client.connect((err) => {
    const  collection  =  client.db("store").collection("products");
    collection.updateOne(
        { name:  "Awesome React T-Shirt" },
        { $set: { name:  "React T-Shirt" } }
    )
    .then(() => {
        client.close();
    });
});
```

To see these changes, run a `find()` or `findOne()` again.

### Delete

To delete something from the database, we can use the `deleteOne()` method. This is similar to `find()`. We just need to pass it an object for it to find and delete.

```js
client.connect((err) => {
    const  collection  =  client.db("store").collection("products");
    collection.deleteOne({ name:  "Vue T-Shirt" }).then(() =>  client.close());
});
```

## Conclusion

It’s super easy to use MongoDB Atlas serverless instances! You will get seamless deployment and scaling, a reliable backend infrastructure, and an intuitive pricing model. We think that serverless instances are a great deployment option for new users on Atlas.

I’d love to hear your feedback or questions. Let’s chat in the [MongoDB Community](https://developer.mongodb.com/community/forums/).

MongoDB Atlas serverless instances are now generally available! What is a serverless instance you might ask? In short, it’s an on-demand serverless database. In this article, we'll deploy a MongoDB Atlas serverless instance and perform some basic CRUD operations.

MongoDB Atlas Serverless Instances: Quick Start

Deno is a “modern” runtime for JavaScript and TypeScript that is built in Rust. This makes it very fast!
If you are familiar with Node.js, then you will be right at home with Deno. It is very similar but has some improvements over Node.js. In fact, the creator of Deno also created Node and Deno is meant to be the successor to Node.js.
Deno pairs nicely with MongoDB.

Getting Started with Deno & MongoDB

In this article, we’ll learn how Mongoose, a third-party library for MongoDB, can help you to structure and access your data with ease.

## What is Mongoose?

Many who learn MongoDB get introduced to it through the very popular library, Mongoose. Mongoose is described as “[elegant MongoDB object modeling for Node.js.](https://mongoosejs.com/)”

Mongoose is an ODM (Object Data Modeling) library for MongoDB. While you don’t need to use an Object Data Modeling (ODM) or Object Relational Mapping (ORM) tool to have a great experience with MongoDB, some developers prefer them. Many Node.js developers choose to work with Mongoose to help with data modeling, schema enforcement, model validation, and general data manipulation. And Mongoose makes these tasks effortless.

> If you want to hear from the maintainer of Mongoose, Val Karpov, give this episode of the [MongoDB Podcast](https://mongodb.libsyn.com/ep-22-val-karpov-and-the-mongoose-odm) a listen!

## Why Mongoose?

By default, MongoDB has a flexible data model. This makes MongoDB databases very easy to alter and update in the future. But a lot of developers are accustomed to having rigid schemas.

Mongoose forces a semi-rigid schema from the beginning. With Mongoose, developers must define a Schema and Model.

## What is a schema?

A schema defines the structure of your collection documents. A Mongoose schema maps directly to a MongoDB collection.

``` js
const blog = new Schema({
  title: String,
  slug: String,
  published: Boolean,
  author: String,
  content: String,
  tags: [String],
  createdAt: Date,
  updatedAt: Date,
  comments: [{
    user: String,
    content: String,
    votes: Number
  }]
});
```

With schemas, we define each field and its data type. Permitted types are:

* String
* Number
* Date
* Buffer
* Boolean
* Mixed
* ObjectId
* Array
* Decimal128
* Map

## What is a model?

Models take your schema and apply it to each document in its collection.

Models are responsible for all document interactions like creating, reading, updating, and deleting (CRUD).

> An important note: the first argument passed to the model should be the singular form of your collection name. Mongoose automatically changes this to the plural form, transforms it to lowercase, and uses that for the database collection name.

``` js
const Blog = mongoose.model('Blog', blog);
```

In this example, `Blog` translates to the `blogs` collection.

## Environment setup

Let’s set up our environment. I’m going to assume you have [Node.js](https://nodejs.org/) installed already.

We’ll run the following commands from the terminal to get going:

```
mkdir mongodb-mongoose
cd mongodb-mongoose
npm init -y
npm i mongoose
npm i -D nodemon
code .
```

This will create the project directory, initialize, install the packages we need, and open the project in VS Code.

Let’s add a script to our `package.json` file to run our project. We will also use ES Modules instead of Common JS, so we’ll add the module `type` as well. This will also allow us to use top-level `await`.

``` js
...
  "scripts": {
    "dev": "nodemon index.js"
  },
  "type": "module",
...
```

## Connecting to MongoDB

Now we’ll create the `index.js` file and use Mongoose to connect to MongoDB.

``` js
import mongoose from 'mongoose'

mongoose.connect("mongodb+srv://<username>:<password>@cluster0.eyhty.mongodb.net/myFirstDatabase?retryWrites=true&w=majority")
```

You could connect to a local MongoDB instance, but for this article we are going to use a free MongoDB Atlas cluster. If you don’t already have an account, it's easy to sign up for a [free MongoDB Atlas cluster here](https://www.mongodb.com/cloud/atlas/register2).

And if you don’t already have a cluster set up, follow our guide to [get your cluster created](https://www.mongodb.com/docs/atlas/getting-started/).

After creating your cluster, you should replace the connection string above with your connection string including your username and password.

> The connection string that you copy from the MongoDB Atlas dashboard will reference the `myFirstDatabase` database. Change that to whatever you would like to call your database.

## Creating a schema and model

Before we do anything with our connection, we’ll need to create a schema and model.

Ideally, you would create a schema/model file for each schema that is needed. So we’ll create a new folder/file structure: `model/Blog.js`.

``` js
import mongoose from 'mongoose';
const { Schema, model } = mongoose;

const blogSchema = new Schema({
  title: String,
  slug: String,
  published: Boolean,
  author: String,
  content: String,
  tags: [String],
  createdAt: Date,
  updatedAt: Date,
  comments: [{
    user: String,
    content: String,
    votes: Number
  }]
});

const Blog = model('Blog', blogSchema);
export default Blog;
```

## Inserting data // method 1

Now that we have our first model and schema set up, we can start inserting data into our database.

Back in the `index.js` file, let’s insert a new blog article.

``` js
import mongoose from 'mongoose';
import Blog from './model/Blog';

mongoose.connect("mongodb+srv://mongo:mongo@cluster0.eyhty.mongodb.net/myFirstDatabase?retryWrites=true&w=majority")

// Create a new blog post object
const article = new Blog({
  title: 'Awesome Post!',
  slug: 'awesome-post',
  published: true,
  content: 'This is the best post ever',
  tags: ['featured', 'announcement'],
});

// Insert the article in our MongoDB database
await article.save();
```

We first need to import the `Blog` model that we created. Next, we create a new blog object and then use the `save()` method to insert it into our MongoDB database.

Let’s add a bit more after that to log what is currently in the database. We’ll use the `findOne()` method for this.

``` js
// Find a single blog post
const firstArticle = await Blog.findOne({});
console.log(firstArticle);
```

Let’s run the code!

```
npm run dev
```

You should see the document inserted logged in your terminal.

> Because we are using `nodemon` in this project, every time you save a file, the code will run again. If you want to insert a bunch of articles, just keep saving. 😄

## Inserting data // method 2

In the previous example, we used the `save()` Mongoose method to insert the document into our database. This requires two actions: instantiating the object, and then saving it.

Alternatively, we can do this in one action using the Mongoose `create()` method.

``` js
// Create a new blog post and insert into database
const article = await Blog.create({
  title: 'Awesome Post!',
  slug: 'awesome-post',
  published: true,
  content: 'This is the best post ever',
  tags: ['featured', 'announcement'],
});

console.log(article);
```

This method is much better! Not only can we insert our document, but we also get returned the document along with its `_id` when we console log it.

## Update data

Mongoose makes updating data very convenient too. Expanding on the previous example, let’s change the `title` of our article.

``` js
article.title = "The Most Awesomest Post!!";
await article.save();
console.log(article);
```

We can directly edit the local object, and then use the `save()` method to write the update back to the database. I don’t think it can get much easier than that!

## Finding data

Let’s make sure we are updating the correct document. We’ll use a special Mongoose method, `findById()`, to get our document by its ObjectId.

``` js
const article = await Blog.findById("62472b6ce09e8b77266d6b1b").exec();
console.log(article);
```

> Notice that we use the `exec()` Mongoose function. This is technically optional and returns a promise. In my experience, it’s better to use this function since it will prevent some head-scratching issues. If you want to read more about it, check out this note in the Mongoose docs about [promises](https://mongoosejs.com/docs/promises.html).

There are many query options in Mongoose. View the [full list of queries](https://mongoosejs.com/docs/queries.html).

## Projecting document fields

Just like with the standard MongoDB Node.js driver, we can project only the fields that we need. Let’s only get the `title`, `slug`, and `content` fields.

``` js
const article = await Blog.findById("62472b6ce09e8b77266d6b1b", "title slug content").exec();
console.log(article);
```

The second parameter can be of type `Object|String|Array<String>` to specify which fields we would like to project. In this case, we used a `String`.

## Deleting data

Just like in the standard MongoDB Node.js driver, we have the `deleteOne()` and `deleteMany()` methods.

``` js
const blog = await Blog.deleteOne({ author: "Jesse Hall" })
console.log(blog)

const blog = await Blog.deleteMany({ author: "Jesse Hall" })
console.log(blog)
```

## Validation

Notice that the documents we have inserted so far have not contained an `author`, dates, or `comments`. So far, we have defined what the structure of our document should look like, but we have not defined which fields are actually required. At this point any field can be omitted.

Let’s set some required fields in our `Blog.js` schema.

``` js
const blogSchema = new Schema({
  title:  {
    type: String,
    required: true,
  },
  slug:  {
    type: String,
    required: true,
    lowercase: true,
  },
  published: {
    type: Boolean,
    default: false,
  },
  author: {
    type: String,
    required: true,
  },
  content: String,
  tags: [String],
  createdAt: {
    type: Date,
    default: () => Date.now(),
    immutable: true,
  },
  updatedAt: Date,
  comments: [{
    user: String,
    content: String,
    votes: Number
  }]
});
```

When including validation on a field, we pass an object as its value.

> `value: String` is the same as `value: {type: String}`.

There are several validation methods that can be used.

We can set `required` to true on any fields we would like to be required.

For the `slug`, we want the string to always be in lowercase. For this, we can set `lowercase` to true. This will take the slug input and convert it to lowercase before saving the document to the database.

For our `created` date, we can set the default buy using an arrow function. We also want this date to be impossible to change later. We can do that by setting `immutable` to true.

> Validators only run on the create or save methods.

## Other useful methods

Mongoose uses many standard MongoDB methods plus introduces many extra helper methods that are abstracted from regular MongoDB methods. Next, we’ll go over just a few of them.

### `exists()`

The `exists()` method returns either `null` or the ObjectId of a document that matches the provided query.

``` js
const blog = await Blog.exists({ author: "Jesse Hall" })
console.log(blog)
```

### `where()`

Mongoose also has its own style of querying data. The `where()` method allows us to chain and build queries.

``` js
// Instead of using a standard find method
const blogFind = await Blog.findOne({ author: "Jesse Hall" });

// Use the equivalent where() method
const blogWhere = await Blog.where("author").equals("Jesse Hall");
console.log(blogWhere)
```

Either of these methods work. Use whichever seems more natural to you.

You can also chain multiple `where()` methods to include even the most complicated query.

### `select()`

To include projection when using the `where()` method, chain the `select()` method after your query.

``` js
const blog = await Blog.where("author").equals("Jesse Hall").select("title author")
console.log(blog)
```

## Multiple schemas

It's important to understand your options when modeling data.

If you’re coming from a relational database background, you’ll be used to having separate tables for all of your related data.

Generally, in MongoDB, data that is accessed together should be stored together.

You should plan this out ahead of time if possible. Nest data within the same schema when it makes sense.

If you have the need for separate schemas, Mongoose makes it a breeze.

Let’s create another schema so that we can see how multiple schemas can be used together.

We’ll create a new file, `User.js`, in the model folder.

``` js
import mongoose from 'mongoose';
const {Schema, model} = mongoose;

const userSchema = new Schema({
  name: {
    type: String,
    required: true,
  },
  email: {
    type: String,
    minLength: 10,
    required: true,
    lowercase: true
  },
});

const User = model('User', userSchema);
export default User;
```

For the `email`, we are using a new property, `minLength`, to require a minimum character length for this string.

Now we’ll reference this new user model in our blog schema for the `author` and `comments.user`.

``` js
import mongoose from 'mongoose';
const { Schema, SchemaTypes, model } = mongoose;

const blogSchema = new Schema({
  ...,
  author: {
    type: SchemaTypes.ObjectId,
    ref: 'User',
    required: true,
  },
  ...,
  comments: [{
    user: {
      type: SchemaTypes.ObjectId,
      ref: 'User',
      required: true,
    },
    content: String,
    votes: Number
  }];
});
...
```

Here, we set the `author` and `comments.user` to `SchemaTypes.ObjectId` and added a `ref`, or reference, to the user model.

This will allow us to “join” our data a bit later.

And don’t forget to destructure `SchemaTypes` from `mongoose` at the top of the file.

Lastly, let’s update the `index.js` file. We’ll need to import our new user model, create a new user, and create a new article with the new user’s `_id`.

``` js
...
import User from './model/User.js';

...

const user = await User.create({
  name: 'Jesse Hall',
  email: 'jesse@email.com',
});

const article = await Blog.create({
  title: 'Awesome Post!',
  slug: 'Awesome-Post',
  author: user._id,
  content: 'This is the best post ever',
  tags: ['featured', 'announcement'],
});

console.log(article);
```

Notice now that there is a `users` collection along with the `blogs` collection in the MongoDB database.

You’ll now see only the user `_id` in the author field. So, how do we get all of the info for the author along with the article?

We can use the `populate()` Mongoose method.

``` js
const article = await Blog.findOne({ title: "Awesome Post!" }).populate("author");
console.log(article);
```

Now the data for the `author` is populated, or “joined,” into the `article` data. Mongoose actually uses the MongoDB `$lookup` method behind the scenes.

## Middleware

In Mongoose, middleware are functions that run before and/or during the execution of asynchronous functions at the schema level.

Here’s an example. Let’s update the `updated` date every time an article is saved or updated. We’ll add this to our `Blog.js` model.

``` js
blogSchema.pre('save', function(next) {
  this.updated = Date.now(); // update the date every time a blog post is saved
  next();
});
```

Then in the `index.js` file, we’ll find an article, update the title, and then save it.

``` js
const article = await Blog.findById("6247589060c9b6abfa1ef530").exec();
article.title = "Updated Title";
await article.save();
console.log(article);
```

Notice that we now have an `updated` date!

Besides `pre()`, there is also a `post()` mongoose middleware function.

## Next steps

I think our example here could use another schema for the `comments`. Try creating that schema and testing it by adding a few users and comments.

There are many other great Mongoose helper methods that are not covered here. Be sure to check out the [official documentation](https://mongoosejs.com/docs/) for references and more examples.

## Conclusion

I think it’s great that developers have many options for connecting and manipulating data in MongoDB. Whether you prefer Mongoose or the standard MongoDB drivers, in the end, it’s all about the data and what’s best for your application and use case.

I can see why Mongoose appeals to many developers and I think I’ll use it more in the future.

In this article, we’ll learn how Mongoose, a library for MongoDB, can help you to structure and access your data with ease. Many who learn MongoDB get introduced to it through the very popular library, Mongoose. Mongoose is described as “elegant MongoDB object modeling for Node.js."

Getting Started with MongoDB & Mongoose

Getting a MongoDB Atlas database created and linked to your Vercel project has never been easier. In this tutorial, we’ll get everything set up—including a starter Next.js application—in just minutes.


## Prerequisites

For this tutorial, you’ll need:

* MongoDB Atlas ([sign up for free](https://www.mongodb.com/cloud/atlas/register2)).
* Vercel account ([sign up for free](https://vercel.com/signup)).
* Node.js 14+.

> This tutorial will work with any frontend framework if Next.js isn’t your preference.

## What is Vercel?

Vercel is a cloud platform for hosting websites and web applications. Deployment is seamless and scaling is automatic.

Many web frameworks will work on Vercel, but the one most notable is Vercel’s own Next.js. Next.js is a React-based framework and has many cool features, like built-in routing, image optimization, and serverless and [Edge Functions](https://vercel.com/docs/concepts/functions/edge-functions). 

## Create a starter project

For our example, we are going to use Next.js. However, you can use any web framework you would like. 

We’ll use the `with-mongodb` example app to get us started. This will give us a Next.js app with MongoDB Atlas integration already set up for us.

```bash
npx create-next-app --example with-mongodb vercel-demo -y
```

We are using the standard `npx create-next-app` command along with the `--example with-mongodb` parameter which will give us our fully integrated MongoDB application. Then, `vercel-demo` is the name of our application. You can name yours whatever you would like.

After that completes, navigate to your application directory:

```bash
cd vercel-demo
````

At this point, we need to configure our MongoDB Atlas database connection. Instead of manually setting up our database and connection within the MongoDB Atlas dashboard, we are going to do it all through Vercel!

Before we move over to Vercel, let’s publish this project to GitHub. Using the built-in Version Control within VS Code, if you are logged into your GitHub account, it’s as easy as pressing one button in the Source Control tab.

![Image of the "Publish Branch" button in VS Code](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/1_f898bc0f69.png)

I’m going to press *Publish Branch* and name my new repo `vercel-integration`.


## Create a Vercel project and integrate MongoDB

From your [Vercel dashboard](https://vercel.com/dashboard), create a new project and then choose to import a GitHub repository by clicking Continue with GitHub.

![Illustration with choices of import methods including GitHub](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/2_09d7bf2a10.png)

Choose the repo that you just created, and then click Deploy. This deployment will actually fail because we have not set up our MongoDB integration yet.

Go back to the main Vercel dashboard and select the Integrations tab. From here, you can browse the marketplace and select the [MongoDB Atlas integration](https://vercel.com/integrations/mongodbatlas). 

![Page showing the MongoDB Atlas Vercel Integration](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/3_728f3ee0de.png)

Click Add Integration, select your account from the dropdown, and then click continue.

Next, you can either add this integration to all projects or select a specific project. I’m going to select the project I just created, and then click Add Integration.

![Illustration showing Vercel account selection](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/4_56b1dffe9f.png)

If you do not already have a MongoDB Atlas account, you can sign up for one at this step. If you already have one, click “Log in now.”

![Sign up for MongoDB or Sign in](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/5_06241925d3.png)

The next step will allow you to select which Atlas Organization you would like to connect to Vercel. Either create a new one or select an existing one. Click Continue, and then I Acknowledge.

![Select your existing organization or create a new one](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/6_1500f3a3f8.png)

The final step allows you to select an Atlas Project and Cluster to connect to. Again, you can either create new ones or select existing ones.

![Vercel integration details](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/7_615b5c0656.png)

After you have completed those steps, you should end up back in Vercel and see that the MongoDB integration has been completed.

If you go to your project in Vercel, then select the Environment Variables section of the Settings page, you’ll see that there is a new variable called `MONGODB_URI`. This can now be used in our Next.js application. 

For more information on how to connect MongoDB Atlas with Vercel, see our [documentation](https://www.mongodb.com/docs/atlas/reference/partner-integrations/vercel/).

## Sync Vercel settings to local environment

All we have to do now is sync our environment variables to our local environment.

You can either manually copy/paste your `MONGODB_URI` into your local `.env` file, or you can use the Vercel CLI to automate that.

Let’s add the Vercel CLI to our project by running the following command:

```bash
npm i vercel
```

In order to link our local project with our Vercel project, run the following command:

```bash
vercel
```

Choose a login method and use the browser pop-up to authenticate.

Answer *yes* to set up and deploy.

Select the appropriate scope for your project.

When asked to link to an existing project, type *Y* and press *enter*.

Now, type the name of your Vercel project. This will link the local project and run another build. Notice that this build works. That is because the environment variable with our MongoDB connection string is already in production.

![Successful connection to MongoDB](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/9_a88fb5d837.png)

But if you run the project locally, you will get an error message.

```bash
npm run dev
```

![Server error when running the project locally](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/8_5394dd728c.png)

We need to pull the environment variables into our project. To do that, run the following:

```bash
vercel env pull
```

Now, every time you update your repo, Vercel will automatically redeploy your changes to production!

## Conclusion

In this tutorial, we set up a Vercel project, linked it to a MongoDB Atlas project and cluster, and linked our local environment to these. 

These same steps will work with any framework and will provide you with the local and production environment variables you need to connect to your MongoDB Atlas database.

For an in-depth tutorial on Next.js and MongoDB, check out [How to Integrate MongoDB Into Your Next.js App](https://www.mongodb.com/developer/how-to/nextjs-with-mongodb/).

If you have any questions or feedback, check out our [MongoDB Community forums](https://developer.mongodb.com/community/forums/) and let us know what you think.

Getting a MongoDB Atlas database created and linked to your Vercel project has never been easier. In this tutorial, we’ll get everything set up—including a starter Next.js application—in just minutes.