@hexar/biometric-identity-sdk-core 1.0.11 → 1.0.13

package/dist/BiometricIdentitySDK.js

@@ -183,12 +183,25 @@ class BiometricIdentitySDK {
      */
     async storeVideoRecording(videoResult) {
         try {
+            logger_1.logger.info('Storing video recording', {
+                framesCount: videoResult.frames?.length || 0,
+                duration: videoResult.duration,
+                hasSessionId: !!videoResult.sessionId
+            });
+            if (!videoResult.frames || videoResult.frames.length === 0) {
+                throw new Error('Video recording has no frames');
+            }
             this.updateState({ isLoading: true, currentStep: types_1.SDKStep.RECORD_LIVENESS });
             this.updateState({
                 videoData: videoResult,
                 progress: 75,
                 isLoading: false,
             });
+            const stateAfterStore = this.getState();
+            logger_1.logger.info('Video recording stored', {
+                storedFramesCount: stateAfterStore.videoData?.frames?.length || 0,
+                hasVideoData: !!stateAfterStore.videoData
+            });
         }
         catch (error) {
             this.handleError(error);
@@ -258,22 +271,50 @@ class BiometricIdentitySDK {
      */
     async validateWithBackend() {
         if (!this.state.frontID || !this.state.videoData) {
+            logger_1.logger.error('Validation failed: missing required data', {
+                hasFrontID: !!this.state.frontID,
+                hasVideoData: !!this.state.videoData
+            });
             throw new Error('Required data not available');
         }
+        logger_1.logger.info('Starting backend validation', {
+            videoFramesCount: this.state.videoData.frames?.length || 0,
+            videoDuration: this.state.videoData.duration,
+            hasBackID: !!this.state.backID
+        });
         this.updateState({ progress: 80 });
         try {
-            // Limit and sample video frames to prevent payload size issues
-            // Take max 30 frames, sampling evenly across the video
             let videoFrames = this.state.videoData.frames;
-            if (videoFrames.length === 0) {
+            if (!videoFrames || videoFrames.length === 0) {
+                logger_1.logger.error('No video frames in state', {
+                    videoDataExists: !!this.state.videoData,
+                    framesProperty: typeof this.state.videoData.frames,
+                    framesLength: this.state.videoData.frames?.length
+                });
                 throw new Error('No video frames available for validation');
             }
-            // Sample frames if we have too many (max 30 frames to keep payload reasonable)
+            if (videoFrames.length < 10) {
+                logger_1.logger.warn('Insufficient frames for validation', {
+                    frameCount: videoFrames.length,
+                    minimumRequired: 10
+                });
+            }
             const MAX_FRAMES = 30;
             if (videoFrames.length > MAX_FRAMES) {
                 const step = Math.floor(videoFrames.length / MAX_FRAMES);
                 videoFrames = videoFrames.filter((_, index) => index % step === 0).slice(0, MAX_FRAMES);
+                logger_1.logger.info('Sampled frames for validation', {
+                    originalCount: this.state.videoData.frames.length,
+                    sampledCount: videoFrames.length
+                });
             }
+            logger_1.logger.info('Sending validation request to backend', {
+                framesCount: videoFrames.length,
+                duration: this.state.videoData.duration,
+                challengesCount: this.state.videoData.challengesCompleted?.length || 0,
+                frontImageSize: this.state.frontID.data?.length || 0,
+                backImageSize: this.state.backID?.data?.length || 0
+            });
             const response = await this.backendClient.fullValidation({
                 frontIdImage: this.state.frontID.data,
                 backIdImage: this.state.backID?.data,
@@ -282,11 +323,15 @@ class BiometricIdentitySDK {
                 challengesCompleted: this.state.videoData.challengesCompleted || [],
             });
             this.updateState({ progress: 95 });
-            // Convert backend response to SDK format
             return this.backendClient.convertToValidationResult(response);
         }
         catch (error) {
-            throw this.createError(types_1.BiometricErrorCode.NETWORK_ERROR, 'Backend validation failed', error);
+            logger_1.logger.error('Backend validation failed', {
+                errorMessage: error?.message,
+                errorName: error?.name,
+                errorStack: error?.stack
+            });
+            throw this.createError(types_1.BiometricErrorCode.NETWORK_ERROR, error?.message || 'Backend validation failed', error);
         }
     }
     /**

package/dist/api/BackendClient.js

@@ -88,10 +88,10 @@ class BackendClient {
      */
     async fullValidation(params) {
         if (!this.currentSessionId) {
-            // Generate a challenge first if no session exists
+            logger_1.logger.info('No session ID, generating challenge');
             await this.generateChallenge();
         }
-        return this.request('/api/v1/validate', 'POST', {
+        const requestBody = {
             front_id_image: params.frontIdImage,
             back_id_image: params.backIdImage,
             video_frames: params.videoFrames,
@@ -101,7 +101,20 @@ class BackendClient {
             document_type: params.documentType,
             country_code: params.countryCode,
             device_info: params.deviceInfo,
+        };
+        logger_1.logger.info('Full validation request', {
+            hasSessionId: !!this.currentSessionId,
+            sessionId: this.currentSessionId,
+            videoFramesCount: params.videoFrames.length,
+            hasFrontImage: !!params.frontIdImage,
+            hasBackImage: !!params.backIdImage,
+            frontImageLength: params.frontIdImage?.length || 0,
+            backImageLength: params.backIdImage?.length || 0,
+            averageFrameLength: params.videoFrames.length > 0
+                ? Math.round(params.videoFrames.reduce((sum, f) => sum + f.length, 0) / params.videoFrames.length)
+                : 0
         });
+        return this.request('/api/v1/validate', 'POST', requestBody);
     }
     /**
      * Convert backend response to SDK ValidationResult format
@@ -189,23 +202,45 @@ class BackendClient {
             });
             clearTimeout(timeoutId);
             if (!response.ok) {
-                // Handle 413 Payload Too Large specifically
+                let errorData = {};
+                try {
+                    const text = await response.text();
+                    if (text) {
+                        errorData = JSON.parse(text);
+                    }
+                }
+                catch {
+                    errorData = {};
+                }
+                const errorMessage = errorData?.error?.message ||
+                    errorData?.detail ||
+                    errorData?.message ||
+                    `Request failed with status ${response.status}`;
+                logger_1.logger.error('Backend request failed', {
+                    url,
+                    method,
+                    status: response.status,
+                    statusText: response.statusText,
+                    errorData
+                });
                 if (response.status === 413) {
                     throw new Error(`Payload too large (413). The request body exceeds the server's size limit. Try reducing the number of video frames or image sizes.`);
                 }
-                const errorData = await response.json().catch(() => ({}));
-                throw new Error(errorData?.error?.message ||
-                    errorData?.detail ||
-                    `Request failed with status ${response.status}`);
+                throw new Error(errorMessage);
             }
             return await response.json();
         }
         catch (error) {
             clearTimeout(timeoutId);
             if (error.name === 'AbortError') {
+                logger_1.logger.error('Request timeout', { url, method, timeout: this.config.timeout });
                 throw new Error('Request timeout');
             }
-            throw error;
+            if (error.message) {
+                throw error;
+            }
+            logger_1.logger.error('Unexpected request error', { url, method, error });
+            throw new Error('Network request failed');
         }
     }
 }

package/dist/i18n/languages/es-AR.js

@@ -54,7 +54,7 @@ exports.esAR = {
     liveness: {
         title: 'Verificación Facial',
         preparing: 'Preparando verificación...',
-        getReady: '¡Prepárate!',
+        getReady: '¡Preparate!',
         countdownMessage: 'Vas a realizar acciones.\nSeguí las instrucciones en pantalla.',
         recordingInstructions: 'Mantené tu rostro visible y seguí las instrucciones',
         instructions: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexar/biometric-identity-sdk-core",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Core AI engine for biometric identity verification",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/BiometricIdentitySDK.ts

@@ -236,6 +236,16 @@ export class BiometricIdentitySDK {
    */
   async storeVideoRecording(videoResult: VideoResult): Promise<void> {
     try {
+      logger.info('Storing video recording', {
+        framesCount: videoResult.frames?.length || 0,
+        duration: videoResult.duration,
+        hasSessionId: !!videoResult.sessionId
+      });
+
+      if (!videoResult.frames || videoResult.frames.length === 0) {
+        throw new Error('Video recording has no frames');
+      }
+
       this.updateState({ isLoading: true, currentStep: SDKStep.RECORD_LIVENESS });
 
       this.updateState({ 
@@ -244,6 +254,12 @@ export class BiometricIdentitySDK {
         isLoading: false,
       });
 
+      const stateAfterStore = this.getState();
+      logger.info('Video recording stored', {
+        storedFramesCount: stateAfterStore.videoData?.frames?.length || 0,
+        hasVideoData: !!stateAfterStore.videoData
+      });
+
     } catch (error) {
       this.handleError(error);
       throw error;
@@ -331,26 +347,58 @@ export class BiometricIdentitySDK {
    */
   private async validateWithBackend(): Promise<ValidationResult> {
     if (!this.state.frontID || !this.state.videoData) {
+      logger.error('Validation failed: missing required data', {
+        hasFrontID: !!this.state.frontID,
+        hasVideoData: !!this.state.videoData
+      });
       throw new Error('Required data not available');
     }
 
+    logger.info('Starting backend validation', {
+      videoFramesCount: this.state.videoData.frames?.length || 0,
+      videoDuration: this.state.videoData.duration,
+      hasBackID: !!this.state.backID
+    });
+
     this.updateState({ progress: 80 });
 
     try {
-      // Limit and sample video frames to prevent payload size issues
-      // Take max 30 frames, sampling evenly across the video
       let videoFrames = this.state.videoData.frames;
-      if (videoFrames.length === 0) {
+      
+      if (!videoFrames || videoFrames.length === 0) {
+        logger.error('No video frames in state', {
+          videoDataExists: !!this.state.videoData,
+          framesProperty: typeof this.state.videoData.frames,
+          framesLength: this.state.videoData.frames?.length
+        });
         throw new Error('No video frames available for validation');
       }
+
+      if (videoFrames.length < 10) {
+        logger.warn('Insufficient frames for validation', {
+          frameCount: videoFrames.length,
+          minimumRequired: 10
+        });
+      }
       
-      // Sample frames if we have too many (max 30 frames to keep payload reasonable)
       const MAX_FRAMES = 30;
       if (videoFrames.length > MAX_FRAMES) {
         const step = Math.floor(videoFrames.length / MAX_FRAMES);
         videoFrames = videoFrames.filter((_, index) => index % step === 0).slice(0, MAX_FRAMES);
+        logger.info('Sampled frames for validation', {
+          originalCount: this.state.videoData.frames.length,
+          sampledCount: videoFrames.length
+        });
       }
       
+      logger.info('Sending validation request to backend', {
+        framesCount: videoFrames.length,
+        duration: this.state.videoData.duration,
+        challengesCount: this.state.videoData.challengesCompleted?.length || 0,
+        frontImageSize: this.state.frontID.data?.length || 0,
+        backImageSize: this.state.backID?.data?.length || 0
+      });
+
       const response = await this.backendClient.fullValidation({
         frontIdImage: this.state.frontID.data,
         backIdImage: this.state.backID?.data,
@@ -361,12 +409,16 @@ export class BiometricIdentitySDK {
 
       this.updateState({ progress: 95 });
 
-      // Convert backend response to SDK format
       return this.backendClient.convertToValidationResult(response);
-    } catch (error) {
+    } catch (error: any) {
+      logger.error('Backend validation failed', {
+        errorMessage: error?.message,
+        errorName: error?.name,
+        errorStack: error?.stack
+      });
       throw this.createError(
         BiometricErrorCode.NETWORK_ERROR,
-        'Backend validation failed',
+        error?.message || 'Backend validation failed',
         error
       );
     }

package/src/api/BackendClient.ts

@@ -261,24 +261,39 @@ export class BackendClient {
     deviceInfo?: Record<string, any>;
   }): Promise<FullValidationResponse> {
     if (!this.currentSessionId) {
-      // Generate a challenge first if no session exists
+      logger.info('No session ID, generating challenge');
       await this.generateChallenge();
     }
 
+    const requestBody = {
+      front_id_image: params.frontIdImage,
+      back_id_image: params.backIdImage,
+      video_frames: params.videoFrames,
+      video_duration_ms: params.videoDurationMs,
+      session_id: this.currentSessionId,
+      challenges_completed: params.challengesCompleted || [],
+      document_type: params.documentType,
+      country_code: params.countryCode,
+      device_info: params.deviceInfo,
+    };
+
+    logger.info('Full validation request', {
+      hasSessionId: !!this.currentSessionId,
+      sessionId: this.currentSessionId,
+      videoFramesCount: params.videoFrames.length,
+      hasFrontImage: !!params.frontIdImage,
+      hasBackImage: !!params.backIdImage,
+      frontImageLength: params.frontIdImage?.length || 0,
+      backImageLength: params.backIdImage?.length || 0,
+      averageFrameLength: params.videoFrames.length > 0 
+        ? Math.round(params.videoFrames.reduce((sum, f) => sum + f.length, 0) / params.videoFrames.length)
+        : 0
+    });
+
     return this.request<FullValidationResponse>(
       '/api/v1/validate',
       'POST',
-      {
-        front_id_image: params.frontIdImage,
-        back_id_image: params.backIdImage,
-        video_frames: params.videoFrames,
-        video_duration_ms: params.videoDurationMs,
-        session_id: this.currentSessionId,
-        challenges_completed: params.challengesCompleted || [],
-        document_type: params.documentType,
-        country_code: params.countryCode,
-        device_info: params.deviceInfo,
-      }
+      requestBody
     );
   }
 
@@ -382,19 +397,36 @@ export class BackendClient {
       clearTimeout(timeoutId);
 
       if (!response.ok) {
-        // Handle 413 Payload Too Large specifically
+        let errorData: Record<string, any> = {};
+        try {
+          const text = await response.text();
+          if (text) {
+            errorData = JSON.parse(text);
+          }
+        } catch {
+          errorData = {};
+        }
+
+        const errorMessage = errorData?.error?.message || 
+          errorData?.detail ||
+          errorData?.message ||
+          `Request failed with status ${response.status}`;
+
+        logger.error('Backend request failed', {
+          url,
+          method,
+          status: response.status,
+          statusText: response.statusText,
+          errorData
+        });
+
         if (response.status === 413) {
           throw new Error(
             `Payload too large (413). The request body exceeds the server's size limit. Try reducing the number of video frames or image sizes.`
           );
         }
         
-        const errorData = await response.json().catch(() => ({})) as Record<string, any>;
-        throw new Error(
-          errorData?.error?.message || 
-          errorData?.detail ||
-          `Request failed with status ${response.status}`
-        );
+        throw new Error(errorMessage);
       }
 
       return await response.json() as T;
@@ -402,10 +434,16 @@ export class BackendClient {
       clearTimeout(timeoutId);
       
       if (error.name === 'AbortError') {
+        logger.error('Request timeout', { url, method, timeout: this.config.timeout });
         throw new Error('Request timeout');
       }
       
-      throw error;
+      if (error.message) {
+        throw error;
+      }
+      
+      logger.error('Unexpected request error', { url, method, error });
+      throw new Error('Network request failed');
     }
   }
 }

package/src/i18n/languages/es-AR.ts

@@ -57,7 +57,7 @@ export const esAR: LanguageStrings = {
   liveness: {
     title: 'Verificación Facial',
     preparing: 'Preparando verificación...',
-    getReady: '¡Prepárate!',
+    getReady: '¡Preparate!',
     countdownMessage: 'Vas a realizar acciones.\nSeguí las instrucciones en pantalla.',
     recordingInstructions: 'Mantené tu rostro visible y seguí las instrucciones',
     instructions: {