@neetru/sdk 3.2.1 → 3.2.3

package/CHANGELOG.md

@@ -5,6 +5,41 @@ 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.3] - 2026-08-07 — **fix(db-sql): re-lease REATIVO — query que bate em cert expirado se auto-cura (P1.5)**
+
+Release **patch** (fecha o gap reativo que sobrou do 3.2.2 — mesma classe de bug, no caminho da query em vez do timer).
+
+### Contexto
+
+O 3.2.2 curou o death-spiral no caminho **proativo** (o timer de renovação, ao falhar o renew, cai pra emitir um lease NOVO). Mas restava um gap: se o timer de renovação NÃO disparar (event-loop travado, processo suspenso pelo Cloud Run entre requests) ou o cert mTLS efêmero (~15min) expirar NO MEIO de uma request, não havia recuperação **reativa** — a query que batia em `certificate expired` (TLS alert 45) ou erro de conexão simplesmente morria, e o processo ficava preso até um restart. Este é o P1.5 da auditoria de estabilização (`docs/_review/DIAGNOSTICO_ESTABILIZACAO_SAAS_2026-08-05.md`), listado como follow-up no próprio 3.2.2.
+
+### Corrigido
+
+- **Wrapper resiliente do pool** (`src/db/sql/resilient-pool.ts`): o `pg.Pool` que o Drizzle usa passa a ser embrulhado num Proxy. O handle Drizzle é construído UMA vez sobre o wrapper (referência estável). Ao pegar um erro de ESTABELECIMENTO de conexão numa query plana (`sql.orm.select()` etc.), o wrapper dispara um re-lease (lease NOVO, sem `leaseId` → pool interno novo com cert fresco → swap) e faz **RETRY 1x** da mesma query no pool novo. O `SqlLeaseManager` troca só o pool REAL interno do wrapper (`_swapPool` via `__neetruSwapInner`) — não reconstrói o Drizzle, então referências cacheadas pelo consumer continuam válidas.
+- **Só retry em erro de ESTABELECIMENTO** (a query nunca foi enviada — sem risco de double-write): handshake TLS / cert expirado (`certificate expired`, `CERT_HAS_EXPIRED`, alerta TLS 45, `ERR_SSL_*`) e fase de conexão de socket/DNS (`ECONNREFUSED`/`ETIMEDOUT`/`ENOTFOUND`/`EHOSTUNREACH`/`EAI_AGAIN`). Erro de Postgres já conectado (constraint, statement timeout, deadlock, permissão) passa DIRETO sem retry. `Connection terminated`/`connection closed` fica de fora DE PROPÓSITO (ambíguo — pode ser meio-de-query; conservador vence).
+- **Transações intactas (pass-through).** O Drizzle abre um client dedicado via `pool.connect()` num `transaction()` (detecta via `client instanceof Pool`); o target do Proxy herda `Pool.prototype`, então `instanceof` continua `true` e `connect` é encaminhado ao pool real sem interceptação. As queries da transação rodam no client dedicado, NUNCA no wrapper — o retry reativo jamais toca uma transação.
+- Re-leases reativos concorrentes são coalescidos (N queries falhando ao mesmo tempo = 1 re-lease). Re-lease que falha propaga o erro ORIGINAL da query.
+- Testes novos cobrindo: cert expirado → re-lease → retry no 2º pool → sucesso; erro não-conexão passa direto sem retry; transação continua funcionando; re-lease falho propaga o erro original; classificador de erro de estabelecimento.
+
+## [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).

package/dist/auth.cjs

@@ -277,7 +277,99 @@ var init_db_errors = __esm({
   }
 });
 
+// src/db/sql/resilient-pool.ts
+function isResilientPool(x) {
+  return typeof x === "object" && x !== null && x[RESILIENT_POOL_BRAND] === true;
+}
+function isConnectionEstablishmentError(err) {
+  const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+  if (code === "ECONNREFUSED" || code === "ETIMEDOUT" || code === "ENOTFOUND" || code === "EHOSTUNREACH" || code === "EAI_AGAIN") {
+    return true;
+  }
+  if (typeof code === "string") {
+    const upper = code.toUpperCase();
+    if (upper === "CERT_HAS_EXPIRED" || upper.startsWith("ERR_SSL") || upper.startsWith("ERR_TLS") || upper.includes("CERTIFICATE_EXPIRED")) {
+      return true;
+    }
+  }
+  const rawMessage = err instanceof Error ? err.message : typeof err === "string" ? err : "";
+  const message = rawMessage.toLowerCase();
+  if (message.length === 0) return false;
+  if (message.includes("certificate expired") || message.includes("certificate has expired") || message.includes("cert_has_expired") || message.includes("alert certificate expired") || message.includes("err_ssl") || message.includes("sslv3 alert") || message.includes("tlsv1 alert")) {
+    return true;
+  }
+  if (message.includes("econnrefused") || message.includes("etimedout") || message.includes("enotfound") || message.includes("ehostunreach") || message.includes("getaddrinfo")) {
+    return true;
+  }
+  return false;
+}
+function createResilientPool(initialInner) {
+  const state = { current: initialInner };
+  let reLease = null;
+  const controls = {
+    __neetruSwapInner(newInner) {
+      const old = state.current;
+      state.current = newInner;
+      return old;
+    },
+    __neetruGetInner() {
+      return state.current;
+    },
+    __neetruSetReLease(fn) {
+      reLease = fn;
+    }
+  };
+  const invokeQuery = (pool, args) => pool.query(...args);
+  const wrappedQuery = (...args) => {
+    if (args.length > 0 && typeof args[args.length - 1] === "function") {
+      return invokeQuery(state.current, args);
+    }
+    return (async () => {
+      try {
+        return await invokeQuery(state.current, args);
+      } catch (err) {
+        const fn = reLease;
+        if (fn === null || !isConnectionEstablishmentError(err)) {
+          throw err;
+        }
+        try {
+          await fn();
+        } catch {
+          throw err;
+        }
+        return await invokeQuery(state.current, args);
+      }
+    })();
+  };
+  const target = Object.create(Object.getPrototypeOf(initialInner));
+  const proxy = new Proxy(target, {
+    get(_t, prop) {
+      if (prop === RESILIENT_POOL_BRAND) return true;
+      if (prop === "__neetruSwapInner") return controls.__neetruSwapInner;
+      if (prop === "__neetruGetInner") return controls.__neetruGetInner;
+      if (prop === "__neetruSetReLease") return controls.__neetruSetReLease;
+      if (prop === "query") return wrappedQuery;
+      if (prop === "constructor") {
+        return state.current.constructor;
+      }
+      const current = state.current;
+      const value = Reflect.get(current, prop, current);
+      return typeof value === "function" ? value.bind(current) : value;
+    }
+  });
+  return proxy;
+}
+var RESILIENT_POOL_BRAND;
+var init_resilient_pool = __esm({
+  "src/db/sql/resilient-pool.ts"() {
+    RESILIENT_POOL_BRAND = /* @__PURE__ */ Symbol.for("neetru.sdk.resilientPool");
+  }
+});
+
 // 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);
@@ -303,6 +395,7 @@ var RENEWAL_THRESHOLD, MIN_RENEWAL_DELAY_MS, SqlLeaseManager;
 var init_lease = __esm({
   "src/db/sql/lease.ts"() {
     init_db_errors();
+    init_resilient_pool();
     RENEWAL_THRESHOLD = 0.8;
     MIN_RENEWAL_DELAY_MS = 3e4;
     SqlLeaseManager = class {
@@ -311,6 +404,12 @@ var init_lease = __esm({
       _orm;
       _renewalTimer = null;
       _closed = false;
+      /**
+       * Promessa de re-lease REATIVO em voo — coalesce chamadas concorrentes
+       * (N queries falhando ao mesmo tempo disparam UM único re-lease). Ver
+       * `_reactiveReLease`.
+       */
+      _reLeaseInFlight = null;
       _deps;
       constructor(lease, pool, orm, deps) {
         this._lease = lease;
@@ -382,37 +481,90 @@ 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();
       }
+      // ─── Re-lease REATIVO (P1.5) ───────────────────────────────────────────────
+      /**
+       * Recuperação REATIVA: chamado pelo wrapper resiliente (`resilient-pool.ts`)
+       * quando uma query plana falha num erro de ESTABELECIMENTO de conexão (cert
+       * mTLS expirado no meio de uma request, ou timer de renovação que não
+       * disparou). Emite um lease NOVO e faz o swap do pool interno do wrapper com
+       * o certificado fresco; o wrapper então re-tenta a query 1x no pool novo.
+       *
+       * Vai DIRETO ao lease novo (sem `leaseId`) — a conexão falhou porque o
+       * certificado do lease atual está ruim, então `renew` (que depende do lease
+       * antigo estar vivo) não é o caminho mais robusto. Emitir do zero é o que já
+       * cura o death-spiral no caminho proativo (ver `_doRenew`).
+       *
+       * Coalesce concorrência: N queries falhando ao mesmo tempo compartilham UM
+       * único re-lease (não N leases). Após o swap, cada query re-tenta no pool
+       * vigente.
+       *
+       * NÃO engole erro: se o re-lease falhar, propaga — o wrapper então relança o
+       * erro ORIGINAL da query pro consumer.
+       */
+      async _reactiveReLease() {
+        if (this._closed) {
+          throw new NeetruDbError(
+            "db_unavailable",
+            "SqlLeaseManager foi fechado \u2014 re-lease reativo abortado."
+          );
+        }
+        if (this._reLeaseInFlight !== null) return this._reLeaseInFlight;
+        const run = (async () => {
+          const withDb = (o) => {
+            if (this._deps.database !== void 0) o.database = this._deps.database;
+            return o;
+          };
+          const fresh = await this._deps.fetchLease(withDb({}));
+          await this._swapPool(fresh);
+        })();
+        this._reLeaseInFlight = run;
+        try {
+          await run;
+        } finally {
+          this._reLeaseInFlight = null;
+        }
+      }
       /**
        * Hot-swap do pool: cria pool novo, atualiza ponteiros, drena pool antigo.
        *
        * 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;
         }
         const newPool = this._deps.createPool(newLease);
+        if (isResilientPool(this._pool)) {
+          const oldInner = this._pool.__neetruSwapInner(newPool);
+          this._lease = newLease;
+          void oldInner.end().catch(() => {
+          });
+          return;
+        }
         const newOrm = this._deps.createDrizzle(newPool, this._deps.schema);
         const oldPool = this._pool;
         this._lease = newLease;
@@ -567,23 +719,26 @@ async function createSqlClientWithDeps(deps, options) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new NeetruDbError("db_unavailable", `Falha ao obter lease inicial: ${msg}`);
   }
-  let pool;
+  let innerPool;
   try {
-    pool = depsWithDb.createPool(lease);
+    innerPool = depsWithDb.createPool(lease);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new NeetruDbError("db_unavailable", `Falha ao abrir pool: ${msg}`);
   }
+  const pool = createResilientPool(innerPool);
   let orm;
   try {
     orm = depsWithDb.createDrizzle(pool, depsWithDb.schema);
   } catch (err) {
-    await pool.end().catch(() => {
+    await innerPool.end().catch(() => {
     });
     const msg = err instanceof Error ? err.message : String(err);
     throw new NeetruDbError("db_unavailable", `Falha ao criar handle Drizzle: ${msg}`);
   }
-  return new SqlLeaseManager(lease, pool, orm, depsWithDb);
+  const manager = new SqlLeaseManager(lease, pool, orm, depsWithDb);
+  pool.__neetruSetReLease(() => manager._reactiveReLease());
+  return manager;
 }
 async function createSqlClientFromConfig(config, schema, options) {
   const fetchLease = createHttpLeaseFetcher(config);
@@ -642,6 +797,7 @@ var init_sql_client = __esm({
   "src/db/sql/sql-client.ts"() {
     init_db_errors();
     init_lease();
+    init_resilient_pool();
     LEASE_ENDPOINT = "/api/sdk/v1/db/lease";
     LEASE_RENEW_ENDPOINT = "/api/sdk/v1/db/lease/renew";
   }