# Como migrei 182 mil usuários para o Supabase

By Tarik Pinarci (https://tarikpinarci.com). Published 2025-03-30. Canonical: https://tarikpinarci.com/pt/blog/migration-to-supabase

De meses adiando até migrar 182 mil usuários: como finalmente levei o meu app para o Supabase.

Migrar 182.000 usuários para um backend novo não é pouca coisa, ainda mais quando você é um dev mobile solo equilibrando um emprego em tempo integral. Mas eu consegui. Passei o meu app, OSM Tactics, de um setup confuso de NestJS + MongoDB para o Supabase, o assunto do momento nos círculos de backend. Neste artigo, vou mostrar a jornada: por que escolhi o Supabase, os desafios que enfrentei e como consegui fazer a migração.

### Por que o Supabase?

Quando o backend do meu app começou a parecer velho, procurei algo melhor, e o Supabase chamou a minha atenção. É uma ferramenta open-source parecida com o Firebase, mas mais simples de começar a usar. Ele te dá um banco de dados PostgreSQL com uma API fácil, recursos em tempo real e login já prontos. Para mim, um cara que constrói apps mobile, isso é perfeito: não quero mexer com coisas complicadas de servidor. Dá para ter um projeto Supabase rodando em uns cinco minutos, e a documentação é super direta, então não me senti perdido, mesmo não sendo um especialista em backend.

Mas o Supabase não é só fácil: ele está crescendo. Ainda não é tão grande quanto o Firebase, mas muitos desenvolvedores estão usando, e a comunidade cresce rápido. Ele tem tudo de que eu preciso: um banco de dados para guardar as coisas, ferramentas de login, um lugar para fazer upload de arquivos e até pequenas funções que posso rodar sem um servidor completo. O Firebase esconde como funciona, mas o Supabase usa o PostgreSQL, um banco de dados antigo e confiável em que muita gente confia. Isso significa que posso mudar as coisas do jeito que eu quiser e crescer depois sem ficar preso. Além disso, há um grupo grande de desenvolvedores online compartilhando dicas, truques e correções em lugares como o GitHub. Eu sabia que, se travasse, podia pesquisar no Google ou perguntar a alguém. Para um programador solo como eu, com pouco tempo, o Supabase pareceu a escolha certa: é simples, mas forte o bastante para aguentar o meu app.

### O setup antigo antes da grande troca

![](https://cdn-images-1.medium.com/max/2000/0*8Dz9gnNI7LqoicSk.gif)

Antes de falar do salto para o Supabase, vamos ver o que eu usava. O meu app, [OSM Tactics](https://apps.apple.com/us/app/osm-tactics/id1632773385), é um jogo mobile para Android e iOS em que as pessoas planejam estratégias táticas. É bem legal, se você curte esse tipo de coisa. O backend era algo que eu mesmo construí com NestJS, um framework para Node.js de que eu gostava porque funciona com TypeScript e mantém tudo organizado. Ele conversava com o MongoDB, um banco de dados onde eu guardava todas as informações dos usuários, os dados do jogo e outras coisas. Eu rodava esse setup havia quase quatro anos.

![O último snapshot do mongodb antes da migração, Osm Tactics, também conhecido como "Osm Guide"](https://cdn-images-1.medium.com/max/4072/1*oPXY2-yvVmlns_ufWV4ZGg.png)_O último snapshot do mongodb antes da migração, Osm Tactics, também conhecido como "Osm Guide"_

Mas aqui está o problema: sou um cara só, com um emprego em tempo integral, e manter esse backend vivo estava acabando comigo. No começo, NestJS e MongoDB estavam ok: eu dava conta. Mas, conforme mais usuários chegavam, a coisa ficou bagunçada. Eu precisava gastar tempo demais garantindo que o servidor não caísse, corrigindo falhas de segurança e mantendo tudo rápido o suficiente. Segurança era a pior parte: eu sei um pouco de Node.js, mas sou um cara de apps mobile, não um especialista em backend. Ainda funcionava, mais ou menos, mas era como um carro velho que vivia quebrando. Eu não podia ficar remendando para sempre. Precisava de algo novo que não me fizesse arrancar os cabelos.

### O salto: decidindo migrar

![](https://cdn-images-1.medium.com/max/2000/1*CUFLlvoA2ItnVtEFWJulrg.png)

Decidir mover tudo não foi rápido. Levou uma eternidade, porque eu vivia adiando. O OSM Tactics não é um app gigante cheio de funcionalidades, mas 182 mil usuários é muito dado para lidar. Sair do MongoDB, onde os dados são soltos e livres, para o PostgreSQL do Supabase, onde tudo fica em tabelas certinhas, parecia difícil. Eu teria que refazer a forma como os dados estavam organizados e garantir que não perderia nada importante. A dupla NestJS e MongoDB ainda estava rodando, mas eu tinha a sensação ruim de que ia explodir logo. Essa preocupação ficou me incomodando até que finalmente eu disse: "Ok, vamos nessa."

Depois que decidi, precisei planejar muito bem. Sentei e descobri como transformar as minhas coisas do MongoDB em tabelas do Supabase, como desenhar um mapa de para onde cada coisa iria. O primeiro passo foi tirar todos os meus dados do MongoDB com segurança, então escrevi um pequeno script para exportar tudo em arquivos JSON. Aqui está o código. É básico, mas fez o trabalho:

```javascript
async function exportCollection(collectionName, outputFileName, query = {}) {
  try {
    await mongoose.connect(mongoURI);

    const Model = mongoose.model(
      collectionName,
      genericSchema,
      collectionName.toLowerCase()
    );

    const documents = await Model.find(query).lean();

    const outputPath = path.join(__dirname, outputFileName);
    fs.writeFileSync(outputPath, JSON.stringify(documents, null, 2));

    await mongoose.disconnect();

    return documents;
  } catch (error) {
    if (mongoose.connection.readyState !== 0) {
      await mongoose.disconnect();
    }
  }
}
```

Esse script se conectava ao MongoDB, puxava todos os dados e salvava como arquivos JSON no meu computador. Era como um backup: eu podia mexer à vontade sem perder tudo se fizesse besteira. Rodei para cada collection, conferi os arquivos para ver se estavam certos e me senti um pouco melhor sabendo que tinha cópias. Mesmo assim, enrolei para começar o trabalho de verdade. Eu ficava olhando para a tela, tomando café e pensando: "Talvez amanhã." Precisei de um empurrão grande para parar de enrolar e realmente começar, mas, quando comecei, mergulhei de cabeça.

### Migrando os usuários: o quebra-cabeça das senhas

Aqui a coisa ficou complicada de verdade: mover 182 mil usuários e manter as senhas funcionando. Os usuários esperam fazer login com o mesmo e-mail e a mesma senha depois que atualizo o app, e é assim que deve ser. Mas fazer isso foi um pesadelo. A parte boa? [O Supabase usa bcrypt para as senhas](https://supabase.com/docs/guides/auth/password-security#how-are-passwords-stored), igual ao MongoDB, então não precisei refazer todas nem obrigar os usuários a escolher senhas novas. Isso teria sido uma experiência terrível: as pessoas odeiam redefinir senha, e eu perderia muitas delas.

### Lidando com a tabela de auth exigente do Supabase

O Supabase tem uma tabela auth.users para os logins, e ela é super rígida. Tem vários campos que você precisa preencher exatamente certo, senão ela surta. Por exemplo, se você coloca uma string vazia em vez de null, quebra. Encontrei alguns erros que outras pessoas tiveram [nesta thread do GitHub](https://github.com/supabase/auth/issues/1940), e isso me deixou bem esperto. Eu precisava acertar tudo perfeitamente. Assim ficava um usuário para o Supabase (eu não usei nada de telefone, então esses campos estão null. Mude isso se você usar):

```javascript
const supabaseUser = {
  id: uid,
  email: user.email,
  encrypted_password: user.password || null,
  instance_id: "00000000–0000–0000–0000–000000000000",
  aud: "authenticated",
  role: "authenticated",
  email_confirmed_at: user.createdAt
    ? new Date(user.createdAt).toISOString()
    : new Date().toISOString(),
  created_at: user.createdAt
    ? new Date(user.createdAt).toISOString()
    : new Date().toISOString(),
  updated_at: user.updatedAt ? new Date(user.updatedAt).toISOString() : null,
  last_sign_in_at: null,
  phone: user.phone || null,
  phone_confirmed_at: null,
  confirmed_at: user.createdAt
    ? new Date(user.createdAt).toISOString()
    : new Date().toISOString(),
  invited_at: null,
  confirmation_token: "",
  confirmation_sent_at: null,
  recovery_token: "",
  recovery_sent_at: null,
  email_change_token_new: "",
  email_change: "",
  email_change_sent_at: null,
  email_change_token_current: "",
  email_change_confirm_status: 0,
  banned_until: null,
  reauthentication_token: "",
  reauthentication_sent_at: null,
  is_super_admin: null,
  phone_change: "",
  phone_change_token: "",
  phone_change_sent_at: null,
  is_sso_user: false,
  deleted_at: null,
  is_anonymous: false,
  raw_user_meta_data: JSON.stringify(rawUserMetaData),
  raw_app_meta_data: JSON.stringify(rawAppMetaData),
};
```

Eu precisava acertar cada campo, senão o Supabase não aceitava. Para mover todos os meus usuários do MongoDB, escrevi um script maior que os buscava, transformava nesse formato e salvava em um arquivo CSV. Aqui está o script. É longo, mas mostra o processo inteiro:

```javascript
const fs = require("fs");
const path = require("path");
const { parse } = require("json2csv");
const { v4: uuidv4 } = require("uuid");
const mongoose = require("mongoose");
const mongoURI = "your-connection-string";

// Define a generic schema for flexible document structure
const userSchema = new mongoose.Schema({}, { strict: false });
async function fetchUsersFromMongoDB() {
  try {
    console.log("Connecting to MongoDB…");
    await mongoose.connect(mongoURI);
    console.log("Connected to MongoDB");
    const UserModel = mongoose.model("Users", userSchema, "users");
    console.log("Fetching users from MongoDB…");
    const users = await UserModel.find({}).lean();
    console.log(`Found ${users.length} users in MongoDB`);
    await mongoose.disconnect();
    console.log("Disconnected from MongoDB");
    return users;
  } catch (error) {
    console.error("Error fetching users from MongoDB:", error);
    if (mongoose.connection.readyState !== 0) {
      await mongoose.disconnect();
    }
    throw error;
  }
}

async function processUsers() {
  console.time("Total processing time");
  const mongoUsersFilePath = path.join(__dirname, "mongo_users.json");
  try {
    // Step 1: Fetch users from MongoDB
    const users = await fetchUsersFromMongoDB();
    // Step 2: Write users to a fresh JSON file
    fs.writeFileSync(mongoUsersFilePath, JSON.stringify(users, null, 2));
    console.log(`Fresh users data written to: ${mongoUsersFilePath}`);
    // Step 3: Read the fresh users file
    const usersData = JSON.parse(fs.readFileSync(mongoUsersFilePath, "utf8"));
    console.log(`Read ${usersData.length} users from fresh file`);
    // Step 4: Filter users to include only those with an email or at least one provider
    const filteredUsers = usersData.filter((user) => {
      return user.email || user.googleId || user.appleId;
    });
    console.log(`Filtered users: ${filteredUsers.length}`);
    // Create a Set to track used IDs and ensure uniqueness
    const usedIds = new Set();
    const usedEmails = new Set();
    const duplicateEmails = [];
    // Step 5: Transform the data to match Supabase Auth users structure
    const transformedUsers = [];
    filteredUsers.forEach((user) => {
      if (!user.email) {
        console.log("Skipping user without email:", user._id);
        return;
      }
      // Check for duplicate email
      const lowerEmail = user.email.toLowerCase();
      if (usedEmails.has(lowerEmail)) {
        duplicateEmails.push({
          email: user.email,
          id: user._id,
          googleId: user.googleId,
          appleId: user.appleId,
        });
        console.warn(`Duplicate email detected and skipped: ${user.email}`);
        return;
      }
      // Mark this email as used
      usedEmails.add(lowerEmail);
      let uid = uuidv4();
      while (usedIds.has(uid)) {
        console.warn("Duplicate ID detected:", uid);
        uid = uuidv4();
      }
      usedIds.add(uid);
      const rawUserMetaData = {
        sub: uid,
        email: user.email,
        email_verified: true,
        phone_verified: false,
      };
      const providers = [];
      // Check for Google ID
      if (user.googleId) {
        providers.push("google");
        rawUserMetaData.iss = "https://accounts.google.com";
        rawUserMetaData.sub = user.googleId;
        rawUserMetaData.provider_id = user.googleId;
      }
      // Check for Apple ID
      if (user.appleId) {
        providers.push("apple"); // Only override iss and sub if Google wasn't already set
        if (!user.googleId) {
          rawUserMetaData.iss = "https://appleid.apple.com";
          rawUserMetaData.sub = user.appleId;
          rawUserMetaData.provider_id = user.appleId;
        }
      }
      // If no external providers, use email
      if (providers.length === 0) {
        providers.push("email");
      }
      // Set the raw app metadata
      const rawAppMetaData = {
        provider: providers[0], // Primary provider is the first one
        providers: providers, // All providers in an array
      };
      transformedUsers.push({
        id: uid,
        email: user.email || null,
        encrypted_password: user.password,
        instance_id: "00000000–0000–0000–0000–000000000000",
        aud: "authenticated",
        role: "authenticated",
        invited_at: null,
        confirmation_token: "",
        confirmation_sent_at: null,
        recovery_token: "",
        recovery_sent_at: null,
        email_change_token_new: "",
        email_change: "",
        email_change_sent_at: null,
        last_sign_in_at: new Date().toISOString(),
        is_super_admin: null,
        phone: "",
        phone_confirmed_at: null,
        phone_change: "",
        phone_change_token: "",
        phone_change_sent_at: null,
        confirmed_at: new Date().toISOString(),
        email_change_token_current: "",
        email_change_confirm_status: 0,
        banned_until: null,
        reauthentication_token: "",
        reauthentication_sent_at: null,
        is_sso_user: false,
        deleted_at: null,
        is_anonymous: false,
        created_at: user.createdAt
          ? new Date(user.createdAt).toISOString()
          : new Date().toISOString(),
        updated_at: null,
        email_confirmed_at: user.createdAt
          ? new Date(user.createdAt).toISOString()
          : new Date().toISOString(),
        phone: user.phone || null,
        phone_confirmed_at: null,
        raw_user_meta_data: rawUserMetaData,
        raw_app_meta_data: rawAppMetaData,
      });
    });
    // Step 6: Convert the transformed data to CSV
    const csvFields = [
      "id",
      "email",
      "encrypted_password",
      "instance_id",
      "aud",
      "role",
      "email_confirmed_at",
      "invited_at",
      "confirmation_token",
      "confirmation_sent_at",
      "recovery_token",
      "recovery_sent_at",
      "email_change_token_new",
      "email_change",
      "email_change_sent_at",
      "last_sign_in_at",
      "raw_app_meta_data",
      "raw_user_meta_data",
      "is_super_admin",
      "created_at",
      "updated_at",
      "phone",
      "phone_confirmed_at",
      "phone_change",
      "phone_change_token",
      "phone_change_sent_at",
      "confirmed_at",
      "email_change_token_current",
      "email_change_confirm_status",
      "banned_until",
      "reauthentication_token",
      "reauthentication_sent_at",
      "is_sso_user",
      "deleted_at",
      "is_anonymous",
    ];
    // Write duplicate emails to a file for reference
    if (duplicateEmails.length > 0) {
      fs.writeFileSync(
        path.join(__dirname, "duplicate_emails.json"),
        JSON.stringify(duplicateEmails, null, 2)
      );
      console.log("Duplicate emails written to duplicate_emails.json");
    }
    const csv = parse(transformedUsers, { fields: csvFields });
    // Step 7: Write the CSV to a file
    const csvFilePath = path.join(__dirname, "supabase_users.csv");
    fs.writeFileSync(csvFilePath, csv);
    console.log("CSV file has been generated:", csvFilePath);
    // Step 8: Delete the temporary fresh users file
    if (fs.existsSync(mongoUsersFilePath)) {
      fs.unlinkSync(mongoUsersFilePath);
      console.log(`Temporary file deleted: ${mongoUsersFilePath}`);
    }
    console.timeEnd("Total processing time");
  } catch (error) {
    console.error("Error processing users:", error);
  } finally {
    if (fs.existsSync(mongoUsersFilePath)) {
      try {
        fs.unlinkSync(mongoUsersFilePath);
        console.log(`Temporary file deleted: ${mongoUsersFilePath}`);
      } catch (deleteError) {
        console.error(`Error deleting temporary file: ${deleteError.message}`);
      }
    }
  }
}
```

Com o CSV em mãos, criei uma tabela falsa no Supabase igual à auth.users. A definição da tabela real é um SQL longo que você pode ver no editor do Supabase em schema auth > users > Definition:

```sql
    create table auth.users (
      instance_id uuid null,
      id uuid not null,
      aud character varying(255) null,
      role character varying(255) null,
      email character varying(255) null,
      encrypted_password character varying(255) null,
      email_confirmed_at timestamp with time zone null,
      invited_at timestamp with time zone null,
      confirmation_token character varying(255) null,
      confirmation_sent_at timestamp with time zone null,
      recovery_token character varying(255) null,
      recovery_sent_at timestamp with time zone null,
      email_change_token_new character varying(255) null,
      email_change character varying(255) null,
      email_change_sent_at timestamp with time zone null,
      last_sign_in_at timestamp with time zone null,
      raw_app_meta_data jsonb null,
      raw_user_meta_data jsonb null,
      is_super_admin boolean null,
      created_at timestamp with time zone null,
      updated_at timestamp with time zone null,
      phone text null default null::character varying,
      phone_confirmed_at timestamp with time zone null,
      phone_change text null default ''::character varying,
      phone_change_token character varying(255) null default ''::character varying,
      phone_change_sent_at timestamp with time zone null,
      confirmed_at timestamp with time zone GENERATED ALWAYS as (LEAST(email_confirmed_at, phone_confirmed_at)) STORED null,
      email_change_token_current character varying(255) null default ''::character varying,
      email_change_confirm_status smallint null default 0,
      banned_until timestamp with time zone null,
      reauthentication_token character varying(255) null default ''::character varying,
      reauthentication_sent_at timestamp with time zone null,
      is_sso_user boolean not null default false,
      deleted_at timestamp with time zone null,
      is_anonymous boolean not null default false,
      constraint users_pkey primary key (id),
      constraint unique_email unique (email),
      constraint users_phone_key unique (phone),
      constraint users_email_change_confirm_status_check check (
        (
          (email_change_confirm_status >= 0)
          and (email_change_confirm_status <= 2)
        )
      )
    ) TABLESPACE pg_default;

    create unique INDEX IF not exists confirmation_token_idx on auth.users using btree (confirmation_token) TABLESPACE pg_default
    where
      ((confirmation_token)::text !~ '^[0-9 ]*$'::text);

    create unique INDEX IF not exists email_change_token_current_idx on auth.users using btree (email_change_token_current) TABLESPACE pg_default
    where
      (
        (email_change_token_current)::text !~ '^[0-9 ]*$'::text
      );

    create unique INDEX IF not exists email_change_token_new_idx on auth.users using btree (email_change_token_new) TABLESPACE pg_default
    where
      (
        (email_change_token_new)::text !~ '^[0-9 ]*$'::text
      );

    create unique INDEX IF not exists reauthentication_token_idx on auth.users using btree (reauthentication_token) TABLESPACE pg_default
    where
      (
        (reauthentication_token)::text !~ '^[0-9 ]*$'::text
      );

    create unique INDEX IF not exists recovery_token_idx on auth.users using btree (recovery_token) TABLESPACE pg_default
    where
      ((recovery_token)::text !~ '^[0-9 ]*$'::text);

    create unique INDEX IF not exists users_email_partial_key on auth.users using btree (email) TABLESPACE pg_default
    where
      (is_sso_user = false);

    create index IF not exists users_instance_id_email_idx on auth.users using btree (instance_id, lower((email)::text)) TABLESPACE pg_default;

    create index IF not exists users_instance_id_idx on auth.users using btree (instance_id) TABLESPACE pg_default;

    create index IF not exists users_is_anonymous_idx on auth.users using btree (is_anonymous) TABLESPACE pg_default;
```

Copiei essa definição para a minha tabela temporária, fiz o upload do CSV nela e depois usei este script para mover os usuários para a tabela auth.users real, mil de cada vez:

```sql
    DO $$
    DECLARE
        batch_size INT := 1000;  -- Adjust batch size as needed
        records_inserted INT;
    BEGIN
        LOOP
            INSERT INTO auth.users (
                id,
                email,
                encrypted_password,
                instance_id,
                aud,
                role,
                email_confirmed_at,
                invited_at,
                confirmation_token,
                confirmation_sent_at,
                recovery_token,
                recovery_sent_at,
                email_change_token_new,
                email_change,
                email_change_sent_at,
                last_sign_in_at,
                raw_app_meta_data,
                raw_user_meta_data,
                is_super_admin,
                created_at,
                updated_at,
                phone,
                phone_confirmed_at,
                phone_change,
                phone_change_token,
                phone_change_sent_at,
                email_change_token_current,
                email_change_confirm_status,
                banned_until,
                reauthentication_token,
                reauthentication_sent_at,
                is_sso_user,
                deleted_at,
                is_anonymous
            )
            SELECT
                id,
                email,
                encrypted_password,
                COALESCE(instance_id, '00000000-0000-0000-0000-000000000000'),
                COALESCE(aud, 'authenticated'),
                COALESCE(NULLIF(role, ''), 'authenticated'),
                COALESCE(email_confirmed_at, NOW()),
                COALESCE(invited_at, NULL),
                COALESCE(confirmation_token, ''),
                COALESCE(confirmation_sent_at, NULL),
                COALESCE(recovery_token, ''),
                COALESCE(recovery_sent_at, NULL),
                COALESCE(email_change_token_new, ''),
                COALESCE(email_change, ''),
                COALESCE(email_change_sent_at, NULL),
                COALESCE(last_sign_in_at, NOW()),
                raw_app_meta_data,  -- Use value from test_users table
                raw_user_meta_data, -- Use value from test_users table
                COALESCE(is_super_admin, NULL),
                COALESCE(created_at, NOW()),
                COALESCE(updated_at, NOW()),
                COALESCE(phone, NULL),
                COALESCE(phone_confirmed_at, NULL),
                COALESCE(phone_change, ''),
                COALESCE(phone_change_token, ''),
                COALESCE(phone_change_sent_at, NULL),
                COALESCE(email_change_token_current, ''),
                COALESCE(email_change_confirm_status, 0),
                COALESCE(banned_until, NULL),
                COALESCE(reauthentication_token, ''),
                COALESCE(reauthentication_sent_at, NULL),
                COALESCE(is_sso_user, false),
                COALESCE(deleted_at, NULL),
                COALESCE(is_anonymous, false)
            FROM public.test_users
            LIMIT batch_size
            ON CONFLICT (email) DO NOTHING;  -- Ignore duplicates

            GET DIAGNOSTICS records_inserted = ROW_COUNT;

            -- Exit the loop if no more records are inserted
            IF records_inserted = 0 THEN
                EXIT;
            END IF;
        END LOOP;
    END $$;
```

Assim, eu conseguia ver cada etapa: exportar, transformar, carregar. Levou mais tempo do que alguma ferramenta sofisticada talvez levasse, mas eu gostava de saber exatamente o que estava acontecendo. Eu conferia a tabela temporária depois de carregar o CSV, checava algumas linhas por amostragem e depois acompanhava o script de lotes rodando para garantir que não travasse.

### Sem espaço para campos personalizados

A tabela auth.users do Supabase não deixa você adicionar os seus próprios campos, e isso me pegou de surpresa. No MongoDB, eu simplesmente enfiava um campo username ali, sem problema. Mas o Supabase diz não: você fica preso ao que ele oferece. Pensei em jogar as coisas extras no raw_user_meta_data, que é como uma sacola de JSON, mas isso fica bagunçado para buscas depois. Em vez disso, criei uma tabela profiles nova que se conecta à auth.users pelo ID do usuário. Ela guarda coisas como username e locale, mantendo tudo organizado.

Veja também esta discussão, que pode ajudar: [https://github.com/orgs/supabase/discussions/3491](https://github.com/orgs/supabase/discussions/3491)

Configurar isso deu mais trabalho: eu precisava puxar esses campos extras do MongoDB, associar aos usuários certos e carregar na tabela nova. Escrevi outro script para buscar esses dados, transformei em CSV e fiz o upload para o Supabase depois que a parte de auth estava pronta. Agora o setup é melhor, porque posso adicionar mais campos depois sem quebrar nada, mas a migração demorou mais, já que eu tinha duas tabelas para lidar em vez de uma.

### Migração dos logins com Google/Apple

![](https://cdn-images-1.medium.com/max/2400/0*ojwVN2SEuLBx9Ybn.jpeg)

Os logins com Google e Apple também deram dor de cabeça. No MongoDB, eu tinha os campos googleId e appleId, e alguns usuários tinham os dois ligados ao mesmo e-mail. O Supabase lida com isso usando campos especiais no raw_user_meta_data, como iss, sub e provider_id.

Assim configurei:

```javascript
const uid = uuidv4();
const providers = [];
// Build raw user metadata
const rawUserMetaData = {
  sub: uid,
  email: user.email,
  email_verified: true,
  phone_verified: false,
};
// Check for Google ID
if (user.googleId) {
  providers.push("google");
  rawUserMetaData.iss = "https://accounts.google.com";
  rawUserMetaData.sub = user.googleId;
  rawUserMetaData.provider_id = user.googleId;
}
// Check for Apple ID
if (user.appleId) {
  providers.push("apple");
  if (!user.googleId) {
    rawUserMetaData.iss = "https://appleid.apple.com";
    rawUserMetaData.sub = user.appleId;
    rawUserMetaData.provider_id = user.appleId;
  }
}
// If no external providers, use email
if (providers.length === 0) {
  providers.push("email");
}
```

No app, atualizei os fluxos de login para usar as APIs do Supabase. Para a Apple:

```javascript
import * as AppleAuthentication from "expo-apple-authentication";
import { supabase } from "your-supabase-client";

const credential = await AppleAuthentication.signInAsync({
  requestedScopes: [
    AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
    AppleAuthentication.AppleAuthenticationScope.EMAIL,
  ],
});
if (credential.identityToken) {
  const { data, error } = await supabase.auth.signInWithIdToken({
    provider: "apple",
    token: credential.identityToken,
  });
}
```

E para o Google:

```javascript
import { GoogleSignin } from "@react-native-google-signin/google-signin";
import { supabase } from "your-supabase-client";

const googleUser = await GoogleSignin.signIn();

if (googleUser.idToken) {
  const { data, error } = await supabase.auth.signInWithIdToken({
    provider: "google",
    token: googleUser.idToken,
  });
}
```

Funcionou, mas lidar com usuários que tinham Google e Apple foi complicado: precisei escolher um como ID principal e registrar o outro como extra. Testei bastante no app para garantir que ninguém ficasse sem acesso.

> **Atenção: possíveis problemas na exportação de CSV no Supabase**
> Até hoje (29/03/2025), exportar dados de tabelas como CSV pode ser [pouco confiável](https://github.com/supabase/supabase/issues/27102). Então lembre disso ao comparar dados entre o Supabase e a sua fonte original.

### Gerando tipos TypeScript

O Supabase tem um truque incrível: ele gera os tipos TypeScript para você. [Você roda um comando](https://supabase.com/docs/guides/api/rest/generating-types#generating-types-using-supabase-cli) e ele cospe arquivos que dizem ao seu código exatamente como o seu banco de dados é. Para o meu app React Native com Expo, isso foi enorme: eu não precisava adivinhar que dados ia receber nem escrever os meus próprios tipos. Reduziu muito os bugs, porque o TypeScript gritava comigo se eu errasse. Antes, eu passava horas corrigindo erros bobos. Agora é bem mais rápido.

Rodei o comando depois de configurar as tabelas, peguei o arquivo de tipos e coloquei no app. De repente, coisas como user.email ou profile.username simplesmente funcionavam, sem ficar na dúvida se eu tinha escrito certo. É uma coisa pequena, mas fez programar o app parecer menos um jogo de adivinhação e mais uma vitória.

### Deixando as funções do banco de dados fazerem o trabalho

O Supabase permite escrever pequenas funções SQL que rodam no banco de dados, o que é super útil. Em vez de escrever um monte de código no app para alterar as coisas, deixei o banco de dados cuidar disso.

Aqui está uma que criei para adicionar créditos ao perfil de um usuário:

```sql
    declare
      current_credits int;
      new_credits int;
    begin
      -- Get current credits from user_profiles table
      select assistant_credits
      into current_credits
      from public.user_profiles
      where public.user_profiles.user_id = increase_assistant_credits.user_id;

      if current_credits is null then
        current_credits := 0;
      end if;

      new_credits := current_credits + credits_to_add;

      -- Update assistant_credits in user_profiles table
      update public.user_profiles
      set assistant_credits = new_credits
      where public.user_profiles.user_id = increase_assistant_credits.user_id;

      return new_credits;
    end;
```

Ela pega os créditos do usuário, soma mais alguns e salva de volta, tudo de uma vez. Sem ela, eu teria que buscar os créditos, somar no app e enviar de volta, o que significa mais código e mais chances de errar. Escrevi algumas dessas para outras tarefas também, e o app ficou mais ágil, já que o banco de dados fazia o trabalho pesado.

### A ressalva do backend

Aqui vai uma reviravolta: o Supabase não acabou com o meu backend por completo. Para usar algumas coisas de login de admin, você precisa da [chave service_role](https://supabase.com/docs/guides/api/api-keys#the-servicerole-key), mas não pode colocá-la no app, porque não é seguro. Então mantive um servidor NestJS pequeno para cuidar dessas tarefas secretas. Ele não é tão grande quanto antes, mas está lá para manter tudo protegido. O Supabase faz a maior parte do trabalho, então ainda é muito mais fácil do que o meu setup antigo.

### Conclusão: valeu o esforço

![](https://cdn-images-1.medium.com/max/2000/0*rugop3f6Ns9U4Ayl.jpg)

Migrar 182.000 usuários para o Supabase não foi só um desafio técnico: foi um desafio mental também. Entre procrastinação, noites em claro e muita insegurança, houve momentos em que achei de verdade que ia quebrar tudo. Foi uma caminhada lenta, cheia de estresse e hesitação. Mas deixar para trás o frágil setup de NestJS + MongoDB e ir para algo mais limpo e fácil de manter valeu muito a pena.

O Supabase me deu a simplicidade, a flexibilidade e o apoio da comunidade de que eu precisava como dev solo equilibrando um emprego em tempo integral. Se você está pensando em migrar o backend do seu próprio app, saiba que é totalmente possível. Não vai ser rápido nem indolor, mas, com um pouco de planejamento (e provavelmente algumas noites longas), você vai sair do outro lado com um setup em que realmente pode confiar.

