@spec extract_error_message(any(), module() | nil) :: String.t()

Extracts a human-readable message from various error formats.

resource is the resource whose declared labels name the error's field. An Ash error AshPhoenix can show on a form (AshPhoenix.FormData.Error) is read the way the form reads it; one the form shows on no field is read by its own message. An error class holding several errors, such as Ash.Error.Invalid, joins the message of each, a repeated message once.

Examples

iex> MishkaGervaz.Errors.extract_error_message(%{message: "Invalid email"})
"Invalid email"

iex> MishkaGervaz.Errors.extract_error_message(%{field: :email, message: "is invalid"})
"Email is invalid"

iex> MishkaGervaz.Errors.extract_error_message(%{field: :tag_id, message: "That tag is archived."})
"That tag is archived."

iex> MishkaGervaz.Errors.extract_error_message(%{field: :title, message: "must be at least %{min}", vars: [min: 3]})
"Title must be at least 3"

@spec field_message(
  String.t() | nil,
  keyword() | map() | nil,
  atom() | String.t() | nil,
  module() | nil
) :: String.t()

An error message about field, as a person reads it.

message is translated with translate_error/2. A translated message that ends a sentence is returned as written; any other is joined to the field's name through the "%{field} %{message}" template. field is named by the label resource declares for it, else by its humanized name. A nil field, or AshPhoenix's :_form for the whole form, returns the message alone.

@spec format_flash_message(any(), module() | nil) :: String.t()

Formats an error into a human-readable flash message.

Handles MishkaGervaz errors, Ash errors, and generic errors. resource names the fields of an error that has no resource of its own; an Action.Failed or Data.LoadFailed uses its own :resource when resource is nil.

An Action.Failed names its action by its :label (a string or a zero-arity function), else by its humanized :action.

Examples

iex> error = MishkaGervaz.Errors.Action.Failed.exception(action: :archive, reason: "forbidden")
iex> MishkaGervaz.Errors.format_flash_message(error)
"Archive failed: forbidden"

iex> error = MishkaGervaz.Errors.Action.Failed.exception(action: :archive, label: "Delete", reason: "forbidden")
iex> MishkaGervaz.Errors.format_flash_message(error)
"Delete failed: forbidden"

@spec translate_error(String.t(), keyword() | map() | nil) :: String.t()

Translates an error's own message in the "errors" domain and fills its %{key} placeholders from vars.

Uses dngettext when vars holds an integer :count. A list var is joined with ", ", and a value String.Chars cannot print is inspected. A message with a %{key} placeholder vars does not fill is returned as written.

Examples

iex> MishkaGervaz.Errors.translate_error("must be at least %{min}", min: 3)
"must be at least 3"

Traverses errors, calling fun for each leaf error, and returns a nested map of results grouped by each error's path.

See Splode.traverse_errors/2 for full documentation.

Example

iex> Elixir.MishkaGervaz.Errors.traverse_errors(error, fn error ->
...>   Exception.message(error)
...> end)
%{name: ["name is required"]}

Raises an error if the result is an error, otherwise returns the result

Alternatively, you can use the defsplode macro, which does this automatically.

Options

• :error_opts - Options to pass to to_error/2 when converting the returned error
• :unknown_error_opts - Options to pass to the unknown error if the function returns only :error. not necessary if your function always returns {:error, error}.

Examples

def function(arg) do

case do_something(arg) do
  :success -> :ok
  {:success, result} -> {:ok, result}
  {:error, error} -> {:error, error}
end

end

def function!(arg) do

YourErrors.unwrap!(function(arg))

end