🚀 URL Shortener Application — Node.js, Express, MongoDB & JWT (MVC Architecture)

A full-featured, secure URL Shortener RESTful Web Application built using Node.js, Express.js, MongoDB (Mongoose), and Server-Side Rendering (EJS). The project implements strict MVC Architecture, stateless JWT Authentication (via HTTP-Only Cookies), and Role-Based Access Control (RBAC).

• 🏗️ Clean MVC Architecture: Modular structure separating Models (Schemas), Views (EJS Templates), Controllers (Business Logic), and Middlewares/Services.
• 🔐 JWT Authentication: Stateless session management using JSON Web Tokens set in secure browser cookies.
• 🛡️ Role-Based Access Control (RBAC) Middleware:
  • Normal Users: Can generate short URLs, view, manage, and track click analytics for only their own generated links.
  • Admin Users: Possess elevated privileges to view and manage all generated URLs across the entire platform.
• 📈 Real-Time Click Analytics: Dynamic redirection tracking total visits and timestamps for each generated short URL.
• 🔒 Security & Best Practices: Middleware-level authorization checks, custom error handling, and environment-variable-ready (.env) configuration.

• Runtime: Node.js (v18+)
• Framework: Express.js
• Template Engine: EJS (Embedded JavaScript)
• Database: MongoDB (Local Community Server & Atlas Ready)
• ODM Library: Mongoose
• Utilities: nanoid, nodemon, cookie-parser, uuid, jsonwebtoken, dotenv
• API Testing: Postman
• Version Control: Git, GitHub

• 🏗️ MVC Architecture – Clean separation of concerns with Models, Views, Controllers, Routes, and Services.
• 🔐 JWT Authentication & Cookies – Secure user signup/login system powered by JSON Web Tokens stored in HTTP-only cookies.
• 🛡️ Role-Based Access Control (RBAC) – Middleware-level authorization layer restricting routes based on user roles (Admin, Normal).
• 🖼️ Server-Side Rendering (SSR) – Clean, dynamic user interfaces rendered using the EJS templating engine.
• 🔗 Dynamic URL Shortening – Generates short, unique IDs using nanoid for fast link management.
• 📊 Click Analytics & History – Tracks total clicks and logs visit timestamps inside MongoDB for every generated link.
• ⚙️ Centralized Environment Vault – Secure handling of sensitive keys (MONGO_URL, JWT_SECRET, PORT) via .env integration.
• 🗄️ MongoDB & Mongoose Validation – Schema-level data validation and efficient database connectivity.
• ⚡ Developer Workflow – Instant auto-reloads during development powered by nodemon.

Generated: 8/2/2026, 1:35:39 PM Root Path: workspace\Node

├── 📁 Learning
│   ├── 📁 Events
│   │   ├── 📄 main.js
│   │   └── 📄 test.txt
│   ├── 📁 Express
│   │   ├── ⚙️ .gitignore
│   │   ├── 📄 index.js
│   │   ├── ⚙️ package-lock.json
│   │   └── ⚙️ package.json
│   ├── 📁 First
│   │   ├── 📄 contacts.txt
│   │   ├── 📄 file.js
│   │   ├── 📄 file.txt
│   │   ├── 📄 math.js
│   │   ├── 📄 modules.js
│   │   ├── ⚙️ package.json
│   │   └── 📄 test.txt
│   ├── 📁 HTTP
│   │   └── 📄 http-notes.js
│   ├── 📁 RestAPI
│   │   ├── 📁 controllers
│   │   │   └── 📄 user.js
│   │   ├── 📁 logs
│   │   │   └── 📄 logs.txt
│   │   ├── 📁 middlewares
│   │   │   └── 📄 middleware.js
│   │   ├── 📁 models
│   │   │   └── 📄 user.js
│   │   ├── 📁 routes
│   │   │   └── 📄 user.js
│   │   ├── 📁 views
│   │   │   └── ⚙️ .gitkeep
│   │   ├── ⚙️ .gitignore
│   │   ├── ⚙️ MOCK_DATA.json
│   │   ├── 📄 connection.js
│   │   ├── 📄 index.js
│   │   ├── ⚙️ package-lock.json
│   │   └── ⚙️ package.json
│   ├── 📁 Server
│   │   ├── 📄 index.js
│   │   ├── 📄 log.txt
│   │   ├── ⚙️ package.json
│   │   └── 📄 url_note.js
│   └── 📁 Versions
│       └── 📄 version.js
├── 📁 Shortener_URL
│   ├── 📁 controllers
│   │   ├── 📄 static.js
│   │   ├── 📄 url.js
│   │   └── 📄 user.js
│   ├── 📁 middlewares
│   │   └── 📄 auth.js
│   ├── 📁 models
│   │   ├── 📄 url.js
│   │   └── 📄 user.js
│   ├── 📁 routes
│   │   ├── 📄 static.js
│   │   ├── 📄 url.js
│   │   └── 📄 user.js
│   ├── 📁 services
│   │   └── 📄 auth.js
│   ├── 📁 views
│   │   ├── 📄 home.ejs
│   │   ├── 📄 login.ejs
│   │   └── 📄 signup.ejs
│   ├── ⚙️ .gitignore
│   ├── 📄 app.js
│   ├── 📄 connect.js
│   ├── ⚙️ package-lock.json
│   ├── ⚙️ package.json
│   └── ⚙️ vercel.json
└── 📝 README.md

• Node.js (v16 or higher)
• npm package manager
• Basic knowledge of JavaScript

In the project directory, you can run the following commands configured in package.json:

npm start

Before deploying, ensure your database access is open to Vercel:

1. Go to MongoDB Atlas.
2. Navigate to Network Access under Security.
3. Click Add IP Address and select Allow Access from Anywhere (0.0.0.0/0).
4. Save changes.

Set up your environment variables in Vercel before or after deployment:

1. In your Vercel Project Dashboard, go to Settings ➔ Environment Variables.
2. Add your environment key-value pairs (e.g., MONGO_URL, JWT_SECRET, PORT).
3. ⚠️ Important Requirement:
   • Ensure Production, Preview, and Development targets are ALL CHECKED.
   • DO NOT toggle on the "Sensitive" option for MONGO_URL to prevent variable save/sync issues.

1. Push your latest code to GitHub.
2. Go to vercel.com and log in.
3. Click "New Project".
4. Connect your GitHub repository.
5. Select/Connect the exact project root folder containing package.json (to avoid nested directory deployment issues).
6. Configure Build Settings:
   • Vercel automatically detects Vite/Node settings.
   • Toggle the "Build Command" switch and manually type npm run build to override it (if using a build step).
7. Ensure all Environment Variables (MONGO_URL, etc.) are added under the project settings.
8. Click "Deploy".

💡 Note: If you edit or update any Environment Variable after deploying, always go to the Deployments tab, click the three dots (...) on the latest deployment, and select Redeploy to apply changes! & Make sure your project structure strictly follows the root layout:

Shortener_URL/
├── models/
├── routes/
├── middlewares/
├── views/
├── .env
├── app.js
├── connect.js
└── package.json

Download and install the LTS version from Node.js Official Site. Verify installation in your terminal:

node -v
npm -v

1. Download MongoDB Community Server from MongoDB Download Center.
2. Download MongoDB Shell (mongosh) to run CLI database operations.
3. Start the local server daemon:

# Verify connection using mongosh CLI
mongosh

Initialize your Node project inside any project directory:

npm init

package name: (name)

version: (1.0.0)

description: may add ​ entry point: (index.js)​

test command: just enter​

git repository: (https://github.com/username/repo_name.git)

keywords: may add

author: may add

license: (ISC)

type: (commonjs) recommended module

Is this OK? (yes)

To enable modern ES6 import/export syntax instead of require(), open package.json and add "type": "module":

{
  "name": "node",
  "version": "1.0.0",
  "bugs": {
    "url": "https://github.com/username/repo/issues"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/username/repo.git"
  },
  "license": "ISC",
  "author": "",
  "type": "commonjs",
  "main": "app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node app.js" // add manually write "nodemon index.js" if installed
  }
}

Run this command inside your project directory to install npm packages in the package.json file:

npm i express
npm i mongoose
npm i nanoid
npm i nodemon
npm i ejs
npm i cookie-parser
npm i uuid
npm i jsonwebtoken
npm i dotenv

It automatically creates package.json if not exist. Like

{
  "name": "pakage name",
  "version": "1.0.0",
  "description": "Something",
  "keywords": [
    "keywords"
  ],
  "homepage": "https://github.com/github.com/username#readme",
  "bugs": {
    "url": "https://github.com/github.com/username/issues"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/github.com/username.git"
  },
  "license": "ISC",
  "author": "Author",
  "type": "module",
  "main": "app.js",
  "scripts": {
    "start": "nodemon app.js"
  },
  "dependencies": {
    "cookie-parser": "^1.4.7",
    "dotenv": "^17.4.2",
    "ejs": "^6.0.1",
    "express": "^5.2.1",
    "jsonwebtoken": "^9.0.3",
    "mongoose": "^9.8.0",
    "nanoid": "^6.0.0",
    "nodemon": "^3.1.14",
    "uuid": "^14.0.1"
  }
}

Note: Install packages when needed

• Install Postman from 🌐 postman.com to test API's

💡 Note: Postman automatically manages the HTTP-only token cookie after login.

• Method & Route: POST /user/signup
• Body (JSON):

{
  "name": "MehmoodCoder",
  "email": "[email protected]",
  "password": "Password123"
}

• Method & Route: POST /user/login
• Body (JSON):

{
  "email": "[email protected]",
  "password": "Password123"
}

• Response: Sets HTTP-only token cookie.

• Method & Route: POST /url
• Body (JSON):

{
  "url": "[https://github.com/MehmoodCoder](https://github.com/MehmoodCoder)"
}

• Response (201 Created):

{
  "id": "8xK9p2Lm"
}

• Method & Route: GET /url/:shortId
• Example: http://localhost:4000/url/8xK9p2Lm
• Response (302 Found): Redirects to target destination & updates analytics.

If you need to clear all test documents without dropping the collection structure:

# 1. Open mongosh CLI
mongosh

# 2. Show All DB's
show dbs

# 3. Switch to project DB
use project-db-name

# 4. Show Exist DB collections
show collections

# 5. Show All Documents
db.collection.find({})

# 6. Delete all documents inside 'project-db-name' collection if wants
db.project-db-name.deleteMany({})

# 5. Exit the interactive MongoDB Shell session and return to the system terminal
.exit

# 6. And many more

• 🟢 Node.js Official Documentation – Core Node.js concepts & runtime docs
• ⚡ Express.js API Reference – Web framework, routing & middleware guides
• 🗄️ MongoDB Manual – NoSQL database features & queries
• 🍃 Mongoose Docs – ODM schemas, models, and queries
• 📦 NPM Official Registry – Package manager & dependency discovery
• 🔑 JSON Web Tokens (JWT) – Token-based authentication mechanics
• 🎨 EJS Templating Engine – Embedded JavaScript templates for SSR
• 🎲 nanoid Documentation – Unique string generator for short URLs
• 🧪 Postman Learning Center – API testing, environments & cookies

• ✅ MVC Architecture – Structuring backend apps using Models, Views, Controllers, Routes, and Services
• ✅ Authentication & JWT – Issuing, signing, and verifying JSON Web Tokens (JWT) for user authentication
• ✅ Cookie Management – Storing and parsing HTTP-only cookies safely with cookie-parser
• ✅ Role-Based Access Control (RBAC) – Restricting route access dynamically based on user roles (Admin, Normal)
• ✅ Server-Side Rendering (SSR) – Dynamic UI rendering with EJS and passing session data to views
• ✅ MongoDB & Mongoose Schema Design – Managing schemas, data types, unique constraints, and population
• ✅ Database Aggregation & Analytics – Array updates ($push) for recording link click history and timestamps
• ✅ Express Middleware Pipeline – Request body parsing (json, urlencoded), auth state injection, and protected route guards
• ✅ RESTful Endpoints & Redirection – Dynamic parameter handling (req.params) and 302 HTTP redirects
• ✅ Environment Vault & Tooling – Managing configuration variables via .env and automated dev workflows with nodemon

MehmoodCoder

• 🔗 GitHub: github.com/MehmoodCoder
• 🌐 Portfolio: My Portfolio Link

This project is open source and available under the MIT License.

• 🔐 JWT Authentication System – Implemented user signup and login flows using JSON Web Tokens (JWT) for stateless authentication.
• 🍪 Cookie-Based Sessions – Integrated cookie-parser middleware to securely pass and verify HTTP-only auth tokens.
• 🛡️ Role-Based Access Control (RBAC) – Added authorization middlewares (RestrictTo) to restrict endpoints based on user roles (Admin, Normal).
• 🖼️ SSR Dashboard (EJS Integration) – Built server-side rendered views for user login, registration, and URL management dashboard.
• ⚙️ Environment Management – Centralized sensitive configurations (PORT, MONGO_URL, JWT_SECRET) into .env file setup.

• 🚀 Core Fundamentals – Built custom HTTP servers, learned EventEmitters, File System (fs) operations, and NPM module handling.
• 🛠️ RESTful API Architecture – Structured scalable Express servers following clean MVC (Model-View-Controller) patterns.
• ⚡ URL Shortener Microservice – Implemented nanoid logic to generate unique short IDs for long URLs.
• 🗄️ MongoDB Integration – Connected Mongoose schemas with real-time URL redirect logic and automated visit analytics tracking.
• 🛠️ Developer Experience – Configured nodemon for auto-reloading during development and created custom logging middlewares.

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request