Migrar do Firebase para o SuperDB.

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

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

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

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

create table if not exists pedidos (
  id uuid primary key default gen_random_uuid(),
  user_id uuid default auth.uid(),   -- dono no SuperDB; vazio até a pessoa migrar
  firebase_uid text,                 -- dono no Firebase, para o vínculo do passo 4
  firebase_id text unique,           -- id do documento no Firestore
  status text not null default 'pendente',
  total_centavos int not null,
  criado_em timestamptz not null default now()
);
create index if not exists pedidos_por_dono on pedidos (user_id, criado_em desc);
create index if not exists pedidos_a_vincular on pedidos (firebase_uid) where user_id is null;

create table if not exists itens_do_pedido (
  id uuid primary key default gen_random_uuid(),
  pedido_id uuid not null references pedidos (id) on delete cascade,
  produto_id uuid not null,
  quantidade int not null,
  preco_centavos int not null
);

import { createClient } from '@superdb/client'
import pedidos from './orders.json' with { type: 'json' }

const admin = createClient(process.env.SUPERDB_URL!, process.env.SUPERDB_SERVICE_ROLE_KEY!, {
  project: process.env.SUPERDB_PROJECT!,
})

for (let i = 0; i < pedidos.length; i += 500) {
  const lote = pedidos.slice(i, i + 500).map((p) => ({
    firebase_id: p.id,
    firebase_uid: p.userId,       // quem era o dono no Firebase
    status: p.status,
    total_centavos: Math.round(p.total * 100),
  }))
  const { error } = await admin.from('pedidos').insert(lote)
  if (error) throw new Error(`lote ${i}: ${error.message}`)
}

match /orders/{orderId} {
  allow read, update, delete: if request.auth.uid == resource.data.userId;
  allow create: if request.auth.uid == request.resource.data.userId;
}

alter table pedidos enable row level security;
drop policy if exists pedidos_do_dono on pedidos;
create policy pedidos_do_dono on pedidos
  for all to authenticated
  using (user_id = auth.uid()) with check (user_id = auth.uid());
revoke all on pedidos from anon;
grant select, insert, update, delete on pedidos to authenticated;

import { createClient } from '@superdb/client'

const SUPERDB_URL = process.env.SUPERDB_URL!           // https://auth.superdb.com.br
const PROJETO = process.env.SUPERDB_PROJECT!
const admin = createClient(SUPERDB_URL, process.env.SUPERDB_SERVICE_ROLE_KEY!, { project: PROJETO })
const TABELAS_COM_DONO = ['pedidos']

// Um cliente por pedido, com a sessão só em memória: nada vaza entre usuários.
function clienteDoPedido() {
  const m = new Map<string, string>()
  return createClient(SUPERDB_URL, process.env.SUPERDB_ANON_KEY!, {
    project: PROJETO,
    storage: {
      getItem: (k) => m.get(k) ?? null,
      setItem: (k, v) => { m.set(k, v) },
      removeItem: (k) => { m.delete(k) },
    },
  })
}

// A senha confere no Firebase? É a prova de que a conta antiga é desta pessoa.
async function uidNoFirebase(email: string, senha: string) {
  const r = await fetch(
    `https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=${process.env.FIREBASE_API_KEY}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ email, password: senha, returnSecureToken: true }),
    },
  )
  return r.ok ? ((await r.json()) as { localId: string }).localId : null
}

export async function POST(req: Request) {
  const { email, senha, novaSenha } = (await req.json()) as { email: string; senha: string; novaSenha?: string }

  const firebaseUid = await uidNoFirebase(email, senha)
  if (!firebaseUid) return Response.json({ erro: 'E-mail ou senha incorretos.' }, { status: 401 })

  // O SuperDB pede 8 caracteres; o Firebase aceitava 6. Nesse caso, a tela pede uma nova.
  const senhaFinal = novaSenha ?? senha
  if (senhaFinal.length < 8) return Response.json({ precisaSenhaNova: true }, { status: 409 })

  const { data, error } = await clienteDoPedido().auth.signUp({ email, password: senhaFinal })
  if (error?.code === 'password_breached') return Response.json({ precisaSenhaNova: true }, { status: 409 })
  if (error) return Response.json({ erro: 'Não deu para migrar a conta agora. Fale com o suporte.' }, { status: 409 })

  // Os dados que eram desta conta no Firebase passam a ser dela no SuperDB.
  for (const tabela of TABELAS_COM_DONO) {
    await admin.from(tabela).update({ user_id: data.user.id }).eq('firebase_uid', firebaseUid).is('user_id', null)
  }

  const { access_token, refresh_token, data_plane_token, expires_in } = data.session
  return Response.json({ access_token, refresh_token, data_plane_token, expires_in })
}

import { db } from './lib/superdb'

export async function entrar(email: string, senha: string, novaSenha?: string) {
  // 1. Quem já migrou entra direto.
  const direto = await db.auth.signInWithPassword({ email, password: senha })
  if (!direto.error) return { ok: true as const }
  if (direto.error.code !== 'invalid_credentials') return { erro: 'Não deu para entrar agora.' }

  // 2. Talvez ainda esteja no Firebase: o servidor confere e migra.
  const r = await fetch('/api/migrar-login', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email, senha, novaSenha }),
  })
  const corpo = await r.json()
  if (corpo.precisaSenhaNova) return { precisaSenhaNova: true as const }
  if (!r.ok) return { erro: corpo.erro as string }

  // 3. A sessão criada no servidor passa a valer aqui.
  await db.auth.setSession(corpo)
  return { ok: true as const }
}

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

admin.initializeApp({
  credential: admin.credential.cert('./service-account.json'),
  storageBucket: '[PROJETO].appspot.com',
})
const superdb = createClient(process.env.SUPERDB_URL!, process.env.SUPERDB_SERVICE_ROLE_KEY!, {
  project: process.env.SUPERDB_PROJECT!,
})

const [arquivos] = await admin.storage().bucket().getFiles({ prefix: 'catalogo/' })
for (const arquivo of arquivos) {
  const [conteudo] = await arquivo.download()
  // Nome completo do bucket: proj_<slug>_catalogo, como aparece no painel
  const { error } = await superdb.storage
    .from(`proj_${process.env.SUPERDB_PROJECT}_catalogo`)
    .upload(arquivo.name.replace(/^catalogo\//, ''), conteudo, {
      contentType: arquivo.metadata.contentType,
      upsert: true,
    })
  console.log(error ? `[falhou] ${arquivo.name}: ${error.message}` : `[ok] ${arquivo.name}`)
}

create table if not exists auditoria (
  id bigint generated always as identity primary key,
  tabela text not null,
  acao text not null,
  linha_id uuid,
  autor uuid default auth.uid(),
  em timestamptz not null default now()
);
alter table auditoria enable row level security;
revoke all on auditoria from anon, authenticated;

create or replace function auditar_pedido() returns trigger
language plpgsql security definer set search_path from current as $$
begin
  insert into auditoria (tabela, acao, linha_id) values ('pedidos', tg_op, coalesce(new.id, old.id));
  return coalesce(new, old);
end $$;

drop trigger if exists pedidos_auditoria on pedidos;
create trigger pedidos_auditoria after insert or update or delete on pedidos
  for each row execute function auditar_pedido();

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

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

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

import { createClient } from '@superdb/client'

const db = createClient(
  import.meta.env.VITE_SUPERDB_URL,       // https://auth.superdb.com.br
  import.meta.env.VITE_SUPERDB_ANON_KEY,
  { project: import.meta.env.VITE_SUPERDB_PROJECT },
)

await db.auth.signInWithPassword({ email, password: senha }) // ou o entrar() do passo 4
const { data: pedidos } = await db
  .from('pedidos')
  .select('id,status,total_centavos,criado_em')
  .order('criado_em', { ascending: false })
// sem filtro por dono: o RLS já devolve só os pedidos de quem está logado

import { RealtimeClient } from '@supabase/realtime-js'
import { db } from './lib/superdb'

async function tokenDeRealtime() {
  const credencial = (await db.auth.getDataPlaneToken()) ?? import.meta.env.VITE_SUPERDB_ANON_KEY
  const r = await fetch('https://auth.superdb.com.br/rt/v1/token', {
    method: 'POST',
    headers: { Authorization: `Bearer ${credencial}` },
  })
  return r.json() // { token, url, expires_in }: vale 1 hora
}

const { token, url } = await tokenDeRealtime()
const rt = new RealtimeClient(url, { params: { apikey: token } })
const canal = rt
  .channel(`proj_${import.meta.env.VITE_SUPERDB_PROJECT}:pedidos`, { config: { private: true } })
  .on('postgres_changes',
    { event: '*', schema: `proj_${import.meta.env.VITE_SUPERDB_PROJECT}`, table: 'pedidos' },
    (mudanca) => aplicarMudanca(mudanca))
  .subscribe()

// antes de vencer, e ao entrar ou sair da conta: rt.setAuth((await tokenDeRealtime()).token)
// ao sair da tela: rt.removeChannel(canal)