> ブックマーク管理APIのNode.jsプロジェクトを作って。
  ディレクトリ名は bookmark-api。
  npm init して package.json を生成、
  express と nodemon をインストールして。

mkdir bookmark-api
cd bookmark-api
npm init -y
npm install express
npm install --save-dev nodemon

{
  "name": "bookmark-api",
  "version": "1.0.0",
  "description": "ブックマーク管理REST API",
  "main": "src/index.js",
  "scripts": {
    "start": "node src/index.js",
    "dev": "nodemon src/index.js"
  },
  "dependencies": {
    "express": "^4.21.0"
  },
  "devDependencies": {
    "nodemon": "^3.1.0"
  }
}

> src/index.js にExpressサーバーを作って。
  ポート3000で起動して、
  GET / にアクセスしたら
  { message: "Bookmark API is running" } を返すようにして。

// src/index.js
const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

// JSON形式のリクエストボディを解析するミドルウェア
app.use(express.json());

// ルートエンドポイント
app.get('/', (req, res) => {
  res.json({ message: 'Bookmark API is running' });
});

// サーバー起動
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

npm run dev

curl http://localhost:3000

{"message":"Bookmark API is running"}

curl -v http://localhost:3000

> /api/bookmarks にGETリクエストしたら、
  サンプルのブックマーク配列を返すエンドポイントを追加して。
  レスポンス形式は { data: [...], error: null }

// サンプルデータ
const sampleBookmarks = [
  { id: 1, title: 'Express公式ドキュメント', url: 'https://expressjs.com', category: '技術' },
  { id: 2, title: 'MDN Web Docs', url: 'https://developer.mozilla.org', category: '技術' },
];

// ブックマーク一覧取得
app.get('/api/bookmarks', (req, res) => {
  res.json({ data: sampleBookmarks, error: null });
});

curl http://localhost:3000/api/bookmarks

bookmark-api/
  src/
    index.js          ← サーバーのエントリーポイント（今回作成）
    routes/            ← ルート定義（第2回）
    middleware/        ← ミドルウェア（第3回）
    db/                ← データベース関連（第5回）
  tests/               ← テストファイル（第9回）
  package.json
  .env                 ← 環境変数（第10回）

良い設計:  DELETE /api/bookmarks/1
悪い設計:  GET /api/bookmarks/delete/1

> Expressでルートパラメータを使って、
  特定のブックマークを取得するエンドポイントを作って。
  GET /api/bookmarks/:id でIDを受け取る。

// ルートパラメータの例
app.get('/api/bookmarks/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const bookmark = bookmarks.find(b => b.id === id);

  if (!bookmark) {
    return res.status(404).json({
      data: null,
      error: 'ブックマークが見つかりません'
    });
  }

  res.json({ data: bookmark, error: null });
});

> クエリ文字列でブックマークをカテゴリで絞り込む機能を追加して。
  GET /api/bookmarks?category=技術 の形式で。

// クエリ文字列の例
app.get('/api/bookmarks', (req, res) => {
  let result = bookmarks;

  // カテゴリで絞り込み
  if (req.query.category) {
    result = result.filter(b => b.category === req.query.category);
  }

  // タイトルで検索
  if (req.query.search) {
    result = result.filter(b =>
      b.title.toLowerCase().includes(req.query.search.toLowerCase())
    );
  }

  res.json({ data: result, error: null });
});

> ブックマークのルート定義を src/routes/bookmarks.js に分離して。
  express.Routerを使って、
  GET一覧、GET個別、POST作成、PUT更新、DELETE削除の
  5つのエンドポイントを定義して。

// src/routes/bookmarks.js
const express = require('express');
const router = express.Router();

// 仮のデータ（後でDBに置き換え）
let bookmarks = [
  { id: 1, title: 'Express公式', url: 'https://expressjs.com', category: '技術' },
  { id: 2, title: 'MDN Web Docs', url: 'https://developer.mozilla.org', category: '技術' },
];
let nextId = 3;

// 一覧取得
router.get('/', (req, res) => {
  let result = bookmarks;
  if (req.query.category) {
    result = result.filter(b => b.category === req.query.category);
  }
  res.json({ data: result, error: null });
});

// 個別取得
router.get('/:id', (req, res) => {
  const bookmark = bookmarks.find(b => b.id === parseInt(req.params.id));
  if (!bookmark) {
    return res.status(404).json({ data: null, error: 'ブックマークが見つかりません' });
  }
  res.json({ data: bookmark, error: null });
});

// 新規作成
router.post('/', (req, res) => {
  const { title, url, category } = req.body;
  const bookmark = { id: nextId++, title, url, category: category || '未分類' };
  bookmarks.push(bookmark);
  res.status(201).json({ data: bookmark, error: null });
});

// 更新
router.put('/:id', (req, res) => {
  const index = bookmarks.findIndex(b => b.id === parseInt(req.params.id));
  if (index === -1) {
    return res.status(404).json({ data: null, error: 'ブックマークが見つかりません' });
  }
  const { title, url, category } = req.body;
  bookmarks[index] = { ...bookmarks[index], title, url, category };
  res.json({ data: bookmarks[index], error: null });
});

// 削除
router.delete('/:id', (req, res) => {
  const index = bookmarks.findIndex(b => b.id === parseInt(req.params.id));
  if (index === -1) {
    return res.status(404).json({ data: null, error: 'ブックマークが見つかりません' });
  }
  const deleted = bookmarks.splice(index, 1)[0];
  res.json({ data: deleted, error: null });
});

module.exports = router;

// src/index.js
const express = require('express');
const bookmarkRoutes = require('./routes/bookmarks');

const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.json());

// ルートのマウント
app.get('/', (req, res) => {
  res.json({ message: 'Bookmark API is running' });
});
app.use('/api/bookmarks', bookmarkRoutes);

app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

# 一覧取得
curl http://localhost:3000/api/bookmarks

# カテゴリ検索
curl "http://localhost:3000/api/bookmarks?category=技術"

# 個別取得
curl http://localhost:3000/api/bookmarks/1

# 新規作成（POSTリクエスト）
curl -X POST http://localhost:3000/api/bookmarks \
  -H "Content-Type: application/json" \
  -d '{"title":"GitHub","url":"https://github.com","category":"開発ツール"}'

# 更新（PUTリクエスト）
curl -X PUT http://localhost:3000/api/bookmarks/1 \
  -H "Content-Type: application/json" \
  -d '{"title":"Express.js公式ドキュメント","url":"https://expressjs.com","category":"技術"}'

# 削除（DELETEリクエスト）
curl -X DELETE http://localhost:3000/api/bookmarks/2

リクエスト → [ミドルウェア1] → [ミドルウェア2] → [ルートハンドラ] → レスポンス

function myMiddleware(req, res, next) {
  // req: リクエストオブジェクト
  // res: レスポンスオブジェクト
  // next: 次のミドルウェアに処理を渡す関数
  console.log('ミドルウェアが実行されました');
  next(); // 次に進む（これを呼ばないとリクエストが止まる）
}

app.use(express.json());

# express.json() がある場合
curl -X POST http://localhost:3000/api/bookmarks \
  -H "Content-Type: application/json" \
  -d '{"title":"テスト"}'
# → req.body は { title: "テスト" }

# express.json() がない場合
# → req.body は undefined

app.use(express.urlencoded({ extended: true }));

app.use(express.static('public'));

> ブックマーク管理APIにミドルウェアを追加して。
  cors — フロントエンドからのアクセスを許可、
  morgan — リクエストのログを出力。
  それぞれnpmでインストールして、app.use()で適用して。

npm install cors morgan

// src/index.js
const express = require('express');
const cors = require('cors');
const morgan = require('morgan');
const bookmarkRoutes = require('./routes/bookmarks');

const app = express();
const PORT = process.env.PORT || 3000;

// ミドルウェアの適用（順序が重要！）
app.use(cors());              // CORS許可
app.use(morgan('dev'));       // リクエストログ
app.use(express.json());     // JSONボディ解析

// ルート
app.get('/', (req, res) => {
  res.json({ message: 'Bookmark API is running' });
});
app.use('/api/bookmarks', bookmarkRoutes);

app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

// 全てのオリジンを許可（開発時）
app.use(cors());

// 特定のオリジンのみ許可（本番推奨）
app.use(cors({
  origin: 'https://my-frontend.com',
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
}));

GET /api/bookmarks 200 3.456 ms - 128
POST /api/bookmarks 201 1.234 ms - 95
GET /api/bookmarks/999 404 0.567 ms - 52

> src/middleware/requestLogger.js に
  カスタムのリクエストログミドルウェアを作って。
  タイムスタンプ、メソッド、URL、レスポンス時間を記録して。

// src/middleware/requestLogger.js
function requestLogger(req, res, next) {
  const start = Date.now();

  // レスポンスが送信された後に実行
  res.on('finish', () => {
    const duration = Date.now() - start;
    const timestamp = new Date().toISOString();
    console.log(
      `[${timestamp}] ${req.method} ${req.originalUrl} → ${res.statusCode} (${duration}ms)`
    );
  });

  next();
}

module.exports = requestLogger;

// src/middleware/requestId.js
const crypto = require('crypto');

function requestId(req, res, next) {
  req.id = crypto.randomUUID();
  res.setHeader('X-Request-Id', req.id);
  next();
}

module.exports = requestId;

// グローバル（全ルートに適用）
app.use(morgan('dev'));

// ルーター単位（特定のパスのルートにだけ適用）
app.use('/api/bookmarks', authMiddleware, bookmarkRoutes);

// ルート単位（特定の1ルートにだけ適用）
router.get('/:id', validateId, (req, res) => {
  // validateId ミドルウェアを通過した場合のみ実行
});

> APIレスポンスの統一フォーマットを設計して。
  成功時は { data: ..., error: null }、
  エラー時は { data: null, error: "メッセージ" } の形式。
  ヘルパー関数として src/utils/response.js に切り出して。

// src/utils/response.js

/**
 * 成功レスポンスを返す
 * @param {object} res - Expressのレスポンスオブジェクト
 * @param {*} data - レスポンスデータ
 * @param {number} statusCode - HTTPステータスコード（デフォルト: 200）
 */
function success(res, data, statusCode = 200) {
  return res.status(statusCode).json({
    data,
    error: null,
  });
}

/**
 * エラーレスポンスを返す
 * @param {object} res - Expressのレスポンスオブジェクト
 * @param {string} message - エラーメッセージ
 * @param {number} statusCode - HTTPステータスコード（デフォルト: 400）
 */
function error(res, message, statusCode = 400) {
  return res.status(statusCode).json({
    data: null,
    error: message,
  });
}

module.exports = { success, error };

> src/data/bookmarkStore.js にインメモリのデータストアを作って。
  bookmarks配列と、CRUD操作の関数を定義して。
  IDは自動採番、作成日時と更新日時も記録して。

// src/data/bookmarkStore.js
let bookmarks = [
  {
    id: 1,
    title: 'Express公式ドキュメント',
    url: 'https://expressjs.com',
    category: '技術',
    description: 'Express.jsの公式ドキュメント',
    createdAt: '2025-01-01T00:00:00.000Z',
    updatedAt: '2025-01-01T00:00:00.000Z',
  },
  {
    id: 2,
    title: 'MDN Web Docs',
    url: 'https://developer.mozilla.org',
    category: '技術',
    description: 'Mozilla Developer Network',
    createdAt: '2025-01-02T00:00:00.000Z',
    updatedAt: '2025-01-02T00:00:00.000Z',
  },
];
let nextId = 3;

// 全件取得（フィルタ対応）
function findAll(filters = {}) {
  let result = [...bookmarks];
  if (filters.category) {
    result = result.filter(b => b.category === filters.category);
  }
  if (filters.search) {
    const keyword = filters.search.toLowerCase();
    result = result.filter(b =>
      b.title.toLowerCase().includes(keyword) ||
      b.description.toLowerCase().includes(keyword)
    );
  }
  return result;
}

// ID指定で取得
function findById(id) {
  return bookmarks.find(b => b.id === id) || null;
}

// 新規作成
function create(data) {
  const now = new Date().toISOString();
  const bookmark = {
    id: nextId++,
    title: data.title,
    url: data.url,
    category: data.category || '未分類',
    description: data.description || '',
    createdAt: now,
    updatedAt: now,
  };
  bookmarks.push(bookmark);
  return bookmark;
}

// 更新
function update(id, data) {
  const index = bookmarks.findIndex(b => b.id === id);
  if (index === -1) return null;

  bookmarks[index] = {
    ...bookmarks[index],
    ...data,
    id, // IDは変更不可
    updatedAt: new Date().toISOString(),
  };
  return bookmarks[index];
}

// 削除
function remove(id) {
  const index = bookmarks.findIndex(b => b.id === id);
  if (index === -1) return null;
  return bookmarks.splice(index, 1)[0];
}

module.exports = { findAll, findById, create, update, remove };

> src/routes/bookmarks.js を書き直して。
  bookmarkStore と response ヘルパーを使って、
  5つのCRUDエンドポイントを実装して。
  基本的なバリデーション（必須項目チェック）も入れて。

// src/routes/bookmarks.js
const express = require('express');
const router = express.Router();
const store = require('../data/bookmarkStore');
const { success, error } = require('../utils/response');

// GET /api/bookmarks — 一覧取得
router.get('/', (req, res) => {
  const filters = {
    category: req.query.category,
    search: req.query.search,
  };
  const bookmarks = store.findAll(filters);
  success(res, bookmarks);
});

// GET /api/bookmarks/:id — 個別取得
router.get('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  if (isNaN(id)) {
    return error(res, 'IDは数値で指定してください', 400);
  }

  const bookmark = store.findById(id);
  if (!bookmark) {
    return error(res, 'ブックマークが見つかりません', 404);
  }
  success(res, bookmark);
});

// POST /api/bookmarks — 新規作成
router.post('/', (req, res) => {
  const { title, url } = req.body;

  // 必須項目のバリデーション
  if (!title || !title.trim()) {
    return error(res, 'タイトルは必須です', 400);
  }
  if (!url || !url.trim()) {
    return error(res, 'URLは必須です', 400);
  }

  // URL形式の簡易チェック
  try {
    new URL(url);
  } catch {
    return error(res, '有効なURLを入力してください', 400);
  }

  const bookmark = store.create(req.body);
  success(res, bookmark, 201);
});

// PUT /api/bookmarks/:id — 更新
router.put('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  if (isNaN(id)) {
    return error(res, 'IDは数値で指定してください', 400);
  }

  const { title, url } = req.body;
  if (title !== undefined && !title.trim()) {
    return error(res, 'タイトルは空にできません', 400);
  }
  if (url !== undefined) {
    try {
      new URL(url);
    } catch {
      return error(res, '有効なURLを入力してください', 400);
    }
  }

  const bookmark = store.update(id, req.body);
  if (!bookmark) {
    return error(res, 'ブックマークが見つかりません', 404);
  }
  success(res, bookmark);
});

// DELETE /api/bookmarks/:id — 削除
router.delete('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  if (isNaN(id)) {
    return error(res, 'IDは数値で指定してください', 400);
  }

  const deleted = store.remove(id);
  if (!deleted) {
    return error(res, 'ブックマークが見つかりません', 404);
  }
  success(res, deleted);
});

module.exports = router;

# 1. 一覧取得
curl http://localhost:3000/api/bookmarks | jq

# 2. 新規作成
curl -X POST http://localhost:3000/api/bookmarks \
  -H "Content-Type: application/json" \
  -d '{"title":"GitHub","url":"https://github.com","category":"開発ツール","description":"コード管理プラットフォーム"}' | jq

# 3. 個別取得（ID=3が作成されたはず）
curl http://localhost:3000/api/bookmarks/3 | jq

# 4. 更新
curl -X PUT http://localhost:3000/api/bookmarks/3 \
  -H "Content-Type: application/json" \
  -d '{"title":"GitHub - コード管理"}' | jq

# 5. 削除
curl -X DELETE http://localhost:3000/api/bookmarks/3 | jq

# 6. バリデーションエラー（タイトルなし）
curl -X POST http://localhost:3000/api/bookmarks \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com"}' | jq

# 7. 存在しないID
curl http://localhost:3000/api/bookmarks/999 | jq

> ブックマーク管理APIにSQLiteデータベースを追加して。
  better-sqlite3をインストールして、
  src/db/database.js にDB初期化コードを作って。
  bookmarksテーブルを作成するマイグレーションも書いて。

npm install better-sqlite3

// src/db/database.js
const Database = require('better-sqlite3');
const path = require('path');

// データベースファイルのパス
const DB_PATH = path.join(__dirname, '../../data/bookmarks.sqlite');

// データベース接続
const db = new Database(DB_PATH);

// WALモードを有効化（パフォーマンス向上）
db.pragma('journal_mode = WAL');

// テーブル作成（存在しなければ）
db.exec(`
  CREATE TABLE IF NOT EXISTS bookmarks (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    url TEXT NOT NULL,
    category TEXT DEFAULT '未分類',
    description TEXT DEFAULT '',
    created_at TEXT DEFAULT (datetime('now')),
    updated_at TEXT DEFAULT (datetime('now'))
  )
`);

module.exports = db;

> src/data/bookmarkStore.js をSQLiteベースに書き換えて。
  better-sqlite3のprepared statementsを使って、
  findAll, findById, create, update, remove の
  5つの関数を実装して。

// src/data/bookmarkStore.js（DB版）
const db = require('../db/database');

// 全件取得（フィルタ対応）
function findAll(filters = {}) {
  let sql = 'SELECT * FROM bookmarks';
  const conditions = [];
  const params = {};

  if (filters.category) {
    conditions.push('category = @category');
    params.category = filters.category;
  }

  if (filters.search) {
    conditions.push('(title LIKE @search OR description LIKE @search)');
    params.search = `%${filters.search}%`;
  }

  if (conditions.length > 0) {
    sql += ' WHERE ' + conditions.join(' AND ');
  }

  sql += ' ORDER BY created_at DESC';

  const stmt = db.prepare(sql);
  return stmt.all(params);
}

// ID指定で取得
function findById(id) {
  const stmt = db.prepare('SELECT * FROM bookmarks WHERE id = ?');
  return stmt.get(id) || null;
}

// 新規作成
function create(data) {
  const stmt = db.prepare(`
    INSERT INTO bookmarks (title, url, category, description)
    VALUES (@title, @url, @category, @description)
  `);

  const result = stmt.run({
    title: data.title,
    url: data.url,
    category: data.category || '未分類',
    description: data.description || '',
  });

  return findById(result.lastInsertRowid);
}

// 更新
function update(id, data) {
  const existing = findById(id);
  if (!existing) return null;

  const stmt = db.prepare(`
    UPDATE bookmarks
    SET title = @title,
        url = @url,
        category = @category,
        description = @description,
        updated_at = datetime('now')
    WHERE id = @id
  `);

  stmt.run({
    id,
    title: data.title ?? existing.title,
    url: data.url ?? existing.url,
    category: data.category ?? existing.category,
    description: data.description ?? existing.description,
  });

  return findById(id);
}

// 削除
function remove(id) {
  const existing = findById(id);
  if (!existing) return null;

  const stmt = db.prepare('DELETE FROM bookmarks WHERE id = ?');
  stmt.run(id);
  return existing;
}

module.exports = { findAll, findById, create, update, remove };

// 危険：SQL文に直接値を埋め込む（SQLインジェクションの危険）
db.exec(`SELECT * FROM bookmarks WHERE category = '${userInput}'`);

// 安全：Prepared Statementを使う
const stmt = db.prepare('SELECT * FROM bookmarks WHERE category = ?');
stmt.all(userInput);

// 名前付きパラメータ（オブジェクトで値を渡す）
const stmt = db.prepare('SELECT * FROM bookmarks WHERE category = @category');
stmt.all({ category: '技術' });

// 位置パラメータ（順番に値を渡す）
const stmt = db.prepare('SELECT * FROM bookmarks WHERE id = ?');
stmt.get(1);

> src/db/seed.js に初期データ投入スクリプトを作って。
  5件のサンプルブックマークを登録して。
  node src/db/seed.js で実行できるようにして。

// src/db/seed.js
const db = require('./database');

// 既存データを削除
db.exec('DELETE FROM bookmarks');

// サンプルデータを投入
const insert = db.prepare(`
  INSERT INTO bookmarks (title, url, category, description)
  VALUES (@title, @url, @category, @description)
`);

const bookmarks = [
  { title: 'Express公式', url: 'https://expressjs.com', category: '技術', description: 'Express.js公式ドキュメント' },
  { title: 'MDN Web Docs', url: 'https://developer.mozilla.org', category: '技術', description: 'Web技術のリファレンス' },
  { title: 'GitHub', url: 'https://github.com', category: '開発ツール', description: 'コード管理プラットフォーム' },
  { title: 'Qiita', url: 'https://qiita.com', category: '技術', description: '技術情報共有サービス' },
  { title: 'Zenn', url: 'https://zenn.dev', category: '技術', description: 'エンジニア向け情報共有' },
];

// トランザクションで一括投入（高速）
const insertMany = db.transaction((items) => {
  for (const item of items) {
    insert.run(item);
  }
});

insertMany(bookmarks);
console.log(`${bookmarks.length}件のブックマークを投入しました`);

node src/db/seed.js
# → 5件のブックマークを投入しました

> ブックマーク管理APIにZodを導入して。
  npm install zodして、
  src/schemas/bookmark.js にブックマークの
  バリデーションスキーマを定義して。
  タイトル（必須、1-200文字）、
  URL（必須、有効なURL）、
  カテゴリ（任意、許可リスト）、
  説明（任意、500文字以内）。

npm install zod

// src/schemas/bookmark.js
const { z } = require('zod');

// 許可されるカテゴリのリスト
const ALLOWED_CATEGORIES = ['技術', '開発ツール', 'デザイン', 'ビジネス', 'エンタメ', '未分類'];

// ブックマーク作成用スキーマ
const createBookmarkSchema = z.object({
  title: z
    .string({ required_error: 'タイトルは必須です' })
    .trim()
    .min(1, 'タイトルは1文字以上で入力してください')
    .max(200, 'タイトルは200文字以内で入力してください'),

  url: z
    .string({ required_error: 'URLは必須です' })
    .trim()
    .url('有効なURLを入力してください'),

  category: z
    .string()
    .trim()
    .refine(val => ALLOWED_CATEGORIES.includes(val), {
      message: `カテゴリは次のいずれかを指定してください: ${ALLOWED_CATEGORIES.join(', ')}`,
    })
    .optional()
    .default('未分類'),

  description: z
    .string()
    .trim()
    .max(500, '説明は500文字以内で入力してください')
    .optional()
    .default(''),
});

// ブックマーク更新用スキーマ（全フィールドを任意に）
const updateBookmarkSchema = createBookmarkSchema.partial();

module.exports = {
  createBookmarkSchema,
  updateBookmarkSchema,
  ALLOWED_CATEGORIES,
};

> src/middleware/validate.js に
  Zodスキーマを受け取ってバリデーションする
  ミドルウェアを作って。
  エラーがあれば { data: null, error: { message, details } } を返して。

// src/middleware/validate.js
const { ZodError } = require('zod');

/**
 * Zodスキーマでリクエストボディをバリデーションするミドルウェア
 * @param {import('zod').ZodSchema} schema - Zodスキーマ
 */
function validate(schema) {
  return (req, res, next) => {
    try {
      // parseで検証とデータ変換を同時に行う
      const validated = schema.parse(req.body);
      // バリデーション済みデータでreq.bodyを置き換え
      req.body = validated;
      next();
    } catch (err) {
      if (err instanceof ZodError) {
        // Zodのエラーを整形
        const details = err.errors.map(e => ({
          field: e.path.join('.'),
          message: e.message,
        }));

        return res.status(400).json({
          data: null,
          error: {
            message: '入力データにエラーがあります',
            details,
          },
        });
      }
      next(err);
    }
  };
}

module.exports = validate;

// src/routes/bookmarks.js
const express = require('express');
const router = express.Router();
const store = require('../data/bookmarkStore');
const { success, error } = require('../utils/response');
const validate = require('../middleware/validate');
const { createBookmarkSchema, updateBookmarkSchema } = require('../schemas/bookmark');

// GET /api/bookmarks — 一覧取得（バリデーション不要）
router.get('/', (req, res) => {
  const filters = {
    category: req.query.category,
    search: req.query.search,
  };
  const bookmarks = store.findAll(filters);
  success(res, bookmarks);
});

// GET /api/bookmarks/:id — 個別取得
router.get('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  if (isNaN(id)) return error(res, 'IDは数値で指定してください', 400);

  const bookmark = store.findById(id);
  if (!bookmark) return error(res, 'ブックマークが見つかりません', 404);
  success(res, bookmark);
});

// POST /api/bookmarks — 新規作成（バリデーションミドルウェア適用）
router.post('/', validate(createBookmarkSchema), (req, res) => {
  const bookmark = store.create(req.body);
  success(res, bookmark, 201);
});

// PUT /api/bookmarks/:id — 更新（バリデーションミドルウェア適用）
router.put('/:id', validate(updateBookmarkSchema), (req, res) => {
  const id = parseInt(req.params.id);
  if (isNaN(id)) return error(res, 'IDは数値で指定してください', 400);

  const bookmark = store.update(id, req.body);
  if (!bookmark) return error(res, 'ブックマークが見つかりません', 404);
  success(res, bookmark);
});

// DELETE /api/bookmarks/:id — 削除
router.delete('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  if (isNaN(id)) return error(res, 'IDは数値で指定してください', 400);

  const deleted = store.remove(id);
  if (!deleted) return error(res, 'ブックマークが見つかりません', 404);
  success(res, deleted);
});

module.exports = router;

// 入力データ
{
  title: "  Express.js  ",   // 前後に余計な空白
  url: "https://expressjs.com",
  // category は省略
  // description は省略
}

// Zodスキーマ通過後
{
  title: "Express.js",       // trimで空白除去
  url: "https://expressjs.com",
  category: "未分類",         // default値が適用
  description: ""             // default値が適用
}

# 正常な作成
curl -X POST http://localhost:3000/api/bookmarks \
  -H "Content-Type: application/json" \
  -d '{"title":"Node.js","url":"https://nodejs.org","category":"技術"}'

# タイトルなし → エラー
curl -X POST http://localhost:3000/api/bookmarks \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com"}'

# 不正なURL → エラー
curl -X POST http://localhost:3000/api/bookmarks \
  -H "Content-Type: application/json" \
  -d '{"title":"テスト","url":"not-a-url"}'

# 許可されていないカテゴリ → エラー
curl -X POST http://localhost:3000/api/bookmarks \
  -H "Content-Type: application/json" \
  -d '{"title":"テスト","url":"https://example.com","category":"無効"}'

# タイトルが201文字 → エラー
curl -X POST http://localhost:3000/api/bookmarks \
  -H "Content-Type: application/json" \
  -d "{\"title\":\"$(python3 -c 'print("a" * 201)')\",\"url\":\"https://example.com\"}"

1. ユーザーがメール+パスワードでログイン
2. サーバーがパスワードを検証し、JWTトークンを生成して返す
3. クライアントはトークンを保存し、以降のリクエストの
   Authorization ヘッダーに付与する
4. サーバーはトークンを検証し、有効なら処理を続行する

xxxxx.yyyyy.zzzzz
ヘッダー.ペイロード.署名

> ブックマーク管理APIにJWT認証を追加して。
  jsonwebtokenとbcryptjsをインストールして。
  usersテーブルを作成して（id, email, password_hash, name）。
  src/routes/auth.js に登録・ログインの
  エンドポイントを作って。

npm install jsonwebtoken bcryptjs

// src/db/database.js に追加
db.exec(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    email TEXT NOT NULL UNIQUE,
    password_hash TEXT NOT NULL,
    name TEXT NOT NULL,
    created_at TEXT DEFAULT (datetime('now'))
  )
`);

// bookmarksテーブルにuser_idカラムを追加
// （既存テーブルがある場合）
try {
  db.exec('ALTER TABLE bookmarks ADD COLUMN user_id INTEGER REFERENCES users(id)');
} catch {
  // カラムが既に存在する場合はエラーを無視
}

// src/routes/auth.js
const express = require('express');
const router = express.Router();
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const db = require('../db/database');
const { z } = require('zod');

const JWT_SECRET = process.env.JWT_SECRET || 'dev-secret-change-in-production';
const JWT_EXPIRES_IN = '24h';

// 登録用スキーマ
const registerSchema = z.object({
  email: z.string().email('有効なメールアドレスを入力してください'),
  password: z.string().min(8, 'パスワードは8文字以上で入力してください'),
  name: z.string().trim().min(1, '名前は必須です').max(100),
});

// POST /api/auth/register — ユーザー登録
router.post('/register', async (req, res) => {
  try {
    const { email, password, name } = registerSchema.parse(req.body);

    // メールアドレスの重複チェック
    const existing = db.prepare('SELECT id FROM users WHERE email = ?').get(email);
    if (existing) {
      return res.status(409).json({
        data: null,
        error: 'このメールアドレスは既に登録されています',
      });
    }

    // パスワードのハッシュ化
    const salt = await bcrypt.genSalt(10);
    const passwordHash = await bcrypt.hash(password, salt);

    // ユーザー作成
    const stmt = db.prepare(
      'INSERT INTO users (email, password_hash, name) VALUES (?, ?, ?)'
    );
    const result = stmt.run(email, passwordHash, name);

    // JWTトークン生成
    const token = jwt.sign(
      { userId: result.lastInsertRowid, email },
      JWT_SECRET,
      { expiresIn: JWT_EXPIRES_IN }
    );

    res.status(201).json({
      data: {
        user: { id: result.lastInsertRowid, email, name },
        token,
      },
      error: null,
    });
  } catch (err) {
    if (err.name === 'ZodError') {
      return res.status(400).json({
        data: null,
        error: { message: '入力データにエラーがあります', details: err.errors },
      });
    }
    res.status(500).json({ data: null, error: 'サーバーエラーが発生しました' });
  }
});

module.exports = router;

// src/routes/auth.js に追加

// ログイン用スキーマ
const loginSchema = z.object({
  email: z.string().email('有効なメールアドレスを入力してください'),
  password: z.string().min(1, 'パスワードは必須です'),
});

// POST /api/auth/login — ログイン
router.post('/login', async (req, res) => {
  try {
    const { email, password } = loginSchema.parse(req.body);

    // ユーザー検索
    const user = db.prepare('SELECT * FROM users WHERE email = ?').get(email);
    if (!user) {
      return res.status(401).json({
        data: null,
        error: 'メールアドレスまたはパスワードが正しくありません',
      });
    }

    // パスワード検証
    const isValid = await bcrypt.compare(password, user.password_hash);
    if (!isValid) {
      return res.status(401).json({
        data: null,
        error: 'メールアドレスまたはパスワードが正しくありません',
      });
    }

    // JWTトークン生成
    const token = jwt.sign(
      { userId: user.id, email: user.email },
      JWT_SECRET,
      { expiresIn: JWT_EXPIRES_IN }
    );

    res.json({
      data: {
        user: { id: user.id, email: user.email, name: user.name },
        token,
      },
      error: null,
    });
  } catch (err) {
    if (err.name === 'ZodError') {
      return res.status(400).json({
        data: null,
        error: { message: '入力データにエラーがあります', details: err.errors },
      });
    }
    res.status(500).json({ data: null, error: 'サーバーエラーが発生しました' });
  }
});

> src/middleware/auth.js にJWT認証ミドルウェアを作って。
  Authorization: Bearer <token> ヘッダーからトークンを取得して、
  検証が成功したら req.user にユーザー情報をセットして。

// src/middleware/auth.js
const jwt = require('jsonwebtoken');
const JWT_SECRET = process.env.JWT_SECRET || 'dev-secret-change-in-production';

function authenticate(req, res, next) {
  // Authorizationヘッダーからトークンを取得
  const authHeader = req.headers.authorization;
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({
      data: null,
      error: '認証トークンが必要です',
    });
  }

  const token = authHeader.split(' ')[1];

  try {
    // トークンの検証
    const decoded = jwt.verify(token, JWT_SECRET);
    req.user = { userId: decoded.userId, email: decoded.email };
    next();
  } catch (err) {
    if (err.name === 'TokenExpiredError') {
      return res.status(401).json({
        data: null,
        error: 'トークンの有効期限が切れています',
      });
    }
    return res.status(401).json({
      data: null,
      error: '無効なトークンです',
    });
  }
}

module.exports = authenticate;

// src/index.js
const authRoutes = require('./routes/auth');
const bookmarkRoutes = require('./routes/bookmarks');
const authenticate = require('./middleware/auth');

// 認証不要
app.use('/api/auth', authRoutes);

// 認証必要（authenticateミドルウェアを挟む）
app.use('/api/bookmarks', authenticate, bookmarkRoutes);

# 1. ユーザー登録
curl -X POST http://localhost:3000/api/auth/register \
  -H "Content-Type: application/json" \
  -d '{"email":"test@example.com","password":"password123","name":"テストユーザー"}'

# レスポンスのtokenをコピー

# 2. トークンなしでアクセス → 401エラー
curl http://localhost:3000/api/bookmarks

# 3. トークン付きでアクセス → 成功
curl http://localhost:3000/api/bookmarks \
  -H "Authorization: Bearer ここにトークンを貼る"

# 4. ログイン
curl -X POST http://localhost:3000/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"test@example.com","password":"password123"}'

> src/utils/errors.js にカスタムエラークラスを作って。
  AppError をベースに、
  NotFoundError（404）、
  ValidationError（400）、
  AuthenticationError（401）、
  ForbiddenError（403）を定義して。
  それぞれステータスコードを持つようにして。

// src/utils/errors.js

class AppError extends Error {
  constructor(message, statusCode = 500) {
    super(message);
    this.name = this.constructor.name;
    this.statusCode = statusCode;
    this.isOperational = true; // 運用上のエラー（予期されるエラー）

    // スタックトレースからこのコンストラクタを除外
    Error.captureStackTrace(this, this.constructor);
  }
}

class NotFoundError extends AppError {
  constructor(message = 'リソースが見つかりません') {
    super(message, 404);
  }
}

class ValidationError extends AppError {
  constructor(message = '入力データが不正です', details = []) {
    super(message, 400);
    this.details = details;
  }
}

class AuthenticationError extends AppError {
  constructor(message = '認証が必要です') {
    super(message, 401);
  }
}

class ForbiddenError extends AppError {
  constructor(message = 'この操作は許可されていません') {
    super(message, 403);
  }
}

module.exports = {
  AppError,
  NotFoundError,
  ValidationError,
  AuthenticationError,
  ForbiddenError,
};

> src/middleware/errorHandler.js に
  グローバルエラーハンドリングミドルウェアを作って。
  AppError系は適切なステータスコードで、
  予期しないエラーは500で返す。
  本番環境ではスタックトレースを隠す。

// src/middleware/errorHandler.js
const { AppError } = require('../utils/errors');

function errorHandler(err, req, res, next) {
  // デフォルト値
  let statusCode = err.statusCode || 500;
  let message = err.message || 'サーバー内部エラーが発生しました';
  let details = err.details || undefined;

  // 予期しないエラーのログ出力
  if (!err.isOperational) {
    console.error('=== 予期しないエラー ===');
    console.error(`${req.method} ${req.originalUrl}`);
    console.error(err.stack);
    console.error('========================');

    // 本番環境では詳細を隠す
    if (process.env.NODE_ENV === 'production') {
      statusCode = 500;
      message = 'サーバー内部エラーが発生しました';
      details = undefined;
    }
  }

  // 統一レスポンス形式
  const response = {
    data: null,
    error: {
      message,
      ...(details && { details }),
      ...(process.env.NODE_ENV !== 'production' && { stack: err.stack }),
    },
  };

  res.status(statusCode).json(response);
}

module.exports = errorHandler;

// src/middleware/notFound.js
const { NotFoundError } = require('../utils/errors');

function notFound(req, res, next) {
  next(new NotFoundError(`${req.method} ${req.originalUrl} は存在しません`));
}

module.exports = notFound;

> src/utils/asyncHandler.js に
  async関数のエラーを自動キャッチする
  ラッパー関数を作って。

// src/utils/asyncHandler.js

/**
 * async関数をラップしてエラーを自動キャッチする
 * try/catchを毎回書く必要がなくなる
 */
function asyncHandler(fn) {
  return (req, res, next) => {
    Promise.resolve(fn(req, res, next)).catch(next);
  };
}

module.exports = asyncHandler;

const asyncHandler = require('../utils/asyncHandler');
const { NotFoundError } = require('../utils/errors');

// asyncHandler なし → try/catchが必要
router.get('/:id', async (req, res, next) => {
  try {
    const bookmark = await findBookmark(req.params.id);
    if (!bookmark) throw new NotFoundError();
    res.json({ data: bookmark, error: null });
  } catch (err) {
    next(err);
  }
});

// asyncHandler あり → try/catch不要、エラーは自動でnextに渡される
router.get('/:id', asyncHandler(async (req, res) => {
  const bookmark = await findBookmark(req.params.id);
  if (!bookmark) throw new NotFoundError();
  res.json({ data: bookmark, error: null });
}));

// src/routes/bookmarks.js（エラーハンドリング改善版）
const express = require('express');
const router = express.Router();
const store = require('../data/bookmarkStore');
const asyncHandler = require('../utils/asyncHandler');
const { NotFoundError, ValidationError } = require('../utils/errors');
const validate = require('../middleware/validate');
const { createBookmarkSchema, updateBookmarkSchema } = require('../schemas/bookmark');

router.get('/:id', asyncHandler(async (req, res) => {
  const id = parseInt(req.params.id);
  if (isNaN(id)) throw new ValidationError('IDは数値で指定してください');

  const bookmark = store.findById(id);
  if (!bookmark) throw new NotFoundError('ブックマークが見つかりません');

  res.json({ data: bookmark, error: null });
}));

router.post('/', validate(createBookmarkSchema), asyncHandler(async (req, res) => {
  const bookmark = store.create(req.body);
  res.status(201).json({ data: bookmark, error: null });
}));

// 他のルートも同様にリファクタリング

// src/index.js
const express = require('express');
const cors = require('cors');
const morgan = require('morgan');
const bookmarkRoutes = require('./routes/bookmarks');
const authRoutes = require('./routes/auth');
const authenticate = require('./middleware/auth');
const notFound = require('./middleware/notFound');
const errorHandler = require('./middleware/errorHandler');

const app = express();

// 1. 基本ミドルウェア
app.use(cors());
app.use(morgan('dev'));
app.use(express.json());

// 2. ルート定義
app.get('/', (req, res) => {
  res.json({ message: 'Bookmark API is running' });
});
app.use('/api/auth', authRoutes);
app.use('/api/bookmarks', authenticate, bookmarkRoutes);

// 3. 404ハンドラ（ルートの後、エラーハンドラの前）
app.use(notFound);

// 4. エラーハンドラ（必ず最後）
app.use(errorHandler);

app.listen(process.env.PORT || 3000);