---
title: "Da Lovable Cloud a Supabase: cosa si rompe nel passaggio"
description: "Ho ripristinato un export in stile Lovable in Supabase: 539 errori, dati caricati lo stesso, grant più ampi e sessioni perse."
url: "https://madsalt.tech/it/blog/lovable-cloud-to-supabase-what-breaks/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/it/about/"
language: "it"
published: 2026-11-08
---

# Da Lovable Cloud a Supabase: cosa si rompe nel passaggio

In breve

Lovable non può spostare un progetto Cloud sul suo Supabase in un solo passaggio: lei ripristina l'export del database, poi sposta a mano file, segreti e impostazioni di accesso. Ho ripetuto l'export e il ripristino su uno stack Supabase locale con un'app inventata. Un semplice `pg_restore` ha segnalato 539 errori e ha caricato comunque ogni riga, quindi sembrava a posto, ma ha dato al ruolo pubblico `anon` il permesso TRUNCATE su ogni tabella, ha perso le sessioni degli utenti e il job pianificato e ha lasciato le impostazioni di accesso ai valori predefiniti. Ripristini la struttura dalle sue migrazioni, poi solo i dati, ed esegua i controlli qui sotto prima di passare l'app al nuovo progetto.

Sono Denys, ingegnere full-stack e di IA. La maggior parte delle guide per lasciare Lovable Cloud si ferma quando il comando di ripristino finisce. Questa parte da lì: com'è il nuovo progetto dopo, e cosa deve controllare prima che arrivino utenti veri.

Non l'ho eseguito sui server di Lovable. Ho costruito un piccolo SaaS fittizio su uno stack Supabase locale (CLI 2.109.1, Postgres 17.6): tre tabelle con RLS e policy, una vista, una funzione `SECURITY DEFINER`, grant espliciti, un bucket privato con due file, due utenti, un job pianificato, una tabella Realtime, impostazioni di accesso più severe e un segreto di funzione. Poi l'ho esportato nel formato che Lovable documenta per il suo export e l'ho ripristinato in un progetto nuovo, due volte.

## Si può spostare un progetto Lovable Cloud su Supabase con un clic?

No, non al 6 novembre 2026. La [documentazione di Lovable](https://docs.lovable.dev/features/database-backups) dice che "non trasferisce un progetto a un altro backend in un solo passaggio": si esporta il database, si scaricano i file dello storage, si sposta il codice con la sincronizzazione Git e si riconfigurano autenticazione, segreti, variabili d'ambiente e servizi esterni. Anche [la pagina di troubleshooting di Supabase](https://supabase.com/docs/guides/troubleshooting/cant-access-supabase-project-lovable-cloud) è d'accordo: non esiste un modo automatico per trasferire un progetto Lovable Cloud al suo account Supabase. Il flusso "claim your project" di cui ha forse letto appartiene all'offerta della piattaforma Supabase per chi costruisce app; la documentazione di Lovable non lo offre per i progetti Cloud.

## Cosa c'è nell'export e cosa no?

Sempre dalla stessa documentazione: l'export contiene l'intero database, struttura e dati, compresi gli account utente e gli hash delle loro password, quindi gli utenti mantengono le password. Non contiene i file nello storage, il codice delle edge function, i segreti, le impostazioni dei provider di accesso né le chiavi API del progetto. È un archivio PostgreSQL compresso per `pg_restore`, limitato a database fino a 15 GB, un file da 5 GB e un export ogni 24 ore.

Il mio export dell'app di prova, fatto con `pg_dump -Fc --compress=zstd`, era di 333 KB e conteneva molto più delle mie tre tabelle: ci sono finiti anche gli schemi di Supabase `auth`, `storage`, `realtime`, `vault`, `extensions` e altri. È questo che rende rumoroso il ripristino semplice.

## Cosa è successo ripristinandolo nel modo semplice?

![Un export, due modi di ripristinarlo. App inventata su stack Supabase locale, CLI 2.109.1, Postgres 17.6. pg_restore semplice: 539 errori → righe caricate → più grant, sessioni perse; Prima migrazioni, poi dati: schema ok → dati, 3 giri → come l'origine; File dello storage: solo righe → file assenti → carica a mano; Impostazioni accesso, segreti: fuori export → tornano default → reimpostarli.](https://madsalt.tech/charts/it/lovable-cloud-to-supabase-what-breaks.svg)

*Figura 1. La mia prova, 6 novembre 2026. Il ripristino semplice sembrava a posto e non lo era.*

In un progetto nuovo, come utente `postgres`, senza opzioni: `pg_restore -d <database> export.dump`. È finito con "errors ignored on restore: 539". La maggior parte riguardava gli schemi interni di Supabase: 91 × "grant options cannot be granted back to your own grantor", 37 × "permission denied for schema auth", 28 × "permission denied for schema storage" e molti "already exists". Facile da ignorare, perché i dati c'erano:

| Cosa                                                        | App di origine                         | Dopo il ripristino semplice                                     |
| ----------------------------------------------------------- | -------------------------------------- | --------------------------------------------------------------- |
| Righe in companies / profiles / orders                      | 2 / 2 / 5                              | 2 / 2 / 5                                                       |
| Utenti, con hash delle password                             | 2                                      | 2, e la vecchia password accede ancora                          |
| Tabelle con RLS attiva, policy                              | 3 attive, 6 policy                     | 3 attive, 6 policy                                              |
| `security_invoker` della vista, impostazioni delle funzioni | impostati                              | invariati                                                       |
| Grant per `anon`                                            | nessuno                                | TRUNCATE, REFERENCES, TRIGGER su tutte le tabelle e sulla vista |
| Grant extra per `authenticated`                             | nessuno oltre a select, insert, update | TRUNCATE, REFERENCES, TRIGGER                                   |
| Sessioni, identità, refresh token                           | 2 / 2 / 2                              | 0 / 0 / 0                                                       |
| Job pianificato                                             | 1                                      | 0                                                               |
| File nel bucket                                             | 2, entrambi si scaricano               | 2 righe, il download fallisce con HTTP 500                      |

Tre di quelle righe contano più del numero di errori:

- **I grant si sono allargati.** L'app di origine aveva revocato tutto ad `anon` e aveva concesso ad `authenticated` solo ciò che le policy richiedono. Il progetto ripristinato ha dato a entrambi i ruoli TRUNCATE, REFERENCES e TRIGGER su ogni tabella. Per quanto posso dire, vengono dai privilegi predefiniti del nuovo progetto, e le istruzioni di grant dell'export erano tra i 539 errori, quindi nulla li ha tolti. La RLS non copre TRUNCATE. Non ho provato se qualcuno potesse usarlo tramite la Data API, ma nessun ruolo client ne ha bisogno, ed è esattamente ciò che il [controllo 6 della mia checklist di sicurezza per Lovable](https://madsalt.tech/it/blog/lovable-app-security-checklist/) rimuove.
- **Tutti sono disconnessi.** Le righe di sessioni, identità e refresh token sono fallite sulle chiavi esterne, quindi un access token emesso dal vecchio progetto ha ricevuto HTTP 403 `session_not_found`. Gli utenti possono accedere di nuovo con la vecchia password, e nella mia prova ha funzionato; anche la documentazione di Lovable avverte della disconnessione. L'accesso con Google o GitHub è la domanda aperta: la tabella `identities` è ciò che collega un login del genere all'utente esistente, ed è tornata vuota.
- **I file sono righe senza file.** `storage.objects` descrive ogni file e le righe sono arrivate, ma i file stessi non sono nell'export. Sul mio stack locale il download è fallito con HTTP 500. Ho provato solo il backend di storage locale, quindi provi lei un download sul nuovo progetto ospitato, e si aspetti che fallisca finché non carica i file.

## Quale ripristino ha funzionato?

Il percorso a cui punta la guida di Lovable: prima la struttura, poi i dati. Sul secondo progetto nuovo:

1. **Struttura dalle sue migrazioni.** Ho applicato l'SQL del mio schema, l'equivalente della cartella `supabase/migrations` che Lovable sincronizza su GitHub. È passato pulito, con i miei grant, policy, vista e funzione esattamente come nell'origine.
2. **Solo i dati dall'export.** `pg_restore --data-only -d <database> export.dump` è finito con 17 errori. La maggior parte erano di nuovo tabelle interne di Supabase, che il nuovo progetto aveva già. Cinque no: `identities`, `sessions`, `refresh_tokens`, `mfa_amr_claims` e `one_time_tokens` sono fallite sulle chiavi esterne, per esempio `Key (user_id)=(…) is not present in table "users"`, perché il ripristino solo dati le ha caricate prima delle righe genitore.
3. **Di nuovo le tabelle fallite, prima i genitori.** Ripristinando `auth.identities` e `auth.sessions` da sole si sono caricate; una terza esecuzione con `auth.refresh_tokens` e `auth.mfa_amr_claims` è finita con codice di uscita 0.
4. **Il job pianificato a mano.** Il ripristino dei dati di `cron` è stato negato ("permission denied for table job"), quindi ho ricreato il job con `cron.schedule`. Il suo storico di esecuzioni non viene trasferito.

Li ho eseguiti dentro il container del database locale; su un progetto ospitato, `$NEW_DB_URL` è la stringa di connessione dalla finestra Connect del nuovo progetto.

```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
```

Dopo, ogni controllo qui sotto coincideva con l'origine: nessuna tabella con RLS disattivata, 4 policy pubbliche e 2 di storage, gli stessi grant tabella per tabella, la vista ancora `security_invoker`, la funzione ancora `SECURITY DEFINER` con un `search_path` vuoto, la sequenza degli id degli ordini al valore giusto, e 2 sessioni, 2 identità e 2 refresh token.

Una cosa che la mia prova non poteva mostrare: un nuovo progetto Supabase creato dopo il 30 maggio 2026 non concede più automaticamente le nuove tabelle alla Data API. Se le sue migrazioni creano tabelle senza un `GRANT`, l'app riceve l'errore 42501 sul nuovo progetto anche se su Lovable Cloud funzionava. [La modifica dei grant del 30 ottobre](https://madsalt.tech/it/blog/supabase-october-30-grant-change/) spiega l'errore e la correzione.

## Cosa è tornato ai valori predefiniti?

Nulla nell'export porta le impostazioni del progetto. Su entrambi i percorsi:

| Impostazione              | App di origine       | Nuovo progetto                                   |
| ------------------------- | -------------------- | ------------------------------------------------ |
| Site URL                  | l'indirizzo dell'app | il predefinito                                   |
| Allowed redirect URLs     | il callback dell'app | il predefinito                                   |
| Conferma email            | attiva               | disattiva                                        |
| Lunghezza minima password | 10                   | 6, una password di 7 caratteri è stata accettata |
| Segreto di funzione       | impostato            | mancante                                         |

La conferma email disattivata e una password minima più corta sono declassamenti silenziosi: nulla si rompe, la registrazione diventa solo più debole. Li reimposti in Authentication prima del passaggio, insieme a ogni provider di accesso e al suo URL di reindirizzamento nella console del provider.

## Cosa controllare prima del passaggio?

Esegua questi controlli sul nuovo progetto, e le stesse query sul vecchio nell'editor SQL di Lovable (More → Database → Manage), e confronti.

1. **Conteggi delle righe** delle sue tabelle principali, e `select count(*) from auth.users;`.
2. **RLS e policy.** Tabelle con RLS disattivata: `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;` e `select count(*) from pg_policies;` su entrambi i lati.
3. **Grant**, tabella per tabella:

```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. **Dati di autenticazione.** `select count(*) from auth.identities;` deve coincidere con il vecchio progetto se qualcuno accede con Google, GitHub o simili.
5. **Job pianificati.** `select jobname, schedule from cron.job;`
6. **File.** Scarichi un file per bucket tramite l'app, con l'accesso del suo proprietario.
7. **Accesso.** Acceda come utente di prova con la vecchia password, poi registri un nuovo utente e controlli che l'email di conferma e la regola sulla password si comportino come prima.
8. **Segreti e funzioni.** Ogni segreto che le sue edge function leggono è impostato, e ogni funzione è distribuita.

Quando il progetto è nel suo account Supabase, il [Controllo sicurezza Supabase](https://madsalt.tech/it/tools/supabase-security-check/) gratuito può collegarsi e svolgere i controlli di configurazione in un solo passaggio. Il test con due utenti e i file restano da fare a mano.

## Cosa richiede ancora il passaggio a mano?

- **File dello storage.** Scarichi ogni bucket da More → Storage in Lovable e carichi i file in bucket con gli stessi nomi, così i percorsi in `storage.objects` puntano a file veri.
- **Segreti.** Non esportati, quindi copi ciascuno dai Secrets di Lovable ai segreti delle edge function del nuovo progetto.
- **Edge function.** Le distribuisca dalla cartella `supabase/functions` del suo repository.
- **Provider di accesso e URL di reindirizzamento**, in Supabase e nella console di ciascun provider.
- **La connessione dell'app.** La punti all'URL e alla chiave pubblica del nuovo progetto e tenga attivo il vecchio backend finché il nuovo non ha superato tutti i controlli qui sopra.

Se la sua app contiene dati di clienti, faccia i controlli di sicurezza sul nuovo progetto prima del passaggio, non dopo: uno spostamento è il momento in cui grant e policy derivano, come ha mostrato il ripristino semplice. L'elenco completo è nella mia [checklist di sicurezza per app Lovable](https://madsalt.tech/it/blog/lovable-app-security-checklist/).

## Il mio caso simile

Un'azienda per cui ho costruito pagava migliaia di dollari al mese per un prodotto documentale enterprise. La sua piattaforma ora costa qualche centinaio al mese, con ruoli per documenti, moduli, report e un portale clienti, e solo le funzioni che il team usa. Vedi il [caso della piattaforma documentale per cantieri](https://madsalt.tech/it/work/construction-document-platform/).

Sta lasciando Lovable Cloud? Mi scriva e prepareremo il passaggio prima che qualcosa si rompa.

Sta lasciando Lovable Cloud?

Mi dica cosa ha adesso e cosa le serve. Le risponderò con l'opzione che sceglierei io.

[Mi scriva](https://madsalt.tech/it/#contact)
