Десять Middleware Node.js для эффективного кодинга

const express = require('express');
const app = express();
 
// Простейший middleware
app.use((req, res, next) => {
  console.log('Время запроса:', Date.now());
  next(); // Не забывайте вызывать next(), иначе запрос зависнет!
});
 
app.get('/', (req, res) => {
  res.send('Привет, мир!');
});
 
app.listen(3000);

app.use(async (req, res, next) => {
  try {
    const result = await someAsyncOperation();
    req.result = result;
    next();
  } catch (error) {
    next(error); // Передаем ошибку Express
  }
});

const middleware = require('./my-middleware');
const httpMocks = require('node-mocks-http');
 
test('middleware добавляет поле user к запросу', () => {
  const req = httpMocks.createRequest();
  const res = httpMocks.createResponse();
  const next = jest.fn();
  
  middleware(req, res, next);
  
  expect(next).toHaveBeenCalled();
  expect(req.user).toBeDefined();
});

const express = require('express');
const helmet = require('helmet');
const app = express();
 
// Применяем Helmet со стандартными настройками
app.use(helmet());
 
// Остальной код приложения

app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      scriptSrc: ["'self'", "trusted-cdn.com"],
      styleSrc: ["'self'", "'unsafe-inline'", "trusted-cdn.com"],
      imgSrc: ["'self'", "data:", "images.cdn.com"],
      connectSrc: ["'self'", "api.myservice.com"]
    }
  },
  crossOriginEmbedderPolicy: false,
  // Другие настройки
}));

app.use(helmet.contentSecurityPolicy({
  directives: {
    defaultSrc: ["'self'"],
    scriptSrc: ["'self'", "'unsafe-eval'"], // Нужно для некоторых бандлеров
    styleSrc: ["'self'", "'unsafe-inline'"], // Для стилей React-компонентов
    imgSrc: ["'self'", "data:", "blob:"],
    connectSrc: ["'self'", "api.mycompany.com"], // Ваш API
    fontSrc: ["'self'", "fonts.gstatic.com"],
    objectSrc: ["'none'"],
    upgradeInsecureRequests: [],
  },
}));

app.use(helmet.contentSecurityPolicy({
  directives: {
    // ... ваши обычные директивы ...
    reportUri: '/csp-violation-report'
  },
  reportOnly: true // Включает режим "только отчеты"
}));
 
// Эндпоинт для сбора отчетов
app.post('/csp-violation-report', (req, res) => {
  console.log('CSP нарушение:', req.body);
  res.status(204).end();
});

const morgan = require('morgan');
app.use(morgan('dev')); // Формат 'dev' для цветного вывода в консоль

GET /api/users 200 54.721 ms - 1293
POST /api/auth 401 32.409 ms - 35

if (process.env.NODE_ENV === 'production') {
  app.use(morgan('combined')); // Расширенный формат для продакшена
} else {
  app.use(morgan('dev')); // Компактный формат для разработки
}

app.use(morgan(':method :url :status :res[content-length] - :response-time ms - :remote-addr - :user-agent'));

const fs = require('fs');
const accessLogStream = fs.createWriteStream(path.join(__dirname, 'access.log'), { flags: 'a' });
app.use(morgan('combined', { stream: accessLogStream }));

const winston = require('winston');
 
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});
 
// В разработке также выводим в консоль
if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

const logger = winston.createLogger({
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  // остальные настройки
});

const { ElasticsearchTransport } = require('winston-elasticsearch');
 
const logger = winston.createLogger({
  transports: [
    new ElasticsearchTransport({
      level: 'info',
      index: 'app-logs',
      clientOpts: { node: 'http://localhost:9200' }
    })
  ]
});

// Обработчик ошибок для Express
app.use((err, req, res, next) => {
  logger.error({
    message: err.message,
    stack: err.stack,
    method: req.method,
    path: req.path,
    ip: req.ip,
    user: req.user ? req.user.id : 'anonymous'
  });
  
  res.status(500).json({ error: 'Что-то пошло не так' });
});

const Sentry = require('@sentry/node');
Sentry.init({ dsn: 'ваш-sentry-dsn' });
 
// Интеграция с Winston
const SentryTransport = require('winston-transport-sentry-node').default;
logger.add(new SentryTransport({
  sentry: Sentry,
  level: 'error'
}));

const compression = require('compression');
const express = require('express');
const app = express();
 
// Включаем сжатие для всех ответов
app.use(compression());
 
app.get('/api/data', (req, res) => {
  // Данные будут автоматически сжаты перед отправкой
  res.json(bigDataObject);
});

app.use(compression({
  level: 6,         // Уровень сжатия (0-9, по умолчанию 6)
  threshold: 1024,  // Минимальный размер для сжатия (в байтах)
  filter: (req, res) => {
    // Не сжимать уже сжатые форматы (изображения, видео и т.д.)
    const contentType = res.getHeader('Content-Type');
    return /text|json|javascript|css/.test(contentType);
  }
}));

const shrinkRay = require('shrink-ray-current');
app.use(shrinkRay());

const compression = require('compression');
const responseCache = new Map();
 
app.use((req, res, next) => {
  const originalSend = res.send;
  
  res.send = function(body) {
    const key = req.url;
    if (responseCache.has(key)) {
      res.setHeader('Content-Encoding', 'gzip');
      return originalSend.call(this, responseCache.get(key));
    }
    
    // Продолжаем нормальную обработку
    return originalSend.call(this, body);
  };
  
  next();
});
 
app.use(compression({
  level: 6,
  threshold: 1024,
  filter: (req, res) => {
    const key = req.url;
    // Кешируем сжатые ответы для будущих запросов
    const originalWrite = res.write;
    const chunks = [];
    
    res.write = function(chunk) {
      chunks.push(chunk);
      return originalWrite.apply(this, arguments);
    };
    
    const originalEnd = res.end;
    res.end = function(chunk) {
      if (chunk) chunks.push(chunk);
      responseCache.set(key, Buffer.concat(chunks));
      return originalEnd.apply(this, arguments);
    };
    
    return true;
  }
}));

const { createGzip } = require('zlib');
const { pipeline } = require('stream');
const fs = require('fs');
 
app.get('/large-file', (req, res) => {
  const fileStream = fs.createReadStream('path/to/large-file.json');
  const gzip = createGzip();
  
  res.setHeader('Content-Encoding', 'gzip');
  pipeline(fileStream, gzip, res, (err) => {
    if (err) {
      console.error('Pipeline failed', err);
    }
  });
});

const cors = require('cors');
const app = express();
 
// Базовое использование - разрешает запросы со всех доменов
app.use(cors());
 
// Более ограниченная настройка
app.use(cors({
  origin: 'https://myapp.com', // разрешаем только этот домен
  methods: ['GET', 'POST'],    // разрешаем только эти методы
  allowedHeaders: ['Content-Type', 'Authorization'] // разрешаем эти заголовки
}));

const whitelist = ['https://app.mycompany.com', 'https://admin.mycompany.com'];
 
app.use(cors({
  origin: function(origin, callback) {
    // Проверяем, находится ли источник в белом списке
    if (whitelist.indexOf(origin) !== -1 || !origin) {
      callback(null, true);
    } else {
      callback(new Error('Доступ запрещен политикой CORS'));
    }
  },
  credentials: true // важно для передачи cookie и аутентификации
}));

const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
 
// Инициализация Passport
app.use(passport.initialize());
 
// Настройка локальной стратегии (логин/пароль)
passport.use(new LocalStrategy(
  function(username, password, done) {
    User.findOne({ username: username }, function(err, user) {
      if (err) { return done(err); }
      if (!user) { return done(null, false); }
      if (!user.verifyPassword(password)) { return done(null, false); }
      return done(null, user);
    });
  }
));

// Маршрут для входа
app.post('/login', passport.authenticate('local', {
  successRedirect: '/dashboard',
  failureRedirect: '/login',
  failureFlash: true // если используете connect-flash
}));
 
// Защита маршрута
app.get('/profile', isAuthenticated, (req, res) => {
  res.json(req.user);
});
 
// Middleware для проверки аутентификации
function isAuthenticated(req, res, next) {
  if (req.isAuthenticated()) {
    return next();
  }
  res.redirect('/login');
}

const JwtStrategy = require('passport-jwt').Strategy;
const ExtractJwt = require('passport-jwt').ExtractJwt;
 
const jwtOptions = {
  jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
  secretOrKey: 'ваш-секретный-ключ'
};
 
passport.use(new JwtStrategy(jwtOptions, (jwtPayload, done) => {
  // Проверяем пользователя по данным из токена
  User.findById(jwtPayload.sub, (err, user) => {
    if (err) return done(err, false);
    if (user) return done(null, user);
    return done(null, false);
  });
}));

const jwt = require('jsonwebtoken');
 
app.post('/api/login', (req, res) => {
  // Проверка учетных данных
  User.findOne({ username: req.body.username }, (err, user) => {
    if (err || !user || !user.verifyPassword(req.body.password)) {
      return res.status(401).json({ message: 'Неверные учетные данные' });
    }
    
    // Создаем JWT
    const token = jwt.sign(
      { sub: user._id, role: user.role },
      'ваш-секретный-ключ',
      { expiresIn: '1h' }
    );
    
    res.json({ token });
  });
});

// Микросервис "Товары" проверяет JWT из запроса
app.get('/api/products', passport.authenticate('jwt', { session: false }), (req, res) => {
  // JWT прошел проверку, пользователь доступен в req.user
  Product.find({ userId: req.user._id }, (err, products) => {
    res.json(products);
  });
});

function getServiceToken() {
  return jwt.sign(
    { service: 'order-service', permissions: ['read:products', 'write:orders'] },
    process.env.SERVICE_SECRET,
    { expiresIn: '1h' }
  );
}
 
// Вызов микросервиса "Товары" из микросервиса "Заказы"
axios.get('http://product-service/api/products/inventory', {
  headers: {
    Authorization: [INLINE]Bearer ${getServiceToken()}[/INLINE]
  }
})
.then(response => processInventory(response.data))
.catch(error => handleError(error));

app.post('/api/token/refresh', (req, res) => {
  const { refreshToken } = req.body;
  
  if (!refreshToken) return res.status(401).json({ message: 'Refresh токен не предоставлен' });
  
  // Проверяем refresh токен в базе данных
  RefreshToken.findOne({ token: refreshToken }, (err, token) => {
    if (err || !token) return res.status(401).json({ message: 'Недействительный токен' });
    
    // Проверяем не отозван ли токен
    if (token.revoked) return res.status(401).json({ message: 'Токен отозван' });
    
    // Создаем новый access токен
    const user = token.user;
    const newAccessToken = jwt.sign(
      { sub: user._id, role: user.role },
      process.env.JWT_SECRET,
      { expiresIn: '1h' }
    );
    
    res.json({ token: newAccessToken });
  });
});

const rateLimit = require('express-rate-limit');
 
const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 минут
  max: 100, // 100 запросов с одного IP
  message: 'Слишком много запросов с вашего IP, попробуйте позже'
});
 
// Применяем к API маршрутам
app.use('/api/', apiLimiter);
 
// Отдельный лимитер для авторизации (защита от брутфорса)
const loginLimiter = rateLimit({
  windowMs: 60 * 60 * 1000, // 1 час
  max: 5, // 5 попыток в час
  message: 'Слишком много неудачных попыток входа, попробуйте позже'
});
 
app.post('/login', loginLimiter, authController.login);

const redis = require('redis');
const { RateLimiterRedis } = require('rate-limiter-flexible');
 
const redisClient = redis.createClient({
  host: process.env.REDIS_HOST,
  port: process.env.REDIS_PORT,
  enable_offline_queue: false
});
 
const rateLimiter = new RateLimiterRedis({
  storeClient: redisClient,
  keyPrefix: 'middleware',
  points: 10, // 10 запросов
  duration: 1, // за 1 секунду
});
 
app.use(async (req, res, next) => {
  try {
    await rateLimiter.consume(req.ip);
    next();
  } catch (err) {
    res.status(429).send('Слишком много запросов');
  }
});

const { body, validationResult } = require('express-validator');
 
app.post('/user', [
  body('email').isEmail().normalizeEmail(),
  body('password').isLength({ min: 8 }).withMessage('Пароль должен содержать минимум 8 символов'),
  body('name').not().isEmpty().trim().escape()
], (req, res) => {
  // Проверяем результаты валидации
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }
  
  // Если всё ок, продолжаем
  createUser(req.body);
  res.status(201).send('Пользователь создан');
});

const Joi = require('joi');
 
const orderSchema = Joi.object({
  customer: Joi.object({
    name: Joi.string().required(),
    email: Joi.string().email().required(),
    address: Joi.string().min(10)
  }),
  items: Joi.array().items(
    Joi.object({
      productId: Joi.string().required(),
      quantity: Joi.number().integer().min(1).required(),
      price: Joi.number().precision(2).positive()
    })
  ).min(1).required(),
  payment: Joi.object({
    method: Joi.string().valid('card', 'paypal', 'cash').required(),
    // Условная валидация - если метод card, то нужны доп. поля
    cardNumber: Joi.when('method', {
      is: 'card',
      then: Joi.string().required(),
      otherwise: Joi.forbidden()
    })
  })
});
 
app.post('/order', (req, res) => {
  const { error, value } = orderSchema.validate(req.body);
  
  if (error) {
    return res.status(400).json({ error: error.details[0].message });
  }
  
  // Данные прошли валидацию и доступны в value
  processOrder(value);
  res.status(201).send('Заказ принят');
});

const multer = require('multer');
 
// Настраиваем хранилище
const storage = multer.diskStorage({
  destination: function(req, file, cb) {
    cb(null, './uploads/'); // папка для сохранения
  },
  filename: function(req, file, cb) {
    // создаем уникальное имя файла
    cb(null, Date.now() + '-' + file.originalname);
  }
});
 
// Настраиваем фильтр файлов
const fileFilter = (req, file, cb) => {
  // Принимаем только изображения
  if (file.mimetype.startsWith('image/')) {
    cb(null, true);
  } else {
    cb(new Error('Недопустимый тип файла!'), false);
  }
};
 
const upload = multer({ 
  storage: storage,
  limits: {
    fileSize: 1024 * 1024 * 5 // 5MB макс размер
  },
  fileFilter: fileFilter
});
 
// Загрузка одного файла
app.post('/upload', upload.single('profileImage'), (req, res) => {
  // req.file содержит информацию о загруженном файле
  // req.body содержит текстовые поля формы
  res.json({
    path: req.file.path,
    message: 'Файл успешно загружен'
  });
});
 
// Загрузка нескольких файлов
app.post('/upload-multiple', upload.array('gallery', 10), (req, res) => {
  res.json({
    files: req.files,
    message: [INLINE]Загружено ${req.files.length} файлов[/INLINE]
  });
});

// Старый способ (до Express 4.16)
const bodyParser = require('body-parser');
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
 
// Новый способ (Express 4.16+)
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

const storage = multer.memoryStorage();
const upload = multer({ storage });
 
app.post('/upload-video', upload.single('video'), (req, res) => {
  const fileBuffer = req.file.buffer;
  
  // Создаем поток для записи
  const writeStream = fs.createWriteStream(`./uploads/${req.file.originalname}`);
  
  // Преобразуем буфер в поток и пишем
  const readStream = new Readable();
  readStream.push(fileBuffer);
  readStream.push(null);
  
  readStream.pipe(writeStream);
  
  writeStream.on('finish', () => {
    res.json({ message: 'Видео успешно загружено' });
  });
});

const aws = require('aws-sdk');
const multerS3 = require('multer-s3');
 
const s3 = new aws.S3({ /* настройки */ });
 
const upload = multer({
  storage: multerS3({
    s3: s3,
    bucket: 'my-bucket',
    contentType: multerS3.AUTO_CONTENT_TYPE,
    key: function (req, file, cb) {
      cb(null, Date.now().toString() + '-' + file.originalname);
    }
  })
});
 
app.post('/upload', upload.single('file'), (req, res) => {
  res.json({ url: req.file.location });
});

app.post('/upload-chunk', (req, res) => {
  const { index, total, fileId } = req.query;
  const chunkFolder = path.join(__dirname, 'chunks', fileId);
  
  // Создаем папку для чанков, если её нет
  if (!fs.existsSync(chunkFolder)) {
    fs.mkdirSync(chunkFolder, { recursive: true });
  }
  
  // Сохраняем чанк
  const writeStream = fs.createWriteStream(path.join(chunkFolder, index));
  req.pipe(writeStream);
  
  writeStream.on('finish', () => {
    // Проверяем, все ли чанки получены
    if (fs.readdirSync(chunkFolder).length == total) {
      // Собираем файл из чанков
      combineChunks(fileId);
    }
    res.json({ status: 'ok' });
  });
});

const sharp = require('sharp');
 
app.post('/upload-image', upload.single('image'), async (req, res) => {
  try {
    // Проверяем, что это реально изображение
    const metadata = await sharp(req.file.path).metadata();
    
    // Проверяем размеры
    if (metadata.width > 5000 || metadata.height > 5000) {
      fs.unlinkSync(req.file.path); // Удаляем файл
      return res.status(400).send('Изображение слишком большое');
    }
    
    // Можно даже изменить изображение на лету
    await sharp(req.file.path)
      .resize(800, 600)
      .toFile(req.file.path + '_resized.jpg');
    
    res.json({ success: true });
  } catch (error) {
    // Если произошла ошибка - это не изображение
    fs.unlinkSync(req.file.path);
    res.status(400).send('Недопустимый формат файла');
  }
});

const prometheus = require('express-prometheus-middleware');
 
app.use(prometheus({
  metricsPath: '/metrics',
  collectDefaultMetrics: true,
  requestDurationBuckets: [0.1, 0.5, 1, 1.5, 2, 5],
  requestLengthBuckets: [512, 1024, 5120, 10240, 51200, 102400],
  responseLengthBuckets: [512, 1024, 5120, 10240, 51200, 102400],
}));

const opentelemetry = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
const { diag, DiagConsoleLogger, DiagLogLevel } = require('@opentelemetry/api');
 
// Включаем логирование для отладки
diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
 
const sdk = new opentelemetry.NodeSDK({
  traceExporter: new opentelemetry.tracing.ConsoleSpanExporter(),
  instrumentations: [getNodeAutoInstrumentations()]
});
 
sdk.start();

function profileMiddleware(operationName) {
  return (req, res, next) => {
    const start = process.hrtime();
    
    // Перехватываем метод end для измерения времени
    const originalEnd = res.end;
    res.end = function(...args) {
      const diff = process.hrtime(start);
      const time = diff[0] * 1e3 + diff[1] * 1e-6; // в миллисекундах
      
      // Отправляем метрику в систему мониторинга
      metrics.timing(`operation.${operationName}`, time);
      
      return originalEnd.apply(this, args);
    };
    
    next();
  };
}
 
// Применение
app.get('/api/products', 
  profileMiddleware('fetchProducts'), 
  productsController.getAll
);

function businessMetricsMiddleware() {
  return (req, res, next) => {
    // Сохраняем оригинальный метод json
    const originalJson = res.json;
    
    res.json = function(body) {
      // Собираем бизнес-метрики на основе ответа
      if (body.orderCompleted) {
        metrics.increment('sales.completed');
        metrics.gauge('sales.amount', body.orderTotal);
      }
      
      return originalJson.call(this, body);
    };
    
    next();
  };
}

const memwatch = require('@airbnb/node-memwatch');
 
app.use((req, res, next) => {
  // Отслеживаем утечки памяти
  const hd = new memwatch.HeapDiff();
  
  res.on('finish', () => {
    const diff = hd.end();
    if (diff.change.size_bytes > 10000000) { // 10MB утечка
      console.warn('Возможная утечка памяти:', diff);
      metrics.gauge('memory.leak.size', diff.change.size_bytes);
    }
  });
  
  next();
});

const redis = require('redis');
const client = redis.createClient();
 
function cacheMiddleware(duration) {
  return (req, res, next) => {
    const key = `cache:${req.originalUrl}`;
    
    client.get(key, (err, cachedResponse) => {
      if (cachedResponse) {
        return res.send(JSON.parse(cachedResponse));
      }
      
      // Перехватываем метод send для кеширования ответа
      const originalSend = res.send;
      res.send = function(body) {
        client.setex(key, duration, JSON.stringify(body));
        return originalSend.call(this, body);
      };
      
      next();
    });
  };
}

function urlTranslator(urlMappings) {
  return (req, res, next) => {
    const userLang = req.headers['accept-language']?.split(',')[0] || 'en';
    const currentPath = req.path;
    
    // Проверяем, есть ли маппинг для текущего пути и языка
    if (urlMappings[currentPath] && urlMappings[currentPath][userLang]) {
      // Меняем путь внутри приложения, но сохраняем оригинальный URL
      req.originalPath = currentPath;
      req.url = req.url.replace(currentPath, urlMappings[currentPath][userLang]);
    }
    
    next();
  };
}
 
// Использование
app.use(urlTranslator({
  '/about': {
    'ru': '/о-нас',
    'de': '/uber-uns'
  },
  '/products': {
    'ru': '/товары',
    'de': '/produkte'
  }
}));

function apiVersionResolver() {
  return (req, res, next) => {
    const userAgent = req.get('User-Agent') || '';
    let apiVersion = 'v1'; // По умолчанию
    
    // Определяем версию по User-Agent
    if (userAgent.includes('MyApp/2.')) {
      apiVersion = 'v2';
    } else if (userAgent.includes('MyApp/3.')) {
      apiVersion = 'v3';
    }
    
    // Изменяем путь запроса, добавляя версию
    if (!req.path.includes(`/api/${apiVersion}/`)) {
      req.url = req.url.replace('/api/', [INLINE]/api/${apiVersion}/[/INLINE]);
    }
    
    req.apiVersion = apiVersion; // Сохраняем для использования в обработчиках
    next();
  };
}

const puppeteer = require('puppeteer');
 
function screenshotMiddleware() {
  let browser;
  
  // Инициализация браузера при старте сервера
  (async () => {
    browser = await puppeteer.launch({ headless: true });
  })();
  
  return async (req, res, next) => {
    // Проверяем, нужен ли скриншот (например, по query-параметру)
    if (!req.query.screenshot) return next();
    
    try {
      const page = await browser.newPage();
      // Формируем полный URL страницы
      const pageUrl = `${req.protocol}://${req.get('host')}${req.path}`;
      
      await page.goto(pageUrl, { waitUntil: 'networkidle2' });
      const screenshot = await page.screenshot({ fullPage: true });
      
      await page.close();
      
      res.type('image/png').send(screenshot);
    } catch (err) {
      next(err);
    }
  };
}

const httpMocks = require('node-mocks-http');
const authMiddleware = require('../middleware/auth');
 
test('auth middleware должен вернуть 401 без токена', () => {
  // Создаем мок-объекты
  const req = httpMocks.createRequest();
  const res = httpMocks.createResponse();
  const next = jest.fn();
  
  // Вызываем тестируемый middleware
  authMiddleware(req, res, next);
  
  // Проверяем результаты
  expect(res.statusCode).toBe(401);
  expect(next).not.toHaveBeenCalled();
});

const request = require('supertest');
const app = require('../app');
 
describe('Интеграционные тесты API', () => {
  test('GET /api/users должен вернуть 401 без авторизации', async () => {
    const response = await request(app).get('/api/users');
    expect(response.statusCode).toBe(401);
  });
  
  test('POST /api/users должен проверять валидацию', async () => {
    const response = await request(app)
      .post('/api/users')
      .set('Authorization', [INLINE]Bearer ${testToken}[/INLINE])
      .send({ name: '' }); // Невалидные данные
    
    expect(response.statusCode).toBe(400);
    expect(response.body).toHaveProperty('errors');
  });
});

// __mocks__/redis.js
module.exports = {
  createClient: jest.fn().mockReturnValue({
    get: jest.fn().mockImplementation((key, callback) => {
      callback(null, null); // Симулируем отсутствие данных в кеше
    }),
    setex: jest.fn()
  })
};

const express = require('express');
const helmet = require('helmet');
const morgan = require('morgan');
const compression = require('compression');
const cors = require('cors');
const rateLimit = require('express-rate-limit');
const { body, validationResult } = require('express-validator');
const multer = require('multer');
const passport = require('passport');
const JwtStrategy = require('passport-jwt').Strategy;
 
const app = express();
 
// 1. Инфраструктурные middleware
app.use(morgan('combined')); // Логирование
app.use(express.json()); // Парсинг JSON
app.use(express.urlencoded({ extended: true })); // Парсинг URL-encoded
app.use(compression()); // Сжатие ответов
 
// 2. Безопасность
app.use(helmet()); // Заголовки безопасности
app.use(cors({
  origin: ['https://myapp.com', 'https://admin.myapp.com'],
  credentials: true
}));
app.use(rateLimit({
  windowMs: 15 * 60 * 1000, // 15 минут
  max: 100 // 100 запросов с одного IP
}));
 
// 3. Аутентификация
app.use(passport.initialize());
// Настройка JWT-стратегии...
 
// 4. Маршруты с валидацией и обработкой файлов
const upload = multer({ dest: 'uploads/' });
 
app.post('/user', [
  body('email').isEmail(),
  body('password').isLength({ min: 8 })
], (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) return res.status(400).json({ errors: errors.array() });
  // Создание пользователя...
});
 
app.post('/upload', upload.single('file'), (req, res) => {
  // Обработка загрузки файла...
});
 
// 5. Обработка ошибок (всегда в конце)
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Что-то пошло не так!');
});
 
app.listen(3000, () => console.log('Сервер запущен на порту 3000'));