@neetru/sdk 3.1.15 → 3.2.2

package/CHANGELOG.md

@@ -5,6 +5,78 @@ All notable changes to `@neetru/sdk` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.2.2] - 2026-08-05 — **fix(db-sql): renovação de lease cai pra emissão nova quando renew falha (death spiral do cert mTLS)**
+
+Release **patch** (bug crítico de conexão em produção — mesma classe do 3.2.1, um nível mais fundo).
+
+### Contexto
+
+Continuação direta do bug do 3.2.1. Confirmado em campo (pdv-agiliza, 2026-08-05, SSH na `snee-002-multi`): mesmo com o hot-swap do 3.2.1 correto, o `SqlLeaseManager._doRenew()` só chamava **renew** (com `leaseId`). O `renew` do Core (`renewLeaseCore`) só funciona com um lease AINDA vivo; se o lease expirou/foi revogado/foi GC'd do Firestore, o renew falha pra sempre — e o `_doRenew` antigo só re-tentava renew a cada 30s, sem NUNCA emitir um lease NOVO. Resultado (death spiral): o cert mTLS de cliente (efêmero, ~15min, mintado por lease em `issuer-core.ts`) expira, TODA leitura do banco do produto morre com `certificate expired` (TLS alert 45, `ERR_SSL_SSL/TLS_ALERT_CERTIFICATE_EXPIRED`), e o processo NUNCA se recupera até restart manual. Observado determinístico por 3h+ (`/api/db/doc` e tenant-resolve do pdv, 500 em toda leitura; schema/relógio/PgBouncer/Postgres todos confirmados sãos — era só o cert).
+
+### Corrigido
+
+- `_doRenew()`: quando o `renew` (com `leaseId`) falha, **cai pra emissão de um lease NOVO** (`fetchLease()` sem `leaseId`) e faz o swap do pool com o certificado fresco. Quebra o death spiral sem depender de restart do processo. Só desiste (reagenda em 30s) se AMBOS falharem (Core inalcançável).
+- Falha de renovação deixou de ser silenciosa em produção: `console.warn` sempre (não só em dev) — renovação que falha é degradação real de disponibilidade e precisa aparecer no log do produto (`app.log`).
+- 3 testes novos: fallback pra lease novo no renew-fail + swap do pool; reagenda sem lançar quando ambos falham; renovação seguinte usa o novo `leaseId`.
+- **Fix de drift:** `VERSION` em `src/index.ts` estava travado em `3.2.0` (o release 3.2.1 bumpou só o `package.json`) — o guard `SDK-QW-5` estava vermelho desde 2026-07-27 (CI off, ninguém pegou). Agora sincronizado em `3.2.2`.
+
+### Follow-up (não nesta release)
+
+- **Re-lease REATIVO** (P1.5 da auditoria de estabilização 2026-08-05, `docs/_review/DIAGNOSTICO_ESTABILIZACAO_SAAS_2026-08-05.md`): ao pegar `certificate expired`/erro de conexão numa query, invalidar o pool + emitir lease novo + retry 1x, pra um processo em execução se auto-curar mesmo se o timer de renovação não tiver disparado. Exige wrapper resiliente sobre o `pg.Pool` (cuidado com transações Drizzle) — trabalho separado, testado à parte.
+
+## [3.2.1] - 2026-07-27 — **fix(db-sql): hot-swap do pool quando host/port/user/senha mudam (bug_pdv_agiliza)**
+
+Release **patch** (bug crítico de conexão em produção — bloqueava login/queries em qualquer produto que renovasse lease sem reiniciar o processo).
+
+### Contexto
+
+Bug real em produção (pdv-agiliza, 2026-07-24/27): `SqlLeaseManager._swapPool()` só recriava o `pg.Pool` quando `leaseId` OU `credentialVersion` mudavam entre renovações. O Core reemite `renew` com o MESMO `leaseId` de propósito, e `credentialVersion` é um placeholder que nunca muda — então essa condição nunca disparava via renovação normal, só na primeira conexão do processo (`fetchLease` inicial). O app renovava a lease a cada poucos minutos (200 OK, confirmado nos logs do Core) mas o `pg.Pool` real, construído uma vez no boot, nunca era recriado — incluindo o certificado de cliente mTLS efêmero, que expira em minutos. Resultado: qualquer processo de longa duração ficava preso pra sempre no host/certificado do boot, mesmo recebendo material de conexão fresco a cada renovação. Só um restart completo do processo corrigia — não é uma solução, é sintoma do bug.
+
+### Corrigido
+
+- `_swapPool()` agora usa `hasConnectionChanged()`, que compara TODOS os campos que afetam a conexão real (`host`, `port`, `dbName`, `user`, `password`, `sslca`, `clientCert`, `clientKey`) além de `leaseId`/`credentialVersion` — superset estrito do comportamento anterior, não remove nenhum gatilho existente. Qualquer mudança de conexão propagada por `renew` agora recria o pool corretamente, sem depender do Core lembrar de bumpar `credentialVersion`.
+- 2 testes novos cobrindo host e password mudando com `leaseId`/`credentialVersion` iguais (o cenário exato do bug). Suite completa: 982/982.
+- `NeetruLoginButton` não resetava `isLoading` após `signIn()` resolver com sucesso (em vez de navegar — ex.: ambiente sem redirect real, teste, ou erro silencioso pós-chamada) — só resetava no `catch`. Agora reseta em ambos os caminhos. (Commit incluído nesta release; nunca teve versão própria publicada.)
+
+## [3.2.0] - 2026-07-24 — **feat(react): `<NeetruLoginButton>` — botão padronizado "Entrar com Neetru"**
+
+Release **minor** (nova API pública aditiva, subpath `@neetru/sdk/react`).
+
+### Contexto
+
+Cada produto SaaS Neetru inventava o próprio botão/estilo pra iniciar o login OIDC (`client.auth.signIn()`), sem nenhum padrão visual em comum. `auth.neetru.com/oauth/login` já tem um botão de referência ("Entrar com Google", preto/BMW) — faltava o equivalente para os produtos oferecerem "Entrar com Neetru" na própria tela de login, com a MESMA identidade visual.
+
+### Adicionado
+
+- `<NeetruLoginButton client={neetru} .../>` (`@neetru/sdk/react`) — botão pronto que chama `client.auth.signIn({ redirectUri, scope, postLoginRedirect })` no click. Visual BMW idêntico ao "Entrar com Google" de referência (altura 48px, `rounded-none`, uppercase, tracking 0.08em) com o ícone-chama Neetru (mesmo asset de `src/components/logo.tsx` no Core) no lugar do ícone do provider.
+  - `theme`: `"dark"` (default, preto — CTA primário) ou `"light"` (branco/borda preta — secundário, ou sobre fundo escuro).
+  - `label`: sobrescreve o texto default `"Entrar com Neetru"`.
+  - `onError`: dispara se `signIn()` lançar antes do redirect (config ausente, runtime sem WebCrypto/sessionStorage).
+  - Estilos **inline** de propósito — roda idêntico em qualquer app consumidor do SDK, com ou sem Tailwind.
+  - 7 testes novos (render, temas, click→signIn, loading/disabled, onError).
+
+## [3.1.15] - 2026-07-22 — **feat(build-guard): withNeetruBuildGuard confirma o env realmente compilado (incidente pdv-agiliza)**
+
+Release **patch** (fecha bug crítico de auth em produção junto com `@neetru/cli >= 2.26.2`).
+
+### Contexto
+
+`.env.local` (fica no disco do dev) vence `.env.production` na precedência de env do Next.js durante `next build` — o bundle de produção podia compilar com `NEXT_PUBLIC_NEETRU_ENV=dev` sem nenhum aviso, ativando `MockAuth` no browser (`MockAuth.signIn()` só finge login em memória, nunca navega pro IdP real — o botão "Entrar com Neetru" não fazia nada).
+
+### Added
+
+- **`withNeetruBuildGuard`** — novo export, **subpath dedicado `@neetru/sdk/build-guard`** (não o barrel principal `.` — é o único módulo do SDK com import estático de `node:fs`/`node:path`, mantido fora do bundle universal browser/Edge de propósito). Envolve `next.config.mjs`:
+  ```js
+  import { withNeetruBuildGuard } from '@neetru/sdk/build-guard';
+  export default withNeetruBuildGuard({ ...nextConfig });
+  ```
+  Grava `.next/neetru-build-manifest.json` com `{builtEnv, productId, oidcClientId, builtAt}` — os valores `NEXT_PUBLIC_NEETRU_*` realmente resolvidos no momento da compilação. `neetru build` (`@neetru/cli >= 2.26.2`) lê esse arquivo depois do build e recusa empacotar o tarball se o valor divergir do ambiente esperado do deploy.
+- Checa a convenção `NEXT_PUBLIC_NEETRU_ENV`/`_PRODUCT_ID`/`_OIDC_CLIENT_ID` (a mesma usada pelo bootstrap Next.js recomendado do ecossistema, ex. `src/lib/neetru/client.ts`) — não é uma checagem universal de qualquer forma de configurar o client.
+
+## [3.1.14] - 2026-07-16 — **feat(dev-suite): env `dev-local` aponta baseUrl pro Core local (F1.3)**
+
+- `NEETRU_ENV=dev-local` (emulador `neetru dev up`) resolve `baseUrl` pro Core local por default; um `baseUrl` explícito no config sempre vence.
+
 ## [3.1.13] - 2026-07-14 — **fix(auth): refresh_token rotation mantém a sessão viva além de ~1h (bug_339a100e)**
 
 Release **patch** (bugfix de segurança/continuidade de sessão).

package/README.md

@@ -75,6 +75,38 @@ if (!check.allowed && check.behavior === 'readonly') {
 | `webhooks` | Produtos registram URL pra receber eventos | `/api/sdk/v1/webhooks` |
 | `notifications` | Produto envia notification in-app | `/api/sdk/v1/notifications` |
 
+## Subpath exports
+
+O barrel principal (`import ... from '@neetru/sdk'`) é universal — roda em browser, Node e Edge runtimes, sem nenhum Node builtin. Código Node-only ou React-only vive em **subpaths dedicados**, pra não vazar dependência pro bundle universal:
+
+| Subpath | Conteúdo |
+|---|---|
+| `@neetru/sdk/auth` | Namespace de auth isolado |
+| `@neetru/sdk/react` | Hooks React (`useUser`, etc) + componentes (`<NeetruLoginButton>`, `<CheckoutLink>`, `<EntitlementGate>`) |
+| `@neetru/sdk/db` | Cliente de banco tenant-scoped |
+| `@neetru/sdk/db/react` | Hooks React do namespace `db` |
+| `@neetru/sdk/mocks` | `MockAuth`, `MockUsage`, `MockSupport`, etc — pra testes/dev |
+| `@neetru/sdk/firestore-compat` | Camada de compat com API estilo Firestore |
+| `@neetru/sdk/build-guard` | **Node-only** — `withNeetruBuildGuard`, ver abaixo |
+| `@neetru/sdk/catalog`, `/entitlements`, `/telemetry`, `/usage`, `/support`, `/errors`, `/checkout`, `/webhooks`, `/notifications`, `/ai` | Cada namespace isolado, pra tree-shaking fino |
+
+### `withNeetruBuildGuard` — confirma o env compilado no build (3.1.15)
+
+Fecha um bug de precedência do Next.js: `.env.local` (fica no disco do dev) vence `.env.production` durante `next build` pra qualquer chave em comum — um build "de prod" podia compilar com `NEXT_PUBLIC_NEETRU_ENV=dev` sem aviso, ativando `MockAuth` no bundle do browser em produção (o login real parava de funcionar silenciosamente).
+
+```js
+// next.config.mjs
+import { withNeetruBuildGuard } from '@neetru/sdk/build-guard';
+
+export default withNeetruBuildGuard({
+  // ...seu nextConfig normal
+});
+```
+
+Grava `.next/neetru-build-manifest.json` com o `NEXT_PUBLIC_NEETRU_ENV`/`_PRODUCT_ID`/`_OIDC_CLIENT_ID` realmente resolvidos no build. `neetru build` (`@neetru/cli >= 2.26.2`) lê esse arquivo depois de compilar e **recusa empacotar o tarball** se o valor divergir do ambiente esperado do deploy — em vez de deployar um bundle silenciosamente quebrado.
+
+Só disponível via `@neetru/sdk/build-guard` (não o barrel `.`) — é o único módulo do SDK com import estático de `node:fs`/`node:path`, mantido fora do bundle universal de propósito.
+
 ## Exemplos por namespace
 
 ### Login OIDC — Authorization Code + PKCE (3.1.3)
@@ -113,6 +145,36 @@ const user = await neetru.auth.verifyToken(idTokenDoCookie);
 `localStorage['neetru_id_token']` (alternativa SPA; o padrão recomendado é o
 cookie httpOnly do backend).
 
+### `<NeetruLoginButton>` — botão padronizado "Entrar com Neetru" (3.2.0)
+
+Subpath `@neetru/sdk/react`. Botão pronto que chama `client.auth.signIn()` no
+click — mesmo visual BMW do botão preto "Entrar com Google" que
+`auth.neetru.com` usa hoje (altura, tipografia, tracking, `rounded-none`),
+com o ícone-chama Neetru no lugar do ícone do provider. É O botão padrão que
+qualquer produto SaaS Neetru deveria usar na própria tela de login, em vez
+de cada um inventar o próprio estilo.
+
+```tsx
+import { NeetruLoginButton } from '@neetru/sdk/react';
+
+<NeetruLoginButton
+  client={neetru}
+  redirectUri="https://app.exemplo.com/auth/callback"
+  postLoginRedirect="/dashboard"
+  theme="dark" // ou "light" — ver abaixo
+/>
+```
+
+- `theme`: `"dark"` (default, preto — CTA primário) ou `"light"` (branco com
+  borda preta — secundário, ou sobre fundo escuro).
+- `label`: sobrescreve o texto (default `"Entrar com Neetru"`).
+- `onError`: dispara se `signIn()` lançar ANTES do redirect (ex:
+  `oidcClientId` ausente, `sessionStorage`/WebCrypto indisponível). No
+  caminho feliz em browser real isso nunca dispara — a navegação interrompe
+  o JS antes de qualquer `catch`.
+- Estilos são **inline** (não Tailwind) de propósito: o componente roda em
+  qualquer app consumidor do SDK, com ou sem Tailwind configurado.
+
 ### Webhooks outbound (v1.2)
 
 ```ts

package/dist/auth.cjs

@@ -278,6 +278,9 @@ var init_db_errors = __esm({
 });
 
 // src/db/sql/lease.ts
+function hasConnectionChanged(oldLease, newLease) {
+  return oldLease.leaseId !== newLease.leaseId || oldLease.credentialVersion !== newLease.credentialVersion || oldLease.host !== newLease.host || oldLease.port !== newLease.port || oldLease.dbName !== newLease.dbName || oldLease.user !== newLease.user || oldLease.password !== newLease.password || oldLease.sslca !== newLease.sslca || oldLease.clientCert !== newLease.clientCert || oldLease.clientKey !== newLease.clientKey;
+}
 function mapPoolError(err) {
   if (err instanceof NeetruDbError) return err;
   const message = err instanceof Error ? err.message : String(err);
@@ -382,21 +385,25 @@ var init_lease = __esm({
       async _doRenew() {
         if (this._closed) return;
         try {
-          const renewOpts = {
-            leaseId: this._lease.leaseId
+          const withDb = (o) => {
+            if (this._deps.database !== void 0) o.database = this._deps.database;
+            return o;
           };
-          if (this._deps.database !== void 0) {
-            renewOpts.database = this._deps.database;
+          let newLease;
+          try {
+            newLease = await this._deps.fetchLease(withDb({ leaseId: this._lease.leaseId }));
+          } catch (renewErr) {
+            newLease = await this._deps.fetchLease(withDb({}));
           }
-          const newLease = await this._deps.fetchLease(renewOpts);
           await this._swapPool(newLease);
         } catch (err) {
           this._renewalTimer = setTimeout(() => {
             void this._doRenew();
           }, MIN_RENEWAL_DELAY_MS);
-          if (process.env["NODE_ENV"] !== "production") {
-            console.warn("[SqlLeaseManager] Lease renewal failed, will retry:", err);
-          }
+          console.warn(
+            `[SqlLeaseManager] renova\xE7\xE3o E emiss\xE3o de lease novo falharam; re-tentando em ${MIN_RENEWAL_DELAY_MS}ms (cert mTLS expira ~15min ap\xF3s o \xFAltimo swap):`,
+            err instanceof Error ? err.message : err
+          );
           return;
         }
         this._scheduleRenewal();
@@ -407,8 +414,7 @@ var init_lease = __esm({
        * Exposto como método protegido para testes.
        */
       async _swapPool(newLease) {
-        const credRotated = newLease.credentialVersion !== this._lease.credentialVersion;
-        if (!credRotated && newLease.leaseId === this._lease.leaseId) {
+        if (!hasConnectionChanged(this._lease, newLease)) {
           this._lease = newLease;
           return;
         }