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

Создай REST API на Express.js для модели 'User' с полями: id (UUID), name (string, required), email (string, required, unique), createdAt (Date). Реализуй CRUD-операции: GET /users — список, GET /users/:id — один, POST /users — создание, PUT /users/:id — обновление, DELETE /users/:id — удаление. Используй Express Router, валидацию через Joi, возвращай HTTP-статусы: 200, 201, 400, 404, 500. Добавь middleware для логирования запросов. Код должен быть в одном файле app.js.

// app.js — результат работы промта
const express = require('express');
const Joi = require('joi');
const { v4: uuidv4 } = require('uuid');

const app = express();
app.use(express.json());

// Middleware логирования
app.use((req, res, next) => {
  console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
  next();
});

const users = [];

// Валидация схемы
const userSchema = Joi.object({
  name: Joi.string().required(),
  email: Joi.string().email().required()
});

// Маршруты
app.get('/users', (req, res) => {
  res.status(200).json(users);
});

app.post('/users', (req, res) => {
  const { error, value } = userSchema.validate(req.body);
  if (error) return res.status(400).json({ error: error.details[0].message });
  const newUser = { id: uuidv4(), ...value, createdAt: new Date() };
  users.push(newUser);
  res.status(201).json(newUser);
});

app.listen(3000, () => console.log('Server on port 3000'));

Напиши middleware для Express.js, который проверяет JWT-токен из заголовка 'Authorization: Bearer <token>'. Используй библиотеку jsonwebtoken. Если токен валидный — извлеки payload (id, role) и добавь в req.user. Если токен отсутствует, истёк или неверный — верни JSON-ответ с ошибкой и статусом 401. Секретный ключ храни в переменной окружения JWT_SECRET. Оберни в функцию authMiddleware.

// authMiddleware.js
const jwt = require('jsonwebtoken');

const authMiddleware = (req, res, next) => {
  const authHeader = req.headers.authorization;
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'Token not provided' });
  }
  const token = authHeader.split(' ')[1];
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = { id: decoded.id, role: decoded.role };
    next();
  } catch (err) {
    return res.status(401).json({ error: 'Invalid or expired token' });
  }
};

module.exports = authMiddleware;

Создай middleware authorizeRoles(...roles) для Express.js. Функция принимает массив допустимых ролей и возвращает middleware. Он проверяет req.user.role (должен быть установлен предыдущим authMiddleware). Если роль не входит в разрешённые — верни 403 Forbidden. Используй замыкание для передачи ролей.

// authorizeRoles.js
const authorizeRoles = (...roles) => {
  return (req, res, next) => {
    if (!req.user) {
      return res.status(401).json({ error: 'Not authenticated' });
    }
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({ error: 'Insufficient permissions' });
    }
    next();
  };
};

// Использование в маршруте
app.delete('/users/:id', authMiddleware, authorizeRoles('admin'), (req, res) => {
  // только admin может удалять
});

Напиши middleware для обработки ошибок в Express.js. Функция должна принимать 4 параметра: (err, req, res, next). Логируй ошибку в консоль с меткой времени. Если err имеет статус-код (err.statusCode) — используй его, иначе 500. Верни JSON: { error: err.message, status: err.statusCode || 500 }. В режиме разработки (NODE_ENV=development) добавь stack trace. Подключи middleware после всех маршрутов.

// errorHandler.js
const errorHandler = (err, req, res, next) => {
  console.error(`[${new Date().toISOString()}] Error:`, err.message);
  const statusCode = err.statusCode || 500;
  const response = {
    error: err.message || 'Internal Server Error',
    status: statusCode
  };
  if (process.env.NODE_ENV === 'development') {
    response.stack = err.stack;
  }
  res.status(statusCode).json(response);
};

// В app.js — после всех маршрутов
app.use(errorHandler);

Создай сервер на Express.js с Socket.IO. Настрой CORS для localhost:3000. Реализуй события: 'connection' — логируем id сокета, 'message' — принимает {user, text} и отправляет обратно всем клиентам через io.emit('message', data). Добавь обработку отключения ('disconnect'). Используй библиотеку socket.io.

// server.js
const express = require('express');
const http = require('http');
const { Server } = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = new Server(server, {
  cors: { origin: 'http://localhost:3000', methods: ['GET', 'POST'] }
});

io.on('connection', (socket) => {
  console.log('User connected:', socket.id);
  socket.on('message', (data) => {
    io.emit('message', { user: data.user, text: data.text, timestamp: new Date() });
  });
  socket.on('disconnect', () => console.log('User disconnected:', socket.id));
});

server.listen(4000, () => console.log('WebSocket on 4000'));

Напиши универсальную middleware-функцию validate(schema, property = 'body') для Express.js. Она принимает схему Joi и свойство объекта req (body, query, params). Валидирует соответствующую часть запроса. Если ошибка — верни 400 с сообщением об ошибке. Если успех — замени req[property] на валидированное значение (через schema.validate с опцией stripUnknown).

// validate.js
const validate = (schema, property = 'body') => {
  return (req, res, next) => {
    const { error, value } = schema.validate(req[property], { stripUnknown: true });
    if (error) {
      return res.status(400).json({ error: error.details[0].message });
    }
    req[property] = value;
    next();
  };
};

// Использование
app.post('/users', validate(userSchema, 'body'), (req, res) => {
  // req.body уже валидирован
});

Настрой rate limiting в Express.js с помощью express-rate-limit. Создай два лимитера: globalLimiter — 100 запросов за 15 минут на IP, и authLimiter — 5 попыток входа за 15 минут. GlobalLimiter применяй ко всем маршрутам, authLimiter — только к POST /login. При превышении лимита возвращай 429 Too Many Requests с JSON-сообщением.

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

const globalLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 минут
  max: 100,
  message: { error: 'Too many requests, please try again later' }
});

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

app.use(globalLimiter);
app.post('/login', authLimiter, loginHandler);

Настрой подключение к MongoDB через Mongoose в Express.js. Используй переменную окружения MONGO_URI. Определи схему User с полями: name, email (уникальный), password (хэшированный), role (enum: user, admin), timestamps. Создай модель. Напиши функцию connectDB, которая подключается и логирует успех или ошибку. Экспортируй модель и функцию.

// db.js
const mongoose = require('mongoose');

const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGO_URI);
    console.log('MongoDB connected');
  } catch (err) {
    console.error('MongoDB error:', err.message);
    process.exit(1);
  }
};

const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
  role: { type: String, enum: ['user', 'admin'], default: 'user' }
}, { timestamps: true });

const User = mongoose.model('User', userSchema);

module.exports = { connectDB, User };

Создай middleware для загрузки файлов с помощью multer. Настрой хранилище diskStorage в папку 'uploads/'. Добавь фильтр файлов: только изображения (jpeg, png, gif) размером не более 5 MB. При ошибке типа файла верни 400 с сообщением. Создай маршрут POST /upload, который принимает поле 'image' и возвращает URL загруженного файла.

const multer = require('multer');
const path = require('path');

const storage = multer.diskStorage({
  destination: './uploads/',
  filename: (req, file, cb) => {
    cb(null, Date.now() + path.extname(file.originalname));
  }
});

const fileFilter = (req, file, cb) => {
  const allowedTypes = ['image/jpeg', 'image/png', 'image/gif'];
  if (allowedTypes.includes(file.mimetype)) {
    cb(null, true);
  } else {
    cb(new Error('Only images allowed'), false);
  }
};

const upload = multer({
  storage,
  fileFilter,
  limits: { fileSize: 5 * 1024 * 1024 } // 5MB
});

app.post('/upload', upload.single('image'), (req, res) => {
  res.json({ url: `/uploads/${req.file.filename}` });
});

Настрой логирование с Winston в Express.js. Создай логгер с двумя транспортами: console (формат: цветной, с меткой времени) и file (в файл combined.log — JSON-формат). Определи три уровня: info, warn, error. Создай middleware, который логирует каждый запрос (метод, URL, статус, длительность). Логируй ошибки через errorHandler.

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.Console({ format: winston.format.cli() }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

// Middleware логирования запросов
app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    logger.info(`${req.method} ${req.url} ${res.statusCode} ${Date.now() - start}ms`);
  });
  next();
});