feat: simplify error handler

Author: zoedsoupe

.formatter.exs

@@ -1,4 +1,4 @@
 # Used by "mix format"
 [
-  inputs: ["{mix,.formatter}.exs", "{config,apps}/**/*.{ex,exs}"]
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
 ]

lib/supabase/error.ex

@@ -37,6 +37,9 @@ defmodule Supabase.Error do
   specific to their application domain.
   """
 
+  alias Supabase.Fetcher.Request
+  alias Supabase.Fetcher.Response
+
   @type t :: %__MODULE__{
           code: atom,
           message: String.t(),
@@ -46,6 +49,9 @@ defmodule Supabase.Error do
 
   defstruct [:message, :service, code: :unexpected, metadata: %{}]
 
+  @doc "Callback used on invoking the HTTP error parsed on a response (status >= 400)"
+  @callback from(source :: term, context :: term) :: t
+
   @doc "Creates a new `Supabase.Error` struct based on informed options"
   @spec new(keyword) :: t
   def new(attrs) when is_list(attrs) do
@@ -101,41 +107,8 @@ defmodule Supabase.Error do
   end
 end
 
-defprotocol Supabase.ErrorParser do
-  @spec from(source :: term, context :: term | nil) :: Supabase.Error.t()
-  def from(source, context \\ nil)
-end
-
-defimpl Supabase.ErrorParser, for: File.Error do
-  def from(%File.Error{} = err, %Supabase.Fetcher.Request{} = ctx) do
-    message = File.Error.message(err)
-    metadata = Supabase.Error.make_default_http_metadata(ctx)
-
-    Supabase.Error.new(
-      code: :transport_error,
-      message: message,
-      service: ctx.service,
-      metadata: metadata
-    )
-  end
-
-  def from(%File.Error{} = err, _) do
-    message = File.Error.message(err)
-
-    Supabase.Error.new(
-      code: err.reason,
-      message: message
-    )
-  end
-end
-
-defimpl Supabase.ErrorParser, for: Supabase.Fetcher.Response do
-  @moduledoc "The default error parser, generally used to return unexpected errors"
-
-  alias Supabase.Fetcher.Request
-  alias Supabase.Fetcher.Response
-
-  @doc """
+defmodule Supabase.HTTPErrorParser do
+  @moduledoc """
   The default error parser in case no one is provided via `Supabase.Fetcher.with_error_parser/2`.
 
   Error parsers should be implement firstly by adjacent services libraries, to
@@ -156,10 +129,17 @@ defimpl Supabase.ErrorParser, for: Supabase.Fetcher.Response do
         headers: []
       }
 
-  All other fields are filled with the `Supabase.Fetcher` struct as context.
+  All other fields are filled with the `Supabase.Request` struct as context,
+  if available.
   """
-  @impl true
-  def from(%Response{} = resp, %Request{service: service} = ctx) do
+
+  alias Supabase.Fetcher.Request
+  alias Supabase.Fetcher.Response
+
+  @behaviour Supabase.Error
+
+  def from(%Response{} = resp, %Request{service: service} = ctx)
+      when resp.status >= 400 do
     code = parse_status(resp.status)
     metadata = Supabase.Error.make_default_http_metadata(ctx)
     metadata = Map.merge(metadata, %{resp_status: resp.status, resp_body: resp.body})

lib/supabase/fetcher.ex

@@ -158,6 +158,8 @@ defmodule Supabase.Fetcher do
       {:ok, ResponseAdapter.from(resp)}
     end
     |> handle_response(builder)
+  rescue
+    exception -> handle_exception(exception, __STACKTRACE__, builder)
   end
 
   @doc """
@@ -182,6 +184,8 @@ defmodule Supabase.Fetcher do
       {:ok, ResponseAdapter.from(resp)}
     end
     |> handle_response(builder)
+  rescue
+    exception -> handle_exception(exception, __STACKTRACE__, builder)
   end
 
   @doc """
@@ -208,6 +212,8 @@ defmodule Supabase.Fetcher do
       {:ok, ResponseAdapter.from(resp)}
     end
     |> handle_response(builder)
+  rescue
+    exception -> handle_exception(exception, __STACKTRACE__, builder)
   end
 
   def stream(%Request{http_client: http_client} = builder, on_response, opts)
@@ -216,6 +222,8 @@ defmodule Supabase.Fetcher do
       {:ok, ResponseAdapter.from(resp)}
     end
     |> handle_response(builder)
+  rescue
+    exception -> handle_exception(exception, __STACKTRACE__, builder)
   end
 
   @doc """
@@ -229,38 +237,34 @@ defmodule Supabase.Fetcher do
     end
     |> handle_response(builder)
   rescue
-    e in File.Error -> {:error, Supabase.ErrorParser.from(e)}
+    exception -> handle_exception(exception, __STACKTRACE__, builder)
   end
 
   @spec handle_response({:ok, response} | {:error, term}, context) :: Supabase.result(response)
         when response: Response.t(),
              context: Request.t()
   defp handle_response({:ok, %Response{} = resp}, %Request{} = builder) do
-    error_parser = builder.error_parser
+    decode_body? = builder.options[:decode_body?] || true
+    parse_http_err? = builder.options[:parse_http_error?] || true
+    http_error_parser = builder.error_parser
     decoder = builder.body_decoder
     decoder_opts = builder.body_decoder_opts
 
-    with {:ok, resp} <- Response.decode_body(resp, decoder, decoder_opts) do
-      if resp.status >= 400 do
-        {:error, error_parser.from(resp, builder)}
+    maybe_decode_body = fn ->
+      if decode_body? do
+        Response.decode_body(resp, decoder, decoder_opts)
+      else
+        resp
+      end
+    end
+
+    with {:ok, resp} <- maybe_decode_body.() do
+      if parse_http_err? and resp.status >= 400 do
+        {:error, http_error_parser.from(resp, builder)}
       else
         {:ok, resp}
       end
     end
-  rescue
-    e in Protocol.UndefinedError ->
-      reraise e, __STACKTRACE__
-
-    exception ->
-      message = Exception.format(:error, exception)
-      stacktrace = Exception.format_stacktrace(__STACKTRACE__)
-
-      Supabase.Error.new(
-        code: :decode_body_failed,
-        message: message,
-        service: builder.service,
-        metadata: %{stacktrace: stacktrace}
-      )
   end
 
   defp handle_response({:error, %Error{} = err}, %Request{} = builder) do
@@ -270,7 +274,28 @@ defmodule Supabase.Fetcher do
   end
 
   defp handle_response({:error, err}, %Request{} = builder) do
-    {:error, Supabase.ErrorParser.from(err, builder)}
+    metadata = Error.make_default_http_metadata(builder)
+
+    {:error,
+     Error.new(
+       code: :unexpected,
+       service: builder.service,
+       metadata: Map.put(metadata, :raw_error, err)
+     )}
+  end
+
+  defp handle_exception(exception, stacktrace, %Request{} = builder) do
+    entity = Map.get(exception, :__struct__)
+    message = entity.message(exception)
+    stacktrace = Exception.format_stacktrace(stacktrace)
+
+    {:error,
+     Supabase.Error.new(
+       code: :exception,
+       message: message,
+       service: builder.service,
+       metadata: %{stacktrace: stacktrace, exception: exception}
+     )}
   end
 
   @doc """

lib/supabase/fetcher/adapter/finch.ex

@@ -135,32 +135,4 @@ defmodule Supabase.Fetcher.Adapter.Finch do
       %Supabase.Fetcher.Response{status: resp.status, headers: resp.headers, body: resp.body}
     end
   end
-
-  defimpl Supabase.ErrorParser, for: Mint.TransportError do
-    def from(%Mint.TransportError{} = err, %Supabase.Fetcher.Request{} = ctx) do
-      message = Mint.TransportError.message(err)
-      metadata = Supabase.Error.make_default_http_metadata(ctx)
-
-      Supabase.Error.new(
-        code: :transport_error,
-        message: message,
-        service: ctx.service,
-        metadata: metadata
-      )
-    end
-  end
-
-  defimpl Supabase.ErrorParser, for: Mint.HTTPError do
-    def from(%Mint.HTTPError{} = err, %Supabase.Fetcher.Request{} = ctx) do
-      message = Mint.HTTPError.message(err)
-      metadata = Supabase.Error.make_default_http_metadata(ctx)
-
-      Supabase.Error.new(
-        code: :http_error,
-        message: message,
-        service: ctx.service,
-        metadata: metadata
-      )
-    end
-  end
 end

lib/supabase/fetcher/request.ex

@@ -66,6 +66,8 @@ defmodule Supabase.Fetcher.Request do
 
   @behaviour Supabase.Fetcher.Request.Behaviour
 
+  @type options :: list({:decode_body?, boolean} | {:parse_http_error?, boolean})
+
   @type t :: %__MODULE__{
           client: Client.t(),
           method: Supabase.Fetcher.method(),
@@ -77,7 +79,8 @@ defmodule Supabase.Fetcher.Request do
           body_decoder: module,
           body_decoder_opts: keyword,
           error_parser: module,
-          http_client: module
+          http_client: module,
+          options: options
         }
 
   defstruct [
@@ -90,8 +93,9 @@ defmodule Supabase.Fetcher.Request do
     headers: [],
     body_decoder_opts: [],
     body_decoder: Supabase.Fetcher.JSONDecoder,
-    error_parser: Supabase.ErrorParser,
-    http_client: Supabase.Fetcher.Adapter.Finch
+    error_parser: Supabase.HTTPErrorParser,
+    http_client: Supabase.Fetcher.Adapter.Finch,
+    options: [decode_body?: false, parse_http_error?: false]
   ]
 
   @doc """
@@ -100,13 +104,14 @@ defmodule Supabase.Fetcher.Request do
   easily composed using the `with_` functions of this module.
   """
   @impl true
-  def new(%Client{global: global} = client) do
+  def new(%Client{global: global} = client, opts \\ []) when is_list(opts) do
     headers =
       global.headers
       |> Map.put("authorization", "Bearer " <> client.access_token)
       |> Map.to_list()
 
     %__MODULE__{client: client, headers: headers}
+    |> Map.update!(:options, &Keyword.merge(&1, opts))
   end
 
   @services [:auth, :functions, :storage, :realtime, :database]
@@ -139,11 +144,14 @@ defmodule Supabase.Fetcher.Request do
   end
 
   @doc """
-  Attaches a custom error parser to be called after a successfull response.
+  Attaches a custom error parser to be called after a "successfull" response.
   The error parser should implement the `Supabase.Error` behaviour, and it default
-  to the `Supabase.ErrorParser`.
+  to the `Supabase.HTTPErrorParser`.
+
+  "successful" response means that the fetcher actually got a HTTP response from
+  the server, so if the HTTP status is >= 400, so this error parser will be invoked.
 
-  THis attribute can't be overwritten.
+  Check `Supabase.HTTPErrorParser` for an example of implementation.
   """
   @impl true
   def with_error_parser(%__MODULE__{} = builder, parser)

lib/supabase/fetcher/request/behaviour.ex

@@ -16,7 +16,7 @@ defmodule Supabase.Fetcher.Request.Behaviour do
   @callback with_body(Request.t(), body) :: Request.t()
             when body: Jason.Encoder.t() | {:stream, Enumerable.t()} | nil
   @callback with_headers(Request.t(), headers) :: Request.t()
-    when headers: Supabase.Fetcher.headers()
+            when headers: Supabase.Fetcher.headers()
   @callback with_body_decoder(Request.t(), decoder, decoder_opts) :: Request.t()
             when decoder: module | decoder_fun,
                  decoder_opts: keyword,

lib/supabase/fetcher/response.ex

@@ -5,7 +5,11 @@ defmodule Supabase.Fetcher.Response do
   same structure
   """
 
-  @type t :: %__MODULE__{status: Supabase.Fetcher.status(), headers: Supabase.Fetcher.headers(), body: Supabase.Fetcher.body()}
+  @type t :: %__MODULE__{
+          status: Supabase.Fetcher.status(),
+          headers: Supabase.Fetcher.headers(),
+          body: Supabase.Fetcher.body()
+        }
 
   defstruct [:status, :headers, :body]
 

lib/supabase/missing_supabase_config.ex

@@ -10,32 +10,32 @@ defmodule Supabase.MissingSupabaseConfig do
     Missing #{missing} configuration for your Supabase Client #{if client, do: client, else: ""}.
 
     #{if client do
-    """
-    Please ensure or add the following to your config/config.exs file:
+      """
+      Please ensure or add the following to your config/config.exs file:
 
-        import Config
+          import Config
 
-        config :supabase_potion, #{client},
-          base_url: "https://<app-name>.supabase.co",
-          api_key: "<supabase-api-key>",
-          conn: %{access_token: "<supabase-access-token>"},
-          db: %{schema: "another"}, # default to public
-          auth: %{debug: true}
+          config :supabase_potion, #{client},
+            base_url: "https://<app-name>.supabase.co",
+            api_key: "<supabase-api-key>",
+            conn: %{access_token: "<supabase-access-token>"},
+            db: %{schema: "another"}, # default to public
+            auth: %{debug: true}
 
-    Remember to set the environment variables SUPABASE_BASE_URL and SUPABASE_API_KEY
-    if you choose this option. Otherwise you can pass the values directly to the config file.
-    """
+      Remember to set the environment variables SUPABASE_BASE_URL and SUPABASE_API_KEY
+      if you choose this option. Otherwise you can pass the values directly to the config file.
+      """
     end}
 
     #{if is_nil(client) do
-    """
-    Please ensure you're passing the values directly to the `Supabase.init_client/3` function:
-
-        iex> Supabase.init_client!(
-        iex>   System.fetch_env!("SUPABASE_BASE_URL"),
-        iex>   System.fetch_env!("SUPABASE_API_KEY"),
-        iex> )
-    """
+      """
+      Please ensure you're passing the values directly to the `Supabase.init_client/3` function:
+
+          iex> Supabase.init_client!(
+          iex>   System.fetch_env!("SUPABASE_BASE_URL"),
+          iex>   System.fetch_env!("SUPABASE_API_KEY"),
+          iex> )
+      """
     end}
 
     #{walktrough}