sprintcheck-expo/src/SprintCheckExpo.ts

SprintCheck SDK for Expo - Identity verification (BVN, NIN, Facial) for React Native Expo projects

import { NativeModules, Platform } from 'react-native';

// Type definitions for SprintCheck SDK
export interface SprintCheckConfig {
  apiKey: string;
  encryptionKey: string;
}

export interface VerificationResult {
  success: boolean;
  message: string;
  data?: any;
  error?: string;
}

// Get the native module exported from Android
const LINKING_ERROR =
  `The package 'SprintCheck' doesn't seem to be linked.\n` +
  'Make sure:\n' +
  '- You have run "expo prebuild" to generate native code\n' +
  '- You have added the SprintCheck plugin to your app.json/app.config.js\n' +
  '- You have rebuilt the app (expo run:android)\n' +
  '- For Expo managed workflow, you need to use "expo prebuild" and then "expo run:android"';

const SprintCheckNative = NativeModules.SprintCheck
  ? NativeModules.SprintCheck
  : new Proxy({}, {
      get() {
        throw new Error(LINKING_ERROR);
      },
    });

/**
 * SprintCheck SDK for Expo
 * Provides identity verification services including BVN, NIN, and Facial verification
 */
class SprintCheckExpo {
  private static instance: SprintCheckExpo;
  private isInitialized: boolean = false;

  private constructor() {}

  /**
   * Get singleton instance of SprintCheckExpo
   */
  public static getInstance(): SprintCheckExpo {
    if (!SprintCheckExpo.instance) {
      SprintCheckExpo.instance = new SprintCheckExpo();
    }
    return SprintCheckExpo.instance;
  }

  /**
   * Initialize the SprintCheck SDK
   * @param config Configuration object containing apiKey and encryptionKey
   * @returns Promise<VerificationResult>
   */
  public async initialize(config: SprintCheckConfig): Promise<VerificationResult> {
    try {
      console.log('Initializing SprintCheck SDK...');
      
      if (Platform.OS !== 'android') {
        throw new Error('SprintCheck SDK currently only supports Android platform');
      }

      const result = await SprintCheckNative.initialize(config.apiKey, config.encryptionKey);
      this.isInitialized = true;
      
      console.log('SprintCheck SDK initialized successfully');
      return {
        success: true,
        message: 'SDK initialized successfully',
        data: result
      };
    } catch (error) {
      console.error('Failed to initialize SprintCheck SDK:', error);
      return {
        success: false,
        message: 'Failed to initialize SDK',
        error: error instanceof Error ? error.message : String(error)
      };
    }
  }

  /**
   * Start BVN verification process
   * @param email User's email address
   * @returns Promise<VerificationResult>
   */
  public async startBvnVerification(email: string): Promise<VerificationResult> {
    try {
      this.checkInitialization();
      
      if (!email || !this.isValidEmail(email)) {
        throw new Error('Valid email address is required');
      }

      console.log('Starting BVN verification for:', email);
      const result = await SprintCheckNative.startBvnVerification(email);
      
      return {
        success: true,
        message: 'BVN verification started successfully',
        data: result
      };
    } catch (error) {
      console.error('Failed to start BVN verification:', error);
      return {
        success: false,
        message: 'Failed to start BVN verification',
        error: error instanceof Error ? error.message : String(error)
      };
    }
  }

  /**
   * Start NIN verification process
   * @param email User's email address
   * @returns Promise<VerificationResult>
   */
  public async startNinVerification(email: string): Promise<VerificationResult> {
    try {
      this.checkInitialization();
      
      if (!email || !this.isValidEmail(email)) {
        throw new Error('Valid email address is required');
      }

      console.log('Starting NIN verification for:', email);
      const result = await SprintCheckNative.startNinVerification(email);
      
      return {
        success: true,
        message: 'NIN verification started successfully',
        data: result
      };
    } catch (error) {
      console.error('Failed to start NIN verification:', error);
      return {
        success: false,
        message: 'Failed to start NIN verification',
        error: error instanceof Error ? error.message : String(error)
      };
    }
  }

  /**
   * Start Facial verification process
   * @param email User's email address
   * @returns Promise<VerificationResult>
   */
  public async startFacialVerification(email: string): Promise<VerificationResult> {
    try {
      this.checkInitialization();
      
      if (!email || !this.isValidEmail(email)) {
        throw new Error('Valid email address is required');
      }

      console.log('Starting Facial verification for:', email);
      const result = await SprintCheckNative.startFacialVerification(email);
      
      return {
        success: true,
        message: 'Facial verification started successfully',
        data: result
      };
    } catch (error) {
      console.error('Failed to start Facial verification:', error);
      return {
        success: false,
        message: 'Failed to start Facial verification',
        error: error instanceof Error ? error.message : String(error)
      };
    }
  }

  /**
   * Check if SDK is initialized
   * @private
   */
  private checkInitialization(): void {
    if (!this.isInitialized) {
      throw new Error('SprintCheck SDK is not initialized. Call initialize() first.');
    }
  }

  /**
   * Validate email format
   * @private
   */
  private isValidEmail(email: string): boolean {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
  }

  /**
   * Get SDK initialization status
   */
  public getInitializationStatus(): boolean {
    return this.isInitialized;
  }
}

// Export singleton instance
export default SprintCheckExpo.getInstance();