# Як я переніс 182 тисячі користувачів на Supabase

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

Місяцями відкладав, а потім переніс 182 тисячі користувачів: ось як я нарешті перевів свій застосунок на Supabase.

Перенести 182 000 користувачів на новий бекенд не дрібниця, особливо коли ти мобільний розробник, який працює сам і паралельно ходить на повну зайнятість. Але мені це вдалося. Я перевів свій застосунок OSM Tactics із заплутаної зв'язки NestJS + MongoDB на Supabase, про який зараз усі говорять у бекенд-колах. У цій статті я розповім, як це було: чому я обрав Supabase, з якими труднощами зіткнувся і як зрештою провів міграцію.

### Чому Supabase?

Коли бекенд мого застосунку почав здаватися застарілим, я почав шукати щось краще, і мені впав в око Supabase. Це open-source рішення, схоже на Firebase, але в нього простіше зайти. Він дає базу даних PostgreSQL із зручним API, real-time можливості й готову авторизацію. Для мене, людини, яка робить мобільні застосунки, це ідеально: я не хочу возитися зі складними серверними штуками. Проєкт Supabase можна запустити хвилин за п'ять, а документація дуже зрозуміла, тож я не почувався загубленим, хоча й не є профі в бекенді.

Але Supabase не просто легкий, він ще й росте. Він поки не такий величезний, як Firebase, але ним користується купа розробників, і спільнота швидко збільшується. У ньому є все, що мені потрібно: база даних для зберігання, інструменти для входу, місце для завантаження файлів і навіть невеликі функції, які можна запускати без повноцінного сервера. Firebase приховує, як він працює, а Supabase використовує PostgreSQL, стару й надійну базу даних, якій довіряє безліч людей. Це означає, що я можу змінювати все як хочу і масштабуватися пізніше, не застрягши. До того ж є велика спільнота розробників, які діляться порадами, хитрощами й виправленнями на GitHub та в інших місцях. Я знав, що коли застрягну, зможу загуглити або когось спитати. Для розробника-одинака, якому вічно бракує часу, Supabase здавався правильним вибором: простий, але достатньо потужний для мого застосунку.

### Стара система до великого переходу

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

Перш ніж перейти до Supabase, розповім, чим я користувався раніше. Мій застосунок [OSM Tactics](https://apps.apple.com/us/app/osm-tactics/id1632773385) це мобільна гра для Android та iOS, де люди планують тактичні стратегії. Доволі класна штука, якщо вам таке подобається. Бекенд я написав сам на NestJS, фреймворку для Node.js, який мені подобався, бо працює з TypeScript і тримає все впорядкованим. Він працював із MongoDB, базою даних, де я зберігав усю інформацію про користувачів, ігрові дані та інше. Ця система працювала майже чотири роки.

![Останній знімок MongoDB перед міграцією, Osm Tactics, він же «Osm Guide»](https://cdn-images-1.medium.com/max/4072/1*oPXY2-yvVmlns_ufWV4ZGg.png)_Останній знімок MongoDB перед міграцією, Osm Tactics, він же «Osm Guide»_

Але от у чому проблема: я один, у мене повна зайнятість на основній роботі, і підтримка цього бекенда мене виснажувала. Спочатку з NestJS і MongoDB усе було гаразд, я справлявся. Та що більше користувачів приходило, то більше все заплутувалося. Я витрачав забагато часу, щоб сервер не падав, щоб латати дірки в безпеці й тримати достатню швидкість. Безпека була найгіршою частиною: Node.js я трохи знаю, але я мобільний розробник, а не експерт з бекенду. Усе ще якось працювало, але було схоже на стару машину, яка постійно ламається. Вічно латати її я не міг, мені потрібно було щось нове, від чого не хотілося б рвати на собі волосся.

### Стрибок: рішення про міграцію

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

Рішення все перенести далося не швидко. Воно забрало цілу вічність, бо я постійно його відкладав. OSM Tactics не якийсь гігантський застосунок із купою функцій, але 182 тисячі користувачів це багато даних. Перехід із MongoDB, де дані лежать вільно й без жорсткої структури, на PostgreSQL у Supabase, де все в акуратних таблицях, здавався складним. Довелося б переробити структуру даних і переконатися, що нічого важливого не загубиться. Стара зв'язка NestJS і MongoDB ще працювала, але в мене було погане передчуття, що скоро все вибухне. Ця тривога не відпускала, поки я нарешті не сказав собі: «Гаразд, робимо».

Коли рішення було ухвалене, треба було все ретельно спланувати. Я сів і розібрався, як перетворити мої дані з MongoDB на таблиці Supabase, ніби малював карту, що куди піде. Першим кроком було безпечно витягти всі дані з MongoDB, тож я написав невеликий скрипт, який вивантажував їх у JSON файли. Ось цей код. Він простий, але свою роботу зробив:

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

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

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

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

    await mongoose.disconnect();

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

Цей скрипт підключався до MongoDB, витягав усі дані й зберігав їх у JSON файли на моєму комп'ютері. Це була своєрідна резервна копія: я міг експериментувати, не боячись усе втратити, якщо щось зіпсую. Я запустив його для кожної колекції, перевірив файли, чи все виглядає правильно, і трохи заспокоївся, знаючи, що копії в мене є. Та все одно я тягнув із початком справжньої роботи: дивився в екран, пив каву й думав: «Може, завтра». Знадобився серйозний поштовх, щоб перестати лінуватися і взятися до справи, але коли я взявся, то вже повністю.

### Перенесення користувачів: головоломка з паролями

Ось тут стало по-справжньому складно: перенести 182 тисячі користувачів так, щоб їхні паролі продовжили працювати. Після оновлення застосунку користувачі очікують входити з тим самим email і паролем, і так і має бути. Але зробити це було жахіттям. Добра новина? [Supabase використовує bcrypt для паролів](https://supabase.com/docs/guides/auth/password-security#how-are-passwords-stored), так само як і MongoDB, тож мені не довелося переробляти їх усі чи змушувати користувачів вигадувати нові. Це був би жахливий досвід: люди ненавидять скидати паролі, і я втратив би чимало з них.

### Вибаглива таблиця авторизації Supabase

У Supabase є таблиця auth.users для входу, і вона дуже сувора. У ній купа полів, які треба заповнити абсолютно правильно, інакше вона ламається. Наприклад, якщо поставити порожній рядок замість null, усе падає. Я знайшов помилки, на які натрапляли інші люди, в [цьому треді на GitHub](https://github.com/supabase/auth/issues/1940), і це мене добряче налякало. Треба було відповідати ідеально. Ось як виглядав користувач для Supabase (поля для телефону я не використовував, тому там null; змініть це, якщо вони вам потрібні):

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

Кожне поле мало бути правильним, інакше Supabase його не приймав. Щоб перенести всіх користувачів із MongoDB, я написав більший скрипт, який їх забирав, перетворював у цей формат і зберігав у CSV файл. Ось цей скрипт. Він довгий, але показує весь процес:

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

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

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

Отримавши CSV, я створив у Supabase тимчасову таблицю, що повторювала auth.users. Структура справжньої таблиці це довгий SQL, який можна побачити в редакторі Supabase в розділі schema auth > users > Definition:

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

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

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

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

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

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

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

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

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

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

Я скопіював цю структуру для своєї тимчасової таблиці, завантажив у неї CSV, а потім цим скриптом переносив користувачів у справжню таблицю auth.users по тисячі за раз:

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

            GET DIAGNOSTICS records_inserted = ROW_COUNT;

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

Так я бачив кожен крок: експорт, перетворення, завантаження. Це зайняло більше часу, ніж могло б із якимсь модним інструментом, але мені подобалося точно знати, що відбувається. Після завантаження CSV я перевіряв тимчасову таблицю, вибірково дивився кілька рядків, а потім стежив за пакетним скриптом, щоб він ніде не захлинувся.

### Ніякого місця для власних полів

Таблиця auth.users у Supabase не дозволяє додавати власні поля, і це мене спантеличило. У MongoDB я просто додав би туди поле username, і жодних проблем. А Supabase каже ні: працюєш із тим, що є. Я думав запхати додаткові дані в raw_user_meta_data, такий собі JSON мішок, але потім шукати по ньому незручно. Натомість я створив нову таблицю profiles, яка зв'язана з auth.users через ID користувача. У ній зберігаються username, locale та інше, і все лишається охайним.

Також погляньте на це обговорення, воно може стати в пригоді: [https://github.com/orgs/supabase/discussions/3491](https://github.com/orgs/supabase/discussions/3491)

Це означало додаткову роботу: треба було витягти ці додаткові поля з MongoDB, зіставити їх із правильними користувачами й завантажити в нову таблицю. Я написав ще один скрипт, який забирав ці дані, перетворював їх у CSV, і завантажив його в Supabase після того, як закінчив з авторизацією. Зараз така структура краща, бо я можу додавати поля пізніше, нічого не зламавши, але міграція через це тривала довше, адже таблиць було дві замість однієї.

### Міграція входу через Google і Apple

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

Вхід через Google і Apple теж дав прикурити. У MongoDB у мене були поля googleId і appleId, і в деяких користувачів обидва були прив'язані до одного email. Supabase обробляє їх через спеціальні поля в raw_user_meta_data, як-от iss, sub і provider_id.

Ось як я це налаштував:

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

У застосунку я оновив процеси входу, щоб вони використовували API Supabase. Для Apple:

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

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

І для Google:

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

const googleUser = await GoogleSignin.signIn();

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

Це запрацювало, але з користувачами, у яких були і Google, і Apple, довелося помучитися: я мав обрати один ID як основний, а інший вказати як додатковий. Я багато тестував це в застосунку, щоб ніхто не втратив доступ до акаунта.

> **Застереження: можливі проблеми з експортом CSV у Supabase**
> Станом на сьогодні (29/03/2025) експорт даних таблиці в CSV може бути [ненадійним](https://github.com/supabase/supabase/issues/27102), тож пам'ятайте про це, коли порівнюєте дані між Supabase і вашим початковим джерелом.

### Генерація TypeScript типів

У Supabase є чудова фішка: він сам генерує TypeScript типи. [Ви запускаєте одну команду](https://supabase.com/docs/guides/api/rest/generating-types#generating-types-using-supabase-cli), і вона видає файли, які точно описують вашому коду, як виглядає база даних. Для мого застосунку на React Native і Expo це було величезним плюсом: не треба було вгадувати, які дані прийдуть, чи писати власні типи. Багів стало значно менше, бо TypeScript сварився на мене щоразу, коли я помилявся. Раніше я годинами виправляв дурні помилки, тепер усе набагато швидше.

Я запустив команду після налаштування таблиць, отримав файл із типами й підключив його до застосунку. І раптом такі речі, як user.email чи profile.username, просто запрацювали, без сумнівів, чи правильно я їх написав. Дрібниця, але писати застосунок стало менше схоже на вгадування і більше на перемогу.

### Хай роботу виконують функції бази даних

Supabase дозволяє писати невеликі SQL функції, які виконуються в базі даних, і це дуже зручно. Замість писати купу коду на боці застосунку, щоб щось змінити, я доручив це базі даних.

Ось функція, яку я зробив для додавання кредитів у профіль користувача:

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

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

      new_credits := current_credits + credits_to_add;

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

      return new_credits;
    end;
```

Вона бере кредити користувача, додає ще й зберігає назад, усе за один раз. Без неї мені довелося б отримати кредити, додати їх у застосунку й надіслати назад, а це більше коду й більше шансів помилитися. Я написав кілька таких функцій і для інших задач, і застосунок став відчуватися швидшим, бо важку роботу виконувала база даних.

### Застереження щодо бекенду

Ось несподіваний поворот: Supabase не позбавив мене бекенду повністю. Для деяких адміністративних функцій авторизації потрібен [service_role key](https://supabase.com/docs/guides/api/api-keys#the-servicerole-key), але класти його в застосунок не можна, це небезпечно. Тому я залишив невеликий сервер на NestJS для таких секретних задач. Він не такий великий, як раніше, але потрібен, щоб усе було захищено. Більшість роботи робить Supabase, тож це все одно набагато простіше, ніж моя стара система.

### Висновок: воно було варте зусиль

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

Перенесення 182 000 користувачів на Supabase було не лише технічним викликом, а й психологічним. Прокрастинація, пізні ночі й постійні сумніви: були моменти, коли я щиро думав, що можу все зламати. Це був повільний і виснажливий процес, повний стресу й вагань. Але залишити крихку зв'язку NestJS + MongoDB і перейти на щось чистіше і простіше в підтримці було абсолютно того варте.

Supabase дав мені простоту, гнучкість і підтримку спільноти, яких я потребував як розробник-одинак із повною зайнятістю на основній роботі. Якщо ви думаєте про міграцію бекенду свого застосунку, знайте: це цілком реально. Швидко й безболісно не буде, але з невеликим плануванням (і, мабуть, кількома довгими ночами) ви опинитеся по той бік із системою, якій справді можна довіряти.

