Kata: ECサイト — 在庫と決済を分離する

# app/models/inventory.rb
class Inventory < ApplicationRecord
  belongs_to :product
 
  validates :quantity, numericality: { greater_than_or_equal_to: 0 }
 
  # 悲観的ロックで在庫を確保する
  def self.reserve!(product_id, quantity, order_id)
    transaction do
      # FOR UPDATE で他のトランザクションをブロック
      inventory = where(product_id: product_id).lock("FOR UPDATE").first
 
      raise InsufficientStockError, "在庫不足" if inventory.quantity < quantity
 
      inventory.decrement!(:quantity, quantity)
 
      # 在庫引当の記録（ロールバック用）
      InventoryReservation.create!(
        inventory: inventory,
        order_id: order_id,
        quantity: quantity
      )
 
      inventory
    end
  end
 
  def self.release!(order_id)
    transaction do
      reservation = InventoryReservation.find_by!(order_id: order_id)
      inventory = where(product_id: reservation.inventory.product_id).lock("FOR UPDATE").first
      inventory.increment!(:quantity, reservation.quantity)
      reservation.destroy!
    end
  end
end

# app/services/order_creation_service.rb
class OrderCreationService
  def initialize(user, cart, payment_method)
    @user = user
    @cart = cart
    @payment_method = payment_method
  end
 
  def call
    # フェーズ1: 在庫確保
    reservations = reserve_inventory!
 
    # フェーズ2: 決済実行
    payment_intent = execute_payment!
 
    # フェーズ3: 注文確定
    order = confirm_order!(reservations, payment_intent)
 
    order
  rescue InsufficientStockError => e
    raise OrderError, "在庫が不足しています: #{e.message}"
  rescue Stripe::CardError => e
    # 決済失敗: 在庫を解放する
    release_reservations!(reservations) if reservations
    raise OrderError, "決済に失敗しました: #{e.message}"
  rescue StandardError => e
    # 予期しないエラー: クリーンアップ
    release_reservations!(reservations) if reservations
    cancel_payment!(payment_intent) if payment_intent
    raise
  end
 
  private
 
  def reserve_inventory!
    @cart.items.map do |item|
      Inventory.reserve!(item.product_id, item.quantity, SecureRandom.uuid)
    end
  end
 
  def execute_payment!
    Stripe::PaymentIntent.create(
      amount: @cart.total_amount_cents,
      currency: "jpy",
      payment_method: @payment_method,
      confirm: true,
      metadata: { user_id: @user.id }
    )
  end
 
  def confirm_order!(reservations, payment_intent)
    Order.create!(
      user: @user,
      items: @cart.items.map { |item| build_order_item(item) },
      total_amount: @cart.total_amount,
      payment_intent_id: payment_intent.id,
      status: :confirmed
    )
  end
 
  def release_reservations!(reservations)
    reservations.each { |r| Inventory.release!(r.order_id) }
  rescue StandardError => e
    # 解放失敗はアラートを上げて人が対応
    AlertService.critical("在庫解放失敗: #{e.message}")
  end
end

# app/models/product.rb
class Product < ApplicationRecord
  belongs_to :seller
  has_one :inventory
  has_many :product_images
  has_many :reviews
 
  scope :active, -> { where(status: :active) }
  scope :with_stock, -> { joins(:inventory).where("inventories.quantity > 0") }
 
  # 検索用のスコープ
  scope :by_category, ->(category) { where(category: category) }
  scope :price_range, ->(min, max) { where(price: min..max) }
end
 
# app/controllers/products_controller.rb
class ProductsController < ApplicationController
  def index
    @products = Rails.cache.fetch(cache_key, expires_in: 5.minutes) do
      Product.active
             .with_stock
             .includes(:seller, :product_images, :inventory)
             .page(params[:page])
             .to_a
    end
  end
 
  private
 
  def cache_key
    "products/#{params[:category]}/#{params[:page]}/#{Product.maximum(:updated_at).to_i}"
  end
end

# ECS サービス定義（ピーク時の対応）
service:
  name: inventory-service
  desiredCount: 2
  autoScaling:
    minCapacity: 2
    maxCapacity: 20
    targetTrackingScalingPolicy:
      targetValue: 70  # CPU使用率70%でスケール
      scaleInCooldown: 300
      scaleOutCooldown: 60  # スケールアウトは素早く

# Saga パターンで補償トランザクションを実装
class OrderSaga
  STATES = %w[pending inventory_reserved payment_processed completed failed].freeze
 
  def self.execute(order_params)
    saga = create!(state: :pending, params: order_params)
    saga.run!
  end
 
  def run!
    # ステップ1
    reserve_inventory!
    update!(state: :inventory_reserved)
 
    # ステップ2
    process_payment!
    update!(state: :payment_processed)
 
    # 完了
    complete_order!
    update!(state: :completed)
  rescue => e
    compensate!(e)
  end
 
  private
 
  def compensate!(error)
    case state
    when "payment_processed"
      refund_payment!
      release_inventory!
    when "inventory_reserved"
      release_inventory!
    end
    update!(state: :failed, error_message: error.message)
    AlertService.notify("注文Saga失敗: #{id}")
  end
end