@finatic/client 0.9.1 → 0.9.2

package/dist/index.mjs

@@ -1,6 +1,4 @@
 import pRetry, { AbortError } from 'p-retry';
-import pino from 'pino';
-import NodeCache from 'node-cache';
 import * as z from 'zod';
 import globalAxios from 'axios';
 
@@ -72,14 +70,12 @@ async function retryApiCall(fn, options = {}, config) {
 }
 
 /**
- * Structured logger utility with browser-safe fallback (Phase 2C).
+ * Structured logger utility with browser-safe console logging (Phase 2C).
  *
  * Generated - do not edit directly.
  *
- * This logger automatically falls back to console-based logging when pino fails
- * in browser environments (Vite, Next.js, etc.).
+ * This logger uses browser console APIs for all logging in browser environments.
  */
-// @ts-ignore - pino types available via @types/pino
 let _loggerInstance = null;
 /**
  * Get environment variable from various sources (browser and Node.js).
@@ -124,30 +120,6 @@ function isProduction() {
         return true;
     return false;
 }
-/**
- * Detect if we're in a browser environment.
- */
-function isBrowser() {
-    // Check for window object (browser)
-    if (typeof window !== 'undefined') {
-        return true;
-    }
-    // Check for globalThis in browser-like environments
-    if (typeof globalThis !== 'undefined') {
-        // In browsers, process might be polyfilled but process.stdout won't exist
-        try {
-            const proc = globalThis.process;
-            if (proc && typeof proc.stdout === 'undefined') {
-                return true;
-            }
-        }
-        catch {
-            // If we can't check, assume browser if window exists
-            return typeof window !== 'undefined';
-        }
-    }
-    return false;
-}
 /**
  * Get or create a logger instance with browser-safe fallback.
  */
@@ -155,36 +127,13 @@ function getLogger(config) {
     if (_loggerInstance) {
         return _loggerInstance;
     }
-    // In browser environments, skip pino entirely and use browser-safe logger
-    if (isBrowser()) {
-        return getBrowserSafeLogger(config);
-    }
-    // Try to use pino first (Node.js environments)
-    try {
-        const logLevel = (config?.logLevel || getEnvVar('FINATIC_LOG_LEVEL') || 'error');
-        const pinoConfig = {
-            level: logLevel === 'silent' ? 'silent' : logLevel,
-            ...(config?.structuredLogging !== false && {
-                formatters: {
-                    level: (label) => {
-                        return { level: label };
-                    },
-                },
-                timestamp: true,
-            }),
-        };
-        _loggerInstance = pino(pinoConfig);
-        return _loggerInstance;
-    }
-    catch (error) {
-        // Fallback to browser-safe logger if pino fails
-        return getBrowserSafeLogger(config, error);
-    }
+    // Client SDK always uses browser-safe logger (no pino)
+    return getBrowserSafeLogger(config);
 }
 /**
- * Browser-safe logger fallback for environments where pino fails.
+ * Browser-safe logger for Client SDK.
  */
-function getBrowserSafeLogger(config, pinoError) {
+function getBrowserSafeLogger(config) {
     // Log level hierarchy (matching pino's numeric levels)
     const LOG_LEVELS = {
         silent: 0,
@@ -215,7 +164,7 @@ function getBrowserSafeLogger(config, pinoError) {
     };
     const logLevel = getEffectiveLogLevel();
     const structuredLogging = config?.structuredLogging ?? false;
-    const isProd = isProduction();
+    isProduction();
     /**
      * Check if we should log at this level.
      */
@@ -348,10 +297,6 @@ function getBrowserSafeLogger(config, pinoError) {
             }
         },
     };
-    // Only warn about fallback logger if pino failed (not if we're in browser)
-    if (pinoError && !isProd) {
-        console.warn('[Finatic SDK] Using fallback logger due to pino initialization error:', pinoError);
-    }
     _loggerInstance = fallbackLogger;
     return _loggerInstance;
 }
@@ -419,11 +364,96 @@ function handleError(error, requestId) {
 }
 
 /**
- * Response caching utility with node-cache (Phase 2B).
+ * Response caching utility with browser-compatible Map-based cache (Phase 2B).
  *
  * Generated - do not edit directly.
  */
-// @ts-ignore - node-cache types available via @types/node-cache
+class MapBasedCache {
+    constructor(maxSize = 1000, defaultTtl = 300) {
+        this.cleanupInterval = null;
+        this.cache = new Map();
+        this.maxSize = maxSize;
+        this.defaultTtl = defaultTtl;
+        this.startCleanup();
+    }
+    startCleanup() {
+        // Clean up expired entries every minute
+        if (typeof window !== 'undefined') {
+            this.cleanupInterval = window.setInterval(() => {
+                this.cleanup();
+            }, 60000);
+        }
+    }
+    cleanup() {
+        const now = Date.now();
+        const keysToDelete = [];
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.expires < now) {
+                keysToDelete.push(key);
+            }
+        }
+        keysToDelete.forEach(key => this.cache.delete(key));
+    }
+    evictLRU() {
+        if (this.cache.size < this.maxSize) {
+            return;
+        }
+        // Simple LRU: remove oldest entry (first in Map)
+        const firstKey = this.cache.keys().next().value;
+        if (firstKey) {
+            this.cache.delete(firstKey);
+        }
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return undefined;
+        }
+        // Check if expired
+        if (entry.expires < Date.now()) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value, ttl) {
+        // Evict if at max size
+        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            this.evictLRU();
+        }
+        const expires = Date.now() + (ttl || this.defaultTtl) * 1000;
+        this.cache.set(key, { value, expires });
+        return true;
+    }
+    del(key) {
+        return this.cache.delete(key) ? 1 : 0;
+    }
+    clear() {
+        this.cache.clear();
+    }
+    keys() {
+        return Array.from(this.cache.keys());
+    }
+    has(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return false;
+        }
+        // Check if expired
+        if (entry.expires < Date.now()) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    destroy() {
+        if (this.cleanupInterval !== null && typeof window !== 'undefined') {
+            window.clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.cache.clear();
+    }
+}
 let _cacheInstance = null;
 /**
  * Get or create cache instance.
@@ -435,11 +465,7 @@ function getCache(config) {
     if (_cacheInstance) {
         return _cacheInstance;
     }
-    _cacheInstance = new NodeCache({
-        stdTTL: config.cacheTtl || 300,
-        maxKeys: config.cacheMaxSize || 1000,
-        useClones: false,
-    });
+    _cacheInstance = new MapBasedCache(config.cacheMaxSize || 1000, config.cacheTtl || 300);
     return _cacheInstance;
 }
 /**