@neetru/sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1142 @@
+// src/errors.ts
+var NeetruError = class _NeetruError extends Error {
+  code;
+  status;
+  requestId;
+  constructor(code, message, status, requestId) {
+    super(message);
+    this.name = "NeetruError";
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    Object.setPrototypeOf(this, _NeetruError.prototype);
+  }
+};
+
+// src/types.ts
+var DEFAULT_BASE_URL = "https://api.neetru.com";
+
+// src/http.ts
+function statusToCode(status) {
+  if (status === 401) return "unauthorized";
+  if (status === 403) return "forbidden";
+  if (status === 404) return "not_found";
+  if (status === 422 || status === 400) return "validation_failed";
+  if (status === 429) return "rate_limited";
+  if (status >= 500) return "server_error";
+  return "unknown";
+}
+function buildUrl(baseUrl, path, query) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(`${base}${p}`);
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v === void 0) continue;
+      url.searchParams.set(k, String(v));
+    }
+  }
+  return url.toString();
+}
+async function safeJson(res) {
+  const text = await res.text();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+async function httpRequest(config, opts) {
+  const method = opts.method ?? "GET";
+  const url = buildUrl(config.baseUrl, opts.path, opts.query);
+  const headers = {
+    accept: "application/json",
+    ...opts.headers
+  };
+  if (opts.requireAuth) {
+    if (!config.apiKey) {
+      throw new NeetruError(
+        "missing_api_key",
+        "This operation requires an apiKey. Pass it to createNeetruClient({ apiKey }) or set NEETRU_API_KEY env var."
+      );
+    }
+    headers.authorization = `Bearer ${config.apiKey}`;
+  }
+  const init = { method, headers };
+  if (opts.body !== void 0 && method !== "GET" && method !== "DELETE") {
+    headers["content-type"] = "application/json";
+    init.body = JSON.stringify(opts.body);
+  }
+  let res;
+  try {
+    res = await config.fetch(url, init);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "fetch failed";
+    throw new NeetruError("network_error", `Network error: ${message}`);
+  }
+  const requestId = res.headers.get("x-request-id") ?? res.headers.get("x-correlation-id") ?? void 0;
+  if (!res.ok) {
+    const body = await safeJson(res);
+    let code = statusToCode(res.status);
+    let message = `HTTP ${res.status}`;
+    if (body && typeof body === "object" && "error" in body) {
+      const errField = body.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 parsed = await safeJson(res);
+  return parsed;
+}
+
+// src/catalog.ts
+function toProduct(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new NeetruError("invalid_response", "Catalog response item is not an object");
+  }
+  const r = raw;
+  if (typeof r.slug !== "string" || !r.slug) {
+    throw new NeetruError("invalid_response", "Catalog product missing slug");
+  }
+  if (typeof r.name !== "string" || !r.name) {
+    throw new NeetruError("invalid_response", "Catalog product missing name");
+  }
+  const product = {
+    slug: r.slug,
+    name: r.name
+  };
+  if (typeof r.tagline === "string") product.tagline = r.tagline;
+  if (typeof r.description === "string") product.description = r.description;
+  if (r.status === "live" || r.status === "soon" || r.status === "beta") {
+    product.status = r.status;
+  }
+  if (typeof r.iconKey === "string") product.iconKey = r.iconKey;
+  if (typeof r.ctaHref === "string") product.ctaHref = r.ctaHref;
+  if (typeof r.ctaLabel === "string") product.ctaLabel = r.ctaLabel;
+  if (Array.isArray(r.plans)) {
+    product.plans = r.plans.filter(
+      (p) => typeof p === "object" && p !== null && typeof p.id === "string" && typeof p.name === "string"
+    );
+  }
+  return product;
+}
+function createCatalogNamespace(config) {
+  return {
+    /**
+     * Lista produtos publicados. Por default só `published=true`; staff
+     * pode passar `includeDrafts: true` (requer Bearer com role admin/operator).
+     */
+    async list(opts = {}) {
+      const raw = await httpRequest(config, {
+        method: "GET",
+        path: "/api/v1/cli/catalog",
+        query: opts.includeDrafts ? { drafts: "true" } : void 0,
+        requireAuth: true
+      });
+      if (!raw || !Array.isArray(raw.products)) {
+        throw new NeetruError(
+          "invalid_response",
+          "Catalog list response missing products array"
+        );
+      }
+      return {
+        products: raw.products.map(toProduct),
+        fetchedAt: typeof raw.fetchedAt === "string" ? raw.fetchedAt : (/* @__PURE__ */ new Date()).toISOString()
+      };
+    },
+    /**
+     * Busca produto único por slug.
+     *
+     * @throws {NeetruError} `not_found` se slug inexistente ou não publicado.
+     */
+    async get(slug) {
+      if (!slug || typeof slug !== "string") {
+        throw new NeetruError("validation_failed", "slug is required");
+      }
+      const raw = await httpRequest(config, {
+        method: "GET",
+        path: `/api/v1/cli/catalog/${encodeURIComponent(slug)}`,
+        requireAuth: true
+      });
+      if (!raw || !raw.product) {
+        throw new NeetruError(
+          "invalid_response",
+          "Catalog get response missing product"
+        );
+      }
+      return toProduct(raw.product);
+    }
+  };
+}
+
+// src/entitlements.ts
+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
+  };
+}
+function createEntitlementsNamespace(config) {
+  async function checkDetailed(productSlug, feature) {
+    if (!productSlug) throw new NeetruError("validation_failed", "productSlug is required");
+    if (!feature) throw new NeetruError("validation_failed", "feature is required");
+    const raw = await httpRequest(config, {
+      method: "GET",
+      path: "/api/v1/sdk/entitlements/check",
+      query: { slug: productSlug, feature },
+      requireAuth: true
+    });
+    return toEntitlementCheck(raw);
+  }
+  return {
+    /**
+     * Verifica se o caller pode usar `feature` no produto `productSlug`.
+     * Retorno simples: `true` libera, `false` bloqueia.
+     *
+     * Use `checkDetailed` se precisar do `reason` pra mensagem de upgrade.
+     */
+    async check(productSlug, feature) {
+      const result = await checkDetailed(productSlug, feature);
+      return result.allowed;
+    },
+    checkDetailed
+  };
+}
+
+// src/telemetry.ts
+var VALID_LOG_LEVELS = ["debug", "info", "warn", "error", "fatal"];
+function consoleFor(level) {
+  switch (level) {
+    case "debug":
+      return console.debug.bind(console);
+    case "info":
+      return console.info.bind(console);
+    case "warn":
+      return console.warn.bind(console);
+    case "error":
+      return console.error.bind(console);
+    case "fatal":
+      return console.error.bind(console);
+    default:
+      return console.log.bind(console);
+  }
+}
+function createTelemetryNamespace(config) {
+  return {
+    /**
+     * Persiste um evento de uso. Lança `NeetruError` em qualquer falha
+     * (incluindo rate-limit).
+     *
+     * @example
+     * ```ts
+     * await client.telemetry.event({
+     *   name: 'dashboard_opened',
+     *   properties: { plan: 'pro', tab: 'overview' },
+     * });
+     * ```
+     */
+    async event(input) {
+      if (!input || typeof input !== "object") {
+        throw new NeetruError("validation_failed", "event input is required");
+      }
+      if (typeof input.name !== "string" || input.name.length === 0) {
+        throw new NeetruError("validation_failed", "event.name is required");
+      }
+      if (input.name.length > 128) {
+        throw new NeetruError("validation_failed", "event.name max 128 chars");
+      }
+      const body = { name: input.name };
+      if (input.properties && typeof input.properties === "object") {
+        body.properties = input.properties;
+      }
+      if (input.timestamp) body.timestamp = input.timestamp;
+      const raw = await httpRequest(config, {
+        method: "POST",
+        path: "/api/v1/sdk/telemetry/event",
+        body,
+        requireAuth: true
+      });
+      if (!raw || raw.ok !== true || typeof raw.eventId !== "string") {
+        throw new NeetruError("invalid_response", "Telemetry response missing eventId");
+      }
+      return { ok: true, eventId: raw.eventId };
+    },
+    /**
+     * Registra um log estruturado per-product (Sprint 6).
+     *
+     * - `NEETRU_ENV=dev`: console.{level}, retorna ack mock.
+     * - workspace/prod: HTTP POST com Bearer auth + correlationId no header.
+     *
+     * @example
+     * ```ts
+     * await client.telemetry.log({
+     *   level: 'error',
+     *   message: 'Falha ao calcular total',
+     *   metadata: { orderId: 'o-123' },
+     * });
+     * ```
+     */
+    async log(input) {
+      if (!input || typeof input !== "object") {
+        throw new NeetruError("validation_failed", "log input is required");
+      }
+      if (!VALID_LOG_LEVELS.includes(input.level)) {
+        throw new NeetruError("validation_failed", `level must be one of ${VALID_LOG_LEVELS.join(", ")}`);
+      }
+      if (typeof input.message !== "string" || input.message.length === 0) {
+        throw new NeetruError("validation_failed", "message is required");
+      }
+      if (input.message.length > 4e3) {
+        throw new NeetruError("validation_failed", "message max 4000 chars");
+      }
+      if (config.env === "dev") {
+        const fn = consoleFor(input.level);
+        fn(`[neetru-sdk] ${input.level}: ${input.message}`, input.metadata ?? {});
+        return { ok: true, mode: "mock" };
+      }
+      const body = {
+        level: input.level,
+        message: input.message
+      };
+      if (input.metadata) body.metadata = input.metadata;
+      if (input.productSlug) body.productSlug = input.productSlug;
+      let cid = input.correlationId;
+      if (!cid) {
+        try {
+          const g = globalThis.NEETRU_CORRELATION_ID;
+          if (typeof g === "string" && g.length > 0) cid = g;
+        } catch {
+        }
+      }
+      const headers = {};
+      if (cid) headers["x-correlation-id"] = cid;
+      const raw = await httpRequest(config, {
+        method: "POST",
+        path: "/sdk/v1/telemetry/log",
+        body,
+        requireAuth: true,
+        headers
+      });
+      if (!raw || raw.ok !== true) {
+        throw new NeetruError("invalid_response", "Telemetry log response missing ok");
+      }
+      return {
+        ok: true,
+        logId: typeof raw.logId === "string" ? raw.logId : void 0,
+        mode: "http"
+      };
+    }
+  };
+}
+
+// src/usage.ts
+function toQuota(metric, raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new NeetruError("invalid_response", "Quota response is not an object");
+  }
+  const r = raw;
+  if (typeof r.used !== "number" || typeof r.limit !== "number") {
+    throw new NeetruError("invalid_response", "Quota response missing used/limit numbers");
+  }
+  return {
+    metric: typeof r.metric === "string" ? r.metric : metric,
+    used: r.used,
+    limit: r.limit,
+    resetsAt: typeof r.resetsAt === "string" ? r.resetsAt : void 0,
+    plan: typeof r.plan === "string" ? r.plan : void 0
+  };
+}
+function createUsageNamespace(config) {
+  return {
+    /**
+     * Persiste um evento de usage. Em dev (mocks ativos via factory) só loga.
+     * Em workspace/prod chama POST /sdk/v1/usage/record.
+     */
+    async track(event, properties) {
+      if (!event || typeof event !== "string") {
+        throw new NeetruError("validation_failed", "event name is required");
+      }
+      if (event.length > 128) {
+        throw new NeetruError("validation_failed", "event name max 128 chars");
+      }
+      const body = { event };
+      if (properties && typeof properties === "object") body.properties = properties;
+      const raw = await httpRequest(config, {
+        method: "POST",
+        path: "/sdk/v1/usage/record",
+        body,
+        requireAuth: true
+      });
+      if (!raw || raw.ok !== true) {
+        throw new NeetruError("invalid_response", "Usage record response missing ok");
+      }
+      return { ok: true };
+    },
+    /**
+     * Lê quota atual de uma métrica. Cacheável (caller decide), SDK não cacheia.
+     */
+    async getQuota(metric) {
+      if (!metric || typeof metric !== "string") {
+        throw new NeetruError("validation_failed", "metric is required");
+      }
+      const raw = await httpRequest(config, {
+        method: "GET",
+        path: "/sdk/v1/usage/quota",
+        query: { metric },
+        requireAuth: true
+      });
+      return toQuota(metric, raw);
+    },
+    /**
+     * v0.3 — Reporta consumo metered. Hit no endpoint canônico Sprint 7.
+     */
+    async report(resource, qty = 1, options) {
+      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");
+      }
+      const productId = options?.productId ?? config.productId;
+      const tenantId = options?.tenantId ?? config.tenantId;
+      if (!productId) {
+        throw new NeetruError(
+          "validation_failed",
+          "productId required (pass to options or set on createNeetruClient)"
+        );
+      }
+      if (!tenantId) {
+        throw new NeetruError(
+          "validation_failed",
+          "tenantId required (pass to options or set on createNeetruClient)"
+        );
+      }
+      const raw = await httpRequest(config, {
+        method: "POST",
+        path: "/sdk/v1/usage/record",
+        body: { productId, tenantId, resource, qty: Math.floor(qty) },
+        requireAuth: true
+      });
+      if (!raw || raw.ok !== true) {
+        throw new NeetruError("invalid_response", "usage.report response missing ok");
+      }
+      return {
+        ok: true,
+        counterId: raw.counterId,
+        value: raw.value,
+        limit: raw.limit,
+        remaining: raw.remaining,
+        status: raw.status
+      };
+    },
+    /**
+     * v0.3 — Verifica entitlement de um resource via GET /sdk/v1/entitlements.
+     */
+    async check(resource, options) {
+      if (!resource || typeof resource !== "string") {
+        throw new NeetruError("validation_failed", "resource is required");
+      }
+      const productId = options?.productId ?? config.productId;
+      const tenantId = options?.tenantId ?? config.tenantId;
+      if (!productId || !tenantId) {
+        throw new NeetruError(
+          "validation_failed",
+          "productId and tenantId required"
+        );
+      }
+      const raw = await httpRequest(config, {
+        method: "GET",
+        path: "/sdk/v1/entitlements",
+        query: { productId, tenantId, feature: resource },
+        requireAuth: true
+      });
+      if (!raw || typeof raw.allowed !== "boolean") {
+        throw new NeetruError("invalid_response", "usage.check response missing allowed");
+      }
+      return {
+        allowed: raw.allowed,
+        reason: raw.reason,
+        remaining: raw.remaining,
+        limit: raw.limit,
+        planId: raw.planId,
+        planFeatures: raw.planFeatures
+      };
+    }
+  };
+}
+
+// src/support.ts
+var VALID_SEVERITIES = ["low", "normal", "high", "urgent"];
+var VALID_STATUSES = ["open", "pending", "resolved", "closed"];
+function toTicket(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new NeetruError("invalid_response", "Ticket response is not an object");
+  }
+  const r = raw;
+  if (typeof r.id !== "string") {
+    throw new NeetruError("invalid_response", "Ticket missing id");
+  }
+  return {
+    id: r.id,
+    subject: typeof r.subject === "string" ? r.subject : "",
+    message: typeof r.message === "string" ? r.message : "",
+    severity: VALID_SEVERITIES.includes(r.severity) ? r.severity : "normal",
+    status: VALID_STATUSES.includes(r.status) ? r.status : "open",
+    createdAt: typeof r.createdAt === "string" ? r.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: typeof r.updatedAt === "string" ? r.updatedAt : void 0,
+    productSlug: typeof r.productSlug === "string" ? r.productSlug : void 0
+  };
+}
+function createSupportNamespace(config) {
+  return {
+    /**
+     * Cria um ticket de suporte. Requer Bearer auth. Se `productSlug` não é
+     * passado, o backend infere do escopo do token.
+     */
+    async createTicket(input) {
+      if (!input || typeof input !== "object") {
+        throw new NeetruError("validation_failed", "input is required");
+      }
+      if (!input.subject || typeof input.subject !== "string") {
+        throw new NeetruError("validation_failed", "subject is required");
+      }
+      if (input.subject.length > 200) {
+        throw new NeetruError("validation_failed", "subject max 200 chars");
+      }
+      if (!input.message || typeof input.message !== "string") {
+        throw new NeetruError("validation_failed", "message is required");
+      }
+      if (input.message.length > 1e4) {
+        throw new NeetruError("validation_failed", "message max 10000 chars");
+      }
+      if (input.severity && !VALID_SEVERITIES.includes(input.severity)) {
+        throw new NeetruError("validation_failed", `severity must be one of ${VALID_SEVERITIES.join(", ")}`);
+      }
+      const slug = input.productSlug ?? "_default";
+      const body = {
+        subject: input.subject,
+        message: input.message,
+        severity: input.severity ?? "normal"
+      };
+      const raw = await httpRequest(config, {
+        method: "POST",
+        path: `/api/v1/products/${encodeURIComponent(slug)}/tickets`,
+        body,
+        requireAuth: true
+      });
+      const candidate = raw && typeof raw === "object" && "ticket" in raw ? raw.ticket : raw;
+      return toTicket(candidate);
+    },
+    /**
+     * Lista tickets do customer no produto atual (escopo do token).
+     */
+    async listMyTickets() {
+      const raw = await httpRequest(config, {
+        method: "GET",
+        path: "/api/v1/products/_default/tickets",
+        requireAuth: true
+      });
+      const list = Array.isArray(raw) ? raw : raw && typeof raw === "object" && "tickets" in raw ? raw.tickets ?? [] : [];
+      return list.map(toTicket);
+    }
+  };
+}
+
+// src/db.ts
+var COLL_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/;
+function assertValidCollection(name) {
+  if (!COLL_RE.test(name)) {
+    throw new NeetruError(
+      "validation_failed",
+      `Invalid collection name: "${name}". Must match ${COLL_RE}.`
+    );
+  }
+}
+function serializeWhere(filter) {
+  const { field, op, value } = filter;
+  if (op === "in") {
+    if (!Array.isArray(value)) {
+      throw new NeetruError(
+        "validation_failed",
+        `where op="in" requer value array (recebido: ${typeof value})`
+      );
+    }
+    return `${field}:in:${value.map((v) => String(v)).join(",")}`;
+  }
+  return `${field}:${op}:${String(value)}`;
+}
+function createDbNamespace(config) {
+  return {
+    collection(name) {
+      assertValidCollection(name);
+      const headers = {};
+      if (config.tenantId) headers["x-neetru-tenant"] = config.tenantId;
+      return {
+        async list(opts) {
+          if (opts?.limit !== void 0) opts.limit;
+          let path = `/sdk/v1/datastore/${name}`;
+          const params = new URLSearchParams();
+          if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+          if (opts?.where && opts.where.length > 0) {
+            for (const f of opts.where) {
+              params.append("where", serializeWhere(f));
+            }
+          }
+          if (config.tenantId) params.set("tenantId", config.tenantId);
+          const qs = params.toString();
+          if (qs) path += `?${qs}`;
+          const raw = await httpRequest(config, {
+            method: "GET",
+            path,
+            requireAuth: true,
+            headers
+          });
+          if (!raw || !Array.isArray(raw.items)) {
+            throw new NeetruError(
+              "invalid_response",
+              "datastore.list missing items[]"
+            );
+          }
+          return raw.items;
+        },
+        async get(id) {
+          if (!id || typeof id !== "string") {
+            throw new NeetruError("validation_failed", "id required");
+          }
+          try {
+            const raw = await httpRequest(config, {
+              method: "GET",
+              path: `/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
+              requireAuth: true,
+              headers
+            });
+            return raw?.item ?? null;
+          } catch (err) {
+            if (err instanceof NeetruError && err.code === "not_found") return null;
+            throw err;
+          }
+        },
+        async add(data) {
+          if (!data || typeof data !== "object") {
+            throw new NeetruError("validation_failed", "data object required");
+          }
+          const raw = await httpRequest(config, {
+            method: "POST",
+            path: `/sdk/v1/datastore/${name}`,
+            body: { data },
+            requireAuth: true,
+            headers
+          });
+          if (!raw || typeof raw.id !== "string") {
+            throw new NeetruError("invalid_response", "datastore.add missing id");
+          }
+          return { ok: true, id: raw.id };
+        },
+        async set(id, data) {
+          if (!id || typeof id !== "string") {
+            throw new NeetruError("validation_failed", "id required");
+          }
+          await httpRequest(config, {
+            method: "PUT",
+            path: `/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
+            body: { data },
+            requireAuth: true,
+            headers
+          });
+          return { ok: true };
+        },
+        async update(id, data) {
+          if (!id || typeof id !== "string") {
+            throw new NeetruError("validation_failed", "id required");
+          }
+          await httpRequest(config, {
+            method: "PATCH",
+            path: `/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
+            body: { data },
+            requireAuth: true,
+            headers
+          });
+          return { ok: true };
+        },
+        async remove(id) {
+          if (!id || typeof id !== "string") {
+            throw new NeetruError("validation_failed", "id required");
+          }
+          await httpRequest(config, {
+            method: "DELETE",
+            path: `/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
+            requireAuth: true,
+            headers
+          });
+          return { ok: true };
+        }
+      };
+    }
+  };
+}
+
+// src/mocks.ts
+var DEV_FIXTURE_USER = Object.freeze({
+  uid: "dev-fixture-uid-0001",
+  email: "dev@neetru.local",
+  emailVerified: true,
+  displayName: "Dev Fixture",
+  isCustomer: true,
+  isStaff: false
+});
+var MockAuth = class {
+  _user;
+  _listeners;
+  constructor(initialUser = null) {
+    this._user = initialUser;
+    this._listeners = /* @__PURE__ */ new Set();
+  }
+  async signIn(_options) {
+    if (!this._user) this._user = { ...DEV_FIXTURE_USER };
+    this._notify();
+    return this._user;
+  }
+  async signOut() {
+    this._user = null;
+    this._notify();
+  }
+  getUser() {
+    return this._user;
+  }
+  onAuthStateChanged(listener) {
+    this._listeners.add(listener);
+    try {
+      listener(this._user);
+    } catch {
+    }
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  /** Helper de tests — força um user state arbitrário. */
+  __setUser(user) {
+    this._user = user;
+    this._notify();
+  }
+  _notify() {
+    for (const l of this._listeners) {
+      try {
+        l(this._user);
+      } catch {
+      }
+    }
+  }
+};
+var MockUsage = class {
+  _records = [];
+  _quotas;
+  /** v0.3 — counters in-memory pra `report()` / `check()`. */
+  _counters = /* @__PURE__ */ new Map();
+  constructor(initialQuotas = {}) {
+    this._quotas = new Map(Object.entries(initialQuotas));
+  }
+  async track(event, properties) {
+    this._records.push({
+      event,
+      properties,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { ok: true };
+  }
+  async getQuota(metric) {
+    const existing = this._quotas.get(metric);
+    if (existing) return existing;
+    return {
+      metric,
+      used: this._records.filter((r) => r.event === metric).length,
+      limit: -1,
+      // unlimited em mock por default
+      plan: "mock"
+    };
+  }
+  /** v0.3 — Mock report incrementa o counter local. */
+  async report(resource, qty = 1, _options) {
+    if (!resource) throw new Error("resource required");
+    const safeQty = Number.isFinite(qty) && qty > 0 ? Math.floor(qty) : 1;
+    const existing = this._counters.get(resource) ?? 0;
+    const next = existing + safeQty;
+    this._counters.set(resource, next);
+    const limitFixture = this._quotas.get(resource);
+    const limit = limitFixture?.limit ?? -1;
+    return {
+      ok: true,
+      counterId: `mock_${resource}`,
+      value: next,
+      limit,
+      remaining: limit < 0 ? -1 : Math.max(0, limit - next),
+      status: limit > 0 && next >= limit ? "read_only_overlimit" : "ok"
+    };
+  }
+  /** v0.3 — Mock check usa quotas + counters in-memory. */
+  async check(resource, _options) {
+    const quota = this._quotas.get(resource);
+    const used = this._counters.get(resource) ?? 0;
+    if (!quota) {
+      return { allowed: true, reason: "granted", limit: -1, remaining: -1 };
+    }
+    const remaining = quota.limit < 0 ? -1 : Math.max(0, quota.limit - used);
+    if (remaining === 0) {
+      return {
+        allowed: false,
+        reason: "limit_exceeded",
+        limit: quota.limit,
+        remaining: 0
+      };
+    }
+    return {
+      allowed: true,
+      reason: "granted",
+      limit: quota.limit,
+      remaining
+    };
+  }
+  /** Test helper. */
+  __getRecords() {
+    return [...this._records];
+  }
+  /** Test helper — substitui quota fixture. */
+  __setQuota(metric, quota) {
+    this._quotas.set(metric, quota);
+  }
+  /** Test helper — limpa estado. */
+  __reset() {
+    this._records = [];
+    this._quotas.clear();
+    this._counters.clear();
+  }
+};
+var mockTicketSeq = 0;
+var MockSupport = class {
+  _tickets = [];
+  async createTicket(input) {
+    if (!input?.subject) throw new Error("subject required");
+    if (!input?.message) throw new Error("message required");
+    const ticket = {
+      id: `mock-ticket-${++mockTicketSeq}`,
+      subject: input.subject,
+      message: input.message,
+      severity: input.severity ?? "normal",
+      status: "open",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      productSlug: input.productSlug
+    };
+    this._tickets.push(ticket);
+    return ticket;
+  }
+  async listMyTickets() {
+    return [...this._tickets];
+  }
+  /** Test helper. */
+  __reset() {
+    this._tickets = [];
+  }
+};
+var MockEntitlements = class {
+  _denied = /* @__PURE__ */ new Set();
+  async check(productSlug, feature) {
+    return !this._denied.has(`${productSlug}:${feature}`);
+  }
+  async checkDetailed(productSlug, feature) {
+    const allowed = await this.check(productSlug, feature);
+    return {
+      allowed,
+      productSlug,
+      feature,
+      reason: allowed ? "granted" : "mock_denied"
+    };
+  }
+  /** Test helper. */
+  __deny(productSlug, feature) {
+    this._denied.add(`${productSlug}:${feature}`);
+  }
+  /** Test helper. */
+  __reset() {
+    this._denied.clear();
+  }
+};
+var MockDb = class {
+  _store = /* @__PURE__ */ new Map();
+  _fixtures;
+  constructor(initialFixtures = {}) {
+    this._fixtures = new Map(Object.entries(initialFixtures));
+  }
+  collection(name) {
+    const _store = this._store;
+    const _fixtures = this._fixtures;
+    if (!_store.has(name)) {
+      const init = _fixtures.get(name);
+      _store.set(
+        name,
+        init ? new Map(Object.entries(init)) : /* @__PURE__ */ new Map()
+      );
+    }
+    const coll = _store.get(name);
+    const matchesFilter = (doc, f) => {
+      const v = doc[f.field];
+      switch (f.op) {
+        case "==":
+          return v === f.value;
+        case "!=":
+          return v !== f.value;
+        case "<":
+          return typeof v === "number" && typeof f.value === "number" && v < f.value;
+        case "<=":
+          return typeof v === "number" && typeof f.value === "number" && v <= f.value;
+        case ">":
+          return typeof v === "number" && typeof f.value === "number" && v > f.value;
+        case ">=":
+          return typeof v === "number" && typeof f.value === "number" && v >= f.value;
+        case "in":
+          return Array.isArray(f.value) && f.value.includes(v);
+        default:
+          return true;
+      }
+    };
+    let autoSeq = 0;
+    return {
+      async list(opts) {
+        let items = Array.from(coll.values());
+        if (opts?.where && opts.where.length > 0) {
+          items = items.filter(
+            (doc) => opts.where.every((f) => matchesFilter(doc, f))
+          );
+        }
+        if (opts?.limit !== void 0) items = items.slice(0, opts.limit);
+        return items;
+      },
+      async get(id) {
+        return coll.get(id) ?? null;
+      },
+      async add(data) {
+        const id = `mock-${++autoSeq}-${Math.random().toString(36).slice(2, 8)}`;
+        coll.set(id, { ...data, id });
+        return { ok: true, id };
+      },
+      async set(id, data) {
+        coll.set(id, { ...data, id });
+        return { ok: true };
+      },
+      async update(id, data) {
+        const cur = coll.get(id);
+        if (!cur) {
+          coll.set(id, { ...data, id });
+        } else {
+          coll.set(id, { ...cur, ...data });
+        }
+        return { ok: true };
+      },
+      async remove(id) {
+        coll.delete(id);
+        return { ok: true };
+      }
+    };
+  }
+  /** Test helper — substitui fixture inteira de uma collection. */
+  __setFixture(name, items) {
+    this._store.set(name, new Map(Object.entries(items)));
+  }
+  /** Test helper — reset total. */
+  __reset() {
+    this._store.clear();
+  }
+};
+
+// src/auth.ts
+function readEnvApiKey() {
+  try {
+    const proc = globalThis.process;
+    const val = proc?.env?.NEETRU_API_KEY;
+    return typeof val === "string" && val.length > 0 ? val : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveEnv(configEnv) {
+  if (configEnv) return configEnv;
+  try {
+    const proc = globalThis.process;
+    const val = proc?.env?.NEETRU_ENV;
+    if (val === "dev" || val === "workspace" || val === "prod") return val;
+  } catch {
+  }
+  try {
+    const g = globalThis.NEETRU_ENV;
+    if (g === "dev" || g === "workspace" || g === "prod") return g;
+  } catch {
+  }
+  return "prod";
+}
+function createOidcAuthNamespace(config) {
+  const STORAGE_KEY = "neetru_id_token";
+  const listeners = /* @__PURE__ */ new Set();
+  let cachedUser = null;
+  function getStorage() {
+    try {
+      return typeof globalThis.localStorage !== "undefined" ? globalThis.localStorage : null;
+    } catch {
+      return null;
+    }
+  }
+  function decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    try {
+      const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+      const pad = "=".repeat((4 - b64.length % 4) % 4);
+      const decoded = typeof atob === "function" ? atob(b64 + pad) : Buffer.from(b64 + pad, "base64").toString("utf-8");
+      return JSON.parse(decoded);
+    } catch {
+      return null;
+    }
+  }
+  function tokenToUser(token) {
+    const payload = decodeJwtPayload(token);
+    if (!payload || typeof payload.sub !== "string") return null;
+    return {
+      uid: payload.sub,
+      email: typeof payload.email === "string" ? payload.email : "",
+      emailVerified: typeof payload.email_verified === "boolean" ? payload.email_verified : void 0,
+      displayName: typeof payload.name === "string" ? payload.name : void 0,
+      photoURL: typeof payload.picture === "string" ? payload.picture : void 0,
+      isStaff: payload.is_staff === true,
+      isCustomer: payload.is_customer === true,
+      tenantId: typeof payload.tenant_id === "string" ? payload.tenant_id : void 0,
+      ...payload
+    };
+  }
+  function loadCachedUser() {
+    if (cachedUser) return cachedUser;
+    const storage = getStorage();
+    if (!storage) return null;
+    const token = storage.getItem(STORAGE_KEY);
+    if (!token) return null;
+    cachedUser = tokenToUser(token);
+    return cachedUser;
+  }
+  function notify() {
+    for (const l of listeners) {
+      try {
+        l(cachedUser);
+      } catch {
+      }
+    }
+  }
+  return {
+    async signIn(options) {
+      if (typeof globalThis.location !== "undefined" && typeof globalThis.location.assign === "function") {
+        const redirectUri = options?.redirectUri ?? globalThis.location.origin;
+        const scope = options?.scope ?? "openid profile email";
+        const state = options?.postLoginRedirect ?? globalThis.location.href;
+        const url = new URL("/oauth/authorize", config.baseUrl.replace(/\/api$/, ""));
+        url.searchParams.set("response_type", "code");
+        url.searchParams.set("redirect_uri", redirectUri);
+        url.searchParams.set("scope", scope);
+        url.searchParams.set("state", state);
+        if (config.apiKey) {
+          const clientId = config.apiKey.split("_")[1] ?? config.apiKey;
+          url.searchParams.set("client_id", clientId);
+        }
+        globalThis.location.assign(url.toString());
+        return;
+      }
+      throw new NeetruError(
+        "invalid_config",
+        "auth.signIn requires a browser context or mocks. Use NEETRU_ENV=dev or pass mocks.auth."
+      );
+    },
+    async signOut() {
+      const storage = getStorage();
+      if (storage) storage.removeItem(STORAGE_KEY);
+      cachedUser = null;
+      try {
+        await config.fetch(`${config.baseUrl}/oauth/revoke`, {
+          method: "POST",
+          headers: { "content-type": "application/json" }
+        });
+      } catch {
+      }
+      notify();
+    },
+    getUser() {
+      return loadCachedUser();
+    },
+    onAuthStateChanged(listener) {
+      listeners.add(listener);
+      try {
+        listener(loadCachedUser());
+      } catch {
+      }
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function createNeetruClient(config = {}) {
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new NeetruError(
+      "invalid_config",
+      "fetch is not available in this runtime. Pass `fetch` explicitly to createNeetruClient."
+    );
+  }
+  const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const apiKey = config.apiKey ?? readEnvApiKey();
+  const env = resolveEnv(config.env);
+  const resolved = Object.freeze({
+    apiKey,
+    baseUrl,
+    fetch: fetchImpl.bind(globalThis),
+    env,
+    productId: config.productId,
+    tenantId: config.tenantId
+  });
+  const isDev = env === "dev";
+  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 db = config.mocks?.db ?? (isDev ? new MockDb() : createDbNamespace(resolved));
+  const client = Object.freeze({
+    config: resolved,
+    auth,
+    catalog: createCatalogNamespace(resolved),
+    entitlements,
+    telemetry: createTelemetryNamespace(resolved),
+    usage,
+    support,
+    db
+  });
+  return client;
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+function initNeetru(config) {
+  const { apiUrl, baseUrl, ...rest } = config;
+  return createNeetruClient({ ...rest, baseUrl: baseUrl ?? apiUrl });
+}
+
+export { DEFAULT_BASE_URL, DEV_FIXTURE_USER, MockAuth, MockDb, MockEntitlements, MockSupport, MockUsage, NeetruError, VERSION, createNeetruClient, initNeetru };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map