12 промтов для Node.js и Express: API, middleware, авторизация

Создай структуру Express-приложения на Node.js с поддержкой маршрутов для пользователей (GET, POST, PUT, DELETE). Используй ES6-синтаксис, модули, обработку ошибок через middleware. Включи пример конфигурации порта и CORS.

import express from 'express';
import cors from 'cors';
import userRoutes from './routes/users.js';

const app = express();
const PORT = process.env.PORT || 3000;

app.use(cors());
app.use(express.json());

app.use('/api/users', userRoutes);

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

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Напиши Express-маршруты для CRUD операций с коллекцией 'tasks'. Каждый маршрут должен включать валидацию полей (title — строка от 3 до 100 символов, completed — булево). Используй express-validator. Верни код с комментариями.

import { Router } from 'express';
import { body, validationResult } from 'express-validator';

const router = Router();

let tasks = [];

router.get('/', (req, res) => {
  res.json(tasks);
});

router.post(
  '/',
  [
    body('title').isString().isLength({ min: 3, max: 100 }),
    body('completed').isBoolean()
  ],
  (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }
    const task = { id: Date.now(), ...req.body };
    tasks.push(task);
    res.status(201).json(task);
  }
);

export default router;

Создай middleware для Express, которое записывает в консоль метод запроса, URL и время обработки в миллисекундах. Используй process.hrtime для точности.

const requestLogger = (req, res, next) => {
  const start = process.hrtime();
  res.on('finish', () => {
    const duration = process.hrtime(start);
    const ms = duration[0] * 1000 + duration[1] / 1e6;
    console.log(`${req.method} ${req.originalUrl} - ${ms.toFixed(2)}ms`);
  });
  next();
};

app.use(requestLogger);

Напиши класс AppError с полями message и statusCode, и middleware, которое перехватывает все ошибки и возвращает JSON с соответствующим HTTP-статусом. Включи поддержку 404, 400 и 500.

class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
  }
}

const errorHandler = (err, req, res, next) => {
  const statusCode = err.statusCode || 500;
  res.status(statusCode).json({
    status: 'error',
    message: err.message || 'Internal Server Error'
  });
};

app.use(errorHandler);

Реализуй на Express аутентификацию с JWT: маршрут /login возвращает access-токен (15 минут) и refresh-токен (7 дней). Маршрут /refresh обновляет access-токен. Используй jsonwebtoken и bcrypt для хеширования паролей. Храни refresh-токены в памяти (массив).

import jwt from 'jsonwebtoken';
import bcrypt from 'bcrypt';

const users = [{ id: 1, email: 'user@test.com', password: '$2b$10$...' }];
let refreshTokens = [];

const ACCESS_SECRET = 'access-secret';
const REFRESH_SECRET = 'refresh-secret';

router.post('/login', async (req, res) => {
  const { email, password } = req.body;
  const user = users.find(u => u.email === email);
  if (!user || !(await bcrypt.compare(password, user.password))) {
    return res.status(401).json({ message: 'Invalid credentials' });
  }
  const accessToken = jwt.sign({ id: user.id }, ACCESS_SECRET, { expiresIn: '15m' });
  const refreshToken = jwt.sign({ id: user.id }, REFRESH_SECRET, { expiresIn: '7d' });
  refreshTokens.push(refreshToken);
  res.json({ accessToken, refreshToken });
});

router.post('/refresh', (req, res) => {
  const { refreshToken } = req.body;
  if (!refreshToken || !refreshTokens.includes(refreshToken)) {
    return res.status(403).json({ message: 'Invalid refresh token' });
  }
  jwt.verify(refreshToken, REFRESH_SECRET, (err, user) => {
    if (err) return res.status(403).json({ message: 'Token expired' });
    const accessToken = jwt.sign({ id: user.id }, ACCESS_SECRET, { expiresIn: '15m' });
    res.json({ accessToken });
  });
});

Напиши middleware authorize(roles) для Express, которое принимает массив допустимых ролей. Предположи, что req.user содержит объект с полем role. Если роль не подходит — верни 403.

const authorize = (...roles) => {
  return (req, res, next) => {
    if (!req.user || !roles.includes(req.user.role)) {
      return res.status(403).json({ message: 'Forbidden' });
    }
    next();
  };
};

// Использование
app.delete('/api/users/:id', authenticate, authorize('admin'), deleteUser);

Настрой стратегию Google OAuth 2.0 с Passport.js для Express. Включи маршруты /auth/google и /auth/google/callback. После успешной аутентификации создавай JWT-токен. Используй переменные окружения для clientID и clientSecret.

import passport from 'passport';
import { Strategy as GoogleStrategy } from 'passport-google-oauth20';

passport.use(
  new GoogleStrategy(
    {
      clientID: process.env.GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
      callbackURL: '/auth/google/callback'
    },
    (accessToken, refreshToken, profile, done) => {
      // Найти или создать пользователя в БД
      done(null, profile);
    }
  )
);

router.get('/auth/google', passport.authenticate('google', { scope: ['profile', 'email'] }));
router.get('/auth/google/callback', passport.authenticate('google', { session: false }), (req, res) => {
  const token = jwt.sign({ id: req.user.id }, process.env.JWT_SECRET);
  res.json({ token });
});

Реализуй WebSocket-сервер с Socket.IO на базе Express. Поддержи комнаты: пользователь может войти в комнату, отправлять сообщения только в неё. На стороне сервера логируй события подключения и отключения.

import { Server } from 'socket.io';

const io = new Server(httpServer);

io.on('connection', (socket) => {
  console.log(`User connected: ${socket.id}`);

  socket.on('join-room', (room) => {
    socket.join(room);
    console.log(`${socket.id} joined room ${room}`);
  });

  socket.on('chat-message', ({ room, message }) => {
    io.to(room).emit('chat-message', { user: socket.id, message });
  });

  socket.on('disconnect', () => {
    console.log(`User disconnected: ${socket.id}`);
  });
});

Настрой middleware для Socket.IO, которое проверяет JWT-токен из query-параметра при подключении. Если токен невалидный — отклони соединение с ошибкой.

import jwt from 'jsonwebtoken';

io.use((socket, next) => {
  const token = socket.handshake.query.token;
  if (!token) {
    return next(new Error('Authentication error'));
  }
  jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
    if (err) return next(new Error('Invalid token'));
    socket.user = decoded;
    next();
  });
});

io.on('connection', (socket) => {
  console.log(`Authenticated user ${socket.user.id}`);
});

Установи rate limiting для всех маршрутов /api/ с лимитом 100 запросов в минуту. Для маршрута /api/auth/login — 10 запросов в минуту. Используй express-rate-limit.

import rateLimit from 'express-rate-limit';

const globalLimiter = rateLimit({
  windowMs: 60 * 1000,
  max: 100,
  message: 'Too many requests, please try again later.'
});

const authLimiter = rateLimit({
  windowMs: 60 * 1000,
  max: 10,
  message: 'Too many login attempts.'
});

app.use('/api/', globalLimiter);
app.use('/api/auth/login', authLimiter);

Настрой helmet для Express (включи CSP, X-Frame-Options, X-Content-Type-Options) и csurf для защиты от CSRF. Верни код с пояснениями.

import helmet from 'helmet';
import csrf from 'csurf';

app.use(helmet());
app.use(csrf({ cookie: true }));

// Маршрут для получения CSRF-токена
app.get('/api/csrf-token', (req, res) => {
  res.json({ csrfToken: req.csrfToken() });
});