---
title: "Do Lovable Cloud ao Supabase: o que se parte na mudança"
description: "Restaurei uma exportação ao estilo Lovable num projeto Supabase novo: 539 erros, dados carregados na mesma, grants mais largos e sessões perdidas."
url: "https://madsalt.tech/pt/blog/lovable-cloud-to-supabase-what-breaks/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/pt/about/"
language: "pt"
published: 2026-11-08
---

# Do Lovable Cloud ao Supabase: o que se parte na mudança

Em resumo

O Lovable não consegue mover um projeto Cloud para o seu Supabase num só passo: você restaura a exportação da base de dados e depois move à mão os ficheiros, os segredos e as definições de início de sessão. Repeti a exportação e o restauro numa stack Supabase local com uma app inventada. Um `pg_restore` simples reportou 539 erros e mesmo assim carregou todas as linhas, por isso parecia bem, mas deu à função pública `anon` o TRUNCATE em todas as tabelas, perdeu as sessões dos utilizadores e a tarefa agendada, e deixou as definições de início de sessão nos valores por omissão. Restaure a estrutura a partir das suas migrações, depois só os dados, e execute as verificações abaixo antes de passar a app para o novo projeto.

Sou o Denys, engenheiro full-stack e de IA. A maioria dos guias para sair do Lovable Cloud pára quando o comando de restauro termina. Este começa aí: como fica o novo projeto depois, e o que tem de verificar antes de chegarem utilizadores a sério.

Não executei isto nos servidores do Lovable. Montei um pequeno SaaS fictício numa stack Supabase local (CLI 2.109.1, Postgres 17.6): três tabelas com RLS e políticas, uma vista, uma função `SECURITY DEFINER`, grants explícitos, um bucket privado com dois ficheiros, dois utilizadores, uma tarefa agendada, uma tabela Realtime, definições de início de sessão mais rigorosas e um segredo de função. Depois exportei-o no formato que o Lovable documenta para a sua exportação e restaurei-o num projeto novo, duas vezes.

## É possível mover um projeto Lovable Cloud para o Supabase com um clique?

Não, não a 6 de novembro de 2026. A [documentação do Lovable](https://docs.lovable.dev/features/database-backups) diz que "não transfere um projeto para outro backend num só passo": exporta-se a base de dados, descarregam-se os ficheiros do armazenamento, move-se o código com a sincronização Git e configuram-se de novo a autenticação, os segredos, as variáveis de ambiente e os serviços externos. A [própria página de resolução de problemas do Supabase](https://supabase.com/docs/guides/troubleshooting/cant-access-supabase-project-lovable-cloud) concorda: não há forma automática de transferir um projeto Lovable Cloud para a sua conta Supabase. O fluxo "claim your project" de que talvez tenha lido pertence à oferta da plataforma Supabase para quem constrói apps; a documentação do Lovable não o oferece para projetos Cloud.

## O que está na exportação e o que não está?

Da mesma documentação: a exportação contém a base de dados completa, estrutura e dados, incluindo as contas de utilizador e os hashes das suas palavras-passe, por isso os utilizadores mantêm as palavras-passe. Não contém os ficheiros do armazenamento, o código das edge functions, os segredos, as definições dos fornecedores de início de sessão nem as chaves de API do projeto. É um arquivo PostgreSQL comprimido para o `pg_restore`, limitado a bases de dados até 15 GB, um ficheiro de 5 GB e uma exportação a cada 24 horas.

A minha exportação da app de teste, feita com `pg_dump -Fc --compress=zstd`, tinha 333 KB e continha muito mais do que as minhas três tabelas: os schemas do próprio Supabase `auth`, `storage`, `realtime`, `vault`, `extensions` e outros vieram juntos. É isso que torna ruidoso o restauro simples.

## O que aconteceu ao restaurá-la da forma simples?

![Uma exportação, duas formas de restaurar. App inventada numa stack Supabase local, CLI 2.109.1, Postgres 17.6. pg_restore simples: 539 erros → todas as linhas → mais grants, sem sessões; Primeiro migrações, depois dados: schema limpo → dados, 3x → igual à origem; Ficheiros do armazenamento: só as linhas → ficheiros fora → envie à mão; Definições de login, segredos: sem export → voltam ao padrão → refaça-os.](https://madsalt.tech/charts/pt/lovable-cloud-to-supabase-what-breaks.svg)

*Figura 1. A minha execução, 6 de novembro de 2026. O restauro simples parecia bem e não estava.*

Num projeto novo, como utilizador `postgres`, sem opções: `pg_restore -d <database> export.dump`. Terminou com "errors ignored on restore: 539". A maioria dizia respeito aos schemas internos do 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 muitos "already exists". Fácil de desvalorizar, porque os dados lá estavam:

| O quê                                               | App de origem                         | Depois do restauro simples                                   |
| --------------------------------------------------- | ------------------------------------- | ------------------------------------------------------------ |
| Linhas em companies / profiles / orders             | 2 / 2 / 5                             | 2 / 2 / 5                                                    |
| Utilizadores, com hashes de palavras-passe          | 2                                     | 2, e a palavra-passe antiga ainda inicia sessão              |
| Tabelas com RLS ligado, políticas                   | 3 ligadas, 6 políticas                | 3 ligadas, 6 políticas                                       |
| `security_invoker` da vista, definições das funções | definidos                             | inalterados                                                  |
| Grants para `anon`                                  | nenhum                                | TRUNCATE, REFERENCES, TRIGGER em todas as tabelas e na vista |
| Grants extra para `authenticated`                   | nenhum além de select, insert, update | TRUNCATE, REFERENCES, TRIGGER                                |
| Sessões, identidades, refresh tokens                | 2 / 2 / 2                             | 0 / 0 / 0                                                    |
| Tarefa agendada                                     | 1                                     | 0                                                            |
| Ficheiros no bucket                                 | 2, ambos se descarregam               | 2 linhas, o download falha com HTTP 500                      |

Três destas linhas importam mais do que o número de erros:

- **Os grants alargaram-se.** A app de origem tinha revogado tudo a `anon` e concedido a `authenticated` apenas o que as políticas precisam. O projeto restaurado deu a ambas as funções TRUNCATE, REFERENCES e TRIGGER em todas as tabelas. Pelo que consigo perceber, vieram dos privilégios por omissão do novo projeto, e as instruções de grant da exportação estavam entre os 539 erros, por isso nada os retirou. O RLS não cobre o TRUNCATE. Não testei se alguém o podia usar através da Data API, mas nenhuma função de cliente precisa dele, e é exatamente o que a [verificação 6 da minha lista de segurança para Lovable](https://madsalt.tech/pt/blog/lovable-app-security-checklist/) remove.
- **Todos ficam sem sessão.** As linhas de sessões, identidades e refresh tokens falharam nas chaves estrangeiras, por isso um access token emitido pelo projeto antigo recebeu HTTP 403 `session_not_found`. Os utilizadores podem iniciar sessão outra vez com a palavra-passe antiga, o que funcionou na minha execução; a documentação do Lovable também avisa da perda de sessão. O início de sessão com Google ou GitHub é a questão em aberto: a tabela `identities` é o que liga um login desses ao utilizador existente, e voltou vazia.
- **Os ficheiros são linhas sem ficheiros.** `storage.objects` descreve cada ficheiro e as linhas passaram, mas os ficheiros em si não estão na exportação. Na minha stack local o download falhou com HTTP 500. Só testei o backend de armazenamento local, por isso experimente você um download no novo projeto alojado e espere que falhe até carregar os ficheiros.

## Que restauro funcionou?

O caminho para o qual aponta o guia do Lovable: primeiro a estrutura, depois os dados. No segundo projeto novo:

1. **Estrutura a partir das suas migrações.** Apliquei o SQL do meu schema, o equivalente à pasta `supabase/migrations` que o Lovable sincroniza com o GitHub. Correu limpo, com os meus grants, políticas, vista e função exatamente como na origem.
2. **Só os dados da exportação.** `pg_restore --data-only -d <database> export.dump` terminou com 17 erros. A maioria eram outra vez tabelas internas do Supabase, que o novo projeto já tinha. Cinco não: `identities`, `sessions`, `refresh_tokens`, `mfa_amr_claims` e `one_time_tokens` falharam nas chaves estrangeiras, por exemplo `Key (user_id)=(…) is not present in table "users"`, porque o restauro só de dados as carregou antes das linhas-pai.
3. **As tabelas falhadas outra vez, primeiro os pais.** Restaurar `auth.identities` e `auth.sessions` à parte carregou-as; uma terceira execução com `auth.refresh_tokens` e `auth.mfa_amr_claims` terminou com código de saída 0.
4. **A tarefa agendada à mão.** O restauro dos dados de `cron` foi negado ("permission denied for table job"), por isso voltei a criar a tarefa com `cron.schedule`. O seu histórico de execuções não acompanha.

Executei isto dentro do contentor da base de dados local; num projeto alojado, `$NEW_DB_URL` é a cadeia de ligação da janela Connect do novo projeto.

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

Depois disso, todas as verificações abaixo coincidiam com a origem: nenhuma tabela com RLS desligado, 4 políticas públicas e 2 de storage, os mesmos grants tabela a tabela, a vista ainda `security_invoker`, a função ainda `SECURITY DEFINER` com um `search_path` vazio, a sequência do id das encomendas no valor certo, e 2 sessões, 2 identidades e 2 refresh tokens.

Uma coisa que a minha execução não podia mostrar: um projeto Supabase novo criado depois de 30 de maio de 2026 já não concede automaticamente as tabelas novas à Data API. Se as suas migrações criam tabelas sem um `GRANT`, a app recebe o erro 42501 no novo projeto mesmo tendo funcionado no Lovable Cloud. [A alteração de grants de 30 de outubro](https://madsalt.tech/pt/blog/supabase-october-30-grant-change/) explica o erro e a correção.

## O que voltou aos valores por omissão?

Nada na exportação transporta as definições do projeto. Nos dois caminhos:

| Definição                       | App de origem     | Projeto novo                                    |
| ------------------------------- | ----------------- | ----------------------------------------------- |
| Site URL                        | o endereço da app | o predefinido                                   |
| Allowed redirect URLs           | o callback da app | o predefinido                                   |
| Confirmação de email            | ligada            | desligada                                       |
| Tamanho mínimo da palavra-passe | 10                | 6, uma palavra-passe de 7 caracteres foi aceite |
| Segredo de função               | definido          | em falta                                        |

A confirmação de email desligada e um mínimo de palavra-passe mais curto são despromoções silenciosas: nada se parte, o registo apenas fica mais fraco. Defina-os de novo em Authentication antes de mudar, juntamente com cada fornecedor de início de sessão e o seu URL de redirecionamento na consola do fornecedor.

## O que deve verificar antes de mudar?

Execute isto no novo projeto, e as mesmas consultas no antigo no editor SQL do Lovable (More → Database → Manage), e compare.

1. **Contagens de linhas** das suas tabelas principais, e `select count(*) from auth.users;`.
2. **RLS e políticas.** Tabelas com RLS desligado: `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;` dos dois lados.
3. **Grants**, tabela a tabela:

```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. **Dados de autenticação.** `select count(*) from auth.identities;` tem de coincidir com o projeto antigo se alguém iniciar sessão com Google, GitHub ou semelhante.
5. **Tarefas agendadas.** `select jobname, schedule from cron.job;`
6. **Ficheiros.** Descarregue um ficheiro por bucket através da app, com a sessão do respetivo dono.
7. **Início de sessão.** Inicie sessão como utilizador de teste com a palavra-passe antiga, depois registe um utilizador novo e verifique que o email de confirmação e a regra da palavra-passe se comportam como antes.
8. **Segredos e funções.** Todos os segredos que as suas edge functions leem estão definidos, e todas as funções estão publicadas.

Quando o projeto estiver na sua própria conta Supabase, a [Auditoria de segurança Supabase](https://madsalt.tech/pt/tools/supabase-security-check/) gratuita pode ligar-se a ele e executar as verificações de configuração de uma só vez. O teste com dois utilizadores e os ficheiros continuam a ser consigo, à mão.

## O que é que a mudança ainda exige à mão?

- **Ficheiros do armazenamento.** Descarregue cada bucket em More → Storage no Lovable e carregue os ficheiros para buckets com os mesmos nomes, para que os caminhos em `storage.objects` apontem para ficheiros reais.
- **Segredos.** Não são exportados, por isso copie cada um dos Secrets do Lovable para os segredos das edge functions do novo projeto.
- **Edge functions.** Publique-as a partir da pasta `supabase/functions` do seu repositório.
- **Fornecedores de início de sessão e URLs de redirecionamento**, no Supabase e na consola de cada fornecedor.
- **A ligação da app.** Aponte-a para o URL e a chave pública do novo projeto, e mantenha o backend antigo a funcionar até o novo ter passado todas as verificações acima.

Se a sua app guarda dados de clientes, faça as verificações de segurança no novo projeto antes de mudar, não depois: uma mudança é o momento em que grants e políticas derivam, como mostrou o restauro simples. A lista completa está na minha [lista de segurança para apps Lovable](https://madsalt.tech/pt/blog/lovable-app-security-checklist/).

## O meu caso semelhante

Uma empresa para quem construí pagava milhares de dólares por mês por um produto documental empresarial. A plataforma própria custa agora centenas por mês, com funções para documentos, formulários, relatórios e um portal de clientes, e só as funcionalidades que a equipa usa. Veja o [caso da plataforma documental de obra](https://madsalt.tech/pt/work/construction-document-platform/).

Vai sair do Lovable Cloud? Escreva-me e preparamos a mudança antes que algo se parta.

Vai sair do Lovable Cloud?

Diga-me o que tem agora e o que precisa. Respondo com a opção que eu escolheria.

[Fale comigo](https://madsalt.tech/pt/#contact)
