CRUD stands for Create, Read, Update, and Delete. These four operations form the backbone of any web application that interacts with a database. In this tutorial, you will learn how to implement CRUD operations in your RESTful API using Node.js and Express. You will also see how to connect to a database, specifically MongoDB, to manage your data effectively.

Overview of CRUD Operations

Create

The Create operation allows users to add new data to the database. In a REST API, this is typically handled by a POST request.

Read

The Read operation retrieves data from the database. This can involve fetching a single record or multiple records and is generally managed with GET requests.

Update

The Update operation modifies existing data in the database. This is accomplished through PUT or PATCH requests, depending on whether you want to replace an entire record or just update specific fields.

Delete

The Delete operation removes data from the database. This is usually done with a DELETE request.

Understanding these operations will empower you to design a fully functional API that can handle various data interactions.

Setting Up the Project with MongoDB

Step 1: Install Mongoose

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It simplifies working with MongoDB by providing a schema-based solution. Install Mongoose in your project directory:

npm install mongoose

Step 2: Connect to MongoDB

In your server.js, set up a connection to your MongoDB database. Add the following code after your Express app initialization:

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mydatabase', {
    useNewUrlParser: true,
    useUnifiedTopology: true
})
.then(() => console.log('MongoDB connected'))
.catch(err => console.error('MongoDB connection error:', err));

Replace 'mydatabase' with the name you want for your database. Make sure your MongoDB server is running.

Step 3: Define a Schema

Create a model to represent the data structure in your database. Create a new folder named models in your project directory:

mkdir models

Inside the models folder, create a file named Item.js:

touch models/Item.js

In Item.js, define a schema for your data:

const mongoose = require('mongoose');

const itemSchema = new mongoose.Schema({
    name: { type: String, required: true },
    description: { type: String },
    price: { type: Number, required: true }
});

module.exports = mongoose.model('Item', itemSchema);

This schema represents an item with a name, description, and price. The required property ensures that these fields must be present.

Implementing CRUD Operations

Create Operation

Step 1: Define the POST Route

Add a route for creating a new item in your server.js:

const Item = require('./models/Item');

app.post('/items', (req, res) => {
    const newItem = new Item(req.body);

    newItem.save()
    .then(item => res.status(201).json(item))
    .catch(err => res.status(400).json({ error: err.message }));
});

This route listens for POST requests at /items. It creates a new item using the data from the request body and saves it to the database. If successful, it responds with the newly created item.

Step 2: Testing the Create Operation

To test this operation, use Postman:

1. Set the request type to POST.
2. Enter http://localhost:3000/items as the URL.
3. In the Body tab, select "raw" and choose "JSON" from the dropdown.
4. Enter the following sample data:

{
    "name": "Sample Item",
    "description": "This is a sample item.",
    "price": 29.99
}

5. Click "Send." You should receive a response containing the created item.

Read Operation

Step 1: Define the GET Routes

Add routes to read all items and a specific item:

// Get all items
app.get('/items', (req, res) => {
    Item.find()
    .then(items => res.json(items))
    .catch(err => res.status(500).json({ error: err.message }));
});

// Get a specific item by ID
app.get('/items/:id', (req, res) => {
    Item.findById(req.params.id)
    .then(item => {
        if (!item) {
            return res.status(404).json({ error: 'Item not found' });
        }
        res.json(item);
    })
    .catch(err => res.status(500).json({ error: err.message }));
});

These routes allow you to retrieve all items and a specific item by its ID.

Step 2: Testing the Read Operation

To test retrieving all items:

1. Set the request type to GET.
2. Enter http://localhost:3000/items as the URL.
3. Click "Send." You should receive an array of items.

To test retrieving a specific item:

1. Use the ID of an item you created earlier.
2. Enter http://localhost:3000/items/{id} as the URL (replace {id} with the actual item ID).
3. Click "Send." You should see the details of that item.

Update Operation

Step 1: Define the PUT Route

Add a route for updating an item:

app.put('/items/:id', (req, res) => {
    Item.findByIdAndUpdate(req.params.id, req.body, { new: true })
    .then(item => {
        if (!item) {
            return res.status(404).json({ error: 'Item not found' });
        }
        res.json(item);
    })
    .catch(err => res.status(400).json({ error: err.message }));
});

This route listens for PUT requests to /items/:id, updating the item specified by the ID in the URL.

Step 2: Testing the Update Operation

To test updating an item:

1. Set the request type to PUT.
2. Enter http://localhost:3000/items/{id} as the URL (replace {id} with the actual item ID).
3. In the Body tab, enter the updated data, for example:

{
    "name": "Updated Item",
    "description": "This item has been updated.",
    "price": 39.99
}

4. Click "Send." You should receive a response with the updated item.

Delete Operation

Step 1: Define the DELETE Route

Add a route for deleting an item:

app.delete('/items/:id', (req, res) => {
    Item.findByIdAndDelete(req.params.id)
    .then(item => {
        if (!item) {
            return res.status(404).json({ error: 'Item not found' });
        }
        res.json({ message: 'Item deleted successfully' });
    })
    .catch(err => res.status(500).json({ error: err.message }));
});

This route listens for DELETE requests at /items/:id, allowing the deletion of a specific item.

Step 2: Testing the Delete Operation

To test deleting an item:

1. Set the request type to DELETE.
2. Enter http://localhost:3000/items/{id} as the URL (replace {id} with the actual item ID).
3. Click "Send." You should receive a confirmation message indicating the item was deleted.

Conclusion

You have now implemented the full set of CRUD operations in your RESTful API. This includes creating, reading, updating, and deleting items in your MongoDB database. These operations form the core functionality of many web applications, allowing users to interact with data effectively. In the next tutorial, you will explore error handling and validation to ensure your API is robust and user-friendly.