Transactions and Constraints

defmodule Bank.MixProject do
  use Mix.Project

  def project do
    [app: :bank, version: "0.1.0", elixir: "~> 1.20", deps: deps()]
  end

  def application do
    [mod: {Bank.Application, []}]
  end

  defp deps do
    [{:ecto_sqlite3, "~> 0.26"}]
  end
end

import Config

config :bank, ecto_repos: [Bank.Repo]

# `log: false` keeps query logs (with their timings) out
# of the output.
config :bank, Bank.Repo, database: "bank.db", log: false

defmodule Bank.Repo do
  use Ecto.Repo, otp_app: :bank, adapter: Ecto.Adapters.SQLite3
end

defmodule Bank.Application do
  use Application

  @impl true
  def start(_type, _args) do
    Supervisor.start_link([Bank.Repo], strategy: :one_for_one, name: Bank.Supervisor)
  end
end

defmodule Bank.Repo.Migrations.CreateAccounts do
  use Ecto.Migration

  def change do
    create table(:accounts) do
      add :name, :string, null: false
      # The database itself refuses a negative balance.
      add :balance, :integer,
        null: false,
        check: %{name: "balance_not_negative", expr: "balance >= 0"}

      add :lock_version, :integer, null: false, default: 1
    end

    create unique_index(:accounts, [:name])

    create table(:transfers) do
      add :key, :string, null: false
      add :from_id, references(:accounts), null: false
      add :to_id, references(:accounts), null: false
      add :amount, :integer, null: false
    end

    # One row per idempotency key, enforced by the database.
    create unique_index(:transfers, [:key])
  end
end

defmodule Bank.Account do
  use Ecto.Schema
  import Ecto.Changeset

  schema "accounts" do
    field :name, :string
    field :balance, :integer
    field :lock_version, :integer, default: 1
  end

  def open(name, balance) do
    %Bank.Account{}
    |> change(name: name, balance: balance)
    |> unique_constraint(:name)
  end

  # `check_constraint/3` turns the database's refusal into
  # a changeset error instead of an exception.
  def adjust(account, delta) do
    account
    |> change(balance: account.balance + delta)
    |> check_constraint(:balance, name: :balance_not_negative, message: "would go negative")
  end

  # Same, plus optimistic locking: the update only
  # applies if `lock_version` is still what we read.
  def adjust_locked(account, delta) do
    account
    |> adjust(delta)
    |> optimistic_lock(:lock_version)
  end
end

defmodule Bank.Transfer do
  use Ecto.Schema
  import Ecto.Changeset

  schema "transfers" do
    field :key, :string
    field :from_id, :integer
    field :to_id, :integer
    field :amount, :integer
  end

  def record(key, from, to, amount) do
    %Bank.Transfer{}
    |> change(key: key, from_id: from.id, to_id: to.id, amount: amount)
    |> unique_constraint(:key)
  end
end

defmodule Bank do
  alias Bank.{Account, Repo, Transfer}
  alias Ecto.Multi

  def open(name, balance), do: Repo.insert(Account.open(name, balance))

  def balances do
    Account |> Repo.all() |> Map.new(&{&1.name, &1.balance})
  end

  def account(name), do: Repo.get_by!(Account, name: name)

  # A transfer is three writes: debit, credit, and a row
  # recording it under its idempotency key. `Ecto.Multi`
  # runs them in one transaction. If any step fails,
  # none of them happened.
  def transfer(key, from_name, to_name, amount) do
    from = account(from_name)
    to = account(to_name)

    Multi.new()
    |> Multi.update(:debit, Account.adjust(from, -amount))
    |> Multi.update(:credit, Account.adjust(to, amount))
    |> Multi.insert(:record, Transfer.record(key, from, to, amount))
    |> Repo.transaction()
    |> case do
      {:ok, _changes} -> :ok
      {:error, step, changeset, _done} -> {:error, step, errors(changeset)}
    end
  end

  # Read-modify-write with optimistic locking. If someone
  # else changed the row since `account` was read, the
  # update matches no row and raises instead of
  # overwriting their change.
  def deposit_locked(account, amount) do
    Repo.update(Account.adjust_locked(account, amount))
  rescue
    Ecto.StaleEntryError -> {:error, :stale}
  end

  defp errors(changeset) do
    Ecto.Changeset.traverse_errors(changeset, fn {message, _opts} -> message end)
  end
end