Supabase Elixir

https://github.com/supabase-community/supabase-ex
Admin
Supabase Elixir is a community SDK that provides Elixir developers with integrations for Supabase...
Tokens:6,543
Snippets:61
Trust Score:9.7
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Start Self-Managed Supabase Client in Supervision Tree (Elixir)

Source: https://github.com/supabase-community/supabase-ex/blob/main/README.md

This example demonstrates how to integrate the self-managed Supabase client into your application's supervision tree, typically within the `application.ex` module. By including `MyApp.Supabase.Client` in the `children` list, the client process will be started and supervised automatically when your application launches.

```elixir
defmodule MyApp.Application do
  use Application

  def start(_type, _args) do
    children = [
      MyApp.Supabase.Client
    ]

    opts = [strategy: :one_for_one, name: MyApp.Supervisor]
    Supervisor.start_link(children, opts)
  end
end
```

--------------------------------

### Start Phoenix Development Server

Source: https://github.com/supabase-community/supabase-ex/blob/main/guides/quickstarts/phoenix_liveview.md

Starts the Phoenix development server and also launches an interactive Elixir session (REPL). Access the running application via a web browser.

```sh
iex -S mix phx.server
```

--------------------------------

### Initialize Supabase Client in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_15_05_2024/presentation.md

Initializes a Supabase client with a given name and optional additional configuration. It returns the PID of the started client process.

```elixir
Supabase.init_client(MyClient, additional_config)
{:ok, #PID<0.123.0>}
```

--------------------------------

### Setting Environment Variables for Supabase

Source: https://github.com/supabase-community/supabase-ex/blob/main/examples/user_management/README.md

Configures Supabase connection details by exporting the Supabase URL and API key as environment variables. These are essential for the application to authenticate with the Supabase backend.

```bash
export SUPABASE_URL=https://your-project.supabase.co
export SUPABASE_KEY=your-anon-key
```

--------------------------------

### Supabase Database Schema for User Profiles and Storage

Source: https://github.com/supabase-community/supabase-ex/blob/main/examples/user_management/README.md

Defines the SQL schema for user profiles and Supabase Storage buckets. It includes table creation, row-level security policies for access control, and storage bucket setup for avatar images.

```sql
-- Create a table for public "profiles"
create table profiles (
  id uuid primary key,
  user_id uuid not null,
  username text,
  website text,
  avatar_url text,
  inserted_at timestamp with time zone default timezone('utc'::text, now()) not null,
  updated_at timestamp with time zone default timezone('utc'::text, now()) not null
);

alter table profiles enable row level security;

create policy "Public profiles are viewable by everyone."
  on profiles for select
  using ( true );

create policy "Users can insert their own profile."
  on profiles for insert
  with check ( auth.uid() = user_id );

create policy "Users can update own profile."
  on profiles for update
  using ( auth.uid() = user_id );

-- Set up Storage
insert into storage.buckets (id, name)
values ('avatars', 'avatars');

create policy "Avatar images are publicly accessible."
  on storage.objects for select
  using ( bucket_id = 'avatars' );

create policy "Anyone can upload an avatar."
  on storage.objects for insert
  with check ( bucket_id = 'avatars' );
```

--------------------------------

### Initialize Supabase Client in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_08_11_2023/presentation.md

Demonstrates two methods for initializing a Supabase client. The first method uses `Supabase.init_client/1` for a named client, and the second shows how to manually start a client using `Supabase.Client.start_link/1` with explicit parameters.

```elixir
Supabase.init_client(%{name: MyClient})
{:ok, #PID<0.123.0>}
```

```elixir
{:ok, #PID<0.123.0>} = Supabase.Client.start_link(params)
```

--------------------------------

### Interact with Self-Managed Supabase Client (Elixir)

Source: https://github.com/supabase-community/supabase-ex/blob/main/README.md

Shows how to retrieve and interact with a self-managed Supabase client. After starting the client process, you can get the client instance using `MyApp.Supabase.Client.get_client()` and then use it to call Supabase functions, such as `Supabase.GoTrue.sign_in_with_password/2`.

```elixir
iex> {:ok, client} = MyApp.Supabase.Client.get_client()
iex> Supabase.GoTrue.sign_in_with_password(client, email: "", password: "")
```

--------------------------------

### Interact with Database using Phoenix Console

Source: https://github.com/supabase-community/supabase-ex/blob/main/guides/quickstarts/phoenix_liveview.md

Demonstrates how to use the Phoenix interactive console (IEx) to interact with the Ecto repository. Examples include inserting a new record and retrieving all records for the 'Article' model.

```iex
iex -S mix

article = %Blog.Posts.Article{title: "Hello Phoenix", body: "I am on Phoenix!"}
Blog.Repo.insert!(article) # Saves the entry to the database
Blog.Repo.all(Blog.Posts.Article) # Lists all the entries of a model in the database
```

--------------------------------

### Use Supabase Storage API in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_08_11_2023/presentation.md

Demonstrates how to interact with the Supabase Storage API using the initialized client. This example shows calling `Supabase.Storage.list_buckets/1`, highlighting that the client PID can be passed directly to integration functions.

```elixir
Supabase.Storage.list_buckets(MyClient) # can also receive the client PID
{:ok, [%Supabase.Storage.Bucket{...}, ...]}}
```

--------------------------------

### Create Phoenix LiveView Project

Source: https://github.com/supabase-community/supabase-ex/blob/main/guides/quickstarts/phoenix_liveview.md

Scaffolds a new Phoenix LiveView project using the Mix build tool. Assumes Elixir and Phoenix installers are up to date. PostgreSQL is the default database.

```sh
mix phx.new blog
```

--------------------------------

### Interact with Specialized Supabase Clients in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_15_05_2024/presentation.md

Shows how to use the defined specialized Supabase clients, such as the Auth client, to interact with Supabase features like getting user information from a session.

```elixir
MyApp.Supabase.Auth.get_user(%Session{})
{:ok, %User{}}
```

--------------------------------

### Manage Supabase Client Supervisor in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_08_11_2023/presentation.md

Illustrates how to integrate Supabase client management into an Elixir application's supervision tree. It defines a supervisor that starts `Supabase.ClientSupervisor`, allowing for robust management of Supabase client processes.

```elixir
defmodule MyApp.Application do
  use Application

  def start(_type, _args) do
    children = [
      {Supabase.ClientSupervisor, []}
    ]

    opts = [strategy: :one_for_one, name: MyApp.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

Supabase.ClientSupervisor.start_child({Supabase.Client, params})
{:ok, #PID<0.123.0>}
```

--------------------------------

### Initialize One-Off Supabase Client (Elixir)

Source: https://github.com/supabase-community/supabase-ex/blob/main/README.md

Demonstrates how to initialize a one-off Supabase client using `Supabase.init_client/2` or `Supabase.init_client/3` with optional configurations. This client is managed by the application and is suitable for simple API interactions. The function returns an `{:ok, %Supabase.Client{}}` tuple upon successful initialization.

```elixir
iex> Supabase.init_client("https://<supabase-url>", "<supabase-api-key>")
iex> {:ok, %Supabase.Client{}}

iex> Supabase.init_client("https://<supabase-url>", "<supabase-api-key>",
  db: [schema: "another"],
  auth: [flow_type: :pkce],
  global: [headers: %{"custom-header" => "custom-value"}]
)
iex> {:ok, %Supabase.Client{}}
```

--------------------------------

### Configure Supabase Client in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_15_05_2024/presentation.md

Sets the necessary Supabase URL and API key in the application's configuration. This is a prerequisite for initializing any Supabase client.

```elixir
import Config

config :supabase_potion,
  supabase_base_url: System.get_env("SUPABASE_URL"),
  supabase_api_key: System.get_env("SUPABASE_KEY")
```

--------------------------------

### Configure Self-Managed Supabase Client (Elixir)

Source: https://github.com/supabase-community/supabase-ex/blob/main/README.md

Illustrates how to configure a self-managed Supabase client in your Elixir application's configuration files (`config.exs` or `runtime.exs`). This involves setting the `base_url`, `api_key`, and optionally `access_token`, along with any other client-specific options. The `:my_app` should match the `otp_app` defined in the client module.

```elixir
import Config

# `:my_app` here is the same `otp_app` option you passed
config :my_app, MyApp.Supabase.Client,
  base_url: "https://<supabase-url>", # required
  api_key: "<supabase-api-key>", # required
  access_token: "<supabase-token>", # optional
   # additional options
  db: [schema: "another"],
  auth: [flow_type: :implicit, debug: true],
  global: [headers: %{"custom-header" => "custom-value"}]
```

--------------------------------

### Create and Run Database Migration

Source: https://github.com/supabase-community/supabase-ex/blob/main/guides/quickstarts/phoenix_liveview.md

Generates an Ecto schema for an 'Article' model with 'title' (string) and 'views' (integer) fields, and then runs the database migrations. This process creates the corresponding table in the database.

```sh
mix phx.gen.schema Posts.Article articles title:string views:integer
mix ecto.migrate
```

--------------------------------

### Configure Supabase Database Connection

Source: https://github.com/supabase-community/supabase-ex/blob/main/guides/quickstarts/phoenix_liveview.md

Sets up environment variables and configuration files for connecting a Phoenix application to a Supabase Postgres database. Includes configurations for both production and local development environments.

```sh
export DATABASE_URL=ecto://postgres.xxxx:password@xxxx.pooler.supabase.com:5432/postgres
```

```elixir
# config/dev.exs

import Config

config :blog, Blog.Repo,
  hostname: "localhost",
  port: 54322, # default supabase-cli postgres port
  username: "postgres",
  password: "postgres",
  database: "postgres"

# other configs

```

--------------------------------

### Phoenix Router Configuration for Supabase Auth in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_15_05_2024/presentation.md

Demonstrates how to configure a Phoenix router to leverage Supabase GoTrue's Plug and LiveView hooks for authentication management, including redirecting users based on authentication status.

```elixir
defmodule MyAppWeb.Router do
  use Phoenix.Router

  import Supabase.GoTrue.Plug
  alias Supabase.GoTrue.LiveView, as: Supabase.LiveView

  pipeline :browser do
   # ...
  end

  scope "/", MyAppWeb do
    pipe_through [:browser, :redirect_if_user_is_authenticated]
  end

  scope "/", MyAppWeb do
    pipe_through [:browser, :require_authenticated_user]
    get "/super-secret", MyController, :show
  end

  scope "/", MyAppWeb do
    pipe_through :browser

    live_session :require_authentication,
      on_mount: [{Supabase.LiveView, :ensure_authenticated}] do
      live "/secret", MyLiveView, :show
    end
  end

end
```

--------------------------------

### Define Self-Managed Supabase Client (Elixir)

Source: https://github.com/supabase-community/supabase-ex/blob/main/README.md

Shows how to define a self-managed Supabase client by creating a module that uses `Supabase.Client` and specifying the `otp_app`. This approach is recommended for long-running applications where the client process needs to be managed separately. The client state is held by an Elixir Agent.

```elixir
defmodule MyApp.Supabase.Client do
  use Supabase.Client, otp_app: :my_app
end
```

--------------------------------

### Configure Supabase Client in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_08_11_2023/presentation.md

Sets up the basic configuration for the Supabase client by reading the Supabase URL and API key from environment variables. This configuration is essential for initializing the client and establishing a connection to Supabase services.

```elixir
import Config

config :supabase,
  base_url: {:system, "SUPABASE_URL"},
  api_key: {:system, "SUPABASE_KEY"}
```

--------------------------------

### Configure Supabase GoTrue for Phoenix/LiveView in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_15_05_2024/presentation.md

Adds specific configuration for Supabase GoTrue integration with Phoenix and LiveView. This includes setting endpoint, redirect paths, and the authentication client.

```elixir
config :supabase_gotrue,
  endpoint: MyAppWeb.Endpoint,
  signed_in_path: "/secret",
  not_authenticated_path: "/login",
  authentication_client: MyClient
```

--------------------------------

### Elixir Project Dependencies for Supabase SDK

Source: https://github.com/supabase-community/supabase-ex/blob/main/README.md

This code snippet shows how to add the Supabase Elixir SDK and its various integrations (Auth, Storage, PostgREST, Functions, Realtime) as dependencies in a Mix project's `deps` function. Ensure you use the specified version constraints for compatibility.

```elixir
def deps do
  [
    {:supabase_potion, "~> 0.6"}, # base SDK
    {:supabase_storage, "~> 0.4"}, # storage integration
    {:supabase_auth, "~> 0.6"}, # auth integration
    {:supabase_postgrest, "~> 1.0"}, # postgrest integration
    {:supabase_functions, "~> 0.1"}, # edge functions integration
    {:supabase_realtime, "~> 0.1"}, # realtime integration
  ]
end
```

--------------------------------

### Define Specialized Supabase Clients in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_15_05_2024/presentation.md

Defines specialized clients for interacting with specific Supabase services like Auth and PostgREST. This uses the `supabase_potion` configuration to manage multiple clients within an application.

```elixir
defmodule MyApp.Supabase do
  defmodule Auth do
    use Supabase.GoTrue, client: MyClient
  end

  defmodule PostgREST do
    use Supabase.GoTrue, client: MyClient
  end

  def start_link(_opts) do
    children = [__MODULE__.Auth, __MODULE__.PostgREST]
    opts = [strategy: :one_for_one, name: __MODULE__]
    Supervisor.start_link(children, opts)
  end

  def child_spec(opts) do
    %{ 
      id: __MODULE__,
      start: {__MODULE__, :start_link, [opts]},
      type: :worker,
      restart: :permanent,
      shutdown: 500
    }
  end
end
```

--------------------------------

### Supabase Client Struct Definition in Elixir

Source: https://github.com/supabase-community/supabase-ex/blob/main/presentations/supaquad_presentation_08_11_2023/presentation.md

Defines the structure of a `Supabase.Client` in Elixir, detailing its various components including connection parameters, database settings, global headers, and authentication configurations. This provides a clear overview of the client's internal state and customizable options.

```elixir
%Supabase.Client{
  name: MyClient,
  conn: %{
    base_url: "https://<app-name>.supabase.io",
    api_key: "<supabase-api-key>",
    access_token: "<supabase-access-token>"
  },
  db: %Supabase.Client.Db{
    schema: "public"
  },
  global: %Supabase.Client.Global{
    headers: %{}
  },
  auth: %Supabase.Client.Auth{
    auto_refresh_token: true,
    debug: false,
    detect_session_in_url: true,
    flow_type: :implicit,
    persist_session: true,
    storage: nil,
    storage_key: "sb-<host>-auth-token"
  }
}
```
Tokens:
Raw