Van maandenlang uitstellen tot het migreren van 182k gebruikers: zo heb ik mijn app eindelijk naar Supabase verhuisd.
182.000 gebruikers naar een nieuwe backend migreren is geen kleinigheid, zeker niet als je in je eentje mobiele apps bouwt naast een fulltime baan. Maar het is me gelukt. Ik heb mijn app, OSM Tactics, overgezet van een rommelige NestJS + MongoDB-setup naar Supabase, op dit moment hét gespreksonderwerp in backendkringen. In dit artikel neem ik je mee door het hele traject: waarom ik voor Supabase koos, tegen welke problemen ik aanliep en hoe ik de migratie voor elkaar kreeg.
Waarom Supabase?
Toen de backend van mijn app oud begon te voelen, ging ik op zoek naar iets beters, en Supabase viel me op. Het is een open source-ding dat lijkt op Firebase, maar waar je makkelijker mee begint. Je krijgt een PostgreSQL-database met een eenvoudige API, realtime functies en inlogfuncties, allemaal al ingericht. Voor mij, iemand die mobiele apps bouwt, is dat perfect: ik wil niet rommelen met ingewikkelde serverzaken. Je hebt een Supabase-project in zo'n vijf minuten draaien, en de documentatie is heel duidelijk, dus ik voelde me niet verloren, ook al ben ik geen backendprofessional.
Supabase is trouwens niet alleen makkelijk, het wordt ook groot. Het is nog niet zo enorm als Firebase, maar heel veel developers gebruiken het en de community groeit snel. Het heeft alles wat ik nodig heb: een database om dingen op te slaan, tools om in te loggen, een plek om bestanden te uploaden en zelfs kleine functies die ik kan draaien zonder volledige server. Firebase verbergt hoe het werkt, maar Supabase gebruikt PostgreSQL, een oude, betrouwbare database waar heel veel mensen op vertrouwen. Daardoor kan ik dingen aanpassen zoals ik wil en later opschalen zonder vast te lopen. Bovendien is er online een grote groep developers die tips, trucs en oplossingen deelt op plekken als GitHub. Ik wist dat ik, als ik vastliep, het kon googelen of iemand kon vragen. Voor een solo-developer zoals ik, die weinig tijd heeft, voelde Supabase als de juiste keuze: het is eenvoudig, maar sterk genoeg om mijn app aan te kunnen.
De oude setup vóór de grote overstap

Voordat ik overstapte op Supabase, eerst even waar ik mee werkte. Mijn app, OSM Tactics, is een mobiele game voor Android en iOS waarin mensen tactische strategieën uitwerken. Best leuk als je daarvan houdt. De backend had ik zelf gebouwd met NestJS, een framework voor Node.js dat ik fijn vond omdat het met TypeScript werkt en alles netjes georganiseerd houdt. Het praatte met MongoDB, een database waarin ik alle gebruikersinfo, gamedata en andere dingen bewaarde. Ik draaide deze setup al bijna vier jaar.
_De laatste snapshot van MongoDB vóór de migratie, Osm Tactics oftewel “Osm Guide” _
Maar hier zit het probleem: ik ben maar één persoon met een fulltime baan, en deze backend in leven houden sloopte me. In het begin waren NestJS en MongoDB prima, die kon ik aan. Maar naarmate er meer gebruikers bijkwamen, werd het een zooi. Ik moest veel te veel tijd steken in zorgen dat de server niet crashte, beveiligingslekken dichten en alles snel genoeg houden. Beveiliging was het ergste: ik ken wel wat Node.js, maar ik ben een mobiele-appontwikkelaar, geen backendexpert. Het werkte nog, min of meer, maar het was als een oude auto die steeds kapotging. Ik kon het niet eeuwig blijven oplappen. Ik had iets nieuws nodig waar ik niet gek van werd.
De sprong: besluiten om te migreren

Besluiten om alles te verhuizen ging niet snel. Het duurde eindeloos omdat ik het steeds uitstelde. OSM Tactics is geen gigantische app met eindeloos veel features, maar 182k gebruikers is veel data om mee te werken. Van MongoDB, waar data los en vrij is, naar de PostgreSQL van Supabase, waar alles in nette tabellen staat: dat klonk lastig. Ik zou de opbouw van de data opnieuw moeten doen en ervoor moeten zorgen dat ik niets belangrijks kwijtraakte. De oude combinatie van NestJS en MongoDB draaide nog, maar ik had het nare gevoel dat het binnenkort zou ontploffen. Die zorg bleef aan me knagen, tot ik uiteindelijk zei: “Oké, we gaan het doen.”
Toen ik eenmaal besloten had, moest ik het flink plannen. Ik ging zitten en bedacht hoe ik mijn MongoDB-data in Supabase-tabellen kon omzetten, een soort kaart tekenen van waar alles terecht zou komen. Stap één was al mijn data veilig uit MongoDB halen, dus schreef ik een klein script dat alles in JSON-bestanden dumpte. Hier is die code. Simpel, maar het deed zijn werk:
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();
}
}
}
Dit script maakte verbinding met MongoDB, haalde alle data eruit en sloeg het op als JSON-bestanden op mijn computer. Het was een soort back-up: ik kon dingen uitproberen zonder alles kwijt te raken als ik het verknalde. Ik draaide het voor elke collection, controleerde of de bestanden er goed uitzagen en voelde me iets beter nu ik kopieën had. Toch bleef ik treuzelen met het echte werk. Ik staarde naar het scherm, nam een slok koffie en dacht: “Misschien morgen.” Er was een flinke duw nodig om op te houden met lanterfanten en er echt in te duiken, maar toen ik dat eenmaal deed, ging ik er helemaal voor.
Gebruikers migreren: de wachtwoordpuzzel
Hier werd het pas echt lastig: 182k gebruikers verhuizen en hun wachtwoorden laten blijven werken. Gebruikers verwachten na een update van de app in te loggen met hetzelfde e-mailadres en wachtwoord. Zo hoort het gewoon. Maar het uitvoeren was een nachtmerrie. Het mooie? Supabase gebruikt bcrypt voor wachtwoorden, net als MongoDB, dus ik hoefde ze niet allemaal opnieuw te doen of gebruikers nieuwe te laten kiezen. Dat zou een vreselijke ervaring zijn geweest: mensen haten het om hun wachtwoord te resetten, en ik zou er een hoop kwijtraken.
Omgaan met de kieskeurige auth-tabel van Supabase
Supabase heeft een tabel auth.users voor logins, en die is superstreng. Er zitten allerlei velden in die je precies goed moet invullen, anders slaat hij op tilt. Als je bijvoorbeeld een lege string zet in plaats van null, gaat het mis. Ik vond een paar fouten waar andere mensen tegenaan liepen in deze GitHub-thread, en dat schrok me flink af. Ik moest het perfect laten aansluiten. Zo zag een gebruiker eruit voor Supabase (ik gebruikte geen telefoonvelden, dus die zijn null; pas het aan als jij dat wel doet):
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),
};
Ik moest elk veld precies goed hebben, anders accepteerde Supabase het niet. Om al mijn MongoDB-gebruikers te verhuizen, schreef ik een groter script dat ze ophaalde, in dit formaat omzette en als CSV-bestand opsloeg. Hier is dat script. Het is lang, maar het laat het hele proces zien:
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}`);
}
}
}
}
Toen ik die CSV had, maakte ik in Supabase een nep-tabel die op auth.users leek. De opbouw van de echte tabel is een lang SQL-stuk dat je in de editor van Supabase kunt bekijken onder 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;
Ik kopieerde die opbouw voor mijn tijdelijke tabel, uploadde de CSV erin en gebruikte daarna dit script om gebruikers per duizend tegelijk naar de echte tabel auth.users te verplaatsen:
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 $$;
Zo kon ik elke stap zien: exporteren, omzetten, laden. Het duurde langer dan met een of andere chique tool misschien het geval was geweest, maar ik vond het fijn om precies te weten wat er gebeurde. Na het laden van de CSV controleerde ik de tijdelijke tabel, keek ik steekproefsgewijs naar een paar rijen en hield ik daarna het batchscript in de gaten om zeker te zijn dat het niet vastliep.
Geen ruimte voor eigen velden
De tabel auth.users van Supabase laat je geen eigen velden toevoegen, en dat bracht me van mijn stuk. In MongoDB stopte ik er gewoon een veld username in, niks aan de hand. Maar Supabase zegt nee: je zit vast aan wat het je geeft. Ik dacht erover extra dingen in raw_user_meta_data te proppen, een soort JSON-zak, maar dat wordt een rommeltje als je later wilt zoeken. In plaats daarvan maakte ik een nieuwe tabel profiles die via het gebruikers-ID aan auth.users gekoppeld is. Daarin staan dingen als username en locale, zodat alles netjes blijft.
Bekijk ook deze discussie, misschien heb je er iets aan: https://github.com/orgs/supabase/discussions/3491
Dit inrichten betekende meer werk: ik moest die extra velden uit MongoDB halen, ze aan de juiste gebruikers koppelen en ze in de nieuwe tabel laden. Ik schreef nog een script om die data op te halen, zette het om naar een CSV en uploadde het naar Supabase nadat de auth-data klaar was. Het is nu een betere setup, want ik kan later meer velden toevoegen zonder iets kapot te maken, maar de migratie duurde er wel langer door omdat ik met twee tabellen te maken had in plaats van één.
Migratie van inloggen met Google en Apple

Inloggen met Google en Apple was ook een gedoe. In MongoDB had ik de velden googleId en appleId, en sommige gebruikers hadden ze allebei aan één e-mailadres gekoppeld. Supabase regelt dit met speciale velden in raw_user_meta_data, zoals iss, sub en provider_id.
Zo heb ik het ingericht:
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");
}
In de app heb ik de inlogflows aangepast om de API's van Supabase te gebruiken. Voor 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,
});
}
En voor 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,
});
}
Het werkte, maar uitzoeken wat ik moest met gebruikers die zowel Google als Apple hadden, was lastig. Ik moest er één kiezen als hoofd-ID en de andere als extra vermelden. Ik heb het vaak getest in de app om zeker te weten dat niemand werd buitengesloten.
Let op: mogelijke problemen met CSV-export in Supabase Op dit moment (29/03/2025) kan het exporteren van tabeldata als CSV onbetrouwbaar zijn. Houd daar dus rekening mee als je data tussen Supabase en je oorspronkelijke bron vergelijkt.
TypeScript-types genereren
Supabase heeft een geweldige truc: het maakt TypeScript-types voor je. Je draait één commando en het spuugt bestanden uit die je code precies vertellen hoe je database eruitziet. Voor mijn React Native- en Expo-app was dat enorm: ik hoefde niet te raden welke data ik zou krijgen of zelf types te schrijven. Het scheelde flink in bugs, omdat TypeScript tegen me schreeuwde als ik iets verkeerd deed. Vroeger was ik uren bezig met domme fouten fixen; nu gaat het veel sneller.
Ik draaide het commando nadat ik mijn tabellen had ingericht, kreeg het typesbestand en plugde het in mijn app. Ineens werkten dingen als user.email of profile.username gewoon, zonder dat ik me nog afvroeg of ik het goed had gespeld. Het is iets kleins, maar het zorgde ervoor dat het bouwen van de app minder als gokken voelde en meer als winst.
Databasefuncties het werk laten doen
Met Supabase kun je kleine SQL-functies schrijven die in de database draaien, en dat is superhandig. In plaats van een hoop code in de app te schrijven om dingen aan te passen, liet ik de database het afhandelen.
Hier is er een die ik maakte om credits aan het profiel van een gebruiker toe te voegen:
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;
Deze haalt de credits van de gebruiker op, telt er wat bij op en slaat het weer op, allemaal in één keer. Zonder deze functie zou ik de credits moeten ophalen, ze in de app optellen en weer terugsturen, wat meer code is en meer kans geeft om het te verpesten. Ik schreef er ook een paar voor andere taken, en daardoor voelde mijn app vlotter aan, omdat de database het zware werk deed.
De kanttekening over de backend
Nu komt er een wending: Supabase heeft mijn backend niet helemaal overbodig gemaakt. Om bepaalde admin-functies rond inloggen te gebruiken, heb je deze service_role key nodig, maar die kun je niet in de app zetten, want dat is niet veilig. Daarom hield ik een kleine NestJS-server over om die geheime taken af te handelen. Hij is niet zo groot als vroeger, maar hij is er om alles goed afgeschermd te houden. Supabase doet het meeste werk, dus het is nog steeds veel makkelijker dan mijn oude setup.
Conclusie: de moeite waard

182.000 gebruikers naar Supabase migreren was niet alleen een technische uitdaging, het was ook een mentale. Tussen het uitstellen, de late avonden en het vele twijfelen door waren er momenten waarop ik echt dacht dat ik alles kapot zou maken. Het was een langzaam gezwoeg, vol stress en aarzeling. Maar de wankele NestJS + MongoDB-setup achter me laten en overstappen op iets wat schoner en beter te onderhouden is, was het absoluut waard.
Supabase gaf me de eenvoud, flexibiliteit en steun van de community die ik nodig had als solo-developer met een fulltime baan. Als je overweegt de backend van je eigen app te migreren: weet dat het prima te doen is. Het gaat niet snel en niet pijnloos, maar met een beetje planning (en waarschijnlijk een paar lange avonden) kom je er aan de andere kant uit met een setup waar je echt op kunt vertrouwen.