Собеседование по Node.js - вопросы и ответы

// Синхронный подход (блокирующий)
const data = fs.readFileSync('/path/to/file');
console.log(data);
console.log('Это выполнится только после чтения файла');
 
// Асинхронный подход (неблокирующий)
fs.readFile('/path/to/file', (err, data) => {
  console.log(data);
});
console.log('Это выполнится еще до того, как файл прочитается');

// В браузере
document.getElementById('myButton');
window.location.href;
 
// В Node.js 
const fs = require('fs');
process.env.NODE_ENV;

const data = fs.readFileSync('file.txt', 'utf8');
console.log(data);

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

const fsPromises = require('fs').promises;
 
async function readFileAsync() {
  try {
    const data = await fsPromises.readFile('file.txt', 'utf8');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

// файл myModule.js
function sayHello() {
  return "Hello, World!";
}
 
module.exports = { sayHello };
 
// файл app.js
const myModule = require('./myModule');
console.log(myModule.sayHello()); // "Hello, World!"

// Пример middleware в Express
app.use((req, res, next) => {
  console.log('Запрос получен в:', Date.now());
  next(); // Передает управление следующему middleware
});

getData(function(a) {
    getMoreData(a, function(b) {
        getEvenMoreData(b, function(c) {
            // это и называется "колбэк-ад"
        });
    });
});

// Импорт встроенного модуля
const fs = require('fs');
 
// Импорт стороннего модуля (установленного через npm)
const express = require('express');
 
// Импорт локального модуля
const myModule = require('./myModule');

// Импорт встроенного модуля
import fs from 'fs';
 
// Импорт отдельной функции
import { readFile } from 'fs/promises';
 
// Импорт локального модуля
import myModule from './myModule.js';

// Клиентский AJAX (в браузере)
fetch('/api/data')
  .then(response => response.json())
  .then(data => console.log(data));
 
// Серверная часть на Node.js
app.get('/api/data', (req, res) => {
  res.json({ message: 'Hello from Node.js!' });
});

// Создание промиса
const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    if (Math.random() > 0.5) {
      resolve('Успех!');
    } else {
      reject(new Error('Что-то пошло не так'));
    }
  }, 1000);
});
 
// Использование промиса
myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error))
  .finally(() => console.log('Завершено'));

async function myFunction() {
  try {
    const result = await myPromise;
    console.log(result);
  } catch (error) {
    console.error(error);
  } finally {
    console.log('Завершено');
  }
}

const EventEmitter = require('events');
 
// Создаём эмиттер
const myEmitter = new EventEmitter();
 
// Регистрируем обработчик события
myEmitter.on('event', (arg1, arg2) => {
  console.log('Событие с аргументами:', arg1, arg2);
});
 
// Генерируем событие
myEmitter.emit('event', 'первый аргумент', 'второй аргумент');

// Создание буфера
const buf1 = Buffer.alloc(10); // Создаёт буфер размером 10 байт, заполненный нулями
const buf2 = Buffer.from('Hello world'); // Создаёт буфер из строки
const buf3 = Buffer.from([1, 2, 3]); // Создаёт буфер из массива
 
// Преобразование буфера в другие форматы
console.log(buf2.toString()); // 'Hello world'
console.log(buf2.toJSON()); // { type: 'Buffer', data: [72, 101, 108, 108, 111, ...] }
 
// Запись в буфер
buf1.write('Hey!');

const fs = require('fs');
 
// Пример потоковой обработки большого файла
const readStream = fs.createReadStream('bigfile.txt');
const writeStream = fs.createWriteStream('output.txt');
 
// Пайпим данные из одного потока в другой
readStream.pipe(writeStream);
 
// Обработка событий
readStream.on('data', (chunk) => {
  console.log(`Получен ${chunk.length} байт данных`);
});
 
readStream.on('end', () => {
  console.log('Чтение завершено');
});

const crypto = require('crypto');
 
// Создание хеша
function hashPassword(password) {
  const salt = crypto.randomBytes(16).toString('hex');
  const hash = crypto.pbkdf2Sync(password, salt, 10000, 64, 'sha512').toString('hex');
  return { salt, hash };
}
 
// Проверка пароля
function verifyPassword(password, salt, hash) {
  const calculatedHash = crypto.pbkdf2Sync(password, salt, 10000, 64, 'sha512').toString('hex');
  return calculatedHash === hash;
}
 
// Шифрование данных
function encryptData(data, key) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
  let encrypted = cipher.update(data, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  return { iv: iv.toString('hex'), encrypted };
}

getData(function(a) {
  getMoreData(a, function(b) {
    getEvenMoreData(b, function(c) {
      getYetEvenMoreData(c, function(d) {
        getFinalData(d, function(finalData) {
          // Код, до которого тяжело добраться
        });
      });
    });
  });
});

getData()
  .then(a => getMoreData(a))
  .then(b => getEvenMoreData(b))
  .then(c => getYetEvenMoreData(c))
  .then(d => getFinalData(d))
  .then(finalData => {
    // Гораздо читабельнее
  })
  .catch(error => console.error(error));

async function getAllData() {
  try {
    const a = await getData();
    const b = await getMoreData(a);
    const c = await getEvenMoreData(b);
    const d = await getYetEvenMoreData(c);
    const finalData = await getFinalData(d);
    // Код читается сверху вниз как обычный синхронный
  } catch (error) {
    console.error(error);
  }
}

function handleFinalData(finalData) {
  // Обработка финальных данных
}
 
function getDataStep4(c) {
  getYetEvenMoreData(c, function(d) {
    getFinalData(d, handleFinalData);
  });
}
 
// И так далее для каждого шага

// Пример использования
const delayedFunction = setTimeout(() => {
  console.log('Выполнится через 2 секунды');
}, 2000);
 
// При необходимости можно отменить выполнение
// clearTimeout(delayedFunction);
 
// Создание повторяющейся задачи
let counter = 0;
const intervalId = setInterval(() => {
  console.log(`Прошло ${++counter} секунд`);
  if (counter >= 5) {
    clearInterval(intervalId); // Остановка после 5 итераций
  }
}, 1000);
 
// Выполнение в следующем тике цикла событий
setImmediate(() => {
  console.log('Это выполнится после всего синхронного кода');
});

console.log('Начало');
 
process.nextTick(() => {
  console.log('process.nextTick #1');
});
 
setImmediate(() => {
  console.log('setImmediate #1');
  process.nextTick(() => {
    console.log('process.nextTick внутри setImmediate');
  });
});
 
process.nextTick(() => {
  console.log('process.nextTick #2');
});
 
setImmediate(() => {
  console.log('setImmediate #2');
});
 
console.log('Конец');
 
// Вывод:
// Начало
// Конец
// process.nextTick #1
// process.nextTick #2
// setImmediate #1
// process.nextTick внутри setImmediate
// setImmediate #2

// Этот код может вывести результаты в разном порядке при разных запусках
setTimeout(() => {
  console.log('setTimeout');
}, 0);
 
setImmediate(() => {
  console.log('setImmediate');
});

const fs = require('fs');
 
fs.readFile(__filename, () => {
  setTimeout(() => {
    console.log('setTimeout');
  }, 0);
  
  setImmediate(() => {
    console.log('setImmediate');
  });
});
 
// Вывод всегда:
// setImmediate
// setTimeout

const { spawn } = require('child_process');
 
const ls = spawn('ls', ['-la']);
 
ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});
 
ls.stderr.on('data', (data) => {
  console.error(`stderr: ${data}`);
});
 
ls.on('close', (code) => {
  console.log(`Процесс завершён с кодом: ${code}`);
});

// parent.js
const { fork } = require('child_process');
 
const child = fork('./child.js');
 
child.on('message', (message) => {
  console.log('Родитель получил сообщение:', message);
});
 
child.send({ hello: 'от родителя' });
 
// child.js
process.on('message', (message) => {
  console.log('Дочерний процесс получил:', message);
  process.send({ echo: message });
});

const express = require('express');
const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
const session = require('express-session');
 
const app = express();
 
// Настройка сессий
app.use(session({
  secret: 'mysecretkey',
  resave: false,
  saveUninitialized: false
}));
 
// Инициализация Passport
app.use(passport.initialize());
app.use(passport.session());
 
// Настройка локальной стратегии
passport.use(new LocalStrategy(
  (username, password, done) => {
    // Здесь был бы запрос к БД
    if (username === 'admin' && password === 'password') {
      return done(null, { id: 1, username: 'admin' });
    }
    return done(null, false, { message: 'Неверные учетные данные' });
  }
));
 
// Сериализация и десериализация пользователя
passport.serializeUser((user, done) => {
  done(null, user.id);
});
 
passport.deserializeUser((id, done) => {
  // Здесь был бы запрос к БД
  if (id === 1) {
    done(null, { id: 1, username: 'admin' });
  } else {
    done(new Error('Пользователь не найден'));
  }
});
 
// Маршрут для логина
app.post('/login', passport.authenticate('local', {
  successRedirect: '/dashboard',
  failureRedirect: '/login',
  failureFlash: true
}));
 
// Защищенный маршрут
app.get('/dashboard', isAuthenticated, (req, res) => {
  res.send(`Привет, ${req.user.username}!`);
});
 
// Middleware проверки аутентификации
function isAuthenticated(req, res, next) {
  if (req.isAuthenticated()) {
    return next();
  }
  res.redirect('/login');
}

// Сервер с Socket.IO
const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
 
const app = express();
const server = http.createServer(app);
const io = socketIo(server);
 
io.on('connection', (socket) => {
  console.log('Новое соединение');
  
  // Обработка событий от клиента
  socket.on('message', (data) => {
    console.log('Получено сообщение:', data);
    
    // Отправка ответа
    socket.emit('response', { status: 'ok', message: 'Получено!' });
    
    // Отправка всем клиентам кроме отправителя
    socket.broadcast.emit('broadcast', { message: 'Новое сообщение!' });
    
    // Отправка всем клиентам включая отправителя
    io.emit('globalEvent', { message: 'Всем привет!' });
  });
  
  socket.on('disconnect', () => {
    console.log('Соединение закрыто');
  });
});
 
server.listen(3000, () => {
  console.log('Сервер запущен на порту 3000');
});

// user-service.js - Микросервис управления пользователями
const express = require('express');
const app = express();
app.use(express.json());
 
const users = []; // В реальном проекте здесь была бы БД
 
app.post('/users', (req, res) => {
  const user = {
    id: Date.now().toString(),
    name: req.body.name,
    email: req.body.email
  };
  users.push(user);
  res.status(201).json(user);
});
 
app.get('/users/:id', (req, res) => {
  const user = users.find(u => u.id === req.params.id);
  if (!user) return res.status(404).send('Пользователь не найден');
  res.json(user);
});
 
app.listen(3001, () => console.log('Сервис пользователей запущен на порту 3001'));

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
 
if (cluster.isMaster) {
  // Код основного процесса
  console.log(`Мастер-процесс ${process.pid} запущен`);
 
  // Создаём воркеры для каждого ядра CPU
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
 
  // Обработка завершения воркера
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Воркер ${worker.process.pid} завершился с кодом ${code}`);
    console.log('Создаём нового воркера...');
    cluster.fork(); // Автоматически заменяем упавший воркер
  });
} else {
  // Код процесса-воркера
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Привет от процесса ${process.pid}`);
  }).listen(8000);
 
  console.log(`Воркер ${process.pid} запущен`);
}

const fs = require('fs');
const readableStream = fs.createReadStream('bigfile.txt', { encoding: 'utf8', highWaterMark: 16 * 1024 });
 
readableStream.on('data', (chunk) => {
  console.log(`Получен чанк данных: ${chunk.length} байт`);
});
 
readableStream.on('end', () => {
  console.log('Чтение завершено');
});

const fs = require('fs');
const writableStream = fs.createWriteStream('output.txt');
 
writableStream.write('Привет, ');
writableStream.write('мир!');
writableStream.end('\nКонец файла');
 
writableStream.on('finish', () => {
  console.log('Запись завершена');
});

const net = require('net');
const server = net.createServer((socket) => {
  // socket - это duplex stream
  socket.write('Привет клиент!');
  socket.on('data', (data) => {
    console.log(`Получено от клиента: ${data}`);
  });
});

const { Transform } = require('stream');
const zlib = require('zlib');
 
// zlib.createGzip() - это transform stream для сжатия данных
const inputFile = fs.createReadStream('input.txt');
const outputFile = fs.createWriteStream('input.txt.gz');
const gzip = zlib.createGzip();
 
inputFile.pipe(gzip).pipe(outputFile);

const { Transform } = require('stream');
 
// Кастомный transform stream для фильтрации JSON-объектов
class FilterStream extends Transform {
  constructor(filterFn) {
    super({ objectMode: true });
    this.filterFn = filterFn;
  }
 
  _transform(chunk, encoding, callback) {
    if (this.filterFn(chunk)) {
      this.push(chunk);
    }
    callback();
  }
}
 
// Использование в конвейере обработки
fs.createReadStream('huge-data.json')
  .pipe(new JsonParseStream())  // Превращает строки в объекты
  .pipe(new FilterStream(obj => obj.score > 90))  // Фильтрует объекты
  .pipe(new JsonStringifyStream())  // Превращает объекты обратно в строки
  .pipe(fs.createWriteStream('filtered-data.json'));

// Простое профилирование с console.time
console.time('операция');
// ... код для профилирования
console.timeEnd('операция');
 
// Использование встроенного профайлера Node.js
node --prof app.js

const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
 
if (cluster.isMaster) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  // Код вашего сервера
}

const nodeCache = require('node-cache');
const cache = new nodeCache({ stdTTL: 100 });
 
function getData(key, cb) {
  const cachedValue = cache.get(key);
  if (cachedValue) {
    return cb(null, cachedValue);
  }
  
  // Данных в кэше нет, получаем их из БД
  db.query('SELECT * FROM data WHERE id = ?', [key], (err, results) => {
    if (err) return cb(err);
    
    // Сохраняем в кэш и возвращаем
    cache.set(key, results);
    cb(null, results);
  });
}

// Плохо: блокируем Event Loop
const users = db.query('SELECT * FROM users').toArray();
processUsers(users);
 
// Хорошо: используем колбэки или async/await
db.query('SELECT * FROM users', (err, users) => {
  if (err) return handleError(err);
  processUsers(users);
});

const fs = require('fs');
const JSONStream = require('JSONStream');
 
fs.createReadStream('huge-data.json')
  .pipe(JSONStream.parse('*.items'))
  .on('data', item => {
    // Обработка каждого элемента по отдельности
    processItem(item);
  });

const apm = require('elastic-apm-node').start({
  serviceName: 'my-service',
  secretToken: 'token',
  serverUrl: 'http://localhost:8200'
});

const express = require('express');
const app = express();
const prom = require('prom-client');
 
// Создаём счётчик для HTTP запросов
const httpRequestsTotal = new prom.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route', 'status']
});
 
// Middleware для подсчёта запросов
app.use((req, res, next) => {
  res.on('finish', () => {
    httpRequestsTotal.inc({
      method: req.method,
      route: req.route ? req.route.path : req.path,
      status: res.statusCode
    });
  });
  next();
});
 
// Эндпоинт для Prometheus
app.get('/metrics', (req, res) => {
  res.set('Content-Type', prom.register.contentType);
  res.end(prom.register.metrics());
});

// Встроенный модуль для дампа памяти
const heapdump = require('heapdump');
 
// Сделать дамп памяти по запросу
app.get('/heapdump', (req, res) => {
  const filename = `/tmp/heapdump-${Date.now()}.heapsnapshot`;
  heapdump.writeSnapshot(filename, (err) => {
    if (err) return res.status(500).send(err.message);
    res.send(`Heapdump written to ${filename}`);
  });
});

const memwatch = require('memwatch-next');
 
// Отслеживание скачков использования памяти
memwatch.on('leak', (info) => {
  console.log('Возможная утечка памяти:', info);
});
 
// Разница между сборками мусора
memwatch.on('stats', (stats) => {
  console.log('Статистика GC:', stats);
});

app.set('view cache', false);  // Отключить дефолтный кэш
const LRU = require('lru-cache');
const viewCache = new LRU({ max: 100 });  // Кэш с ограничением
 
app.use((req, res, next) => {
  const render = res.render;
  res.render = function(view, options, callback) {
    const cacheKey = `${view}-${JSON.stringify(options)}`;
    const cachedHTML = viewCache.get(cacheKey);
    
    if (cachedHTML) {
      return res.send(cachedHTML);
    }
    
    render.call(this, view, options, (err, html) => {
      if (!err) {
        viewCache.set(cacheKey, html);
      }
      if (typeof callback === 'function') {
        callback(err, html);
      } else {
        res.send(html);
      }
    });
  };
  next();
});

// Уязвимый код
db.query(`SELECT * FROM users WHERE username = '${username}'`);  // SQL инъекция
 
// Безопасный код
db.query('SELECT * FROM users WHERE username = ?', [username]);

// Уязвимый код
res.send(`Привет, ${username}!`);  // Если username содержит HTML/JS
 
// Безопасный код с Express
const escapeHtml = require('escape-html');
res.send(`Привет, ${escapeHtml(username)}!`);

// Уязвимый код
const obj = JSON.parse(data);  // OK для JSON
const obj = eval('(' + data + ')');  // Крайне небезопасно!
 
// Для других форматов используйте проверенные библиотеки

// Плохо
const password = 'SuperSecret123';
 
// Хорошо
const password = process.env.DB_PASSWORD;

// Хеширование пароля
const bcrypt = require('bcrypt');
const hashedPassword = await bcrypt.hash(password, 10);
 
// Сравнение
const match = await bcrypt.compare(password, hashedPassword);

// Слишком разрешительные настройки
app.use(cors());  // Разрешает все домены
 
// Более безопасно
app.use(cors({
  origin: ['https://trusted-site.com'],
  methods: ['GET', 'POST'],
  credentials: true
}));

app.use((req, res, next) => {
  res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self'");
  next();
});

const { body, validationResult } = require('express-validator');
 
app.post('/user',
  // Валидация
  body('email').isEmail().normalizeEmail(),
  body('password').isLength({ min: 8 }),
  body('name').trim().escape(),  // Санитизация от HTML/JS-инъекций
  
  (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }
    
    // Безопасно использовать данные
    createUser(req.body);
  }
);

// MongoDB (с Mongoose)
User.findOne({ username: username })  // Параметры автоматически эскейпятся
 
// Vanilla SQL
connection.query('SELECT * FROM users WHERE id = ?', [userId]);

const bodyParser = require('body-parser');
app.use(bodyParser.json({ limit: '1mb' }));
app.use(bodyParser.urlencoded({ limit: '1mb', extended: true }));

const multer = require('multer');
const upload = multer({
  limits: { fileSize: 5 * 1024 * 1024 },  // 5MB
  fileFilter: (req, file, cb) => {
    const allowedTypes = ['image/jpeg', 'image/png'];
    if (!allowedTypes.includes(file.mimetype)) {
      return cb(new Error('Invalid file type'));
    }
    cb(null, true);
  }
});
 
app.post('/upload', upload.single('avatar'), (req, res) => {
  // Файл прошел все проверки
});

const https = require('https');
const fs = require('fs');
const express = require('express');
 
const app = express();
 
// Ваши маршруты и middleware
app.get('/', (req, res) => {
  res.send('Привет из защищённого сервера!');
});
 
// Настройка SSL
const options = {
  key: fs.readFileSync('/path/to/privkey.pem'),
  cert: fs.readFileSync('/path/to/cert.pem'),
  ca: fs.readFileSync('/path/to/chain.pem')  // Если есть цепочка сертификатов
};
 
// Создание HTTPS-сервера
https.createServer(options, app).listen(443, () => {
  console.log('HTTPS сервер запущен на порту 443');
});

const http = require('http');
const express = require('express');
 
const httpApp = express();
 
// Перенаправление всех HTTP запросов на HTTPS
httpApp.all('*', (req, res) => {
  res.redirect(301, [INLINE]https://${req.hostname}${req.url}[/INLINE]);
});
 
http.createServer(httpApp).listen(80);

app.use((req, res, next) => {
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');
  next();
});

const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');
 
app.post('/login', async (req, res) => {
  const { username, password } = req.body;
  
  // Поиск пользователя в БД
  const user = await User.findOne({ username });
  if (!user) {
    return res.status(401).json({ message: 'Пользователь не найден' });
  }
  
  // Проверка пароля
  const validPassword = await bcrypt.compare(password, user.password);
  if (!validPassword) {
    return res.status(401).json({ message: 'Неверный пароль' });
  }
  
  // Создание JWT токена
  const token = jwt.sign(
    { id: user._id, username: user.username, role: user.role },
    process.env.JWT_SECRET,
    { expiresIn: '1h' }  // Токен действителен 1 час
  );
  
  res.json({ token });
});

function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];  // Bearer TOKEN
  
  if (!token) {
    return res.status(401).json({ message: 'Нет токена авторизации' });
  }
  
  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({ message: 'Недействительный токен' });
    }
    
    req.user = user;  // Добавляем данные пользователя в объект запроса
    next();
  });
}
 
// Защита маршрута
app.get('/protected', authenticateToken, (req, res) => {
  res.json({ message: `Привет, ${req.user.username}!` });
});

function authorizeRole(role) {
  return (req, res, next) => {
    if (req.user.role !== role) {
      return res.status(403).json({ message: 'Нет доступа' });
    }
    next();
  };
}
 
// Маршрут только для администраторов
app.get('/admin', authenticateToken, authorizeRole('admin'), (req, res) => {
  res.json({ message: 'Панель администратора' });
});

// Сервис пользователей
const express = require('express');
const app = express();
 
app.get('/api/users/:id', async (req, res) => {
  // Логика получения пользователя
});
 
app.listen(3001);
 
// Сервис продуктов (отдельное приложение)
const express = require('express');
const app = express();
 
app.get('/api/products/:id', async (req, res) => {
  // Логика получения продукта
});
 
app.listen(3002);

// Отправка задачи в очередь
const amqp = require('amqplib');
 
async function publishToQueue(task) {
  const connection = await amqp.connect('amqp://localhost');
  const channel = await connection.createChannel();
  
  await channel.assertQueue('tasks_queue');
  channel.sendToQueue('tasks_queue', Buffer.from(JSON.stringify(task)));
  
  console.log("Задача отправлена в очередь");
  
  setTimeout(() => {
    connection.close();
  }, 500);
}
 
// Обработчик задач (отдельный процесс)
async function processQueue() {
  const connection = await amqp.connect('amqp://localhost');
  const channel = await connection.createChannel();
  
  await channel.assertQueue('tasks_queue');
  
  console.log("Ожидание задач...");
  
  channel.consume('tasks_queue', (msg) => {
    const task = JSON.parse(msg.content.toString());
    
    // Длительная обработка задачи
    processTask(task);
    
    channel.ack(msg);
  });
}

const session = require('express-session');
const RedisStore = require('connect-redis').default;
const { createClient } = require('redis');
 
// Создание клиента Redis
const redisClient = createClient({ url: 'redis://localhost:6379' });
redisClient.connect().catch(console.error);
 
// Настройка хранилища сессий
const redisStore = new RedisStore({
  client: redisClient,
  prefix: "myapp:"
});
 
app.use(session({
  store: redisStore,
  secret: process.env.SESSION_SECRET,
  resave: false,
  saveUninitialized: false
}));

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);
 
app.get('/', (req, res) => {
  res.sendFile(__dirname + '/index.html');
});
 
// Обработка соединений
io.on('connection', (socket) => {
  console.log('Пользователь подключился');
  
  // Отправка сообщения конкретному клиенту
  socket.emit('welcome', { message: 'Добро пожаловать!' });
  
  // Отправка всем кроме отправителя
  socket.on('chat message', (msg) => {
    socket.broadcast.emit('chat message', msg);
  });
  
  // Отправка всем включая отправителя
  socket.on('global event', (data) => {
    io.emit('global event', data);
  });
  
  // Комнаты (каналы)
  socket.on('join room', (room) => {
    socket.join(room);
    io.to(room).emit('room message', [INLINE]Новый пользователь в комнате ${room}[/INLINE]);
  });
  
  socket.on('disconnect', () => {
    console.log('Пользователь отключился');
  });
});
 
server.listen(3000, () => {
  console.log('Сервер запущен на порту 3000');
});

const express = require('express');
const { createServer } = require('http');
const { Server } = require('socket.io');
const { createAdapter } = require('@socket.io/redis-adapter');
const { createClient } = require('redis');
 
const app = express();
const server = createServer(app);
const io = new Server(server);
 
// Настройка Redis-адаптера
const pubClient = createClient({ url: 'redis://localhost:6379' });
const subClient = pubClient.duplicate();
 
Promise.all([pubClient.connect(), subClient.connect()]).then(() => {
  io.adapter(createAdapter(pubClient, subClient));
  
  io.on('connection', (socket) => {
    // Теперь сообщения будут работать между разными инстансами
    // приложения, подключенными к одному Redis
  });
  
  server.listen(3000);
});

// Глобальные обработчики ошибок
process.on('uncaughtException', (err) => {
  console.error('Необработанное исключение:', err);
  // Сохранение диагностической информации, уведомление
  
  // Корректное завершение процесса после обработки всех запросов
  gracefulShutdown();
});
 
process.on('unhandledRejection', (reason, promise) => {
  console.error('Необработанный reject промиса:', reason);
});

function gracefulShutdown() {
  console.log('Запуск корректного завершения');
  
  // Прекратить принимать новые запросы
  server.close(() => {
    console.log('HTTP сервер закрыт');
    
    // Закрыть соединения с БД
    mongoose.connection.close(() => {
      console.log('Соединения с БД закрыты');
      process.exit(0);
    });
  });
  
  // Если не удалось завершить за 10 секунд, принудительное завершение
  setTimeout(() => {
    console.error('Принудительное завершение!');
    process.exit(1);
  }, 10000);
}
 
// Обработка сигналов от OS
process.on('SIGTERM', gracefulShutdown);
process.on('SIGINT', gracefulShutdown);

const CircuitBreaker = require('opossum');
 
// Создание circuit breaker для внешнего API
const breaker = new CircuitBreaker(callExternalAPI, {
  timeout: 3000,           // Таймаут операции
  errorThresholdPercentage: 50,  // % ошибок перед размыканием
  resetTimeout: 10000      // Время до повторной попытки
});
 
// Обработка событий
breaker.on('open', () => console.log('Circuit Breaker открыт'));
breaker.on('close', () => console.log('Circuit Breaker закрыт'));
breaker.on('halfOpen', () => console.log('Circuit Breaker полуоткрыт'));
breaker.on('fallback', () => console.log('Использую запасной вариант'));
 
// Использование
app.get('/api/data', async (req, res) => {
  try {
    const result = await breaker.fire(req.query.id);
    res.json(result);
  } catch (err) {
    // Обработка ошибки или использование fallback
    res.status(503).json({ error: 'Сервис временно недоступен' });
  }
});

// Повторная отправка при сбое
const amqp = require('amqplib');
 
async function sendToQueue(data, maxRetries = 3) {
  let retries = 0;
  
  async function attempt() {
    try {
      const connection = await amqp.connect('amqp://localhost');
      const channel = await connection.createChannel();
      
      await channel.assertQueue('important_queue', { durable: true });
      channel.sendToQueue('important_queue', Buffer.from(JSON.stringify(data)), {
        persistent: true  // Сообщение сохранится даже при перезапуске RabbitMQ
      });
      
      await channel.close();
      await connection.close();
    } catch (err) {
      console.error(`Ошибка при отправке (попытка ${retries + 1}):`, err);
      
      if (++retries < maxRetries) {
        // Экспоненциальная выдержка между попытками
        const delay = Math.pow(2, retries) * 1000;
        console.log(`Повторная попытка через ${delay}мс`);
        setTimeout(attempt, delay);
      } else {
        console.error('Максимальное число попыток исчерпано');
        throw err;
      }
    }
  }
  
  return attempt();
}

function responseTimeMiddleware(req, res, next) {
  // Сохраняем время начала запроса
  const start = process.hrtime();
  
  // Отлавливаем событие окончания запроса
  res.on('finish', () => {
    // Получаем время в наносекундах и переводим в миллисекунды
    const diff = process.hrtime(start);
    const responseTime = diff[0] * 1000 + diff[1] / 1000000;
    
    console.log(`Запрос ${req.method} ${req.url} обработан за ${responseTime.toFixed(2)} мс`);
    
    // В реальном приложении здесь можно отправлять метрики
    // в систему мониторинга типа Prometheus
  });
  
  next();
}
 
// Использование
app.use(responseTimeMiddleware);

class AutoCleanCache {
  constructor(maxSize = 100, cleanInterval = 60000) {
    this.cache = new Map();
    this.maxSize = maxSize;
    this.lastAccessed = new Map(); // Время последнего доступа
    
    // Запуск автоочистки
    this.cleanIntervalId = setInterval(() => this.cleanOldEntries(), cleanInterval);
    
    // Не забываем очистить интервал при выгрузке модуля
    process.on('beforeExit', () => {
      clearInterval(this.cleanIntervalId);
    });
  }
  
  set(key, value, ttl = 3600000) { // По умолчанию 1 час
    // Контроль размера кэша
    if (this.cache.size >= this.maxSize) {
      this.removeOldest();
    }
    
    this.cache.set(key, {
      value,
      expires: Date.now() + ttl
    });
    this.updateAccessTime(key);
  }
  
  get(key) {
    const entry = this.cache.get(key);
    
    if (!entry) return null;
    
    // Проверка на истекшее время жизни
    if (entry.expires < Date.now()) {
      this.cache.delete(key);
      this.lastAccessed.delete(key);
      return null;
    }
    
    this.updateAccessTime(key);
    return entry.value;
  }
  
  updateAccessTime(key) {
    this.lastAccessed.set(key, Date.now());
  }
  
  removeOldest() {
    // Находим самую старую запись
    let oldestKey = null;
    let oldestTime = Infinity;
    
    for (const [key, accessTime] of this.lastAccessed.entries()) {
      if (accessTime < oldestTime) {
        oldestTime = accessTime;
        oldestKey = key;
      }
    }
    
    if (oldestKey) {
      this.cache.delete(oldestKey);
      this.lastAccessed.delete(oldestKey);
    }
  }
  
  cleanOldEntries() {
    const now = Date.now();
    
    // Удаляем истекшие записи
    for (const [key, entry] of this.cache.entries()) {
      if (entry.expires < now) {
        this.cache.delete(key);
        this.lastAccessed.delete(key);
      }
    }
  }
}
 
// Использование
const cache = new AutoCleanCache(1000, 30000);
cache.set('user:1', { name: 'John' });

blog-api/
├── config/
│   ├── database.js
│   └── jwt.js
├── controllers/
│   ├── articlesController.js
│   └── authController.js
├── middleware/
│   ├── auth.js
│   └── errorHandler.js
├── models/
│   ├── Article.js
│   └── User.js
├── routes/
│   ├── articles.js
│   └── auth.js
├── utils/
│   ├── cache.js
│   └── logger.js
├── app.js
├── server.js
└── package.json

require('dotenv').config();
const http = require('http');
const app = require('./app');
const { Server } = require('socket.io');
const mongoose = require('mongoose');
const logger = require('./utils/logger');
const { connectDatabase } = require('./config/database');
 
// Создаем HTTP-сервер
const server = http.createServer(app);
 
// Настройка Socket.IO
const io = new Server(server, {
  cors: {
    origin: process.env.FRONTEND_URL || 'http://localhost:3000',
    methods: ['GET', 'POST']
  }
});
 
// Глобально делаем io доступным для использования в других модулях
app.set('io', io);
 
// WebSocket обработка
io.on('connection', (socket) => {
  logger.info(`Новое WebSocket соединение: ${socket.id}`);
  
  socket.on('join article', (articleId) => {
    socket.join(`article:${articleId}`);
    logger.info(`Клиент ${socket.id} присоединился к комнате article:${articleId}`);
  });
  
  socket.on('disconnect', () => {
    logger.info(`WebSocket соединение закрыто: ${socket.id}`);
  });
});
 
// Подключение к базе данных
connectDatabase();
 
// Запуск сервера
const PORT = process.env.PORT || 5000;
server.listen(PORT, () => {
  logger.info(`Сервер запущен на порту ${PORT}`);
});
 
// Graceful shutdown
const shutdown = async () => {
  logger.info('Получен сигнал на завершение работы');
  
  // Закрываем сервер, прекращаем принимать новые соединения
  server.close(() => {
    logger.info('HTTP сервер закрыт');
    
    // Закрываем подключение к MongoDB
    mongoose.connection.close(false, () => {
      logger.info('Соединение с MongoDB закрыто');
      process.exit(0);
    });
  });
  
  // Если сервер не закрылся за 10 секунд, принудительно завершаем процесс
  setTimeout(() => {
    logger.error('Принудительное завершение через таймаут');
    process.exit(1);
  }, 10000);
};
 
// Обработка сигналов завершения
process.on('SIGTERM', shutdown);
process.on('SIGINT', shutdown);
 
// Обработка необработанных исключений и rejected промисов
process.on('uncaughtException', (error) => {
  logger.error('Необработанное исключение:', error);
  shutdown();
});
 
process.on('unhandledRejection', (reason, promise) => {
  logger.error('Необработанный reject промиса:', reason);
});

const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');
const rateLimit = require('express-rate-limit');
const errorHandler = require('./middleware/errorHandler');
const authRoutes = require('./routes/auth');
const articleRoutes = require('./routes/articles');
 
const app = express();
 
// Базовые middleware
app.use(helmet());  // Безопасные HTTP-заголовки
app.use(cors());    // Разрешаем кросс-доменные запросы
app.use(express.json());  // Парсинг JSON в req.body
app.use(morgan('dev'));   // Логирование запросов
 
// Ограничение количества запросов (защита от DDoS)
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,  // 15 минут
  max: 100,  // 100 запросов с одного IP
  standardHeaders: true,
  legacyHeaders: false
});
app.use(limiter);
 
// Маршруты
app.use('/api/auth', authRoutes);
app.use('/api/articles', articleRoutes);
 
// Проверка работоспособности
app.get('/health', (req, res) => {
  res.status(200).json({ status: 'ok' });
});
 
// Обработка ошибок
app.use(errorHandler);
 
module.exports = app;