MongoDB: Mongooseスキーマ設計と埋め込み vs 参照

// === 埋め込みパターン：ユーザー内に住所を埋め込み ===
const userSchema = new mongoose.Schema({
  username: String,
  email: String,
  addresses: [{              // 埋め込みドキュメント配列
    street: String,
    city: String,
    zipCode: String,
    isDefault: Boolean
  }]
});

// === 参照パターン：注文がユーザーを参照 ===
const orderSchema = new mongoose.Schema({
  orderNumber: String,
  userId: {                  // 参照フィールド
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User'
  },
  total: Number,
  status: String
});

// === 1対1 埋め込みパターン ===
const userSchema = new mongoose.Schema({
  username: String,
  email: String,
  profile: {                 // 埋め込みドキュメント
    avatar: String,
    bio: String,
    website: String
  }
});

// 使用例
const user = await User.findById(userId);
console.log(user.profile.bio);  // 追加クエリ不要

// === 1対少：カテゴリに製品を埋め込み ===
const categorySchema = new mongoose.Schema({
  name: String,
  slug: String,
  products: [{
    sku: String,
    title: String,
    price: Number
  }]
});

// === 1対多：注文がユーザーを参照 ===
const orderSchema = new mongoose.Schema({
  orderNumber: String,
  userId: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User'
  },
  items: [orderItemSchema],
  total: Number
});

// populateで結合
const orders = await Order.find()
  .populate('userId', 'username email');

// === 多対多：製品とタグ ===
const productSchema = new mongoose.Schema({
  sku: String,
  title: String,
  tagIds: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Tag'
  }]
});

const tagSchema = new mongoose.Schema({
  name: String,
  slug: String,
  productIds: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Product'
  }]
});

// 双方向populate
const product = await Product.findById(productId)
  .populate('tagIds');

const productSchema = new mongoose.Schema({
  // 基本型
  sku: {
    type: String,
    required: [true, 'SKU is required'],
    unique: true,
    trim: true,
    uppercase: true
  },
  title: {
    type: String,
    required: true,
    maxlength: [200, 'Title cannot exceed 200 characters']
  },
  price: {
    type: Number,
    required: true,
    min: [0, 'Price cannot be negative']
  },
  category: {
    type: String,
    enum: ['Electronics', 'Books', 'Clothing', 'Home']
  },
  isActive: {
    type: Boolean,
    default: true
  },
  tags: [String],             // 文字列配列
  metadata: {                 // 埋め込みドキュメント
    views: { type: Number, default: 0 },
    likes: { type: Number, default: 0 }
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});

// インデックス作成
productSchema.index({ title: 'text', description: 'text' });

// モデル作成
const Product = mongoose.model('Product', productSchema);

// ShopHub Eコマース：注文とアイテムのスキーマ設計
const orderItemSchema = new mongoose.Schema({
  productId: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Product',
    required: true
  },
  sku: String,              // 冗長フィールド（高速表示用）
  title: String,            // 注文時点の商品名
  price: Number,            // 注文時点の価格
  qty: { type: Number, min: 1 }
});

const orderSchema = new mongoose.Schema({
  orderNumber: { type: String, unique: true },
  userId: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  items: [orderItemSchema],  // 埋め込み配列
  total: { type: Number, min: 0 },
  status: {
    type: String,
    enum: ['pending', 'paid', 'shipped', 'delivered', 'cancelled'],
    default: 'pending'
  },
  shippingAddress: {         // 埋め込み（注文時に固定）
    street: String,
    city: String,
    zipCode: String,
    country: String
  },
  createdAt: { type: Date, default: Date.now }
});

// 複合インデックス
orderSchema.index({ userId: 1, createdAt: -1 });
orderSchema.index({ status: 1 });

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

// TechBlog：記事とコメントの1対多関係
const commentSchema = new mongoose.Schema({
  author: { type: String, required: true },
  content: { type: String, required: true, maxlength: 1000 },
  createdAt: { type: Date, default: Date.now }
});

const articleSchema = new mongoose.Schema({
  title: { type: String, required: true },
  slug: { type: String, unique: true },
  content: String,
  author: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User'
  },
  comments: [commentSchema],    // 埋め込み：コメント数が有限
  tags: [{ type: String }],      // 多対多：タグは参照でも可
  viewCount: { type: Number, default: 0 },
  isPublished: { type: Boolean, default: false },
  publishedAt: Date,
  createdAt: { type: Date, default: Date.now }
});

// テキストインデックス
articleSchema.index({ title: 'text', content: 'text' });

const Article = mongoose.model('Article', articleSchema);

// コメント追加
const article = await Article.findByIdAndUpdate(
  articleId,
  {
    $push: {
      comments: {
        author: 'Alice',
        content: 'Great article!'
      }
    }
  },
  { new: true }
);

// SocialApp：ユーザーとフォロー関係（多対多）
const userSchema = new mongoose.Schema({
  username: { type: String, required: true, unique: true },
  email: { type: String, required: true, unique: true },
  avatar: String,
  bio: { type: String, maxlength: 200 },
  // フォローしているユーザー（参照配列）
  following: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User'
  }],
  // フォロワー（参照配列）
  followers: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User'
  }],
  createdAt: { type: Date, default: Date.now }
});

// 複合インデックス
userSchema.index({ username: 1 });
userSchema.index({ email: 1 });

// フォロー追加メソッド
userSchema.methods.follow = async function(targetUserId) {
  if (this._id.equals(targetUserId)) {
    throw new Error('自分自身をフォローできません');
  }
  
  const targetUser = await this.constructor.findById(targetUserId);
  if (!targetUser) {
    throw new Error('ユーザーが見つかりません');
  }
  
  // 既にフォロー済みかチェック
  const alreadyFollowing = this.following.some(id => id.equals(targetUserId));
  if (alreadyFollowing) {
    throw new Error('既にフォローしています');
  }
  
  // 双方向に追加
  this.following.push(targetUserId);
  targetUser.followers.push(this._id);
  
  await Promise.all([this.save(), targetUser.save()]);
};

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

// 使用例：ユーザー情報とフォロワーを取得
const user = await User.findById(userId)
  .populate('following', 'username avatar')
  .populate('followers', 'username avatar');