@neetru/sdk 3.0.2 → 3.1.1

package/dist/auth.d.cts

@@ -1,5 +1,4 @@
-import { o as NeetruClientConfig, N as NeetruClient } from './types-Dc4bjrrt.cjs';
-import './collection-ref-BDdfD87k.cjs';
+import { B as NeetruClientConfig, z as NeetruClient } from './types-DePdSU3P.cjs';
 import 'drizzle-orm/node-postgres';
 import './errors.cjs';
 

package/dist/auth.d.ts

@@ -1,5 +1,4 @@
-import { o as NeetruClientConfig, N as NeetruClient } from './types-D7zVkO3n.js';
-import './collection-ref-BDdfD87k.js';
+import { B as NeetruClientConfig, z as NeetruClient } from './types-B3XFHD4A.js';
 import 'drizzle-orm/node-postgres';
 import './errors.js';
 

package/dist/auth.mjs

@@ -51,8 +51,47 @@ var init_idempotency = __esm({
 // src/http.ts
 var http_exports = {};
 __export(http_exports, {
+  checkCoreVersionCompat: () => checkCoreVersionCompat,
   httpRequest: () => httpRequest
 });
+function stripRevision(v) {
+  return v.split("+")[0] ?? v;
+}
+function compareCalVer(a, b) {
+  const partsA = stripRevision(a).split(".").map(Number);
+  const partsB = stripRevision(b).split(".").map(Number);
+  const len = Math.max(partsA.length, partsB.length);
+  for (let i = 0; i < len; i++) {
+    const pa = partsA[i] ?? 0;
+    const pb = partsB[i] ?? 0;
+    if (pa !== pb) return pa - pb;
+  }
+  return 0;
+}
+function getSdkMajor() {
+  try {
+    const ver = globalThis.__NEETRU_SDK_VERSION__;
+    if (ver) return parseInt(ver.split(".")[0] ?? "3", 10);
+  } catch {
+  }
+  return 3;
+}
+function checkCoreVersionCompat(coreVersion) {
+  if (!coreVersion) return;
+  const sdkMajor = getSdkMajor();
+  const minCore = COMPAT_MATRIX[sdkMajor];
+  if (!minCore) return;
+  const stripped = stripRevision(coreVersion);
+  if (compareCalVer(stripped, minCore) < 0) {
+    const key = `${sdkMajor}:${stripped}`;
+    if (!_warnedCoreTooOld.has(key)) {
+      _warnedCoreTooOld.add(key);
+      console.warn(
+        `[Neetru SDK] Aten\xE7\xE3o: Core vers\xE3o "${coreVersion}" \xE9 anterior ao m\xEDnimo recomendado "${minCore}" para SDK major ${sdkMajor}. Alguns recursos podem n\xE3o funcionar corretamente. Atualize o Core para a vers\xE3o mais recente.`
+      );
+    }
+  }
+}
 function backoffMs(attempt) {
   const base = 200 * Math.pow(4, attempt);
   const jitter = base * 0.2 * (Math.random() * 2 - 1);
@@ -61,11 +100,11 @@ function backoffMs(attempt) {
 function parseRetryAfter(value) {
   if (!value) return null;
   const secs = Number(value);
-  if (Number.isFinite(secs) && secs >= 0) return Math.round(secs * 1e3);
+  if (Number.isFinite(secs) && secs >= 0) return Math.min(Math.round(secs * 1e3), MAX_RETRY_AFTER_MS);
   const dateMs = Date.parse(value);
   if (Number.isFinite(dateMs)) {
     const delta = dateMs - Date.now();
-    if (delta > 0) return delta;
+    if (delta > 0) return Math.min(delta, MAX_RETRY_AFTER_MS);
   }
   return null;
 }
@@ -76,6 +115,7 @@ function statusToCode(status) {
   if (status === 401) return "unauthorized";
   if (status === 403) return "forbidden";
   if (status === 404) return "not_found";
+  if (status === 409) return "conflict";
   if (status === 422 || status === 400) return "validation_failed";
   if (status === 429) return "rate_limited";
   if (status >= 500) return "server_error";
@@ -147,6 +187,8 @@ async function httpRequest(config, opts) {
     }
     const requestId = res.headers.get("x-request-id") ?? res.headers.get("x-correlation-id") ?? void 0;
     if (res.ok) {
+      const coreVersion = res.headers.get("x-neetru-version");
+      if (coreVersion) checkCoreVersionCompat(coreVersion);
       const parsed = await safeJson(res);
       return parsed;
     }
@@ -175,11 +217,17 @@ async function httpRequest(config, opts) {
   }
   throw lastError ?? new NeetruError("unknown", "unexpected httpRequest exit");
 }
-var DEFAULT_RETRIES_READ, DEFAULT_RETRIES_WRITE, READ_METHODS, RETRYABLE_CODES;
+var COMPAT_MATRIX, _warnedCoreTooOld, DEFAULT_RETRIES_READ, DEFAULT_RETRIES_WRITE, READ_METHODS, RETRYABLE_CODES, MAX_RETRY_AFTER_MS;
 var init_http = __esm({
   "src/http.ts"() {
     init_errors();
     init_idempotency();
+    COMPAT_MATRIX = {
+      // SDK major 3.x requer Core ≥ 2026.05.1 (suporte a X-Neetru-Version header,
+      // runTransaction write-after-read, verifyWebhookRequest, webhooks 3.0+)
+      3: "2026.05.1"
+    };
+    _warnedCoreTooOld = /* @__PURE__ */ new Set();
     DEFAULT_RETRIES_READ = 2;
     DEFAULT_RETRIES_WRITE = 0;
     READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
@@ -188,6 +236,7 @@ var init_http = __esm({
       "server_error",
       "network_error"
     ]);
+    MAX_RETRY_AFTER_MS = 6e4;
   }
 });
 
@@ -889,11 +938,11 @@ var TRACK_MAX_QUEUE = 50;
 function createTelemetryNamespace(config) {
   const queue = [];
   let flushTimer = null;
+  let _inflightDrain = null;
   async function drainQueue() {
     if (queue.length === 0) return;
     const batch = queue.splice(0, queue.length);
-    flushTimer = null;
-    await Promise.allSettled(
+    const work = Promise.allSettled(
       batch.map(async (ev) => {
         try {
           const body = { name: ev.name };
@@ -915,6 +964,14 @@ function createTelemetryNamespace(config) {
         }
       })
     );
+    _inflightDrain = work.then(() => {
+      _inflightDrain = null;
+    });
+    await work;
+    flushTimer = null;
+    if (queue.length > 0) {
+      scheduleFlush();
+    }
   }
   function scheduleFlush() {
     if (flushTimer) return;
@@ -977,6 +1034,10 @@ function createTelemetryNamespace(config) {
       if (input.name.length > 128) return;
       queue.push(input);
       if (queue.length >= TRACK_MAX_QUEUE) {
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+          flushTimer = null;
+        }
         void drainQueue();
       } else {
         scheduleFlush();
@@ -991,6 +1052,7 @@ function createTelemetryNamespace(config) {
         clearTimeout(flushTimer);
         flushTimer = null;
       }
+      if (_inflightDrain) await _inflightDrain;
       await drainQueue();
     },
     /**
@@ -1479,6 +1541,31 @@ var LocalStore = class {
     this.db?.close();
     this.db = null;
   }
+  /**
+   * Apaga completamente o banco IndexedDB e o recria do zero.
+   *
+   * Ao contrário de `close()` + `open()` (que reabre o banco existente sem
+   * apagar dados), `clearAll()` chama `indexedDB.deleteDatabase(dbName)` e
+   * só então chama `open()` — garantindo que nenhum documento, mutação ou
+   * metadado sobrevive.
+   *
+   * BUG fix: `clearCache()` em `NeetruDbDocumentsImpl` chamava close+open,
+   * que reabre o mesmo banco. `clearAll()` é o método correto.
+   */
+  async clearAll() {
+    if (this.db !== null) {
+      this.db.close();
+      this.db = null;
+    }
+    await new Promise((resolve, reject) => {
+      const req = indexedDB.deleteDatabase(this.dbName);
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+      req.onblocked = () => {
+      };
+    });
+    await this.open();
+  }
   assertOpen() {
     if (this.db === null) {
       throw new Error("LocalStore: banco n\xE3o est\xE1 aberto. Chame open() primeiro.");
@@ -1686,6 +1773,12 @@ var MemoryStore = class {
   async open() {
   }
   async close() {
+  }
+  /**
+   * Apaga todos os dados em memória — equivalente ao `indexedDB.deleteDatabase`
+   * que `LocalStore.clearAll()` executa em ambientes com IndexedDB.
+   */
+  async clearAll() {
     this._docs.clear();
     this._mutations.clear();
     this._meta.clear();
@@ -2041,7 +2134,60 @@ var MutationQueue = class {
   }
 };
 
+// src/db/field-value.ts
+var NEETRU_SENTINEL_KEY = "__neetru__";
+function isFieldSentinel(v) {
+  return typeof v === "object" && v !== null && NEETRU_SENTINEL_KEY in v && typeof v[NEETRU_SENTINEL_KEY] === "string";
+}
+function isServerTimestampSentinel(v) {
+  return isFieldSentinel(v) && v.__neetru__ === "serverTimestamp";
+}
+function isIncrementSentinel(v) {
+  return isFieldSentinel(v) && v.__neetru__ === "increment" && typeof v.operand === "number" && Number.isFinite(v.operand);
+}
+function resolveSentinelLocally(value, baseValue) {
+  if (isServerTimestampSentinel(value)) {
+    return Date.now();
+  }
+  if (isIncrementSentinel(value)) {
+    const base = typeof baseValue === "number" && Number.isFinite(baseValue) ? baseValue : 0;
+    return base + value.operand;
+  }
+  return value;
+}
+function resolveSentinelsLocally(data, existing) {
+  let touched = false;
+  const out = {};
+  for (const [k, v] of Object.entries(data)) {
+    if (isFieldSentinel(v)) {
+      touched = true;
+      out[k] = resolveSentinelLocally(v, existing?.[k]);
+    } else {
+      out[k] = v;
+    }
+  }
+  return touched ? out : data;
+}
+function hasFieldSentinel(data) {
+  for (const v of Object.values(data)) {
+    if (isFieldSentinel(v)) return true;
+  }
+  return false;
+}
+
 // src/db/offline/sync-engine.ts
+function hasSentinels(payload) {
+  return payload !== null && hasFieldSentinel(payload);
+}
+function sanitizeSentinelPayload(payload) {
+  if (payload === null) return null;
+  if (!hasFieldSentinel(payload)) return payload;
+  const out = {};
+  for (const [k, v] of Object.entries(payload)) {
+    if (!isFieldSentinel(v)) out[k] = v;
+  }
+  return out;
+}
 var SyncEngine = class {
   _store;
   _queue;
@@ -2147,6 +2293,8 @@ var SyncEngine = class {
       const phase1Ok = await this._phase1Push();
       if (!phase1Ok) {
         this._updateState({ status: "idle" });
+        this._refreshPendingWrites().catch(() => {
+        });
         this._syncing = false;
         return;
       }
@@ -2249,11 +2397,16 @@ var SyncEngine = class {
       }
       return;
     }
-    const newData = mut.payload ?? (existing?.data ?? {});
+    const literalPayload = sanitizeSentinelPayload(mut.payload);
+    const newData = literalPayload ?? (existing?.data ?? {});
     const updatedDoc = {
       collection,
       id: docId,
-      data: mut.op === "update" ? { ...existing?.data ?? {}, ...newData } : newData,
+      data: mut.op === "update" ? { ...existing?.data ?? {}, ...newData } : (
+        // add/set: se o payload tinha sentinels, o cache otimista (existing.data)
+        // é a fonte de verdade até o pull; senão usa o payload literal.
+        hasSentinels(mut.payload) ? { ...existing?.data ?? {}, ...newData } : newData
+      ),
       meta: {
         serverVersion,
         updatedAtServer: serverTimestamp,
@@ -2528,7 +2681,7 @@ var SyncEngine = class {
             ownerId: localDoc.meta.ownerId
           }
         };
-        const pendingMuts = await this._queue.drain();
+        const pendingMuts = await this._queue.listAll();
         const docMut = pendingMuts.find(
           (m) => m.collection === serverDoc.collection && m.docId === serverDoc.id
         );
@@ -3335,43 +3488,6 @@ var TabCoordinator = class {
 
 // src/db/collection-ref.ts
 init_db_errors();
-
-// src/db/field-value.ts
-var NEETRU_SENTINEL_KEY = "__neetru__";
-function isFieldSentinel(v) {
-  return typeof v === "object" && v !== null && NEETRU_SENTINEL_KEY in v && typeof v[NEETRU_SENTINEL_KEY] === "string";
-}
-function isServerTimestampSentinel(v) {
-  return isFieldSentinel(v) && v.__neetru__ === "serverTimestamp";
-}
-function isIncrementSentinel(v) {
-  return isFieldSentinel(v) && v.__neetru__ === "increment" && typeof v.operand === "number" && Number.isFinite(v.operand);
-}
-function resolveSentinelLocally(value, baseValue) {
-  if (isServerTimestampSentinel(value)) {
-    return Date.now();
-  }
-  if (isIncrementSentinel(value)) {
-    const base = typeof baseValue === "number" && Number.isFinite(baseValue) ? baseValue : 0;
-    return base + value.operand;
-  }
-  return value;
-}
-function resolveSentinelsLocally(data, existing) {
-  let touched = false;
-  const out = {};
-  for (const [k, v] of Object.entries(data)) {
-    if (isFieldSentinel(v)) {
-      touched = true;
-      out[k] = resolveSentinelLocally(v, existing?.[k]);
-    } else {
-      out[k] = v;
-    }
-  }
-  return touched ? out : data;
-}
-
-// src/db/collection-ref.ts
 function isIndexedDBUnavailable() {
   return typeof indexedDB === "undefined" || typeof window === "undefined";
 }
@@ -3919,8 +4035,13 @@ var NeetruDbDocumentsImpl = class {
     return this._engine.flush();
   }
   async clearCache() {
-    await this._store.close();
-    await this._store.open();
+    const storeWithClear = this._store;
+    if (typeof storeWithClear.clearAll === "function") {
+      await storeWithClear.clearAll();
+    } else {
+      await this._store.close();
+      await this._store.open();
+    }
   }
   async getConflicts() {
     return this._store.listConflicts();
@@ -4807,7 +4928,8 @@ function createHttpCheckoutNamespace(config) {
         method: "POST",
         path: "/api/v1/checkout/intents",
         body,
-        requireAuth: true
+        requireAuth: true,
+        idempotencyKey: true
       });
       const result = parseStartResponse(raw);
       const shouldRedirect = input.autoRedirect !== false;
@@ -5562,6 +5684,7 @@ function createOidcAuthNamespace(config) {
   const STORAGE_KEY = "neetru_id_token";
   const listeners = /* @__PURE__ */ new Set();
   let cachedUser = null;
+  let _expiryTimerId = null;
   function getStorage() {
     try {
       return typeof globalThis.localStorage !== "undefined" ? globalThis.localStorage : null;
@@ -5584,6 +5707,9 @@ function createOidcAuthNamespace(config) {
   function tokenToUser(token) {
     const payload = decodeJwtPayload(token);
     if (!payload || typeof payload.sub !== "string") return null;
+    if (typeof payload.exp === "number" && payload.exp * 1e3 < Date.now()) {
+      return null;
+    }
     return {
       uid: payload.sub,
       email: typeof payload.email === "string" ? payload.email : "",
@@ -5597,12 +5723,28 @@ function createOidcAuthNamespace(config) {
     };
   }
   function loadCachedUser() {
-    if (cachedUser) return cachedUser;
+    if (cachedUser) {
+      const exp = cachedUser.exp;
+      if (typeof exp === "number" && exp * 1e3 < Date.now()) {
+        cachedUser = null;
+        const storage2 = getStorage();
+        storage2?.removeItem(STORAGE_KEY);
+        notify();
+        return null;
+      }
+      return cachedUser;
+    }
     const storage = getStorage();
     if (!storage) return null;
     const token = storage.getItem(STORAGE_KEY);
     if (!token) return null;
-    cachedUser = tokenToUser(token);
+    const user = tokenToUser(token);
+    if (!user) {
+      storage.removeItem(STORAGE_KEY);
+      return null;
+    }
+    cachedUser = user;
+    scheduleExpiryTimer(user);
     return cachedUser;
   }
   function notify() {
@@ -5613,6 +5755,23 @@ function createOidcAuthNamespace(config) {
       }
     }
   }
+  function cancelExpiryTimer() {
+    if (_expiryTimerId !== null) {
+      clearTimeout(_expiryTimerId);
+      _expiryTimerId = null;
+    }
+  }
+  function scheduleExpiryTimer(user) {
+    cancelExpiryTimer();
+    const exp = user.exp;
+    if (typeof exp !== "number") return;
+    const msUntilExpiry = exp * 1e3 - Date.now();
+    if (msUntilExpiry <= 0) return;
+    _expiryTimerId = setTimeout(() => {
+      _expiryTimerId = null;
+      loadCachedUser();
+    }, msUntilExpiry + 1);
+  }
   return {
     async signIn(options) {
       if (typeof globalThis.location !== "undefined" && typeof globalThis.location.assign === "function") {
@@ -5640,18 +5799,24 @@ function createOidcAuthNamespace(config) {
     },
     async signOut() {
       const storage = getStorage();
+      const storedToken = storage?.getItem(STORAGE_KEY) ?? null;
       if (storage) storage.removeItem(STORAGE_KEY);
+      cancelExpiryTimer();
       cachedUser = null;
       const overrideAuthUrl = typeof globalThis.NEETRU_AUTH_URL === "string" ? globalThis.NEETRU_AUTH_URL : null;
       const idpOrigin = overrideAuthUrl ?? config.baseUrl.replace(/^https?:\/\/api\./, "https://auth.");
       const revokeUrl = `${idpOrigin}/api/v1/oauth/revoke`;
+      const revokeBody = storedToken ? JSON.stringify({ token: storedToken }) : null;
       let revokeError = null;
       for (let attempt = 0; attempt < 2; attempt++) {
         try {
-          await config.fetch(revokeUrl, {
-            method: "POST",
-            headers: { "content-type": "application/json" }
-          });
+          if (revokeBody) {
+            await config.fetch(revokeUrl, {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: revokeBody
+            });
+          }
           revokeError = null;
           break;
         } catch (err) {