DEV Community: suraj kushwaha

How to Perform Crud Operation In Express with Mongodb

suraj kushwaha — Fri, 07 Nov 2025 12:36:01 +0000

How to Perform CRUD Operations in Express.js with Mongoose: A Step-by-Step Guide

CRUD—Create, Read, Update, and Delete—are the four fundamental operations that form the backbone of almost every dynamic web application. Mastering them is a critical skill for any backend developer. When building with Node.js, the combination of the Express.js framework for routing and the Mongoose ODM for MongoDB interaction provides a powerful and developer-friendly stack to build robust APIs.

This technical guide will walk you through building a complete RESTful API that performs all four CRUD operations. We will create a simple application to manage blog posts, demonstrating each step with clear code examples and explanations.

Prerequisites

Before we begin, ensure you have the following installed and set up:

Node.js and npm: You can download them from the official Node.js website.
MongoDB: You need a running MongoDB instance, either locally on your machine or through a cloud service like MongoDB Atlas.
A code editor: Such as Visual Studio Code.
Basic knowledge: A foundational understanding of JavaScript, Node.js, and how APIs work is recommended.

Step 1: Setting Up the Project Environment

First, let's create our project directory and initialize a new Node.js application.

Initialize the Node.js Project

Open your terminal, create a new folder for your project, and navigate into it.

mkdir express-crud-api
cd express-crud-api

Now, initialize a package.json file using npm.

npm init -y

Install Dependencies

We need a few key packages to build our application:

express: The web framework for Node.js that will handle our routing and server logic.
mongoose: An Object Data Modeling (ODM) library for MongoDB and Node.js. It simplifies interactions with the database.
dotenv: A module to load environment variables from a .env file into process.env.
nodemon (dev dependency): A tool that automatically restarts the server during development whenever file changes are detected.

Install the required dependencies:

npm install express mongoose dotenv

Install nodemon as a development dependency:

npm install --save-dev nodemon

Next, open your package.json and add a start script to run the server with nodemon.

"scripts": {
  "start": "nodemon server.js"
}

Step 2: Creating the Express Server and Connecting to MongoDB

Now it's time to write some code. Create a file named server.js in your project's root directory. This file will be the entry point for our application.

Basic Server Setup

Add the following code to server.js to create a minimal Express server.

// server.js
const express = require('express');

const app = express();
const PORT = process.env.PORT || 3000;

// Middleware to parse JSON bodies
app.use(express.json());

app.get('/', (req, res) => {
  res.send('CRUD API is running!');
});

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

Database Connection

To keep our database connection string secure, create a .env file in the root directory and add your MongoDB URI.

# .env
MONGO_URI=mongodb://localhost:27017/blogDB

Now, let's update server.js to connect to our MongoDB database using Mongoose. We will also require the dotenv package to load the environment variable.

// server.js
require('dotenv').config(); // Load environment variables
const express = require('express');
const mongoose = require('mongoose');

const app = express();
const PORT = process.env.PORT || 3000;

// Middleware
app.use(express.json());

// Connect to MongoDB
mongoose.connect(process.env.MONGO_URI)
  .then(() => {
    console.log('Successfully connected to MongoDB');
    app.listen(PORT, () => {
      console.log(`Server is running on port ${PORT}`);
    });
  })
  .catch((err) => {
    console.error('Database connection error:', err);
  });

app.get('/', (req, res) => {
  res.send('CRUD API is running!');
});

Now, if you run npm start in your terminal, your server should start and connect to the database.

Step 3: Defining the Mongoose Schema and Model

Mongoose works with Schemas and Models. A Schema defines the structure of the documents within a collection, and a Model provides an interface to the database for creating, querying, updating, and deleting records.

Create a new folder named models and inside it, a file named post.model.js.

// models/post.model.js
const mongoose = require('mongoose');

const postSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true,
    trim: true
  },
  content: {
    type: String,
    required: true
  },
  author: {
    type: String,
    required: false,
    default: 'Anonymous'
  }
}, {
  timestamps: true // Automatically adds createdAt and updatedAt fields
});

const Post = mongoose.model('Post', postSchema);

module.exports = Post;

This schema defines a Post with a title, content, and author. The timestamps option will automatically manage createdAt and updatedAt fields for us.

Step 4: Implementing the CRUD Operations

With our model in place, we can now create the API endpoints for each CRUD operation in server.js.

First, import the Post model at the top of your server.js file.

const Post = require('./models/post.model');

1. Create (POST)

To create a new post, we'll define a POST route. This route will expect a JSON object in the request body that matches our postSchema.

// CREATE a new post
app.post('/posts', async (req, res) => {
  try {
    const post = await Post.create(req.body);
    res.status(201).json(post);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

Route: POST /posts
Logic: We use an async/await block to handle the asynchronous database operation. Post.create(req.body) creates a new document in the posts collection using the data from the request body.
Response: On success, we send a 201 Created status with the newly created post. If an error occurs, we send a 500 Internal Server Error.

2. Read (GET)

Reading data can be done in two ways: fetching a list of all items or fetching a single item by its unique identifier.

Get All Posts

This endpoint will retrieve all posts from the database.

// READ all posts
app.get('/posts', async (req, res) => {
  try {
    const posts = await Post.find({});
    res.status(200).json(posts);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

Route: GET /posts
Logic: Post.find({}) queries the collection and returns all documents. An empty object {} as the filter means "match all."
Response: We return a 200 OK status with an array of posts.

Get a Single Post by ID

This endpoint will retrieve a specific post using its _id.

// READ a single post by ID
app.get('/posts/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const post = await Post.findById(id);

    if (!post) {
      return res.status(404).json({ message: 'Post not found' });
    }

    res.status(200).json(post);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

Route: GET /posts/:id (e.g., /posts/60d21b4667d0d8992e610c85)
Logic: We extract the id from the URL parameters (req.params). Post.findById(id) finds the document with the matching _id. We also handle the case where no post is found, returning a 404 Not Found.
Response: On success, we return the found post.

3. Update (PUT)

To update an existing post, we'll use a PUT request. This route will identify the post by its ID and update it with the data provided in the request body.

// UPDATE a post by ID
app.put('/posts/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const post = await Post.findByIdAndUpdate(id, req.body, { new: true });

    if (!post) {
      return res.status(404).json({ message: 'Post not found' });
    }

    res.status(200).json(post);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

Route: PUT /posts/:id
Logic: Post.findByIdAndUpdate() finds a document by its ID and updates it. The first argument is the id, the second is the update data (req.body), and the third is an options object. { new: true } ensures that the method returns the modified document, not the original one.
Response: We return the updated post.

4. Delete (DELETE)

Finally, to delete a post, we'll use the DELETE HTTP method.

// DELETE a post by ID
app.delete('/posts/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const post = await Post.findByIdAndDelete(id);

    if (!post) {
      return res.status(404).json({ message: 'Post not found' });
    }

    res.status(200).json({ message: 'Post deleted successfully' });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

Route: DELETE /posts/:id
Logic: Post.findByIdAndDelete() finds a document by its ID and removes it from the collection.
Response: On successful deletion, we return a confirmation message.

Conclusion

Congratulations! You have successfully built a complete RESTful API with Express.js and Mongoose, implementing all four essential CRUD operations. You now have a solid foundation for creating, reading, updating, and deleting data from a MongoDB database.

These fundamental patterns are the building blocks for more complex applications. From here, you can expand on this project by adding features like:

Input Validation: Use a library like Joi or express-validator to validate incoming data.
Authentication and Authorization: Secure your endpoints so only authorized users can perform certain actions.
Refactoring: Organize your code by separating routes and controller logic into different files for better maintainability (e.g., using the MVC pattern).

By mastering CRUD operations in Express, you've unlocked the ability to build powerful and scalable backend services for any web or mobile application.

Authentication in Express with Mongoose (Step-by-Step Guide)

suraj kushwaha — Wed, 17 Sep 2025 15:11:16 +0000

Authentication is one of the most important parts of any web application. Without it, your users can’t securely log in, access their data, or trust your app. In this guide, we’ll learn how to implement authentication in Express.js using Mongoose with JWT (JSON Web Tokens).

By the end, you’ll have a working setup with Register, Login, and Protected Routes.

Step 1: Setup the Project

Initialize a new project:
mkdir express-auth && cd express-auth npm init -y
Install dependencies:
npm install express mongoose bcrypt jsonwebtoken dotenv cors npm install --save-dev nodemon
Project structure:
📂 express-auth ┣ 📂 models ┃ ┗ user.model.js ┣ 📂 routes ┃ ┗ auth.routes.js ┣ 📂 middlewares ┃ ┗ auth.middleware.js ┣ server.js ┣ .env

Step 2: Connect to MongoDB

Inside server.js

import express from "express";
import mongoose from "mongoose";
import dotenv from "dotenv";
import cors from "cors";

dotenv.config();

const app = express();
app.use(express.json());
app.use(cors());

mongoose
  .connect(process.env.MONGO_URI)
  .then(() => console.log("MongoDB connected"))
  .catch((err) => console.error(err));

app.listen(5000, () => console.log("Server running on port 5000"));

Step 3: Create User Model

models/user.model.js

import mongoose from "mongoose";
import bcrypt from "bcrypt";

const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
});

// Hash password before saving
userSchema.pre("save", async function (next) {
  if (!this.isModified("password")) return next();
  this.password = await bcrypt.hash(this.password, 10);
  next();
});

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

Auth Routes (Register & Login)

*routes/auth.routes.js
*

import express from "express";
import jwt from "jsonwebtoken";
import bcrypt from "bcrypt";
import User from "../models/user.model.js";

const router = express.Router();

// Register
router.post("/register", async (req, res) => {
  try {
    const { name, email, password } = req.body;
    const existing = await User.findOne({ email });
    if (existing) return res.status(400).json({ message: "User already exists" });

    const user = new User({ name, email, password });
    await user.save();

    res.status(201).json({ message: "User registered successfully" });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// Login
router.post("/login", async (req, res) => {
  try {
    const { email, password } = req.body;

    const user = await User.findOne({ email });
    if (!user) return res.status(400).json({ message: "Invalid credentials" });

    const isMatch = await bcrypt.compare(password, user.password);
    if (!isMatch) return res.status(400).json({ message: "Invalid credentials" });

    const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: "1h" });

    res.json({ token, user: { id: user._id, name: user.name, email: user.email } });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

export default router;

🛠️ Step 5: Middleware for Protecting Routes

middlewares/auth.middleware.js

import jwt from "jsonwebtoken";

export const authMiddleware = (req, res, next) => {
  const token = req.headers.authorization?.split(" ")[1]; // Bearer <token>
  if (!token) return res.status(401).json({ message: "No token provided" });

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch {
    res.status(401).json({ message: "Invalid token" });
  }
};

✅ Best Practices

🔒 Never store plain-text passwords. Always hash them.

⏳ Use short-lived JWTs + refresh tokens for long sessions.

🔑 Keep your JWT_SECRET safe and outside source code.

🍪 Prefer HttpOnly cookies for storing tokens in production.

🌐 Always use HTTPS in production.

🎯 Conclusion

You just built authentication in Express with Mongoose and JWT!
We created a User model, added Register/Login routes, generated JWT tokens, and protected routes with a middleware.

👉 Next steps:

Add role-based authorization (admin, user, etc.)

Implement refresh tokens for longer sessions

Add OAuth (Google/GitHub login)

🔥 That’s it! You now have a secure authentication system in your Express app.

Building Smarter AI Applications: A Journey Through the LangChain Ecosystem

suraj kushwaha — Tue, 02 Sep 2025 19:49:42 +0000

**What’s the Problem Langchain Solving?
**Building AI applications used to feel like trying to have a conversation through a brick wall. You’d send a prompt to an AI model and hope for the best, with no visibility into what was happening inside and limited control over the process. The results were often unpredictable, hard to debug, and difficult to integrate with real-world data.

The LangChain ecosystem tackles these challenges head-on, giving developers the tools to build reliable, observable, and sophisticated AI applications.

LangChain: The Foundation
Think of LangChain as the Swiss Army knife of AI development. Instead of wrestling with raw API calls and complex prompt management, LangChain provides clean abstractions that make building AI applications feel like connecting Lego blocks.

What LangChain Does
LangChain handles the tedious parts of AI development:

Prompt Templates: Create reusable, dynamic prompts
Chains: Connect multiple AI operations together
Memory: Give your AI the ability to remember previous conversations
Agents: Let AI decide which tools to use and when
RAG: Making AI Actually Useful
RAG (Retrieval-Augmented Generation) solves one of the biggest problems with AI: it often doesn’t know about your specific data. Your company documents, recent events, or personal information simply weren’t in the AI’s training data.

How RAG Works
RAG is elegantly simple:

Store your data in a searchable format (usually vector embeddings)
When someone asks a question, find relevant information from your data
Feed both the question and relevant context to the AI
Get answers grounded in your actual data
Why This Matters
Without RAG:

AI: “I don’t have information about your company’s Q3 results”
You: frustrated developer noises
With RAG:

AI: “Based on your Q3 report, revenue increased 23% compared to last quarter…”
You: happy developer noises
LangGraph: When Simple Chains Aren’t Enough
While LangChain is great for linear workflows, real-world AI applications often need more complex logic. What if your AI needs to research a topic, reflect on its findings, and then decide whether to research more or provide an answer?

LangGraph handles these complex, stateful workflows where AI agents need to make decisions, loop back, and collaborate.

LangSmith: Finally, Visibility Into AI
Here’s the frustrating part about building AI applications: when something goes wrong, you often have no idea why. LangSmith solves this by giving you X-ray vision into your AI applications.

What LangSmith Shows You
Trace every step of your AI workflow
See exact prompts sent to models
Monitor performance and costs
Debug issues with real data
A/B test different approaches