@databuddy/sdk 2.3.30 → 2.4.0

package/dist/shared/@databuddy/sdk.Ugr1p2j9.mjs

@@ -0,0 +1,601 @@
+class Logger {
+  debugEnabled = false;
+  /**
+   * Enable or disable debug logging
+   */
+  setDebug(enabled) {
+    this.debugEnabled = enabled;
+  }
+  /**
+   * Log debug messages (only when debug is enabled)
+   */
+  debug(...args) {
+    if (this.debugEnabled) {
+      console.log("[Databuddy]", ...args);
+    }
+  }
+  /**
+   * Log info messages (always enabled)
+   */
+  info(...args) {
+    console.info("[Databuddy]", ...args);
+  }
+  /**
+   * Log warning messages (always enabled)
+   */
+  warn(...args) {
+    console.warn("[Databuddy]", ...args);
+  }
+  /**
+   * Log error messages (always enabled)
+   */
+  error(...args) {
+    console.error("[Databuddy]", ...args);
+  }
+  /**
+   * Log with table format (only when debug is enabled)
+   */
+  table(data) {
+    if (this.debugEnabled) {
+      console.table(data);
+    }
+  }
+  /**
+   * Time a function execution (only when debug is enabled)
+   */
+  time(label) {
+    if (this.debugEnabled) {
+      console.time(`[Databuddy] ${label}`);
+    }
+  }
+  /**
+   * End timing a function execution (only when debug is enabled)
+   */
+  timeEnd(label) {
+    if (this.debugEnabled) {
+      console.timeEnd(`[Databuddy] ${label}`);
+    }
+  }
+  /**
+   * Log JSON data (only when debug is enabled)
+   */
+  json(data) {
+    if (this.debugEnabled) {
+      console.log("[Databuddy]", JSON.stringify(data, null, 2));
+    }
+  }
+}
+const logger = new Logger();
+
+const DEFAULT_RESULT = {
+  enabled: false,
+  value: false,
+  payload: null,
+  reason: "DEFAULT"
+};
+function getCacheKey(key, user) {
+  if (!(user?.userId || user?.email)) {
+    return key;
+  }
+  return `${key}:${user.userId ?? ""}:${user.email ?? ""}`;
+}
+function buildQueryParams(config, user) {
+  const params = new URLSearchParams();
+  params.set("clientId", config.clientId);
+  const u = user ?? config.user;
+  if (u?.userId) {
+    params.set("userId", u.userId);
+  }
+  if (u?.email) {
+    params.set("email", u.email);
+  }
+  if (u?.organizationId) {
+    params.set("organizationId", u.organizationId);
+  }
+  if (u?.teamId) {
+    params.set("teamId", u.teamId);
+  }
+  if (u?.properties) {
+    params.set("properties", JSON.stringify(u.properties));
+  }
+  if (config.environment) {
+    params.set("environment", config.environment);
+  }
+  return params;
+}
+async function fetchFlags(apiUrl, keys, params) {
+  const batchParams = new URLSearchParams(params);
+  batchParams.set("keys", keys.join(","));
+  const url = `${apiUrl}/public/v1/flags/bulk?${batchParams}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    const result = {};
+    for (const key of keys) {
+      result[key] = { ...DEFAULT_RESULT, reason: "ERROR" };
+    }
+    return result;
+  }
+  const data = await response.json();
+  return data.flags ?? {};
+}
+async function fetchAllFlags(apiUrl, params) {
+  const url = `${apiUrl}/public/v1/flags/bulk?${params}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    return {};
+  }
+  const data = await response.json();
+  return data.flags ?? {};
+}
+class RequestBatcher {
+  pending = /* @__PURE__ */ new Map();
+  timer = null;
+  batchDelayMs;
+  apiUrl;
+  params;
+  constructor(apiUrl, params, batchDelayMs = 10) {
+    this.apiUrl = apiUrl;
+    this.params = params;
+    this.batchDelayMs = batchDelayMs;
+  }
+  request(key) {
+    return new Promise((resolve, reject) => {
+      const existing = this.pending.get(key);
+      if (existing) {
+        existing.push({ resolve, reject });
+      } else {
+        this.pending.set(key, [{ resolve, reject }]);
+      }
+      if (!this.timer) {
+        this.timer = setTimeout(() => this.flush(), this.batchDelayMs);
+      }
+    });
+  }
+  async flush() {
+    this.timer = null;
+    const keys = [...this.pending.keys()];
+    const callbacks = new Map(this.pending);
+    this.pending.clear();
+    if (keys.length === 0) {
+      return;
+    }
+    try {
+      const results = await fetchFlags(this.apiUrl, keys, this.params);
+      for (const [key, cbs] of callbacks) {
+        const result = results[key] ?? {
+          ...DEFAULT_RESULT,
+          reason: "NOT_FOUND"
+        };
+        for (const cb of cbs) {
+          cb.resolve(result);
+        }
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Fetch failed");
+      for (const cbs of callbacks.values()) {
+        for (const cb of cbs) {
+          cb.reject(error);
+        }
+      }
+    }
+  }
+  destroy() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.pending.clear();
+  }
+}
+
+const ANON_ID_KEY = "did";
+const DEFAULT_API = "https://api.databuddy.cc";
+function resolved(result, ttl, staleTime) {
+  const now = Date.now();
+  return {
+    promise: Promise.resolve(result),
+    result,
+    expiresAt: now + ttl,
+    staleAt: now + staleTime
+  };
+}
+function isValid(entry) {
+  return entry !== void 0 && Date.now() <= entry.expiresAt;
+}
+function isStale(entry) {
+  return Date.now() > entry.staleAt;
+}
+class BaseFlagsManager {
+  config;
+  storage;
+  cache = /* @__PURE__ */ new Map();
+  batcher = null;
+  ready = false;
+  listeners = /* @__PURE__ */ new Set();
+  snapshot = { flags: {}, isReady: false };
+  constructor(options) {
+    this.config = {
+      apiUrl: DEFAULT_API,
+      disabled: false,
+      debug: false,
+      autoFetch: true,
+      cacheTtl: 6e4,
+      staleTime: 3e4,
+      ...options.config
+    };
+    this.storage = options.storage;
+    logger.setDebug(this.config.debug ?? false);
+  }
+  shouldSkipFetch() {
+    return false;
+  }
+  onCacheUpdated() {
+  }
+  onFlagEvaluated(_key, _result) {
+  }
+  async runInit() {
+    if (this.storage) {
+      this.hydrate();
+    }
+    if (this.config.autoFetch && !this.config.isPending) {
+      await this.fetchAllFlags();
+    }
+    this.ready = true;
+  }
+  hydrate() {
+    if (!this.storage) {
+      return;
+    }
+    try {
+      const stored = this.storage.getAll();
+      const { ttl, stale } = this.ttls();
+      for (const [key, value] of Object.entries(stored)) {
+        if (value && typeof value === "object") {
+          this.cache.set(key, resolved(value, ttl, stale));
+        }
+      }
+      if (this.cache.size > 0) {
+        this.emit();
+      }
+    } catch (err) {
+      logger.warn("Failed to load from storage:", err);
+    }
+  }
+  persist() {
+    if (!this.storage) {
+      return;
+    }
+    try {
+      const flags = {};
+      for (const [key, entry] of this.cache) {
+        if (entry.result) {
+          flags[key] = entry.result;
+        }
+      }
+      this.storage.setAll(flags);
+    } catch (err) {
+      logger.warn("Failed to save to storage:", err);
+    }
+  }
+  ttls() {
+    const ttl = this.config.cacheTtl ?? 6e4;
+    return { ttl, stale: this.config.staleTime ?? ttl / 2 };
+  }
+  validEntry(cacheKey) {
+    const entry = this.cache.get(cacheKey);
+    if (isValid(entry)) {
+      return entry;
+    }
+    if (entry) {
+      this.cache.delete(cacheKey);
+    }
+    return null;
+  }
+  ensureBatcher() {
+    if (!this.batcher) {
+      const params = buildQueryParams(this.config);
+      this.batcher = new RequestBatcher(
+        this.config.apiUrl ?? DEFAULT_API,
+        params,
+        this.batchDelay()
+      );
+    }
+    return this.batcher;
+  }
+  batchDelay() {
+    return 10;
+  }
+  pruneStaleKeys(validKeys, user) {
+    const ctx = user ?? this.config.user;
+    const suffix = ctx?.userId || ctx?.email ? `:${ctx.userId ?? ""}:${ctx.email ?? ""}` : "";
+    for (const key of this.cache.keys()) {
+      const belongsToUser = suffix ? key.endsWith(suffix) : !key.includes(":");
+      if (belongsToUser && !validKeys.has(key)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  revalidate(key, cacheKey) {
+    const existing = this.cache.get(cacheKey);
+    if (existing && !existing.result) {
+      return;
+    }
+    const { ttl, stale } = this.ttls();
+    const promise = this.ensureBatcher().request(key);
+    this.cache.set(cacheKey, {
+      promise,
+      result: existing?.result ?? null,
+      expiresAt: existing?.expiresAt ?? Date.now() + ttl,
+      staleAt: existing?.staleAt ?? Date.now() + stale
+    });
+    promise.then((result) => {
+      this.cache.set(cacheKey, resolved(result, ttl, stale));
+      this.emit();
+      this.onCacheUpdated();
+    }).catch((err) => {
+      logger.error(`Revalidation error: ${key}`, err);
+    });
+  }
+  async getFlag(key, user) {
+    if (this.config.disabled) {
+      return DEFAULT_RESULT;
+    }
+    if (this.config.isPending) {
+      return { ...DEFAULT_RESULT, reason: "SESSION_PENDING" };
+    }
+    const cacheKey = getCacheKey(key, user ?? this.config.user);
+    const entry = this.validEntry(cacheKey);
+    if (entry) {
+      if (isStale(entry) && !this.shouldSkipFetch()) {
+        this.revalidate(key, cacheKey);
+      }
+      return entry.result ?? entry.promise;
+    }
+    const pending = this.cache.get(cacheKey);
+    if (pending) {
+      return pending.promise;
+    }
+    const { ttl, stale } = this.ttls();
+    const promise = this.ensureBatcher().request(key);
+    this.cache.set(cacheKey, {
+      promise,
+      result: null,
+      expiresAt: Date.now() + ttl,
+      staleAt: Date.now() + stale
+    });
+    try {
+      const result = await promise;
+      this.cache.set(cacheKey, resolved(result, ttl, stale));
+      this.emit();
+      this.onCacheUpdated();
+      this.onFlagEvaluated(key, result);
+      return result;
+    } catch (err) {
+      this.cache.delete(cacheKey);
+      throw err;
+    }
+  }
+  async fetchAllFlags(user) {
+    if (this.config.disabled || this.config.isPending) {
+      return;
+    }
+    if (this.shouldSkipFetch() && this.cache.size > 0) {
+      return;
+    }
+    const params = buildQueryParams(this.config, user);
+    const { ttl, stale } = this.ttls();
+    try {
+      const flags = await fetchAllFlags(
+        this.config.apiUrl ?? DEFAULT_API,
+        params
+      );
+      const entries = Object.entries(flags).map(([key, result]) => ({
+        cacheKey: getCacheKey(key, user ?? this.config.user),
+        entry: resolved(result, ttl, stale)
+      }));
+      this.pruneStaleKeys(
+        new Set(entries.map(({ cacheKey }) => cacheKey)),
+        user
+      );
+      for (const { cacheKey, entry } of entries) {
+        this.cache.set(cacheKey, entry);
+      }
+      this.ready = true;
+      this.emit();
+      this.onCacheUpdated();
+    } catch (err) {
+      logger.error("Bulk fetch error:", err);
+    }
+  }
+  isEnabled(key) {
+    const cacheKey = getCacheKey(key, this.config.user);
+    const entry = this.validEntry(cacheKey);
+    if (entry?.result) {
+      if (isStale(entry) && !this.shouldSkipFetch()) {
+        this.revalidate(key, cacheKey);
+      }
+      return {
+        on: entry.result.enabled,
+        status: entry.result.reason === "ERROR" ? "error" : "ready",
+        loading: false,
+        value: entry.result.value,
+        variant: entry.result.variant
+      };
+    }
+    if (!entry) {
+      this.getFlag(key).catch(
+        (err) => logger.error(`Background fetch error: ${key}`, err)
+      );
+    }
+    return { on: false, status: "loading", loading: true };
+  }
+  getValue(key, defaultValue) {
+    const cacheKey = getCacheKey(key, this.config.user);
+    const entry = this.validEntry(cacheKey);
+    if (entry?.result) {
+      if (isStale(entry) && !this.shouldSkipFetch()) {
+        this.revalidate(key, cacheKey);
+      }
+      return entry.result.value;
+    }
+    if (!entry) {
+      this.getFlag(key).catch(
+        (err) => logger.error(`Background fetch error: ${key}`, err)
+      );
+    }
+    return defaultValue ?? this.config.defaults?.[key] ?? false;
+  }
+  updateUser(user) {
+    this.config = { ...this.config, user: this.enrichUser(user) };
+    this.resetBatcher();
+    this.refresh().catch((err) => logger.error("Refresh error:", err));
+  }
+  async refresh(forceClear = false) {
+    if (forceClear) {
+      this.cache.clear();
+      this.storage?.clear();
+      this.emit();
+    }
+    await this.fetchAllFlags();
+  }
+  updateConfig(config) {
+    const wasInactive = this.config.disabled || this.config.isPending;
+    this.config = { ...this.config, ...config };
+    this.resetBatcher();
+    if (wasInactive && !this.config.disabled && !this.config.isPending) {
+      this.fetchAllFlags().catch((err) => logger.error("Fetch error:", err));
+    }
+  }
+  getMemoryFlags() {
+    const flags = {};
+    for (const [key, entry] of this.cache) {
+      if (entry.result) {
+        flags[key.split(":").at(0) ?? key] = entry.result;
+      }
+    }
+    return flags;
+  }
+  isReady() {
+    return this.ready;
+  }
+  destroy() {
+    this.batcher?.destroy();
+    this.cache.clear();
+    this.listeners.clear();
+  }
+  subscribe = (cb) => {
+    this.listeners.add(cb);
+    return () => {
+      this.listeners.delete(cb);
+    };
+  };
+  getSnapshot = () => this.snapshot;
+  enrichUser(user) {
+    return user;
+  }
+  emit() {
+    this.snapshot = { flags: this.getMemoryFlags(), isReady: this.ready };
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+  resetBatcher() {
+    this.batcher?.destroy();
+    this.batcher = null;
+  }
+  revalidateStale() {
+    for (const entry of this.cache.values()) {
+      if (isStale(entry)) {
+        this.fetchAllFlags().catch(
+          (err) => logger.error("Revalidation error:", err)
+        );
+        return;
+      }
+    }
+  }
+}
+class BrowserFlagsManager extends BaseFlagsManager {
+  isVisible = true;
+  visibilityCleanup;
+  trackedFlags = /* @__PURE__ */ new Set();
+  constructor(options) {
+    super(options);
+    this.config.user = this.enrichUser(this.config.user ?? {});
+    this.config.autoFetch = options.config.autoFetch !== false;
+    this.setupVisibilityListener();
+    this.runInit();
+  }
+  shouldSkipFetch() {
+    return !this.isVisible;
+  }
+  onCacheUpdated() {
+    this.persist();
+  }
+  onFlagEvaluated(key, result) {
+    const dedupeKey = `${key}:${String(result.value)}`;
+    if (this.trackedFlags.has(dedupeKey)) {
+      return;
+    }
+    this.trackedFlags.add(dedupeKey);
+    try {
+      if (typeof window !== "undefined" && (window.databuddy || window.db)) {
+        const tracker = window.databuddy ?? window.db;
+        tracker?.track?.("$flag_evaluated", {
+          flag: key,
+          value: result.value,
+          variant: result.variant,
+          enabled: result.enabled
+        });
+      }
+    } catch {
+    }
+  }
+  enrichUser(user) {
+    if (user.userId || user.email) {
+      return user;
+    }
+    const anonId = this.getOrCreateAnonId();
+    if (!anonId) {
+      return user;
+    }
+    return { ...user, userId: anonId };
+  }
+  destroy() {
+    super.destroy();
+    this.visibilityCleanup?.();
+    this.trackedFlags.clear();
+  }
+  getOrCreateAnonId() {
+    if (typeof localStorage === "undefined") {
+      return null;
+    }
+    try {
+      let id = localStorage.getItem(ANON_ID_KEY);
+      if (id) {
+        return id;
+      }
+      id = `anon_${crypto.randomUUID()}`;
+      localStorage.setItem(ANON_ID_KEY, id);
+      return id;
+    } catch {
+      return null;
+    }
+  }
+  setupVisibilityListener() {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const handler = () => {
+      this.isVisible = document.visibilityState === "visible";
+      if (this.isVisible) {
+        this.revalidateStale();
+      }
+    };
+    document.addEventListener("visibilitychange", handler);
+    this.visibilityCleanup = () => {
+      document.removeEventListener("visibilitychange", handler);
+    };
+  }
+}
+
+export { BrowserFlagsManager as B, BaseFlagsManager as a, logger as l };

package/dist/shared/@databuddy/sdk.rnu91OSC.d.mts

@@ -0,0 +1,81 @@
+interface FlagResult {
+    enabled: boolean;
+    value: boolean | string | number;
+    payload: Record<string, unknown> | null;
+    reason: string;
+    variant?: string;
+}
+interface UserContext {
+    userId?: string;
+    email?: string;
+    organizationId?: string;
+    teamId?: string;
+    properties?: Record<string, unknown>;
+}
+interface FlagsConfig {
+    clientId: string;
+    apiUrl?: string;
+    user?: UserContext;
+    disabled?: boolean;
+    debug?: boolean;
+    /** Skip persistent storage (browser only) */
+    skipStorage?: boolean;
+    /** Defer evaluation until session resolves */
+    isPending?: boolean;
+    /** Auto-fetch all flags on init (default: true) */
+    autoFetch?: boolean;
+    environment?: string;
+    /** Cache TTL in ms (default: 60000) */
+    cacheTtl?: number;
+    /** Stale time in ms — revalidate in background after this (default: cacheTtl/2) */
+    staleTime?: number;
+    /** Default values by flag key */
+    defaults?: Record<string, boolean | string | number>;
+}
+type FlagStatus = "loading" | "ready" | "error" | "pending";
+interface FlagState {
+    on: boolean;
+    status: FlagStatus;
+    loading: boolean;
+    value?: boolean | string | number;
+    variant?: string;
+}
+interface FlagsContext {
+    getFlag: (key: string) => FlagState;
+    getValue: <T extends boolean | string | number = boolean>(key: string, defaultValue?: T) => T;
+    isOn: (key: string) => boolean;
+    fetchFlag: (key: string) => Promise<FlagResult>;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: UserContext) => void;
+    refresh: (forceClear?: boolean) => Promise<void>;
+    isReady: boolean;
+}
+interface FlagsSnapshot {
+    flags: Record<string, FlagResult>;
+    isReady: boolean;
+}
+interface StorageInterface {
+    getAll(): Record<string, FlagResult>;
+    setAll(flags: Record<string, FlagResult>): void;
+    clear(): void;
+}
+interface FlagsManagerOptions {
+    config: FlagsConfig;
+    storage?: StorageInterface;
+}
+interface FlagsManager {
+    getFlag(key: string, user?: UserContext): Promise<FlagResult>;
+    isEnabled(key: string): FlagState;
+    getValue<T = boolean | string | number>(key: string, defaultValue?: T): T;
+    fetchAllFlags(user?: UserContext): Promise<void>;
+    updateUser(user: UserContext): void;
+    refresh(forceClear?: boolean): Promise<void>;
+    updateConfig(config: FlagsConfig): void;
+    getMemoryFlags(): Record<string, FlagResult>;
+    isReady(): boolean;
+    destroy(): void;
+    subscribe(callback: () => void): () => void;
+    getSnapshot(): FlagsSnapshot;
+}
+
+export type { FlagsConfig as F, StorageInterface as S, UserContext as U, FlagState as a, FlagsContext as b, FlagResult as c, FlagsManager as d, FlagsManagerOptions as e, FlagsSnapshot as f };