@neetru/sdk 3.4.0 → 3.4.1

package/dist/db.d.cts

@@ -1,3 +1,3 @@
-export { w as ConflictRecord, x as CreateOfflineDocumentsOptions, z as DbBatchOp, B as DbChangeType, E as DbCollectionRef, F as DbDoc, G as DbDocRef, H as DbGetResult, I as DbListResult, K as DbQuery, L as DbSqlLease, N as DbWhereFilter, P as FieldSentinel, Q as IncrementSentinel, V as NEETRU_SENTINEL_KEY, Y as NeetruDb, Z as NeetruDbDocuments, _ as NeetruDbEngine, $ as NeetruDbError, a0 as NeetruDbErrorCode, a1 as NeetruDbOptions, a2 as NeetruDbTransport, a4 as NeetruSqlClient, ad as RealtimeTransport, ai as ServerTimestampSentinel, ak as SqlOptions, ap as SyncState, aG as WithFieldSentinels, aH as __resetDbIdWarningForTests, aK as createNeetruDb, aM as createRestSyncTransport, aO as getWebSocketRealtimeClient, aP as increment, aQ as isFieldSentinel, aR as isIncrementSentinel, aS as isServerTimestampSentinel, aT as serverTimestamp } from './types-BoFSCHF_.cjs';
+export { w as ConflictRecord, x as CreateOfflineDocumentsOptions, z as DbBatchOp, B as DbChangeType, E as DbCollectionRef, F as DbDoc, G as DbDocRef, H as DbGetResult, I as DbListResult, K as DbQuery, L as DbSqlLease, N as DbWhereFilter, P as FieldSentinel, Q as IncrementSentinel, V as NEETRU_SENTINEL_KEY, Y as NeetruDb, Z as NeetruDbDocuments, _ as NeetruDbEngine, $ as NeetruDbError, a0 as NeetruDbErrorCode, a1 as NeetruDbOptions, a2 as NeetruDbTransport, a4 as NeetruSqlClient, ad as RealtimeTransport, ai as ServerTimestampSentinel, ak as SqlOptions, ap as SyncErrorEvent, aq as SyncState, aH as WithFieldSentinels, aI as __resetDbIdWarningForTests, aL as createNeetruDb, aN as createRestSyncTransport, aP as getWebSocketRealtimeClient, aQ as increment, aR as isFieldSentinel, aS as isIncrementSentinel, aT as isServerTimestampSentinel, aU as serverTimestamp } from './types-D-QdG502.cjs';
 import 'drizzle-orm/node-postgres';
 import './errors.cjs';

package/dist/db.d.ts

@@ -1,3 +1,3 @@
-export { w as ConflictRecord, x as CreateOfflineDocumentsOptions, z as DbBatchOp, B as DbChangeType, E as DbCollectionRef, F as DbDoc, G as DbDocRef, H as DbGetResult, I as DbListResult, K as DbQuery, L as DbSqlLease, N as DbWhereFilter, P as FieldSentinel, Q as IncrementSentinel, V as NEETRU_SENTINEL_KEY, Y as NeetruDb, Z as NeetruDbDocuments, _ as NeetruDbEngine, $ as NeetruDbError, a0 as NeetruDbErrorCode, a1 as NeetruDbOptions, a2 as NeetruDbTransport, a4 as NeetruSqlClient, ad as RealtimeTransport, ai as ServerTimestampSentinel, ak as SqlOptions, ap as SyncState, aG as WithFieldSentinels, aH as __resetDbIdWarningForTests, aK as createNeetruDb, aM as createRestSyncTransport, aO as getWebSocketRealtimeClient, aP as increment, aQ as isFieldSentinel, aR as isIncrementSentinel, aS as isServerTimestampSentinel, aT as serverTimestamp } from './types-DdJyqBy-.js';
+export { w as ConflictRecord, x as CreateOfflineDocumentsOptions, z as DbBatchOp, B as DbChangeType, E as DbCollectionRef, F as DbDoc, G as DbDocRef, H as DbGetResult, I as DbListResult, K as DbQuery, L as DbSqlLease, N as DbWhereFilter, P as FieldSentinel, Q as IncrementSentinel, V as NEETRU_SENTINEL_KEY, Y as NeetruDb, Z as NeetruDbDocuments, _ as NeetruDbEngine, $ as NeetruDbError, a0 as NeetruDbErrorCode, a1 as NeetruDbOptions, a2 as NeetruDbTransport, a4 as NeetruSqlClient, ad as RealtimeTransport, ai as ServerTimestampSentinel, ak as SqlOptions, ap as SyncErrorEvent, aq as SyncState, aH as WithFieldSentinels, aI as __resetDbIdWarningForTests, aL as createNeetruDb, aN as createRestSyncTransport, aP as getWebSocketRealtimeClient, aQ as increment, aR as isFieldSentinel, aS as isIncrementSentinel, aT as isServerTimestampSentinel, aU as serverTimestamp } from './types-BlOLDMR0.js';
 import 'drizzle-orm/node-postgres';
 import './errors.js';

package/dist/db.mjs

@@ -1734,8 +1734,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);
@@ -1744,12 +1746,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);
@@ -1758,9 +1762,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
@@ -1816,6 +1835,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);
 }
@@ -1850,6 +1873,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. */
@@ -1908,6 +1933,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.
@@ -1940,8 +1978,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;
@@ -1976,6 +2016,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);
     }
@@ -1983,10 +2026,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 = [];
@@ -2013,8 +2062,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);
@@ -2206,6 +2263,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.
@@ -2245,10 +2363,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}`;
@@ -2408,7 +2530,8 @@ var SyncEngine = class {
       status: isOnline ? "idle" : "offline",
       pendingWrites: 0,
       lastSyncedAt: null,
-      isLeaderTab: this._tabCoordinator.isLeader()
+      isLeaderTab: this._tabCoordinator.isLeader(),
+      lastError: null
     };
   }
   /**
@@ -2418,7 +2541,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);
@@ -2432,6 +2555,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.
@@ -3241,7 +3379,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 })),
@@ -3249,7 +3389,8 @@ var DbCollectionRefImpl = class {
       fromCache,
       stale,
       hasPendingWrites: hasPending,
-      changes: []
+      changes: [],
+      truncated
     };
   }
   // ── CRUD ────────────────────────────────────────────────────────────────────
@@ -3695,6 +3836,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);
@@ -4171,6 +4315,7 @@ var defaultWebSocketFactory = (url) => {
 init_db_errors();
 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;
@@ -4283,6 +4428,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 {
@@ -4292,11 +4438,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);
@@ -4307,6 +4453,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;
@@ -4334,7 +4483,7 @@ function createRestSyncTransport(config) {
           });
         }
       }
-      return { docs, newWatermark: now };
+      return { docs, newWatermark: now, truncatedCollections };
     }
   };
 }
@@ -4399,23 +4548,23 @@ function buildTicketProvider(config, opts) {
 function getWebSocketRealtimeClient(gatewayUrl, ticketProvider, dbId, wsFactory) {
   return new NeetruRealtimeClient({ gatewayUrl, ticketProvider, dbId, webSocketFactory: wsFactory });
 }
-var _hasWarnedMissingDbId = false;
+var _hasWarnedDbIdIgnored = false;
 function __resetDbIdWarningForTests() {
-  _hasWarnedMissingDbId = false;
+  _hasWarnedDbIdIgnored = false;
 }
-function warnMissingDbIdOnce(config, dbOpts) {
-  if (_hasWarnedMissingDbId) return;
-  if (dbOpts.dbId) return;
+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;
@@ -4493,6 +4642,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?.();
+      };
     }
   };
 }