Chore

Describe the chore

Objective: Enhance the Supabase.Fetcher module to provide a higher-level API that seamlessly integrates with Supabase.Client, reducing redundancy and improving error handling across various Supabase integration libraries.

Key Enhancements:

1. Centralized Error Handling:

   • Implementation:
     Introduce a behaviour, Supabase.Error, to standardize error deserialization across different Supabase services. Each service can implement this behaviour to handle its specific error formats. Additionally, implement a unified Supabase.Error struct to encapsulate errors with contextual information such as the request path, arguments, and a semantic error atom.
   • Example:

     defmodule Supabase.Error do
        @type t :: %__MODULE__{
        	code: atom, 
        	message: String.t(), 
        	path: String.t(),
        	service: :database | :storage | :auth | :functions | :realtime,
        	args: map
        }
     
       defstruct [:code, :message, :path, :args, :service]
     
       @callback from_response(Finch.response(), context :: map) :: {:ok, t} | {:error, atom}
     end
     
     defmodule Supabase.Storage.Error do
       @behaviour Supabase.ErrorParser
     
       def from_response(%Finch.Response{body: body}, %{path: path, args: args}) do
         %{"code" => code, "message" => message} = body
     
         %Supabase.Error{
           code: String.to_existing_atom(code),
           message: message,
           path: path,
           args: args,
           service: :storage
         }
       end
     end

2. Enhanced Integration with Supabase.Client:

   • Implementation:
     Refactor Supabase.Fetcher to accept a Supabase.Client struct, automatically applying necessary headers and base URLs. This approach eliminates repetitive code in integration libraries and ensures consistent request construction. Also implement a request builder approach, so we can build the request with in different ways depending on the service using it without coupling the Fetcher directly to these services, so we avoid code duplication.
   • Example:

     defmodule Supabase.Fetcher do
        def new(client) do
          # merge headers
          %Finch.Request{}
        end
     
        def with_method(builder, method) do
          %{builder | method: method}
        end
     
        def with_path(builder, path) do
      	  %{builder | path: path}
        end
     
        def with_body(builder, body) do
          %{builder | body: body}
        end
     
        def with_headers(builder, headers) do
          %{builder | headers: headers}
        end
     
        def with_opts(builder, opts) do
      	  %{builder | opts: opts}
        end
     end

3. Simplified Usage in Integration Libraries:

   • Implementation:
     With the refactored Fetcher, integration libraries like storage-ex and postgrest-ex can perform API requests without manually managing headers or constructing URLs manually. This streamlines their codebases and ensures consistency across different services.
   • Example:

     defmodule Supabase.Storage do
       def list_buckets(client) do
         Supabase.Fetcher.new(client)
         |> Supabase.Fetcher.with_method(:get)
         |> Supabase.Fetcher.with_path("/bucket")
         |> then(fn
           {:ok, resp} -> parse_buckets(resp)
           {:error, resp} -> Supabase.Storage.Error.from_response(resp)
         end)
       end
     
       defp parse_buckets(response_body) do
         # Parse the response body into a list of Bucket structs
       end
     end

Benefits:

• Consistency: Standardized error parsing across services ensures uniform error handling.
• Reduced Redundancy: Automatic application of client headers and base URLs minimizes repetitive code.
• Improved Developer Experience: Integration libraries can focus on core functionalities without dealing with low-level HTTP details.

Additional context

This refactor aims to align the Elixir Supabase client with best practices observed in other language implementations within the Supabase ecosystem, promoting a cohesive developer experience across different platforms.

For reference, Supabase's documentation provides insights into error codes and handling mechanisms:

• Auth Error Codes: https://supabase.com/docs/guides/auth/debugging/error-codes
• Storage Error Codes: https://supabase.com/docs/guides/storage/debugging/error-codes

These resources can guide the implementation of the SupabaseErrorParser protocol for different services.