Ecto.Multi: transacciones compuestas sin perder el hilo

Código fuente con numeración de líneas sobre pantalla oscura
Fotografía de Harshit Katiyar · Unsplash (licencia gratuita). Concepto de operaciones explícitas; no es código Ecto fotografiado. · Ver imagen original

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.

Ilustración conceptual de composición transaccional en Ecto.Multi: operaciones insert y commit.
Ilustración conceptual original: síntesis visual del tema del artículo, no captura ni prueba ejecutada.

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.