# Как я перенёс 182 тысячи пользователей на Supabase

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

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

Перенести 182 000 пользователей на новый бэкенд непросто, особенно когда ты мобильный разработчик-одиночка и параллельно работаешь на полной ставке. Но у меня получилось. Я перевёл своё приложение OSM Tactics с запутанной связки NestJS + MongoDB на Supabase, о котором сейчас много говорят в бэкенд кругах. В этой статье я расскажу, как всё прошло: почему я выбрал Supabase, с какими трудностями столкнулся и как провёл миграцию.

### Почему Supabase?

Когда бэкенд моего приложения начал казаться устаревшим, я стал искать что-то получше, и мне попался Supabase. Это open source решение, похожее на Firebase, но с ним проще начать. Он даёт базу данных PostgreSQL с удобным API, работу в реальном времени и готовую авторизацию. Для меня, человека, который делает мобильные приложения, это идеально: я не хочу возиться со сложной серверной частью. Проект на 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 тысячи пользователей так, чтобы их пароли продолжали работать. Пользователи ожидают, что после обновления приложения смогут войти с той же почтой и тем же паролем, и так и должно быть. Но реализовать это было кошмаром. Хорошая новость? [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

![Логотипы входа через Google и Apple](https://cdn-images-1.medium.com/max/2400/0*ojwVN2SEuLBx9Ybn.jpeg)

Вход через Google и Apple тоже доставил хлопот. В MongoDB у меня были поля googleId и appleId, и у некоторых пользователей обе учётки были привязаны к одной почте. 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](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 дал мне простоту, гибкость и поддержку сообщества, которые были нужны мне как разработчику-одиночке с основной работой на полную ставку. Если вы думаете о миграции бэкенда своего приложения, знайте: это вполне реально. Быстро и безболезненно не будет, но с небольшим планированием (и, скорее всего, парой долгих ночей) вы получите архитектуру, которой действительно можно доверять.

