MongoDB is a document-oriented NoSQL database.

Instead of storing information in traditional relational tables, MongoDB stores documents inside collections.

A MongoDB document resembles a JSON object, but MongoDB internally stores documents using BSON.

For example, a users collection might contain:

{
  "_id": "ObjectId(...) ",
  "name": "John Doe",
  "email": "john@example.com",
  "age": 25,
  "isActive": true
}

Mongoose is an Object Data Modeling library that provides a structured way to interact with MongoDB from Node.js.

Mongoose provides:

• Schema definitions.
• Models.
• Validation.
• Middleware hooks.
• Query helpers.
• Population.
• Transactions support through MongoDB sessions.

We will use Mongoose to define and manage our user collection.

MongoDB Atlas provides a managed MongoDB database service.

Follow these steps:

1. Open MongoDB Atlas.
2. Create an account or sign in.
3. Create a project.
4. Create a database deployment.
5. Select an available free deployment option if suitable for your learning project.
6. Choose a cloud provider and region.
7. Create the deployment.
8. Wait for the database deployment to become available.

The exact free-tier availability and deployment options may vary by region and current Atlas plans.

After creating the deployment, configure database access and network access before connecting from Node.js.

MongoDB Atlas requires a database user to authenticate database connections.

Follow these steps:

1. Open the Database Access section.
2. Add a new database user.
3. Choose password-based authentication.
4. Generate a strong password.
5. Assign the minimum database privileges required for the application.
6. Save the database user.

Do not confuse your MongoDB Atlas website login with the database user credentials.

The application uses the database user credentials to authenticate its MongoDB connection.

For production applications, follow the principle of least privilege and avoid using broad administrative roles.

MongoDB Atlas also restricts which IP addresses can access your database deployment.

Open Network Access in Atlas.

Add the public IP address of your development machine.

For local development, use the current public IP address rather than allowing every IP address.

Allowing 0.0.0.0/0 makes the database reachable from all IPv4 addresses, subject to authentication and other controls. It is not a recommended production configuration.

For production, use private networking or carefully controlled network access wherever possible.

Open your Atlas database deployment and select Connect.

Choose the Drivers connection option.

Select Node.js and copy the connection string.

It generally looks like this:

mongodb+srv://<username>:<password>@cluster.example.mongodb.net/<database>

Replace the placeholders with your database username, password, and database name.

Special characters in database credentials must be percent-encoded when embedded in a MongoDB URI.

Add the resulting connection string to the MONGODB_URI environment variable.

Never expose this connection string to the browser.

MONGODB_URI=mongodb+srv://dbuser:encoded-password@cluster.example.mongodb.net/rest_api_db

Create src/config/database.js.

Import Mongoose and define a reusable connection function.

The application should wait for the database connection before accepting requests that depend on MongoDB.

Mongoose provides mongoose.connect() for establishing the connection.

import mongoose from 'mongoose';

export async function connectDatabase() {
  const connectionString = process.env.MONGODB_URI;

  if (!connectionString) {
    throw new Error('MONGODB_URI is not configured');
  }

  await mongoose.connect(connectionString, {
    serverSelectionTimeoutMS: 10000
  });

  console.log(`MongoDB connected: ${mongoose.connection.name}`);
}

export async function disconnectDatabase() {
  await mongoose.disconnect();
}

Before creating models, verify that the backend can connect to MongoDB.

You can temporarily create a small test script or integrate the connection function into your server startup.

When the connection succeeds, you should see a message similar to:

MongoDB connected: rest_api_db

If the connection fails, check:

1. Whether the MongoDB deployment is running.
2. Whether the connection string is correct.
3. Whether the database username is correct.
4. Whether the password is correctly encoded.
5. Whether your IP address is allowed.
6. Whether your network permits outbound database connections.

Do not proceed with database-dependent endpoints until the connection works.

Create src/models/user.model.js.

A Mongoose schema defines the structure and behavior of documents stored in a collection.

For our application, a user will contain:

• name
• email
• password
• age
• role
• isActive
• createdAt
• updatedAt

The email should be unique, and the password should be excluded from ordinary query results by default.

Mongoose timestamps automatically manage createdAt and updatedAt.

import mongoose from 'mongoose';

const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
    trim: true,
    minlength: 2,
    maxlength: 80
  },
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true,
    trim: true
  },
  password: {
    type: String,
    required: true,
    select: false
  },
  age: {
    type: Number,
    min: 18,
    max: 120
  },
  role: {
    type: String,
    enum: ['user', 'admin'],
    default: 'user'
  },
  isActive: {
    type: Boolean,
    default: true
  }
}, {
  timestamps: true
});

export const User = mongoose.model('User', userSchema);

A Mongoose model is created from a schema and provides an interface for interacting with a MongoDB collection.

For example:

const user = await User.findOne({ email: 'john@example.com' });

Here:

• User is the Mongoose model.
• findOne() is a model query method.
• The result is a Mongoose document or null.

A Mongoose document represents an individual database record and provides methods such as save() and toObject().

Models are also used for creating, updating, and deleting documents.

const user = new User({
  name: 'John Doe',
  email: 'john@example.com',
  password: 'hashed-password'
});

await user.save();

console.log(user._id);