# 182 Bin Kullanıcıyı Supabase'e Nasıl Taşıdım

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

Aylarca erteledikten sonra 182 bin kullanıcıyı taşımaya: uygulamamı sonunda Supabase'e nasıl geçirdim.

182.000 kullanıcıyı yeni bir backend'e taşımak küçük bir iş değil, hele ki tam zamanlı bir işle birlikte her şeyi tek başına çeviren bir mobil geliştiriciyseniz. Ama başardım. Uygulamam OSM Tactics'i karmakarışık bir NestJS + MongoDB kurulumundan, şu sıralar backend çevrelerinin gözde konusu olan Supabase'e geçirdim. Bu yazıda size bu yolculuğu anlatacağım: neden Supabase'i seçtiğimi, karşılaştığım zorlukları ve taşımayı nasıl başardığımı.

### Neden Supabase?

Uygulamamın backend'i eskimiş hissettirmeye başladığında daha iyi bir şey aramaya başladım ve Supabase dikkatimi çekti. Firebase'e benzeyen ama başlaması daha kolay, açık kaynaklı bir şey. Size kullanımı kolay bir API'ye sahip bir PostgreSQL veritabanı, gerçek zamanlı özellikler ve hazır kurulu giriş özellikleri veriyor. Mobil uygulama geliştiren biri olarak benim için bu mükemmeldi, çünkü karmaşık sunucu işleriyle uğraşmak istemiyorum. Bir Supabase projesini beş dakika gibi bir sürede ayağa kaldırabiliyorsunuz ve dokümanlar son derece anlaşılır; bu yüzden backend uzmanı olmasam da kaybolmuş hissetmedim.

Ama Supabase sadece kolay değil, aynı zamanda büyüyor. Henüz Firebase kadar devasa değil, ama çok sayıda geliştirici kullanıyor ve topluluk hızla büyüyor. İhtiyacım olan her şey var: veri saklamak için bir veritabanı, giriş araçları, dosya yüklemek için bir yer ve hatta tam bir sunucu olmadan çalıştırabileceğim küçük fonksiyonlar. Firebase nasıl çalıştığını gizliyor, Supabase ise pek çok kişinin güvendiği köklü ve güvenilir bir veritabanı olan PostgreSQL'i kullanıyor. Bu da işleri istediğim gibi değiştirebileceğim ve ileride bir yere sıkışmadan büyütebileceğim anlamına geliyor. Üstelik GitHub gibi yerlerde ipuçları, püf noktaları ve çözümler paylaşan büyük bir geliştirici topluluğu var. Takılırsam Google'da arayabileceğimi ya da birine sorabileceğimi biliyordum. Benim gibi zamanı kısıtlı, tek başına kod yazan biri için Supabase doğru seçim gibi geldi: basit ama uygulamamı kaldıracak kadar güçlü.

### Büyük Geçişten Önceki Eski Kurulum

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

Supabase'e geçmeden önce ne kullandığımdan bahsedelim. Uygulamam [OSM Tactics](https://apps.apple.com/us/app/osm-tactics/id1632773385), insanların taktik stratejileri planladığı Android ve iOS için bir mobil oyun; bu işlerle ilgileniyorsanız oldukça havalı. Backend'i kendim NestJS ile yazmıştım; NestJS, TypeScript ile çalıştığı ve işleri düzenli tuttuğu için sevdiğim bir Node.js framework'ü. Tüm kullanıcı bilgilerini, oyun verilerini ve diğer parçaları tuttuğum bir veritabanı olan MongoDB ile konuşuyordu. Bu kurulumu neredeyse dört yıldır çalıştırıyordum.

![Taşımadan önce MongoDB'nin son anlık görüntüsü, diğer adıyla "Osm Guide" olan Osm Tactics ](https://cdn-images-1.medium.com/max/4072/1*oPXY2-yvVmlns_ufWV4ZGg.png)_Taşımadan önce MongoDB'nin son anlık görüntüsü, diğer adıyla "Osm Guide" olan Osm Tactics _

Ama sorun şu: tam zamanlı bir işi olan tek bir kişiyim ve bu backend'i ayakta tutmak beni bitiriyordu. Başlangıçta NestJS ve MongoDB sorun değildi, idare edebiliyordum. Ama kullanıcı sayısı arttıkça işler karıştı. Sunucunun çökmemesini sağlamak, güvenlik açıklarını kapatmak ve yeterince hızlı kalmasını sağlamak için çok fazla zaman harcamak zorunda kaldım. En kötü kısım güvenlikti: biraz Node.js biliyorum, ama ben bir backend uzmanı değil, mobil uygulama geliştiricisiyim. Hâlâ bir şekilde çalışıyordu, ama sürekli bozulan eski bir araba gibiydi. Sonsuza kadar yama yapamazdım; saçımı başımı yolduğum bir şey değil, yeni bir şeye ihtiyacım vardı.

### Büyük Adım: Taşıma Kararı

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

Her şeyi taşıma kararı hızlı gelmedi; sürekli ertelediğim için çok uzun sürdü. OSM Tactics tonla özelliği olan dev bir uygulama değil, ama 182 bin kullanıcı uğraşılacak çok fazla veri demek. Verinin serbest ve gevşek olduğu MongoDB'den her şeyin düzenli tablolarda durduğu Supabase'in PostgreSQL'ine geçmek kulağa zor geliyordu. Verinin yapısını baştan kurmam ve önemli hiçbir şeyi kaybetmediğimden emin olmam gerekecekti. Eski NestJS ve MongoDB ikilisi hâlâ çalışıyordu, ama yakında patlayacağına dair kötü bir his vardı içimde. Bu endişe, sonunda "Tamam, yapalım" diyene kadar beni rahatsız etmeye devam etti.

Karar verdikten sonra ciddi bir plan yapmam gerekti. Oturdum ve MongoDB'deki verilerimi Supabase tablolarına nasıl dönüştüreceğimi çıkardım; her şeyin nereye gideceğini gösteren bir harita çizmek gibi. İlk adım tüm verimi MongoDB'den güvenli bir şekilde çıkarmaktı, bu yüzden verileri JSON dosyalarına döken küçük bir script yazdım. İşte o kod; basit ama işini gördü:

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

Bu script MongoDB'ye bağlandı, tüm veriyi çekti ve bilgisayarımda JSON dosyaları olarak kaydetti. Bir yedek gibiydi: bir şeyi berbat edersem her şeyi kaybetmeden kurcalayabilirdim. Her collection için çalıştırdım, dosyaların doğru göründüğünden emin olmak için kontrol ettim ve kopyalarımın olduğunu bilmek içimi biraz rahatlattı. Yine de asıl işe başlamakta ayak sürüdüm: ekrana bakıp kahvemi yudumluyor ve "Belki yarın" diye düşünüyordum. Tembelliği bırakıp gerçekten işe girişmek için büyük bir itki gerekti, ama bir kez başlayınca tamamen kendimi verdim.

### Kullanıcıları Taşımak: Şifre Bulmacası

İşin gerçekten çetrefilli hale geldiği yer burası: 182 bin kullanıcıyı taşımak ve şifrelerinin çalışmaya devam etmesini sağlamak. Kullanıcılar ben uygulamayı güncelledikten sonra aynı e-posta ve şifreyle giriş yapabilmeyi bekliyor; olması gereken de bu. Ama bunu yapmak tam bir kabustu. İşin güzel yanı ne mi? [Supabase de şifreler için bcrypt kullanıyor](https://supabase.com/docs/guides/auth/password-security#how-are-passwords-stored), tıpkı MongoDB'deki gibi; bu yüzden hepsini yeniden oluşturmam ya da kullanıcılara yeni şifre seçtirmem gerekmedi. Aksi korkunç bir deneyim olurdu: insanlar şifre sıfırlamaktan nefret eder ve birçoğunu kaybederdim.

### Supabase'in Titiz Auth Tablosuyla Uğraşmak

Supabase'in girişler için bir auth.users tablosu var ve son derece katı. Tam olarak doğru doldurmanız gereken bir sürü alanı var, yoksa çıldırıyor; örneğin null yerine boş bir string koyarsanız bozuluyor. Diğer insanların karşılaştığı bazı hataları [bu GitHub başlığında](https://github.com/supabase/auth/issues/1940) buldum ve bu beni bir hayli korkuttu. Yapıyı birebir tutturmam gerekiyordu. Supabase için bir kullanıcı şöyle görünüyordu (telefonla ilgili alanları kullanmadım, bu yüzden onlar null; siz kullanıyorsanız değiştirin):

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

Her bir alanı doğru tutturmam gerekiyordu, yoksa Supabase kabul etmiyordu. Tüm MongoDB kullanıcılarımı taşımak için onları alan, bu formata dönüştüren ve bir CSV dosyası olarak kaydeden daha büyük bir script yazdım. İşte o script; uzun ama tüm süreci gösteriyor:

```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 elimdeyken Supabase'te auth.users'a benzeyen sahte bir tablo oluşturdum. Gerçek tablonun yapısı, Supabase editöründe schema auth > users > Definition altında görebileceğiniz uzun bir SQL tanımı:

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

Bu yapıyı geçici tablom için kopyaladım, CSV'yi oraya yükledim ve ardından şu script ile kullanıcıları gerçek auth.users tablosuna biner biner taşıdım:

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

Bu şekilde her adımı görebiliyordum: dışa aktarma, dönüştürme, yükleme. Gösterişli bir araçla olabileceğinden daha uzun sürdü, ama tam olarak ne olduğunu bilmek hoşuma gitti. CSV'yi yükledikten sonra geçici tabloyu kontrol ediyor, birkaç satırı rastgele inceliyor ve ardından batch script'in takılmadığından emin olmak için çalışmasını izliyordum.

### Özel Alanlara Yer Yok

Supabase'in auth.users tablosu kendi alanlarınızı eklemenize izin vermiyor ve bu beni şaşırttı. MongoDB'de oraya bir username alanı ekler geçerdim, büyük mesele değil. Ama Supabase hayır diyor: size verdiğiyle yetinmek zorundasınız. Ekstra verileri bir tür JSON torbası olan raw_user_meta_data'ya tıkıştırmayı düşündüm, ama bu ileride arama yapmak için dağınık olurdu. Onun yerine auth.users'a kullanıcı ID'si ile bağlanan yeni bir profiles tablosu oluşturdum. Bu tablo username ve locale gibi şeyleri tutuyor ve her şeyi derli toplu tutuyor.

Faydalı olabilecek şu tartışmaya da göz atın: [https://github.com/orgs/supabase/discussions/3491](https://github.com/orgs/supabase/discussions/3491)

Bunu kurmak daha fazla iş demekti: o ekstra alanları MongoDB'den çekmem, doğru kullanıcılarla eşleştirmem ve yeni tabloya yüklemem gerekiyordu. Bu veriyi almak için bir script daha yazdım, CSV'ye dönüştürdüm ve auth tarafı bittikten sonra Supabase'e yükledim. Artık daha iyi bir yapı var, çünkü ileride hiçbir şeyi bozmadan yeni alanlar ekleyebiliyorum. Ama bir yerine iki tabloyla uğraşmam gerektiği için taşıma daha uzun sürdü.

### Google/Apple Girişlerinin Taşınması

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

Google ve Apple girişleri de baş ağrıtıcıydı. MongoDB'de googleId ve appleId alanlarım vardı ve bazı kullanıcıların ikisi de tek bir e-postaya bağlıydı. Supabase bunları raw_user_meta_data içindeki iss, sub ve provider_id gibi özel alanlarla yönetiyor.

Ben şöyle kurdum:

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

Uygulamada giriş akışlarını Supabase'in API'lerini kullanacak şekilde güncelledim. Apple için:

```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 için de:

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

Çalıştı, ama hem Google hem Apple hesabı olan kullanıcıları çözmek zordu: birini ana ID olarak seçip diğerini ek olarak listelemem gerekti. Kimsenin hesabının dışında kalmadığından emin olmak için uygulamada bolca test ettim.

> **Uyarı: Supabase'te CSV Dışa Aktarmanın Olası Sorunları**
> Bugün itibarıyla (29/03/2025), tablo verisini CSV olarak dışa aktarmak [güvenilir olmayabilir](https://github.com/supabase/supabase/issues/27102); bu yüzden Supabase ile orijinal kaynağınız arasındaki verileri karşılaştırırken bunu aklınızda tutun.

### TypeScript Tiplerini Üretmek

Supabase'in sizin için TypeScript tiplerini üreten harika bir numarası var. [Tek bir komut çalıştırıyorsunuz](https://supabase.com/docs/guides/api/rest/generating-types#generating-types-using-supabase-cli) ve kodunuza veritabanınızın tam olarak nasıl göründüğünü söyleyen dosyalar üretiyor. React Native ve Expo uygulamam için bu çok büyük bir şeydi: hangi veriyi alacağımı tahmin etmem ya da kendi tiplerimi yazmam gerekmedi. TypeScript bir şeyi yanlış yaptığımda bana bağırdığı için hataları ciddi ölçüde azalttı. Eskiden saatlerimi aptalca hataları düzeltmekle geçirirdim; şimdi çok daha hızlı.

Tablolarımı kurduktan sonra komutu çalıştırdım, tip dosyasını aldım ve uygulamama ekledim. Birdenbire user.email ya da profile.username gibi şeyler doğrudan çalışmaya başladı; doğru yazıp yazmadığımı merak etmek yok artık. Küçük bir şey, ama uygulamayı kodlamayı bir tahmin oyunu olmaktan çıkarıp bir kazanca dönüştürdü.

### İşi Veritabanı Fonksiyonlarına Yaptırmak

Supabase, veritabanında çalışan küçük SQL fonksiyonları yazmanıza izin veriyor ve bu son derece kullanışlı. Bir şeyleri değiştirmek için uygulama tarafında bir sürü kod yazmak yerine işi veritabanına bıraktım.

İşte bir kullanıcının profiline kredi eklemek için yazdığım bir fonksiyon:

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

Bu fonksiyon kullanıcının kredilerini alıyor, üzerine ekliyor ve geri kaydediyor; hepsi tek seferde. Bu olmasa kredileri çekmem, uygulamada eklemem ve geri göndermem gerekirdi; bu da daha fazla kod ve hata yapmak için daha fazla fırsat demek. Başka işler için de bunlardan birkaç tane yazdım ve ağır işi veritabanı üstlendiği için uygulamam daha çevik hissettirdi.

### Backend'le İlgili Bir Uyarı

İşin ilginç bir yanı var: Supabase backend'imden tamamen kurtulmamı sağlamadı. Bazı admin giriş işlemlerini kullanmak için bu [service_role key](https://supabase.com/docs/guides/api/api-keys#the-servicerole-key)'e ihtiyacınız var, ama onu uygulamanın içine koyamazsınız, çünkü güvenli değil. Bu yüzden bu gizli işleri halletmek için küçük bir NestJS sunucusu tuttum. Eskisi kadar büyük değil, ama işleri güvende tutmak için orada. İşin çoğunu Supabase yapıyor, bu yüzden yine de eski kurulumumdan çok daha kolay.

### Sonuç: Uğraşmaya Değdi

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

182.000 kullanıcıyı Supabase'e taşımak sadece teknik değil, zihinsel bir meydan okumaydı da. Ertelemeler, geç saatlere kadar süren geceler ve bolca kendinden şüphe etme arasında, gerçekten her şeyi bozabileceğimi düşündüğüm anlar oldu. Stres ve tereddütle dolu, yavaş ilerleyen yorucu bir süreçti. Ama kırılgan NestJS + MongoDB kurulumunu geride bırakıp daha temiz ve daha sürdürülebilir bir şeye geçmek kesinlikle buna değdi.

Supabase bana, tam zamanlı bir işle birlikte her şeyi tek başına çeviren bir geliştirici olarak ihtiyacım olan sadeliği, esnekliği ve topluluk desteğini verdi. Kendi uygulamanızın backend'ini taşımayı düşünüyorsanız, bunun tamamen yapılabilir olduğunu bilin. Ne hızlı ne de acısız olacak, ama biraz planlamayla (ve muhtemelen birkaç uzun geceyle) sonunda gerçekten güvenebileceğiniz bir kuruluma kavuşacaksınız.

