Какие плюсы и минусы Knex.js?

Какие плюсы и минусы Knex.js?

Knex.js — популярный SQL query builder для Node.js. За мою карьеру я использовал его в десятках проектов и глубоко понимаю его сильные и слабые стороны. Это хороший выбор для проектов, требующих гибкости между raw SQL и полноценным ORM.

Что такое Knex.js

Knex.js — это SQL query builder, который позволяет писать SQL запросы на JavaScript/TypeScript:

const knex = require('knex');

const db = knex({
  client: 'pg',
  connection: {
    host: 'localhost',
    user: 'postgres',
    password: 'password',
    database: 'myapp'
  }
});

// Вместо писания SQL
const query = db('users')
  .select('id', 'name', 'email')
  .where('status', '=', 'active')
  .orderBy('created_at', 'desc')
  .limit(10);

const users = await query;

Плюсы Knex.js

1. Основной SQL без хардкода

// Защита от SQL-инъекций
const userId = req.params.id; // от пользователя
const user = await db('users')
  .select('*')
  .where('id', userId); // Параметризированный запрос

// SQL: SELECT * FROM users WHERE id = $1
// Значение передаётся отдельно

2. Database агностика

// Один код для разных БД
const knex = require('knex');

// PostgreSQL
const pgKnex = knex({ client: 'pg', connection: {...} });

// MySQL
const mysqlKnex = knex({ client: 'mysql', connection: {...} });

// SQLite
const sqliteKnex = knex({ client: 'sqlite3', connection: ':memory:' });

// Одинаковые запросы работают везде
const query = db('users').select('*').where('active', true);

3. Миграции из коробки

# Создать миграцию
knex migrate:make create_users_table

// migrations/001_create_users_table.js
exports.up = function(knex) {
  return knex.schema.createTable('users', table => {
    table.increments('id');
    table.string('name').notNullable();
    table.string('email').unique();
    table.timestamp('created_at').defaultTo(knex.fn.now());
  });
};

exports.down = function(knex) {
  return knex.schema.dropTable('users');
};

# Запустить миграции
knex migrate:latest

# Откатить последнюю
knex migrate:rollback

4. Сложные JOIN операции

// Легко писать сложные JOIN
const posts = await db('posts')
  .select('posts.*', 'users.name', 'users.email')
  .join('users', 'posts.user_id', '=', 'users.id')
  .leftJoin('comments', 'posts.id', '=', 'comments.post_id')
  .where('posts.status', 'published')
  .groupBy('posts.id')
  .having('count(comments.id)', '>', 0)
  .orderBy('posts.created_at', 'desc');

5. Транзакции

// ACID транзакции
const result = await db.transaction(async trx => {
  // Оба запроса выполняются в одной транзакции
  await trx('accounts')
    .where('id', fromAccountId)
    .decrement('balance', amount);

  await trx('accounts')
    .where('id', toAccountId)
    .increment('balance', amount);

  return { success: true };
});

// Если ошибка — всё откатится

6. Batch операции

// Вставка множества строк
const users = [
  { name: 'John', email: 'john@example.com' },
  { name: 'Jane', email: 'jane@example.com' },
  { name: 'Bob', email: 'bob@example.com' }
];

await db('users').insert(users);

// Обновление в цикле
const ids = [1, 2, 3];
for (const id of ids) {
  await db('users').where('id', id).update({ status: 'active' });
}

7. Raw SQL когда нужно

// Если builder недостаточно — использовать raw SQL
const result = await db.raw(
  'SELECT * FROM users WHERE id = ? AND status = ?',
  [userId, 'active']
);

// С именованными параметрами
const result = await db.raw(
  'SELECT * FROM users WHERE id = :id AND status = :status',
  { id: userId, status: 'active' }
);

8. Seed файлы для тестовых данных

// seeds/001_initial_users.js
exports.seed = async (knex) => {
  // Удалить существующие
  await knex('users').del();

  // Вставить тестовые данные
  await knex('users').insert([
    { id: 1, name: 'John', email: 'john@example.com' },
    { id: 2, name: 'Jane', email: 'jane@example.com' }
  ]);
};

Минусы Knex.js

1. Не ORM — нет автоматических relations

// Нужно вручную писать JOIN
const user = await db('users').where('id', 1).first();

// Нужно отдельно загружать relations
const posts = await db('posts').where('user_id', user.id);
user.posts = posts;

// Сравните с Sequelize, где это автоматически:
// const user = await User.findById(1, { include: ['Posts'] });

2. Нет типизации для результатов (без workarounds)

// Плохо: результат имеет тип any
const users = await db('users');
// users: any

// Нужно явно типизировать
interface User {
  id: number;
  name: string;
  email: string;
}

const users = await db('users') as User[];

3. Более многословно для простых операций

// С Knex — довольно много кода
const user = await db('users')
  .select('*')
  .where('id', '=', 1)
  .first();

// С ORM было бы проще
const user = await User.findById(1);

4. Не валидирует данные

// Knex просто передаст любые данные
const user = await db('users').insert({
  name: 'John',
  email: 'invalid-email', // Нет валидации!
  unknown_field: 'test'    // Может быть проблема
});

// Нужна отдельная библиотека для валидации
// Например: joi, yup, class-validator

5. Отсутствие жизненных циклов (hooks)

// Нет встроенных before/after hooks
// Нужно вручную обрабатывать

// Хотим хешировать пароль перед сохранением
const user = {
  email: 'john@example.com',
  password: plainPassword
};

// С Knex нужно вручную
user.password = await hashPassword(user.password);
await db('users').insert(user);

// С ORM было бы автоматически в hook beforeCreate

6. Нет встроенной кеширования

// Нужно вручную реализовать кеш
const cacheKey = `user:${userId}`;
let user = await redis.get(cacheKey);

if (!user) {
  user = await db('users').where('id', userId).first();
  await redis.set(cacheKey, JSON.stringify(user), 'EX', 3600);
}

7. Проблемы с N+1 queries

// Легко создать N+1 проблему
const users = await db('users').limit(10);

for (const user of users) {
  // 10 дополнительных запросов!
  user.posts = await db('posts').where('user_id', user.id);
}

// Нужно вручную оптимизировать
// Лучше использовать JOIN
const users = await db('users')
  .select('users.*')
  .leftJoin('posts', 'users.id', '=', 'posts.user_id')
  .limit(10);

8. Миграции требуют файловой системы

// Файлы миграций должны быть на диске
// Сложно с динамическими миграциями
// Требует дополнительного управления версионированием

Когда использовать Knex.js

✓ Используй Knex когда:

• Нужна гибкость SQL и мощь query builder
• Работаешь с простыми моделями без сложных relations
• Нужна database агностика
• Предпочитаешь контроль над raw SQL

✗ Не используй Knex когда:

• Нужны сложные relations и associations
• Хочешь минимизировать boilerplate код
• Требуется встроенная валидация и хуки
• Работаешь с очень сложными моделями данных

Альтернативы

TypeORM — полнофункциональный ORM

const user = await User.findOne({ where: { id: 1 }, relations: ['posts'] });

Sequelize — популярный ORM для Node.js

const user = await User.findByPk(1, { include: ['Posts'] });

Prisma — современный ORM с типизацией

const user = await prisma.user.findUnique({
  where: { id: 1 },
  include: { posts: true }
});

Best Practices при использовании Knex

• Используй миграции для версионирования схемы БД
• Создавай query builder функции для переиспользуемых запросов
• Используй транзакции для операций, требующих consistency
• Избегай N+1 queries — планируй JOINs
• Типизируй результаты вручную для TypeScript
• Валидируй данные отдельной библиотекой

Knex.js — отличный выбор для баланса между контролем и удобством. Это не ORM, но и не raw SQL — идеальное решение для многих проектов.