Development Features

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

📂 Repository Structure

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

🎯 Quick Start Guide

Prerequisites

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

1. Clone the Repository

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

2. Choose Your Implementation

🟡 JavaScript Version

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

🔷 TypeScript Version

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

3. Environment Configuration

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

4. Start Development

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

🔗 API Documentation

Both implementations provide the same API endpoints:

Authentication Endpoints

Example Usage

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"
  }'

📚 Implementation Comparison

🛠️ Technology Stack

Backend Technologies

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

Development Tools

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

Security & Middleware

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

🏗️ Architecture Patterns

Both implementations follow clean architecture principles:

📁 Config Layer

• Database connection setup
• Environment variable management
• Application configuration

🎛️ Controller Layer

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

🔒 Middleware Layer

• Authentication verification
• Request preprocessing
• Error handling

📊 Model Layer

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

🛣️ Route Layer

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

🔒 Security Features

• 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

📖 Learning Path

Beginner Level

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

Intermediate Level

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

Advanced Level

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

🚀 Production Deployment

JavaScript Version

cd JavaScript
npm install --production
npm start

TypeScript Version

cd TypeScript
npm install
npm run build
npm start

Deployment Platforms

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

🧪 Testing the APIs

Using cURL

See the API documentation section above for cURL examples.

Using Postman

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

Using VS Code REST Client

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"
}

🔄 Version History

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

🤝 Contributing

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

How to Contribute

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

Contribution Guidelines

• 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

Areas for Contribution

• 🧪 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

📞 Support & Community

Getting Help

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

Connect with the Community

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

📄 License

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

License Summary

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

👨‍💻 Author

Nhan Pham Thanh

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

🌟 Acknowledgments

Special thanks to:

• Express.js Team for the amazing framework
• MongoDB Team for the robust database solution
• TypeScript Team fo