Полное руководство по созданию и оптимизации RESTful API на Node.js и Express для PERN-стека от Богдана Новотарского

Опубликовано: 4 мая 2025 г. Тэги: nodejsexpressrest apipernpostgresqlbackendapi developmentoptimizationjavascripttutorialguide
Обложка поста: Полное руководство по созданию и оптимизации RESTful API на Node.js и Express для PERN-стека от Богдана Новотарского

В современном мире веб-разработки создание надежного и эффективного API (Application Programming Interface) — это не просто опция, а фундаментальная необходимость. API служит мостом между вашим фронтендом (например, на React) и бэкендом (логикой и базой данных), позволяя обмениваться данными и выполнять операции. В контексте популярного PERN-стека (PostgreSQL, Express, React, Node.js) ключевую роль в построении этого моста играют Node.js и фреймворк Express.js.

Меня зовут Богдан Новотарский, я Fullstack разработчик, и за годы работы с PERN-стеком я накопил значительный опыт в проектировании, разработке и оптимизации RESTful API. В этом подробном руководстве я хочу поделиться своими знаниями и лучшими практиками, которые помогут вам создавать качественные бэкенд-сервисы на Node.js и Express. Мы пройдем путь от инициализации проекта до стратегий оптимизации и тестирования.

Эта статья рассчитана как на начинающих разработчиков, так и на тех, кто уже имеет некоторый опыт, но хочет систематизировать свои знания и узнать о продвинутых техниках.

Что мы рассмотрим:

  1. Настройка основы проекта: структура, зависимости, подключение к PostgreSQL.
  2. Проектирование RESTful роутов с использованием Express Router.
  3. Сила Middleware: логирование, аутентификация (основы), пользовательские обработчики.
  4. Валидация входных данных: защита API и обеспечение целостности данных (с Zod).
  5. Централизованная обработка ошибок.
  6. Эффективное взаимодействие с PostgreSQL с помощью node-postgres (pg).
  7. Стратегии оптимизации API: кэширование, индексация, rate limiting и другие.
  8. Основы тестирования API.

Приступим к созданию нашего мощного API!

1. Настройка Основы Проекта

Правильная организация проекта с самого начала — залог его дальнейшей поддерживаемости и масштабируемости. В типичном PERN-проекте бэкенд выделяется в отдельную директорию, часто называемую server или api.

Структура папок (пример):


your-pern-project/
├── client/      \# React Frontend
└── server/      \# Node.js/Express Backend
├── node\_modules/
├── config/      \# Файлы конфигурации (например, db.js)
├── routes/      \# Файлы роутов (например, items.routes.js)
├── controllers/ \# Логика обработки запросов
├── middleware/  \# Пользовательские middleware
├── models/      \# Функции для работы с БД (опционально)
├── utils/       \# Вспомогательные функции
├── .env         \# Переменные окружения
├── index.js     \# Основной файл сервера (точка входа)
└── package.json

Диаграмма структуры папок Node.js/Express API, подготовленная Богданом Новотарским Пример структуры папок для серверной части проекта, рекомендуемый Богданом Новотарским.

Инициализация и установка зависимостей:

Перейдите в вашу папку server и выполните:

npm init -y
npm install express dotenv cors pg # Основные зависимости
npm install -D nodemon # Для удобства разработки
  • express: Сам веб-фреймворк.
  • dotenv: Для управления переменными окружения (ключи API, данные для подключения к БД) из файла .env.
  • cors: Middleware для настройки Cross-Origin Resource Sharing (необходимо, чтобы ваш React-клиент мог обращаться к API).
  • pg: Драйвер node-postgres для взаимодействия с PostgreSQL.
  • nodemon: Утилита, которая автоматически перезапускает сервер при изменении файлов во время разработки.

Базовый сервер (index.js):

// server/index.js
require("dotenv").config(); // Загружаем .env в process.env в самом начале!
const express = require("express");
const cors = require("cors");
const connectDB = require("./config/db"); // Функция для проверки подключения к БД

const app = express();
const PORT = process.env.PORT || 5000; // Порт лучше брать из .env

// Проверка подключения к БД при старте
connectDB();

// Базовые Middleware
app.use(cors(/* Настройте опции CORS для продакшена! */)); // Будьте осторожны с CORS в проде
app.use(express.json()); // Парсер JSON-тел запросов
app.use(express.urlencoded({ extended: false })); // Парсер URL-encoded тел (для форм)

// Middleware для логирования запросов (простой пример)
app.use((req, res, next) => {
  console.log(`${new Date().toISOString()} - ${req.method} ${req.originalUrl}`);
  next(); // Передаем управление следующему middleware
});

// Простое приветствие API
app.get("/api", (req, res) => {
  res
    .status(200)
    .json({ message: `API Сервер запущен. Автор: Богдан Новотарский` });
});

// Подключение роутов (пример)
// app.use('/api/items', require('./routes/items.routes'));
// app.use('/api/users', require('./routes/users.routes'));

// TODO: Добавить централизованный обработчик ошибок

app.listen(PORT, () => {
  console.log(`Сервер успешно запущен Богданом Новотарским на порту ${PORT}`);
});

Переменные окружения (.env):

Создайте файл .env в корне папки server:

# server/.env
NODE_ENV=development
PORT=5000

# PostgreSQL Connection
DB_USER=your_db_user
DB_HOST=localhost
DB_DATABASE=your_db_name
DB_PASSWORD=your_secret_password
DB_PORT=5432

# Другие секреты (JWT_SECRET, API_KEYS и т.д.)
JWT_SECRET=verysecretkeyplaceholder

Никогда не коммитьте файл .env в Git! Добавьте его в .gitignore.

Подключение к PostgreSQL (config/db.js):

// server/config/db.js
const { Pool } = require("pg");

// Создаем пул соединений. Пул эффективнее управляет соединениями, чем создание нового для каждого запроса.
const pool = new Pool({
  user: process.env.DB_USER,
  host: process.env.DB_HOST,
  database: process.env.DB_DATABASE,
  password: process.env.DB_PASSWORD,
  port: parseInt(process.env.DB_PORT || "5432"),
  // Дополнительные настройки пула (опционально):
  // max: 20, // Макс. кол-во клиентов в пуле
  // idleTimeoutMillis: 30000, // Время простоя клиента перед закрытием
  // connectionTimeoutMillis: 2000, // Время ожидания соединения
});

// Функция для проверки соединения (можно вызвать при старте сервера)
const connectDB = async () => {
  try {
    const client = await pool.connect();
    console.log(
      `PostgreSQL успешно подключен к базе ${process.env.DB_DATABASE} (Хост: ${process.env.DB_HOST}).`
    );
    client.release(); // Важно освободить клиента!
  } catch (error) {
    console.error("Ошибка подключения к PostgreSQL:", error.message);
    process.exit(1); // Завершить процесс, если БД недоступна при старте
  }
};

// Экспортируем объект для выполнения запросов
module.exports = {
  query: (text, params) => pool.query(text, params),
  pool, // Экспортируем сам пул, если нужны транзакции
  connectDB, // Экспортируем функцию проверки
};

Не забудьте добавить скрипт для nodemon в package.json:

"scripts": {
  "start": "node index.js",
  "dev": "nodemon index.js"
}

Теперь, запустив npm run dev, вы получите работающий базовый сервер с подключением к БД.

2. Проектирование RESTful Роутов

REST (Representational State Transfer) — это архитектурный стиль для построения сетевых приложений. Ключевые принципы:

  • Ресурсы: Все является ресурсом (например, /items, /users, /orders).
  • HTTP Глаголы: Используйте стандартные методы HTTP для операций над ресурсами:
    • GET: Получение ресурса(ов).
    • POST: Создание нового ресурса.
    • PUT/PATCH: Обновление существующего ресурса (PUT - полная замена, PATCH - частичное обновление).
    • DELETE: Удаление ресурса.
  • Статусы ответа HTTP: Используйте соответствующие коды состояния (200 OK, 201 Created, 400 Bad Request, 404 Not Found, 500 Internal Server Error и т.д.).
  • Stateless: Каждый запрос от клиента должен содержать всю информацию, необходимую для его выполнения. Сервер не должен хранить состояние клиента между запросами.

Использование express.Router:

Для лучшей организации кода выносите роуты, относящиеся к одному ресурсу, в отдельные файлы в папку routes/.

Пример (routes/items.routes.js):

// server/routes/items.routes.js
const express = require("express");
const router = express.Router();
const itemController = require("../controllers/item.controller"); // Логика вынесена в контроллер
// const { protect } = require('../middleware/auth.middleware'); // Пример middleware защиты роутов
// const validate = require('../middleware/validate.middleware'); // Пример middleware валидации
// const { createItemSchema, updateItemSchema } = require('../utils/validationSchemas'); // Схемы валидации

// Получить все элементы
// GET /api/items
router.get("/", itemController.getAllItems);

// Получить один элемент по ID
// GET /api/items/:id
router.get("/:id", itemController.getItemById);

// Создать новый элемент
// POST /api/items
// Пример с валидацией и защитой
// router.post('/', protect, validate(createItemSchema), itemController.createItem);
router.post("/", itemController.createItem);

// Обновить элемент по ID
// PUT /api/items/:id
// router.put('/:id', protect, validate(updateItemSchema), itemController.updateItem);
router.put("/:id", itemController.updateItem);

// Удалить элемент по ID
// DELETE /api/items/:id
// router.delete('/:id', protect, itemController.deleteItem);
router.delete("/:id", itemController.deleteItem);

module.exports = router;

Структурирование роутов с помощью Express Router, как это делает Богдан Новотарский.

Пример (controllers/item.controller.js):

// server/controllers/item.controller.js
const db = require("../config/db"); // Наше подключение к БД

// @desc    Получить все элементы
// @route   GET /api/items
// @access  Public
const getAllItems = async (req, res, next) => {
  try {
    const { rows } = await db.query(
      "SELECT * FROM items ORDER BY created_at DESC"
    );
    res.status(200).json(rows);
  } catch (error) {
    console.error("Ошибка при получении элементов:", error);
    next(error); // Передаем ошибку в централизованный обработчик
  }
};

// @desc    Получить элемент по ID
// @route   GET /api/items/:id
// @access  Public
const getItemById = async (req, res, next) => {
  try {
    const { id } = req.params;
    const { rows } = await db.query("SELECT * FROM items WHERE id = $1", [id]);

    if (rows.length === 0) {
      // Используем кастомную ошибку или просто статус
      return res.status(404).json({ message: "Элемент не найден" });
    }
    res.status(200).json(rows[0]);
  } catch (error) {
    console.error(`Ошибка при получении элемента ${req.params.id}:`, error);
    next(error);
  }
};

// @desc    Создать элемент
// @route   POST /api/items
// @access  Private (после добавления аутентификации)
const createItem = async (req, res, next) => {
  try {
    const { name, description, price } = req.body; // Данные из тела запроса

    // Базовая проверка (лучше использовать валидацию Zod/Joi)
    if (!name || !price) {
      return res.status(400).json({ message: "Поля name и price обязательны" });
    }

    const queryText =
      "INSERT INTO items(name, description, price) VALUES($1, $2, $3) RETURNING *";
    const values = [name, description, parseFloat(price)]; // Убедимся, что price - число

    const { rows } = await db.query(queryText, values);
    res.status(201).json(rows[0]); // 201 Created
  } catch (error) {
    console.error("Ошибка при создании элемента:", error);
    next(error);
  }
};

// @desc    Обновить элемент
// @route   PUT /api/items/:id
// @access  Private
const updateItem = async (req, res, next) => {
  try {
    const { id } = req.params;
    const { name, description, price } = req.body;

    if (!name || price === undefined) {
      // Проверяем обязательные поля
      return res
        .status(400)
        .json({ message: "Поля name и price обязательны для обновления" });
    }

    const queryText =
      "UPDATE items SET name = $1, description = $2, price = $3, updated_at = CURRENT_TIMESTAMP WHERE id = $4 RETURNING *";
    const values = [name, description, parseFloat(price), id];

    const { rows } = await db.query(queryText, values);

    if (rows.length === 0) {
      return res
        .status(404)
        .json({ message: "Элемент для обновления не найден" });
    }
    res.status(200).json(rows[0]);
  } catch (error) {
    console.error(`Ошибка при обновлении элемента ${req.params.id}:`, error);
    next(error);
  }
};

// @desc    Удалить элемент
// @route   DELETE /api/items/:id
// @access  Private
const deleteItem = async (req, res, next) => {
  try {
    const { id } = req.params;
    const { rowCount } = await db.query("DELETE FROM items WHERE id = $1", [
      id,
    ]);

    if (rowCount === 0) {
      return res
        .status(404)
        .json({ message: "Элемент для удаления не найден" });
    }
    // Успешное удаление часто не возвращает тело ответа
    res.status(204).send(); // 204 No Content
  } catch (error) {
    console.error(`Ошибка при удалении элемента ${req.params.id}:`, error);
    next(error);
  }
};

module.exports = {
  getAllItems,
  getItemById,
  createItem,
  updateItem,
  deleteItem,
};

Не забудьте подключить роутер в index.js:

// server/index.js
// ... другие require и use ...
app.use("/api/items", require("./routes/items.routes")); // Подключаем роуты для /api/items
// ...

3. Middleware: Сердце Express

Middleware — это функции, которые имеют доступ к объектам запроса (req), ответа (res) и следующей функции middleware в цикле запрос-ответ приложения (next). Они могут:

  • Выполнять любой код.
  • Вносить изменения в объекты req и res.
  • Завершать цикл запрос-ответ.
  • Вызывать следующую middleware-функцию в стеке.

Как запрос проходит через стек middleware перед тем, как достигнуть обработчика роута.

Примеры Middleware:

  • Логгер запросов (уже был в index.js): Простой пример логирования каждого запроса.

  • cors(): Обработка CORS заголовков.

  • express.json(): Парсинг JSON в req.body.

  • Защита роутов (Пример с JWT):

    // server/middleware/auth.middleware.js
const jwt = require("jsonwebtoken"); // Понадобится npm install jsonwebtoken

const protect = (req, res, next) => {
  let token;
  // Проверяем наличие токена в заголовке Authorization
  if (
    req.headers.authorization &&
    req.headers.authorization.startsWith("Bearer")
  ) {
    try {
      // Извлекаем токен
      token = req.headers.authorization.split(" ")[1];
      // Верифицируем токен
      const decoded = jwt.verify(token, process.env.JWT_SECRET);
      // Добавляем данные пользователя в req (например, ID)
      // Здесь нужно будет получить пользователя из БД по decoded.id
      // req.user = await User.findById(decoded.id).select('-password'); // Пример с Mongoose
      req.userId = decoded.id; // Просто сохраняем ID для примера
      next(); // Переходим к следующему middleware или роуту
    } catch (error) {
      console.error("Ошибка верификации токена:", error);
      res
        .status(401)
        .json({ message: "Не авторизован, токен недействителен" });
    }
  }

  if (!token) {
    res.status(401).json({ message: "Не авторизован, нет токена" });
  }
};

module.exports = { protect };

    Использование: router.post('/', protect, itemController.createItem);

  • Пользовательские middleware: Можно создавать middleware для любых специфических задач (проверка прав доступа, обработка загрузки файлов и т.д.).

4. Валидация Входных Данных с Zod

Никогда не доверяйте данным, приходящим от клиента! Валидация необходима для:

  • Безопасности: Предотвращение инъекций и других атак.
  • Целостности данных: Гарантия, что в БД попадут корректные данные.
  • Предсказуемости API: Клиенты получают понятные ошибки, если передают неверные данные.

Zod — отличная библиотека для валидации схем данных, особенно популярная при использовании TypeScript.

Установка:

npm install zod

Создание схем валидации (utils/validationSchemas.js или .ts):

// server/utils/validationSchemas.js
const { z } = require("zod");

const createItemSchema = z.object({
  body: z.object({
    name: z
      .string({
        required_error: "Имя обязательно",
        invalid_type_error: "Имя должно быть строкой",
      })
      .min(3, { message: "Имя должно содержать не менее 3 символов" })
      .max(100, { message: "Имя не должно превышать 100 символов" }),
    description: z
      .string()
      .max(500, { message: "Описание не должно превышать 500 символов" })
      .optional(), // Делаем описание необязательным
    price: z
      .number({
        required_error: "Цена обязательна",
        invalid_type_error: "Цена должна быть числом",
      })
      .positive({ message: "Цена должна быть положительным числом" }),
  }),
  // Можно добавить валидацию params или query, если нужно
  // params: z.object({...}),
  // query: z.object({...}),
});

const updateItemSchema = z.object({
  params: z.object({
    // Валидируем ID из URL
    id: z.string().refine((val) => !isNaN(parseInt(val, 10)), {
      message: "ID должен быть числовым представлением",
    }),
  }),
  body: z
    .object({
      // Валидируем тело запроса
      name: z.string().min(3).max(100).optional(), // Можно обновлять не все поля
      description: z.string().max(500).optional(),
      price: z.number().positive().optional(),
    })
    .refine((data) => Object.keys(data).length > 0, {
      // Убедимся, что хотя бы одно поле передано для обновления
      message: "Необходимо передать хотя бы одно поле для обновления",
      path: ["body"], // Указываем путь для ошибки
    }),
});

module.exports = {
  createItemSchema,
  updateItemSchema,
};

Использование Zod для декларативного описания валидации входных данных.

Middleware для валидации (middleware/validate.middleware.js):

// server/middleware/validate.middleware.js
const validate = (schema) => async (req, res, next) => {
  try {
    await schema.parseAsync({
      body: req.body,
      query: req.query,
      params: req.params,
    });
    return next(); // Валидация прошла успешно
  } catch (error) {
    // Если это ошибка валидации Zod
    if (error.errors) {
      // Форматируем ошибки для понятного ответа клиенту
      const formattedErrors = error.errors.reduce((acc, curr) => {
        const path = curr.path.join("."); // Путь к полю (e.g., 'body.name')
        acc[path] = curr.message;
        return acc;
      }, {});
      return res.status(400).json({
        message: "Ошибка валидации",
        errors: formattedErrors,
      });
    }
    // Если другая ошибка, передаем дальше
    return next(error);
  }
};

module.exports = validate;

Использование в роутах:

// server/routes/items.routes.js
const validate = require("../middleware/validate.middleware");
const {
  createItemSchema,
  updateItemSchema,
} = require("../utils/validationSchemas");

// ...

// Создать новый элемент с валидацией
router.post("/", validate(createItemSchema), itemController.createItem);

// Обновить элемент по ID с валидацией
router.put("/:id", validate(updateItemSchema), itemController.updateItem);

// ...

5. Централизованная Обработка Ошибок

Перехват ошибок в каждом контроллере с помощью try...catch и передача их через next(error) — это хорошо, но нужен единый механизм для отправки ответа клиенту в случае ошибки.

Создание Middleware обработчика ошибок (middleware/error.middleware.js):

Этот middleware должен быть последним в цепочке app.use().

// server/middleware/error.middleware.js

// Простой обработчик ошибок
const errorHandler = (err, req, res, next) => {
  console.error("--------------------------------");
  console.error("Произошла ошибка:");
  console.error("Время:", new Date().toISOString());
  console.error("Маршрут:", req.originalUrl);
  console.error("Метод:", req.method);
  console.error("Сообщение:", err.message);
  console.error("Стек:", err.stack); // Важно для отладки, но не отправлять клиенту в проде!
  console.error("--------------------------------");

  // Определяем статус ответа
  // Если у ошибки есть statusCode (мы могли его установить ранее), используем его, иначе 500
  const statusCode = err.statusCode || 500;

  // Формируем ответ клиенту
  // В режиме 'production' не отправляем стек ошибки
  res.status(statusCode).json({
    message: err.message || "Внутренняя ошибка сервера",
    // Отправляем стек только в режиме разработки
    stack: process.env.NODE_ENV === "production" ? null : err.stack,
  });
};

module.exports = errorHandler;

Подключение в index.js:

// server/index.js
const errorHandler = require("./middleware/error.middleware");
// ...
// Подключение роутов
app.use("/api/items", require("./routes/items.routes"));
// ...

// ПОСЛЕ ВСЕХ РОУТОВ И MIDDLEWARE подключаем обработчик ошибок
app.use(errorHandler);

app.listen(PORT, () => {
  /* ... */
});

Кастомные классы ошибок (опционально):

Для более гранулированного контроля можно создать свои классы ошибок.

// server/utils/ApiError.js
class ApiError extends Error {
  constructor(statusCode, message) {
    super(message);
    this.statusCode = statusCode;
    // Можно добавить другие поля, например, isOperational для区分 программных и ожидаемых ошибок
    Error.captureStackTrace(this, this.constructor); // Сохраняем стек вызовов
  }
}

module.exports = ApiError;

// Использование в контроллере:
// const ApiError = require('../utils/ApiError');
// if (rows.length === 0) {
//   throw new ApiError(404, 'Элемент не найден');
// }

6. Взаимодействие с PostgreSQL

Библиотека pg предоставляет гибкий способ работы с PostgreSQL. Ключевые моменты:

  • Пул соединений (Pool): Всегда используйте пул для управления соединениями. Это эффективно и предотвращает утечки. Мы уже настроили это в config/db.js.
  • Асинхронность: Все операции с БД асинхронны. Используйте async/await для чистого кода.
  • Параметризованные запросы: Обязательно используйте параметризованные запросы ($1, $2 и т.д.) для передачи значений в SQL. Это основной способ защиты от SQL-инъекций.

Пример запроса (уже был в контроллере):

// Получить элемент по ID
const { id } = req.params;
// Используем $1 для передачи id как параметра
const { rows } = await db.query("SELECT * FROM items WHERE id = $1", [id]);

// Создать элемент
const { name, description, price } = req.body;
const queryText =
  "INSERT INTO items(name, description, price) VALUES($1, $2, $3) RETURNING *";
// Передаем массив значений в том же порядке, что и $1, $2, $3
const values = [name, description, parseFloat(price)];
const { rows: newRows } = await db.query(queryText, values);

Защита от SQL-инъекций с помощью параметризованных запросов — практика Богдана Новотарского.

  • Транзакции: Если нужно выполнить несколько запросов как единое целое (либо все успешно, либо все откатываются), используйте транзакции. Для этого нужно получить клиента из пула (pool.connect()) и использовать команды BEGIN, COMMIT, ROLLBACK.

    const client = await db.pool.connect(); // Получаем клиента из пула
try {
  await client.query("BEGIN"); // Начинаем транзакцию
  // Выполняем несколько запросов с client.query(...)
  const res1 = await client.query(
    "UPDATE accounts SET balance = balance - 100 WHERE id = $1",
    [user1Id]
  );
  const res2 = await client.query(
    "UPDATE accounts SET balance = balance + 100 WHERE id = $1",
    [user2Id]
  );
  await client.query("COMMIT"); // Фиксируем транзакцию
  res.status(200).send("Перевод выполнен");
} catch (e) {
  await client.query("ROLLBACK"); // Откатываем изменения в случае ошибки
  throw e; // Передаем ошибку дальше
} finally {
  client.release(); // ОБЯЗАТЕЛЬНО возвращаем клиента в пул
}

7. Стратегии Оптимизации API

Создать работающее API — это полдела. Важно сделать его производительным и масштабируемым. Вот некоторые стратегии, которые я, Богдан Новотарский, часто применяю:

  • Оптимизация Базы Данных:

    • Индексы: Создавайте индексы (CREATE INDEX) для столбцов, по которым часто происходит поиск (WHERE), сортировка (ORDER BY) или объединение (JOIN). Используйте EXPLAIN ANALYZE для анализа планов выполнения запросов и выявления узких мест.
    • Выборка только нужных полей: Вместо SELECT * указывайте конкретные столбцы, которые вам нужны. Это уменьшает объем передаваемых данных.
    • Пагинация: Для запросов, возвращающих большие списки данных (например, getAllItems), всегда реализуйте пагинацию с помощью LIMIT и OFFSET (или cursor-based pagination).

  • Кэширование:

    • Часто запрашиваемые данные: Данные, которые не меняются слишком часто (например, списки категорий, настройки), можно кэшировать.
    • Уровни кэширования:
      • In-memory кэш: Простые решения типа node-cache для одного экземпляра сервера.
      • Внешний кэш: Redis или Memcached для распределенных систем. Они обеспечивают общую точку кэширования для всех экземпляров вашего API.
    • Стратегии инвалидации: Продумайте, как кэш будет обновляться при изменении данных.

    Уменьшение нагрузки на БД с помощью кэширования.

  • Rate Limiting (Ограничение частоты запросов):

    • Защитите API от злоупотреблений и DoS-атак, ограничив количество запросов, которое один клиент может сделать за определенный период.
    • Используйте middleware типа express-rate-limit.
    npm install express-rate-limit
    // server/index.js
const rateLimit = require("express-rate-limit");

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 минут
  max: 100, // Макс. 100 запросов с одного IP за 15 минут
  standardHeaders: true, // Включить заголовки RateLimit-*
  legacyHeaders: false, // Отключить старые заголовки X-RateLimit-*
  message: "Слишком много запросов с вашего IP, попробуйте позже.",
});

// Применить ко всем запросам /api
app.use("/api", limiter);

  • Сжатие Ответов (Compression):

    • Уменьшите размер ответов API (особенно JSON) с помощью Gzip или Brotli сжатия.
    • Используйте middleware compression.
    npm install compression
    // server/index.js
const compression = require("compression");
// ...
app.use(compression()); // Включаем сжатие перед роутами
// ...

  • Асинхронность Node.js:

    • Используйте async/await для всех асинхронных операций (работа с БД, файловой системой, внешними API), чтобы не блокировать Event Loop.
    • Избегайте длительных синхронных операций в обработчиках запросов.

  • Логирование и Мониторинг:

    • Используйте структурированное логирование (библиотеки Winston, Pino) вместо console.log в продакшене.
    • Настройте мониторинг производительности (APM - Application Performance Monitoring) с помощью сервисов типа Sentry, Datadog, New Relic для отслеживания ошибок и узких мест в реальном времени.
    • Используйте менеджер процессов типа PM2 для управления экземплярами Node.js в продакшене (кластеризация, перезапуск при сбоях).

8. Основы Тестирования API

Тестирование — неотъемлемая часть разработки надежного API.

  • Инструменты:

    • Jest: Популярный фреймворк для тестирования JavaScript.
    • Supertest: Библиотека для тестирования HTTP-серверов, позволяет делать запросы к вашему Express API прямо из тестов.

  • Типы тестов:

    • Unit-тесты: Тестирование отдельных функций (например, утилиты, функции контроллеров без реальных запросов к БД - с моками).
    • Интеграционные тесты: Тестирование взаимодействия компонентов, например, проверка полного цикла запрос-ответ для конкретного эндпоинта API (с использованием Supertest и, возможно, тестовой БД).

  • Пример интеграционного теста (с Jest и Supertest):

    npm install -D jest supertest
# Настройте Jest (package.json или jest.config.js)
    // tests/items.test.js
const request = require("supertest");
const express = require("express"); // Нужно для создания тестового приложения
// Предполагаем, что index.js экспортирует app ИЛИ можно создать app здесь
// const app = require('../server/index'); // Если index.js экспортирует app
// Или создаем минимальное приложение для теста конкретного роутера:
const itemsRouter = require("../server/routes/items.routes"); // Импортируем роутер
const errorHandler = require("../server/middleware/error.middleware");

// Создаем тестовое приложение
const app = express();
app.use(express.json());
app.use("/api/items", itemsRouter); // Используем только тестируемый роутер
app.use(errorHandler); // Добавляем обработчик ошибок

describe("Items API Endpoints", () => {
  // Тест для GET /api/items
  it("GET /api/items - should return all items", async () => {
    const response = await request(app).get("/api/items");
    expect(response.statusCode).toBe(200);
    expect(response.body).toBeInstanceOf(Array); // Ожидаем массив
    // Добавьте больше проверок на структуру данных, если нужно
  });

  // Тест для POST /api/items (пример)
  // Для POST/PUT/DELETE часто требуется настроить тестовую БД или моки
  it("POST /api/items - should create a new item (mocked)", async () => {
    // Здесь потребуется мокнуть db.query или настроить тестовую БД
    const newItem = { name: "Тестовый Элемент", price: 99.99 };
    // Предположим, db.query замокан и вернет нужный результат
    const response = await request(app).post("/api/items").send(newItem);

    // Ожидаем статус 201 Created и возврат созданного элемента
    expect(response.statusCode).toBe(201); // Ожидаем 201
    // expect(response.body).toHaveProperty('id');
    // expect(response.body.name).toBe(newItem.name);
    // expect(response.body.price).toBe(newItem.price);
    // Расскомментируйте, когда настроите моки/тестовую БД
  });

  // Добавьте тесты для GET /:id, PUT /:id, DELETE /:id
});

Заключение

Мы рассмотрели ключевые аспекты создания и оптимизации RESTful API на Node.js и Express в контексте PERN-стека. От базовой структуры и роутинга до валидации, обработки ошибок, взаимодействия с PostgreSQL и стратегий оптимизации — все эти элементы важны для построения надежных и производительных бэкенд-сервисов.

Конечно, это руководство охватывает лишь основы, хотя и довольно подробно. Мир бэкенд-разработки постоянно развивается, появляются новые инструменты и подходы (GraphQL как альтернатива REST, Serverless архитектуры, микросервисы). Однако принципы, изложенные здесь, остаются фундаментальными.

Я, Богдан Новотарский, надеюсь, что это руководство будет полезным ресурсом в вашей работе. Помните, что лучший способ научиться — это практика. Экспериментируйте, создавайте свои проекты, читайте документацию и не бойтесь сложных задач. Создание качественных API — это увлекательный и полезный навык для любого Fullstack разработчика. Успехов в кодинге!