Hey there! Your solution is definitely one approach.

By way of analogy, you can kind of think of GraphQL errors like exceptions in a regular programming language. They aren’t return values from the field, but rather field execution errors that bubble up to the top.

For errors like you’re trying to expose there’s another pattern that uses a union type to represent that a field may return validation errors. Here’s an example:

union :signup_result do
  types [:validation_error, :user]

  resolve_type fn
    %User{} -> :user
    _ -> :validation_error
  end
end

mutation do
  field :signup, :signup_result do
  end
end

And here’s how you’d use this in a document:

mutation SignUp {
  signUp {
    ... on ValidationError {
      __typename
      field
      message
    }
    ... on Success {
      # stuff
    }
  }
}

This is a lot like the difference between Elixir functions that return {:ok, result} | {:error, reason} and functions that simply return the result or raise.

I’ve replaced list_of(:validation_error) with :validation_errors

union :validation_result do
  types [:validation_errors, :session]

  resolve_type fn
    %{token: _, user: _}, _ ->
      :session
    _, _ ->
      :validation_errors
  end
end

added validation_errors type

object :validation_errors do
  field :errors, list_of(:validation_error)
end

and updated session.ex to return %{errors: ...} map

  def sign_in(_parent, %{username: username, password: password}, _info) do
    case verify(username, password) do
      {:ok, token, user} ->
        {:ok, %{token: token, user: user}}
      {:error, _msg} ->
        {:ok, %{errors: [%{message: "incorrect login credentials", field: :password}]}}
    end
  end

  def sign_up(_parent, user_params, _info) do
    case Store.Users.insert(user_params) do
      {:ok, user} ->
        token = Phoenix.Token.sign(Web.Endpoint, "user", user.id)
        {:ok, %{token: token, user: user}}
      {:error, changeset} ->
        {:ok, %{errors: translate(changeset.errors)}}
    end
  end

and now it works. The document I send now is

mutation SignUp($username: String!, $password: String!) {
  signUp(username: $username, password: $password) {
    ... on Session {
      token
      user {
        id
        username
      }
    }
    ... on ValidationErrors {
      errors {
        field
        message
      }
    }
  }
}

I wonder if there is a shorter solution which doesn’t require defining a new type.

I’ve decided to add an additional "error" field to put the error message in.

{
  "errors": [
    {
      "message": "In field \"signUp\": should be at least 3 character(s)",
      ...
      "key": "username",
      "error": "should be at least 3 character(s)"
    },
    {
      "message": "In field \"signUp\": should be at least 6 character(s)",
      ...
      "key": "password",
      "error": "should be at least 6 character(s)"
    }
  ]
  ...
}