Supabase.Fable 1.1.1

Supabase.Fable

Supabase.Fable

F# bindings for Supabase JavaScript libraries via Fable.

Installation

For Fable projects

1. Install the F# package:

dotnet add package Supabase.Fable

2. Install the JavaScript dependency:

npm install @supabase/supabase-js

Usage

In F# (Fable) projects

open Supabase.Fable.Client

// Create a client
let client = createSimple "YOUR_SUPABASE_URL" "YOUR_SUPABASE_ANON_KEY"

// Use authentication
let! result = client.Auth.SignUp("user@example.com", "password")

// Query data  
let! data = client.From<MyRecord>("my_table").Select("*").Execute()

In Oxpecker.Solid components

open Oxpecker.Solid
open Supabase.Fable.Client

let supabaseUrl = "YOUR_SUPABASE_URL"
let supabaseKey = "YOUR_SUPABASE_ANON_KEY" 

[<SolidComponent>]
let MyComponent() =
    let client = createSimple supabaseUrl supabaseKey
    let data, setData = createSignal [||]
    
    onMount(fun () ->
        promise {
            let! result = client.From<MyRecord>("my_table").Select("*").Execute()
            match result with
            | Ok records -> setData(records)
            | Error err -> console.error(err)
        } |> ignore
    )
    
    div() {
        For(each = data()) {
            yield fun item _ -> 
                div() { item.Name }
        }
    }

Dependencies

This library requires:

• @supabase/supabase-js (JavaScript dependency)
• Fable.Core (F# dependency)
• Fable.Promise (F# dependency)

API

The library provides F# bindings for:

• Authentication (client.Auth)
• Database queries (client.From<'T>())
• Storage (client.Storage)
• Realtime (client.Realtime)

See the Supabase documentation for detailed API usage.

Features

• Type-safe F# bindings for the complete Supabase JavaScript API
• Promise-based async operations using F# async workflows
• Comprehensive coverage of Authentication, Database, Storage, and Realtime APIs
• Fable.Core integration for seamless JavaScript interop
• Complete examples and test suite

Installation

1. Add this library and the Fable package references to your project:

   <PackageReference Include="Fable.Core" Version="4.5.0" />
   <PackageReference Include="Fable.Promise" Version="3.2.0" />
   <PackageReference Include="Supabase.Fable" Version="[1.0.0, 2.0.0)" />
   

2. Install the required npm dependencies:

   npm install @supabase/supabase-js
   

Quick Start

open Supabase.Fable.Client

// Create a Supabase client
let supabaseUrl = "https://your-project.supabase.co"
let supabaseKey = "your-anon-key-here"
let client = createSimple supabaseUrl supabaseKey

// Example: Authentication
let signUpUser() = promise {
    let! result = client.Auth.SignUp("user@example.com", "password123")
    match result.data with
    | Some data -> printfn $"User created: {data.user.email}"
    | None -> printfn "Sign up failed"
}

// Example: Database query
let getUsers() = promise {
    let! response = client.From("users").Select("*").Execute()
    match response.data with
    | Some users -> printfn $"Found {users.Length} users"
    | None -> printfn "Query failed"
}

API Coverage

Authentication (client.Auth)

• SignUp(email, password) - Create new user account
• SignInWithPassword(email, password) - Sign in with email/password
• SignInWithOAuth(provider) - Sign in with OAuth provider
• SignOut() - Sign out current user
• GetUser(jwt) - Get current user
• GetSession() - Get current session
• RefreshSession() - Refresh current session
• ResetPasswordForEmail(email) - Send password reset email

Database (client.From(table))

Query Builder:

• Select(columns) - Select specific columns
• Insert(data) - Insert new records
• Update(data) - Update existing records
• Delete() - Delete records
• Upsert(data) - Insert or update records

Filters:

• Eq(column, value) - Equals filter
• Neq(column, value) - Not equals filter
• Gt(column, value) - Greater than filter
• Gte(column, value) - Greater than or equal filter
• Lt(column, value) - Less than filter
• Lte(column, value) - Less than or equal filter
• Like(column, pattern) - Pattern matching filter
• In(column, values) - Value in list filter

Modifiers:

• Order(column, ascending) - Sort results
• Limit(count) - Limit number of results
• Range(from, to) - Range pagination
• Single() - Get single record
• Execute() - Execute query

Storage (client.Storage)

Bucket Management:

• ListBuckets() - List all buckets
• GetBucket(id) - Get bucket details
• CreateBucket(id, options) - Create new bucket
• DeleteBucket(id) - Delete bucket
• EmptyBucket(id) - Empty bucket contents

File Operations: (client.Storage.From(bucket))

• Upload(path, file, options) - Upload file
• Download(path) - Download file
• Remove(paths) - Delete files
• List(path, options) - List files
• GetPublicUrl(path) - Get public URL
• CreateSignedUrl(path, expiresIn) - Create signed URL

Realtime (client.Realtime)

• Channel(topic) - Create realtime channel
• Subscribe(callback) - Subscribe to changes
• Unsubscribe() - Unsubscribe from changes
• GetChannels() - Get active channels

Examples

The examples/ directory contains comprehensive examples showing:

• Authentication flows - Sign up, sign in, session management
• Database operations - CRUD operations with type-safe queries
• Storage management - File upload, download, and bucket management
• Realtime subscriptions - Live updates and change notifications

Run the examples:

cd examples
dotnet build
# For browser: compile with Fable and open in browser
# For Node.js: run with Node.js after Fable compilation

Testing

The tests/ directory contains unit tests using Fable.Mocha:

cd tests
dotnet build
# Compile with Fable and run in test environment

Project Structure

src/
├── Types.fs           # Supabase type definitions
├── Bindings.fs        # JavaScript interop bindings
├── SupabaseClient.fs  # Main client interface
├── Auth.fs            # Authentication module
├── Database.fs        # Database query builder
├── Storage.fs         # Storage management
└── Realtime.fs        # Realtime subscriptions

examples/
└── Examples.fs        # Comprehensive usage examples

tests/
└── Tests.fs           # Unit test suite

Type Safety

All Supabase operations are wrapped in F# types for compile-time safety:

// Responses are wrapped in Result-like types
type SupabaseResponse<'T> = {
    data: 'T option
    error: SupabaseError option
}

// User-defined types are preserved
type User = {
    id: int option
    name: string
    email: string
    created_at: string option
}

// Type-safe database operations
let getUser (id: int) = promise {
    let! response = client.From("users").Select("*").Eq("id", id).Single()
    return response.data // User option
}

Browser vs Node.js

This library works in both browser and Node.js environments:

• Browser: Use with Fable.React, Elmish, or any Fable web framework
• Node.js: Use for server-side F# applications with Supabase

Contributing

1. Fork the repository
2. Create a feature branch
3. Add tests for new functionality
4. Ensure all projects build: dotnet build
5. Submit a pull request

Dependencies

• Fable.Core 4.5.0+ - Core Fable compilation support
• @supabase/supabase-js 2.57.4+ - Supabase JavaScript client
• Fable.Promise 3.2.0+ - Promise-based async operations (optional)
• Fable.Mocha 2.17.0+ - Testing framework (dev dependency)

License

MIT License - see LICENSE file for details

Supabase Resources

• Supabase Documentation
• Supabase JavaScript Client
• Fable Compiler
• F# Documentation