# Wie ich 182k Nutzer zu Supabase migriert habe

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

Erst monatelang aufgeschoben, dann 182k Nutzer migriert: So habe ich meine App endlich zu Supabase umgezogen.

182.000 Nutzer auf ein neues Backend zu migrieren ist keine Kleinigkeit, vor allem nicht, wenn man als Solo-Mobile-Entwickler nebenbei einen Vollzeitjob hat. Aber ich habe es geschafft. Ich habe meine App OSM Tactics von einem verworrenen Setup aus NestJS und MongoDB auf Supabase umgestellt, das gerade das heiße Thema in Backend-Kreisen ist. In diesem Artikel nehme ich dich mit auf die Reise: warum ich mich für Supabase entschieden habe, auf welche Herausforderungen ich gestoßen bin und wie ich die Migration durchgezogen habe.

### Warum Supabase?

Als sich das Backend meiner App alt anzufühlen begann, habe ich mich nach etwas Besserem umgesehen, und Supabase ist mir ins Auge gefallen. Es ist ein Open-Source-Ding, das ein bisschen wie Firebase ist, aber einfacher zum Einsteigen. Du bekommst eine PostgreSQL-Datenbank mit einer einfachen API, Echtzeit-Features und fertig eingerichteten Login-Funktionen. Für mich als jemanden, der mobile Apps baut, ist das perfekt: Ich will mich nicht mit kompliziertem Server-Kram herumschlagen. Ein Supabase-Projekt läuft in etwa fünf Minuten, und die Dokumentation ist super verständlich, deshalb habe ich mich nicht verloren gefühlt, obwohl ich kein Backend-Profi bin.

Supabase ist aber nicht nur einfach, es wird auch groß. Es ist noch nicht so riesig wie Firebase, aber unzählige Entwickler nutzen es, und die Community wächst schnell. Es hat alles, was ich brauche: eine Datenbank zum Speichern, Login-Tools, einen Ort zum Hochladen von Dateien und sogar kleine Funktionen, die ich ohne kompletten Server ausführen kann. Firebase versteckt, wie es funktioniert, aber Supabase nutzt PostgreSQL, eine alte, zuverlässige Datenbank, der sehr viele Leute vertrauen. Das heißt, ich kann Dinge so ändern, wie ich will, und später skalieren, ohne festzustecken. Außerdem gibt es online eine große Gruppe von Entwicklern, die Tipps, Tricks und Fixes auf Plattformen wie GitHub teilen. Ich wusste: Wenn ich nicht weiterkomme, kann ich es googeln oder jemanden fragen. Für einen Solo-Entwickler wie mich, der wenig Zeit hat, fühlte sich Supabase wie die richtige Wahl an: einfach, aber stark genug für meine App.

### Das alte Setup vor dem großen Wechsel

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

Bevor ich zu Supabase gewechselt bin, reden wir kurz darüber, was ich vorher genutzt habe. Meine App [OSM Tactics](https://apps.apple.com/us/app/osm-tactics/id1632773385) ist ein Mobile Game für Android und iOS, in dem Leute Taktikstrategien planen. Ziemlich cool, wenn man darauf steht. Das Backend hatte ich selbst mit NestJS gebaut, einem Framework für Node.js, das ich mochte, weil es mit TypeScript funktioniert und Ordnung hält. Es sprach mit MongoDB, einer Datenbank, in der ich alle Nutzerdaten, Spieldaten und andere Kleinigkeiten gespeichert habe. Dieses Setup lief bei mir fast vier Jahre lang.

![Der letzte Snapshot von MongoDB vor der Migration, Osm Tactics alias "Osm Guide" ](https://cdn-images-1.medium.com/max/4072/1*oPXY2-yvVmlns_ufWV4ZGg.png)_Der letzte Snapshot von MongoDB vor der Migration, Osm Tactics alias "Osm Guide" _

Aber hier ist das Problem: Ich bin nur ein einzelner Mensch mit einem Vollzeitjob, und dieses Backend am Leben zu halten, hat mich fertiggemacht. Am Anfang waren NestJS und MongoDB in Ordnung, damit kam ich klar. Aber je mehr Nutzer dazukamen, desto chaotischer wurde es. Ich musste viel zu viel Zeit damit verbringen, dafür zu sorgen, dass der Server nicht abstürzt, Sicherheitslücken zu schließen und alles schnell genug zu halten. Sicherheit war der schlimmste Teil: Ich kenne mich etwas mit Node.js aus, aber ich bin Mobile-Entwickler, kein Backend-Experte. Es hat noch funktioniert, irgendwie, aber es war wie ein altes Auto, das ständig liegen bleibt. Ich konnte es nicht ewig flicken. Ich brauchte etwas Neues, bei dem ich mir nicht die Haare raufen wollte.

### Der Sprung: Die Entscheidung zur Migration

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

Die Entscheidung, alles umzuziehen, fiel nicht schnell. Sie hat ewig gedauert, weil ich sie immer wieder aufgeschoben habe. OSM Tactics ist keine riesige App mit unzähligen Features, aber 182k Nutzer sind eine Menge Daten. Von MongoDB, wo die Daten locker und frei herumliegen, zu PostgreSQL in Supabase zu wechseln, wo alles in ordentlichen Tabellen steckt, klang schwer. Ich musste neu aufbauen, wie die Daten strukturiert waren, und sicherstellen, dass nichts Wichtiges verloren geht. Die alte Kombination aus NestJS und MongoDB lief noch, aber ich hatte das ungute Gefühl, dass sie bald explodieren würde. Diese Sorge hat mich so lange beschäftigt, bis ich endlich gesagt habe: "Okay, machen wir's."

Nachdem die Entscheidung gefallen war, musste ich gründlich planen. Ich habe mich hingesetzt und überlegt, wie ich meine MongoDB-Daten in Supabase-Tabellen umwandle, so als würde ich eine Karte zeichnen, wo alles hingehört. Schritt eins war, alle Daten sicher aus MongoDB herauszuholen, also habe ich ein kleines Skript geschrieben, das sie in JSON-Dateien exportiert. Hier ist der Code, simpel, aber er hat seinen Job gemacht:

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

Dieses Skript hat sich mit MongoDB verbunden, alle Daten herausgezogen und als JSON-Dateien auf meinem Rechner gespeichert. Es war wie ein Backup: Ich konnte herumprobieren, ohne alles zu verlieren, falls ich Mist baue. Ich habe es für jede Collection ausgeführt, die Dateien geprüft, ob sie richtig aussehen, und mich etwas besser gefühlt, weil ich Kopien hatte. Trotzdem habe ich den Start der eigentlichen Arbeit hinausgezögert. Ich habe auf den Bildschirm gestarrt, Kaffee getrunken und gedacht: "Vielleicht morgen." Es hat einen großen Ruck gebraucht, mit dem Trödeln aufzuhören und wirklich loszulegen, aber als ich es getan habe, war ich voll dabei.

### Nutzer migrieren: Das Passwort-Puzzle

Jetzt wurde es richtig haarig: 182k Nutzer umziehen und dafür sorgen, dass ihre Passwörter weiter funktionieren. Nutzer erwarten, dass sie sich nach einem App-Update mit derselben E-Mail und demselben Passwort einloggen können, so muss es einfach sein. Aber das umzusetzen war ein Albtraum. Das Gute? [Supabase nutzt bcrypt für Passwörter](https://supabase.com/docs/guides/auth/password-security#how-are-passwords-stored), genau wie MongoDB, also musste ich sie nicht alle neu erzeugen oder Nutzer neue wählen lassen. Das wäre eine schreckliche Erfahrung gewesen: Leute hassen es, Passwörter zurückzusetzen, und ich hätte viele von ihnen verloren.

### Der Umgang mit der pingeligen Auth-Tabelle von Supabase

Supabase hat für Logins die Tabelle auth.users, und die ist extrem streng. Sie hat jede Menge Felder, die du genau richtig füllen musst, sonst dreht sie durch. Wenn du zum Beispiel einen leeren String statt null einträgst, bricht sie. Ich habe in [diesem GitHub-Thread](https://github.com/supabase/auth/issues/1940) Fehler gefunden, auf die andere gestoßen sind, und das hat mich gründlich wachgerüttelt. Ich musste es perfekt treffen. So sah ein Nutzer für Supabase aus (Telefon-Features habe ich nicht genutzt, deshalb sind diese Felder null; ändere das, wenn du sie nutzt):

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

Ich musste jedes einzelne Feld richtig setzen, sonst hätte Supabase den Datensatz nicht angenommen. Um alle meine MongoDB-Nutzer umzuziehen, habe ich ein größeres Skript geschrieben, das sie geholt, in dieses Format umgewandelt und als CSV-Datei gespeichert hat. Hier ist das Skript. Es ist lang, zeigt aber den ganzen Prozess:

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

Als ich die CSV hatte, habe ich in Supabase eine Nachbau-Tabelle erstellt, die wie auth.users aussah. Die Definition der echten Tabelle ist ein langes SQL-Statement, das du im Editor von Supabase unter schema auth > users > Definition findest:

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

Ich habe diese Definition für meine temporäre Tabelle kopiert, die CSV hineingeladen und dann mit diesem Skript die Nutzer in Batches von je tausend in die echte Tabelle auth.users verschoben:

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

So konnte ich jeden Schritt sehen: Export, Umwandlung, Import. Es hat länger gedauert als mit irgendeinem schicken Tool, aber mir gefiel es, genau zu wissen, was passiert. Nach dem Laden der CSV habe ich die temporäre Tabelle geprüft, ein paar Zeilen stichprobenartig kontrolliert und dann zugeschaut, wie das Batch-Skript läuft, um sicherzugehen, dass es nicht hängen bleibt.

### Kein Platz für eigene Felder

In der Tabelle auth.users von Supabase kannst du keine eigenen Felder hinzufügen, und das hat mich aus dem Konzept gebracht. In MongoDB hätte ich einfach ein Feld username hineingepackt, kein Problem. Aber Supabase sagt nein: Du musst mit dem leben, was es dir gibt. Ich habe überlegt, zusätzliche Daten in raw_user_meta_data zu stopfen, das ist so etwas wie ein JSON-Beutel, aber das wird später beim Suchen unordentlich. Stattdessen habe ich eine neue Tabelle profiles angelegt, die über die User-ID mit auth.users verknüpft ist. Sie enthält Dinge wie username und locale und hält alles ordentlich.

Sieh dir auch diese Diskussion an, sie könnte hilfreich sein: [https://github.com/orgs/supabase/discussions/3491](https://github.com/orgs/supabase/discussions/3491)

Das aufzusetzen bedeutete mehr Arbeit: Ich musste diese zusätzlichen Felder aus MongoDB holen, sie den richtigen Nutzern zuordnen und in die neue Tabelle laden. Ich habe ein weiteres Skript geschrieben, das diese Daten holt, sie in eine CSV umwandelt, und habe sie nach dem Auth-Teil zu Supabase hochgeladen. Das Setup ist jetzt besser, weil ich später weitere Felder hinzufügen kann, ohne etwas kaputtzumachen, aber die Migration hat dadurch länger gedauert, weil ich mich um zwei Tabellen statt einer kümmern musste.

### Migration der Logins mit Google und Apple

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

Die Logins mit Google und Apple waren ebenfalls mühsam. In MongoDB hatte ich die Felder googleId und appleId, und manche Nutzer hatten beide mit derselben E-Mail verknüpft. Supabase verwaltet das über spezielle Felder in raw_user_meta_data wie iss, sub und provider_id.

So habe ich es aufgesetzt:

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

In der App habe ich die Sign-in-Flows auf die APIs von Supabase umgestellt. Für 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,
  });
}
```

Und für 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,
  });
}
```

Es hat funktioniert, aber Nutzer mit Google und Apple gleichzeitig richtig zuzuordnen war knifflig. Ich musste eine ID als Haupt-ID wählen und die andere als zusätzliche eintragen. Ich habe das in der App ausgiebig getestet, um sicherzugehen, dass niemand ausgesperrt wird.

> **Achtung: Mögliche Probleme beim CSV-Export in Supabase**
> Stand heute (29/03/2025) kann der Export von Tabellendaten als CSV [unzuverlässig](https://github.com/supabase/supabase/issues/27102) sein. Behalte das im Hinterkopf, wenn du Daten zwischen Supabase und deiner ursprünglichen Quelle vergleichst.

### TypeScript-Typen generieren

Supabase hat diesen großartigen Trick, dass es TypeScript-Typen für dich erzeugt. [Du führst einen Befehl aus](https://supabase.com/docs/guides/api/rest/generating-types#generating-types-using-supabase-cli), und es spuckt Dateien aus, die deinem Code genau sagen, wie deine Datenbank aussieht. Für meine App mit React Native und Expo war das riesig: Ich musste nicht raten, welche Daten ich bekomme, und keine eigenen Typen schreiben. Es hat die Bugs massiv reduziert, weil TypeScript mich angeschrien hat, wenn ich etwas falsch gemacht habe. Früher habe ich Stunden damit verbracht, dumme Fehler zu beheben. Jetzt geht es viel schneller.

Ich habe den Befehl ausgeführt, nachdem ich meine Tabellen aufgesetzt hatte, die Typdatei bekommen und sie in meine App eingebunden. Plötzlich funktionierten Dinge wie user.email oder profile.username einfach, ohne dass ich mich fragen musste, ob ich sie richtig geschrieben habe. Eine Kleinigkeit, aber dadurch fühlte sich das Programmieren der App weniger wie ein Ratespiel an und mehr wie ein Erfolg.

### Datenbankfunktionen die Arbeit machen lassen

Mit Supabase kannst du kleine SQL-Funktionen schreiben, die in der Datenbank laufen, und das ist super praktisch. Statt viel Code auf App-Seite zu schreiben, um Dinge zu ändern, lasse ich die Datenbank das übernehmen.

Hier ist eine, die ich gebaut habe, um dem Profil eines Nutzers Credits hinzuzufügen:

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

Sie holt die Credits des Nutzers, addiert etwas dazu und speichert sie zurück, alles in einem Rutsch. Ohne sie müsste ich die Credits abrufen, sie in der App addieren und zurückschicken, was mehr Code und mehr Gelegenheiten für Fehler bedeutet. Ich habe noch ein paar solcher Funktionen für andere Aufgaben geschrieben, und dadurch fühlte sich meine App flotter an, weil die Datenbank die schwere Arbeit erledigt hat.

### Der Haken beim Backend

Jetzt kommt eine Wendung: Supabase hat mein Backend nicht komplett überflüssig gemacht. Für einige Admin-Funktionen rund um Logins brauchst du den [service_role key](https://supabase.com/docs/guides/api/api-keys#the-servicerole-key), aber den darfst du nicht in die App packen, das ist nicht sicher. Also habe ich einen kleinen NestJS-Server behalten, der diese geheimen Aufgaben übernimmt. Er ist nicht mehr so groß wie früher, aber er ist da, um alles abzusichern. Supabase erledigt den Großteil der Arbeit, also ist es immer noch viel einfacher als mein altes Setup.

### Fazit: Der Kampf hat sich gelohnt

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

182.000 Nutzer zu Supabase zu migrieren war nicht nur eine technische Herausforderung, sondern auch eine mentale. Zwischen Aufschieberei, langen Nächten und jeder Menge Selbstzweifel gab es Momente, in denen ich ernsthaft dachte, ich würde alles kaputtmachen. Es war eine langsame Plackerei voller Stress und Zögern. Aber das brüchige Setup aus NestJS und MongoDB hinter mir zu lassen und auf etwas Saubereres und Wartbareres umzusteigen, hat sich absolut gelohnt.

Supabase hat mir die Einfachheit, Flexibilität und Unterstützung durch die Community gegeben, die ich als Solo-Entwickler mit Vollzeitjob gebraucht habe. Wenn du darüber nachdenkst, das Backend deiner eigenen App zu migrieren: Es ist absolut machbar. Es wird weder schnell noch schmerzlos sein, aber mit etwas Planung (und wahrscheinlich ein paar langen Nächten) kommst du am Ende mit einem Setup heraus, dem du wirklich vertrauen kannst.

