MongoDB: Express/Mongoose統合：アプリケーションアーキテクチャ

shophub-api/
├── package.json
├── .env                    # 環境変数（非Git管理）
├── .env.example            # 環境変数テンプレート
├── src/
│   ├── app.js              # Expressアプリケーション
│   ├── config/
│   │   └── db.js           # Mongoose接続
│   ├── models/             # データモデル
│   │   ├── User.js
│   │   ├── Product.js
│   │   └── Review.js
│   ├── controllers/        # ビジネスロジック
│   │   ├── authController.js
│   │   ├── productController.js
│   │   └── reviewController.js
│   ├── routes/             # ルーティング
│   │   ├── auth.js
│   │   ├── products.js
│   │   └── reviews.js
│   ├── middlewares/        # ミドルウェア
│   │   ├── auth.js         # JWT認証
│   │   ├── errorHandler.js
│   │   └── validate.js
│   ├── validators/         # リクエスト検証
│   │   └── schemas.js
│   └── utils/              # ユーティリティ
│       ├── logger.js
│       └── jwt.js
└── README.md

// === Mongoose接続設定 ===
const mongoose = require('mongoose');

mongoose.connect(process.env.MONGODB_URI, {
  maxPoolSize: 50,          // 最大接続数（デフォルト100）
  minPoolSize: 5,           // 最小接続数（デフォルト0）
  maxIdleTimeMS: 30000,     // 接続アイドルタイムアウト（デフォルト無制限）
  waitQueueTimeoutMS: 10000, // 接続待機タイムアウト
  serverSelectionTimeoutMS: 5000, // サーバー選択タイムアウト
  socketTimeoutMS: 45000,   // ソケットタイムアウト
  family: 4                 // IPv4を使用
})
.then(() => console.log('MongoDB接続成功'))
.catch(err => console.error('MongoDB接続エラー:', err));

// === 接続イベント監視 ===
mongoose.connection.on('connected', () => {
  console.log('Mongooseが接続されました');
});

mongoose.connection.on('error', (err) => {
  console.error('Mongoose接続エラー:', err);
});

mongoose.connection.on('disconnected', () => {
  console.log('Mongoose接続が切断されました');
});

// === アプリケーション終了時に接続をクローズ ===
process.on('SIGINT', async () => {
  await mongoose.connection.close();
  console.log('MongoDB接続を閉じました');
  process.exit(0);
});

const UserSchema = new mongoose.Schema({
  email: {
    type: String,
    required: [true, 'メールアドレスは必須です'],
    unique: true,
    lowercase: true,
    trim: true,
    match: [/^\S+@\S+\.\S+$/, '無効なメール形式です']
  },
  username: {
    type: String,
    required: true,
    unique: true,
    minlength: 3,
    maxlength: 30,
    match: [/^[a-zA-Z0-9_]+$/, '英数字とアンダースコアのみ']
  },
  passwordHash: {
    type: String,
    required: true,
    minlength: 60,  // bcryptハッシュ長
    select: false    // デフォルトで返さない
  },
  role: {
    type: String,
    enum: ['customer', 'admin', 'moderator'],
    default: 'customer'
  },
  isActive: {
    type: Boolean,
    default: true
  }
}, {
  timestamps: true,           // createdAt, updatedAtを自動管理
  toJSON: { virtuals: true }, // JSONシリアライズ時に仮想フィールドを含める
  toObject: { virtuals: true }
});

// インデックス作成
UserSchema.index({ email: 1 }, { unique: true });
UserSchema.index({ username: 1 }, { unique: true });

const ProductSchema = new mongoose.Schema({
  sku: { type: String, required: true, unique: true },
  title: { type: String, required: true },
  price: { type: Number, required: true },
  isDeleted: { type: Boolean, default: false, select: false }
}, { timestamps: true });

// 全findクエリで自動フィルタリング（ソフト削除を除外）
ProductSchema.pre(/^find/, function(next) {
  this.where({ isDeleted: { $ne: true } });
  next();
});

// 復元メソッド
ProductSchema.methods.restore = function() {
  this.isDeleted = false;
  return this.save();
};

const bcrypt = require('bcrypt');

UserSchema.pre('save', async function(next) {
  // passwordHashが変更された場合のみハッシュ化
  if (!this.isModified('passwordHash')) return next();
  
  // パスワードをハッシュ化
  this.passwordHash = await bcrypt.hash(this.passwordHash, 10);
  next();
});

// パスワード検証メソッド
UserSchema.methods.comparePassword = function(candidate) {
  return bcrypt.compare(candidate, this.passwordHash);
};

UserSchema.pre('findOneAndUpdate', function(next) {
  // updatedAtを自動更新
  this.set({ updatedAt: new Date() });
  next();
});

UserSchema.post('findOneAndDelete', async function(doc) {
  // ユーザー削除後、関連データをクリーンアップ
  if (doc) {
    await Review.deleteMany({ userId: doc._id });
    await Cart.deleteOne({ userId: doc._id });
  }
});

// === routes/products.js ===
const express = require('express');
const router = express.Router();
const productController = require('../controllers/productController');
const { authenticate, authorize } = require('../middlewares/auth');
const { validateProduct } = require('../middlewares/validate');

// 一般ユーザー向けルート
router.get('/', productController.listProducts);
router.get('/:id', productController.getProduct);

// 管理者専用ルート
router.post('/',
  authenticate,
  authorize('admin'),
  validateProduct,
  productController.createProduct
);

router.put('/:id',
  authenticate,
  authorize('admin'),
  validateProduct,
  productController.updateProduct
);

router.delete('/:id',
  authenticate,
  authorize('admin'),
  productController.deleteProduct
);

module.exports = router;

// === controllers/productController.js ===
const Product = require('../models/Product');

exports.listProducts = async (req, res) => {
  const { page = 1, limit = 20, category } = req.query;

  const query = { isActive: true };
  if (category) query.category = category;

  const [products, total] = await Promise.all([
    Product.find(query)
      .select('sku title price thumbnail rating')
      .sort({ createdAt: -1 })
      .limit(+limit)
      .skip((page - 1) * limit)
      .lean(),
    Product.countDocuments(query)
  ]);

  res.json({
    success: true,
    data: products,
    meta: { page: +page, limit: +limit, total }
  });
};

exports.getProduct = async (req, res) => {
  const product = await Product.findById(req.params.id);
  if (!product) {
    return res.status(404).json({ error: '商品が見つかりません' });
  }
  res.json(product);
};

exports.createProduct = async (req, res) => {
  const product = await Product.create(req.body);
  res.status(201).json(product);
};

exports.updateProduct = async (req, res) => {
  const product = await Product.findByIdAndUpdate(
    req.params.id,
    req.body,
    { new: true, runValidators: true }
  );
  if (!product) {
    return res.status(404).json({ error: '商品が見つかりません' });
  }
  res.json(product);
};

exports.deleteProduct = async (req, res) => {
  const product = await Product.findByIdAndDelete(req.params.id);
  if (!product) {
    return res.status(404).json({ error: '商品が見つかりません' });
  }
  res.json({ message: '商品を削除しました' });
};

// === middlewares/errorHandler.js ===
const errorHandler = (err, req, res, next) => {
  console.error('エラー:', err);

  // Mongoose検証エラー
  if (err.name === 'ValidationError') {
    const messages = Object.values(err.errors).map(e => e.message);
    return res.status(400).json({
      error: '検証エラー',
      details: messages
    });
  }

  // MongoDB重複キーエラー
  if (err.code === 11000) {
    const field = Object.keys(err.keyValue)[0];
    return res.status(409).json({
      error: `${field}は既に使用されています`
    });
  }

  // JWTエラー
  if (err.name === 'JsonWebTokenError') {
    return res.status(401).json({ error: '無効なトークンです' });
  }

  // デフォルトサーバーエラー
  res.status(500).json({
    error: 'サーバーエラーが発生しました'
  });
};

module.exports = errorHandler;

// === app.js ===
const errorHandler = require('./middlewares/errorHandler');

// ルーティングの後にエラーハンドラを登録
app.use(errorHandler);

// app.js - Expressアプリケーションのエントリーポイント
const express = require('express');
const mongoose = require('mongoose');
const errorHandler = require('./middlewares/errorHandler');

const app = express();

// ミドルウェア設定
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// データベース接続
const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI, {
      maxPoolSize: 50,
      minPoolSize: 5,
      serverSelectionTimeoutMS: 5000
    });
    console.log('MongoDB接続成功');
  } catch (error) {
    console.error('MongoDB接続エラー:', error.message);
    process.exit(1);
  }
};

// 接続イベント監視
mongoose.connection.on('disconnected', () => {
  console.log('MongoDB接続が切断されました');
});

// ルーティング
app.use('/api/products', require('./routes/products'));
app.use('/api/users', require('./routes/users'));

// ヘルスチェック
app.get('/health', (req, res) => {
  const dbStatus = mongoose.connection.readyState === 1 ? 'connected' : 'disconnected';
  res.json({ status: 'ok', database: dbStatus });
});

// エラーハンドラ（最後に配置）
app.use(errorHandler);

// グレースフルシャットダウン
process.on('SIGINT', async () => {
  await mongoose.connection.close();
  console.log('MongoDB接続を閉じました');
  process.exit(0);
});

// 起動
const PORT = process.env.PORT || 3000;
connectDB().then(() => {
  app.listen(PORT, () => console.log(`サーバー起動: http://localhost:${PORT}`));
});

module.exports = app;

// controllers/productController.js - 商品CRUDコントローラー
const Product = require('../models/Product');
const mongoose = require('mongoose');

// 商品一覧（ページネーション + フィルタ）
exports.listProducts = async (req, res, next) => {
  try {
    const { page = 1, limit = 20, category, minPrice, maxPrice } = req.query;

    const query = { isActive: true };
    if (category) query.category = category;
    if (minPrice || maxPrice) {
      query.price = {};
      if (minPrice) query.price.$gte = +minPrice;
      if (maxPrice) query.price.$lte = +maxPrice;
    }

    const [products, total] = await Promise.all([
      Product.find(query)
        .select('sku title price category avgRating')
        .sort({ createdAt: -1 })
        .limit(+limit)
        .skip((+page - 1) * +limit)
        .lean(),
      Product.countDocuments(query)
    ]);

    res.json({
      success: true,
      data: products,
      meta: { page: +page, limit: +limit, total, pages: Math.ceil(total / +limit) }
    });
  } catch (error) {
    next(error);
  }
};

// 商品詳細
exports.getProduct = async (req, res, next) => {
  try {
    const { id } = req.params;

    if (!mongoose.Types.ObjectId.isValid(id)) {
      return res.status(400).json({ success: false, error: '無効なID形式です' });
    }

    const product = await Product.findById(id);
    if (!product || !product.isActive) {
      return res.status(404).json({ success: false, error: '商品が見つかりません' });
    }

    res.json({ success: true, data: product });
  } catch (error) {
    next(error);
  }
};

// 商品作成
exports.createProduct = async (req, res, next) => {
  try {
    const { sku, title, price, category, description, stock } = req.body;

    // SKU重複チェック
    const existing = await Product.findOne({ sku });
    if (existing) {
      return res.status(409).json({ success: false, error: `SKU ${sku}は既に存在します` });
    }

    const product = await Product.create({ sku, title, price, category, description, stock });
    res.status(201).json({ success: true, data: product });
  } catch (error) {
    next(error);
  }
};

// 商品更新
exports.updateProduct = async (req, res, next) => {
  try {
    const { id } = req.params;
    const updates = req.body;

    // 更新禁止フィールドを除外
    delete updates._id;
    delete updates.createdAt;
    delete updates.__v;

    const product = await Product.findByIdAndUpdate(
      id,
      { $set: updates },
      { new: true, runValidators: true }
    );

    if (!product) {
      return res.status(404).json({ success: false, error: '商品が見つかりません' });
    }

    res.json({ success: true, data: product });
  } catch (error) {
    next(error);
  }
};

// 商品削除（ソフト削除）
exports.deleteProduct = async (req, res, next) => {
  try {
    const { id } = req.params;

    const product = await Product.findByIdAndUpdate(
      id,
      { $set: { isDeleted: true } },
      { new: true }
    );

    if (!product) {
      return res.status(404).json({ success: false, error: '商品が見つかりません' });
    }

    res.status(204).send();
  } catch (error) {
    next(error);
  }
};

// middlewares/auth.js - JWT認証ミドルウェア
const jwt = require('jsonwebtoken');

// JWT認証
exports.authenticate = (req, res, next) => {
  const authHeader = req.header('Authorization');

  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ error: '認証が必要です' });
  }

  const token = authHeader.replace('Bearer ', '');

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;  // { id, role, username }
    next();
  } catch (err) {
    return res.status(401).json({ error: '無効なトークンです' });
  }
};

// 権限チェック
exports.authorize = (...roles) => {
  return (req, res, next) => {
    if (!req.user) {
      return res.status(401).json({ error: '認証が必要です' });
    }

    if (!roles.includes(req.user.role)) {
      return res.status(403).json({ error: 'この操作を行う権限がありません' });
    }

    next();
  };
};

// routes/products.js - 商品ルーティング
const express = require('express');
const router = express.Router();
const productController = require('../controllers/productController');
const { authenticate, authorize } = require('../middlewares/auth');

// 公開ルート（認証不要）
router.get('/', productController.listProducts);
router.get('/:id', productController.getProduct);

// 管理者専用ルート
router.post('/',
  authenticate,
  authorize('admin'),
  productController.createProduct
);

router.put('/:id',
  authenticate,
  authorize('admin'),
  productController.updateProduct
);

router.delete('/:id',
  authenticate,
  authorize('admin'),
  productController.deleteProduct
);

module.exports = router;

// テストコマンド
// 商品一覧: curl http://localhost:3000/api/products
// 商品作成（管理者）: curl -X POST http://localhost:3000/api/products \
//   -H "Authorization: Bearer <token>" \
//   -H "Content-Type: application/json" \
//   -d '{"sku":"TEST-001","title":"Test Product","price":99,"category":"Electronics"}'