A comprehensive collection of Express.js backend templates showcasing modern web development practices with both JavaScript and TypeScript implementations. This repository serves as a complete learning resource and production-ready foundation for building scalable backend applications.

This repository contains two complete Express.js backend implementations:

• 🟡 JavaScript Version: Traditional JavaScript implementation with ES6+ features
• 🔷 TypeScript Version: Modern TypeScript implementation with full type safety

Both projects demonstrate the same core functionality but showcase different development approaches, allowing you to choose the best fit for your project requirements.

• ✅ User Authentication System (Register/Login)
• ✅ JWT Token-Based Security
• ✅ Password Hashing & Encryption
• ✅ MongoDB Integration with Mongoose
• ✅ RESTful API Design
• ✅ CORS Configuration
• ✅ Environment-Based Configuration
• ✅ Middleware Architecture
• ✅ Error Handling & Validation

8000
• 🔧 Hot Reloading (Development Mode)
• 📝 Comprehensive Documentation
• 🧪 Production-Ready Setup
• 🔒 Security Best Practices
• 📁 Clean Architecture Pattern
• 🎯 API Testing Examples

Backend-Express-Tutorial/
├── 📁 JavaScript/              # JavaScript Implementation
│   ├── 📄 server.js            # Main server file
│   ├── 📄 package.json         # Dependencies & scripts
│   ├── 📁 config/              # Configuration files
│   ├── 📁 controllers/         # Business logic
│   ├── 📁 middleware/          # Custom middleware
│   ├── 📁 models/              # Database models
│   ├── 📁 routes/              # API routes
│   └── 📄 README.md            # JavaScript-specific docs
│
├── 📁 TypeScript/              # TypeScript Implementation
│   ├── 📄 tsconfig.json        # TypeScript configuration
│   ├── 📄 package.json         # Dependencies & scripts
│   ├── 📁 src/                 # Source code
│   │   ├── 📄 index.ts         # Application entry point
│   │   ├── 📄 server.ts        # Express server setup
│   │   ├── 📁 config/          # Configuration files
│   │   ├── 📁 controllers/     # Business logic with types
│   │   ├── 📁 middleware/      # Type-safe middleware
│   │   ├── 📁 models/          # Mongoose models with types
│   │   ├── 📁 routes/          # Type-safe routes
│   │   └── 📁 types/           # Type definitions
│   └── 📄 README.md            # TypeScript-specific docs
│
├── 📄 LICENSE                  # MIT License
├── 📄 .gitignore              # Git ignore rules
└── 📄 README.md               # This file

• Node.js (v14+ for JavaScript, v16+ for TypeScript)
• MongoDB (Local or Atlas)
• Git

git clone https://github.com/NhanPhamThanh-IT/Backend-Express-Tutorial.git
cd Backend-Express-Tutorial

cd JavaScript
npm install
# Create .env file with your configuration
npm run dev

cd TypeScript
npm install
# Create .env file with your configuration
npm run dev

Create a .env file in your chosen project directory:

PORT=5000
MONGODB_URI=mongodb://localhost:27017/your-database
JWT_SECRET=your-super-secret-jwt-key
CLIENT_URL=http://localhost:3000
NODE_ENV=development

Your server will be running at http://localhost:5000

Both implementations provide the same API endpoints:

Register a new user:

curl -X POST http://localhost:5000/api/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{
    "fullName": "John Doe",
    "email": "john@example.com",
    "password": "securePassword123"
  }'

Login user:

curl -X POST http://localhost:5000/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "email": "john@example.com",
    "password": "securePassword123"
  }'

• Express.js: Fast, unopinionated web framework
• MongoDB: NoSQL database
• Mongoose: MongoDB object modeling
• JWT: JSON Web Token authentication
• bcryptjs: Password hashing library

• Nodemon: Auto-restart development server
• TypeScript: (TypeScript version) Static type checking
• ts-node: (TypeScript version) TypeScript execution

• CORS: Cross-Origin Resource Sharing
• body-parser: Request body parsing
• dotenv: Environment variable management

Both implementations follow clean architecture principles:

• Database connection setup
• Environment variable management
• Application configuration

• Business logic implementation
• Request/response handling
• Data validation and processing

• Authentication verification
• Request preprocessing
• Error handling

• Database schema definition
• Data relationships
• Model methods and validations

• API endpoint definitions
• Route-specific middleware
• Request routing logic

• Password Encryption: bcryptjs hashing
• JWT Authentication: Stateless token-based auth
• CORS Protection: Configurable cross-origin requests
• Input Validation: Request data validation
• Error Sanitization: Safe error responses
• Environment Isolation: Secure configuration management

1. Start with the JavaScript version
2. Understand Express.js fundamentals
3. Learn MongoDB and Mongoose basics
4. Grasp authentication concepts

1. Explore the TypeScript version
2. Learn type definitions and interfaces
3. Understand middleware patterns
4. Practice API testing and debugging

1. Compare both implementations
2. Implement additional features
3. Add testing suites
4. Deploy to production

cd JavaScript
npm install --production
npm start

cd TypeScript
npm install
npm run build
npm start

• Heroku: Easy deployment with git integration
• Vercel: Serverless deployment option
• DigitalOcean: VPS deployment
• AWS EC2: Scalable cloud deployment
• Railway: Simple cloud deployment

See the API documentation section above for cURL examples.

1. Import the API endpoints
2. Set up environment variables
3. Test registration and login flows
4. Verify JWT token authentication

Create a .http file with:

### Register User
POST http://localhost:5000/api/v1/auth/register
Content-Type: application/json

{
  "fullName": "John Doe",
  "email": "john@example.com",
  "password": "securePassword123"
}

### Login User
POST http://localhost:5000/api/v1/auth/login
Content-Type: application/json

{
  "email": "john@example.com",
  "password": "securePassword123"
}

• v1.0.0 - Initial release with JavaScript and TypeScript implementations
• Features: Complete authentication system, MongoDB integration, JWT security

We welcome contributions! Here's how you can help:

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

• Follow the existing code style
• Add appropriate comments and documentation
• Test your changes thoroughly
• Update README if necessary
• Ensure both JavaScript and TypeScript versions work

• 🧪 Testing: Add unit and integration tests
• 📝 Documentation: Improve or translate documentation
• 🔒 Security: Enhance security features
• ⚡ Performance: Optimize code performance
• 🎨 UI: Add frontend examples
• 🔌 Features: Implement new functionality

• 📖 Documentation: Check the README files in each project
• 🐛 Issues: Open an issue
• 💬 Discussions: GitHub Discussions

• ⭐ Star this repository if you find it helpful
• 🍴 Fork to create your own version
• 📢 Share with other developers

This project is licensed under the MIT License - see the LICENSE file for details.

• ✅ Commercial use
• ✅ Modification
• ✅ Distribution
• ✅ Private use
• ❌ Liability
• ❌ Warranty

Nhan Pham Thanh

• 🌐 GitHub: @NhanPhamThanh-IT
• 📧 Email: Contact via GitHub
• 💼 LinkedIn: Connect on LinkedIn

Special thanks to:

• Express.js Team for the amazing framework
• MongoDB Team for the robust database solution
• TypeScript Team for bringing type safety to JavaScript
• Open Source Community for continuous inspiration
• Contributors who help improve this project

• Express.js Documentation
• MongoDB Documentation
• Mongoose Documentation
• TypeScript Documentation
• JWT.io

• MDN Web Docs
• Node.js Best Practices
• TypeScript Handbook

⭐ Star this repository if it helped you build better Express.js applications! ⭐

Made with ❤️ by Nhan Pham Thanh

Building the future, one API at a time 🚀