@keverdjs/fraud-sdk-react 1.1.0 → 1.1.2

package/README.md

@@ -85,7 +85,6 @@ interface KeverdProviderProps {
 ```typescript
 interface KeverdLoadOptions {
   apiKey: string;              // Required: Your Keverd API key
-  endpoint?: string;           // Optional: Custom API endpoint (default: https://api.keverd.com)
   debug?: boolean;             // Optional: Enable debug logging (default: false)
 }
 ```
@@ -151,21 +150,6 @@ const sdk = useKeverdContext();
 
 ## Configuration
 
-### Custom Endpoint
-
-If you're using a custom backend endpoint:
-
-```tsx
-<KeverdProvider
-  loadOptions={{
-    apiKey: 'your-api-key',
-    endpoint: 'https://api.yourdomain.com/v1/fingerprint/score',
-  }}
->
-  {children}
-</KeverdProvider>
-```
-
 ### Debug Mode
 
 Enable debug logging for development:

package/dist/index.d.mts

@@ -82,7 +82,6 @@ interface KeverdVisitorData {
 }
 interface KeverdConfig {
     apiKey: string;
-    endpoint?: string;
     userId?: string;
     debug?: boolean;
     extendedResult?: boolean;
@@ -90,7 +89,6 @@ interface KeverdConfig {
 }
 interface KeverdLoadOptions {
     apiKey: string;
-    endpoint?: string;
     debug?: boolean;
 }
 interface KeverdVisitorDataOptions {
@@ -135,6 +133,10 @@ declare class KeverdSDK {
      * Get visitor data (fingerprint and risk assessment)
      */
     getVisitorData(options?: KeverdVisitorDataOptions): Promise<KeverdVisitorData>;
+    /**
+     * Extract origin and referrer from browser
+     */
+    private getOriginHeaders;
     /**
      * Send fingerprint request to backend
      */
@@ -151,10 +153,44 @@ declare class KeverdSDK {
      * Generate a session ID
      */
     private generateSessionId;
+    /**
+     * Start a new session (called automatically on init, but can be called manually)
+     */
+    startSession(userId?: string, deviceHash?: string, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * End the current session
+     */
+    endSession(): Promise<void>;
+    /**
+     * Pause the current session (e.g., when app goes to background)
+     */
+    pauseSession(): Promise<void>;
+    /**
+     * Resume a paused session (e.g., when app comes to foreground)
+     */
+    resumeSession(): Promise<void>;
+    /**
+     * Get current session status
+     */
+    getSessionStatus(): Promise<{
+        session_id: string;
+        status: string;
+        is_active: boolean;
+        is_paused: boolean;
+        event_count: number;
+        started_at: string;
+        last_activity_at: string;
+        duration_seconds: number | null;
+    } | null>;
+    /**
+     * Helper methods for browser/OS detection
+     */
+    private _detectBrowser;
+    private _detectOS;
     /**
      * Destroy the SDK instance
      */
-    destroy(): void;
+    destroy(): Promise<void>;
     /**
      * Get current configuration
      */

package/dist/index.d.ts

@@ -82,7 +82,6 @@ interface KeverdVisitorData {
 }
 interface KeverdConfig {
     apiKey: string;
-    endpoint?: string;
     userId?: string;
     debug?: boolean;
     extendedResult?: boolean;
@@ -90,7 +89,6 @@ interface KeverdConfig {
 }
 interface KeverdLoadOptions {
     apiKey: string;
-    endpoint?: string;
     debug?: boolean;
 }
 interface KeverdVisitorDataOptions {
@@ -135,6 +133,10 @@ declare class KeverdSDK {
      * Get visitor data (fingerprint and risk assessment)
      */
     getVisitorData(options?: KeverdVisitorDataOptions): Promise<KeverdVisitorData>;
+    /**
+     * Extract origin and referrer from browser
+     */
+    private getOriginHeaders;
     /**
      * Send fingerprint request to backend
      */
@@ -151,10 +153,44 @@ declare class KeverdSDK {
      * Generate a session ID
      */
     private generateSessionId;
+    /**
+     * Start a new session (called automatically on init, but can be called manually)
+     */
+    startSession(userId?: string, deviceHash?: string, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * End the current session
+     */
+    endSession(): Promise<void>;
+    /**
+     * Pause the current session (e.g., when app goes to background)
+     */
+    pauseSession(): Promise<void>;
+    /**
+     * Resume a paused session (e.g., when app comes to foreground)
+     */
+    resumeSession(): Promise<void>;
+    /**
+     * Get current session status
+     */
+    getSessionStatus(): Promise<{
+        session_id: string;
+        status: string;
+        is_active: boolean;
+        is_paused: boolean;
+        event_count: number;
+        started_at: string;
+        last_activity_at: string;
+        duration_seconds: number | null;
+    } | null>;
+    /**
+     * Helper methods for browser/OS detection
+     */
+    private _detectBrowser;
+    private _detectOS;
     /**
      * Destroy the SDK instance
      */
-    destroy(): void;
+    destroy(): Promise<void>;
     /**
      * Get current configuration
      */

package/dist/index.js

@@ -657,7 +657,6 @@ var KeverdSDK = class {
       throw new Error("Keverd SDK: apiKey is required");
     }
     this.config = {
-      endpoint: config.endpoint || this.getDefaultEndpoint(),
       debug: false,
       ...config
     };
@@ -665,10 +664,10 @@ var KeverdSDK = class {
     this.sessionId = this.generateSessionId();
     this.isInitialized = true;
     if (this.config.debug) {
-      console.log("[Keverd SDK] Initialized successfully", {
-        endpoint: this.config.endpoint
-      });
+      console.log("[Keverd SDK] Initialized successfully");
     }
+    this.startSession().catch(() => {
+    });
   }
   /**
    * Get visitor data (fingerprint and risk assessment)
@@ -703,6 +702,17 @@ var KeverdSDK = class {
       throw keverdError;
     }
   }
+  /**
+   * Extract origin and referrer from browser
+   */
+  getOriginHeaders() {
+    if (typeof window === "undefined") {
+      return {};
+    }
+    const origin = window.location.origin || void 0;
+    const referrer = document.referrer || void 0;
+    return { origin, referrer };
+  }
   /**
    * Send fingerprint request to backend
    */
@@ -710,13 +720,19 @@ var KeverdSDK = class {
     if (!this.config) {
       throw new Error("SDK not initialized");
     }
-    const endpoint = this.config.endpoint || this.getDefaultEndpoint();
-    const url = `${endpoint}/fingerprint/score`;
+    const url = `${this.getDefaultEndpoint()}/fingerprint/score`;
     const headers = {
       "Content-Type": "application/json",
       "X-SDK-Source": "react"
       // Identify SDK source for backend analytics
     };
+    const { origin, referrer } = this.getOriginHeaders();
+    if (origin) {
+      headers["X-Origin-URL"] = origin;
+    }
+    if (referrer) {
+      headers["X-Referrer-URL"] = referrer;
+    }
     const apiKey = this.config.apiKey;
     if (apiKey) {
       headers["x-keverd-key"] = apiKey;
@@ -726,10 +742,17 @@ var KeverdSDK = class {
     if (options?.tag === "sandbox") {
       headers["X-Sandbox"] = "true";
     }
+    const requestBody = {
+      ...request,
+      session: {
+        ...request.session || {},
+        sessionId: this.sessionId || request.session?.sessionId
+      }
+    };
     const response = await fetch(url, {
       method: "POST",
       headers,
-      body: JSON.stringify(request)
+      body: JSON.stringify(requestBody)
     });
     if (!response.ok) {
       const errorText = await response.text().catch(() => "Unknown error");
@@ -775,10 +798,204 @@ var KeverdSDK = class {
   generateSessionId() {
     return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
   }
+  /**
+   * Start a new session (called automatically on init, but can be called manually)
+   */
+  async startSession(userId, deviceHash, metadata) {
+    if (!this.isInitialized || !this.config) {
+      throw new Error("Keverd SDK not initialized. Call init() first.");
+    }
+    if (!this.sessionId) {
+      this.sessionId = this.generateSessionId();
+    }
+    try {
+      const url = `${this.getDefaultEndpoint()}/dashboard/sessions/start`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      const deviceInfo = this.deviceCollector.collect();
+      await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          session_id: this.sessionId,
+          user_id: userId || this.config.userId,
+          device_hash: deviceHash || deviceInfo.fingerprint,
+          session_metadata: metadata || {},
+          user_agent: navigator.userAgent,
+          browser: this._detectBrowser(),
+          os: this._detectOS(),
+          platform: "web",
+          sdk_type: "web",
+          sdk_source: "react"
+        })
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session started: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to start session on server:", error);
+      }
+    }
+  }
+  /**
+   * End the current session
+   */
+  async endSession() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return;
+    }
+    try {
+      const url = `${this.getDefaultEndpoint()}/dashboard/sessions/${this.sessionId}/end`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session ended: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to end session on server:", error);
+      }
+    }
+  }
+  /**
+   * Pause the current session (e.g., when app goes to background)
+   */
+  async pauseSession() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return;
+    }
+    try {
+      const url = `${this.getDefaultEndpoint()}/dashboard/sessions/${this.sessionId}/pause`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session paused: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to pause session on server:", error);
+      }
+    }
+  }
+  /**
+   * Resume a paused session (e.g., when app comes to foreground)
+   */
+  async resumeSession() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return;
+    }
+    try {
+      const url = `${this.getDefaultEndpoint()}/dashboard/sessions/${this.sessionId}/resume`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session resumed: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to resume session on server:", error);
+      }
+    }
+  }
+  /**
+   * Get current session status
+   */
+  async getSessionStatus() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return null;
+    }
+    try {
+      const url = `${this.getDefaultEndpoint()}/dashboard/sessions/${this.sessionId}/status`;
+      const headers = {};
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      const response = await fetch(url, {
+        method: "GET",
+        headers
+      });
+      if (!response.ok) {
+        return null;
+      }
+      return await response.json();
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to get session status:", error);
+      }
+      return null;
+    }
+  }
+  /**
+   * Helper methods for browser/OS detection
+   */
+  _detectBrowser() {
+    const ua = navigator.userAgent;
+    if (ua.includes("Chrome") && !ua.includes("Edg")) return "Chrome";
+    if (ua.includes("Firefox")) return "Firefox";
+    if (ua.includes("Safari") && !ua.includes("Chrome")) return "Safari";
+    if (ua.includes("Edg")) return "Edge";
+    return "Unknown";
+  }
+  _detectOS() {
+    const ua = navigator.userAgent;
+    if (ua.includes("Windows")) return "Windows";
+    if (ua.includes("Mac")) return "macOS";
+    if (ua.includes("Linux")) return "Linux";
+    if (ua.includes("Android")) return "Android";
+    if (ua.includes("iOS") || ua.includes("iPhone") || ua.includes("iPad")) return "iOS";
+    return "Unknown";
+  }
   /**
    * Destroy the SDK instance
    */
-  destroy() {
+  async destroy() {
+    if (this.sessionId) {
+      await this.endSession();
+    }
     const wasDebug = this.config?.debug;
     this.behavioralCollector.stop();
     this.isInitialized = false;
@@ -810,14 +1027,14 @@ function KeverdProvider({ loadOptions, children }) {
     if (!sdk.isReady()) {
       sdk.init({
         apiKey: loadOptions.apiKey,
-        endpoint: loadOptions.endpoint,
         debug: loadOptions.debug || false
       });
       setIsReady(true);
     }
     return () => {
       if (sdk.isReady()) {
-        sdk.destroy();
+        sdk.destroy().catch(() => {
+        });
         setIsReady(false);
       }
     };