Blog

Comment j’ai migré 182k utilisateurs vers Supabase

30 mars 2025 15 min de lecture

Le guide complet pour migrer votre backend vers Supabase. Découvrez la migration de la base de données, la configuration de l’authentification et la mise en place des fonctionnalités temps réel.

Comment j’ai migré 182k utilisateurs vers Supabase
SupabaseBackendMigrationBase de donnéesAuthentification

Des mois à repousser l’échéance, puis 182k utilisateurs migrés : comment j’ai enfin passé mon application sur Supabase.

Migrer 182 000 utilisateurs vers un nouveau backend n’a rien d’anodin, surtout quand on est développeur mobile solo avec un emploi à temps plein à côté. Mais j’y suis arrivé. J’ai fait passer mon application, OSM Tactics, d’un montage NestJS + MongoDB devenu inextricable à Supabase, le sujet qui monte en ce moment dans le monde du backend. Dans cet article, je vous raconte le parcours : pourquoi j’ai choisi Supabase, les difficultés que j’ai rencontrées et comment j’ai mené la migration à bien.

Pourquoi Supabase ?

Quand le backend de mon application a commencé à vieillir, j’ai cherché quelque chose de mieux, et Supabase a attiré mon attention. C’est un outil open source qui ressemble à Firebase, mais en plus simple à prendre en main. Il vous donne une base de données PostgreSQL avec une API facile à utiliser, du temps réel et des fonctionnalités de connexion déjà prêtes. Pour moi, qui développe des applications mobiles, c’est parfait : je n’ai pas envie de me battre avec des trucs serveur compliqués. On peut lancer un projet Supabase en cinq minutes environ, et la documentation est très claire, donc je ne me suis pas senti perdu, même si je ne suis pas un pro du backend.

Mais Supabase n’est pas seulement facile, il prend aussi de l’ampleur. Il n’est pas encore aussi énorme que Firebase, mais énormément de développeurs l’utilisent et la communauté grandit vite. Il a tout ce dont j’ai besoin : une base de données pour stocker les données, des outils de connexion, un endroit pour uploader des fichiers et même de petites fonctions que je peux exécuter sans serveur complet. Firebase cache son fonctionnement, alors que Supabase utilise PostgreSQL, une base de données éprouvée et fiable en laquelle énormément de gens ont confiance. Je peux donc modifier les choses comme je veux et faire grandir le projet plus tard sans me retrouver coincé. En plus, il y a une grande communauté de développeurs en ligne qui partagent astuces, conseils et correctifs sur des plateformes comme GitHub. Je savais que si je bloquais, je pourrais chercher sur Google ou demander à quelqu’un. Pour un développeur solo comme moi qui manque de temps, Supabase semblait être le bon choix : simple, mais assez solide pour supporter mon application.

L’ancienne configuration avant le grand changement

Avant de parler du passage à Supabase, voyons ce que j’utilisais. Mon application, OSM Tactics, est un jeu mobile pour Android et iOS dans lequel les gens planifient des stratégies tactiques, plutôt sympa si vous aimez ce genre de choses. Le backend, je l’avais construit moi-même avec NestJS, un framework pour Node.js que j’appréciais parce qu’il fonctionne avec TypeScript et garde le code organisé. Il communiquait avec MongoDB, une base de données où je stockais toutes les informations des utilisateurs, les données de jeu et le reste. Je faisais tourner cette configuration depuis presque quatre ans.

Le dernier aperçu de mongodb avant la migration, Osm Tactics alias « Osm Guide » _Le dernier aperçu de mongodb avant la migration, Osm Tactics alias « Osm Guide » _

Mais voilà le problème : je suis tout seul, avec un emploi à temps plein, et maintenir ce backend en vie m’épuisait. Au début, NestJS et MongoDB allaient très bien, je m’en sortais. Mais à mesure que les utilisateurs arrivaient, tout est devenu compliqué. Je passais beaucoup trop de temps à éviter que le serveur ne plante, à corriger des failles de sécurité et à garder des performances correctes. La sécurité était le pire : je connais un peu Node.js, mais je suis un développeur d’applications mobiles, pas un expert backend. Ça marchait encore, plus ou moins, mais c’était comme une vieille voiture qui tombe sans arrêt en panne. Je ne pouvais pas continuer à la rafistoler éternellement. Il me fallait quelque chose de nouveau qui ne me donne pas envie de m’arracher les cheveux.

Le grand saut : décider de migrer

Décider de tout déplacer n’a pas été rapide : ça m’a pris une éternité, parce que je n’arrêtais pas de repousser. OSM Tactics n’est pas une application géante bourrée de fonctionnalités, mais 182k utilisateurs, ça fait beaucoup de données à gérer. Passer de MongoDB, où les données sont libres et peu structurées, au PostgreSQL de Supabase, où tout est rangé dans des tables bien nettes, semblait difficile. Je devais revoir l’organisation des données et m’assurer de ne rien perdre d’important. Le vieux duo NestJS et MongoDB tournait encore, mais j’avais le mauvais pressentiment qu’il allait bientôt exploser. Cette inquiétude ne me lâchait pas, jusqu’au jour où je me suis dit : « Bon, allons-y. »

Une fois la décision prise, j’ai dû tout planifier sérieusement. Je me suis posé et j’ai réfléchi à la façon de transformer mes données MongoDB en tables Supabase, un peu comme dessiner une carte de l’endroit où chaque chose irait. La première étape consistait à sortir toutes mes données de MongoDB en toute sécurité, alors j’ai écrit un petit script pour les exporter dans des fichiers JSON. Voici ce code, basique mais efficace :

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();
    }
  }
}

Ce script se connectait à MongoDB, récupérait toutes les données et les enregistrait sous forme de fichiers JSON sur mon ordinateur. C’était comme une sauvegarde : je pouvais expérimenter sans tout perdre si je faisais une bêtise. Je l’ai lancé pour chaque collection, j’ai vérifié que les fichiers avaient l’air corrects et je me suis senti un peu mieux en sachant que j’avais des copies. Malgré tout, j’ai traîné des pieds avant de commencer le vrai travail : je fixais l’écran, je sirotais mon café et je me disais « Peut-être demain ». Il m’a fallu un gros effort pour arrêter de procrastiner et m’y mettre vraiment, mais une fois lancé, je m’y suis consacré à fond.

Migrer les utilisateurs : le casse-tête des mots de passe

C’est là que ça s’est vraiment corsé : déplacer 182k utilisateurs en gardant leurs mots de passe fonctionnels. Les utilisateurs s’attendent à se connecter avec le même e-mail et le même mot de passe après la mise à jour de l’application, et c’est normal. Mais le faire a été un cauchemar. La bonne nouvelle ? Supabase utilise bcrypt pour les mots de passe, comme MongoDB, donc je n’ai pas eu à tous les refaire ni à demander aux utilisateurs d’en choisir de nouveaux. Ç’aurait été une expérience terrible : les gens détestent réinitialiser leur mot de passe, et j’en aurais perdu un bon nombre.

Composer avec la table d’authentification très exigeante de Supabase

Supabase a une table auth.users pour les connexions, et elle est extrêmement stricte. Elle contient toute une série de champs qu’il faut remplir exactement comme il faut, sinon elle panique : par exemple, si vous mettez une chaîne vide au lieu de null, ça casse. J’ai trouvé des erreurs rencontrées par d’autres personnes dans ce fil GitHub, et ça m’a remis les idées en place. Je devais respecter le format à la perfection. Voici à quoi ressemblait un utilisateur pour Supabase (je n’utilisais pas le téléphone, donc ces champs sont à null, changez-les si c’est votre cas) :

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),
};

Chaque champ devait être correct, sinon Supabase refusait. Pour déplacer tous mes utilisateurs MongoDB, j’ai écrit un script plus conséquent qui les récupérait, les convertissait dans ce format et les enregistrait dans un fichier CSV. Voici ce script, il est long mais il montre tout le processus :

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}`);
      }
    }
  }
}

Une fois ce CSV obtenu, j’ai créé dans Supabase une table temporaire qui imitait auth.users. La configuration de la vraie table est une longue requête SQL que vous pouvez voir dans l’éditeur de Supabase, sous 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;

J’ai copié cette configuration pour ma table temporaire, j’y ai importé le CSV, puis j’ai utilisé ce script pour déplacer les utilisateurs dans la vraie table auth.users par lots de mille :

    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 $$;

De cette façon, je pouvais suivre chaque étape : export, transformation, chargement. Ça a pris plus de temps qu’avec un outil sophistiqué, mais j’aimais savoir exactement ce qui se passait. Je vérifiais la table temporaire après avoir chargé le CSV, je contrôlais quelques lignes au hasard, puis je surveillais le script par lots pour m’assurer qu’il ne plantait pas.

Pas de place pour les champs personnalisés

La table auth.users de Supabase ne permet pas d’ajouter ses propres champs, ce qui m’a déstabilisé. Dans MongoDB, j’ajoutais simplement un champ username, sans problème. Mais Supabase dit non : vous devez vous contenter de ce qu’il fournit. J’ai pensé à mettre les données supplémentaires dans raw_user_meta_data, une sorte de sac JSON, mais ce n’est pas pratique pour faire des recherches ensuite. J’ai plutôt créé une nouvelle table profiles reliée à auth.users par l’ID utilisateur. Elle contient des choses comme username et locale, et tout reste bien rangé.

Voir aussi cette discussion, qui peut être utile : https://github.com/orgs/supabase/discussions/3491

Mettre ça en place a demandé plus de travail : je devais extraire ces champs supplémentaires de MongoDB, les associer aux bons utilisateurs et les charger dans la nouvelle table. J’ai écrit un autre script pour récupérer ces données, je les ai converties en CSV et je les ai importées dans Supabase une fois la partie authentification terminée. La configuration est meilleure aujourd’hui, parce que je peux ajouter des champs plus tard sans rien casser, mais la migration a pris plus de temps, puisque j’avais deux tables à gérer au lieu d’une.

Migration des connexions Google/Apple

Les connexions Google et Apple ont aussi été pénibles. Dans MongoDB, j’avais des champs googleId et appleId, et certains utilisateurs avaient les deux associés à un même e-mail. Supabase gère ça avec des champs spéciaux dans raw_user_meta_data, comme iss, sub et provider_id.

Voici comment je l’ai 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");
}

Dans l’application, j’ai mis à jour les parcours de connexion pour utiliser les API de Supabase. Pour 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,
  });
}

Et pour 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,
  });
}

Ça a fonctionné, mais gérer les utilisateurs qui avaient à la fois Google et Apple était délicat : je devais en choisir un comme identifiant principal et ajouter l’autre comme identifiant secondaire. J’ai beaucoup testé dans l’application pour m’assurer que personne ne se retrouvait bloqué.

Attention : problèmes possibles avec l’export CSV dans Supabase À ce jour (29/03/2025), l’export des données d’une table en CSV peut être peu fiable, gardez-le en tête quand vous comparez les données entre Supabase et votre source d’origine.

Générer les types TypeScript

Supabase a une astuce géniale : il génère les types TypeScript pour vous. Vous lancez une seule commande, et elle produit des fichiers qui décrivent exactement à votre code à quoi ressemble votre base de données. Pour mon application React Native et Expo, c’était énorme : je n’avais plus à deviner quelles données j’allais recevoir ni à écrire mes propres types. Ça a considérablement réduit les bugs, parce que TypeScript me signalait chaque erreur. Avant, je passais des heures à corriger des erreurs bêtes ; maintenant, c’est bien plus rapide.

J’ai lancé la commande après avoir configuré mes tables, j’ai récupéré le fichier de types et je l’ai branché dans mon application. Du jour au lendemain, des choses comme user.email ou profile.username fonctionnaient directement, sans plus me demander si je les avais bien orthographiées. C’est un détail, mais coder l’application ressemblait moins à un jeu de devinettes et davantage à une victoire.

Laisser les fonctions de base de données faire le travail

Supabase permet d’écrire de petites fonctions SQL qui s’exécutent dans la base de données, ce qui est très pratique. Au lieu d’écrire beaucoup de code côté application pour modifier les données, je laisse la base de données s’en charger.

Voici une fonction que j’ai créée pour ajouter des crédits au profil d’un utilisateur :

    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;

Elle récupère les crédits de l’utilisateur, en ajoute et enregistre le résultat, le tout en une seule opération. Sans elle, je devrais récupérer les crédits, les additionner dans l’application et les renvoyer, ce qui fait plus de code et plus de risques d’erreur. J’en ai écrit quelques autres pour d’autres tâches, et mon application est devenue plus réactive, puisque la base de données faisait le gros du travail.

La limite côté backend

Petite surprise : Supabase ne m’a pas complètement débarrassé de mon backend. Pour utiliser certaines fonctions d’authentification réservées aux administrateurs, il faut cette clé service_role, mais on ne peut pas la mettre dans l’application, ce n’est pas sûr. J’ai donc gardé un petit serveur NestJS pour gérer ces tâches sensibles. Il est beaucoup plus petit qu’avant, mais il est là pour tout garder sous clé. Supabase fait l’essentiel du travail, donc c’est quand même bien plus simple que mon ancienne configuration.

Conclusion : ça valait la peine

Migrer 182 000 utilisateurs vers Supabase n’a pas seulement été un défi technique, ça a aussi été un défi mental. Entre la procrastination, les nuits tardives et les nombreuses remises en question, il y a eu des moments où j’ai vraiment cru que j’allais tout casser. C’était un travail lent et laborieux, plein de stress et d’hésitations. Mais laisser derrière moi la configuration fragile NestJS + MongoDB pour passer à quelque chose de plus propre et plus maintenable en valait largement la peine.

Supabase m’a apporté la simplicité, la flexibilité et le soutien de la communauté dont j’avais besoin en tant que développeur solo avec un emploi à temps plein. Si vous envisagez de migrer le backend de votre propre application, sachez que c’est tout à fait faisable. Ce ne sera ni rapide ni indolore, mais avec un peu de planification (et probablement quelques longues nuits), vous arriverez au bout avec une configuration en laquelle vous pourrez vraiment avoir confiance.