Elixir GenServer 교착·상태꼬임을 순수함수로 리팩터링

def handle_call({:reserve, item_id}, _from, state) do
  # 나쁜 예: handle_call 안에서 다른 GenServer.call을 기다림
  price = GenServer.call(Pricing, {:price, item_id}, 5_000)
  {:reply, {:ok, price}, state}
end

defmodule CartDomain do
  @type item_id :: binary()
  @type qty :: pos_integer()

  @type t :: %{
          items: %{optional(item_id()) => qty()},
          version: non_neg_integer()
        }

  def new(), do: %{items: %{}, version: 0}

  @spec add_item(t(), item_id(), qty()) :: {:ok, t()} | {:error, term()}
  def add_item(state, item_id, qty) when is_binary(item_id) and qty > 0 do
    items = Map.update(state.items, item_id, qty, &(&1 + qty))
    {:ok, bump(%{state | items: items})}
  end

  def add_item(_state, _item_id, _qty), do: {:error, :invalid_input}

  @spec remove_item(t(), item_id()) :: {:ok, t()} | {:error, term()}
  def remove_item(state, item_id) do
    if Map.has_key?(state.items, item_id) do
      {:ok, bump(%{state | items: Map.delete(state.items, item_id)})}
    else
      {:error, :not_found}
    end
  end

  defp bump(state), do: %{state | version: state.version + 1}
end

defmodule CartServer do
  use GenServer

  def start_link(opts) do
    name = Keyword.fetch!(opts, :name)
    GenServer.start_link(__MODULE__, :ok, name: name)
  end

  def init(:ok) do
    {:ok, CartDomain.new()}
  end

  def add_item(server, item_id, qty) do
    GenServer.call(server, {:add_item, item_id, qty})
  end

  def remove_item(server, item_id) do
    GenServer.call(server, {:remove_item, item_id})
  end

  def handle_call({:add_item, item_id, qty}, _from, state) do
    case CartDomain.add_item(state, item_id, qty) do
      {:ok, new_state} -> {:reply, :ok, new_state}
      {:error, reason} -> {:reply, {:error, reason}, state}
    end
  end

  def handle_call({:remove_item, item_id}, _from, state) do
    case CartDomain.remove_item(state, item_id) do
      {:ok, new_state} -> {:reply, :ok, new_state}
      {:error, reason} -> {:reply, {:error, reason}, state}
    end
  end
end

defmodule CheckoutDomain do
  @type t :: %{cart: map(), status: :idle | :checking_out}

  def new(cart), do: %{cart: cart, status: :idle}

  # 커맨드를 반환해 GenServer가 사이드이펙트를 실행하게 함
  def begin_checkout(%{status: :idle} = state) do
    new_state = %{state | status: :checking_out}
    commands = [{:fetch_tax, state.cart}, {:reserve_inventory, state.cart}]
    {:ok, new_state, commands}
  end

  def begin_checkout(state), do: {:error, :invalid_state, state, []}

  def checkout_succeeded(state), do: {:ok, %{state | status: :idle}}
  def checkout_failed(state, _reason), do: {:ok, %{state | status: :idle}}
end

defmodule CheckoutServer do
  use GenServer

  def start_link(opts), do: GenServer.start_link(__MODULE__, opts, name: opts[:name])

  def init(opts) do
    {:ok, %{domain: CheckoutDomain.new(opts[:cart]), pending: MapSet.new()}}
  end

  def begin_checkout(server) do
    GenServer.call(server, :begin_checkout)
  end

  def handle_call(:begin_checkout, _from, %{domain: domain} = state) do
    case CheckoutDomain.begin_checkout(domain) do
      {:ok, new_domain, commands} ->
        pending =
          Enum.reduce(commands, state.pending, fn cmd, acc ->
            ref = Task.Supervisor.async_nolink(CheckoutTasks, fn -> run(cmd) end).ref
            MapSet.put(acc, ref)
          end)

        {:reply, :ok, %{state | domain: new_domain, pending: pending}}

      {:error, reason, same_domain, _} ->
        {:reply, {:error, reason}, %{state | domain: same_domain}}
    end
  end

  def handle_info({ref, {:ok, _result}}, state) do
    Process.demonitor(ref, [:flush])
    pending = MapSet.delete(state.pending, ref)

    # 모든 작업이 끝났을 때 상태 전이
    state =
      if MapSet.size(pending) == 0 do
        {:ok, domain} = CheckoutDomain.checkout_succeeded(state.domain)
        %{state | domain: domain, pending: pending}
      else
        %{state | pending: pending}
      end

    {:noreply, state}
  end

  def handle_info({:DOWN, ref, :process, _pid, reason}, state) do
    pending = MapSet.delete(state.pending, ref)
    {:ok, domain} = CheckoutDomain.checkout_failed(state.domain, reason)
    {:noreply, %{state | domain: domain, pending: pending}}
  end

  defp run({:fetch_tax, cart}) do
    # 외부 API 호출 가정
    _ = cart
    {:ok, :tax_done}
  end

  defp run({:reserve_inventory, cart}) do
    _ = cart
    {:ok, :inventory_done}
  end
end

defmodule CartDomainTest do
  use ExUnit.Case, async: true

  test "add_item increments qty and bumps version" do
    s0 = CartDomain.new()
    {:ok, s1} = CartDomain.add_item(s0, "A", 2)
    {:ok, s2} = CartDomain.add_item(s1, "A", 1)

    assert s2.items["A"] == 3
    assert s2.version == s0.version + 2
  end

  test "remove_item fails when missing" do
    s0 = CartDomain.new()
    assert {:error, :not_found} = CartDomain.remove_item(s0, "X")
  end
end