Migrar do Firebase pro SuperDB.

# 1. Exporte tudo pro GCS (use --collection-ids pra exportar só algumas)
gcloud firestore export gs://[BUCKET]/firestore-backup \
  --project=[PROJECT_ID]

# 2. Baixe localmente
gsutil -m cp -r gs://[BUCKET]/firestore-backup ./firestore-dump

# 3. (Alternativa) Export legível com firebase-tools
npx -p firebase-tools firestore-export \
  --accountCredentials service-account.json \
  --backupFile firestore.json

import admin from 'firebase-admin'
import { writeFileSync } from 'fs'

admin.initializeApp({ credential: admin.credential.cert('./service-account.json') })
const db = admin.firestore()

async function dump(collection: string) {
  const snap = await db.collection(collection).get()
  const docs = snap.docs.map((d) => ({ id: d.id, ...d.data() }))
  writeFileSync(`${collection}.json`, JSON.stringify(docs, null, 2))
  console.log(`[ok] ${collection}: ${docs.length} docs`)
}

await Promise.all([dump('users'), dump('orders'), dump('products')])

create table public.users (
  id uuid primary key default gen_random_uuid(),
  email text unique not null,
  display_name text,
  created_at timestamptz default now()
);

create table public.orders (
  id uuid primary key default gen_random_uuid(),
  user_id uuid not null references public.users(id) on delete cascade,
  status text not null default 'pending',
  total_cents int not null,
  created_at timestamptz default now()
);

create index on public.orders (user_id, created_at desc);

create table public.order_items (
  id uuid primary key default gen_random_uuid(),
  order_id uuid not null references public.orders(id) on delete cascade,
  product_id uuid not null,
  qty int not null,
  price_cents int not null
);

import { createClient } from '@superdb/supabase-compat'
import users from './users.json' assert { type: 'json' }
import orders from './orders.json' assert { type: 'json' }

const db = createClient(
  process.env.SUPERDB_URL!,
  process.env.SUPERDB_SERVICE_ROLE!
)

const idMap = new Map<string, string>()  // firebase id → uuid

for (const batch of chunk(users, 500)) {
  const { data, error } = await db.from('users').insert(
    batch.map((u) => ({
      email: u.email,
      display_name: u.displayName ?? null,
      firebase_id: u.id,
    }))
  ).select('id, firebase_id')

  if (error) throw error
  for (const row of data!) idMap.set(row.firebase_id, row.id)
}

for (const batch of chunk(orders, 500)) {
  await db.from('orders').insert(
    batch.map((o) => ({
      user_id: idMap.get(o.userId)!,
      status: o.status,
      total_cents: Math.round(o.total * 100),
      firebase_id: o.id,
    }))
  )
}

function chunk<T>(arr: T[], n: number): T[][] {
  const out: T[][] = []
  for (let i = 0; i < arr.length; i += n) out.push(arr.slice(i, i + n))
  return out
}

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /orders/{orderId} {
      allow read: if request.auth.uid == resource.data.userId;
      allow create: if request.auth.uid == request.resource.data.userId;
      allow update, delete: if request.auth.uid == resource.data.userId;
    }
  }
}

alter table public.orders enable row level security;

create policy "users see their own orders"
  on public.orders for select
  using (user_id = auth.uid());

create policy "users create their own orders"
  on public.orders for insert
  with check (user_id = auth.uid());

create policy "users update their own orders"
  on public.orders for update
  using (user_id = auth.uid())
  with check (user_id = auth.uid());

create policy "users delete their own orders"
  on public.orders for delete
  using (user_id = auth.uid());

firebase auth:export users.json --project [PROJECT_ID]

{
  "users": [
    {
      "localId": "xYz123...",
      "email": "alice@example.com",
      "emailVerified": true,
      "passwordHash": "BASE64==",
      "salt": "BASE64==",
      "createdAt": "1670000000000",
      "providerUserInfo": [
        { "providerId": "google.com", "rawId": "1100...", "email": "alice@gmail.com" }
      ]
    }
  ]
}

import { createClient } from '@superdb/supabase-compat'
import users from './users.json' assert { type: 'json' }

const db = createClient(
  process.env.SUPERDB_URL!,
  process.env.SUPERDB_SERVICE_ROLE!
)

for (const u of users.users) {
  await db.auth.admin.createUser({
    email: u.email,
    email_confirm: u.emailVerified,
    // hash externo: SuperDB aceita firebase_scrypt e re-hash no próximo login
    password_hash: u.passwordHash
      ? `firebase_scrypt$${u.salt}$${u.passwordHash}`
      : undefined,
    user_metadata: {
      firebase_uid: u.localId,
      providers: u.providerUserInfo?.map((p) => p.providerId) ?? [],
    },
  })
}

import admin from 'firebase-admin'
import { createClient } from '@superdb/supabase-compat'

admin.initializeApp({
  credential: admin.credential.cert('./service-account.json'),
  storageBucket: '[PROJECT].appspot.com',
})

const sup = createClient(
  process.env.SUPERDB_URL!,
  process.env.SUPERDB_SERVICE_ROLE!
)

const bucket = admin.storage().bucket()
const [files] = await bucket.getFiles({ prefix: 'uploads/' })

for (const file of files) {
  const [buf] = await file.download()
  const { error } = await sup.storage
    .from('uploads')
    .upload(file.name.replace(/^uploads\//, ''), buf, {
      contentType: file.metadata.contentType,
      upsert: true,
    })
  if (error) console.error(`[fail] ${file.name}:`, error.message)
  else console.log(`[ok]   ${file.name}`)
}

create function public.log_order_change()
returns trigger language plpgsql as $$
begin
  insert into public.audit_log (table_name, action, row_id, actor_id)
  values ('orders', tg_op, new.id, auth.uid());
  return new;
end $$;

create trigger orders_audit
  after insert or update or delete on public.orders
  for each row execute function public.log_order_change();

// ────────── ANTES: Firestore ──────────
import { getFirestore, collection, query, where, getDocs } from 'firebase/firestore'
import { getAuth, signInWithEmailAndPassword } from 'firebase/auth'

const auth = getAuth(app)
const db = getFirestore(app)

await signInWithEmailAndPassword(auth, email, password)

const q = query(
  collection(db, 'orders'),
  where('userId', '==', auth.currentUser!.uid)
)
const snap = await getDocs(q)
const orders = snap.docs.map((d) => ({ id: d.id, ...d.data() }))

// ────────── DEPOIS: SuperDB ──────────
import { createClient } from '@superdb/supabase-compat'

const db = createClient(
  process.env.NEXT_PUBLIC_SUPERDB_URL!,
  process.env.NEXT_PUBLIC_SUPERDB_ANON_KEY!
)

await db.auth.signInWithPassword({ email, password })

const { data: orders } = await db
  .from('orders')
  .select('*')
  .order('created_at', { ascending: false })
// RLS já filtra por user_id = auth.uid()

// ────────── ANTES: Firestore ──────────
const unsub = onSnapshot(
  query(collection(db, 'messages'), where('room', '==', 'room-1')),
  (snap) => {
    setMessages(snap.docs.map((d) => ({ id: d.id, ...d.data() })))
  }
)

// ────────── DEPOIS: SuperDB ──────────
const channel = sup
  .channel('room-1')
  .on('postgres_changes',
    { event: 'INSERT', schema: 'public', table: 'messages', filter: 'room=eq.room-1' },
    (payload) => setMessages((prev) => [...prev, payload.new])
  )
  .subscribe()

// cleanup
return () => { sup.removeChannel(channel) }