De aplazarlo durante meses a migrar 182k usuarios: así fue como por fin pasé mi app a Supabase.
Migrar 182,000 usuarios a un nuevo backend no es poca cosa, sobre todo cuando eres un desarrollador móvil en solitario que compagina un trabajo a tiempo completo. Pero lo logré. Pasé mi app, OSM Tactics, de una configuración enredada de NestJS + MongoDB a Supabase, el tema del momento en los círculos de backend. En este artículo te cuento el recorrido: por qué elegí Supabase, los retos que encontré y cómo saqué adelante la migración.
¿Por qué Supabase?
Cuando el backend de mi app empezó a sentirse viejo, busqué algo mejor y Supabase me llamó la atención. Es una herramienta open source parecida a Firebase pero más fácil para empezar. Te da una base de datos PostgreSQL con una API sencilla, funciones en tiempo real y autenticación ya configurada. Para mí, que construyo apps móviles, es perfecto: no quiero pelearme con cosas complicadas de servidor. Puedes tener un proyecto de Supabase funcionando en unos cinco minutos, y la documentación es muy directa, así que no me sentí perdido aunque no sea un profesional del backend.
Pero Supabase no solo es fácil: está creciendo mucho. Todavía no es tan grande como Firebase, pero muchísimos desarrolladores lo usan y la comunidad crece rápido. Tiene todo lo que necesito: una base de datos para guardar cosas, herramientas de autenticación, un sitio para subir archivos e incluso pequeñas funciones que puedo ejecutar sin un servidor completo. Firebase oculta cómo funciona, pero Supabase usa PostgreSQL, una base de datos veterana y fiable en la que confía muchísima gente. Eso significa que puedo cambiar las cosas como quiera y escalarlas más adelante sin quedarme atascado. Además, hay un gran grupo de desarrolladores en internet compartiendo consejos, trucos y soluciones en sitios como GitHub. Sabía que, si me atascaba, podía buscarlo en Google o preguntarle a alguien. Para un programador en solitario como yo, con poco tiempo, Supabase parecía la elección correcta: es simple pero lo bastante sólido para soportar mi app.
La configuración anterior, antes del gran cambio

Antes de saltar a Supabase, hablemos de lo que usaba. Mi app, OSM Tactics, es un juego móvil para Android e iOS donde la gente planifica estrategias tácticas (bastante chulo si te gusta el tema). El backend lo construí yo mismo con NestJS, un framework para Node.js que me gustaba porque funciona con TypeScript y mantiene las cosas organizadas. Se comunicaba con MongoDB, una base de datos donde guardaba toda la información de los usuarios, los datos del juego y otras cosas. Llevaba casi cuatro años con esta configuración.
La última captura de MongoDB antes de la migración, Osm Tactics, también conocida como "Osm Guide"
Pero aquí está el problema: soy un solo tipo con un trabajo a tiempo completo, y mantener vivo este backend me estaba matando. Al principio, NestJS y MongoDB estaban bien; podía con ellos. Pero a medida que se unían más usuarios, todo se complicó. Tenía que dedicar demasiado tiempo a asegurarme de que el servidor no se cayera, a tapar agujeros de seguridad y a mantenerlo lo bastante rápido. La seguridad era lo peor: sé algo de Node.js, pero soy un desarrollador de apps móviles, no un experto en backend. Seguía funcionando, más o menos, pero era como un coche viejo que no paraba de averiarse. No podía seguir parcheándolo para siempre. Necesitaba algo nuevo que no me hiciera querer arrancarme el pelo.
El salto: decidir migrar

Decidir moverlo todo no fue rápido. Me llevó una eternidad porque no dejaba de aplazarlo. OSM Tactics no es una app gigante con montones de funciones, pero 182k usuarios son muchos datos que manejar. Pasar de MongoDB, donde los datos son sueltos y libres, al PostgreSQL de Supabase, donde todo está en tablas ordenadas, sonaba difícil. Tendría que rehacer cómo estaban organizados los datos y asegurarme de no perder nada importante. La combinación de NestJS y MongoDB seguía funcionando, pero tenía la mala sensación de que pronto iba a reventar. Esa preocupación no me dejó en paz hasta que finalmente dije: "Vale, hagámoslo".
Una vez decidido, tuve que planificarlo a fondo. Me senté y pensé cómo convertir mis datos de MongoDB en tablas de Supabase, como si dibujara un mapa de dónde iría cada cosa. El primer paso era sacar todos mis datos de MongoDB de forma segura, así que escribí un pequeño script para volcarlos en archivos JSON. Aquí está el código; es básico, pero cumplió su función:
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();
}
}
}
Este script se conectaba a MongoDB, extraía todos los datos y los guardaba como archivos JSON en mi ordenador. Era como una copia de seguridad: podía experimentar sin perderlo todo si metía la pata. Lo ejecuté para cada colección, revisé los archivos para asegurarme de que se veían bien y me sentí un poco mejor sabiendo que tenía copias. Aun así, me costaba arrancar con el trabajo de verdad: miraba la pantalla, tomaba un sorbo de café y pensaba: "Quizá mañana". Hizo falta un buen empujón para dejar de holgazanear y ponerme en serio, pero una vez que empecé, me entregué por completo.
Migrar usuarios: el rompecabezas de las contraseñas
Aquí es donde la cosa se puso realmente peliaguda: mover 182k usuarios y mantener sus contraseñas funcionando. Los usuarios esperan iniciar sesión con el mismo correo y la misma contraseña después de que actualice la app; así es como debe ser. Pero hacerlo fue una pesadilla. ¿Lo bueno? Supabase usa bcrypt para las contraseñas, igual que MongoDB, así que no tuve que rehacerlas todas ni obligar a los usuarios a elegir otras nuevas. Habría sido una experiencia terrible: la gente odia restablecer contraseñas, y habría perdido a un montón de usuarios.
Lidiar con la exigente tabla de autenticación de Supabase
Supabase tiene una tabla auth.users para los inicios de sesión, y es extremadamente estricta. Tiene un montón de campos que debes rellenar exactamente bien o se vuelve loca; por ejemplo, si pones una cadena vacía en lugar de null, se rompe. Encontré algunos errores con los que se toparon otras personas en este hilo de GitHub, y me metió el miedo en el cuerpo. Tenía que encajar a la perfección. Así se veía un usuario para Supabase (no usaba nada de teléfono, así que esos campos son null; cámbialo si tú sí lo usas):
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),
};
Tenía que acertar con cada campo o Supabase no lo aceptaba. Para mover todos mis usuarios de MongoDB, escribí un script más grande que los obtenía, los convertía a este formato y los guardaba en un archivo CSV. Aquí está ese script; es largo, pero muestra todo el proceso:
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}`);
}
}
}
}
Una vez que tuve ese CSV, creé una tabla de prueba en Supabase que imitaba auth.users. La definición de la tabla real es este largo bloque de SQL que puedes ver en el editor de Supabase en schema auth > users > Definition:
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;
Copié esa definición para mi tabla temporal, subí el CSV a ella y luego usé este script para mover los usuarios a la tabla real auth.users de mil en mil:
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 $$;
Así podía ver cada paso: exportar, transformar, cargar. Tardó más de lo que habría tardado alguna herramienta sofisticada, pero me gustaba saber exactamente qué estaba pasando. Revisaba la tabla temporal después de cargar el CSV, comprobaba al azar algunas filas y luego vigilaba la ejecución del script por lotes para asegurarme de que no se atragantara.
Sin espacio para campos personalizados
La tabla auth.users de Supabase no te deja añadir tus propios campos, y eso me descolocó. En MongoDB, simplemente metía un campo username y listo. Pero Supabase dice que no: te quedas con lo que te da. Pensé en meter datos extra en raw_user_meta_data, que es como una bolsa JSON, pero eso complica las búsquedas después. En su lugar, creé una nueva tabla profiles que se conecta con auth.users mediante el ID de usuario. Guarda cosas como username y locale, y mantiene todo ordenado.
Mira también esta discusión, que puede resultarte útil: https://github.com/orgs/supabase/discussions/3491
Configurar esto supuso más trabajo: tuve que extraer esos campos extra de MongoDB, emparejarlos con los usuarios correctos y cargarlos en la nueva tabla. Escribí otro script para obtener esos datos, los convertí en un CSV y los subí a Supabase después de terminar con la autenticación. Ahora la configuración es mejor porque puedo añadir más campos más adelante sin romper nada, pero alargó la migración, ya que tenía que lidiar con dos tablas en lugar de una.
Migración de los inicios de sesión con Google y Apple

Los inicios de sesión con Google y Apple también fueron un dolor de cabeza. En MongoDB tenía los campos googleId y appleId, y algunos usuarios tenían ambos vinculados a un mismo correo. Supabase los gestiona con campos especiales en raw_user_meta_data, como iss, sub y provider_id.
Así lo configuré:
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");
}
En la app, actualicé los flujos de inicio de sesión para usar las APIs de Supabase. Para Apple:
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,
});
}
Y para Google:
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,
});
}
Funcionó, pero resolver los usuarios que tenían Google y Apple a la vez fue complicado: tuve que elegir uno como ID principal y registrar el otro como adicional. Lo probé muchísimo en la app para asegurarme de que nadie se quedara sin acceso.
Advertencia: posibles problemas al exportar CSV en Supabase A día de hoy (29/03/2025), exportar los datos de una tabla como CSV puede ser poco fiable, así que tenlo en cuenta al comparar datos entre Supabase y tu fuente original.
Generar tipos de TypeScript
Supabase tiene un truco genial: genera los tipos de TypeScript por ti. Ejecutas un comando y te devuelve archivos que le dicen a tu código exactamente cómo es tu base de datos. Para mi app con React Native y Expo, eso fue enorme: no tuve que adivinar qué datos iba a recibir ni escribir mis propios tipos. Redujo muchísimo los bugs, porque TypeScript me gritaba si me equivocaba. Antes pasaba horas arreglando errores tontos; ahora es mucho más rápido.
Ejecuté el comando después de configurar mis tablas, obtuve el archivo de tipos y lo conecté a mi app. De repente, cosas como user.email o profile.username simplemente funcionaban, sin tener que preguntarme si lo había escrito bien. Es algo pequeño, pero hizo que programar la app se pareciera menos a un juego de adivinanzas y más a una victoria.
Dejar que las funciones de la base de datos hagan el trabajo
Supabase te permite escribir pequeñas funciones SQL que se ejecutan en la base de datos, algo muy práctico. En lugar de escribir un montón de código en la app para modificar datos, dejé que la base de datos se encargara.
Aquí tienes una que hice para añadir créditos al perfil de un usuario:
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;
Esto obtiene los créditos del usuario, suma algunos y los vuelve a guardar, todo de una vez. Sin ella, tendría que obtener los créditos, sumarlos en la app y enviarlos de vuelta, lo que significa más código y más oportunidades de equivocarme. También escribí algunas de estas para otras tareas, y mi app se sintió más ágil porque la base de datos hacía el trabajo pesado.
La salvedad del backend
Aquí viene un giro: Supabase no eliminó mi backend por completo. Para usar algunas funciones de administración de la autenticación necesitas la clave service_role, pero no puedes ponerla en la app porque no es seguro. Así que mantuve un pequeño servidor NestJS para encargarse de esas tareas sensibles. No es tan grande como antes, pero está ahí para mantener todo bien protegido. Supabase hace la mayor parte del trabajo, así que sigue siendo mucho más fácil que mi configuración anterior.
Conclusión: valió la pena el esfuerzo

Migrar 182,000 usuarios a Supabase no fue solo un reto técnico: también fue un reto mental. Entre la procrastinación, las noches en vela y muchas dudas, hubo momentos en los que de verdad pensé que podía romperlo todo. Fue un avance lento, lleno de estrés y vacilaciones. Pero dejar atrás la frágil configuración de NestJS + MongoDB y pasar a algo más limpio y fácil de mantener valió totalmente la pena.
Supabase me dio la simplicidad, la flexibilidad y el apoyo de la comunidad que necesitaba como desarrollador en solitario con un trabajo a tiempo completo. Si estás pensando en migrar el backend de tu propia app, que sepas que es totalmente posible. No será rápido ni indoloro, pero con un poco de planificación (y probablemente algunas noches largas), saldrás al otro lado con una configuración en la que realmente puedes confiar.