Migrer depuis Supabase
L'API client, les politiques RLS et Edge Functions sont reportées. La CLI exporte vos utilisateurs Supabase avec leurs hachages de mot de passe bcrypt, restaure un simple pg_dump (instructions, corps de fonction, données COPY) et importe les utilisateurs : cette page indique exactement ce que chaque étape entraîne et où elle s'arrête.
95 % identique à Supabase#
L'API client, les politiques RLS, le modèle d'authentification et le stockage suivent les conventions de Supabase, donc le code de l'application change très peu. Le tableau ci-dessous indique ce qui est identique et ce qui ne l'est pas.
| Caractéristique | Compatibilité | Remarque |
|---|---|---|
createClient() | Idem | Importez @aurabase/aurabase-js au lieu de @supabase/supabase-js |
.from().select() | Idem | Même API PostgREST chaînable |
| Politiques RLS | Idem | Postgres Politiques SQL. to authenticated, to anon et to service_role sont acceptés comme alias de aura_authenticated, aura_anon et aura_service_role. Ces rôles sont créés avec le cluster de base de données du projet ; sur un cluster créé avant cette modification, écrivez les noms de rôle aura_*. |
auth.uid() et auth.role() | Idem | Aides compatibles revendication par revendication |
auth.getUser() | Différence mineure | data est l'utilisateur (data.email) ; Supabase renvoie { data: { user } }. Le code écrit sous la forme const { data: { user } } = await supabase.auth.getUser() obtient user === undefined ici : écrivez const { data: user } = await aura.auth.getUser() |
.rpc() | Idem | Même signature pour les fonctions Postgres |
.storage.from().upload() | Idem | API compatible S3 avec des chemins identiques |
.channel().on("postgres_changes") | Idem | Même surface de capture des données modifiées |
| Edge Functions (Deno) | Idem | Exécution standard Deno ; Deno.serve() fonctionne sans réécriture |
| Crochets d'authentification | Différence mineure | Webhooks HTTP et points de terminaison dédiés |
| Clé de rôle de service | Idem | Même rôle, même portée |
Quatre commandes, dans l'ordre#
- Exporter —
aura migrate export-supabaseécritusers.json(utilisateurs, hachages de mots de passe, identités OAuth) etdump.sql(pg_dumpdu schéma, de la structure et des donnéespublic) - Restaurer —
aura db restore dump.sqlrelit le dump dans le projet lié - Importer des utilisateurs —
aura auth import users.json; les utilisateurs conservent leur identifiant et leur mot de passe - Cutover — changez l'URL et les clés de votre application ; déployez votre Edge Functions inchangé
# 1. Exporter depuis Supabase (Paramètres > Base de données > chaîne de connexion, rôle `postgres`)
aura migrate export-supabase --db-url "$SUPABASE_DB_URL" --output-dir ./supabase-export
# 2. Restaurez le schéma et les données dans le projet Aurabase lié
aura link <project>
aura db restore ./supabase-export/dump.sql --dry-run # analyser et imprimer le plan uniquement
aura db restore ./supabase-export/dump.sql
# 3. Importez les utilisateurs, avec leurs hachages de mot de passe
aura auth import ./supabase-export/users.json
Restaurer le schéma et les données#
aura migrate export-supabase exécute pg_dump --schema=public --no-owner --no-acl --format=plain avec votre pg_dump local (installez les outils clients PostgreSQL ; sans eux, la commande imprime la ligne exacte pg_dump à exécuter vous-même).
aura db restore <file.sql> lit un dump SQL simple comme le fait psql : les instructions sont divisées en dehors des chaînes, les identifiants, les commentaires et les corps cités en dollars ($$ … $$, $fn$ … $fn$), les blocs COPY … FROM stdin sont lus jusqu'à leur ligne \. et les méta-commandes psql (\connect, \restrict) sont ignorés. Il alors :
- supprime le qualificatif
public.écrit parpg_dump, de sorte que les tables atterrissent dans le schéma du projet (--source-schemapour un autre schéma) ; - ignore ce qui n'a aucun sens sur Aurabase et dit pourquoi : paramètres de session (
SET,set_config),OWNER TO,GRANT/REVOKEdes rôles Supabase,CREATE EXTENSION(les extensions sont gérées par Aurabase),CREATE SCHEMA public; - exécute tout le reste dans l'ordre du fichier, et s'arrête à la première étape défaillante avec son numéro, sa ligne de dump et l'erreur. Corrigez la cause et reprenez avec
--from <step>, ou transmettez--continue-on-errorpour passer les étapes qui ont échoué et obtenir la liste à la fin.--dry-runimprime le plan sans rien exécuter.
Deux chemins, choisis comme aura db push:
Projet lié, non DATABASE_URL | DATABASE_URL défini (chaîne de connexion directe) | |
|---|---|---|
| Transports | Un appel API SQL par instruction, validé par le serveur | Une connexion PostgreSQL |
Données COPY | Converti en lots INSERT (500 lignes) | Protocole COPY, données telles que vidées |
Fonctions, déclencheurs, blocs DO | Refusé par l'API SQL : créez-les avec aura db function create et aura db trigger create | Créé |
| Limite de sécurité | La politique d'isolement du serveur pour le projet | Le rôle PostgreSQL du projet (sa propre base de données uniquement, pas de superutilisateur, la sécurité au niveau des lignes s'applique) |
Sur le chemin de l'API SQL, le serveur refuse également les chaînes E'…', les références à d'autres schémas et, dans une instruction, le texte qui ressemble à une commande interdite, même à l'intérieur d'une chaîne littérale : une ligne de données contenant un tel texte échoue avec son numéro d'étape. Utilisez le chemin direct pour ces dumps. La chaîne de connexion directe se trouve dans Paramètres › Connexion lorsque votre déploiement publie un accès direct PostgreSQL.
La restauration s'exécute séquentiellement: un dump SQL simple est ordonné (tables, puis données, puis contraintes et index) et n'a aucun graphe de dépendances à paralléliser. Aucun chiffre de débit n’est publié.
Les références à auth.users ne sont pas restaurées telles quelles. Aurabase Auth ne conserve pas ses utilisateurs dans une table auth.users, donc une clé étrangère telle que REFERENCES auth.users(id) échoue. Restaurez avec --continue-on-error et conservez les colonnes user_id sans cette contrainte : les identifiants utilisateur sont conservés par l'import ci-dessous, donc les valeurs correspondent toujours.
Utilisateurs et mots de passe#
aura migrate export-supabase lit auth.users et auth.identities et écrit, pour chaque utilisateur : l'identifiant original , l'e-mail, email_verified, le hachage bcrypt de encrypted_password, le nom et les métadonnées (raw_user_meta_data, et raw_app_meta_data sans les propres clés provider/providers de Supabase), et les identités OAuth liées (Google, GitHub…). Le fichier est écrit et lisible par vous seul : il contient les hachages de mots de passe, supprimez-le après l'importation.
aura auth import users.json envoie les utilisateurs par lots de 1 000 à l'API d'importation admin et imprime chaque ligne qui n'est pas créée (skipped lorsque l'email ou l'identifiant existe déjà, error avec la raison). L'exécuter à nouveau est sûr : les utilisateurs existants ne sont jamais écrasés.
Lors de la connexion, Aurabase Auth vérifie le hachage bcrypt, puis le remplace par un hachage Argon2id : vos utilisateurs conservent leur mot de passe et ne font rien. L'importation accepte les hachages bcrypt $2a$, $2b$ et $2y$ avec un coût de 4 à 12 (Supabase en utilise 10) et les hachages Argon2id avec des paramètres limités ; tout autre format est refusé ligne par ligne. Les utilisateurs OAuth se reconnectent avec le même fournisseur et atterrissent sur le même compte.
Non reporté : facteurs MFA (TOTP, téléphone), sessions actives et jetons d'actualisation (chaque utilisateur se reconnecte), bannissements, utilisateurs par téléphone uniquement, anonymes et supprimés (comptés et signalés par l'export). Les utilisateurs avec MFA doivent se réinscrire.
Natif Deno — zéro réécriture#
Aurabase exécute un runtime Deno standard. Vos fonctions utilisant Deno.serve() sont 100% compatibles sans modification :
// Fonction standard Deno — fonctionne telle quelle sur Aurabase
Deno.serve(async (req) => {
const { name } = await req.json()
return new Response(
JSON.stringify({ message: `Hello ${name}!` }),
{ headers: { 'content-type': 'application/json' } }
)
})