How to Use MongoDB Atlas: Free Cloud Database Setup (2026)

mongodb+srv://appuser:<password>@my-app-cluster.abc12.mongodb.net/?retryWrites=true&w=majority&appName=my-app-cluster

mongodb+srv://appuser:yourpassword@my-app-cluster.abc12.mongodb.net/myappdb?retryWrites=true&w=majority

# .env
MONGODB_URI=mongodb+srv://appuser:yourpassword@my-app-cluster.abc12.mongodb.net/myappdb?retryWrites=true&w=majority
PORT=3000

npm install mongoose dotenv

// src/db.js
const mongoose = require('mongoose');

const connectDB = async () => {
  try {
    const conn = await mongoose.connect(process.env.MONGODB_URI, {
      // These options are the defaults in Mongoose 7+, but explicit is good
      serverSelectionTimeoutMS: 5000,  // Timeout after 5 seconds if can't connect
      socketTimeoutMS: 45000,           // Close socket after 45 seconds of inactivity
    });
    
    console.log(`MongoDB connected: ${conn.connection.host}`);
  } catch (err) {
    console.error('MongoDB connection error:', err.message);
    process.exit(1);  // Exit on connection failure — don't run without DB
  }
};

// Handle connection events
mongoose.connection.on('disconnected', () => {
  console.log('MongoDB disconnected');
});

mongoose.connection.on('error', (err) => {
  console.error('MongoDB error:', err);
});

module.exports = connectDB;

// src/index.js
require('dotenv').config();
const express = require('express');
const connectDB = require('./db');

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

// Connect to MongoDB before starting the server
connectDB().then(() => {
  const PORT = process.env.PORT || 3000;
  app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
  });
});

// src/models/Post.js
const mongoose = require('mongoose');
const { Schema } = mongoose;

const PostSchema = new Schema({
  title: {
    type: String,
    required: [true, 'Title is required'],
    trim: true,
    minlength: [3, 'Title must be at least 3 characters'],
    maxlength: [500, 'Title cannot exceed 500 characters']
  },
  content: {
    type: String,
    required: [true, 'Content is required'],
    minlength: [10, 'Content must be at least 10 characters']
  },
  excerpt: {
    type: String,
    maxlength: 300,
    default: function() {
      // Auto-generate excerpt from content if not provided
      return this.content.substring(0, 150) + '...';
    }
  },
  author: {
    type: Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  tags: {
    type: [String],
    default: []
  },
  published: {
    type: Boolean,
    default: false
  },
  views: {
    type: Number,
    default: 0,
    min: 0
  },
  metadata: {
    type: Schema.Types.Mixed,
    default: {}
  }
}, {
  timestamps: true,     // Adds createdAt and updatedAt automatically
  versionKey: false     // Remove the __v field from documents
});

// Index for common query patterns
PostSchema.index({ author: 1, published: 1 });
PostSchema.index({ tags: 1 });
PostSchema.index({ createdAt: -1 });
PostSchema.index({ title: 'text', content: 'text' });  // Text search index

// Instance method
PostSchema.methods.incrementViews = function() {
  this.views += 1;
  return this.save();
};

// Static method
PostSchema.statics.findPublished = function(limit = 20) {
  return this.find({ published: true })
    .sort({ createdAt: -1 })
    .limit(limit)
    .populate('author', 'name email');
};

const Post = mongoose.model('Post', PostSchema);
module.exports = Post;

// src/models/User.js
const mongoose = require('mongoose');

const UserSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
    trim: true
  },
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true,
    trim: true,
    match: [/^\S+@\S+\.\S+$/, 'Invalid email format']
  },
  role: {
    type: String,
    enum: ['user', 'admin'],
    default: 'user'
  }
}, { timestamps: true, versionKey: false });

module.exports = mongoose.model('User', UserSchema);

// src/routes/posts.js
const express = require('express');
const router = express.Router();
const Post = require('../models/Post');

// GET /posts — list published posts with pagination
router.get('/', async (req, res) => {
  try {
    const page = parseInt(req.query.page) || 1;
    const limit = Math.min(parseInt(req.query.limit) || 10, 100);
    const skip = (page - 1) * limit;
    
    const [posts, total] = await Promise.all([
      Post.find({ published: true })
        .sort({ createdAt: -1 })
        .skip(skip)
        .limit(limit)
        .populate('author', 'name')
        .select('-content'),  // Exclude full content from list view
      Post.countDocuments({ published: true })
    ]);
    
    res.json({
      data: posts,
      meta: { page, limit, total, pages: Math.ceil(total / limit) }
    });
  } catch (err) {
    res.status(500).json({ error: 'Failed to fetch posts', message: err.message });
  }
});

// GET /posts/:id — single post
router.get('/:id', async (req, res) => {
  try {
    const post = await Post.findById(req.params.id)
      .populate('author', 'name email');
    
    if (!post) {
      return res.status(404).json({ error: 'Post not found' });
    }
    
    // Increment view count asynchronously (don't await — don't block the response)
    post.incrementViews().catch(console.error);
    
    res.json(post);
  } catch (err) {
    // Handle invalid ObjectId format
    if (err.name === 'CastError') {
      return res.status(400).json({ error: 'Invalid post ID format' });
    }
    res.status(500).json({ error: 'Failed to fetch post' });
  }
});

// POST /posts — create new post
router.post('/', async (req, res) => {
  try {
    const post = new Post({
      ...req.body,
      author: req.user?.id  // Assuming auth middleware sets req.user
    });
    
    const saved = await post.save();
    res.status(201).json(saved);
  } catch (err) {
    if (err.name === 'ValidationError') {
      const errors = Object.values(err.errors).map(e => ({
        field: e.path,
        message: e.message
      }));
      return res.status(400).json({ error: 'Validation failed', details: errors });
    }
    res.status(500).json({ error: 'Failed to create post' });
  }
});

// PATCH /posts/:id — update post
router.patch('/:id', async (req, res) => {
  try {
    // Use findByIdAndUpdate with runValidators to validate changes
    const post = await Post.findByIdAndUpdate(
      req.params.id,
      { $set: req.body },
      { new: true, runValidators: true }  // new: true returns updated doc
    );
    
    if (!post) return res.status(404).json({ error: 'Post not found' });
    res.json(post);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// DELETE /posts/:id — delete post
router.delete('/:id', async (req, res) => {
  try {
    const post = await Post.findByIdAndDelete(req.params.id);
    if (!post) return res.status(404).json({ error: 'Post not found' });
    res.status(204).send();
  } catch (err) {
    res.status(500).json({ error: 'Failed to delete post' });
  }
});

// GET /posts/search?q=keyword — text search
router.get('/search', async (req, res) => {
  try {
    const query = req.query.q;
    if (!query) return res.status(400).json({ error: 'Search query required' });
    
    const posts = await Post.find(
      { $text: { $search: query }, published: true },
      { score: { $meta: 'textScore' } }
    )
    .sort({ score: { $meta: 'textScore' } })
    .limit(20);
    
    res.json(posts);
  } catch (err) {
    res.status(500).json({ error: 'Search failed' });
  }
});

module.exports = router;