ErrorMessage (error_message v0.3.2) View Source

ErrorMessage

This library exists to simplify error systems in a code base and allow for a simple unified experience when using and reading error messages around the code base

This creates one standard, that all errors should fit into the context of HTTP error codes, if they don't :internal_server_error should be used and you can use the message and details to provide a further level of depth

Installation

The package can be installed by adding error_message to your list of dependencies in mix.exs:

def deps do
  [
    {:error_message, "~> 0.2.0"}
  ]
end

Documentation can be found at https://hexdocs.pm/error_message.

Usage Example

iex> id = 1
iex> ErrorMessage.not_found("no user with id #{id}", %{user_id: id})
%ErrorMessage{
  code: :not_found,
  message: "no user with id 1",
  details: %{user_id: 1}
}

iex> ErrorMessage.internal_server_error("critical internal error", %{
...>   reason: :massive_issue_with_x
...> })
%ErrorMessage{
  code: :internal_server_error,
  message: "critical internal error",
  details: %{reason: :massive_issue_with_x}
}

Why is this important

If we want to have a good way to catch errors around our system as well as be able to display errors that happen throughout our system, it's useful to have a common error api so we can predict what will come out of a system

For example if we used elixir through our server, we would be able to catch a not found pretty easily since we can predict the error code coming in without needing to know the message. This leads to more resilliant code since message changes won't break the functionality of your application

# Because our error system is setup with `find_user` we can easily
# catch no users and have a solid backup plan
with {:error, %ErrorMessage{code: :not_found}} <- find_user(%{name: "bill"}) do
  create_user(%{name: "bill"})
end

Usage with Phoenix

Another benefit is error rendering to the frontend, because all our errors are part of the HTTP error system, it's quite easy to now return the proper status codes and messages to our frontend clients. For example:

defmodule MyController do
  def index(conn, param) do
    case find_thing(params) do
      {:ok, res} -> json(conn, res)
      {:error, e} -> json_error(conn, e)
    end
  end

  defp json_error(conn, %ErrorMessage{code: code} = e) do
    conn
      |> put_status(code) # Plug.Conn
      |> json(ErrorMessage.to_jsonable_map(e))
  end
end

This will also add a request_id from Logger.metadata[:request_id] when found

Usage with Logger

Ontop of being useful for Phoenix we can also find some good use from this system and Logger, since ErrorMessage implements String.Chars protocol

case do_thing() do
  {:ok, value} -> {:ok, do_other_thing(value)}
  {:error, e} = res ->
    Logger.error("[MyModule] \#{e}")
    Logger.warn(to_string(e))

    res
end

Link to this section Summary

Types

code()

t()

t(details)

t_map()

t_map(details)

t_ok_res()

t_ok_res(details_type)

t_res()

t_res(result_type)

t_res(result_type, details_type)

Functions

bad_gateway(message)

Create bad_gateway error message for status code 502

bad_gateway(message, details)

Create bad_gateway error message for status code 502 with a details item which is passed in as the details key under the ErrorMessage struct

bad_request(message)

Create bad_request error message for status code 400

bad_request(message, details)

Create bad_request error message for status code 400 with a details item which is passed in as the details key under the ErrorMessage struct

conflict(message)

Create conflict error message for status code 409

conflict(message, details)

Create conflict error message for status code 409 with a details item which is passed in as the details key under the ErrorMessage struct

expectation_failed(message)

Create expectation_failed error message for status code 417

expectation_failed(message, details)

Create expectation_failed error message for status code 417 with a details item which is passed in as the details key under the ErrorMessage struct

failed_dependency(message)

Create failed_dependency error message for status code 424

failed_dependency(message, details)

Create failed_dependency error message for status code 424 with a details item which is passed in as the details key under the ErrorMessage struct

forbidden(message)

Create forbidden error message for status code 403

forbidden(message, details)

Create forbidden error message for status code 403 with a details item which is passed in as the details key under the ErrorMessage struct

found(message)

Create found error message for status code 302

found(message, details)

Create found error message for status code 302 with a details item which is passed in as the details key under the ErrorMessage struct

gateway_timeout(message)

Create gateway_timeout error message for status code 504

gateway_timeout(message, details)

Create gateway_timeout error message for status code 504 with a details item which is passed in as the details key under the ErrorMessage struct

gone(message)

Create gone error message for status code 410

gone(message, details)

Create gone error message for status code 410 with a details item which is passed in as the details key under the ErrorMessage struct

http_code(error_code)

Returns the http code for an error message or error code atom

http_code_reason_atom(error_code)

Returns the http reason as an atom for the http error code

http_version_not_supported(message)

Create http_version_not_supported error message for status code 505

http_version_not_supported(message, details)

Create http_version_not_supported error message for status code 505 with a details item which is passed in as the details key under the ErrorMessage struct

im_a_teapot(message)

Create im_a_teapot error message for status code 418

im_a_teapot(message, details)

Create im_a_teapot error message for status code 418 with a details item which is passed in as the details key under the ErrorMessage struct

insufficient_storage(message)

Create insufficient_storage error message for status code 507

insufficient_storage(message, details)

Create insufficient_storage error message for status code 507 with a details item which is passed in as the details key under the ErrorMessage struct

internal_server_error(message)

Create internal_server_error error message for status code 500

internal_server_error(message, details)

Create internal_server_error error message for status code 500 with a details item which is passed in as the details key under the ErrorMessage struct

length_required(message)

Create length_required error message for status code 411

length_required(message, details)

Create length_required error message for status code 411 with a details item which is passed in as the details key under the ErrorMessage struct

locked(message)

Create locked error message for status code 423

locked(message, details)

Create locked error message for status code 423 with a details item which is passed in as the details key under the ErrorMessage struct

loop_detected(message)

Create loop_detected error message for status code 508

loop_detected(message, details)

Create loop_detected error message for status code 508 with a details item which is passed in as the details key under the ErrorMessage struct

method_not_allowed(message)

Create method_not_allowed error message for status code 405

method_not_allowed(message, details)

Create method_not_allowed error message for status code 405 with a details item which is passed in as the details key under the ErrorMessage struct

misdirected_request(message)

Create misdirected_request error message for status code 421

misdirected_request(message, details)

Create misdirected_request error message for status code 421 with a details item which is passed in as the details key under the ErrorMessage struct

moved_permanently(message)

Create moved_permanently error message for status code 301

moved_permanently(message, details)

Create moved_permanently error message for status code 301 with a details item which is passed in as the details key under the ErrorMessage struct

multiple_choices(message)

Create multiple_choices error message for status code 300

multiple_choices(message, details)

Create multiple_choices error message for status code 300 with a details item which is passed in as the details key under the ErrorMessage struct

network_authentication_required(message)

Create network_authentication_required error message for status code 511

network_authentication_required(message, details)

Create network_authentication_required error message for status code 511 with a details item which is passed in as the details key under the ErrorMessage struct

not_acceptable(message)

Create not_acceptable error message for status code 406

not_acceptable(message, details)

Create not_acceptable error message for status code 406 with a details item which is passed in as the details key under the ErrorMessage struct

not_extended(message)

Create not_extended error message for status code 510

not_extended(message, details)

Create not_extended error message for status code 510 with a details item which is passed in as the details key under the ErrorMessage struct

not_found(message)

Create not_found error message for status code 404

not_found(message, details)

Create not_found error message for status code 404 with a details item which is passed in as the details key under the ErrorMessage struct

not_implemented(message)

Create not_implemented error message for status code 501

not_implemented(message, details)

Create not_implemented error message for status code 501 with a details item which is passed in as the details key under the ErrorMessage struct

not_modified(message)

Create not_modified error message for status code 304

not_modified(message, details)

Create not_modified error message for status code 304 with a details item which is passed in as the details key under the ErrorMessage struct

payment_required(message)

Create payment_required error message for status code 402

payment_required(message, details)

Create payment_required error message for status code 402 with a details item which is passed in as the details key under the ErrorMessage struct

permanent_redirect(message)

Create permanent_redirect error message for status code 308

permanent_redirect(message, details)

Create permanent_redirect error message for status code 308 with a details item which is passed in as the details key under the ErrorMessage struct

precondition_failed(message)

Create precondition_failed error message for status code 412

precondition_failed(message, details)

Create precondition_failed error message for status code 412 with a details item which is passed in as the details key under the ErrorMessage struct

precondition_required(message)

Create precondition_required error message for status code 428

precondition_required(message, details)

Create precondition_required error message for status code 428 with a details item which is passed in as the details key under the ErrorMessage struct

proxy_authentication_required(message)

Create proxy_authentication_required error message for status code 407

proxy_authentication_required(message, details)

Create proxy_authentication_required error message for status code 407 with a details item which is passed in as the details key under the ErrorMessage struct

request_entity_too_large(message)

Create request_entity_too_large error message for status code 413

request_entity_too_large(message, details)

Create request_entity_too_large error message for status code 413 with a details item which is passed in as the details key under the ErrorMessage struct

request_header_fields_too_large(message)

Create request_header_fields_too_large error message for status code 431

request_header_fields_too_large(message, details)

Create request_header_fields_too_large error message for status code 431 with a details item which is passed in as the details key under the ErrorMessage struct

request_timeout(message)

Create request_timeout error message for status code 408

request_timeout(message, details)

Create request_timeout error message for status code 408 with a details item which is passed in as the details key under the ErrorMessage struct

request_uri_too_long(message)

Create request_uri_too_long error message for status code 414

request_uri_too_long(message, details)

Create request_uri_too_long error message for status code 414 with a details item which is passed in as the details key under the ErrorMessage struct

requested_range_not_satisfiable(message)

Create requested_range_not_satisfiable error message for status code 416

requested_range_not_satisfiable(message, details)

Create requested_range_not_satisfiable error message for status code 416 with a details item which is passed in as the details key under the ErrorMessage struct

see_other(message)

Create see_other error message for status code 303

see_other(message, details)

Create see_other error message for status code 303 with a details item which is passed in as the details key under the ErrorMessage struct

service_unavailable(message)

Create service_unavailable error message for status code 503

service_unavailable(message, details)

Create service_unavailable error message for status code 503 with a details item which is passed in as the details key under the ErrorMessage struct

switch_proxy(message)

Create switch_proxy error message for status code 306

switch_proxy(message, details)

Create switch_proxy error message for status code 306 with a details item which is passed in as the details key under the ErrorMessage struct

temporary_redirect(message)

Create temporary_redirect error message for status code 307

temporary_redirect(message, details)

Create temporary_redirect error message for status code 307 with a details item which is passed in as the details key under the ErrorMessage struct

to_jsonable_map(error_message)

Converts an %ErrorMessage{} struct to a map and makes sure that the contents of the details map can be converted to json

to_string(error_message)

Converts an %ErrorMessage{} struct to a string formatted error message

too_early(message)

Create too_early error message for status code 425

too_early(message, details)

Create too_early error message for status code 425 with a details item which is passed in as the details key under the ErrorMessage struct

too_many_requests(message)

Create too_many_requests error message for status code 429

too_many_requests(message, details)

Create too_many_requests error message for status code 429 with a details item which is passed in as the details key under the ErrorMessage struct

unauthorized(message)

Create unauthorized error message for status code 401

unauthorized(message, details)

Create unauthorized error message for status code 401 with a details item which is passed in as the details key under the ErrorMessage struct

unavailable_for_legal_reasons(message)

Create unavailable_for_legal_reasons error message for status code 451

unavailable_for_legal_reasons(message, details)

Create unavailable_for_legal_reasons error message for status code 451 with a details item which is passed in as the details key under the ErrorMessage struct

unprocessable_entity(message)

Create unprocessable_entity error message for status code 422

unprocessable_entity(message, details)

Create unprocessable_entity error message for status code 422 with a details item which is passed in as the details key under the ErrorMessage struct

unsupported_media_type(message)

Create unsupported_media_type error message for status code 415

unsupported_media_type(message, details)

Create unsupported_media_type error message for status code 415 with a details item which is passed in as the details key under the ErrorMessage struct

upgrade_required(message)

Create upgrade_required error message for status code 426

upgrade_required(message, details)

Create upgrade_required error message for status code 426 with a details item which is passed in as the details key under the ErrorMessage struct

use_proxy(message)

Create use_proxy error message for status code 305

use_proxy(message, details)

Create use_proxy error message for status code 305 with a details item which is passed in as the details key under the ErrorMessage struct

variant_also_negotiates(message)

Create variant_also_negotiates error message for status code 506

variant_also_negotiates(message, details)

Create variant_also_negotiates error message for status code 506 with a details item which is passed in as the details key under the ErrorMessage struct

Link to this section Types

code()

Specs

code() ::
  :multiple_choices
  | :moved_permanently
  | :found
  | :see_other
  | :not_modified
  | :use_proxy
  | :switch_proxy
  | :temporary_redirect
  | :permanent_redirect
  | :bad_request
  | :unauthorized
  | :payment_required
  | :forbidden
  | :not_found
  | :method_not_allowed
  | :not_acceptable
  | :proxy_authentication_required
  | :request_timeout
  | :conflict
  | :gone
  | :length_required
  | :precondition_failed
  | :request_entity_too_large
  | :request_uri_too_long
  | :unsupported_media_type
  | :requested_range_not_satisfiable
  | :expectation_failed
  | :im_a_teapot
  | :misdirected_request
  | :unprocessable_entity
  | :locked
  | :failed_dependency
  | :too_early
  | :upgrade_required
  | :precondition_required
  | :too_many_requests
  | :request_header_fields_too_large
  | :unavailable_for_legal_reasons
  | :internal_server_error
  | :not_implemented
  | :bad_gateway
  | :service_unavailable
  | :gateway_timeout
  | :http_version_not_supported
  | :variant_also_negotiates
  | :insufficient_storage
  | :loop_detected
  | :not_extended
  | :network_authentication_required

t()

Specs

t() :: %ErrorMessage{code: code(), details: any(), message: String.t()}

t(details)

Specs

t(details) :: %ErrorMessage{code: code(), details: details, message: String.t()}

t_map()

Specs

t_map() ::
  %{code: code(), message: String.t(), details: any(), request_id: String.t()}
  | %{code: code(), message: String.t(), details: any()}

t_map(details)

Specs

t_map(details) ::
  %{code: code(), message: String.t(), details: details, request_id: String.t()}
  | %{code: code(), message: String.t(), details: details}

t_ok_res()

Specs

t_ok_res() :: :ok | {:error, t()}

t_ok_res(details_type)

Specs

t_ok_res(details_type) :: :ok | {:error, t(details_type)}

t_res()

Specs

t_res() :: {:ok, term()} | {:error, t()}

t_res(result_type)

Specs

t_res(result_type) :: {:ok, result_type} | {:error, t()}

t_res(result_type, details_type)

Specs

t_res(result_type, details_type) ::
  {:ok, result_type} | {:error, t(details_type)}

Link to this section Functions

bad_gateway(message)

Specs

bad_gateway(message :: String.t()) :: t()

Create bad_gateway error message for status code 502

Example

iex> ErrorMessage.bad_gateway("error message")
%ErrorMessage{code: :bad_gateway, message: "error message"}

bad_gateway(message, details)

Specs

bad_gateway(message :: String.t(), details :: any()) :: t()

Create bad_gateway error message for status code 502 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.bad_gateway("error message", %{item: 1234})
%ErrorMessage{code: :bad_gateway, message: "error message", details: %{item: 1234}}

bad_request(message)

Specs

bad_request(message :: String.t()) :: t()

Create bad_request error message for status code 400

Example

iex> ErrorMessage.bad_request("error message")
%ErrorMessage{code: :bad_request, message: "error message"}

bad_request(message, details)

Specs

bad_request(message :: String.t(), details :: any()) :: t()

Create bad_request error message for status code 400 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.bad_request("error message", %{item: 1234})
%ErrorMessage{code: :bad_request, message: "error message", details: %{item: 1234}}

conflict(message)

Specs

conflict(message :: String.t()) :: t()

Create conflict error message for status code 409

Example

iex> ErrorMessage.conflict("error message")
%ErrorMessage{code: :conflict, message: "error message"}

conflict(message, details)

Specs

conflict(message :: String.t(), details :: any()) :: t()

Create conflict error message for status code 409 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.conflict("error message", %{item: 1234})
%ErrorMessage{code: :conflict, message: "error message", details: %{item: 1234}}

expectation_failed(message)

Specs

expectation_failed(message :: String.t()) :: t()

Create expectation_failed error message for status code 417

Example

iex> ErrorMessage.expectation_failed("error message")
%ErrorMessage{code: :expectation_failed, message: "error message"}

expectation_failed(message, details)

Specs

expectation_failed(message :: String.t(), details :: any()) :: t()

Create expectation_failed error message for status code 417 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.expectation_failed("error message", %{item: 1234})
%ErrorMessage{code: :expectation_failed, message: "error message", details: %{item: 1234}}

failed_dependency(message)

Specs

failed_dependency(message :: String.t()) :: t()

Create failed_dependency error message for status code 424

Example

iex> ErrorMessage.failed_dependency("error message")
%ErrorMessage{code: :failed_dependency, message: "error message"}

failed_dependency(message, details)

Specs

failed_dependency(message :: String.t(), details :: any()) :: t()

Create failed_dependency error message for status code 424 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.failed_dependency("error message", %{item: 1234})
%ErrorMessage{code: :failed_dependency, message: "error message", details: %{item: 1234}}

forbidden(message)

Specs

forbidden(message :: String.t()) :: t()

Create forbidden error message for status code 403

Example

iex> ErrorMessage.forbidden("error message")
%ErrorMessage{code: :forbidden, message: "error message"}

forbidden(message, details)

Specs

forbidden(message :: String.t(), details :: any()) :: t()

Create forbidden error message for status code 403 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.forbidden("error message", %{item: 1234})
%ErrorMessage{code: :forbidden, message: "error message", details: %{item: 1234}}

found(message)

Specs

found(message :: String.t()) :: t()

Create found error message for status code 302

Example

iex> ErrorMessage.found("error message")
%ErrorMessage{code: :found, message: "error message"}

found(message, details)

Specs

found(message :: String.t(), details :: any()) :: t()

Create found error message for status code 302 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.found("error message", %{item: 1234})
%ErrorMessage{code: :found, message: "error message", details: %{item: 1234}}

gateway_timeout(message)

Specs

gateway_timeout(message :: String.t()) :: t()

Create gateway_timeout error message for status code 504

Example

iex> ErrorMessage.gateway_timeout("error message")
%ErrorMessage{code: :gateway_timeout, message: "error message"}

gateway_timeout(message, details)

Specs

gateway_timeout(message :: String.t(), details :: any()) :: t()

Create gateway_timeout error message for status code 504 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.gateway_timeout("error message", %{item: 1234})
%ErrorMessage{code: :gateway_timeout, message: "error message", details: %{item: 1234}}

gone(message)

Specs

gone(message :: String.t()) :: t()

Create gone error message for status code 410

Example

iex> ErrorMessage.gone("error message")
%ErrorMessage{code: :gone, message: "error message"}

gone(message, details)

Specs

gone(message :: String.t(), details :: any()) :: t()

Create gone error message for status code 410 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.gone("error message", %{item: 1234})
%ErrorMessage{code: :gone, message: "error message", details: %{item: 1234}}

http_code(error_code)

Specs

http_code(error_code :: code()) :: non_neg_integer()

http_code(error_message :: t()) :: non_neg_integer()

Returns the http code for an error message or error code atom

Example

iex> ErrorMessage.http_code(:internal_server_error)
500

iex> ErrorMessage.http_code(ErrorMessage.not_found("some_message"))
404

http_code_reason_atom(error_code)

Specs

http_code_reason_atom(error_code :: non_neg_integer()) :: code()

Returns the http reason as an atom for the http error code

Example

iex> ErrorMessage.http_code_reason_atom(500)
:internal_server_error

http_version_not_supported(message)

Specs

http_version_not_supported(message :: String.t()) :: t()

Create http_version_not_supported error message for status code 505

Example

iex> ErrorMessage.http_version_not_supported("error message")
%ErrorMessage{code: :http_version_not_supported, message: "error message"}

http_version_not_supported(message, details)

Specs

http_version_not_supported(message :: String.t(), details :: any()) :: t()

Create http_version_not_supported error message for status code 505 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.http_version_not_supported("error message", %{item: 1234})
%ErrorMessage{code: :http_version_not_supported, message: "error message", details: %{item: 1234}}

im_a_teapot(message)

Specs

im_a_teapot(message :: String.t()) :: t()

Create im_a_teapot error message for status code 418

Example

iex> ErrorMessage.im_a_teapot("error message")
%ErrorMessage{code: :im_a_teapot, message: "error message"}

im_a_teapot(message, details)

Specs

im_a_teapot(message :: String.t(), details :: any()) :: t()

Create im_a_teapot error message for status code 418 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.im_a_teapot("error message", %{item: 1234})
%ErrorMessage{code: :im_a_teapot, message: "error message", details: %{item: 1234}}

insufficient_storage(message)

Specs

insufficient_storage(message :: String.t()) :: t()

Create insufficient_storage error message for status code 507

Example

iex> ErrorMessage.insufficient_storage("error message")
%ErrorMessage{code: :insufficient_storage, message: "error message"}

insufficient_storage(message, details)

Specs

insufficient_storage(message :: String.t(), details :: any()) :: t()

Create insufficient_storage error message for status code 507 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.insufficient_storage("error message", %{item: 1234})
%ErrorMessage{code: :insufficient_storage, message: "error message", details: %{item: 1234}}

internal_server_error(message)

Specs

internal_server_error(message :: String.t()) :: t()

Create internal_server_error error message for status code 500

Example

iex> ErrorMessage.internal_server_error("error message")
%ErrorMessage{code: :internal_server_error, message: "error message"}

internal_server_error(message, details)

Specs

internal_server_error(message :: String.t(), details :: any()) :: t()

Create internal_server_error error message for status code 500 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.internal_server_error("error message", %{item: 1234})
%ErrorMessage{code: :internal_server_error, message: "error message", details: %{item: 1234}}

length_required(message)

Specs

length_required(message :: String.t()) :: t()

Create length_required error message for status code 411

Example

iex> ErrorMessage.length_required("error message")
%ErrorMessage{code: :length_required, message: "error message"}

length_required(message, details)

Specs

length_required(message :: String.t(), details :: any()) :: t()

Create length_required error message for status code 411 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.length_required("error message", %{item: 1234})
%ErrorMessage{code: :length_required, message: "error message", details: %{item: 1234}}

locked(message)

Specs

locked(message :: String.t()) :: t()

Create locked error message for status code 423

Example

iex> ErrorMessage.locked("error message")
%ErrorMessage{code: :locked, message: "error message"}

locked(message, details)

Specs

locked(message :: String.t(), details :: any()) :: t()

Create locked error message for status code 423 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.locked("error message", %{item: 1234})
%ErrorMessage{code: :locked, message: "error message", details: %{item: 1234}}

loop_detected(message)

Specs

loop_detected(message :: String.t()) :: t()

Create loop_detected error message for status code 508

Example

iex> ErrorMessage.loop_detected("error message")
%ErrorMessage{code: :loop_detected, message: "error message"}

loop_detected(message, details)

Specs

loop_detected(message :: String.t(), details :: any()) :: t()

Create loop_detected error message for status code 508 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.loop_detected("error message", %{item: 1234})
%ErrorMessage{code: :loop_detected, message: "error message", details: %{item: 1234}}

method_not_allowed(message)

Specs

method_not_allowed(message :: String.t()) :: t()

Create method_not_allowed error message for status code 405

Example

iex> ErrorMessage.method_not_allowed("error message")
%ErrorMessage{code: :method_not_allowed, message: "error message"}

method_not_allowed(message, details)

Specs

method_not_allowed(message :: String.t(), details :: any()) :: t()

Create method_not_allowed error message for status code 405 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.method_not_allowed("error message", %{item: 1234})
%ErrorMessage{code: :method_not_allowed, message: "error message", details: %{item: 1234}}

misdirected_request(message)

Specs

misdirected_request(message :: String.t()) :: t()

Create misdirected_request error message for status code 421

Example

iex> ErrorMessage.misdirected_request("error message")
%ErrorMessage{code: :misdirected_request, message: "error message"}

misdirected_request(message, details)

Specs

misdirected_request(message :: String.t(), details :: any()) :: t()

Create misdirected_request error message for status code 421 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.misdirected_request("error message", %{item: 1234})
%ErrorMessage{code: :misdirected_request, message: "error message", details: %{item: 1234}}

moved_permanently(message)

Specs

moved_permanently(message :: String.t()) :: t()

Create moved_permanently error message for status code 301

Example

iex> ErrorMessage.moved_permanently("error message")
%ErrorMessage{code: :moved_permanently, message: "error message"}

moved_permanently(message, details)

Specs

moved_permanently(message :: String.t(), details :: any()) :: t()

Create moved_permanently error message for status code 301 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.moved_permanently("error message", %{item: 1234})
%ErrorMessage{code: :moved_permanently, message: "error message", details: %{item: 1234}}

multiple_choices(message)

Specs

multiple_choices(message :: String.t()) :: t()

Create multiple_choices error message for status code 300

Example

iex> ErrorMessage.multiple_choices("error message")
%ErrorMessage{code: :multiple_choices, message: "error message"}

multiple_choices(message, details)

Specs

multiple_choices(message :: String.t(), details :: any()) :: t()

Create multiple_choices error message for status code 300 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.multiple_choices("error message", %{item: 1234})
%ErrorMessage{code: :multiple_choices, message: "error message", details: %{item: 1234}}

network_authentication_required(message)

Specs

network_authentication_required(message :: String.t()) :: t()

Create network_authentication_required error message for status code 511

Example

iex> ErrorMessage.network_authentication_required("error message")
%ErrorMessage{code: :network_authentication_required, message: "error message"}

network_authentication_required(message, details)

Specs

network_authentication_required(message :: String.t(), details :: any()) :: t()

Create network_authentication_required error message for status code 511 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.network_authentication_required("error message", %{item: 1234})
%ErrorMessage{code: :network_authentication_required, message: "error message", details: %{item: 1234}}

not_acceptable(message)

Specs

not_acceptable(message :: String.t()) :: t()

Create not_acceptable error message for status code 406

Example

iex> ErrorMessage.not_acceptable("error message")
%ErrorMessage{code: :not_acceptable, message: "error message"}

not_acceptable(message, details)

Specs

not_acceptable(message :: String.t(), details :: any()) :: t()

Create not_acceptable error message for status code 406 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.not_acceptable("error message", %{item: 1234})
%ErrorMessage{code: :not_acceptable, message: "error message", details: %{item: 1234}}

not_extended(message)

Specs

not_extended(message :: String.t()) :: t()

Create not_extended error message for status code 510

Example

iex> ErrorMessage.not_extended("error message")
%ErrorMessage{code: :not_extended, message: "error message"}

not_extended(message, details)

Specs

not_extended(message :: String.t(), details :: any()) :: t()

Create not_extended error message for status code 510 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.not_extended("error message", %{item: 1234})
%ErrorMessage{code: :not_extended, message: "error message", details: %{item: 1234}}

not_found(message)

Specs

not_found(message :: String.t()) :: t()

Create not_found error message for status code 404

Example

iex> ErrorMessage.not_found("error message")
%ErrorMessage{code: :not_found, message: "error message"}

not_found(message, details)

Specs

not_found(message :: String.t(), details :: any()) :: t()

Create not_found error message for status code 404 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.not_found("error message", %{item: 1234})
%ErrorMessage{code: :not_found, message: "error message", details: %{item: 1234}}

not_implemented(message)

Specs

not_implemented(message :: String.t()) :: t()

Create not_implemented error message for status code 501

Example

iex> ErrorMessage.not_implemented("error message")
%ErrorMessage{code: :not_implemented, message: "error message"}

not_implemented(message, details)

Specs

not_implemented(message :: String.t(), details :: any()) :: t()

Create not_implemented error message for status code 501 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.not_implemented("error message", %{item: 1234})
%ErrorMessage{code: :not_implemented, message: "error message", details: %{item: 1234}}

not_modified(message)

Specs

not_modified(message :: String.t()) :: t()

Create not_modified error message for status code 304

Example

iex> ErrorMessage.not_modified("error message")
%ErrorMessage{code: :not_modified, message: "error message"}

not_modified(message, details)

Specs

not_modified(message :: String.t(), details :: any()) :: t()

Create not_modified error message for status code 304 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.not_modified("error message", %{item: 1234})
%ErrorMessage{code: :not_modified, message: "error message", details: %{item: 1234}}

payment_required(message)

Specs

payment_required(message :: String.t()) :: t()

Create payment_required error message for status code 402

Example

iex> ErrorMessage.payment_required("error message")
%ErrorMessage{code: :payment_required, message: "error message"}

payment_required(message, details)

Specs

payment_required(message :: String.t(), details :: any()) :: t()

Create payment_required error message for status code 402 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.payment_required("error message", %{item: 1234})
%ErrorMessage{code: :payment_required, message: "error message", details: %{item: 1234}}

permanent_redirect(message)

Specs

permanent_redirect(message :: String.t()) :: t()

Create permanent_redirect error message for status code 308

Example

iex> ErrorMessage.permanent_redirect("error message")
%ErrorMessage{code: :permanent_redirect, message: "error message"}

permanent_redirect(message, details)

Specs

permanent_redirect(message :: String.t(), details :: any()) :: t()

Create permanent_redirect error message for status code 308 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.permanent_redirect("error message", %{item: 1234})
%ErrorMessage{code: :permanent_redirect, message: "error message", details: %{item: 1234}}

precondition_failed(message)

Specs

precondition_failed(message :: String.t()) :: t()

Create precondition_failed error message for status code 412

Example

iex> ErrorMessage.precondition_failed("error message")
%ErrorMessage{code: :precondition_failed, message: "error message"}

precondition_failed(message, details)

Specs

precondition_failed(message :: String.t(), details :: any()) :: t()

Create precondition_failed error message for status code 412 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.precondition_failed("error message", %{item: 1234})
%ErrorMessage{code: :precondition_failed, message: "error message", details: %{item: 1234}}

precondition_required(message)

Specs

precondition_required(message :: String.t()) :: t()

Create precondition_required error message for status code 428

Example

iex> ErrorMessage.precondition_required("error message")
%ErrorMessage{code: :precondition_required, message: "error message"}

precondition_required(message, details)

Specs

precondition_required(message :: String.t(), details :: any()) :: t()

Create precondition_required error message for status code 428 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.precondition_required("error message", %{item: 1234})
%ErrorMessage{code: :precondition_required, message: "error message", details: %{item: 1234}}

proxy_authentication_required(message)

Specs

proxy_authentication_required(message :: String.t()) :: t()

Create proxy_authentication_required error message for status code 407

Example

iex> ErrorMessage.proxy_authentication_required("error message")
%ErrorMessage{code: :proxy_authentication_required, message: "error message"}

proxy_authentication_required(message, details)

Specs

proxy_authentication_required(message :: String.t(), details :: any()) :: t()

Create proxy_authentication_required error message for status code 407 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.proxy_authentication_required("error message", %{item: 1234})
%ErrorMessage{code: :proxy_authentication_required, message: "error message", details: %{item: 1234}}

request_entity_too_large(message)

Specs

request_entity_too_large(message :: String.t()) :: t()

Create request_entity_too_large error message for status code 413

Example

iex> ErrorMessage.request_entity_too_large("error message")
%ErrorMessage{code: :request_entity_too_large, message: "error message"}

request_entity_too_large(message, details)

Specs

request_entity_too_large(message :: String.t(), details :: any()) :: t()

Create request_entity_too_large error message for status code 413 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.request_entity_too_large("error message", %{item: 1234})
%ErrorMessage{code: :request_entity_too_large, message: "error message", details: %{item: 1234}}

request_header_fields_too_large(message)

Specs

request_header_fields_too_large(message :: String.t()) :: t()

Create request_header_fields_too_large error message for status code 431

Example

iex> ErrorMessage.request_header_fields_too_large("error message")
%ErrorMessage{code: :request_header_fields_too_large, message: "error message"}

request_header_fields_too_large(message, details)

Specs

request_header_fields_too_large(message :: String.t(), details :: any()) :: t()

Create request_header_fields_too_large error message for status code 431 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.request_header_fields_too_large("error message", %{item: 1234})
%ErrorMessage{code: :request_header_fields_too_large, message: "error message", details: %{item: 1234}}

request_timeout(message)

Specs

request_timeout(message :: String.t()) :: t()

Create request_timeout error message for status code 408

Example

iex> ErrorMessage.request_timeout("error message")
%ErrorMessage{code: :request_timeout, message: "error message"}

request_timeout(message, details)

Specs

request_timeout(message :: String.t(), details :: any()) :: t()

Create request_timeout error message for status code 408 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.request_timeout("error message", %{item: 1234})
%ErrorMessage{code: :request_timeout, message: "error message", details: %{item: 1234}}

request_uri_too_long(message)

Specs

request_uri_too_long(message :: String.t()) :: t()

Create request_uri_too_long error message for status code 414

Example

iex> ErrorMessage.request_uri_too_long("error message")
%ErrorMessage{code: :request_uri_too_long, message: "error message"}

request_uri_too_long(message, details)

Specs

request_uri_too_long(message :: String.t(), details :: any()) :: t()

Create request_uri_too_long error message for status code 414 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.request_uri_too_long("error message", %{item: 1234})
%ErrorMessage{code: :request_uri_too_long, message: "error message", details: %{item: 1234}}

requested_range_not_satisfiable(message)

Specs

requested_range_not_satisfiable(message :: String.t()) :: t()

Create requested_range_not_satisfiable error message for status code 416

Example

iex> ErrorMessage.requested_range_not_satisfiable("error message")
%ErrorMessage{code: :requested_range_not_satisfiable, message: "error message"}

requested_range_not_satisfiable(message, details)

Specs

requested_range_not_satisfiable(message :: String.t(), details :: any()) :: t()

Create requested_range_not_satisfiable error message for status code 416 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.requested_range_not_satisfiable("error message", %{item: 1234})
%ErrorMessage{code: :requested_range_not_satisfiable, message: "error message", details: %{item: 1234}}

see_other(message)

Specs

see_other(message :: String.t()) :: t()

Create see_other error message for status code 303

Example

iex> ErrorMessage.see_other("error message")
%ErrorMessage{code: :see_other, message: "error message"}

see_other(message, details)

Specs

see_other(message :: String.t(), details :: any()) :: t()

Create see_other error message for status code 303 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.see_other("error message", %{item: 1234})
%ErrorMessage{code: :see_other, message: "error message", details: %{item: 1234}}

service_unavailable(message)

Specs

service_unavailable(message :: String.t()) :: t()

Create service_unavailable error message for status code 503

Example

iex> ErrorMessage.service_unavailable("error message")
%ErrorMessage{code: :service_unavailable, message: "error message"}

service_unavailable(message, details)

Specs

service_unavailable(message :: String.t(), details :: any()) :: t()

Create service_unavailable error message for status code 503 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.service_unavailable("error message", %{item: 1234})
%ErrorMessage{code: :service_unavailable, message: "error message", details: %{item: 1234}}

switch_proxy(message)

Specs

switch_proxy(message :: String.t()) :: t()

Create switch_proxy error message for status code 306

Example

iex> ErrorMessage.switch_proxy("error message")
%ErrorMessage{code: :switch_proxy, message: "error message"}

switch_proxy(message, details)

Specs

switch_proxy(message :: String.t(), details :: any()) :: t()

Create switch_proxy error message for status code 306 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.switch_proxy("error message", %{item: 1234})
%ErrorMessage{code: :switch_proxy, message: "error message", details: %{item: 1234}}

temporary_redirect(message)

Specs

temporary_redirect(message :: String.t()) :: t()

Create temporary_redirect error message for status code 307

Example

iex> ErrorMessage.temporary_redirect("error message")
%ErrorMessage{code: :temporary_redirect, message: "error message"}

temporary_redirect(message, details)

Specs

temporary_redirect(message :: String.t(), details :: any()) :: t()

Create temporary_redirect error message for status code 307 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.temporary_redirect("error message", %{item: 1234})
%ErrorMessage{code: :temporary_redirect, message: "error message", details: %{item: 1234}}

to_jsonable_map(error_message)

Specs

to_jsonable_map(error_message :: t()) :: t_map()

Converts an %ErrorMessage{} struct to a map and makes sure that the contents of the details map can be converted to json

## Example

  iex> ErrorMessage.to_jsonable_map(ErrorMessage.not_found("couldn't find user", %{user_id: "as21fasdfJ"}))
  %{code: :not_found, message: "couldn't find user", details: %{user_id: "as21fasdfJ"}}

  iex> error = ErrorMessage.im_a_teapot("teapot", %{
  ...>   user: %{health: {:alive, 500}},
  ...>   test: %TestStruct{a: [Date.new!(2020, 1, 10)]}
  ...> })
  iex> ErrorMessage.to_jsonable_map(error)
  %{
    code: :im_a_teapot,
    message: "teapot",
    details: %{
      user: %{health: [:alive, 500]},
      test: %{struct: "ErrorMessageTest.TestStruct", data: %{a: ["2020-01-10"]}}
    }
  }

to_string(error_message)

Specs

to_string(error_message :: t()) :: String.t()

Converts an %ErrorMessage{} struct to a string formatted error message

## Example

  iex> ErrorMessage.to_string(ErrorMessage.internal_server_error("Something bad happened", %{result: :unknown}))
  "internal_server_error - Something bad happened\nDetails: \n%{result: :unknown}"

too_early(message)

Specs

too_early(message :: String.t()) :: t()

Create too_early error message for status code 425

Example

iex> ErrorMessage.too_early("error message")
%ErrorMessage{code: :too_early, message: "error message"}

too_early(message, details)

Specs

too_early(message :: String.t(), details :: any()) :: t()

Create too_early error message for status code 425 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.too_early("error message", %{item: 1234})
%ErrorMessage{code: :too_early, message: "error message", details: %{item: 1234}}

too_many_requests(message)

Specs

too_many_requests(message :: String.t()) :: t()

Create too_many_requests error message for status code 429

Example

iex> ErrorMessage.too_many_requests("error message")
%ErrorMessage{code: :too_many_requests, message: "error message"}

too_many_requests(message, details)

Specs

too_many_requests(message :: String.t(), details :: any()) :: t()

Create too_many_requests error message for status code 429 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.too_many_requests("error message", %{item: 1234})
%ErrorMessage{code: :too_many_requests, message: "error message", details: %{item: 1234}}

unauthorized(message)

Specs

unauthorized(message :: String.t()) :: t()

Create unauthorized error message for status code 401

Example

iex> ErrorMessage.unauthorized("error message")
%ErrorMessage{code: :unauthorized, message: "error message"}

unauthorized(message, details)

Specs

unauthorized(message :: String.t(), details :: any()) :: t()

Create unauthorized error message for status code 401 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.unauthorized("error message", %{item: 1234})
%ErrorMessage{code: :unauthorized, message: "error message", details: %{item: 1234}}

unavailable_for_legal_reasons(message)

Specs

unavailable_for_legal_reasons(message :: String.t()) :: t()

Create unavailable_for_legal_reasons error message for status code 451

Example

iex> ErrorMessage.unavailable_for_legal_reasons("error message")
%ErrorMessage{code: :unavailable_for_legal_reasons, message: "error message"}

unavailable_for_legal_reasons(message, details)

Specs

unavailable_for_legal_reasons(message :: String.t(), details :: any()) :: t()

Create unavailable_for_legal_reasons error message for status code 451 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.unavailable_for_legal_reasons("error message", %{item: 1234})
%ErrorMessage{code: :unavailable_for_legal_reasons, message: "error message", details: %{item: 1234}}

unprocessable_entity(message)

Specs

unprocessable_entity(message :: String.t()) :: t()

Create unprocessable_entity error message for status code 422

Example

iex> ErrorMessage.unprocessable_entity("error message")
%ErrorMessage{code: :unprocessable_entity, message: "error message"}

unprocessable_entity(message, details)

Specs

unprocessable_entity(message :: String.t(), details :: any()) :: t()

Create unprocessable_entity error message for status code 422 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.unprocessable_entity("error message", %{item: 1234})
%ErrorMessage{code: :unprocessable_entity, message: "error message", details: %{item: 1234}}

unsupported_media_type(message)

Specs

unsupported_media_type(message :: String.t()) :: t()

Create unsupported_media_type error message for status code 415

Example

iex> ErrorMessage.unsupported_media_type("error message")
%ErrorMessage{code: :unsupported_media_type, message: "error message"}

unsupported_media_type(message, details)

Specs

unsupported_media_type(message :: String.t(), details :: any()) :: t()

Create unsupported_media_type error message for status code 415 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.unsupported_media_type("error message", %{item: 1234})
%ErrorMessage{code: :unsupported_media_type, message: "error message", details: %{item: 1234}}

upgrade_required(message)

Specs

upgrade_required(message :: String.t()) :: t()

Create upgrade_required error message for status code 426

Example

iex> ErrorMessage.upgrade_required("error message")
%ErrorMessage{code: :upgrade_required, message: "error message"}

upgrade_required(message, details)

Specs

upgrade_required(message :: String.t(), details :: any()) :: t()

Create upgrade_required error message for status code 426 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.upgrade_required("error message", %{item: 1234})
%ErrorMessage{code: :upgrade_required, message: "error message", details: %{item: 1234}}

use_proxy(message)

Specs

use_proxy(message :: String.t()) :: t()

Create use_proxy error message for status code 305

Example

iex> ErrorMessage.use_proxy("error message")
%ErrorMessage{code: :use_proxy, message: "error message"}

use_proxy(message, details)

Specs

use_proxy(message :: String.t(), details :: any()) :: t()

Create use_proxy error message for status code 305 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.use_proxy("error message", %{item: 1234})
%ErrorMessage{code: :use_proxy, message: "error message", details: %{item: 1234}}

variant_also_negotiates(message)

Specs

variant_also_negotiates(message :: String.t()) :: t()

Create variant_also_negotiates error message for status code 506

Example

iex> ErrorMessage.variant_also_negotiates("error message")
%ErrorMessage{code: :variant_also_negotiates, message: "error message"}

variant_also_negotiates(message, details)

Specs

variant_also_negotiates(message :: String.t(), details :: any()) :: t()

Create variant_also_negotiates error message for status code 506 with a details item which is passed in as the details key under the ErrorMessage struct

Example

iex> ErrorMessage.variant_also_negotiates("error message", %{item: 1234})
%ErrorMessage{code: :variant_also_negotiates, message: "error message", details: %{item: 1234}}