@sanctum-key/react-native-sdk 1.0.0

package/src/modules/api/TemplateService.ts

@@ -0,0 +1,168 @@
+import axios from 'axios';
+import { BackendKYCTemplate, TemplateAPIResponse } from '../../types/KYC.types';
+import { logger } from '../../utils/logger';
+import { errorMessage } from './KYCService';
+import KYCConfig from '../../config/KYCConfig';
+
+export class TemplateServiceClass {
+  private cache: Map<string, { template: BackendKYCTemplate; timestamp: number }> = new Map();
+  private cacheTimeout = 5 * 60 * 1000; // 5 minutes
+
+  /**
+   * Get headers for API requests
+   */
+  private getHeaders(apiKey?: string, token?: string) {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+
+    if (apiKey) {
+      headers['Authorization'] = `ApiKey ${apiKey}`;
+    } else if (token) {
+      headers['Authorization'] = `Bearer ${token}`;
+    }
+
+    return headers;
+  }
+
+  /**
+   * Fetch a template from the backend API
+   * @param templateId - The ID of the template to fetch
+   * @param apiKey - Optional API key for authentication
+   * @param token - Optional Bearer token for authentication
+   * @param useCache - Whether to use cached version if available (default: true)
+   * @returns The backend template
+   */
+  async fetchTemplate(
+    templateId: string,
+    apiKey?: string,
+    token?: string,
+    useCache: boolean = true
+  ): Promise<BackendKYCTemplate> {
+    // Check cache first
+    if (useCache) {
+      const cached = this.cache.get(templateId);
+      if (cached) {
+        const age = Date.now() - cached.timestamp;
+        if (age < this.cacheTimeout) {
+          logger.log(`Template ${templateId} loaded from cache`);
+          return cached.template;
+        } else {
+          // Cache expired, remove it
+          this.cache.delete(templateId);
+        }
+      }
+    }
+
+    try {
+      const url = `${KYCConfig.getBackendUrl()}/templates/kyc/template/${templateId}/`;
+      logger.log(templateId)
+      logger.log(`Fetching template from: ${url} with apiKey: ${apiKey} and token: ${token}`, {
+        headers: this.getHeaders(apiKey, token)
+      });
+
+      const response = await axios.get<TemplateAPIResponse>(url, {
+        headers: this.getHeaders(apiKey, token),
+        timeout: 30000, // 30 seconds timeout
+      });
+
+      const template: BackendKYCTemplate = response.data;
+
+      // Validate template structure
+      if (!template.id || !template.name || !Array.isArray(template.components)) {
+        throw new Error('Invalid template structure received from API');
+      }
+
+      // Store in cache
+      this.cache.set(templateId, {
+        template,
+        timestamp: Date.now(),
+      });
+
+      logger.log(`Template ${templateId} fetched successfully`);
+      return template;
+    } catch (error: any) {
+      logger.error(`Error fetching template ${templateId}:`, JSON.stringify(errorMessage(error), null, 2));
+
+      // Extract backend error message if available
+      const backendMessage = errorMessage(error);
+
+      if (error.response?.status === 404) {
+        throw new Error(`Template not found: ${templateId}`);
+      }
+
+      if (error.response?.status === 401 || error.response?.status === 403) {
+        throw new Error(`Unauthorized: Invalid API key or token`);
+      }
+
+      if (backendMessage) {
+        throw new Error(`Failed to fetch template: ${JSON.stringify(backendMessage)}`);
+      }
+
+      throw new Error(`Failed to fetch template: ${error.message || 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Clear the template cache
+   * @param templateId - Optional template ID to clear. If not provided, clears all cache.
+   */
+  clearCache(templateId?: string): void {
+    if (templateId) {
+      this.cache.delete(templateId);
+      logger.log(`Cache cleared for template: ${templateId}`);
+    } else {
+      this.cache.clear();
+      logger.log('All template cache cleared');
+    }
+  }
+
+  /**
+   * Get cached template if available
+   * @param templateId - The template ID
+   * @returns The cached template or null if not found/expired
+   */
+  getCachedTemplate(templateId: string): BackendKYCTemplate | null {
+    const cached = this.cache.get(templateId);
+    if (cached) {
+      const age = Date.now() - cached.timestamp;
+      if (age < this.cacheTimeout) {
+        return cached.template;
+      } else {
+        this.cache.delete(templateId);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Fetch list of available templates (optional feature)
+   * @param apiKey - Optional API key for authentication
+   * @param token - Optional Bearer token for authentication
+   * @returns Array of template metadata
+   */
+  async fetchTemplateList(apiKey?: string, token?: string): Promise<Array<{ id: string; name: Record<string, string>; version?: string; status?: string }>> {
+    try {
+      const url = `${KYCConfig.getBackendUrl()}/templates/kyc/templates`;
+      logger.log(`Fetching template list from: ${url}`);
+
+      const response = await axios.get<Array<{ id: string; name: Record<string, string>; version?: string; status?: string }>>(url, {
+        headers: this.getHeaders(apiKey, token),
+        timeout: 30000,
+      });
+
+      logger.log(`Fetched ${response.data.length} templates`);
+      return response.data;
+    } catch (error: any) {
+      logger.error('Error fetching template list:', JSON.stringify(errorMessage(error), null, 2));
+      throw new Error(`Failed to fetch template list: ${error.message || 'Unknown error'}`);
+    }
+  }
+}
+
+// Export singleton instance as default
+const templateService = new TemplateServiceClass();
+export default templateService;
+
+// Also export the class for advanced usage
+// export { TemplateServiceClass };

package/src/modules/api/backendApi.ts

@@ -0,0 +1,8 @@
+// import kycService from "./KYCService"
+
+
+
+// const initializesession = (token: string) => {
+
+//     // const session = await kycService.post("/session", {
+// }

package/src/modules/api/types.ts

@@ -0,0 +1,59 @@
+export interface SessionResponse {
+    id: number;
+    session_id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    metadata: string;
+    user: number;
+    module: number;
+}
+
+
+export interface VerificationSessionRequest {
+    step: number;
+    data: VerificationSessionData;
+    templateId: string | null;
+    session_id: string;
+    token: string;
+    action: string
+    apiKey?: string;
+}
+
+
+// dynamic type
+export type VerificationSessionData = Record<string, any>;
+
+
+export interface VerificationResult {
+    [key: string]: {
+        data: {
+            verification_id: string;
+            verification_status: string;
+            completion_timestamp: string;
+            user_data: {
+                personal_information: {
+                    full_name: string;
+                    first_name: string | null;
+                    given_name: string | null;
+                    last_name: string | null;
+                    date_of_birth: string;
+                    sex: string;
+                    expiry_date: string ;
+                    issue_date: string;
+                    issue_place: string | null;
+                    place_of_birth: string | null;
+                    address: string | null;
+                    city: string | null;
+                    postal_code: string | null;
+                    country: string | null;
+                };
+            };
+            selfie_info: {
+                is_match: boolean;
+                similarity: number;
+                image: string;
+            };
+        };
+    };
+}

package/src/modules/camera/NativeCameraModule.ts

@@ -0,0 +1,170 @@
+import { NativeEventEmitter, Platform } from "react-native";
+import TransfergratisSdkModule from "../../TransfergratisSdkModule";
+
+
+export interface CameraCaptureResult {
+  success: boolean;
+  path?: string;
+  error?: string;
+}
+
+export interface FilePickerResult {
+  success: boolean;
+  uri?: string;
+  path?: string;
+  error?: string;
+}
+
+export class NativeCameraModule {
+  private eventEmitter: NativeEventEmitter | null = null;
+
+  /**
+   * Test simple du module natif
+   */
+  async testModule(): Promise<string> {
+    try {
+      if (!TransfergratisSdkModule) {
+        console.warn('TransfergratisSdk native module not available');
+        return 'Module not available';
+      }
+      return await TransfergratisSdkModule.testModule();
+    } catch (error) {
+      console.error('Error testing module:', error);
+      return 'Test failed';
+    }
+  }
+
+  constructor() {
+    console.log('NativeCameraModule constructor called');
+    console.log('Platform:', Platform.OS);
+    
+    // Vérifier que le module natif est disponible
+    if (TransfergratisSdkModule) {
+      console.log('TransfergratisSdk module found, creating event emitter');
+      try {
+        // this.eventEmitter = new NativeEventEmitter(TransfergratisSdkModule as unknown as NativeModule);
+        console.log('Event emitter created successfully');
+      } catch (error) {
+        console.error('Error creating event emitter:', error);
+        this.eventEmitter = null;
+      }
+    } else {
+      console.warn('TransfergratisSdk native module not available');
+    }
+  }
+
+  /**
+   * Demande les permissions de caméra
+   */
+  async requestCameraPermission(): Promise<boolean> {
+    console.log('requestCameraPermission');
+    
+    try {
+      if (!TransfergratisSdkModule) {
+        console.warn('TransfergratisSdk native module not available');
+        return false;
+      }
+      return await TransfergratisSdkModule.requestCameraPermission();
+    } catch (error) {
+      console.error('Error requesting camera permission:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Ouvre la caméra avec des instructions personnalisées
+   */
+  async openCameraWithInstructions(instructions: string): Promise<CameraCaptureResult> {
+    try {
+      if (!TransfergratisSdkModule) {
+        console.warn('TransfergratisSdk native module not available');
+        return {
+          success: false,
+          error: 'Native module not available'
+        };
+      }
+
+      const hasPermission = await this.requestCameraPermission();
+      if (!hasPermission) {
+        return {
+          success: false,
+          error: 'Camera permission not granted'
+        };
+      }
+
+      const result = await TransfergratisSdkModule.openCameraWithInstructions(instructions);
+      return {
+        success: result.success,
+        path: result.path
+      };
+    } catch (error) {
+      console.error('Error opening camera:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  /**
+   * Ouvre le sélecteur de fichiers
+   */
+  async openFilePicker(allowedTypes: string[] = ['*/*']): Promise<FilePickerResult> {
+    try {
+      if (!TransfergratisSdkModule) {
+        console.warn('TransfergratisSdk native module not available');
+        return {
+          success: false,
+          error: 'Native module not available'
+        };
+      }
+      const result = await TransfergratisSdkModule.openFilePicker(allowedTypes);
+      return {
+        success: result.success,
+        uri: result.uri,
+        path: result.path
+      };
+    } catch (error) {
+      console.error('Error opening file picker:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  /**
+   * Écoute les événements de la caméra
+   */
+  onCameraCapture(callback: (event: any) => void) {
+    if (!this.eventEmitter) {
+      console.warn('EventEmitter not available');
+      return { remove: () => {} };
+    }
+    return this.eventEmitter.addListener('onCameraCapture', callback);
+  }
+
+  /**
+   * Écoute les événements de sélection de fichiers
+   */
+  onFileSelected(callback: (event: any) => void) {
+    if (!this.eventEmitter) {
+      console.warn('EventEmitter not available');
+      return { remove: () => {} };
+    }
+    return this.eventEmitter.addListener('onFileSelected', callback);
+  }
+
+  /**
+   * Écoute les erreurs
+   */
+  onError(callback: (event: any) => void) {
+    if (!this.eventEmitter) {
+      console.warn('EventEmitter not available');
+      return { remove: () => {} };
+    }
+    return this.eventEmitter.addListener('onError', callback);
+  }
+}
+
+export default new NativeCameraModule(); 

package/src/modules/camera/UnifiedCameraModule.ts

@@ -0,0 +1,160 @@
+import { Platform } from "react-native";
+import NativeCameraModule from "./NativeCameraModule";
+import VisionCameraModule from "./VisionCameraModule";
+
+export interface CameraCaptureResult {
+  success: boolean;
+  path?: string;
+  error?: string;
+}
+
+export interface FilePickerResult {
+  success: boolean;
+  uri?: string;
+  path?: string;
+  error?: string;
+}
+
+// Define a shared interface for the methods UnifiedCameraModule relies on
+interface CameraModuleApi {
+  testModule?: () => Promise<string>;
+  requestCameraPermission: () => Promise<boolean>;
+  openCameraWithInstructions: (instructions: string) => Promise<CameraCaptureResult>;
+  openFilePicker: (allowedTypes?: string[]) => Promise<FilePickerResult>;
+  onCameraCapture?: (callback: (event: any) => void) => { remove: () => void } | void;
+  onFileSelected?: (callback: (event: any) => void) => { remove: () => void } | void;
+  onError?: (callback: (event: any) => void) => { remove: () => void } | void;
+  destroy?: () => void;
+}
+
+export class UnifiedCameraModule {
+  private nativeModule: CameraModuleApi;
+  private webModule: CameraModuleApi;
+  private isWeb: boolean;
+
+  constructor() {
+    this.isWeb = Platform.OS === 'web';
+    // Cast to the shared interface which contains the subset of methods we use
+    this.nativeModule = NativeCameraModule as unknown as CameraModuleApi;
+    this.webModule = VisionCameraModule as unknown as CameraModuleApi;
+    
+    console.log('UnifiedCameraModule initialized for:', Platform.OS);
+  }
+
+  /**
+   * Retourne le module approprié selon la plateforme
+   */
+  private getModule(): CameraModuleApi {
+    return this.isWeb ? this.webModule : this.nativeModule;
+  }
+
+  /**
+   * Test simple du module
+   */
+  async testModule(): Promise<string> {
+    try {
+      const module = this.getModule();
+      if (module.testModule) {
+        return await module.testModule();
+      }
+      return 'No test available';
+    } catch (error) {
+      console.error('Error testing module:', error);
+      return 'Test failed';
+    }
+  }
+
+  /**
+   * Demande les permissions de caméra
+   */
+  async requestCameraPermission(): Promise<boolean> {
+    try {
+      const module = this.getModule();
+      return await module.requestCameraPermission();
+    } catch (error) {
+      console.error('Error requesting camera permission:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Ouvre la caméra avec des instructions personnalisées
+   */
+  async openCameraWithInstructions(instructions: string): Promise<CameraCaptureResult> {
+    try {
+      const module = this.getModule();
+      return await module.openCameraWithInstructions(instructions);
+    } catch (error) {
+      console.error('Error opening camera:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  /**
+   * Ouvre le sélecteur de fichiers
+   */
+  async openFilePicker(allowedTypes: string[] = ['*/*']): Promise<FilePickerResult> {
+    try {
+      const module = this.getModule();
+      return await module.openFilePicker(allowedTypes);
+    } catch (error) {
+      console.error('Error opening file picker:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  /**
+   * Écoute les événements de la caméra
+   */
+  onCameraCapture(callback: (event: any) => void) {
+    const module = this.getModule();
+    return module?.onCameraCapture?.(callback);
+  }
+
+  /**
+   * Écoute les événements de sélection de fichiers
+   */
+  onFileSelected(callback: (event: any) => void) {
+    const module = this.getModule();
+    return module.onFileSelected?.(callback);
+  }
+
+  /**
+   * Écoute les erreurs
+   */
+  onError(callback: (event: any) => void) {
+    const module = this.getModule();
+    return module.onError?.(callback);
+  }
+
+  /**
+   * Nettoyage des ressources (spécifique au web)
+   */
+  destroy() {
+    if (this.isWeb) {
+      this.webModule.destroy?.();
+    }
+  }
+
+  /**
+   * Vérifie si on est sur le web
+   */
+  isWebPlatform(): boolean {
+    return this.isWeb;
+  }
+
+  /**
+   * Vérifie si on est sur mobile natif
+   */
+  isNativePlatform(): boolean {
+    return !this.isWeb;
+  }
+}
+
+export default new UnifiedCameraModule();