Express vs Fastify vs Hapi vs Koa vs Sails: 実務で選ぶべき Node.js フレームワーク

Node.js でバックエンドを構築する際、express、fastify、hapi、koa、sails の中からどれを選ぶかは、プロジェクトの規模、パフォーマンス要件、そしてチームの文化に大きく依存します。これらは単に「HTTP サーバー」であるだけでなく、アプリケーションの構造や保守性に直結する設計思想の違いを持っています。実務的な観点から、これら 5 つのフレームワークを比較します。

🏗️ 基本構造とリクエスト処理

フレームワークの核となる部分は、リクエストをどのように受け取り、処理するかです。

express は関数型のミドルウェアスタックを採用しています。リクエストとレスポンスオブジェクトを直接操作します。

// express: 基本的なルート定義
const express = require('express');
const app = express();

app.get('/user/:id', (req, res) => {
  res.send(`User ID: ${req.params.id}`);
});

fastify は高速化のため、リクエストとレスポンスのラッパーを使用し、スキーマ定義を推奨します。

// fastify: スキーマ付きルート定義
const fastify = require('fastify')();

fastify.get('/user/:id', {
  schema: {
    params: { id: { type: 'integer' } }
  }
}, async (request, reply) => {
  reply.send({ id: request.params.id });
});

hapi は設定オブジェクトを通じてルートを定義し、ハンドラー関数は構造化されたデータを返します。

// hapi: 設定ベースのルート定義
const Hapi = require('@hapi/hapi');

const server = Hapi.server({ port: 3000 });
server.route({
  method: 'GET',
  path: '/user/{id}',
  handler: (request, h) => {
    return { id: request.params.id };
  }
});

koa は Express の創作者によるもので、コンテキストオブジェクト ctx を使用し、非同期フローを制御します。

// koa: コンテキストベースの処理
const Koa = require('koa');
const app = new Koa();

app.use(async ctx => {
  ctx.body = `User ID: ${ctx.params.id}`;
});

sails は MVC アーキテクチャを採用し、コントローラーアクションとして処理を記述します。

// sails: コントローラーアクション
// api/controllers/UserController.js
module.exports = {
  show: async function (req, res) {
    return res.ok({ id: req.param('id') });
  }
};

🔌 ミドルウェアと拡張性

機能を追加する際の仕組みは、フレームワークの拡張性を決定づけます。

express は app.use() を使用して、関数型のミドルウェアをスタックします。サードパーティ製が豊富です。

// express: ミドルウェア使用
const cors = require('cors');
app.use(cors());
app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});

fastify はプラグインシステムを採用しており、カプセル化されたスコープを持ちます。

// fastify: プラグイン登録
app.register(require('fastify-cors'));
app.register(async function (instance) {
  instance.get('/plugin-route', () => { return 'ok' });
});

hapi はプラグイン機能を持ち、サーバーの機能を拡張するために使用されます。

// hapi: プラグイン登録
await server.register({
  plugin: require('@hapi/inert') // 静的ファイル提供など
});

koa はミドルウェアを使用しますが、Express と異なりダウンストリームとアップストリームの両方を制御できます。

// koa: 非同期ミドルウェア
app.use(async (ctx, next) => {
  const start = Date.now();
  await next();
  const ms = Date.now() - start;
  console.log(`Response time: ${ms}ms`);
});

sails はポリシ（ポリシー）とフックという概念でアクセス制御や機能拡張を行います。

// sails: ポリシ適用
// config/policies.js
module.exports.policies = {
  UserController: {
    '*': 'isAuthenticated',
    show: true
  }
};

🛡️ 入力検証とセキュリティ

ユーザー入力の処理はセキュリティの要です。フレームワークごとのアプローチが異なります。

express はデフォルトでは検証機能を持たず、joi や zod などのライブラリをミドルウェアとして組み込む必要があります。

// express: 外部ライブラリでの検証
const { body, validationResult } = require('express-validator');

app.post('/user', [
  body('email').isEmail()
], (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) return res.status(400).json({ errors });
});

fastify は JSON Schema をネイティブにサポートしており、高速な検証が可能です。

// fastify: スキーマベース検証
fastify.post('/user', {
  schema: {
    body: {
      type: 'object',
      required: ['email'],
      properties: { email: { type: 'string', format: 'email' } }
    }
  }
}, async (request, reply) => {
  // 検証済みデータが request.body にある
});

hapi は joi をベースにした強力な検証機能をルート設定に組み込んでいます。

// hapi: 組み込み検証
server.route({
  method: 'POST',
  path: '/user',
  options: {
    validate: {
      payload: {
        email: Joi.string().email().required()
      }
    }
  },
  handler: (request) => { /*...*/ }
});

koa は Express と同様、コアには検証機能が含まれていないため、ミドルウェアを追加します。

// koa: 検証ミドルウェア
const koaBody = require('koa-body');
app.use(koaBody({
  onerror: (err, ctx) => {
    ctx.throw(400, err);
  }
}));

sails は Waterline ORM を通じて、モデル定義時に検証ルールを記述します。

// sails: モデルベース検証
// api/models/User.js
attributes: {
  emailAddress: {
    type: 'string',
    isEmail: true,
    required: true
  }
}

⚡ 非同期処理とパフォーマンス

現代の Node.js 開発において、非同期処理の扱いやすさと実行速度は重要です。

express は伝統的にコールバックスタイルでしたが、現在は async/await が広く使われています。ただし、エラーハンドリングには next(err) が必要です。

// express: エラーハンドリング
app.get('/data', async (req, res, next) => {
  try {
    const data = await fetchData();
    res.json(data);
  } catch (err) {
    next(err); // エラーを次のハンドラーへ
  }
});

fastify は async/await をネイティブにサポートしており、エラーハンドリングがスローするだけで完了します。

// fastify: 自動エラーハンドリング
fastify.get('/data', async (request, reply) => {
  const data = await fetchData();
  return data; // エラーは自動的に捕捉される
});

hapi も async/await をサポートしており、エラーはスローするか h.response().code() で処理します。

// hapi: 非同期ハンドラー
handler: async (request, h) => {
  try {
    const data = await fetchData();
    return data;
  } catch (err) {
    throw err; // hapi が捕捉
  }
}

koa は最初から async/await 前提で設計されており、ミドルウェアチェーンの制御が直感的です。

// koa: 自然な非同期フロー
app.use(async (ctx, next) => {
  ctx.state.data = await fetchData();
  await next();
});

sails は内部で Promise を使用しますが、コントローラー構造に従う必要があります。

// sails: 非同期アクション
show: async function (req, res) {
  const user = await User.findOne(req.param('id'));
  return res.json(user);
}

🚫 非推奨およびメンテナンス状況について

選択にあたり、メンテナンス状況は重要な要素です。

express は長年維持されており、安定していますが、新機能の追加は緩やかです。レガシーなコードベースが多いことに注意が必要です。

fastify は活発に開発が続いており、パフォーマンスと機能面で現代的な要件を満たしています。新規プロジェクトに推奨されます。

hapi は v21 以降もメンテナンスされており、エンタープライズ用途で安定しています。

koa はメンテナンスされていますが、Express や Fastify に比べると更新頻度は低めです。

sails は過去にメンテナンスが停滞した時期がありましたが、v1 以降も更新は続いています。ただし、エコシステムの規模は他より小さく、新規大規模プロジェクトでの採用は慎重になるべきです。

📊 比較サマリー

💡 結論：どのフレームワークを選ぶべきか

express は、豊富なリソースとミドルウェアを必要とする場合、あるいは既存の知識資産を活かしたい場合に依然として強力な選択肢です。しかし、パフォーマンスや型安全性を重視する新規プロジェクトでは、fastify がより現代的な代替案となります。

hapi は、大規模な組織で設定ファイルによる統一管理を徹底したい場合に適しています。koa は、Express の軽量化版を求めており、ミドルウェアの制御を細かく行いたい開発者に向いています。

sails は、リアルタイム機能や ORM との密な統合を最初から必要とする場合に有用ですが、フレームワークの制約が強いため、柔軟性を求める場合は避けるべきです。

最終的には、チームのスキルセットとプロジェクトの長期的な保守性を考慮して選定することが重要です。