@neetru/sdk 3.4.4 → 3.4.6

package/dist/auth.d.cts

@@ -1,4 +1,4 @@
-import { X as NeetruClientConfig, W as NeetruClient } from './types-Dw0fqhHm.cjs';
+import { X as NeetruClientConfig, W as NeetruClient } from './types-DIVZl7nO.cjs';
 import 'drizzle-orm/node-postgres';
 import './errors.cjs';
 
@@ -25,5 +25,56 @@ declare function __resetJwksCacheForTests(): void;
  * @throws {NeetruError} `invalid_config` se fetch não disponível no runtime.
  */
 declare function createNeetruClient(config?: NeetruClientConfig): NeetruClient;
+/**
+ * Singleton server-side de `NeetruClient`, cacheado via `globalThis`.
+ *
+ * bug_d0d4e5bf: `client.db` server-side (Node.js, sem IndexedDB) cai em
+ * `MemoryStore` — um store 100% em memória, isolado POR INSTÂNCIA de client.
+ * Chamar `createNeetruClient(...)` mais de uma vez (ex.: uma vez por Server
+ * Action, outra por Route Handler) cria MemoryStores diferentes e ISOLADOS:
+ * um `set()` numa instância nunca fica visível pra um `get()`/`onSnapshot()`
+ * noutra, mesmo dentro do MESMO processo Node — não é um bug de rede nem de
+ * timing, é ausência de estado compartilhado.
+ *
+ * Use esta função em vez de `createNeetruClient` direto em qualquer código
+ * SERVER-ONLY (Server Actions, Route Handlers, Server Components) que use
+ * `client.db`:
+ *
+ * ```ts
+ * import { getServerNeetruClient } from '@neetru/sdk';
+ *
+ * export async function myServerAction() {
+ *   const client = getServerNeetruClient({ apiKey: process.env.NEETRU_API_KEY });
+ *   await client.db.collection('orders').set('123', { status: 'paid' });
+ * }
+ *
+ * export async function GET() {
+ *   const client = getServerNeetruClient(); // config já cacheada, argumento ignorado
+ *   const order = await client.db.collection('orders').get('123');
+ *   // ...
+ * }
+ * ```
+ *
+ * `config` só é lida na PRIMEIRA chamada (cria a instância); chamadas
+ * subsequentes a ignoram e devolvem a instância já cacheada — o padrão
+ * esperado é config ESTÁTICA por processo (lida de env vars no boot), não
+ * variável por-request. Se o produto precisa de múltiplos clients com config
+ * diferente no mesmo processo (raro), use `createNeetruClient` direto e
+ * gerencie o cache você mesmo.
+ *
+ * NÃO é necessário (nem recomendado) em código client-side (browser): lá o
+ * `IndexedDB` real persiste entre chamadas do jeito esperado, e o padrão
+ * usual é criar o client uma vez num Provider/Context React.
+ *
+ * @throws {NeetruError} `invalid_config` se `fetch` não disponível no runtime
+ *   (mesma validação de `createNeetruClient`, só na primeira chamada).
+ */
+declare function getServerNeetruClient(config?: NeetruClientConfig): NeetruClient;
+/**
+ * @internal Reseta o singleton server-side cacheado via `globalThis`.
+ * Uso exclusivo de testes — evita vazamento de estado entre `it()` blocks
+ * que chamam `getServerNeetruClient`.
+ */
+declare function __resetServerNeetruClientForTests(): void;
 
-export { __resetJwksCacheForTests, createNeetruClient };
+export { __resetJwksCacheForTests, __resetServerNeetruClientForTests, createNeetruClient, getServerNeetruClient };

package/dist/auth.d.ts

@@ -1,4 +1,4 @@
-import { X as NeetruClientConfig, W as NeetruClient } from './types-Bzxb5rlF.js';
+import { X as NeetruClientConfig, W as NeetruClient } from './types-nnztVk7G.js';
 import 'drizzle-orm/node-postgres';
 import './errors.js';
 
@@ -25,5 +25,56 @@ declare function __resetJwksCacheForTests(): void;
  * @throws {NeetruError} `invalid_config` se fetch não disponível no runtime.
  */
 declare function createNeetruClient(config?: NeetruClientConfig): NeetruClient;
+/**
+ * Singleton server-side de `NeetruClient`, cacheado via `globalThis`.
+ *
+ * bug_d0d4e5bf: `client.db` server-side (Node.js, sem IndexedDB) cai em
+ * `MemoryStore` — um store 100% em memória, isolado POR INSTÂNCIA de client.
+ * Chamar `createNeetruClient(...)` mais de uma vez (ex.: uma vez por Server
+ * Action, outra por Route Handler) cria MemoryStores diferentes e ISOLADOS:
+ * um `set()` numa instância nunca fica visível pra um `get()`/`onSnapshot()`
+ * noutra, mesmo dentro do MESMO processo Node — não é um bug de rede nem de
+ * timing, é ausência de estado compartilhado.
+ *
+ * Use esta função em vez de `createNeetruClient` direto em qualquer código
+ * SERVER-ONLY (Server Actions, Route Handlers, Server Components) que use
+ * `client.db`:
+ *
+ * ```ts
+ * import { getServerNeetruClient } from '@neetru/sdk';
+ *
+ * export async function myServerAction() {
+ *   const client = getServerNeetruClient({ apiKey: process.env.NEETRU_API_KEY });
+ *   await client.db.collection('orders').set('123', { status: 'paid' });
+ * }
+ *
+ * export async function GET() {
+ *   const client = getServerNeetruClient(); // config já cacheada, argumento ignorado
+ *   const order = await client.db.collection('orders').get('123');
+ *   // ...
+ * }
+ * ```
+ *
+ * `config` só é lida na PRIMEIRA chamada (cria a instância); chamadas
+ * subsequentes a ignoram e devolvem a instância já cacheada — o padrão
+ * esperado é config ESTÁTICA por processo (lida de env vars no boot), não
+ * variável por-request. Se o produto precisa de múltiplos clients com config
+ * diferente no mesmo processo (raro), use `createNeetruClient` direto e
+ * gerencie o cache você mesmo.
+ *
+ * NÃO é necessário (nem recomendado) em código client-side (browser): lá o
+ * `IndexedDB` real persiste entre chamadas do jeito esperado, e o padrão
+ * usual é criar o client uma vez num Provider/Context React.
+ *
+ * @throws {NeetruError} `invalid_config` se `fetch` não disponível no runtime
+ *   (mesma validação de `createNeetruClient`, só na primeira chamada).
+ */
+declare function getServerNeetruClient(config?: NeetruClientConfig): NeetruClient;
+/**
+ * @internal Reseta o singleton server-side cacheado via `globalThis`.
+ * Uso exclusivo de testes — evita vazamento de estado entre `it()` blocks
+ * que chamam `getServerNeetruClient`.
+ */
+declare function __resetServerNeetruClientForTests(): void;
 
-export { __resetJwksCacheForTests, createNeetruClient };
+export { __resetJwksCacheForTests, __resetServerNeetruClientForTests, createNeetruClient, getServerNeetruClient };

package/dist/auth.mjs

@@ -1189,80 +1189,28 @@ function createCatalogNamespace(config) {
 
 // src/entitlements.ts
 init_errors();
-init_http();
-function toEntitlementCheck(raw) {
-  if (!raw || typeof raw !== "object") {
-    throw new NeetruError("invalid_response", "Entitlement response is not an object");
-  }
-  const r = raw;
-  if (typeof r.allowed !== "boolean") {
-    throw new NeetruError("invalid_response", "Entitlement response missing `allowed` boolean");
-  }
-  return {
-    allowed: r.allowed,
-    productSlug: typeof r.productSlug === "string" ? r.productSlug : "",
-    feature: typeof r.feature === "string" ? r.feature : "",
-    reason: typeof r.reason === "string" ? r.reason : void 0
-  };
+var DEPRECATION_MESSAGE = "client.entitlements.check()/checkDetailed() est\xE3o DEPRECADOS \u2014 apontavam para GET /api/v1/sdk/entitlements/check, um endpoint que o Core nunca escreve (sempre retornava not_subscribed). Use client.usage.check(resource, { productId, tenantId }) no lugar \u2014 mesmo resultado (allowed/reason/remaining/limit/behavior), endpoint real.";
+function throwDeprecated() {
+  throw new NeetruError("validation_failed", DEPRECATION_MESSAGE);
 }
-var CACHE_TTL_MS = 6e4;
-var CACHE_MAX = 100;
-function createEntitlementsNamespace(config) {
-  const cache = /* @__PURE__ */ new Map();
-  function cacheKey(productSlug, feature) {
-    return `${productSlug}::${feature}`;
-  }
-  function readCache(key) {
-    const entry = cache.get(key);
-    if (!entry) return null;
-    if (entry.expiresAt < Date.now()) {
-      cache.delete(key);
-      return null;
-    }
-    cache.delete(key);
-    cache.set(key, entry);
-    return entry.value;
-  }
-  function writeCache(key, value) {
-    if (cache.size >= CACHE_MAX) {
-      const oldest = cache.keys().next().value;
-      if (oldest !== void 0) cache.delete(oldest);
-    }
-    cache.set(key, { value, expiresAt: Date.now() + CACHE_TTL_MS });
-  }
-  async function checkDetailed(productSlug, feature, opts = {}) {
-    if (!productSlug) throw new NeetruError("validation_failed", "productSlug is required");
-    if (!feature) throw new NeetruError("validation_failed", "feature is required");
-    const key = cacheKey(productSlug, feature);
-    if (!opts.cacheBust) {
-      const cached = readCache(key);
-      if (cached) return cached;
-    }
-    const raw = await httpRequest(config, {
-      method: "GET",
-      path: "/api/v1/sdk/entitlements/check",
-      query: { slug: productSlug, feature },
-      requireAuth: true
-    });
-    const result = toEntitlementCheck(raw);
-    writeCache(key, result);
-    return result;
-  }
+function createEntitlementsNamespace(_config) {
   return {
     /**
-     * Verifica se o caller pode usar `feature` no produto `productSlug`.
-     * Retorno simples: `true` libera, `false` bloqueia. Cache 60s automático.
-     *
-     * Use `checkDetailed` se precisar do `reason` pra mensagem de upgrade.
+     * @deprecated Endpoint morto no Core — sempre retornava `not_subscribed`.
+     * Lança `NeetruError`. Use `client.usage.check(resource, {productId, tenantId})`.
+     */
+    async check(_productSlug, _feature, _opts) {
+      throwDeprecated();
+    },
+    /**
+     * @deprecated Endpoint morto no Core — sempre retornava `not_subscribed`.
+     * Lança `NeetruError`. Use `client.usage.check(resource, {productId, tenantId})`.
      */
-    async check(productSlug, feature, opts) {
-      const result = await checkDetailed(productSlug, feature, opts);
-      return result.allowed;
+    async checkDetailed(_productSlug, _feature, _opts) {
+      throwDeprecated();
     },
-    checkDetailed,
-    /** Test helper: limpa o cache LRU. */
+    /** Test helper legado — no-op (não há mais cache). Mantido por compat. */
     __resetCache() {
-      cache.clear();
     }
   };
 }
@@ -1271,6 +1219,12 @@ function createEntitlementsNamespace(config) {
 init_errors();
 init_http();
 var VALID_LOG_LEVELS = ["debug", "info", "warn", "error", "fatal"];
+function isBrowserContext() {
+  return typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+}
+function resolveEventTransport() {
+  return isBrowserContext() ? { path: "/api/sdk/v1/telemetry/event/public", requireAuth: false } : { path: "/api/sdk/v1/telemetry/event", requireAuth: true };
+}
 function consoleFor(level) {
   switch (level) {
     case "debug":
@@ -1300,15 +1254,18 @@ function createTelemetryNamespace(config) {
       batch.map(async (ev) => {
         try {
           const body = { name: ev.name };
+          const productSlug = ev.productSlug ?? config.productId;
+          if (productSlug) body.productSlug = productSlug;
           if (ev.properties && typeof ev.properties === "object") {
             body.properties = ev.properties;
           }
           if (ev.timestamp) body.timestamp = ev.timestamp;
+          const transport = resolveEventTransport();
           await httpRequest(config, {
             method: "POST",
-            path: "/api/sdk/v1/telemetry/event",
+            path: transport.path,
             body,
-            requireAuth: true,
+            requireAuth: transport.requireAuth,
             retries: 1,
             // caça-bruxas: retry sem Idempotency-Key duplicava o evento se o
             // servidor já tinha persistido antes da falha transiente. Mesmo
@@ -1361,15 +1318,18 @@ function createTelemetryNamespace(config) {
         throw new NeetruError("validation_failed", "event.name max 128 chars");
       }
       const body = { name: input.name };
+      const productSlug = input.productSlug ?? config.productId;
+      if (productSlug) body.productSlug = productSlug;
       if (input.properties && typeof input.properties === "object") {
         body.properties = input.properties;
       }
       if (input.timestamp) body.timestamp = input.timestamp;
+      const transport = resolveEventTransport();
       const raw = await httpRequest(config, {
         method: "POST",
-        path: "/api/sdk/v1/telemetry/event",
+        path: transport.path,
         body,
-        requireAuth: true
+        requireAuth: transport.requireAuth
       });
       if (!raw || raw.ok !== true || typeof raw.eventId !== "string") {
         throw new NeetruError("invalid_response", "Telemetry response missing eventId");
@@ -1488,7 +1448,7 @@ init_http();
 
 // src/validators.ts
 init_errors();
-var SDK_ID_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/;
+var SDK_ID_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/i;
 function assertValidSdkId(field, value) {
   if (typeof value !== "string" || !SDK_ID_RE.test(value)) {
     throw new NeetruError(
@@ -7606,7 +7566,7 @@ function createNeetruClient(config = {}) {
   const auth = config.mocks?.auth ?? (isDev ? new MockAuth({ ...DEV_FIXTURE_USER }) : createOidcAuthNamespace(resolved));
   const usage = config.mocks?.usage ?? (isDev ? new MockUsage() : createUsageNamespace(resolved));
   const support = config.mocks?.support ?? (isDev ? new MockSupport() : createSupportNamespace(resolved));
-  const entitlements = config.mocks?.entitlements ?? (isDev ? new MockEntitlements() : createEntitlementsNamespace(resolved));
+  const entitlements = config.mocks?.entitlements ?? (isDev ? new MockEntitlements() : createEntitlementsNamespace());
   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));
@@ -7627,7 +7587,18 @@ function createNeetruClient(config = {}) {
   });
   return client;
 }
+var NEETRU_SERVER_CLIENT_KEY = /* @__PURE__ */ Symbol.for("@neetru/sdk:serverClient");
+function getServerNeetruClient(config = {}) {
+  const g = globalThis;
+  if (!g[NEETRU_SERVER_CLIENT_KEY]) {
+    g[NEETRU_SERVER_CLIENT_KEY] = createNeetruClient(config);
+  }
+  return g[NEETRU_SERVER_CLIENT_KEY];
+}
+function __resetServerNeetruClientForTests() {
+  delete globalThis[NEETRU_SERVER_CLIENT_KEY];
+}
 
-export { __resetJwksCacheForTests, createNeetruClient };
+export { __resetJwksCacheForTests, __resetServerNeetruClientForTests, createNeetruClient, getServerNeetruClient };
 //# sourceMappingURL=auth.mjs.map
 //# sourceMappingURL=auth.mjs.map