@simplr-ai/node 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -20,10 +20,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  NetworkLogShipper: () => NetworkLogShipper,
   Simplr: () => Simplr,
+  SimplrAI: () => SimplrAI,
   SimplrAdmin: () => SimplrAdmin,
   SimplrError: () => SimplrError,
   SimplrFlags: () => SimplrFlags,
+  SimplrProfiles: () => SimplrProfiles,
+  SimplrRUM: () => SimplrRUM,
   WebhookVerificationError: () => WebhookVerificationError,
   constructWebhookEvent: () => constructEvent,
   default: () => src_default,
@@ -49,17 +53,128 @@ var WebhookVerificationError = class extends Error {
   }
 };
 
+// src/network-log.ts
+var SENSITIVE_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "x-csrf-token",
+  "x-xsrf-token"
+]);
+var SENSITIVE_KEY_PARTS = [
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "api_key",
+  "apikey",
+  "authorization",
+  "auth",
+  "credential",
+  "private_key",
+  "card",
+  "cardnumber",
+  "pan",
+  "cvv",
+  "cvc",
+  "ssn",
+  "pin",
+  "otp"
+];
+var MAX_REDACT_DEPTH = 8;
+var MAX_BODY_CHARS = 1e4;
+function isSensitiveKey(key, extraKeys) {
+  const lower = key.toLowerCase();
+  if (extraKeys.some((k) => lower === k.toLowerCase())) return true;
+  return SENSITIVE_KEY_PARTS.some((part) => lower.includes(part));
+}
+function redactDeep(value, extraKeys, depth = 0) {
+  if (depth >= MAX_REDACT_DEPTH) return "[truncated]";
+  if (Array.isArray(value)) return value.map((v) => redactDeep(v, extraKeys, depth + 1));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, val] of Object.entries(value)) {
+      out[key] = isSensitiveKey(key, extraKeys) ? "[REDACTED]" : redactDeep(val, extraKeys, depth + 1);
+    }
+    return out;
+  }
+  return value;
+}
+function redactHeaders(headers) {
+  if (!headers) return void 0;
+  const out = {};
+  const set = (key, value) => {
+    out[key] = SENSITIVE_HEADERS.has(key.toLowerCase()) ? "[REDACTED]" : value;
+  };
+  if (typeof headers.forEach === "function" && !Array.isArray(headers)) {
+    headers.forEach((value, key) => set(key, value));
+  } else {
+    for (const [key, value] of Object.entries(headers)) {
+      set(key, String(value));
+    }
+  }
+  return out;
+}
+function previewBody(raw, redactFields = []) {
+  if (raw === void 0 || raw === null) return void 0;
+  let value = raw;
+  if (typeof raw === "string") {
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      return raw.length > MAX_BODY_CHARS ? raw.slice(0, MAX_BODY_CHARS) + "\u2026[truncated]" : raw;
+    }
+  }
+  const redacted = redactDeep(value, redactFields);
+  let text;
+  try {
+    text = JSON.stringify(redacted);
+  } catch {
+    return "[unserializable]";
+  }
+  if (text.length > MAX_BODY_CHARS) {
+    return text.slice(0, MAX_BODY_CHARS) + "\u2026[truncated]";
+  }
+  return redacted;
+}
+function newLogId() {
+  const uuid = globalThis?.crypto?.randomUUID;
+  if (typeof uuid === "function") return uuid.call(globalThis.crypto);
+  return `req_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+}
+
 // src/http.ts
 async function apiRequest(cfg, method, path, body) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), cfg.timeoutMs);
+  const url = `${cfg.baseUrl}${path}`;
+  const requestHeaders = {
+    "Content-Type": "application/json",
+    ...cfg.authHeaders
+  };
+  const startedAt = Date.now();
+  const log = cfg.onNetworkLog ? {
+    id: newLogId(),
+    source: "backend",
+    timestamp: new Date(startedAt).toISOString(),
+    method,
+    url,
+    requestHeaders: redactHeaders(requestHeaders),
+    requestBody: cfg.logBodies ? previewBody(body, cfg.redactFields) : void 0
+  } : null;
+  const emit = (extra) => {
+    if (!log || !cfg.onNetworkLog) return;
+    try {
+      cfg.onNetworkLog({ ...log, durationMs: Date.now() - startedAt, ...extra });
+    } catch {
+    }
+  };
   try {
-    const res = await cfg.fetchImpl(`${cfg.baseUrl}${path}`, {
+    const res = await cfg.fetchImpl(url, {
       method,
-      headers: {
-        "Content-Type": "application/json",
-        ...cfg.authHeaders
-      },
+      headers: requestHeaders,
       body: body !== void 0 ? JSON.stringify(body) : void 0,
       signal: controller.signal
     });
@@ -70,6 +185,13 @@ async function apiRequest(cfg, method, path, body) {
     } catch {
       parsed = text;
     }
+    emit({
+      status: res.status,
+      statusText: res.statusText,
+      ok: res.ok,
+      responseHeaders: redactHeaders(res.headers),
+      responseBody: cfg.logBodies ? previewBody(parsed ?? text, cfg.redactFields) : void 0
+    });
     if (!res.ok) {
       const message = parsed && (parsed.message || parsed.error) || `Simplr API error ${res.status}`;
       throw new SimplrError(message, res.status, parsed);
@@ -78,14 +200,68 @@ async function apiRequest(cfg, method, path, body) {
   } catch (err) {
     if (err instanceof SimplrError) throw err;
     if (err instanceof Error && err.name === "AbortError") {
+      emit({ ok: false, error: `timed out after ${cfg.timeoutMs}ms` });
       throw new SimplrError(`Request to ${path} timed out after ${cfg.timeoutMs}ms`, 0, null);
     }
+    emit({ ok: false, error: err instanceof Error ? err.message : "Network error" });
     throw new SimplrError(err instanceof Error ? err.message : "Network error", 0, null);
   } finally {
     clearTimeout(timer);
   }
 }
 
+// src/network-shipper.ts
+var DEFAULT_BATCH = 25;
+var DEFAULT_FLUSH_MS = 5e3;
+var NetworkLogShipper = class {
+  cfg;
+  queue = [];
+  timer = null;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  start() {
+    if (this.timer) return;
+    const interval = this.cfg.flushIntervalMs ?? DEFAULT_FLUSH_MS;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, interval);
+    this.timer?.unref?.();
+  }
+  add(entry) {
+    this.queue.push({
+      ...entry,
+      sdk: this.cfg.sdk,
+      applicationId: entry.applicationId ?? this.cfg.applicationId,
+      environment: entry.environment ?? this.cfg.environment
+    });
+    if (this.queue.length >= (this.cfg.batchSize ?? DEFAULT_BATCH)) {
+      void this.flush();
+    }
+  }
+  async flush() {
+    if (this.queue.length === 0) return;
+    const logs = this.queue;
+    this.queue = [];
+    try {
+      await this.cfg.fetchImpl(`${this.cfg.baseUrl}/v1/network-logs`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.cfg.apiKey
+        },
+        body: JSON.stringify({ logs })
+      });
+    } catch {
+    }
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    void this.flush();
+  }
+};
+
 // src/resources.ts
 var OrdersResource = class {
   constructor(cfg) {
@@ -188,7 +364,10 @@ var SimplrFlags = class {
       authHeaders: { "X-API-Key": options.publicKey },
       baseUrl: (options.baseUrl || "https://api.simplr.sh").replace(/\/+$/, ""),
       timeoutMs: options.timeoutMs ?? 15e3,
-      fetchImpl: options.fetch ?? globalThis.fetch
+      fetchImpl: options.fetch ?? globalThis.fetch,
+      onNetworkLog: options.onNetworkLog,
+      logBodies: options.logBodies,
+      redactFields: options.redactFields
     };
     this.environment = options.environment;
     this.refreshIntervalMs = options.refreshIntervalMs ?? 6e4;
@@ -210,7 +389,7 @@ var SimplrFlags = class {
   }
   /** Re-fetch the flag config (counts as one billable request). */
   async refresh() {
-    const path = this.environment ? `/v1/flags?environment=${this.environment}` : "/v1/flags";
+    const path = this.environment ? `/v1/flags?environment=${encodeURIComponent(this.environment)}` : "/v1/flags";
     try {
       const content = await apiRequest(this.cfg, "GET", path);
       const list = content?.flags || [];
@@ -246,6 +425,295 @@ var SimplrFlags = class {
   }
 };
 
+// src/profiles.ts
+var SimplrProfiles = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  /**
+   * Identify a user — creates or updates an anonymous profile and (optionally)
+   * links a device fingerprint. POST /v1/profiles.
+   */
+  identify(externalId, options) {
+    const { profileType, fingerprintHash, ...rest } = options ?? {};
+    const body = {
+      external_id: externalId,
+      profile_type: profileType || "customer",
+      ...rest
+    };
+    if (fingerprintHash) body.fingerprint_hash = fingerprintHash;
+    return apiRequest(this.cfg, "POST", "/v1/profiles", body);
+  }
+  /** Submit an order for real-time fraud scoring. POST /v1/orders. */
+  submitOrder(order) {
+    return apiRequest(this.cfg, "POST", "/v1/orders", order);
+  }
+  /** Get the risk profile for a user. GET /v1/profiles/{externalId}. */
+  getProfileRisk(externalId) {
+    return apiRequest(
+      this.cfg,
+      "GET",
+      `/v1/profiles/${encodeURIComponent(externalId)}`
+    );
+  }
+  /** Report a profile as fraud or legitimate. POST /v1/profiles/{externalId}/outcome. */
+  async reportOutcome(externalId, outcome) {
+    await apiRequest(
+      this.cfg,
+      "POST",
+      `/v1/profiles/${encodeURIComponent(externalId)}/outcome`,
+      { outcome }
+    );
+  }
+};
+
+// src/rum.ts
+var DEFAULT_BATCH_SIZE = 30;
+var DEFAULT_FLUSH_INTERVAL = 1e4;
+var DEFAULT_ENDPOINT = "/v1/rum/events";
+function genId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
+}
+var SimplrRUM = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  config = null;
+  initialized = false;
+  queue = [];
+  timer = null;
+  flushing = false;
+  sessionId = null;
+  currentViewId = null;
+  userId;
+  userAttributes;
+  globalAttributes = {};
+  batchSize = DEFAULT_BATCH_SIZE;
+  endpoint = DEFAULT_ENDPOINT;
+  /** Initialize the SDK, start a session, and begin the flush timer. */
+  initialize(config) {
+    if (this.initialized) return;
+    this.config = config;
+    this.batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.endpoint = config.endpoint ?? DEFAULT_ENDPOINT;
+    this.sessionId = genId();
+    this.initialized = true;
+    this.trackEvent("session_start");
+    const interval = config.flushInterval ?? DEFAULT_FLUSH_INTERVAL;
+    if (interval > 0) {
+      this.timer = setInterval(() => {
+        void this.flush();
+      }, interval);
+      this.timer?.unref?.();
+    }
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  /** Associate subsequent events with a user. */
+  setUser(userId, attributes) {
+    this.userId = userId;
+    this.userAttributes = attributes;
+  }
+  clearUser() {
+    this.userId = void 0;
+    this.userAttributes = void 0;
+  }
+  addAttribute(key, value) {
+    this.globalAttributes[key] = value;
+  }
+  removeAttribute(key) {
+    delete this.globalAttributes[key];
+  }
+  /** Track a screen/page view. */
+  trackView(name, attributes) {
+    if (!this.initialized) return;
+    this.currentViewId = genId();
+    this.trackEvent("view", {
+      view: { id: this.currentViewId, name },
+      attributes
+    });
+  }
+  /** Track a user action. */
+  trackAction(name, attributes) {
+    if (!this.initialized) return;
+    this.trackEvent("action", { action: { name, type: "custom" }, attributes });
+  }
+  /** Track an error. */
+  trackError(error, attributes) {
+    if (!this.initialized) return;
+    const data = error instanceof Error ? { message: error.message, stack: error.stack, type: error.constructor.name } : error;
+    this.trackEvent("error", { error: data, attributes });
+  }
+  /** Emit a log line. */
+  log(level, message, attributes) {
+    if (!this.initialized) return;
+    this.trackEvent("log", { log: { level, message }, attributes });
+  }
+  trackEvent(type, data) {
+    if (!this.initialized || !this.sessionId) return;
+    const event = {
+      type,
+      timestamp: Date.now(),
+      sessionId: this.sessionId,
+      viewId: this.currentViewId || void 0,
+      userId: this.userId,
+      applicationId: this.config.applicationId,
+      applicationVersion: this.config?.applicationVersion,
+      environment: this.config?.environment,
+      userAttributes: this.userAttributes,
+      globalAttributes: Object.keys(this.globalAttributes).length > 0 ? this.globalAttributes : void 0,
+      ...data
+    };
+    this.queue.push(event);
+    if (this.queue.length >= this.batchSize) void this.flush();
+  }
+  /** Flush queued events to POST /v1/rum/events. */
+  async flush() {
+    if (this.flushing || this.queue.length === 0) return;
+    this.flushing = true;
+    const events = this.queue;
+    this.queue = [];
+    try {
+      await apiRequest(this.cfg, "POST", this.endpoint, {
+        events,
+        sentAt: Date.now()
+      });
+    } catch {
+      this.queue = [...events, ...this.queue];
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /** End the session, flush remaining events, and stop the timer. */
+  async stopSession() {
+    if (!this.initialized) return;
+    this.trackEvent("session_end");
+    await this.flush();
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.initialized = false;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getViewId() {
+    return this.currentViewId;
+  }
+};
+
+// src/ai.ts
+function mapDelegation(d) {
+  return {
+    delegationId: d.delegation_id,
+    endUserId: d.end_user_id,
+    bindingMode: d.binding_mode,
+    status: d.status,
+    expiresAt: d.expires_at,
+    useCount: d.use_count,
+    lastUsedAt: d.last_used_at,
+    createdAt: d.created_at
+  };
+}
+var SimplrAI = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  /** Create a new AI delegation token for a user. POST /v1/ai/delegations. */
+  async createDelegation(options) {
+    const content = await apiRequest(this.cfg, "POST", "/v1/ai/delegations", {
+      end_user_id: options.userId,
+      end_user_email: options.email,
+      binding: options.binding || "any_location",
+      expires_in_days: options.expiresInDays || 7,
+      session_id: options.sessionId,
+      fingerprint_hash: options.fingerprintHash
+    });
+    const d = content.delegation;
+    return {
+      token: d.token,
+      delegationId: d.delegation_id,
+      expiresAt: d.expires_at,
+      bindingMode: d.binding_mode
+    };
+  }
+  /** Validate (introspect) an AI delegation token. POST /v1/ai/validate. */
+  async validate(token, options) {
+    try {
+      const content = await apiRequest(this.cfg, "POST", "/v1/ai/validate", {
+        token,
+        fingerprint_hash: options?.fingerprintHash,
+        ai_provider: options?.aiProvider,
+        action: options?.action
+      });
+      return {
+        valid: true,
+        sessionType: content.session_type,
+        endUserId: content.end_user_id,
+        delegation: content.delegation ? {
+          delegationId: content.delegation.delegation_id,
+          bindingMode: content.delegation.binding_mode,
+          expiresAt: content.delegation.expires_at,
+          useCount: content.delegation.use_count
+        } : void 0
+      };
+    } catch (err) {
+      return { valid: false, error: err instanceof Error ? err.message : "Validation failed" };
+    }
+  }
+  /** Revoke a delegation. POST /v1/ai/delegations/{id}/revoke. */
+  async revoke(delegationId, reason) {
+    await apiRequest(
+      this.cfg,
+      "POST",
+      `/v1/ai/delegations/${encodeURIComponent(delegationId)}/revoke`,
+      { reason }
+    );
+  }
+  /** List delegations, optionally filtered by user. GET /v1/ai/delegations. */
+  async list(userId) {
+    const path = userId ? `/v1/ai/delegations?end_user_id=${encodeURIComponent(userId)}` : "/v1/ai/delegations";
+    const content = await apiRequest(this.cfg, "GET", path);
+    return (content.delegations || []).map(mapDelegation);
+  }
+  /** Get a single delegation. GET /v1/ai/delegations/{id}. */
+  async get(delegationId) {
+    const content = await apiRequest(
+      this.cfg,
+      "GET",
+      `/v1/ai/delegations/${encodeURIComponent(delegationId)}`
+    );
+    return mapDelegation(content.delegation);
+  }
+  /** Get delegation statistics. GET /v1/ai/stats. */
+  async stats() {
+    const content = await apiRequest(this.cfg, "GET", "/v1/ai/stats");
+    const s = content.stats;
+    return {
+      totalDelegations: s.total_delegations,
+      activeDelegations: s.active_delegations,
+      totalUses: s.total_uses,
+      delegationsByBinding: {
+        verifiedDevice: s.delegations_by_binding.verified_device,
+        anyLocation: s.delegations_by_binding.any_location
+      }
+    };
+  }
+  /** Revoke all delegations for a user (e.g. on logout). POST /v1/ai/revoke-all. */
+  async revokeAllForUser(userId, reason) {
+    const content = await apiRequest(this.cfg, "POST", "/v1/ai/revoke-all", {
+      end_user_id: userId,
+      reason
+    });
+    return content.revoked_count;
+  }
+};
+
 // src/webhooks.ts
 var webhooks_exports = {};
 __export(webhooks_exports, {
@@ -392,16 +860,43 @@ var Simplr = class {
   orders;
   phone;
   edge;
+  /** Anonymous user profiles + order fraud monitoring. */
+  profiles;
+  /** Real User Monitoring — batched events to /v1/rum/events. */
+  rum;
+  /** AI delegation — OAuth-like AI authentication. */
+  ai;
   /** Webhook signature helpers (no network). */
   webhooks = webhooks_exports;
   _flags;
+  shipper;
   constructor(options) {
     if (!options?.apiKey) throw new Error("Simplr: `apiKey` is required");
+    const baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (options.shipNetworkLogs) {
+      this.shipper = new NetworkLogShipper({
+        baseUrl,
+        apiKey: options.apiKey,
+        fetchImpl,
+        sdk: "node",
+        applicationId: options.applicationId,
+        environment: options.environment
+      });
+      this.shipper.start();
+    }
+    const onNetworkLog = this.shipper || options.onNetworkLog ? (entry) => {
+      this.shipper?.add(entry);
+      options.onNetworkLog?.(entry);
+    } : void 0;
     this.cfg = {
       authHeaders: { "X-API-Key": options.apiKey },
-      baseUrl: (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, ""),
+      baseUrl,
       timeoutMs: options.timeoutMs ?? 15e3,
-      fetchImpl: options.fetch ?? globalThis.fetch
+      fetchImpl,
+      onNetworkLog,
+      logBodies: options.logBodies ?? options.shipNetworkLogs,
+      redactFields: options.redactFields
     };
     if (typeof this.cfg.fetchImpl !== "function") {
       throw new Error("Simplr: no global fetch available \u2014 use Node 18+ or pass `fetch` in options");
@@ -409,12 +904,19 @@ var Simplr = class {
     this.orders = new OrdersResource(this.cfg);
     this.phone = new PhoneResource(this.cfg);
     this.edge = new EdgeResource(this.cfg);
+    this.profiles = new SimplrProfiles(this.cfg);
+    this.rum = new SimplrRUM(this.cfg);
+    this.ai = new SimplrAI(this.cfg);
     if (options.publicKey) {
       this._flags = new SimplrFlags({
         publicKey: options.publicKey,
+        environment: options.environment,
         baseUrl: this.cfg.baseUrl,
         timeoutMs: this.cfg.timeoutMs,
-        fetch: this.cfg.fetchImpl
+        fetch: this.cfg.fetchImpl,
+        onNetworkLog: this.cfg.onNetworkLog,
+        logBodies: this.cfg.logBodies,
+        redactFields: options.redactFields
       });
     }
   }
@@ -438,14 +940,25 @@ var Simplr = class {
   checkBulk(items) {
     return apiRequest(this.cfg, "POST", "/v1/check/bulk", { items });
   }
+  flushNetworkLogs() {
+    return this.shipper?.flush() ?? Promise.resolve();
+  }
+  close() {
+    this.shipper?.stop();
+    this._flags?.dispose();
+  }
 };
 var src_default = Simplr;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  NetworkLogShipper,
   Simplr,
+  SimplrAI,
   SimplrAdmin,
   SimplrError,
   SimplrFlags,
+  SimplrProfiles,
+  SimplrRUM,
   WebhookVerificationError,
   constructWebhookEvent,
   verifyWebhook