@neetru/sdk 3.4.0 → 3.4.2

package/dist/auth.d.cts

@@ -1,4 +1,4 @@
-import { X as NeetruClientConfig, W as NeetruClient } from './types-BoFSCHF_.cjs';
+import { X as NeetruClientConfig, W as NeetruClient } from './types-D-QdG502.cjs';
 import 'drizzle-orm/node-postgres';
 import './errors.cjs';
 

package/dist/auth.d.ts

@@ -1,4 +1,4 @@
-import { X as NeetruClientConfig, W as NeetruClient } from './types-DdJyqBy-.js';
+import { X as NeetruClientConfig, W as NeetruClient } from './types-BlOLDMR0.js';
 import 'drizzle-orm/node-postgres';
 import './errors.js';
 

package/dist/auth.mjs

@@ -682,13 +682,17 @@ var init_lease = __esm({
 // src/db/sql/sql-client.ts
 var sql_client_exports = {};
 __export(sql_client_exports, {
+  DEFAULT_POOL_CONNECT_TIMEOUT_MS: () => DEFAULT_POOL_CONNECT_TIMEOUT_MS,
+  DEFAULT_POOL_IDLE_MS: () => DEFAULT_POOL_IDLE_MS,
+  DEFAULT_POOL_MAX: () => DEFAULT_POOL_MAX,
   LEASE_ENDPOINT: () => LEASE_ENDPOINT,
   LEASE_RENEW_ENDPOINT: () => LEASE_RENEW_ENDPOINT,
   createDrizzleHandle: () => createDrizzleHandle,
   createHttpLeaseFetcher: () => createHttpLeaseFetcher,
   createPgPool: () => createPgPool,
   createSqlClientFromConfig: () => createSqlClientFromConfig,
-  createSqlClientWithDeps: () => createSqlClientWithDeps
+  createSqlClientWithDeps: () => createSqlClientWithDeps,
+  resolvePoolTuning: () => resolvePoolTuning
 });
 function mapEnvToCore(sdkEnv) {
   if (sdkEnv === "workspace") return "staging";
@@ -777,6 +781,30 @@ function parseLease(raw) {
     expiresAt: req("expiresAt", "string")
   };
 }
+function readEnvInt(name, def, min, max) {
+  const raw = typeof process !== "undefined" ? process.env?.[name] : void 0;
+  if (raw === void 0 || raw.trim() === "") return def;
+  const n = Number.parseInt(raw.trim(), 10);
+  if (!Number.isFinite(n) || n < min || n > max) return def;
+  return n;
+}
+function resolvePoolTuning() {
+  return {
+    // Teto 100: bem abaixo do `max_client_conn = 500` do PgBouncer, com folga
+    // para múltiplas instâncias do app dividirem o mesmo front-door.
+    max: readEnvInt("NEETRU_DB_POOL_MAX", DEFAULT_POOL_MAX, 1, 100),
+    // Teto 15min = janela do cert; piso 1s.
+    idleTimeoutMillis: readEnvInt("NEETRU_DB_POOL_IDLE_MS", DEFAULT_POOL_IDLE_MS, 1e3, 9e5),
+    connectionTimeoutMillis: readEnvInt(
+      "NEETRU_DB_POOL_CONNECT_TIMEOUT_MS",
+      DEFAULT_POOL_CONNECT_TIMEOUT_MS,
+      1e3,
+      12e4
+    ),
+    keepAlive: true,
+    keepAliveInitialDelayMillis: 1e4
+  };
+}
 async function createPgPool(lease) {
   const { Pool } = await import(
     /* webpackIgnore: true */
@@ -795,9 +823,7 @@ async function createPgPool(lease) {
     user: lease.user,
     password: lease.password,
     ssl,
-    max: 3,
-    idleTimeoutMillis: 3e4,
-    connectionTimeoutMillis: 1e4
+    ...resolvePoolTuning()
   });
 }
 async function createDrizzleHandle(pool, schema) {
@@ -932,9 +958,9 @@ async function createSqlClientFromConfig(config, schema, options) {
       user: lease.user,
       password: lease.password,
       ssl,
-      max: 3,
-      idleTimeoutMillis: 3e4,
-      connectionTimeoutMillis: 1e4
+      // Tuning centralizado (env-tunável) — ver resolvePoolTuning + auditoria
+      // docs/_review/AUDITORIA_DB_CONN_PERF_2026-09-06.md no Core.
+      ...resolvePoolTuning()
     });
   };
   const createDrizzle = (pool, s) => {
@@ -957,7 +983,7 @@ async function createSqlClientFromConfig(config, schema, options) {
     options
   );
 }
-var LEASE_ENDPOINT, LEASE_RENEW_ENDPOINT;
+var LEASE_ENDPOINT, LEASE_RENEW_ENDPOINT, DEFAULT_POOL_MAX, DEFAULT_POOL_IDLE_MS, DEFAULT_POOL_CONNECT_TIMEOUT_MS;
 var init_sql_client = __esm({
   "src/db/sql/sql-client.ts"() {
     init_db_errors();
@@ -966,6 +992,9 @@ var init_sql_client = __esm({
     init_resilient_pool();
     LEASE_ENDPOINT = "/api/sdk/v1/db/lease";
     LEASE_RENEW_ENDPOINT = "/api/sdk/v1/db/lease/renew";
+    DEFAULT_POOL_MAX = 10;
+    DEFAULT_POOL_IDLE_MS = 6e4;
+    DEFAULT_POOL_CONNECT_TIMEOUT_MS = 1e4;
   }
 });
 
@@ -2541,8 +2570,10 @@ var MutationQueue = class {
     await this.store.deleteMutation(mutationId);
   }
   /**
-   * Marca uma mutação como `failed` e registra o erro.
-   * Incrementa `attempts`. Chamado pelo SyncEngine em falha permanente.
+   * Marca uma mutação como `failed` (dead-letter) e registra o erro.
+   * Incrementa `attempts` e carimba `lastAttemptAt`. Chamado pelo SyncEngine
+   * quando a mutação esgota o teto de tentativas (mutação-veneno): sai do
+   * conjunto `queued`, então `drain()` para de devolvê-la e a fila DESTRAVA.
    */
   async markFailed(mutationId, error) {
     const mut = await this.store.getMutation(mutationId);
@@ -2551,12 +2582,14 @@ var MutationQueue = class {
       ...mut,
       status: "failed",
       lastError: error,
-      attempts: mut.attempts + 1
+      attempts: mut.attempts + 1,
+      lastAttemptAt: Date.now()
     });
   }
   /**
-   * Incrementa `attempts` e volta para `queued` (falha transiente com backoff).
-   * Chamado pelo SyncEngine em falha transiente (5xx, timeout).
+   * Incrementa `attempts`, carimba `lastAttemptAt` e volta para `queued`
+   * (falha transiente com backoff). Chamado pelo SyncEngine em falha
+   * transiente (5xx, timeout) da mutação que REALMENTE foi tentada.
    */
   async markRetry(mutationId, error) {
     const mut = await this.store.getMutation(mutationId);
@@ -2565,9 +2598,24 @@ var MutationQueue = class {
       ...mut,
       status: "queued",
       lastError: error,
-      attempts: mut.attempts + 1
+      attempts: mut.attempts + 1,
+      lastAttemptAt: Date.now()
     });
   }
+  /**
+   * Reverte uma mutação `inflight` de volta a `queued` SEM tocar em `attempts`
+   * nem `lastAttemptAt`. Usado para mutações que foram marcadas inflight mas
+   * NUNCA chegaram a ser enviadas (estavam atrás da head no FIFO e o push
+   * parou antes delas): contá-las como tentativa as empurraria pro dead-letter
+   * por engano, e adiaria seu envio via backoff sem que tenham falhado.
+   * No-op se a mutação não está mais `inflight`.
+   */
+  async requeueInflight(mutationId) {
+    const mut = await this.store.getMutation(mutationId);
+    if (!mut) return;
+    if (mut.status !== "inflight") return;
+    await this.store.putMutation({ ...mut, status: "queued" });
+  }
 };
 
 // src/db/field-value.ts
@@ -2612,6 +2660,10 @@ function hasFieldSentinel(data) {
 }
 
 // src/db/offline/sync-engine.ts
+var MAX_MUTATION_ATTEMPTS = 8;
+var BACKOFF_BASE_MS = 1e3;
+var BACKOFF_CAP_MS = 5 * 60 * 1e3;
+var TRUNCATED_COLLECTIONS_META_KEY = "truncatedCollections";
 function hasSentinels(payload) {
   return payload !== null && hasFieldSentinel(payload);
 }
@@ -2646,6 +2698,8 @@ var SyncEngine = class {
   _state;
   /** Listeners de mudança de SyncState. */
   _stateListeners = /* @__PURE__ */ new Set();
+  /** Listeners de erro de ciclo de sync (P2-C — não mais engolido em silêncio). */
+  _errorListeners = /* @__PURE__ */ new Set();
   /** Cleanup functions dos listeners externos. */
   _cleanups = [];
   /** Timer de resync periódico. */
@@ -2704,6 +2758,19 @@ var SyncEngine = class {
       this._stateListeners.delete(cb);
     };
   }
+  /**
+   * Registra um hook de erro de sync (P2-C). Disparado quando um ciclo falha
+   * (exceção inesperada nas fases, falha de pull/resync ou dead-letter de uma
+   * mutação-veneno) — o que antes era engolido com "log silencioso".
+   * O mesmo diagnóstico também aparece em `SyncState.lastError`.
+   * Retorna uma função de unsubscribe.
+   */
+  onError(cb) {
+    this._errorListeners.add(cb);
+    return () => {
+      this._errorListeners.delete(cb);
+    };
+  }
   /**
    * Força um sync imediato (I3 §10.3 `flush()`).
    * Resolve quando a fila esvazia OU rejeita se o engine estiver destruído.
@@ -2736,8 +2803,10 @@ var SyncEngine = class {
       }
       await this._phase2Pull();
       this._phase3Realtime();
-      this._updateState({ status: "idle", lastSyncedAt: Date.now() });
+      this._updateState({ status: "idle", lastSyncedAt: Date.now(), lastError: null });
     } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this._recordSyncError("cycle", `ciclo de sync falhou: ${msg}`);
       this._updateState({ status: "idle" });
     } finally {
       this._syncing = false;
@@ -2772,6 +2841,9 @@ var SyncEngine = class {
   async _phase1Push() {
     const mutations = await this._queue.drain();
     if (mutations.length === 0) return true;
+    if (this._isInBackoff(mutations[0])) {
+      return true;
+    }
     for (const mut of mutations) {
       await this._queue.markInflight(mut.mutationId);
     }
@@ -2779,10 +2851,16 @@ var SyncEngine = class {
     try {
       result = await this._transport.pushMutations(mutations);
     } catch (err) {
-      for (const mut of mutations) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        await this._queue.markRetry(mut.mutationId, errMsg);
-      }
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const busChangesOnThrow = [];
+      const [head, ...behind] = mutations;
+      await this._retryOrDeadLetter(head, errMsg, busChangesOnThrow);
+      for (const mut of behind) {
+        await this._queue.requeueInflight(mut.mutationId);
+      }
+      if (busChangesOnThrow.length > 0) this._bus.emit(busChangesOnThrow);
+      this._refreshPendingWrites().catch(() => {
+      });
       return false;
     }
     const busChanges = [];
@@ -2809,8 +2887,16 @@ var SyncEngine = class {
     }
     const processedIds = new Set(result.results.map((r) => r.mutationId));
     const unprocessed = mutations.filter((m) => !processedIds.has(m.mutationId));
-    for (const mut of unprocessed) {
-      await this._queue.markRetry(mut.mutationId, "partial_push: muta\xE7\xE3o n\xE3o processada no lote");
+    if (unprocessed.length > 0) {
+      const [boundary, ...behind] = unprocessed;
+      await this._retryOrDeadLetter(
+        boundary,
+        "partial_push: muta\xE7\xE3o n\xE3o processada no lote",
+        busChanges
+      );
+      for (const mut of behind) {
+        await this._queue.requeueInflight(mut.mutationId);
+      }
     }
     if (busChanges.length > 0) {
       this._bus.emit(busChanges);
@@ -3002,6 +3088,67 @@ var SyncEngine = class {
       });
     }
   }
+  // ─── Dead-letter + backoff (P1-C) ────────────────────────────────────────────
+  /**
+   * Trata a falha transiente de UMA mutação que foi realmente tentada.
+   *
+   * - Se ainda há orçamento de tentativas → `markRetry` (volta pra fila com
+   *   backoff, `attempts++`).
+   * - Se esgotou (`attempts+1 >= MAX_MUTATION_ATTEMPTS`) → DEAD-LETTER:
+   *   `markFailed` (sai do conjunto `queued`, então `drain()` para de devolvê-la
+   *   e a fila FIFO DESTRAVA para as demais coleções) + grava um ConflictRecord
+   *   `failed_max_attempts` (o produto vê via `getConflicts()`) + limpa o estado
+   *   pending do doc no cache + registra `lastError`/dispara `onError`.
+   */
+  async _retryOrDeadLetter(mut, errMsg, busChanges) {
+    if (mut.attempts + 1 < MAX_MUTATION_ATTEMPTS) {
+      await this._queue.markRetry(mut.mutationId, errMsg);
+      return;
+    }
+    await this._queue.markFailed(mut.mutationId, errMsg);
+    const conflictRecord = {
+      collection: mut.collection,
+      docId: mut.docId,
+      mutationId: mut.mutationId,
+      losingData: mut.payload ?? {},
+      winningData: {},
+      reason: "failed_max_attempts",
+      detectedAt: Date.now(),
+      delivered: false
+    };
+    await this._store.appendConflict(conflictRecord);
+    const existing = await this._store.getDoc(mut.collection, mut.docId);
+    if (existing) {
+      await this._store.putDoc({
+        ...existing,
+        meta: { ...existing.meta, state: "synced", pendingMutationIds: [] }
+      });
+      busChanges.push({
+        type: "modified",
+        collection: mut.collection,
+        doc: { id: mut.docId, data: existing.data }
+      });
+    }
+    this._recordSyncError(
+      "push",
+      `muta\xE7\xE3o ${mut.mutationId} (${mut.collection}/${mut.docId}) descartada ap\xF3s ${mut.attempts + 1} tentativas: ${errMsg}`
+    );
+  }
+  /**
+   * `true` se a mutação (head do FIFO) ainda está dentro da janela de backoff
+   * desde a última tentativa falha. Só se aplica a mutações já tentadas
+   * (`attempts > 0` e `lastAttemptAt` carimbado).
+   */
+  _isInBackoff(mut) {
+    if (mut.attempts <= 0) return false;
+    const last = mut.lastAttemptAt;
+    if (typeof last !== "number") return false;
+    return Date.now() < last + this._backoffDelayMs(mut.attempts);
+  }
+  /** Backoff exponencial keyed em `attempts`, com teto `BACKOFF_CAP_MS`. */
+  _backoffDelayMs(attempts) {
+    return Math.min(BACKOFF_BASE_MS * 2 ** (attempts - 1), BACKOFF_CAP_MS);
+  }
   // ─── FASE 2 — pull (reconciliar o cache) ─────────────────────────────────────
   /**
    * Busca mudanças do servidor e aplica ao cache via ConflictResolver.
@@ -3041,10 +3188,14 @@ var SyncEngine = class {
     }
     const busChanges = [];
     await this._applyServerDocs(resyncResult.docs, busChanges, true);
+    const truncatedCollections = resyncResult.truncatedCollections ?? [];
+    const truncatedSet = new Set(truncatedCollections);
+    await this._store.setMeta(TRUNCATED_COLLECTIONS_META_KEY, truncatedCollections);
     const returnedKeys = new Set(
       resyncResult.docs.map((d) => `${d.collection}::${d.id}`)
     );
     for (const col of collections) {
+      if (truncatedSet.has(col)) continue;
       const queryResult = await this._store.listDocs(col, {});
       for (const { id } of queryResult.docs) {
         const key = `${col}::${id}`;
@@ -3204,7 +3355,8 @@ var SyncEngine = class {
       status: isOnline ? "idle" : "offline",
       pendingWrites: 0,
       lastSyncedAt: null,
-      isLeaderTab: this._tabCoordinator.isLeader()
+      isLeaderTab: this._tabCoordinator.isLeader(),
+      lastError: null
     };
   }
   /**
@@ -3214,7 +3366,7 @@ var SyncEngine = class {
   _updateState(partial) {
     const prev = this._state;
     const next = { ...prev, ...partial };
-    const changed = prev.status !== next.status || prev.pendingWrites !== next.pendingWrites || prev.lastSyncedAt !== next.lastSyncedAt || prev.isLeaderTab !== next.isLeaderTab;
+    const changed = prev.status !== next.status || prev.pendingWrites !== next.pendingWrites || prev.lastSyncedAt !== next.lastSyncedAt || prev.isLeaderTab !== next.isLeaderTab || (prev.lastError ?? null) !== (next.lastError ?? null);
     this._state = next;
     if (changed) {
       this._emitState(next);
@@ -3228,6 +3380,21 @@ var SyncEngine = class {
       }
     }
   }
+  /**
+   * P2-C: registra a falha de um ciclo de sync — antes engolida em silêncio.
+   * Publica em `SyncState.lastError` (visível via `onSyncStateChanged`) e
+   * dispara o hook `onError`. Nunca lança (diagnóstico é best-effort).
+   */
+  _recordSyncError(phase, message) {
+    this._updateState({ lastError: message });
+    const event = { phase, message, at: Date.now() };
+    for (const listener of this._errorListeners) {
+      try {
+        listener({ ...event });
+      } catch {
+      }
+    }
+  }
   /**
    * Atualiza `pendingWrites` no estado.
    * Chamado de forma assíncrona quando necessário.
@@ -4037,7 +4204,9 @@ var DbCollectionRefImpl = class {
     const isOnline = this._isOnline();
     const syncState = this._engine.getSyncState();
     const nextCursor = buildNextCursor(result.docs, effectiveLimit);
-    const stale = !isOnline || syncState.status === "offline";
+    const truncatedRaw = await this._store.getMeta(TRUNCATED_COLLECTIONS_META_KEY);
+    const truncated = Array.isArray(truncatedRaw) && truncatedRaw.includes(this._collection);
+    const stale = !isOnline || syncState.status === "offline" || truncated;
     const fromCache = hasPending || syncState.lastSyncedAt === null || stale;
     return {
       docs: result.docs.map((d) => ({ id: d.id, data: d.data })),
@@ -4045,7 +4214,8 @@ var DbCollectionRefImpl = class {
       fromCache,
       stale,
       hasPendingWrites: hasPending,
-      changes: []
+      changes: [],
+      truncated
     };
   }
   // ── CRUD ────────────────────────────────────────────────────────────────────
@@ -4491,6 +4661,9 @@ var NeetruDbDocumentsImpl = class {
   async getConflicts() {
     return this._store.listConflicts();
   }
+  onError(cb) {
+    return this._engine.onError(cb);
+  }
 };
 async function createOfflineDocumentsNamespace(opts) {
   const store = isIndexedDBUnavailable() ? new MemoryStore() : new LocalStore(opts.dbName);
@@ -4966,6 +5139,7 @@ var defaultWebSocketFactory = (url) => {
 // src/db/client-db.ts
 var DATASTORE_COLLECTION_ENDPOINT = (collection) => `/api/sdk/v1/datastore/${encodeURIComponent(collection)}`;
 var DATASTORE_DOC_ENDPOINT = (collection, docId) => `/api/sdk/v1/datastore/${encodeURIComponent(collection)}/${encodeURIComponent(docId)}`;
+var DOCUMENTS_RESYNC_PAGE_CAP = 200;
 function resolveTransport(transport, opts, config) {
   if (opts._transport) {
     return opts._transport;
@@ -5078,6 +5252,7 @@ function createRestSyncTransport(config) {
       const tenantHeaders = tenantScopeId ? { "x-neetru-tenant": tenantScopeId } : void 0;
       const now = Date.now();
       const docs = [];
+      const truncatedCollections = [];
       for (const collection of collections) {
         let raw;
         try {
@@ -5087,11 +5262,11 @@ function createRestSyncTransport(config) {
             requireAuth: true,
             retries: 2,
             headers: tenantHeaders,
-            // Teto do Core é 200. Coleções > 200 docs truncam silenciosamente
-            // aqui (paginação cursor é tarefa Core separada) — a detecção de
-            // deleção-por-ausência do SyncEngine NÃO deve rodar sobre truncamento,
-            // então mantemos o limite no máximo do servidor por ora.
-            query: { limit: 200 }
+            // Teto do Core (DOCUMENTS_RESYNC_PAGE_CAP). Coleções acima dele vêm
+            // TRUNCADAS — reportadas em `truncatedCollections` p/ o SyncEngine
+            // (a) NÃO rodar deleção-por-ausência e (b) sinalizar
+            // `DbListResult.truncated`. Paginação por cursor é tarefa Core (gated).
+            query: { limit: DOCUMENTS_RESYNC_PAGE_CAP }
           });
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
@@ -5102,6 +5277,9 @@ function createRestSyncTransport(config) {
         }
         const resp = raw;
         const items = Array.isArray(resp?.items) ? resp.items : [];
+        if (items.length >= DOCUMENTS_RESYNC_PAGE_CAP) {
+          truncatedCollections.push(collection);
+        }
         for (const item of items) {
           if (!item || typeof item !== "object") continue;
           const record = item;
@@ -5129,7 +5307,7 @@ function createRestSyncTransport(config) {
           });
         }
       }
-      return { docs, newWatermark: now };
+      return { docs, newWatermark: now, truncatedCollections };
     }
   };
 }
@@ -5191,20 +5369,20 @@ function buildTicketProvider(config, opts) {
     return ticket;
   };
 }
-var _hasWarnedMissingDbId = false;
-function warnMissingDbIdOnce(config, dbOpts) {
-  if (_hasWarnedMissingDbId) return;
-  if (dbOpts.dbId) return;
+var _hasWarnedDbIdIgnored = false;
+function warnDbIdIgnoredOnce(config, dbOpts) {
+  if (_hasWarnedDbIdIgnored) return;
+  if (!dbOpts.dbId) return;
   if (config.env === "prod") return;
   if (typeof window === "undefined") return;
   if (typeof console === "undefined" || typeof console.warn !== "function") return;
-  _hasWarnedMissingDbId = true;
+  _hasWarnedDbIdIgnored = true;
   console.warn(
-    "[neetru/sdk] client.db sem `dbId` expl\xEDcito: escritas client-side (add/set/update/remove/list) caem no datastore gen\xE9rico do Core, escopado por tenant/produto (header x-neetru-tenant) \u2014 `dbId` s\xF3 nomeia o cache offline LOCAL (IndexedDB), n\xE3o roteia nem escopa nada no servidor. Veja o JSDoc de NeetruDbOptions.dbId."
+    '[neetru/sdk] client.db recebeu `dbId` ("' + dbOpts.dbId + '") mas ele N\xC3O roteia nem escopa nada no servidor: as escritas do mundo Documentos (add/set/update/remove/list) SEMPRE caem no datastore gen\xE9rico do Core, escopado s\xF3 por tenant/produto (header x-neetru-tenant). `dbId` apenas nomeia o cache offline LOCAL (IndexedDB). ATEN\xC7\xC3O: usar dbIds distintos no MESMO tenant/produto N\xC3O isola os dados no servidor \u2014 eles se misturam (co-mingling). Veja o JSDoc de NeetruDbOptions.dbId.'
   );
 }
 function createNeetruDb(config, dbOpts = {}) {
-  warnMissingDbIdOnce(config, dbOpts);
+  warnDbIdIgnoredOnce(config, dbOpts);
   let resolvedTransport;
   if (dbOpts.transport !== void 0) {
     resolvedTransport = dbOpts.transport;
@@ -5282,6 +5460,20 @@ function createNeetruDb(config, dbOpts = {}) {
     async getConflicts() {
       const docs = await getDocsPromise();
       return docs.getConflicts();
+    },
+    onError(cb) {
+      if (_docsResolved) return _docsResolved.onError(cb);
+      let unsub = null;
+      let cancelled = false;
+      getDocsPromise().then((docs) => {
+        if (!cancelled) {
+          unsub = docs.onError(cb);
+        }
+      });
+      return () => {
+        cancelled = true;
+        unsub?.();
+      };
     }
   };
 }