# Cara Saya Memigrasikan 182 Ribu Pengguna ke Supabase

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

Dari menundanya berbulan-bulan sampai memigrasikan 182 ribu pengguna: begini akhirnya saya memindahkan aplikasi saya ke Supabase.

Memigrasikan 182.000 pengguna ke backend baru bukan hal kecil, apalagi kalau kamu developer mobile yang bekerja sendirian sambil punya pekerjaan full-time. Tapi saya berhasil. Saya memindahkan aplikasi saya, OSM Tactics, dari setup NestJS + MongoDB yang kusut ke Supabase, topik yang sedang ramai di kalangan backend saat ini. Di artikel ini, saya akan mengajak kamu melihat perjalanannya: kenapa saya memilih Supabase, tantangan yang saya hadapi, dan bagaimana saya menyelesaikan migrasinya.

### Kenapa Supabase?

Saat backend aplikasi saya mulai terasa usang, saya mencari sesuatu yang lebih baik, dan Supabase menarik perhatian saya. Ini adalah layanan open source yang mirip Firebase tapi lebih mudah untuk langsung dipakai. Supabase memberimu database PostgreSQL dengan API yang mudah, fitur real-time, dan fitur login yang sudah siap pakai. Bagi saya, orang yang membangun aplikasi mobile, itu sempurna: saya tidak mau repot dengan urusan server yang rumit. Kamu bisa menjalankan proyek Supabase dalam sekitar lima menit, dan dokumentasinya sangat lugas, jadi saya tidak merasa tersesat walaupun saya bukan ahli backend.

Tapi Supabase bukan cuma mudah, Supabase juga makin besar. Memang belum sebesar Firebase, tetapi banyak sekali developer yang memakainya, dan komunitasnya tumbuh cepat. Supabase punya semua yang saya butuhkan: database untuk menyimpan data, tool login, tempat untuk mengunggah file, bahkan fungsi kecil yang bisa saya jalankan tanpa server penuh. Firebase menyembunyikan cara kerjanya, sedangkan Supabase memakai PostgreSQL, database lama yang andal dan dipercaya banyak orang. Artinya saya bisa mengubah hal-hal sesuai keinginan dan memperbesarnya nanti tanpa terjebak. Ditambah lagi, ada banyak developer online yang berbagi tips, trik, dan perbaikan di tempat seperti GitHub. Saya tahu kalau saya mentok, saya bisa mencarinya di Google atau bertanya ke seseorang. Untuk coder yang bekerja sendirian dan kekurangan waktu seperti saya, Supabase terasa seperti pilihan yang tepat: sederhana, tetapi cukup kuat untuk menangani aplikasi saya.

### Setup Lama Sebelum Perpindahan Besar

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

Sebelum saya pindah ke Supabase, mari kita bahas apa yang saya pakai sebelumnya. Aplikasi saya, [OSM Tactics](https://apps.apple.com/us/app/osm-tactics/id1632773385), adalah game mobile untuk Android dan iOS tempat orang merencanakan strategi taktik. Cukup seru kalau kamu suka hal semacam itu. Backend-nya saya buat sendiri dengan NestJS, framework untuk Node.js yang saya suka karena mendukung TypeScript dan membuat semuanya tetap rapi. Backend itu terhubung ke MongoDB, database tempat saya menyimpan semua info pengguna, data game, dan data lainnya. Saya sudah menjalankan setup ini selama hampir empat tahun.

![Snapshot terakhir mongodb sebelum migrasi, Osm Tactics alias “Osm Guide”](https://cdn-images-1.medium.com/max/4072/1*oPXY2-yvVmlns_ufWV4ZGg.png)_Snapshot terakhir mongodb sebelum migrasi, Osm Tactics alias “Osm Guide”_

Tapi masalahnya begini: saya cuma satu orang dengan pekerjaan full-time, dan menjaga backend ini tetap hidup benar-benar menguras tenaga. Awalnya NestJS dan MongoDB baik-baik saja, saya masih bisa menanganinya. Tapi seiring makin banyak pengguna bergabung, semuanya jadi berantakan. Saya harus menghabiskan terlalu banyak waktu memastikan server tidak crash, menambal celah keamanan, dan menjaganya tetap cukup cepat. Keamanan adalah bagian terburuk: saya paham sedikit Node.js, tetapi saya orang aplikasi mobile, bukan ahli backend. Semuanya masih berjalan, kurang lebih, tapi rasanya seperti mobil tua yang terus mogok. Saya tidak bisa terus menambalnya selamanya. Saya butuh sesuatu yang baru yang tidak membuat saya ingin mencabuti rambut sendiri.

### Lompatan: Memutuskan untuk Migrasi

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

Memutuskan untuk memindahkan semuanya tidak cepat. Butuh waktu lama karena saya terus menundanya. OSM Tactics bukan aplikasi raksasa dengan banyak fitur, tetapi 182 ribu pengguna berarti banyak data yang harus diurus. Pindah dari MongoDB, tempat data serba longgar dan bebas, ke PostgreSQL di Supabase, tempat semuanya tersusun rapi dalam tabel, terdengar sulit. Saya harus mengubah cara data disusun dan memastikan tidak ada yang penting yang hilang. Kombinasi lama NestJS dan MongoDB masih berjalan, tetapi saya punya firasat buruk bahwa semuanya akan meledak sebentar lagi. Kekhawatiran itu terus mengganggu sampai akhirnya saya berkata, “Oke, ayo kita lakukan.”

Begitu memutuskan, saya harus merencanakannya dengan serius. Saya duduk dan memikirkan cara mengubah data MongoDB saya menjadi tabel Supabase, seperti menggambar peta ke mana semuanya akan pergi. Langkah pertama adalah mengeluarkan semua data dari MongoDB dengan aman, jadi saya menulis script kecil untuk men-dump-nya ke file JSON. Berikut kodenya, sederhana tapi berhasil:

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

Script ini terhubung ke MongoDB, menarik semua data, lalu menyimpannya sebagai file JSON di komputer saya. Ini seperti backup: saya bisa bereksperimen tanpa kehilangan semuanya kalau saya mengacaukan sesuatu. Saya menjalankannya untuk setiap collection, memeriksa file-filenya untuk memastikan semuanya terlihat benar, dan merasa sedikit lebih tenang karena punya salinannya. Meski begitu, saya masih menunda-nunda memulai pekerjaan yang sebenarnya. Saya menatap layar, menyeruput kopi, dan berpikir, “Mungkin besok saja.” Butuh dorongan besar untuk berhenti bermalas-malasan dan benar-benar mulai, tetapi begitu saya mulai, saya mengerjakannya habis-habisan.

### Memigrasikan Pengguna: Teka-teki Password

Di sinilah semuanya jadi benar-benar rumit: memindahkan 182 ribu pengguna dan memastikan password mereka tetap berfungsi. Pengguna berharap bisa login dengan email dan password yang sama setelah saya memperbarui aplikasi. Memang seharusnya begitu. Tapi melakukannya adalah mimpi buruk. Kabar baiknya? [Supabase memakai bcrypt untuk password](https://supabase.com/docs/guides/auth/password-security#how-are-passwords-stored), sama seperti MongoDB, jadi saya tidak perlu mengulang semuanya atau meminta pengguna membuat password baru. Itu akan jadi pengalaman yang buruk: orang benci mereset password, dan saya akan kehilangan banyak pengguna.

### Menghadapi Tabel Auth Supabase yang Rewel

Supabase punya tabel auth.users untuk login, dan tabel ini sangat ketat. Ada banyak field yang harus diisi dengan tepat, atau tabelnya akan bermasalah. Misalnya, kalau kamu memasukkan string kosong alih-alih null, semuanya rusak. Saya menemukan beberapa error yang dialami orang lain di [thread GitHub ini](https://github.com/supabase/auth/issues/1940), dan itu membuat saya waspada. Saya harus mencocokkannya dengan sempurna. Berikut bentuk data pengguna untuk Supabase (saya tidak memakai fitur nomor telepon, jadi field itu null; ubah kalau kamu memakainya):

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

Saya harus mengisi setiap field dengan benar, kalau tidak Supabase tidak akan menerimanya. Untuk memindahkan semua pengguna MongoDB, saya menulis script yang lebih besar untuk mengambil data mereka, mengubahnya ke format ini, lalu menyimpannya sebagai file CSV. Berikut script-nya, panjang tapi menunjukkan seluruh prosesnya:

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

Setelah punya CSV itu, saya membuat tabel tiruan di Supabase yang bentuknya sama dengan auth.users. Setup tabel aslinya berupa SQL panjang yang bisa kamu lihat di editor Supabase pada 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;
```

Saya menyalin setup itu untuk tabel sementara, mengunggah CSV ke dalamnya, lalu memakai script ini untuk memindahkan pengguna ke tabel auth.users yang asli, seribu pengguna sekaligus:

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

Dengan cara ini, saya bisa melihat setiap langkahnya: ekspor, ubah, muat. Memang lebih lama daripada memakai tool canggih, tetapi saya suka tahu persis apa yang terjadi. Saya memeriksa tabel sementara setelah memuat CSV, mengecek beberapa baris secara acak, lalu mengawasi script batch berjalan untuk memastikan tidak tersendat.

### Tidak Ada Tempat untuk Field Kustom

Tabel auth.users di Supabase tidak mengizinkan kamu menambahkan field sendiri, dan itu membuat saya bingung. Di MongoDB, saya tinggal menambahkan field username, tidak masalah. Tapi Supabase menolak: kamu terpaku pada apa yang disediakannya. Saya sempat berpikir untuk menjejalkan data tambahan ke raw_user_meta_data, yang seperti kantong JSON, tetapi itu merepotkan untuk pencarian nanti. Sebagai gantinya, saya membuat tabel profiles baru yang terhubung ke auth.users lewat ID pengguna. Tabel ini menyimpan hal seperti username dan locale, sehingga semuanya tetap rapi.

Lihat juga diskusi ini yang mungkin membantu: [https://github.com/orgs/supabase/discussions/3491](https://github.com/orgs/supabase/discussions/3491)

Menyiapkan ini berarti kerja tambahan: saya harus menarik field tambahan itu dari MongoDB, mencocokkannya dengan pengguna yang tepat, dan memuatnya ke tabel baru. Saya menulis script lain untuk mengambil data itu, mengubahnya menjadi CSV, lalu mengunggahnya ke Supabase setelah urusan auth selesai. Setup-nya sekarang lebih baik karena saya bisa menambahkan field lain nanti tanpa merusak apa pun, tetapi migrasinya jadi lebih lama karena saya harus mengurus dua tabel, bukan satu.

### Migrasi Sign-In Google/Apple

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

Login Google dan Apple juga merepotkan. Di MongoDB, saya punya field googleId dan appleId, dan beberapa pengguna punya keduanya yang terhubung ke satu email. Supabase menangani ini dengan field khusus di raw_user_meta_data seperti iss, sub, dan provider_id.

Berikut cara saya menyiapkannya:

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

Di aplikasi, saya memperbarui alur sign-in agar memakai API Supabase. Untuk 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,
  });
}
```

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

Berhasil, tetapi menangani pengguna yang punya Google dan Apple sekaligus cukup rumit. Saya harus memilih salah satu sebagai ID utama dan mencantumkan yang lain sebagai tambahan. Saya mengujinya berkali-kali di aplikasi untuk memastikan tidak ada yang terkunci di luar.

> **Catatan: Potensi Masalah Ekspor CSV di Supabase**
> Per hari ini (29/03/2025), ekspor data tabel sebagai CSV mungkin [tidak andal](https://github.com/supabase/supabase/issues/27102), jadi ingat hal itu saat membandingkan data antara Supabase dan sumber aslimu.

### Men-generate Tipe TypeScript

Supabase punya trik keren: Supabase bisa membuatkan tipe TypeScript untukmu. [Kamu cukup menjalankan satu perintah](https://supabase.com/docs/guides/api/rest/generating-types#generating-types-using-supabase-cli), dan hasilnya adalah file yang memberi tahu kode kamu persis seperti apa bentuk database-mu. Untuk aplikasi React Native dan Expo saya, itu sangat berarti: saya tidak perlu menebak data apa yang akan saya dapat atau menulis tipe sendiri. Bug berkurang drastis karena TypeScript langsung memperingatkan saya kalau saya salah. Dulu saya menghabiskan berjam-jam memperbaiki kesalahan konyol; sekarang jauh lebih cepat.

Saya menjalankan perintah itu setelah menyiapkan tabel, mendapatkan file tipe, lalu memasangnya di aplikasi. Tiba-tiba, hal seperti user.email atau profile.username langsung berfungsi, tidak perlu lagi bertanya-tanya apakah ejaannya benar. Ini hal kecil, tetapi membuat proses coding aplikasi terasa bukan lagi permainan tebak-tebakan, melainkan sebuah kemenangan.

### Membiarkan Fungsi Database Bekerja

Supabase memungkinkan kamu menulis fungsi SQL kecil yang berjalan di database, dan itu sangat praktis. Alih-alih menulis banyak kode di sisi aplikasi untuk mengubah data, saya membiarkan database yang menanganinya.

Berikut salah satu fungsi yang saya buat untuk menambahkan kredit ke profil pengguna:

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

Fungsi ini mengambil kredit pengguna, menambahkannya, lalu menyimpannya kembali, semuanya dalam satu langkah. Tanpa fungsi ini, saya harus mengambil kredit, menambahkannya di aplikasi, lalu mengirimkannya kembali, yang berarti lebih banyak kode dan lebih banyak peluang untuk salah. Saya juga menulis beberapa fungsi seperti ini untuk tugas lain, dan aplikasi saya terasa lebih responsif karena database yang mengerjakan bagian beratnya.

### Catatan Soal Backend

Ada kejutan kecil: Supabase tidak sepenuhnya menghapus backend saya. Untuk memakai beberapa fitur login admin, kamu butuh [service_role key](https://supabase.com/docs/guides/api/api-keys#the-servicerole-key), tetapi kamu tidak boleh menaruhnya di aplikasi karena tidak aman. Jadi, saya mempertahankan server NestJS kecil untuk menangani pekerjaan rahasia itu. Ukurannya tidak sebesar dulu, tetapi tetap ada untuk menjaga keamanan. Supabase mengerjakan sebagian besar pekerjaannya, jadi semuanya tetap jauh lebih mudah daripada setup lama saya.

### Kesimpulan: Sepadan dengan Perjuangannya

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

Memigrasikan 182.000 pengguna ke Supabase bukan hanya tantangan teknis, tetapi juga tantangan mental. Di antara kebiasaan menunda, begadang, dan banyak keraguan, ada saat-saat ketika saya benar-benar mengira akan merusak segalanya. Prosesnya lambat dan melelahkan, penuh stres dan keraguan. Tapi meninggalkan setup NestJS + MongoDB yang rapuh dan pindah ke sesuatu yang lebih bersih dan lebih mudah dipelihara benar-benar sepadan.

Supabase memberi saya kesederhanaan, fleksibilitas, dan dukungan komunitas yang saya butuhkan sebagai developer yang bekerja sendirian sambil punya pekerjaan full-time. Kalau kamu sedang mempertimbangkan migrasi backend aplikasimu sendiri, ketahuilah bahwa itu sangat mungkin dilakukan. Prosesnya tidak akan cepat atau mulus, tetapi dengan sedikit perencanaan (dan mungkin beberapa malam panjang), kamu akan sampai di sisi lain dengan setup yang benar-benar bisa kamu percaya.

