**SERVER:**
```
const express = require('express');
const app = express();
// Middleware to parse incoming JSON requests
app.use(express.json());
// Custom middleware to log request method and URL
app.use((req, res, next) => {
console.log(`${req.method} ${req.url}`);
next(); // Proceed to the next middleware or route
});
// Basic GET route that returns a message
app.get('/', (req, res) => res.send('Server is running!'));
// Error Handling Middleware to catch and handle errors in one place
app.use((err, req, res, next) => {
console.error(err.message);
res.status(500).json({ error: 'Internal Server Error' });
});
// Start Server on defined PORT or fallback to 5000
const PORT = process.env.PORT || 5000;
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));
```
**ERROR HANDLING:**
```
const asyncHandler = fn => (req, res, next) =>
Promise.resolve(fn(req, res, next)).catch(next);
// Example Usage in Route
app.get('/data', asyncHandler(async (req, res) => {
const data = await fetchDataFromDB();
res.json(data);
}));
```
**MONGO DATABASE:**
```
const mongoose = require('mongoose');
const connectDB = async () => {
try {
await mongoose.connect(process.env.MONGO_URI, {
useNewUrlParser: true,
useUnifiedTopology: true,
});
console.log('MongoDB Connected');
} catch (error) {
console.error(error.message);
process.exit(1); // Exit process with failure
}
};
module.exports = connectDB;
// Usage in main file
// const connectDB = require('./db');
// connectDB();
```
**PREVENT DOS ATTACK:**
```
const rateLimit = require('express-rate-limit');
const limiter = rateLimit({
windowMs: 15 * 60 * 1000, // 15 minutes
max: 100, // Limit each IP to 100 requests per window
message: "Too many requests from this IP, please try again later."
});
app.use('/api', limiter);
```
**AUTHENTICATE API ROUTE:**
```
const jwt = require('jsonwebtoken');
const authMiddleware = (req, res, next) => {
const token = req.header('Authorization');
if (!token) return res.status(401).json({ message: 'Access Denied' });
try {
const decoded = jwt.verify(token.split(' ')[1], process.env.JWT_SECRET);
req.user = decoded; // Attach user info to request
next();
} catch (error) {
res.status(400).json({ message: 'Invalid Token' });
}
};
module.exports = authMiddleware;
// Usage in routes:
// app.get('/protected', authMiddleware, (req, res) => res.json({ user: req.user }));
```
**FILE UPLOAD:**
```
const multer = require('multer');
const storage = multer.diskStorage({
destination: (req, file, cb) => cb(null, 'uploads/'), // Define where files are stored
filename: (req, file, cb) => cb(null, `${Date.now()}-${file.originalname}`) // Rename file
});
const upload = multer({ storage });
app.post('/upload', upload.single('file'), (req, res) => {
res.json({ filePath: `/uploads/${req.file.filename}` });
});
```
**PREVENT SERVER CRASH:**
```
process.on('SIGINT', async () => {
console.log('Shutting down server...');
await client.quit();
process.exit(0);
});
```
**PROCESSING LARGE CPU RUNTIME - background TASKS:**
```
const Queue = require('bull');
const emailQueue = new Queue('emailQueue');
emailQueue.process(async (job) => {
console.log(`Sending email to ${job.data.email}`);
await sendEmail(job.data.email);
});
const addToQueue = (email) => {
emailQueue.add({ email });
};
// Usage
addToQueue('
[email protected]');
```
**WEB-SOCKET:**
```
const http = require('http');
const socketIo = require('socket.io');
const server = http.createServer(app);
const io = socketIo(server);
io.on('connection', (socket) => {
console.log('New client connected');
socket.on('message', (data) => {
io.emit('message', data);
});
socket.on('disconnect', () => console.log('Client disconnected'));
});
server.listen(5000, () => console.log('WebSocket server running on port 5000'));
```
**CACHING:**
```
const redis = require('redis');
const client = redis.createClient();
const cache = (req, res, next) => {
const key = req.originalUrl;
client.get(key, (err, data) => {
if (err) throw err;
if (data) return res.json(JSON.parse(data));
next();
});
};
app.get('/data', cache, async (req, res) => {
const data = await fetchFromDB();
client.setex(req.originalUrl, 3600, JSON.stringify(data)); // Cache for 1 hour
res.json(data);
});
```