Facade パターン — 複雑さを隠す

class OrdersController < ApplicationController
  def create
    # 在庫確認 -- この時点で既に Product を知りすぎている
    params[:items].each do |item|
      product = Product.find(item[:product_id])
      raise InsufficientStockError unless product.stock >= item[:quantity]
    end
 
    # 注文作成 -- ドメインロジックがコントローラに漏れている
    order = Order.new(user: current_user, status: :pending)
    params[:items].each do |item|
      product = Product.find(item[:product_id])
      order.order_items.build(product: product, quantity: item[:quantity],
                               unit_price: product.price)
    end
    order.calculate_totals
    order.save!
 
    # 決済処理 -- Stripe の詳細をコントローラが知っている
    gateway = StripeGateway.new
    result = gateway.charge(user: current_user, amount: order.total_price,
                             payment_token: params[:payment_token])
    raise PaymentFailedError unless result[:success]
    order.update!(payment_id: result[:transaction_id], status: :paid)
 
    # 在庫更新
    order.order_items.each do |item|
      item.product.decrement!(:stock, item.quantity)
    end
 
    # メール送信 / ポイント付与（100円=1ポイント）/ ダッシュボード更新
    OrderMailer.confirmation(order).deliver_later
    current_user.increment!(:points, (order.total_price / 100).floor)
    Dashboard.refresh_sales_data
 
    render json: { order_id: order.id, status: "success" }
  rescue InsufficientStockError
    render json: { error: "在庫不足です" }, status: :unprocessable_entity
  rescue PaymentFailedError
    render json: { error: "決済に失敗しました" }, status: :unprocessable_entity
  end
end

# app/services/order_creation_service.rb
class OrderCreationService
  Result = Struct.new(:success?, :order, :error, keyword_init: true)
 
  def initialize(user:, items:, payment_token:)
    @user = user
    @items = items
    @payment_token = payment_token
  end
 
  def call
    order = nil
 
    ActiveRecord::Base.transaction do
      validate_stock!
      order = create_order
      charge_payment(order)
      update_stock(order)
    end
 
    # トランザクション外（失敗してもロールバック不要な副作用）
    send_confirmation_email(order)
    grant_points(order)
    refresh_dashboard
 
    Result.new(success?: true, order: order)
  rescue InsufficientStockError => e
    Result.new(success?: false, error: e.message)
  rescue PaymentFailedError => e
    Result.new(success?: false, error: e.message)
  end
 
  private
 
  def validate_stock!
    @items.each do |item|
      product = Product.find(item[:product_id])
      unless product.stock >= item[:quantity]
        raise InsufficientStockError, "#{product.name}の在庫が不足しています"
      end
    end
  end
 
  def create_order
    order = Order.new(user: @user, status: :pending)
    @items.each do |item|
      product = Product.find(item[:product_id])
      order.order_items.build(product: product, quantity: item[:quantity],
                               unit_price: product.price)
    end
    order.calculate_totals
    order.save!
    order
  end
 
  def charge_payment(order)
    result = StripeGateway.new.charge(
      user: @user, amount: order.total_price, payment_token: @payment_token
    )
    raise PaymentFailedError, "決済に失敗しました" unless result[:success]
    order.update!(payment_id: result[:transaction_id], status: :paid)
  end
 
  def update_stock(order)
    order.order_items.each { |item| item.product.decrement!(:stock, item.quantity) }
  end
 
  def send_confirmation_email(order) = OrderMailer.confirmation(order).deliver_later
  def grant_points(order) = @user.increment!(:points, (order.total_price / 100).floor)
  def refresh_dashboard = Dashboard.refresh_sales_data
 
  class InsufficientStockError < StandardError; end
  class PaymentFailedError < StandardError; end
end

# After: app/controllers/orders_controller.rb
class OrdersController < ApplicationController
  def create
    result = OrderCreationService.new(
      user: current_user,
      items: order_params[:items],
      payment_token: order_params[:payment_token]
    ).call
 
    if result.success?
      render json: { order_id: result.order.id, status: "success" }
    else
      render json: { error: result.error }, status: :unprocessable_entity
    end
  end
 
  private
 
  def order_params
    params.require(:order).permit(:payment_token, items: [:product_id, :quantity])
  end
end

Result = Struct.new(:success?, :data, :error, keyword_init: true)
 
Result.new(success?: true, data: { order_id: 123 })   # 成功
Result.new(success?: false, error: "在庫不足です")      # 失敗

# Gemfile: gem "dry-monads"
class OrderCreationService
  include Dry::Monads[:result]
 
  def call
    validate_stock!
    order = create_order
    charge_payment(order)
    Success(order)
  rescue InsufficientStockError => e
    Failure(e.message)
  rescue PaymentFailedError => e
    Failure(e.message)
  end
end
 
# コントローラでパターンマッチングを使う
case OrderCreationService.new(...).call
in Success(order)
  render json: { order_id: order.id }
in Failure(error)
  render json: { error: error }, status: :unprocessable_entity
end

# app/services/user_registration_service.rb
class UserRegistrationService
  Result = Struct.new(:success?, :user, :error, keyword_init: true)
 
  def initialize(email:, password:, name:)
    @email = email
    @password = password
    @name = name
  end
 
  def call
    user = nil
    ActiveRecord::Base.transaction do
      user = User.create!(email: @email, password: @password, name: @name, role: :member)
      UserPreference.create!(user: user, newsletter: true, notification_email: true)
    end
    UserMailer.welcome(user).deliver_later
    SlackNotifier.post(channel: "#new-members", message: "新規会員: #{user.name}")
    Result.new(success?: true, user: user)
  rescue ActiveRecord::RecordInvalid => e
    Result.new(success?: false, error: e.record.errors.full_messages.join(", "))
  end
end

# spec/services/order_creation_service_spec.rb
RSpec.describe OrderCreationService do
  let(:user) { create(:user, points: 0) }
  let(:product) { create(:product, price: 1000, stock: 5) }
  let(:items) { [{ product_id: product.id, quantity: 2 }] }
 
  subject(:service) do
    described_class.new(user: user, items: items, payment_token: "tok_visa")
  end
 
  before do
    allow_any_instance_of(StripeGateway).to receive(:charge).and_return(
      { success: true, transaction_id: "ch_123" }
    )
  end
 
  context "在庫が十分にある場合" do
    it "注文を作成して成功を返す" do
      result = service.call
      expect(result.success?).to be true
      expect(result.order).to be_persisted
    end
 
    it "在庫を減らす" do
      expect { service.call }.to change { product.reload.stock }.by(-2)
    end
 
    it "ポイントを付与する（100円=1ポイント）" do
      expect { service.call }.to change { user.reload.points }.by(20)
    end
  end
 
  context "在庫が不足している場合" do
    let(:items) { [{ product_id: product.id, quantity: 10 }] }
 
    it "失敗を返す" do
      result = service.call
      expect(result.success?).to be false
      expect(result.error).to include("在庫が不足")
    end
 
    it "注文が作成されない" do
      expect { service.call }.not_to change(Order, :count)
    end
  end
 
  context "決済に失敗した場合" do
    before do
      allow_any_instance_of(StripeGateway).to receive(:charge).and_return({ success: false })
    end
 
    it "失敗を返し注文がロールバックされる" do
      result = service.call
      expect(result.success?).to be false
      expect(Order.count).to eq(0)
    end
  end
end

class OrderCreationService
  def call
    stock_service.validate!(@items)
    order = order_builder.build(@user, @items)
    payment_service.charge(order, @payment_token)
    notification_service.notify_completion(order, @user)
    Result.new(success?: true, order: order)
  rescue => e
    Result.new(success?: false, error: e.message)
  end
 
  private
 
  def stock_service       = StockValidationService.new
  def order_builder       = OrderBuilder.new
  def payment_service     = PaymentProcessingService.new
  def notification_service = OrderNotificationService.new
end
 
# 通知のFacade（メール + ポイント + ダッシュボード）
class OrderNotificationService
  def notify_completion(order, user)
    OrderMailer.confirmation(order).deliver_later
    user.increment!(:points, (order.total_price / 100).floor)
    Dashboard.refresh_sales_data
  end
end

# NG: 何でも知っていて何でもできる GodService
class OrderService
  def create_order(...)      ... end  # 注文作成
  def update_order(...)      ... end  # 注文更新
  def cancel_order(...)      ... end  # キャンセル
  def refund_order(...)      ... end  # 返金処理
  def export_to_csv(...)     ... end  # CSV出力
  def generate_report(...)   ... end  # レポート生成
  # ...500行続く
end
 
# OK: ユースケース単位に分割
class OrderCreationService     # 注文作成フロー
class OrderCancellationService # キャンセルフロー
class OrderRefundService       # 返金フロー
class OrderReportService       # レポート生成

# Gemfile: gem "interactor"
class ValidateStock
  include Interactor
 
  def call
    context.items.each do |item|
      product = Product.find(item[:product_id])
      context.fail!(error: "#{product.name}の在庫が不足") unless product.stock >= item[:quantity]
    end
  end
end
 
class CreateOrder
  include Interactor
 
  def call
    order = Order.create!(user: context.user, status: :pending)
    context.order = order
  end
end
 
# Organizer で複数のInteractorをチェーン
class PlaceOrder
  include Interactor::Organizer
  organize ValidateStock, CreateOrder, ChargePayment, SendNotification
end
 
# 呼び出し方は手製サービスと同じ感覚
result = PlaceOrder.call(user: current_user, items: items, payment_token: token)
if result.success?
  render json: { order_id: result.order.id }
else
  render json: { error: result.error }, status: :unprocessable_entity
end