Elixir GenServer 상태폭발? 불변+순수함수로 리팩터

defmodule MyApp.OrderServer do
  use GenServer

  def start_link(order_id), do: GenServer.start_link(__MODULE__, order_id, name: via(order_id))

  def init(order_id) do
    state = %{order_id: order_id, items: [], status: :new, retry: 0}
    {:ok, state}
  end

  def add_item(order_id, item), do: GenServer.call(via(order_id), {:add_item, item})
  def checkout(order_id), do: GenServer.call(via(order_id), :checkout)

  def handle_call({:add_item, item}, _from, state) do
    # 상태 변경 규칙이 이 콜백에 박혀 있음
    state = update_in(state.items, &[item | &1])
    {:reply, :ok, state}
  end

  def handle_call(:checkout, _from, state) do
    # 외부 I/O가 콜백에 섞임
    case MyApp.Payments.charge(state.order_id, Enum.reverse(state.items)) do
      {:ok, receipt} ->
        state = state |> Map.put(:status, :paid) |> Map.put(:receipt, receipt)
        {:reply, {:ok, receipt}, state}

      {:error, reason} ->
        # 재시도/타이머 로직까지 섞임
        Process.send_after(self(), {:retry_charge, reason}, 1_000)
        state = state |> Map.put(:status, :payment_failed) |> Map.update!(:retry, &(&1 + 1))
        {:reply, {:error, reason}, state}
    end
  end

  def handle_info({:retry_charge, _reason}, state) do
    # 또 다른 상태 변경 규칙
    if state.retry < 3 do
      case MyApp.Payments.charge(state.order_id, Enum.reverse(state.items)) do
        {:ok, receipt} ->
          {:noreply, %{state | status: :paid, receipt: receipt}}

        {:error, reason} ->
          Process.send_after(self(), {:retry_charge, reason}, 2_000)
          {:noreply, %{state | retry: state.retry + 1}}
      end
    else
      {:noreply, %{state | status: :give_up}}
    end
  end

  defp via(order_id), do: {:via, Registry, {MyApp.OrderRegistry, order_id}}
end

defmodule MyApp.OrderState do
  @enforce_keys [:order_id]
  defstruct order_id: nil,
            items: [],
            status: :new,
            receipt: nil,
            retry: 0
end

defmodule MyApp.OrderDomain do
  alias MyApp.OrderState

  @type effect ::
          {:charge, order_id :: term(), items :: list()} |
          {:schedule_retry, millis :: non_neg_integer()} |
          {:none}

  @spec add_item(OrderState.t(), term()) :: {OrderState.t(), [effect()]}
  def add_item(%OrderState{status: :new} = state, item) do
    {%{state | items: [item | state.items]}, [{:none}]}
  end

  def add_item(state, _item) do
    # 이미 결제 진행/완료면 아이템 추가 금지 같은 규칙을 명시
    {state, [{:none}]}
  end

  @spec checkout(OrderState.t()) :: {OrderState.t(), [effect()]}
  def checkout(%OrderState{status: :new} = state) do
    items = Enum.reverse(state.items)
    {%{state | status: :charging}, [{:charge, state.order_id, items}]}
  end

  def checkout(state), do: {state, [{:none}]}

  @spec charge_result(OrderState.t(), {:ok, term()} | {:error, term()}) :: {OrderState.t(), [effect()]}
  def charge_result(%OrderState{} = state, {:ok, receipt}) do
    {%{state | status: :paid, receipt: receipt}, [{:none}]}
  end

  def charge_result(%OrderState{retry: retry} = state, {:error, _reason}) when retry < 3 do
    next = %{state | status: :payment_failed, retry: retry + 1}
    {next, [{:schedule_retry, backoff_ms(retry)}]}
  end

  def charge_result(%OrderState{} = state, {:error, _reason}) do
    {%{state | status: :give_up}, [{:none}]}
  end

  defp backoff_ms(retry), do: 1_000 * (retry + 1)
end

defmodule MyApp.OrderServer do
  use GenServer

  alias MyApp.OrderState
  alias MyApp.OrderDomain

  def start_link(order_id), do: GenServer.start_link(__MODULE__, order_id, name: via(order_id))

  def add_item(order_id, item), do: GenServer.call(via(order_id), {:add_item, item})
  def checkout(order_id), do: GenServer.call(via(order_id), :checkout)

  @impl true
  def init(order_id) do
    {:ok, %OrderState{order_id: order_id}}
  end

  @impl true
  def handle_call({:add_item, item}, _from, state) do
    {state, effects} = OrderDomain.add_item(state, item)
    state = run_effects(effects, state)
    {:reply, :ok, state}
  end

  def handle_call(:checkout, _from, state) do
    {state, effects} = OrderDomain.checkout(state)
    state = run_effects(effects, state)
    {:reply, :ok, state}
  end

  @impl true
  def handle_info(:retry_charge, state) do
    # 재시도는 “다시 charge 효과를 실행”으로 단순화
    items = Enum.reverse(state.items)
    state = run_effects([{:charge, state.order_id, items}], state)
    {:noreply, state}
  end

  def handle_info({:charge_result, result}, state) do
    {state, effects} = OrderDomain.charge_result(state, result)
    state = run_effects(effects, state)
    {:noreply, state}
  end

  defp run_effects(effects, state) do
    Enum.reduce(effects, state, fn
      {:none}, acc ->
        acc

      {:schedule_retry, ms}, acc ->
        Process.send_after(self(), :retry_charge, ms)
        acc

      {:charge, order_id, items}, acc ->
        # 외부 호출은 Task로 분리하고 결과를 메시지로 되돌림
        Task.start(fn ->
          result = MyApp.Payments.charge(order_id, items)
          send(self(), {:charge_result, result})
        end)

        acc
    end)
  end

  defp via(order_id), do: {:via, Registry, {MyApp.OrderRegistry, order_id}}
end

defmodule MyApp.OrderDomainTest do
  use ExUnit.Case

  alias MyApp.OrderDomain
  alias MyApp.OrderState

  test "checkout emits charge effect" do
    state = %OrderState{order_id: 1, items: [:a, :b], status: :new}
    {next, effects} = OrderDomain.checkout(state)

    assert next.status == :charging
    assert effects == [{:charge, 1, [:b, :a]}]
  end

  test "charge error schedules retry up to 3" do
    state = %OrderState{order_id: 1, retry: 0}
    {next, effects} = OrderDomain.charge_result(state, {:error, :timeout})

    assert next.retry == 1
    assert {:schedule_retry, _ms} = hd(effects)
  end
end

defmodule MyApp.OrderEvent do
  defstruct type: nil, payload: nil
end