Jidoka.Error (Jidoka v0.8.0-beta.1)

Copy Markdown View Source

Splode-backed error helpers for Jidoka.

Runtime-facing APIs should return these errors instead of leaking raw atoms, tuples, or third-party exception structs. Lower-level constructors may still return library-native validation details when that is the precise contract.

Summary

Types

category()
class()
class_module()
context()
error_class()
t()

Functions

category(arg1)

Returns the Jidoka error category for a normalized exception or aggregate error.

config_error(message, details \\ %{})

Builds a Splode-backed configuration error.

execution_error(message, details \\ %{})

Builds a Splode-backed execution error.

format(error)

Formats a Jidoka/Splode error into a short human-readable message.

normalize(reason, context \\ %{})

Normalizes arbitrary error terms into a Jidoka/Splode exception.

normalized?(error)

Returns whether an error term is already a Jidoka/Splode error.

splode_error?(arg1, splode)
to_map(error)

Converts a Jidoka/Splode error into a serializable map.

traverse_errors(error_or_errors, fun)

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

unwrap!(result, opts \\ nil)

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

validation_error(message, details \\ %{})

Builds a Splode-backed validation error.

Types

category()

@type category() :: :validation | :configuration | :execution | :internal | :unknown

class()

@type class() :: %{
  :__struct__ => class_module(),
  :__exception__ => true,
  :errors => [t()],
  :class => error_class(),
  :bread_crumbs => [String.t()],
  :vars => Keyword.t(),
  :stacktrace => Splode.Stacktrace.t() | nil,
  :context => map(),
  optional(atom()) => any()
}

class_module()

@type class_module() ::
  Jidoka.Error.Internal
  | Jidoka.Error.Config
  | Jidoka.Error.Execution
  | Jidoka.Error.Invalid
  | Splode.Error.Unknown

context()

@type context() :: keyword() | map()

error_class()

@type error_class() :: :internal | :config | :execution | :invalid | :unknown

t()

@type t() :: %{
  :__struct__ => module(),
  :__exception__ => true,
  :class => error_class(),
  :bread_crumbs => [String.t()],
  :vars => Keyword.t(),
  :stacktrace => Splode.Stacktrace.t() | nil,
  :context => map(),
  optional(atom()) => any()
}

Functions

category(arg1)

@spec category(term()) :: category()

Returns the Jidoka error category for a normalized exception or aggregate error.

config_error(message, details \\ %{})

@spec config_error(String.t(), keyword() | map()) :: Exception.t()

Builds a Splode-backed configuration error.

execution_error(message, details \\ %{})

@spec execution_error(String.t(), keyword() | map()) :: Exception.t()

Builds a Splode-backed execution error.

format(error)

@spec format(term()) :: String.t()

Formats a Jidoka/Splode error into a short human-readable message.

normalize(reason, context \\ %{})

@spec normalize(term(), context()) :: Exception.t()

Normalizes arbitrary error terms into a Jidoka/Splode exception.

normalized?(error)

@spec normalized?(term()) :: boolean()

Returns whether an error term is already a Jidoka/Splode error.

splode_error?(arg1, splode)

to_map(error)

@spec to_map(term()) :: map()

Converts a Jidoka/Splode error into a serializable map.

traverse_errors(error_or_errors, fun)

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.Jidoka.Error.traverse_errors(error, fn error ->
...>   Exception.message(error)
...> end)
%{name: ["name is required"]}

unwrap!(result, opts \\ nil)

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

validation_error(message, details \\ %{})

@spec validation_error(String.t(), keyword() | map()) :: Exception.t()

Builds a Splode-backed validation error.