A first attempt at a usable user controller setup in Phoenix

application_controller.ex

defmodule CloseBy.ApplicationController do

  defmacro __using__(_opts) do
    quote do
      use Phoenix.Controller
      import CloseBy.ApplicationController
      alias CloseBy.Router
    end
  end
end

user_controller.ex

defmodule CloseBy.UserController do
  use CloseBy.ApplicationController
  plug :action

  def call(conn, opts) do
    conn = Phoenix.Plugs.ContentTypeFetcher.fetch(conn)
    try do
      super(conn, opts)
    rescue
      Ecto.NotSingleResult -> conn |> put_status(404) |> render("show", errors: %{message: "Not Found"})
    end
  end

  def new(conn, params) do
    user_params = params["user"] || %{}
    user = %User{ email: user_params["email"] }
    render conn, "new", user: user
  end

  def edit(conn, params) do
    user = fetch_user(params["id"])
    render conn, "show", user: user
  end

  def create(conn, params) do
    user_params = params["user"] || %{}
    user = %User{ email: user_params["email"] }
      |> User.set_password(user_params["password"], user_params["confirm_password"])

    case User.validate(user) do
      [] ->
        user = CloseBy.Repo.insert(user)
        redirect conn, CloseBy.Router.Helpers.users_path(:show, user.id)
      errors ->
        conn |> put_status(422) |> render "new", user: user, errors: errors
    end
  end

  def index(conn, _params) do
    users = User.Query.all
    render conn, "index", users: users
  end

  def show(conn, %{"id" => the_id }) do
    user = fetch_user(the_id)
    render conn, "show", user: user
  end

  defp fetch_user(the_id) do
    { id, _ } = Integer.parse(the_id)
    CloseBy.Repo.get! User, id
  end
end

user_query.ex

defmodule User.Query do
  import Ecto.Query

  def all do
    query = from user in User,
            select: user
    CloseBy.Repo.all(query)
  end
end

user_serializer.ex

defmodule Serializers.User do
  def basic(user) do
    Map.take(user, [:email, :id])
  end
end

user_view.ex

defmodule CloseBy.UserView do
  use CloseBy.Views
  use Jazz

  def render("index.json", %{users: users}) do
    JSON.encode! users |> Enum.map &Serializers.User.basic(&1)
  end

  def render("show.json", %{conn: conn, errors: errors}), do: JSON.encode!(errors)
  def render("show.json", %{user: user}), do: JSON.encode!(Serializers.User.basic(user))
end