架构演进史（三）：Context 之道，从技术分层到业务分层

app/
├── models/
│   ├── user.py
│   ├── order.py
│   └── product.py
├── views/
│   ├── user_views.py
│   ├── order_views.py
│   └── product_views.py
└── controllers/
    ├── user_controller.py
    ├── order_controller.py
    └── product_controller.py

lib/my_app/
├── accounts.ex         # 「账户」Context 模块
├── accounts/           # 「账户」相关的 Schema
│   └── user.ex
├── catalog.ex          # 「商品目录」Context 模块
├── catalog/
│   └── product.ex
├── orders.ex           # 「订单」Context 模块
└── orders/
    └── order.ex

defmodule MyApp.Accounts do
  @moduledoc """
  账户上下文。处理用户相关的所有业务逻辑。
  """

  alias MyApp.Accounts.User
  alias MyApp.Repo

  # ===== 查询 =====

  def list_users do
    Repo.all(User)
  end

  def get_user!(id), do: Repo.get!(User, id)

  def get_user(id), do: Repo.get(User, id)

  def get_user_by_email(email), do: Repo.get_by(User, email: email)

  # ===== 变更 =====

  def create_user(attrs \\ %{}) do
    %User{}
    |> User.changeset(attrs)
    |> Repo.insert()
  end

  def update_user(%User{} = user, attrs) do
    user
    |> User.changeset(attrs)
    |> Repo.update()
  end

  def delete_user(%User{} = user) do
    Repo.delete(user)
  end

  # ===== Changeset（用于表单） =====

  def change_user(%User{} = user, attrs \\ %{}) do
    User.changeset(user, attrs)
  end
end

defmodule MyAppWeb.UserController do
  use MyAppWeb, :controller

  alias MyApp.Accounts

  def index(conn, _params) do
    users = Accounts.list_users()
    render(conn, :index, users: users)
  end

  def new(conn, _params) do
    changeset = Accounts.change_user(%Accounts.User{})
    render(conn, :new, changeset: changeset)
  end

  def create(conn, %{"user" => user_params}) do
    case Accounts.create_user(user_params) do
      {:ok, user} ->
        conn
        |> put_flash(:info, "用户创建成功")
        |> redirect(to: ~p"/users/#{user}")

      {:error, %Ecto.Changeset{} = changeset} ->
        render(conn, :new, changeset: changeset)
    end
  end
end

Controller → Context → Schema/Repo
   ↓
  View

defmodule MyApp.AccountsTest do
  use MyApp.DataCase

  alias MyApp.Accounts

  describe "users" do
    @valid_attrs %{name: "Alice", email: "alice@example.com"}
    @invalid_attrs %{name: nil, email: nil}

    test "list_users/0 returns all users" do
      {:ok, user} = Accounts.create_user(@valid_attrs)
      assert Accounts.list_users() == [user]
    end

    test "create_user/1 with valid data creates a user" do
      assert {:ok, %Accounts.User{} = user} = Accounts.create_user(@valid_attrs)
      assert user.name == "Alice"
      assert user.email == "alice@example.com"
    end

    test "create_user/1 with invalid data returns error changeset" do
      assert {:error, %Ecto.Changeset{}} = Accounts.create_user(@invalid_attrs)
    end
  end
end

defmodule MyApp.Orders do
  alias MyApp.{Accounts, Catalog}
  alias MyApp.Orders.Order

  def create_order(attrs) do
    # 调用其他 Context 的公开 API
    with {:ok, user} <- fetch_user(attrs.user_id),
         {:ok, product} <- fetch_product(attrs.product_id),
         :ok <- check_stock(product, attrs.quantity) do
      %Order{}
      |> Order.changeset(%{
        user_id: user.id,
        product_id: product.id,
        quantity: attrs.quantity,
        total: calculate_total(product, attrs.quantity)
      })
      |> Repo.insert()
    end
  end

  defp fetch_user(user_id) do
    case Accounts.get_user(user_id) do
      nil -> {:error, :user_not_found}
      user -> {:ok, user}
    end
  end

  defp fetch_product(product_id) do
    case Catalog.get_product(product_id) do
      nil -> {:error, :product_not_found}
      product -> {:ok, product}
    end
  end

  defp check_stock(product, quantity) do
    if Catalog.in_stock?(product, quantity),
      do: :ok,
      else: {:error, :out_of_stock}
  end

  defp calculate_total(product, quantity) do
    Decimal.mult(product.price, quantity)
  end
end

def create(conn, %{"order" => order_params}) do
  user = Accounts.get_user!(order_params["user_id"])
  product = Catalog.get_product!(order_params["product_id"])

  case Orders.create_order(user, product, order_params) do
    {:ok, order} ->
      conn
      |> put_flash(:info, "订单创建成功")
      |> redirect(to: ~p"/orders/#{order}")

    {:error, %Ecto.Changeset{} = changeset} ->
      render(conn, :new, changeset: changeset)
  end
end

lib/my_app/
├── users/      # User 表相关
├── orders/     # Order 表相关
└── products/   # Product 表相关

lib/my_app/
├── accounts/       # 用户注册、认证、授权
├── catalog/        # 商品浏览、搜索、分类
├── orders/         # 下单、支付、履约
└── inventory/      # 库存管理、预警

# ❌ 错误：直接访问另一个 Context 的 Repo
def create_order(user_id, ...) do
  user = MyApp.Repo.get!(MyApp.Accounts.User, user_id)
  # ...
end

# ✅ 正确：调用 Context 的公开 API
def create_order(user_id, ...) do
  user = MyApp.Accounts.get_user!(user_id)
  # ...
end

web/
├── controllers/
├── models/
└── views/

lib/my_app/
├── services/
│   ├── user_service.ex
│   └── order_service.ex
web/
├── controllers/
└── views/

lib/my_app/
├── accounts.ex          # Context 入口
├── accounts/
│   ├── user.ex          # Schema
│   └── credential.ex    # Schema
├── orders.ex
└── orders/
    └── order.ex
lib/my_app_web/
├── controllers/
└── components/

# 单元测试：测试单个 Context
defmodule MyApp.AccountsTest do
  use MyApp.DataCase
  alias MyApp.Accounts
  # ...
end

# 集成测试：测试跨 Context 流程
defmodule MyApp.OrdersTest do
  use MyApp.DataCase

  test "创建订单需要有效用户和商品" do
    {:ok, user} = Accounts.create_user(%{name: "Alice", email: "a@b.com"})
    {:ok, product} = Catalog.create_product(%{name: "Book", price: 29.99})

    assert {:ok, order} = Orders.create_order(%{
      user_id: user.id,
      product_id: product.id,
      quantity: 1
    })
  end
end