Command パターン — 操作をオブジェクト化する

# Bad: DB トランザクションだけで囲む（外部APIは戻せない）
ActiveRecord::Base.transaction do
  # 1. Stripe に返金リクエスト（外部API → ロールバック不可）
  StripeGateway.new.refund(order.payment_id, order.total_price)
 
  # 2. 在庫を戻す（DB操作 → ロールバック可能）
  order.order_items.each { |item| item.product.increment!(:stock, item.quantity) }
 
  # ↑ ここでエラー発生 → DB はロールバックされる
  # でも Stripe はすでに返金済み！
  raise ActiveRecord::Rollback
end

# app/commands/base_command.rb
class BaseCommand
  def execute
    raise NotImplementedError, "#{self.class}#execute を実装してください"
  end
 
  def undo
    raise NotImplementedError, "#{self.class}#undo を実装してください"
  end
 
  # Command が成功したかを外部から確認できるようにする
  def executed?
    @executed ||= false
  end
end

# app/commands/refund_command.rb
class RefundCommand < BaseCommand
  def initialize(order:, amount:)
    @order = order
    @amount = amount
    @refund_id = nil
  end
 
  def execute
    result = StripeGateway.new.refund(
      transaction_id: @order.payment_id,
      amount: @amount
    )
    @refund_id = result[:refund_id]
    @order.update!(refund_id: @refund_id, refund_amount: @amount)
    @executed = true
  end
 
  def undo
    # 補償トランザクション: 返金のキャンセルAPIを呼ぶ
    return unless @executed && @refund_id
 
    StripeGateway.new.cancel_refund(refund_id: @refund_id)
    @order.update!(refund_id: nil, refund_amount: 0)
    Rails.logger.info("RefundCommand.undo: refund #{@refund_id} cancelled")
    @executed = false
  end
end

# app/commands/restock_command.rb
class RestockCommand < BaseCommand
  def initialize(order:)
    @order = order
  end
 
  def execute
    @order.order_items.each do |item|
      item.product.increment!(:stock, item.quantity)
    end
    @executed = true
  end
 
  def undo
    return unless @executed
 
    @order.order_items.each do |item|
      item.product.decrement!(:stock, item.quantity)
    end
    @executed = false
  end
end

# app/commands/revoke_points_command.rb
class RevokePointsCommand < BaseCommand
  def initialize(order:)
    @order = order
    @points = (order.total_price / 100).floor
  end
 
  def execute
    @order.user.decrement!(:points, @points)
    @executed = true
  end
 
  def undo
    return unless @executed
 
    @order.user.increment!(:points, @points)
    @executed = false
  end
end

# app/commands/command_executor.rb
class CommandExecutor
  def initialize
    @history = []
  end
 
  def execute_all(commands)
    commands.each_with_index do |command, index|
      command.execute
      @history << command
    rescue StandardError => e
      Rails.logger.error("Command失敗 at index #{index}: #{e.message}")
      rollback_executed
      raise e
    end
    true
  end
 
  private
 
  def rollback_executed
    @history.reverse_each do |command|
      command.undo
    rescue StandardError => e
      # undoの失敗は記録するが、他のundoは続行する
      Rails.logger.error("undo失敗: #{command.class.name} - #{e.message}")
    end
  end
end

# app/services/order_cancellation_service.rb
class OrderCancellationService
  def initialize(order:)
    @order = order
  end
 
  def call
    commands = [
      RefundCommand.new(order: @order, amount: @order.total_price),
      RestockCommand.new(order: @order),
      RevokePointsCommand.new(order: @order),
    ]
 
    executor = CommandExecutor.new
    executor.execute_all(commands)
 
    @order.update!(status: :cancelled)
    { success: true }
  rescue StandardError => e
    # executorが自動的にundoを実行済み
    { success: false, error: e.message }
  end
end

# app/jobs/order_notification_job.rb
class OrderNotificationJob < ApplicationJob
  queue_as :notifications
  retry_on ActiveRecord::RecordNotFound, wait: 30.seconds, attempts: 3
  discard_on ActiveJob::DeserializationError
 
  def perform(order_id)
    order = Order.find(order_id)
    OrderMailer.confirmation(order).deliver_now
  end
end
 
# Command をキューに積む
OrderNotificationJob.perform_later(order.id)
 
# 5分後に実行（遅延 Command）
OrderNotificationJob.set(wait: 5.minutes).perform_later(order.id)
 
# 明日の朝8時に実行（スケジュール Command）
OrderNotificationJob.set(wait_until: Date.tomorrow.beginning_of_day + 8.hours).perform_later(order.id)

# Sidekiq で優先度別キューを設定する例
# config/sidekiq.yml
# queues:
#   - [critical, 3]   # 決済系は優先度3倍
#   - [default, 2]
#   - [notifications, 1]
 
class PaymentJob < ApplicationJob
  queue_as :critical  # 優先キューに積む
 
  sidekiq_options retry: 5, backtrace: true
 
  def perform(order_id, amount)
    order = Order.find(order_id)
    PaymentService.new(order).charge(amount)
  end
end

# app/models/command_log.rb
class CommandLog < ApplicationRecord
  belongs_to :user
  belongs_to :target, polymorphic: true
 
  # columns:
  # - command_type: string (例: "RefundCommand")
  # - payload: jsonb (コマンドのパラメータ)
  # - status: string (pending/executed/undone/failed)
  # - executed_at: datetime
  # - error_message: text
 
  enum :status, { pending: 0, executed: 1, undone: 2, failed: 3 }
end

# paper_trail gem を使った変更履歴との連携
# Gemfile: gem 'paper_trail'
 
class Product < ApplicationRecord
  has_paper_trail
  # paper_trail が自動で versions テーブルに変更を記録する
end
 
# 過去の状態に戻す
product = Product.find(1)
product.paper_trail.version_at(1.hour.ago)  # 1時間前の状態を取得
product.versions.last.reify.save!           # 1つ前の状態に戻す

# app/services/undo_redo_service.rb
class UndoRedoService
  def initialize(user:)
    @user = user
    @undo_stack = []
    @redo_stack = []
  end
 
  def execute(command)
    command.execute
    @undo_stack.push(command)
    @redo_stack.clear  # 新しい操作でredoスタックはクリア
  end
 
  def undo
    return if @undo_stack.empty?
 
    command = @undo_stack.pop
    command.undo
    @redo_stack.push(command)
  end
 
  def redo
    return if @redo_stack.empty?
 
    command = @redo_stack.pop
    command.execute
    @undo_stack.push(command)
  end
 
  def can_undo? = !@undo_stack.empty?
  def can_redo? = !@redo_stack.empty?
end

# 使い方: ブログ記事の編集画面
service = UndoRedoService.new(user: current_user)
 
# 操作を実行
service.execute(AssignTagCommand.new(post: post, tag: tag))
service.execute(PublishPostCommand.new(post: post))
 
# 取り消し（Ctrl+Z 相当）
service.undo if service.can_undo?
 
# やり直し（Ctrl+Y 相当）
service.redo if service.can_redo?

# app/commands/macro_command.rb
class MacroCommand < BaseCommand
  def initialize(commands)
    @commands = commands
    @executed = []
  end
 
  def execute
    @commands.each do |command|
      command.execute
      @executed << command
    end
  end
 
  def undo
    @executed.reverse_each(&:undo)
    @executed.clear
  end
end

# Before: バラバラに呼ぶ
refund_cmd = RefundCommand.new(order: order, amount: order.total_price)
restock_cmd = RestockCommand.new(order: order)
revoke_cmd = RevokePointsCommand.new(order: order)
 
refund_cmd.execute
restock_cmd.execute
revoke_cmd.execute
# エラーが起きても誰も取り消してくれない
 
# After: MacroCommandでまとめる
cancellation = MacroCommand.new([
  RefundCommand.new(order: order, amount: order.total_price),
  RestockCommand.new(order: order),
  RevokePointsCommand.new(order: order),
])
 
cancellation.execute  # 全部実行、途中エラーで全undo
cancellation.undo     # まとめて全部取り消し

# spec/commands/refund_command_spec.rb
RSpec.describe RefundCommand do
  let(:order) { create(:order, status: :paid, payment_id: "ch_123") }
  let(:command) { described_class.new(order: order, amount: 5000) }
 
  describe "#execute" do
    before do
      allow_any_instance_of(StripeGateway).to receive(:refund).and_return(
        { refund_id: "re_456" }
      )
    end
 
    it "返金IDをorderに保存する" do
      command.execute
      expect(order.reload.refund_id).to eq("re_456")
    end
 
    it "executed? が true になる" do
      command.execute
      expect(command.executed?).to be true
    end
  end
 
  describe "#undo" do
    context "executeした後" do
      before do
        allow_any_instance_of(StripeGateway).to receive(:refund)
          .and_return({ refund_id: "re_456" })
        allow_any_instance_of(StripeGateway).to receive(:cancel_refund)
        command.execute
      end
 
      it "返金キャンセルAPIを呼ぶ" do
        expect_any_instance_of(StripeGateway).to receive(:cancel_refund)
          .with(refund_id: "re_456")
        command.undo
      end
 
      it "executed? が false に戻る" do
        command.undo
        expect(command.executed?).to be false
      end
    end
 
    context "executeしていない場合" do
      it "何もしない（エラーを出さない）" do
        expect { command.undo }.not_to raise_error
      end
    end
  end
end

# spec/commands/command_executor_spec.rb
RSpec.describe CommandExecutor do
  it "途中で失敗したとき実行済みCommandを逆順でundoする" do
    cmd1 = instance_double(BaseCommand, execute: nil, undo: nil)
    cmd2 = instance_double(BaseCommand, execute: nil, undo: nil)
    cmd3 = instance_double(BaseCommand)
    allow(cmd3).to receive(:execute).and_raise(RuntimeError, "DB error")
 
    expect(cmd2).to receive(:undo).ordered
    expect(cmd1).to receive(:undo).ordered
 
    expect {
      described_class.new.execute_all([cmd1, cmd2, cmd3])
    }.to raise_error(RuntimeError)
  end
end

# 通常: 「現在の状態」だけ保存（経緯が消える）
order.update!(status: :cancelled, total_price: 0)
 
# EventSourcing: 「何が起きたか」を全て保存
[
  { event_type: "order_placed",     payload: { total: 5000 } },
  { event_type: "payment_completed",payload: { stripe_id: "ch_123" } },
  { event_type: "order_cancelled",  payload: { reason: "user_request" } },
].each { |attrs| OrderEvent.create!(order: order, **attrs, occurred_at: Time.current) }
 
# 任意の時点の状態を再現できる
order.rebuild_state_at(1.hour.ago)