DEV Community: Gurkirat Singh

Creating Generic APIs with MongoDB and Node.js

Gurkirat Singh — Sun, 25 May 2025 16:44:18 +0000

In modern web applications, creating reusable and generic APIs can significantly speed up development and reduce redundancy. In this post, you'll learn how to build generic APIs in a Node.js backend using MongoDB and Mongoose that can adapt to different collections and schemas dynamically.

When building full-stack applications, you'll often find yourself repeating CRUD (Create, Read, Update, Delete) operations for every collection in your database. What if you could handle all of that using generic APIs?

In this post, I’ll walk you through how to build generic RESTful APIs using Node.js with MongoDB that:

Automatically validate data using schema metadata
Handle multiple collections dynamically
Simplify frontend integration using a unified structure

⚙️ Tech Stack

Node.js with Express
MongoDB with Mongoose or native driver
TypeScript (optional but recommended)
React + MUI (for the frontend) [future post]

🧩 Folder Structure

/generic-api
│
├── controllers/
│   └── generic.controller.js
├── routes/
│   └── generic.routes.js
├── schemas/
│   └── schemaConfig.js  // Optional schema metadata
├── server.js

🚀 API Endpoints

Method	Endpoint	Description
GET	`/generic/:collectionName`	Fetch all documents
GET	`/generic/:collectionName/:id`	Fetch single document by ID
POST	`/generic/:collectionName`	Create a new document
PUT	`/generic/:collectionName/:id`	Update a document
DELETE	`/generic/:collectionName/:id`	Delete a document
GET	`/generic/schema/:collectionName`	Fetch schema metadata (optional)

🛠️ Sample: Generic Controller

const { ObjectId } = require("mongodb");
const db = require("../db/mongo"); // Mongo client instance

exports.getAll = async (req, res) => {
  const { collectionName } = req.params;
  const collection = db.collection(collectionName);
  const data = await collection.find({}).toArray();
  res.json(data);
};

exports.getById = async (req, res) => {
  const { collectionName, id } = req.params;
  const collection = db.collection(collectionName);
  const doc = await collection.findOne({ _id: new ObjectId(id) });
  res.json(doc);
};

exports.create = async (req, res) => {
  const { collectionName } = req.params;
  const collection = db.collection(collectionName);
  const result = await collection.insertOne(req.body);
  res.json(result);
};

exports.update = async (req, res) => {
  const { collectionName, id } = req.params;
  const collection = db.collection(collectionName);
  const result = await collection.updateOne(
    { _id: new ObjectId(id) },
    { $set: req.body }
  );
  res.json(result);
};

exports.remove = async (req, res) => {
  const { collectionName, id } = req.params;
  const collection = db.collection(collectionName);
  const result = await collection.deleteOne({ _id: new ObjectId(id) });
  res.json(result);
};

🧭 Optional: Schema Metadata Endpoint

You can store field metadata in a collection or a separate config file. Example response for /generic/schema/users:

{
  "bsonType": "object",
  "required": ["email", "name"],
  "properties": {
    "email": {
      "bsonType": "string",
      "description": "User email"
    },
    "name": {
      "bsonType": "string",
      "description": "Full name"
    },
    "role": {
      "bsonType": "string",
      "enum": ["admin", "user", "viewer"]
    }
  }
}

This helps the frontend dynamically render forms and data grids with appropriate validations and display names.

🧪 Testing the APIs

You can test the generic APIs using:

Postman for manual testing
React + MUI DataGrid to dynamically fetch and render based on schema
Swagger/OpenAPI if you want to document it generically

✅ Benefits of Generic APIs

💡 Reduced Boilerplate: One controller handles all collections
⚡ Rapid Development: Just create a schema and start inserting data
🔁 Schema-Driven UI: Use schema metadata to auto-render forms and tables
🔒 Validation Layer: Add schema validation at collection or app level

🧠 Final Thoughts

Creating generic APIs saves tons of dev effort and aligns with the DRY principle. You can always override generic behavior for edge cases or add collection-specific logic later.

This pattern works great for internal tools, admin dashboards, content platforms, or any place where data models are dynamic or frequently evolving.

Coming Next: How to build a dynamic frontend using React + MUI DataGrid that adapts to the schema from /generic/schema/:collection.

Tags:

#nodejs #mongodb #api #backend #javascript #fullstack

How to Build a RESTful API in Node.js and Test it with Postman

Gurkirat Singh — Sun, 04 May 2025 06:11:11 +0000

Whether you're a frontend developer wanting to dip your toes into backend, or a beginner who wants to understand how APIs work — this guide is for you. We'll build a simple REST API using Node.js + Express, then test it with Postman.

📚 Table of Contents

Introduction
Prerequisites
Project Setup
Creating a Basic Server
Building the REST API (CRUD Users)
Testing with Postman
Optional Improvements
Final Thoughts

🔰 Introduction

In this tutorial, you'll learn how to:

Create a REST API with Node.js and Express
Add basic CRUD operations
Test everything using Postman

You won’t need any database here — we’ll simulate one using an in-memory array. Perfect for learning the basics.

🧰 Prerequisites

Make sure you have the following installed:

Node.js
Postman
A code editor like VS Code

⚙️ Project Setup

Step 1: Initialize the project

mkdir node-api-tutorial
cd node-api-tutorial
npm init -y

Step 2: Install dependencies

npm install express cors
npm install --save-dev nodemon

Step 3: Create the entry file

📝 You can create this manually by:

Right-clicking in your file explorer and choosing New File (e.g., in VS Code).

🛠️ Creating a Basic Server

Paste this code in server.js:

const express = require('express');
const cors = require('cors');

const app = express();
const port = 5000;

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

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

app.listen(port, () => {
  console.log(`Server is running at http://localhost:${port}`);
});

Update your package.json to use nodemon:

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

Then run your server:

npm start

Visit http://localhost:5000 in your browser. You should see:

API is working!

🔄 Building the REST API (CRUD Users)

Add this below the root endpoint in server.js:

let users = [
  { id: 1, name: 'Alice', email: 'alice@example.com' },
  { id: 2, name: 'Bob', email: 'bob@example.com' },
];

// GET all users
app.get('/users', (req, res) => {
  res.json(users);
});

// GET user by ID
app.get('/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).send('User not found');
  res.json(user);
});

// POST a new user
app.post('/users', (req, res) => {
  const newUser = {
    id: users.length + 1,
    name: req.body.name,
    email: req.body.email
  };
  users.push(newUser);
  res.status(201).json(newUser);
});

// PUT update user
app.put('/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).send('User not found');

  user.name = req.body.name;
  user.email = req.body.email;
  res.json(user);
});

// DELETE user
app.delete('/users/:id', (req, res) => {
  users = users.filter(u => u.id !== parseInt(req.params.id));
  res.status(204).send();
});

🧪 Testing with Postman

Open Postman and try out the following requests:

➕ POST `/users`

Creates a new user
Method: POST
Endpoint: http://localhost:5000/users
Body (raw JSON):

{
  "name": "Charlie",
  "email": "charlie@example.com"
}

📥 GET `/users`

Returns all users.
Method: GET
Endpoint: http://localhost:5000/users

📥 GET `/users/1`

Returns user with ID = 1.
Method: GET
Endpoint: http://localhost:5000/users/1

🛠 PUT `/users/2`

Updates a user with ID = 2
Method: PUT
Endpoint: http://localhost:5000/users/2
Body:

{
  "name": "Bobby",
  "email": "bobby@newmail.com"
}

❌ DELETE `/users/1`

Deletes user with ID = 1.
Method: DELETE
Endpoint: http://localhost:5000/users/1

🧩 Optional Improvements

Once you're comfortable, try adding:

✅ Input validation using Joi

💾 MongoDB + Mongoose for real persistence

🛡 Environment variables with dotenv

📘 API documentation with Swagger

🔐 JWT-based authentication

✅ Final Thoughts

You’ve just built your first REST API with Node.js and Express, and tested it with Postman. This is a great step forward for any developer — especially if you're aiming to become full-stack or start freelancing.

🐱‍💻 Source Code

👉 GitHub Repo https://github.com/gurkeerats2/node-api-tutorial