Splode - Aggregatable and consistent errors for Elixir

Neat! I can think of a few places where this would clean up some of my own code.

A few ergonomics improvements that come to mind:

1. To ease the transition from existing custom exceptions to Splode and to decrease the API footprint, the existing message callback could be wrapped instead of using a splode_message callback.

2. Implement a default splode_message (or message if the first suggestion is taken) that, for instance, just inspects the :fields present in the error.

These last two I’m less sure of, but would pretty significantly reduce boilerplate:

3. Allow module namespaces to be used as implicit error classes when unspecified. For instance:

   defmodule MyApp.Errors do
     use Splode,
       error_classes: [MyApp.Errors.Invalid, MyApp.Errors.Unknown],
       unknown_error: MyApp.Errors.Unknown.Unknown
   end
   
   defmodule MyApp.Errors.Invalid.InvalidThing do
      # Implicitly belongs to the MyApp.Errors.Invalid error class
     use Splode.Error, fields: [:foo, :bar]
   end
   

4. Define error classes explicitly with use Splode.ErrorClass as opposed to implicitly by including a :errors field. This could inject the splode_message implementation, which it looks like will almost always (or just always?) be the same.

   defmodule MyApp.Errors.Invalid do
     use Splode.ErrorClass
   end
   

Taken all together, before:

defmodule MyApp.Errors do
  use Splode, error_classes: [
    invalid: MyApp.Errors.Invalid,
    unknown: MyApp.Errors.Unknown
  ],
  unknown_error: MyApp.Errors.Unknown.Unknown
end

defmodule MyApp.Errors.Invalid do
  use Splode.Error, fields: [:errors], class: :invalid

  def splode_message(%{errors: errors}) do
    Splode.ErrorClass.error_messages(errors)
  end
end

defmodule MyApp.Errors.Unknown do
  use Splode.Error, fields: [:errors], class: :unknown

  def splode_message(%{errors: errors}) do
    Splode.ErrorClass.error_messages(errors)
  end
end

defmodule MyApp.Errors.Unknown.Unknown do
  use Splode.Error, fields: [:error], class: :unknown

  def splode_message(%{error: error}) do
    if is_binary(error) do
      to_string(error)
    else
      inspect(error)
    end
  end
end

defmodule MyApp.Errors.InvalidArgument do
  use Splode.Error, fields: [:name, :message], class: :invalid

  def splode_message(%{name: name, message: message}) do
    "Invalid argument #{name}: #{message}"
  end
end

And after:

defmodule MyApp.Errors do
  use Splode,
    error_classes: [MyApp.Errors.Invalid, MyApp.Errors.Unknown],
    unknown_error: MyApp.Errors.Unknown.Unknown
end

defmodule MyApp.Errors.Invalid do
  use Splode.ErrorClass
end

defmodule MyApp.Errors.Unknown do
  use Splode.ErrorClass
end

defmodule MyApp.Errors.Unknown.Unknown do
  use Splode.Error, fields: [:error]
end

defmodule MyApp.Errors.InvalidArgument do
  use Splode.Error, fields: [:name, :message]

  def splode_message(%{name: name, message: message}) do
    "Invalid argument #{name}: #{message}"
  end
end

I’m not sure if we can wrap their existing message callback, as the message callback is required for exceptions. As for use Splode.ErrorClass I agree

I’d prefer not to use module names to implicitly detect error classes. A wrapper macro could be made that does that in someone’s application if they wish.

Also on board with splode_message having a default

If you were to switch from splode_message to using message, I think you’d need to use @before_compile and defoverridable message: 1. A basic sketch:

defmodule Splode.Error do
  defmacro __using__(opts) do
    quote do
      @before_compile unquote(__MODULE__)
      # mostly everything as before, except don't def message here
    end
  end

  defmacro __before_compile__(env) do
    ensure_def_message =
      if Module.defines?(env, {:message, 1}, :def) do
        quote(do: defoverridable message: 1)
      else
        quote do
          # default impl
        end
      end

    quote do
      unquote(ensure_def_message)

      # the existing def message implementation, except use super instead of calling splode_message
      def message(%{vars: vars} = exception) do
        string = super(exception)
        ...
      end
    end
  end
end

Yeah, that makes sense! I’m down to give that a try would want to make that change early since it affects end users defining custom extensions. Would you want to PR that change? If not I’ll add it to my list

I’d like to contribute, but won’t likely have time until mid next week at the earliest. If you want to get to it before then, that’s perfectly fine by me! How about this: I’ll open issues for these suggestions, and whichever of us gets started first can reply to those so that we’re not duplicating effort.

Perfect

I’ve made the following changes in 0.2.0:

1. now you define message/1 instead of splode_message/1
2. use Splode.ErrorClass can be used now, which adds the errors field and a default message/1 implementation.

As for the other things discussed:

1. deriving error class from namespaces: I’d personally rather not do this. It takes something explicit and makes it implicit. I imagine users that want to do this can create a custom module to use and make it work that way for them.

2. adding a default message/1 for any given error. I’m open to this, I just didn’t get around to it. It wouldn’t be a breaking change, so PRs welcome on that front

0.2.5 adds a .unwrap!/2 function on your modules that use Splode. This allows defining “bang” versions of your functions more simply.

def get_user!(user_id) do
  user_id
  |> get_user()
  |> MyApp.Errors.unwrap!()
end

def get_user(user_id) do
  case Repo.get(user_id) do
    nil ->
      {:error, MyApp.Error.NotFound.exception(resource: User, key: user_id)}
    user ->
      {:ok, user}
  end
end