@neetru/sdk 3.1.7 → 3.1.10

package/dist/auth.d.cts

@@ -1,4 +1,4 @@
-import { G as NeetruClientConfig, B as NeetruClient } from './types-BXvGHppn.cjs';
+import { S as NeetruClientConfig, R as NeetruClient } from './types-Cog9S-tC.cjs';
 import 'drizzle-orm/node-postgres';
 import './errors.cjs';
 

package/dist/auth.d.ts

@@ -1,4 +1,4 @@
-import { G as NeetruClientConfig, B as NeetruClient } from './types-CQVak2a3.js';
+import { S as NeetruClientConfig, R as NeetruClient } from './types-dagUxKYz.js';
 import 'drizzle-orm/node-postgres';
 import './errors.js';
 

package/dist/auth.mjs

@@ -446,7 +446,7 @@ __export(sql_client_exports, {
 function mapEnvToCore(sdkEnv) {
   if (sdkEnv === "workspace") return "staging";
   if (sdkEnv === "prod") return "production";
-  return "dev";
+  return "dev-local";
 }
 function createHttpLeaseFetcher(config) {
   return async (opts) => {
@@ -955,7 +955,11 @@ function createTelemetryNamespace(config) {
             path: "/api/sdk/v1/telemetry/event",
             body,
             requireAuth: true,
-            retries: 1
+            retries: 1,
+            // caça-bruxas: retry sem Idempotency-Key duplicava o evento se o
+            // servidor já tinha persistido antes da falha transiente. Mesmo
+            // padrão do usage.report (key estável por chamada, reusada no retry).
+            idempotencyKey: true
           });
         } catch (err) {
           if (typeof console !== "undefined") {
@@ -1159,8 +1163,8 @@ function createUsageNamespace(config) {
       if (!resource || typeof resource !== "string") {
         throw new NeetruError("validation_failed", "resource is required");
       }
-      if (!Number.isFinite(qty) || qty <= 0) {
-        throw new NeetruError("validation_failed", "qty must be positive integer");
+      if (!Number.isFinite(qty) || qty <= 0 || !Number.isInteger(qty)) {
+        throw new NeetruError("validation_failed", "qty must be a positive integer");
       }
       const productId = options?.productId ?? config.productId;
       const tenantId = options?.tenantId ?? config.tenantId;
@@ -1409,7 +1413,12 @@ function evaluateFilter(data, filter) {
       if (!Array.isArray(value)) return true;
       return !value.includes(fieldValue);
     default:
-      return false;
+      if (op === "array-contains-any") {
+        return Array.isArray(fieldValue) && Array.isArray(value) && value.some((v) => fieldValue.includes(v));
+      }
+      throw new Error(
+        `QueryEngine: operador de filtro '${String(op)}' n\xE3o suportado em leitura offline/cache. Use um operador suportado (==, !=, <, <=, >, >=, array-contains, array-contains-any, in, not-in) ou fa\xE7a a query server-side.`
+      );
   }
 }
 function matchesAllFilters(data, filters) {
@@ -1939,7 +1948,7 @@ var MutationQueue = class {
    *   - `{ removed: true }`       — a mutação existente deve ser deletada (add+remove)
    *   - `null`                    — não é possível coalescir
    */
-  tryCoalesce(existing, newOp, newPayload, newBatchId) {
+  tryCoalesce(existing, newOp, newPayload, newBatchId, newUpsert) {
     if (existing.batchId !== newBatchId) return null;
     if (existing.status === "inflight") return null;
     const existingOp = existing.op;
@@ -1947,10 +1956,12 @@ var MutationQueue = class {
       return { removed: true };
     }
     if (existingOp === "update" && newOp === "update") {
+      const mergedUpsert = existing.upsert || newUpsert;
       return {
         coalesced: {
           ...existing,
-          payload: { ...existing.payload ?? {}, ...newPayload ?? {} }
+          payload: { ...existing.payload ?? {}, ...newPayload ?? {} },
+          ...mergedUpsert ? { upsert: true } : {}
         }
       };
     }
@@ -1999,13 +2010,13 @@ var MutationQueue = class {
    * Atômico: a persistência final é uma única operação putMutation.
    */
   async enqueue(params) {
-    const { collection, op, payload, baseVersion, batchId } = params;
+    const { collection, op, payload, baseVersion, batchId, upsert } = params;
     const docId = params.docId ?? (op === "add" ? generateUUIDv4() : "");
     await this.syncSeq();
     const existingMutations = await this.store.listMutations({ collection, docId });
     const lastQueued = existingMutations.filter((m) => m.status === "queued").sort((a, b) => b.seq - a.seq)[0];
     if (lastQueued !== void 0) {
-      const coalesceResult = this.tryCoalesce(lastQueued, op, payload, batchId);
+      const coalesceResult = this.tryCoalesce(lastQueued, op, payload, batchId, upsert);
       if (coalesceResult !== null) {
         if ("removed" in coalesceResult) {
           await this.store.deleteMutation(lastQueued.mutationId);
@@ -2043,7 +2054,9 @@ var MutationQueue = class {
       attempts: 0,
       lastError: null,
       status: "queued",
-      batchId
+      batchId,
+      // bug_0273e4dd: só persiste o flag quando verdadeiro (mantém o doc limpo).
+      ...upsert ? { upsert: true } : {}
     };
     await this.store.putMutation(mutation);
     return mutation;
@@ -2372,10 +2385,15 @@ var SyncEngine = class {
         await this._applyRejected(mut, res, busChanges);
       }
     }
+    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 (busChanges.length > 0) {
       this._bus.emit(busChanges);
     }
-    return true;
+    return unprocessed.length === 0;
   }
   /** Atualiza o cache após confirmação de escrita (outcome=confirmed). */
   async _applySyncedDoc(collection, docId, serverVersion, serverTimestamp, mut, busChanges) {
@@ -3682,7 +3700,7 @@ var DbCollectionRefImpl = class {
     }]);
     return { ok: true };
   }
-  async update(id, data) {
+  async update(id, data, opts) {
     assertValidId(id);
     const existing = await this._store.getDoc(this._collection, id);
     const rawData = data;
@@ -3695,7 +3713,9 @@ var DbCollectionRefImpl = class {
       op: "update",
       payload: rawData,
       baseVersion: existing?.meta.serverVersion ?? null,
-      batchId: null
+      batchId: null,
+      // bug_0273e4dd: propaga merge-upsert (setDoc({merge:true}) cria-se-ausente).
+      upsert: opts?.upsert
     });
     await this._store.putDoc({
       collection: this._collection,
@@ -3819,7 +3839,9 @@ var DbCollectionRefImpl = class {
           op: "update",
           payload: data,
           baseVersion: existing?.meta.serverVersion ?? null,
-          batchId
+          batchId,
+          // bug_0273e4dd: propaga merge-upsert (writeBatch.set(merge) cria-se-ausente).
+          upsert: op.upsert
         });
         await this._store.putDoc({
           collection,
@@ -4081,6 +4103,10 @@ async function createOfflineDocumentsNamespace(opts) {
     connectivity,
     periodicSyncIntervalMs: opts.periodicSyncIntervalMs ?? 5 * 60 * 1e3
   });
+  connectivity.start();
+  if (!opts.singleTab && tabCoordinatorLike instanceof TabCoordinator) {
+    tabCoordinatorLike.start();
+  }
   return new NeetruDbDocumentsImpl({
     store,
     queue,
@@ -4550,11 +4576,11 @@ function createRestSyncTransport(config) {
           let raw;
           if (m.op === "add") {
             raw = await httpRequest2(config, {
-              method: "POST",
-              path: DATASTORE_COLLECTION_ENDPOINT(m.collection),
+              method: "PUT",
+              path: DATASTORE_DOC_ENDPOINT(m.collection, m.docId),
               body: { data: m.payload ?? {} },
               requireAuth: true,
-              retries: 0,
+              retries: 2,
               headers: tenantHeaders
             });
           } else if (m.op === "set") {
@@ -4570,7 +4596,7 @@ function createRestSyncTransport(config) {
             raw = await httpRequest2(config, {
               method: "PATCH",
               path: DATASTORE_DOC_ENDPOINT(m.collection, m.docId),
-              body: { data: m.payload ?? {} },
+              body: { data: m.payload ?? {}, ...m.upsert ? { upsert: true } : {} },
               requireAuth: true,
               retries: 2,
               headers: tenantHeaders
@@ -4593,7 +4619,24 @@ function createRestSyncTransport(config) {
           });
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
-          throw new NeetruDbError("db_unavailable", `pushMutations falhou: ${msg}`);
+          const code = err?.code;
+          const status = err?.status;
+          const isPermanent = code === "forbidden" || code === "unauthorized" || code === "not_found" || code === "conflict" || code === "validation_failed" || typeof status === "number" && status >= 400 && status < 500 && status !== 408 && status !== 429;
+          if (isPermanent) {
+            const reason = code === "forbidden" || code === "unauthorized" ? "rejected_permission" : "rejected_validation";
+            results.push({
+              mutationId: m.mutationId,
+              outcome: "rejected",
+              reason,
+              serverVersion: null,
+              serverData: null
+            });
+            continue;
+          }
+          if (results.length === 0) {
+            throw new NeetruDbError("db_unavailable", `pushMutations falhou: ${msg}`);
+          }
+          break;
         }
       }
       return { results };
@@ -5454,6 +5497,235 @@ var MockNotifications = class {
   }
 };
 
+// src/ai.ts
+init_errors();
+init_http();
+var AI_CHAT_PATH = "/api/sdk/v1/ai/chat";
+var AI_NONSTREAM_TIMEOUT_MS = 12e4;
+function resolveAiBody(config, opts, stream) {
+  if (!opts || typeof opts !== "object") {
+    throw new NeetruError("validation_failed", "ai: options object is required");
+  }
+  if (typeof opts.model !== "string" || opts.model.length === 0) {
+    throw new NeetruError("validation_failed", "ai: model is required");
+  }
+  if (!Array.isArray(opts.messages) || opts.messages.length === 0) {
+    throw new NeetruError("validation_failed", "ai: messages must be a non-empty array");
+  }
+  for (const m of opts.messages) {
+    if (!m || typeof m !== "object" || typeof m.role !== "string" || m.role.length === 0 || typeof m.content !== "string") {
+      throw new NeetruError(
+        "validation_failed",
+        "ai: each message must be { role: string, content: string }"
+      );
+    }
+  }
+  const productId = opts.productId ?? config.productId;
+  const tenantId = opts.tenantId ?? config.tenantId;
+  if (!productId) {
+    throw new NeetruError(
+      "validation_failed",
+      "ai: productId required (pass to options or set on createNeetruClient)"
+    );
+  }
+  if (!tenantId) {
+    throw new NeetruError(
+      "validation_failed",
+      "ai: tenantId required (pass to options or set on createNeetruClient)"
+    );
+  }
+  assertValidSdkId("productId", productId);
+  assertValidSdkId("tenantId", tenantId);
+  const body = {
+    productId,
+    tenantId,
+    model: opts.model,
+    messages: opts.messages,
+    stream
+  };
+  if (opts.maxTokens !== void 0) {
+    if (!Number.isInteger(opts.maxTokens) || opts.maxTokens <= 0) {
+      throw new NeetruError("validation_failed", "ai: maxTokens must be a positive integer");
+    }
+    body.maxTokens = opts.maxTokens;
+  }
+  if (opts.temperature !== void 0) {
+    if (typeof opts.temperature !== "number" || !Number.isFinite(opts.temperature)) {
+      throw new NeetruError("validation_failed", "ai: temperature must be a finite number");
+    }
+    body.temperature = opts.temperature;
+  }
+  return body;
+}
+async function safeJson2(res) {
+  try {
+    const text = await res.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function statusToCode2(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";
+  return "unknown";
+}
+function joinUrl(baseUrl, path) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${p}`;
+}
+async function aiFetch(config, body, signal, stream) {
+  if (!config.apiKey) {
+    throw new NeetruError(
+      "missing_api_key",
+      "ai requires an apiKey. Pass it to createNeetruClient({ apiKey }) or set NEETRU_API_KEY env var."
+    );
+  }
+  const url = joinUrl(config.baseUrl, AI_CHAT_PATH);
+  const headers = {
+    "content-type": "application/json",
+    accept: stream ? "text/event-stream" : "application/json",
+    authorization: `Bearer ${config.apiKey}`
+  };
+  const init = { method: "POST", headers, body: JSON.stringify(body) };
+  if (stream) {
+    if (signal) init.signal = signal;
+  } else {
+    init.signal = signal ?? AbortSignal.timeout(AI_NONSTREAM_TIMEOUT_MS);
+  }
+  let res;
+  try {
+    res = await config.fetch(url, init);
+  } catch (err) {
+    const message = err instanceof DOMException && err.name === "TimeoutError" ? `Network error: timeout after ${AI_NONSTREAM_TIMEOUT_MS / 1e3}s` : err instanceof DOMException && err.name === "AbortError" ? "Network error: request aborted" : `Network error: ${err instanceof Error ? err.message : "fetch failed"}`;
+    throw new NeetruError("network_error", message);
+  }
+  const requestId = res.headers.get("x-request-id") ?? res.headers.get("x-correlation-id") ?? void 0;
+  if (!res.ok) {
+    const parsed = await safeJson2(res);
+    let code = statusToCode2(res.status);
+    let message = `HTTP ${res.status}`;
+    if (parsed && typeof parsed === "object" && "error" in parsed) {
+      const errField = parsed.error;
+      if (typeof errField === "string") {
+        message = errField;
+      } else if (errField && typeof errField === "object") {
+        if (typeof errField.code === "string") code = errField.code;
+        if (typeof errField.message === "string") message = errField.message;
+      }
+    }
+    throw new NeetruError(code, message, res.status, requestId);
+  }
+  const coreVersion = res.headers.get("x-neetru-version");
+  if (coreVersion) checkCoreVersionCompat(coreVersion);
+  return res;
+}
+function readMeta(res) {
+  return {
+    provider: res.headers.get("x-neetru-provider") ?? "",
+    usageWarning: res.headers.get("x-neetru-ai-usage-warning") === "1"
+  };
+}
+function parseSseData(rawEvent) {
+  const dataLines = [];
+  for (const line of rawEvent.split("\n")) {
+    const trimmed = line.replace(/\r$/, "");
+    if (trimmed.startsWith("data:")) {
+      let v = trimmed.slice(5);
+      if (v.startsWith(" ")) v = v.slice(1);
+      dataLines.push(v);
+    }
+  }
+  if (dataLines.length === 0) return null;
+  const payload = dataLines.join("\n");
+  if (payload === "[DONE]") return { done: true };
+  try {
+    const obj = JSON.parse(payload);
+    const content = obj?.choices?.[0]?.delta?.content;
+    if (typeof content === "string" && content.length > 0) return { content };
+    return null;
+  } catch {
+    return null;
+  }
+}
+function createAiNamespace(config) {
+  return {
+    async chat(opts) {
+      const body = resolveAiBody(config, opts, false);
+      const res = await aiFetch(config, body, opts.signal, false);
+      const { provider: providerHeader, usageWarning } = readMeta(res);
+      const raw = await safeJson2(res);
+      if (!raw || raw.ok !== true || !Array.isArray(raw.choices)) {
+        throw new NeetruError("invalid_response", "ai.chat response missing ok/choices");
+      }
+      return {
+        choices: raw.choices,
+        usage: raw.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+        model: raw.model ?? opts.model,
+        provider: raw.provider ?? providerHeader ?? "",
+        usageWarning
+      };
+    },
+    stream(opts) {
+      const body = resolveAiBody(config, opts, true);
+      const responsePromise = aiFetch(config, body, opts.signal, true);
+      const meta = responsePromise.then(readMeta);
+      meta.catch(() => {
+      });
+      async function* iterate() {
+        const res = await responsePromise;
+        const stream = res.body;
+        if (!stream) {
+          throw new NeetruError("invalid_response", "ai.stream: response has no body");
+        }
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            let sep;
+            while ((sep = buffer.indexOf("\n\n")) !== -1) {
+              const rawEvent = buffer.slice(0, sep);
+              buffer = buffer.slice(sep + 2);
+              const parsed = parseSseData(rawEvent);
+              if (parsed && "done" in parsed) return;
+              if (parsed && "content" in parsed) yield parsed.content;
+            }
+          }
+          const tail = buffer.trim();
+          if (tail) {
+            const parsed = parseSseData(tail);
+            if (parsed && "content" in parsed) yield parsed.content;
+          }
+        } finally {
+          try {
+            reader.releaseLock();
+          } catch {
+          }
+          try {
+            await stream.cancel();
+          } catch {
+          }
+        }
+      }
+      return {
+        meta,
+        [Symbol.asyncIterator]: iterate
+      };
+    }
+  };
+}
+
 // src/mocks.ts
 init_errors();
 var DEV_FIXTURE_USER = Object.freeze({
@@ -5739,6 +6011,57 @@ var MockEntitlements = class {
     this._denied.clear();
   }
 };
+var MockAi = class {
+  _calls = [];
+  _reply(opts) {
+    const last = [...opts.messages].reverse().find((m) => m.role === "user") ?? opts.messages[opts.messages.length - 1];
+    const content = last?.content ?? "";
+    return content ? `mock-reply: ${content}` : "mock-reply";
+  }
+  async chat(opts) {
+    if (!opts || typeof opts.model !== "string" || opts.model.length === 0) {
+      throw new NeetruError("validation_failed", "ai: model is required");
+    }
+    if (!Array.isArray(opts.messages) || opts.messages.length === 0) {
+      throw new NeetruError("validation_failed", "ai: messages must be a non-empty array");
+    }
+    this._calls.push({ model: opts.model, messages: opts.messages, stream: false });
+    const text = this._reply(opts);
+    const promptTokens = opts.messages.reduce((n, m) => n + (m.content?.length ?? 0), 0);
+    const completionTokens = text.length;
+    return {
+      choices: [{ message: { role: "assistant", content: text }, finish_reason: "stop" }],
+      usage: {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens
+      },
+      model: opts.model,
+      provider: "mock",
+      usageWarning: false
+    };
+  }
+  stream(opts) {
+    if (!opts || typeof opts.model !== "string" || opts.model.length === 0) {
+      throw new NeetruError("validation_failed", "ai: model is required");
+    }
+    if (!Array.isArray(opts.messages) || opts.messages.length === 0) {
+      throw new NeetruError("validation_failed", "ai: messages must be a non-empty array");
+    }
+    this._calls.push({ model: opts.model, messages: opts.messages, stream: true });
+    const text = this._reply(opts);
+    const parts = text.match(/\S+\s*/g) ?? [text];
+    const meta = Promise.resolve({ provider: "mock", usageWarning: false });
+    async function* iterate() {
+      for (const p of parts) yield p;
+    }
+    return { meta, [Symbol.asyncIterator]: iterate };
+  }
+  /** Test helper — histórico de chamadas. */
+  __getCalls() {
+    return this._calls;
+  }
+};
 
 // src/auth.ts
 function readEnvApiKey() {
@@ -6109,15 +6432,15 @@ function createOidcAuthNamespace(config) {
       const overrideAuthUrl = typeof globalThis.NEETRU_AUTH_URL === "string" ? globalThis.NEETRU_AUTH_URL : null;
       const idpOrigin = overrideAuthUrl ?? config.baseUrl.replace(/^https?:\/\/api\./, "https://auth.");
       const issuer = idpOrigin;
-      const jwksUrl = `${idpOrigin}/api/v1/oauth/.well-known/jwks.json`;
+      const jwksUrl = `${idpOrigin}/api/v1/oauth/.well-known/jwks`;
       const cacheTtlMs = options?.jwksCacheTtlMs ?? DEFAULT_JWKS_TTL_MS;
       const audienceFromOptions = options?.audience;
       const parsedKey = tryParseApiKey(config.apiKey);
-      const audience = audienceFromOptions ?? parsedKey?.keyId;
+      const audience = audienceFromOptions ?? config.oidcClientId ?? parsedKey?.keyId;
       if (!audience) {
         throw new NeetruError(
           "invalid_config",
-          "verifyToken requires an audience: provide apiKey on the client or pass options.audience. Calling jwtVerify without an audience allows tokens issued for other OIDC clients to pass."
+          "verifyToken requires an audience: provide oidcClientId/apiKey on the client or pass options.audience. Calling jwtVerify without an audience allows tokens issued for other OIDC clients to pass."
         );
       }
       const jwks = _getJwks(jwksUrl, cacheTtlMs);
@@ -6180,6 +6503,7 @@ function createNeetruClient(config = {}) {
   const db = config.mocks?.db ?? createNeetruDb(resolved, config.db);
   const webhooks = config.mocks?.webhooks ?? (isDev ? new MockWebhooks() : createWebhooksNamespace(resolved));
   const notifications = config.mocks?.notifications ?? (isDev ? new MockNotifications() : createNotificationsNamespace(resolved));
+  const ai = config.mocks?.ai ?? (isDev ? new MockAi() : createAiNamespace(resolved));
   const client = Object.freeze({
     config: resolved,
     auth,
@@ -6191,7 +6515,8 @@ function createNeetruClient(config = {}) {
     db,
     checkout: createCheckoutNamespace(resolved),
     webhooks,
-    notifications
+    notifications,
+    ai
   });
   return client;
 }