# Så migrerade jag 182k användare till Supabase

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

Från att ha skjutit upp det i månader till att migrera 182k användare: så flyttade jag till slut min app till Supabase.

Att migrera 182 000 användare till en ny backend är ingen liten sak, särskilt inte när du är ensam mobilutvecklare och har ett heltidsjobb vid sidan av. Men jag klarade det. Jag flyttade min app, OSM Tactics, från en trasslig uppsättning med NestJS + MongoDB till Supabase, som är det heta ämnet i backendkretsar just nu. I den här artikeln tar jag dig genom resan: varför jag valde Supabase, vilka utmaningar jag stötte på och hur jag genomförde migreringen.

### Varför Supabase?

När min apps backend började kännas gammal letade jag efter något bättre, och Supabase fångade mitt intresse. Det är en open source-grej som påminner om Firebase men är enklare att komma igång med. Du får en PostgreSQL-databas med ett enkelt API, realtidsfunktioner och inloggning färdigt från start. För mig, en kille som bygger mobilappar, är det perfekt: jag vill inte bråka med krånglig serverskräp. Du kan ha ett Supabase-projekt igång på typ fem minuter, och dokumentationen är superrak, så jag kände mig inte vilse trots att jag inte är något backendproffs.

Supabase är dock inte bara enkelt, det växer också. Det är inte lika stort som Firebase än, men massor av utvecklare använder det och communityn växer snabbt. Det har allt jag behöver: en databas att lagra saker i, verktyg för inloggning, ett ställe att ladda upp filer och till och med små funktioner som jag kan köra utan en hel server. Firebase döljer hur det fungerar, men Supabase använder PostgreSQL, en gammal och pålitlig databas som massor av människor litar på. Det betyder att jag kan ändra saker som jag vill och skala upp senare utan att fastna. Dessutom finns det en stor grupp utvecklare online som delar tips, knep och lösningar på ställen som GitHub. Jag visste att om jag körde fast kunde jag googla eller fråga någon. För en ensam kodare som jag, med ont om tid, kändes Supabase som rätt val: det är enkelt men tillräckligt kraftfullt för min app.

### Den gamla uppsättningen före det stora bytet

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

Innan jag hoppade över till Supabase ska vi prata om vad jag använde. Min app, [OSM Tactics](https://apps.apple.com/us/app/osm-tactics/id1632773385), är ett mobilspel för Android och iOS där folk planerar taktiska strategier. Det är ganska coolt om man gillar sånt. Backenden byggde jag själv med NestJS, ett ramverk för Node.js som jag gillade eftersom det fungerar med TypeScript och håller ordning på saker. Den pratade med MongoDB, en databas där jag sparade all användarinfo, speldata och annat. Jag hade kört den här uppsättningen i nästan fyra år.

![Den senaste ögonblicksbilden av mongodb före migreringen, Osm Tactics även kallat "Osm Guide" ](https://cdn-images-1.medium.com/max/4072/1*oPXY2-yvVmlns_ufWV4ZGg.png)_Den senaste ögonblicksbilden av mongodb före migreringen, Osm Tactics även kallat "Osm Guide" _

Men här är problemet: jag är bara en person med ett heltidsjobb, och att hålla den här backenden vid liv tog livet av mig. I början var NestJS och MongoDB okej, jag klarade av dem. Men när fler användare kom till blev det rörigt. Jag fick lägga alldeles för mycket tid på att se till att servern inte kraschade, täppa till säkerhetshål och hålla den tillräckligt snabb. Säkerheten var det värsta. Jag kan en del Node.js, men jag är en mobilappskille, inte en backendexpert. Det fungerade fortfarande, typ, men det var som en gammal bil som hela tiden gick sönder. Jag kunde inte lappa och laga för evigt. Jag behövde något nytt som inte fick mig att vilja slita mitt hår.

### Språnget: beslutet att migrera

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

Beslutet att flytta allt gick inte snabbt. Det tog en evighet, eftersom jag hela tiden sköt upp det. OSM Tactics är ingen jätteapp med massor av funktioner, men 182k användare är mycket data att hantera. Att gå från MongoDB, där datan är lös och fri, till Supabases PostgreSQL, där allt ligger i prydliga tabeller, lät svårt. Jag skulle behöva göra om hur datan var strukturerad och se till att jag inte tappade något viktigt. Den gamla kombinationen NestJS och MongoDB rullade fortfarande, men jag hade en dålig känsla av att den snart skulle smälla. Den oron gnagde i mig tills jag till slut sa: "Okej, nu kör vi."

När jag väl hade bestämt mig var jag tvungen att planera ordentligt. Jag satte mig ner och listade ut hur mina MongoDB-data skulle bli Supabase-tabeller, ungefär som att rita en karta över var allt skulle hamna. Steg ett var att få ut all data ur MongoDB på ett säkert sätt, så jag skrev ett litet script som dumpade den till JSON-filer. Här är koden. Den är enkel men gjorde jobbet:

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

Scriptet kopplade upp sig mot MongoDB, hämtade all data och sparade den som JSON-filer på min dator. Det fungerade som en backup: jag kunde experimentera utan att förlora allt om jag klantade till det. Jag körde det för varje collection, kontrollerade att filerna såg rätt ut och kände mig lite lugnare när jag visste att jag hade kopior. Ändå drog jag benen efter mig innan jag började med det riktiga arbetet. Jag stirrade på skärmen, smuttade på kaffe och tänkte: "Kanske i morgon." Det krävdes en rejäl knuff för att sluta slöa och faktiskt sätta igång, men när jag väl gjorde det var jag helt inne i det.

### Migrera användare: lösenordspusslet

Här blev det riktigt knepigt: att flytta 182k användare och få deras lösenord att fortsätta fungera. Användare förväntar sig att kunna logga in med samma e-post och lösenord efter att jag uppdaterat appen. Så ska det bara vara. Men att genomföra det var en mardröm. Det fina? [Supabase använder bcrypt för lösenord](https://supabase.com/docs/guides/auth/password-security#how-are-passwords-stored), precis som MongoDB, så jag behövde inte göra om dem eller tvinga användarna att välja nya. Det hade varit en hemsk upplevelse. Folk hatar att återställa lösenord, och jag hade tappat en hel del av dem.

### Hantera Supabases kinkiga auth-tabell

Supabase har tabellen auth.users för inloggningar, och den är superstrikt. Den har en massa fält som måste fyllas i exakt rätt, annars spårar den ur. Om du till exempel lägger in en tom sträng i stället för null går det sönder. Jag hittade fel som andra stött på i [den här GitHub-tråden](https://github.com/supabase/auth/issues/1940), och det skrämde mig till ordning. Jag var tvungen att matcha den perfekt. Så här såg en användare ut för Supabase (jag använde inte telefonfunktionerna, så de är null, ändra det om du använder dem):

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

Jag var tvungen att få varenda fält rätt, annars ville Supabase inte ta emot det. För att flytta alla mina MongoDB-användare skrev jag ett större script som hämtade dem, gjorde om dem till det här formatet och sparade dem som en CSV-fil. Här är scriptet. Det är långt, men det visar hela processen:

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

När jag hade CSV-filen skapade jag en låtsastabell i Supabase som såg ut som auth.users. Den riktiga tabellens uppsättning är en lång SQL-sak som du kan se i Supabase-editorn under 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;
```

Jag kopierade den uppsättningen till min tillfälliga tabell, laddade upp CSV-filen till den och använde sedan det här scriptet för att flytta användare till den riktiga tabellen auth.users, tusen åt gången:

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

På det här sättet kunde jag se varje steg: export, omvandling och inläsning. Det tog längre tid än något flashigt verktyg kanske hade gjort, men jag gillade att veta exakt vad som hände. Jag kollade den tillfälliga tabellen efter att CSV-filen lästs in, stickprovskontrollerade några rader och såg sedan på när batchscriptet körde för att se till att det inte satte i halsen.

### Inget utrymme för egna fält

Supabases tabell auth.users låter dig inte lägga till egna fält, vilket fick mig ur balans. I MongoDB lade jag bara in ett username-fält, ingen stor grej. Men Supabase säger nej: du får nöja dig med det den ger dig. Jag funderade på att trycka in extra data i raw_user_meta_data, som är ungefär som en JSON-påse, men det blir rörigt när man vill söka senare. I stället skapade jag en ny tabell, profiles, som kopplas till auth.users med användarens ID. Den innehåller saker som username och locale och håller allt prydligt.

Se också den här diskussionen, som kan vara till hjälp: [https://github.com/orgs/supabase/discussions/3491](https://github.com/orgs/supabase/discussions/3491)

Att sätta upp det här innebar mer arbete. Jag var tvungen att hämta de extra fälten från MongoDB, matcha dem mot rätt användare och läsa in dem i den nya tabellen. Jag skrev ytterligare ett script som hämtade den datan, gjorde om den till en CSV-fil och laddade upp den till Supabase när auth-delen var klar. Uppsättningen är bättre nu, eftersom jag kan lägga till fler fält senare utan att något går sönder, men migreringen tog längre tid eftersom jag hade två tabeller att hantera i stället för en.

### Migrering av inloggning med Google/Apple

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

Inloggningar med Google och Apple var också jobbiga. I MongoDB hade jag fälten googleId och appleId, och vissa användare hade båda kopplade till samma e-post. Supabase hanterar det med särskilda fält i raw_user_meta_data, som iss, sub och provider_id.

Så här satte jag upp det:

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

I appen uppdaterade jag inloggningsflödena så att de använder Supabases API:er. 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,
  });
}
```

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

Det fungerade, men det var knepigt att hantera användare med både Google och Apple. Jag var tvungen att välja ett som huvud-ID och lista det andra som extra. Jag testade det massor i appen för att se till att ingen blev utelåst.

> **Förbehåll: möjliga problem med CSV-export i Supabase**
> I dagsläget (29/03/2025) kan export av tabelldata som CSV vara [opålitlig](https://github.com/supabase/supabase/issues/27102), så tänk på det när du jämför data mellan Supabase och din ursprungliga källa.

### Generera TypeScript-typer

Supabase har ett grymt knep där den genererar TypeScript-typer åt dig. [Du kör ett enda kommando](https://supabase.com/docs/guides/api/rest/generating-types#generating-types-using-supabase-cli), och det spottar ut filer som berättar för din kod exakt hur databasen ser ut. För min app i React Native och Expo var det enormt. Jag behövde inte gissa vilken data jag skulle få eller skriva egna typer. Det minskade buggarna rejält, eftersom TypeScript skrek åt mig om jag gjorde fel. Tidigare kunde jag lägga timmar på att fixa dumma misstag. Nu går det mycket snabbare.

Jag körde kommandot efter att ha satt upp tabellerna, fick typfilen och kopplade in den i appen. Plötsligt fungerade saker som user.email eller profile.username bara, inget mer funderande på om jag stavat rätt. Det är en liten sak, men det gjorde att kodandet kändes mindre som en gissningslek och mer som en vinst.

### Låt databasfunktioner göra jobbet

Supabase låter dig skriva små SQL-funktioner som körs i databasen, vilket är superpraktiskt. I stället för att skriva en massa kod i appen för att ändra saker lät jag databasen sköta det.

Här är en som jag gjorde för att lägga till krediter i en användares profil:

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

Den hämtar användarens krediter, lägger till några och sparar tillbaka dem, allt i ett svep. Utan den hade jag behövt hämta krediterna, lägga till dem i appen och skicka tillbaka dem, vilket betyder mer kod och fler chanser att göra fel. Jag skrev några sådana här för andra uppgifter också, och appen kändes kvickare eftersom databasen gjorde grovjobbet.

### Förbehållet om backenden

Här kommer en twist: Supabase gjorde sig inte av med min backend helt. För att använda vissa admin-funktioner för inloggning behöver du den här [service_role-nyckeln](https://supabase.com/docs/guides/api/api-keys#the-servicerole-key), men du kan inte lägga den i appen eftersom det inte är säkert. Så jag behöll en liten NestJS-server för de hemliga jobben. Den är inte lika stor som förut, men den finns där för att hålla saker låsta. Supabase gör det mesta av jobbet, så det är fortfarande mycket enklare än min gamla uppsättning.

### Slutsats: värt mödan

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

Att migrera 182 000 användare till Supabase var inte bara en teknisk utmaning, det var en mental utmaning också. Mellan prokrastinering, sena nätter och en hel del tvivel fanns det stunder då jag på riktigt trodde att jag skulle förstöra allt. Det var ett långsamt slit, fullt av stress och tvekan. Men att lämna den sköra uppsättningen med NestJS + MongoDB bakom mig och flytta till något renare och lättare att underhålla var absolut värt det.

Supabase gav mig den enkelhet, flexibilitet och det stöd från communityn som jag behövde som ensam utvecklare med ett heltidsjobb vid sidan av. Om du funderar på att migrera backenden för din egen app ska du veta att det absolut går att göra. Det kommer inte att gå snabbt eller smärtfritt, men med lite planering (och förmodligen några långa nätter) kommer du ut på andra sidan med en uppsättning som du faktiskt kan lita på.

