@trustchex/react-native-sdk 1.475.1 → 1.478.7

package/src/Shared/Services/DataUploadService.ts

@@ -7,9 +7,10 @@ import type {
 } from '../Types/identificationInfo';
 import { getSessionKey, encryptWithAes } from '../Libs/crypto.utils';
 import mrzUtils from '../Libs/mrz.utils';
-import httpClient from '../Libs/http-client';
+import httpClient, { getSessionToken } from '../Libs/http-client';
 import { NotFoundError } from '../Libs/http-client';
 import { runWithRetry } from '../Libs/promise.utils';
+import { debugLog, debugWarn, logError, logWarn } from '../Libs/debug.utils';
 
 /**
  * Service to upload collected identification data to the backend.
@@ -27,15 +28,16 @@ export class DataUploadService {
   private async ensureIdentificationExists(
     identificationId: string
   ): Promise<void> {
-    console.log(
-      '[DataUploadService] POST',
+    debugLog(
+      'DataUploadService',
+      'POST',
       `${this.apiUrl}/identifications/${identificationId}`
     );
     await httpClient.post(
       `${this.apiUrl}/identifications/${identificationId}`,
       {}
     );
-    console.log('[DataUploadService] ✓ Identification created/verified');
+    debugLog('DataUploadService', '✓ Identification created/verified');
   }
 
   /**
@@ -47,13 +49,13 @@ export class DataUploadService {
     sessionKey: string
   ): Promise<void> {
     if (!scannedDocument || scannedDocument.documentType === 'UNKNOWN') {
-      console.log('[DataUploadService] No document data to submit');
+      debugLog('DataUploadService', 'No document data to submit');
       return;
     }
 
     const mrzFields = scannedDocument.mrzFields;
     if (!mrzFields) {
-      console.log('[DataUploadService] No MRZ fields to submit');
+      debugLog('DataUploadService', 'No MRZ fields to submit');
       return;
     }
 
@@ -72,10 +74,10 @@ export class DataUploadService {
       mrzText: scannedDocument.mrzText,
     };
 
-    console.log(
-      '[DataUploadService] Submitting document data:',
-      identificationDocument.type,
-      identificationDocument.number
+    debugLog(
+      'DataUploadService',
+      'Submitting document data:',
+      identificationDocument.type
     );
 
     const { encryptedData, nonce } = encryptWithAes(
@@ -83,8 +85,9 @@ export class DataUploadService {
       sessionKey
     );
 
-    console.log(
-      '[DataUploadService] POST',
+    debugLog(
+      'DataUploadService',
+      'POST',
       `${this.apiUrl}/identifications/${identificationId}/documents`
     );
     await runWithRetry(() =>
@@ -97,7 +100,7 @@ export class DataUploadService {
       )
     );
 
-    console.log('[DataUploadService] ✓ Document data submitted');
+    debugLog('DataUploadService', '✓ Document data submitted');
   }
 
   /**
@@ -109,11 +112,13 @@ export class DataUploadService {
     livenessDetection?: LivenessDetection,
     onProgress?: (progress: number) => void
   ): Promise<void> {
+    const sessionToken = getSessionToken();
     const uploadFileOptions: RNFS.UploadFileOptions = {
       toUrl: `${this.apiUrl}/identifications/${identificationId}/media`,
       method: 'POST',
       headers: {
         Accept: 'application/json',
+        ...(sessionToken ? { 'X-Session-Token': sessionToken } : {}),
       },
       files: [],
       progress: (res) => {
@@ -122,159 +127,142 @@ export class DataUploadService {
       },
     };
 
-    // Add document front image
-    const frontImage = scannedDocument?.frontImage;
-    if (frontImage && frontImage !== '') {
-      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_FRONT_IMAGE.jpg`;
-      await RNFS.writeFile(decodeURIComponent(filePath), frontImage, 'base64');
-      uploadFileOptions.files.push({
-        name: 'files',
-        filename: 'DOCUMENT_FRONT_IMAGE.jpg',
-        filepath: decodeURIComponent(filePath),
-        filetype: 'image/jpeg',
-      });
-    }
+    // Plaintext identity images/video staged on disk for the multipart upload;
+    // every entry is deleted in the finally below, whether the upload succeeds
+    // or not.
+    const tempPaths: string[] = [];
 
-    // Add document back image
-    const backImage = scannedDocument?.backImage;
-    if (backImage && backImage !== '') {
-      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_BACK_IMAGE.jpg`;
-      await RNFS.writeFile(decodeURIComponent(filePath), backImage, 'base64');
+    const writeTempImage = async (fileName: string, base64Data: string) => {
+      const filePath = decodeURIComponent(
+        `${RNFS.TemporaryDirectoryPath}/${fileName}`
+      );
+      await RNFS.writeFile(filePath, base64Data, 'base64');
+      tempPaths.push(filePath);
       uploadFileOptions.files.push({
         name: 'files',
-        filename: 'DOCUMENT_BACK_IMAGE.jpg',
-        filepath: decodeURIComponent(filePath),
+        filename: fileName,
+        filepath: filePath,
         filetype: 'image/jpeg',
       });
-    }
+      return filePath;
+    };
 
-    // Add face image from document
-    const faceImage = scannedDocument?.faceImage;
-    if (faceImage && faceImage !== '') {
-      const filePath = `${RNFS.TemporaryDirectoryPath}/FACE_IMAGE.jpg`;
-      await RNFS.writeFile(decodeURIComponent(filePath), faceImage, 'base64');
-      uploadFileOptions.files.push({
-        name: 'files',
-        filename: 'FACE_IMAGE.jpg',
-        filepath: decodeURIComponent(filePath),
-        filetype: 'image/jpeg',
-      });
-    }
+    try {
+      // Add document front image
+      const frontImage = scannedDocument?.frontImage;
+      if (frontImage && frontImage !== '') {
+        await writeTempImage('DOCUMENT_FRONT_IMAGE.jpg', frontImage);
+      }
 
-    // Add secondary face image from document (optional)
-    const secondaryFaceImage = scannedDocument?.secondaryFaceImage;
-    if (secondaryFaceImage && secondaryFaceImage !== '') {
-      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_SECONDARY_FACE_IMAGE.jpg`;
-      await RNFS.writeFile(
-        decodeURIComponent(filePath),
-        secondaryFaceImage,
-        'base64'
-      );
-      uploadFileOptions.files.push({
-        name: 'files',
-        filename: 'DOCUMENT_SECONDARY_FACE_IMAGE.jpg',
-        filepath: decodeURIComponent(filePath),
-        filetype: 'image/jpeg',
-      });
-    }
+      // Add document back image
+      const backImage = scannedDocument?.backImage;
+      if (backImage && backImage !== '') {
+        await writeTempImage('DOCUMENT_BACK_IMAGE.jpg', backImage);
+      }
 
-    // Add hologram image from document (optional)
-    const hologramImage = scannedDocument?.hologramImage;
-    if (hologramImage && hologramImage !== '') {
-      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_HOLOGRAM_IMAGE.jpg`;
-      await RNFS.writeFile(
-        decodeURIComponent(filePath),
-        hologramImage,
-        'base64'
-      );
-      uploadFileOptions.files.push({
-        name: 'files',
-        filename: 'DOCUMENT_HOLOGRAM_IMAGE.jpg',
-        filepath: decodeURIComponent(filePath),
-        filetype: 'image/jpeg',
-      });
-    }
+      // Add face image from document
+      const faceImage = scannedDocument?.faceImage;
+      if (faceImage && faceImage !== '') {
+        await writeTempImage('FACE_IMAGE.jpg', faceImage);
+      }
 
-    // Add liveness images and selfie from liveness detection
-    if (livenessDetection?.instructions) {
-      for (const instruction of livenessDetection.instructions) {
-        if (instruction?.photo) {
-          const filePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_${instruction.instruction}_IMAGE.jpg`;
-          await RNFS.writeFile(
-            decodeURIComponent(filePath),
-            instruction.photo,
-            'base64'
-          );
-          uploadFileOptions.files.push({
-            name: 'files',
-            filename: `LIVENESS_${instruction.instruction}_IMAGE.jpg`,
-            filepath: decodeURIComponent(filePath),
-            filetype: 'image/jpeg',
-          });
-
-          if (instruction.instruction === 'LOOK_STRAIGHT_AND_BLINK') {
-            uploadFileOptions.files.push({
-              name: 'files',
-              filename: 'SELFIE_IMAGE.jpg',
-              filepath: decodeURIComponent(filePath),
-              filetype: 'image/jpeg',
-            });
+      // Add secondary face image from document (optional)
+      const secondaryFaceImage = scannedDocument?.secondaryFaceImage;
+      if (secondaryFaceImage && secondaryFaceImage !== '') {
+        await writeTempImage(
+          'DOCUMENT_SECONDARY_FACE_IMAGE.jpg',
+          secondaryFaceImage
+        );
+      }
+
+      // Add hologram image from document (optional)
+      const hologramImage = scannedDocument?.hologramImage;
+      if (hologramImage && hologramImage !== '') {
+        await writeTempImage('DOCUMENT_HOLOGRAM_IMAGE.jpg', hologramImage);
+      }
+
+      // Add liveness images and selfie from liveness detection
+      if (livenessDetection?.instructions) {
+        for (const instruction of livenessDetection.instructions) {
+          if (instruction?.photo) {
+            const filePath = await writeTempImage(
+              `LIVENESS_${instruction.instruction}_IMAGE.jpg`,
+              instruction.photo
+            );
+
+            if (instruction.instruction === 'LOOK_STRAIGHT_AND_BLINK') {
+              uploadFileOptions.files.push({
+                name: 'files',
+                filename: 'SELFIE_IMAGE.jpg',
+                filepath: filePath,
+                filetype: 'image/jpeg',
+              });
+            }
           }
         }
       }
-    }
 
-    // Add liveness video (optional)
-    if (livenessDetection?.videoPath) {
-      let videoFilePath: string;
-      if (Platform.OS === 'ios') {
-        const tempDir = `${RNFS.TemporaryDirectoryPath}/${new Date().getTime()}`;
-        await RNFS.mkdir(tempDir);
-        videoFilePath = `${tempDir}/LIVENESS_VIDEO.mp4`;
-      } else {
-        videoFilePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_VIDEO.mp4`;
-      }
+      // Add liveness video (optional). Only the staged copy is cleaned up here;
+      // livenessDetection.videoPath stays available for later submissions.
+      if (livenessDetection?.videoPath) {
+        let videoFilePath: string;
+        if (Platform.OS === 'ios') {
+          const tempDir = `${RNFS.TemporaryDirectoryPath}/${new Date().getTime()}`;
+          await RNFS.mkdir(tempDir);
+          tempPaths.push(tempDir);
+          videoFilePath = `${tempDir}/LIVENESS_VIDEO.mp4`;
+        } else {
+          videoFilePath = decodeURIComponent(
+            `${RNFS.TemporaryDirectoryPath}/LIVENESS_VIDEO.mp4`
+          );
+          tempPaths.push(videoFilePath);
+        }
 
-      await RNFS.copyFile(livenessDetection.videoPath, videoFilePath);
+        await RNFS.copyFile(livenessDetection.videoPath, videoFilePath);
 
-      uploadFileOptions.files.push({
-        name: 'files',
-        filename: 'LIVENESS_VIDEO.mp4',
-        filepath: decodeURIComponent(videoFilePath),
-        filetype: 'video/mp4',
-      });
-    }
+        uploadFileOptions.files.push({
+          name: 'files',
+          filename: 'LIVENESS_VIDEO.mp4',
+          filepath: decodeURIComponent(videoFilePath),
+          filetype: 'video/mp4',
+        });
+      }
 
-    // Skip upload if no files
-    if (uploadFileOptions.files.length === 0) {
-      console.log('[DataUploadService] No media files to upload');
-      return;
-    }
+      // Skip upload if no files
+      if (uploadFileOptions.files.length === 0) {
+        debugLog('DataUploadService', 'No media files to upload');
+        return;
+      }
 
-    console.log(
-      '[DataUploadService] Uploading',
-      uploadFileOptions.files.length,
-      'media files to',
-      uploadFileOptions.toUrl
-    );
-    const response = await runWithRetry(
-      () => RNFS.uploadFiles(uploadFileOptions).promise
-    );
-    console.log(
-      '[DataUploadService] Upload response status:',
-      response.statusCode
-    );
+      debugLog(
+        'DataUploadService',
+        `Uploading ${uploadFileOptions.files.length} media files to`,
+        uploadFileOptions.toUrl
+      );
+      const response = await runWithRetry(
+        () => RNFS.uploadFiles(uploadFileOptions).promise
+      );
+      debugLog(
+        'DataUploadService',
+        'Upload response status:',
+        response.statusCode
+      );
 
-    if (![200, 201, 204].includes(response.statusCode)) {
-      console.error(
-        '[DataUploadService] Media upload failed:',
-        response.statusCode,
-        response.body
+      if (![200, 201, 204].includes(response.statusCode)) {
+        logError(
+          'DataUploadService',
+          `Media upload failed: ${response.statusCode}`
+        );
+        debugLog('DataUploadService', 'Failed upload response:', response.body);
+        throw new Error(`Media upload failed: ${response.statusCode}`);
+      }
+
+      debugLog('DataUploadService', '✓ Media uploaded successfully');
+    } finally {
+      await Promise.all(
+        tempPaths.map((path) => RNFS.unlink(path).catch(() => {}))
       );
-      throw new Error(`Media upload failed: ${response.statusCode}`);
     }
-
-    console.log('[DataUploadService] ✓ Media uploaded successfully');
   }
 
   /**
@@ -289,17 +277,18 @@ export class DataUploadService {
     let { authToken } = identificationInfo;
 
     if (!identificationId) {
-      console.log('[DataUploadService] No identification ID, skipping upload');
+      debugLog('DataUploadService', 'No identification ID, skipping upload');
       return false;
     }
 
-    console.log(
-      '[DataUploadService] ========== UPLOADING COLLECTED DATA =========='
+    debugLog(
+      'DataUploadService',
+      '========== UPLOADING COLLECTED DATA =========='
     );
-    console.log('[DataUploadService] Identification ID:', identificationId);
-    console.log('[DataUploadService] Has document:', !!scannedDocument);
-    console.log('[DataUploadService] Has liveness:', !!livenessDetection);
-    console.log('[DataUploadService] Has auth token:', !!authToken);
+    debugLog('DataUploadService', 'Identification ID:', identificationId);
+    debugLog('DataUploadService', 'Has document:', !!scannedDocument);
+    debugLog('DataUploadService', 'Has liveness:', !!livenessDetection);
+    debugLog('DataUploadService', 'Has auth token:', !!authToken);
 
     try {
       await runWithRetry(() =>
@@ -309,16 +298,17 @@ export class DataUploadService {
       // Always refresh session key for current session (required for encrypted submission)
       if (sessionId) {
         const existingAuthToken = authToken;
-        console.log('[DataUploadService] Getting session key...');
+        debugLog('DataUploadService', 'Getting session key...');
         try {
           authToken = await runWithRetry(() =>
             getSessionKey(this.apiUrl, sessionId)
           );
-          console.log('[DataUploadService] ✓ Session key obtained');
+          debugLog('DataUploadService', '✓ Session key obtained');
         } catch (error) {
           if (existingAuthToken) {
-            console.warn(
-              '[DataUploadService] Session key refresh failed, using existing token'
+            debugWarn(
+              'DataUploadService',
+              'Session key refresh failed, using existing token'
             );
             authToken = existingAuthToken;
           } else {
@@ -328,8 +318,9 @@ export class DataUploadService {
       }
 
       if (!authToken) {
-        console.log(
-          '[DataUploadService] No session key available, skipping upload'
+        debugLog(
+          'DataUploadService',
+          'No session key available, skipping upload'
         );
         return false;
       }
@@ -357,7 +348,7 @@ export class DataUploadService {
       );
       onProgress?.(1.0);
 
-      console.log('[DataUploadService] ✓ All collected data uploaded');
+      debugLog('DataUploadService', '✓ All collected data uploaded');
 
       // Mark media as uploaded during video call
       identificationInfo.mediaUploadedDuringVideoCall = true;
@@ -367,15 +358,13 @@ export class DataUploadService {
       return true;
     } catch (error) {
       if (error instanceof NotFoundError) {
-        console.warn(
-          '[DataUploadService] Upload skipped: identification is not active anymore'
+        logWarn(
+          'DataUploadService',
+          'Upload skipped: identification is not active anymore'
         );
         return false;
       }
-      console.error(
-        '[DataUploadService] Failed to upload collected data:',
-        error
-      );
+      logError('DataUploadService', 'Failed to upload collected data:', error);
       return false;
     }
   }

package/src/Shared/Services/VideoSessionService.ts

@@ -1,3 +1,4 @@
+import { debugLog } from '../Libs/debug.utils';
 export interface VideoSessionInfo {
   sessionId: string;
   identificationId: string;
@@ -124,13 +125,20 @@ export class VideoSessionService {
       const EventSource = require('react-native-sse').default;
 
       const url = `${this.baseUrl}/api/app/mobile/video-sessions/${sessionId}/queue-status?identificationId=${this.identificationId}`;
-      console.log('[VideoSessionService] Creating SSE connection to:', url);
+      debugLog(
+        'VideoSessionService',
+        '[VideoSessionService] Creating SSE connection to:',
+        url
+      );
 
       const es = new EventSource(url);
       let heartbeatInterval: ReturnType<typeof setInterval> | null = null;
 
       es.addEventListener('open', () => {
-        console.log('[VideoSessionService] Queue SSE connected');
+        debugLog(
+          'VideoSessionService',
+          '[VideoSessionService] Queue SSE connected'
+        );
         // Send initial heartbeat
         this.sendHeartbeat(sessionId).catch(() => {});
         // Set up periodic heartbeat (every 20s to stay under 30s watchdog)
@@ -147,7 +155,11 @@ export class VideoSessionService {
       es.addEventListener('message', (event: any) => {
         try {
           const data = JSON.parse(event.data);
-          console.log('[VideoSessionService] Queue update:', data);
+          debugLog(
+            'VideoSessionService',
+            '[VideoSessionService] Queue update:',
+            data
+          );
           if (data.queuePosition !== undefined) {
             onUpdate(data.queuePosition);
           }

package/src/Translation/Resources/en.ts

@@ -140,6 +140,7 @@ export default {
   'identityDocumentCamera.alignIDBackSide':
     'Align the back side of your ID card',
   'identityDocumentCamera.scanCompleted': 'Scan completed!',
+  'identityDocumentCamera.mrzDetected': 'MRZ detected — hold steady',
   'identityDocumentCamera.searchingDocument':
     'Position document within the frame',
   'identityDocumentCamera.faceDetected': 'Keep device steady...',

package/src/Translation/Resources/tr.ts

@@ -141,6 +141,7 @@ export default {
   'identityDocumentCamera.alignIDBackSide':
     'Kimlik kartınızın arka yüzünü hizalayın',
   'identityDocumentCamera.scanCompleted': 'Tarama tamamlandı!',
+  'identityDocumentCamera.mrzDetected': 'MRZ algılandı — sabit tutun',
   'identityDocumentCamera.searchingDocument':
     'Belgeyi çerçeve içine yerleştirin',
   'identityDocumentCamera.faceDetected': 'Cihazı sabit tutun...',

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is auto-generated. Do not edit manually.
 // Version is synced from package.json during build.
-export const SDK_VERSION = '1.475.1';
+export const SDK_VERSION = '1.478.7';