Documentation

Tout ce qu'il faut pour brancher ton app sur ton backend Clicbase. L'API suit les conventions Supabase/PostgREST : si tu connais l'une, tu connais l'autre.

Démarrage rapide

1. Crée un projet dans le dashboard : tu obtiens une base PostgreSQL isolée, une URL d'API et tes clés (anon côté navigateur, service côté serveur uniquement).

2. Crée une table (éditeur SQL du dashboard) :

create table articles (
  id uuid primary key default gen_random_uuid(),
  title text not null,
  created_at timestamptz default now()
);
-- l'API la sert immédiatement, sans redéploiement

3. Lis-la depuis ton app (remplace <slug> par l'identifiant de ton projet) :

const res = await fetch(
  "https://clicbase.com/db/<slug>/articles?select=*&order=created_at.desc",
  { headers: { apikey: "<clé anon>" } }
);
const articles = await res.json();

API REST (tables)

Chaque table de ton schéma public est exposée sur /db/<slug>/<table> avec la syntaxe PostgREST. La sécurité se règle en base (RLS), pas dans ton code.

# Lire (filtres, tri, pagination)
GET /db/<slug>/articles?select=id,title&status=eq.published&order=created_at.desc&limit=10

# Créer
POST /db/<slug>/articles
Content-Type: application/json
{ "title": "Bonjour" }

# Modifier
PATCH /db/<slug>/articles?id=eq.<uuid>
{ "title": "Nouveau titre" }

# Supprimer
DELETE /db/<slug>/articles?id=eq.<uuid>

# En-têtes (toutes les requêtes)
apikey: <clé anon>
Authorization: Bearer <token utilisateur>   # après connexion (sinon rôle anon)

Authentification

Comptes email + mot de passe intégrés, confirmation d'email en option, OAuth Google si configuré. Le token retourné s'utilise en Authorization: Bearer sur l'API REST : la RLS voit alors l'utilisateur connecté.

# Inscription
POST /db/<slug>/auth/signup        { "email": "...", "password": "..." }

# Connexion
POST /db/<slug>/auth/login         { "email": "...", "password": "..." }
# → { "token": "...", "user": { ... } }

# Compatible clients Supabase (GoTrue)
POST /db/<slug>/auth/token?grant_type=password

# Mot de passe oublié / réinitialisation
POST /db/<slug>/auth/recover       { "email": "..." }
POST /db/<slug>/auth/reset         { "token": "...", "password": "..." }

# Utilisateur courant
GET  /db/<slug>/auth/user          (Authorization: Bearer <token>)

# OAuth Google (si activé sur le projet)
GET  /db/<slug>/auth/authorize/google?redirect_to=<url>

Storage (fichiers)

# Envoyer un fichier
POST /db/<slug>/storage/v1/object/<bucket>/<chemin/fichier.jpg>
(corps = fichier binaire, Authorization: Bearer <token>)

# Télécharger / servir
GET  /db/<slug>/storage/v1/object/<bucket>/<chemin>

# Image redimensionnée à la volée
GET  /db/<slug>/storage/v1/render/image/<bucket>/<chemin>?width=400

# Gérer les buckets
GET/POST /db/<slug>/storage/v1/bucket

Les buckets peuvent être publics, privés, ou « owner-scoped » (chaque utilisateur n'écrit que dans son dossier).

Realtime

Abonne-toi aux changements d'une table en websocket :

const ws = new WebSocket(
  "wss://clicbase.com/db/<slug>/realtime?apikey=<clé anon>"
);
ws.onopen = () =>
  ws.send(JSON.stringify({ type: "subscribe", table: "articles" }));
ws.onmessage = (e) => {
  const { event, record } = JSON.parse(e.data); // INSERT | UPDATE | DELETE
  console.log(event, record);
};

Functions

Du code serveur déployé depuis le dashboard, appelé en HTTP :

POST /db/<slug>/functions/v1/<nom-de-la-fonction>
apikey: <clé anon>
{ "n'importe": "quel JSON" }

Emails

Envoi d'emails transactionnels depuis ton projet (adresse à ton domaine), avec modèles gérés dans le dashboard :

# Envoi direct (clé service, côté serveur uniquement)
POST /db/<slug>/email/send
{ "to": "[email protected]", "subject": "...", "html": "..." }

# Envoi d'un modèle (variables substituées)
POST /db/<slug>/email/send-template
{ "template": "welcome", "to": "...", "vars": { "name": "Hina" } }

SDK JavaScript

Un client minimal et typé, sans dépendance :

npm install clicbase-js

import { createClient } from "clicbase-js";

const db = createClient("https://clicbase.com/db/<slug>", "<clé anon>");

// Auth
await db.auth.signUp({ email, password });
const { token, user } = await db.auth.signIn({ email, password });

// Tables (la RLS s'applique automatiquement au token)
const articles = await db.from("articles")
  .select("id,title").eq("status", "published")
  .order("created_at", { ascending: false }).limit(10).get();

await db.from("articles").insert({ title: "Bonjour" });

// Storage
await db.storage.upload("photos", "avatars/moi.jpg", file);
const url = db.storage.publicUrl("photos", "avatars/moi.jpg");

Tu utilises déjà @supabase/supabase-js ? Il fonctionne en pointant son URL sur https://clicbase.com/db/<slug> : l'API REST et le login (grant_type=password) suivent les mêmes conventions. C'est aussi la voie de la migration depuis Supabase, dans les deux sens.