PO MongoDB Integration | Express JS Course

Back to Express JS Course

MongoDB and Express JS are two technologies commonly used together in web development, particularly in the context of building server-side applications and APIs.

MongoDB is a NoSQL database that stores data in a flexible, JSON-like format called BSON (Binary JSON). It's known for its scalability, flexibility, and performance, making it a popular choice for applications that require handling large volumes of data or where the data structure evolves over time.

Key features of MongoDB include:

Document-Oriented: Data is stored in flexible, JSON-like documents.
Scalable: Supports horizontal scaling through sharding.
Flexible Schema: Fields can vary from document to document.
High Performance: Uses internal memory for storing working sets of data and indexes.

Lets refactor our code to include mongoose for connecting mongodb.

db.mjs

import mongoose from 'mongoose';

mongoose.connect('mongodb+srv://praveenoruganti:testpassword@praveenoruganti.neyvmhh.mongodb.net/sampledb?retryWrites=true&w=majority&appName=praveenoruganti', {
    useNewUrlParser: true,
    useUnifiedTopology: true,
});

const db = mongoose.connection;

db.on('error', console.error.bind(console, 'MongoDB connection error:'));
db.once('open', () => {
    console.log('Connected to MongoDB');
});

export default db;

Passport.mjs

import passport from 'passport';
import LocalStrategy from 'passport-local';
import bcrypt from 'bcryptjs';
import User from '../models/User.mjs';

passport.use(new LocalStrategy(
    function(username, password, done) {
        User.findOne({ username: username }, function(err, user) {
            if (err) { return done(err); }
            if (!user) {
                return done(null, false, { message: 'Incorrect username.' });
            }
            bcrypt.compare(password, user.password, function(err, res) {
                if (res) {
                    return done(null, user);
                } else {
                    return done(null, false, { message: 'Incorrect password.' });
                }
            });
        });
    }
));

passport.serializeUser(function(user, done) {
    done(null, user.id);
});

passport.deserializeUser(function(id, done) {
    User.findById(id, function(err, user) {
        done(err, user);
    });
});

User.mjs

import mongoose from 'mongoose';

const userSchema = new mongoose.Schema({
    name: String,
    username: String,
    password: String,
    designation: String,
    city: String,
}, { collection: 'users' }); // Specify the collection name 'users'

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

export default User;

usersRouter.mjs

import express from 'express';
import passport from 'passport';
import bcrypt from 'bcryptjs';
import User from '../models/User.mjs'; // Ensure correct path

const router = express.Router();

// Login route using Passport's authenticate middleware
router.post('/login', passport.authenticate('local'), (req, res) => {
    // If authentication succeeds, this function will be called
    res.send('Login successful');
});

// Route to logout
router.get('/logout', (req, res) => {
    req.logout(); // Terminate the login session
    res.send('Logged out successfully');
});

// Route to get all users
router.get('/', (req, res) => {
    User.find({}, (err, users) => {
        if (err) {
            return res.status(500).send('Internal Server Error');
        }

        const { name, designation, city } = req.query;

        let filteredUsers = users;

        if (name) {
            filteredUsers = filteredUsers.filter(user => user.name.toLowerCase().includes(name.toLowerCase()));
        }

        if (designation) {
            filteredUsers = filteredUsers.filter(user => user.designation.toLowerCase().includes(designation.toLowerCase()));
        }

        if (city) {
            filteredUsers = filteredUsers.filter(user => user.city.toLowerCase().includes(city.toLowerCase()));
        }

        res.send({ users: filteredUsers });
    });
});

// Route to get a single user by ID
router.get('/:id', (req, res) => {
    User.findById(req.params.id, (err, user) => {
        if (err) {
            return res.status(500).send('Internal Server Error');
        }
        if (!user) {
            return res.status(404).send('User not found');
        }
        res.send(user);
    });
});

// Route to add a new user
router.post('/', (req, res) => {
    const newUser = new User(req.body);

    // Hash password before saving to database
    bcrypt.genSalt(10, (err, salt) => {
        bcrypt.hash(newUser.password, salt, (err, hash) => {
            if (err) throw err;
            newUser.password = hash;
            newUser.save((err, savedUser) => {
                if (err) {
                    return res.status(400).send('Bad Request. Missing required fields');
                }
                res.status(201).send(savedUser);
            });
        });
    });
});

// Route to update an existing user
router.put('/:id', (req, res) => {
    User.findByIdAndUpdate(req.params.id, req.body, { new: true }, (err, user) => {
        if (err) {
            return res.status(500).send('Internal Server Error');
        }
        if (!user) {
            return res.status(404).send('User not found');
        }
        res.send(user);
    });
});

// PATCH endpoint to update user by ID
router.patch('/:id', (req, res) => {
    User.findByIdAndUpdate(req.params.id, req.body, { new: true }, (err, user) => {
        if (err) {
            return res.status(500).send('Internal Server Error');
        }
        if (!user) {
            return res.status(404).send('User not found');
        }
        res.send(user);
    });
});

// Route to delete a user
router.delete('/:id', (req, res) => {
    User.findByIdAndRemove(req.params.id, (err, user) => {
        if (err) {
            return res.status(500).send('Internal Server Error');
        }
        if (!user) {
            return res.status(404).send('User not found');
        }
        res.status(204).send(); // No Content
    });
});

export default router;

index.mjs

import express from 'express';
import session from 'express-session';
import passport from 'passport';
import db from './config/db.mjs'; // Import MongoDB connection
import usersRouter from './routes/usersRouter.mjs'; // Import users router

const app = express();

app.use(express.json());
app.use(express.urlencoded({ extended: false }));

// Initialize and use session middleware
app.use(session({
    secret: 'praveenoruganti',
    resave: false,
    saveUninitialized: false,
    cookie: {
        maxAge: 900000, // 15 minutes
        httpOnly: true,
    }
}));

// Initialize and use Passport middleware
app.use(passport.initialize());
app.use(passport.session());

// Mount the usersRouter at /users
app.use('/users', usersRouter);

const PORT = process.env.PORT || 5000;

// Start the server after establishing MongoDB connection
db.once('open', () => {
    console.log('Connected to MongoDB');
    app.listen(PORT, () => {
        console.log(`Server is running on port ${PORT}`);
    });
});

// Handle MongoDB connection errors
db.on('error', console.error.bind(console, 'MongoDB connection error:'));