Connecteur Supabase

Connectez votre projet Supabase pour synchroniser les enregistrements de base de données, les données d’authentification utilisateur, les événements de stockage de fichiers et les changements en temps réel pour l’automatisation de l’engagement client.

Vue d’ensemble

Fonctionnalités

• API REST auto-générée, Opérations CRUD sur toute table Postgres via PostgREST, sans code
• Synchronisation des utilisateurs Auth, Synchronisez les utilisateurs Supabase Auth (e-mail, téléphone, logins sociaux) vers votre plateforme d’engagement
• Abonnements temps réel, Écoutez les événements INSERT, UPDATE, DELETE sur toute table en temps réel
• Row Level Security, Tout accès à l’API respecte les politiques RLS Postgres pour des données multi-tenants sécurisées
• Intégration de stockage, Suivez les uploads de fichiers et gérez les assets entre les buckets Storage
• Edge Functions, Invoquez des fonctions Deno serverless pour la logique personnalisée et les webhooks
• Recherche plein texte, Exploitez les capacités de recherche plein texte Postgres via l’API

Prérequis

Avant de commencer, assurez-vous de disposer de :

1. Un projet Supabase (app.supabase.com)
2. L’URL de l’API et les clés d’API de votre projet (dans Settings → API)
3. Un compte Tajo avec accès API

Authentification

Supabase utilise une authentification par clé API. Chaque requête nécessite l’en-tête apikey et éventuellement un bearer token Authorization pour un accès scoped à l’utilisateur.

# Avec la clé anon (respecte RLS)
curl 'https://<project_ref>.supabase.co/rest/v1/customers' \
  -H "apikey: <SUPABASE_ANON_KEY>" \
  -H "Authorization: Bearer <SUPABASE_ANON_KEY>"

# Avec la clé service_role (contourne RLS)
curl 'https://<project_ref>.supabase.co/rest/v1/customers' \
  -H "apikey: <SUPABASE_SERVICE_ROLE_KEY>" \
  -H "Authorization: Bearer <SUPABASE_SERVICE_ROLE_KEY>"

Configuration

Configuration de base

connectors:
  supabase:
    enabled: true
    project_url: "https://xyzcompany.supabase.co"
    api_key: "${SUPABASE_SERVICE_ROLE_KEY}"

    # Options de synchronisation des données
    sync:
      users: true
      tables:
        - customers
        - orders
        - products
      storage: true
      realtime: true

    # Mapper les utilisateurs Supabase Auth vers les contacts
    user_mapping:
      email: email
      phone: SMS
      user_metadata.full_name: FIRSTNAME
      created_at: SIGNUP_DATE

Mappage des champs

Mappez les colonnes des tables Supabase vers les attributs de la plateforme d’engagement :

Mappage de table personnalisé

table_mapping:
  customers:
    # Mappage Colonne → Attribut
    email: email
    full_name: FIRSTNAME
    company: COMPANY
    plan: SUBSCRIPTION_PLAN
    mrr: MONTHLY_REVENUE
    created_at: SIGNUP_DATE

  orders:
    # Suivre en tant qu'événements
    sync_as: events
    event_name: "order_placed"
    properties:
      total: amount
      status: order_status
      items: line_items

Endpoints API

L’API REST Supabase est auto-générée à partir du schéma de votre base de données sur https://<ref>.supabase.co/rest/v1/.

Opérateurs de filtrage

Événements

Événements Auth

Événements base de données (Realtime)

Événements webhook

Exemples de code

Initialiser le connecteur

import { TajoClient } from '@tajo/sdk';
import { createClient } from '@supabase/supabase-js';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
});

// Connecter le projet Supabase
await tajo.connectors.connect('supabase', {
  projectUrl: process.env.SUPABASE_URL,
  serviceRoleKey: process.env.SUPABASE_SERVICE_ROLE_KEY,
});

Synchroniser les utilisateurs vers des contacts

// Synchroniser tous les utilisateurs Supabase Auth en tant que contacts
await tajo.connectors.sync('supabase', {
  type: 'full',
  resources: ['users'],
});

// Synchronisation incrémentale (uniquement utilisateurs nouveaux/modifiés)
await tajo.connectors.sync('supabase', {
  type: 'incremental',
  resources: ['users'],
  since: '2024-01-01T00:00:00Z',
});

Écouter les changements en temps réel

// S'abonner aux nouvelles commandes pour déclencher l'engagement
const supabase = createClient(
  process.env.SUPABASE_URL,
  process.env.SUPABASE_SERVICE_ROLE_KEY
);

supabase
  .channel('orders')
  .on('postgres_changes',
    { event: 'INSERT', schema: 'public', table: 'orders' },
    async (payload) => {
      // Transférer à Tajo en tant qu'événement
      await tajo.events.track({
        email: payload.new.customer_email,
        event: 'order_placed',
        properties: {
          order_id: payload.new.id,
          total: payload.new.total,
          items: payload.new.line_items,
        },
      });
    }
  )
  .subscribe();

Requête et segmentation

// Interroger les clients par plan pour des campagnes ciblées
const { data: proUsers } = await supabase
  .from('customers')
  .select('email, full_name, plan, mrr')
  .eq('plan', 'pro')
  .gt('mrr', 100)
  .order('mrr', { ascending: false });

// Synchroniser vers une liste Brevo pour cibler des campagnes
await tajo.lists.addContacts(PRO_LIST_ID, proUsers);

Limites de débit

Dépannage

Problèmes courants

Mode debug

connectors:
  supabase:
    debug: true
    log_level: verbose
    log_queries: true
    log_realtime: true

Tester la connexion

tajo connectors test supabase
# ✓ API connection successful
# ✓ Auth endpoint accessible
# ✓ Tables readable (12 tables found)
# ✓ Storage accessible (3 buckets)
# ✓ Realtime connection established
# ✓ Edge Functions available (4 functions)

Bonnes pratiques

1. Utilisez la clé service_role uniquement côté serveur, Ne l’exposez jamais dans du code client
2. Activez RLS sur toutes les tables, Même avec service_role, concevez avec RLS pour une défense en profondeur
3. Utilisez Realtime pour la synchronisation événementielle, Plus efficace que le polling pour les changements
4. Opérations par lots, Utilisez les inserts en masse et le filtre in pour les opérations à fort volume
5. Mappez les métadonnées utilisateur, Stockez les champs pertinents pour l’engagement dans user_metadata à l’inscription
6. Utilisez les Edge Functions pour les webhooks, Traitez les webhooks entrants avec les Supabase Edge Functions pour une gestion à faible latence

Sécurité

• Authentification par clé API, Toutes les requêtes nécessitent des clés API valides
• Row Level Security (RLS), Contrôle d’accès natif Postgres par ligne
• Vérification JWT, Les tokens d’auth sont des JWT signés vérifiés à chaque requête
• SSL/TLS, Toutes les connexions chiffrées en transit
• SOC 2 Type II, Supabase est conforme SOC 2
• Restrictions réseau, Allowlist d’IP en option sur les plans payants

Ressources associées

• Connecteur Shopify
• Connecteur Stripe
• Connecteur Auth0
• Docs officielle Supabase
• Guide de l’API REST Supabase
• Guide Supabase Auth