MongoDB: Mongoose応用パターン：パフォーマンスと柔軟性

// === 基本的なpopulate ===
const user = await User.findById(userId).populate('addresses');
// SELECT u.*, a.* FROM users u LEFT JOIN addresses a ON u._id = a.userId

// === ネストしたpopulate ===
const order = await Order.findById(orderId)
  .populate('userId')
  .populate({
    path: 'items.productId',
    select: 'sku title price'
  });

// === 条件付きpopulate ===
const orders = await Order.find()
  .populate({
    path: 'userId',
    match: { isActive: true },
    select: 'username avatar'
  });

// === 基本Userモデル ===
const UserSchema = new mongoose.Schema({
  email: String,
  username: String,
  passwordHash: String
}, { discriminatorKey: 'role' });

const User = mongoose.model('User', UserSchema);

// === Customer Discriminator ===
const Customer = User.discriminator('Customer', new mongoose.Schema({
  loyaltyPoints: { type: Number, default: 0 },
  preferredCategories: [String]
}));

// === Admin Discriminator ===
const Admin = User.discriminator('Admin', new mongoose.Schema({
  permissions: [String],
  lastLoginAt: Date
}));

// === 異なるロールを作成 ===
const customer = await Customer.create({
  email: 'alice@example.com',
  username: 'alice',
  passwordHash: '...',
  loyaltyPoints: 100,
  preferredCategories: ['Electronics']
});

const admin = await Admin.create({
  email: 'admin@example.com',
  username: 'admin',
  passwordHash: '...',
  permissions: ['manage_products']
});

// === 検索時、roleで分類 ===
const customers = await Customer.find();
const admins = await Admin.find();
// 全データは同じコレクション(users)にある、discriminatorKeyで分類

// === 通常クエリ：Mongoose Documentを返す ===
const products = await Product.find();
// 各productはMongoose Document（save()等のメソッドを持つ）

// === lean()：純粋なJSオブジェクトを返す ===
const products = await Product.find().lean();
// 各productはプレーンオブジェクト、パフォーマンス3-5倍向上

// === 比較テスト ===
console.time('without lean');
const a = await Product.find({ category: 'Electronics' }).limit(100);
console.timeEnd('without lean');  // ~150ms

console.time('with lean');
const b = await Product.find({ category: 'Electronics' }).lean().limit(100);
console.timeEnd('with lean');  // ~30ms

// === Mongooseで集計を使用 ===
const stats = await Product.aggregate([
  { $match: { isActive: true } },
  { $group: { _id: '$category', count: { $sum: 1 }, avgPrice: { $avg: '$price' } } },
  { $sort: { count: -1 } }
]);

// === aggregate + populate（Mongoose 6+）===
const results = await Order.aggregate([
  { $match: { status: 'paid' } },
  {
    $lookup: {
      from: 'users',
      localField: 'userId',
      foreignField: '_id',
      as: 'customer'
    }
  },
  { $unwind: '$customer' }
]);

const ProductSchema = new mongoose.Schema({
  sku: { type: String, index: true, unique: true },
  title: { type: String, text: true },  // テキストインデックス
  price: { type: Number, index: true },
  category: { type: String, index: true }
});

// === 複合インデックス ===
ProductSchema.index({ category: 1, price: -1 });

// === 部分インデックス ===
ProductSchema.index(
  { category: 1 },
  { partialFilterExpression: { isActive: true } }
);

// === TTLインデックス ===
ProductSchema.index(
  { createdAt: 1 },
  { expireAfterSeconds: 30 * 24 * 60 * 60 }
);

// === 最適化1：autoIndex無効化（本番環境）===
mongoose.connect(uri, { autoIndex: false });
// 起動時に手動でインデックス作成：await Product.syncIndexes();

// === 最適化2：バルク操作 ===
await Product.bulkWrite([
  { updateOne: { filter: { sku: 'A' }, update: { $inc: { stock: -1 } } } },
  { updateOne: { filter: { sku: 'B' }, update: { $inc: { stock: -1 } } } }
]);

// === 最適化3：投影でデータ転送を削減 ===
const products = await Product.find()
  .select('sku title price')  // 3フィールドのみ検索
  .lean();

// === 最適化4：カーソルでストリーム処理 ===
const cursor = Product.find().cursor();
for await (const doc of cursor) {
  // 各ドキュメントを処理
}

// === 最適化5：バルクインサート ===
await Product.insertMany(docs, { ordered: false });

// === 最適化された一覧API ===
app.get('/api/products', async (req, res) => {
  const { page = 1, limit = 20, category, search } = req.query;

  // 1. クエリを構築
  const query = { isActive: true };
  if (category) query.category = category;
  if (search) query.$text = { $search: search };

  // 2. 並列クエリ（find + count）
  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, pages: Math.ceil(total / limit) }
  });
});

// === シーン：ShopHub注文詳細API（3層関連）===
const mongoose = require('mongoose');

// スキーマ定義
const AddressSchema = new mongoose.Schema({ city: String, country: String, zipCode: String });
const UserSchema = new mongoose.Schema({
  email: String, username: String,
  addresses: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Address' }]
});
const ProductSchema = new mongoose.Schema({ sku: String, title: String, price: Number, thumbnail: String });
const OrderSchema = new mongoose.Schema({
  orderNumber: String,
  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
  items: [{ productId: { type: mongoose.Schema.Types.ObjectId, ref: 'Product' }, qty: Number, price: Number }],
  status: String
}, { timestamps: true });

const Address = mongoose.model('Address', AddressSchema);
const User = mongoose.model('User', UserSchema);
const Product = mongoose.model('Product', ProductSchema);
const Order = mongoose.model('Order', OrderSchema);

// 3層populate + lean
const order = await Order.findById('647f1f77bcf86cd799439001')
  .populate({ path: 'userId', select: 'username email',
    populate: { path: 'addresses', select: 'city country' }
  })
  .populate({ path: 'items.productId', select: 'sku title price' })
  .lean();

console.log({
  orderNumber: order.orderNumber,
  customer: order.userId.username,
  city: order.userId.addresses[0]?.city,
  items: order.items.map(i => `${i.productId.title} x${i.qty}`)
});
// 出力：{ orderNumber: 'ORD-001', customer: 'alice', city: 'San Francisco',
//         items: ['Smartphone X x2', 'Laptop Pro x1'] }

// === 1. populate多段リレーション ===
// 注文 + ユーザー + 商品（3層ネスト）
const order = await Order.findById(orderId)
  .populate({
    path: 'userId',
    select: 'username email avatar',
    populate: { path: 'addresses', select: 'city country' }  // ユーザーの住所
  })
  .populate({
    path: 'items.productId',
    select: 'sku title price thumbnail'
  })
  .lean();  // パフォーマンス最適化

console.log('注文:', {
  orderNumber: order.orderNumber,
  customer: {
    username: order.userId.username,
    address: order.userId.addresses[0]?.city
  },
  items: order.items.map(i => ({
    product: i.productId.title,
    qty: i.qty,
    price: i.price
  }))
});

// === 2. discriminator単一コレクション、複数スキーマ ===
// User基底クラス
const UserSchema = new mongoose.Schema({
  email: { type: String, required: true, unique: true },
  username: String,
  passwordHash: String,
  createdAt: { type: Date, default: Date.now }
}, { discriminatorKey: 'role' });

const User = mongoose.model('User', UserSchema);

// Customer Discriminator（Userを継承 + 拡張フィールド）
const Customer = User.discriminator('Customer', new mongoose.Schema({
  loyaltyPoints: { type: Number, default: 0 },
  preferredCategories: [String],
  totalSpent: mongoose.Schema.Types.Decimal128
}));

// Admin Discriminator
const Admin = User.discriminator('Admin', new mongoose.Schema({
  permissions: [String],
  lastLoginAt: Date
}));

// 異なるロールを作成（全てusersコレクションに存在、roleフィールドで区別）
const customer = await Customer.create({
  email: 'alice@example.com',
  username: 'alice',
  passwordHash: '...',
  loyaltyPoints: 100,
  preferredCategories: ['Electronics']
});

const admin = await Admin.create({
  email: 'admin@example.com',
  username: 'admin',
  passwordHash: '...',
  permissions: ['manage_products', 'manage_users']
});

// 検索時、roleで自動フィルタ
const customers = await Customer.find({ loyaltyPoints: { $gt: 50 } });
// 実際のクエリ：{ role: 'Customer', loyaltyPoints: { $gt: 50 } }

// === 3. lean()パフォーマンス最適化比較 ===
console.time('without lean');
const a = await Product.find({ category: 'Electronics' }).limit(100);
console.timeEnd('without lean');  // ~150ms

console.time('with lean');
const b = await Product.find({ category: 'Electronics' }).lean().limit(100);
console.timeEnd('with lean');  // ~30ms（5倍パフォーマンス向上）

// === 4. Model.aggregate()データベース層集計 ===
const stats = await Product.aggregate([
  { $match: { isActive: true } },
  {
    $facet: {
      totalCount: [{ $count: 'count' }],
      byCategory: [
        { $group: { _id: '$category', count: { $sum: 1 }, avgPrice: { $avg: '$price' } } },
        { $sort: { count: -1 } }
      ],
      topRated: [
        { $sort: { rating: -1 } },
        { $limit: 5 },
        { $project: { sku: 1, title: 1, rating: 1 } }
      ]
    }
  }
]);

// 出力：
// {
//   totalCount: [{ count: 1250 }],
//   byCategory: [
//     { _id: 'Electronics', count: 450, avgPrice: 599 },
//     { _id: 'Books', count: 380, avgPrice: 29 },
//     ...
//   ],
//   topRated: [
//     { sku: 'PHONE-001', title: 'Smartphone X', rating: 4.9 },
//     ...
//   ]
// }

// シーン：ShopHub管理ダッシュボードで顧客・商品情報付き注文を表示
const mongoose = require('mongoose');

// ref付きスキーマ
const OrderSchema = new mongoose.Schema({
  orderNumber: String,
  customerId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
  items: [{
    productId: { type: mongoose.Schema.Types.ObjectId, ref: 'Product' },
    qty: Number,
    price: Number
  }],
  status: { type: String, enum: ['pending', 'paid', 'shipped', 'delivered'] },
  total: Number,
  createdAt: { type: Date, default: Date.now }
});

const Order = mongoose.model('Order', OrderSchema);

// 方法1：populate（小規模データセット向き）
async function getOrdersWithPopulate() {
  return await Order.find({ status: 'paid' })
    .populate('customerId', 'username email')
    .populate('items.productId', 'sku title')
    .sort({ createdAt: -1 })
    .limit(20)
    .lean();  // leanと組み合わせて読み取り専用
}

// 方法2：aggregate + $lookup（大規模データセット + フィルタ向き）
async function getOrdersWithAggregate() {
  return await Order.aggregate([
    { $match: { status: 'paid' } },
    { $sort: { createdAt: -1 } },
    { $limit: 20 },
    // 顧客を結合
    {
      $lookup: {
        from: 'users',
        localField: 'customerId',
        foreignField: '_id',
        as: 'customer'
      }
    },
    { $unwind: '$customer' },
    // 商品を結合
    {
      $lookup: {
        from: 'products',
        localField: 'items.productId',
        foreignField: '_id',
        as: 'productDetails'
      }
    },
    // 最終形
    {
      $project: {
        orderNumber: 1,
        total: 1,
        status: 1,
        customer: { username: '$customer.username', email: '$customer.email' },
        itemCount: { $size: '$items' }
      }
    }
  ]);
}

// 使用例
const orders = await getOrdersWithPopulate();
console.log(`${orders.length}件の注文を顧客情報付きで読み込み`);