How to Migrate from Firebase to Supabase

1// Firebase service → Supabase equivalent
2// Firestore collections   → PostgreSQL tables
3// Firestore subcollections → Foreign key relationships
4// Security rules           → Row Level Security (RLS)
5// Firebase Auth            → Supabase Auth (GoTrue)
6// Cloud Storage            → Supabase Storage
7// Cloud Functions          → Edge Functions (Deno)
8// Firebase Hosting         → Vercel, Netlify, or Supabase
9// Realtime Database        → Supabase Realtime (Postgres Changes)
10// Cloud Messaging (FCM)    → Third-party push service

1import * as admin from 'firebase-admin'
2import * as fs from 'fs'
3
4admin.initializeApp({ credential: admin.credential.applicationDefault() })
5const db = admin.firestore()
6
7async function exportCollection(collectionName: string) {
8  const snapshot = await db.collection(collectionName).get()
9  const data = snapshot.docs.map((doc) => ({
10    _id: doc.id,
11    ...doc.data(),
12  }))
13  fs.writeFileSync(
14    `./export/${collectionName}.json`,
15    JSON.stringify(data, null, 2)
16  )
17  console.log(`Exported ${data.length} docs from ${collectionName}`)
18}
19
20// Export each collection
21await exportCollection('users')
22await exportCollection('posts')
23await exportCollection('comments')

1-- Create tables in Supabase SQL Editor
2create table public.users (
3  id uuid primary key default gen_random_uuid(),
4  firebase_uid text unique,          -- keep old Firebase UID for reference
5  email text unique not null,
6  display_name text,
7  avatar_url text,
8  created_at timestamptz default now()
9);
10
11create table public.posts (
12  id uuid primary key default gen_random_uuid(),
13  author_id uuid references public.users(id) on delete cascade,
14  title text not null,
15  body text,
16  tags text[] default '{}',          -- Firestore array → PostgreSQL array
17  created_at timestamptz default now(),
18  updated_at timestamptz default now()
19);
20
21create table public.comments (
22  id uuid primary key default gen_random_uuid(),
23  post_id uuid references public.posts(id) on delete cascade,
24  author_id uuid references public.users(id) on delete cascade,
25  content text not null,
26  created_at timestamptz default now()
27);
28
29-- Enable RLS on all tables
30alter table public.users enable row level security;
31alter table public.posts enable row level security;
32alter table public.comments enable row level security;

1import { createClient } from '@supabase/supabase-js'
2import * as fs from 'fs'
3
4const supabase = createClient(
5  process.env.SUPABASE_URL!,
6  process.env.SUPABASE_SERVICE_ROLE_KEY!  // Use service role to bypass RLS
7)
8
9async function importUsers() {
10  const raw = JSON.parse(fs.readFileSync('./export/users.json', 'utf8'))
11
12  const users = raw.map((doc: any) => ({
13    firebase_uid: doc._id,
14    email: doc.email,
15    display_name: doc.displayName || null,
16    avatar_url: doc.photoURL || null,
17    created_at: doc.createdAt || new Date().toISOString(),
18  }))
19
20  const { error } = await supabase.from('users').insert(users)
21  if (error) console.error('Import error:', error)
22  else console.log(`Imported ${users.length} users`)
23}
24
25await importUsers()

1// Export Firebase Auth users
2const listAllUsers = async (nextPageToken?: string) => {
3  const result = await admin.auth().listUsers(1000, nextPageToken)
4  const users = result.users.map((user) => ({
5    firebase_uid: user.uid,
6    email: user.email,
7    display_name: user.displayName,
8    phone: user.phoneNumber,
9    providers: user.providerData.map((p) => p.providerId),
10    created_at: user.metadata.creationTime,
11  }))
12
13  // Write to file
14  fs.appendFileSync(
15    './export/auth-users.json',
16    JSON.stringify(users, null, 2)
17  )
18
19  if (result.pageToken) {
20    await listAllUsers(result.pageToken)
21  }
22}
23
24await listAllUsers()
25
26// Then in Supabase, configure the same OAuth providers
27// in Authentication > Providers (Google, GitHub, etc.)
28// Email/password users will need to use "Forgot Password"
29// on their first Supabase login

1-- Firebase rule: allow read if request.auth != null
2-- Supabase equivalent:
3create policy "Authenticated users can read posts"
4  on public.posts for select
5  using (auth.uid() is not null);
6
7-- Firebase rule: allow write if request.auth.uid == resource.data.authorId
8-- Supabase equivalent:
9create policy "Users can update own posts"
10  on public.posts for update
11  using (auth.uid() = author_id)
12  with check (auth.uid() = author_id);
13
14-- Firebase rule: allow create if request.resource.data.title.size() > 0
15-- Supabase equivalent (use a check constraint instead):
16alter table public.posts
17  add constraint posts_title_not_empty
18  check (length(title) > 0);
19
20-- Firebase rule: allow delete if request.auth.uid == resource.data.authorId
21create policy "Users can delete own posts"
22  on public.posts for delete
23  using (auth.uid() = author_id);

1// BEFORE: Firebase
2import { collection, getDocs, query, where } from 'firebase/firestore'
3const q = query(collection(db, 'posts'), where('authorId', '==', userId))
4const snapshot = await getDocs(q)
5const posts = snapshot.docs.map(d => ({ id: d.id, ...d.data() }))
6
7// AFTER: Supabase
8import { createClient } from '@supabase/supabase-js'
9const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY)
10const { data: posts } = await supabase
11  .from('posts')
12  .select('*')
13  .eq('author_id', userId)
14
15// BEFORE: Firebase Auth
16import { signInWithPopup, GoogleAuthProvider } from 'firebase/auth'
17await signInWithPopup(auth, new GoogleAuthProvider())
18
19// AFTER: Supabase Auth
20await supabase.auth.signInWithOAuth({ provider: 'google' })
21
22// BEFORE: Firebase real-time
23onSnapshot(query(...), (snap) => { /* update */ })
24
25// AFTER: Supabase real-time
26supabase.channel('posts').on(
27  'postgres_changes',
28  { event: '*', schema: 'public', table: 'posts' },
29  (payload) => { /* update */ }
30).subscribe()