---
title: "Lovable Cloud vers Supabase : ce qui casse ensuite"
description: "J'ai restauré un export Lovable dans un nouveau projet Supabase. Restauration simple : 539 erreurs, données chargées, droits élargis, sessions perdues."
url: "https://madsalt.tech/fr/blog/lovable-cloud-to-supabase-what-breaks/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/fr/about/"
language: "fr"
published: 2026-11-08
---

# Lovable Cloud vers Supabase : ce qui casse ensuite

En bref

Lovable ne peut pas déplacer un projet Cloud vers votre propre Supabase en une seule étape : vous restaurez l'export de sa base de données, puis vous déplacez à la main les fichiers, les secrets et les réglages de connexion. J'ai répété l'export et la restauration sur une stack Supabase locale avec une application fictive. Un simple `pg_restore` a signalé 539 erreurs et a pourtant chargé chaque ligne : tout avait l'air correct, mais il a donné au rôle public `anon` le droit TRUNCATE sur chaque table, perdu les sessions des utilisateurs et la tâche planifiée, et laissé les réglages de connexion à leurs valeurs par défaut. Restaurez la structure depuis vos migrations, puis seulement les données, et lancez les contrôles ci-dessous avant de basculer l'application.

Je suis Denys, ingénieur full-stack et IA. La plupart des guides pour quitter Lovable Cloud s'arrêtent quand la commande de restauration se termine. Celui-ci commence là : à quoi ressemble le nouveau projet ensuite, et ce qu'il faut vérifier avant que de vrais utilisateurs y arrivent.

Je ne l'ai pas exécuté sur les serveurs de Lovable. J'ai construit un petit SaaS fictif sur une stack Supabase locale (CLI 2.109.1, Postgres 17.6) : trois tables avec RLS et politiques, une vue, une fonction `SECURITY DEFINER`, des droits explicites, un bucket privé avec deux fichiers, deux utilisateurs, une tâche planifiée, une table Realtime, des réglages de connexion plus stricts et un secret de fonction. Puis je l'ai exporté dans le format que Lovable documente pour son export et restauré dans un projet neuf, deux fois.

## Peut-on déplacer un projet Lovable Cloud vers Supabase en un clic ?

Non, pas au 6 novembre 2026. [La documentation de Lovable](https://docs.lovable.dev/features/database-backups) dit qu'il « ne transfère pas un projet vers un autre backend en une seule étape » : vous exportez la base, téléchargez les fichiers du stockage, déplacez le code avec la synchronisation Git, et reconfigurez l'authentification, les secrets, les variables d'environnement et les services externes. [La page de dépannage de Supabase](https://supabase.com/docs/guides/troubleshooting/cant-access-supabase-project-lovable-cloud) est d'accord : il n'existe aucun moyen automatisé de transférer un projet Lovable Cloud vers votre compte Supabase. Le parcours « claim your project » dont vous avez peut-être entendu parler relève de l'offre de plateforme de Supabase pour les créateurs d'applications ; la documentation de Lovable ne le propose pas pour les projets Cloud.

## Que contient l'export, et que ne contient-il pas ?

D'après la même documentation, l'export contient toute la base, structure et données, y compris les comptes utilisateurs et leurs hachages de mot de passe : les utilisateurs gardent donc leurs mots de passe. Il ne contient ni les fichiers du stockage, ni le code des edge functions, ni les secrets, ni les réglages des fournisseurs de connexion, ni les clés d'API du projet. C'est une archive PostgreSQL compressée pour `pg_restore`, limitée aux bases jusqu'à 15 Go, à un fichier de 5 Go et à un export toutes les 24 heures.

Mon export de l'application de test, fait avec `pg_dump -Fc --compress=zstd`, pesait 333 Ko et contenait bien plus que mes trois tables : les schémas propres à Supabase `auth`, `storage`, `realtime`, `vault`, `extensions` et d'autres l'accompagnaient. C'est ce qui rend la restauration simple si bruyante.

## Que s'est-il passé avec la restauration simple ?

![Un export, deux façons de le restaurer. Application fictive sur une stack Supabase locale, CLI 2.109.1, Postgres 17.6. pg_restore simple: 539 échecs → tout chargé → droits élargis, 0 session; Migrations d'abord, puis données: schéma OK → données ×3 → égal à la source; Fichiers du stockage: lignes OK → sans fichiers → envoi manuel; Réglages de connexion, secrets: non exporté → retour au défaut → à reconfigurer.](https://madsalt.tech/charts/fr/lovable-cloud-to-supabase-what-breaks.svg)

*Figure 1. Mon essai, 6 novembre 2026. La restauration simple avait l'air correcte et ne l'était pas.*

Dans un projet neuf, avec l'utilisateur `postgres`, sans option : `pg_restore -d <database> export.dump`. Elle s'est terminée par « errors ignored on restore: 539 ». La plupart concernaient les schémas internes de Supabase : 91 × « grant options cannot be granted back to your own grantor », 37 × « permission denied for schema auth », 28 × « permission denied for schema storage », et beaucoup de « already exists ». Facile à balayer d'un revers de main, puisque les données étaient là :

| Quoi                                           | Application source                      | Après la restauration simple                                  |
| ---------------------------------------------- | --------------------------------------- | ------------------------------------------------------------- |
| Lignes dans companies / profiles / orders      | 2 / 2 / 5                               | 2 / 2 / 5                                                     |
| Utilisateurs, avec hachages de mot de passe    | 2                                       | 2, et l'ancien mot de passe fonctionne toujours               |
| Tables avec RLS activée, politiques            | 3 activées, 6 politiques                | 3 activées, 6 politiques                                      |
| Vue `security_invoker`, réglages des fonctions | définis                                 | inchangés                                                     |
| Droits pour `anon`                             | aucun                                   | TRUNCATE, REFERENCES, TRIGGER sur toutes les tables et la vue |
| Droits supplémentaires pour `authenticated`    | aucun au-delà de select, insert, update | TRUNCATE, REFERENCES, TRIGGER                                 |
| Sessions, identités, refresh tokens            | 2 / 2 / 2                               | 0 / 0 / 0                                                     |
| Tâche planifiée                                | 1                                       | 0                                                             |
| Fichiers dans le bucket                        | 2, les deux se téléchargent             | 2 lignes, le téléchargement échoue avec HTTP 500              |

Trois de ces lignes comptent plus que le nombre d'erreurs :

- **Les droits se sont élargis.** L'application source avait retiré tous les droits à `anon` et accordé à `authenticated` seulement ce dont les politiques ont besoin. Le projet restauré a donné aux deux rôles TRUNCATE, REFERENCES et TRIGGER sur chaque table. D'après ce que je vois, ils viennent des privilèges par défaut du nouveau projet, et les propres instructions de droits de l'export figuraient parmi les 539 erreurs : rien ne les a donc repris. La RLS ne couvre pas TRUNCATE. Je n'ai pas testé si quelqu'un pourrait s'en servir via la Data API, mais aucun rôle client n'en a besoin, et c'est exactement ce que retire le [contrôle 6 de ma checklist de sécurité Lovable](https://madsalt.tech/fr/blog/lovable-app-security-checklist/).
- **Tout le monde est déconnecté.** Les lignes de sessions, d'identités et de refresh tokens ont échoué sur des clés étrangères : un access token émis par l'ancien projet a donc reçu HTTP 403 `session_not_found`. Les utilisateurs peuvent se reconnecter avec leur ancien mot de passe, ce qui a fonctionné dans mon essai ; la documentation de Lovable avertit aussi de la déconnexion. La connexion Google ou GitHub reste la question ouverte : la table `identities` relie une telle connexion à l'utilisateur existant, et elle est revenue vide.
- **Les fichiers sont des lignes sans fichiers.** `storage.objects` décrit chaque fichier, et les lignes sont passées, mais les fichiers eux-mêmes ne sont pas dans l'export. Sur ma stack locale, le téléchargement a échoué avec HTTP 500. Je n'ai testé que le backend de stockage local : essayez vous-même un téléchargement sur le nouveau projet hébergé, et attendez-vous à ce qu'il échoue tant que vous n'avez pas envoyé les fichiers.

## Quelle restauration a fonctionné ?

Le chemin vers lequel pointe le guide de Lovable : la structure d'abord, puis les données. Sur le deuxième projet neuf :

1. **La structure depuis vos migrations.** J'ai appliqué mon SQL de schéma, l'équivalent du dossier `supabase/migrations` que Lovable synchronise vers GitHub. Il s'est exécuté sans erreur, avec mes droits, politiques, vue et fonction exactement comme dans la source.
2. **Les données seules depuis l'export.** `pg_restore --data-only -d <database> export.dump` s'est terminé avec 17 erreurs. La plupart concernaient encore les tables internes de Supabase, que le nouveau projet avait déjà. Cinq non : `identities`, `sessions`, `refresh_tokens`, `mfa_amr_claims` et `one_time_tokens` ont échoué sur des clés étrangères, par exemple `Key (user_id)=(…) is not present in table "users"`, parce que la restauration des données seules les chargeait avant leurs lignes parentes.
3. **Les tables en échec de nouveau, parents d'abord.** Restaurer `auth.identities` et `auth.sessions` seules les a chargées ; une troisième exécution avec `auth.refresh_tokens` et `auth.mfa_amr_claims` s'est terminée avec le code de sortie 0.
4. **La tâche planifiée à la main.** La restauration des données `cron` a été refusée (« permission denied for table job »), j'ai donc recréé la tâche avec `cron.schedule`. Son historique d'exécution ne suit pas.

J'ai exécuté ceci dans le conteneur de base de données local ; sur un projet hébergé, `$NEW_DB_URL` est la chaîne de connexion du dialogue Connect du nouveau projet.

```bash
pg_restore --data-only -d "$NEW_DB_URL" export.dump
pg_restore --data-only -d "$NEW_DB_URL" -n auth -t identities -t sessions export.dump
pg_restore --data-only -d "$NEW_DB_URL" -n auth -t refresh_tokens -t mfa_amr_claims export.dump
```

Après cela, chaque contrôle ci-dessous correspondait à la source : aucune table avec la RLS désactivée, 4 politiques publiques et 2 de stockage, les mêmes droits table par table, la vue toujours `security_invoker`, la fonction toujours `SECURITY DEFINER` avec un `search_path` vide, la séquence de l'identifiant des commandes à la bonne valeur, et 2 sessions, 2 identités et 2 refresh tokens.

Une chose que mon essai ne pouvait pas montrer : un nouveau projet Supabase créé après le 30 mai 2026 n'accorde plus automatiquement les nouvelles tables à la Data API. Si vos migrations créent des tables sans `GRANT`, l'application reçoit l'erreur 42501 sur le nouveau projet alors qu'elle fonctionnait sur Lovable Cloud. [Le changement de droits du 30 octobre](https://madsalt.tech/fr/blog/supabase-october-30-grant-change/) explique l'erreur et la correction.

## Qu'est-ce qui est revenu à ses valeurs par défaut ?

Rien dans l'export ne porte les réglages du projet. Sur les deux chemins :

| Réglage                           | Application source           | Nouveau projet                                   |
| --------------------------------- | ---------------------------- | ------------------------------------------------ |
| Site URL                          | l'adresse de l'application   | la valeur par défaut                             |
| URL de redirection autorisées     | le callback de l'application | la valeur par défaut                             |
| Confirmation par e-mail           | activée                      | désactivée                                       |
| Longueur minimale du mot de passe | 10                           | 6, un mot de passe de 7 caractères a été accepté |
| Secret de fonction                | défini                       | absent                                           |

La confirmation par e-mail désactivée et un mot de passe minimal plus court sont des régressions silencieuses : rien ne casse, l'inscription devient simplement plus faible. Réglez-les de nouveau dans Authentication avant de basculer, ainsi que chaque fournisseur de connexion et son URL de redirection dans la console du fournisseur.

## Que vérifier avant de basculer ?

Lancez ceci sur le nouveau projet, et les mêmes requêtes sur l'ancien dans le SQL editor de Lovable (More → Database → Manage), puis comparez.

1. **Les nombres de lignes** de vos tables principales, et `select count(*) from auth.users;`.
2. **La RLS et les politiques.** Tables avec la RLS désactivée : `select relname from pg_class c join pg_namespace n on n.oid = c.relnamespace where n.nspname = 'public' and c.relkind = 'r' and not c.relrowsecurity;` et `select count(*) from pg_policies;` des deux côtés.
3. **Les droits**, table par table :

```sql
select grantee, table_name, string_agg(privilege_type, ', ' order by privilege_type)
from information_schema.role_table_grants
where table_schema = 'public' and grantee in ('anon', 'authenticated')
group by grantee, table_name
order by table_name, grantee;
```

4. **Les données d'authentification.** `select count(*) from auth.identities;` doit correspondre à l'ancien projet si quelqu'un se connecte avec Google, GitHub ou similaire.
5. **Les tâches planifiées.** `select jobname, schedule from cron.job;`
6. **Les fichiers.** Téléchargez un fichier par bucket via l'application, connecté en tant que son propriétaire.
7. **La connexion.** Connectez-vous en utilisateur de test avec l'ancien mot de passe, puis inscrivez un nouvel utilisateur et vérifiez que l'e-mail de confirmation et la règle de mot de passe se comportent comme avant.
8. **Les secrets et les fonctions.** Chaque secret que lisent vos edge functions est défini, et chaque fonction est déployée.

Une fois le projet dans votre propre compte Supabase, l'[Audit de sécurité Supabase](https://madsalt.tech/fr/tools/supabase-security-check/) gratuit peut s'y connecter et lancer les contrôles de configuration en une passe. Le test à deux utilisateurs et les fichiers restent à faire à la main.

## Que demande encore le déplacement à la main ?

- **Les fichiers du stockage.** Téléchargez chaque bucket depuis More → Storage dans Lovable et envoyez les fichiers dans des buckets de mêmes noms, pour que les chemins de `storage.objects` pointent vers de vrais fichiers.
- **Les secrets.** Ils ne sont pas exportés : copiez chacun depuis les Secrets de Lovable vers les secrets de fonction du nouveau projet.
- **Les edge functions.** Déployez-les depuis le dossier `supabase/functions` de votre dépôt.
- **Les fournisseurs de connexion et les URL de redirection**, dans Supabase et dans la console de chaque fournisseur.
- **La connexion de l'application.** Pointez-la vers l'URL et la clé publique du nouveau projet, et gardez l'ancien backend en marche jusqu'à ce que le nouveau ait passé tous les contrôles ci-dessus.

Si votre application contient des données de clients, faites les contrôles de sécurité sur le nouveau projet avant la bascule, pas après : un déplacement est le moment où droits et politiques dérivent, comme l'a montré la restauration simple. La liste complète est dans ma [checklist de sécurité pour applications Lovable](https://madsalt.tech/fr/blog/lovable-app-security-checklist/).

## Mon cas similaire

Une entreprise pour laquelle j'ai construit payait des milliers de dollars par mois pour un produit documentaire d'entreprise. Sa propre plateforme coûte maintenant quelques centaines par mois, avec des rôles pour les documents, les formulaires, les rapports et un portail client, et seulement les fonctions que l'équipe utilise. Voir le [cas de la plateforme documentaire de chantier](https://madsalt.tech/fr/work/construction-document-platform/).

Vous quittez Lovable Cloud ? Écrivez-moi et nous préparerons la migration avant que quelque chose ne casse.

Vous quittez Lovable Cloud ?

Dites-moi ce que vous avez aujourd'hui et ce qu'il vous faut. Je vous répondrai avec l'option que je choisirais.

[Me contacter](https://madsalt.tech/fr/#contact)
