@superdb/client e @superdb/auth-js

# Com os nomes do supabase-js (recomendado pra migrar)
npm install @superdb/client

# Só o auth, sem o cliente de dados
npm install @superdb/auth-js

import { createClient } from '@superdb/client'

const db = createClient(
  process.env.NEXT_PUBLIC_SUPERDB_URL!,   // https://auth.superdb.com.br
  process.env.NEXT_PUBLIC_SUPERDB_ANON_KEY!,
  { project: 'meu_projeto' }              // obrigatório — vira o Accept-Profile
)

// Cadastro e login com e-mail e senha
await db.auth.signUp({ email, password })
await db.auth.signInWithPassword({ email, password })

// Login social (PKCE): abra data.url; na volta, troque o ?code= pela sessão
const { data } = await db.auth.signInWithOAuth({ provider: 'google', redirectTo: 'https://meuapp.com.br/callback' })
await db.auth.exchangeCodeForSession(code)

// Sessão e usuário atual
const { data: { session } } = await db.auth.getSession()
const { data: { user } } = await db.auth.getUser()

// Reagir a login, saída e renovação (a sessão se renova sozinha antes de o token de 1 hora vencer)
const { data: { subscription } } = db.auth.onAuthStateChange((evento, sessao) => {
  // INITIAL_SESSION, SIGNED_IN, SIGNED_OUT, TOKEN_REFRESHED, USER_UPDATED
})
subscription.unsubscribe() // ao sair da tela

// Metadados do usuário (mescla) e troca de senha
await db.auth.updateUser({ data: { nome: 'Ana' } })
await db.auth.updateUser({ password: novaSenha, current_password: senhaAtual })

// Esqueci a senha: o link volta para a sua tela com #token=... no endereço
await db.auth.resetPasswordForEmail(email, { redirectTo: 'https://meuapp.com.br/nova-senha' })
await db.auth.resetPassword({ token, password: novaSenha })

// Sair
await db.auth.signOut()

const { data } = await db.from('tasks').select('*').eq('done', false)
await db.from('tasks').insert({ title: 'Comprar pão' })
await db.from('tasks').update({ done: true }).eq('id', taskId)
await db.from('tasks').delete().eq('id', taskId)

// Insert que devolve a linha criada: encadeie .select()
const { data: criada } = await db.from('tasks').insert({ title: 'Pagar a luz' }).select().single()

// Upsert: cria ou atualiza pela chave única
await db.from('perfis').upsert({ id: userId, nome: 'Ana' }, { onConflict: 'id' })

// OU, negação, busca textual e contagem sem trazer as linhas
await db.from('tasks').select('*').or('done.eq.false,prioridade.gt.3')
await db.from('tasks').select('*').not('status', 'in', ['arquivada', 'cancelada'])
await db.from('artigos').select('id, titulo').textSearch('corpo', 'banco de dados', { type: 'websearch', config: 'portuguese' })
const { count } = await db.from('tasks').select('*', { count: 'exact', head: true }).eq('done', false)

const ANON_KEY = process.env.NEXT_PUBLIC_SUPERDB_ANON_KEY!
const DATA_URL = 'https://api.superdb.com.br'

// Select (leitura → Accept-Profile)
const res = await fetch(`${DATA_URL}/tasks?done=eq.false`, {
  headers: { 'Authorization': `Bearer ${ANON_KEY}`, 'apikey': ANON_KEY,
             'Accept-Profile': 'proj_meuapp' }
})
const data = await res.json()

// Insert (escrita → Content-Profile)
await fetch(`${DATA_URL}/tasks`, {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${ANON_KEY}`, 'apikey': ANON_KEY,
             'Content-Type': 'application/json', 'Content-Profile': 'proj_meuapp',
             'Prefer': 'return=minimal' },
  body: JSON.stringify({ title: 'Comprar pão' })
})

const BUCKET = 'proj_meuapp_avatares'

// Upload (upsert substitui o arquivo que já existe)
await db.storage.from(BUCKET).upload('user1.png', file, { upsert: true })

// Download
const { data } = await db.storage.from(BUCKET).download('user1.png')

// URL pública (bucket público) e miniatura 200×200
const { data: { publicUrl } } = db.storage.from(BUCKET).getPublicUrl('user1.png')
const thumb = publicUrl.replace('/object/', '/render/image/') + '?width=200&height=200&resize=cover'

// URL assinada (bucket privado), válida por 1 hora
const { data: signed } = await db.storage
  .from('proj_meuapp_documentos').createSignedUrl('contrato.pdf', 3600)

// 1) Troque a chave por um token de storage. A credencial vai no HEADER.
//    Nada no corpo é lido: mandar { "token": ... } não muda nada.
const mint = await fetch('https://auth.superdb.com.br/st/v1/token', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.SUPERDB_SERVICE_ROLE_KEY}` },
})
const { token, url, role, pode_escrever } = await mint.json()

// 2) Confira o papel ANTES de subir — é o que explica um 403 depois.
//    A resposta já diz: não precisa decodificar o JWT (e não use atob nele,
//    que é base64url e quebra o atob em parte dos tokens).
if (!pode_escrever) {
  throw new Error(`chave errada: token veio com role=${role}, não escreve em bucket privado`)
}

// 3) Suba no storage-api com o token mintado.
await fetch(`${url}/object/${bucket}/${caminho}`, {
  method: 'POST',
  headers: { Authorization: `Bearer ${token}`, 'Content-Type': arquivo.type },
  body: arquivo,
})

const r = await fetch(`${url}/object/sign/${bucket}/${caminho}`, {
  method: 'POST',
  headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({ expiresIn: 300 }),   // SEGUNDOS. não é expires_in
})
const { signedURL } = await r.json()          // atenção: URL em maiúsculas

// signedURL é RELATIVO. Sem juntar com `url`, o navegador resolve contra o
// SEU domínio e devolve 404 — que é o erro mais comum aqui.
const paraOUsuario = `${url}${signedURL}`

// mesma URL serve para os dois. O `&` é porque ela já traz ?token=
const paraBaixar = `${paraOUsuario}&download=${encodeURIComponent('Relatorio.pdf')}`

// NFD separa a letra do acento; a faixa \u0300-\u036f são os acentos.
export const nomeSeguro = (nome: string) =>
  nome.normalize('NFD').replace(/[\u0300-\u036f]/g, '')

nomeSeguro('Relatório Final (v2).pdf')  // 'Relatorio Final (v2).pdf'  ✅

import { RealtimeClient } from '@supabase/realtime-js'

// 1) Minta o token com a credencial de quem está usando o app
async function tokenDeRealtime() {
  const credencial = (await db.auth.getDataPlaneToken()) ?? ANON_KEY // sem login: a anon key
  const res = await fetch('https://auth.superdb.com.br/rt/v1/token', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${credencial}` }
  })
  return res.json() // { token, url, papel_de_origem, expires_in }
}

// 2) Conecta com o token mintado
const { token, url } = await tokenDeRealtime() // url = o socket do SEU projeto; use sempre este
const rt = new RealtimeClient(url, { params: { apikey: token } })
const channel = rt.channel('proj_meuapp:tasks-changes', { config: { private: true } })
  .on('postgres_changes',
    { event: 'INSERT', schema: 'proj_meuapp', table: 'tasks' },
    (payload) => console.log(payload.new)
  )
  .subscribe()

// 3) O token vale 1 hora. Troque antes de vencer, e ao entrar ou sair da conta:
//    rt.setAuth((await tokenDeRealtime()).token)

const sala = rt.channel('proj_meuapp:sala-1', { config: { private: true } })
  .on('broadcast', { event: 'digitando' }, ({ payload }) => mostrar(payload))
  .on('presence', { event: 'sync' }, () => atualizarOnline(sala.presenceState()))
  .subscribe()

import { createSuperDB } from '@superdb/auth-js'

const { auth } = createSuperDB({
  url: 'https://auth.superdb.com.br',
  anonKey: process.env.SUPERDB_ANON_KEY!,
  project: 'meu_projeto',
})

// Cadastro com dados extras: vão em options.data e viram user_metadata
await auth.signUp({
  email: 'user@exemplo.com.br',
  password: 'senha-segura',
  options: { data: { nome: 'Ana' } },
})

// Código por WhatsApp (com o canal configurado no projeto)
await auth.signInWithOtp({ phone: '+5511999998888', options: { channel: 'whatsapp' } })

// Confirmar o código: o mesmo telefone, no mesmo formato
await auth.verifyOtp({ phone: '+5511999998888', code: '123456' })

// MFA TOTP, com a sessão ativa: data traz secret e uri (otpauth://, para o QR code)
const { data } = await auth.mfa.enroll({ factorType: 'totp' })

import type { User, Session } from '@superdb/client'
import type { SuperDBUser, AuthError, SessionStorage } from '@superdb/auth-js'