Node.js REST API with TypeScript, Redis & Docker

Production-grade REST API built with Node.js, TypeScript, Express, MongoDB, and Redis.

🚀 Features

• TypeScript - Type-safe development
• Express.js - Fast, unopinionated web framework
• MongoDB - NoSQL database with Mongoose ODM
• Redis - In-memory caching and session management
• Docker - Containerized deployment
• JWT Authentication - Secure token-based auth
• Rate Limiting - Redis-based distributed rate limiting
• Security - Helmet, CORS, input validation
• Logging - Morgan for HTTP request logging

📋 Prerequisites

• Node.js >= 18.0.0
• Docker & Docker Compose
• npm >= 9.0.0

🛠️ Installation

1. Clone the repository

git clone <your-repo-url>
cd node-rest-api-typescript

2. Install dependencies

npm install

3. Environment Setup

cp .env.example .env

Edit .env with your configuration:

# Application
NODE_ENV=development
PORT=3000

# Database
MONGODB_URI=mongodb://admin:password123@mongodb:27017/myapp?authSource=admin
MONGO_USERNAME=admin
MONGO_PASSWORD=password123

# Redis
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_PASSWORD=redis_secret_password

# JWT
JWT_SECRET=your-super-secret-jwt-key-change-in-production
JWT_EXPIRE=7d

🐳 Docker Setup

Development Mode

# Start all services (MongoDB, Redis, App, Admin UIs)
npm run docker:dev

# Or manually
docker-compose -f docker-compose.dev.yml up -d

# View logs
npm run docker:logs

Services available:

• API: http://localhost:3000
• MongoDB: mongodb://localhost:27017
• Redis: localhost:6379
• Mongo Express: http://localhost:8082
• Redis Commander: http://localhost:8081

Production Mode

# Build production image
npm run docker:build

# Start production services
npm run docker:prod

# Stop services
npm run docker:down

💻 Local Development (Without Docker)

1. Start MongoDB and Redis locally

# Using Homebrew (macOS)
brew install mongodb-community redis
brew services start mongodb-community
brew services start redis

# Or use Docker for just MongoDB and Redis
docker run -d -p 27017:27017 --name mongodb mongo:7.0
docker run -d -p 6379:6379 --name redis redis:7-alpine

2. Update .env for local development

MONGODB_URI=mongodb://localhost:27017/myapp
REDIS_HOST=localhost

3. Run the application

# Development mode with hot reload
npm run dev

# Build for production
npm run build

# Start production server
npm start

📁 Project Structure

src/
├── config/
│   ├── db.ts              # MongoDB connection
│   └── redis.ts           # Redis client & utilities
├── middleware/
│   ├── auth.middleware.ts
│   ├── cache.middleware.ts
│   ├── error.middleware.ts
│   └── redisRateLimiter.middleware.ts
├── models/
│   └── user.model.ts
├── routes/
│   ├── auth.routes.ts
│   └── user.routes.ts
├── services/
│   └── cache.service.ts   # Redis cache service
├── types/
│   └── express.d.ts
└── server.ts              # Application entry point

🔑 Redis Usage Examples

Caching

import { cacheService } from './services/cache.service';

// Cache user data
await cacheService.cacheUser(userId, userData, 3600);

// Get cached user
const user = await cacheService.getCachedUser(userId);

// Cache query results
await cacheService.cacheQuery('allUsers', users);

Rate Limiting

import { redisRateLimiter } from './middleware/redisRateLimiter.middleware';

// Custom rate limiter
app.use('/api/expensive', redisRateLimiter({
  windowMs: 60000,  // 1 minute
  max: 10,          // 10 requests per minute
}));

Session Management

// Create session
await cacheService.createSession(sessionId, userId, 86400);

// Get session
const session = await cacheService.getSession(sessionId);

// Delete session
await cacheService.deleteSession(sessionId);

🔒 API Endpoints

Authentication

• POST /api/auth/register - Register new user
• POST /api/auth/login - Login user
• POST /api/auth/logout - Logout user

Users

• GET /api/users - Get all users (cached)
• GET /api/users/:id - Get user by ID
• PUT /api/users/:id - Update user
• DELETE /api/users/:id - Delete user

Health Check

• GET /health - Server health status

📊 Monitoring

Redis Commander

Access Redis GUI at http://localhost:8081

• View all keys
• Monitor memory usage
• Execute Redis commands

Mongo Express

Access MongoDB GUI at http://localhost:8082

• Browse collections
• Run queries
• Manage documents

🧪 Testing

npm test

📝 Scripts

npm run dev          # Development mode with hot reload
npm run build        # Build TypeScript to JavaScript
npm start            # Start production server
npm run lint         # Lint code
npm run lint:fix     # Fix linting errors
npm run format       # Format code with Prettier

# Docker scripts
npm run docker:dev   # Start development environment
npm run docker:prod  # Start production environment
npm run docker:down  # Stop all containers
npm run docker:logs  # View container logs
npm run docker:build # Build Docker images

🚢 Deployment

Docker Production Deployment

1. Build the image:

docker build -t your-api:latest .

2. Push to registry:

docker tag your-api:latest your-registry/your-api:latest
docker push your-registry/your-api:latest

3. Deploy to server:

docker-compose -f docker-compose.yml up -d

Environment Variables for Production

Ensure these are set in production:

• Generate strong JWT_SECRET
• Use secure database passwords
• Set NODE_ENV=production
• Configure proper CORS_ORIGIN

🔐 Security Features

• ✅ Helmet.js for security headers
• ✅ CORS configuration
• ✅ Rate limiting with Redis
• ✅ JWT token authentication
• ✅ Password hashing with Argon2
• ✅ Input validation with Joi
• ✅ Token blacklisting for logout
• ✅ Graceful shutdown handling

📚 Technologies

• Node.js - Runtime environment
• TypeScript - Type safety
• Express - Web framework
• MongoDB - Database
• Mongoose - ODM
• Redis - Caching & sessions
• Docker - Containerization
• JWT - Authentication
• Argon2 - Password hashing

🤝 Contributing

1. Fork the repository
2. Create your feature branch
3. Commit your changes
4. Push to the branch
5. Create a Pull Request

📄 License

MIT

👨‍💻 Author

Your Name

---

Made with ❤️ and TypeScript