MongoDB: トランザクション処理：ACIDとマルチドキュメント整合性

// ❌ 反例：トランザクションなしの送金
async function transfer(fromUserId, toUserId, amount) {
  await User.updateOne({ _id: fromUserId }, { $inc: { balance: -amount } });
  // システムクラッシュ！
  await User.updateOne({ _id: toUserId }, { $inc: { balance: amount } });
  // 送金元の残高は減ったが、送金先に入金されていない
}

// === MongoDB 4.0+ マルチドキュメントトランザクション ===
const session = db.getMongo().startSession();

session.startTransaction();
try {
  // 1. 引き落とし
  db.users.updateOne(
    { _id: fromUserId },
    { $inc: { balance: -amount } },
    { session }
  );

  // 2. 入金
  db.users.updateOne(
    { _id: toUserId },
    { $inc: { balance: amount } },
    { session }
  );

  // 3. トランザクションコミット
  await session.commitTransaction();
} catch (err) {
  // 4. ロールバック
  await session.abortTransaction();
  throw err;
} finally {
  session.endSession();
}

session.startTransaction({
  writeConcern: {
    w: 'majority',         // 過半数ノードで確認
    j: true,               // ディスクjournalに書き込み
    wtimeout: 5000         // 5秒タイムアウト
  }
});

session.startTransaction({
  readConcern: {
    level: 'majority'      // コミット済みデータを読む
  },
  writeConcern: { w: 'majority' }
});

session.startTransaction({
  readPreference: 'primary'             // プライマリノードのみ読み取り
});

session.startTransaction({
  readPreference: 'secondary'           // セカンダリから読み取り
});

session.startTransaction({
  readPreference: 'secondaryPreferred'  // セカンダリ優先
});

// === Mongooseトランザクションカプセル化 ===
async function withTransaction(callback) {
  const session = await mongoose.startSession();
  session.startTransaction();
  try {
    const result = await callback(session);
    await session.commitTransaction();
    return result;
  } catch (err) {
    await session.abortTransaction();
    throw err;
  } finally {
    session.endSession();
  }
}

// === 使用例：送金 ===
async function transfer(fromUserId, toUserId, amount) {
  return withTransaction(async (session) => {
    const fromUser = await User.findById(fromUserId).session(session);
    if (fromUser.balance < amount) {
      throw new Error('残高不足');
    }

    await User.updateOne(
      { _id: fromUserId },
      { $inc: { balance: -amount } },
      { session }
    );

    await User.updateOne(
      { _id: toUserId },
      { $inc: { balance: amount } },
      { session }
    );

    await TransactionLog.create([{
      fromUserId,
      toUserId,
      amount,
      createdAt: new Date()
    }], { session });

    return { success: true };
  });
}

// AliceのShopHub金融システム：トランザクションでWriteConflictに遭遇したら自動リトライ
async function withRetryTransaction(callback, maxRetries = 3) {
  let lastError;
  for (let i = 0; i < maxRetries; i++) {
    const session = await mongoose.startSession();
    session.startTransaction({
      readConcern: { level: 'snapshot' },
      writeConcern: { w: 'majority' }
    });
    try {
      const result = await callback(session);
      await session.commitTransaction();
      return result;
    } catch (err) {
      await session.abortTransaction();
      lastError = err;
      if (err.errorLabels && err.errorLabels.includes('TransientTransactionError')) {
        console.log(`WriteConflictによりリトライ ${i + 1}/${maxRetries}`);
        continue;
      }
      throw err;
    } finally {
      session.endSession();
    }
  }
  throw lastError;
}

// 使用例
await withRetryTransaction(async (session) => {
  await User.updateOne({ _id: fromId }, { $inc: { balance: -100 } }, { session });
  await User.updateOne({ _id: toId }, { $inc: { balance: 100 } }, { session });
});

// === 因果整合性：操作の正しい順序を保証 ===
const session = db.getMongo().startSession();
session.startTransaction({
  readConcern: { level: 'majority' },
  writeConcern: { w: 'majority' }
});

// 操作1：現在の残高を読む
const account = db.accounts.findOne({ userId: 'user_001' }, { session });
// 操作2：読み取り結果に基づいて書き込み
db.accounts.updateOne(
  { userId: 'user_001' },
  { $set: { balance: account.balance - 100 } },
  { session }
);
// 保証：操作2は操作1の後の状態を見る

// シーン：注文確定プロセス（注文 + 在庫減少 + ウォレット引き落とし + ログ記録）、完全に原子的
// 前提：レプリカセットが必要。トランザクションは実行中であること

// データ初期化
db.products.insertOne({ sku: 'PHONE-001', stock: 10, price: 599 });
db.users.insertOne({ _id: 'user_001', balance: 1000 });
db.transaction_logs.createIndex({ userId: 1, createdAt: -1 });

// 完全なトランザクション関数
async function placeOrder(userId, items) {
  const session = db.getMongo().startSession();
  session.startTransaction({
    readConcern: { level: 'snapshot' },
    writeConcern: { w: 'majority' }
  });

  try {
    // 1. 合計金額を計算 + 在庫チェック（原子的読み取り）
    let total = 0;
    for (const item of items) {
      const product = db.products.findOne(
        { sku: item.sku, stock: { $gte: item.qty } },
        { session }
      );
      if (!product) {
        throw new Error(`在庫切れ: ${item.sku}`);
      }
      total += product.price * item.qty;
    }

    // 2. ユーザー残高チェック
    const user = db.users.findOne({ _id: userId }, { session });
    if (user.balance < total) {
      throw new Error('残高不足');
    }

    // 3. 在庫減少（条件付き、オーバーセール防止）
    for (const item of items) {
      const result = db.products.updateOne(
        { sku: item.sku, stock: { $gte: item.qty } },
        { $inc: { stock: -item.qty } },
        { session }
      );
      if (result.modifiedCount === 0) {
        throw new Error(`在庫減少失敗: ${item.sku}`);
      }
    }

    // 4. ユーザー残高から引き落とし
    db.users.updateOne(
      { _id: userId, balance: { $gte: total } },
      { $inc: { balance: -total } },
      { session }
    );

    // 5. 注文作成
    const orderResult = db.orders.insertOne({
      userId,
      items,
      total,
      status: 'paid',
      createdAt: new Date()
    }, { session });

    // 6. 取引ログを記録
    db.transaction_logs.insertOne({
      userId,
      orderId: orderResult.insertedId,
      amount: total,
      type: 'purchase',
      createdAt: new Date()
    }, { session });

    // 7. トランザクションコミット
    session.commitTransaction();
    return { success: true, orderId: orderResult.insertedId };

  } catch (err) {
    // いずれか失敗 → 全てロールバック
    session.abortTransaction();
    return { success: false, error: err.message };
  } finally {
    session.endSession();
  }
}

// 実行：注文確定
placeOrder('user_001', [
  { sku: 'PHONE-001', qty: 1 }
]);

// ロールバックシナリオのテスト：意図的にエラーを作成
placeOrder('user_001', [
  { sku: 'NONEXIST', qty: 1 }  // 商品が存在しない
]);
// 例外発生 → トランザクションロールバック → 在庫、残高、注文、ログ全て変更なし

// 原子性の検証：
// db.products.findOne({ sku: 'PHONE-001' }) → stock: 10（減少していない）
// db.users.findOne({ _id: 'user_001' }) → balance: 1000（引き落としなし）

// シーン：ShopHubチェックアウト - 在庫予約、注文作成、決済引き落としを原子的に
const mongoose = require('mongoose');
const session = await mongoose.startSession();
session.startTransaction();

try {
  const Product = mongoose.model('Product');
  const Order = mongoose.model('Order');
  const User = mongoose.model('User');

  const userId = 'user_001';
  const items = [
    { productId: 'prod_001', sku: 'PHONE-001', qty: 2, price: 599 },
    { productId: 'prod_002', sku: 'BOOK-001', qty: 1, price: 29 }
  ];
  const totalAmount = 1227;

  // ステップ1：在庫チェックと予約（悲観ロック付き）
  for (const item of items) {
    const product = await Product.findOneAndUpdate(
      { _id: item.productId, stock: { $gte: item.qty } },
      { $inc: { stock: -item.qty } },
      { session, new: true }
    );
    if (!product) {
      throw new Error(`${item.sku}の在庫不足`);
    }
  }

  // ステップ2：ユーザー残高から引き落とし
  const user = await User.findOneAndUpdate(
    { _id: userId, balance: { $gte: totalAmount } },
    { $inc: { balance: -totalAmount } },
    { session, new: true }
  );
  if (!user) {
    throw new Error('残高不足');
  }

  // ステップ3：注文作成
  const order = await Order.create([{
    userId,
    items,
    total: totalAmount,
    status: 'paid',
    paidAt: new Date()
  }], { session });

  await session.commitTransaction();
  console.log('注文作成完了:', order[0]._id);
} catch (err) {
  await session.abortTransaction();
  console.error('トランザクション失敗:', err.message);
} finally {
  session.endSession();
}