cgs-compliance-sdk 2.0.0

package/dist/geolocation/index.mjs

@@ -0,0 +1,777 @@
+import { useState, useCallback, useEffect, useRef } from 'react';
+
+// src/geolocation/client.ts
+var GeolocationClient = class {
+  constructor(config) {
+    this.config = {
+      baseURL: config.baseURL,
+      tenantId: config.tenantId,
+      apiKey: config.apiKey || "",
+      headers: config.headers || {},
+      timeout: config.timeout || 1e4,
+      debug: config.debug || false
+    };
+  }
+  // ============================================================================
+  // Private Helper Methods
+  // ============================================================================
+  async request(endpoint, options = {}) {
+    const url = `${this.config.baseURL}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Tenant-ID": this.config.tenantId,
+      ...this.config.headers,
+      ...options.headers || {}
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      if (this.config.debug) {
+        console.log(`[GeolocationSDK] ${options.method || "GET"} ${url}`, {
+          headers,
+          body: options.body
+        });
+      }
+      const response = await fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok) {
+        throw new Error(data.error || data.message || `HTTP ${response.status}`);
+      }
+      if (this.config.debug) {
+        console.log(`[GeolocationSDK] Response:`, data);
+      }
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new Error(`Request timeout after ${this.config.timeout}ms`);
+        }
+        throw error;
+      }
+      throw new Error("Unknown error occurred");
+    }
+  }
+  buildQueryString(params) {
+    const query = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        query.append(key, String(value));
+      }
+    });
+    const queryString = query.toString();
+    return queryString ? `?${queryString}` : "";
+  }
+  // ============================================================================
+  // IP Verification & Compliance
+  // ============================================================================
+  /**
+   * Verify an IP address and check compliance
+   *
+   * @param request - Verification request with IP, user ID, event type, and optional device fingerprint
+   * @returns Location verification result with risk assessment
+   *
+   * @example
+   * ```typescript
+   * const result = await client.verifyIP({
+   *   ip_address: "8.8.8.8",
+   *   user_id: "user_123",
+   *   event_type: "login",
+   *   device_fingerprint: {
+   *     device_id: "device_abc",
+   *     user_agent: navigator.userAgent,
+   *     platform: "web"
+   *   }
+   * });
+   *
+   * if (result.is_blocked) {
+   *   console.log("Access blocked:", result.risk_reasons);
+   * }
+   * ```
+   */
+  async verifyIP(request) {
+    return this.request("/api/v1/geo/verify", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Check compliance for a specific country
+   *
+   * @param countryISO - ISO 3166-1 alpha-2 country code (e.g., "US", "GB")
+   * @returns Jurisdiction configuration and compliance status
+   *
+   * @example
+   * ```typescript
+   * const compliance = await client.checkCompliance("KP"); // North Korea
+   * if (!compliance.is_compliant) {
+   *   console.log("Country is not allowed:", compliance.jurisdiction?.status);
+   * }
+   * ```
+   */
+  async checkCompliance(countryISO) {
+    return this.request(
+      `/api/v1/geo/compliance?country_iso=${countryISO}`
+    );
+  }
+  /**
+   * Get location history for a user
+   *
+   * @param userId - User ID to retrieve history for
+   * @param limit - Maximum number of records to return (default: 100)
+   * @returns Array of geolocation records
+   */
+  async getUserLocationHistory(userId, limit = 100) {
+    return this.request(
+      `/api/v1/geo/history?user_id=${userId}&limit=${limit}`
+    );
+  }
+  // ============================================================================
+  // Alert Management
+  // ============================================================================
+  /**
+   * Get a specific alert by ID
+   *
+   * @param alertId - Alert ID
+   * @returns Alert details
+   */
+  async getAlert(alertId) {
+    return this.request(`/api/v1/alerts/${alertId}`);
+  }
+  /**
+   * List alerts with filters and pagination
+   *
+   * @param filters - Optional filters (status, severity, type, user, dates)
+   * @param pagination - Optional pagination (page, page_size)
+   * @returns Paginated list of alerts
+   *
+   * @example
+   * ```typescript
+   * const alerts = await client.listAlerts(
+   *   { status: "active", severity: "critical" },
+   *   { page: 1, page_size: 20 }
+   * );
+   * console.log(`Found ${alerts.total} critical alerts`);
+   * ```
+   */
+  async listAlerts(filters, pagination) {
+    const params = {
+      ...filters,
+      ...pagination
+    };
+    return this.request(`/api/v1/alerts${this.buildQueryString(params)}`);
+  }
+  /**
+   * Update alert status
+   *
+   * @param alertId - Alert ID
+   * @param status - New status
+   */
+  async updateAlertStatus(alertId, status) {
+    await this.request(`/api/v1/alerts/${alertId}/status`, {
+      method: "PUT",
+      body: JSON.stringify({ status })
+    });
+  }
+  /**
+   * Assign an alert to an analyst
+   *
+   * @param alertId - Alert ID
+   * @param assignedTo - User ID to assign to
+   */
+  async assignAlert(alertId, assignedTo) {
+    await this.request(`/api/v1/alerts/${alertId}/assign`, {
+      method: "POST",
+      body: JSON.stringify({ assigned_to: assignedTo })
+    });
+  }
+  /**
+   * Resolve an alert
+   *
+   * @param alertId - Alert ID
+   * @param resolution - Resolution type
+   * @param notes - Optional notes
+   */
+  async resolveAlert(alertId, resolution, notes) {
+    await this.request(`/api/v1/alerts/${alertId}/resolve`, {
+      method: "POST",
+      body: JSON.stringify({ resolution, notes })
+    });
+  }
+  /**
+   * Dismiss an alert as false positive
+   *
+   * @param alertId - Alert ID
+   * @param notes - Optional notes explaining why it's a false positive
+   */
+  async dismissAlert(alertId, notes) {
+    await this.request(`/api/v1/alerts/${alertId}/dismiss`, {
+      method: "POST",
+      body: JSON.stringify({ notes })
+    });
+  }
+  /**
+   * Escalate an alert to higher severity or different assignee
+   *
+   * @param alertId - Alert ID
+   * @param assignedTo - New assignee user ID
+   * @param severity - New severity level
+   * @param notes - Escalation notes
+   */
+  async escalateAlert(alertId, assignedTo, severity, notes) {
+    await this.request(`/api/v1/alerts/${alertId}/escalate`, {
+      method: "POST",
+      body: JSON.stringify({ assigned_to: assignedTo, severity, notes })
+    });
+  }
+  /**
+   * Block an alert (mark as blocked)
+   *
+   * @param alertId - Alert ID
+   * @param notes - Optional notes
+   */
+  async blockAlert(alertId, notes) {
+    await this.request(`/api/v1/alerts/${alertId}/block`, {
+      method: "POST",
+      body: JSON.stringify({ notes })
+    });
+  }
+  /**
+   * Get dashboard metrics
+   *
+   * @param timeRangeHours - Time range in hours (default: 24)
+   * @returns Dashboard metrics and statistics
+   *
+   * @example
+   * ```typescript
+   * const metrics = await client.getDashboardMetrics(168); // Last 7 days
+   * console.log(`${metrics.critical_alerts} critical alerts in last week`);
+   * ```
+   */
+  async getDashboardMetrics(timeRangeHours = 24) {
+    return this.request(
+      `/api/v1/alerts/metrics?time_range_hours=${timeRangeHours}`
+    );
+  }
+  // ============================================================================
+  // Jurisdiction Configuration
+  // ============================================================================
+  /**
+   * List all jurisdiction configurations
+   *
+   * @returns Array of jurisdiction configurations
+   */
+  async listJurisdictions() {
+    return this.request("/api/v1/jurisdictions");
+  }
+  /**
+   * Get a jurisdiction configuration by ID
+   *
+   * @param jurisdictionId - Jurisdiction ID
+   * @returns Jurisdiction configuration
+   */
+  async getJurisdiction(jurisdictionId) {
+    return this.request(`/api/v1/jurisdictions/${jurisdictionId}`);
+  }
+  /**
+   * Create a new jurisdiction configuration
+   *
+   * @param request - Jurisdiction configuration data
+   * @returns Created jurisdiction
+   *
+   * @example
+   * ```typescript
+   * const jurisdiction = await client.createJurisdiction({
+   *   country_iso: "US",
+   *   country_name: "United States",
+   *   status: "allowed",
+   *   risk_level: "low",
+   *   allow_login: true,
+   *   allow_registration: true,
+   *   allow_transactions: true,
+   *   require_kyc: false,
+   *   require_enhanced_verification: false
+   * });
+   * ```
+   */
+  async createJurisdiction(request) {
+    return this.request("/api/v1/jurisdictions", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Update a jurisdiction configuration
+   *
+   * @param jurisdictionId - Jurisdiction ID
+   * @param request - Updated fields
+   * @returns Updated jurisdiction
+   */
+  async updateJurisdiction(jurisdictionId, request) {
+    return this.request(`/api/v1/jurisdictions/${jurisdictionId}`, {
+      method: "PUT",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Delete a jurisdiction configuration
+   *
+   * @param jurisdictionId - Jurisdiction ID
+   */
+  async deleteJurisdiction(jurisdictionId) {
+    await this.request(`/api/v1/jurisdictions/${jurisdictionId}`, {
+      method: "DELETE"
+    });
+  }
+  // ============================================================================
+  // Geofence Rules
+  // ============================================================================
+  /**
+   * List all geofence rules
+   *
+   * @returns Array of geofence rules
+   */
+  async listGeofenceRules() {
+    return this.request("/api/v1/geofence-rules");
+  }
+  /**
+   * Get a geofence rule by ID
+   *
+   * @param ruleId - Geofence rule ID
+   * @returns Geofence rule
+   */
+  async getGeofenceRule(ruleId) {
+    return this.request(`/api/v1/geofence-rules/${ruleId}`);
+  }
+  /**
+   * Create a new geofence rule
+   *
+   * @param request - Geofence rule data
+   * @returns Created geofence rule
+   *
+   * @example
+   * ```typescript
+   * const rule = await client.createGeofenceRule({
+   *   name: "Block High Risk Countries",
+   *   rule_type: "block_list",
+   *   action: "block",
+   *   countries: ["KP", "IR", "SY"],
+   *   event_types: ["login", "transaction"],
+   *   priority: 100
+   * });
+   * ```
+   */
+  async createGeofenceRule(request) {
+    return this.request("/api/v1/geofence-rules", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Update a geofence rule
+   *
+   * @param ruleId - Geofence rule ID
+   * @param request - Updated fields
+   * @returns Updated geofence rule
+   */
+  async updateGeofenceRule(ruleId, request) {
+    return this.request(`/api/v1/geofence-rules/${ruleId}`, {
+      method: "PUT",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Delete a geofence rule
+   *
+   * @param ruleId - Geofence rule ID
+   */
+  async deleteGeofenceRule(ruleId) {
+    await this.request(`/api/v1/geofence-rules/${ruleId}`, {
+      method: "DELETE"
+    });
+  }
+  // ============================================================================
+  // Device Fingerprinting
+  // ============================================================================
+  /**
+   * Get all devices for a user
+   *
+   * @param userId - User ID
+   * @returns Array of device fingerprints
+   */
+  async getUserDevices(userId) {
+    return this.request(`/api/v1/devices/user/?user_id=${userId}`);
+  }
+  /**
+   * Get a specific device by device ID
+   *
+   * @param deviceId - Device ID
+   * @returns Device fingerprint
+   */
+  async getDevice(deviceId) {
+    return this.request(`/api/v1/devices/?device_id=${deviceId}`);
+  }
+  /**
+   * Update device trust status
+   *
+   * @param deviceId - Device ID
+   * @param action - "trust" or "untrust"
+   *
+   * @example
+   * ```typescript
+   * // Mark a device as trusted
+   * await client.updateDeviceTrust("device_abc", "trust");
+   *
+   * // Mark a device as untrusted
+   * await client.updateDeviceTrust("device_xyz", "untrust");
+   * ```
+   */
+  async updateDeviceTrust(deviceId, action) {
+    await this.request(`/api/v1/devices/?device_id=${deviceId}&action=${action}`, {
+      method: "POST"
+    });
+  }
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  /**
+   * Check service health
+   *
+   * @returns Health status object
+   */
+  async healthCheck() {
+    return this.request("/api/v1/health");
+  }
+  /**
+   * Update client configuration
+   *
+   * @param config - Partial configuration to update
+   */
+  updateConfig(config) {
+    this.config = {
+      ...this.config,
+      ...config,
+      headers: {
+        ...this.config.headers,
+        ...config.headers || {}
+      }
+    };
+  }
+  /**
+   * Get current configuration (readonly)
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+function useGeolocation(client, options = {}) {
+  const [verification, setVerification] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const verifyIP = useCallback(
+    async (request) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await client.verifyIP(request);
+        setVerification(result);
+        return result;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Verification failed");
+        setError(error2);
+        throw error2;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [client]
+  );
+  const checkCompliance = useCallback(
+    async (countryISO) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await client.checkCompliance(countryISO);
+        return result;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Compliance check failed");
+        setError(error2);
+        throw error2;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [client]
+  );
+  const refresh = useCallback(async () => {
+    if (verification) {
+      await verifyIP({
+        ip_address: verification.ip_address,
+        user_id: "",
+        // Will need to be provided
+        event_type: options.eventType || "api_access"
+      });
+    }
+  }, [verification, verifyIP, options.eventType]);
+  useEffect(() => {
+    if (options.autoVerify) {
+      const detectAndVerify = async () => {
+        try {
+          const ipResponse = await fetch("https://api.ipify.org?format=json");
+          const { ip } = await ipResponse.json();
+          let deviceFingerprint;
+          if (options.includeDeviceFingerprint && typeof window !== "undefined") {
+            deviceFingerprint = {
+              device_id: localStorage.getItem("device_id") || generateDeviceId(),
+              user_agent: navigator.userAgent,
+              platform: navigator.platform,
+              language: navigator.language,
+              timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+              screen_resolution: `${window.screen.width}x${window.screen.height}`
+            };
+            if (!localStorage.getItem("device_id")) {
+              localStorage.setItem("device_id", deviceFingerprint.device_id);
+            }
+          }
+          await verifyIP({
+            ip_address: ip,
+            user_id: "",
+            // Should be provided by auth context
+            event_type: options.eventType || "page_view",
+            device_fingerprint: deviceFingerprint
+          });
+        } catch (err) {
+          console.error("Auto-verification failed:", err);
+        }
+      };
+      detectAndVerify();
+    }
+  }, [options.autoVerify, options.includeDeviceFingerprint, options.eventType, verifyIP]);
+  return {
+    verification,
+    loading,
+    error,
+    verifyIP,
+    checkCompliance,
+    refresh
+  };
+}
+function useAlerts(client, options = {}) {
+  const [alerts, setAlerts] = useState([]);
+  const [total, setTotal] = useState(0);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const pollIntervalRef = useRef();
+  const fetchAlerts = useCallback(
+    async (filters, pagination) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await client.listAlerts(
+          filters || options.filters,
+          pagination || options.pagination
+        );
+        setAlerts(result.alerts);
+        setTotal(result.total);
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Failed to fetch alerts");
+        setError(error2);
+        throw error2;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [client, options.filters, options.pagination]
+  );
+  const updateStatus = useCallback(
+    async (alertId, status) => {
+      try {
+        await client.updateAlertStatus(alertId, status);
+        setAlerts(
+          (prev) => prev.map(
+            (alert) => alert.id === alertId ? { ...alert, status } : alert
+          )
+        );
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Failed to update status");
+        setError(error2);
+        throw error2;
+      }
+    },
+    [client]
+  );
+  const assignAlert = useCallback(
+    async (alertId, assignedTo) => {
+      try {
+        await client.assignAlert(alertId, assignedTo);
+        setAlerts(
+          (prev) => prev.map(
+            (alert) => alert.id === alertId ? { ...alert, assigned_to: assignedTo, status: "under_review" } : alert
+          )
+        );
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Failed to assign alert");
+        setError(error2);
+        throw error2;
+      }
+    },
+    [client]
+  );
+  const resolveAlert = useCallback(
+    async (alertId, resolution, notes) => {
+      try {
+        await client.resolveAlert(alertId, resolution, notes);
+        setAlerts(
+          (prev) => prev.map(
+            (alert) => alert.id === alertId ? { ...alert, status: "resolved", resolution, notes } : alert
+          )
+        );
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Failed to resolve alert");
+        setError(error2);
+        throw error2;
+      }
+    },
+    [client]
+  );
+  const dismissAlert = useCallback(
+    async (alertId, notes) => {
+      try {
+        await client.dismissAlert(alertId, notes);
+        setAlerts(
+          (prev) => prev.map(
+            (alert) => alert.id === alertId ? { ...alert, status: "false_positive", resolution: "false_positive", notes } : alert
+          )
+        );
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Failed to dismiss alert");
+        setError(error2);
+        throw error2;
+      }
+    },
+    [client]
+  );
+  const refresh = useCallback(async () => {
+    await fetchAlerts();
+  }, [fetchAlerts]);
+  useEffect(() => {
+    if (options.autoFetch) {
+      fetchAlerts();
+    }
+  }, [options.autoFetch, fetchAlerts]);
+  useEffect(() => {
+    if (options.pollInterval && options.pollInterval > 0) {
+      pollIntervalRef.current = setInterval(() => {
+        fetchAlerts();
+      }, options.pollInterval);
+      return () => {
+        if (pollIntervalRef.current) {
+          clearInterval(pollIntervalRef.current);
+        }
+      };
+    }
+  }, [options.pollInterval, fetchAlerts]);
+  return {
+    alerts,
+    total,
+    loading,
+    error,
+    fetchAlerts,
+    updateStatus,
+    assignAlert,
+    resolveAlert,
+    dismissAlert,
+    refresh
+  };
+}
+function useDashboardMetrics(client, timeRangeHours = 24, autoFetch = true) {
+  const [metrics, setMetrics] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetchMetrics = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.getDashboardMetrics(timeRangeHours);
+      setMetrics(result);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to fetch metrics");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client, timeRangeHours]);
+  useEffect(() => {
+    if (autoFetch) {
+      fetchMetrics();
+    }
+  }, [autoFetch, fetchMetrics]);
+  return {
+    metrics,
+    loading,
+    error,
+    refresh: fetchMetrics
+  };
+}
+function generateDeviceId() {
+  return `device_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+}
+function getBrowserInfo() {
+  if (typeof window === "undefined") return {};
+  const userAgent = navigator.userAgent;
+  let browser;
+  let browserVersion;
+  let os;
+  if (userAgent.indexOf("Firefox") > -1) {
+    browser = "Firefox";
+    browserVersion = userAgent.match(/Firefox\/([0-9.]+)/)?.[1];
+  } else if (userAgent.indexOf("Chrome") > -1) {
+    browser = "Chrome";
+    browserVersion = userAgent.match(/Chrome\/([0-9.]+)/)?.[1];
+  } else if (userAgent.indexOf("Safari") > -1) {
+    browser = "Safari";
+    browserVersion = userAgent.match(/Version\/([0-9.]+)/)?.[1];
+  } else if (userAgent.indexOf("Edge") > -1) {
+    browser = "Edge";
+    browserVersion = userAgent.match(/Edge\/([0-9.]+)/)?.[1];
+  }
+  if (userAgent.indexOf("Win") > -1) os = "Windows";
+  else if (userAgent.indexOf("Mac") > -1) os = "macOS";
+  else if (userAgent.indexOf("Linux") > -1) os = "Linux";
+  else if (userAgent.indexOf("Android") > -1) os = "Android";
+  else if (userAgent.indexOf("iOS") > -1) os = "iOS";
+  return {
+    browser,
+    browser_version: browserVersion,
+    os
+  };
+}
+function createDeviceFingerprint() {
+  const browserInfo = getBrowserInfo();
+  const deviceId = localStorage.getItem("device_id") || generateDeviceId();
+  if (!localStorage.getItem("device_id")) {
+    localStorage.setItem("device_id", deviceId);
+  }
+  return {
+    device_id: deviceId,
+    user_agent: navigator.userAgent,
+    platform: navigator.platform,
+    language: navigator.language,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    screen_resolution: `${window.screen.width}x${window.screen.height}`,
+    ...browserInfo
+  };
+}
+
+export { GeolocationClient, createDeviceFingerprint, getBrowserInfo, useAlerts, useDashboardMetrics, useGeolocation };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map