Cuando necesitas hacer 3 inserts y 2 updates en secuencia, y todos
deben triunfar o todos deben fallar, Ecto.Multi es la herramienta
correcta. No es Repo.transaction/1 con una función anónima — es
mejor.
El patrón
def register_user(attrs) do
Ecto.Multi.new()
|> Ecto.Multi.insert(:user, User.changeset(%User{}, attrs))
|> Ecto.Multi.insert(:profile, fn %{user: user} ->
Profile.changeset(%Profile{user_id: user.id}, %{})
end)
|> Ecto.Multi.insert(:audit, fn %{user: user} ->
AuditLog.changeset(%{action: "user_registered", user_id: user.id})
end)
|> Repo.transaction()
end
Cada paso tiene un nombre (:user, :profile, :audit), y los
pasos subsecuentes pueden acceder a los resultados previos por
pattern matching en la función anónima.
Por qué es mejor que Repo.transaction
Con Repo.transaction(fn -> ... end), si algo falla, tienes que
manejar el rollback manualmente y no sabes en qué paso falló. Con
Ecto.Multi, el {:error, failed_step, failed_value, _changes}
te dice exactamente qué paso falló y con qué valor.
Caso real: registro de usuario con welcome email
def register(attrs) do
Ecto.Multi.new()
|> Ecto.Multi.insert(:user, User.changeset(%User{}, attrs))
|> Ecto.Multi.run(:welcome_email, fn _repo, %{user: user} ->
case Mailer.send_welcome(user) do
{:ok, _} -> {:ok, :sent}
{:error, reason} -> {:error, reason}
end
end)
|> Repo.transaction()
end
Si el email falla, el usuario NO se crea. Si el usuario falla, el email no se envía. Atomicidad garantizada.
Conclusión
Ecto.Multi transforma transacciones de “espagueti de código” a pipeline declarativo. Es una de las APIs más elegantes que he usado en cualquier lenguaje para este problema.