Exemplo de autenticação Node

O que acontece: o navegador envia só o domínio do e-mail e o BFF chama GetPublicSignInConfiguration para devolver a configuração SAML do tenant.

O que esperar: a lista de provedores SAML do tenant.

sign-in unavailable

const response = await fetch("/auth/discover", {
  method: "POST",
  headers: { "content-type": "application/json" },
  credentials: "same-origin",
  body: JSON.stringify({ email_domain: "example.com", origin: location.origin }),
});
const { configuration } = await response.json();
const auth = PortalAuth.fromPublicSignInConfiguration(configuration);

O que acontece: o login vai por redirect contra o GCIP, nunca por popup.

O que esperar: uma identidade Firebase autenticada no tenant.

Aguardando descoberta…

await auth.signInWithRedirect(provider.value);

// No retorno do provedor, já na carga da página:
const result = await auth.getRedirectResult();
const unsubscribe = auth.onChange((claims, user) => render(user));

O que acontece: o BFF valida o ID token e mostra as entradas de access que ele carrega.

O que esperar: um painel com a identidade e os escopos, presets e grants efetivos do token.

As claims são um snapshot do momento de emissão. Atualize o token para receber claims reconciliados depois.

Ainda não validado.

await auth.refresh();                       // claims reconciliados
const firebaseIDToken = await auth.token();

await fetch("/api/jwt/me", {
  headers: { Authorization: `Bearer ${firebaseIDToken}` },
  credentials: "same-origin",
});

O que acontece: o ID token é trocado por uma sessão authd (CreateSession), que depois é validada e revogada.

O que esperar: cookie __Host-auth_example HttpOnly no navegador, com o sid, e sessão validada no servidor a cada requisição.

Nesta arquitetura, o campo chamado sid pelo protocolo é o token secreto. Ele viaja só nesse cookie HttpOnly, que o JavaScript da página não lê, e expira junto com a sessão. Revogar apaga o cookie só depois de o authd confirmar.

Nenhuma sessão criada.

const created = await authd.sessions.createSession({ firebaseIdToken, origin, discoveryToken });
const context = await authd.sessions.validateSession({ sid: created.sid, audience });
await authd.sessions.revokeCurrentSession({ sid: created.sid, requestId });

O que acontece: o navegador decodifica access por escopo e o BFF autoriza cada rota com a tabela da aplicação e o recurso resolvido.

O que esperar: escopos, presets e grants efetivos legíveis, além de uma montagem que separa rotas públicas das rotas autenticadas.

O JWT carrega entradas [kind, scope_id, preset_id, grants]. O middleware nunca usa IDs crus da URL como verdade: a aplicação resolve o tenant, a organização ou o customer real antes de chamar can.

Claims ainda não lidos.

Use modulesOfAnyScope apenas para descoberta. Para autorizar uma rota, passe o escopo resolvido e o namespace do tenant a hasModule, hasVariant ou modulesOf.

import { can, hasModule, hasVariant, modulesOfAnyScope, type AccessEntry, type Resolved } from "@iniciador-de-pagamentos/auth-sdk/browser";

const access: AccessEntry[] = [
  ["t", "", "preset-viewer", [9010004]],
  ["o", "org-A", "preset-admin", [9010006]],
];
const customerX: Resolved = {
  kind: "customer", customerId: "customer-X", organizationId: "org-A",
  tenantId: "tenant-home", tenantNamespace: "tenant-home-ns",
};

can(access, customerX, "tenant-home-ns", 1, 4); // true: inherited read access
hasModule({ access }, "pay_by_bank", customerX, "tenant-home-ns"); // true
hasVariant({ access }, "pay_by_bank", "sdk_headless", customerX, "tenant-home-ns"); // true via wildcard
modulesOfAnyScope({ access }); // discovery only; not an authorization decision

// Workspace-only example: @auth/verifier is a monorepo package.
import { Hono } from "hono";
import { applicationEndpointsProvider } from "@iniciador-de-pagamentos/auth-sdk/server";
import { authenticate, createAccessMiddleware, type AuthVariables } from "@auth/verifier";

const endpoints = applicationEndpointsProvider(authorizationClient, applicationId);
const accessMiddleware = createAccessMiddleware({
  endpoints,
  resolve: async (c) => {
    const resource = await resourceStore.findCustomerById(c.req.param("customerId"));
    if (resource === undefined) throw new Error("customer not found");
    return {
      kind: "customer", customerId: resource.id, organizationId: resource.organizationId,
      tenantId: resource.tenantId, tenantNamespace: resource.tenantNamespace,
    };
  },
});
const app = new Hono<{ Variables: AuthVariables }>();

// PUBLIC: do not mount authenticate() or access middleware.
app.get("/health", (c) => c.text("ok"));
// Authenticated with access: authenticate() runs first.
app.use("/customers/*", authenticate());
app.use("/customers/*", accessMiddleware);

const claims = await auth.getClaims();

claims.access?.forEach(([kind, scopeID, presetID, grants]) => {
  console.log({ kind, scopeID, presetID, grants });
});