Blog

Jak przeniosłem 182 tys. użytkowników do Supabase

30 marca 2025 15 min czytania

Kompletny przewodnik po migracji backendu do Supabase. Migracja bazy danych, konfiguracja uwierzytelniania i wdrożenie funkcji czasu rzeczywistego.

Jak przeniosłem 182 tys. użytkowników do Supabase
SupabaseBackendMigracjaBaza danychUwierzytelnianie

Od miesięcy odkładania do migracji 182 tys. użytkowników: jak w końcu przeniosłem swoją aplikację do Supabase.

Migracja 182 000 użytkowników na nowy backend to nie byle co, zwłaszcza gdy jesteś jedynym mobile devem w projekcie i równolegle pracujesz na pełen etat. Ale udało mi się. Przeniosłem swoją aplikację, OSM Tactics, z zagmatwanego setupu NestJS + MongoDB na Supabase, o którym w świecie backendu mówi się teraz najwięcej. W tym artykule przeprowadzę cię przez całą drogę: dlaczego wybrałem Supabase, z jakimi problemami się zmierzyłem i jak przeprowadziłem migrację.

Dlaczego Supabase?

Kiedy backend mojej aplikacji zaczął się starzeć, rozejrzałem się za czymś lepszym i wpadł mi w oko Supabase. To open source'owe narzędzie, trochę jak Firebase, ale łatwiej w nie wskoczyć. Dostajesz bazę PostgreSQL z prostym API, funkcje real-time i gotowe logowanie. Dla mnie, gościa, który robi aplikacje mobilne, to ideał: nie chcę grzebać w skomplikowanych serwerowych sprawach. Projekt w Supabase da się postawić w jakieś pięć minut, a dokumentacja jest bardzo przystępna, więc nie czułem się zagubiony, mimo że nie jestem specem od backendu.

Supabase jest nie tylko prosty, ale też szybko rośnie. Nie jest jeszcze tak duży jak Firebase, ale korzysta z niego mnóstwo developerów, a społeczność rośnie w szybkim tempie. Ma wszystko, czego potrzebuję: bazę danych, narzędzia do logowania, miejsce na upload plików, a nawet małe funkcje, które mogę uruchamiać bez pełnego serwera. Firebase ukrywa, jak działa w środku, a Supabase stoi na PostgreSQL, starej i niezawodnej bazie, której ufa masa ludzi. To znaczy, że mogę zmieniać rzeczy po swojemu i skalować się później, bez utknięcia w ślepym zaułku. Do tego jest duża grupa developerów, którzy dzielą się w sieci poradami, trikami i poprawkami, na przykład na GitHubie. Wiedziałem, że jak utknę, to wygoogluję problem albo kogoś zapytam. Dla kogoś, kto koduje sam i ma mało czasu, Supabase wydał się właściwym wyborem: prosty, ale wystarczająco mocny, żeby udźwignąć moją aplikację.

Stary setup przed wielką zmianą

Zanim przeskoczyłem na Supabase, opowiem, czego używałem wcześniej. Moja aplikacja, OSM Tactics, to mobilna gra na Androida i iOS, w której ludzie planują strategie taktyczne (całkiem fajna rzecz, jeśli kogoś to kręci). Backend zbudowałem sam w NestJS, frameworku dla Node.js, który lubiłem, bo działa z TypeScriptem i trzyma porządek w kodzie. Gadał z MongoDB, bazą, w której trzymałem wszystkie dane użytkowników, dane gry i inne drobiazgi. Ten setup działał u mnie prawie cztery lata.

Ostatni snapshot MongoDB przed migracją, Osm Tactics, czyli „Osm Guide”Ostatni snapshot MongoDB przed migracją, Osm Tactics, czyli „Osm Guide”

Ale tu jest problem: jestem jednym człowiekiem z pracą na pełen etat, a utrzymywanie tego backendu przy życiu mnie wykańczało. Na początku NestJS i MongoDB były w porządku, dawałem sobie z nimi radę. Ale im więcej użytkowników dochodziło, tym większy robił się bałagan. Spędzałem stanowczo za dużo czasu na pilnowaniu, żeby serwer się nie wywalił, łataniu dziur w bezpieczeństwie i utrzymywaniu odpowiedniej wydajności. Bezpieczeństwo było najgorsze: znam trochę Node.js, ale jestem od aplikacji mobilnych, nie ekspertem od backendu. To wciąż jakoś działało, ale przypominało stary samochód, który ciągle się psuje. Nie mogłem go łatać w nieskończoność. Potrzebowałem czegoś nowego, przy czym nie miałbym ochoty wyrywać sobie włosów z głowy.

Skok: decyzja o migracji

Decyzja o przeniesieniu wszystkiego nie zapadła szybko. Trwało to wieki, bo ciągle ją odkładałem. OSM Tactics nie jest jakąś gigantyczną aplikacją z masą funkcji, ale 182 tys. użytkowników to sporo danych do ogarnięcia. Przejście z MongoDB, gdzie dane są luźne i swobodne, na PostgreSQL w Supabase, gdzie wszystko leży w schludnych tabelach, brzmiało ciężko. Musiałbym przebudować strukturę danych i upewnić się, że nie stracę niczego ważnego. Stary duet NestJS i MongoDB wciąż działał, ale miałem złe przeczucie, że niedługo coś wybuchnie. Ten niepokój nie dawał mi spokoju, aż w końcu powiedziałem: „Dobra, robimy to”.

Kiedy już się zdecydowałem, musiałem porządnie wszystko zaplanować. Usiadłem i rozpisałem, jak zamienić moje dane z MongoDB na tabele w Supabase, coś jak rysowanie mapy, gdzie co ma trafić. Pierwszym krokiem było bezpieczne wyciągnięcie wszystkich danych z MongoDB, więc napisałem mały skrypt, który zrzucał je do plików JSON. Oto ten kod, prosty, ale zrobił robotę:

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

Ten skrypt łączył się z MongoDB, wyciągał wszystkie dane i zapisywał je jako pliki JSON na moim komputerze. To była taka kopia zapasowa: mogłem eksperymentować bez ryzyka, że stracę wszystko, jeśli coś zepsuję. Uruchomiłem go dla każdej kolekcji, przejrzałem pliki, żeby sprawdzić, czy wyglądają dobrze, i poczułem się trochę lepiej, wiedząc, że mam kopie. Mimo to zwlekałem z rozpoczęciem właściwej pracy. Gapiłem się w ekran, popijałem kawę i myślałem: „Może jutro”. Potrzebowałem mocnego kopniaka, żeby przestać się obijać i naprawdę się za to zabrać, ale jak już zacząłem, wszedłem w to na całego.

Migracja użytkowników: zagadka haseł

Tu zrobiło się naprawdę grubo: przenieść 182 tys. użytkowników i zachować działające hasła. Użytkownicy oczekują, że po aktualizacji aplikacji zalogują się tym samym mailem i hasłem, i tak właśnie powinno być. Ale zrobienie tego to był koszmar. Dobra wiadomość? Supabase używa bcrypt do haseł, tak samo jak MongoDB, więc nie musiałem ich wszystkich przerabiać ani kazać użytkownikom wymyślać nowych. To byłoby fatalne doświadczenie: ludzie nienawidzą resetowania haseł, a ja straciłbym sporą część z nich.

Wybredna tabela auth w Supabase

Supabase ma tabelę auth.users do logowania i jest ona bardzo restrykcyjna. Ma mnóstwo pól, które trzeba wypełnić dokładnie tak, jak trzeba, inaczej wariuje. Na przykład jeśli wstawisz pusty string zamiast null, wszystko się sypie. Znalazłem błędy, na które trafili inni, w tym wątku na GitHubie, i to mnie skutecznie postraszyło. Musiałem trafić idealnie. Tak wyglądał użytkownik w formacie dla Supabase (nie używałem niczego związanego z telefonem, więc te pola są null, zmień to, jeśli ty używasz):

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

Musiałem ustawić poprawnie każde pojedyncze pole, inaczej Supabase by tego nie przyjął. Żeby przenieść wszystkich użytkowników z MongoDB, napisałem większy skrypt, który ich pobierał, przerabiał na ten format i zapisywał jako plik CSV. Oto ten skrypt, długi, ale pokazuje cały proces:

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

Kiedy miałem już CSV, stworzyłem w Supabase zastępczą tabelę, która wyglądała jak auth.users. Definicja prawdziwej tabeli to długi kawałek SQL, który znajdziesz w edytorze Supabase pod 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;

Skopiowałem tę definicję dla swojej tymczasowej tabeli, wgrałem do niej CSV, a potem tym skryptem przenosiłem użytkowników do prawdziwej tabeli auth.users po tysiąc naraz:

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

Dzięki temu widziałem każdy krok: eksport, przekształcenie, ładowanie. Trwało to dłużej niż z jakimś wymyślnym narzędziem, ale lubiłem wiedzieć dokładnie, co się dzieje. Po załadowaniu CSV sprawdzałem tymczasową tabelę, wyrywkowo przeglądałem kilka wierszy, a potem obserwowałem, jak leci skrypt z batchami, żeby upewnić się, że się nie zadławi.

Nie ma miejsca na własne pola

Tabela auth.users w Supabase nie pozwala dodawać własnych pól, co mnie zbiło z tropu. W MongoDB po prostu wrzucałem tam pole username i nie było sprawy. Ale Supabase mówi nie: musisz się zadowolić tym, co dostajesz. Myślałem, żeby upchnąć dodatkowe rzeczy w raw_user_meta_data, czyli takim worku na JSON, ale to robi bałagan przy późniejszym wyszukiwaniu. Zamiast tego stworzyłem nową tabelę profiles, która łączy się z auth.users przez ID użytkownika. Trzyma rzeczy takie jak username i locale, więc wszystko jest uporządkowane.

Zobacz też tę dyskusję, może się przydać: https://github.com/orgs/supabase/discussions/3491

Ustawienie tego oznaczało więcej pracy: musiałem wyciągnąć te dodatkowe pola z MongoDB, dopasować je do właściwych użytkowników i załadować do nowej tabeli. Napisałem kolejny skrypt, który pobierał te dane, zamieniał je na CSV, i wgrałem go do Supabase po zakończeniu części z auth. Teraz setup jest lepszy, bo mogę później dodawać kolejne pola, niczego nie psując, ale migracja trwała przez to dłużej, bo miałem do ogarnięcia dwie tabele zamiast jednej.

Migracja logowania przez Google i Apple

Logowanie przez Google i Apple też było utrapieniem. W MongoDB miałem pola googleId i appleId, a część użytkowników miała oba powiązane z jednym mailem. Supabase obsługuje to przez specjalne pola w raw_user_meta_data, takie jak iss, sub i provider_id.

Tak to ustawiłem:

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

W aplikacji zaktualizowałem flow logowania tak, żeby korzystały z API Supabase. Dla 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,
  });
}

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

Działało, ale ogarnięcie użytkowników, którzy mieli i Google, i Apple, było podchwytliwe. Musiałem wybrać jedno jako główne ID, a drugie wpisać jako dodatkowe. Sporo to testowałem w aplikacji, żeby nikt nie został odcięty od konta.

Uwaga: możliwe problemy z eksportem CSV w Supabase Na dzień dzisiejszy (29/03/2025) eksport danych z tabeli do CSV może być zawodny, więc miej to na uwadze, porównując dane między Supabase a oryginalnym źródłem.

Generowanie typów TypeScript

Supabase ma świetny trik: sam generuje dla ciebie typy TypeScript. Uruchamiasz jedną komendę i dostajesz pliki, które mówią twojemu kodowi dokładnie, jak wygląda baza danych. W mojej aplikacji w React Native i Expo to była ogromna rzecz: nie musiałem zgadywać, jakie dane dostanę, ani pisać własnych typów. Mocno ograniczyło to liczbę bugów, bo TypeScript krzyczał na mnie, kiedy coś pomieszałem. Wcześniej spędzałem godziny na poprawianiu głupich błędów, teraz idzie to dużo szybciej.

Uruchomiłem komendę po ustawieniu tabel, dostałem plik z typami i podpiąłem go w aplikacji. Nagle takie rzeczy jak user.email czy profile.username po prostu działały, bez zastanawiania się, czy dobrze to napisałem. Drobiazg, ale dzięki niemu kodowanie aplikacji przestało przypominać zgadywankę, a zaczęło dawać poczucie wygranej.

Niech funkcje bazy danych odwalą robotę

Supabase pozwala pisać małe funkcje SQL, które działają w bazie danych, co jest bardzo wygodne. Zamiast pisać sporo kodu po stronie aplikacji, żeby coś zmienić, oddałem to bazie.

Oto funkcja, którą napisałem do dodawania kredytów do profilu użytkownika:

    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;

Pobiera kredyty użytkownika, dodaje do nich wartość i zapisuje z powrotem, wszystko za jednym razem. Bez niej musiałbym pobrać kredyty, dodać je w aplikacji i odesłać z powrotem, co oznacza więcej kodu i więcej okazji do pomyłki. Napisałem kilka takich funkcji do innych zadań i aplikacja zaczęła działać żwawiej, bo ciężką robotę wykonywała baza.

Haczyk z backendem

Tu jest zwrot akcji: Supabase nie pozbył się mojego backendu całkowicie. Do niektórych administracyjnych operacji na logowaniu potrzebny jest klucz service_role, ale nie możesz go umieścić w aplikacji, bo to nie jest bezpieczne. Dlatego zostawiłem mały serwer NestJS do obsługi tych tajnych zadań. Nie jest tak duży jak wcześniej, ale jest, żeby trzymać wszystko pod kluczem. Większość roboty robi Supabase, więc i tak jest dużo łatwiej niż w moim starym setupie.

Podsumowanie: warto było się namęczyć

Migracja 182 000 użytkowników do Supabase to było nie tylko wyzwanie techniczne, ale też psychiczne. Między prokrastynacją, nocnym siedzeniem i ciągłym podważaniem własnych decyzji były momenty, w których naprawdę myślałem, że wszystko zepsuję. To była powolna harówka, pełna stresu i wahania. Ale porzucenie kruchego setupu NestJS + MongoDB i przejście na coś czystszego i łatwiejszego w utrzymaniu było absolutnie tego warte.

Supabase dał mi prostotę, elastyczność i wsparcie społeczności, których potrzebowałem jako solo dev z pracą na pełen etat. Jeśli myślisz o migracji backendu własnej aplikacji, wiedz, że to jak najbardziej wykonalne. Nie będzie szybko ani bezboleśnie, ale z odrobiną planowania (i pewnie kilkoma długimi nocami) wyjdziesz z tego z setupem, któremu naprawdę możesz zaufać.