Category: 01. Express Js

For real-time communication, you can use WebSockets with the ws library or socket.io.

a. Install Socket.IO

npm install socket.io

b. Set Up Socket.IO

In app.js:

const http = require('http');
const socketIo = require('socket.io');
const server = http.createServer(app);
const io = socketIo(server);

io.on('connection', (socket) => {
  console.log('A user connected');
  socket.on('disconnect', () => {
console.log('User disconnected');
  });
});

server.listen(port, () => {
  console.log(Server is running on http://localhost:${port});
});

Handle file uploads using middleware like multer.

a. Install Multer

npm install multer

b. Configure Multer

In app.js:

const multer = require('multer');
const upload = multer({ dest: 'uploads/' });

app.post('/upload', upload.single('file'), (req, res) => {
  res.send('File uploaded successfully');
});

Here, dest specifies the directory where files will be stored, and upload.single('file') handles single file uploads.

Securing your Express application is crucial to prevent common vulnerabilities. Here are some best practices and tools to help with that.

a. Helmet

Helmet helps secure your Express apps by setting various HTTP headers.

npm install helmet

In your app.js:

const helmet = require('helmet');
app.use(helmet());

b. Rate Limiting

Limit the number of requests from a single IP to prevent abuse.

npm install rate-limit

In your app.js:

const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100 // Limit each IP to 100 requests per windowMs
});

app.use(limiter);

c. CORS (Cross-Origin Resource Sharing)

Control how your resources are shared across different origins.

npm install cors

In your app.js:

const cors = require('cors');
app.use(cors());

You can configure CORS to allow or block specific origins:

app.use(cors({
  origin: 'https://example.com'
}));

Testing is crucial for ensuring your application works correctly.

a. Install Testing Libraries

For unit and integration tests, you might use libraries like Mocha and Chai.

npm install mocha chai supertest

b. Write Tests

Create a test directory and a test file, e.g., test/app.test.js:

const request = require('supertest');
const app = require('../app'); // Your Express app

describe('GET /', () => {
  it('should return Hello World', async () => {
const response = await request(app).get('/');
expect(response.text).toBe('Hello World!');
  });
});

c. Run Tests

Add a test script in package.json:

"scripts": {
  "test": "mocha"
}

Run your tests:

bashCopy codenpm test

Use environment variables to manage configuration, like database connection strings, API keys, etc.

a. Install dotenv

codenpm install dotenv

b. Create a .env File

PORT=3000
MONGODB_URI=mongodb://localhost/mydatabase

c. Use Environment Variables

In app.js:

require('dotenv').config();

const port = process.env.PORT || 3000;
const mongooseUri = process.env.MONGODB_URI;

mongoose.connect(mongooseUri, {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

Express can manage sessions using middleware like express-session.

a. Install express-session

codenpm install express-session

b. Configure Sessions

const session = require('express-session');

app.use(session({
  secret: 'your-secret-key',
  resave: false,
  saveUninitialized: true,
  cookie: { secure: false } // Set to true if using HTTPS
}));

c. Use Sessions

app.get('/login', (req, res) => {
  req.session.user = { id: 1, name: 'John Doe' };
  res.send('User logged in');
});

app.get('/profile', (req, res) => {
  if (req.session.user) {
res.send(Welcome ${req.session.user.name});
  } else {
res.send('Please log in');
  }
});

Query parameters can be accessed through req.query. For example:

app.get('/search', (req, res) => {
  const query = req.query.q;
  res.send(Search results for: ${query});
});

You can access http://localhost:3000/search?q=express to see the results.

Express can render dynamic HTML pages using template engines like EJS, Pug, or Handlebars.

a. Installing a Template Engine

For EJS, install it with npm:

npm install ejs

Set up EJS in app.js:

app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));

Create a views directory and add an index.ejs file:

<!DOCTYPE html>
<html>
<head>
  <title><%= title %></title>
</head>
<body>
  <h1>Hello, <%= name %>!</h1>
</body>
</html>

Render the template in your route:

app.get('/', (req, res) => {
  res.render('index', { title: 'Home Page', name: 'World' });
});

Express supports modular routing, which can help organize your code better.

a. Creating Router Modules

You can create a separate file for your routes. For example, create a file named userRoutes.js:

const express = require('express');
const router = express.Router();

// Define routes
router.get('/', (req, res) => {
  res.send('User List');
});

router.get('/:id', (req, res) => {
  const userId = req.params.id;
  res.send(User ID: ${userId});
});

module.exports = router;

In your app.js:

const userRoutes = require('./userRoutes');
app.use('/users', userRoutes);

Middleware functions are a core feature of Express.js. They can be used to handle requests, modify request and response objects, end requests, and call the next middleware function in the stack.

a. Creating Custom Middleware

Here’s an example of custom middleware that logs the request method and URL:

const logger = (req, res, next) => {
  console.log(${req.method} ${req.url});
  next(); // Call the next middleware or route handler
};

app.use(logger); // Apply middleware globally

b. Error Handling Middleware

In Express, error handling middleware functions have four arguments: err, req, res, and next. Here’s how you can use it:

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something went wrong!');
});