# 18万2千人のユーザーをSupabaseに移行した方法

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

何か月も先延ばしにしていた状態から、18万2千人のユーザーを移行するまで。私がついにアプリをSupabaseに移した方法です。

18万2千人のユーザーを新しいバックエンドに移行するのは簡単なことではありません。フルタイムの仕事を抱えながらひとりでモバイル開発をしているなら、なおさらです。でも、やり遂げました。私のアプリOSM Tacticsを、絡まり合ったNestJS + MongoDBの構成から、今バックエンド界隈で話題のSupabaseへ移行しました。この記事では、その道のりを紹介します。なぜSupabaseを選んだのか、どんな課題に直面したのか、そしてどうやって移行をやり遂げたのか。

### なぜSupabaseなのか?

アプリのバックエンドが古く感じられるようになったとき、もっと良いものを探し回って、目に留まったのがSupabaseでした。Firebaseに似ているけれど、もっと気軽に始められるオープンソースのサービスです。使いやすいAPIを備えたPostgreSQLのデータベース、リアルタイム機能、ログイン機能がすべて用意されています。モバイルアプリを作っている私にとって、これは完璧でした。複雑なサーバーまわりのことには手を出したくないのです。Supabaseのプロジェクトは5分ほどで動かせますし、ドキュメントもとてもわかりやすいので、バックエンドのプロではない私でも迷うことはありませんでした。

ただし、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向けのモバイルゲームで、ユーザーが戦術を練ることができます。そういうのが好きな人にはかなり面白いアプリです。バックエンドは、Node.jsのフレームワークであるNestJSで自作したものでした。TypeScriptで使えて、コードを整理しておけるところが気に入っていました。バックエンドはMongoDBとやり取りしていて、そこにユーザー情報やゲームのデータ、その他もろもろを保存していました。この構成を4年近く運用していました。

![移行前の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は機能が山ほどある巨大なアプリではありませんが、18万2千人のユーザーとなると、扱うデータは膨大です。データがゆるく自由に置かれているMongoDBから、すべてがきちんとしたテーブルに収まるSupabaseのPostgreSQLへ移るのは、難しそうに聞こえました。データの構造を作り直し、大事なものを何も失わないようにしなければなりません。古い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ファイルとして保存しました。バックアップのようなものです。失敗しても、すべてを失わずにいろいろ試せます。すべてのコレクションに対して実行し、ファイルの中身が正しそうかを確認して、コピーがあることに少し安心しました。それでも、本格的な作業に取りかかるのはなかなか進みませんでした。画面を見つめ、コーヒーをすすりながら「たぶん明日だな」と考えていました。だらだらするのをやめて実際に取りかかるには大きな後押しが必要でしたが、一度始めてからは全力投球でした。

### ユーザーの移行: パスワードというパズル

ここから本当に厄介になりました。18万2千人のユーザーを移し、しかも彼らのパスワードが使えるままにしなければなりません。ユーザーは、アプリを更新したあとも同じメールアドレスとパスワードでログインできると思っています。当然そうあるべきです。でも、それを実現するのは悪夢でした。嬉しかったのは、[SupabaseがMongoDBと同じくパスワードにbcryptを使っている](https://supabase.com/docs/guides/auth/password-security#how-are-passwords-stored)ことです。おかげでパスワードをすべて作り直したり、ユーザーに新しいパスワードを決めてもらったりする必要はありませんでした。そうなっていたらひどい体験になっていたでしょう。みんなパスワードのリセットが大嫌いですし、多くのユーザーを失っていたはずです。

### 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テーブルにユーザーを1,000人ずつ移しました。

```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を読み込んだあとに仮のテーブルを確認し、いくつかの行を抜き取りでチェックして、バッチのスクリプトが詰まらずに動くのを見守りました。

### カスタムフィールドを入れる余地はない

Supabaseのauth.usersテーブルには独自のフィールドを追加できず、これには戸惑いました。MongoDBなら、usernameフィールドをそのまま放り込めば済む話でした。でもSupabaseではそうはいきません。用意されたものを使うしかないのです。追加のデータをJSONの入れ物のようなraw_user_meta_dataに押し込むことも考えましたが、あとで検索するときに面倒です。代わりに、ユーザーIDでauth.usersとつながる新しいprofilesテーブルを作りました。そこにusernameやlocaleなどを持たせて、すべてを整理しています。

参考になるかもしれないこちらの議論も見てください: [https://github.com/orgs/supabase/discussions/3491](https://github.com/orgs/supabase/discussions/3491)

これを用意するには、さらに作業が必要でした。MongoDBからそれらの追加フィールドを取り出し、正しいユーザーと対応づけて、新しいテーブルに読み込まなければなりません。そのデータを取得してCSVに変換するスクリプトをもうひとつ書き、認証まわりの作業が終わってからSupabaseにアップロードしました。今ではあとから何も壊さずにフィールドを追加できるので、より良い構成になりました。でも、扱うテーブルがひとつではなく2つになったので、移行には余計に時間がかかりました。

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

アプリでは、サインインのフローをSupabaseのAPIを使うように更新しました。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に選び、もう一方を追加として登録する必要がありました。誰もログインできなくならないように、アプリで何度もテストしました。

> **注意: SupabaseでのCSVエクスポートの潜在的な問題**
> 今日(2025年3月29日)の時点で、テーブルのデータを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)

18万2千人のユーザーをSupabaseに移行することは、技術的な挑戦であると同時に、精神的な挑戦でもありました。先延ばし、夜更かし、そして何度もの迷いの中で、本気ですべてを壊してしまうかもしれないと思った瞬間もありました。ストレスとためらいに満ちた、地道な作業でした。それでも、もろいNestJS + MongoDBの構成を後にして、よりすっきりした保守しやすいものへ移ったのは、間違いなくその価値がありました。

Supabaseは、フルタイムの仕事を抱えるひとり開発者として私が必要としていたシンプルさ、柔軟性、そしてコミュニティのサポートを与えてくれました。自分のアプリのバックエンドの移行を考えているなら、それは十分に可能だと知っておいてください。すぐに終わるわけでも、痛みがないわけでもありません。でも少しの計画(とたぶん何度かの長い夜)があれば、本当に信頼できる構成を手にして向こう側にたどり着けます。

