Node js mongodb crud operations with Example
Introduction:
Node.js is a JavaScript runtime server-side programming language, and Node.js is server-side programming more popular with MEAN stack developers Node.js CRUD Operations with MongoDB due to its efficiency and scalability.
Essentially, Nodejs is joined with MongoDB, a NoSQL data set, and it turns into a powerful stage for building web applications.
In this article, we will investigate how to perform Muck (Make, Read, Update, Erase) tasks utilizing Node.js and MongoDB, furnishing you with a reasonable Node js crud operation with mongodb guide to begin with.
Angular mongodb crud -
Step 1: Install Required Software -
Before we begin the crud operations, we want to set up our development environment is crucial. Follow those steps:
1. Install Node.js: Visit the official Node.js website (www.nodejs.org) and go to the download section, Search for the appropriate version for your operating system. Run the installer and ensure that node.Js and npm (node package deal manager) are successfully established.
2. Install MongoDB: Head over to the MongoDB website (www.mongodb.com) and download the community edition. Install the MongoDB and make sure it successfully running.
For local development, you can use the default settings.
3. Create a New Node.js Project: first you open your terminal vs code and navigate to the directory in which you need to create your undertaking project..
Create a new Node.js project:
4. Install Dependencies: In order to working with MongoDB and Node.js, We must be need to install the necessary packages. Run the following command to install the required dependencies:
Step 2: Creating the Express Server
mkdir node-Mongo-crud
cd node-Mongo-crud
npm init -y
4. Install Dependencies: In order to working with MongoDB and Node.js, We must be need to install the necessary packages. Run the following command to install the required dependencies:
npm install express mongoose
Step 2: Creating the Express Server
Now that Node.js CRUD Operations with MongoDB have our project set up, let's create an Express server to handle our API requests. Expressjs is a nodejs model used as a web framework for Node.js that simplified the all technique of building web applications.
1. We can Create the `index.js` file in the root directory of your Nodejs project.
2. Open the`index.Js` file record in your chosen code editor and import the important packages:
Javascript File -
const express = require('express');
const mongoose = require('mongoose');
3. We can first to Installation the specific app and connect with MongoDB:
Javascript File -
const app = express();
mongoose.connect('mongodb://localhost:27017/mydatabase', {
useNewUrlParser: true,
useUnifiedTopology: true,
});
const db = mongoose.connection;
db.on('error', console.error.bind(console, 'MongoDB connection error:'));
4. We can Define a port variety for the node server :
Javascript File -
const port = 3000;
5. Then we can Start the server:
Javascript File -
app.listen(port, () => {
console.log(`Server is running on port ${port}`);
});
Step 3: Performing CRUD Operations
- node js crud operation with mongodb example
Now that our server is up and running, let's we are able to put implement the CRUD operations the use of mongoose, the object facts modeling (odm) library used for mongodb.
1. Create a brand new folder known as `models` in the root directory of your project.
2. In the `models` folder, create a record named `product.js` and define a schema for your product model:
Javascript File -
const mongoose = require('mongoose');
const productSchema = new mongoose.Schema({
name: { type: String, required: true },
price: { type: Number, required: true },
description: { type: String, required: true },
});
module.exports = mongoose.model('Product', productSchema);
3. In `index.js`, we must be import the `Product` model: we can write follwing code as mentions,
Javascript File -
const Product = require('./models/product');
4. than, we must Implement the CRUD routes using Express js : Use the folloing code for express code.
- We can Create a new product:
app.post('/products', (req, res) => {
const { name, price, description } = req.body;
const newProduct = new Product({ name, price, description });
newProduct.save((err) => {
if (err) {
console.error(err);
res.status(500).send('Error creating product');
} else {
res.status(201).send('Product created successfully');
}
});
});
- Then we Retrieve all products :
Javascript File -
app.get('/products', (req, res) => {
Product.find((err, products) => {
if (err) {
console.error(err);
res.status(500).send('Error retrieving products');
} else {
res.status(200).json(products);
}
});
});
- Retrieve a single product by using ID:
app.get('/products/:id', (req, res) => {
const { id } = req.params;
Product.findById(id, (err, product) => {
if (err) {
console.error(err);
res.status(500).send('Error retrieving product');
} else if (!product) {
res.status(404).send('Product not found');
} else {
res.status(200).json(product);
}
});
});
- Update the your product :
Javascript File -
app.put('/products/:id', (req, res) => {
const { id } = req.params;
const { name, price, description } = req.body;
Product.findByIdAndUpdate(
id,
{ name, price, description },
{ new: true },
(err, updatedProduct) => {
if (err) {
console.error(err);
res.status(500).send('Error updating product');
} else if (!updatedProduct) {
res.status(404).send('Product not found');
} else {
res.status(200).json(updatedProduct);
}
}
);
});
- Delete a product :
app.delete('/products/:id', (req, res) => {
const { id } = req.params;
Product.findByIdAndRemove(id, (err, deletedProduct) => {
if (err) {
console.error(err);
res.status(500).send('Error deleting product');
} else if (!deletedProduct) {
res.status(404).send('Product not found');
} else {
res.status(200).send('Product deleted successfully');
}
});
});
Conclusion:
In this article, we can check out performing muck (make, read, update, erase) responsibilities using mongodb crud nodejs giving you a useful sensible practical model version.
We started Node.js CRUD Operations with MongoDB by means of putting in the development surroundings, developing an specific Express server,, and imposing the essential routes for creating, reading, updating, and deleting products.
The MEAN stack all developers to customize and develop your project to your crud-specific requirements.
Read more -
FAQ
1) How do you make CRUD with Express?
Ans -
Set up the explicit server and configure middleware (e.G., frame-parser for parsing incoming statistics).
Outline routes for handling distinctive http methods (get, put up, placed, delete).
Create handlers for each route to perform the crud operations using a database (e.G., mongodb, mysql).
For create (submit) and update (positioned) operations, extract facts from the request body and save/update it within the database.
For examine (get) operations, fetch statistics from the database and return it as a response.
For delete (delete) operations, put off the required facts from the database.
2) How to create CRUD API using node js?
Ans - Node.js: Install Node.js on your system.
Create project: create a brand new undertaking folder and run "npm init" to create a bundle.Json report.
Install dependencies: installation required programs like express (npm install explicit) for dealing with http requests.
Create routes: installation routes for each crud operation (create, read, replace, delete) the usage of express.
Create controllers: put in force controller features to handle the enterprise good judgment for each crud operation.
Connect to a database: Choose a database (e.g., MongoDB) and use a library like Mongoose to connect and interact with it.
Test the API: use tools like postman to test your api endpoints.
Deploy the API: Host your Node.js app on a server or cloud platform for public access.
Secure the API: observe authentication and authorization mechanisms to guard touchy records and restrict get right of entry to to precise users. more
3) What is CRUD and REST API?
Ans - rud represents make, examine, update, and erase — a gaggle of vital tasks for overseeing information in a information set. Relaxation programming interface, which represents true country flow, is a building style for planning organized applications.
It utilizes widespread http strategies (get, submit, positioned, erase) to carry out muck technique on belongings, making it broadly utilized in internet administrations. more
